@confect/server 1.0.3 → 3.0.0

package/src/Handler.ts

@@ -1,4 +1,5 @@
 import type { FunctionSpec, RuntimeAndFunctionType } from "@confect/core";
+import type * as FunctionProvenance from "@confect/core/FunctionProvenance";
 import type { NodeContext } from "@effect/platform-node";
 import type { Effect } from "effect";
 import type * as ActionCtx from "./ActionCtx";
@@ -12,6 +13,7 @@ import type * as MutationCtx from "./MutationCtx";
 import type * as MutationRunner from "./MutationRunner";
 import type * as QueryCtx from "./QueryCtx";
 import type * as QueryRunner from "./QueryRunner";
+import type * as RegisteredFunction from "./RegisteredFunction";
 import type * as Scheduler from "./Scheduler";
 import type {
   StorageActionWriter,
@@ -23,27 +25,49 @@ import type * as VectorSearch from "./VectorSearch";
 export type Handler<
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
   FunctionSpec_ extends FunctionSpec.AnyWithProps,
+> =
+  FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<
+    FunctionSpec_,
+    FunctionProvenance.AnyConvex
+  >
+    ? ConvexProvenanceHandler<FunctionSpec_>
+    : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<
+          FunctionSpec_,
+          FunctionProvenance.AnyConfect
+        >
+      ? ConfectProvenanceHandler<DatabaseSchema_, FunctionSpec_>
+      : never;
+
+type ConvexProvenanceHandler<
+  FunctionSpec_ extends
+    FunctionSpec.AnyWithPropsWithFunctionProvenance<FunctionProvenance.AnyConvex>,
+> = RegisteredFunction.ConvexRegisteredFunction<FunctionSpec_>;
+
+type ConfectProvenanceHandler<
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+  FunctionSpec_ extends
+    FunctionSpec.AnyWithPropsWithFunctionProvenance<FunctionProvenance.AnyConfect>,
 > =
   FunctionSpec_ extends FunctionSpec.WithFunctionType<FunctionSpec_, "query">
-    ? Query<DatabaseSchema_, FunctionSpec_>
+    ? ConfectProvenanceQuery<DatabaseSchema_, FunctionSpec_>
     : FunctionSpec_ extends FunctionSpec.WithFunctionType<
           FunctionSpec_,
           "mutation"
         >
-      ? Mutation<DatabaseSchema_, FunctionSpec_>
+      ? ConfectProvenanceMutation<DatabaseSchema_, FunctionSpec_>
       : FunctionSpec_ extends FunctionSpec.WithRuntimeAndFunctionType<
             FunctionSpec_,
             RuntimeAndFunctionType.ConvexAction
           >
-        ? ConvexAction<DatabaseSchema_, FunctionSpec_>
+        ? ConvexRuntimeAction<DatabaseSchema_, FunctionSpec_>
         : FunctionSpec_ extends FunctionSpec.WithRuntimeAndFunctionType<
               FunctionSpec_,
               RuntimeAndFunctionType.NodeAction
             >
-          ? NodeAction<DatabaseSchema_, FunctionSpec_>
+          ? NodeRuntimeAction<DatabaseSchema_, FunctionSpec_>
           : never;
 
-export type Query<
+export type ConfectProvenanceQuery<
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
   FunctionSpec_ extends
     FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyQuery>,
@@ -56,7 +80,7 @@ export type Query<
   | QueryCtx.QueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>
 >;
 
-export type Mutation<
+export type ConfectProvenanceMutation<
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
   FunctionSpec_ extends
     FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyMutation>,
@@ -89,13 +113,13 @@ type ActionServices<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> =
       DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
     >;
 
-export type ConvexAction<
+export type ConvexRuntimeAction<
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
   FunctionSpec_ extends
     FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyAction>,
 > = Base<FunctionSpec_, ActionServices<DatabaseSchema_>>;
 
-export type NodeAction<
+export type NodeRuntimeAction<
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
   FunctionSpec_ extends
     FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.NodeAction>,
@@ -105,13 +129,14 @@ export type NodeAction<
 >;
 
 type Base<FunctionSpec_ extends FunctionSpec.AnyWithProps, R> = (
-  args: FunctionSpec.Args<FunctionSpec_>["Type"],
-) => Effect.Effect<FunctionSpec.Returns<FunctionSpec_>["Type"], never, R>;
+  args: FunctionSpec.Args<FunctionSpec_>,
+) => Effect.Effect<FunctionSpec.Returns<FunctionSpec_>, never, R>;
 
-export type AnyWithProps = Handler<
-  DatabaseSchema.AnyWithProps,
-  FunctionSpec.AnyWithProps
->;
+export type Any = AnyConfectProvenance | AnyConvexProvenance;
+
+export type AnyConfectProvenance = Base<FunctionSpec.AnyConfect, any>;
+
+export type AnyConvexProvenance = RegisteredFunction.Any;
 
 export type WithName<
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,

package/src/HttpApi.ts

@@ -16,13 +16,14 @@ import {
   type RouteSpecWithPathPrefix,
 } from "convex/server";
 import { Array, Layer, pipe, Record } from "effect";
+import * as ActionCtx from "./ActionCtx";
 import * as ActionRunner from "./ActionRunner";
 import * as Auth from "./Auth";
+import * as ConvexConfigProvider from "./ConvexConfigProvider";
 import * as MutationRunner from "./MutationRunner";
 import * as QueryRunner from "./QueryRunner";
 import * as Scheduler from "./Scheduler";
 import { StorageActionWriter, StorageReader, StorageWriter } from "./Storage";
-import * as ActionCtx from "./ActionCtx";
 
 type Middleware = (
   httpApp: HttpApp.Default,
@@ -84,6 +85,7 @@ const makeHandler =
       ApiLive,
       ApiDocsLive,
       HttpServer.layerContext,
+      Layer.setConfigProvider(ConvexConfigProvider.make()),
     );
 
     const { handler } = HttpApiBuilder.toWebHandler(

package/src/MutationRunner.ts

@@ -1,39 +1,54 @@
 import * as Ref from "@confect/core/Ref";
 import { type GenericMutationCtx } from "convex/server";
 import type { ParseResult } from "effect";
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Effect, Layer, Match, Schema } from "effect";
 
-const makeMutationRunner =
+const make =
   (runMutation: GenericMutationCtx<any>["runMutation"]) =>
   <Mutation extends Ref.AnyMutation>(
     mutation: Mutation,
-    args: Ref.Args<Mutation>["Type"],
-  ): Effect.Effect<Ref.Returns<Mutation>["Type"], ParseResult.ParseError> =>
+    args: Ref.Args<Mutation>,
+  ): Effect.Effect<Ref.Returns<Mutation>, ParseResult.ParseError> =>
     Effect.gen(function* () {
-      const function_ = Ref.getFunction(mutation);
+      const functionSpec = Ref.getFunctionSpec(mutation);
       const functionName = Ref.getConvexFunctionName(mutation);
 
-      const encodedArgs = yield* Schema.encode(function_.args)(args);
-      const encodedReturns = yield* Effect.promise(() =>
-        runMutation(functionName as any, encodedArgs),
+      return yield* Match.value(functionSpec.functionProvenance).pipe(
+        Match.tag("Confect", (confectFunctionSpec) =>
+          Effect.gen(function* () {
+            const encodedArgs = yield* Schema.encode(confectFunctionSpec.args)(
+              args,
+            );
+            const encodedReturns = yield* Effect.promise(() =>
+              runMutation(functionName as any, encodedArgs),
+            );
+            return yield* Schema.decode(confectFunctionSpec.returns)(
+              encodedReturns,
+            );
+          }),
+        ),
+        Match.tag("Convex", () =>
+          Effect.promise(() => runMutation(functionName as any, args as any)),
+        ),
+        Match.exhaustive,
       );
-      return yield* Schema.decode(function_.returns)(encodedReturns);
     });
 
-export const MutationRunner = Context.GenericTag<
-  ReturnType<typeof makeMutationRunner>
->("@confect/server/MutationRunner");
+export const MutationRunner = Context.GenericTag<ReturnType<typeof make>>(
+  "@confect/server/MutationRunner",
+);
 export type MutationRunner = typeof MutationRunner.Identifier;
 
 export const layer = (runMutation: GenericMutationCtx<any>["runMutation"]) =>
-  Layer.succeed(MutationRunner, makeMutationRunner(runMutation));
+  Layer.succeed(MutationRunner, make(runMutation));
 
-export class MutationRollback extends Schema.TaggedError<MutationRollback>(
+export class MutationRollback extends Schema.TaggedError<MutationRollback>()(
   "MutationRollback",
-)("MutationRollback", {
-  mutationName: Schema.String,
-  error: Schema.Unknown,
-}) {
+  {
+    mutationName: Schema.String,
+    error: Schema.Unknown,
+  },
+) {
   /* v8 ignore start */
   override get message(): string {
     return `Mutation ${this.mutationName} failed and was rolled back.\n\n${this.error}`;

package/src/QueryInitializer.ts

@@ -280,12 +280,13 @@ export const getById =
       Effect.andThen(Document.decode(tableName, table.Fields)),
     );
 
-export class GetByIdFailure extends Schema.TaggedError<GetByIdFailure>(
+export class GetByIdFailure extends Schema.TaggedError<GetByIdFailure>()(
   "GetByIdFailure",
-)("GetByIdFailure", {
-  id: Schema.String,
-  tableName: Schema.String,
-}) {
+  {
+    id: Schema.String,
+    tableName: Schema.String,
+  },
+) {
   override get message(): string {
     return Document.documentErrorMessage({
       id: this.id,
@@ -295,13 +296,14 @@ export class GetByIdFailure extends Schema.TaggedError<GetByIdFailure>(
   }
 }
 
-export class GetByIndexFailure extends Schema.TaggedError<GetByIndexFailure>(
+export class GetByIndexFailure extends Schema.TaggedError<GetByIndexFailure>()(
   "GetByIndexFailure",
-)("GetByIndexFailure", {
-  tableName: Schema.String,
-  indexName: Schema.String,
-  indexFieldValues: Schema.Array(Schema.String),
-}) {
+  {
+    tableName: Schema.String,
+    indexName: Schema.String,
+    indexFieldValues: Schema.Array(Schema.String),
+  },
+) {
   override get message(): string {
     return `No documents found in table '${this.tableName}' with index '${this.indexName}' and field values '${this.indexFieldValues}'`;
   }

package/src/QueryRunner.ts

@@ -1,23 +1,37 @@
 import * as Ref from "@confect/core/Ref";
 import { type GenericQueryCtx } from "convex/server";
 import type { ParseResult } from "effect";
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Effect, Layer, Match, Schema } from "effect";
 
 const make =
   (runQuery: GenericQueryCtx<any>["runQuery"]) =>
   <Query extends Ref.AnyQuery>(
     query: Query,
-    args: Ref.Args<Query>["Type"],
-  ): Effect.Effect<Ref.Returns<Query>["Type"], ParseResult.ParseError> =>
+    args: Ref.Args<Query>,
+  ): Effect.Effect<Ref.Returns<Query>, ParseResult.ParseError> =>
     Effect.gen(function* () {
-      const function_ = Ref.getFunction(query);
+      const functionSpec = Ref.getFunctionSpec(query);
       const functionName = Ref.getConvexFunctionName(query);
 
-      const encodedArgs = yield* Schema.encode(function_.args)(args);
-      const encodedReturns = yield* Effect.promise(() =>
-        runQuery(functionName as any, encodedArgs),
+      return yield* Match.value(functionSpec.functionProvenance).pipe(
+        Match.tag("Confect", (confectFunctionSpec) =>
+          Effect.gen(function* () {
+            const encodedArgs = yield* Schema.encode(confectFunctionSpec.args)(
+              args,
+            );
+            const encodedReturns = yield* Effect.promise(() =>
+              runQuery(functionName as any, encodedArgs),
+            );
+            return yield* Schema.decode(confectFunctionSpec.returns)(
+              encodedReturns,
+            );
+          }),
+        ),
+        Match.tag("Convex", () =>
+          Effect.promise(() => runQuery(functionName as any, args as any)),
+        ),
+        Match.exhaustive,
       );
-      return yield* Schema.decode(function_.returns)(encodedReturns);
     });
 
 export const QueryRunner = Context.GenericTag<ReturnType<typeof make>>(

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";
@@ -28,52 +31,61 @@ 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,
@@ -137,6 +149,7 @@ const queryFunction = <
                 >(),
                 ctx,
               ),
+              Layer.setConfigProvider(ConvexConfigProvider.make()),
             ),
           ),
         ),
@@ -167,6 +180,7 @@ export const mutationLayer = <Schema extends DatabaseSchema.AnyWithProps>(
       >(),
       ctx,
     ),
+    Layer.setConfigProvider(ConvexConfigProvider.make()),
   );
 
 export type MutationServices<Schema extends DatabaseSchema.AnyWithProps> =
@@ -248,5 +262,9 @@ const convexActionFunction = <
     args,
     returns,
     handler,
-    createLayer: (ctx) => RegisteredFunction.actionLayer(schema, ctx),
+    createLayer: (ctx) =>
+      Layer.mergeAll(
+        RegisteredFunction.actionLayer(schema, ctx),
+        Layer.setConfigProvider(ConvexConfigProvider.make()),
+      ),
   });

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,