sailfork / t3code-github / .repos/ alchemy-effect/ packages/ neon/ src/ FunctionBridge.ts

import * as NodeServices from "@effect/platform-node/NodeServices";
import { waitUntil as nativeWaitUntil } from "@neon/functions";
import { safeHttpEffect } from "alchemy/Http";
import { makeEntrypointLayer, reifyBoundConfigProvider } from "alchemy/Runtime";
import { RuntimeContext } from "alchemy/RuntimeContext";
import { Self } from "alchemy/Self";
import { StackContext } from "alchemy/StackContext";
import * as ConfigProvider from "effect/ConfigProvider";
import * as Context from "effect/Context";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as FetchHttpClient from "effect/http/FetchHttpClient";
import * as EffectHttp from "effect/http/HttpEffect";
import * as HttpServerRequest from "effect/http/HttpServerRequest";
import * as HttpServerResponse from "effect/http/HttpServerResponse";
import * as Layer from "effect/Layer";
import * as Scope from "effect/Scope";
import { FunctionEnvironment, FunctionRequest } from "./FunctionEnvironment.ts";
import type { FunctionRuntimeContext } from "./FunctionRuntimeContext.ts";
import { FunctionUpgradeSockets } from "./FunctionUpgrade.ts";

const closeRequestScope = (scope: Scope.Closeable) => {
  Scope.close(scope, Exit.void).pipe(
    Effect.timeout("15 seconds"),
    Effect.ignoreCause({ log: "Error" }),
    Effect.runPromise,
    nativeWaitUntil,
  );
};

/** Build a Node-only Fetch bridge once per process, with a fresh scope for every request. */
export const makeFunctionBridge = (entrypoint: unknown) => {
  const instanceScope = Scope.makeUnsafe();
  const tag = Self as unknown as Context.Service<never, { RuntimeContext: FunctionRuntimeContext }>;
  const platform = Layer.mergeAll(
    NodeServices.layer,
    FetchHttpClient.layer,
    Layer.succeed(FunctionEnvironment, process.env),
    Layer.succeed(
      ConfigProvider.ConfigProvider,
      reifyBoundConfigProvider(
        ConfigProvider.orElse(
          ConfigProvider.fromUnknown({ ALCHEMY_PHASE: "runtime" }),
          ConfigProvider.fromEnv(),
        ),
        process.env,
      ),
    ),
    Layer.succeed(StackContext, {
      name: process.env.ALCHEMY_STACK_NAME ?? "NeonFunction",
      stage: process.env.ALCHEMY_STAGE ?? "runtime",
      bindings: {},
      resources: {},
      actions: {},
    }),
  );
  const build = Layer.buildWithScope(
    makeEntrypointLayer(tag, entrypoint).pipe(Layer.provideMerge(platform)),
    instanceScope,
  ).pipe(
    Effect.flatMap((context) =>
      tag.pipe(
        Effect.flatMap((host) =>
          host.RuntimeContext.handler.pipe(
            Effect.map((handler) => ({
              ...handler,
              runtime: host.RuntimeContext,
              built: context,
            })),
          ),
        ),
        Effect.provideContext(context),
      ),
    ),
    Effect.cachedWithTTL((exit) => (Exit.isSuccess(exit) ? Infinity : 0)),
    Effect.runSync,
  );
  const close = Scope.close(instanceScope, Exit.void).pipe(
    Effect.timeout("4 seconds"),
    Effect.ignoreCause({ log: "Error" }),
  );
  process.once("SIGINT", () => {
    Effect.runFork(close);
  });

  return {
    fetch: (request: Request) =>
      Effect.gen(function* () {
        const built = yield* build;
        const response = yield* Deferred.make<Response>();
        const services = Context.mergeAll(
          built.built,
          built.context,
          Context.make(RuntimeContext, built.runtime),
          Context.make(FunctionRequest, request),
          Context.make(HttpServerRequest.HttpServerRequest, HttpServerRequest.fromWeb(request)),
        );
        const handler = safeHttpEffect(built.dispatch(new URL(request.url).pathname)).pipe(
          Effect.interruptible,
        );
        return yield* EffectHttp.toHandled(handler, (req, res) =>
          Effect.gen(function* () {
            const scope = yield* Effect.scope;
            const context = yield* Effect.context<never>();
            if (res.body._tag === "Raw" && res.body.body instanceof Response) {
              // Neon attaches upgrade metadata to this exact object.
              const socket = FunctionUpgradeSockets.get(res.body.body);
              if (socket && socket.readyState !== socket.CLOSED) {
                EffectHttp.scopeDisableClose(scope);
                const onClose = () => closeRequestScope(scope as Scope.Closeable);
                socket.addEventListener("close", onClose, { once: true });
                request.signal.addEventListener("abort", onClose, {
                  once: true,
                });
                yield* Effect.addFinalizer(() =>
                  Effect.sync(() => {
                    socket.removeEventListener("close", onClose);
                    request.signal.removeEventListener("abort", onClose);
                  }),
                );
                if (request.signal.aborted) onClose();
              }
              yield* Deferred.succeed(response, res.body.body);
              return;
            }
            const withoutBody = req.method === "HEAD";
            const transferred = HttpServerResponse.omitsBody(res, withoutBody)
              ? res
              : EffectHttp.scopeTransferToStream(res);
            const web = HttpServerResponse.toWeb(transferred, {
              withoutBody,
              context,
            });
            // The body outlives fetch; propagate actual request aborts to its producer.
            yield* Deferred.succeed(
              response,
              res.body._tag === "Stream" && web.body
                ? new Response(
                    web.body.pipeThrough(new TransformStream<Uint8Array, Uint8Array>(), {
                      signal: request.signal,
                    }),
                    {
                      status: web.status,
                      statusText: web.statusText,
                      headers: web.headers,
                    },
                  )
                : web,
            );
          }),
        ).pipe(Effect.andThen(Deferred.await(response)), Effect.provideContext(services));
      }).pipe((effect) => Effect.runPromise(effect, { signal: request.signal })),
  };
};