@gaganref/confect-server 10.3.1-fork.3 → 10.3.1-fork.30

package/src/DatabaseWriter.ts

@@ -10,13 +10,16 @@ import { pipe } from "effect/Function";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
 import * as Record from "effect/Record";
-import * as DatabaseSchema from "./DatabaseSchema";
-import type * as DataModel from "./DataModel";
-import type { DocumentByName as DocumentByName_ } from "./DataModel";
-import * as Document from "./Document";
-import * as QueryInitializer from "./QueryInitializer";
-import type * as Table from "./Table";
+import * as Result from "effect/Result";
+import * as DatabaseSchema from "./DatabaseSchema.js";
+import type * as DataModel from "./DataModel.js";
+import type { DocumentByName as DocumentByName_ } from "./DataModel.js";
+import * as Document from "./Document.js";
+import * as DocumentPatch from "./internal/DocumentPatch.js";
+import * as QueryInitializer from "./QueryInitializer.js";
+import type * as Table from "./Table.js";
 
 /**
  * The argument accepted by `patch`: like `Partial<Doc>` without system fields,
@@ -97,11 +100,54 @@ export type DatabaseWriterTag<
   DatabaseWriterService<DatabaseSchema_, Docs>
 >;
 
+/**
+ * Decoded documents surrounding one successful write.
+ */
+export type Change<S extends DatabaseSchema.AnyWithProps> = {
+  [Name in DataModel.TableNames<DataModel.FromSchema<S>>]: {
+    readonly tableName: Name;
+  } & (
+    | {
+        readonly operation: "insert";
+        readonly oldDoc: null;
+        readonly newDoc: DocumentByName_<DataModel.FromSchema<S>, Name>;
+      }
+    | {
+        readonly operation: "update";
+        readonly oldDoc: DocumentByName_<DataModel.FromSchema<S>, Name>;
+        readonly newDoc: DocumentByName_<DataModel.FromSchema<S>, Name>;
+      }
+    | {
+        readonly operation: "delete";
+        readonly oldDoc: DocumentByName_<DataModel.FromSchema<S>, Name>;
+        readonly newDoc: null;
+      }
+  );
+}[DataModel.TableNames<DataModel.FromSchema<S>>];
+
+/**
+ * Runs after the write, in its transaction. A defect aborts the mutation.
+ *
+ * Only writes through this writer are observed. Raw `ctx.db`, `MutationCtx`
+ * writes and a second `DatabaseWriter.make` bypass the hook, so a host that
+ * relies on it keeps raw writers out of its functions. Component writers and
+ * nested `runMutation` calls each need their own hook installation.
+ *
+ * Concurrent writes to one document (for example under `Effect.all`) can
+ * interleave the read-write-read steps. Await them sequentially when the hook
+ * needs exact per-write snapshots. The writer takes no lock, because a hook
+ * that writes through the same writer would deadlock under one.
+ */
+export type Hook<S extends DatabaseSchema.AnyWithProps> = (
+  change: Change<S>,
+) => Effect.Effect<void>;
+
 export const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
   databaseSchema: DatabaseSchema_,
   convexDatabaseWriter: GenericDatabaseWriter<
     DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
   >,
+  hook?: Hook<DatabaseSchema_>,
 ): DatabaseWriterService<DatabaseSchema_> => {
   type DataModel_ = DataModel.FromSchema<DatabaseSchema_>;
 
@@ -131,38 +177,108 @@ export const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
       return id as unknown as DataModel.Id<DataModel_, TableName>;
     });
 
+    // A codec whose encoding spans fields cannot encode a patch on its own, so
+    // the patch is merged into the decoded document and the result replaces it.
+    const replacePatched = (
+      id: DataModel.Id<DataModel_, TableName>,
+      patchedValues: PatchValue<
+        Document.WithoutSystemFields<DocumentByName_<DataModel_, TableName>>
+      >,
+    ) =>
+      Effect.gen(function* () {
+        const originalDecodedDoc = yield* QueryInitializer.getById<
+          Table.AnyWithProps,
+          TableName
+        >(
+          convexDatabaseWriter as any,
+          tableDef,
+        )(id as unknown as GenericId<TableName>);
+
+        const updatedEncodedDoc = yield* pipe(
+          patchedValues,
+          Record.reduce(originalDecodedDoc, (acc, value, key) =>
+            value === undefined
+              ? Record.remove(acc, key)
+              : Record.set(acc, key, value),
+          ),
+          Document.encode(tableDef),
+        );
+
+        yield* Effect.promise(() =>
+          convexDatabaseWriter.replace(
+            id as unknown as GenericId<TableName>,
+            updatedEncodedDoc as Expand<
+              BetterOmit<
+                DocumentByName<DataModel.ToConvex<DataModel_>, TableName>,
+                "_creationTime" | "_id"
+              >
+            >,
+          ),
+        );
+      });
+
     const patch = Effect.fn("DatabaseWriter.patch")(function* (
       id: DataModel.Id<DataModel_, TableName>,
       patchedValues: PatchValue<
         Document.WithoutSystemFields<DocumentByName_<DataModel_, TableName>>
       >,
     ) {
-      const originalDecodedDoc = yield* QueryInitializer.getById<
-        Table.AnyWithProps,
-        TableName
-      >(
-        convexDatabaseWriter as any,
-        tableDef,
-      )(id as unknown as GenericId<TableName>);
+      const encodePatch = DocumentPatch.encoder(tableDef);
+      if (encodePatch === undefined) {
+        return yield* replacePatched(id, patchedValues);
+      }
 
-      const updatedEncodedDoc = yield* pipe(
-        patchedValues,
-        Record.reduce(originalDecodedDoc, (acc, value, key) =>
-          value === undefined
-            ? Record.remove(acc, key)
-            : Record.set(acc, key, value),
+      const storedDoc = yield* pipe(
+        Effect.promise(() =>
+          convexDatabaseWriter.get(id as unknown as GenericId<TableName>),
+        ),
+        Effect.andThen((value) =>
+          Effect.fromResult(
+            Result.fromNullishOr(
+              value,
+              () =>
+                new QueryInitializer.GetByIdFailure({
+                  tableName,
+                  id,
+                }),
+            ),
+          ),
+        ),
+      );
+      // The patch must encode and the patched document must decode. When
+      // either fails, the stored document decides whose fault that is.
+      const encodedPatch = yield* pipe(
+        encodePatch(patchedValues),
+        Effect.mapError(({ message }) => message),
+        Effect.tap((delta) =>
+          pipe(
+            { ...storedDoc, ...delta },
+            Record.filter(Predicate.isNotUndefined),
+            Document.decode(tableDef),
+            Effect.mapError(({ parseError }) => parseError),
+          ),
+        ),
+        Effect.catch((parseError) =>
+          pipe(
+            Document.decode(storedDoc, tableDef),
+            Effect.andThen(
+              Effect.fail(
+                new Document.DocumentEncodeError({
+                  tableName,
+                  id,
+                  parseError,
+                }),
+              ),
+            ),
+          ),
         ),
-        Document.encode(tableDef),
       );
 
       yield* Effect.promise(() =>
-        convexDatabaseWriter.replace(
+        convexDatabaseWriter.patch(
           id as unknown as GenericId<TableName>,
-          updatedEncodedDoc as Expand<
-            BetterOmit<
-              DocumentByName<DataModel.ToConvex<DataModel_>, TableName>,
-              "_creationTime" | "_id"
-            >
+          encodedPatch as Partial<
+            DocumentByName<DataModel.ToConvex<DataModel_>, TableName>
           >,
         ),
       );
@@ -194,11 +310,52 @@ export const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
         convexDatabaseWriter.delete(id as unknown as GenericId<TableName>),
       );
 
+    const accessor = { insert, patch, replace, delete: delete_ };
+    if (hook === undefined) return accessor;
+
+    const read = (id: DataModel.Id<DataModel_, TableName>) =>
+      QueryInitializer.getById<Table.AnyWithProps, TableName>(
+        convexDatabaseWriter as any,
+        tableDef,
+      )(id as unknown as GenericId<TableName>);
+    const notify = (
+      operation: "insert" | "update" | "delete",
+      oldDoc: unknown,
+      newDoc: unknown,
+    ) =>
+      hook({ tableName, operation, oldDoc, newDoc } as Change<DatabaseSchema_>);
+    const update =
+      <A extends ReadonlyArray<unknown>, E, BeforeError>(
+        before: (
+          id: DataModel.Id<DataModel_, TableName>,
+        ) => Effect.Effect<unknown, BeforeError>,
+        write: (
+          id: DataModel.Id<DataModel_, TableName>,
+          ...args: A
+        ) => Effect.Effect<void, E>,
+      ) =>
+      (id: DataModel.Id<DataModel_, TableName>, ...args: A) =>
+        Effect.gen(function* () {
+          const oldDoc = yield* before(id);
+          yield* write(id, ...args);
+          yield* notify("update", oldDoc, yield* read(id).pipe(Effect.orDie));
+        });
+
     return {
-      insert,
-      patch,
-      replace,
-      delete: delete_,
+      insert: (document: Parameters<typeof insert>[0]) =>
+        Effect.gen(function* () {
+          const id = yield* insert(document);
+          yield* notify("insert", null, yield* read(id).pipe(Effect.orDie));
+          return id;
+        }),
+      patch: update(read, patch),
+      replace: update((id) => read(id).pipe(Effect.orDie), replace),
+      delete: (id: DataModel.Id<DataModel_, TableName>) =>
+        Effect.gen(function* () {
+          const oldDoc = yield* read(id).pipe(Effect.orDie);
+          yield* delete_(id);
+          yield* notify("delete", oldDoc, null);
+        }),
     };
   };
 
@@ -225,8 +382,9 @@ export const layer = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
   convexDatabaseWriter: GenericDatabaseWriter<
     DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
   >,
+  hook?: Hook<DatabaseSchema_>,
 ) =>
   Layer.succeed(
     DatabaseWriter<DatabaseSchema_>(),
-    make(databaseSchema, convexDatabaseWriter),
+    make(databaseSchema, convexDatabaseWriter, hook),
   );

package/src/Document.ts

@@ -4,10 +4,10 @@ import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Schema from "effect/Schema";
 import type { ReadonlyRecord } from "effect/Record";
-import type * as DatabaseSchema from "./DatabaseSchema";
-import type * as DataModel from "./DataModel";
-import type * as TableInfo from "./TableInfo";
-import type * as Table from "./Table";
+import type * as DatabaseSchema from "./DatabaseSchema.js";
+import type * as DataModel from "./DataModel.js";
+import type * as TableInfo from "./TableInfo.js";
+import type * as Table from "./Table.js";
 
 export type Document<
   Schema_ extends DatabaseSchema.AnyWithProps,

package/src/FunctionImpl.ts

@@ -1,15 +1,15 @@
 import type * as FunctionSpec from "@confect/core/FunctionSpec";
 import type * as GroupSpec from "@confect/core/GroupSpec";
 import type * as MiddlewareSpec from "@confect/core/MiddlewareSpec";
-import * as Registry from "./Registry";
+import * as Registry from "./Registry.js";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Ref from "effect/Ref";
-import type * as DatabaseSchema from "./DatabaseSchema";
-import type * as Handler from "./Handler";
-import { setNestedProperty } from "./internal/utils";
-import * as FunctionRegistryItem from "./FunctionRegistryItem";
+import type * as DatabaseSchema from "./DatabaseSchema.js";
+import type * as Handler from "./Handler.js";
+import { setNestedProperty } from "./internal/utils.js";
+import * as FunctionRegistryItem from "./FunctionRegistryItem.js";
 
 export interface FunctionImpl<Name_ extends string> {
   readonly name: Name_;

package/src/FunctionRegistryItem.ts

@@ -5,7 +5,7 @@ import type { FunctionType, FunctionVisibility } from "convex/server";
 import * as Match from "effect/Match";
 import * as Predicate from "effect/Predicate";
 import type * as Schema from "effect/Schema";
-import type * as Handler from "./Handler";
+import type * as Handler from "./Handler.js";
 
 export const TypeId = "~@confect/server/FunctionRegistryItem";
 export type TypeId = typeof TypeId;

package/src/GroupImpl.ts

@@ -1,17 +1,18 @@
 import type * as GroupSpec from "@confect/core/GroupSpec";
 import type * as MiddlewareSpec from "@confect/core/MiddlewareSpec";
-import * as Registry from "./Registry";
-import * as RegistryItems from "./RegistryItems";
+import * as Registry from "./Registry.js";
+import * as RegistryItems from "./RegistryItems.js";
 import * as Array from "effect/Array";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
+import * as Data from "effect/Data";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
 import * as Ref from "effect/Ref";
-import type * as DatabaseSchema from "./DatabaseSchema";
-import type * as FunctionImpl from "./FunctionImpl";
-import type * as MiddlewareImpl from "./MiddlewareImpl";
+import type * as DatabaseSchema from "./DatabaseSchema.js";
+import type * as FunctionImpl from "./FunctionImpl.js";
+import type * as MiddlewareImpl from "./MiddlewareImpl.js";
 
 export const TypeId = "~@confect/server/GroupImpl";
 export type TypeId = typeof TypeId;
@@ -111,10 +112,20 @@ export const make = <
     FunctionImpl.FromGroupSpec<Group> | MiddlewareImpl.FromGroupSpec<Group>
   >;
 
-const findUnfinalizedGroupImpl = <S>(
-  context: Context.Context<S>,
-): Option.Option<AnyUnfinalized> =>
-  Array.findFirst(context.mapUnsafe.values(), isUnfinalizedGroupImpl);
+const findGroupImpl = <S>(context: Context.Context<S>): Option.Option<Any> =>
+  Array.findFirst(context.mapUnsafe.values(), isGroupImpl);
+
+export class MissingRequiredMiddlewareError extends Data.TaggedError(
+  "MissingRequiredMiddlewareError",
+)<{
+  readonly missing: ReadonlyArray<RegistryItems.MissingMiddleware>;
+}> {
+  override get message(): string {
+    return `GroupImpl.finalize: ${this.missing.map(({ functionName, middlewareKey }) => `${functionName} requires middleware "${middlewareKey}"`).join("\n")}`;
+  }
+}
+
+type Finalizable = Layer.Layer<AnyUnfinalized> | Layer.Layer<AnyFinalized>;
 
 /**
  * Mark a `GroupImpl` layer as fully implemented. The parameter type defaults
@@ -127,20 +138,52 @@ const findUnfinalizedGroupImpl = <S>(
  * registered into this group's scope are snapshotted onto the produced service
  * value's `registeredFunctionNames` field, so consumers can verify impl
  * completeness against a `GroupSpec`'s expected functions without having to
- * inspect the `Registry` themselves.
+ * inspect the `Registry` themselves. Pass `{ required }` to check every
+ * registered function's middleware at layer build, including internal
+ * functions. This form also accepts a finalized layer so generated registration
+ * can enforce the backend declaration without changing authored impls. Pass
+ * `groupPath` to qualify uncovered function names in the diagnostic.
  */
-export const finalize = (
+export function finalize(options: {
+  readonly groupPath?: string;
+  readonly required: ReadonlyArray<
+    Pick<MiddlewareSpec.AnyMiddlewareSpec, "key">
+  >;
+}): (group: Finalizable) => Layer.Layer<GroupImpl<"Finalized">>;
+export function finalize(
   group: Layer.Layer<GroupImpl<"Unfinalized">>,
+): Layer.Layer<GroupImpl<"Finalized">>;
+export function finalize(
+  input:
+    | Finalizable
+    | {
+        readonly groupPath?: string;
+        readonly required: ReadonlyArray<
+          Pick<MiddlewareSpec.AnyMiddlewareSpec, "key">
+        >;
+      },
+):
+  | Layer.Layer<GroupImpl<"Finalized">>
+  | ((group: Finalizable) => Layer.Layer<GroupImpl<"Finalized">>) {
+  return "required" in input
+    ? (group) => finalizeWith(group, input.required, input.groupPath)
+    : finalizeWith(input, []);
+}
+
+const finalizeWith = (
+  group: Layer.Layer<never>,
+  required: ReadonlyArray<Pick<MiddlewareSpec.AnyMiddlewareSpec, "key">>,
+  groupPath = "",
 ): Layer.Layer<GroupImpl<"Finalized">> =>
   Layer.flatMap(group, (context): Layer.Layer<GroupImpl<"Finalized">> =>
-    findUnfinalizedGroupImpl(context).pipe(
+    findGroupImpl(context).pipe(
       Option.match({
         onNone: () =>
           Layer.effect(
             GroupImpl<"Finalized">({ finalizationStatus: "Finalized" }),
             Effect.die(
               new Error(
-                "GroupImpl.finalize: no Unfinalized GroupImpl service was found in the layer's context.",
+                "GroupImpl.finalize: no GroupImpl service was found in the layer's context.",
               ),
             ),
           ),
@@ -150,6 +193,16 @@ export const finalize = (
             Effect.gen(function* () {
               const registry = yield* Registry.Registry;
               const items = yield* Ref.get(registry);
+              const missing = RegistryItems.missingRequired(
+                items,
+                required,
+                groupPath,
+              );
+              if (missing.length > 0) {
+                return yield* Effect.die(
+                  new MissingRequiredMiddlewareError({ missing }),
+                );
+              }
               return {
                 [TypeId]: TypeId,
                 finalizationStatus: "Finalized" as const,

package/src/GroupRegistry.ts

@@ -1,10 +1,10 @@
 import * as Effect from "effect/Effect";
 import type * as Layer from "effect/Layer";
 import * as Ref from "effect/Ref";
-import * as Registry from "./Registry";
-import type * as RegistryItems from "./RegistryItems";
-import type * as GroupImpl from "./GroupImpl";
-import * as MiddlewareRegistryItem from "./MiddlewareRegistryItem";
+import * as Registry from "./Registry.js";
+import type * as RegistryItems from "./RegistryItems.js";
+import type * as GroupImpl from "./GroupImpl.js";
+import * as MiddlewareRegistryItem from "./MiddlewareRegistryItem.js";
 
 export const make = (
   groupLayer: Layer.Layer<GroupImpl.GroupImpl<"Finalized">>,

package/src/Handler.ts

@@ -1,30 +1,31 @@
+import type { ActionCall } from "@confect/core/ActionCall";
 import type { FunctionSpec, RuntimeAndFunctionType } from "@confect/core";
 import type * as FunctionProvenance from "@confect/core/FunctionProvenance";
 import type * as NodeServices from "@effect/platform-node/NodeServices";
 import type { Effect } from "effect";
-import type * as ActionCtx from "./ActionCtx";
-import type * as ActionRunner from "./ActionRunner";
-import type * as Auth from "./Auth";
-import type * as DatabaseReader from "./DatabaseReader";
-import type * as DatabaseSchema from "./DatabaseSchema";
-import type * as DatabaseWriter from "./DatabaseWriter";
-import type * as DataModel from "./DataModel";
-import type { ExecutionMetadata } from "./ExecutionMetadata";
-import type { RequestMetadata } from "./RequestMetadata";
-import type { TransactionMetadata } from "./TransactionMetadata";
-import type * as MutationCtx from "./MutationCtx";
-import type * as MutationRunner from "./MutationRunner";
-import type { MutationTransactionContext } from "./MutationTransactionContext";
-import type * as QueryCtx from "./QueryCtx";
-import type * as QueryRunner from "./QueryRunner";
-import type { QueryTransactionContext } from "./QueryTransactionContext";
-import type * as RegisteredFunction from "./RegisteredFunction";
-import type * as Scheduler from "./Scheduler";
-import type { Storage } from "./Storage";
-import type * as StorageActionWriter from "./StorageActionWriter";
-import type * as StorageReader from "./StorageReader";
-import type * as StorageWriter from "./StorageWriter";
-import type * as VectorSearch from "./VectorSearch";
+import type * as ActionCtx from "./ActionCtx.js";
+import type * as ActionRunner from "./ActionRunner.js";
+import type * as Auth from "./Auth.js";
+import type * as DatabaseReader from "./DatabaseReader.js";
+import type * as DatabaseSchema from "./DatabaseSchema.js";
+import type * as DatabaseWriter from "./DatabaseWriter.js";
+import type * as DataModel from "./DataModel.js";
+import type { ExecutionMetadata } from "./ExecutionMetadata.js";
+import type { RequestMetadata } from "./RequestMetadata.js";
+import type { TransactionMetadata } from "./TransactionMetadata.js";
+import type * as MutationCtx from "./MutationCtx.js";
+import type * as MutationRunner from "./MutationRunner.js";
+import type { MutationTransactionContext } from "./MutationTransactionContext.js";
+import type * as QueryCtx from "./QueryCtx.js";
+import type * as QueryRunner from "./QueryRunner.js";
+import type { QueryTransactionContext } from "./QueryTransactionContext.js";
+import type * as RegisteredFunction from "./RegisteredFunction.js";
+import type * as Scheduler from "./Scheduler.js";
+import type { Storage } from "./Storage.js";
+import type * as StorageActionWriter from "./StorageActionWriter.js";
+import type * as StorageReader from "./StorageReader.js";
+import type * as StorageWriter from "./StorageWriter.js";
+import type * as VectorSearch from "./VectorSearch.js";
 
 export type Handler<
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
@@ -114,9 +115,7 @@ export type MutationServices<
 /**
  * Shared by both action runtimes.
  */
-export type ActionServices<
-  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
-> =
+type RawActionServices<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> =
   | Scheduler.ForScope<DatabaseSchema.Scope<DatabaseSchema_>>
   | (DatabaseSchema_["target"]["kind"] extends "component" ? never : Auth.Auth)
   | StorageReader.ForScope<DatabaseSchema.Scope<DatabaseSchema_>>
@@ -134,6 +133,22 @@ export type ActionServices<
       DatabaseSchema.Scope<DatabaseSchema_>
     >;
 
+export type ActionServices<S extends DatabaseSchema.AnyWithProps, R = never> = [
+  Extract<R, ActionCall>,
+] extends [never]
+  ? RawActionServices<S>
+  : Exclude<
+      RawActionServices<S>,
+      | Scheduler.ForScope<DatabaseSchema.Scope<S>>
+      | QueryRunner.QueryRunner
+      | MutationRunner.MutationRunner
+      | ActionRunner.ActionRunner
+      | ActionCtx.ActionCtx<
+          DataModel.ToConvex<DataModel.FromSchema<S>>,
+          DatabaseSchema.Scope<S>
+        >
+    >;
+
 export type ConfectProvenanceQuery<
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
   FunctionSpec_ extends
@@ -153,7 +168,7 @@ export type ConvexRuntimeAction<
   FunctionSpec_ extends
     FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyAction>,
   R = never,
-> = Base<FunctionSpec_, ActionServices<DatabaseSchema_> | R>;
+> = Base<FunctionSpec_, ActionServices<DatabaseSchema_, R> | R>;
 
 export type NodeRuntimeAction<
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
@@ -162,7 +177,7 @@ export type NodeRuntimeAction<
   R = never,
 > = Base<
   FunctionSpec_,
-  ActionServices<DatabaseSchema_> | NodeServices.NodeServices | R
+  ActionServices<DatabaseSchema_, R> | NodeServices.NodeServices | R
 >;
 
 type Base<FunctionSpec_ extends FunctionSpec.AnyWithProps, R> = (

package/src/HttpRouter.ts

@@ -25,23 +25,23 @@ import type * as Etag from "effect/http/Etag";
 import type * as HttpPlatform from "effect/http/HttpPlatform";
 import * as HttpRouter from "effect/http/HttpRouter";
 import * as HttpServer from "effect/http/HttpServer";
-import type * as ActionRunner from "./ActionRunner";
-import type * as Auth from "./Auth";
-import type { ExecutionMetadata } from "./ExecutionMetadata";
-import type { RequestMetadata } from "./RequestMetadata";
-import type * as DatabaseSchema from "./DatabaseSchema";
-import type * as DataModel from "./DataModel";
-import type * as Handler from "./Handler";
-import * as ConvexConfigProvider from "./ConvexConfigProvider";
-import * as ConvexLogger from "./ConvexLogger";
-import type * as MutationRunner from "./MutationRunner";
-import type * as QueryRunner from "./QueryRunner";
-import * as RegisteredFunction from "./RegisteredFunction";
-import type * as Scheduler from "./Scheduler";
-import type { Storage } from "./Storage";
-import type { StorageActionWriter } from "./StorageActionWriter";
-import type { StorageReader } from "./StorageReader";
-import type { StorageWriter } from "./StorageWriter";
+import type * as ActionRunner from "./ActionRunner.js";
+import type * as Auth from "./Auth.js";
+import type { ExecutionMetadata } from "./ExecutionMetadata.js";
+import type { RequestMetadata } from "./RequestMetadata.js";
+import type * as DatabaseSchema from "./DatabaseSchema.js";
+import type * as DataModel from "./DataModel.js";
+import type * as Handler from "./Handler.js";
+import * as ConvexConfigProvider from "./ConvexConfigProvider.js";
+import * as ConvexLogger from "./ConvexLogger.js";
+import type * as MutationRunner from "./MutationRunner.js";
+import type * as QueryRunner from "./QueryRunner.js";
+import * as RegisteredFunction from "./RegisteredFunction.js";
+import type * as Scheduler from "./Scheduler.js";
+import type { Storage } from "./Storage.js";
+import type { StorageActionWriter } from "./StorageActionWriter.js";
+import type { StorageReader } from "./StorageReader.js";
+import type { StorageWriter } from "./StorageWriter.js";
 
 /**
  * The Confect services available to HTTP route handlers and middleware,

package/src/MiddlewareImpl.ts

@@ -1,28 +1,28 @@
 import type * as FunctionSpec from "@confect/core/FunctionSpec";
 import type * as GroupSpec from "@confect/core/GroupSpec";
 import * as MiddlewareSpec from "@confect/core/MiddlewareSpec";
-import * as Registry from "./Registry";
+import * as Registry from "./Registry.js";
 import type { FunctionType } from "convex/server";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Ref from "effect/Ref";
-import type * as Auth from "./Auth";
-import type * as DatabaseReader from "./DatabaseReader";
-import type * as DatabaseSchema from "./DatabaseSchema";
-import type * as Handler from "./Handler";
-import type { ExecutionMetadata } from "./ExecutionMetadata";
-import type { RequestMetadata } from "./RequestMetadata";
-import type { TransactionMetadata } from "./TransactionMetadata";
-import type * as MutationRunner from "./MutationRunner";
-import type * as QueryRunner from "./QueryRunner";
-import type { QueryTransactionContext } from "./QueryTransactionContext";
-import type * as Scheduler from "./Scheduler";
-import type { Storage } from "./Storage";
-import type * as StorageReader from "./StorageReader";
-import type * as StorageWriter from "./StorageWriter";
-import * as MiddlewareRegistryItem from "./MiddlewareRegistryItem";
-import { setNestedProperty } from "./internal/utils";
+import type * as Auth from "./Auth.js";
+import type * as DatabaseReader from "./DatabaseReader.js";
+import type * as DatabaseSchema from "./DatabaseSchema.js";
+import type * as Handler from "./Handler.js";
+import type { ExecutionMetadata } from "./ExecutionMetadata.js";
+import type { RequestMetadata } from "./RequestMetadata.js";
+import type { TransactionMetadata } from "./TransactionMetadata.js";
+import type * as MutationRunner from "./MutationRunner.js";
+import type * as QueryRunner from "./QueryRunner.js";
+import type { QueryTransactionContext } from "./QueryTransactionContext.js";
+import type * as Scheduler from "./Scheduler.js";
+import type { Storage } from "./Storage.js";
+import type * as StorageReader from "./StorageReader.js";
+import type * as StorageWriter from "./StorageWriter.js";
+import * as MiddlewareRegistryItem from "./MiddlewareRegistryItem.js";
+import { setNestedProperty } from "./internal/utils.js";
 
 /**
  * Marker service produced by providing a middleware's implementation to a