@confect/core 10.0.0-next.9 → 10.1.0

package/README.md

@@ -5,7 +5,9 @@ Confect is a framework that deeply integrates Effect with Convex. It's more than
 - Define your Convex database schema using Effect schemas.
 - Write Convex function args and returns validators using Effect's schema library.
 - Use Confect functions to automatically decode and encode your data according to your Effect schema definitions for end-to-end rich types, from client to function to database (and back).
-- Use Effect's HTTP API modules to define your HTTP API(s). Includes interactive OpenAPI documentation powered by [Scalar](https://github.com/scalar/scalar).
+- Add reusable, type-safe middleware to function groups or individual functions to provide Effect services and run logic around handlers.
+- Declare typed errors on functions and middleware using Effect schemas, then handle the decoded errors at every call site.
+- Use Effect's native HTTP API modules to define your HTTP API.
 - Access Convex platform capabilities via Effect services.
 
 Want to learn more? Read the [docs](https://confect.dev)!

package/dist/FunctionProvenance.d.ts

@@ -1,122 +1,220 @@
 import type { DefaultFunctionArgs } from "convex/server";
-import type { Schema } from "effect";
 import * as Data from "effect/Data";
+import * as Schema from "effect/Schema";
+import * as PaginationOptions from "./PaginationOptions";
+import * as PaginationResult from "./PaginationResult";
+/**
+ * A field map accepted as Confect function args. Restricting each field to a
+ * context-free codec means the struct assembled from the fields can always be
+ * encoded and decoded synchronously at a Convex boundary.
+ */
+export type ArgsFields = {
+    readonly [key: PropertyKey]: Schema.ConstraintCodec<any, any>;
+};
+/**
+ * A struct-shaped Confect args schema that keeps its exact field map while
+ * erasing the rest of `Schema.Struct`'s large implementation type. Decoded and
+ * encoded args are derived directly from `ArgsFields_`; keeping the runtime
+ * codec structural prevents every ref lookup from expanding the full Effect
+ * schema type.
+ */
+export interface ArgsSchema<ArgsFields_ extends ArgsFields> extends Schema.Codec<any, any> {
+    readonly fields: ArgsFields_;
+}
+/**
+ * Erased structural view used after the exact field map is no longer needed.
+ */
+export type AnyArgsSchema = ArgsSchema<ArgsFields>;
 export type FunctionProvenance = Data.TaggedEnum<{
     Confect: {
-        args: Schema.Codec<any, any>;
+        args: AnyArgsSchema;
         returns: Schema.Codec<any, any>;
         error?: Schema.Codec<any, any>;
+        kind: ConfectKind;
+    };
+    Convex: {
+        "~args": DefaultFunctionArgs;
+        "~returns": any;
     };
-    Convex: {};
 }>;
-export interface Confect<Args extends Schema.Codec<any, any>, Returns extends Schema.Codec<any, any>, Error extends Schema.Codec<any, any> = never> {
+/**
+ * The declaration shape of a Confect function—orthogonal to both the provenance
+ * origin (Confect vs Convex) and the function type (query/mutation/action). A
+ * `Standard` function declares its args fields and returns schema directly; a
+ * `Paginated` function declares user-args fields and an item schema from which
+ * the Convex-facing `args`/`returns` are composed.
+ */
+export type ConfectKind = Standard | Paginated;
+export interface Standard {
+    readonly _tag: "Standard";
+}
+export interface Paginated<UserArgsFields_ extends ArgsFields = ArgsFields, Item extends Schema.Codec<any, any> = Schema.Codec<any, any>> {
+    readonly _tag: "Paginated";
+    /**
+     * User-declared args—no `paginationOpts`.
+     */
+    readonly userArgs: ArgsSchema<UserArgsFields_>;
+    /**
+     * Page element schema.
+     */
+    readonly item: Item;
+    /**
+     * Mutable array of items—the page decode target.
+     */
+    readonly page: Schema.Codec<any, any>;
+}
+export interface Confect<ArgsFields_ extends ArgsFields, Returns extends Schema.Codec<any, any>, Error extends Schema.Codec<any, any> = never, Kind extends ConfectKind = ConfectKind> {
     readonly _tag: "Confect";
-    readonly args: Args;
+    readonly "~ArgsFields": ArgsFields_;
+    readonly args: ArgsSchema<ArgsFields_>;
     readonly returns: Returns;
     readonly error?: Error;
+    readonly kind: Kind;
 }
-export interface AnyConfect extends Confect<Schema.Codec<any, any>, Schema.Codec<any, any>, Schema.Codec<any, any>> {
+export interface AnyConfect {
+    readonly _tag: "Confect";
+    readonly args: AnyArgsSchema;
+    readonly returns: Schema.Codec<any, any>;
+    readonly error?: Schema.Codec<any, any>;
+    readonly kind: ConfectKind;
 }
 export interface Convex<Args extends DefaultFunctionArgs, Returns> {
     readonly _tag: "Convex";
-    readonly _args: Args;
-    readonly _returns: Returns;
+    readonly "~args": Args;
+    readonly "~returns": Returns;
 }
 export interface AnyConvex extends Convex<DefaultFunctionArgs, any> {
 }
 export declare const FunctionProvenance: {
-    readonly Confect: Data.TaggedEnum.ConstructorFrom<{
-        readonly _tag: "Confect";
-        readonly args: Schema.Codec<any, any>;
-        readonly returns: Schema.Codec<any, any>;
-        readonly error?: Schema.Codec<any, any>;
-    }, "_tag">;
-    readonly Convex: Data.TaggedEnum.ConstructorFrom<{
-        readonly _tag: "Convex";
-        readonly _args: DefaultFunctionArgs;
-        readonly _returns: any;
-    }, "_tag">;
     readonly $is: <Tag extends "Confect" | "Convex">(tag: Tag) => (u: unknown) => u is Extract<{
         readonly _tag: "Confect";
-        readonly args: Schema.Codec<any, any>;
+        readonly args: AnyArgsSchema;
         readonly returns: Schema.Codec<any, any>;
         readonly error?: Schema.Codec<any, any>;
+        readonly kind: ConfectKind;
     }, {
         readonly _tag: Tag;
     }> | Extract<{
         readonly _tag: "Convex";
-        readonly _args: DefaultFunctionArgs;
-        readonly _returns: any;
+        readonly "~args": DefaultFunctionArgs;
+        readonly "~returns": any;
     }, {
         readonly _tag: Tag;
     }>;
     readonly $match: {
-        <Cases extends {
-            readonly Confect: (args: {
-                readonly _tag: "Confect";
-                readonly args: Schema.Codec<any, any>;
-                readonly returns: Schema.Codec<any, any>;
-                readonly error?: Schema.Codec<any, any>;
-            }) => any;
-            readonly Convex: (args: {
-                readonly _tag: "Convex";
-                readonly _args: DefaultFunctionArgs;
-                readonly _returns: any;
-            }) => any;
-        }>(cases: Cases): (value: {
+        <Cases extends { readonly [Tag in "Confect" | "Convex"]: (args: Extract<{
+            readonly _tag: "Confect";
+            readonly args: AnyArgsSchema;
+            readonly returns: Schema.Codec<any, any>;
+            readonly error?: Schema.Codec<any, any>;
+            readonly kind: ConfectKind;
+        } | {
+            readonly _tag: "Convex";
+            readonly "~args": DefaultFunctionArgs;
+            readonly "~returns": any;
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(cases: Cases): (value: {
             readonly _tag: "Confect";
-            readonly args: Schema.Codec<any, any>;
+            readonly args: AnyArgsSchema;
             readonly returns: Schema.Codec<any, any>;
             readonly error?: Schema.Codec<any, any>;
+            readonly kind: ConfectKind;
         } | {
             readonly _tag: "Convex";
-            readonly _args: DefaultFunctionArgs;
-            readonly _returns: any;
+            readonly "~args": DefaultFunctionArgs;
+            readonly "~returns": any;
         }) => import("effect/Unify").Unify<ReturnType<Cases["Confect" | "Convex"]>>;
-        <Cases extends {
-            readonly Confect: (args: {
-                readonly _tag: "Confect";
-                readonly args: Schema.Codec<any, any>;
-                readonly returns: Schema.Codec<any, any>;
-                readonly error?: Schema.Codec<any, any>;
-            }) => any;
-            readonly Convex: (args: {
-                readonly _tag: "Convex";
-                readonly _args: DefaultFunctionArgs;
-                readonly _returns: any;
-            }) => any;
-        }>(value: {
+        <Cases extends { readonly [Tag in "Confect" | "Convex"]: (args: Extract<{
+            readonly _tag: "Confect";
+            readonly args: AnyArgsSchema;
+            readonly returns: Schema.Codec<any, any>;
+            readonly error?: Schema.Codec<any, any>;
+            readonly kind: ConfectKind;
+        } | {
+            readonly _tag: "Convex";
+            readonly "~args": DefaultFunctionArgs;
+            readonly "~returns": any;
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(value: {
             readonly _tag: "Confect";
-            readonly args: Schema.Codec<any, any>;
+            readonly args: AnyArgsSchema;
             readonly returns: Schema.Codec<any, any>;
             readonly error?: Schema.Codec<any, any>;
+            readonly kind: ConfectKind;
         } | {
             readonly _tag: "Convex";
-            readonly _args: DefaultFunctionArgs;
-            readonly _returns: any;
+            readonly "~args": DefaultFunctionArgs;
+            readonly "~returns": any;
         }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Confect" | "Convex"]>>;
     };
+    readonly Confect: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Confect";
+        readonly args: AnyArgsSchema;
+        readonly returns: Schema.Codec<any, any>;
+        readonly error?: Schema.Codec<any, any>;
+        readonly kind: ConfectKind;
+    }, "_tag">;
+    readonly Convex: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Convex";
+        readonly "~args": DefaultFunctionArgs;
+        readonly "~returns": any;
+    }, "_tag">;
 };
 /**
- * Build a `Confect` provenance from lazy schema thunks. `args`, `returns`,
- * and `error` are exposed as sync lazy memoised getters (via {@link Lazy.defineProperty})
- * that only evaluate their thunk on first access, mirroring how `Table`
- * defers `Fields`/`Doc`/`tableDefinition`. This keeps importing the assembled
- * `_generated/spec.ts` cheap — no `Schema.Struct(...)` / `Schema.Array(...)`
- * work runs at module load; it is deferred to the first invocation that
- * actually compiles validators or runs a codec.
+ * Build a `Confect` provenance from lazy args-fields and schema thunks. `args`,
+ * `returns`, and `error` are exposed as sync lazy memoised getters (via
+ * {@link Lazy.defineProperty}) that only evaluate their thunk on first access,
+ * mirroring how `Table` defers `Fields`/`Doc`. This keeps importing the
+ * assembled `_generated/spec.ts` cheap—no
+ * `Schema.Struct(...)`/`Schema.Array(...)` work runs at module load; it is
+ * deferred to the first invocation that actually compiles validators or runs a
+ * codec.
  *
  * The object is built by hand rather than through `FunctionProvenance.Confect`
  * because the `Data` constructor copies its input with `Object.assign`, which
- * would force the getters at construction time and defeat the laziness.
- * `error` is only installed when an `errorThunk` is provided, so its absence
- * is observable via `"error" in provenance` without forcing anything; nothing
+ * would force the getters at construction time and defeat the laziness. `error`
+ * is only installed when an `errorThunk` is provided, so its absence is
+ * observable via `"error" in provenance` without forcing anything; nothing
  * relies on `Data`'s structural `Equal`/`Hash` for provenance values.
  */
-export declare const Confect: <Args extends Schema.Codec<any, any>, Returns extends Schema.Codec<any, any>, Error extends Schema.Codec<any, any> = never>(args: () => Args, returns: () => Returns, error?: () => Error) => Confect<Args, Returns, Error>;
-export declare const Convex: <_Args extends DefaultFunctionArgs, _Returns>() => {
+export declare const Confect: <const ArgsFields_ extends ArgsFields, Returns extends Schema.Codec<any, any>, Error extends Schema.Codec<any, any> = never>(args: () => ArgsFields_, returns: () => Returns, error?: () => Error) => Confect<ArgsFields_, Returns, Error, Standard>;
+/**
+ * The composed args schema of a paginated query: the user-declared fields plus
+ * the `paginationOpts` field managed by Convex's pagination protocol.
+ *
+ * The fields-first representation keeps the user-declared map available for
+ * type-level composition without reconstructing it from an erased schema.
+ */
+export type PaginatedArgsFields<UserArgsFields extends ArgsFields> = UserArgsFields & {
+    readonly paginationOpts: typeof PaginationOptions.PaginationOptions;
+};
+export type PaginatedArgs<UserArgsFields extends ArgsFields> = Schema.Struct<PaginatedArgsFields<UserArgsFields>>;
+/**
+ * The composed returns schema of a paginated query: a `PaginationResult` of the
+ * item schema. Same deferred-conditional device as {@link PaginatedArgs}.
+ */
+export type PaginatedReturns<Item extends Schema.Codec<any, any>> = PaginationResult.PaginationResult<Item> extends infer ComposedReturns extends Schema.Codec<any, any> ? ComposedReturns : never;
+export interface ConfectPaginated<UserArgsFields extends ArgsFields, Item extends Schema.Codec<any, any>, Error extends Schema.Codec<any, any> = never> extends Confect<PaginatedArgsFields<UserArgsFields>, PaginatedReturns<Item>, Error, Paginated<UserArgsFields, Item>> {
+}
+export interface AnyConfectPaginated extends AnyConfect {
+    readonly kind: Paginated;
+}
+/**
+ * Build the provenance of a paginated query from lazy schema thunks, with the
+ * same laziness contract as {@link Confect}. The user-facing schemas live on the
+ * `Paginated` kind (`kind.userArgs`, `kind.item`, `kind.page`)—the kind
+ * container is built eagerly (it is cheap) while the schemas inside it stay
+ * lazy. The composed Convex-facing `args`/`returns` are derived lazily from
+ * them: `args` spreads the user fields plus `paginationOpts`, and `returns`
+ * wraps the item in `PaginationResult`. Composition living here means the
+ * composed schemas can never drift from the stored user schemas.
+ */
+export declare const ConfectPaginated: <const UserArgsFields_ extends ArgsFields, Item extends Schema.Codec<any, any>, Error extends Schema.Codec<any, any> = never>(userArgs: () => UserArgsFields_, item: () => Item, error?: () => Error) => ConfectPaginated<UserArgsFields_, Item, Error>;
+export declare const Convex: <Args extends DefaultFunctionArgs, Returns>() => {
     readonly _tag: "Convex";
-    readonly _args: DefaultFunctionArgs;
-    readonly _returns: any;
+    readonly "~args": DefaultFunctionArgs;
+    readonly "~returns": any;
 };
 //# sourceMappingURL=FunctionProvenance.d.ts.map

package/dist/FunctionProvenance.d.ts.map

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

package/dist/FunctionProvenance.js

@@ -1,38 +1,80 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { defineProperty } from "./Lazy.js";
+import { PaginationOptions } from "./PaginationOptions.js";
+import { PaginationResult } from "./PaginationResult.js";
 import * as Data from "effect/Data";
+import * as Schema from "effect/Schema";
 //#region src/FunctionProvenance.ts
 var FunctionProvenance_exports = /* @__PURE__ */ __exportAll({
 	Confect: () => Confect,
+	ConfectPaginated: () => ConfectPaginated,
 	Convex: () => Convex,
 	FunctionProvenance: () => FunctionProvenance
 });
 const FunctionProvenance = Data.taggedEnum();
+const Standard = { _tag: "Standard" };
 /**
-* Build a `Confect` provenance from lazy schema thunks. `args`, `returns`,
-* and `error` are exposed as sync lazy memoised getters (via {@link Lazy.defineProperty})
-* that only evaluate their thunk on first access, mirroring how `Table`
-* defers `Fields`/`Doc`/`tableDefinition`. This keeps importing the assembled
-* `_generated/spec.ts` cheap — no `Schema.Struct(...)` / `Schema.Array(...)`
-* work runs at module load; it is deferred to the first invocation that
-* actually compiles validators or runs a codec.
+* Build a `Confect` provenance from lazy args-fields and schema thunks. `args`,
+* `returns`, and `error` are exposed as sync lazy memoised getters (via
+* {@link Lazy.defineProperty}) that only evaluate their thunk on first access,
+* mirroring how `Table` defers `Fields`/`Doc`. This keeps importing the
+* assembled `_generated/spec.ts` cheap—no
+* `Schema.Struct(...)`/`Schema.Array(...)` work runs at module load; it is
+* deferred to the first invocation that actually compiles validators or runs a
+* codec.
 *
 * The object is built by hand rather than through `FunctionProvenance.Confect`
 * because the `Data` constructor copies its input with `Object.assign`, which
-* would force the getters at construction time and defeat the laziness.
-* `error` is only installed when an `errorThunk` is provided, so its absence
-* is observable via `"error" in provenance` without forcing anything; nothing
+* would force the getters at construction time and defeat the laziness. `error`
+* is only installed when an `errorThunk` is provided, so its absence is
+* observable via `"error" in provenance` without forcing anything; nothing
 * relies on `Data`'s structural `Equal`/`Hash` for provenance values.
 */
 const Confect = (args, returns, error) => {
-	const provenance = { _tag: "Confect" };
-	defineProperty(provenance, "args", args);
+	const provenance = {
+		_tag: "Confect",
+		kind: Standard
+	};
+	defineProperty(provenance, "args", () => Schema.Struct(args()));
 	defineProperty(provenance, "returns", returns);
 	if (error !== void 0) defineProperty(provenance, "error", error);
 	return provenance;
 };
+/**
+* Build the provenance of a paginated query from lazy schema thunks, with the
+* same laziness contract as {@link Confect}. The user-facing schemas live on the
+* `Paginated` kind (`kind.userArgs`, `kind.item`, `kind.page`)—the kind
+* container is built eagerly (it is cheap) while the schemas inside it stay
+* lazy. The composed Convex-facing `args`/`returns` are derived lazily from
+* them: `args` spreads the user fields plus `paginationOpts`, and `returns`
+* wraps the item in `PaginationResult`. Composition living here means the
+* composed schemas can never drift from the stored user schemas.
+*/
+const ConfectPaginated = (userArgs, item, error) => {
+	const kind = { _tag: "Paginated" };
+	const paginatedKind = kind;
+	defineProperty(kind, "userArgs", () => Schema.Struct(userArgs()));
+	defineProperty(kind, "item", item);
+	defineProperty(kind, "page", () => Schema.mutable(Schema.Array(paginatedKind.item)));
+	const provenance = {
+		_tag: "Confect",
+		kind: paginatedKind
+	};
+	const self = provenance;
+	defineProperty(provenance, "args", () => {
+		const fields = paginatedKind.userArgs.fields;
+		if ("paginationOpts" in fields) throw new globalThis.Error("A paginated query's args schema must not declare `paginationOpts`—it is added automatically from the `PaginationOptions` schema");
+		return Schema.Struct({
+			...fields,
+			paginationOpts: PaginationOptions
+		});
+	});
+	defineProperty(provenance, "returns", () => PaginationResult(paginatedKind.item));
+	if (error !== void 0) defineProperty(provenance, "error", error);
+	return self;
+};
 const Convex = () => FunctionProvenance.Convex({});
 //#endregion
-export { Confect, Convex, FunctionProvenance, FunctionProvenance_exports };
+export { Confect, ConfectPaginated, Convex, FunctionProvenance, FunctionProvenance_exports };
 
 //# sourceMappingURL=FunctionProvenance.js.map

package/dist/FunctionProvenance.js.map

@@ -1 +1 @@
-{"version":3,"file":"FunctionProvenance.js","names":[],"sources":["../src/FunctionProvenance.ts"],"sourcesContent":["import type { DefaultFunctionArgs } from \"convex/server\";\nimport type { Schema } from \"effect\";\nimport * as Data from \"effect/Data\";\nimport * as Lazy from \"./Lazy\";\n\nexport type FunctionProvenance = Data.TaggedEnum<{\n  Confect: {\n    args: Schema.Codec<any, any>;\n    returns: Schema.Codec<any, any>;\n    error?: Schema.Codec<any, any>;\n  };\n  Convex: {\n    /** @internal */\n    _args: DefaultFunctionArgs;\n    /** @internal */\n    _returns: any;\n  };\n}>;\n\nexport interface Confect<\n  Args extends Schema.Codec<any, any>,\n  Returns extends Schema.Codec<any, any>,\n  Error extends Schema.Codec<any, any> = never,\n> {\n  readonly _tag: \"Confect\";\n  readonly args: Args;\n  readonly returns: Returns;\n  readonly error?: Error;\n}\n\nexport interface AnyConfect extends Confect<\n  Schema.Codec<any, any>,\n  Schema.Codec<any, any>,\n  Schema.Codec<any, any>\n> {}\n\nexport interface Convex<Args extends DefaultFunctionArgs, Returns> {\n  readonly _tag: \"Convex\";\n  readonly _args: Args;\n  readonly _returns: Returns;\n}\n\nexport interface AnyConvex extends Convex<DefaultFunctionArgs, any> {}\n\nexport const FunctionProvenance = Data.taggedEnum<FunctionProvenance>();\n\n/**\n * Build a `Confect` provenance from lazy schema thunks. `args`, `returns`,\n * and `error` are exposed as sync lazy memoised getters (via {@link Lazy.defineProperty})\n * that only evaluate their thunk on first access, mirroring how `Table`\n * defers `Fields`/`Doc`/`tableDefinition`. This keeps importing the assembled\n * `_generated/spec.ts` cheap — no `Schema.Struct(...)` / `Schema.Array(...)`\n * work runs at module load; it is deferred to the first invocation that\n * actually compiles validators or runs a codec.\n *\n * The object is built by hand rather than through `FunctionProvenance.Confect`\n * because the `Data` constructor copies its input with `Object.assign`, which\n * would force the getters at construction time and defeat the laziness.\n * `error` is only installed when an `errorThunk` is provided, so its absence\n * is observable via `\"error\" in provenance` without forcing anything; nothing\n * relies on `Data`'s structural `Equal`/`Hash` for provenance values.\n */\nexport const Confect = <\n  Args extends Schema.Codec<any, any>,\n  Returns extends Schema.Codec<any, any>,\n  Error extends Schema.Codec<any, any> = never,\n>(\n  args: () => Args,\n  returns: () => Returns,\n  error?: () => Error,\n): Confect<Args, Returns, Error> => {\n  const provenance = { _tag: \"Confect\" as const };\n\n  Lazy.defineProperty(provenance, \"args\", args);\n  Lazy.defineProperty(provenance, \"returns\", returns);\n  if (error !== undefined) {\n    Lazy.defineProperty(provenance, \"error\", error);\n  }\n\n  return provenance as Confect<Args, Returns, Error>;\n};\n\nexport const Convex = <_Args extends DefaultFunctionArgs, _Returns>() =>\n  FunctionProvenance.Convex(\n    {} as {\n      _args: _Args;\n      _returns: _Returns;\n    },\n  );\n"],"mappings":";;;;;;;;;AA4CA,MAAa,qBAAqB,KAAK,WAA+B;;;;;;;;;;;;;;;;;AAkBtE,MAAa,WAKX,MACA,SACA,UACkC;CAClC,MAAM,aAAa,EAAE,MAAM,UAAmB;CAE9C,eAAoB,YAAY,QAAQ,IAAI;CAC5C,eAAoB,YAAY,WAAW,OAAO;CAClD,IAAI,UAAU,KAAA,GACZ,eAAoB,YAAY,SAAS,KAAK;CAGhD,OAAO;AACT;AAEA,MAAa,eACX,mBAAmB,OACjB,CAAC,CAIH"}
+{"version":3,"file":"FunctionProvenance.js","names":["PaginationOptions.PaginationOptions","PaginationResult.PaginationResult"],"sources":["../src/FunctionProvenance.ts"],"sourcesContent":["import type { DefaultFunctionArgs } from \"convex/server\";\nimport * as Data from \"effect/Data\";\nimport * as Schema from \"effect/Schema\";\nimport * as Lazy from \"./Lazy\";\nimport * as PaginationOptions from \"./PaginationOptions\";\nimport * as PaginationResult from \"./PaginationResult\";\n\n/**\n * A field map accepted as Confect function args. Restricting each field to a\n * context-free codec means the struct assembled from the fields can always be\n * encoded and decoded synchronously at a Convex boundary.\n */\nexport type ArgsFields = {\n  readonly [key: PropertyKey]: Schema.ConstraintCodec<any, any>;\n};\n\n/**\n * A struct-shaped Confect args schema that keeps its exact field map while\n * erasing the rest of `Schema.Struct`'s large implementation type. Decoded and\n * encoded args are derived directly from `ArgsFields_`; keeping the runtime\n * codec structural prevents every ref lookup from expanding the full Effect\n * schema type.\n */\nexport interface ArgsSchema<\n  ArgsFields_ extends ArgsFields,\n> extends Schema.Codec<any, any> {\n  readonly fields: ArgsFields_;\n}\n\n/**\n * Erased structural view used after the exact field map is no longer needed.\n */\nexport type AnyArgsSchema = ArgsSchema<ArgsFields>;\n\nexport type FunctionProvenance = Data.TaggedEnum<{\n  Confect: {\n    args: AnyArgsSchema;\n    returns: Schema.Codec<any, any>;\n    error?: Schema.Codec<any, any>;\n    kind: ConfectKind;\n  };\n  Convex: {\n    \"~args\": DefaultFunctionArgs;\n    \"~returns\": any;\n  };\n}>;\n\n/**\n * The declaration shape of a Confect function—orthogonal to both the provenance\n * origin (Confect vs Convex) and the function type (query/mutation/action). A\n * `Standard` function declares its args fields and returns schema directly; a\n * `Paginated` function declares user-args fields and an item schema from which\n * the Convex-facing `args`/`returns` are composed.\n */\nexport type ConfectKind = Standard | Paginated;\n\nexport interface Standard {\n  readonly _tag: \"Standard\";\n}\n\nexport interface Paginated<\n  UserArgsFields_ extends ArgsFields = ArgsFields,\n  Item extends Schema.Codec<any, any> = Schema.Codec<any, any>,\n> {\n  readonly _tag: \"Paginated\";\n  /**\n   * User-declared args—no `paginationOpts`.\n   */\n  readonly userArgs: ArgsSchema<UserArgsFields_>;\n  /**\n   * Page element schema.\n   */\n  readonly item: Item;\n  /**\n   * Mutable array of items—the page decode target.\n   */\n  readonly page: Schema.Codec<any, any>;\n}\n\nexport interface Confect<\n  ArgsFields_ extends ArgsFields,\n  Returns extends Schema.Codec<any, any>,\n  Error extends Schema.Codec<any, any> = never,\n  Kind extends ConfectKind = ConfectKind,\n> {\n  readonly _tag: \"Confect\";\n  readonly \"~ArgsFields\": ArgsFields_;\n  readonly args: ArgsSchema<ArgsFields_>;\n  readonly returns: Returns;\n  readonly error?: Error;\n  readonly kind: Kind;\n}\n\nexport interface AnyConfect {\n  readonly _tag: \"Confect\";\n  readonly args: AnyArgsSchema;\n  readonly returns: Schema.Codec<any, any>;\n  readonly error?: Schema.Codec<any, any>;\n  readonly kind: ConfectKind;\n}\n\nexport interface Convex<Args extends DefaultFunctionArgs, Returns> {\n  readonly _tag: \"Convex\";\n  readonly \"~args\": Args;\n  readonly \"~returns\": Returns;\n}\n\nexport interface AnyConvex extends Convex<DefaultFunctionArgs, any> {}\n\nexport const FunctionProvenance = Data.taggedEnum<FunctionProvenance>();\n\nconst Standard: Standard = { _tag: \"Standard\" };\n\n/**\n * Build a `Confect` provenance from lazy args-fields and schema thunks. `args`,\n * `returns`, and `error` are exposed as sync lazy memoised getters (via\n * {@link Lazy.defineProperty}) that only evaluate their thunk on first access,\n * mirroring how `Table` defers `Fields`/`Doc`. This keeps importing the\n * assembled `_generated/spec.ts` cheap—no\n * `Schema.Struct(...)`/`Schema.Array(...)` work runs at module load; it is\n * deferred to the first invocation that actually compiles validators or runs a\n * codec.\n *\n * The object is built by hand rather than through `FunctionProvenance.Confect`\n * because the `Data` constructor copies its input with `Object.assign`, which\n * would force the getters at construction time and defeat the laziness. `error`\n * is only installed when an `errorThunk` is provided, so its absence is\n * observable via `\"error\" in provenance` without forcing anything; nothing\n * relies on `Data`'s structural `Equal`/`Hash` for provenance values.\n */\nexport const Confect = <\n  const ArgsFields_ extends ArgsFields,\n  Returns extends Schema.Codec<any, any>,\n  Error extends Schema.Codec<any, any> = never,\n>(\n  args: () => ArgsFields_,\n  returns: () => Returns,\n  error?: () => Error,\n): Confect<ArgsFields_, Returns, Error, Standard> => {\n  const provenance = { _tag: \"Confect\" as const, kind: Standard };\n\n  Lazy.defineProperty(provenance, \"args\", () => Schema.Struct(args()));\n  Lazy.defineProperty(provenance, \"returns\", returns);\n  if (error !== undefined) {\n    Lazy.defineProperty(provenance, \"error\", error);\n  }\n\n  return provenance as Confect<ArgsFields_, Returns, Error, Standard>;\n};\n\n/**\n * The composed args schema of a paginated query: the user-declared fields plus\n * the `paginationOpts` field managed by Convex's pagination protocol.\n *\n * The fields-first representation keeps the user-declared map available for\n * type-level composition without reconstructing it from an erased schema.\n */\nexport type PaginatedArgsFields<UserArgsFields extends ArgsFields> =\n  UserArgsFields & {\n    readonly paginationOpts: typeof PaginationOptions.PaginationOptions;\n  };\n\nexport type PaginatedArgs<UserArgsFields extends ArgsFields> = Schema.Struct<\n  PaginatedArgsFields<UserArgsFields>\n>;\n\n/**\n * The composed returns schema of a paginated query: a `PaginationResult` of the\n * item schema. Same deferred-conditional device as {@link PaginatedArgs}.\n */\nexport type PaginatedReturns<Item extends Schema.Codec<any, any>> =\n  PaginationResult.PaginationResult<Item> extends infer ComposedReturns extends\n    Schema.Codec<any, any>\n    ? ComposedReturns\n    : never;\n\nexport interface ConfectPaginated<\n  UserArgsFields extends ArgsFields,\n  Item extends Schema.Codec<any, any>,\n  Error extends Schema.Codec<any, any> = never,\n> extends Confect<\n  PaginatedArgsFields<UserArgsFields>,\n  PaginatedReturns<Item>,\n  Error,\n  Paginated<UserArgsFields, Item>\n> {}\n\nexport interface AnyConfectPaginated extends AnyConfect {\n  readonly kind: Paginated;\n}\n\n/**\n * Build the provenance of a paginated query from lazy schema thunks, with the\n * same laziness contract as {@link Confect}. The user-facing schemas live on the\n * `Paginated` kind (`kind.userArgs`, `kind.item`, `kind.page`)—the kind\n * container is built eagerly (it is cheap) while the schemas inside it stay\n * lazy. The composed Convex-facing `args`/`returns` are derived lazily from\n * them: `args` spreads the user fields plus `paginationOpts`, and `returns`\n * wraps the item in `PaginationResult`. Composition living here means the\n * composed schemas can never drift from the stored user schemas.\n */\nexport const ConfectPaginated = <\n  const UserArgsFields_ extends ArgsFields,\n  Item extends Schema.Codec<any, any>,\n  Error extends Schema.Codec<any, any> = never,\n>(\n  userArgs: () => UserArgsFields_,\n  item: () => Item,\n  error?: () => Error,\n): ConfectPaginated<UserArgsFields_, Item, Error> => {\n  const kind = { _tag: \"Paginated\" as const };\n  const paginatedKind = kind as Paginated<UserArgsFields_, Item>;\n\n  Lazy.defineProperty(kind, \"userArgs\", () => Schema.Struct(userArgs()));\n  Lazy.defineProperty(kind, \"item\", item);\n  Lazy.defineProperty(kind, \"page\", () =>\n    Schema.mutable(Schema.Array(paginatedKind.item)),\n  );\n\n  const provenance = { _tag: \"Confect\" as const, kind: paginatedKind };\n  const self = provenance as ConfectPaginated<UserArgsFields_, Item, Error>;\n\n  Lazy.defineProperty(provenance, \"args\", () => {\n    const fields = paginatedKind.userArgs.fields;\n    if (\"paginationOpts\" in fields) {\n      throw new globalThis.Error(\n        \"A paginated query's args schema must not declare `paginationOpts`—\" +\n          \"it is added automatically from the `PaginationOptions` schema\",\n      );\n    }\n    return Schema.Struct({\n      ...fields,\n      paginationOpts: PaginationOptions.PaginationOptions,\n    });\n  });\n  Lazy.defineProperty(provenance, \"returns\", () =>\n    PaginationResult.PaginationResult(paginatedKind.item),\n  );\n  if (error !== undefined) {\n    Lazy.defineProperty(provenance, \"error\", error);\n  }\n\n  return self;\n};\n\nexport const Convex = <Args extends DefaultFunctionArgs, Returns>() =>\n  FunctionProvenance.Convex(\n    {} as {\n      \"~args\": Args;\n      \"~returns\": Returns;\n    },\n  );\n"],"mappings":";;;;;;;;;;;;;AA6GA,MAAa,qBAAqB,KAAK,WAA+B;AAEtE,MAAM,WAAqB,EAAE,MAAM,WAAW;;;;;;;;;;;;;;;;;;AAmB9C,MAAa,WAKX,MACA,SACA,UACmD;CACnD,MAAM,aAAa;EAAE,MAAM;EAAoB,MAAM;CAAS;CAE9D,eAAoB,YAAY,cAAc,OAAO,OAAO,KAAK,CAAC,CAAC;CACnE,eAAoB,YAAY,WAAW,OAAO;CAClD,IAAI,UAAU,KAAA,GACZ,eAAoB,YAAY,SAAS,KAAK;CAGhD,OAAO;AACT;;;;;;;;;;;AAqDA,MAAa,oBAKX,UACA,MACA,UACmD;CACnD,MAAM,OAAO,EAAE,MAAM,YAAqB;CAC1C,MAAM,gBAAgB;CAEtB,eAAoB,MAAM,kBAAkB,OAAO,OAAO,SAAS,CAAC,CAAC;CACrE,eAAoB,MAAM,QAAQ,IAAI;CACtC,eAAoB,MAAM,cACxB,OAAO,QAAQ,OAAO,MAAM,cAAc,IAAI,CAAC,CACjD;CAEA,MAAM,aAAa;EAAE,MAAM;EAAoB,MAAM;CAAc;CACnE,MAAM,OAAO;CAEb,eAAoB,YAAY,cAAc;EAC5C,MAAM,SAAS,cAAc,SAAS;EACtC,IAAI,oBAAoB,QACtB,MAAM,IAAI,WAAW,MACnB,iIAEF;EAEF,OAAO,OAAO,OAAO;GACnB,GAAG;GACH,gBAAgBA;EAClB,CAAC;CACH,CAAC;CACD,eAAoB,YAAY,iBAC9BC,iBAAkC,cAAc,IAAI,CACtD;CACA,IAAI,UAAU,KAAA,GACZ,eAAoB,YAAY,SAAS,KAAK;CAGhD,OAAO;AACT;AAEA,MAAa,eACX,mBAAmB,OACjB,CAAC,CAIH"}