@confect/server 6.0.0 → 7.0.0

package/dist/RegisteredFunction.d.ts

@@ -16,14 +16,15 @@ import * as convex_server0 from "convex/server";
 import { DefaultFunctionArgs, FunctionVisibility, GenericActionCtx, RegisteredAction, RegisteredMutation, RegisteredQuery } from "convex/server";
 import { FunctionSpec, RuntimeAndFunctionType } from "@confect/core";
 import * as convex_values0 from "convex/values";
-import * as effect_ParseResult0 from "effect/ParseResult";
+import { Value } from "convex/values";
 import * as FunctionProvenance from "@confect/core/FunctionProvenance";
+import * as effect_ParseResult0 from "effect/ParseResult";
 import * as effect_Duration0 from "effect/Duration";
 import * as effect_DateTime0 from "effect/DateTime";
 
 //#region src/RegisteredFunction.d.ts
 declare namespace RegisteredFunction_d_exports {
-  export { ActionServices, Any, ConvexRegisteredFunction, RegisteredFunction, actionFunctionBase, actionLayer };
+  export { ActionServices, Any, ConvexRegisteredFunction, RegisteredFunction, actionFunctionBase, actionLayer, runHandlerPromise };
 }
 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;
@@ -35,14 +36,32 @@ type ConvexRegisteredFunction<FunctionSpec_ extends FunctionSpec.AnyWithProps> =
   };
 } ? 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;
 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;
+/**
+ * Run the `Effect` as a `Promise`. The error schema acts as an allowlist of
+ * failures that may be surfaced to the client as a `ConvexError`:
+ *
+ * - With a schema: typed errors are schema-encoded and wrapped in a
+ * `ConvexError`, then thrown so Convex surfaces the data to the client.
+ * `Effect.either` escapes the failure channel before `runPromise` so the thrown
+ * `ConvexError` retains its `Symbol.for("ConvexError")` identity instead of
+ * being wrapped in Effect's `FiberFailure`.
+ *
+ * - Without a schema: every failure is converted to a defect via
+ * `Effect.orDie`, so nothing—not even a `ConvexError` the handler placed in its
+ * error channel—reaches the client as a `ConvexError`. The fiber dies and
+ * `runPromise` rejects with a generic failure.
+ */
+declare const runHandlerPromise: (errorSchema: Schema.Schema.AnyNoContext | undefined) => <A, E>(effect: Effect.Effect<A, E>) => Promise<A>;
 declare const actionFunctionBase: <Schema extends AnyWithProps, Args, ConvexArgs extends DefaultFunctionArgs, Returns, ConvexReturns, E, R>({
   args,
   returns,
+  error,
   handler,
   createLayer
 }: {
   args: Schema.Schema<Args, ConvexArgs>;
   returns: Schema.Schema<Returns, ConvexReturns>;
+  error: Schema.Schema<Error, Value> | undefined;
   handler: (a: Args) => Effect.Effect<Returns, E, R>;
   createLayer: (ctx: GenericActionCtx<ToConvex<FromSchema<Schema>>>) => Layer.Layer<R>;
 }) => {
@@ -51,10 +70,10 @@ declare const actionFunctionBase: <Schema extends AnyWithProps, Args, ConvexArgs
   handler: (ctx: GenericActionCtx<ToConvex<FromSchema<Schema>>>, actualArgs: ConvexArgs) => Promise<ConvexReturns>;
 };
 type ActionServices<DatabaseSchema_ extends AnyWithProps> = Scheduler$1 | Auth$1 | StorageReader$1 | StorageWriter$1 | StorageActionWriter$1 | QueryRunner | MutationRunner | ActionRunner | VectorSearch<FromSchema<DatabaseSchema_>> | ActionCtx<ToConvex<FromSchema<DatabaseSchema_>>>;
-declare const actionLayer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, ctx: GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>>) => Layer.Layer<(<Action extends _confect_core_Ref0.AnyAction>(action: Action, ...args: _confect_core_Ref0.OptionalArgs<Action>) => Effect.Effect<_confect_core_Ref0.Returns<Action>, effect_ParseResult0.ParseError, never>) | GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>> | {
+declare const actionLayer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, ctx: GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>>) => Layer.Layer<(<Action extends _confect_core_Ref0.AnyAction>(action: Action, ...args: _confect_core_Ref0.OptionalArgs<Action>) => Effect.Effect<_confect_core_Ref0.Returns<Action>, _confect_core_Ref0.Error<Action> | effect_ParseResult0.ParseError>) | Auth$1 | StorageReader$1 | StorageWriter$1 | (<Query extends _confect_core_Ref0.AnyQuery>(query: Query, ...args: _confect_core_Ref0.OptionalArgs<Query>) => Effect.Effect<_confect_core_Ref0.Returns<Query>, _confect_core_Ref0.Error<Query> | effect_ParseResult0.ParseError>) | {
   runAfter: <Ref_ extends _confect_core_Ref0.AnyMutation | _confect_core_Ref0.AnyAction>(delay: effect_Duration0.Duration, ref: Ref_, ...args: _confect_core_Ref0.OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
   runAt: <Ref_ extends _confect_core_Ref0.AnyMutation | _confect_core_Ref0.AnyAction>(dateTime: effect_DateTime0.DateTime, ref: Ref_, ...args: _confect_core_Ref0.OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
-} | Auth$1 | StorageReader$1 | StorageWriter$1 | StorageActionWriter$1 | (<Query extends _confect_core_Ref0.AnyQuery>(query: Query, ...args: _confect_core_Ref0.OptionalArgs<Query>) => Effect.Effect<_confect_core_Ref0.Returns<Query>, effect_ParseResult0.ParseError, never>) | (<Mutation extends _confect_core_Ref0.AnyMutation>(mutation: Mutation, ...args: _confect_core_Ref0.OptionalArgs<Mutation>) => Effect.Effect<_confect_core_Ref0.Returns<Mutation>, effect_ParseResult0.ParseError, never>) | (<TableName extends TableNames<FromSchema<DatabaseSchema_>>, IndexName extends keyof convex_server0.VectorIndexes<convex_server0.NamedTableInfo<ToConvex<FromSchema<DatabaseSchema_>>, TableName>>>(tableName: TableName, indexName: IndexName, query: {
+} | (<Mutation extends _confect_core_Ref0.AnyMutation>(mutation: Mutation, ...args: _confect_core_Ref0.OptionalArgs<Mutation>) => Effect.Effect<_confect_core_Ref0.Returns<Mutation>, _confect_core_Ref0.Error<Mutation> | effect_ParseResult0.ParseError>) | GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>> | StorageActionWriter$1 | (<TableName extends TableNames<FromSchema<DatabaseSchema_>>, IndexName extends keyof convex_server0.VectorIndexes<convex_server0.NamedTableInfo<ToConvex<FromSchema<DatabaseSchema_>>, TableName>>>(tableName: TableName, indexName: IndexName, query: {
   vector: number[];
   limit?: number;
   filter?: (q: convex_server0.VectorFilterBuilder<convex_server0.DocumentByInfo<convex_server0.NamedTableInfo<ToConvex<FromSchema<DatabaseSchema_>>, TableName>>, convex_server0.NamedVectorIndex<convex_server0.NamedTableInfo<ToConvex<FromSchema<DatabaseSchema_>>, TableName>, IndexName>>) => convex_server0.FilterExpression<boolean>;
@@ -63,5 +82,5 @@ declare const actionLayer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema
   _score: number;
 }[], never, never>), never, never>;
 //#endregion
-export { ActionServices, Any, ConvexRegisteredFunction, RegisteredFunction, RegisteredFunction_d_exports, actionFunctionBase, actionLayer };
+export { ActionServices, Any, ConvexRegisteredFunction, RegisteredFunction, RegisteredFunction_d_exports, actionFunctionBase, actionLayer, runHandlerPromise };
 //# sourceMappingURL=RegisteredFunction.d.ts.map

package/dist/RegisteredFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredFunction.d.ts","names":[],"sources":["../src/RegisteredFunction.ts"],"mappings":"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"}
+{"version":3,"file":"RegisteredFunction.d.ts","names":[],"sources":["../src/RegisteredFunction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;KA2BY,GAAA,GACR,eAAA,CAAgB,kBAAA,EAAoB,mBAAA,SACpC,kBAAA,CAAmB,kBAAA,EAAoB,mBAAA,SACvC,gBAAA,CAAiB,kBAAA,EAAoB,mBAAA;AAAA,KAEpC,yBAAA,uBACmB,YAAA,CAAa,YAAA,IAEnC,YAAA,CAAa,WAAA,CAAY,aAAA,8BACvB,mBAAA,GACE,sBAAA,CAAuB,eAAA,CACrB,aAAA,8CAEA,eAAA,CACE,YAAA,CAAa,qBAAA,CAAsB,aAAA,GACnC,KAAA,EACA,OAAA,CAAQ,YAAA,CAAa,cAAA,CAAe,aAAA,MAEtC,sBAAA,CAAuB,eAAA,CACnB,aAAA,iDAEF,kBAAA,CACE,YAAA,CAAa,qBAAA,CAAsB,aAAA,GACnC,KAAA,EACA,OAAA,CAAQ,YAAA,CAAa,cAAA,CAAe,aAAA,MAEtC,sBAAA,CAAuB,eAAA,CACnB,aAAA,+CAEF,gBAAA,CACE,YAAA,CAAa,qBAAA,CAAsB,aAAA,GACnC,KAAA,EACA,OAAA,CAAQ,YAAA,CAAa,cAAA,CAAe,aAAA;AAAA,KAKtC,wBAAA,uBACY,YAAA,CAAa,YAAA,IACjC,aAAA;EACF,kBAAA;IACE,IAAA;IACA,KAAA,sBAA2B,mBAAA;IAC3B,QAAA;EAAA;AAAA,IAGA,sBAAA,CAAuB,eAAA,CACrB,aAAA,8CAEA,eAAA,CACE,YAAA,CAAa,qBAAA,CAAsB,aAAA,GACnC,KAAA,EACA,QAAA,IAEF,sBAAA,CAAuB,eAAA,CACnB,aAAA,iDAEF,kBAAA,CACE,YAAA,CAAa,qBAAA,CAAsB,aAAA,GACnC,KAAA,EACA,QAAA,IAEF,sBAAA,CAAuB,eAAA,CACnB,aAAA,+CAEF,gBAAA,CACE,YAAA,CAAa,qBAAA,CAAsB,aAAA,GACnC,KAAA,EACA,QAAA;AAAA,KAKA,kBAAA,uBACY,YAAA,CAAa,YAAA,IAEnC,aAAA,SAAsB,YAAA,CAAa,sBAAA,CACjC,aAAA,EACA,kBAAA,CAAmB,SAAA,IAEjB,wBAAA,CAAyB,aAAA,IACzB,aAAA,SAAsB,YAAA,CAAa,sBAAA,CAC/B,aAAA,EACA,kBAAA,CAAmB,UAAA,IAErB,yBAAA,CAA0B,aAAA;;;;;;;;;AArFlC;;;;;;;cAuGa,iBAAA,GACV,WAAA,EAAa,MAAA,CAAO,MAAA,CAAO,YAAA,wBACrB,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,MAAK,OAAA,CAAQ,CAAA;AAAA,cAyBlC,kBAAA,kBACI,YAAA,2BAEI,mBAAA;EAKnB,IAAA;EAAA,OAAA;EAAA,KAAA;EAAA,OAAA;EAAA;AAAA;EAOA,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,IAAA,EAAM,UAAA;EAC1B,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,OAAA,EAAS,aAAA;EAChC,KAAA,EAAO,MAAA,CAAO,MAAA,CAAO,KAAA,EAAO,KAAA;EAC5B,OAAA,GAAU,CAAA,EAAG,IAAA,KAAS,MAAA,CAAO,MAAA,CAAO,OAAA,EAAS,CAAA,EAAG,CAAA;EAChD,WAAA,GACE,GAAA,EAAK,gBAAA,CAAiB,QAAA,CAAmB,UAAA,CAAqB,MAAA,QAC3D,KAAA,CAAM,KAAA,CAAM,CAAA;AAAA;QAAD,cAAA,CAAA,kBAAA;;iBAKT,gBAAA,CAAiB,QAAA,CAAmB,UAAA,CAAqB,MAAA,KAAS,UAAA,EAC3D,UAAA,KACX,OAAA,CAAQ,aAAA;AAAA;AAAA,KAcD,cAAA,yBACc,YAAA,IAEtB,WAAA,GACA,MAAA,GACA,eAAA,GACA,eAAA,GACA,qBAAA,GACA,WAAA,GACA,cAAA,GACA,YAAA,GACA,YAAA,CAA0B,UAAA,CAAqB,eAAA,KAC/C,SAAA,CACE,QAAA,CAAmB,UAAA,CAAqB,eAAA;AAAA,cAGjC,WAAA,2BACa,YAAA,EAExB,cAAA,EAAgB,eAAA,EAChB,GAAA,EAAK,gBAAA,CACH,QAAA,CAAmB,UAAA,CAAqB,eAAA,QACzC,KAAA,CAAA,KAAA,kBAFoB,kBAAA,CAEpB,SAAA,EAAA,MAAA,EAAA,MAAA,KAAA,IAAA,EAAA,kBAAA,CAAA,YAAA,CAAA,MAAA,MAAA,MAAA,CAAA,MAAA,CAAA,kBAAA,CAAA,OAAA,CAAA,MAAA,GAAA,kBAAA,CAAA,KAAA,CAAA,MAAA,IAAA,mBAAA,CAAA,UAAA,KAAA,MAAA,GAAA,eAAA,GAAA,eAAA,mBAAA,kBAAA,CAAA,QAAA,EAAA,KAAA,EAAA,KAAA,KAAA,IAAA,EAAA,kBAAA,CAAA,YAAA,CAAA,KAAA,MAAA,MAAA,CAAA,MAAA,CAAA,kBAAA,CAAA,OAAA,CAAA,KAAA,GAAA,kBAAA,CAAA,KAAA,CAAA,KAAA,IAAA,mBAAA,CAAA,UAAA;0BAAA,kBAAA,CAAA,WAAA"}

package/dist/RegisteredFunction.js

@@ -10,21 +10,50 @@ import { StorageActionWriter as StorageActionWriter$1 } from "./StorageActionWri
 import { StorageReader as StorageReader$1 } from "./StorageReader.js";
 import { StorageWriter as StorageWriter$1 } from "./StorageWriter.js";
 import { layer as layer$5 } from "./VectorSearch.js";
-import { Effect, Layer, Schema, pipe } from "effect";
+import { Effect, Either, Layer, Schema, pipe } from "effect";
 import "convex/server";
+import { ConvexError } from "convex/values";
 
 //#region src/RegisteredFunction.ts
 var RegisteredFunction_exports = /* @__PURE__ */ __exportAll({
 	actionFunctionBase: () => actionFunctionBase,
-	actionLayer: () => actionLayer
+	actionLayer: () => actionLayer,
+	runHandlerPromise: () => runHandlerPromise
 });
-const actionFunctionBase = ({ args, returns, handler, createLayer }) => ({
+/**
+* Run the `Effect` as a `Promise`. The error schema acts as an allowlist of
+* failures that may be surfaced to the client as a `ConvexError`:
+*
+* - With a schema: typed errors are schema-encoded and wrapped in a
+* `ConvexError`, then thrown so Convex surfaces the data to the client.
+* `Effect.either` escapes the failure channel before `runPromise` so the thrown
+* `ConvexError` retains its `Symbol.for("ConvexError")` identity instead of
+* being wrapped in Effect's `FiberFailure`.
+*
+* - Without a schema: every failure is converted to a defect via
+* `Effect.orDie`, so nothing—not even a `ConvexError` the handler placed in its
+* error channel—reaches the client as a `ConvexError`. The fiber dies and
+* `runPromise` rejects with a generic failure.
+*/
+const runHandlerPromise = (errorSchema) => (effect) => {
+	if (errorSchema === void 0) return Effect.runPromise(Effect.orDie(effect));
+	const withConvexError = effect.pipe(Effect.catchAll((typedError) => pipe(Schema.encode(errorSchema)(typedError), Effect.orDie, Effect.andThen((encodedError) => Effect.fail(new ConvexError(encodedError))))));
+	return Effect.runPromise(Effect.either(withConvexError)).then(Either.match({
+		onLeft: (error) => {
+			throw error;
+		},
+		onRight: (value) => value
+	}));
+};
+const actionFunctionBase = ({ args, returns, error, handler, createLayer }) => ({
 	args: compileArgsSchema(args),
 	returns: compileReturnsSchema(returns),
-	handler: (ctx, actualArgs) => 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)
+	handler: (ctx, actualArgs) => Effect.gen(function* () {
+		return yield* pipe(yield* handler(yield* pipe(actualArgs, Schema.decode(args), Effect.orDie)).pipe(Effect.provide(createLayer(ctx))), Schema.encode(returns), Effect.orDie);
+	}).pipe(runHandlerPromise(error))
 });
 const actionLayer = (databaseSchema, ctx) => Layer.mergeAll(layer$4(ctx.scheduler), layer$1(ctx.auth), StorageReader$1.layer(ctx.storage), StorageWriter$1.layer(ctx.storage), StorageActionWriter$1.layer(ctx.storage), layer$3(ctx.runQuery), layer$2(ctx.runMutation), layer(ctx.runAction), layer$5(ctx.vectorSearch), Layer.succeed(ActionCtx(), ctx));
 
 //#endregion
-export { RegisteredFunction_exports, actionFunctionBase, actionLayer };
+export { RegisteredFunction_exports, actionFunctionBase, actionLayer, runHandlerPromise };
 //# sourceMappingURL=RegisteredFunction.js.map

package/dist/RegisteredFunction.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredFunction.js","names":["SchemaToValidator.compileArgsSchema","SchemaToValidator.compileReturnsSchema","Scheduler.layer","Auth.layer","StorageReader","StorageWriter","StorageActionWriter","QueryRunner.layer","MutationRunner.layer","ActionRunner.layer","VectorSearch.layer","ActionCtx.ActionCtx"],"sources":["../src/RegisteredFunction.ts"],"sourcesContent":["import type { FunctionSpec, RuntimeAndFunctionType } from \"@confect/core\";\nimport type * as FunctionProvenance from \"@confect/core/FunctionProvenance\";\nimport {\n  type DefaultFunctionArgs,\n  type FunctionVisibility,\n  type GenericActionCtx,\n  type RegisteredAction,\n  type RegisteredMutation,\n  type RegisteredQuery,\n} from \"convex/server\";\nimport { Effect, Layer, pipe, Schema } from \"effect\";\nimport * as ActionCtx from \"./ActionCtx\";\nimport * as ActionRunner from \"./ActionRunner\";\nimport * as Auth from \"./Auth\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as DataModel from \"./DataModel\";\nimport * as MutationRunner from \"./MutationRunner\";\nimport * as QueryRunner from \"./QueryRunner\";\nimport * as Scheduler from \"./Scheduler\";\nimport * as SchemaToValidator from \"./SchemaToValidator\";\nimport { StorageActionWriter } from \"./StorageActionWriter\";\nimport { StorageReader } from \"./StorageReader\";\nimport { StorageWriter } from \"./StorageWriter\";\nimport * as VectorSearch from \"./VectorSearch\";\n\nexport type Any =\n  | RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;\n\ntype ConfectRegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> =\n  FunctionSpec.EncodedArgs<FunctionSpec_> extends infer Args_ extends\n    DefaultFunctionArgs\n    ? RuntimeAndFunctionType.GetFunctionType<\n        FunctionSpec_[\"runtimeAndFunctionType\"]\n      > extends \"query\"\n      ? RegisteredQuery<\n          FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n          Args_,\n          Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n        >\n      : RuntimeAndFunctionType.GetFunctionType<\n            FunctionSpec_[\"runtimeAndFunctionType\"]\n          > extends \"mutation\"\n        ? RegisteredMutation<\n            FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n            Args_,\n            Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n          >\n        : RuntimeAndFunctionType.GetFunctionType<\n              FunctionSpec_[\"runtimeAndFunctionType\"]\n            > extends \"action\"\n          ? RegisteredAction<\n              FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n              Args_,\n              Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n            >\n          : never\n    : never;\n\nexport type ConvexRegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> = FunctionSpec_ extends {\n  functionProvenance: {\n    _tag: \"Convex\";\n    _args: infer Args_ extends DefaultFunctionArgs;\n    _returns: infer Returns_;\n  };\n}\n  ? RuntimeAndFunctionType.GetFunctionType<\n      FunctionSpec_[\"runtimeAndFunctionType\"]\n    > extends \"query\"\n    ? RegisteredQuery<\n        FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n        Args_,\n        Returns_\n      >\n    : RuntimeAndFunctionType.GetFunctionType<\n          FunctionSpec_[\"runtimeAndFunctionType\"]\n        > extends \"mutation\"\n      ? RegisteredMutation<\n          FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n          Args_,\n          Returns_\n        >\n      : RuntimeAndFunctionType.GetFunctionType<\n            FunctionSpec_[\"runtimeAndFunctionType\"]\n          > extends \"action\"\n        ? RegisteredAction<\n            FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n            Args_,\n            Returns_\n          >\n        : never\n  : never;\n\nexport type RegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> =\n  FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<\n    FunctionSpec_,\n    FunctionProvenance.AnyConvex\n  >\n    ? ConvexRegisteredFunction<FunctionSpec_>\n    : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<\n          FunctionSpec_,\n          FunctionProvenance.AnyConfect\n        >\n      ? ConfectRegisteredFunction<FunctionSpec_>\n      : never;\n\nexport const actionFunctionBase = <\n  Schema extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n  R,\n>({\n  args,\n  returns,\n  handler,\n  createLayer,\n}: {\n  args: Schema.Schema<Args, ConvexArgs>;\n  returns: Schema.Schema<Returns, ConvexReturns>;\n  handler: (a: Args) => Effect.Effect<Returns, E, R>;\n  createLayer: (\n    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n  ) => Layer.Layer<R>;\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        handler(decodedArgs).pipe(Effect.provide(createLayer(ctx))),\n      ),\n      Effect.andThen((convexReturns) =>\n        Schema.encodeUnknown(returns)(convexReturns),\n      ),\n      Effect.runPromise,\n    ),\n});\n\nexport type ActionServices<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n> =\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<DatabaseSchema_>>\n  | ActionCtx.ActionCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n    >;\n\nexport const actionLayer = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n>(\n  databaseSchema: DatabaseSchema_,\n  ctx: GenericActionCtx<\n    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n  >,\n) =>\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<DatabaseSchema_>>\n      >(),\n      ctx,\n    ),\n  );\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAiHA,MAAa,sBAQX,EACA,MACA,SACA,SACA,mBAQK;CACL,MAAMA,kBAAoC,KAAK;CAC/C,SAASC,qBAAuC,QAAQ;CACxD,UACE,KACA,eAEA,KACE,YACA,OAAO,OAAO,KAAK,EACnB,OAAO,OACP,OAAO,SAAS,gBACd,QAAQ,YAAY,CAAC,KAAK,OAAO,QAAQ,YAAY,IAAI,CAAC,CAAC,CAC5D,EACD,OAAO,SAAS,kBACd,OAAO,cAAc,QAAQ,CAAC,cAAc,CAC7C,EACD,OAAO,WACR;CACJ;AAkBD,MAAa,eAGX,gBACA,QAIA,MAAM,SACJC,QAAgB,IAAI,UAAU,EAC9BC,QAAW,IAAI,KAAK,EACpBC,gBAAc,MAAM,IAAI,QAAQ,EAChCC,gBAAc,MAAM,IAAI,QAAQ,EAChCC,sBAAoB,MAAM,IAAI,QAAQ,EACtCC,QAAkB,IAAI,SAAS,EAC/BC,QAAqB,IAAI,YAAY,EACrCC,MAAmB,IAAI,UAAU,EACjCC,QAAmB,IAAI,aAAa,EACpC,MAAM,QACJC,WAEG,EACH,IACD,CACF"}
+{"version":3,"file":"RegisteredFunction.js","names":["SchemaToValidator.compileArgsSchema","SchemaToValidator.compileReturnsSchema","Scheduler.layer","Auth.layer","QueryRunner.layer","MutationRunner.layer","ActionRunner.layer","VectorSearch.layer","ActionCtx.ActionCtx"],"sources":["../src/RegisteredFunction.ts"],"sourcesContent":["import type { FunctionSpec, RuntimeAndFunctionType } from \"@confect/core\";\nimport type * as FunctionProvenance from \"@confect/core/FunctionProvenance\";\nimport {\n  type DefaultFunctionArgs,\n  type FunctionVisibility,\n  type GenericActionCtx,\n  type RegisteredAction,\n  type RegisteredMutation,\n  type RegisteredQuery,\n} from \"convex/server\";\nimport type { Value } from \"convex/values\";\nimport { ConvexError } from \"convex/values\";\nimport { Effect, Either, Layer, pipe, Schema } from \"effect\";\nimport * as ActionCtx from \"./ActionCtx\";\nimport * as ActionRunner from \"./ActionRunner\";\nimport * as Auth from \"./Auth\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as DataModel from \"./DataModel\";\nimport * as MutationRunner from \"./MutationRunner\";\nimport * as QueryRunner from \"./QueryRunner\";\nimport * as Scheduler from \"./Scheduler\";\nimport * as SchemaToValidator from \"./SchemaToValidator\";\nimport * as StorageActionWriter from \"./StorageActionWriter\";\nimport * as StorageReader from \"./StorageReader\";\nimport * as StorageWriter from \"./StorageWriter\";\nimport * as VectorSearch from \"./VectorSearch\";\n\nexport type Any =\n  | RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;\n\ntype ConfectRegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> =\n  FunctionSpec.EncodedArgs<FunctionSpec_> extends infer Args_ extends\n    DefaultFunctionArgs\n    ? RuntimeAndFunctionType.GetFunctionType<\n        FunctionSpec_[\"runtimeAndFunctionType\"]\n      > extends \"query\"\n      ? RegisteredQuery<\n          FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n          Args_,\n          Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n        >\n      : RuntimeAndFunctionType.GetFunctionType<\n            FunctionSpec_[\"runtimeAndFunctionType\"]\n          > extends \"mutation\"\n        ? RegisteredMutation<\n            FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n            Args_,\n            Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n          >\n        : RuntimeAndFunctionType.GetFunctionType<\n              FunctionSpec_[\"runtimeAndFunctionType\"]\n            > extends \"action\"\n          ? RegisteredAction<\n              FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n              Args_,\n              Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n            >\n          : never\n    : never;\n\nexport type ConvexRegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> = FunctionSpec_ extends {\n  functionProvenance: {\n    _tag: \"Convex\";\n    _args: infer Args_ extends DefaultFunctionArgs;\n    _returns: infer Returns_;\n  };\n}\n  ? RuntimeAndFunctionType.GetFunctionType<\n      FunctionSpec_[\"runtimeAndFunctionType\"]\n    > extends \"query\"\n    ? RegisteredQuery<\n        FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n        Args_,\n        Returns_\n      >\n    : RuntimeAndFunctionType.GetFunctionType<\n          FunctionSpec_[\"runtimeAndFunctionType\"]\n        > extends \"mutation\"\n      ? RegisteredMutation<\n          FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n          Args_,\n          Returns_\n        >\n      : RuntimeAndFunctionType.GetFunctionType<\n            FunctionSpec_[\"runtimeAndFunctionType\"]\n          > extends \"action\"\n        ? RegisteredAction<\n            FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n            Args_,\n            Returns_\n          >\n        : never\n  : never;\n\nexport type RegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> =\n  FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<\n    FunctionSpec_,\n    FunctionProvenance.AnyConvex\n  >\n    ? ConvexRegisteredFunction<FunctionSpec_>\n    : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<\n          FunctionSpec_,\n          FunctionProvenance.AnyConfect\n        >\n      ? ConfectRegisteredFunction<FunctionSpec_>\n      : never;\n\n/**\n * Run the `Effect` as a `Promise`. The error schema acts as an allowlist of\n * failures that may be surfaced to the client as a `ConvexError`:\n *\n * - With a schema: typed errors are schema-encoded and wrapped in a\n * `ConvexError`, then thrown so Convex surfaces the data to the client.\n * `Effect.either` escapes the failure channel before `runPromise` so the thrown\n * `ConvexError` retains its `Symbol.for(\"ConvexError\")` identity instead of\n * being wrapped in Effect's `FiberFailure`.\n *\n * - Without a schema: every failure is converted to a defect via\n * `Effect.orDie`, so nothing—not even a `ConvexError` the handler placed in its\n * error channel—reaches the client as a `ConvexError`. The fiber dies and\n * `runPromise` rejects with a generic failure.\n */\nexport const runHandlerPromise =\n  (errorSchema: Schema.Schema.AnyNoContext | undefined) =>\n  <A, E>(effect: Effect.Effect<A, E>): Promise<A> => {\n    if (errorSchema === undefined) {\n      return Effect.runPromise(Effect.orDie(effect));\n    }\n    const withConvexError = effect.pipe(\n      Effect.catchAll((typedError) =>\n        pipe(\n          Schema.encode(errorSchema)(typedError),\n          Effect.orDie,\n          Effect.andThen((encodedError) =>\n            Effect.fail(new ConvexError(encodedError)),\n          ),\n        ),\n      ),\n    );\n    return Effect.runPromise(Effect.either(withConvexError)).then(\n      Either.match({\n        onLeft: (error) => {\n          throw error;\n        },\n        onRight: (value) => value,\n      }),\n    );\n  };\n\nexport const actionFunctionBase = <\n  Schema extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n  R,\n>({\n  args,\n  returns,\n  error,\n  handler,\n  createLayer,\n}: {\n  args: Schema.Schema<Args, ConvexArgs>;\n  returns: Schema.Schema<Returns, ConvexReturns>;\n  error: Schema.Schema<Error, Value> | undefined;\n  handler: (a: Args) => Effect.Effect<Returns, E, R>;\n  createLayer: (\n    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n  ) => Layer.Layer<R>;\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    Effect.gen(function* () {\n      const decodedArgs = yield* pipe(\n        actualArgs,\n        Schema.decode(args),\n        Effect.orDie,\n      );\n      const decodedReturns = yield* handler(decodedArgs).pipe(\n        Effect.provide(createLayer(ctx)),\n      );\n      return yield* pipe(decodedReturns, Schema.encode(returns), Effect.orDie);\n    }).pipe(runHandlerPromise(error)),\n});\n\nexport type ActionServices<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n> =\n  | Scheduler.Scheduler\n  | Auth.Auth\n  | StorageReader.StorageReader\n  | StorageWriter.StorageWriter\n  | StorageActionWriter.StorageActionWriter\n  | QueryRunner.QueryRunner\n  | MutationRunner.MutationRunner\n  | ActionRunner.ActionRunner\n  | VectorSearch.VectorSearch<DataModel.FromSchema<DatabaseSchema_>>\n  | ActionCtx.ActionCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n    >;\n\nexport const actionLayer = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n>(\n  databaseSchema: DatabaseSchema_,\n  ctx: GenericActionCtx<\n    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n  >,\n) =>\n  Layer.mergeAll(\n    Scheduler.layer(ctx.scheduler),\n    Auth.layer(ctx.auth),\n    StorageReader.StorageReader.layer(ctx.storage),\n    StorageWriter.StorageWriter.layer(ctx.storage),\n    StorageActionWriter.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<DatabaseSchema_>>\n      >(),\n      ctx,\n    ),\n  );\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkIA,MAAa,qBACV,iBACM,WAA4C;AACjD,KAAI,gBAAgB,OAClB,QAAO,OAAO,WAAW,OAAO,MAAM,OAAO,CAAC;CAEhD,MAAM,kBAAkB,OAAO,KAC7B,OAAO,UAAU,eACf,KACE,OAAO,OAAO,YAAY,CAAC,WAAW,EACtC,OAAO,OACP,OAAO,SAAS,iBACd,OAAO,KAAK,IAAI,YAAY,aAAa,CAAC,CAC3C,CACF,CACF,CACF;AACD,QAAO,OAAO,WAAW,OAAO,OAAO,gBAAgB,CAAC,CAAC,KACvD,OAAO,MAAM;EACX,SAAS,UAAU;AACjB,SAAM;;EAER,UAAU,UAAU;EACrB,CAAC,CACH;;AAGL,MAAa,sBAQX,EACA,MACA,SACA,OACA,SACA,mBASK;CACL,MAAMA,kBAAoC,KAAK;CAC/C,SAASC,qBAAuC,QAAQ;CACxD,UACE,KACA,eAEA,OAAO,IAAI,aAAa;AAStB,SAAO,OAAO,KAHS,OAAO,QALV,OAAO,KACzB,YACA,OAAO,OAAO,KAAK,EACnB,OAAO,MACR,CACiD,CAAC,KACjD,OAAO,QAAQ,YAAY,IAAI,CAAC,CACjC,EACkC,OAAO,OAAO,QAAQ,EAAE,OAAO,MAAM;GACxE,CAAC,KAAK,kBAAkB,MAAM,CAAC;CACpC;AAkBD,MAAa,eAGX,gBACA,QAIA,MAAM,SACJC,QAAgB,IAAI,UAAU,EAC9BC,QAAW,IAAI,KAAK,kBACQ,MAAM,IAAI,QAAQ,kBAClB,MAAM,IAAI,QAAQ,wBACN,MAAM,IAAI,QAAQ,EAC1DC,QAAkB,IAAI,SAAS,EAC/BC,QAAqB,IAAI,YAAY,EACrCC,MAAmB,IAAI,UAAU,EACjCC,QAAmB,IAAI,aAAa,EACpC,MAAM,QACJC,WAEG,EACH,IACD,CACF"}

package/dist/RegisteredNodeFunction.js

@@ -11,12 +11,14 @@ const make = (api, { functionSpec, handler }) => Match.value(functionSpec.functi
 	return Match.value(functionVisibility).pipe(Match.when("public", () => actionGeneric), Match.when("internal", () => internalActionGeneric), Match.exhaustive)(nodeActionFunction(api.databaseSchema, {
 		args: functionProvenance.args,
 		returns: functionProvenance.returns,
+		error: functionProvenance.error,
 		handler
 	}));
 }), Match.exhaustive);
-const nodeActionFunction = (databaseSchema, { args, returns, handler }) => actionFunctionBase({
+const nodeActionFunction = (databaseSchema, { args, returns, error, handler }) => actionFunctionBase({
 	args,
 	returns,
+	error,
 	handler,
 	createLayer: (ctx) => Layer.mergeAll(actionLayer(databaseSchema, ctx), NodeContext.layer)
 });

package/dist/RegisteredNodeFunction.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredNodeFunction.js","names":["RegisteredFunction.actionFunctionBase","RegisteredFunction.actionLayer"],"sources":["../src/RegisteredNodeFunction.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport { 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 type * as Handler from \"./Handler\";\nimport * as RegisteredFunction from \"./RegisteredFunction\";\nimport type * as RegistryItem from \"./RegistryItem\";\n\nexport const make = <Api_ extends Api.AnyWithPropsWithRuntime<\"Node\">>(\n  api: Api_,\n  { functionSpec, handler }: RegistryItem.AnyWithProps,\n): RegisteredFunction.Any =>\n  Match.value(functionSpec.functionProvenance).pipe(\n    Match.tag(\"Convex\", () => handler as RegisteredFunction.Any),\n    Match.tag(\"Confect\", () => {\n      const { functionVisibility, functionProvenance } =\n        functionSpec as FunctionSpec.AnyConfect;\n\n      const genericFunction = Match.value(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: functionProvenance.args,\n          returns: functionProvenance.returns,\n          handler: handler as Handler.AnyConfectProvenance,\n        }),\n      );\n    }),\n    Match.exhaustive,\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":";;;;;;;;AAeA,MAAa,QACX,KACA,EAAE,cAAc,cAEhB,MAAM,MAAM,aAAa,mBAAmB,CAAC,KAC3C,MAAM,IAAI,gBAAgB,QAAkC,EAC5D,MAAM,IAAI,iBAAiB;CACzB,MAAM,EAAE,oBAAoB,uBAC1B;AAQF,QANwB,MAAM,MAAM,mBAAmB,CAAC,KACtD,MAAM,KAAK,gBAAgB,cAAc,EACzC,MAAM,KAAK,kBAAkB,sBAAsB,EACnD,MAAM,WACP,CAGC,mBAAmB,IAAI,gBAAgB;EACrC,MAAM,mBAAmB;EACzB,SAAS,mBAAmB;EACnB;EACV,CAAC,CACH;EACD,EACF,MAAM,WACP;AAEH,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"}
+{"version":3,"file":"RegisteredNodeFunction.js","names":["RegisteredFunction.actionFunctionBase","RegisteredFunction.actionLayer"],"sources":["../src/RegisteredNodeFunction.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport { 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 type * as Handler from \"./Handler\";\nimport * as RegisteredFunction from \"./RegisteredFunction\";\nimport type * as RegistryItem from \"./RegistryItem\";\n\nexport const make = <Api_ extends Api.AnyWithPropsWithRuntime<\"Node\">>(\n  api: Api_,\n  { functionSpec, handler }: RegistryItem.AnyWithProps,\n): RegisteredFunction.Any =>\n  Match.value(functionSpec.functionProvenance).pipe(\n    Match.tag(\"Convex\", () => handler as RegisteredFunction.Any),\n    Match.tag(\"Confect\", () => {\n      const { functionVisibility, functionProvenance } =\n        functionSpec as FunctionSpec.AnyConfect;\n\n      const genericFunction = Match.value(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: functionProvenance.args,\n          returns: functionProvenance.returns,\n          error: functionProvenance.error,\n          handler: handler as Handler.AnyConfectProvenance,\n        }),\n      );\n    }),\n    Match.exhaustive,\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    error,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    error: Schema.Schema.AnyNoContext | undefined;\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    error,\n    handler,\n    createLayer: (ctx) =>\n      Layer.mergeAll(\n        RegisteredFunction.actionLayer(databaseSchema, ctx),\n        NodeContext.layer,\n      ),\n  });\n"],"mappings":";;;;;;;;AAeA,MAAa,QACX,KACA,EAAE,cAAc,cAEhB,MAAM,MAAM,aAAa,mBAAmB,CAAC,KAC3C,MAAM,IAAI,gBAAgB,QAAkC,EAC5D,MAAM,IAAI,iBAAiB;CACzB,MAAM,EAAE,oBAAoB,uBAC1B;AAQF,QANwB,MAAM,MAAM,mBAAmB,CAAC,KACtD,MAAM,KAAK,gBAAgB,cAAc,EACzC,MAAM,KAAK,kBAAkB,sBAAsB,EACnD,MAAM,WACP,CAGC,mBAAmB,IAAI,gBAAgB;EACrC,MAAM,mBAAmB;EACzB,SAAS,mBAAmB;EAC5B,OAAO,mBAAmB;EACjB;EACV,CAAC,CACH;EACD,EACF,MAAM,WACP;AAEH,MAAM,sBAQJ,gBACA,EACE,MACA,SACA,OACA,cAeFA,mBAAsC;CACpC;CACA;CACA;CACA;CACA,cAAc,QACZ,MAAM,SACJC,YAA+B,gBAAgB,IAAI,EACnD,YAAY,MACb;CACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@confect/server",
-  "version": "6.0.0",
+  "version": "7.0.0",
   "description": "Backend bindings to the Convex platform",
   "repository": {
     "type": "git",
@@ -55,7 +55,7 @@
     "@swc/jest": "0.2.39",
     "@types/node": "25.3.3",
     "@vitest/coverage-v8": "3.2.4",
-    "convex-test": "0.0.41",
+    "convex-test": "0.0.50",
     "dotenv": "17.3.1",
     "effect": "3.19.19",
     "eslint": "10.0.2",
@@ -67,15 +67,15 @@
     "vite": "7.3.1",
     "vite-tsconfig-paths": "6.1.1",
     "vitest": "3.2.4",
-    "@confect/cli": "6.0.0",
-    "@confect/test": "6.0.0"
+    "@confect/cli": "7.0.0",
+    "@confect/test": "7.0.0"
   },
   "peerDependencies": {
     "@effect/platform": "^0.94.5",
     "@effect/platform-node": "^0.104.1",
     "convex": "^1.30.0",
     "effect": "^3.19.16",
-    "@confect/core": "6.0.0"
+    "@confect/core": "7.0.0"
   },
   "engines": {
     "node": ">=22",

package/src/ActionRunner.ts

@@ -1,5 +1,6 @@
 import * as Ref from "@confect/core/Ref";
 import { type GenericActionCtx } from "convex/server";
+import type { ParseResult, Effect } from "effect";
 import { Context, Layer } from "effect";
 
 const make =
@@ -7,7 +8,10 @@ const make =
   <Action extends Ref.AnyAction>(
     action: Action,
     ...args: Ref.OptionalArgs<Action>
-  ) =>
+  ): Effect.Effect<
+    Ref.Returns<Action>,
+    Ref.Error<Action> | ParseResult.ParseError
+  > =>
     Ref.runWithCodec(
       action,
       (args[0] ?? {}) as Ref.Args<Action>,

package/src/Handler.ts

@@ -128,7 +128,11 @@ export type NodeRuntimeAction<
 
 type Base<FunctionSpec_ extends FunctionSpec.AnyWithProps, R> = (
   args: FunctionSpec.Args<FunctionSpec_>,
-) => Effect.Effect<FunctionSpec.Returns<FunctionSpec_>, never, R>;
+) => Effect.Effect<
+  FunctionSpec.Returns<FunctionSpec_>,
+  FunctionSpec.Error<FunctionSpec_>,
+  R
+>;
 
 export type Any = AnyConfectProvenance | AnyConvexProvenance;
 

package/src/MutationRunner.ts

@@ -1,13 +1,17 @@
 import * as Ref from "@confect/core/Ref";
 import { type GenericMutationCtx } from "convex/server";
-import { Context, Layer, Schema } from "effect";
+import type { ParseResult, Effect } from "effect";
+import { Context, Layer } from "effect";
 
 const make =
   (runMutation: GenericMutationCtx<any>["runMutation"]) =>
   <Mutation extends Ref.AnyMutation>(
     mutation: Mutation,
     ...args: Ref.OptionalArgs<Mutation>
-  ) =>
+  ): Effect.Effect<
+    Ref.Returns<Mutation>,
+    Ref.Error<Mutation> | ParseResult.ParseError
+  > =>
     Ref.runWithCodec(
       mutation,
       (args[0] ?? {}) as Ref.Args<Mutation>,
@@ -22,17 +26,3 @@ export type MutationRunner = typeof MutationRunner.Identifier;
 
 export const layer = (runMutation: GenericMutationCtx<any>["runMutation"]) =>
   Layer.succeed(MutationRunner, make(runMutation));
-
-export class MutationRollback extends Schema.TaggedError<MutationRollback>()(
-  "MutationRollback",
-  {
-    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}`;
-  }
-  /* v8 ignore stop */
-}

package/src/QueryRunner.ts

@@ -1,5 +1,6 @@
 import * as Ref from "@confect/core/Ref";
 import { type GenericQueryCtx } from "convex/server";
+import type { ParseResult, Effect } from "effect";
 import { Context, Layer } from "effect";
 
 const make =
@@ -7,7 +8,10 @@ const make =
   <Query extends Ref.AnyQuery>(
     query: Query,
     ...args: Ref.OptionalArgs<Query>
-  ) =>
+  ): Effect.Effect<
+    Ref.Returns<Query>,
+    Ref.Error<Query> | ParseResult.ParseError
+  > =>
     Ref.runWithCodec(
       query,
       (args[0] ?? {}) as Ref.Args<Query>,

package/src/RegisteredConvexFunction.ts

@@ -10,6 +10,7 @@ import {
   mutationGeneric,
   queryGeneric,
 } from "convex/server";
+import type { Value } from "convex/values";
 import { Clock, Effect, Layer, Match, pipe, Schema } from "effect";
 import type * as Api from "./Api";
 import * as Auth from "./Auth";
@@ -49,9 +50,11 @@ export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Convex">>(
           );
 
           return genericFunction(
-            queryFunction(api.databaseSchema, {
+            queryFunction({
+              databaseSchema: api.databaseSchema,
               args: functionProvenance.args,
               returns: functionProvenance.returns,
+              error: functionProvenance.error,
               handler: handler as Handler.AnyConfectProvenance,
             }),
           );
@@ -64,9 +67,11 @@ export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Convex">>(
           );
 
           return genericFunction(
-            mutationFunction(api.databaseSchema, {
+            mutationFunction({
+              databaseSchema: api.databaseSchema,
               args: functionProvenance.args,
               returns: functionProvenance.returns,
+              error: functionProvenance.error,
               handler: handler as Handler.AnyConfectProvenance,
             }),
           );
@@ -82,6 +87,7 @@ export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Convex">>(
             convexActionFunction(api.databaseSchema, {
               args: functionProvenance.args,
               returns: functionProvenance.returns,
+              error: functionProvenance.error,
               handler: handler as Handler.AnyConfectProvenance,
             }),
           );
@@ -99,9 +105,9 @@ export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Convex">>(
 // relying on real time for correctness anyway.
 //
 // Users who explicitly want the real timestamp can still reach it via Effect's
-// Clock service (Clock.currentTimeMillis / Clock.currentTimeNanos). We provide
+// Clock service (Clock.currentTimeMillis/Clock.currentTimeNanos). We provide
 // a Clock layer whose methods close over the *original* Date.now, so opting in
-// to Clock is an opt-in to worse caching — but caching is not broken by default.
+// to Clock is an opt-in to worse caching—but caching is not broken by default.
 const unpatchedClock = (realDateNow: () => number): Clock.Clock => {
   const bigint1e6 = BigInt(1_000_000);
   const unsafeCurrentTimeMillis = () => realDateNow();
@@ -136,30 +142,31 @@ const queryFunction = <
   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_>>
-        >
-    >;
-  },
-) => ({
+>({
+  databaseSchema,
+  args,
+  returns,
+  error,
+  handler,
+}: {
+  databaseSchema: DatabaseSchema_;
+  args: Schema.Schema<Args, ConvexArgs>;
+  returns: Schema.Schema<Returns, ConvexReturns>;
+  error: Schema.Schema<Error, Value> | undefined;
+  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: (
@@ -169,35 +176,37 @@ const queryFunction = <
     actualArgs: ConvexArgs,
   ): Promise<ConvexReturns> =>
     withStubbedDateNow((clock) =>
-      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,
-                ),
-                Layer.setConfigProvider(ConvexConfigProvider.make()),
+      Effect.gen(function* () {
+        const decodedArgs = yield* pipe(
+          actualArgs,
+          Schema.decode(args),
+          Effect.orDie,
+        );
+        const decodedReturns = yield* handler(decodedArgs).pipe(
+          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,
               ),
+              Layer.setConfigProvider(ConvexConfigProvider.make()),
             ),
           ),
-        ),
-        Effect.andThen((convexReturns) =>
-          Schema.encodeUnknown(returns)(convexReturns),
-        ),
+        );
+        return yield* pipe(
+          decodedReturns,
+          Schema.encode(returns),
+          Effect.orDie,
+        );
+      }).pipe(
         Effect.withClock(clock),
-        Effect.runPromise,
+        RegisteredFunction.runHandlerPromise(error),
       ),
     ),
 });
@@ -236,42 +245,46 @@ export type MutationServices<Schema extends DatabaseSchema.AnyWithProps> =
   | MutationCtx.MutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>;
 
 const mutationFunction = <
-  Schema extends DatabaseSchema.AnyWithProps,
+  DatabaseSchema_ 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>>;
-  },
-) => ({
+>({
+  databaseSchema,
+  args,
+  returns,
+  error,
+  handler,
+}: {
+  databaseSchema: DatabaseSchema_;
+  args: Schema.Schema<Args, ConvexArgs>;
+  returns: Schema.Schema<Returns, ConvexReturns>;
+  error: Schema.Schema<Error, Value> | undefined;
+  handler: (
+    a: Args,
+  ) => Effect.Effect<Returns, E, MutationServices<DatabaseSchema_>>;
+}) => ({
   args: SchemaToValidator.compileArgsSchema(args),
   returns: SchemaToValidator.compileReturnsSchema(returns),
   handler: (
-    ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,
+    ctx: GenericMutationCtx<
+      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
+    >,
     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,
-    ),
+    Effect.gen(function* () {
+      const decodedArgs = yield* pipe(
+        actualArgs,
+        Schema.decode(args),
+        Effect.orDie,
+      );
+      const decodedReturns = yield* handler(decodedArgs).pipe(
+        Effect.provide(mutationLayer(databaseSchema, ctx)),
+      );
+      return yield* pipe(decodedReturns, Schema.encode(returns), Effect.orDie);
+    }).pipe(RegisteredFunction.runHandlerPromise(error)),
 });
 
 const convexActionFunction = <
@@ -286,10 +299,12 @@ const convexActionFunction = <
   {
     args,
     returns,
+    error,
     handler,
   }: {
     args: Schema.Schema<Args, ConvexArgs>;
     returns: Schema.Schema<Returns, ConvexReturns>;
+    error: Schema.Schema.AnyNoContext | undefined;
     handler: (
       a: Args,
     ) => Effect.Effect<
@@ -302,6 +317,7 @@ const convexActionFunction = <
   RegisteredFunction.actionFunctionBase({
     args,
     returns,
+    error,
     handler,
     createLayer: (ctx) =>
       Layer.mergeAll(