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

package/dist/DatabaseReader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DatabaseReader.d.ts","names":[],"sources":["../src/DatabaseReader.ts"],"mappings":";;;;;;;;;;;;;;;;;;cAQa,IAAA,2BAAgC,YAAA,EAC3C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA;kCAUR,IAAA,CAAU,mBAAA,CAAA,MAAA,CAAA,eAAA,KAAgB,SAAA,EAC7C,SAAA;IAAA;;;;;;;;;;;cAgCJ,cAAA,2BACa,YAAA,OAA2B,OAAA,CAAA,GAAA;kCAlC1B,IAAA,CAAA,mBAAA,CAAA,MAAA,CAAA,eAAA,KAAA,SAAA,EAAA,SAAA;IAAA;;;;;;;;;;;kCAAA,IAAA,CAAA,mBAAA,CAAA,MAAA,CAAA,eAAA,KAAA,SAAA,EAAA,SAAA;IAAA;;;;;;;;;;;KAwCf,cAAA,yBACc,YAAA,IACtB,UAAA,QAAkB,cAAA,CAAe,eAAA;AAAA,cAExB,KAAA,2BAAiC,YAAA,EAC5C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA,QACzC,KAAA,CAAA,KAAA;kCAhDwB,IAAA,CAAA,mBAAA,CAAA,MAAA,CAAA,eAAA,KAAA,SAAA,EAAA,SAAA;IAAA"}
+{"version":3,"file":"DatabaseReader.d.ts","names":[],"sources":["../src/DatabaseReader.ts"],"mappings":"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"}

package/dist/DatabaseReader.js

@@ -1,8 +1,7 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { systemTables } from "./Table.js";
-import { extendWithSystemTables } from "./DatabaseSchema.js";
 import { make as make$1 } from "./QueryInitializer.js";
-import { Array, Context, Layer } from "effect";
+import { systemTables } from "./Table.js";
+import { Context, Layer } from "effect";
 
 //#region src/DatabaseReader.ts
 var DatabaseReader_exports = /* @__PURE__ */ __exportAll({
@@ -11,16 +10,16 @@ var DatabaseReader_exports = /* @__PURE__ */ __exportAll({
 	make: () => make
 });
 const make = (databaseSchema, convexDatabaseReader) => {
-	const extendedTables = extendWithSystemTables(databaseSchema.tables);
 	return { table: (tableName) => {
-		const table = Object.values(extendedTables).find((def) => def.name === tableName);
-		const baseDatabaseReader = Array.some(Object.values(systemTables), (systemTableDef) => systemTableDef.name === tableName) ? {
+		const isSystem = Object.hasOwn(systemTables, tableName);
+		const baseDatabaseReader = isSystem ? {
 			get: convexDatabaseReader.system.get,
 			query: convexDatabaseReader.system.query
 		} : {
 			get: convexDatabaseReader.get,
 			query: convexDatabaseReader.query
 		};
+		const table = isSystem ? systemTables[tableName] : databaseSchema.tables[tableName];
 		return make$1(tableName, baseDatabaseReader, table);
 	} };
 };

package/dist/DatabaseReader.js.map

@@ -1 +1 @@
-{"version":3,"file":"DatabaseReader.js","names":["DatabaseSchema.extendWithSystemTables","Table.systemTables","QueryInitializer.make"],"sources":["../src/DatabaseReader.ts"],"sourcesContent":["import type { GenericDatabaseReader } from \"convex/server\";\nimport { Array, Context, Layer } from \"effect\";\nimport type { BaseDatabaseReader } from \"@confect/core/Types\";\nimport * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as DataModel from \"./DataModel\";\nimport * as QueryInitializer from \"./QueryInitializer\";\nimport * as Table from \"./Table\";\n\nexport const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(\n  databaseSchema: DatabaseSchema_,\n  convexDatabaseReader: GenericDatabaseReader<\n    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n  >,\n) => {\n  type Tables = DatabaseSchema.Tables<DatabaseSchema_>;\n  type IncludedTables = DatabaseSchema.IncludeSystemTables<Tables>;\n  const extendedTables = DatabaseSchema.extendWithSystemTables(\n    databaseSchema.tables as Table.TablesRecord<Tables>,\n  );\n\n  return {\n    table: <const TableName extends Table.Name<IncludedTables>>(\n      tableName: TableName,\n    ) => {\n      const table = Object.values(extendedTables).find(\n        (def) => def.name === tableName,\n      ) as Table.WithName<IncludedTables, TableName>;\n\n      const baseDatabaseReader: BaseDatabaseReader<any> = Array.some(\n        Object.values(Table.systemTables),\n        (systemTableDef) => systemTableDef.name === tableName,\n      )\n        ? ({\n            get: convexDatabaseReader.system.get,\n            query: convexDatabaseReader.system.query,\n          } as BaseDatabaseReader<\n            DataModel.ToConvex<DataModel.FromTables<Table.SystemTables>>\n          >)\n        : ({\n            get: convexDatabaseReader.get,\n            query: convexDatabaseReader.query,\n          } as BaseDatabaseReader<\n            DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n          >);\n\n      return QueryInitializer.make<IncludedTables, TableName>(\n        tableName,\n        baseDatabaseReader,\n        table,\n      );\n    },\n  };\n};\n\nexport const DatabaseReader = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n>() =>\n  Context.GenericTag<ReturnType<typeof make<DatabaseSchema_>>>(\n    \"@confect/server/DatabaseReader\",\n  );\n\nexport type DatabaseReader<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n> = ReturnType<typeof DatabaseReader<DatabaseSchema_>>[\"Identifier\"];\n\nexport const layer = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(\n  databaseSchema: DatabaseSchema_,\n  convexDatabaseReader: GenericDatabaseReader<\n    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n  >,\n) =>\n  Layer.succeed(\n    DatabaseReader<DatabaseSchema_>(),\n    make(databaseSchema, convexDatabaseReader),\n  );\n"],"mappings":";;;;;;;;;;;;AAQA,MAAa,QACX,gBACA,yBAGG;CAGH,MAAM,iBAAiBA,uBACrB,eAAe,OAChB;AAED,QAAO,EACL,QACE,cACG;EACH,MAAM,QAAQ,OAAO,OAAO,eAAe,CAAC,MACzC,QAAQ,IAAI,SAAS,UACvB;EAED,MAAM,qBAA8C,MAAM,KACxD,OAAO,OAAOC,aAAmB,GAChC,mBAAmB,eAAe,SAAS,UAC7C,GACI;GACC,KAAK,qBAAqB,OAAO;GACjC,OAAO,qBAAqB,OAAO;GACpC,GAGA;GACC,KAAK,qBAAqB;GAC1B,OAAO,qBAAqB;GAC7B;AAIL,SAAOC,OACL,WACA,oBACA,MACD;IAEJ;;AAGH,MAAa,uBAGX,QAAQ,WACN,iCACD;AAMH,MAAa,SACX,gBACA,yBAIA,MAAM,QACJ,gBAAiC,EACjC,KAAK,gBAAgB,qBAAqB,CAC3C"}
+{"version":3,"file":"DatabaseReader.js","names":["Table.systemTables","QueryInitializer.make"],"sources":["../src/DatabaseReader.ts"],"sourcesContent":["import type { GenericDatabaseReader } from \"convex/server\";\nimport { Context, Layer } from \"effect\";\nimport type { BaseDatabaseReader } from \"@confect/core/Types\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as DataModel from \"./DataModel\";\nimport * as QueryInitializer from \"./QueryInitializer\";\nimport * as Table from \"./Table\";\n\nexport const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(\n  databaseSchema: DatabaseSchema_,\n  convexDatabaseReader: GenericDatabaseReader<\n    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n  >,\n) => {\n  type Tables = DatabaseSchema.Tables<DatabaseSchema_>;\n  type IncludedTables = Tables | Table.SystemTables;\n\n  return {\n    table: <const TableName extends Table.Name<IncludedTables>>(\n      tableName: TableName,\n    ) => {\n      const isSystem = Object.hasOwn(Table.systemTables, tableName);\n\n      const baseDatabaseReader: BaseDatabaseReader<any> = isSystem\n        ? {\n            get: convexDatabaseReader.system.get,\n            query: convexDatabaseReader.system.query,\n          }\n        : {\n            get: convexDatabaseReader.get,\n            query: convexDatabaseReader.query,\n          };\n\n      const table = (\n        isSystem\n          ? (Table.systemTables as Record<string, Table.AnyWithProps>)[\n              tableName\n            ]\n          : databaseSchema.tables[tableName]\n      ) as Table.WithName<IncludedTables, TableName>;\n\n      return QueryInitializer.make<IncludedTables, TableName>(\n        tableName,\n        baseDatabaseReader,\n        table,\n      );\n    },\n  };\n};\n\nexport const DatabaseReader = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n>() =>\n  Context.GenericTag<ReturnType<typeof make<DatabaseSchema_>>>(\n    \"@confect/server/DatabaseReader\",\n  );\n\nexport type DatabaseReader<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n> = ReturnType<typeof DatabaseReader<DatabaseSchema_>>[\"Identifier\"];\n\nexport const layer = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(\n  databaseSchema: DatabaseSchema_,\n  convexDatabaseReader: GenericDatabaseReader<\n    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n  >,\n) =>\n  Layer.succeed(\n    DatabaseReader<DatabaseSchema_>(),\n    make(databaseSchema, convexDatabaseReader),\n  );\n"],"mappings":";;;;;;;;;;;AAQA,MAAa,QACX,gBACA,yBAGG;AAIH,QAAO,EACL,QACE,cACG;EACH,MAAM,WAAW,OAAO,OAAOA,cAAoB,UAAU;EAE7D,MAAM,qBAA8C,WAChD;GACE,KAAK,qBAAqB,OAAO;GACjC,OAAO,qBAAqB,OAAO;GACpC,GACD;GACE,KAAK,qBAAqB;GAC1B,OAAO,qBAAqB;GAC7B;EAEL,MAAM,QACJ,WACKA,aACC,aAEF,eAAe,OAAO;AAG5B,SAAOC,OACL,WACA,oBACA,MACD;IAEJ;;AAGH,MAAa,uBAGX,QAAQ,WACN,iCACD;AAMH,MAAa,SACX,gBACA,yBAIA,MAAM,QACJ,gBAAiC,EACjC,KAAK,gBAAgB,qBAAqB,CAC3C"}

package/dist/DatabaseSchema.d.ts

@@ -1,11 +1,8 @@
-import { AnyWithProps as AnyWithProps$1, Name, SystemTables, Table, TablesRecord, WithName } from "./Table.js";
-import { Expand, GenericSchema, SchemaDefinition } from "convex/server";
-import * as convex_values0 from "convex/values";
-import * as effect_Schema0 from "effect/Schema";
+import { AnyWithProps as AnyWithProps$1, Name, WithName } from "./Table.js";
 
 //#region src/DatabaseSchema.d.ts
 declare namespace DatabaseSchema_d_exports {
-  export { Any, AnyWithProps, ConvexDatabaseSchemaFromTables, DatabaseSchema, ExtendWithSystemTables, IncludeSystemTables, TableNames, TableWithName, Tables, TypeId, extendWithSystemTables, isDatabaseSchema, make, systemSchema };
+  export { Any, AnyWithProps, DatabaseSchema, TableNames, TableWithName, Tables, TypeId, isDatabaseSchema, make };
 }
 declare const TypeId = "@confect/server/DatabaseSchema";
 type TypeId = typeof TypeId;
@@ -14,126 +11,42 @@ interface Any {
 }
 declare const isDatabaseSchema: (u: unknown) => u is Any;
 /**
- * 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.
  */
 interface DatabaseSchema<Tables_ extends AnyWithProps$1 = never> {
   readonly [TypeId]: TypeId;
-  readonly tables: TablesRecord<Tables_>;
-  readonly convexSchemaDefinition: SchemaDefinition<ConvexDatabaseSchemaFromTables<Tables_>, true>;
-  /**
-   * Add a table definition to the schema.
-   */
-  addTable<TableDef extends AnyWithProps$1>(table: TableDef): DatabaseSchema<Tables_ | TableDef>;
+  readonly tables: { readonly [TableName in Name<Tables_>]: WithName<Tables_, TableName> };
 }
 interface AnyWithProps {
   readonly [TypeId]: TypeId;
   readonly tables: Record<string, AnyWithProps$1>;
-  readonly convexSchemaDefinition: SchemaDefinition<GenericSchema, true>;
-  addTable<TableDef extends AnyWithProps$1>(table: TableDef): AnyWithProps;
 }
 type Tables<DatabaseSchema_ extends AnyWithProps> = DatabaseSchema_ extends DatabaseSchema<infer Tables_> ? Tables_ : never;
 type TableNames<DatabaseSchema_ extends AnyWithProps> = Name<Tables<DatabaseSchema_>> & string;
 type TableWithName<DatabaseSchema_ extends AnyWithProps, TableName extends TableNames<DatabaseSchema_>> = Extract<Tables<DatabaseSchema_>, {
-  readonly name: TableName;
+  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.
  */
-declare const make: () => DatabaseSchema<never>;
-type ConvexDatabaseSchemaFromTables<Tables_ extends AnyWithProps$1> = Expand<{ [TableName in Name<Tables_> & string]: WithName<Tables_, TableName>["tableDefinition"] }>;
-declare const systemSchema: DatabaseSchema<Table<"_scheduled_functions", effect_Schema0.Struct<{
-  name: typeof effect_Schema0.String;
-  args: effect_Schema0.Array$<typeof effect_Schema0.Any>;
-  scheduledTime: typeof effect_Schema0.Number;
-  completedTime: effect_Schema0.optionalWith<typeof effect_Schema0.Number, {
-    exact: true;
-  }>;
-  state: effect_Schema0.Union<[effect_Schema0.Struct<{
-    kind: effect_Schema0.Literal<["pending"]>;
-  }>, effect_Schema0.Struct<{
-    kind: effect_Schema0.Literal<["inProgress"]>;
-  }>, effect_Schema0.Struct<{
-    kind: effect_Schema0.Literal<["success"]>;
-  }>, effect_Schema0.Struct<{
-    kind: effect_Schema0.Literal<["failed"]>;
-    error: typeof effect_Schema0.String;
-  }>, effect_Schema0.Struct<{
-    kind: effect_Schema0.Literal<["canceled"]>;
-  }>]>;
-}>, convex_values0.VObject<{
-  name: string;
-  args: any[];
-  scheduledTime: number;
-  state: {
-    kind: "pending";
-  } | {
-    kind: "inProgress";
-  } | {
-    kind: "success";
-  } | {
-    kind: "failed";
-    error: string;
-  } | {
-    kind: "canceled";
-  };
-  completedTime?: number;
-}, {
-  name: convex_values0.VString<string, "required">;
-  args: convex_values0.VArray<any[], convex_values0.VAny<any, "required", string>, "required">;
-  scheduledTime: convex_values0.VFloat64<number, "required">;
-  state: convex_values0.VUnion<{
-    kind: "pending";
-  } | {
-    kind: "inProgress";
-  } | {
-    kind: "success";
-  } | {
-    kind: "failed";
-    error: string;
-  } | {
-    kind: "canceled";
-  }, [convex_values0.VObject<{
-    kind: "pending";
-  }, {
-    kind: convex_values0.VLiteral<"pending", "required">;
-  }, "required", "kind">, convex_values0.VObject<{
-    kind: "inProgress";
-  }, {
-    kind: convex_values0.VLiteral<"inProgress", "required">;
-  }, "required", "kind">, convex_values0.VObject<{
-    kind: "success";
-  }, {
-    kind: convex_values0.VLiteral<"success", "required">;
-  }, "required", "kind">, convex_values0.VObject<{
-    kind: "failed";
-    error: string;
-  }, {
-    kind: convex_values0.VLiteral<"failed", "required">;
-    error: convex_values0.VString<string, "required">;
-  }, "required", "kind" | "error">, convex_values0.VObject<{
-    kind: "canceled";
-  }, {
-    kind: convex_values0.VLiteral<"canceled", "required">;
-  }, "required", "kind">], "required", "kind" | "error">;
-  completedTime: convex_values0.VFloat64<number | undefined, "optional">;
-}, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}> | Table<"_storage", effect_Schema0.Struct<{
-  sha256: typeof effect_Schema0.String;
-  size: typeof effect_Schema0.Number;
-  contentType: effect_Schema0.optionalWith<typeof effect_Schema0.String, {
-    exact: true;
-  }>;
-}>, convex_values0.VObject<{
-  sha256: string;
-  size: number;
-  contentType?: string;
-}, {
-  sha256: convex_values0.VString<string, "required">;
-  size: convex_values0.VFloat64<number, "required">;
-  contentType: convex_values0.VString<string | undefined, "optional">;
-}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>>;
-declare const extendWithSystemTables: <Tables_ extends AnyWithProps$1>(tables: TablesRecord<Tables_>) => ExtendWithSystemTables<Tables_>;
-type ExtendWithSystemTables<Tables_ extends AnyWithProps$1> = TablesRecord<Tables_ | SystemTables>;
-type IncludeSystemTables<Tables_ extends AnyWithProps$1> = Tables_ | SystemTables extends infer T ? T extends AnyWithProps$1 ? T : never : never;
+declare const make: <const TablesRecord extends Record<string, AnyWithProps$1>>(tables: TablesRecord) => DatabaseSchema<TablesRecord[keyof TablesRecord]>;
 //#endregion
-export { Any, AnyWithProps, ConvexDatabaseSchemaFromTables, DatabaseSchema, DatabaseSchema_d_exports, ExtendWithSystemTables, IncludeSystemTables, TableNames, TableWithName, Tables, TypeId, extendWithSystemTables, isDatabaseSchema, make, systemSchema };
+export { Any, AnyWithProps, DatabaseSchema, DatabaseSchema_d_exports, TableNames, TableWithName, Tables, TypeId, isDatabaseSchema, make };
 //# sourceMappingURL=DatabaseSchema.d.ts.map

package/dist/DatabaseSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DatabaseSchema.d.ts","names":[],"sources":["../src/DatabaseSchema.ts"],"mappings":";;;;;;;;;cAQa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,UAEX,GAAA;EAAA,UACL,MAAA,GAAS,MAAA;AAAA;AAAA,cAGR,gBAAA,GAAoB,CAAA,cAAa,CAAA,IAAK,GAAA;;;;UAMlC,cAAA,iBAA+B,cAAA;EAAA,UACpC,MAAA,GAAS,MAAA;EAAA,SACV,MAAA,EAAQ,YAAA,CAAmB,OAAA;EAAA,SAC3B,sBAAA,EAAwB,gBAAA,CAC/B,8BAAA,CAA+B,OAAA;;;;EAOjC,QAAA,kBAA0B,cAAA,EACxB,KAAA,EAAO,QAAA,GACN,cAAA,CAAe,OAAA,GAAU,QAAA;AAAA;AAAA,UAGb,YAAA;EAAA,UACL,MAAA,GAAS,MAAA;EAAA,SACV,MAAA,EAAQ,MAAA,SAAe,cAAA;EAAA,SACvB,sBAAA,EAAwB,gBAAA,CAAiB,aAAA;EAClD,QAAA,kBAA0B,cAAA,EAAoB,KAAA,EAAO,QAAA,GAAW,YAAA;AAAA;AAAA,KAGtD,MAAA,yBAA+B,YAAA,IACzC,eAAA,SAAwB,cAAA,kBAAgC,OAAA;AAAA,KAE9C,UAAA,yBAAmC,YAAA,IAAgB,IAAA,CAC7D,MAAA,CAAO,eAAA;AAAA,KAIG,aAAA,yBACc,YAAA,oBACN,UAAA,CAAW,eAAA,KAC3B,OAAA,CAAQ,MAAA,CAAO,eAAA;EAAA,SAA6B,IAAA,EAAM,SAAA;AAAA;;AA5CtD;;cAqFa,IAAA,QAAW,cAAA;AAAA,KAMZ,8BAAA,iBAA+C,cAAA,IACzD,MAAA,iBACgB,IAAA,CAAW,OAAA,aAAoB,QAAA,CAC3C,OAAA,EACA,SAAA;AAAA,cAMO,YAAA,EAAY,cAAA,CAAA,KAAA,wCAAA,MAAA;eAEM,cAAA,CAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAFN,cAAA,CAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAA,cAAA,CAAA,MAAA;;;;;;;;;;;;;;cAIZ,sBAAA,mBAA0C,cAAA,EACrD,MAAA,EAAQ,YAAA,CAAmB,OAAA,MAC1B,sBAAA,CAAuB,OAAA;AAAA,KAMd,sBAAA,iBAAuC,cAAA,IACjD,YAAA,CAAmB,OAAA,GAAU,YAAA;AAAA,KAEnB,mBAAA,iBAAoC,cAAA,IAC5C,OAAA,GACA,YAAA,mBACA,CAAA,SAAU,cAAA,GACR,CAAA"}
+{"version":3,"file":"DatabaseSchema.d.ts","names":[],"sources":["../src/DatabaseSchema.ts"],"mappings":";;;;;;cAGa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,UAEX,GAAA;EAAA,UACL,MAAA,GAAS,MAAA;AAAA;AAAA,cAGR,gBAAA,GAAoB,CAAA,cAAa,CAAA,IAAK,GAAA;;;;;;;;UAUlC,cAAA,iBAA+B,cAAA;EAAA,UACpC,MAAA,GAAS,MAAA;EAAA,SACV,MAAA,2BACgB,IAAA,CAAW,OAAA,IAAW,QAAA,CAC3C,OAAA,EACA,SAAA;AAAA;AAAA,UAKW,YAAA;EAAA,UACL,MAAA,GAAS,MAAA;EAAA,SACV,MAAA,EAAQ,MAAA,SAAe,cAAA;AAAA;AAAA,KAGtB,MAAA,yBAA+B,YAAA,IACzC,eAAA,SAAwB,cAAA,kBAAgC,OAAA;AAAA,KAE9C,UAAA,yBAAmC,YAAA,IAAgB,IAAA,CAC7D,MAAA,CAAO,eAAA;AAAA,KAIG,aAAA,yBACc,YAAA,oBACN,UAAA,CAAW,eAAA,KAC3B,OAAA,CAAQ,MAAA,CAAO,eAAA;EAAA,SAA6B,SAAA,EAAW,SAAA;AAAA;;AApC3D;;;;;;;;;AAUA;;;;;;cA4Ca,IAAA,8BACgB,MAAA,SAAe,cAAA,GAE1C,MAAA,EAAQ,YAAA,KACP,cAAA,CAAe,YAAA,OAAmB,YAAA"}

package/dist/DatabaseSchema.js

@@ -1,45 +1,35 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { scheduledFunctionsTable, storageTable, systemTables } from "./Table.js";
-import { Array, Predicate, Record, pipe } from "effect";
-import { defineSchema } from "convex/server";
+import { Predicate } from "effect";
 
 //#region src/DatabaseSchema.ts
 var DatabaseSchema_exports = /* @__PURE__ */ __exportAll({
 	TypeId: () => TypeId,
-	extendWithSystemTables: () => extendWithSystemTables,
 	isDatabaseSchema: () => isDatabaseSchema,
-	make: () => make,
-	systemSchema: () => systemSchema
+	make: () => make
 });
 const TypeId = "@confect/server/DatabaseSchema";
 const isDatabaseSchema = (u) => Predicate.hasProperty(u, TypeId);
-const Proto = {
-	[TypeId]: TypeId,
-	addTable(table) {
-		const newTablesArray = [...Object.values(this.tables), table];
-		return makeProto({
-			tables: Record.set(this.tables, table.name, table),
-			convexSchemaDefinition: pipe(newTablesArray, Array.map(({ name, tableDefinition }) => [name, tableDefinition]), Record.fromEntries, defineSchema)
-		});
-	}
-};
-const makeProto = ({ tables, convexSchemaDefinition }) => Object.assign(Object.create(Proto), {
-	tables,
-	convexSchemaDefinition
-});
 /**
-* 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.
 */
-const make = () => makeProto({
-	tables: Record.empty(),
-	convexSchemaDefinition: defineSchema({})
-});
-const systemSchema = make().addTable(scheduledFunctionsTable).addTable(storageTable);
-const extendWithSystemTables = (tables) => ({
-	...tables,
-	...systemTables
+const make = (tables) => ({
+	[TypeId]: TypeId,
+	tables
 });
 
 //#endregion
-export { DatabaseSchema_exports, TypeId, extendWithSystemTables, isDatabaseSchema, make, systemSchema };
+export { DatabaseSchema_exports, TypeId, isDatabaseSchema, make };
 //# sourceMappingURL=DatabaseSchema.js.map

package/dist/DatabaseSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"DatabaseSchema.js","names":["defineConvexSchema","Table.scheduledFunctionsTable","Table.storageTable","Table.systemTables"],"sources":["../src/DatabaseSchema.ts"],"sourcesContent":["import type { Expand, GenericSchema } from \"convex/server\";\nimport {\n  defineSchema as defineConvexSchema,\n  type SchemaDefinition,\n} from \"convex/server\";\nimport { Array, pipe, Predicate, Record } from \"effect\";\nimport * as Table from \"./Table\";\n\nexport const TypeId = \"@confect/server/DatabaseSchema\";\nexport type TypeId = typeof TypeId;\n\nexport interface Any {\n  readonly [TypeId]: TypeId;\n}\n\nexport const isDatabaseSchema = (u: unknown): u is Any =>\n  Predicate.hasProperty(u, TypeId);\n\n/**\n * A schema definition tracks the schema and its Convex schema definition.\n */\nexport interface DatabaseSchema<Tables_ extends Table.AnyWithProps = never> {\n  readonly [TypeId]: TypeId;\n  readonly tables: Table.TablesRecord<Tables_>;\n  readonly convexSchemaDefinition: SchemaDefinition<\n    ConvexDatabaseSchemaFromTables<Tables_>,\n    true\n  >;\n\n  /**\n   * Add a table definition to the schema.\n   */\n  addTable<TableDef extends Table.AnyWithProps>(\n    table: TableDef,\n  ): DatabaseSchema<Tables_ | TableDef>;\n}\n\nexport interface AnyWithProps {\n  readonly [TypeId]: TypeId;\n  readonly tables: Record<string, Table.AnyWithProps>;\n  readonly convexSchemaDefinition: SchemaDefinition<GenericSchema, true>;\n  addTable<TableDef extends Table.AnyWithProps>(table: TableDef): AnyWithProps;\n}\n\nexport type Tables<DatabaseSchema_ extends AnyWithProps> =\n  DatabaseSchema_ extends DatabaseSchema<infer Tables_> ? Tables_ : never;\n\nexport type TableNames<DatabaseSchema_ extends AnyWithProps> = Table.Name<\n  Tables<DatabaseSchema_>\n> &\n  string;\n\nexport type TableWithName<\n  DatabaseSchema_ extends AnyWithProps,\n  TableName extends TableNames<DatabaseSchema_>,\n> = Extract<Tables<DatabaseSchema_>, { readonly name: TableName }>;\n\nconst Proto = {\n  [TypeId]: TypeId,\n\n  addTable<TableDef extends Table.AnyWithProps>(\n    this: DatabaseSchema<Table.AnyWithProps>,\n    table: TableDef,\n  ) {\n    const tablesArray = Object.values(this.tables) as Table.AnyWithProps[];\n    const newTablesArray = [...tablesArray, table];\n\n    return makeProto({\n      tables: Record.set(this.tables, table.name, table),\n      convexSchemaDefinition: pipe(\n        newTablesArray,\n        Array.map(\n          ({ name, tableDefinition }) => [name, tableDefinition] as const,\n        ),\n        Record.fromEntries,\n        defineConvexSchema,\n      ),\n    });\n  },\n};\n\nconst makeProto = <Tables_ extends Table.AnyWithProps>({\n  tables,\n  convexSchemaDefinition,\n}: {\n  tables: Record.ReadonlyRecord<string, Tables_>;\n  convexSchemaDefinition: SchemaDefinition<GenericSchema, true>;\n}): DatabaseSchema<Tables_> =>\n  Object.assign(Object.create(Proto), {\n    tables,\n    convexSchemaDefinition,\n  });\n\n/**\n * Create an empty schema definition. Add tables incrementally via `addTable`.\n */\nexport const make = (): DatabaseSchema<never> =>\n  makeProto({\n    tables: Record.empty(),\n    convexSchemaDefinition: defineConvexSchema({}),\n  });\n\nexport type ConvexDatabaseSchemaFromTables<Tables_ extends Table.AnyWithProps> =\n  Expand<{\n    [TableName in Table.Name<Tables_> & string]: Table.WithName<\n      Tables_,\n      TableName\n    >[\"tableDefinition\"];\n  }>;\n\n// System tables\n\nexport const systemSchema = make()\n  .addTable(Table.scheduledFunctionsTable)\n  .addTable(Table.storageTable);\n\nexport const extendWithSystemTables = <Tables_ extends Table.AnyWithProps>(\n  tables: Table.TablesRecord<Tables_>,\n): ExtendWithSystemTables<Tables_> =>\n  ({\n    ...tables,\n    ...Table.systemTables,\n  }) as ExtendWithSystemTables<Tables_>;\n\nexport type ExtendWithSystemTables<Tables_ extends Table.AnyWithProps> =\n  Table.TablesRecord<Tables_ | Table.SystemTables>;\n\nexport type IncludeSystemTables<Tables_ extends Table.AnyWithProps> =\n  | Tables_\n  | Table.SystemTables extends infer T\n  ? T extends Table.AnyWithProps\n    ? T\n    : never\n  : never;\n"],"mappings":";;;;;;;;;;;;;AAQA,MAAa,SAAS;AAOtB,MAAa,oBAAoB,MAC/B,UAAU,YAAY,GAAG,OAAO;AAyClC,MAAM,QAAQ;EACX,SAAS;CAEV,SAEE,OACA;EAEA,MAAM,iBAAiB,CAAC,GADJ,OAAO,OAAO,KAAK,OAAO,EACN,MAAM;AAE9C,SAAO,UAAU;GACf,QAAQ,OAAO,IAAI,KAAK,QAAQ,MAAM,MAAM,MAAM;GAClD,wBAAwB,KACtB,gBACA,MAAM,KACH,EAAE,MAAM,sBAAsB,CAAC,MAAM,gBAAgB,CACvD,EACD,OAAO,aACPA,aACD;GACF,CAAC;;CAEL;AAED,MAAM,aAAiD,EACrD,QACA,6BAKA,OAAO,OAAO,OAAO,OAAO,MAAM,EAAE;CAClC;CACA;CACD,CAAC;;;;AAKJ,MAAa,aACX,UAAU;CACR,QAAQ,OAAO,OAAO;CACtB,wBAAwBA,aAAmB,EAAE,CAAC;CAC/C,CAAC;AAYJ,MAAa,eAAe,MAAM,CAC/B,SAASC,wBAA8B,CACvC,SAASC,aAAmB;AAE/B,MAAa,0BACX,YAEC;CACC,GAAG;CACH,GAAGC;CACJ"}
+{"version":3,"file":"DatabaseSchema.js","names":[],"sources":["../src/DatabaseSchema.ts"],"sourcesContent":["import { Predicate } from \"effect\";\nimport type * as Table from \"./Table\";\n\nexport const TypeId = \"@confect/server/DatabaseSchema\";\nexport type TypeId = typeof TypeId;\n\nexport interface Any {\n  readonly [TypeId]: TypeId;\n}\n\nexport const isDatabaseSchema = (u: unknown): u is Any =>\n  Predicate.hasProperty(u, TypeId);\n\n/**\n * A schema definition holding a record of bound `Table`s keyed by table\n * name. Codegen emits a single static `DatabaseSchema.make({ ... })` call;\n * laziness now lives entirely on each `Table` (its `Fields`, `Doc`, and\n * `tableDefinition` are lazy memoised getters), so this layer is a plain\n * record indirection with no module-loading or async machinery.\n */\nexport interface DatabaseSchema<Tables_ extends Table.AnyWithProps = never> {\n  readonly [TypeId]: TypeId;\n  readonly tables: {\n    readonly [TableName in Table.Name<Tables_>]: Table.WithName<\n      Tables_,\n      TableName\n    >;\n  };\n}\n\nexport interface AnyWithProps {\n  readonly [TypeId]: TypeId;\n  readonly tables: Record<string, Table.AnyWithProps>;\n}\n\nexport type Tables<DatabaseSchema_ extends AnyWithProps> =\n  DatabaseSchema_ extends DatabaseSchema<infer Tables_> ? Tables_ : never;\n\nexport type TableNames<DatabaseSchema_ extends AnyWithProps> = Table.Name<\n  Tables<DatabaseSchema_>\n> &\n  string;\n\nexport type TableWithName<\n  DatabaseSchema_ extends AnyWithProps,\n  TableName extends TableNames<DatabaseSchema_>,\n> = Extract<Tables<DatabaseSchema_>, { readonly tableName: TableName }>;\n\n/**\n * Construct a `DatabaseSchema` from a record of bound `Table`s. The empty\n * case is `DatabaseSchema.make({})`. The `Tables_` union is inferred from\n * the value record's values, so codegen-emitted calls of the form\n * `DatabaseSchema.make({ notes, tags, users })` do not need an explicit\n * type argument.\n *\n * Invariant: each record **key must equal its value's `tableName`**. The\n * record is stored verbatim and later read by key (`databaseSchema.tables[\n * tableName]` in `DatabaseReader`/`DatabaseWriter`), so a key that diverges\n * from the bound table's name would make those lookups silently miss. The\n * type signature does not enforce this — codegen upholds it by deriving both\n * the key and the table name from the same filename (and the shorthand\n * `{ notes, tags, users }` form it emits makes them identical by\n * construction). Hand-written calls must preserve it.\n */\nexport const make = <\n  const TablesRecord extends Record<string, Table.AnyWithProps>,\n>(\n  tables: TablesRecord,\n): DatabaseSchema<TablesRecord[keyof TablesRecord]> => ({\n  [TypeId]: TypeId,\n  tables: tables as unknown as DatabaseSchema<\n    TablesRecord[keyof TablesRecord]\n  >[\"tables\"],\n});\n"],"mappings":";;;;;;;;;AAGA,MAAa,SAAS;AAOtB,MAAa,oBAAoB,MAC/B,UAAU,YAAY,GAAG,OAAO;;;;;;;;;;;;;;;;;AAqDlC,MAAa,QAGX,YACsD;EACrD,SAAS;CACF;CAGT"}

package/dist/DatabaseWriter.d.ts

@@ -13,7 +13,7 @@ declare namespace DatabaseWriter_d_exports {
 declare const make: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseWriter: GenericDatabaseWriter<ToConvex<FromSchema<DatabaseSchema_>>>) => {
   table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
     insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
-    patch: (id: GenericId<TableName>, patchedValues: Partial<WithoutSystemFields<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>>) => Effect.Effect<void, DocumentEncodeError | GetByIdFailure | DocumentDecodeError, never>;
+    patch: (id: GenericId<TableName>, patchedValues: Partial<WithoutSystemFields<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>>) => Effect.Effect<void, DocumentDecodeError | DocumentEncodeError | GetByIdFailure, never>;
     replace: (id: GenericId<TableName>, value: WithoutSystemFields<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<void, DocumentEncodeError, never>;
     delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
   };
@@ -21,14 +21,14 @@ declare const make: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: Datab
 declare const DatabaseWriter: <DatabaseSchema_ extends AnyWithProps>() => Context.Tag<{
   table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
     insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
-    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentEncodeError | GetByIdFailure | DocumentDecodeError, never>;
+    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentDecodeError | DocumentEncodeError | GetByIdFailure, never>;
     replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
     delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
   };
 }, {
   table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
     insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
-    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentEncodeError | GetByIdFailure | DocumentDecodeError, never>;
+    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentDecodeError | DocumentEncodeError | GetByIdFailure, never>;
     replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
     delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
   };
@@ -37,7 +37,7 @@ type DatabaseWriter<DatabaseSchema_ extends AnyWithProps> = ReturnType<typeof Da
 declare const layer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseWriter: GenericDatabaseWriter<ToConvex<FromSchema<DatabaseSchema_>>>) => Layer.Layer<{
   table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
     insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
-    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentEncodeError | GetByIdFailure | DocumentDecodeError, never>;
+    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentDecodeError | DocumentEncodeError | GetByIdFailure, never>;
     replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
     delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
   };

package/dist/DatabaseWriter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DatabaseWriter.d.ts","names":[],"sources":["../src/DatabaseWriter.ts"],"mappings":";;;;;;;;;;;;cAiBa,IAAA,2BAAgC,YAAA,EAC3C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA;kCAMH,UAAA,CAAoB,UAAA,CAAA,eAAA,IAAY,SAAA,EAC1D,SAAA;uBAQC,qBAAA,CACR,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,OAC7B,MAAA,CAAA,MAAA,CAAA,SAAA,CAAA,SAAA,GAAA,mBAAA;gBAsBG,SAAA,CAAU,SAAA,GAAU,aAAA,EACT,OAAA,CACb,mBAAA,CAAoB,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,QACjD,MAAA,CAAA,MAAA,OAAA,mBAAA,GAAA,cAAA,GAAA,mBAAA;kBAiCG,SAAA,CAAU,SAAA,GAAU,KAAA,EACjB,mBAAA,CAAoB,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,OAAW,MAAA,CAAA,MAAA,OAAA,mBAAA;iBAsB/C,SAAA,CAAU,SAAA,MAAU,MAAA,CAAA,MAAA;EAAA;AAAA;AAAA,cAgBhC,cAAA,2BACa,YAAA,OAA2B,OAAA,CAAA,GAAA;kCA7GrB,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA;;;;;;;kCAAA,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA;;;;;;;KAmHpB,cAAA,yBACc,YAAA,IACtB,UAAA,QAAkB,cAAA,CAAe,eAAA;AAAA,cAExB,KAAA,2BAAiC,YAAA,EAC5C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA,QACzC,KAAA,CAAA,KAAA;kCA3H6B,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA"}
+{"version":3,"file":"DatabaseWriter.d.ts","names":[],"sources":["../src/DatabaseWriter.ts"],"mappings":";;;;;;;;;;;;cAiBa,IAAA,2BAAgC,YAAA,EAC3C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA;kCAKH,UAAA,CAAoB,UAAA,CAAA,eAAA,IAAY,SAAA,EAC1D,SAAA;uBAQC,qBAAA,CACR,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,OAC7B,MAAA,CAAA,MAAA,CAAA,SAAA,CAAA,SAAA,GAAA,mBAAA;gBAsBG,SAAA,CAAU,SAAA,GAAU,aAAA,EACT,OAAA,CACb,mBAAA,CAAoB,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,QACjD,MAAA,CAAA,MAAA,OAAA,mBAAA,GAAA,mBAAA,GAAA,cAAA;kBAqCG,SAAA,CAAU,SAAA,GAAU,KAAA,EACjB,mBAAA,CAAoB,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,OAAW,MAAA,CAAA,MAAA,OAAA,mBAAA;iBAsB/C,SAAA,CAAU,SAAA,MAAU,MAAA,CAAA,MAAA;EAAA;AAAA;AAAA,cAgBhC,cAAA,2BACa,YAAA,OAA2B,OAAA,CAAA,GAAA;kCAjHrB,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA;;;;;;;kCAAA,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA;;;;;;;KAuHpB,cAAA,yBACc,YAAA,IACtB,UAAA,QAAkB,cAAA,CAAe,eAAA;AAAA,cAExB,KAAA,2BAAiC,YAAA,EAC5C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA,QACzC,KAAA,CAAA,KAAA;kCA/H6B,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA"}

package/dist/DatabaseWriter.js

@@ -10,21 +10,20 @@ var DatabaseWriter_exports = /* @__PURE__ */ __exportAll({
 	make: () => make
 });
 const make = (databaseSchema, convexDatabaseWriter) => {
-	const tables = databaseSchema.tables;
 	const table = (tableName) => {
-		const tableDef = tables[tableName];
-		const tableSchema = tableDef.Fields;
+		const tableDef = databaseSchema.tables[tableName];
 		const insert = (document) => Effect.gen(function* () {
 			const encodedDocument = yield* encode(document, tableName, tableDef.Fields);
 			return yield* Effect.promise(() => convexDatabaseWriter.insert(tableName, encodedDocument));
 		});
 		const patch = (id, patchedValues) => Effect.gen(function* () {
+			const tableSchema = tableDef.Fields;
 			const originalDecodedDoc = yield* getById(tableName, convexDatabaseWriter, tableDef)(id);
 			const updatedEncodedDoc = yield* pipe(patchedValues, Record.reduce(originalDecodedDoc, (acc, value, key) => value === void 0 ? Record.remove(acc, key) : Record.set(acc, key, value)), encode(tableName, tableSchema));
 			yield* Effect.promise(() => convexDatabaseWriter.replace(id, updatedEncodedDoc));
 		});
 		const replace = (id, value) => Effect.gen(function* () {
-			const updatedEncodedDoc = yield* encode(value, tableName, tableSchema);
+			const updatedEncodedDoc = yield* encode(value, tableName, tableDef.Fields);
 			yield* Effect.promise(() => convexDatabaseWriter.replace(id, updatedEncodedDoc));
 		});
 		const delete_ = (id) => Effect.promise(() => convexDatabaseWriter.delete(id));

package/dist/DatabaseWriter.js.map

@@ -1 +1 @@
-{"version":3,"file":"DatabaseWriter.js","names":["Document.encode","QueryInitializer.getById"],"sources":["../src/DatabaseWriter.ts"],"sourcesContent":["import type {\n  BetterOmit,\n  DocumentByName,\n  Expand,\n  GenericDatabaseWriter,\n  WithoutSystemFields,\n} from \"convex/server\";\nimport type { GenericId } from \"convex/values\";\nimport { Context, Effect, Layer, pipe, Record } from \"effect\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as DataModel from \"./DataModel\";\nimport type { DocumentByName as DocumentByName_ } from \"./DataModel\";\nimport * as Document from \"./Document\";\nimport * as QueryInitializer from \"./QueryInitializer\";\nimport type * as Table from \"./Table\";\nimport type * as TableInfo from \"./TableInfo\";\n\nexport const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(\n  databaseSchema: DatabaseSchema_,\n  convexDatabaseWriter: GenericDatabaseWriter<\n    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n  >,\n) => {\n  type DataModel_ = DataModel.FromSchema<DatabaseSchema_>;\n  const tables = databaseSchema.tables as Record<string, Table.AnyWithProps>;\n\n  const table = <const TableName extends DataModel.TableNames<DataModel_>>(\n    tableName: TableName,\n  ) => {\n    const tableDef = tables[tableName]!;\n    const tableSchema = tableDef.Fields as TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >;\n\n    const insert = (\n      document: Document.WithoutSystemFields<\n        DocumentByName_<DataModel_, TableName>\n      >,\n    ) =>\n      Effect.gen(function* () {\n        const encodedDocument = yield* Document.encode(\n          document,\n          tableName,\n          tableDef.Fields,\n        );\n\n        const id = yield* Effect.promise(() =>\n          convexDatabaseWriter.insert(\n            tableName,\n            encodedDocument as WithoutSystemFields<\n              DocumentByName<DataModel.ToConvex<DataModel_>, TableName>\n            >,\n          ),\n        );\n\n        return id;\n      });\n\n    const patch = (\n      id: GenericId<TableName>,\n      patchedValues: Partial<\n        WithoutSystemFields<DocumentByName_<DataModel_, TableName>>\n      >,\n    ) =>\n      Effect.gen(function* () {\n        const originalDecodedDoc = yield* QueryInitializer.getById(\n          tableName,\n          convexDatabaseWriter as any,\n          tableDef,\n        )(id);\n\n        const updatedEncodedDoc = yield* pipe(\n          patchedValues,\n          Record.reduce(originalDecodedDoc, (acc, value, key) =>\n            value === undefined\n              ? Record.remove(acc, key)\n              : Record.set(acc, key, value),\n          ),\n          Document.encode(tableName, tableSchema),\n        );\n\n        yield* Effect.promise(() =>\n          convexDatabaseWriter.replace(\n            id,\n            updatedEncodedDoc as Expand<\n              BetterOmit<\n                DocumentByName<DataModel.ToConvex<DataModel_>, TableName>,\n                \"_creationTime\" | \"_id\"\n              >\n            >,\n          ),\n        );\n      });\n\n    const replace = (\n      id: GenericId<TableName>,\n      value: WithoutSystemFields<DocumentByName_<DataModel_, TableName>>,\n    ) =>\n      Effect.gen(function* () {\n        const updatedEncodedDoc = yield* Document.encode(\n          value,\n          tableName,\n          tableSchema,\n        );\n\n        yield* Effect.promise(() =>\n          convexDatabaseWriter.replace(\n            id,\n            updatedEncodedDoc as Expand<\n              BetterOmit<\n                DocumentByName<DataModel.ToConvex<DataModel_>, TableName>,\n                \"_creationTime\" | \"_id\"\n              >\n            >,\n          ),\n        );\n      });\n\n    const delete_ = (id: GenericId<TableName>) =>\n      Effect.promise(() => convexDatabaseWriter.delete(id));\n\n    return {\n      insert,\n      patch,\n      replace,\n      delete: delete_,\n    };\n  };\n\n  return {\n    table,\n  };\n};\n\nexport const DatabaseWriter = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n>() =>\n  Context.GenericTag<ReturnType<typeof make<DatabaseSchema_>>>(\n    \"@confect/server/DatabaseWriter\",\n  );\n\nexport type DatabaseWriter<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n> = ReturnType<typeof DatabaseWriter<DatabaseSchema_>>[\"Identifier\"];\n\nexport const layer = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(\n  databaseSchema: DatabaseSchema_,\n  convexDatabaseWriter: GenericDatabaseWriter<\n    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n  >,\n) =>\n  Layer.succeed(\n    DatabaseWriter<DatabaseSchema_>(),\n    make(databaseSchema, convexDatabaseWriter),\n  );\n"],"mappings":";;;;;;;;;;;AAiBA,MAAa,QACX,gBACA,yBAGG;CAEH,MAAM,SAAS,eAAe;CAE9B,MAAM,SACJ,cACG;EACH,MAAM,WAAW,OAAO;EACxB,MAAM,cAAc,SAAS;EAI7B,MAAM,UACJ,aAIA,OAAO,IAAI,aAAa;GACtB,MAAM,kBAAkB,OAAOA,OAC7B,UACA,WACA,SAAS,OACV;AAWD,UATW,OAAO,OAAO,cACvB,qBAAqB,OACnB,WACA,gBAGD,CACF;IAGD;EAEJ,MAAM,SACJ,IACA,kBAIA,OAAO,IAAI,aAAa;GACtB,MAAM,qBAAqB,OAAOC,QAChC,WACA,sBACA,SACD,CAAC,GAAG;GAEL,MAAM,oBAAoB,OAAO,KAC/B,eACA,OAAO,OAAO,qBAAqB,KAAK,OAAO,QAC7C,UAAU,SACN,OAAO,OAAO,KAAK,IAAI,GACvB,OAAO,IAAI,KAAK,KAAK,MAAM,CAChC,EACDD,OAAgB,WAAW,YAAY,CACxC;AAED,UAAO,OAAO,cACZ,qBAAqB,QACnB,IACA,kBAMD,CACF;IACD;EAEJ,MAAM,WACJ,IACA,UAEA,OAAO,IAAI,aAAa;GACtB,MAAM,oBAAoB,OAAOA,OAC/B,OACA,WACA,YACD;AAED,UAAO,OAAO,cACZ,qBAAqB,QACnB,IACA,kBAMD,CACF;IACD;EAEJ,MAAM,WAAW,OACf,OAAO,cAAc,qBAAqB,OAAO,GAAG,CAAC;AAEvD,SAAO;GACL;GACA;GACA;GACA,QAAQ;GACT;;AAGH,QAAO,EACL,OACD;;AAGH,MAAa,uBAGX,QAAQ,WACN,iCACD;AAMH,MAAa,SACX,gBACA,yBAIA,MAAM,QACJ,gBAAiC,EACjC,KAAK,gBAAgB,qBAAqB,CAC3C"}
+{"version":3,"file":"DatabaseWriter.js","names":["Document.encode","QueryInitializer.getById"],"sources":["../src/DatabaseWriter.ts"],"sourcesContent":["import type {\n  BetterOmit,\n  DocumentByName,\n  Expand,\n  GenericDatabaseWriter,\n  WithoutSystemFields,\n} from \"convex/server\";\nimport type { GenericId } from \"convex/values\";\nimport { Context, Effect, Layer, pipe, Record } from \"effect\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as DataModel from \"./DataModel\";\nimport type { DocumentByName as DocumentByName_ } from \"./DataModel\";\nimport * as Document from \"./Document\";\nimport * as QueryInitializer from \"./QueryInitializer\";\nimport type * as Table from \"./Table\";\nimport type * as TableInfo from \"./TableInfo\";\n\nexport const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(\n  databaseSchema: DatabaseSchema_,\n  convexDatabaseWriter: GenericDatabaseWriter<\n    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n  >,\n) => {\n  type DataModel_ = DataModel.FromSchema<DatabaseSchema_>;\n\n  const table = <const TableName extends DataModel.TableNames<DataModel_>>(\n    tableName: TableName,\n  ) => {\n    const tableDef = databaseSchema.tables[tableName] as Table.WithName<\n      DatabaseSchema.Tables<DatabaseSchema_>,\n      TableName\n    >;\n\n    const insert = (\n      document: Document.WithoutSystemFields<\n        DocumentByName_<DataModel_, TableName>\n      >,\n    ) =>\n      Effect.gen(function* () {\n        const encodedDocument = yield* Document.encode(\n          document,\n          tableName,\n          tableDef.Fields,\n        );\n\n        const id = yield* Effect.promise(() =>\n          convexDatabaseWriter.insert(\n            tableName,\n            encodedDocument as WithoutSystemFields<\n              DocumentByName<DataModel.ToConvex<DataModel_>, TableName>\n            >,\n          ),\n        );\n\n        return id;\n      });\n\n    const patch = (\n      id: GenericId<TableName>,\n      patchedValues: Partial<\n        WithoutSystemFields<DocumentByName_<DataModel_, TableName>>\n      >,\n    ) =>\n      Effect.gen(function* () {\n        const tableSchema = tableDef.Fields as TableInfo.TableSchema<\n          DataModel.TableInfoWithName_<DataModel_, TableName>\n        >;\n\n        const originalDecodedDoc = yield* QueryInitializer.getById(\n          tableName,\n          convexDatabaseWriter as any,\n          tableDef,\n        )(id);\n\n        const updatedEncodedDoc = yield* pipe(\n          patchedValues,\n          Record.reduce(originalDecodedDoc, (acc, value, key) =>\n            value === undefined\n              ? Record.remove(acc, key)\n              : Record.set(acc, key, value),\n          ),\n          Document.encode(tableName, tableSchema),\n        );\n\n        yield* Effect.promise(() =>\n          convexDatabaseWriter.replace(\n            id,\n            updatedEncodedDoc as Expand<\n              BetterOmit<\n                DocumentByName<DataModel.ToConvex<DataModel_>, TableName>,\n                \"_creationTime\" | \"_id\"\n              >\n            >,\n          ),\n        );\n      });\n\n    const replace = (\n      id: GenericId<TableName>,\n      value: WithoutSystemFields<DocumentByName_<DataModel_, TableName>>,\n    ) =>\n      Effect.gen(function* () {\n        const updatedEncodedDoc = yield* Document.encode(\n          value,\n          tableName,\n          tableDef.Fields,\n        );\n\n        yield* Effect.promise(() =>\n          convexDatabaseWriter.replace(\n            id,\n            updatedEncodedDoc as Expand<\n              BetterOmit<\n                DocumentByName<DataModel.ToConvex<DataModel_>, TableName>,\n                \"_creationTime\" | \"_id\"\n              >\n            >,\n          ),\n        );\n      });\n\n    const delete_ = (id: GenericId<TableName>) =>\n      Effect.promise(() => convexDatabaseWriter.delete(id));\n\n    return {\n      insert,\n      patch,\n      replace,\n      delete: delete_,\n    };\n  };\n\n  return {\n    table,\n  };\n};\n\nexport const DatabaseWriter = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n>() =>\n  Context.GenericTag<ReturnType<typeof make<DatabaseSchema_>>>(\n    \"@confect/server/DatabaseWriter\",\n  );\n\nexport type DatabaseWriter<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n> = ReturnType<typeof DatabaseWriter<DatabaseSchema_>>[\"Identifier\"];\n\nexport const layer = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(\n  databaseSchema: DatabaseSchema_,\n  convexDatabaseWriter: GenericDatabaseWriter<\n    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n  >,\n) =>\n  Layer.succeed(\n    DatabaseWriter<DatabaseSchema_>(),\n    make(databaseSchema, convexDatabaseWriter),\n  );\n"],"mappings":";;;;;;;;;;;AAiBA,MAAa,QACX,gBACA,yBAGG;CAGH,MAAM,SACJ,cACG;EACH,MAAM,WAAW,eAAe,OAAO;EAKvC,MAAM,UACJ,aAIA,OAAO,IAAI,aAAa;GACtB,MAAM,kBAAkB,OAAOA,OAC7B,UACA,WACA,SAAS,OACV;AAWD,UATW,OAAO,OAAO,cACvB,qBAAqB,OACnB,WACA,gBAGD,CACF;IAGD;EAEJ,MAAM,SACJ,IACA,kBAIA,OAAO,IAAI,aAAa;GACtB,MAAM,cAAc,SAAS;GAI7B,MAAM,qBAAqB,OAAOC,QAChC,WACA,sBACA,SACD,CAAC,GAAG;GAEL,MAAM,oBAAoB,OAAO,KAC/B,eACA,OAAO,OAAO,qBAAqB,KAAK,OAAO,QAC7C,UAAU,SACN,OAAO,OAAO,KAAK,IAAI,GACvB,OAAO,IAAI,KAAK,KAAK,MAAM,CAChC,EACDD,OAAgB,WAAW,YAAY,CACxC;AAED,UAAO,OAAO,cACZ,qBAAqB,QACnB,IACA,kBAMD,CACF;IACD;EAEJ,MAAM,WACJ,IACA,UAEA,OAAO,IAAI,aAAa;GACtB,MAAM,oBAAoB,OAAOA,OAC/B,OACA,WACA,SAAS,OACV;AAED,UAAO,OAAO,cACZ,qBAAqB,QACnB,IACA,kBAMD,CACF;IACD;EAEJ,MAAM,WAAW,OACf,OAAO,cAAc,qBAAqB,OAAO,GAAG,CAAC;AAEvD,SAAO;GACL;GACA;GACA;GACA,QAAQ;GACT;;AAGH,QAAO,EACL,OACD;;AAGH,MAAa,uBAGX,QAAQ,WACN,iCACD;AAMH,MAAa,SACX,gBACA,yBAIA,MAAM,QACJ,gBAAiC,EACjC,KAAK,gBAAgB,qBAAqB,CAC3C"}

package/dist/FunctionImpl.d.ts

@@ -1,37 +1,46 @@
-import { AnyWithProps, Schema as Schema$1 } from "./Api.js";
+import { AnyWithProps } from "./DatabaseSchema.js";
 import { WithName } from "./Handler.js";
 import { Context, Layer } from "effect";
-import * as GroupSpec from "@confect/core/GroupSpec";
 import * as FunctionSpec from "@confect/core/FunctionSpec";
+import * as GroupSpec from "@confect/core/GroupSpec";
 
 //#region src/FunctionImpl.d.ts
 declare namespace FunctionImpl_d_exports {
-  export { ForGroupPathAndFunction, FromGroupAtPath, FromGroupSpec, FunctionImpl, make };
+  export { ForFunction, FromGroupSpec, FunctionImpl, make };
 }
-interface FunctionImpl<GroupPath_ extends string, FunctionName extends string> {
-  readonly groupPath: GroupPath_;
+interface FunctionImpl<FunctionName extends string> {
   readonly functionName: FunctionName;
 }
-declare const FunctionImpl: <GroupPath_ extends string, FunctionName extends string>({
-  groupPath,
+declare const FunctionImpl: <FunctionName extends string>({
   functionName
 }: {
-  groupPath: GroupPath_;
   functionName: FunctionName;
-}) => Context.Tag<FunctionImpl<GroupPath_, FunctionName>, FunctionImpl<GroupPath_, FunctionName>>;
-declare const make: <Api_ extends AnyWithProps, Group extends GroupSpec.AnyWithProps, const FunctionName extends FunctionSpec.Name<GroupSpec.Functions<Group>>>(api: Api_, group: Group, functionName: FunctionName, handler: WithName<Schema$1<Api_>, GroupSpec.Functions<Group>, FunctionName>) => Layer.Layer<FunctionImpl<string, FunctionName>>;
+}) => Context.Tag<FunctionImpl<FunctionName>, FunctionImpl<FunctionName>>;
 /**
- * Get the function implementation service type for a specific group path and function name.
+ * 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).
  */
-type ForGroupPathAndFunction<GroupPath_ extends string, FunctionName extends string> = FunctionImpl<GroupPath_, FunctionName>;
+declare const make: <DatabaseSchema_ extends AnyWithProps, Group extends GroupSpec.AnyWithProps, const FunctionName extends FunctionSpec.Name<GroupSpec.Functions<Group>>>(_databaseSchema: DatabaseSchema_, group: Group, functionName: FunctionName, handler: WithName<DatabaseSchema_, GroupSpec.Functions<Group>, FunctionName>) => Layer.Layer<FunctionImpl<FunctionName>>;
 /**
- * Get all function implementation services required for a group spec.
+ * Get the function implementation service type for a specific function name.
  */
-type FromGroupSpec<Group extends GroupSpec.AnyWithProps> = FunctionSpec.Name<GroupSpec.Functions<Group>> extends infer FunctionNames extends string ? FunctionNames extends string ? FunctionImpl<string, FunctionNames> : never : never;
+type ForFunction<FunctionName extends string> = FunctionImpl<FunctionName>;
 /**
- * @deprecated Use {@link FromGroupSpec} instead.
+ * Get all function implementation services required for a group spec.
  */
-type FromGroupAtPath<_GroupPath extends string, Group extends GroupSpec.AnyWithProps> = FromGroupSpec<Group>;
+type FromGroupSpec<Group extends GroupSpec.AnyWithProps> = FunctionSpec.Name<GroupSpec.Functions<Group>> extends infer FunctionNames extends string ? FunctionNames extends string ? FunctionImpl<FunctionNames> : never : never;
 //#endregion
-export { ForGroupPathAndFunction, FromGroupAtPath, FromGroupSpec, FunctionImpl, FunctionImpl_d_exports, make };
+export { ForFunction, FromGroupSpec, FunctionImpl, FunctionImpl_d_exports, make };
 //# sourceMappingURL=FunctionImpl.d.ts.map

package/dist/FunctionImpl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FunctionImpl.d.ts","names":[],"sources":["../src/FunctionImpl.ts"],"mappings":";;;;;;;;;;UASiB,YAAA;EAAA,SAIN,SAAA,EAAW,UAAA;EAAA,SACX,YAAA,EAAc,YAAA;AAAA;AAAA,cAGZ,YAAA;EAGX,SAAA;EAAA;AAAA;EAIA,SAAA,EAAW,UAAA;EACX,YAAA,EAAc,YAAA;AAAA,MACf,OAAA,CAAA,GAAA,CAAA,YAAA,CAAA,UAAA,EAAA,YAAA,GAAA,YAAA,CAAA,UAAA,EAAA,YAAA;AAAA,cAKY,IAAA,gBACE,YAAA,gBACC,SAAA,CAAU,YAAA,6BACG,YAAA,CAAa,IAAA,CAAK,SAAA,CAAU,SAAA,CAAU,KAAA,IAEjE,GAAA,EAAK,IAAA,EACL,KAAA,EAAO,KAAA,EACP,YAAA,EAAc,YAAA,EACd,OAAA,EAAS,QAAA,CACP,QAAA,CAAW,IAAA,GACX,SAAA,CAAU,SAAA,CAAU,KAAA,GACpB,YAAA,MAED,KAAA,CAAM,KAAA,CAAM,YAAA,SAAqB,YAAA;;AAnCpC;;KAqEY,uBAAA,2DAGR,YAAA,CAAa,UAAA,EAAY,YAAA;;;;KAKjB,aAAA,eAA4B,SAAA,CAAU,YAAA,IAChD,YAAA,CAAa,IAAA,CACX,SAAA,CAAU,SAAA,CAAU,KAAA,gDAElB,aAAA,kBACE,YAAA,SAAqB,aAAA;;;;KAOjB,eAAA,0CAEI,SAAA,CAAU,YAAA,IACtB,aAAA,CAAc,KAAA"}
+{"version":3,"file":"FunctionImpl.d.ts","names":[],"sources":["../src/FunctionImpl.ts"],"mappings":";;;;;;;;;;UASiB,YAAA;EAAA,SACN,YAAA,EAAc,YAAA;AAAA;AAAA,cAGZ,YAAA;EAA6C;AAAA;EAGxD,YAAA,EAAc,YAAA;AAAA,MACf,OAAA,CAAA,GAAA,CAAA,YAAA,CAAA,YAAA,GAAA,YAAA,CAAA,YAAA;;;;AARD;;;;;;;;;AAIA;;;;cAyBa,IAAA,2BACa,YAAA,gBACV,SAAA,CAAU,YAAA,6BACG,YAAA,CAAa,IAAA,CAAK,SAAA,CAAU,SAAA,CAAU,KAAA,IAEjE,eAAA,EAAiB,eAAA,EACjB,KAAA,EAAO,KAAA,EACP,YAAA,EAAc,YAAA,EACd,OAAA,EAAS,QAAA,CACP,eAAA,EACA,SAAA,CAAU,SAAA,CAAU,KAAA,GACpB,YAAA,MAED,KAAA,CAAM,KAAA,CAAM,YAAA,CAAa,YAAA;;;;KA2BhB,WAAA,gCACV,YAAA,CAAa,YAAA;;;;KAKH,aAAA,eAA4B,SAAA,CAAU,YAAA,IAChD,YAAA,CAAa,IAAA,CACX,SAAA,CAAU,SAAA,CAAU,KAAA,gDAElB,aAAA,kBACE,YAAA,CAAa,aAAA"}

package/dist/FunctionImpl.js

@@ -1,8 +1,7 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { resolveGroupPathUnsafe } from "./Api.js";
 import { setNestedProperty } from "./internal/utils.js";
 import { make as make$1 } from "./RegistryItem.js";
-import { Context, Effect, Layer, Ref, String } from "effect";
+import { Context, Effect, Layer, Ref } from "effect";
 import * as Registry from "@confect/core/Registry";
 
 //#region src/FunctionImpl.ts
@@ -10,23 +9,32 @@ var FunctionImpl_exports = /* @__PURE__ */ __exportAll({
 	FunctionImpl: () => FunctionImpl,
 	make: () => make
 });
-const FunctionImpl = ({ groupPath, functionName }) => Context.GenericTag(`@confect/server/FunctionImpl/${groupPath}/${functionName}`);
-const make = (api, group, functionName, handler) => {
-	const groupPath = resolveGroupPathUnsafe(api, group);
+const FunctionImpl = ({ functionName }) => Context.GenericTag(`@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).
+*/
+const make = (_databaseSchema, group, functionName, handler) => {
 	const functionSpec = group.functions[functionName];
-	return Layer.effect(FunctionImpl({
-		groupPath,
-		functionName
-	}), Effect.gen(function* () {
+	return Layer.effect(FunctionImpl({ functionName }), Effect.gen(function* () {
 		const registry = yield* Registry.Registry;
-		yield* Ref.update(registry, (registryItems) => setNestedProperty(registryItems, [...String.split(groupPath, "."), functionName], make$1({
+		yield* Ref.update(registry, (registryItems) => setNestedProperty(registryItems, [functionName], make$1({
 			functionSpec,
 			handler
 		})));
-		return {
-			groupPath,
-			functionName
-		};
+		return { functionName };
 	}));
 };
 

package/dist/FunctionImpl.js.map

@@ -1 +1 @@
-{"version":3,"file":"FunctionImpl.js","names":["Api.resolveGroupPathUnsafe","RegistryItem.make"],"sources":["../src/FunctionImpl.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport * as Registry from \"@confect/core/Registry\";\nimport { Context, Effect, Layer, Ref, String } from \"effect\";\nimport * as Api from \"./Api\";\nimport type * as Handler from \"./Handler\";\nimport { setNestedProperty } from \"./internal/utils\";\nimport * as RegistryItem from \"./RegistryItem\";\n\nexport interface FunctionImpl<\n  GroupPath_ extends string,\n  FunctionName extends string,\n> {\n  readonly groupPath: GroupPath_;\n  readonly functionName: FunctionName;\n}\n\nexport const FunctionImpl = <\n  GroupPath_ extends string,\n  FunctionName extends string,\n>({\n  groupPath,\n  functionName,\n}: {\n  groupPath: GroupPath_;\n  functionName: FunctionName;\n}) =>\n  Context.GenericTag<FunctionImpl<GroupPath_, FunctionName>>(\n    `@confect/server/FunctionImpl/${groupPath}/${functionName}`,\n  );\n\nexport const make = <\n  Api_ extends Api.AnyWithProps,\n  Group extends GroupSpec.AnyWithProps,\n  const FunctionName extends FunctionSpec.Name<GroupSpec.Functions<Group>>,\n>(\n  api: Api_,\n  group: Group,\n  functionName: FunctionName,\n  handler: Handler.WithName<\n    Api.Schema<Api_>,\n    GroupSpec.Functions<Group>,\n    FunctionName\n  >,\n): Layer.Layer<FunctionImpl<string, FunctionName>> => {\n  const groupPath = Api.resolveGroupPathUnsafe(api, group);\n  const functionSpec = group.functions[functionName]!;\n\n  return Layer.effect(\n    FunctionImpl<string, FunctionName>({\n      groupPath,\n      functionName,\n    }),\n    Effect.gen(function* () {\n      const registry = yield* Registry.Registry;\n\n      yield* Ref.update(registry, (registryItems) =>\n        setNestedProperty(\n          registryItems,\n          [...String.split(groupPath, \".\"), functionName],\n          RegistryItem.make({\n            functionSpec,\n            handler,\n          }),\n        ),\n      );\n\n      return {\n        groupPath,\n        functionName,\n      };\n    }),\n  );\n};\n\n/**\n * Get the function implementation service type for a specific group path and function name.\n */\nexport type ForGroupPathAndFunction<\n  GroupPath_ extends string,\n  FunctionName extends string,\n> = FunctionImpl<GroupPath_, FunctionName>;\n\n/**\n * Get all function implementation services required for a group spec.\n */\nexport type FromGroupSpec<Group extends GroupSpec.AnyWithProps> =\n  FunctionSpec.Name<\n    GroupSpec.Functions<Group>\n  > extends infer FunctionNames extends string\n    ? FunctionNames extends string\n      ? FunctionImpl<string, FunctionNames>\n      : never\n    : never;\n\n/**\n * @deprecated Use {@link FromGroupSpec} instead.\n */\nexport type FromGroupAtPath<\n  _GroupPath extends string,\n  Group extends GroupSpec.AnyWithProps,\n> = FromGroupSpec<Group>;\n"],"mappings":";;;;;;;;;;;;AAiBA,MAAa,gBAGX,EACA,WACA,mBAKA,QAAQ,WACN,gCAAgC,UAAU,GAAG,eAC9C;AAEH,MAAa,QAKX,KACA,OACA,cACA,YAKoD;CACpD,MAAM,YAAYA,uBAA2B,KAAK,MAAM;CACxD,MAAM,eAAe,MAAM,UAAU;AAErC,QAAO,MAAM,OACX,aAAmC;EACjC;EACA;EACD,CAAC,EACF,OAAO,IAAI,aAAa;EACtB,MAAM,WAAW,OAAO,SAAS;AAEjC,SAAO,IAAI,OAAO,WAAW,kBAC3B,kBACE,eACA,CAAC,GAAG,OAAO,MAAM,WAAW,IAAI,EAAE,aAAa,EAC/CC,OAAkB;GAChB;GACA;GACD,CAAC,CACH,CACF;AAED,SAAO;GACL;GACA;GACD;GACD,CACH"}
+{"version":3,"file":"FunctionImpl.js","names":["RegistryItem.make"],"sources":["../src/FunctionImpl.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport * as Registry from \"@confect/core/Registry\";\nimport { Context, Effect, Layer, Ref } from \"effect\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as Handler from \"./Handler\";\nimport { setNestedProperty } from \"./internal/utils\";\nimport * as RegistryItem from \"./RegistryItem\";\n\nexport interface FunctionImpl<FunctionName extends string> {\n  readonly functionName: FunctionName;\n}\n\nexport const FunctionImpl = <FunctionName extends string>({\n  functionName,\n}: {\n  functionName: FunctionName;\n}) =>\n  Context.GenericTag<FunctionImpl<FunctionName>>(\n    `@confect/server/FunctionImpl/${functionName}`,\n  );\n\n/**\n * Register a single function's implementation into the group's `Registry`.\n *\n * The function is registered under a flat, single-segment key (its own\n * `functionName`), not a project-wide dot-path. Each group's impl layer is\n * built in isolation — `RegisteredFunctions.buildForGroup` (and the CLI's\n * `validateImpl`) provide a fresh `Registry` per group — so function names\n * only need to be unique within their own group.\n *\n * `databaseSchema` is retained purely as a type-level carrier: the handler's\n * ctx-service requirements (`DatabaseReader`, `QueryCtx<DataModel>`, …) are\n * derived from it via `Handler.WithName`. It is not read at runtime — the\n * generated per-group registry forwards the schema value to the function\n * builders — so impls depend on `_generated/schema` (table schemas) rather than\n * `_generated/api` (which transitively imports every function spec).\n */\nexport const make = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Group extends GroupSpec.AnyWithProps,\n  const FunctionName extends FunctionSpec.Name<GroupSpec.Functions<Group>>,\n>(\n  _databaseSchema: DatabaseSchema_,\n  group: Group,\n  functionName: FunctionName,\n  handler: Handler.WithName<\n    DatabaseSchema_,\n    GroupSpec.Functions<Group>,\n    FunctionName\n  >,\n): Layer.Layer<FunctionImpl<FunctionName>> => {\n  const functionSpec = group.functions[functionName]!;\n\n  return Layer.effect(\n    FunctionImpl<FunctionName>({ functionName }),\n    Effect.gen(function* () {\n      const registry = yield* Registry.Registry;\n\n      yield* Ref.update(registry, (registryItems) =>\n        setNestedProperty(\n          registryItems,\n          [functionName],\n          RegistryItem.make({\n            functionSpec,\n            handler,\n          }),\n        ),\n      );\n\n      return { functionName };\n    }),\n  );\n};\n\n/**\n * Get the function implementation service type for a specific function name.\n */\nexport type ForFunction<FunctionName extends string> =\n  FunctionImpl<FunctionName>;\n\n/**\n * Get all function implementation services required for a group spec.\n */\nexport type FromGroupSpec<Group extends GroupSpec.AnyWithProps> =\n  FunctionSpec.Name<\n    GroupSpec.Functions<Group>\n  > extends infer FunctionNames extends string\n    ? FunctionNames extends string\n      ? FunctionImpl<FunctionNames>\n      : never\n    : never;\n"],"mappings":";;;;;;;;;;;AAaA,MAAa,gBAA6C,EACxD,mBAIA,QAAQ,WACN,gCAAgC,eACjC;;;;;;;;;;;;;;;;;AAkBH,MAAa,QAKX,iBACA,OACA,cACA,YAK4C;CAC5C,MAAM,eAAe,MAAM,UAAU;AAErC,QAAO,MAAM,OACX,aAA2B,EAAE,cAAc,CAAC,EAC5C,OAAO,IAAI,aAAa;EACtB,MAAM,WAAW,OAAO,SAAS;AAEjC,SAAO,IAAI,OAAO,WAAW,kBAC3B,kBACE,eACA,CAAC,aAAa,EACdA,OAAkB;GAChB;GACA;GACD,CAAC,CACH,CACF;AAED,SAAO,EAAE,cAAc;GACvB,CACH"}