@confect/core 10.0.0-next.17 → 10.0.0-next.19

package/src/Ref.ts

@@ -1,4 +1,5 @@
 import type {
+  DefaultFunctionArgs,
   FunctionReference as ConvexFunctionReference,
   FunctionVisibility,
   PaginationOptions,
@@ -18,18 +19,17 @@ import * as MiddlewareSpec from "./MiddlewareSpec";
 import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
 
 export interface Base<
-  _RuntimeAndFunctionType extends RuntimeAndFunctionType.RuntimeAndFunctionType,
-  _FunctionVisibility extends FunctionVisibility,
-  _Args,
-  _Returns,
-  _Error = never,
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
+  FunctionVisibility_ extends FunctionVisibility,
+  Args_ extends DefaultFunctionArgs,
+  Returns_,
+  Error_ = never,
 > {
-  readonly _RuntimeAndFunctionType?: _RuntimeAndFunctionType;
-  readonly _FunctionVisibility?: _FunctionVisibility;
-  readonly _Args?: _Args;
-  readonly _Returns?: _Returns;
-  readonly _Error?: _Error;
-  /** @internal */
+  readonly "~RuntimeAndFunctionType": RuntimeAndFunctionType_;
+  readonly "~FunctionVisibility": FunctionVisibility_;
+  readonly "~Args": Args_;
+  readonly "~Returns": Returns_;
+  readonly "~Error": Error_;
   readonly convexFunctionName: string;
 }
 
@@ -39,73 +39,93 @@ export interface Base<
  * errors. A ref is one of two shapes, keyed by the spec's provenance.
  */
 export type Ref<
-  _RuntimeAndFunctionType extends RuntimeAndFunctionType.RuntimeAndFunctionType,
-  _FunctionVisibility extends FunctionVisibility,
-  _Args,
-  _Returns,
-  _Error = never,
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
+  FunctionVisibility_ extends FunctionVisibility,
+  Args_ extends DefaultFunctionArgs,
+  Returns_,
+  Error_ = never,
 > =
-  | ConfectRef<
-      _RuntimeAndFunctionType,
-      _FunctionVisibility,
-      _Args,
-      _Returns,
-      _Error
+  | ConfectRefWithTypes<
+      RuntimeAndFunctionType_,
+      FunctionVisibility_,
+      FunctionProvenance.ArgsFields,
+      Args_,
+      Returns_,
+      Error_
     >
   | ConvexRef<
-      _RuntimeAndFunctionType,
-      _FunctionVisibility,
-      _Args,
-      _Returns,
-      _Error
+      RuntimeAndFunctionType_,
+      FunctionVisibility_,
+      Args_,
+      Returns_,
+      Error_
     >;
 
-export interface ConfectRef<
-  _RuntimeAndFunctionType extends RuntimeAndFunctionType.RuntimeAndFunctionType,
-  _FunctionVisibility extends FunctionVisibility,
-  _Args,
-  _Returns,
-  _Error = never,
+export type ConfectRef<
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
+  FunctionVisibility_ extends FunctionVisibility,
+  ArgsFields_ extends FunctionProvenance.ArgsFields,
+  ReturnsSchema_ extends Schema.Codec<any, any>,
+  ErrorSchema_ extends Schema.Codec<any, any> = never,
+  MiddlewareError_ = never,
+> = ConfectRefWithTypes<
+  RuntimeAndFunctionType_,
+  FunctionVisibility_,
+  ArgsFields_,
+  Schema.Struct.Type<ArgsFields_>,
+  ReturnsSchema_["Type"],
+  ErrorSchema_["Type"] | MiddlewareError_
+>;
+
+/**
+ * Internal form used while mapping a spec to a ref. Supplying the already
+ * derived value types avoids repeatedly expanding `Schema.Struct` for every
+ * leaf in a generated ref tree; the public `ConfectRef` alias still derives
+ * the same values from its fields and schemas.
+ */
+interface ConfectRefWithTypes<
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
+  FunctionVisibility_ extends FunctionVisibility,
+  ArgsFields_ extends FunctionProvenance.ArgsFields,
+  Args_ extends DefaultFunctionArgs,
+  Returns_,
+  Error_,
 > extends Base<
-  _RuntimeAndFunctionType,
-  _FunctionVisibility,
-  _Args,
-  _Returns,
-  _Error
+  RuntimeAndFunctionType_,
+  FunctionVisibility_,
+  Args_,
+  Returns_,
+  Error_
 > {
-  /** @internal */
   readonly _tag: "Confect";
-  /** @internal */
-  readonly args: Schema.Codec<any, any>;
-  /** @internal */
+  readonly args: FunctionProvenance.ArgsSchema<ArgsFields_>;
   readonly returns: Schema.Codec<any, any>;
-  /** @internal */
   readonly kind: FunctionProvenance.ConfectKind;
-  /** @internal */
   readonly middlewareSpecs: ReadonlyArray<MiddlewareSpec.AnyMiddlewareSpec>;
-  /** @internal */
   readonly error?: Schema.Codec<any, any>;
 }
 
 export interface ConvexRef<
-  _RuntimeAndFunctionType extends RuntimeAndFunctionType.RuntimeAndFunctionType,
-  _FunctionVisibility extends FunctionVisibility,
-  _Args,
-  _Returns,
-  _Error = never,
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
+  FunctionVisibility_ extends FunctionVisibility,
+  Args_ extends DefaultFunctionArgs,
+  Returns_,
+  Error_ = never,
 > extends Base<
-  _RuntimeAndFunctionType,
-  _FunctionVisibility,
-  _Args,
-  _Returns,
-  _Error
+  RuntimeAndFunctionType_,
+  FunctionVisibility_,
+  Args_,
+  Returns_,
+  Error_
 > {
-  /** @internal */
   readonly _tag: "Convex";
 }
 
 export type Any = Ref<any, any, any, any, any>;
 
+/** Erased Confect-provenance ref used by provenance-specific APIs. */
+export type AnyConfect = Extract<Any, { readonly _tag: "Confect" }>;
+
 export type AnyInternal = Ref<any, "internal", any, any, any>;
 
 export type AnyPublic = Ref<any, "public", any, any, any>;
@@ -118,16 +138,17 @@ export type AnyQuery = Ref<
   any
 >;
 
-export type AnyPublicPaginatedQuery = Ref<
-  RuntimeAndFunctionType.AnyQuery,
-  "public",
-  {
-    [key: string]: any;
-    paginationOpts: PaginationOptions;
-  },
-  PaginationResult<any>,
-  any
->;
+export type AnyPaginatedQuery = AnyQuery &
+  Base<
+    RuntimeAndFunctionType.AnyQuery,
+    FunctionVisibility,
+    {
+      [key: string]: any;
+      paginationOpts: PaginationOptions;
+    },
+    PaginationResult<any>,
+    any
+  >;
 
 export type AnyMutation = Ref<
   RuntimeAndFunctionType.AnyMutation,
@@ -153,6 +174,13 @@ export type AnyPublicQuery = Ref<
   any
 >;
 
+export type AnyConfectPublicQuery = Extract<AnyPublicQuery, AnyConfect>;
+
+export type AnyPublicPaginatedQuery = AnyPublicQuery & AnyPaginatedQuery;
+
+export type AnyConfectPublicPaginatedQuery = AnyConfectPublicQuery &
+  AnyPublicPaginatedQuery;
+
 export type AnyPublicMutation = Ref<
   RuntimeAndFunctionType.AnyMutation,
   "public",
@@ -161,6 +189,8 @@ export type AnyPublicMutation = Ref<
   any
 >;
 
+export type AnyConfectPublicMutation = Extract<AnyPublicMutation, AnyConfect>;
+
 export type AnyPublicAction = Ref<
   RuntimeAndFunctionType.AnyAction,
   "public",
@@ -169,86 +199,62 @@ export type AnyPublicAction = Ref<
   any
 >;
 
-export type GetRuntimeAndFunctionType<Ref_> =
-  Ref_ extends Base<
-    infer RuntimeAndFunctionType_,
-    infer _FunctionVisibility,
-    infer _Args,
-    infer _Returns,
-    infer _Error
-  >
-    ? RuntimeAndFunctionType_
-    : never;
-
-export type GetRuntime<Ref_> =
-  Ref_ extends Base<
-    infer RuntimeAndFunctionType_,
-    infer _FunctionVisibility,
-    infer _Args,
-    infer _Returns,
-    infer _Error
-  >
-    ? RuntimeAndFunctionType.GetRuntime<RuntimeAndFunctionType_>
-    : never;
-
-export type GetFunctionType<Ref_> =
-  Ref_ extends Base<
-    infer RuntimeAndFunctionType_,
-    infer _FunctionVisibility,
-    infer _Args,
-    infer _Returns,
-    infer _Error
-  >
-    ? RuntimeAndFunctionType.GetFunctionType<RuntimeAndFunctionType_>
-    : never;
-
-export type GetFunctionVisibility<Ref_> =
-  Ref_ extends Base<
-    infer _RuntimeAndFunctionType,
-    infer FunctionVisibility_,
-    infer _Args,
-    infer _Returns,
-    infer _Error
-  >
-    ? FunctionVisibility_
-    : never;
-
-export type Args<Ref_> =
-  Ref_ extends Base<
-    infer _RuntimeAndFunctionType,
-    infer _FunctionVisibility,
-    infer Args_,
-    infer _Returns,
-    infer _Error
-  >
-    ? Args_
-    : never;
+export type AnyConfectPublicAction = Extract<AnyPublicAction, AnyConfect>;
+
+export type GetRuntimeAndFunctionType<Ref_> = Ref_ extends {
+  readonly "~RuntimeAndFunctionType": infer RuntimeAndFunctionType_ extends
+    RuntimeAndFunctionType.RuntimeAndFunctionType;
+}
+  ? RuntimeAndFunctionType_
+  : never;
+
+export type GetRuntime<Ref_> = RuntimeAndFunctionType.GetRuntime<
+  GetRuntimeAndFunctionType<Ref_>
+>;
+
+export type GetFunctionType<Ref_> = RuntimeAndFunctionType.GetFunctionType<
+  GetRuntimeAndFunctionType<Ref_>
+>;
+
+export type GetFunctionVisibility<Ref_> = Ref_ extends {
+  readonly "~FunctionVisibility": infer FunctionVisibility_;
+}
+  ? FunctionVisibility_
+  : never;
+
+export type Args<Ref_> = Ref_ extends { readonly "~Args": infer Args_ }
+  ? Args_
+  : never;
+
+/** The field map captured by a Confect-provenance ref. */
+export type ArgsFields<Ref_> = Ref_ extends {
+  readonly _tag: "Confect";
+  readonly args: {
+    readonly fields: infer ArgsFields_ extends FunctionProvenance.ArgsFields;
+  };
+}
+  ? ArgsFields_
+  : never;
+
+/** The assembled args schema carried by a Confect-provenance ref. */
+export type ArgsSchema<Ref_> = Ref_ extends {
+  readonly _tag: "Confect";
+  readonly args: infer ArgsSchema_ extends FunctionProvenance.AnyArgsSchema;
+}
+  ? ArgsSchema_
+  : never;
 
 export type OptionalArgs<Ref_ extends Any> = keyof Args<Ref_> extends never
   ? [args?: Args<Ref_>]
   : [args: Args<Ref_>];
 
-export type Returns<Ref_> =
-  Ref_ extends Base<
-    infer _RuntimeAndFunctionType,
-    infer _FunctionVisibility,
-    infer _Args,
-    infer Returns_,
-    infer _Error
-  >
-    ? Returns_
-    : never;
-
-export type Error<Ref_> =
-  Ref_ extends Base<
-    infer _RuntimeAndFunctionType,
-    infer _FunctionVisibility,
-    infer _Args,
-    infer _Returns,
-    infer Error_
-  >
-    ? Error_
-    : never;
+export type Returns<Ref_> = Ref_ extends { readonly "~Returns": infer Returns_ }
+  ? Returns_
+  : never;
+
+export type Error<Ref_> = Ref_ extends { readonly "~Error": infer Error_ }
+  ? Error_
+  : never;
 
 export type FunctionReference<Ref_ extends Any> = ConvexFunctionReference<
   GetFunctionType<Ref_>,
@@ -262,6 +268,7 @@ export type FromFunctionSpec<
   FunctionSpec_,
   FunctionSpec.GetRuntimeAndFunctionType<FunctionSpec_>,
   FunctionSpec.GetFunctionVisibility<FunctionSpec_>,
+  FunctionSpec.ArgsFields<FunctionSpec_>,
   FunctionSpec.Args<FunctionSpec_>,
   FunctionSpec.Returns<FunctionSpec_>,
   FunctionSpec.Error<FunctionSpec_> | MiddlewareError
@@ -271,7 +278,8 @@ type FromFunctionSpecHelper<
   FunctionSpec_ extends FunctionSpec.AnyWithProps,
   RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
   FunctionVisibility_ extends FunctionVisibility,
-  Args_,
+  ArgsFields_ extends FunctionProvenance.ArgsFields,
+  Args_ extends DefaultFunctionArgs,
   Returns_,
   Error_,
 > =
@@ -282,17 +290,18 @@ type FromFunctionSpecHelper<
     ? ConvexRef<
         RuntimeAndFunctionType_,
         FunctionVisibility_,
-        Args_,
+        Args_ extends DefaultFunctionArgs ? Args_ : never,
         Returns_,
-        Error_
+        never
       >
     : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<
           FunctionSpec_,
           FunctionProvenance.AnyConfect
         >
-      ? ConfectRef<
+      ? ConfectRefWithTypes<
           RuntimeAndFunctionType_,
           FunctionVisibility_,
+          ArgsFields_,
           Args_,
           Returns_,
           Error_
@@ -318,10 +327,14 @@ export const make = <FunctionSpec_ extends FunctionSpec.AnyWithProps>(
   const convexFunctionName = `${convexFunctionNamespace}:${functionSpec.name}`;
 
   return Match.value(functionSpec.functionProvenance).pipe(
-    Match.tag("Convex", (): Any => ({
-      _tag: "Convex",
-      convexFunctionName,
-    })),
+    Match.tag(
+      "Convex",
+      (): Any =>
+        ({
+          _tag: "Convex",
+          convexFunctionName,
+        }) as Any,
+    ),
     Match.tag("Confect", (provenance): Any => {
       const ref = {
         _tag: "Confect" as const,
@@ -557,14 +570,12 @@ const missingPaginatedProvenanceError = (ref: Any) =>
       "those constructors store. Define the function as, e.g.:\n\n" +
       "  FunctionSpec.publicPaginatedQuery({\n" +
       '    name: "...",\n' +
-      "    args: () => Schema.Struct({ ... }), // optional; without paginationOpts\n" +
+      "    args: () => ({ ... }), // optional; without paginationOpts\n" +
       "    item: () => ItemSchema,\n" +
       "  })",
   );
 
-const paginatedKind = (
-  ref: ConfectRef<any, any, any, any, any>,
-): FunctionProvenance.Paginated =>
+const paginatedKind = (ref: AnyConfect): FunctionProvenance.Paginated =>
   Match.value(ref.kind).pipe(
     Match.tag("Paginated", (kind) => kind),
     Match.tag("Standard", () => {

package/src/Refs.ts

@@ -42,6 +42,7 @@ type FunctionSpecMatchesPredicate<
     FunctionSpec.GetRuntimeAndFunctionType<FunctionSpec_>,
     FunctionSpec.GetFunctionVisibility<FunctionSpec_>,
     any,
+    any,
     any
   > extends Predicate
     ? true