@confect/server 1.0.0-next.3 → 1.0.0

package/dist/RegisteredFunctions.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredFunctions.js","names":["Registry.Registry","Impl.Impl","RegistryItem.isRegistryItem","SchemaToValidator.compileArgsSchema","SchemaToValidator.compileReturnsSchema","DatabaseReader.layer","Auth.layer","StorageReader","QueryRunner.layer","QueryCtx.QueryCtx","DatabaseWriter.layer","Scheduler.layer","StorageWriter","MutationRunner.layer","MutationCtx.MutationCtx","StorageActionWriter","ActionRunner.layer","VectorSearch.layer","ActionCtx.ActionCtx"],"sources":["../src/RegisteredFunctions.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport type * as Spec from \"@confect/core/Spec\";\nimport {\n  actionGeneric,\n  type DefaultFunctionArgs,\n  type FunctionVisibility,\n  type GenericActionCtx,\n  type GenericMutationCtx,\n  type GenericQueryCtx,\n  internalActionGeneric,\n  internalMutationGeneric,\n  internalQueryGeneric,\n  mutationGeneric,\n  queryGeneric,\n  type RegisteredAction,\n  type RegisteredMutation,\n  type RegisteredQuery,\n} from \"convex/server\";\nimport { Effect, Layer, Match, pipe, Ref, Schema, type Types } from \"effect\";\nimport * as ActionCtx from \"./ActionCtx\";\nimport * as ActionRunner from \"./ActionRunner\";\nimport type * as Api from \"./Api\";\nimport * as Auth from \"./Auth\";\nimport * as DatabaseReader from \"./DatabaseReader\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport * as DatabaseWriter from \"./DatabaseWriter\";\nimport type * as DataModel from \"./DataModel\";\nimport * as Impl from \"./Impl\";\nimport { mapLeaves } from \"./internal/utils\";\nimport * as MutationCtx from \"./MutationCtx\";\nimport * as MutationRunner from \"./MutationRunner\";\nimport * as QueryCtx from \"./QueryCtx\";\nimport * as QueryRunner from \"./QueryRunner\";\nimport * as Registry from \"./Registry\";\nimport * as RegistryItem from \"./RegistryItem\";\nimport * as Scheduler from \"./Scheduler\";\nimport * as SchemaToValidator from \"./SchemaToValidator\";\nimport { StorageActionWriter, StorageReader, StorageWriter } from \"./Storage\";\nimport * as VectorSearch from \"./VectorSearch\";\n\nexport type RegisteredFunction =\n  | RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;\n\nexport type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> =\n  Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Spec_>>>;\n\ntype RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {\n  [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<\n    Groups,\n    GroupName\n  > extends infer Group extends GroupSpec.AnyWithProps\n    ? GroupSpec.Groups<Group> extends infer SubGroups extends\n        GroupSpec.AnyWithProps\n      ? Types.Simplify<\n          RegisteredFunctionsHelper<SubGroups> & {\n            [FunctionName in FunctionSpec.Name<\n              GroupSpec.Functions<Group>\n            >]: FunctionSpec.WithName<\n              GroupSpec.Functions<Group>,\n              FunctionName\n            > extends infer Function extends FunctionSpec.AnyWithProps\n              ? FunctionSpec.RegisteredFunction<Function>\n              : never;\n          }\n        >\n      : {\n          [FunctionName in FunctionSpec.Name<\n            GroupSpec.Functions<Group>\n          >]: FunctionSpec.WithName<\n            GroupSpec.Functions<Group>,\n            FunctionName\n          > extends infer Function extends FunctionSpec.AnyWithProps\n            ? FunctionSpec.RegisteredFunction<Function>\n            : never;\n        }\n    : never;\n};\n\nexport interface AnyWithProps {\n  readonly [key: string]: RegisteredFunction | AnyWithProps;\n}\n\nexport const make = <Api_ extends Api.AnyWithProps>(\n  impl: Layer.Layer<Impl.Impl<Api_, \"Finalized\">>,\n) =>\n  Effect.gen(function* () {\n    const registry = yield* Registry.Registry;\n    const functionImplItems = yield* Ref.get(registry);\n    const { api, finalizationStatus } = yield* Impl.Impl<Api_, \"Finalized\">();\n\n    return yield* Match.value(\n      finalizationStatus as Impl.FinalizationStatus,\n    ).pipe(\n      Match.withReturnType<Effect.Effect<RegisteredFunctions<Api_[\"spec\"]>>>(),\n      Match.when(\"Unfinalized\", () =>\n        Effect.dieMessage(\"Impl is not finalized\"),\n      ),\n      Match.when(\"Finalized\", () =>\n        Effect.succeed(\n          mapLeaves<RegistryItem.AnyWithProps, RegisteredFunction>(\n            functionImplItems,\n            RegistryItem.isRegistryItem,\n            (registryItem) => makeRegisteredFunction(api, registryItem),\n          ) as RegisteredFunctions<Api_[\"spec\"]>,\n        ),\n      ),\n      Match.exhaustive,\n    );\n  }).pipe(Effect.provide(impl), Effect.runSync);\n\nconst makeRegisteredFunction = <Api_ extends Api.AnyWithProps>(\n  api: Api_,\n  { function_, handler }: RegistryItem.AnyWithProps,\n): RegisteredFunction =>\n  Match.value(function_.functionType).pipe(\n    Match.when(\"query\", () => {\n      const genericFunction = Match.value(function_.functionVisibility).pipe(\n        Match.when(\"public\", () => queryGeneric),\n        Match.when(\"internal\", () => internalQueryGeneric),\n        Match.exhaustive,\n      );\n\n      return genericFunction(\n        queryFunction(api.databaseSchema, {\n          args: function_.args,\n          returns: function_.returns,\n          handler,\n        }),\n      );\n    }),\n    Match.when(\"mutation\", () => {\n      const genericFunction = Match.value(function_.functionVisibility).pipe(\n        Match.when(\"public\", () => mutationGeneric),\n        Match.when(\"internal\", () => internalMutationGeneric),\n        Match.exhaustive,\n      );\n\n      return genericFunction(\n        mutationFunction(api.databaseSchema, {\n          args: function_.args,\n          returns: function_.returns,\n          handler,\n        }),\n      );\n    }),\n    Match.when(\"action\", () => {\n      const genericFunction = Match.value(function_.functionVisibility).pipe(\n        Match.when(\"public\", () => actionGeneric),\n        Match.when(\"internal\", () => internalActionGeneric),\n        Match.exhaustive,\n      );\n\n      return genericFunction(\n        actionFunction({\n          args: function_.args,\n          returns: function_.returns,\n          handler,\n        }),\n      );\n    }),\n    Match.exhaustive,\n  );\n\nconst queryFunction = <\n  Schema extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  schema: Schema,\n  {\n    args,\n    returns,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      | DatabaseReader.DatabaseReader<Schema>\n      | Auth.Auth\n      | StorageReader\n      | QueryRunner.QueryRunner\n      | QueryCtx.QueryCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>\n    >;\n  },\n) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    pipe(\n      actualArgs,\n      Schema.decode(args),\n      Effect.orDie,\n      Effect.andThen((decodedArgs) =>\n        pipe(\n          handler(decodedArgs),\n          Effect.provide(\n            Layer.mergeAll(\n              DatabaseReader.layer(schema, ctx.db),\n              Auth.layer(ctx.auth),\n              StorageReader.layer(ctx.storage),\n              QueryRunner.layer(ctx.runQuery),\n              Layer.succeed(\n                QueryCtx.QueryCtx<\n                  DataModel.ToConvex<DataModel.FromSchema<Schema>>\n                >(),\n                ctx,\n              ),\n            ),\n          ),\n        ),\n      ),\n      Effect.andThen((convexReturns) =>\n        Schema.encodeUnknown(returns)(convexReturns),\n      ),\n      Effect.runPromise,\n    ),\n});\n\nexport const mutationLayer = <Schema extends DatabaseSchema.AnyWithProps>(\n  schema: Schema,\n  ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n) =>\n  Layer.mergeAll(\n    DatabaseReader.layer(schema, ctx.db),\n    DatabaseWriter.layer(schema, ctx.db),\n    Auth.layer(ctx.auth),\n    Scheduler.layer(ctx.scheduler),\n    StorageReader.layer(ctx.storage),\n    StorageWriter.layer(ctx.storage),\n    QueryRunner.layer(ctx.runQuery),\n    MutationRunner.layer(ctx.runMutation),\n    Layer.succeed(\n      MutationCtx.MutationCtx<\n        DataModel.ToConvex<DataModel.FromSchema<Schema>>\n      >(),\n      ctx,\n    ),\n  );\n\nexport type MutationServices<Schema extends DatabaseSchema.AnyWithProps> =\n  | DatabaseReader.DatabaseReader<Schema>\n  | DatabaseWriter.DatabaseWriter<Schema>\n  | Auth.Auth\n  | Scheduler.Scheduler\n  | StorageReader\n  | StorageWriter\n  | QueryRunner.QueryRunner\n  | MutationRunner.MutationRunner\n  | MutationCtx.MutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>;\n\nconst mutationFunction = <\n  Schema extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  schema: Schema,\n  {\n    args,\n    returns,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    handler: (a: Args) => Effect.Effect<Returns, E, MutationServices<Schema>>;\n  },\n) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    pipe(\n      actualArgs,\n      Schema.decode(args),\n      Effect.orDie,\n      Effect.andThen((decodedArgs) =>\n        handler(decodedArgs).pipe(Effect.provide(mutationLayer(schema, ctx))),\n      ),\n      Effect.andThen((convexReturns) =>\n        Schema.encodeUnknown(returns)(convexReturns),\n      ),\n      Effect.runPromise,\n    ),\n});\n\nconst actionFunction = <\n  Schema extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>({\n  args,\n  returns,\n  handler,\n}: {\n  args: Schema.Schema<Args, ConvexArgs>;\n  returns: Schema.Schema<Returns, ConvexReturns>;\n  handler: (\n    a: Args,\n  ) => Effect.Effect<\n    Returns,\n    E,\n    | Scheduler.Scheduler\n    | Auth.Auth\n    | StorageReader\n    | StorageWriter\n    | StorageActionWriter\n    | QueryRunner.QueryRunner\n    | MutationRunner.MutationRunner\n    | ActionRunner.ActionRunner\n    | VectorSearch.VectorSearch<DataModel.FromSchema<Schema>>\n    | ActionCtx.ActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>\n  >;\n}) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    pipe(\n      actualArgs,\n      Schema.decode(args),\n      Effect.orDie,\n      Effect.andThen((decodedArgs) =>\n        pipe(\n          handler(decodedArgs),\n          Effect.provide(\n            Layer.mergeAll(\n              Scheduler.layer(ctx.scheduler),\n              Auth.layer(ctx.auth),\n              StorageReader.layer(ctx.storage),\n              StorageWriter.layer(ctx.storage),\n              StorageActionWriter.layer(ctx.storage),\n              QueryRunner.layer(ctx.runQuery),\n              MutationRunner.layer(ctx.runMutation),\n              ActionRunner.layer(ctx.runAction),\n              VectorSearch.layer(ctx.vectorSearch),\n              Layer.succeed(\n                ActionCtx.ActionCtx<\n                  DataModel.ToConvex<DataModel.FromSchema<Schema>>\n                >(),\n                ctx,\n              ),\n            ),\n          ),\n        ),\n      ),\n      Effect.andThen((convexReturns) =>\n        Schema.encodeUnknown(returns)(convexReturns),\n      ),\n      Effect.runPromise,\n    ),\n});\n"],"mappings":"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"}
+{"version":3,"file":"RegisteredFunctions.js","names":["Registry.Registry","Impl.Impl","RegistryItem.isRegistryItem"],"sources":["../src/RegisteredFunctions.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport type * as Spec from \"@confect/core/Spec\";\nimport type { Layer } from \"effect\";\nimport { Effect, Match, Ref, type Types } from \"effect\";\nimport type * as Api from \"./Api\";\nimport * as Impl from \"./Impl\";\nimport { mapLeaves } from \"./internal/utils\";\nimport type * as RegisteredFunction from \"./RegisteredFunction\";\nimport * as Registry from \"./Registry\";\nimport * as RegistryItem from \"./RegistryItem\";\n\nexport type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> =\n  Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Spec_>>>;\n\ntype RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {\n  [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<\n    Groups,\n    GroupName\n  > extends infer Group extends GroupSpec.AnyWithProps\n    ? GroupSpec.Groups<Group> extends infer SubGroups extends\n        GroupSpec.AnyWithProps\n      ? Types.Simplify<\n          RegisteredFunctionsHelper<SubGroups> & {\n            [FunctionName in FunctionSpec.Name<\n              GroupSpec.Functions<Group>\n            >]: FunctionSpec.WithName<\n              GroupSpec.Functions<Group>,\n              FunctionName\n            > extends infer Function extends FunctionSpec.AnyWithProps\n              ? FunctionSpec.RegisteredFunction<Function>\n              : never;\n          }\n        >\n      : {\n          [FunctionName in FunctionSpec.Name<\n            GroupSpec.Functions<Group>\n          >]: FunctionSpec.WithName<\n            GroupSpec.Functions<Group>,\n            FunctionName\n          > extends infer Function extends FunctionSpec.AnyWithProps\n            ? FunctionSpec.RegisteredFunction<Function>\n            : never;\n        }\n    : never;\n};\n\nexport interface AnyWithProps {\n  readonly [key: string]: RegisteredFunction.RegisteredFunction | AnyWithProps;\n}\n\nexport const make = <Api_ extends Api.AnyWithProps>(\n  impl: Layer.Layer<Impl.Impl<Api_, \"Finalized\">>,\n  makeRegisteredFunction: (\n    api: Api_,\n    registryItem: RegistryItem.AnyWithProps,\n  ) => RegisteredFunction.RegisteredFunction,\n) =>\n  Effect.gen(function* () {\n    const registry = yield* Registry.Registry;\n    const functionImplItems = yield* Ref.get(registry);\n    const { api, finalizationStatus } = yield* Impl.Impl<Api_, \"Finalized\">();\n\n    return yield* Match.value(\n      finalizationStatus as Impl.FinalizationStatus,\n    ).pipe(\n      Match.withReturnType<Effect.Effect<RegisteredFunctions<Api_[\"spec\"]>>>(),\n      Match.when(\"Unfinalized\", () =>\n        Effect.dieMessage(\"Impl is not finalized\"),\n      ),\n      Match.when(\"Finalized\", () =>\n        Effect.succeed(\n          mapLeaves<\n            RegistryItem.AnyWithProps,\n            RegisteredFunction.RegisteredFunction\n          >(functionImplItems, RegistryItem.isRegistryItem, (registryItem) =>\n            makeRegisteredFunction(api, registryItem),\n          ) as RegisteredFunctions<Api_[\"spec\"]>,\n        ),\n      ),\n      Match.exhaustive,\n    );\n  }).pipe(Effect.provide(impl), Effect.runSync);\n"],"mappings":";;;;;;;;;AAmDA,MAAa,QACX,MACA,2BAKA,OAAO,IAAI,aAAa;CACtB,MAAM,WAAW,OAAOA;CACxB,MAAM,oBAAoB,OAAO,IAAI,IAAI,SAAS;CAClD,MAAM,EAAE,KAAK,uBAAuB,OAAOC,MAA8B;AAEzE,QAAO,OAAO,MAAM,MAClB,mBACD,CAAC,KACA,MAAM,gBAAkE,EACxE,MAAM,KAAK,qBACT,OAAO,WAAW,wBAAwB,CAC3C,EACD,MAAM,KAAK,mBACT,OAAO,QACL,UAGE,mBAAmBC,iBAA8B,iBACjD,uBAAuB,KAAK,aAAa,CAC1C,CACF,CACF,EACD,MAAM,WACP;EACD,CAAC,KAAK,OAAO,QAAQ,KAAK,EAAE,OAAO,QAAQ"}

package/dist/RegisteredNodeFunction.d.ts

@@ -0,0 +1,15 @@
+import { AnyWithPropsWithRuntime } from "./Api.js";
+import { RegisteredFunction } from "./RegisteredFunction.js";
+import { AnyWithProps } from "./RegistryItem.js";
+
+//#region src/RegisteredNodeFunction.d.ts
+declare namespace RegisteredNodeFunction_d_exports {
+  export { make };
+}
+declare const make: <Api_ extends AnyWithPropsWithRuntime<"Node">>(api: Api_, {
+  function_,
+  handler
+}: AnyWithProps) => RegisteredFunction;
+//#endregion
+export { RegisteredNodeFunction_d_exports, make };
+//# sourceMappingURL=RegisteredNodeFunction.d.ts.map

package/dist/RegisteredNodeFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegisteredNodeFunction.d.ts","names":[],"sources":["../src/RegisteredNodeFunction.ts"],"mappings":";;;;;;;;cAaa,IAAA,gBAAqB,uBAAA,UAChC,GAAA,EAAK,IAAA;EACL,SAAA;EAAA;AAAA,GAAwB,YAAA,KACvB,kBAAA"}

package/dist/RegisteredNodeFunction.js

@@ -0,0 +1,25 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { actionFunctionBase, actionLayer } from "./RegisteredFunction.js";
+import { Layer, Match } from "effect";
+import { actionGeneric, internalActionGeneric } from "convex/server";
+import { NodeContext } from "@effect/platform-node";
+
+//#region src/RegisteredNodeFunction.ts
+var RegisteredNodeFunction_exports = /* @__PURE__ */ __exportAll({ make: () => make });
+const make = (api, { function_, handler }) => {
+	return Match.value(function_.functionVisibility).pipe(Match.when("public", () => actionGeneric), Match.when("internal", () => internalActionGeneric), Match.exhaustive)(nodeActionFunction(api.databaseSchema, {
+		args: function_.args,
+		returns: function_.returns,
+		handler
+	}));
+};
+const nodeActionFunction = (databaseSchema, { args, returns, handler }) => actionFunctionBase({
+	args,
+	returns,
+	handler,
+	createLayer: (ctx) => Layer.mergeAll(actionLayer(databaseSchema, ctx), NodeContext.layer)
+});
+
+//#endregion
+export { RegisteredNodeFunction_exports, make };
+//# sourceMappingURL=RegisteredNodeFunction.js.map

package/dist/RegisteredNodeFunction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegisteredNodeFunction.js","names":["RegisteredFunction.actionFunctionBase","RegisteredFunction.actionLayer"],"sources":["../src/RegisteredNodeFunction.ts"],"sourcesContent":["import { NodeContext } from \"@effect/platform-node\";\nimport {\n  actionGeneric,\n  type DefaultFunctionArgs,\n  internalActionGeneric,\n} from \"convex/server\";\nimport type { Effect } from \"effect\";\nimport { Layer, Match, type Schema } from \"effect\";\nimport type * as Api from \"./Api\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport * as RegisteredFunction from \"./RegisteredFunction\";\nimport type * as RegistryItem from \"./RegistryItem\";\n\nexport const make = <Api_ extends Api.AnyWithPropsWithRuntime<\"Node\">>(\n  api: Api_,\n  { function_, handler }: RegistryItem.AnyWithProps,\n): RegisteredFunction.RegisteredFunction => {\n  const genericFunction = Match.value(function_.functionVisibility).pipe(\n    Match.when(\"public\", () => actionGeneric),\n    Match.when(\"internal\", () => internalActionGeneric),\n    Match.exhaustive,\n  );\n\n  return genericFunction(\n    nodeActionFunction(api.databaseSchema, {\n      args: function_.args,\n      returns: function_.returns,\n      handler,\n    }),\n  );\n};\n\nconst nodeActionFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  databaseSchema: DatabaseSchema_,\n  {\n    args,\n    returns,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      | RegisteredFunction.ActionServices<DatabaseSchema_>\n      | NodeContext.NodeContext\n    >;\n  },\n) =>\n  RegisteredFunction.actionFunctionBase({\n    args,\n    returns,\n    handler,\n    createLayer: (ctx) =>\n      Layer.mergeAll(\n        RegisteredFunction.actionLayer(databaseSchema, ctx),\n        NodeContext.layer,\n      ),\n  });\n"],"mappings":";;;;;;;;AAaA,MAAa,QACX,KACA,EAAE,WAAW,cAC6B;AAO1C,QANwB,MAAM,MAAM,UAAU,mBAAmB,CAAC,KAChE,MAAM,KAAK,gBAAgB,cAAc,EACzC,MAAM,KAAK,kBAAkB,sBAAsB,EACnD,MAAM,WACP,CAGC,mBAAmB,IAAI,gBAAgB;EACrC,MAAM,UAAU;EAChB,SAAS,UAAU;EACnB;EACD,CAAC,CACH;;AAGH,MAAM,sBAQJ,gBACA,EACE,MACA,SACA,cAcFA,mBAAsC;CACpC;CACA;CACA;CACA,cAAc,QACZ,MAAM,SACJC,YAA+B,gBAAgB,IAAI,EACnD,YAAY,MACb;CACJ,CAAC"}

package/dist/index.d.ts

@@ -24,7 +24,9 @@ import { FunctionImpl_d_exports } from "./FunctionImpl.js";
 import { GroupImpl_d_exports } from "./GroupImpl.js";
 import { HttpApi_d_exports } from "./HttpApi.js";
 import { Impl_d_exports } from "./Impl.js";
-import { RegisteredFunctions_d_exports } from "./RegisteredFunctions.js";
+import { RegisteredFunction_d_exports } from "./RegisteredFunction.js";
 import { RegistryItem_d_exports } from "./RegistryItem.js";
+import { RegisteredConvexFunction_d_exports } from "./RegisteredConvexFunction.js";
+import { RegisteredFunctions_d_exports } from "./RegisteredFunctions.js";
 import { Registry_d_exports } from "./Registry.js";
-export { ActionCtx_d_exports as ActionCtx, ActionRunner_d_exports as ActionRunner, Api_d_exports as Api, Auth_d_exports as Auth, DataModel_d_exports as DataModel, DatabaseReader_d_exports as DatabaseReader, DatabaseSchema_d_exports as DatabaseSchema, DatabaseWriter_d_exports as DatabaseWriter, Document_d_exports as Document, FunctionImpl_d_exports as FunctionImpl, GroupImpl_d_exports as GroupImpl, Handler_d_exports as Handler, HttpApi_d_exports as HttpApi, Impl_d_exports as Impl, MutationCtx_d_exports as MutationCtx, MutationRunner_d_exports as MutationRunner, OrderedQuery_d_exports as OrderedQuery, QueryCtx_d_exports as QueryCtx, QueryInitializer_d_exports as QueryInitializer, QueryRunner_d_exports as QueryRunner, RegisteredFunctions_d_exports as RegisteredFunctions, Registry_d_exports as Registry, RegistryItem_d_exports as RegistryItem, Scheduler_d_exports as Scheduler, SchemaToValidator_d_exports as SchemaToValidator, Storage_d_exports as Storage, Table_d_exports as Table, TableInfo_d_exports as TableInfo, VectorSearch_d_exports as VectorSearch };
+export { ActionCtx_d_exports as ActionCtx, ActionRunner_d_exports as ActionRunner, Api_d_exports as Api, Auth_d_exports as Auth, DataModel_d_exports as DataModel, DatabaseReader_d_exports as DatabaseReader, DatabaseSchema_d_exports as DatabaseSchema, DatabaseWriter_d_exports as DatabaseWriter, Document_d_exports as Document, FunctionImpl_d_exports as FunctionImpl, GroupImpl_d_exports as GroupImpl, Handler_d_exports as Handler, HttpApi_d_exports as HttpApi, Impl_d_exports as Impl, MutationCtx_d_exports as MutationCtx, MutationRunner_d_exports as MutationRunner, OrderedQuery_d_exports as OrderedQuery, QueryCtx_d_exports as QueryCtx, QueryInitializer_d_exports as QueryInitializer, QueryRunner_d_exports as QueryRunner, RegisteredConvexFunction_d_exports as RegisteredConvexFunction, RegisteredFunction_d_exports as RegisteredFunction, RegisteredFunctions_d_exports as RegisteredFunctions, Registry_d_exports as Registry, RegistryItem_d_exports as RegistryItem, Scheduler_d_exports as Scheduler, SchemaToValidator_d_exports as SchemaToValidator, Storage_d_exports as Storage, Table_d_exports as Table, TableInfo_d_exports as TableInfo, VectorSearch_d_exports as VectorSearch };

package/dist/index.js

@@ -25,7 +25,9 @@ import { Impl_exports } from "./Impl.js";
 import { MutationCtx_exports } from "./MutationCtx.js";
 import { QueryCtx_exports } from "./QueryCtx.js";
 import { VectorSearch_exports } from "./VectorSearch.js";
+import { RegisteredFunction_exports } from "./RegisteredFunction.js";
+import { RegisteredConvexFunction_exports } from "./RegisteredConvexFunction.js";
 import { RegisteredFunctions_exports } from "./RegisteredFunctions.js";
 import { TableInfo_exports } from "./TableInfo.js";
 
-export { ActionCtx_exports as ActionCtx, ActionRunner_exports as ActionRunner, Api_exports as Api, Auth_exports as Auth, DataModel_exports as DataModel, DatabaseReader_exports as DatabaseReader, DatabaseSchema_exports as DatabaseSchema, DatabaseWriter_exports as DatabaseWriter, Document_exports as Document, FunctionImpl_exports as FunctionImpl, GroupImpl_exports as GroupImpl, Handler_exports as Handler, HttpApi_exports as HttpApi, Impl_exports as Impl, MutationCtx_exports as MutationCtx, MutationRunner_exports as MutationRunner, OrderedQuery_exports as OrderedQuery, QueryCtx_exports as QueryCtx, QueryInitializer_exports as QueryInitializer, QueryRunner_exports as QueryRunner, RegisteredFunctions_exports as RegisteredFunctions, Registry_exports as Registry, RegistryItem_exports as RegistryItem, Scheduler_exports as Scheduler, SchemaToValidator_exports as SchemaToValidator, Storage_exports as Storage, Table_exports as Table, TableInfo_exports as TableInfo, VectorSearch_exports as VectorSearch };
+export { ActionCtx_exports as ActionCtx, ActionRunner_exports as ActionRunner, Api_exports as Api, Auth_exports as Auth, DataModel_exports as DataModel, DatabaseReader_exports as DatabaseReader, DatabaseSchema_exports as DatabaseSchema, DatabaseWriter_exports as DatabaseWriter, Document_exports as Document, FunctionImpl_exports as FunctionImpl, GroupImpl_exports as GroupImpl, Handler_exports as Handler, HttpApi_exports as HttpApi, Impl_exports as Impl, MutationCtx_exports as MutationCtx, MutationRunner_exports as MutationRunner, OrderedQuery_exports as OrderedQuery, QueryCtx_exports as QueryCtx, QueryInitializer_exports as QueryInitializer, QueryRunner_exports as QueryRunner, RegisteredConvexFunction_exports as RegisteredConvexFunction, RegisteredFunction_exports as RegisteredFunction, RegisteredFunctions_exports as RegisteredFunctions, Registry_exports as Registry, RegistryItem_exports as RegistryItem, Scheduler_exports as Scheduler, SchemaToValidator_exports as SchemaToValidator, Storage_exports as Storage, Table_exports as Table, TableInfo_exports as TableInfo, VectorSearch_exports as VectorSearch };

package/dist/node.d.ts

@@ -0,0 +1,2 @@
+import { RegisteredNodeFunction_d_exports } from "./RegisteredNodeFunction.js";
+export { RegisteredNodeFunction_d_exports as RegisteredNodeFunction };

package/dist/node.js

@@ -0,0 +1,3 @@
+import { RegisteredNodeFunction_exports } from "./RegisteredNodeFunction.js";
+
+export { RegisteredNodeFunction_exports as RegisteredNodeFunction };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@confect/server",
-  "version": "1.0.0-next.3",
+  "version": "1.0.0",
   "description": "Backend bindings to the Convex platform",
   "repository": {
     "type": "git",
@@ -30,7 +30,11 @@
       "default": "./dist/*.js"
     },
     "./package.json": "./package.json",
-    "./internal/*": null
+    "./internal/*": null,
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "default": "./dist/node.js"
+    }
   },
   "keywords": [
     "effect",
@@ -43,7 +47,6 @@
     "@effect/experimental": "0.58.0",
     "@effect/language-service": "0.73.1",
     "@effect/platform": "0.94.4",
-    "@effect/platform-node": "0.104.1",
     "@effect/rpc": "0.73.0",
     "@effect/sql": "0.49.0",
     "@effect/vitest": "0.27.0",
@@ -63,14 +66,15 @@
     "vite": "7.3.1",
     "vite-tsconfig-paths": "6.1.1",
     "vitest": "3.2.4",
-    "@confect/cli": "1.0.0-next.3",
-    "@confect/test": "1.0.0-next.3"
+    "@confect/cli": "1.0.0",
+    "@confect/test": "1.0.0"
   },
   "peerDependencies": {
     "@effect/platform": "^0.94.4",
+    "@effect/platform-node": "^0.104.1",
     "convex": "^1.30.0",
     "effect": "^3.19.16",
-    "@confect/core": "1.0.0-next.3"
+    "@confect/core": "1.0.0"
   },
   "engines": {
     "node": ">=22",

package/src/Api.ts

@@ -1,3 +1,4 @@
+import type { RuntimeAndFunctionType } from "@confect/core";
 import type * as Spec from "@confect/core/Spec";
 import type { GenericSchema, SchemaDefinition } from "convex/server";
 import { defineSchema as defineConvexSchema } from "convex/server";
@@ -28,8 +29,17 @@ export interface AnyWithProps extends Api<
   Spec.AnyWithProps
 > {}
 
+export interface AnyWithPropsWithRuntime<
+  Runtime extends RuntimeAndFunctionType.Runtime,
+> extends Api<
+  DatabaseSchema.AnyWithProps,
+  Spec.AnyWithPropsWithRuntime<Runtime>
+> {}
+
 export type Schema<Api_ extends AnyWithProps> = Api_["databaseSchema"];
 
+export type GetSpec<Api_ extends AnyWithProps> = Api_["spec"];
+
 export type Groups<Api_ extends AnyWithProps> = Spec.Groups<Api_["spec"]>;
 
 const Proto = {

package/src/Handler.ts

@@ -1,4 +1,5 @@
-import type { FunctionSpec } from "@confect/core";
+import type { FunctionSpec, RuntimeAndFunctionType } from "@confect/core";
+import type { NodeContext } from "@effect/platform-node";
 import type { Effect } from "effect";
 import type * as ActionCtx from "./ActionCtx";
 import type * as ActionRunner from "./ActionRunner";
@@ -30,16 +31,22 @@ export type Handler<
           "mutation"
         >
       ? Mutation<DatabaseSchema_, FunctionSpec_>
-      : FunctionSpec_ extends FunctionSpec.WithFunctionType<
+      : FunctionSpec_ extends FunctionSpec.WithRuntimeAndFunctionType<
             FunctionSpec_,
-            "action"
+            RuntimeAndFunctionType.ConvexAction
           >
-        ? Action<DatabaseSchema_, FunctionSpec_>
-        : never;
+        ? ConvexAction<DatabaseSchema_, FunctionSpec_>
+        : FunctionSpec_ extends FunctionSpec.WithRuntimeAndFunctionType<
+              FunctionSpec_,
+              RuntimeAndFunctionType.NodeAction
+            >
+          ? NodeAction<DatabaseSchema_, FunctionSpec_>
+          : never;
 
 export type Query<
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
-  FunctionSpec_ extends FunctionSpec.AnyWithPropsWithFunctionType<"query">,
+  FunctionSpec_ extends
+    FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyQuery>,
 > = Base<
   FunctionSpec_,
   | DatabaseReader.DatabaseReader<DatabaseSchema_>
@@ -51,7 +58,8 @@ export type Query<
 
 export type Mutation<
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
-  FunctionSpec_ extends FunctionSpec.AnyWithPropsWithFunctionType<"mutation">,
+  FunctionSpec_ extends
+    FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyMutation>,
 > = Base<
   FunctionSpec_,
   | DatabaseReader.DatabaseReader<DatabaseSchema_>
@@ -67,11 +75,7 @@ export type Mutation<
     >
 >;
 
-export type Action<
-  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
-  FunctionSpec_ extends FunctionSpec.AnyWithPropsWithFunctionType<"action">,
-> = Base<
-  FunctionSpec_,
+type ActionServices<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> =
   | Scheduler.Scheduler
   | Auth.Auth
   | StorageReader
@@ -83,7 +87,21 @@ export type Action<
   | VectorSearch.VectorSearch<DataModel.FromSchema<DatabaseSchema_>>
   | ActionCtx.ActionCtx<
       DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
-    >
+    >;
+
+export type ConvexAction<
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+  FunctionSpec_ extends
+    FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyAction>,
+> = Base<FunctionSpec_, ActionServices<DatabaseSchema_>>;
+
+export type NodeAction<
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+  FunctionSpec_ extends
+    FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.NodeAction>,
+> = Base<
+  FunctionSpec_,
+  ActionServices<DatabaseSchema_> | NodeContext.NodeContext
 >;
 
 type Base<FunctionSpec_ extends FunctionSpec.AnyWithProps, R> = (

package/src/RegisteredConvexFunction.ts

@@ -0,0 +1,252 @@
+import {
+  actionGeneric,
+  type DefaultFunctionArgs,
+  type GenericMutationCtx,
+  type GenericQueryCtx,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
+  mutationGeneric,
+  queryGeneric,
+} from "convex/server";
+import { Effect, Layer, Match, pipe, Schema } from "effect";
+import type * as Api from "./Api";
+import * as Auth from "./Auth";
+import * as DatabaseReader from "./DatabaseReader";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import * as DatabaseWriter from "./DatabaseWriter";
+import type * as DataModel from "./DataModel";
+import * as MutationCtx from "./MutationCtx";
+import * as MutationRunner from "./MutationRunner";
+import * as QueryCtx from "./QueryCtx";
+import * as QueryRunner from "./QueryRunner";
+import * as RegisteredFunction from "./RegisteredFunction";
+import type * as RegistryItem from "./RegistryItem";
+import * as Scheduler from "./Scheduler";
+import * as SchemaToValidator from "./SchemaToValidator";
+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,
+      );
+
+      return genericFunction(
+        queryFunction(api.databaseSchema, {
+          args: function_.args,
+          returns: function_.returns,
+          handler,
+        }),
+      );
+    }),
+    Match.when("mutation", () => {
+      const genericFunction = Match.value(function_.functionVisibility).pipe(
+        Match.when("public", () => mutationGeneric),
+        Match.when("internal", () => internalMutationGeneric),
+        Match.exhaustive,
+      );
+
+      return genericFunction(
+        mutationFunction(api.databaseSchema, {
+          args: function_.args,
+          returns: function_.returns,
+          handler,
+        }),
+      );
+    }),
+    Match.when("action", () => {
+      const genericFunction = Match.value(function_.functionVisibility).pipe(
+        Match.when("public", () => actionGeneric),
+        Match.when("internal", () => internalActionGeneric),
+        Match.exhaustive,
+      );
+
+      return genericFunction(
+        convexActionFunction(api.databaseSchema, {
+          args: function_.args,
+          returns: function_.returns,
+          handler,
+        }),
+      );
+    }),
+    Match.exhaustive,
+  );
+
+const queryFunction = <
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+  Args,
+  ConvexArgs extends DefaultFunctionArgs,
+  Returns,
+  ConvexReturns,
+  E,
+>(
+  databaseSchema: DatabaseSchema_,
+  {
+    args,
+    returns,
+    handler,
+  }: {
+    args: Schema.Schema<Args, ConvexArgs>;
+    returns: Schema.Schema<Returns, ConvexReturns>;
+    handler: (
+      a: Args,
+    ) => Effect.Effect<
+      Returns,
+      E,
+      | DatabaseReader.DatabaseReader<DatabaseSchema_>
+      | Auth.Auth
+      | StorageReader
+      | QueryRunner.QueryRunner
+      | QueryCtx.QueryCtx<
+          DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
+        >
+    >;
+  },
+) => ({
+  args: SchemaToValidator.compileArgsSchema(args),
+  returns: SchemaToValidator.compileReturnsSchema(returns),
+  handler: (
+    ctx: GenericQueryCtx<
+      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
+    >,
+    actualArgs: ConvexArgs,
+  ): Promise<ConvexReturns> =>
+    pipe(
+      actualArgs,
+      Schema.decode(args),
+      Effect.orDie,
+      Effect.andThen((decodedArgs) =>
+        pipe(
+          handler(decodedArgs),
+          Effect.provide(
+            Layer.mergeAll(
+              DatabaseReader.layer(databaseSchema, ctx.db),
+              Auth.layer(ctx.auth),
+              StorageReader.layer(ctx.storage),
+              QueryRunner.layer(ctx.runQuery),
+              Layer.succeed(
+                QueryCtx.QueryCtx<
+                  DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
+                >(),
+                ctx,
+              ),
+            ),
+          ),
+        ),
+      ),
+      Effect.andThen((convexReturns) =>
+        Schema.encodeUnknown(returns)(convexReturns),
+      ),
+      Effect.runPromise,
+    ),
+});
+
+export const mutationLayer = <Schema extends DatabaseSchema.AnyWithProps>(
+  schema: Schema,
+  ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,
+) =>
+  Layer.mergeAll(
+    DatabaseReader.layer(schema, ctx.db),
+    DatabaseWriter.layer(schema, ctx.db),
+    Auth.layer(ctx.auth),
+    Scheduler.layer(ctx.scheduler),
+    StorageReader.layer(ctx.storage),
+    StorageWriter.layer(ctx.storage),
+    QueryRunner.layer(ctx.runQuery),
+    MutationRunner.layer(ctx.runMutation),
+    Layer.succeed(
+      MutationCtx.MutationCtx<
+        DataModel.ToConvex<DataModel.FromSchema<Schema>>
+      >(),
+      ctx,
+    ),
+  );
+
+export type MutationServices<Schema extends DatabaseSchema.AnyWithProps> =
+  | DatabaseReader.DatabaseReader<Schema>
+  | DatabaseWriter.DatabaseWriter<Schema>
+  | Auth.Auth
+  | Scheduler.Scheduler
+  | StorageReader
+  | StorageWriter
+  | QueryRunner.QueryRunner
+  | MutationRunner.MutationRunner
+  | MutationCtx.MutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>;
+
+const mutationFunction = <
+  Schema extends DatabaseSchema.AnyWithProps,
+  Args,
+  ConvexArgs extends DefaultFunctionArgs,
+  Returns,
+  ConvexReturns,
+  E,
+>(
+  schema: Schema,
+  {
+    args,
+    returns,
+    handler,
+  }: {
+    args: Schema.Schema<Args, ConvexArgs>;
+    returns: Schema.Schema<Returns, ConvexReturns>;
+    handler: (a: Args) => Effect.Effect<Returns, E, MutationServices<Schema>>;
+  },
+) => ({
+  args: SchemaToValidator.compileArgsSchema(args),
+  returns: SchemaToValidator.compileReturnsSchema(returns),
+  handler: (
+    ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,
+    actualArgs: ConvexArgs,
+  ): Promise<ConvexReturns> =>
+    pipe(
+      actualArgs,
+      Schema.decode(args),
+      Effect.orDie,
+      Effect.andThen((decodedArgs) =>
+        handler(decodedArgs).pipe(Effect.provide(mutationLayer(schema, ctx))),
+      ),
+      Effect.andThen((convexReturns) =>
+        Schema.encodeUnknown(returns)(convexReturns),
+      ),
+      Effect.runPromise,
+    ),
+});
+
+const convexActionFunction = <
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+  Args,
+  ConvexArgs extends DefaultFunctionArgs,
+  Returns,
+  ConvexReturns,
+  E,
+>(
+  schema: DatabaseSchema_,
+  {
+    args,
+    returns,
+    handler,
+  }: {
+    args: Schema.Schema<Args, ConvexArgs>;
+    returns: Schema.Schema<Returns, ConvexReturns>;
+    handler: (
+      a: Args,
+    ) => Effect.Effect<
+      Returns,
+      E,
+      RegisteredFunction.ActionServices<DatabaseSchema_>
+    >;
+  },
+) =>
+  RegisteredFunction.actionFunctionBase({
+    args,
+    returns,
+    handler,
+    createLayer: (ctx) => RegisteredFunction.actionLayer(schema, ctx),
+  });

package/src/RegisteredFunction.ts

@@ -0,0 +1,108 @@
+import {
+  type DefaultFunctionArgs,
+  type FunctionVisibility,
+  type GenericActionCtx,
+  type RegisteredAction,
+  type RegisteredMutation,
+  type RegisteredQuery,
+} from "convex/server";
+import { Effect, Layer, pipe, Schema } from "effect";
+import * as ActionCtx from "./ActionCtx";
+import * as ActionRunner from "./ActionRunner";
+import * as Auth from "./Auth";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as DataModel from "./DataModel";
+import * as MutationRunner from "./MutationRunner";
+import * as QueryRunner from "./QueryRunner";
+import * as Scheduler from "./Scheduler";
+import * as SchemaToValidator from "./SchemaToValidator";
+import { StorageActionWriter, StorageReader, StorageWriter } from "./Storage";
+import * as VectorSearch from "./VectorSearch";
+
+export type RegisteredFunction =
+  | RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any>
+  | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any>
+  | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;
+
+export const actionFunctionBase = <
+  Schema extends DatabaseSchema.AnyWithProps,
+  Args,
+  ConvexArgs extends DefaultFunctionArgs,
+  Returns,
+  ConvexReturns,
+  E,
+  R,
+>({
+  args,
+  returns,
+  handler,
+  createLayer,
+}: {
+  args: Schema.Schema<Args, ConvexArgs>;
+  returns: Schema.Schema<Returns, ConvexReturns>;
+  handler: (a: Args) => Effect.Effect<Returns, E, R>;
+  createLayer: (
+    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,
+  ) => Layer.Layer<R>;
+}) => ({
+  args: SchemaToValidator.compileArgsSchema(args),
+  returns: SchemaToValidator.compileReturnsSchema(returns),
+  handler: (
+    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,
+    actualArgs: ConvexArgs,
+  ): Promise<ConvexReturns> =>
+    pipe(
+      actualArgs,
+      Schema.decode(args),
+      Effect.orDie,
+      Effect.andThen((decodedArgs) =>
+        handler(decodedArgs).pipe(Effect.provide(createLayer(ctx))),
+      ),
+      Effect.andThen((convexReturns) =>
+        Schema.encodeUnknown(returns)(convexReturns),
+      ),
+      Effect.runPromise,
+    ),
+});
+
+export type ActionServices<
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+> =
+  | Scheduler.Scheduler
+  | Auth.Auth
+  | StorageReader
+  | StorageWriter
+  | StorageActionWriter
+  | QueryRunner.QueryRunner
+  | MutationRunner.MutationRunner
+  | ActionRunner.ActionRunner
+  | VectorSearch.VectorSearch<DataModel.FromSchema<DatabaseSchema_>>
+  | ActionCtx.ActionCtx<
+      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
+    >;
+
+export const actionLayer = <
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+>(
+  databaseSchema: DatabaseSchema_,
+  ctx: GenericActionCtx<
+    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
+  >,
+) =>
+  Layer.mergeAll(
+    Scheduler.layer(ctx.scheduler),
+    Auth.layer(ctx.auth),
+    StorageReader.layer(ctx.storage),
+    StorageWriter.layer(ctx.storage),
+    StorageActionWriter.layer(ctx.storage),
+    QueryRunner.layer(ctx.runQuery),
+    MutationRunner.layer(ctx.runMutation),
+    ActionRunner.layer(ctx.runAction),
+    VectorSearch.layer(ctx.vectorSearch),
+    Layer.succeed(
+      ActionCtx.ActionCtx<
+        DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
+      >(),
+      ctx,
+    ),
+  );