@gaganref/confect-core 10.3.1-fork.3 → 10.3.1-fork.30

package/src/Profile.ts

@@ -0,0 +1,141 @@
+import type * as Schema from "effect/Schema";
+import type * as FunctionProvenance from "./FunctionProvenance.js";
+import type * as MiddlewareSpec from "./MiddlewareSpec.js";
+
+/**
+ * A type-level function from a function's name and args fields to the fields a
+ * profile's builders require. Read `this["Name"]` and `this["Args"]` directly
+ * in `Type`, passing them to a type alias; a nested object type cannot name
+ * `this`.
+ */
+export interface Fields {
+  readonly Name: string;
+  // `unknown`, not `ArgsFields`: an index signature here would leak into
+  // `keyof this["Args"]`.
+  readonly Args: unknown;
+  readonly Type: object;
+}
+
+export interface NoFields extends Fields {
+  readonly Type: {};
+}
+
+export type Apply<
+  Fields_ extends Fields,
+  Name_ extends string,
+  Args_,
+> = (Fields_ & { readonly Name: Name_; readonly Args: Args_ })["Type"];
+
+/**
+ * A base profile's fields and its extension's, for one function.
+ */
+export interface Both<
+  Base extends Fields,
+  Extension extends Fields,
+> extends Fields {
+  readonly Type: Apply<Base, this["Name"], this["Args"]> &
+    Apply<Extension, this["Name"], this["Args"]>;
+}
+
+/**
+ * What a profile callback sees. `args` stays a thunk.
+ */
+export interface Info<FieldsType> {
+  readonly name: string;
+  readonly description?: string;
+  readonly args: () => FunctionProvenance.ArgsFields;
+  readonly fields: "description" extends keyof FieldsType
+    ? Omit<FieldsType, "description">
+    : FieldsType;
+}
+
+export interface Attachment<
+  MiddlewareSpec_ extends MiddlewareSpec.AnyMiddlewareSpec,
+  FieldsType,
+> {
+  readonly spec: MiddlewareSpec_;
+  readonly options: (
+    info: Info<FieldsType>,
+  ) => MiddlewareSpec.Options<MiddlewareSpec_>;
+}
+
+/**
+ * A middleware without options has none to compute and is attached at most
+ * once, so it joins a profile's list directly.
+ */
+type TakesOptions<MiddlewareSpec_ extends MiddlewareSpec.AnyMiddlewareSpec> = [
+  MiddlewareSpec.WithoutOptions<MiddlewareSpec_>,
+] extends [never]
+  ? unknown
+  : MiddlewareSpec.AttachmentError<`Middleware "${MiddlewareSpec.Key<MiddlewareSpec_>}" takes no options, so list it without Profile.attach`>;
+
+/**
+ * Attach a middleware that takes options to every function a profile builds,
+ * with options computed from each function's fields.
+ */
+export const attach = <
+  MiddlewareSpec_ extends MiddlewareSpec.AnyMiddlewareSpec,
+  FieldsType,
+>(
+  spec: MiddlewareSpec_ & TakesOptions<MiddlewareSpec_>,
+  options: (
+    info: Info<FieldsType>,
+  ) => MiddlewareSpec.Options<NoInfer<MiddlewareSpec_>>,
+): Attachment<MiddlewareSpec_, FieldsType> => ({ spec, options });
+
+/**
+ * A type function for a schema wrapper, applied to each declared codec.
+ */
+export interface SchemaTransform {
+  readonly Input: Schema.Codec<unknown, unknown>;
+  readonly Type: Schema.Codec<any, any>;
+}
+
+/**
+ * Args wrappers transform the declared field map, before Struct composition.
+ */
+export interface ArgsTransform {
+  readonly Input: unknown;
+  readonly Type: FunctionProvenance.ArgsFields;
+}
+
+export interface Transforms {
+  readonly args?: ArgsTransform;
+  readonly returns?: SchemaTransform;
+  readonly item?: SchemaTransform;
+  readonly error?: SchemaTransform;
+}
+
+export type Transform<T, Input> = (T & { readonly Input: Input })["Type" &
+  keyof T];
+
+/**
+ * Error wrappers opt into Schema.Never when no error thunk was declared.
+ */
+export type Wrappers<T extends Transforms, FieldsType> = {
+  readonly [K in keyof T]-?: K extends keyof Transforms
+    ? <
+        Input extends (K extends "args"
+          ? FunctionProvenance.ArgsFields
+          : Schema.Codec<any, any>),
+      >(
+        thunk: () => Input,
+        info: Info<FieldsType>,
+      ) => () => Transform<T[K], Input>
+    : never;
+} & { readonly [K in Exclude<keyof Transforms, keyof T>]?: never };
+
+type NonemptyError<T extends Transforms> = T extends {
+  readonly error: infer E extends SchemaTransform;
+}
+  ? [Transform<E, typeof Schema.Never>["Type"]] extends [never]
+    ? MiddlewareSpec.AttachmentError<"Profile error wrapper must add an error to Schema.Never">
+    : unknown
+  : unknown;
+
+export type SchemaConfig<T extends Transforms, FieldsType> = ([
+  keyof T,
+] extends [never]
+  ? { readonly schemas?: never }
+  : { readonly schemas: Wrappers<T, FieldsType> }) &
+  NonemptyError<T>;

package/src/Ref.ts

@@ -1,4 +1,4 @@
-import type * as MiddlewareAttachment from "./MiddlewareAttachment";
+import type * as MiddlewareAttachment from "./MiddlewareAttachment.js";
 import type {
   DefaultFunctionArgs,
   FunctionReference as ConvexFunctionReference,
@@ -14,11 +14,11 @@ import * as Match from "effect/Match";
 import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
 import * as Schema from "effect/Schema";
-import type * as FunctionProvenance from "./FunctionProvenance";
-import type * as FunctionSpec from "./FunctionSpec";
-import * as Lazy from "./Lazy";
-import * as MiddlewareSpec from "./MiddlewareSpec";
-import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
+import type * as FunctionProvenance from "./FunctionProvenance.js";
+import type * as FunctionSpec from "./FunctionSpec.js";
+import * as Lazy from "./Lazy.js";
+import * as MiddlewareSpec from "./MiddlewareSpec.js";
+import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType.js";
 
 export const TypeId = "~@confect/core/Ref";
 export type TypeId = typeof TypeId;
@@ -41,6 +41,7 @@ export interface Base<
     : (args: Args_) => void;
   readonly "~Returns": Returns_;
   readonly "~Error": Error_;
+  readonly functionType?: RuntimeAndFunctionType_["functionType"];
   readonly convexFunctionName: string;
   /**
    * Preserved for component references and function handles, which have no
@@ -447,14 +448,18 @@ export const make = <
         ({
           [TypeId]: TypeId,
           _tag: "Convex",
+          functionType: functionSpec.runtimeAndFunctionType.functionType,
           convexFunctionName,
         }) as Any,
     ),
     Match.tag("Confect", (provenance): Any =>
-      fromProvenance(convexFunctionName, provenance, [
-        ...groupMiddlewareAttachments,
-        ...functionSpec.middlewareAttachments,
-      ]),
+      fromProvenance(
+        convexFunctionName,
+        provenance,
+        [...groupMiddlewareAttachments, ...functionSpec.middlewareAttachments],
+        undefined,
+        functionSpec.runtimeAndFunctionType.functionType,
+      ),
     ),
     Match.exhaustive,
   ) as FromFunctionSpec<
@@ -476,10 +481,12 @@ export const fromProvenance = (
   provenance: FunctionProvenance.AnyConfect,
   middlewareAttachments: ReadonlyArray<MiddlewareAttachment.MiddlewareAttachment>,
   functionReference?: ConvexFunctionReference<any, any>,
+  functionType?: "query" | "mutation" | "action",
 ): AnyConfect => {
   const ref = {
     [TypeId]: TypeId as TypeId,
     _tag: "Confect" as const,
+    ...(functionType === undefined ? {} : { functionType }),
     convexFunctionName,
     ...(functionReference === undefined ? {} : { functionReference }),
     kind: provenance.kind,
@@ -532,6 +539,7 @@ export const fromFunctionReference = <
   Returns_,
 >(
   functionReference: ConvexFunctionReference<Type, Visibility, Args_, Returns_>,
+  functionType?: NoInfer<Type>,
 ): ConvexRef<
   Extract<
     RuntimeAndFunctionType.RuntimeAndFunctionType,
@@ -545,6 +553,7 @@ export const fromFunctionReference = <
   return {
     [TypeId]: TypeId,
     _tag: "Convex",
+    ...(functionType === undefined ? {} : { functionType }),
     convexFunctionName:
       address.name ??
       address.reference ??

package/src/Refs.ts

@@ -2,11 +2,11 @@ import type { Types } from "effect";
 import { pipe } from "effect/Function";
 import * as Option from "effect/Option";
 import * as Record from "effect/Record";
-import type * as FunctionSpec from "./FunctionSpec";
-import type * as GroupSpec from "./GroupSpec";
-import type * as MiddlewareSpec from "./MiddlewareSpec";
-import * as Ref from "./Ref";
-import * as Spec from "./Spec";
+import type * as FunctionSpec from "./FunctionSpec.js";
+import type * as GroupSpec from "./GroupSpec.js";
+import type * as MiddlewareSpec from "./MiddlewareSpec.js";
+import * as Ref from "./Ref.js";
+import * as Spec from "./Spec.js";
 
 export type Refs<
   Spec_ extends Spec.AnyWithProps,

package/src/SchemaToValidator.ts

@@ -1,4 +1,4 @@
-import * as IdScope from "./IdScope";
+import * as IdScope from "./IdScope.js";
 import type {
   GenericId as ConvexGenericId,
   PropertyValidators,
@@ -30,7 +30,7 @@ import * as Schema from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 import * as String from "effect/String";
 
-import * as GenericId from "./GenericId";
+import * as GenericId from "./GenericId.js";
 import type {
   IsAny,
   IsOptional,
@@ -39,7 +39,7 @@ import type {
   IsUnion,
   TypeError,
   UnionToTuple,
-} from "./Types";
+} from "./Types.js";
 
 // Args
 

package/src/Spec.ts

@@ -1,6 +1,6 @@
 import * as Predicate from "effect/Predicate";
 import * as Record from "effect/Record";
-import * as GroupSpec from "./GroupSpec";
+import * as GroupSpec from "./GroupSpec.js";
 
 export const TypeId = "~@confect/core/Spec";
 export type TypeId = typeof TypeId;

package/src/SystemFields.ts

@@ -1,4 +1,4 @@
-import type * as IdScope from "./IdScope";
+import type * as IdScope from "./IdScope.js";
 import type { SystemFields as NonIdSystemFields } from "convex/server";
 import { pipe } from "effect/Function";
 import * as Array from "effect/Array";
@@ -11,7 +11,7 @@ import * as SchemaAST from "effect/SchemaAST";
 import * as SchemaGetter from "effect/SchemaGetter";
 import * as SchemaTransformation from "effect/SchemaTransformation";
 import * as Struct from "effect/Struct";
-import * as GenericId from "./GenericId";
+import * as GenericId from "./GenericId.js";
 
 /**
  * Produces a schema for Convex system fields. In Confect, system fields include

package/src/Table.ts

@@ -1,7 +1,7 @@
-import * as IdScope from "./IdScope";
-import * as Lazy from "./Lazy";
-import * as SystemFields from "./SystemFields";
-import type { TableSchemaToTableValidator } from "./SchemaToValidator";
+import * as IdScope from "./IdScope.js";
+import * as Lazy from "./Lazy.js";
+import * as SystemFields from "./SystemFields.js";
+import type { TableSchemaToTableValidator } from "./SchemaToValidator.js";
 import type {
   SystemFields as ConvexSystemFields,
   Expand,

package/src/index.ts

@@ -1,29 +1,31 @@
-export * as Callback from "./Callback";
-export * as FunctionProvenance from "./FunctionProvenance";
-export * as FunctionSpec from "./FunctionSpec";
-export * as GenericId from "./GenericId";
-export * as App from "./App";
-export * as Auth from "./Auth";
-export * as Component from "./Component";
-export * as Env from "./Env";
-export * as Http from "./Http";
-export * as IdScope from "./IdScope";
-export * as GroupPath from "./GroupPath";
-export * as GroupSpec from "./GroupSpec";
-export * as Identifier from "./Identifier";
-export * as Lazy from "./Lazy";
-export * as Manifest from "./Manifest";
-export * as MiddlewareAttachment from "./MiddlewareAttachment";
-export * as MiddlewareSpec from "./MiddlewareSpec";
-export * as PaginationError from "./PaginationError";
-export * as PaginationOptions from "./PaginationOptions";
-export * as PaginationResult from "./PaginationResult";
-export * as Ref from "./Ref";
-export * as Refs from "./Refs";
-export * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
-export * as SchemaToValidator from "./SchemaToValidator";
-export * as Spec from "./Spec";
-export * as SystemFields from "./SystemFields";
-export * as Table from "./Table";
-export * as Types from "./Types";
-export * as UserIdentity from "./UserIdentity";
+export * as ActionCall from "./ActionCall.js";
+export * as Callback from "./Callback.js";
+export * as FunctionProvenance from "./FunctionProvenance.js";
+export * as FunctionSpec from "./FunctionSpec.js";
+export * as GenericId from "./GenericId.js";
+export * as App from "./App.js";
+export * as Auth from "./Auth.js";
+export * as Component from "./Component.js";
+export * as Env from "./Env.js";
+export * as Http from "./Http.js";
+export * as IdScope from "./IdScope.js";
+export * as GroupPath from "./GroupPath.js";
+export * as GroupSpec from "./GroupSpec.js";
+export * as Identifier from "./Identifier.js";
+export * as Lazy from "./Lazy.js";
+export * as Manifest from "./Manifest.js";
+export * as MiddlewareAttachment from "./MiddlewareAttachment.js";
+export * as MiddlewareSpec from "./MiddlewareSpec.js";
+export * as PaginationError from "./PaginationError.js";
+export * as PaginationOptions from "./PaginationOptions.js";
+export * as PaginationResult from "./PaginationResult.js";
+export * as Profile from "./Profile.js";
+export * as Ref from "./Ref.js";
+export * as Refs from "./Refs.js";
+export * as RuntimeAndFunctionType from "./RuntimeAndFunctionType.js";
+export * as SchemaToValidator from "./SchemaToValidator.js";
+export * as Spec from "./Spec.js";
+export * as SystemFields from "./SystemFields.js";
+export * as Table from "./Table.js";
+export * as Types from "./Types.js";
+export * as UserIdentity from "./UserIdentity.js";