@confect/server 9.0.0-next.1 → 9.0.0-next.10

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","sourceRoot":"","sources":["../src/DatabaseReader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,KAAK,cAAc,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,KAAK,SAAS,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,gBAAgB,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AAEjC,eAAO,MAAM,IAAI,GAAI,eAAe,SAAS,cAAc,CAAC,YAAY,EACtE,gBAAgB,eAAe,EAC/B,sBAAsB,qBAAqB,CACzC,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,CAC1D;kBAMe,SAAS,SAAS,KAAK,CAAC,IAAI,6DAAgB,aAC7C,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BzB,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,eAAe,SAAS,cAAc,CAAC,YAAY;kBAjCnC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAT,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCxB,CAAC;AAEJ,MAAM,MAAM,cAAc,CACxB,eAAe,SAAS,cAAc,CAAC,YAAY,IACjD,UAAU,CAAC,OAAO,cAAc,CAAC,eAAe,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;AAErE,eAAO,MAAM,KAAK,GAAI,eAAe,SAAS,cAAc,CAAC,YAAY,EACvE,gBAAgB,eAAe,EAC/B,sBAAsB,qBAAqB,CACzC,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,CAC1D;kBA/Ce,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAoDxB,CAAC"}

package/dist/DatabaseReader.js

@@ -1,8 +1,8 @@
 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 * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
 
 //#region src/DatabaseReader.ts
 var DatabaseReader_exports = /* @__PURE__ */ __exportAll({
@@ -11,16 +11,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 * as Context from \"effect/Context\";\nimport * as Layer from \"effect/Layer\";\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":";;;;;;;;;;;;AASA,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,139 +1,47 @@
-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";
-
-//#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 };
+import type * as Table from "./Table";
+export declare const TypeId = "@confect/server/DatabaseSchema";
+export type TypeId = typeof TypeId;
+export interface Any {
+    readonly [TypeId]: TypeId;
 }
-declare const TypeId = "@confect/server/DatabaseSchema";
-type TypeId = typeof TypeId;
-interface Any {
-  readonly [TypeId]: TypeId;
-}
-declare const isDatabaseSchema: (u: unknown) => u is Any;
+export 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 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>;
+export interface DatabaseSchema<Tables_ extends Table.AnyWithProps = never> {
+    readonly [TypeId]: TypeId;
+    readonly tables: {
+        readonly [TableName in Table.Name<Tables_>]: Table.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;
+export interface AnyWithProps {
+    readonly [TypeId]: TypeId;
+    readonly tables: Record<string, Table.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;
+export type Tables<DatabaseSchema_ extends AnyWithProps> = DatabaseSchema_ extends DatabaseSchema<infer Tables_> ? Tables_ : never;
+export type TableNames<DatabaseSchema_ extends AnyWithProps> = Table.Name<Tables<DatabaseSchema_>> & string;
+export type TableWithName<DatabaseSchema_ extends AnyWithProps, TableName extends TableNames<DatabaseSchema_>> = 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.
  */
-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;
-//#endregion
-export { Any, AnyWithProps, ConvexDatabaseSchemaFromTables, DatabaseSchema, DatabaseSchema_d_exports, ExtendWithSystemTables, IncludeSystemTables, TableNames, TableWithName, Tables, TypeId, extendWithSystemTables, isDatabaseSchema, make, systemSchema };
+export declare const make: <const TablesRecord extends Record<string, Table.AnyWithProps>>(tables: TablesRecord) => DatabaseSchema<TablesRecord[keyof TablesRecord]>;
 //# 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","sourceRoot":"","sources":["../src/DatabaseSchema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,KAAK,MAAM,SAAS,CAAC;AAEtC,eAAO,MAAM,MAAM,mCAAmC,CAAC;AACvD,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC;AAEnC,MAAM,WAAW,GAAG;IAClB,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,eAAO,MAAM,gBAAgB,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,GACjB,CAAC;AAEnC;;;;;;GAMG;AACH,MAAM,WAAW,cAAc,CAAC,OAAO,SAAS,KAAK,CAAC,YAAY,GAAG,KAAK;IACxE,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE;QACf,QAAQ,EAAE,SAAS,IAAI,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,KAAK,CAAC,QAAQ,CACzD,OAAO,EACP,SAAS,CACV;KACF,CAAC;CACH;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;CACrD;AAED,MAAM,MAAM,MAAM,CAAC,eAAe,SAAS,YAAY,IACrD,eAAe,SAAS,cAAc,CAAC,MAAM,OAAO,CAAC,GAAG,OAAO,GAAG,KAAK,CAAC;AAE1E,MAAM,MAAM,UAAU,CAAC,eAAe,SAAS,YAAY,IAAI,KAAK,CAAC,IAAI,CACvE,MAAM,CAAC,eAAe,CAAC,CACxB,GACC,MAAM,CAAC;AAET,MAAM,MAAM,aAAa,CACvB,eAAe,SAAS,YAAY,EACpC,SAAS,SAAS,UAAU,CAAC,eAAe,CAAC,IAC3C,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,EAAE;IAAE,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;CAAE,CAAC,CAAC;AAExE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,IAAI,GACf,KAAK,CAAC,YAAY,SAAS,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,YAAY,CAAC,EAE7D,QAAQ,YAAY,KACnB,cAAc,CAAC,YAAY,CAAC,MAAM,YAAY,CAAC,CAKhD,CAAC"}

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 * as Predicate from "effect/Predicate";
 
 //#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 * as Predicate from \"effect/Predicate\";\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 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

@@ -1,47 +1,43 @@
-import { AnyWithProps } from "./DatabaseSchema.js";
-import { DocumentDecodeError, DocumentEncodeError, WithoutSystemFields as WithoutSystemFields$1 } from "./Document.js";
-import { DocumentByName, FromSchema, TableNames, ToConvex } from "./DataModel.js";
-import { GetByIdFailure } from "./QueryInitializer.js";
-import { Context, Effect, Layer } from "effect";
-import { BetterOmit, Expand, GenericDatabaseWriter, WithoutSystemFields } from "convex/server";
-import { GenericId } from "convex/values";
-
-//#region src/DatabaseWriter.d.ts
-declare namespace DatabaseWriter_d_exports {
-  export { DatabaseWriter, layer, make };
-}
-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, GetByIdFailure | DocumentDecodeError | DocumentEncodeError, 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>;
-  };
+import type { BetterOmit, Expand, GenericDatabaseWriter, WithoutSystemFields } from "convex/server";
+import type { GenericId } from "convex/values";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type * 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";
+export declare const make: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseWriter: GenericDatabaseWriter<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>) => {
+    table: <const TableName extends DataModel.TableNames<DataModel.FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
+        insert: (document: Document.WithoutSystemFields<DocumentByName_<DataModel.FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, Document.DocumentEncodeError, never>;
+        patch: (id: GenericId<TableName>, patchedValues: Partial<WithoutSystemFields<DocumentByName_<DataModel.FromSchema<DatabaseSchema_>, TableName>>>) => Effect.Effect<void, Document.DocumentDecodeError | Document.DocumentEncodeError | QueryInitializer.GetByIdFailure, never>;
+        replace: (id: GenericId<TableName>, value: WithoutSystemFields<DocumentByName_<DataModel.FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<void, Document.DocumentEncodeError, never>;
+        delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
+    };
 };
-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, GetByIdFailure | DocumentDecodeError | DocumentEncodeError, 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>;
-  };
+export declare const DatabaseWriter: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>() => Context.Tag<{
+    table: <const TableName extends DataModel.TableNames<DataModel.FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
+        insert: (document: Document.WithoutSystemFields<DataModel.DocumentByName<DataModel.FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, Document.DocumentEncodeError, never>;
+        patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DataModel.DocumentByName<DataModel.FromSchema<DatabaseSchema_>, TableName>, "_creationTime" | "_id">>>) => Effect.Effect<void, Document.DocumentDecodeError | Document.DocumentEncodeError | QueryInitializer.GetByIdFailure, never>;
+        replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DataModel.DocumentByName<DataModel.FromSchema<DatabaseSchema_>, TableName>, "_creationTime" | "_id">>) => Effect.Effect<void, Document.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, GetByIdFailure | DocumentDecodeError | DocumentEncodeError, 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 DataModel.TableNames<DataModel.FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
+        insert: (document: Document.WithoutSystemFields<DataModel.DocumentByName<DataModel.FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, Document.DocumentEncodeError, never>;
+        patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DataModel.DocumentByName<DataModel.FromSchema<DatabaseSchema_>, TableName>, "_creationTime" | "_id">>>) => Effect.Effect<void, Document.DocumentDecodeError | Document.DocumentEncodeError | QueryInitializer.GetByIdFailure, never>;
+        replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DataModel.DocumentByName<DataModel.FromSchema<DatabaseSchema_>, TableName>, "_creationTime" | "_id">>) => Effect.Effect<void, Document.DocumentEncodeError, never>;
+        delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
+    };
 }>;
-type DatabaseWriter<DatabaseSchema_ extends AnyWithProps> = ReturnType<typeof DatabaseWriter<DatabaseSchema_>>["Identifier"];
-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, GetByIdFailure | DocumentDecodeError | DocumentEncodeError, 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>;
-  };
+export type DatabaseWriter<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> = ReturnType<typeof DatabaseWriter<DatabaseSchema_>>["Identifier"];
+export declare const layer: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseWriter: GenericDatabaseWriter<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>) => Layer.Layer<{
+    table: <const TableName extends DataModel.TableNames<DataModel.FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
+        insert: (document: Document.WithoutSystemFields<DataModel.DocumentByName<DataModel.FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, Document.DocumentEncodeError, never>;
+        patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DataModel.DocumentByName<DataModel.FromSchema<DatabaseSchema_>, TableName>, "_creationTime" | "_id">>>) => Effect.Effect<void, Document.DocumentDecodeError | Document.DocumentEncodeError | QueryInitializer.GetByIdFailure, never>;
+        replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DataModel.DocumentByName<DataModel.FromSchema<DatabaseSchema_>, TableName>, "_creationTime" | "_id">>) => Effect.Effect<void, Document.DocumentEncodeError, never>;
+        delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
+    };
 }, never, never>;
-//#endregion
-export { DatabaseWriter, DatabaseWriter_d_exports, layer, make };
 //# sourceMappingURL=DatabaseWriter.d.ts.map

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,cAAA,GAAA,mBAAA,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","sourceRoot":"","sources":["../src/DatabaseWriter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EAEV,MAAM,EACN,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,KAAK,cAAc,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,KAAK,SAAS,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,IAAI,eAAe,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,gBAAgB,MAAM,oBAAoB,CAAC;AAIvD,eAAO,MAAM,IAAI,GAAI,eAAe,SAAS,cAAc,CAAC,YAAY,EACtE,gBAAgB,eAAe,EAC/B,sBAAsB,qBAAqB,CACzC,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,CAC1D;kBAIoB,SAAS,SAAS,SAAS,CAAC,UAAU,uCAAY,aAC1D,SAAS;2BAQR,QAAQ,CAAC,mBAAmB,CACpC,eAAe,wCAAa,SAAS,CAAC,CACvC;oBAsBG,SAAS,CAAC,SAAS,CAAC,iBACT,OAAO,CACpB,mBAAmB,CAAC,eAAe,wCAAa,SAAS,CAAC,CAAC,CAC5D;sBAqCG,SAAS,CAAC,SAAS,CAAC,SACjB,mBAAmB,CAAC,eAAe,wCAAa,SAAS,CAAC,CAAC;qBAsB/C,SAAS,CAAC,SAAS,CAAC;;CAc5C,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,eAAe,SAAS,cAAc,CAAC,YAAY;kBAjH9B,SAAS;;;;;;;kBAAT,SAAS;;;;;;EAqH7B,CAAC;AAEJ,MAAM,MAAM,cAAc,CACxB,eAAe,SAAS,cAAc,CAAC,YAAY,IACjD,UAAU,CAAC,OAAO,cAAc,CAAC,eAAe,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;AAErE,eAAO,MAAM,KAAK,GAAI,eAAe,SAAS,cAAc,CAAC,YAAY,EACvE,gBAAgB,eAAe,EAC/B,sBAAsB,qBAAqB,CACzC,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,CAC1D;kBA/HoB,SAAS;;;;;;gBAoI7B,CAAC"}

package/dist/DatabaseWriter.js

@@ -1,7 +1,11 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { encode } from "./Document.js";
 import { getById } from "./QueryInitializer.js";
-import { Context, Effect, Layer, Record, pipe } from "effect";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import { pipe } from "effect/Function";
+import * as Effect from "effect/Effect";
+import * as Record from "effect/Record";
 
 //#region src/DatabaseWriter.ts
 var DatabaseWriter_exports = /* @__PURE__ */ __exportAll({
@@ -10,21 +14,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 { pipe } from \"effect/Function\";\nimport * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport * as Record from \"effect/Record\";\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":";;;;;;;;;;;;;;;AAqBA,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"}