@confect/server 9.0.0-next.4 → 9.0.0-next.6

package/src/DatabaseSchema.ts

@@ -1,10 +1,5 @@
-import type { Expand, GenericSchema } from "convex/server";
-import {
-  defineSchema as defineConvexSchema,
-  type SchemaDefinition,
-} from "convex/server";
-import { Array, pipe, Predicate, Record } from "effect";
-import * as Table from "./Table";
+import { Predicate } from "effect";
+import type * as Table from "./Table";
 
 export const TypeId = "@confect/server/DatabaseSchema";
 export type TypeId = typeof TypeId;
@@ -17,29 +12,25 @@ export const isDatabaseSchema = (u: unknown): u is Any =>
   Predicate.hasProperty(u, TypeId);
 
 /**
- * A schema definition tracks the schema and its Convex schema definition.
+ * A schema definition holding a record of bound `Table`s keyed by table
+ * name. Codegen emits a single static `DatabaseSchema.make({ ... })` call;
+ * laziness now lives entirely on each `Table` (its `Fields`, `Doc`, and
+ * `tableDefinition` are lazy memoised getters), so this layer is a plain
+ * record indirection with no module-loading or async machinery.
  */
 export interface DatabaseSchema<Tables_ extends Table.AnyWithProps = never> {
   readonly [TypeId]: TypeId;
-  readonly tables: Table.TablesRecord<Tables_>;
-  readonly convexSchemaDefinition: SchemaDefinition<
-    ConvexDatabaseSchemaFromTables<Tables_>,
-    true
-  >;
-
-  /**
-   * Add a table definition to the schema.
-   */
-  addTable<TableDef extends Table.AnyWithProps>(
-    table: TableDef,
-  ): DatabaseSchema<Tables_ | TableDef>;
+  readonly tables: {
+    readonly [TableName in Table.Name<Tables_>]: Table.WithName<
+      Tables_,
+      TableName
+    >;
+  };
 }
 
 export interface AnyWithProps {
   readonly [TypeId]: TypeId;
   readonly tables: Record<string, Table.AnyWithProps>;
-  readonly convexSchemaDefinition: SchemaDefinition<GenericSchema, true>;
-  addTable<TableDef extends Table.AnyWithProps>(table: TableDef): AnyWithProps;
 }
 
 export type Tables<DatabaseSchema_ extends AnyWithProps> =
@@ -53,82 +44,31 @@ export type TableNames<DatabaseSchema_ extends AnyWithProps> = Table.Name<
 export type TableWithName<
   DatabaseSchema_ extends AnyWithProps,
   TableName extends TableNames<DatabaseSchema_>,
-> = Extract<Tables<DatabaseSchema_>, { readonly name: TableName }>;
-
-const Proto = {
-  [TypeId]: TypeId,
-
-  addTable<TableDef extends Table.AnyWithProps>(
-    this: DatabaseSchema<Table.AnyWithProps>,
-    table: TableDef,
-  ) {
-    const tablesArray = Object.values(this.tables) as Table.AnyWithProps[];
-    const newTablesArray = [...tablesArray, table];
-
-    return makeProto({
-      tables: Record.set(this.tables, table.name, table),
-      convexSchemaDefinition: pipe(
-        newTablesArray,
-        Array.map(
-          ({ name, tableDefinition }) => [name, tableDefinition] as const,
-        ),
-        Record.fromEntries,
-        defineConvexSchema,
-      ),
-    });
-  },
-};
-
-const makeProto = <Tables_ extends Table.AnyWithProps>({
-  tables,
-  convexSchemaDefinition,
-}: {
-  tables: Record.ReadonlyRecord<string, Tables_>;
-  convexSchemaDefinition: SchemaDefinition<GenericSchema, true>;
-}): DatabaseSchema<Tables_> =>
-  Object.assign(Object.create(Proto), {
-    tables,
-    convexSchemaDefinition,
-  });
+> = Extract<Tables<DatabaseSchema_>, { readonly tableName: TableName }>;
 
 /**
- * Create an empty schema definition. Add tables incrementally via `addTable`.
+ * Construct a `DatabaseSchema` from a record of bound `Table`s. The empty
+ * case is `DatabaseSchema.make({})`. The `Tables_` union is inferred from
+ * the value record's values, so codegen-emitted calls of the form
+ * `DatabaseSchema.make({ notes, tags, users })` do not need an explicit
+ * type argument.
+ *
+ * Invariant: each record **key must equal its value's `tableName`**. The
+ * record is stored verbatim and later read by key (`databaseSchema.tables[
+ * tableName]` in `DatabaseReader`/`DatabaseWriter`), so a key that diverges
+ * from the bound table's name would make those lookups silently miss. The
+ * type signature does not enforce this — codegen upholds it by deriving both
+ * the key and the table name from the same filename (and the shorthand
+ * `{ notes, tags, users }` form it emits makes them identical by
+ * construction). Hand-written calls must preserve it.
  */
-export const make = (): DatabaseSchema<never> =>
-  makeProto({
-    tables: Record.empty(),
-    convexSchemaDefinition: defineConvexSchema({}),
-  });
-
-export type ConvexDatabaseSchemaFromTables<Tables_ extends Table.AnyWithProps> =
-  Expand<{
-    [TableName in Table.Name<Tables_> & string]: Table.WithName<
-      Tables_,
-      TableName
-    >["tableDefinition"];
-  }>;
-
-// System tables
-
-export const systemSchema = make()
-  .addTable(Table.scheduledFunctionsTable)
-  .addTable(Table.storageTable);
-
-export const extendWithSystemTables = <Tables_ extends Table.AnyWithProps>(
-  tables: Table.TablesRecord<Tables_>,
-): ExtendWithSystemTables<Tables_> =>
-  ({
-    ...tables,
-    ...Table.systemTables,
-  }) as ExtendWithSystemTables<Tables_>;
-
-export type ExtendWithSystemTables<Tables_ extends Table.AnyWithProps> =
-  Table.TablesRecord<Tables_ | Table.SystemTables>;
-
-export type IncludeSystemTables<Tables_ extends Table.AnyWithProps> =
-  | Tables_
-  | Table.SystemTables extends infer T
-  ? T extends Table.AnyWithProps
-    ? T
-    : never
-  : never;
+export const make = <
+  const TablesRecord extends Record<string, Table.AnyWithProps>,
+>(
+  tables: TablesRecord,
+): DatabaseSchema<TablesRecord[keyof TablesRecord]> => ({
+  [TypeId]: TypeId,
+  tables: tables as unknown as DatabaseSchema<
+    TablesRecord[keyof TablesRecord]
+  >["tables"],
+});

package/src/DatabaseWriter.ts

@@ -22,14 +22,13 @@ export const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
   >,
 ) => {
   type DataModel_ = DataModel.FromSchema<DatabaseSchema_>;
-  const tables = databaseSchema.tables as Record<string, Table.AnyWithProps>;
 
   const table = <const TableName extends DataModel.TableNames<DataModel_>>(
     tableName: TableName,
   ) => {
-    const tableDef = tables[tableName]!;
-    const tableSchema = tableDef.Fields as TableInfo.TableSchema<
-      DataModel.TableInfoWithName_<DataModel_, TableName>
+    const tableDef = databaseSchema.tables[tableName] as Table.WithName<
+      DatabaseSchema.Tables<DatabaseSchema_>,
+      TableName
     >;
 
     const insert = (
@@ -63,6 +62,10 @@ export const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
       >,
     ) =>
       Effect.gen(function* () {
+        const tableSchema = tableDef.Fields as TableInfo.TableSchema<
+          DataModel.TableInfoWithName_<DataModel_, TableName>
+        >;
+
         const originalDecodedDoc = yield* QueryInitializer.getById(
           tableName,
           convexDatabaseWriter as any,
@@ -100,7 +103,7 @@ export const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
         const updatedEncodedDoc = yield* Document.encode(
           value,
           tableName,
-          tableSchema,
+          tableDef.Fields,
         );
 
         yield* Effect.promise(() =>

package/src/FunctionImpl.ts

@@ -1,63 +1,66 @@
 import type * as FunctionSpec from "@confect/core/FunctionSpec";
 import type * as GroupSpec from "@confect/core/GroupSpec";
 import * as Registry from "@confect/core/Registry";
-import { Context, Effect, Layer, Ref, String } from "effect";
-import * as Api from "./Api";
+import { Context, Effect, Layer, Ref } from "effect";
+import type * as DatabaseSchema from "./DatabaseSchema";
 import type * as Handler from "./Handler";
 import { setNestedProperty } from "./internal/utils";
 import * as RegistryItem from "./RegistryItem";
 
-export interface FunctionImpl<
-  GroupPath_ extends string,
-  FunctionName extends string,
-> {
-  readonly groupPath: GroupPath_;
+export interface FunctionImpl<FunctionName extends string> {
   readonly functionName: FunctionName;
 }
 
-export const FunctionImpl = <
-  GroupPath_ extends string,
-  FunctionName extends string,
->({
-  groupPath,
+export const FunctionImpl = <FunctionName extends string>({
   functionName,
 }: {
-  groupPath: GroupPath_;
   functionName: FunctionName;
 }) =>
-  Context.GenericTag<FunctionImpl<GroupPath_, FunctionName>>(
-    `@confect/server/FunctionImpl/${groupPath}/${functionName}`,
+  Context.GenericTag<FunctionImpl<FunctionName>>(
+    `@confect/server/FunctionImpl/${functionName}`,
   );
 
+/**
+ * Register a single function's implementation into the group's `Registry`.
+ *
+ * The function is registered under a flat, single-segment key (its own
+ * `functionName`), not a project-wide dot-path. Each group's impl layer is
+ * built in isolation — `RegisteredFunctions.buildForGroup` (and the CLI's
+ * `validateImpl`) provide a fresh `Registry` per group — so function names
+ * only need to be unique within their own group.
+ *
+ * `databaseSchema` is retained purely as a type-level carrier: the handler's
+ * ctx-service requirements (`DatabaseReader`, `QueryCtx<DataModel>`, …) are
+ * derived from it via `Handler.WithName`. It is not read at runtime — the
+ * generated per-group registry forwards the schema value to the function
+ * builders — so impls depend on `_generated/schema` (table schemas) rather than
+ * `_generated/api` (which transitively imports every function spec).
+ */
 export const make = <
-  Api_ extends Api.AnyWithProps,
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
   Group extends GroupSpec.AnyWithProps,
   const FunctionName extends FunctionSpec.Name<GroupSpec.Functions<Group>>,
 >(
-  api: Api_,
+  _databaseSchema: DatabaseSchema_,
   group: Group,
   functionName: FunctionName,
   handler: Handler.WithName<
-    Api.Schema<Api_>,
+    DatabaseSchema_,
     GroupSpec.Functions<Group>,
     FunctionName
   >,
-): Layer.Layer<FunctionImpl<string, FunctionName>> => {
-  const groupPath = Api.resolveGroupPathUnsafe(api, group);
+): Layer.Layer<FunctionImpl<FunctionName>> => {
   const functionSpec = group.functions[functionName]!;
 
   return Layer.effect(
-    FunctionImpl<string, FunctionName>({
-      groupPath,
-      functionName,
-    }),
+    FunctionImpl<FunctionName>({ functionName }),
     Effect.gen(function* () {
       const registry = yield* Registry.Registry;
 
       yield* Ref.update(registry, (registryItems) =>
         setNestedProperty(
           registryItems,
-          [...String.split(groupPath, "."), functionName],
+          [functionName],
           RegistryItem.make({
             functionSpec,
             handler,
@@ -65,21 +68,16 @@ export const make = <
         ),
       );
 
-      return {
-        groupPath,
-        functionName,
-      };
+      return { functionName };
     }),
   );
 };
 
 /**
- * Get the function implementation service type for a specific group path and function name.
+ * Get the function implementation service type for a specific function name.
  */
-export type ForGroupPathAndFunction<
-  GroupPath_ extends string,
-  FunctionName extends string,
-> = FunctionImpl<GroupPath_, FunctionName>;
+export type ForFunction<FunctionName extends string> =
+  FunctionImpl<FunctionName>;
 
 /**
  * Get all function implementation services required for a group spec.
@@ -89,14 +87,6 @@ export type FromGroupSpec<Group extends GroupSpec.AnyWithProps> =
     GroupSpec.Functions<Group>
   > extends infer FunctionNames extends string
     ? FunctionNames extends string
-      ? FunctionImpl<string, FunctionNames>
+      ? FunctionImpl<FunctionNames>
       : never
     : never;
-
-/**
- * @deprecated Use {@link FromGroupSpec} instead.
- */
-export type FromGroupAtPath<
-  _GroupPath extends string,
-  Group extends GroupSpec.AnyWithProps,
-> = FromGroupSpec<Group>;

package/src/GroupImpl.ts

@@ -10,9 +10,8 @@ import {
   Predicate,
   Record,
   Ref,
-  String,
 } from "effect";
-import * as Api from "./Api";
+import type * as DatabaseSchema from "./DatabaseSchema";
 import type * as FunctionImpl from "./FunctionImpl";
 
 export const TypeId = "@confect/server/GroupImpl";
@@ -21,11 +20,9 @@ export type TypeId = typeof TypeId;
 export type FinalizationStatus = "Unfinalized" | "Finalized";
 
 export interface GroupImpl<
-  GroupPath_ extends string,
   FinalizationStatus_ extends FinalizationStatus = "Unfinalized",
 > {
   readonly [TypeId]: TypeId;
-  readonly groupPath: GroupPath_;
   readonly finalizationStatus: FinalizationStatus_;
   /**
    * Names of every function registered into this group's layer scope by
@@ -36,13 +33,13 @@ export interface GroupImpl<
   readonly registeredFunctionNames: ReadonlyArray<string>;
 }
 
-export interface Any extends GroupImpl<string, FinalizationStatus> {}
+export interface Any extends GroupImpl<FinalizationStatus> {}
 
 export const isGroupImpl = (u: unknown): u is Any =>
   Predicate.hasProperty(u, TypeId);
 
-export interface AnyFinalized extends GroupImpl<string, "Finalized"> {}
-export interface AnyUnfinalized extends GroupImpl<string, "Unfinalized"> {}
+export interface AnyFinalized extends GroupImpl<"Finalized"> {}
+export interface AnyUnfinalized extends GroupImpl<"Unfinalized"> {}
 
 export const isFinalizedGroupImpl = (u: unknown): u is AnyFinalized =>
   isGroupImpl(u) && u.finalizationStatus === "Finalized";
@@ -54,83 +51,71 @@ export const isUnfinalizedGroupImpl = (u: unknown): u is AnyUnfinalized =>
  * Build the runtime tag for a `GroupImpl` service. The finalization status is
  * embedded in the tag string so that `Unfinalized` and `Finalized` are distinct
  * services at runtime; consumers of a finalized layer (the server's
- * `RegisteredFunctions.buildForGroup` and the CLI's `implValidation`) retrieve
+ * `RegisteredFunctions.buildForGroup` and the CLI's `validateImpl`) retrieve
  * the typed `Finalized` service directly rather than scanning the context.
+ *
+ * The tag is keyed only by finalization status — no group path — because each
+ * group's impl layer is built in its own isolated scope (`buildForGroup` /
+ * `validateImpl` each provide a fresh `Registry`), so at most one `GroupImpl`
+ * service of each status exists per build.
  */
-export const GroupImpl = <
-  GroupPath_ extends string,
-  FinalizationStatus_ extends FinalizationStatus,
->({
-  groupPath,
+export const GroupImpl = <FinalizationStatus_ extends FinalizationStatus>({
   finalizationStatus,
 }: {
-  groupPath: GroupPath_;
   finalizationStatus: FinalizationStatus_;
 }) =>
-  Context.GenericTag<GroupImpl<GroupPath_, FinalizationStatus_>>(
-    `@confect/server/GroupImpl/${finalizationStatus}/${groupPath}`,
+  Context.GenericTag<GroupImpl<FinalizationStatus_>>(
+    `@confect/server/GroupImpl/${finalizationStatus}`,
   );
 
+/**
+ * Begin a group's impl layer. `databaseSchema` and `group` are retained only as
+ * type-level carriers (`group` drives the required `FunctionImpl` services via
+ * `FromGroupSpec<Group>`; `databaseSchema` keeps the impl's dependency on
+ * `_generated/schema` symmetric with `FunctionImpl.make`). Neither is read at
+ * runtime.
+ */
 export const make = <
-  Api_ extends Api.AnyWithProps,
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
   Group extends GroupSpec.AnyWithProps,
 >(
-  api: Api_,
-  group: Group,
+  _databaseSchema: DatabaseSchema_,
+  _group: Group,
 ): Layer.Layer<
-  GroupImpl<string, "Unfinalized">,
+  GroupImpl<"Unfinalized">,
   never,
   FunctionImpl.FromGroupSpec<Group>
-> => {
-  const groupPath = Api.resolveGroupPathUnsafe(api, group);
-
-  return Layer.succeed(
-    GroupImpl<string, "Unfinalized">({
-      groupPath,
-      finalizationStatus: "Unfinalized",
-    }),
+> =>
+  Layer.succeed(
+    GroupImpl<"Unfinalized">({ finalizationStatus: "Unfinalized" }),
     {
       [TypeId]: TypeId,
-      groupPath,
       finalizationStatus: "Unfinalized" as const,
       registeredFunctionNames: [],
     },
   ) as Layer.Layer<
-    GroupImpl<string, "Unfinalized">,
+    GroupImpl<"Unfinalized">,
     never,
     FunctionImpl.FromGroupSpec<Group>
   >;
-};
 
 const isFunctionShaped = (value: unknown): boolean =>
   Predicate.isRecord(value) && "functionSpec" in value;
 
 /**
- * Walk a `RegistryItems` tree to the entries at `groupPath` and return the
- * names of the function-shaped leaves directly underneath.
+ * Return the names of the function-shaped entries in a group's (flat,
+ * isolated) registry. `FunctionImpl.make` registers each function under a
+ * single-segment key, so the registry built for one group contains exactly
+ * that group's functions at the top level.
  */
-const collectFunctionNamesAtPath = (
+const collectFunctionNames = (
   items: Registry.RegistryItems,
-  groupPath: string,
 ): ReadonlyArray<string> =>
   pipe(
-    String.split(groupPath, "."),
-    Array.reduce(Option.some<unknown>(items), (acc, segment) =>
-      acc.pipe(
-        Option.filter(Predicate.isRecord),
-        Option.flatMap((node) =>
-          segment in node ? Option.some(node[segment]) : Option.none(),
-        ),
-      ),
+    Record.toEntries(items),
+    Array.filterMap(([name, value]) =>
+      isFunctionShaped(value) ? Option.some(name) : Option.none(),
     ),
-    Option.filter(Predicate.isRecord),
-    Option.map(Record.toEntries),
-    Option.map(
-      Array.filterMap(([name, value]) =>
-        isFunctionShaped(value) ? Option.some(name) : Option.none(),
-      ),
-    ),
-    Option.getOrElse((): ReadonlyArray<string> => []),
   );
 
 const findUnfinalizedGroupImpl = <S>(
@@ -151,12 +136,12 @@ const findUnfinalizedGroupImpl = <S>(
  * impl completeness against a `GroupSpec`'s expected functions without
  * having to inspect the `Registry` themselves.
  */
-export const finalize = <GroupPath_ extends string>(
-  group: Layer.Layer<GroupImpl<GroupPath_, "Unfinalized">>,
-): Layer.Layer<GroupImpl<GroupPath_, "Finalized">> =>
+export const finalize = (
+  group: Layer.Layer<GroupImpl<"Unfinalized">>,
+): Layer.Layer<GroupImpl<"Finalized">> =>
   Layer.flatMap(
     group,
-    (context): Layer.Layer<GroupImpl<GroupPath_, "Finalized">> =>
+    (context): Layer.Layer<GroupImpl<"Finalized">> =>
       findUnfinalizedGroupImpl(context).pipe(
         Option.match({
           onNone: () =>
@@ -165,28 +150,19 @@ export const finalize = <GroupPath_ extends string>(
                 "GroupImpl.finalize: no Unfinalized GroupImpl service was found in the layer's context.",
               ),
             ),
-          onSome: (unfinalized) => {
-            const groupPath = unfinalized.groupPath as GroupPath_;
-            return Layer.effect(
-              GroupImpl<GroupPath_, "Finalized">({
-                groupPath,
-                finalizationStatus: "Finalized",
-              }),
+          onSome: () =>
+            Layer.effect(
+              GroupImpl<"Finalized">({ finalizationStatus: "Finalized" }),
               Effect.gen(function* () {
                 const registry = yield* Registry.Registry;
                 const items = yield* Ref.get(registry);
                 return {
                   [TypeId]: TypeId,
-                  groupPath,
                   finalizationStatus: "Finalized" as const,
-                  registeredFunctionNames: collectFunctionNamesAtPath(
-                    items,
-                    groupPath,
-                  ),
+                  registeredFunctionNames: collectFunctionNames(items),
                 };
               }),
-            );
-          },
+            ),
         }),
       ),
   );

package/src/QueryInitializer.ts

@@ -238,7 +238,13 @@ export const make = <
     return OrderedQuery.make<
       DataModel.TableInfoWithName_<DataModel_, TableName>,
       TableName
-    >(orderedQuery, tableName, table.Fields);
+    >(
+      orderedQuery,
+      tableName,
+      table.Fields as TableInfo.TableSchema<
+        DataModel.TableInfoWithName_<DataModel_, TableName>
+      >,
+    );
   };
 
   const search: QueryInitializerFunction<"search"> = (
@@ -253,7 +259,9 @@ export const make = <
         .query(tableName)
         .withSearchIndex(indexName, searchFilter),
       tableName,
-      table.Fields,
+      table.Fields as TableInfo.TableSchema<
+        DataModel.TableInfoWithName_<DataModel_, TableName>
+      >,
     );
 
   return {

package/src/RegisteredConvexFunction.ts

@@ -12,7 +12,6 @@ import {
 } from "convex/server";
 import type { Value } from "convex/values";
 import { Clock, Effect, Layer, Match, pipe, Schema } from "effect";
-import type * as Api from "./Api";
 import * as Auth from "./Auth";
 import * as ConvexConfigProvider from "./ConvexConfigProvider";
 import * as DatabaseReader from "./DatabaseReader";
@@ -31,8 +30,8 @@ import * as SchemaToValidator from "./SchemaToValidator";
 import { StorageReader } from "./StorageReader";
 import { StorageWriter } from "./StorageWriter";
 
-export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Convex">>(
-  api: Api_,
+export const make = (
+  databaseSchema: DatabaseSchema.AnyWithProps,
   { functionSpec, handler }: RegistryItem.AnyWithProps,
 ): RegisteredFunction.Any =>
   Match.value(functionSpec.functionProvenance).pipe(
@@ -51,7 +50,7 @@ export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Convex">>(
 
           return genericFunction(
             queryFunction({
-              databaseSchema: api.databaseSchema,
+              databaseSchema,
               args: functionProvenance.args,
               returns: functionProvenance.returns,
               error: functionProvenance.error,
@@ -68,7 +67,7 @@ export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Convex">>(
 
           return genericFunction(
             mutationFunction({
-              databaseSchema: api.databaseSchema,
+              databaseSchema,
               args: functionProvenance.args,
               returns: functionProvenance.returns,
               error: functionProvenance.error,
@@ -84,7 +83,7 @@ export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Convex">>(
           );
 
           return genericFunction(
-            convexActionFunction(api.databaseSchema, {
+            convexActionFunction(databaseSchema, {
               args: functionProvenance.args,
               returns: functionProvenance.returns,
               error: functionProvenance.error,