@confect/core 10.0.0-next.1 → 10.0.0-next.10

package/src/FunctionProvenance.ts

@@ -1,13 +1,16 @@
 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 Lazy from "./Lazy";
+import * as PaginationOptions from "./PaginationOptions";
+import * as PaginationResult from "./PaginationResult";
 
 export type FunctionProvenance = Data.TaggedEnum<{
   Confect: {
     args: Schema.Codec<any, any>;
     returns: Schema.Codec<any, any>;
     error?: Schema.Codec<any, any>;
+    kind: ConfectKind;
   };
   Convex: {
     /** @internal */
@@ -17,15 +20,43 @@ export type FunctionProvenance = Data.TaggedEnum<{
   };
 }>;
 
+/**
+ * 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` and
+ * `returns` schemas directly; a `Paginated` function declares `userArgs` and
+ * `item` schemas from which the Convex-facing `args`/`returns` are composed.
+ */
+export type ConfectKind = Standard | Paginated;
+
+export interface Standard {
+  readonly _tag: "Standard";
+}
+
+export interface Paginated<
+  UserArgs extends AnyUserArgs = AnyUserArgs,
+  Item extends Schema.Codec<any, any> = Schema.Codec<any, any>,
+> {
+  readonly _tag: "Paginated";
+  /** User-declared args — no `paginationOpts`. */
+  readonly userArgs: UserArgs;
+  /** Page element schema. */
+  readonly item: Item;
+  /** Mutable array of items — the page decode target. */
+  readonly page: Schema.Codec<any, any>;
+}
+
 export interface Confect<
   Args extends Schema.Codec<any, any>,
   Returns extends Schema.Codec<any, any>,
   Error extends Schema.Codec<any, any> = never,
+  Kind extends ConfectKind = ConfectKind,
 > {
   readonly _tag: "Confect";
   readonly args: Args;
   readonly returns: Returns;
   readonly error?: Error;
+  readonly kind: Kind;
 }
 
 export interface AnyConfect extends Confect<
@@ -44,6 +75,8 @@ export interface AnyConvex extends Convex<DefaultFunctionArgs, any> {}
 
 export const FunctionProvenance = Data.taggedEnum<FunctionProvenance>();
 
+const Standard: 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})
@@ -68,8 +101,8 @@ export const Confect = <
   args: () => Args,
   returns: () => Returns,
   error?: () => Error,
-): Confect<Args, Returns, Error> => {
-  const provenance = { _tag: "Confect" as const };
+): Confect<Args, Returns, Error, Standard> => {
+  const provenance = { _tag: "Confect" as const, kind: Standard };
 
   Lazy.defineProperty(provenance, "args", args);
   Lazy.defineProperty(provenance, "returns", returns);
@@ -77,7 +110,117 @@ export const Confect = <
     Lazy.defineProperty(provenance, "error", error);
   }
 
-  return provenance as Confect<Args, Returns, Error>;
+  return provenance as Confect<Args, Returns, Error, Standard>;
+};
+
+/**
+ * Any struct-shaped, context-free schema usable as a paginated query's user
+ * args. A structural bound rather than `Schema.Struct<Schema.Struct.Fields>`
+ * because `Schema.Struct` is not covariant in its fields parameter — concrete
+ * structs do not extend `Schema.Struct<Schema.Struct.Fields>`.
+ */
+// eslint-disable-next-line import/namespace -- oxlint's namespace resolution misses type-only exports, and `Schema` is an interface/namespace
+export interface AnyUserArgs extends Schema.Codec<any, any> {
+  readonly fields: Schema.Struct.Fields;
+}
+
+/**
+ * The composed args schema of a paginated query: the user-declared fields
+ * plus the `paginationOpts` field managed by Convex's pagination protocol.
+ *
+ * The `extends infer ... extends` conditional lets TypeScript accept the
+ * composed struct where `Schema.Codec<any, any>` is required even while
+ * `UserArgs` is an unresolved type parameter; for concrete user args it
+ * evaluates away entirely.
+ */
+export type PaginatedArgs<UserArgs extends AnyUserArgs> =
+  Schema.Struct<
+    UserArgs["fields"] & {
+      paginationOpts: typeof PaginationOptions.PaginationOptions;
+    }
+  > extends infer ComposedArgs extends Schema.Codec<any, any>
+    ? ComposedArgs
+    : never;
+
+/**
+ * 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<
+  UserArgs extends AnyUserArgs,
+  Item extends Schema.Codec<any, any>,
+  Error extends Schema.Codec<any, any> = never,
+> extends Confect<
+  PaginatedArgs<UserArgs>,
+  PaginatedReturns<Item>,
+  Error,
+  Paginated<UserArgs, Item>
+> {}
+
+export interface AnyConfectPaginated extends ConfectPaginated<
+  AnyUserArgs,
+  Schema.Codec<any, any>,
+  Schema.Codec<any, any>
+> {}
+
+/**
+ * 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 const ConfectPaginated = <
+  UserArgs extends AnyUserArgs,
+  Item extends Schema.Codec<any, any>,
+  Error extends Schema.Codec<any, any> = never,
+>(
+  userArgs: () => UserArgs,
+  item: () => Item,
+  error?: () => Error,
+): ConfectPaginated<UserArgs, Item, Error> => {
+  const kind = { _tag: "Paginated" as const };
+  const paginatedKind = kind as Paginated<UserArgs, Item>;
+
+  Lazy.defineProperty(kind, "userArgs", userArgs);
+  Lazy.defineProperty(kind, "item", item);
+  Lazy.defineProperty(kind, "page", () =>
+    Schema.mutable(Schema.Array(paginatedKind.item)),
+  );
+
+  const provenance = { _tag: "Confect" as const, kind: paginatedKind };
+  const self = provenance as ConfectPaginated<UserArgs, Item, Error>;
+
+  Lazy.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.PaginationOptions,
+    });
+  });
+  Lazy.defineProperty(provenance, "returns", () =>
+    PaginationResult.PaginationResult(paginatedKind.item),
+  );
+  if (error !== undefined) {
+    Lazy.defineProperty(provenance, "error", error);
+  }
+
+  return self;
 };
 
 export const Convex = <_Args extends DefaultFunctionArgs, _Returns>() =>

package/src/FunctionSpec.ts

@@ -5,7 +5,7 @@ import type {
   RegisteredMutation,
   RegisteredQuery,
 } from "convex/server";
-import type { Schema } from "effect";
+import * as Schema from "effect/Schema";
 import * as Predicate from "effect/Predicate";
 import * as FunctionProvenance from "./FunctionProvenance";
 import { validateConfectFunctionIdentifier } from "./Identifier";
@@ -244,11 +244,77 @@ const make =
     });
   };
 
+/**
+ * `Schema.Struct` fields that must not declare `paginationOpts`. Used to
+ * reject a user args schema that redeclares the field the paginated
+ * constructors add themselves; the check reports at the `args` thunk with an
+ * unsatisfiable type when violated.
+ */
+type ForbidPaginationOpts<UserArgs extends FunctionProvenance.AnyUserArgs> =
+  "paginationOpts" extends keyof UserArgs["fields"]
+    ? { readonly fields: { readonly paginationOpts: never } }
+    : unknown;
+
+const makePaginated =
+  <
+    RuntimeAndFunctionType_ extends
+      RuntimeAndFunctionType.RuntimeAndFunctionType,
+    FunctionVisibility_ extends FunctionVisibility,
+  >(
+    runtimeAndFunctionType: RuntimeAndFunctionType_,
+    functionVisibility: FunctionVisibility_,
+  ) =>
+  <
+    const Name_ extends string,
+    Item_ extends Schema.Codec<any, any>,
+    UserArgs_ extends FunctionProvenance.AnyUserArgs = Schema.Struct<{}>,
+    Error_ extends Schema.Codec<any, any> = never,
+  >({
+    name,
+    args,
+    item,
+    error,
+  }: {
+    name: Name_;
+    /** User-declared args, without `paginationOpts` — it is added automatically. */
+    args?: (() => UserArgs_) & ForbidPaginationOpts<UserArgs_>;
+    /** The page element schema. */
+    item: () => Item_;
+    error?: () => Error_;
+  }): FunctionSpec<
+    RuntimeAndFunctionType_,
+    FunctionVisibility_,
+    Name_,
+    FunctionProvenance.ConfectPaginated<UserArgs_, Item_, Error_>
+  > => {
+    validateConfectFunctionIdentifier(name);
+
+    return Object.assign(Object.create(Proto), {
+      runtimeAndFunctionType,
+      functionVisibility,
+      name,
+      functionProvenance: FunctionProvenance.ConfectPaginated(
+        // When `args` is omitted, `UserArgs_` is its `Schema.Struct<{}>` default.
+        args ?? ((() => Schema.Struct({})) as unknown as () => UserArgs_),
+        item,
+        error,
+      ),
+    });
+  };
+
 export const publicQuery = make(RuntimeAndFunctionType.ConvexQuery, "public");
 export const internalQuery = make(
   RuntimeAndFunctionType.ConvexQuery,
   "internal",
 );
+export const publicPaginatedQuery = makePaginated(
+  RuntimeAndFunctionType.ConvexQuery,
+  "public",
+);
+export const internalPaginatedQuery = makePaginated(
+  RuntimeAndFunctionType.ConvexQuery,
+  "internal",
+);
 export const publicMutation = make(
   RuntimeAndFunctionType.ConvexMutation,
   "public",

package/src/PaginationOptions.ts

@@ -0,0 +1,23 @@
+import * as Schema from "effect/Schema";
+
+/**
+ * Schema for the `paginationOpts` argument that every paginated query
+ * receives. Mirrors `paginationOptsValidator` from `convex/server`.
+ *
+ * Use this as the `paginationOpts` field of a paginated query's args schema.
+ * Beyond `numItems` and `cursor`, Convex's pagination protocol sends the
+ * optional fields (`endCursor`, `id`, `maximumRowsRead`, `maximumBytesRead`)
+ * with real requests — most notably `usePaginatedQuery` from `convex/react`
+ * always includes `id`, and includes `endCursor` when splitting pages.
+ * Declaring them is required for the generated Convex argument validator to
+ * accept those requests and for the fields to survive decoding and reach
+ * `paginate`.
+ */
+export const PaginationOptions = Schema.Struct({
+  numItems: Schema.Number,
+  cursor: Schema.Union([Schema.String, Schema.Null]),
+  endCursor: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+  id: Schema.optionalKey(Schema.Number),
+  maximumRowsRead: Schema.optionalKey(Schema.Number),
+  maximumBytesRead: Schema.optionalKey(Schema.Number),
+});

package/src/PaginationResult.ts

@@ -1,5 +1,9 @@
 import * as Schema from "effect/Schema";
 
+export type PaginationResult<Doc extends Schema.Codec<any, any>> = ReturnType<
+  typeof PaginationResult<Doc>
+>;
+
 export const PaginationResult = <Doc extends Schema.Codec<any, any>>(
   Doc: Doc,
 ) =>

package/src/Ref.ts

@@ -1,6 +1,8 @@
 import type {
   FunctionReference as ConvexFunctionReference,
   FunctionVisibility,
+  PaginationOptions,
+  PaginationResult,
 } from "convex/server";
 import { makeFunctionReference } from "convex/server";
 import type { Value } from "convex/values";
@@ -44,6 +46,17 @@ export interface AnyQuery extends Ref<
   any
 > {}
 
+export interface AnyPublicPaginatedQuery extends Ref<
+  RuntimeAndFunctionType.AnyQuery,
+  "public",
+  {
+    [key: string]: any;
+    paginationOpts: PaginationOptions;
+  },
+  PaginationResult<any>,
+  any
+> {}
+
 export interface AnyMutation extends Ref<
   RuntimeAndFunctionType.AnyMutation,
   FunctionVisibility,
@@ -315,7 +328,7 @@ export const decodeErrorOrElse =
   <Ref_ extends Any, E>(ref: Ref_, mapUnknownError: (error: unknown) => E) =>
   (error: unknown): Error<Ref_> | E => {
     if (isConvexError(error)) {
-      const decoded = decodeErrorSync(ref, error.data);
+      const decoded = decodeErrorOption(ref, error.data);
       if (Option.isSome(decoded)) {
         return decoded.value;
       }
@@ -350,44 +363,96 @@ export const decodeError = <Ref_ extends Any>(
   );
 
 /**
- * Synchronous counterpart to `decodeError`. Throws on schema decode failure;
- * returns `None` when the ref doesn't declare a typed error.
+ * Synchronous counterpart to `decodeError`. Returns `None` when the value is
+ * not this ref's typed error — either because the ref declares no `error`
+ * schema, or because `encodedError` doesn't match the one it declares.
+ *
+ * The second case is reachable in normal operation: Convex raises its own
+ * `ConvexError`s (an `InvalidCursor` pagination error, for instance), and
+ * those never match a user-declared error schema. Callers pair this with a
+ * fallback that surfaces the original error, so failing to decode must not
+ * throw — a `ParseError` here would replace the real error with an opaque one
+ * and lose the only useful diagnostic. Hence the `Option` suffix rather than
+ * `Sync`, matching `Schema.decodeUnknownOption`: the sibling `*Sync` helpers
+ * in this module all throw on a parse failure, and this one deliberately
+ * doesn't.
  */
-export const decodeErrorSync = <Ref_ extends Any>(
+export const decodeErrorOption = <Ref_ extends Any>(
   ref: Ref_,
   encodedError: unknown,
 ): Option.Option<Error<Ref_>> =>
   Match.value(ref.functionSpec.functionProvenance).pipe(
     Match.tag("Confect", (confectFunctionProvenance) =>
       "error" in confectFunctionProvenance
-        ? Option.some(
-            Schema.decodeUnknownSync(confectFunctionProvenance.error)(
-              encodedError,
-            ) as Error<Ref_>,
-          )
+        ? (Schema.decodeUnknownOption(confectFunctionProvenance.error)(
+            encodedError,
+          ) as Option.Option<Error<Ref_>>)
         : Option.none<Error<Ref_>>(),
     ),
     Match.tag("Convex", () => Option.none<Error<Ref_>>()),
     Match.exhaustive,
   );
 
-export const maybeDecodeErrorSync = <Ref_ extends Any>(
+const missingPaginatedProvenanceError = (ref: Any) =>
+  new globalThis.Error(
+    `Paginated query ref "${getConvexFunctionName(ref)}" was not built with ` +
+      "`FunctionSpec.publicPaginatedQuery` (or `FunctionSpec.internalPaginatedQuery`). " +
+      "Paginated encoding and decoding require the user-args and item schemas " +
+      "those constructors store. Define the function as, e.g.:\n\n" +
+      "  FunctionSpec.publicPaginatedQuery({\n" +
+      '    name: "...",\n' +
+      "    args: () => Schema.Struct({ ... }), // optional; without paginationOpts\n" +
+      "    item: () => ItemSchema,\n" +
+      "  })",
+  );
+
+/**
+ * Encode the args of a paginated query ref via its user-args schema —
+ * `paginationOpts` is excluded, since the pagination protocol fields are
+ * managed by the client (e.g. `usePaginatedQuery` from `convex/react`), not by
+ * the caller. Requires a ref built with `FunctionSpec.publicPaginatedQuery`
+ * (or `internalPaginatedQuery`).
+ */
+export const encodePaginatedQueryArgsSync = <
+  Ref_ extends AnyPublicPaginatedQuery,
+>(
   ref: Ref_,
-  error: unknown,
+  args: Omit<Args<Ref_>, "paginationOpts">,
 ): unknown =>
-  isConvexError(error)
-    ? Match.value(ref.functionSpec.functionProvenance).pipe(
-        Match.tag("Confect", (confectFunctionProvenance) =>
-          "error" in confectFunctionProvenance
-            ? Schema.decodeUnknownSync(confectFunctionProvenance.error)(
-                error.data,
-              )
-            : error,
-        ),
-        Match.tag("Convex", () => error),
-        Match.exhaustive,
-      )
-    : error;
+  Match.value(ref.functionSpec.functionProvenance).pipe(
+    Match.tag("Confect", (confectFunctionProvenance) => {
+      if (confectFunctionProvenance.kind._tag !== "Paginated") {
+        throw missingPaginatedProvenanceError(ref);
+      }
+      return Schema.encodeUnknownSync(confectFunctionProvenance.kind.userArgs)(
+        args,
+      );
+    }),
+    Match.tag("Convex", () => args),
+    Match.exhaustive,
+  );
+
+/**
+ * Decode a page of a paginated query's results via the ref's item schema.
+ * Requires a ref built with `FunctionSpec.publicPaginatedQuery` (or
+ * `internalPaginatedQuery`).
+ */
+export const decodePaginationPageSync = <Ref_ extends AnyPublicPaginatedQuery>(
+  ref: Ref_,
+  encodedPage: unknown,
+): Returns<Ref_>["page"] =>
+  Match.value(ref.functionSpec.functionProvenance).pipe(
+    Match.tag("Confect", (confectFunctionProvenance) => {
+      if (confectFunctionProvenance.kind._tag !== "Paginated") {
+        throw missingPaginatedProvenanceError(ref);
+      }
+      return Schema.decodeUnknownSync(confectFunctionProvenance.kind.page)(
+        encodedPage,
+      );
+    }),
+    Match.tag("Convex", () => encodedPage),
+    Match.exhaustive,
+  ) as Returns<Ref_>["page"];
 
 /**
  * Encode args via the ref's args schema, invoke `call`, decode returns via the
@@ -416,7 +481,7 @@ export const runWithCodec = <Ref_ extends Any, E = never>(
         try: () => Promise.resolve(call(functionReference, encodedArgs)),
         catch: (error): Error<Ref_> | E => {
           if (isConvexError(error)) {
-            const decoded = decodeErrorSync(ref, error.data);
+            const decoded = decodeErrorOption(ref, error.data);
             if (Option.isSome(decoded)) {
               return decoded.value;
             }

package/src/SystemFields.ts

@@ -191,9 +191,7 @@ export const extendWithSystemFields = <
     if (
       s.ast.encoding === undefined &&
       SchemaAST.isUnion(s.ast) &&
-      Array.isArray(
-        (s as Partial<Schema.Union<ReadonlyArray<Schema.Top>>>).members,
-      )
+      Array.isArray((s as { readonly members?: unknown }).members)
     ) {
       return Schema.Union(
         Array.map(
@@ -205,8 +203,7 @@ export const extendWithSystemFields = <
     if (
       s.ast.encoding === undefined &&
       SchemaAST.isObjects(s.ast) &&
-      typeof (s as Partial<Schema.Struct<Schema.Struct.Fields>>).mapFields ===
-        "function"
+      typeof (s as { readonly mapFields?: unknown }).mapFields === "function"
     ) {
       return Schema.fieldsAssign(system)(
         s as Schema.Struct<Schema.Struct.Fields>,

package/src/Types.ts

@@ -66,7 +66,11 @@ export type DeepMutable<T> =
           ? Set<DeepMutable<V>>
           : [keyof T] extends [never]
             ? T
-            : { -readonly [K in keyof T]: DeepMutable<T[K]> };
+            : {
+                -readonly [K in keyof T]: IsOptional<T, K> extends true
+                  ? DeepMutable<Exclude<T[K], undefined>>
+                  : DeepMutable<T[K]>;
+              };
 
 export type TypeError<Message extends string, T = never> = [Message, T];
 

package/src/index.ts

@@ -5,6 +5,7 @@ export * as GroupPath from "./GroupPath";
 export * as GroupSpec from "./GroupSpec";
 export * as Identifier from "./Identifier";
 export * as Lazy from "./Lazy";
+export * as PaginationOptions from "./PaginationOptions";
 export * as PaginationResult from "./PaginationResult";
 export * as Ref from "./Ref";
 export * as Refs from "./Refs";