@confect/server 9.0.2 → 9.1.1

package/dist/DatabaseReader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DatabaseReader.d.ts","sourceRoot":"","sources":["../src/DatabaseReader.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"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,KAAK,cAAc,CAAC,eAAe,SAAS,cAAc,CAAC,YAAY,IACnE,cAAc,CAAC,MAAM,CAAC,eAAe,CAAC,GACtC,KAAK,CAAC,YAAY,CAAC;AAEvB,KAAK,iBAAiB,CAAC,eAAe,SAAS,cAAc,CAAC,YAAY,IACxE,SAAS,CAAC,SAAS,CAAC,cAAc,CAAC,eAAe,CAAC,CAAC,CAAC;AAEvD,MAAM,WAAW,qBAAqB,CACpC,eAAe,SAAS,cAAc,CAAC,YAAY,EACnD,IAAI,GAAG,EAAE;IAET,QAAQ,CAAC,KAAK,EAAE,CACd,KAAK,CAAC,SAAS,SAAS,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,CAAC,EAEnE,SAAS,EAAE,SAAS,KACjB,gBAAgB,CAAC,gBAAgB,CACpC,iBAAiB,CAAC,eAAe,CAAC,EAClC,SAAS,EACT,SAAS,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,eAAe,CAAC,EAAE,SAAS,CAAC,EAC1E,SAAS,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,eAAe,CAAC,EAAE,SAAS,CAAC,EAC3E,SAAS,SAAS,MAAM,IAAI,GACxB,IAAI,CAAC,SAAS,CAAC,GACf,SAAS,CAAC,gBAAgB,CACxB,iBAAiB,CAAC,eAAe,CAAC,EAClC,SAAS,CACV,CACN,CAAC;CACH;AAED,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,KACA,qBAAqB,CAAC,eAAe,CAkCvC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,CAC3B,eAAe,SAAS,cAAc,CAAC,YAAY,EACnD,IAAI,GAAG,EAAE,IACP,OAAO,CAAC,GAAG,CACb,qBAAqB,CAAC,eAAe,CAAC,EACtC,qBAAqB,CAAC,eAAe,EAAE,IAAI,CAAC,CAC7C,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,eAAe,SAAS,cAAc,CAAC,YAAY,EACnD,IAAI,GAAG,EAAE,OACN,iBAAiB,CAAC,eAAe,EAAE,IAAI,CAIP,CAAC;AAEtC,MAAM,MAAM,cAAc,CACxB,eAAe,SAAS,cAAc,CAAC,YAAY,IACjD,qBAAqB,CAAC,eAAe,CAAC,CAAC;AAE3C,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,0EAKA,CAAC"}

package/dist/DatabaseReader.js.map

@@ -1 +1 @@
-{"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"}
+{"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\ntype IncludedTables<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> =\n  | DatabaseSchema.Tables<DatabaseSchema_>\n  | Table.SystemTables;\n\ntype IncludedDataModel<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> =\n  DataModel.DataModel<IncludedTables<DatabaseSchema_>>;\n\nexport interface DatabaseReaderService<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Docs = {},\n> {\n  readonly table: <\n    const TableName extends Table.Name<IncludedTables<DatabaseSchema_>>,\n  >(\n    tableName: TableName,\n  ) => QueryInitializer.QueryInitializer<\n    IncludedDataModel<DatabaseSchema_>,\n    TableName,\n    DataModel.TableInfoWithName<IncludedDataModel<DatabaseSchema_>, TableName>,\n    DataModel.TableInfoWithName_<IncludedDataModel<DatabaseSchema_>, TableName>,\n    TableName extends keyof Docs\n      ? Docs[TableName]\n      : DataModel.DocumentWithName<\n          IncludedDataModel<DatabaseSchema_>,\n          TableName\n        >\n  >;\n}\n\nexport const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(\n  databaseSchema: DatabaseSchema_,\n  convexDatabaseReader: GenericDatabaseReader<\n    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n  >,\n): DatabaseReaderService<DatabaseSchema_> => {\n  return {\n    table: <\n      const TableName extends Table.Name<IncludedTables<DatabaseSchema_>>,\n    >(\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<DatabaseSchema_>, TableName>;\n\n      return QueryInitializer.make<IncludedTables<DatabaseSchema_>, TableName>(\n        tableName,\n        baseDatabaseReader,\n        table,\n      );\n    },\n  } as DatabaseReaderService<DatabaseSchema_>;\n};\n\n/**\n * The tag's *Identifier* (the Effect requirements-channel type) is\n * `Docs`-independent so a helper's `R` channel is the same whether or not a\n * codegen document registry is supplied — this keeps it identical to what\n * `Handler`/runtime provisioning provide. The tag's *Service* (what `yield*`\n * produces) carries `Docs`, so queries resolve to the named doc interfaces.\n */\nexport type DatabaseReaderTag<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Docs = {},\n> = Context.Tag<\n  DatabaseReaderService<DatabaseSchema_>,\n  DatabaseReaderService<DatabaseSchema_, Docs>\n>;\n\nexport const DatabaseReader = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Docs = {},\n>(): DatabaseReaderTag<DatabaseSchema_, Docs> =>\n  Context.GenericTag<\n    DatabaseReaderService<DatabaseSchema_>,\n    DatabaseReaderService<DatabaseSchema_, Docs>\n  >(\"@confect/server/DatabaseReader\");\n\nexport type DatabaseReader<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n> = DatabaseReaderService<DatabaseSchema_>;\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":";;;;;;;;;;;;AAsCA,MAAa,QACX,gBACA,yBAG2C;AAC3C,QAAO,EACL,QAGE,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;;AAkBH,MAAa,uBAIX,QAAQ,WAGN,iCAAiC;AAMrC,MAAa,SACX,gBACA,yBAIA,MAAM,QACJ,gBAAiC,EACjC,KAAK,gBAAgB,qBAAqB,CAC3C"}

package/dist/DatabaseWriter.d.ts

@@ -1,4 +1,4 @@
-import type { BetterOmit, Expand, GenericDatabaseWriter, WithoutSystemFields } from "convex/server";
+import type { GenericDatabaseWriter } from "convex/server";
 import type { GenericId } from "convex/values";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
@@ -8,36 +8,28 @@ 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>;
-    };
-};
-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 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>;
-    };
-}>;
-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>;
+export interface DatabaseWriterTableAccessor<DataModel_ extends DataModel.AnyWithProps, TableName extends DataModel.TableNames<DataModel_>, Doc = DocumentByName_<DataModel_, TableName>> {
+    readonly insert: (document: Document.WithoutSystemFields<Doc>) => Effect.Effect<GenericId<TableName>, Document.DocumentEncodeError>;
+    readonly patch: (id: GenericId<TableName>, patchedValues: Partial<Document.WithoutSystemFields<Doc>>) => Effect.Effect<void, QueryInitializer.GetByIdFailure | Document.DocumentDecodeError | Document.DocumentEncodeError>;
+    readonly replace: (id: GenericId<TableName>, value: Document.WithoutSystemFields<Doc>) => Effect.Effect<void, Document.DocumentEncodeError>;
+    readonly delete: (id: GenericId<TableName>) => Effect.Effect<void>;
+}
+/**
+ * The service shape backing the `DatabaseWriter` tag. Named (rather than an
+ * inferred anonymous object) so declaration emit prints
+ * `DatabaseWriterService<…>` by reference instead of expanding the data model.
+ * `Docs` is the optional named document registry (see `DatabaseReaderService`).
+ */
+export interface DatabaseWriterService<DatabaseSchema_ extends DatabaseSchema.AnyWithProps, Docs = {}> {
+    readonly table: <const TableName extends DataModel.TableNames<DataModel.FromSchema<DatabaseSchema_>>>(tableName: TableName) => DatabaseWriterTableAccessor<DataModel.FromSchema<DatabaseSchema_>, TableName, TableName extends keyof Docs ? Docs[TableName] : DocumentByName_<DataModel.FromSchema<DatabaseSchema_>, TableName>>;
+}
+/**
+ * The tag's *Identifier* is `Docs`-independent (see `DatabaseReaderTag`); only
+ * the *Service* carries `Docs` so writer inputs print the named doc interfaces.
+ */
+export type DatabaseWriterTag<DatabaseSchema_ extends DatabaseSchema.AnyWithProps, Docs = {}> = Context.Tag<DatabaseWriterService<DatabaseSchema_>, DatabaseWriterService<DatabaseSchema_, Docs>>;
+export declare const make: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseWriter: GenericDatabaseWriter<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>) => DatabaseWriterService<DatabaseSchema_>;
+export declare const DatabaseWriter: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps, Docs = {}>() => DatabaseWriterTag<DatabaseSchema_, Docs>;
+export type DatabaseWriter<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> = DatabaseWriterService<DatabaseSchema_>;
+export declare const layer: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseWriter: GenericDatabaseWriter<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>) => Layer.Layer<DatabaseWriterService<DatabaseSchema_, {}>, never, never>;
 //# sourceMappingURL=DatabaseWriter.d.ts.map

package/dist/DatabaseWriter.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"DatabaseWriter.d.ts","sourceRoot":"","sources":["../src/DatabaseWriter.ts"],"names":[],"mappings":"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"}

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 { 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"}
+{"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 interface DatabaseWriterTableAccessor<\n  DataModel_ extends DataModel.AnyWithProps,\n  TableName extends DataModel.TableNames<DataModel_>,\n  Doc = DocumentByName_<DataModel_, TableName>,\n> {\n  readonly insert: (\n    document: Document.WithoutSystemFields<Doc>,\n  ) => Effect.Effect<GenericId<TableName>, Document.DocumentEncodeError>;\n  readonly patch: (\n    id: GenericId<TableName>,\n    patchedValues: Partial<Document.WithoutSystemFields<Doc>>,\n  ) => Effect.Effect<\n    void,\n    | QueryInitializer.GetByIdFailure\n    | Document.DocumentDecodeError\n    | Document.DocumentEncodeError\n  >;\n  readonly replace: (\n    id: GenericId<TableName>,\n    value: Document.WithoutSystemFields<Doc>,\n  ) => Effect.Effect<void, Document.DocumentEncodeError>;\n  readonly delete: (id: GenericId<TableName>) => Effect.Effect<void>;\n}\n\n/**\n * The service shape backing the `DatabaseWriter` tag. Named (rather than an\n * inferred anonymous object) so declaration emit prints\n * `DatabaseWriterService<…>` by reference instead of expanding the data model.\n * `Docs` is the optional named document registry (see `DatabaseReaderService`).\n */\nexport interface DatabaseWriterService<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Docs = {},\n> {\n  readonly table: <\n    const TableName extends DataModel.TableNames<\n      DataModel.FromSchema<DatabaseSchema_>\n    >,\n  >(\n    tableName: TableName,\n  ) => DatabaseWriterTableAccessor<\n    DataModel.FromSchema<DatabaseSchema_>,\n    TableName,\n    TableName extends keyof Docs\n      ? Docs[TableName]\n      : DocumentByName_<DataModel.FromSchema<DatabaseSchema_>, TableName>\n  >;\n}\n\n/**\n * The tag's *Identifier* is `Docs`-independent (see `DatabaseReaderTag`); only\n * the *Service* carries `Docs` so writer inputs print the named doc interfaces.\n */\nexport type DatabaseWriterTag<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Docs = {},\n> = Context.Tag<\n  DatabaseWriterService<DatabaseSchema_>,\n  DatabaseWriterService<DatabaseSchema_, Docs>\n>;\n\nexport const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(\n  databaseSchema: DatabaseSchema_,\n  convexDatabaseWriter: GenericDatabaseWriter<\n    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n  >,\n): DatabaseWriterService<DatabaseSchema_> => {\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  } as DatabaseWriterService<DatabaseSchema_>;\n};\n\nexport const DatabaseWriter = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Docs = {},\n>(): DatabaseWriterTag<DatabaseSchema_, Docs> =>\n  Context.GenericTag<\n    DatabaseWriterService<DatabaseSchema_>,\n    DatabaseWriterService<DatabaseSchema_, Docs>\n  >(\"@confect/server/DatabaseWriter\");\n\nexport type DatabaseWriter<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n> = DatabaseWriterService<DatabaseSchema_>;\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":";;;;;;;;;;;;;;;AAkFA,MAAa,QACX,gBACA,yBAG2C;CAG3C,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,uBAIX,QAAQ,WAGN,iCAAiC;AAMrC,MAAa,SACX,gBACA,yBAIA,MAAM,QACJ,gBAAiC,EACjC,KAAK,gBAAgB,qBAAqB,CAC3C"}

package/dist/Document.d.ts

@@ -1,9 +1,11 @@
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import type { ReadonlyRecord } from "effect/Record";
+import type * as DatabaseSchema from "./DatabaseSchema";
 import type * as DataModel from "./DataModel";
 import type { ReadonlyValue } from "./SchemaToValidator";
 import type * as TableInfo from "./TableInfo";
+export type Document<Schema_ extends DatabaseSchema.AnyWithProps, TableName extends DatabaseSchema.TableNames<Schema_>> = DataModel.DocumentByName<DataModel.FromSchema<Schema_>, TableName>;
 export type WithoutSystemFields<Doc> = Omit<Doc, "_creationTime" | "_id">;
 export type Any = any;
 export type AnyEncoded = ReadonlyRecord<string, ReadonlyValue>;

package/dist/Document.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Document.d.ts","sourceRoot":"","sources":["../src/Document.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Document.d.ts","sourceRoot":"","sources":["../src/Document.ts"],"names":[],"mappings":"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"}

package/dist/Document.js.map

@@ -1 +1 @@
-{"version":3,"file":"Document.js","names":[],"sources":["../src/Document.ts"],"sourcesContent":["import * as SystemFields from \"@confect/core/SystemFields\";\nimport { pipe } from \"effect/Function\";\nimport * as Effect from \"effect/Effect\";\nimport * as Function from \"effect/Function\";\nimport * as ParseResult from \"effect/ParseResult\";\nimport * as Schema from \"effect/Schema\";\nimport type { ReadonlyRecord } from \"effect/Record\";\nimport type * as DataModel from \"./DataModel\";\nimport type { ReadonlyValue } from \"./SchemaToValidator\";\nimport type * as TableInfo from \"./TableInfo\";\n\nexport type WithoutSystemFields<Doc> = Omit<Doc, \"_creationTime\" | \"_id\">;\n\nexport type Any = any;\nexport type AnyEncoded = ReadonlyRecord<string, ReadonlyValue>;\n\ntype Decode = (doc: unknown) => Effect.Effect<unknown, ParseResult.ParseError>;\n\nconst decoderCache = new WeakMap<\n  Schema.Schema.AnyNoContext,\n  Map<string, Decode>\n>();\n\nconst getDecoder = (\n  tableName: string,\n  tableSchema: Schema.Schema.AnyNoContext,\n): Decode => {\n  const byTable =\n    decoderCache.get(tableSchema) ??\n    (() => {\n      const map = new Map<string, Decode>();\n      decoderCache.set(tableSchema, map);\n      return map;\n    })();\n\n  return (\n    byTable.get(tableName) ??\n    (() => {\n      const decoder = Schema.decode(\n        SystemFields.extendWithSystemFields(tableName, tableSchema),\n      ) as Decode;\n      byTable.set(tableName, decoder);\n      return decoder;\n    })()\n  );\n};\n\nexport const decode = Function.dual<\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ) => (\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"convexDocument\"],\n  ) => Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    DocumentDecodeError\n  >,\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"convexDocument\"],\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ) => Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    DocumentDecodeError\n  >\n>(\n  3,\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"convexDocument\"],\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ): Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    DocumentDecodeError\n  > =>\n    pipe(\n      self,\n      getDecoder(tableName, tableSchema),\n      Effect.catchIf(ParseResult.isParseError, (parseError) =>\n        Effect.gen(function* () {\n          const formattedParseError =\n            yield* ParseResult.TreeFormatter.formatError(parseError);\n\n          return yield* new DocumentDecodeError({\n            tableName,\n            id: self._id,\n            parseError: formattedParseError,\n          });\n        }),\n      ),\n      Effect.map(\n        (decodedDoc) =>\n          decodedDoc as DataModel.TableInfoWithName_<\n            DataModel_,\n            TableName\n          >[\"document\"],\n      ),\n    ),\n);\n\ntype Encode = (doc: unknown) => Effect.Effect<unknown, ParseResult.ParseError>;\n\nconst encoderCache = new WeakMap<Schema.Schema.AnyNoContext, Encode>();\n\nconst getEncoder = (tableSchema: Schema.Schema.AnyNoContext): Encode =>\n  encoderCache.get(tableSchema) ??\n  (() => {\n    const encoder = Schema.encode(tableSchema) as Encode;\n    encoderCache.set(tableSchema, encoder);\n    return encoder;\n  })();\n\nexport const encode = Function.dual<\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ) => (\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n  ) => Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"encodedDocument\"],\n    DocumentEncodeError\n  >,\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ) => Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"encodedDocument\"],\n    DocumentEncodeError\n  >\n>(\n  3,\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ): Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"encodedDocument\"],\n    DocumentEncodeError\n  > =>\n    pipe(\n      self,\n      getEncoder(tableSchema),\n      Effect.catchIf(ParseResult.isParseError, (parseError) =>\n        Effect.gen(function* () {\n          const formattedParseError =\n            yield* ParseResult.TreeFormatter.formatError(parseError);\n\n          return yield* new DocumentEncodeError({\n            tableName,\n            id: self._id,\n            parseError: formattedParseError,\n          });\n        }),\n      ),\n      Effect.map(\n        (encodedDoc) =>\n          encodedDoc as DataModel.TableInfoWithName_<\n            DataModel_,\n            TableName\n          >[\"encodedDocument\"],\n      ),\n    ),\n);\n\nexport class DocumentDecodeError extends Schema.TaggedError<DocumentDecodeError>()(\n  \"DocumentDecodeError\",\n  {\n    tableName: Schema.String,\n    id: Schema.String,\n    parseError: Schema.String,\n  },\n) {\n  override get message(): string {\n    return documentErrorMessage({\n      id: this.id,\n      tableName: this.tableName,\n      message: `could not be decoded:\\n\\n${this.parseError}`,\n    });\n  }\n}\n\nexport class DocumentEncodeError extends Schema.TaggedError<DocumentEncodeError>()(\n  \"DocumentEncodeError\",\n  {\n    tableName: Schema.String,\n    id: Schema.String,\n    parseError: Schema.String,\n  },\n) {\n  override get message(): string {\n    return documentErrorMessage({\n      id: this.id,\n      tableName: this.tableName,\n      message: `could not be encoded:\\n\\n${this.parseError}`,\n    });\n  }\n}\n\nexport const documentErrorMessage = ({\n  id,\n  tableName,\n  message,\n}: {\n  id: string;\n  tableName: string;\n  message: string;\n}) => `Document with ID '${id}' in table '${tableName}' ${message}`;\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,MAAM,+BAAe,IAAI,SAGtB;AAEH,MAAM,cACJ,WACA,gBACW;CACX,MAAM,UACJ,aAAa,IAAI,YAAY,WACtB;EACL,MAAM,sBAAM,IAAI,KAAqB;AACrC,eAAa,IAAI,aAAa,IAAI;AAClC,SAAO;KACL;AAEN,QACE,QAAQ,IAAI,UAAU,WACf;EACL,MAAM,UAAU,OAAO,OACrB,aAAa,uBAAuB,WAAW,YAAY,CAC5D;AACD,UAAQ,IAAI,WAAW,QAAQ;AAC/B,SAAO;KACL;;AAIR,MAAa,SAAS,SAAS,KA6B7B,IAKE,MACA,WACA,gBAOA,KACE,MACA,WAAW,WAAW,YAAY,EAClC,OAAO,QAAQ,YAAY,eAAe,eACxC,OAAO,IAAI,aAAa;CACtB,MAAM,sBACJ,OAAO,YAAY,cAAc,YAAY,WAAW;AAE1D,QAAO,OAAO,IAAI,oBAAoB;EACpC;EACA,IAAI,KAAK;EACT,YAAY;EACb,CAAC;EACF,CACH,EACD,OAAO,KACJ,eACC,WAIH,CACF,CACJ;AAID,MAAM,+BAAe,IAAI,SAA6C;AAEtE,MAAM,cAAc,gBAClB,aAAa,IAAI,YAAY,WACtB;CACL,MAAM,UAAU,OAAO,OAAO,YAAY;AAC1C,cAAa,IAAI,aAAa,QAAQ;AACtC,QAAO;IACL;AAEN,MAAa,SAAS,SAAS,KA6B7B,IAKE,MACA,WACA,gBAOA,KACE,MACA,WAAW,YAAY,EACvB,OAAO,QAAQ,YAAY,eAAe,eACxC,OAAO,IAAI,aAAa;CACtB,MAAM,sBACJ,OAAO,YAAY,cAAc,YAAY,WAAW;AAE1D,QAAO,OAAO,IAAI,oBAAoB;EACpC;EACA,IAAI,KAAK;EACT,YAAY;EACb,CAAC;EACF,CACH,EACD,OAAO,KACJ,eACC,WAIH,CACF,CACJ;AAED,IAAa,sBAAb,cAAyC,OAAO,aAAkC,CAChF,uBACA;CACE,WAAW,OAAO;CAClB,IAAI,OAAO;CACX,YAAY,OAAO;CACpB,CACF,CAAC;CACA,IAAa,UAAkB;AAC7B,SAAO,qBAAqB;GAC1B,IAAI,KAAK;GACT,WAAW,KAAK;GAChB,SAAS,4BAA4B,KAAK;GAC3C,CAAC;;;AAIN,IAAa,sBAAb,cAAyC,OAAO,aAAkC,CAChF,uBACA;CACE,WAAW,OAAO;CAClB,IAAI,OAAO;CACX,YAAY,OAAO;CACpB,CACF,CAAC;CACA,IAAa,UAAkB;AAC7B,SAAO,qBAAqB;GAC1B,IAAI,KAAK;GACT,WAAW,KAAK;GAChB,SAAS,4BAA4B,KAAK;GAC3C,CAAC;;;AAIN,MAAa,wBAAwB,EACnC,IACA,WACA,cAKI,qBAAqB,GAAG,cAAc,UAAU,IAAI"}
+{"version":3,"file":"Document.js","names":[],"sources":["../src/Document.ts"],"sourcesContent":["import * as SystemFields from \"@confect/core/SystemFields\";\nimport { pipe } from \"effect/Function\";\nimport * as Effect from \"effect/Effect\";\nimport * as Function from \"effect/Function\";\nimport * as ParseResult from \"effect/ParseResult\";\nimport * as Schema from \"effect/Schema\";\nimport type { ReadonlyRecord } from \"effect/Record\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as DataModel from \"./DataModel\";\nimport type { ReadonlyValue } from \"./SchemaToValidator\";\nimport type * as TableInfo from \"./TableInfo\";\n\nexport type Document<\n  Schema_ extends DatabaseSchema.AnyWithProps,\n  TableName extends DatabaseSchema.TableNames<Schema_>,\n> = DataModel.DocumentByName<DataModel.FromSchema<Schema_>, TableName>;\n\nexport type WithoutSystemFields<Doc> = Omit<Doc, \"_creationTime\" | \"_id\">;\n\nexport type Any = any;\nexport type AnyEncoded = ReadonlyRecord<string, ReadonlyValue>;\n\ntype Decode = (doc: unknown) => Effect.Effect<unknown, ParseResult.ParseError>;\n\nconst decoderCache = new WeakMap<\n  Schema.Schema.AnyNoContext,\n  Map<string, Decode>\n>();\n\nconst getDecoder = (\n  tableName: string,\n  tableSchema: Schema.Schema.AnyNoContext,\n): Decode => {\n  const byTable =\n    decoderCache.get(tableSchema) ??\n    (() => {\n      const map = new Map<string, Decode>();\n      decoderCache.set(tableSchema, map);\n      return map;\n    })();\n\n  return (\n    byTable.get(tableName) ??\n    (() => {\n      const decoder = Schema.decode(\n        SystemFields.extendWithSystemFields(tableName, tableSchema),\n      ) as Decode;\n      byTable.set(tableName, decoder);\n      return decoder;\n    })()\n  );\n};\n\nexport const decode = Function.dual<\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ) => (\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"convexDocument\"],\n  ) => Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    DocumentDecodeError\n  >,\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"convexDocument\"],\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ) => Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    DocumentDecodeError\n  >\n>(\n  3,\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"convexDocument\"],\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ): Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    DocumentDecodeError\n  > =>\n    pipe(\n      self,\n      getDecoder(tableName, tableSchema),\n      Effect.catchIf(ParseResult.isParseError, (parseError) =>\n        Effect.gen(function* () {\n          const formattedParseError =\n            yield* ParseResult.TreeFormatter.formatError(parseError);\n\n          return yield* new DocumentDecodeError({\n            tableName,\n            id: self._id,\n            parseError: formattedParseError,\n          });\n        }),\n      ),\n      Effect.map(\n        (decodedDoc) =>\n          decodedDoc as DataModel.TableInfoWithName_<\n            DataModel_,\n            TableName\n          >[\"document\"],\n      ),\n    ),\n);\n\ntype Encode = (doc: unknown) => Effect.Effect<unknown, ParseResult.ParseError>;\n\nconst encoderCache = new WeakMap<Schema.Schema.AnyNoContext, Encode>();\n\nconst getEncoder = (tableSchema: Schema.Schema.AnyNoContext): Encode =>\n  encoderCache.get(tableSchema) ??\n  (() => {\n    const encoder = Schema.encode(tableSchema) as Encode;\n    encoderCache.set(tableSchema, encoder);\n    return encoder;\n  })();\n\nexport const encode = Function.dual<\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ) => (\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n  ) => Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"encodedDocument\"],\n    DocumentEncodeError\n  >,\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ) => Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"encodedDocument\"],\n    DocumentEncodeError\n  >\n>(\n  3,\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ): Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"encodedDocument\"],\n    DocumentEncodeError\n  > =>\n    pipe(\n      self,\n      getEncoder(tableSchema),\n      Effect.catchIf(ParseResult.isParseError, (parseError) =>\n        Effect.gen(function* () {\n          const formattedParseError =\n            yield* ParseResult.TreeFormatter.formatError(parseError);\n\n          return yield* new DocumentEncodeError({\n            tableName,\n            id: self._id,\n            parseError: formattedParseError,\n          });\n        }),\n      ),\n      Effect.map(\n        (encodedDoc) =>\n          encodedDoc as DataModel.TableInfoWithName_<\n            DataModel_,\n            TableName\n          >[\"encodedDocument\"],\n      ),\n    ),\n);\n\nexport class DocumentDecodeError extends Schema.TaggedError<DocumentDecodeError>()(\n  \"DocumentDecodeError\",\n  {\n    tableName: Schema.String,\n    id: Schema.String,\n    parseError: Schema.String,\n  },\n) {\n  override get message(): string {\n    return documentErrorMessage({\n      id: this.id,\n      tableName: this.tableName,\n      message: `could not be decoded:\\n\\n${this.parseError}`,\n    });\n  }\n}\n\nexport class DocumentEncodeError extends Schema.TaggedError<DocumentEncodeError>()(\n  \"DocumentEncodeError\",\n  {\n    tableName: Schema.String,\n    id: Schema.String,\n    parseError: Schema.String,\n  },\n) {\n  override get message(): string {\n    return documentErrorMessage({\n      id: this.id,\n      tableName: this.tableName,\n      message: `could not be encoded:\\n\\n${this.parseError}`,\n    });\n  }\n}\n\nexport const documentErrorMessage = ({\n  id,\n  tableName,\n  message,\n}: {\n  id: string;\n  tableName: string;\n  message: string;\n}) => `Document with ID '${id}' in table '${tableName}' ${message}`;\n"],"mappings":";;;;;;;;;;;;;;;;AAwBA,MAAM,+BAAe,IAAI,SAGtB;AAEH,MAAM,cACJ,WACA,gBACW;CACX,MAAM,UACJ,aAAa,IAAI,YAAY,WACtB;EACL,MAAM,sBAAM,IAAI,KAAqB;AACrC,eAAa,IAAI,aAAa,IAAI;AAClC,SAAO;KACL;AAEN,QACE,QAAQ,IAAI,UAAU,WACf;EACL,MAAM,UAAU,OAAO,OACrB,aAAa,uBAAuB,WAAW,YAAY,CAC5D;AACD,UAAQ,IAAI,WAAW,QAAQ;AAC/B,SAAO;KACL;;AAIR,MAAa,SAAS,SAAS,KA6B7B,IAKE,MACA,WACA,gBAOA,KACE,MACA,WAAW,WAAW,YAAY,EAClC,OAAO,QAAQ,YAAY,eAAe,eACxC,OAAO,IAAI,aAAa;CACtB,MAAM,sBACJ,OAAO,YAAY,cAAc,YAAY,WAAW;AAE1D,QAAO,OAAO,IAAI,oBAAoB;EACpC;EACA,IAAI,KAAK;EACT,YAAY;EACb,CAAC;EACF,CACH,EACD,OAAO,KACJ,eACC,WAIH,CACF,CACJ;AAID,MAAM,+BAAe,IAAI,SAA6C;AAEtE,MAAM,cAAc,gBAClB,aAAa,IAAI,YAAY,WACtB;CACL,MAAM,UAAU,OAAO,OAAO,YAAY;AAC1C,cAAa,IAAI,aAAa,QAAQ;AACtC,QAAO;IACL;AAEN,MAAa,SAAS,SAAS,KA6B7B,IAKE,MACA,WACA,gBAOA,KACE,MACA,WAAW,YAAY,EACvB,OAAO,QAAQ,YAAY,eAAe,eACxC,OAAO,IAAI,aAAa;CACtB,MAAM,sBACJ,OAAO,YAAY,cAAc,YAAY,WAAW;AAE1D,QAAO,OAAO,IAAI,oBAAoB;EACpC;EACA,IAAI,KAAK;EACT,YAAY;EACb,CAAC;EACF,CACH,EACD,OAAO,KACJ,eACC,WAIH,CACF,CACJ;AAED,IAAa,sBAAb,cAAyC,OAAO,aAAkC,CAChF,uBACA;CACE,WAAW,OAAO;CAClB,IAAI,OAAO;CACX,YAAY,OAAO;CACpB,CACF,CAAC;CACA,IAAa,UAAkB;AAC7B,SAAO,qBAAqB;GAC1B,IAAI,KAAK;GACT,WAAW,KAAK;GAChB,SAAS,4BAA4B,KAAK;GAC3C,CAAC;;;AAIN,IAAa,sBAAb,cAAyC,OAAO,aAAkC,CAChF,uBACA;CACE,WAAW,OAAO;CAClB,IAAI,OAAO;CACX,YAAY,OAAO;CACpB,CACF,CAAC;CACA,IAAa,UAAkB;AAC7B,SAAO,qBAAqB;GAC1B,IAAI,KAAK;GACT,WAAW,KAAK;GAChB,SAAS,4BAA4B,KAAK;GAC3C,CAAC;;;AAIN,MAAa,wBAAwB,EACnC,IACA,WACA,cAKI,qBAAqB,GAAG,cAAc,UAAU,IAAI"}

package/dist/MutationCtx.d.ts

@@ -1,5 +1,6 @@
 import type { GenericDataModel, GenericMutationCtx } from "convex/server";
 import * as Context from "effect/Context";
-export declare const MutationCtx: <DataModel extends GenericDataModel>() => Context.Tag<GenericMutationCtx<DataModel>, GenericMutationCtx<DataModel>>;
-export type MutationCtx<DataModel extends GenericDataModel> = ReturnType<typeof MutationCtx<DataModel>>["Identifier"];
+export type MutationCtxTag<DataModel extends GenericDataModel> = Context.Tag<GenericMutationCtx<DataModel>, GenericMutationCtx<DataModel>>;
+export declare const MutationCtx: <DataModel extends GenericDataModel>() => MutationCtxTag<DataModel>;
+export type MutationCtx<DataModel extends GenericDataModel> = GenericMutationCtx<DataModel>;
 //# sourceMappingURL=MutationCtx.d.ts.map

package/dist/MutationCtx.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MutationCtx.d.ts","sourceRoot":"","sources":["../src/MutationCtx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAC1E,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,eAAO,MAAM,WAAW,GAAI,SAAS,SAAS,gBAAgB,gFAG3D,CAAC;AAEJ,MAAM,MAAM,WAAW,CAAC,SAAS,SAAS,gBAAgB,IAAI,UAAU,CACtE,OAAO,WAAW,CAAC,SAAS,CAAC,CAC9B,CAAC,YAAY,CAAC,CAAC"}
+{"version":3,"file":"MutationCtx.d.ts","sourceRoot":"","sources":["../src/MutationCtx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAC1E,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,MAAM,MAAM,cAAc,CAAC,SAAS,SAAS,gBAAgB,IAAI,OAAO,CAAC,GAAG,CAC1E,kBAAkB,CAAC,SAAS,CAAC,EAC7B,kBAAkB,CAAC,SAAS,CAAC,CAC9B,CAAC;AAEF,eAAO,MAAM,WAAW,GACtB,SAAS,SAAS,gBAAgB,OAC/B,cAAc,CAAC,SAAS,CAG1B,CAAC;AAEJ,MAAM,MAAM,WAAW,CAAC,SAAS,SAAS,gBAAgB,IACxD,kBAAkB,CAAC,SAAS,CAAC,CAAC"}

package/dist/MutationCtx.js.map

@@ -1 +1 @@
-{"version":3,"file":"MutationCtx.js","names":[],"sources":["../src/MutationCtx.ts"],"sourcesContent":["import type { GenericDataModel, GenericMutationCtx } from \"convex/server\";\nimport * as Context from \"effect/Context\";\n\nexport const MutationCtx = <DataModel extends GenericDataModel>() =>\n  Context.GenericTag<GenericMutationCtx<DataModel>>(\n    \"@confect/server/MutationCtx\",\n  );\n\nexport type MutationCtx<DataModel extends GenericDataModel> = ReturnType<\n  typeof MutationCtx<DataModel>\n>[\"Identifier\"];\n"],"mappings":";;;;;AAGA,MAAa,oBACX,QAAQ,WACN,8BACD"}
+{"version":3,"file":"MutationCtx.js","names":[],"sources":["../src/MutationCtx.ts"],"sourcesContent":["import type { GenericDataModel, GenericMutationCtx } from \"convex/server\";\nimport * as Context from \"effect/Context\";\n\nexport type MutationCtxTag<DataModel extends GenericDataModel> = Context.Tag<\n  GenericMutationCtx<DataModel>,\n  GenericMutationCtx<DataModel>\n>;\n\nexport const MutationCtx = <\n  DataModel extends GenericDataModel,\n>(): MutationCtxTag<DataModel> =>\n  Context.GenericTag<GenericMutationCtx<DataModel>>(\n    \"@confect/server/MutationCtx\",\n  );\n\nexport type MutationCtx<DataModel extends GenericDataModel> =\n  GenericMutationCtx<DataModel>;\n"],"mappings":";;;;;AAQA,MAAa,oBAGX,QAAQ,WACN,8BACD"}

package/dist/OrderedQuery.d.ts

@@ -4,15 +4,15 @@ import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Document from "./Document";
 import type * as TableInfo from "./TableInfo";
-export type OrderedQuery<TableInfo_ extends TableInfo.AnyWithProps, _TableName extends string> = {
-    readonly first: () => Effect.Effect<Option.Option<TableInfo_["document"]>, Document.DocumentDecodeError>;
-    readonly take: (n: number) => Effect.Effect<ReadonlyArray<TableInfo_["document"]>, Document.DocumentDecodeError>;
-    readonly collect: () => Effect.Effect<ReadonlyArray<TableInfo_["document"]>, Document.DocumentDecodeError>;
-    readonly stream: () => Stream.Stream<TableInfo_["document"], Document.DocumentDecodeError>;
+export type OrderedQuery<TableInfo_ extends TableInfo.AnyWithProps, _TableName extends string, Doc = TableInfo_["document"]> = {
+    readonly first: () => Effect.Effect<Option.Option<Doc>, Document.DocumentDecodeError>;
+    readonly take: (n: number) => Effect.Effect<ReadonlyArray<Doc>, Document.DocumentDecodeError>;
+    readonly collect: () => Effect.Effect<ReadonlyArray<Doc>, Document.DocumentDecodeError>;
+    readonly stream: () => Stream.Stream<Doc, Document.DocumentDecodeError>;
     readonly paginate: (options: {
         cursor: string | null;
         numItems: number;
-    }, filter?: (q: FilterBuilder<TableInfo.ConvexTableInfo<TableInfo_>>) => ExpressionOrValue<boolean>) => Effect.Effect<PaginationResult<TableInfo_["document"]>, Document.DocumentDecodeError>;
+    }, filter?: (q: FilterBuilder<TableInfo.ConvexTableInfo<TableInfo_>>) => ExpressionOrValue<boolean>) => Effect.Effect<PaginationResult<Doc>, Document.DocumentDecodeError>;
 };
 export declare const make: <TableInfo_ extends TableInfo.AnyWithProps, TableName extends string>(query: ConvexOrderedQuery<TableInfo.ConvexTableInfo<TableInfo_>>, tableName: TableName, tableSchema: TableInfo.TableSchema<TableInfo_>) => OrderedQuery<TableInfo_, TableName>;
 //# sourceMappingURL=OrderedQuery.d.ts.map

package/dist/OrderedQuery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OrderedQuery.d.ts","sourceRoot":"","sources":["../src/OrderedQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,aAAa,EACb,YAAY,IAAI,kBAAkB,EAClC,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,KAAK,SAAS,MAAM,aAAa,CAAC;AAE9C,MAAM,MAAM,YAAY,CACtB,UAAU,SAAS,SAAS,CAAC,YAAY,EACzC,UAAU,SAAS,MAAM,IACvB;IACF,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC,MAAM,CACjC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,EACrC,QAAQ,CAAC,mBAAmB,CAC7B,CAAC;IACF,QAAQ,CAAC,IAAI,EAAE,CACb,CAAC,EAAE,MAAM,KACN,MAAM,CAAC,MAAM,CAChB,aAAa,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,EACrC,QAAQ,CAAC,mBAAmB,CAC7B,CAAC;IACF,QAAQ,CAAC,OAAO,EAAE,MAAM,MAAM,CAAC,MAAM,CACnC,aAAa,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,EACrC,QAAQ,CAAC,mBAAmB,CAC7B,CAAC;IACF,QAAQ,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,MAAM,CAClC,UAAU,CAAC,UAAU,CAAC,EACtB,QAAQ,CAAC,mBAAmB,CAC7B,CAAC;IACF,QAAQ,CAAC,QAAQ,EAAE,CACjB,OAAO,EAAE;QACP,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,QAAQ,EAAE,MAAM,CAAC;KAClB,EACD,MAAM,CAAC,EAAE,CACP,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,KACpD,iBAAiB,CAAC,OAAO,CAAC,KAC5B,MAAM,CAAC,MAAM,CAChB,gBAAgB,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,EACxC,QAAQ,CAAC,mBAAmB,CAC7B,CAAC;CACH,CAAC;AAEF,eAAO,MAAM,IAAI,GACf,UAAU,SAAS,SAAS,CAAC,YAAY,EACzC,SAAS,SAAS,MAAM,EAExB,OAAO,kBAAkB,CAAC,SAAS,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,EAChE,WAAW,SAAS,EACpB,aAAa,SAAS,CAAC,WAAW,CAAC,UAAU,CAAC,KAC7C,YAAY,CAAC,UAAU,EAAE,SAAS,CAgEpC,CAAC"}
+{"version":3,"file":"OrderedQuery.d.ts","sourceRoot":"","sources":["../src/OrderedQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,aAAa,EACb,YAAY,IAAI,kBAAkB,EAClC,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,KAAK,SAAS,MAAM,aAAa,CAAC;AAE9C,MAAM,MAAM,YAAY,CACtB,UAAU,SAAS,SAAS,CAAC,YAAY,EACzC,UAAU,SAAS,MAAM,EACzB,GAAG,GAAG,UAAU,CAAC,UAAU,CAAC,IAC1B;IACF,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC,MAAM,CACjC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,EAClB,QAAQ,CAAC,mBAAmB,CAC7B,CAAC;IACF,QAAQ,CAAC,IAAI,EAAE,CACb,CAAC,EAAE,MAAM,KACN,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,mBAAmB,CAAC,CAAC;IACrE,QAAQ,CAAC,OAAO,EAAE,MAAM,MAAM,CAAC,MAAM,CACnC,aAAa,CAAC,GAAG,CAAC,EAClB,QAAQ,CAAC,mBAAmB,CAC7B,CAAC;IACF,QAAQ,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,mBAAmB,CAAC,CAAC;IACxE,QAAQ,CAAC,QAAQ,EAAE,CACjB,OAAO,EAAE;QACP,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,QAAQ,EAAE,MAAM,CAAC;KAClB,EACD,MAAM,CAAC,EAAE,CACP,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,KACpD,iBAAiB,CAAC,OAAO,CAAC,KAC5B,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,mBAAmB,CAAC,CAAC;CACzE,CAAC;AAEF,eAAO,MAAM,IAAI,GACf,UAAU,SAAS,SAAS,CAAC,YAAY,EACzC,SAAS,SAAS,MAAM,EAExB,OAAO,kBAAkB,CAAC,SAAS,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,EAChE,WAAW,SAAS,EACpB,aAAa,SAAS,CAAC,WAAW,CAAC,UAAU,CAAC,KAC7C,YAAY,CAAC,UAAU,EAAE,SAAS,CAgEpC,CAAC"}

package/dist/OrderedQuery.js.map

@@ -1 +1 @@
-{"version":3,"file":"OrderedQuery.js","names":["Document.decode"],"sources":["../src/OrderedQuery.ts"],"sourcesContent":["import type {\n  ExpressionOrValue,\n  FilterBuilder,\n  OrderedQuery as ConvexOrderedQuery,\n  PaginationResult,\n} from \"convex/server\";\nimport { identity, pipe } from \"effect/Function\";\nimport type { Option } from \"effect\";\nimport * as Chunk from \"effect/Chunk\";\nimport * as Effect from \"effect/Effect\";\nimport * as Stream from \"effect/Stream\";\nimport * as Document from \"./Document\";\nimport type * as TableInfo from \"./TableInfo\";\n\nexport type OrderedQuery<\n  TableInfo_ extends TableInfo.AnyWithProps,\n  _TableName extends string,\n> = {\n  readonly first: () => Effect.Effect<\n    Option.Option<TableInfo_[\"document\"]>,\n    Document.DocumentDecodeError\n  >;\n  readonly take: (\n    n: number,\n  ) => Effect.Effect<\n    ReadonlyArray<TableInfo_[\"document\"]>,\n    Document.DocumentDecodeError\n  >;\n  readonly collect: () => Effect.Effect<\n    ReadonlyArray<TableInfo_[\"document\"]>,\n    Document.DocumentDecodeError\n  >;\n  readonly stream: () => Stream.Stream<\n    TableInfo_[\"document\"],\n    Document.DocumentDecodeError\n  >;\n  readonly paginate: (\n    options: {\n      cursor: string | null;\n      numItems: number;\n    },\n    filter?: (\n      q: FilterBuilder<TableInfo.ConvexTableInfo<TableInfo_>>,\n    ) => ExpressionOrValue<boolean>,\n  ) => Effect.Effect<\n    PaginationResult<TableInfo_[\"document\"]>,\n    Document.DocumentDecodeError\n  >;\n};\n\nexport const make = <\n  TableInfo_ extends TableInfo.AnyWithProps,\n  TableName extends string,\n>(\n  query: ConvexOrderedQuery<TableInfo.ConvexTableInfo<TableInfo_>>,\n  tableName: TableName,\n  tableSchema: TableInfo.TableSchema<TableInfo_>,\n): OrderedQuery<TableInfo_, TableName> => {\n  type OrderedQueryFunction<\n    FunctionName extends keyof OrderedQuery<TableInfo_, TableName>,\n  > = OrderedQuery<TableInfo_, TableName>[FunctionName];\n\n  const streamEncoded = Stream.fromAsyncIterable(query, identity).pipe(\n    Stream.orDie,\n  );\n\n  const stream: OrderedQueryFunction<\"stream\"> = () =>\n    pipe(\n      streamEncoded,\n      Stream.mapEffect(Document.decode(tableName, tableSchema)),\n    );\n\n  const first: OrderedQueryFunction<\"first\"> = () =>\n    pipe(stream(), Stream.take(1), Stream.runHead);\n\n  const take: OrderedQueryFunction<\"take\"> = (n: number) =>\n    pipe(\n      stream(),\n      Stream.take(n),\n      Stream.runCollect,\n      Effect.map((chunk) => Chunk.toReadonlyArray(chunk)),\n    );\n\n  const collect: OrderedQueryFunction<\"collect\"> = () =>\n    pipe(stream(), Stream.runCollect, Effect.map(Chunk.toReadonlyArray));\n\n  const paginate: OrderedQueryFunction<\"paginate\"> = (options, filter) =>\n    Effect.gen(function* () {\n      const filteredQuery = filter !== undefined ? query.filter(filter) : query;\n\n      const paginationResult = yield* Effect.promise(() =>\n        filteredQuery.paginate(options),\n      );\n\n      const parsedPage = yield* Effect.forEach(\n        paginationResult.page,\n        Document.decode(tableName, tableSchema),\n      );\n\n      return {\n        page: parsedPage,\n        isDone: paginationResult.isDone,\n        continueCursor: paginationResult.continueCursor,\n        /* v8 ignore start */\n        ...(paginationResult.splitCursor\n          ? { splitCursor: paginationResult.splitCursor }\n          : {}),\n        ...(paginationResult.pageStatus\n          ? { pageStatus: paginationResult.pageStatus }\n          : {}),\n        /* v8 ignore stop */\n      };\n    });\n\n  return {\n    first,\n    take,\n    collect,\n    paginate,\n    stream,\n  };\n};\n"],"mappings":";;;;;;;;;AAkDA,MAAa,QAIX,OACA,WACA,gBACwC;CAKxC,MAAM,gBAAgB,OAAO,kBAAkB,OAAO,SAAS,CAAC,KAC9D,OAAO,MACR;CAED,MAAM,eACJ,KACE,eACA,OAAO,UAAUA,OAAgB,WAAW,YAAY,CAAC,CAC1D;CAEH,MAAM,cACJ,KAAK,QAAQ,EAAE,OAAO,KAAK,EAAE,EAAE,OAAO,QAAQ;CAEhD,MAAM,QAAsC,MAC1C,KACE,QAAQ,EACR,OAAO,KAAK,EAAE,EACd,OAAO,YACP,OAAO,KAAK,UAAU,MAAM,gBAAgB,MAAM,CAAC,CACpD;CAEH,MAAM,gBACJ,KAAK,QAAQ,EAAE,OAAO,YAAY,OAAO,IAAI,MAAM,gBAAgB,CAAC;CAEtE,MAAM,YAA8C,SAAS,WAC3D,OAAO,IAAI,aAAa;EACtB,MAAM,gBAAgB,WAAW,SAAY,MAAM,OAAO,OAAO,GAAG;EAEpE,MAAM,mBAAmB,OAAO,OAAO,cACrC,cAAc,SAAS,QAAQ,CAChC;AAOD,SAAO;GACL,MANiB,OAAO,OAAO,QAC/B,iBAAiB,MACjBA,OAAgB,WAAW,YAAY,CACxC;GAIC,QAAQ,iBAAiB;GACzB,gBAAgB,iBAAiB;GAEjC,GAAI,iBAAiB,cACjB,EAAE,aAAa,iBAAiB,aAAa,GAC7C,EAAE;GACN,GAAI,iBAAiB,aACjB,EAAE,YAAY,iBAAiB,YAAY,GAC3C,EAAE;GAEP;GACD;AAEJ,QAAO;EACL;EACA;EACA;EACA;EACA;EACD"}
+{"version":3,"file":"OrderedQuery.js","names":["Document.decode"],"sources":["../src/OrderedQuery.ts"],"sourcesContent":["import type {\n  ExpressionOrValue,\n  FilterBuilder,\n  OrderedQuery as ConvexOrderedQuery,\n  PaginationResult,\n} from \"convex/server\";\nimport { identity, pipe } from \"effect/Function\";\nimport type { Option } from \"effect\";\nimport * as Chunk from \"effect/Chunk\";\nimport * as Effect from \"effect/Effect\";\nimport * as Stream from \"effect/Stream\";\nimport * as Document from \"./Document\";\nimport type * as TableInfo from \"./TableInfo\";\n\nexport type OrderedQuery<\n  TableInfo_ extends TableInfo.AnyWithProps,\n  _TableName extends string,\n  Doc = TableInfo_[\"document\"],\n> = {\n  readonly first: () => Effect.Effect<\n    Option.Option<Doc>,\n    Document.DocumentDecodeError\n  >;\n  readonly take: (\n    n: number,\n  ) => Effect.Effect<ReadonlyArray<Doc>, Document.DocumentDecodeError>;\n  readonly collect: () => Effect.Effect<\n    ReadonlyArray<Doc>,\n    Document.DocumentDecodeError\n  >;\n  readonly stream: () => Stream.Stream<Doc, Document.DocumentDecodeError>;\n  readonly paginate: (\n    options: {\n      cursor: string | null;\n      numItems: number;\n    },\n    filter?: (\n      q: FilterBuilder<TableInfo.ConvexTableInfo<TableInfo_>>,\n    ) => ExpressionOrValue<boolean>,\n  ) => Effect.Effect<PaginationResult<Doc>, Document.DocumentDecodeError>;\n};\n\nexport const make = <\n  TableInfo_ extends TableInfo.AnyWithProps,\n  TableName extends string,\n>(\n  query: ConvexOrderedQuery<TableInfo.ConvexTableInfo<TableInfo_>>,\n  tableName: TableName,\n  tableSchema: TableInfo.TableSchema<TableInfo_>,\n): OrderedQuery<TableInfo_, TableName> => {\n  type OrderedQueryFunction<\n    FunctionName extends keyof OrderedQuery<TableInfo_, TableName>,\n  > = OrderedQuery<TableInfo_, TableName>[FunctionName];\n\n  const streamEncoded = Stream.fromAsyncIterable(query, identity).pipe(\n    Stream.orDie,\n  );\n\n  const stream: OrderedQueryFunction<\"stream\"> = () =>\n    pipe(\n      streamEncoded,\n      Stream.mapEffect(Document.decode(tableName, tableSchema)),\n    );\n\n  const first: OrderedQueryFunction<\"first\"> = () =>\n    pipe(stream(), Stream.take(1), Stream.runHead);\n\n  const take: OrderedQueryFunction<\"take\"> = (n: number) =>\n    pipe(\n      stream(),\n      Stream.take(n),\n      Stream.runCollect,\n      Effect.map((chunk) => Chunk.toReadonlyArray(chunk)),\n    );\n\n  const collect: OrderedQueryFunction<\"collect\"> = () =>\n    pipe(stream(), Stream.runCollect, Effect.map(Chunk.toReadonlyArray));\n\n  const paginate: OrderedQueryFunction<\"paginate\"> = (options, filter) =>\n    Effect.gen(function* () {\n      const filteredQuery = filter !== undefined ? query.filter(filter) : query;\n\n      const paginationResult = yield* Effect.promise(() =>\n        filteredQuery.paginate(options),\n      );\n\n      const parsedPage = yield* Effect.forEach(\n        paginationResult.page,\n        Document.decode(tableName, tableSchema),\n      );\n\n      return {\n        page: parsedPage,\n        isDone: paginationResult.isDone,\n        continueCursor: paginationResult.continueCursor,\n        /* v8 ignore start */\n        ...(paginationResult.splitCursor\n          ? { splitCursor: paginationResult.splitCursor }\n          : {}),\n        ...(paginationResult.pageStatus\n          ? { pageStatus: paginationResult.pageStatus }\n          : {}),\n        /* v8 ignore stop */\n      };\n    });\n\n  return {\n    first,\n    take,\n    collect,\n    paginate,\n    stream,\n  };\n};\n"],"mappings":";;;;;;;;;AA0CA,MAAa,QAIX,OACA,WACA,gBACwC;CAKxC,MAAM,gBAAgB,OAAO,kBAAkB,OAAO,SAAS,CAAC,KAC9D,OAAO,MACR;CAED,MAAM,eACJ,KACE,eACA,OAAO,UAAUA,OAAgB,WAAW,YAAY,CAAC,CAC1D;CAEH,MAAM,cACJ,KAAK,QAAQ,EAAE,OAAO,KAAK,EAAE,EAAE,OAAO,QAAQ;CAEhD,MAAM,QAAsC,MAC1C,KACE,QAAQ,EACR,OAAO,KAAK,EAAE,EACd,OAAO,YACP,OAAO,KAAK,UAAU,MAAM,gBAAgB,MAAM,CAAC,CACpD;CAEH,MAAM,gBACJ,KAAK,QAAQ,EAAE,OAAO,YAAY,OAAO,IAAI,MAAM,gBAAgB,CAAC;CAEtE,MAAM,YAA8C,SAAS,WAC3D,OAAO,IAAI,aAAa;EACtB,MAAM,gBAAgB,WAAW,SAAY,MAAM,OAAO,OAAO,GAAG;EAEpE,MAAM,mBAAmB,OAAO,OAAO,cACrC,cAAc,SAAS,QAAQ,CAChC;AAOD,SAAO;GACL,MANiB,OAAO,OAAO,QAC/B,iBAAiB,MACjBA,OAAgB,WAAW,YAAY,CACxC;GAIC,QAAQ,iBAAiB;GACzB,gBAAgB,iBAAiB;GAEjC,GAAI,iBAAiB,cACjB,EAAE,aAAa,iBAAiB,aAAa,GAC7C,EAAE;GACN,GAAI,iBAAiB,aACjB,EAAE,YAAY,iBAAiB,YAAY,GAC3C,EAAE;GAEP;GACD;AAEJ,QAAO;EACL;EACA;EACA;EACA;EACA;EACD"}

package/dist/QueryCtx.d.ts

@@ -1,5 +1,6 @@
 import type { GenericDataModel, GenericQueryCtx } from "convex/server";
 import * as Context from "effect/Context";
-export declare const QueryCtx: <DataModel extends GenericDataModel>() => Context.Tag<GenericQueryCtx<DataModel>, GenericQueryCtx<DataModel>>;
-export type QueryCtx<DataModel extends GenericDataModel> = ReturnType<typeof QueryCtx<DataModel>>["Identifier"];
+export type QueryCtxTag<DataModel extends GenericDataModel> = Context.Tag<GenericQueryCtx<DataModel>, GenericQueryCtx<DataModel>>;
+export declare const QueryCtx: <DataModel extends GenericDataModel>() => QueryCtxTag<DataModel>;
+export type QueryCtx<DataModel extends GenericDataModel> = GenericQueryCtx<DataModel>;
 //# sourceMappingURL=QueryCtx.d.ts.map

package/dist/QueryCtx.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryCtx.d.ts","sourceRoot":"","sources":["../src/QueryCtx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACvE,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,eAAO,MAAM,QAAQ,GAAI,SAAS,SAAS,gBAAgB,0EACiB,CAAC;AAE7E,MAAM,MAAM,QAAQ,CAAC,SAAS,SAAS,gBAAgB,IAAI,UAAU,CACnE,OAAO,QAAQ,CAAC,SAAS,CAAC,CAC3B,CAAC,YAAY,CAAC,CAAC"}
+{"version":3,"file":"QueryCtx.d.ts","sourceRoot":"","sources":["../src/QueryCtx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACvE,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,MAAM,MAAM,WAAW,CAAC,SAAS,SAAS,gBAAgB,IAAI,OAAO,CAAC,GAAG,CACvE,eAAe,CAAC,SAAS,CAAC,EAC1B,eAAe,CAAC,SAAS,CAAC,CAC3B,CAAC;AAEF,eAAO,MAAM,QAAQ,GACnB,SAAS,SAAS,gBAAgB,OAC/B,WAAW,CAAC,SAAS,CACkD,CAAC;AAE7E,MAAM,MAAM,QAAQ,CAAC,SAAS,SAAS,gBAAgB,IACrD,eAAe,CAAC,SAAS,CAAC,CAAC"}

package/dist/QueryCtx.js.map

@@ -1 +1 @@
-{"version":3,"file":"QueryCtx.js","names":[],"sources":["../src/QueryCtx.ts"],"sourcesContent":["import type { GenericDataModel, GenericQueryCtx } from \"convex/server\";\nimport * as Context from \"effect/Context\";\n\nexport const QueryCtx = <DataModel extends GenericDataModel>() =>\n  Context.GenericTag<GenericQueryCtx<DataModel>>(\"@confect/server/QueryCtx\");\n\nexport type QueryCtx<DataModel extends GenericDataModel> = ReturnType<\n  typeof QueryCtx<DataModel>\n>[\"Identifier\"];\n"],"mappings":";;;;;AAGA,MAAa,iBACX,QAAQ,WAAuC,2BAA2B"}
+{"version":3,"file":"QueryCtx.js","names":[],"sources":["../src/QueryCtx.ts"],"sourcesContent":["import type { GenericDataModel, GenericQueryCtx } from \"convex/server\";\nimport * as Context from \"effect/Context\";\n\nexport type QueryCtxTag<DataModel extends GenericDataModel> = Context.Tag<\n  GenericQueryCtx<DataModel>,\n  GenericQueryCtx<DataModel>\n>;\n\nexport const QueryCtx = <\n  DataModel extends GenericDataModel,\n>(): QueryCtxTag<DataModel> =>\n  Context.GenericTag<GenericQueryCtx<DataModel>>(\"@confect/server/QueryCtx\");\n\nexport type QueryCtx<DataModel extends GenericDataModel> =\n  GenericQueryCtx<DataModel>;\n"],"mappings":";;;;;AAQA,MAAa,iBAGX,QAAQ,WAAuC,2BAA2B"}

package/dist/QueryInitializer.d.ts

@@ -8,17 +8,17 @@ import * as Document from "./Document";
 import * as OrderedQuery from "./OrderedQuery";
 import type * as Table from "./Table";
 import type * as TableInfo from "./TableInfo";
-type QueryInitializer<DataModel_ extends DataModel.AnyWithProps, TableName extends DataModel.TableNames<DataModel_>, _ConvexTableInfo extends GenericTableInfo, _TableInfo extends TableInfo.AnyWithProps> = {
+export interface QueryInitializer<DataModel_ extends DataModel.AnyWithProps, TableName extends DataModel.TableNames<DataModel_>, ConvexTableInfo_ extends GenericTableInfo, TableInfo_ extends TableInfo.AnyWithProps, Doc = TableInfo_["document"]> {
     readonly get: {
-        (id: GenericId<TableName>): Effect.Effect<_TableInfo["document"], Document.DocumentDecodeError | GetByIdFailure>;
-        <IndexName extends keyof Indexes<_ConvexTableInfo>>(indexName: IndexName, ...indexFieldValues: IndexFieldTypesForEq<DataModel.ToConvex<DataModel_>, TableName, Indexes<_ConvexTableInfo>[IndexName]>): Effect.Effect<_TableInfo["document"], Document.DocumentDecodeError | GetByIndexFailure>;
+        (id: GenericId<TableName>): Effect.Effect<Doc, Document.DocumentDecodeError | GetByIdFailure>;
+        <IndexName extends keyof Indexes<ConvexTableInfo_>>(indexName: IndexName, ...indexFieldValues: IndexFieldTypesForEq<DataModel.ToConvex<DataModel_>, TableName, Indexes<ConvexTableInfo_>[IndexName]>): Effect.Effect<Doc, Document.DocumentDecodeError | GetByIndexFailure>;
     };
     readonly index: {
-        <IndexName extends keyof Indexes<_ConvexTableInfo>>(indexName: IndexName, indexRange?: (q: IndexRangeBuilder<_TableInfo["convexDocument"], NamedIndex<_ConvexTableInfo, IndexName>>) => IndexRange, order?: "asc" | "desc"): OrderedQuery.OrderedQuery<_TableInfo, TableName>;
-        <IndexName extends keyof Indexes<_ConvexTableInfo>>(indexName: IndexName, order?: "asc" | "desc"): OrderedQuery.OrderedQuery<_TableInfo, TableName>;
+        <IndexName extends keyof Indexes<ConvexTableInfo_>>(indexName: IndexName, indexRange?: (q: IndexRangeBuilder<TableInfo_["convexDocument"], NamedIndex<ConvexTableInfo_, IndexName>>) => IndexRange, order?: "asc" | "desc"): OrderedQuery.OrderedQuery<TableInfo_, TableName, Doc>;
+        <IndexName extends keyof Indexes<ConvexTableInfo_>>(indexName: IndexName, order?: "asc" | "desc"): OrderedQuery.OrderedQuery<TableInfo_, TableName, Doc>;
     };
-    readonly search: <IndexName extends keyof SearchIndexes<_ConvexTableInfo>>(indexName: IndexName, searchFilter: (q: SearchFilterBuilder<DocumentByInfo<_ConvexTableInfo>, NamedSearchIndex<_ConvexTableInfo, IndexName>>) => SearchFilter) => OrderedQuery.OrderedQuery<_TableInfo, TableName>;
-};
+    readonly search: <IndexName extends keyof SearchIndexes<ConvexTableInfo_>>(indexName: IndexName, searchFilter: (q: SearchFilterBuilder<DocumentByInfo<ConvexTableInfo_>, NamedSearchIndex<ConvexTableInfo_, IndexName>>) => SearchFilter) => OrderedQuery.OrderedQuery<TableInfo_, TableName, Doc>;
+}
 export declare const make: <Tables extends Table.AnyWithProps, TableName extends Table.Name<Tables>>(tableName: TableName, convexDatabaseReader: BaseDatabaseReader<DataModel.ToConvex<DataModel.FromTables<Tables>>>, table: Table.WithName<Tables, TableName>) => QueryInitializer<DataModel.DataModel<Tables>, TableName, DataModel.TableInfoWithName<DataModel.DataModel<Tables>, TableName>, DataModel.TableInfoWithName_<DataModel.DataModel<Tables>, TableName>>;
 export declare const getById: <Tables extends Table.AnyWithProps, TableName extends Table.Name<Tables>>(tableName: TableName, convexDatabaseReader: BaseDatabaseReader<DataModel.ToConvex<DataModel.FromTables<Tables>>>, table: Table.WithName<Tables, TableName>) => (id: GenericId<TableName>) => Effect.Effect<any, Document.DocumentDecodeError | GetByIdFailure, never>;
 declare const GetByIdFailure_base: Schema.TaggedErrorClass<GetByIdFailure, "GetByIdFailure", {

package/dist/QueryInitializer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryInitializer.d.ts","sourceRoot":"","sources":["../src/QueryInitializer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,cAAc,EAEd,gBAAgB,EAChB,OAAO,EACP,UAAU,EACV,iBAAiB,EACjB,UAAU,EACV,gBAAgB,EAGhB,YAAY,EACZ,mBAAmB,EACnB,aAAa,EACd,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG/C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,EACV,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,KAAK,SAAS,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,KAAK,KAAK,MAAM,SAAS,CAAC;AACtC,OAAO,KAAK,KAAK,SAAS,MAAM,aAAa,CAAC;AAE9C,KAAK,gBAAgB,CACnB,UAAU,SAAS,SAAS,CAAC,YAAY,EACzC,SAAS,SAAS,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC,EAClD,gBAAgB,SAAS,gBAAgB,EACzC,UAAU,SAAS,SAAS,CAAC,YAAY,IACvC;IACF,QAAQ,CAAC,GAAG,EAAE;QACZ,CACE,EAAE,EAAE,SAAS,CAAC,SAAS,CAAC,GACvB,MAAM,CAAC,MAAM,CACd,UAAU,CAAC,UAAU,CAAC,EACtB,QAAQ,CAAC,mBAAmB,GAAG,cAAc,CAC9C,CAAC;QACF,CAAC,SAAS,SAAS,MAAM,OAAO,CAAC,gBAAgB,CAAC,EAChD,SAAS,EAAE,SAAS,EACpB,GAAG,gBAAgB,EAAE,oBAAoB,CACvC,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC,EAC9B,SAAS,EACT,OAAO,CAAC,gBAAgB,CAAC,CAAC,SAAS,CAAC,CACrC,GACA,MAAM,CAAC,MAAM,CACd,UAAU,CAAC,UAAU,CAAC,EACtB,QAAQ,CAAC,mBAAmB,GAAG,iBAAiB,CACjD,CAAC;KACH,CAAC;IACF,QAAQ,CAAC,KAAK,EAAE;QACd,CAAC,SAAS,SAAS,MAAM,OAAO,CAAC,gBAAgB,CAAC,EAChD,SAAS,EAAE,SAAS,EACpB,UAAU,CAAC,EAAE,CACX,CAAC,EAAE,iBAAiB,CAClB,UAAU,CAAC,gBAAgB,CAAC,EAC5B,UAAU,CAAC,gBAAgB,EAAE,SAAS,CAAC,CACxC,KACE,UAAU,EACf,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,GACrB,YAAY,CAAC,YAAY,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QACpD,CAAC,SAAS,SAAS,MAAM,OAAO,CAAC,gBAAgB,CAAC,EAChD,SAAS,EAAE,SAAS,EACpB,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,GACrB,YAAY,CAAC,YAAY,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;KACrD,CAAC;IACF,QAAQ,CAAC,MAAM,EAAE,CAAC,SAAS,SAAS,MAAM,aAAa,CAAC,gBAAgB,CAAC,EACvE,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,CACZ,CAAC,EAAE,mBAAmB,CACpB,cAAc,CAAC,gBAAgB,CAAC,EAChC,gBAAgB,CAAC,gBAAgB,EAAE,SAAS,CAAC,CAC9C,KACE,YAAY,KACd,YAAY,CAAC,YAAY,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;CACvD,CAAC;AAEF,eAAO,MAAM,IAAI,GACf,MAAM,SAAS,KAAK,CAAC,YAAY,EACjC,SAAS,SAAS,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,EAEpC,WAAW,SAAS,EACpB,sBAAsB,kBAAkB,CACtC,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CACjD,EACD,OAAO,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,KACvC,gBAAgB,CACjB,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,EAC3B,SAAS,EACT,SAAS,CAAC,iBAAiB,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,EACnE,SAAS,CAAC,kBAAkB,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,CAiLrE,CAAC;AAEF,eAAO,MAAM,OAAO,GACjB,MAAM,SAAS,KAAK,CAAC,YAAY,EAAE,SAAS,SAAS,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,EACtE,WAAW,SAAS,EACpB,sBAAsB,kBAAkB,CACtC,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CACjD,EACD,OAAO,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,MAEzC,IAAI,SAAS,CAAC,SAAS,CAAC,6EAOtB,CAAC;;;;;;;AAEN,qBAAa,cAAe,SAAQ,mBAMnC;IACC,IAAa,OAAO,IAAI,MAAM,CAM7B;CACF;;;;;;;;AAED,qBAAa,iBAAkB,SAAQ,sBAOtC;IACC,IAAa,OAAO,IAAI,MAAM,CAK7B;CACF"}
+{"version":3,"file":"QueryInitializer.d.ts","sourceRoot":"","sources":["../src/QueryInitializer.ts"],"names":[],"mappings":"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"}

package/dist/QueryInitializer.js.map

@@ -1 +1 @@
-{"version":3,"file":"QueryInitializer.js","names":["Document.decode","OrderedQuery.make","Document.documentErrorMessage"],"sources":["../src/QueryInitializer.ts"],"sourcesContent":["import type {\n  OrderedQuery as ConvexOrderedQuery,\n  QueryInitializer as ConvexQueryInitializer,\n  DocumentByInfo,\n  GenericTableIndexes,\n  GenericTableInfo,\n  Indexes,\n  IndexRange,\n  IndexRangeBuilder,\n  NamedIndex,\n  NamedSearchIndex,\n  NamedTableInfo,\n  Query,\n  SearchFilter,\n  SearchFilterBuilder,\n  SearchIndexes,\n} from \"convex/server\";\nimport type { GenericId } from \"convex/values\";\nimport { pipe } from \"effect/Function\";\nimport * as Array from \"effect/Array\";\nimport * as Effect from \"effect/Effect\";\nimport * as Either from \"effect/Either\";\nimport * as Schema from \"effect/Schema\";\nimport type {\n  BaseDatabaseReader,\n  IndexFieldTypesForEq,\n} from \"@confect/core/Types\";\nimport type * as DataModel from \"./DataModel\";\nimport * as Document from \"./Document\";\nimport * as OrderedQuery from \"./OrderedQuery\";\nimport type * as Table from \"./Table\";\nimport type * as TableInfo from \"./TableInfo\";\n\ntype QueryInitializer<\n  DataModel_ extends DataModel.AnyWithProps,\n  TableName extends DataModel.TableNames<DataModel_>,\n  _ConvexTableInfo extends GenericTableInfo,\n  _TableInfo extends TableInfo.AnyWithProps,\n> = {\n  readonly get: {\n    (\n      id: GenericId<TableName>,\n    ): Effect.Effect<\n      _TableInfo[\"document\"],\n      Document.DocumentDecodeError | GetByIdFailure\n    >;\n    <IndexName extends keyof Indexes<_ConvexTableInfo>>(\n      indexName: IndexName,\n      ...indexFieldValues: IndexFieldTypesForEq<\n        DataModel.ToConvex<DataModel_>,\n        TableName,\n        Indexes<_ConvexTableInfo>[IndexName]\n      >\n    ): Effect.Effect<\n      _TableInfo[\"document\"],\n      Document.DocumentDecodeError | GetByIndexFailure\n    >;\n  };\n  readonly index: {\n    <IndexName extends keyof Indexes<_ConvexTableInfo>>(\n      indexName: IndexName,\n      indexRange?: (\n        q: IndexRangeBuilder<\n          _TableInfo[\"convexDocument\"],\n          NamedIndex<_ConvexTableInfo, IndexName>\n        >,\n      ) => IndexRange,\n      order?: \"asc\" | \"desc\",\n    ): OrderedQuery.OrderedQuery<_TableInfo, TableName>;\n    <IndexName extends keyof Indexes<_ConvexTableInfo>>(\n      indexName: IndexName,\n      order?: \"asc\" | \"desc\",\n    ): OrderedQuery.OrderedQuery<_TableInfo, TableName>;\n  };\n  readonly search: <IndexName extends keyof SearchIndexes<_ConvexTableInfo>>(\n    indexName: IndexName,\n    searchFilter: (\n      q: SearchFilterBuilder<\n        DocumentByInfo<_ConvexTableInfo>,\n        NamedSearchIndex<_ConvexTableInfo, IndexName>\n      >,\n    ) => SearchFilter,\n  ) => OrderedQuery.OrderedQuery<_TableInfo, TableName>;\n};\n\nexport const make = <\n  Tables extends Table.AnyWithProps,\n  TableName extends Table.Name<Tables>,\n>(\n  tableName: TableName,\n  convexDatabaseReader: BaseDatabaseReader<\n    DataModel.ToConvex<DataModel.FromTables<Tables>>\n  >,\n  table: Table.WithName<Tables, TableName>,\n): QueryInitializer<\n  DataModel.DataModel<Tables>,\n  TableName,\n  DataModel.TableInfoWithName<DataModel.DataModel<Tables>, TableName>,\n  DataModel.TableInfoWithName_<DataModel.DataModel<Tables>, TableName>\n> => {\n  type DataModel_ = DataModel.DataModel<Tables>;\n  type ConvexDataModel_ = DataModel.ToConvex<DataModel_>;\n  type ThisQueryInitializer = QueryInitializer<\n    DataModel_,\n    TableName,\n    DataModel.TableInfoWithName<DataModel_, TableName>,\n    DataModel.TableInfoWithName_<DataModel_, TableName>\n  >;\n  type QueryInitializerFunction<\n    FunctionName extends keyof ThisQueryInitializer,\n  > = ThisQueryInitializer[FunctionName];\n\n  const getByIndex = <\n    IndexName extends keyof Indexes<\n      DataModel.TableInfoWithName<DataModel_, TableName>\n    >,\n  >(\n    indexName: IndexName,\n    indexFieldValues: IndexFieldTypesForEq<\n      DataModel.ToConvex<DataModel_>,\n      TableName,\n      Indexes<DataModel.TableInfoWithName<DataModel_, TableName>>[IndexName]\n    >,\n  ): Effect.Effect<\n    DataModel.DocumentWithName<DataModel_, TableName>,\n    Document.DocumentDecodeError | GetByIndexFailure\n  > => {\n    const indexFields: GenericTableIndexes[keyof GenericTableIndexes] = (\n      table.indexes as GenericTableIndexes\n    )[indexName as keyof GenericTableIndexes]!;\n\n    return pipe(\n      Effect.promise(() =>\n        convexDatabaseReader\n          .query(tableName)\n          .withIndex(indexName, (q) =>\n            Array.reduce(\n              indexFieldValues,\n              q,\n              (q_, v, i) => q_.eq(indexFields[i] as any, v as any) as any,\n            ),\n          )\n          .unique(),\n      ),\n      Effect.andThen(\n        Either.fromNullable(\n          () =>\n            new GetByIndexFailure({\n              tableName,\n              indexName: indexName as string,\n              indexFieldValues,\n            }),\n        ),\n      ),\n      Effect.andThen(Document.decode(tableName, table.Fields)),\n    );\n  };\n\n  const get: QueryInitializerFunction<\"get\"> = ((\n    ...args: Parameters<QueryInitializerFunction<\"get\">>\n  ) => {\n    if (args.length === 1) {\n      const id = args[0] as GenericId<TableName>;\n\n      return getById(tableName, convexDatabaseReader, table)(id);\n    } else {\n      const [indexName, ...indexFieldValues] = args;\n\n      return getByIndex(\n        indexName as keyof Indexes<\n          DataModel.TableInfoWithName<DataModel_, TableName>\n        >,\n        indexFieldValues,\n      );\n    }\n  }) as QueryInitializerFunction<\"get\">;\n\n  const index: QueryInitializerFunction<\"index\"> = <\n    IndexName extends keyof Indexes<\n      DataModel.TableInfoWithName<DataModel_, TableName>\n    >,\n  >(\n    indexName: IndexName,\n    indexRangeOrOrder?:\n      | ((\n          q: IndexRangeBuilder<\n            DataModel.TableInfoWithName_<\n              DataModel_,\n              TableName\n            >[\"convexDocument\"],\n            NamedIndex<\n              DataModel.TableInfoWithName<DataModel_, TableName>,\n              IndexName\n            >\n          >,\n        ) => IndexRange)\n      | \"asc\"\n      | \"desc\",\n    order?: \"asc\" | \"desc\",\n  ) => {\n    const {\n      applyWithIndex,\n      applyOrder,\n    }: {\n      applyWithIndex: (\n        queryInitializer: ConvexQueryInitializer<\n          NamedTableInfo<ConvexDataModel_, TableName>\n        >,\n      ) => Query<NamedTableInfo<ConvexDataModel_, TableName>>;\n      applyOrder: (\n        query: Query<NamedTableInfo<ConvexDataModel_, TableName>>,\n      ) => ConvexOrderedQuery<NamedTableInfo<ConvexDataModel_, TableName>>;\n    } =\n      indexRangeOrOrder === undefined\n        ? {\n            applyWithIndex: (q) => q.withIndex(indexName),\n            applyOrder: (q) => q.order(\"asc\"),\n          }\n        : typeof indexRangeOrOrder === \"function\"\n          ? order === undefined\n            ? {\n                applyWithIndex: (q) =>\n                  q.withIndex(indexName, indexRangeOrOrder),\n                applyOrder: (q) => q.order(\"asc\"),\n              }\n            : {\n                applyWithIndex: (q) =>\n                  q.withIndex(indexName, indexRangeOrOrder),\n                applyOrder: (q) => q.order(order),\n              }\n          : {\n              applyWithIndex: (q) => q.withIndex(indexName),\n              applyOrder: (q) => q.order(indexRangeOrOrder),\n            };\n\n    const orderedQuery = pipe(\n      convexDatabaseReader.query(tableName),\n      applyWithIndex,\n      applyOrder,\n    );\n\n    return OrderedQuery.make<\n      DataModel.TableInfoWithName_<DataModel_, TableName>,\n      TableName\n    >(\n      orderedQuery,\n      tableName,\n      table.Fields as TableInfo.TableSchema<\n        DataModel.TableInfoWithName_<DataModel_, TableName>\n      >,\n    );\n  };\n\n  const search: QueryInitializerFunction<\"search\"> = (\n    indexName,\n    searchFilter,\n  ) =>\n    OrderedQuery.make<\n      DataModel.TableInfoWithName_<DataModel_, TableName>,\n      TableName\n    >(\n      convexDatabaseReader\n        .query(tableName)\n        .withSearchIndex(indexName, searchFilter),\n      tableName,\n      table.Fields as TableInfo.TableSchema<\n        DataModel.TableInfoWithName_<DataModel_, TableName>\n      >,\n    );\n\n  return {\n    get,\n    index,\n    search,\n  };\n};\n\nexport const getById =\n  <Tables extends Table.AnyWithProps, TableName extends Table.Name<Tables>>(\n    tableName: TableName,\n    convexDatabaseReader: BaseDatabaseReader<\n      DataModel.ToConvex<DataModel.FromTables<Tables>>\n    >,\n    table: Table.WithName<Tables, TableName>,\n  ) =>\n  (id: GenericId<TableName>) =>\n    pipe(\n      Effect.promise(() => convexDatabaseReader.get(id)),\n      Effect.andThen(\n        Either.fromNullable(() => new GetByIdFailure({ tableName, id })),\n      ),\n      Effect.andThen(Document.decode(tableName, table.Fields)),\n    );\n\nexport class GetByIdFailure extends Schema.TaggedError<GetByIdFailure>()(\n  \"GetByIdFailure\",\n  {\n    id: Schema.String,\n    tableName: Schema.String,\n  },\n) {\n  override get message(): string {\n    return Document.documentErrorMessage({\n      id: this.id,\n      tableName: this.tableName,\n      message: \"not found\",\n    });\n  }\n}\n\nexport class GetByIndexFailure extends Schema.TaggedError<GetByIndexFailure>()(\n  \"GetByIndexFailure\",\n  {\n    tableName: Schema.String,\n    indexName: Schema.String,\n    indexFieldValues: Schema.Array(Schema.Unknown),\n  },\n) {\n  override get message(): string {\n    return `No documents found in table '${this.tableName}' with index '${this.indexName}' and field values '${JSON.stringify(\n      this.indexFieldValues,\n      (_key, value) => (typeof value === \"bigint\" ? value.toString() : value),\n    )}'`;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAqFA,MAAa,QAIX,WACA,sBAGA,UAMG;CAaH,MAAM,cAKJ,WACA,qBAQG;EACH,MAAM,cACJ,MAAM,QACN;AAEF,SAAO,KACL,OAAO,cACL,qBACG,MAAM,UAAU,CAChB,UAAU,YAAY,MACrB,MAAM,OACJ,kBACA,IACC,IAAI,GAAG,MAAM,GAAG,GAAG,YAAY,IAAW,EAAS,CACrD,CACF,CACA,QAAQ,CACZ,EACD,OAAO,QACL,OAAO,mBAEH,IAAI,kBAAkB;GACpB;GACW;GACX;GACD,CAAC,CACL,CACF,EACD,OAAO,QAAQA,OAAgB,WAAW,MAAM,OAAO,CAAC,CACzD;;CAGH,MAAM,QACJ,GAAG,SACA;AACH,MAAI,KAAK,WAAW,GAAG;GACrB,MAAM,KAAK,KAAK;AAEhB,UAAO,QAAQ,WAAW,sBAAsB,MAAM,CAAC,GAAG;SACrD;GACL,MAAM,CAAC,WAAW,GAAG,oBAAoB;AAEzC,UAAO,WACL,WAGA,iBACD;;;CAIL,MAAM,SAKJ,WACA,mBAeA,UACG;EACH,MAAM,EACJ,gBACA,eAWA,sBAAsB,SAClB;GACE,iBAAiB,MAAM,EAAE,UAAU,UAAU;GAC7C,aAAa,MAAM,EAAE,MAAM,MAAM;GAClC,GACD,OAAO,sBAAsB,aAC3B,UAAU,SACR;GACE,iBAAiB,MACf,EAAE,UAAU,WAAW,kBAAkB;GAC3C,aAAa,MAAM,EAAE,MAAM,MAAM;GAClC,GACD;GACE,iBAAiB,MACf,EAAE,UAAU,WAAW,kBAAkB;GAC3C,aAAa,MAAM,EAAE,MAAM,MAAM;GAClC,GACH;GACE,iBAAiB,MAAM,EAAE,UAAU,UAAU;GAC7C,aAAa,MAAM,EAAE,MAAM,kBAAkB;GAC9C;EAET,MAAM,eAAe,KACnB,qBAAqB,MAAM,UAAU,EACrC,gBACA,WACD;AAED,SAAOC,OAIL,cACA,WACA,MAAM,OAGP;;CAGH,MAAM,UACJ,WACA,iBAEAA,OAIE,qBACG,MAAM,UAAU,CAChB,gBAAgB,WAAW,aAAa,EAC3C,WACA,MAAM,OAGP;AAEH,QAAO;EACL;EACA;EACA;EACD;;AAGH,MAAa,WAET,WACA,sBAGA,WAED,OACC,KACE,OAAO,cAAc,qBAAqB,IAAI,GAAG,CAAC,EAClD,OAAO,QACL,OAAO,mBAAmB,IAAI,eAAe;CAAE;CAAW;CAAI,CAAC,CAAC,CACjE,EACD,OAAO,QAAQD,OAAgB,WAAW,MAAM,OAAO,CAAC,CACzD;AAEL,IAAa,iBAAb,cAAoC,OAAO,aAA6B,CACtE,kBACA;CACE,IAAI,OAAO;CACX,WAAW,OAAO;CACnB,CACF,CAAC;CACA,IAAa,UAAkB;AAC7B,SAAOE,qBAA8B;GACnC,IAAI,KAAK;GACT,WAAW,KAAK;GAChB,SAAS;GACV,CAAC;;;AAIN,IAAa,oBAAb,cAAuC,OAAO,aAAgC,CAC5E,qBACA;CACE,WAAW,OAAO;CAClB,WAAW,OAAO;CAClB,kBAAkB,OAAO,MAAM,OAAO,QAAQ;CAC/C,CACF,CAAC;CACA,IAAa,UAAkB;AAC7B,SAAO,gCAAgC,KAAK,UAAU,gBAAgB,KAAK,UAAU,sBAAsB,KAAK,UAC9G,KAAK,mBACJ,MAAM,UAAW,OAAO,UAAU,WAAW,MAAM,UAAU,GAAG,MAClE,CAAC"}
+{"version":3,"file":"QueryInitializer.js","names":["Document.decode","OrderedQuery.make","Document.documentErrorMessage"],"sources":["../src/QueryInitializer.ts"],"sourcesContent":["import type {\n  OrderedQuery as ConvexOrderedQuery,\n  QueryInitializer as ConvexQueryInitializer,\n  DocumentByInfo,\n  GenericTableIndexes,\n  GenericTableInfo,\n  Indexes,\n  IndexRange,\n  IndexRangeBuilder,\n  NamedIndex,\n  NamedSearchIndex,\n  NamedTableInfo,\n  Query,\n  SearchFilter,\n  SearchFilterBuilder,\n  SearchIndexes,\n} from \"convex/server\";\nimport type { GenericId } from \"convex/values\";\nimport { pipe } from \"effect/Function\";\nimport * as Array from \"effect/Array\";\nimport * as Effect from \"effect/Effect\";\nimport * as Either from \"effect/Either\";\nimport * as Schema from \"effect/Schema\";\nimport type {\n  BaseDatabaseReader,\n  IndexFieldTypesForEq,\n} from \"@confect/core/Types\";\nimport type * as DataModel from \"./DataModel\";\nimport * as Document from \"./Document\";\nimport * as OrderedQuery from \"./OrderedQuery\";\nimport type * as Table from \"./Table\";\nimport type * as TableInfo from \"./TableInfo\";\n\nexport interface QueryInitializer<\n  DataModel_ extends DataModel.AnyWithProps,\n  TableName extends DataModel.TableNames<DataModel_>,\n  ConvexTableInfo_ extends GenericTableInfo,\n  TableInfo_ extends TableInfo.AnyWithProps,\n  Doc = TableInfo_[\"document\"],\n> {\n  readonly get: {\n    (\n      id: GenericId<TableName>,\n    ): Effect.Effect<Doc, Document.DocumentDecodeError | GetByIdFailure>;\n    <IndexName extends keyof Indexes<ConvexTableInfo_>>(\n      indexName: IndexName,\n      ...indexFieldValues: IndexFieldTypesForEq<\n        DataModel.ToConvex<DataModel_>,\n        TableName,\n        Indexes<ConvexTableInfo_>[IndexName]\n      >\n    ): Effect.Effect<Doc, Document.DocumentDecodeError | GetByIndexFailure>;\n  };\n  readonly index: {\n    <IndexName extends keyof Indexes<ConvexTableInfo_>>(\n      indexName: IndexName,\n      indexRange?: (\n        q: IndexRangeBuilder<\n          TableInfo_[\"convexDocument\"],\n          NamedIndex<ConvexTableInfo_, IndexName>\n        >,\n      ) => IndexRange,\n      order?: \"asc\" | \"desc\",\n    ): OrderedQuery.OrderedQuery<TableInfo_, TableName, Doc>;\n    <IndexName extends keyof Indexes<ConvexTableInfo_>>(\n      indexName: IndexName,\n      order?: \"asc\" | \"desc\",\n    ): OrderedQuery.OrderedQuery<TableInfo_, TableName, Doc>;\n  };\n  readonly search: <IndexName extends keyof SearchIndexes<ConvexTableInfo_>>(\n    indexName: IndexName,\n    searchFilter: (\n      q: SearchFilterBuilder<\n        DocumentByInfo<ConvexTableInfo_>,\n        NamedSearchIndex<ConvexTableInfo_, IndexName>\n      >,\n    ) => SearchFilter,\n  ) => OrderedQuery.OrderedQuery<TableInfo_, TableName, Doc>;\n}\n\nexport const make = <\n  Tables extends Table.AnyWithProps,\n  TableName extends Table.Name<Tables>,\n>(\n  tableName: TableName,\n  convexDatabaseReader: BaseDatabaseReader<\n    DataModel.ToConvex<DataModel.FromTables<Tables>>\n  >,\n  table: Table.WithName<Tables, TableName>,\n): QueryInitializer<\n  DataModel.DataModel<Tables>,\n  TableName,\n  DataModel.TableInfoWithName<DataModel.DataModel<Tables>, TableName>,\n  DataModel.TableInfoWithName_<DataModel.DataModel<Tables>, TableName>\n> => {\n  type DataModel_ = DataModel.DataModel<Tables>;\n  type ConvexDataModel_ = DataModel.ToConvex<DataModel_>;\n  type ThisQueryInitializer = QueryInitializer<\n    DataModel_,\n    TableName,\n    DataModel.TableInfoWithName<DataModel_, TableName>,\n    DataModel.TableInfoWithName_<DataModel_, TableName>\n  >;\n  type QueryInitializerFunction<\n    FunctionName extends keyof ThisQueryInitializer,\n  > = ThisQueryInitializer[FunctionName];\n\n  const getByIndex = <\n    IndexName extends keyof Indexes<\n      DataModel.TableInfoWithName<DataModel_, TableName>\n    >,\n  >(\n    indexName: IndexName,\n    indexFieldValues: IndexFieldTypesForEq<\n      DataModel.ToConvex<DataModel_>,\n      TableName,\n      Indexes<DataModel.TableInfoWithName<DataModel_, TableName>>[IndexName]\n    >,\n  ): Effect.Effect<\n    DataModel.DocumentWithName<DataModel_, TableName>,\n    Document.DocumentDecodeError | GetByIndexFailure\n  > => {\n    const indexFields: GenericTableIndexes[keyof GenericTableIndexes] = (\n      table.indexes as GenericTableIndexes\n    )[indexName as keyof GenericTableIndexes]!;\n\n    return pipe(\n      Effect.promise(() =>\n        convexDatabaseReader\n          .query(tableName)\n          .withIndex(indexName, (q) =>\n            Array.reduce(\n              indexFieldValues,\n              q,\n              (q_, v, i) => q_.eq(indexFields[i] as any, v as any) as any,\n            ),\n          )\n          .unique(),\n      ),\n      Effect.andThen(\n        Either.fromNullable(\n          () =>\n            new GetByIndexFailure({\n              tableName,\n              indexName: indexName as string,\n              indexFieldValues,\n            }),\n        ),\n      ),\n      Effect.andThen(Document.decode(tableName, table.Fields)),\n    );\n  };\n\n  const get: QueryInitializerFunction<\"get\"> = ((\n    ...args: Parameters<QueryInitializerFunction<\"get\">>\n  ) => {\n    if (args.length === 1) {\n      const id = args[0] as GenericId<TableName>;\n\n      return getById(tableName, convexDatabaseReader, table)(id);\n    } else {\n      const [indexName, ...indexFieldValues] = args;\n\n      return getByIndex(\n        indexName as keyof Indexes<\n          DataModel.TableInfoWithName<DataModel_, TableName>\n        >,\n        indexFieldValues,\n      );\n    }\n  }) as QueryInitializerFunction<\"get\">;\n\n  const index: QueryInitializerFunction<\"index\"> = <\n    IndexName extends keyof Indexes<\n      DataModel.TableInfoWithName<DataModel_, TableName>\n    >,\n  >(\n    indexName: IndexName,\n    indexRangeOrOrder?:\n      | ((\n          q: IndexRangeBuilder<\n            DataModel.TableInfoWithName_<\n              DataModel_,\n              TableName\n            >[\"convexDocument\"],\n            NamedIndex<\n              DataModel.TableInfoWithName<DataModel_, TableName>,\n              IndexName\n            >\n          >,\n        ) => IndexRange)\n      | \"asc\"\n      | \"desc\",\n    order?: \"asc\" | \"desc\",\n  ) => {\n    const {\n      applyWithIndex,\n      applyOrder,\n    }: {\n      applyWithIndex: (\n        queryInitializer: ConvexQueryInitializer<\n          NamedTableInfo<ConvexDataModel_, TableName>\n        >,\n      ) => Query<NamedTableInfo<ConvexDataModel_, TableName>>;\n      applyOrder: (\n        query: Query<NamedTableInfo<ConvexDataModel_, TableName>>,\n      ) => ConvexOrderedQuery<NamedTableInfo<ConvexDataModel_, TableName>>;\n    } =\n      indexRangeOrOrder === undefined\n        ? {\n            applyWithIndex: (q) => q.withIndex(indexName),\n            applyOrder: (q) => q.order(\"asc\"),\n          }\n        : typeof indexRangeOrOrder === \"function\"\n          ? order === undefined\n            ? {\n                applyWithIndex: (q) =>\n                  q.withIndex(indexName, indexRangeOrOrder),\n                applyOrder: (q) => q.order(\"asc\"),\n              }\n            : {\n                applyWithIndex: (q) =>\n                  q.withIndex(indexName, indexRangeOrOrder),\n                applyOrder: (q) => q.order(order),\n              }\n          : {\n              applyWithIndex: (q) => q.withIndex(indexName),\n              applyOrder: (q) => q.order(indexRangeOrOrder),\n            };\n\n    const orderedQuery = pipe(\n      convexDatabaseReader.query(tableName),\n      applyWithIndex,\n      applyOrder,\n    );\n\n    return OrderedQuery.make<\n      DataModel.TableInfoWithName_<DataModel_, TableName>,\n      TableName\n    >(\n      orderedQuery,\n      tableName,\n      table.Fields as TableInfo.TableSchema<\n        DataModel.TableInfoWithName_<DataModel_, TableName>\n      >,\n    );\n  };\n\n  const search: QueryInitializerFunction<\"search\"> = (\n    indexName,\n    searchFilter,\n  ) =>\n    OrderedQuery.make<\n      DataModel.TableInfoWithName_<DataModel_, TableName>,\n      TableName\n    >(\n      convexDatabaseReader\n        .query(tableName)\n        .withSearchIndex(indexName, searchFilter),\n      tableName,\n      table.Fields as TableInfo.TableSchema<\n        DataModel.TableInfoWithName_<DataModel_, TableName>\n      >,\n    );\n\n  return {\n    get,\n    index,\n    search,\n  };\n};\n\nexport const getById =\n  <Tables extends Table.AnyWithProps, TableName extends Table.Name<Tables>>(\n    tableName: TableName,\n    convexDatabaseReader: BaseDatabaseReader<\n      DataModel.ToConvex<DataModel.FromTables<Tables>>\n    >,\n    table: Table.WithName<Tables, TableName>,\n  ) =>\n  (id: GenericId<TableName>) =>\n    pipe(\n      Effect.promise(() => convexDatabaseReader.get(id)),\n      Effect.andThen(\n        Either.fromNullable(() => new GetByIdFailure({ tableName, id })),\n      ),\n      Effect.andThen(Document.decode(tableName, table.Fields)),\n    );\n\nexport class GetByIdFailure extends Schema.TaggedError<GetByIdFailure>()(\n  \"GetByIdFailure\",\n  {\n    id: Schema.String,\n    tableName: Schema.String,\n  },\n) {\n  override get message(): string {\n    return Document.documentErrorMessage({\n      id: this.id,\n      tableName: this.tableName,\n      message: \"not found\",\n    });\n  }\n}\n\nexport class GetByIndexFailure extends Schema.TaggedError<GetByIndexFailure>()(\n  \"GetByIndexFailure\",\n  {\n    tableName: Schema.String,\n    indexName: Schema.String,\n    indexFieldValues: Schema.Array(Schema.Unknown),\n  },\n) {\n  override get message(): string {\n    return `No documents found in table '${this.tableName}' with index '${this.indexName}' and field values '${JSON.stringify(\n      this.indexFieldValues,\n      (_key, value) => (typeof value === \"bigint\" ? value.toString() : value),\n    )}'`;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgFA,MAAa,QAIX,WACA,sBAGA,UAMG;CAaH,MAAM,cAKJ,WACA,qBAQG;EACH,MAAM,cACJ,MAAM,QACN;AAEF,SAAO,KACL,OAAO,cACL,qBACG,MAAM,UAAU,CAChB,UAAU,YAAY,MACrB,MAAM,OACJ,kBACA,IACC,IAAI,GAAG,MAAM,GAAG,GAAG,YAAY,IAAW,EAAS,CACrD,CACF,CACA,QAAQ,CACZ,EACD,OAAO,QACL,OAAO,mBAEH,IAAI,kBAAkB;GACpB;GACW;GACX;GACD,CAAC,CACL,CACF,EACD,OAAO,QAAQA,OAAgB,WAAW,MAAM,OAAO,CAAC,CACzD;;CAGH,MAAM,QACJ,GAAG,SACA;AACH,MAAI,KAAK,WAAW,GAAG;GACrB,MAAM,KAAK,KAAK;AAEhB,UAAO,QAAQ,WAAW,sBAAsB,MAAM,CAAC,GAAG;SACrD;GACL,MAAM,CAAC,WAAW,GAAG,oBAAoB;AAEzC,UAAO,WACL,WAGA,iBACD;;;CAIL,MAAM,SAKJ,WACA,mBAeA,UACG;EACH,MAAM,EACJ,gBACA,eAWA,sBAAsB,SAClB;GACE,iBAAiB,MAAM,EAAE,UAAU,UAAU;GAC7C,aAAa,MAAM,EAAE,MAAM,MAAM;GAClC,GACD,OAAO,sBAAsB,aAC3B,UAAU,SACR;GACE,iBAAiB,MACf,EAAE,UAAU,WAAW,kBAAkB;GAC3C,aAAa,MAAM,EAAE,MAAM,MAAM;GAClC,GACD;GACE,iBAAiB,MACf,EAAE,UAAU,WAAW,kBAAkB;GAC3C,aAAa,MAAM,EAAE,MAAM,MAAM;GAClC,GACH;GACE,iBAAiB,MAAM,EAAE,UAAU,UAAU;GAC7C,aAAa,MAAM,EAAE,MAAM,kBAAkB;GAC9C;EAET,MAAM,eAAe,KACnB,qBAAqB,MAAM,UAAU,EACrC,gBACA,WACD;AAED,SAAOC,OAIL,cACA,WACA,MAAM,OAGP;;CAGH,MAAM,UACJ,WACA,iBAEAA,OAIE,qBACG,MAAM,UAAU,CAChB,gBAAgB,WAAW,aAAa,EAC3C,WACA,MAAM,OAGP;AAEH,QAAO;EACL;EACA;EACA;EACD;;AAGH,MAAa,WAET,WACA,sBAGA,WAED,OACC,KACE,OAAO,cAAc,qBAAqB,IAAI,GAAG,CAAC,EAClD,OAAO,QACL,OAAO,mBAAmB,IAAI,eAAe;CAAE;CAAW;CAAI,CAAC,CAAC,CACjE,EACD,OAAO,QAAQD,OAAgB,WAAW,MAAM,OAAO,CAAC,CACzD;AAEL,IAAa,iBAAb,cAAoC,OAAO,aAA6B,CACtE,kBACA;CACE,IAAI,OAAO;CACX,WAAW,OAAO;CACnB,CACF,CAAC;CACA,IAAa,UAAkB;AAC7B,SAAOE,qBAA8B;GACnC,IAAI,KAAK;GACT,WAAW,KAAK;GAChB,SAAS;GACV,CAAC;;;AAIN,IAAa,oBAAb,cAAuC,OAAO,aAAgC,CAC5E,qBACA;CACE,WAAW,OAAO;CAClB,WAAW,OAAO;CAClB,kBAAkB,OAAO,MAAM,OAAO,QAAQ;CAC/C,CACF,CAAC;CACA,IAAa,UAAkB;AAC7B,SAAO,gCAAgC,KAAK,UAAU,gBAAgB,KAAK,UAAU,sBAAsB,KAAK,UAC9G,KAAK,mBACJ,MAAM,UAAW,OAAO,UAAU,WAAW,MAAM,UAAU,GAAG,MAClE,CAAC"}