@confect/server 2.0.0 → 3.0.0

package/src/RegisteredConvexFunction.ts

@@ -1,3 +1,4 @@
+import type * as FunctionSpec from "@confect/core/FunctionSpec";
 import {
   actionGeneric,
   type DefaultFunctionArgs,
@@ -12,10 +13,12 @@ import {
 import { Effect, Layer, Match, pipe, Schema } from "effect";
 import type * as Api from "./Api";
 import * as Auth from "./Auth";
+import * as ConvexConfigProvider from "./ConvexConfigProvider";
 import * as DatabaseReader from "./DatabaseReader";
 import type * as DatabaseSchema from "./DatabaseSchema";
 import * as DatabaseWriter from "./DatabaseWriter";
 import type * as DataModel from "./DataModel";
+import type * as Handler from "./Handler";
 import * as MutationCtx from "./MutationCtx";
 import * as MutationRunner from "./MutationRunner";
 import * as QueryCtx from "./QueryCtx";
@@ -24,57 +27,65 @@ import * as RegisteredFunction from "./RegisteredFunction";
 import type * as RegistryItem from "./RegistryItem";
 import * as Scheduler from "./Scheduler";
 import * as SchemaToValidator from "./SchemaToValidator";
-import * as ConvexConfigProvider from "./ConvexConfigProvider";
 import { StorageReader, StorageWriter } from "./Storage";
 
 export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Convex">>(
   api: Api_,
-  { function_, handler }: RegistryItem.AnyWithProps,
-): RegisteredFunction.RegisteredFunction =>
-  Match.value(function_.runtimeAndFunctionType.functionType).pipe(
-    Match.when("query", () => {
-      const genericFunction = Match.value(function_.functionVisibility).pipe(
-        Match.when("public", () => queryGeneric),
-        Match.when("internal", () => internalQueryGeneric),
-        Match.exhaustive,
-      );
+  { functionSpec, handler }: RegistryItem.AnyWithProps,
+): RegisteredFunction.Any =>
+  Match.value(functionSpec.functionProvenance).pipe(
+    Match.tag("Convex", () => handler as RegisteredFunction.Any),
+    Match.tag("Confect", () => {
+      const { functionVisibility, functionProvenance } =
+        functionSpec as FunctionSpec.AnyConfect;
 
-      return genericFunction(
-        queryFunction(api.databaseSchema, {
-          args: function_.args,
-          returns: function_.returns,
-          handler,
+      return Match.value(functionSpec.runtimeAndFunctionType.functionType).pipe(
+        Match.when("query", () => {
+          const genericFunction = Match.value(functionVisibility).pipe(
+            Match.when("public", () => queryGeneric),
+            Match.when("internal", () => internalQueryGeneric),
+            Match.exhaustive,
+          );
+
+          return genericFunction(
+            queryFunction(api.databaseSchema, {
+              args: functionProvenance.args,
+              returns: functionProvenance.returns,
+              handler: handler as Handler.AnyConfectProvenance,
+            }),
+          );
         }),
-      );
-    }),
-    Match.when("mutation", () => {
-      const genericFunction = Match.value(function_.functionVisibility).pipe(
-        Match.when("public", () => mutationGeneric),
-        Match.when("internal", () => internalMutationGeneric),
-        Match.exhaustive,
-      );
+        Match.when("mutation", () => {
+          const genericFunction = Match.value(functionVisibility).pipe(
+            Match.when("public", () => mutationGeneric),
+            Match.when("internal", () => internalMutationGeneric),
+            Match.exhaustive,
+          );
 
-      return genericFunction(
-        mutationFunction(api.databaseSchema, {
-          args: function_.args,
-          returns: function_.returns,
-          handler,
+          return genericFunction(
+            mutationFunction(api.databaseSchema, {
+              args: functionProvenance.args,
+              returns: functionProvenance.returns,
+              handler: handler as Handler.AnyConfectProvenance,
+            }),
+          );
         }),
-      );
-    }),
-    Match.when("action", () => {
-      const genericFunction = Match.value(function_.functionVisibility).pipe(
-        Match.when("public", () => actionGeneric),
-        Match.when("internal", () => internalActionGeneric),
-        Match.exhaustive,
-      );
+        Match.when("action", () => {
+          const genericFunction = Match.value(functionVisibility).pipe(
+            Match.when("public", () => actionGeneric),
+            Match.when("internal", () => internalActionGeneric),
+            Match.exhaustive,
+          );
 
-      return genericFunction(
-        convexActionFunction(api.databaseSchema, {
-          args: function_.args,
-          returns: function_.returns,
-          handler,
+          return genericFunction(
+            convexActionFunction(api.databaseSchema, {
+              args: functionProvenance.args,
+              returns: functionProvenance.returns,
+              handler: handler as Handler.AnyConfectProvenance,
+            }),
+          );
         }),
+        Match.exhaustive,
       );
     }),
     Match.exhaustive,

package/src/RegisteredFunction.ts

@@ -1,3 +1,5 @@
+import type { FunctionSpec, RuntimeAndFunctionType } from "@confect/core";
+import type * as FunctionProvenance from "@confect/core/FunctionProvenance";
 import {
   type DefaultFunctionArgs,
   type FunctionVisibility,
@@ -19,11 +21,94 @@ import * as SchemaToValidator from "./SchemaToValidator";
 import { StorageActionWriter, StorageReader, StorageWriter } from "./Storage";
 import * as VectorSearch from "./VectorSearch";
 
-export type RegisteredFunction =
+export type Any =
   | RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any>
   | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any>
   | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;
 
+type ConfectRegisteredFunction<
+  FunctionSpec_ extends FunctionSpec.AnyWithProps,
+> =
+  FunctionSpec.EncodedArgs<FunctionSpec_> extends infer Args_ extends
+    DefaultFunctionArgs
+    ? RuntimeAndFunctionType.GetFunctionType<
+        FunctionSpec_["runtimeAndFunctionType"]
+      > extends "query"
+      ? RegisteredQuery<
+          FunctionSpec.GetFunctionVisibility<FunctionSpec_>,
+          Args_,
+          Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>
+        >
+      : RuntimeAndFunctionType.GetFunctionType<
+            FunctionSpec_["runtimeAndFunctionType"]
+          > extends "mutation"
+        ? RegisteredMutation<
+            FunctionSpec.GetFunctionVisibility<FunctionSpec_>,
+            Args_,
+            Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>
+          >
+        : RuntimeAndFunctionType.GetFunctionType<
+              FunctionSpec_["runtimeAndFunctionType"]
+            > extends "action"
+          ? RegisteredAction<
+              FunctionSpec.GetFunctionVisibility<FunctionSpec_>,
+              Args_,
+              Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>
+            >
+          : never
+    : never;
+
+export type ConvexRegisteredFunction<
+  FunctionSpec_ extends FunctionSpec.AnyWithProps,
+> = FunctionSpec_ extends {
+  functionProvenance: {
+    _tag: "Convex";
+    _args: infer Args_ extends DefaultFunctionArgs;
+    _returns: infer Returns_;
+  };
+}
+  ? RuntimeAndFunctionType.GetFunctionType<
+      FunctionSpec_["runtimeAndFunctionType"]
+    > extends "query"
+    ? RegisteredQuery<
+        FunctionSpec.GetFunctionVisibility<FunctionSpec_>,
+        Args_,
+        Returns_
+      >
+    : RuntimeAndFunctionType.GetFunctionType<
+          FunctionSpec_["runtimeAndFunctionType"]
+        > extends "mutation"
+      ? RegisteredMutation<
+          FunctionSpec.GetFunctionVisibility<FunctionSpec_>,
+          Args_,
+          Returns_
+        >
+      : RuntimeAndFunctionType.GetFunctionType<
+            FunctionSpec_["runtimeAndFunctionType"]
+          > extends "action"
+        ? RegisteredAction<
+            FunctionSpec.GetFunctionVisibility<FunctionSpec_>,
+            Args_,
+            Returns_
+          >
+        : never
+  : never;
+
+export type RegisteredFunction<
+  FunctionSpec_ extends FunctionSpec.AnyWithProps,
+> =
+  FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<
+    FunctionSpec_,
+    FunctionProvenance.AnyConvex
+  >
+    ? ConvexRegisteredFunction<FunctionSpec_>
+    : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<
+          FunctionSpec_,
+          FunctionProvenance.AnyConfect
+        >
+      ? ConfectRegisteredFunction<FunctionSpec_>
+      : never;
+
 export const actionFunctionBase = <
   Schema extends DatabaseSchema.AnyWithProps,
   Args,

package/src/RegisteredFunctions.ts

@@ -27,8 +27,8 @@ type RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {
             >]: FunctionSpec.WithName<
               GroupSpec.Functions<Group>,
               FunctionName
-            > extends infer Function extends FunctionSpec.AnyWithProps
-              ? FunctionSpec.RegisteredFunction<Function>
+            > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps
+              ? RegisteredFunction.RegisteredFunction<FunctionSpec_>
               : never;
           }
         >
@@ -38,15 +38,15 @@ type RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {
           >]: FunctionSpec.WithName<
             GroupSpec.Functions<Group>,
             FunctionName
-          > extends infer Function extends FunctionSpec.AnyWithProps
-            ? FunctionSpec.RegisteredFunction<Function>
+          > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps
+            ? RegisteredFunction.RegisteredFunction<FunctionSpec_>
             : never;
         }
     : never;
 };
 
 export interface AnyWithProps {
-  readonly [key: string]: RegisteredFunction.RegisteredFunction | AnyWithProps;
+  readonly [key: string]: RegisteredFunction.Any | AnyWithProps;
 }
 
 export const make = <Api_ extends Api.AnyWithProps>(
@@ -54,7 +54,7 @@ export const make = <Api_ extends Api.AnyWithProps>(
   makeRegisteredFunction: (
     api: Api_,
     registryItem: RegistryItem.AnyWithProps,
-  ) => RegisteredFunction.RegisteredFunction,
+  ) => RegisteredFunction.Any,
 ) =>
   Effect.gen(function* () {
     const registry = yield* Registry.Registry;
@@ -70,11 +70,10 @@ export const make = <Api_ extends Api.AnyWithProps>(
       ),
       Match.when("Finalized", () =>
         Effect.succeed(
-          mapLeaves<
-            RegistryItem.AnyWithProps,
-            RegisteredFunction.RegisteredFunction
-          >(functionImplItems, RegistryItem.isRegistryItem, (registryItem) =>
-            makeRegisteredFunction(api, registryItem),
+          mapLeaves<RegistryItem.AnyWithProps, RegisteredFunction.Any>(
+            functionImplItems,
+            RegistryItem.isRegistryItem,
+            (registryItem) => makeRegisteredFunction(api, registryItem),
           ) as RegisteredFunctions<Api_["spec"]>,
         ),
       ),

package/src/RegisteredNodeFunction.ts

@@ -1,3 +1,4 @@
+import type * as FunctionSpec from "@confect/core/FunctionSpec";
 import { NodeContext } from "@effect/platform-node";
 import {
   actionGeneric,
@@ -8,27 +9,36 @@ import type { Effect } from "effect";
 import { Layer, Match, type Schema } from "effect";
 import type * as Api from "./Api";
 import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as Handler from "./Handler";
 import * as RegisteredFunction from "./RegisteredFunction";
 import type * as RegistryItem from "./RegistryItem";
 
 export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Node">>(
   api: Api_,
-  { function_, handler }: RegistryItem.AnyWithProps,
-): RegisteredFunction.RegisteredFunction => {
-  const genericFunction = Match.value(function_.functionVisibility).pipe(
-    Match.when("public", () => actionGeneric),
-    Match.when("internal", () => internalActionGeneric),
-    Match.exhaustive,
-  );
+  { functionSpec, handler }: RegistryItem.AnyWithProps,
+): RegisteredFunction.Any =>
+  Match.value(functionSpec.functionProvenance).pipe(
+    Match.tag("Convex", () => handler as RegisteredFunction.Any),
+    Match.tag("Confect", () => {
+      const { functionVisibility, functionProvenance } =
+        functionSpec as FunctionSpec.AnyConfect;
 
-  return genericFunction(
-    nodeActionFunction(api.databaseSchema, {
-      args: function_.args,
-      returns: function_.returns,
-      handler,
+      const genericFunction = Match.value(functionVisibility).pipe(
+        Match.when("public", () => actionGeneric),
+        Match.when("internal", () => internalActionGeneric),
+        Match.exhaustive,
+      );
+
+      return genericFunction(
+        nodeActionFunction(api.databaseSchema, {
+          args: functionProvenance.args,
+          returns: functionProvenance.returns,
+          handler: handler as Handler.AnyConfectProvenance,
+        }),
+      );
     }),
+    Match.exhaustive,
   );
-};
 
 const nodeActionFunction = <
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,

package/src/RegistryItem.ts

@@ -18,27 +18,24 @@ export interface RegistryItem<
   FunctionSpec_ extends FunctionSpec.AnyWithProps,
 > {
   readonly [TypeId]: TypeId;
-  readonly function_: FunctionSpec_;
+  readonly functionSpec: FunctionSpec_;
   readonly handler: Handler.Handler<DatabaseSchema_, FunctionSpec_>;
 }
 
 export interface AnyWithProps {
   readonly [TypeId]: TypeId;
-  readonly function_: FunctionSpec.AnyWithProps;
-  readonly handler: Handler.AnyWithProps;
+  readonly functionSpec: FunctionSpec.AnyWithProps;
+  readonly handler: Handler.Any;
 }
 
-export const make = <
-  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
-  FunctionSpec_ extends FunctionSpec.AnyWithProps,
->({
-  function_,
+export const make = ({
+  functionSpec,
   handler,
 }: {
-  function_: FunctionSpec_;
-  handler: Handler.Handler<DatabaseSchema_, FunctionSpec_>;
-}): RegistryItem<DatabaseSchema_, FunctionSpec_> =>
+  functionSpec: FunctionSpec.AnyWithProps;
+  handler: AnyWithProps["handler"];
+}): AnyWithProps =>
   Object.assign(Object.create(RegistryItemProto), {
-    function_,
+    functionSpec,
     handler,
   });

package/src/index.ts

@@ -2,12 +2,12 @@ export * as ActionCtx from "./ActionCtx";
 export * as ActionRunner from "./ActionRunner";
 export * as Api from "./Api";
 export * as Auth from "./Auth";
+export * as ConvexConfigProvider from "./ConvexConfigProvider";
 export * as DatabaseReader from "./DatabaseReader";
 export * as DatabaseSchema from "./DatabaseSchema";
 export * as DatabaseWriter from "./DatabaseWriter";
 export * as DataModel from "./DataModel";
 export * as Document from "./Document";
-export * as ConvexConfigProvider from "./ConvexConfigProvider";
 export * as FunctionImpl from "./FunctionImpl";
 export * as GroupImpl from "./GroupImpl";
 export * as Handler from "./Handler";