@gaganref/confect-test 0.0.0-stage → 10.3.1-fork.1

package/src/TestConfect.ts

@@ -0,0 +1,422 @@
+import { App, Ref } from "@confect/core";
+import type { DatabaseSchema, DataModel } from "@confect/server";
+import { RegisteredConvexFunction } from "@confect/server";
+import type {
+  TestConvexForDataModel,
+  TestConvexForDataModelAndIdentity,
+} from "convex-test";
+import { convexTest } from "convex-test";
+import type {
+  GenericDataModel,
+  GenericMutationCtx,
+  GenericSchema,
+  SchemaDefinition,
+  UserIdentity,
+} from "convex/server";
+import type { Value } from "convex/values";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as MountedHttp from "./internal/MountedHttp";
+
+/**
+ * Register a component's Convex schema and modules at its installation path.
+ */
+export type RegisterComponent =
+  TestConvexForDataModelAndIdentity<GenericDataModel>["registerComponent"];
+
+/**
+ * An installed component path and the HTTP prefix exposed by its host.
+ */
+export type HttpMount = {
+  readonly componentPath: string;
+  readonly httpPrefix: string;
+};
+
+export type LayerOptions = {
+  /**
+   * Register component kits synchronously before the test service is available.
+   */
+  readonly register?: (registerComponent: RegisterComponent) => void;
+  /**
+   * Explicit HTTP mounts. The test layer does not evaluate convex.config.ts.
+   */
+  readonly httpMounts?: ReadonlyArray<HttpMount>;
+};
+
+export type TestConfectWithoutIdentity<
+  ConfectSchema extends DatabaseSchema.AnyWithProps,
+> = {
+  query: <QueryRef extends Ref.AnyQuery>(
+    queryRef: QueryRef,
+    ...args: Ref.OptionalArgs<QueryRef>
+  ) => Effect.Effect<
+    Ref.Returns<QueryRef>,
+    Ref.Error<QueryRef> | Schema.SchemaError
+  >;
+  mutation: <MutationRef extends Ref.AnyMutation>(
+    mutationRef: MutationRef,
+    ...args: Ref.OptionalArgs<MutationRef>
+  ) => Effect.Effect<
+    Ref.Returns<MutationRef>,
+    Ref.Error<MutationRef> | Schema.SchemaError
+  >;
+  action: <ActionRef extends Ref.AnyAction>(
+    actionRef: ActionRef,
+    ...args: Ref.OptionalArgs<ActionRef>
+  ) => Effect.Effect<
+    Ref.Returns<ActionRef>,
+    Ref.Error<ActionRef> | Schema.SchemaError
+  >;
+  run: {
+    <E>(
+      handler: Effect.Effect<
+        void,
+        E,
+        RegisteredConvexFunction.MutationServices<ConfectSchema>
+      >,
+    ): Effect.Effect<void>;
+    <A, B extends Value, E>(
+      handler: Effect.Effect<
+        A,
+        E,
+        RegisteredConvexFunction.MutationServices<ConfectSchema>
+      >,
+      returns: Schema.Codec<A, B>,
+    ): Effect.Effect<A, Schema.SchemaError>;
+  };
+  fetch: (
+    pathQueryFragment: string,
+    init?: RequestInit,
+  ) => Effect.Effect<Response>;
+  finishInProgressScheduledFunctions: () => Effect.Effect<void>;
+  finishAllScheduledFunctions: (
+    advanceTimers: () => void,
+  ) => Effect.Effect<void>;
+};
+
+export type TestConfect<ConfectSchema extends DatabaseSchema.AnyWithProps> = {
+  registerComponent: (
+    componentPath: string,
+    schema: SchemaDefinition<GenericSchema, boolean>,
+    modules: Record<string, () => Promise<any>>,
+  ) => Effect.Effect<void>;
+  withIdentity: (
+    userIdentity: Partial<UserIdentity>,
+  ) => TestConfectWithoutIdentity<ConfectSchema>;
+} & TestConfectWithoutIdentity<ConfectSchema>;
+
+export const TestConfect = <
+  ConfectSchema extends DatabaseSchema.AnyWithProps,
+>() => Context.Service<TestConfect<ConfectSchema>>("@confect/test/TestConfect");
+
+class TestConfectImplWithoutIdentity<
+  ConfectSchema extends DatabaseSchema.AnyWithProps,
+> implements TestConfectWithoutIdentity<ConfectSchema> {
+  constructor(
+    private confectSchema: ConfectSchema,
+    private testConvex: TestConvexForDataModel<
+      DataModel.ToConvex<DataModel.FromSchema<ConfectSchema>>
+    >,
+    private mountedHttp: ReturnType<typeof MountedHttp.make>,
+  ) {}
+
+  readonly query = <QueryRef extends Ref.AnyQuery>(
+    queryRef: QueryRef,
+    ...args: Ref.OptionalArgs<QueryRef>
+  ): Effect.Effect<
+    Ref.Returns<QueryRef>,
+    Ref.Error<QueryRef> | Schema.SchemaError
+  > =>
+    Ref.runWithCodec(
+      queryRef,
+      (args[0] ?? {}) as Ref.Args<QueryRef>,
+      (functionReference, encodedArgs) =>
+        this.testConvex.query(functionReference as any, encodedArgs),
+    );
+
+  readonly mutation = <MutationRef extends Ref.AnyMutation>(
+    mutationRef: MutationRef,
+    ...args: Ref.OptionalArgs<MutationRef>
+  ): Effect.Effect<
+    Ref.Returns<MutationRef>,
+    Ref.Error<MutationRef> | Schema.SchemaError
+  > =>
+    Ref.runWithCodec(
+      mutationRef,
+      (args[0] ?? {}) as Ref.Args<MutationRef>,
+      (functionReference, encodedArgs) =>
+        this.testConvex.mutation(functionReference as any, encodedArgs),
+    );
+
+  readonly action = <ActionRef extends Ref.AnyAction>(
+    actionRef: ActionRef,
+    ...args: Ref.OptionalArgs<ActionRef>
+  ): Effect.Effect<
+    Ref.Returns<ActionRef>,
+    Ref.Error<ActionRef> | Schema.SchemaError
+  > =>
+    Ref.runWithCodec(
+      actionRef,
+      (args[0] ?? {}) as Ref.Args<ActionRef>,
+      (functionReference, encodedArgs) =>
+        this.testConvex.action(functionReference as any, encodedArgs),
+    );
+
+  readonly run: TestConfectWithoutIdentity<ConfectSchema>["run"] = (<
+    A,
+    B extends Value,
+    E,
+  >(
+    handler: Effect.Effect<
+      A,
+      E,
+      RegisteredConvexFunction.MutationServices<ConfectSchema>
+    >,
+    returns?: Schema.Codec<A, B>,
+  ): Effect.Effect<void> | Effect.Effect<A, Schema.SchemaError> => {
+    const makeMutationLayer = (
+      mutationCtx: GenericMutationCtx<
+        DataModel.ToConvex<DataModel.FromSchema<ConfectSchema>>
+      >,
+    ): Layer.Layer<RegisteredConvexFunction.MutationServices<ConfectSchema>> =>
+      RegisteredConvexFunction.mutationLayer(
+        this.confectSchema,
+        mutationCtx,
+      ) as Layer.Layer<
+        RegisteredConvexFunction.MutationServices<ConfectSchema>
+      >;
+
+    return returns === undefined
+      ? Effect.promise(() =>
+          this.testConvex.run((mutationCtx) =>
+            Effect.runPromise(
+              handler.pipe(
+                Effect.asVoid,
+                Effect.provide(makeMutationLayer(mutationCtx)),
+              ),
+            ),
+          ),
+        )
+      : Effect.promise(() =>
+          this.testConvex.run((mutationCtx) =>
+            Effect.runPromise(
+              handler.pipe(
+                Effect.andThen(Schema.encodeEffect(returns)),
+                Effect.provide(makeMutationLayer(mutationCtx)),
+              ),
+            ),
+          ),
+        ).pipe(Effect.andThen(Schema.decodeEffect(returns)));
+  }) as TestConfectWithoutIdentity<ConfectSchema>["run"];
+
+  readonly fetch = <PathQueryFragment extends string>(
+    pathQueryFragment: PathQueryFragment,
+    init?: RequestInit,
+  ) =>
+    Effect.promise(() =>
+      this.mountedHttp.fetch(this.testConvex, pathQueryFragment, init),
+    );
+
+  readonly finishInProgressScheduledFunctions = () =>
+    Effect.promise(() => this.testConvex.finishInProgressScheduledFunctions());
+
+  readonly finishAllScheduledFunctions = (advanceTimers: () => void) =>
+    Effect.promise(() =>
+      this.testConvex.finishAllScheduledFunctions(advanceTimers),
+    );
+}
+
+class TestConfectImpl<
+  ConfectSchema extends DatabaseSchema.AnyWithProps,
+> implements TestConfect<ConfectSchema> {
+  private readonly testConfectImplWithoutIdentity: TestConfectImplWithoutIdentity<ConfectSchema>;
+
+  constructor(
+    private confectSchema: ConfectSchema,
+    private testConvex: TestConvexForDataModelAndIdentity<
+      DataModel.ToConvex<DataModel.FromSchema<ConfectSchema>>
+    >,
+    private mountedHttp: ReturnType<typeof MountedHttp.make>,
+  ) {
+    this.testConfectImplWithoutIdentity = new TestConfectImplWithoutIdentity(
+      confectSchema,
+      testConvex,
+      mountedHttp,
+    );
+  }
+
+  readonly withIdentity = (userIdentity: Partial<UserIdentity>) =>
+    new TestConfectImplWithoutIdentity(
+      this.confectSchema,
+      this.testConvex.withIdentity(userIdentity),
+      this.mountedHttp,
+    );
+
+  readonly registerComponent: TestConfect<ConfectSchema>["registerComponent"] =
+    Effect.fn("TestConfect.registerComponent")(
+      (componentPath, schema, modules) =>
+        Effect.sync(() =>
+          this.mountedHttp.register(componentPath, schema, modules),
+        ),
+    );
+
+  readonly query = <QueryRef extends Ref.AnyQuery>(
+    queryRef: QueryRef,
+    ...args: Ref.OptionalArgs<QueryRef>
+  ) => this.testConfectImplWithoutIdentity.query(queryRef, ...args);
+
+  readonly mutation = <MutationRef extends Ref.AnyMutation>(
+    mutationRef: MutationRef,
+    ...args: Ref.OptionalArgs<MutationRef>
+  ) => this.testConfectImplWithoutIdentity.mutation(mutationRef, ...args);
+
+  readonly action = <ActionRef extends Ref.AnyAction>(
+    actionRef: ActionRef,
+    ...args: Ref.OptionalArgs<ActionRef>
+  ) => this.testConfectImplWithoutIdentity.action(actionRef, ...args);
+
+  readonly run: TestConfect<ConfectSchema>["run"] = ((
+    handler: any,
+    returns?: any,
+  ) =>
+    this.testConfectImplWithoutIdentity.run(
+      handler,
+      returns,
+    )) as TestConfect<ConfectSchema>["run"];
+
+  readonly fetch = <PathQueryFragment extends string>(
+    pathQueryFragment: PathQueryFragment,
+    init?: RequestInit,
+  ) => this.testConfectImplWithoutIdentity.fetch(pathQueryFragment, init);
+
+  readonly finishInProgressScheduledFunctions = () =>
+    this.testConfectImplWithoutIdentity.finishInProgressScheduledFunctions();
+
+  readonly finishAllScheduledFunctions = (advanceTimers: () => void) =>
+    this.testConfectImplWithoutIdentity.finishAllScheduledFunctions(
+      advanceTimers,
+    );
+}
+
+/**
+ * Codegen's test-only schema and module registry.
+ */
+export type Registry<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> = {
+  readonly schema: DatabaseSchema_;
+  readonly convexSchema: SchemaDefinition<GenericSchema, true>;
+  readonly modules: Record<string, () => Promise<any>>;
+  readonly components: Readonly<
+    Record<
+      string,
+      {
+        readonly schema: SchemaDefinition<GenericSchema, boolean>;
+        readonly modules: Record<string, () => Promise<any>>;
+      }
+    >
+  >;
+};
+
+/**
+ * The declared app's generated, test-only representation.
+ */
+export type DeclaredApp<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> =
+  Registry<DatabaseSchema_> & {
+    readonly httpMounts: ReadonlyArray<HttpMount>;
+  };
+
+/**
+ * Build a fresh test backend from a declaration and its generated
+ * `confect/_generated/testing` registry, without restating component mounts.
+ */
+export function layer<DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
+  app: DeclaredApp<DatabaseSchema_>,
+): Layer.Layer<TestConfect<DatabaseSchema_>>;
+export function layer<
+  A extends App.Any,
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+>(
+  app: A,
+  registry: Registry<DatabaseSchema_> & {
+    readonly components: Readonly<
+      Record<
+        keyof NoInfer<A>["mounts"],
+        Registry<DatabaseSchema_>["components"][string]
+      >
+    >;
+  },
+): Layer.Layer<TestConfect<DatabaseSchema_>>;
+export function layer<DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
+  databaseSchema: DatabaseSchema_,
+  convexSchemaDefinition: SchemaDefinition<GenericSchema, true>,
+  modules: Record<string, () => Promise<any>>,
+  options?: LayerOptions,
+): Layer.Layer<TestConfect<DatabaseSchema_>>;
+export function layer<DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
+  appOrSchema: App.Any | DeclaredApp<DatabaseSchema_> | DatabaseSchema_,
+  registryOrSchema?:
+    | Registry<DatabaseSchema_>
+    | SchemaDefinition<GenericSchema, true>,
+  modules?: Record<string, () => Promise<any>>,
+  options: LayerOptions = {},
+): Layer.Layer<TestConfect<DatabaseSchema_>> {
+  if (App.isApp(appOrSchema)) {
+    const registry = registryOrSchema as Registry<DatabaseSchema_>;
+    const mounts = App.mounts(appOrSchema);
+    return schemaLayer(
+      registry.schema,
+      registry.convexSchema,
+      registry.modules,
+      {
+        httpMounts: mounts.flatMap(({ name, httpPrefix }) =>
+          httpPrefix === undefined ? [] : [{ componentPath: name, httpPrefix }],
+        ),
+        register: (registerComponent) => {
+          for (const [name, component] of Object.entries(registry.components)) {
+            if (
+              mounts.some(
+                (mount) =>
+                  name === mount.name || name.startsWith(`${mount.name}/`),
+              )
+            ) {
+              registerComponent(name, component.schema, component.modules);
+            }
+          }
+        },
+      },
+    );
+  }
+  if ("httpMounts" in appOrSchema) {
+    const app = appOrSchema as DeclaredApp<DatabaseSchema_>;
+    return schemaLayer(app.schema, app.convexSchema, app.modules, {
+      httpMounts: app.httpMounts,
+      register: (registerComponent) => {
+        for (const [name, component] of Object.entries(app.components)) {
+          registerComponent(name, component.schema, component.modules);
+        }
+      },
+    });
+  }
+  return schemaLayer(
+    appOrSchema as DatabaseSchema_,
+    registryOrSchema as SchemaDefinition<GenericSchema, true>,
+    modules!,
+    options,
+  );
+}
+
+const schemaLayer = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
+  databaseSchema: DatabaseSchema_,
+  convexSchemaDefinition: SchemaDefinition<GenericSchema, true>,
+  modules: Record<string, () => Promise<any>>,
+  options: LayerOptions = {},
+): Layer.Layer<TestConfect<DatabaseSchema_>> =>
+  Layer.sync(TestConfect<DatabaseSchema_>(), () => {
+    const testConvex = convexTest(convexSchemaDefinition, modules);
+    const mountedHttp = MountedHttp.make(options.httpMounts ?? [], (...args) =>
+      testConvex.registerComponent(...args),
+    );
+    options.register?.(mountedHttp.register);
+    return new TestConfectImpl(databaseSchema, testConvex as any, mountedHttp);
+  });

package/src/index.ts

@@ -0,0 +1 @@
+export * as TestConfect from "./TestConfect";

package/src/internal/MountedHttp.ts

@@ -0,0 +1,266 @@
+/* oxlint-disable effecttsgo/async-function -- This convex-test adapter uses Promise callbacks and temporarily overrides the real process environment consumed by HTTP module construction. */
+import type { TestConvexForDataModel } from "convex-test";
+import type {
+  GenericDataModel,
+  HttpRouter,
+  FunctionReference,
+  RoutableMethod,
+  PublicHttpAction,
+} from "convex/server";
+import { actionGeneric } from "convex/server";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import type { HttpMount, RegisterComponent } from "../TestConfect";
+
+declare const process: { env: Record<string, string | undefined> };
+
+class InvalidHttpMount extends Schema.TaggedError<InvalidHttpMount>()(
+  "InvalidHttpMount",
+  {
+    componentPath: Schema.String,
+    httpPrefix: Schema.String,
+    message: Schema.String,
+  },
+) {}
+
+class ComponentHttpError extends Schema.TaggedError<ComponentHttpError>()(
+  "ComponentHttpError",
+  { componentPath: Schema.String, message: Schema.String },
+) {}
+
+class InvalidFetchPath extends Schema.TaggedError<InvalidFetchPath>()(
+  "InvalidFetchPath",
+  { path: Schema.String, message: Schema.String },
+) {}
+
+type NormalizedMount = {
+  readonly componentPath: string;
+  readonly prefix: string;
+};
+
+const normalizeMounts = (mounts: ReadonlyArray<HttpMount>) => {
+  const normalized: Array<NormalizedMount> = [];
+  for (const mount of mounts) {
+    if (!mount.httpPrefix.startsWith("/") || /[?#]/.test(mount.httpPrefix)) {
+      return Result.fail(
+        new InvalidHttpMount({
+          ...mount,
+          message:
+            "httpPrefix must be an absolute path without a query or fragment.",
+        }),
+      );
+    }
+    const prefix = mount.httpPrefix.replace(/\/+$/, "");
+    if (normalized.some((previous) => previous.prefix === prefix)) {
+      return Result.fail(
+        new InvalidHttpMount({
+          ...mount,
+          message: "Each httpPrefix must select one component installation.",
+        }),
+      );
+    }
+    normalized.push({ componentPath: mount.componentPath, prefix });
+  }
+  return Result.succeed(
+    normalized.sort((a, b) => b.prefix.length - a.prefix.length),
+  );
+};
+
+type HttpRequest = {
+  siteUrl: string;
+  url: string;
+  pathname: string;
+  method: string;
+  headers: Array<[string, string]>;
+  body: ArrayBuffer | null;
+};
+
+type HttpResponse = {
+  status: number;
+  statusText: string;
+  headers: Array<[string, string]>;
+  body: ArrayBuffer;
+};
+
+// Convex omits this runtime entry point from its published declarations.
+const isInvokable = (
+  action: PublicHttpAction,
+): action is PublicHttpAction & {
+  invokeHttpAction(request: Request): Promise<Response>;
+} =>
+  "invokeHttpAction" in action && typeof action.invokeHttpAction === "function";
+
+const bridgeModule = "__confect_test_http";
+const defaultSiteUrl = "https://some.convex.site";
+
+export const make = (
+  mounts: ReadonlyArray<HttpMount>,
+  registerComponent: RegisterComponent,
+) => {
+  const normalized = normalizeMounts(mounts);
+  if (Result.isFailure(normalized)) throw normalized.failure;
+  const registered = new Set<string>();
+  let tail = Promise.resolve();
+
+  const register: RegisterComponent = (componentPath, schema, modules) => {
+    if (
+      !normalized.success.some((mount) => mount.componentPath === componentPath)
+    ) {
+      registerComponent(componentPath, schema, modules);
+      return;
+    }
+    const generated = Object.keys(modules).find((key) =>
+      key.includes("_generated"),
+    );
+    const root = generated?.split("_generated", 2)[0];
+    const moduleLoaders = Object.fromEntries(
+      Object.entries(modules).map(([path, load]) => [
+        path.replace(/\.[^.]+$/, ""),
+        load,
+      ]),
+    );
+    const loadHttp =
+      root === undefined ? undefined : moduleLoaders[`${root}http`];
+    if (root === undefined || loadHttp === undefined) {
+      throw new ComponentHttpError({
+        componentPath,
+        message:
+          "Mounted components need an HTTP module and Convex _generated modules.",
+      });
+    }
+    const bridgePath = `${root}${bridgeModule}.ts`;
+    if (`${root}${bridgeModule}` in moduleLoaders) {
+      throw new ComponentHttpError({
+        componentPath,
+        message: `${bridgeModule} is reserved for mounted HTTP tests.`,
+      });
+    }
+    const routers = new Map<string, Promise<HttpRouter>>();
+    const invoke = actionGeneric({
+      handler: async (_ctx, args: HttpRequest): Promise<HttpResponse> => {
+        const previousSiteUrl = process.env.CONVEX_SITE_URL;
+        try {
+          process.env.CONVEX_SITE_URL = args.siteUrl;
+          let router = routers.get(args.siteUrl);
+          if (router === undefined) {
+            router = loadHttp().then(
+              (module: { default: HttpRouter }) => module.default,
+            );
+            routers.set(args.siteUrl, router);
+          }
+          const route = (await router).lookup(
+            args.pathname,
+            args.method as RoutableMethod,
+          );
+          let response: Response;
+          if (route === null) {
+            response = new Response(
+              `No HttpAction routed for ${args.pathname}`,
+              { status: 404 },
+            );
+          } else {
+            const action = route[0];
+            if (!isInvokable(action)) {
+              throw new ComponentHttpError({
+                componentPath,
+                message:
+                  "This Convex version does not expose invokeHttpAction for HTTP tests.",
+              });
+            }
+            // Convex selects on the relative path and passes the full URL to the handler.
+            response = await action.invokeHttpAction(
+              new Request(args.url, {
+                method: args.method,
+                headers: args.headers,
+                ...(args.body === null ? {} : { body: args.body }),
+              }),
+            );
+          }
+          return {
+            status: response.status,
+            statusText: response.statusText,
+            headers: [...response.headers],
+            body: await response.arrayBuffer(),
+          };
+        } finally {
+          if (previousSiteUrl === undefined) delete process.env.CONVEX_SITE_URL;
+          else process.env.CONVEX_SITE_URL = previousSiteUrl;
+        }
+      },
+    });
+    registerComponent(componentPath, schema, {
+      ...modules,
+      [bridgePath]: () => Promise.resolve({ invoke }),
+    });
+    registered.add(componentPath);
+  };
+
+  const fetch = <DataModel extends GenericDataModel>(
+    accessor: TestConvexForDataModel<DataModel>,
+    path: string,
+    init?: RequestInit,
+  ): Promise<Response> => {
+    if (normalized.success.length === 0) return accessor.fetch(path, init);
+    const run = async () => {
+      if (!path.startsWith("/")) {
+        throw new InvalidFetchPath({
+          path,
+          message: 'Path given to fetch must start with a "/".',
+        });
+      }
+      const pathname = new URL(`${defaultSiteUrl}${path}`).pathname;
+      const mount = normalized.success.find(
+        ({ prefix }) =>
+          pathname === prefix || pathname.startsWith(`${prefix}/`),
+      );
+      if (mount === undefined) return accessor.fetch(path, init);
+      if (!registered.has(mount.componentPath)) {
+        throw new ComponentHttpError({
+          componentPath: mount.componentPath,
+          message: "Register the mounted component before calling fetch.",
+        });
+      }
+      const appSiteUrl = (
+        process.env.CONVEX_SITE_URL || defaultSiteUrl
+      ).replace(/\/$/, "");
+      const request = new Request(new URL(`${appSiteUrl}${path}`), init);
+      // convex-test encodes exact component paths in test-only function handles.
+      const reference =
+        `function://${mount.componentPath};${bridgeModule}:invoke` as unknown as FunctionReference<
+          "action",
+          "public",
+          HttpRequest,
+          HttpResponse
+        >;
+      const response = await accessor.action(reference, {
+        siteUrl: `${appSiteUrl}${mount.prefix}`,
+        url: request.url,
+        pathname: pathname.slice(mount.prefix.length) || "/",
+        method: request.method,
+        headers: [...request.headers],
+        body:
+          request.method === "GET" || request.method === "HEAD"
+            ? null
+            : await request.arrayBuffer(),
+      });
+      return new Response(
+        request.method === "HEAD" || [204, 205, 304].includes(response.status)
+          ? null
+          : response.body,
+        {
+          status: response.status,
+          statusText: response.statusText,
+          headers: response.headers,
+        },
+      );
+    };
+    const result = tail.then(run);
+    tail = result.then(
+      () => undefined,
+      () => undefined,
+    );
+    return result;
+  };
+
+  return { register, fetch };
+};