fluent-convex 0.7.2 → 0.8.0

package/src/ConvexBuilder.ts

@@ -1,129 +1,95 @@
 import type { GenericDataModel } from "convex/server";
-import { InferredArgs } from "./types";
-import { InferHandlerReturn } from "./types";
 import { ConvexBuilderDef } from "./types";
-import { CallableBuilder } from "./types";
-import { ConvexBuilderWithHandler } from "./ConvexBuilderWithHandler";
-import type { ConvexMiddleware, AnyConvexMiddleware } from "./middleware";
+import { ConvexBuilderWithFunctionKind } from "./ConvexBuilderWithFunctionKind";
+import type { ConvexMiddleware } from "./middleware";
 import type {
-  FunctionType,
-  Context,
-  EmptyObject,
-  ConvexArgsValidator,
-  ConvexReturnsValidator,
   QueryCtx,
   MutationCtx,
   ActionCtx,
+  Context,
+  EmptyObject,
 } from "./types";
-import {
-  type ValidatorInput,
-  type ToConvexArgsValidator,
-  isZodSchema,
-  toConvexValidator,
-  type ReturnsValidatorInput,
-  type ToConvexReturnsValidator,
-} from "./zod_support";
 
 export class ConvexBuilder<
   TDataModel extends GenericDataModel = GenericDataModel,
-  TFunctionType extends FunctionType | undefined = undefined,
-  TInitialContext extends Context = EmptyObject,
-  TCurrentContext extends Context = EmptyObject,
-  TArgsValidator extends ConvexArgsValidator | undefined = undefined,
-  TReturnsValidator extends ConvexReturnsValidator | undefined = undefined,
 > {
-  protected def: ConvexBuilderDef<
-    TFunctionType,
-    TArgsValidator,
-    TReturnsValidator
-  >;
+  private def: ConvexBuilderDef<undefined, undefined, undefined, "public">;
 
   constructor(
-    def: ConvexBuilderDef<TFunctionType, TArgsValidator, TReturnsValidator>
+    def: ConvexBuilderDef<undefined, undefined, undefined, "public">
   ) {
     this.def = def;
   }
 
-  query(
-    this: ConvexBuilder<
-      TDataModel,
-      undefined,
-      TInitialContext,
-      TCurrentContext,
-      TArgsValidator,
-      TReturnsValidator
-    >
-  ): ConvexBuilder<
+  query(): ConvexBuilderWithFunctionKind<
     TDataModel,
     "query",
     QueryCtx<TDataModel>,
     QueryCtx<TDataModel>
   > {
-    return new ConvexBuilder({
+    return new ConvexBuilderWithFunctionKind<
+      TDataModel,
+      "query",
+      QueryCtx<TDataModel>,
+      QueryCtx<TDataModel>
+    >({
       ...this.def,
       functionType: "query",
-    }) as any;
+    });
   }
 
-  mutation(
-    this: ConvexBuilder<
-      TDataModel,
-      undefined,
-      TInitialContext,
-      TCurrentContext,
-      TArgsValidator,
-      TReturnsValidator
-    >
-  ): ConvexBuilder<
+  mutation(): ConvexBuilderWithFunctionKind<
     TDataModel,
     "mutation",
     MutationCtx<TDataModel>,
     MutationCtx<TDataModel>
   > {
-    return new ConvexBuilder({
+    return new ConvexBuilderWithFunctionKind<
+      TDataModel,
+      "mutation",
+      MutationCtx<TDataModel>,
+      MutationCtx<TDataModel>
+    >({
       ...this.def,
       functionType: "mutation",
-    }) as any;
+    });
   }
 
-  action(
-    this: ConvexBuilder<
-      TDataModel,
-      undefined,
-      TInitialContext,
-      TCurrentContext,
-      TArgsValidator,
-      TReturnsValidator
-    >
-  ): ConvexBuilder<
+  action(): ConvexBuilderWithFunctionKind<
     TDataModel,
     "action",
     ActionCtx<TDataModel>,
     ActionCtx<TDataModel>
   > {
-    return new ConvexBuilder({
+    return new ConvexBuilderWithFunctionKind<
+      TDataModel,
+      "action",
+      ActionCtx<TDataModel>,
+      ActionCtx<TDataModel>
+    >({
       ...this.def,
       functionType: "action",
-    }) as any;
+    });
   }
 
-  $context<U extends Context>(): ConvexBuilder<
-    TDataModel,
-    TFunctionType,
-    U & EmptyObject,
-    U,
-    TArgsValidator,
-    TReturnsValidator
-  > {
-    return new ConvexBuilder({
-      ...this.def,
-      middlewares: [],
-    }) as any;
+  $context<U extends Context>(): {
+    middleware<UOutContext extends Context>(
+      middleware: ConvexMiddleware<U, UOutContext>
+    ): ConvexMiddleware<U, UOutContext>;
+  } {
+    // Return an object that allows middleware creation with a specific context type
+    return {
+      middleware<UOutContext extends Context>(
+        middleware: ConvexMiddleware<U, UOutContext>
+      ): ConvexMiddleware<U, UOutContext> {
+        return middleware;
+      },
+    };
   }
 
   middleware<UOutContext extends Context>(
-    middleware: ConvexMiddleware<TInitialContext, UOutContext>
-  ): ConvexMiddleware<TInitialContext, UOutContext>;
+    middleware: ConvexMiddleware<EmptyObject, UOutContext>
+  ): ConvexMiddleware<EmptyObject, UOutContext>;
   middleware<UInContext extends Context, UOutContext extends Context>(
     middleware: ConvexMiddleware<UInContext, UOutContext>
   ): ConvexMiddleware<UInContext, UOutContext>;
@@ -132,146 +98,4 @@ export class ConvexBuilder<
   ): ConvexMiddleware<UInContext, UOutContext> {
     return middleware;
   }
-
-  use<UOutContext extends Context>(
-    this: ConvexBuilder<
-      TDataModel,
-      FunctionType,
-      TInitialContext,
-      TCurrentContext,
-      TArgsValidator,
-      TReturnsValidator
-    >,
-    middleware: ConvexMiddleware<TCurrentContext, UOutContext>
-  ): ConvexBuilder<
-    TDataModel,
-    TFunctionType,
-    TInitialContext,
-    TCurrentContext & UOutContext,
-    TArgsValidator,
-    TReturnsValidator
-  > {
-    return new ConvexBuilder({
-      ...this.def,
-      middlewares: [...this.def.middlewares, middleware as AnyConvexMiddleware],
-    }) as any;
-  }
-
-  input<UInput extends ValidatorInput>(
-    this: ConvexBuilder<
-      TDataModel,
-      FunctionType,
-      TInitialContext,
-      TCurrentContext,
-      TArgsValidator,
-      TReturnsValidator
-    >,
-    validator: UInput
-  ): ConvexBuilder<
-    TDataModel,
-    TFunctionType,
-    TInitialContext,
-    TCurrentContext,
-    ToConvexArgsValidator<UInput>,
-    TReturnsValidator
-  > {
-    const convexValidator = (
-      isZodSchema(validator) ? toConvexValidator(validator) : validator
-    ) as ToConvexArgsValidator<UInput>;
-
-    return new ConvexBuilder({
-      ...this.def,
-      argsValidator: convexValidator,
-    }) as any;
-  }
-
-  returns<UReturns extends ReturnsValidatorInput>(
-    this: ConvexBuilder<
-      TDataModel,
-      FunctionType,
-      TInitialContext,
-      TCurrentContext,
-      TArgsValidator,
-      TReturnsValidator
-    >,
-    validator: UReturns
-  ): ConvexBuilder<
-    TDataModel,
-    TFunctionType,
-    TInitialContext,
-    TCurrentContext,
-    TArgsValidator,
-    ToConvexReturnsValidator<UReturns>
-  > {
-    const convexValidator = (
-      isZodSchema(validator) ? toConvexValidator(validator) : validator
-    ) as ToConvexReturnsValidator<UReturns>;
-
-    return new ConvexBuilder({
-      ...this.def,
-      returnsValidator: convexValidator,
-    }) as any;
-  }
-
-  handler<
-    TReturn extends InferHandlerReturn<
-      TReturnsValidator,
-      any
-    > = InferHandlerReturn<TReturnsValidator, any>,
-  >(
-    this: ConvexBuilder<
-      TDataModel,
-      FunctionType,
-      TInitialContext,
-      TCurrentContext,
-      TArgsValidator,
-      TReturnsValidator
-    >,
-    handlerFn: (options: {
-      context: TCurrentContext;
-      input: InferredArgs<TArgsValidator>;
-    }) => Promise<TReturn>
-  ): ConvexBuilderWithHandler<
-    TDataModel,
-    TFunctionType & FunctionType,
-    TCurrentContext,
-    TArgsValidator,
-    TReturnsValidator,
-    InferHandlerReturn<TReturnsValidator, TReturn>
-  > &
-    CallableBuilder<
-      TCurrentContext,
-      TArgsValidator,
-      InferHandlerReturn<TReturnsValidator, TReturn>
-    > {
-    if (this.def.handler) {
-      throw new Error(
-        "Handler already defined. Only one handler can be set per function chain."
-      );
-    }
-
-    const rawHandler = async (
-      transformedCtx: Context,
-      baseArgs: InferredArgs<TArgsValidator>
-    ) => {
-      return handlerFn({
-        context: transformedCtx as TCurrentContext,
-        input: baseArgs,
-      });
-    };
-
-    type InferredReturn = InferHandlerReturn<TReturnsValidator, TReturn>;
-
-    return new ConvexBuilderWithHandler<
-      TDataModel,
-      TFunctionType & FunctionType,
-      TCurrentContext,
-      TArgsValidator,
-      TReturnsValidator,
-      InferredReturn
-    >({
-      ...this.def,
-      handler: rawHandler as any,
-    } as any) as any;
-  }
 }

package/src/ConvexBuilderWithFunctionKind.ts

@@ -0,0 +1,262 @@
+import type { GenericDataModel } from "convex/server";
+import { ConvexBuilderWithHandler } from "./ConvexBuilderWithHandler";
+import { InferredArgs } from "./types";
+import { ExpectedReturnType } from "./types";
+import { ConvexBuilderDef } from "./types";
+import { CallableBuilder } from "./types";
+import type { ConvexMiddleware, AnyConvexMiddleware } from "./middleware";
+import type {
+  FunctionType,
+  Context,
+  EmptyObject,
+  ConvexArgsValidator,
+  ConvexReturnsValidator,
+  Visibility,
+} from "./types";
+import {
+  type ValidatorInput,
+  type ToConvexArgsValidator,
+  isZodSchema,
+  toConvexValidator,
+  type ReturnsValidatorInput,
+  type ToConvexReturnsValidator,
+} from "./zod_support";
+
+export class ConvexBuilderWithFunctionKind<
+  TDataModel extends GenericDataModel = GenericDataModel,
+  TFunctionType extends FunctionType = FunctionType,
+  TInitialContext extends Context = EmptyObject,
+  TCurrentContext extends Context = EmptyObject,
+  TArgsValidator extends ConvexArgsValidator | undefined = undefined,
+  TReturnsValidator extends ConvexReturnsValidator | undefined = undefined,
+  TVisibility extends Visibility = "public",
+  THasHandler extends boolean = false,
+  THandlerReturn = any,
+> {
+  protected def: ConvexBuilderDef<
+    TFunctionType,
+    TArgsValidator,
+    TReturnsValidator,
+    TVisibility
+  >;
+
+  constructor(
+    def: ConvexBuilderDef<
+      TFunctionType,
+      TArgsValidator,
+      TReturnsValidator,
+      TVisibility
+    >
+  ) {
+    this.def = def;
+  }
+
+  $context<U extends Context>(): ConvexBuilderWithFunctionKind<
+    TDataModel,
+    TFunctionType,
+    U & EmptyObject,
+    U,
+    TArgsValidator,
+    TReturnsValidator,
+    TVisibility,
+    THasHandler,
+    THandlerReturn
+  > {
+    return new ConvexBuilderWithFunctionKind<
+      TDataModel,
+      TFunctionType,
+      U & EmptyObject,
+      U,
+      TArgsValidator,
+      TReturnsValidator,
+      TVisibility,
+      THasHandler,
+      THandlerReturn
+    >({
+      ...this.def,
+      middlewares: [],
+    });
+  }
+
+  middleware<UOutContext extends Context>(
+    middleware: ConvexMiddleware<TInitialContext, UOutContext>
+  ): ConvexMiddleware<TInitialContext, UOutContext>;
+  middleware<UInContext extends Context, UOutContext extends Context>(
+    middleware: ConvexMiddleware<UInContext, UOutContext>
+  ): ConvexMiddleware<UInContext, UOutContext>;
+  middleware<UInContext extends Context, UOutContext extends Context>(
+    middleware: ConvexMiddleware<UInContext, UOutContext>
+  ): ConvexMiddleware<UInContext, UOutContext> {
+    return middleware;
+  }
+
+  use<UOutContext extends Context>(
+    middleware: ConvexMiddleware<TCurrentContext, UOutContext>
+  ): ConvexBuilderWithFunctionKind<
+    TDataModel,
+    TFunctionType,
+    TInitialContext,
+    TCurrentContext & UOutContext,
+    TArgsValidator,
+    TReturnsValidator,
+    TVisibility,
+    THasHandler,
+    THandlerReturn
+  > {
+    return new ConvexBuilderWithFunctionKind<
+      TDataModel,
+      TFunctionType,
+      TInitialContext,
+      TCurrentContext & UOutContext,
+      TArgsValidator,
+      TReturnsValidator,
+      TVisibility,
+      THasHandler,
+      THandlerReturn
+    >({
+      ...this.def,
+      middlewares: [...this.def.middlewares, middleware as AnyConvexMiddleware],
+    });
+  }
+
+  input<UInput extends ValidatorInput>(
+    validator: UInput
+  ): ConvexBuilderWithFunctionKind<
+    TDataModel,
+    TFunctionType,
+    TInitialContext,
+    TCurrentContext,
+    ToConvexArgsValidator<UInput>,
+    TReturnsValidator,
+    TVisibility,
+    THasHandler,
+    THandlerReturn
+  > {
+    const convexValidator = isZodSchema(validator)
+      ? (toConvexValidator(validator) as ToConvexArgsValidator<UInput>)
+      : (validator as ToConvexArgsValidator<UInput>);
+
+    return new ConvexBuilderWithFunctionKind<
+      TDataModel,
+      TFunctionType,
+      TInitialContext,
+      TCurrentContext,
+      ToConvexArgsValidator<UInput>,
+      TReturnsValidator,
+      TVisibility,
+      THasHandler,
+      THandlerReturn
+    >({
+      ...this.def,
+      argsValidator: convexValidator,
+    });
+  }
+
+  returns<UReturns extends ReturnsValidatorInput>(
+    validator: UReturns
+  ): ConvexBuilderWithFunctionKind<
+    TDataModel,
+    TFunctionType,
+    TInitialContext,
+    TCurrentContext,
+    TArgsValidator,
+    ToConvexReturnsValidator<UReturns>,
+    TVisibility,
+    THasHandler,
+    THandlerReturn
+  > {
+    const convexValidator = isZodSchema(validator)
+      ? (toConvexValidator(validator) as ToConvexReturnsValidator<UReturns>)
+      : (validator as ToConvexReturnsValidator<UReturns>);
+
+    return new ConvexBuilderWithFunctionKind<
+      TDataModel,
+      TFunctionType,
+      TInitialContext,
+      TCurrentContext,
+      TArgsValidator,
+      ToConvexReturnsValidator<UReturns>,
+      TVisibility,
+      THasHandler,
+      THandlerReturn
+    >({
+      ...this.def,
+      returnsValidator: convexValidator,
+    });
+  }
+
+  handler<
+    TReturn extends [TReturnsValidator] extends [ConvexReturnsValidator]
+      ? ExpectedReturnType<TReturnsValidator>
+      : any = [TReturnsValidator] extends [ConvexReturnsValidator]
+      ? ExpectedReturnType<TReturnsValidator>
+      : any,
+  >(
+    handlerFn: (
+      context: TCurrentContext,
+      input: InferredArgs<TArgsValidator>
+    ) => Promise<TReturn>
+  ): ConvexBuilderWithHandler<
+    TDataModel,
+    TFunctionType,
+    TInitialContext,
+    TCurrentContext,
+    TArgsValidator,
+    TReturnsValidator,
+    TVisibility,
+    [TReturnsValidator] extends [ConvexReturnsValidator]
+      ? ExpectedReturnType<TReturnsValidator>
+      : TReturn
+  > &
+    CallableBuilder<
+      TCurrentContext,
+      TArgsValidator,
+      [TReturnsValidator] extends [ConvexReturnsValidator]
+        ? ExpectedReturnType<TReturnsValidator>
+        : TReturn
+    > {
+    if (this.def.handler) {
+      throw new Error(
+        "Handler already defined. Only one handler can be set per function chain."
+      );
+    }
+
+    // Store the raw handler function - it will be composed with all middlewares
+    // (including those added after .handler()) when .public() or .internal() is called
+    // The handler signature matches what Convex expects: (ctx, args) => Promise<return>
+    const rawHandler = async (
+      transformedCtx: Context,
+      baseArgs: InferredArgs<TArgsValidator>
+    ) => {
+      return handlerFn(transformedCtx as TCurrentContext, baseArgs);
+    };
+
+    type InferredReturn = [TReturnsValidator] extends [ConvexReturnsValidator]
+      ? ExpectedReturnType<TReturnsValidator>
+      : TReturn;
+
+    return new ConvexBuilderWithHandler<
+      TDataModel,
+      TFunctionType,
+      TInitialContext,
+      TCurrentContext,
+      TArgsValidator,
+      TReturnsValidator,
+      TVisibility,
+      InferredReturn
+    >({
+      ...this.def,
+      handler: rawHandler as any,
+    }) as ConvexBuilderWithHandler<
+      TDataModel,
+      TFunctionType,
+      TInitialContext,
+      TCurrentContext,
+      TArgsValidator,
+      TReturnsValidator,
+      TVisibility,
+      InferredReturn
+    > &
+      CallableBuilder<TCurrentContext, TArgsValidator, InferredReturn>;
+  }
+}