@confect/server 6.0.0 → 8.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@confect/server",
-  "version": "6.0.0",
+  "version": "8.0.0",
   "description": "Backend bindings to the Convex platform",
   "repository": {
     "type": "git",
@@ -44,38 +44,38 @@
   "license": "ISC",
   "devDependencies": {
     "@ark/attest": "0.56.0",
-    "@effect/cluster": "0.56.4",
-    "@effect/experimental": "0.58.0",
-    "@effect/platform": "0.94.5",
-    "@effect/rpc": "0.73.2",
-    "@effect/sql": "0.49.0",
-    "@effect/vitest": "0.27.0",
-    "@effect/workflow": "0.16.0",
+    "@effect/cluster": "0.58.2",
+    "@effect/experimental": "0.60.0",
+    "@effect/platform": "0.96.1",
+    "@effect/rpc": "0.75.1",
+    "@effect/sql": "0.51.1",
+    "@effect/vitest": "0.29.0",
+    "@effect/workflow": "0.18.1",
     "@eslint/js": "10.0.1",
     "@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",
+    "effect": "3.21.2",
     "eslint": "10.0.2",
     "prettier": "3.8.1",
     "tsdown": "0.20.3",
-    "tsx": "^4.21.0",
+    "tsx": "4.21.0",
     "typescript": "5.9.3",
     "typescript-eslint": "8.56.1",
     "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": "8.0.0",
+    "@confect/test": "8.0.0"
   },
   "peerDependencies": {
-    "@effect/platform": "^0.94.5",
-    "@effect/platform-node": "^0.104.1",
+    "@effect/platform": "^0.96.1",
+    "@effect/platform-node": "^0.106.0",
     "convex": "^1.30.0",
-    "effect": "^3.19.16",
-    "@confect/core": "6.0.0"
+    "effect": "^3.21.2",
+    "@confect/core": "^8.0.0"
   },
   "engines": {
     "node": ">=22",
@@ -88,11 +88,15 @@
     "build": "tsdown --config-loader unrun",
     "dev": "tsdown --watch",
     "test": "vitest run",
+    "test:mock-backend": "vitest run --config vitest.mock-backend.config.ts",
+    "test:local-backend": "vitest run --config vitest.local-backend.config.ts",
+    "codegen:mock-backend": "cd test/mock-backend/fixtures && pnpm confect codegen && CONVEX_AGENT_MODE=anonymous pnpm convex dev --once --typecheck=disable --tail-logs=disable",
+    "codegen:local-backend": "cd test/local-backend/fixtures && pnpm confect codegen && CONVEX_AGENT_MODE=anonymous pnpm convex dev --once --typecheck=disable --tail-logs=disable",
     "typecheck": "tsc --noEmit --project tsconfig.json",
     "fix": "prettier --write . && eslint --fix . --max-warnings=0",
     "format": "prettier --check .",
     "lint": "eslint . --max-warnings=0",
-    "bench": "tsx test/SchemaToValidator.bench.ts",
+    "bench": "tsx test/SchemaToValidator.bench.ts && tsx test/Document.bench.ts",
     "clean": "rm -rf dist coverage node_modules"
   }
 }

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/DatabaseSchema.ts

@@ -3,14 +3,15 @@ import {
   defineSchema as defineConvexSchema,
   type SchemaDefinition,
 } from "convex/server";
-import { Array, pipe, Predicate, Record } from "effect";
+import { Array, pipe, Record } from "effect";
 import * as Table from "./Table";
+import { TypeId } from "@confect/core/DatabaseSchema";
 
-export const TypeId = "@confect/server/DatabaseSchema";
-export type TypeId = typeof TypeId;
-
-export const isSchema = (u: unknown): u is Any =>
-  Predicate.hasProperty(u, TypeId);
+export {
+  type Any,
+  isDatabaseSchema,
+  TypeId,
+} from "@confect/core/DatabaseSchema";
 
 /**
  * A schema definition tracks the schema and its Convex schema definition.
@@ -31,10 +32,6 @@ export interface DatabaseSchema<Tables_ extends Table.AnyWithProps = never> {
   ): DatabaseSchema<Tables_ | TableDef>;
 }
 
-export interface Any {
-  readonly [TypeId]: TypeId;
-}
-
 export interface AnyWithProps {
   readonly [TypeId]: TypeId;
   readonly tables: Record<string, Table.AnyWithProps>;

package/src/Document.ts

@@ -1,6 +1,6 @@
+import * as SystemFields from "@confect/core/SystemFields";
 import { Effect, Function, ParseResult, pipe, Schema } from "effect";
 import type { ReadonlyRecord } from "effect/Record";
-import * as SystemFields from "@confect/core/SystemFields";
 import type * as DataModel from "./DataModel";
 import type { ReadonlyValue } from "./SchemaToValidator";
 import type * as TableInfo from "./TableInfo";
@@ -10,6 +10,37 @@ export type WithoutSystemFields<Doc> = Omit<Doc, "_creationTime" | "_id">;
 export type Any = any;
 export type AnyEncoded = ReadonlyRecord<string, ReadonlyValue>;
 
+type Decode = (doc: unknown) => Effect.Effect<unknown, ParseResult.ParseError>;
+
+const decoderCache = new WeakMap<
+  Schema.Schema.AnyNoContext,
+  Map<string, Decode>
+>();
+
+const getDecoder = (
+  tableName: string,
+  tableSchema: Schema.Schema.AnyNoContext,
+): Decode => {
+  const byTable =
+    decoderCache.get(tableSchema) ??
+    (() => {
+      const map = new Map<string, Decode>();
+      decoderCache.set(tableSchema, map);
+      return map;
+    })();
+
+  return (
+    byTable.get(tableName) ??
+    (() => {
+      const decoder = Schema.decode(
+        SystemFields.extendWithSystemFields(tableName, tableSchema),
+      ) as Decode;
+      byTable.set(tableName, decoder);
+      return decoder;
+    })()
+  );
+};
+
 export const decode = Function.dual<
   <
     DataModel_ extends DataModel.AnyWithProps,
@@ -53,36 +84,43 @@ export const decode = Function.dual<
     DataModel.TableInfoWithName_<DataModel_, TableName>["document"],
     DocumentDecodeError
   > =>
-    Effect.gen(function* () {
-      const TableSchemaWithSystemFields = SystemFields.extendWithSystemFields(
-        tableName,
-        tableSchema,
-      );
-
-      const encodedDoc =
-        self as (typeof TableSchemaWithSystemFields)["Encoded"];
-
-      const decodedDoc = yield* pipe(
-        encodedDoc,
-        Schema.decode(TableSchemaWithSystemFields),
-        Effect.catchTag("ParseError", (parseError) =>
-          Effect.gen(function* () {
-            const formattedParseError =
-              yield* ParseResult.TreeFormatter.formatError(parseError);
-
-            return yield* new DocumentDecodeError({
-              tableName,
-              id: encodedDoc._id,
-              parseError: formattedParseError,
-            });
-          }),
-        ),
-      );
-
-      return decodedDoc;
-    }),
+    pipe(
+      self,
+      getDecoder(tableName, tableSchema),
+      Effect.catchIf(ParseResult.isParseError, (parseError) =>
+        Effect.gen(function* () {
+          const formattedParseError =
+            yield* ParseResult.TreeFormatter.formatError(parseError);
+
+          return yield* new DocumentDecodeError({
+            tableName,
+            id: self._id,
+            parseError: formattedParseError,
+          });
+        }),
+      ),
+      Effect.map(
+        (decodedDoc) =>
+          decodedDoc as DataModel.TableInfoWithName_<
+            DataModel_,
+            TableName
+          >["document"],
+      ),
+    ),
 );
 
+type Encode = (doc: unknown) => Effect.Effect<unknown, ParseResult.ParseError>;
+
+const encoderCache = new WeakMap<Schema.Schema.AnyNoContext, Encode>();
+
+const getEncoder = (tableSchema: Schema.Schema.AnyNoContext): Encode =>
+  encoderCache.get(tableSchema) ??
+  (() => {
+    const encoder = Schema.encode(tableSchema) as Encode;
+    encoderCache.set(tableSchema, encoder);
+    return encoder;
+  })();
+
 export const encode = Function.dual<
   <
     DataModel_ extends DataModel.AnyWithProps,
@@ -126,35 +164,29 @@ export const encode = Function.dual<
     DataModel.TableInfoWithName_<DataModel_, TableName>["encodedDocument"],
     DocumentEncodeError
   > =>
-    Effect.gen(function* () {
-      type TableSchemaWithSystemFields = SystemFields.ExtendWithSystemFields<
-        TableName,
-        TableInfo.TableSchema<
-          DataModel.TableInfoWithName_<DataModel_, TableName>
-        >
-      >;
-
-      const decodedDoc = self as TableSchemaWithSystemFields["Type"];
-
-      const encodedDoc = yield* pipe(
-        decodedDoc,
-        Schema.encode(tableSchema),
-        Effect.catchTag("ParseError", (parseError) =>
-          Effect.gen(function* () {
-            const formattedParseError =
-              yield* ParseResult.TreeFormatter.formatError(parseError);
-
-            return yield* new DocumentEncodeError({
-              tableName,
-              id: decodedDoc._id,
-              parseError: formattedParseError,
-            });
-          }),
-        ),
-      );
-
-      return encodedDoc;
-    }),
+    pipe(
+      self,
+      getEncoder(tableSchema),
+      Effect.catchIf(ParseResult.isParseError, (parseError) =>
+        Effect.gen(function* () {
+          const formattedParseError =
+            yield* ParseResult.TreeFormatter.formatError(parseError);
+
+          return yield* new DocumentEncodeError({
+            tableName,
+            id: self._id,
+            parseError: formattedParseError,
+          });
+        }),
+      ),
+      Effect.map(
+        (encodedDoc) =>
+          encodedDoc as DataModel.TableInfoWithName_<
+            DataModel_,
+            TableName
+          >["encodedDocument"],
+      ),
+    ),
 );
 
 export class DocumentDecodeError extends Schema.TaggedError<DocumentDecodeError>()(

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>,