effect-zero 0.5.0 → 0.6.0-beta.0

package/src/server-transaction.ts

@@ -1,25 +1,28 @@
 import type { Schema as ZeroSchema, ServerTransaction as ZeroServerTransaction } from "@rocicorp/zero";
-import type { TransactionProviderHooks, ZQLDatabase } from "@rocicorp/zero/server";
+import type { ZQLDatabase } from "@rocicorp/zero/server";
 import * as Cause from "effect/Cause";
 import * as Ctx from "effect/Context";
 import * as Data from "effect/Data";
-import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
 import type { NodeInspectSymbol } from "effect/Inspectable";
 import * as Layer from "effect/Layer";
 import * as Predicate from "effect/Predicate";
 import type * as Unify from "effect/Unify";
-import type * as ClientTransaction from "./client-transaction.js";
-import { MutationAlreadyProcessedError, OutOfOrderMutationError, ServerTransactionInput } from "./internal/server.js";
-import * as ServerSynchronizationContext from "./internal/server-synchronization-context.js";
+import * as ClientTransaction from "./client-transaction.js";
+import type {
+  MultipleTransactionsError,
+  TransactCallbackNotInvokedError,
+  TransactInternalError,
+} from "./internal/server.js";
+import type * as ServerSynchronizationContext from "./internal/server-synchronization-context.js";
 import { prefixId } from "./internal/utils.js";
 
-// Updated to: https://github.com/rocicorp/mono/blob/3082c9fa061891067b4bd7dc9fe74f798270d8d7/packages/zero-server/src/push-processor.ts
-
 type _NodeInspectSymbol = NodeInspectSymbol;
 type _Unify = Unify.typeSymbol | Unify.unifySymbol | Unify.ignoreSymbol;
 
+export const DatabaseSymbol = Symbol.for(prefixId("Database"));
+export const ServerTransactionCallbackSymbol = Symbol.for(prefixId("ServerTransactionCallback"));
+
 // biome-ignore lint/suspicious/noExplicitAny: any client transaction (its Id literal is irrelevant here)
 export type Context<TSchema extends ZeroSchema, TTransaction> = ReturnType<typeof make<any, TSchema, TTransaction>>;
 
@@ -28,111 +31,62 @@ export const make = <const Id extends string, TSchema extends ZeroSchema, TTrans
   database: ZQLDatabase<TSchema, TTransaction>,
   clientTransaction: ClientTransaction.Context<TSchema>,
 ) => {
-  class Context extends Ctx.Service<
-    Context,
-    { transaction: ZeroServerTransaction<TSchema, TTransaction>; transactionHooks: TransactionProviderHooks }
-  >()(`${id as string}/ServerTransactionContext` as const) {}
+  class Context extends Ctx.Service<Context, ZeroServerTransaction<TSchema, TTransaction>>()(
+    `${id as string}/ServerTransactionContext` as const,
+  ) {}
 
-  const use = <A>(
+  class ServerTransactionCallback extends Ctx.Service<
+    ServerTransactionCallback,
+    {
+      readonly transact: <A, E, R>(
+        fn: (transaction: ZeroServerTransaction<TSchema, TTransaction>) => Effect.Effect<A, E, R>,
+      ) => Effect.Effect<
+        A,
+        E | TransactInternalError | TransactCallbackNotInvokedError | MultipleTransactionsError,
+        R | ServerSynchronizationContext.ServerSynchronizationContext
+      >;
+    }
+  >()(`${id as string}/ServerTransactionCallback` as const) {}
+
+  const use = Effect.fn(function* <A>(
     fn: (
       transaction: ZeroServerTransaction<TSchema, TTransaction>,
       options: { readonly signal: AbortSignal },
     ) => PromiseLike<A>,
-  ) =>
-    Effect.gen(function* () {
-      const ctx = yield* Context;
-      return yield* Effect.tryPromise({
-        try: (signal) => fn(ctx.transaction, { signal }),
-        catch: (error) => new ServerTransactionError({ cause: Cause.fail(error) }),
-      });
+  ) {
+    const transaction = yield* Context;
+    return yield* Effect.tryPromise({
+      try: (signal) => fn(transaction, { signal }),
+      catch: (error) => new TransactionUseError({ cause: Cause.fail(error) }),
     });
+  });
 
   const execute = Effect.fn(function* <A, E, R>(effect: Effect.Effect<A, E, R>) {
-    const ctx = yield* Effect.context<
-      ServerTransactionInput | Exclude<R, (typeof clientTransaction.Context)["Identifier"] | Context>
-    >();
-    const result = yield* Deferred.make<A, E | Effect.Error<typeof checkAndIncrementLastMutationId>>();
-
-    const transactionInput = yield* ServerTransactionInput;
-    yield* Effect.tryPromise({
-      try: (signal) =>
-        database.transaction(async (transaction, transactionHooks) => {
-          const exit = await Effect.flatMap(checkAndIncrementLastMutationId, () => effect).pipe(
-            Effect.provide([
-              Layer.succeed(Context, { transaction, transactionHooks }),
-              Layer.succeed(clientTransaction.Context, transaction),
-            ]),
-            (effect) => Effect.runPromiseExitWith(ctx)(effect, { signal }),
-          );
-          Deferred.doneUnsafe(result, exit);
-          if (Exit.isFailure(exit)) {
-            // This error's purpose is to differentiate between "external" errors
-            // that originate from the user-defined mutator code and "internal" errors
-            // that originate from our own code and the Zero API.
-            // Both types are caught in the "catch" block below, but at this point we only need to handle
-            // the "internal" errors wrapping them in a `ZeroDatabaseError`, because "external" errors
-            // are already covered by passing the Exit result to the Deferred, which is why
-            // we have the ServerTransactionUserError silenced below in the pipe.
-            throw new ServerTransactionUserError();
-          }
-          return exit.value;
-        }, transactionInput),
-      catch: (error) => {
-        if (ServerTransactionUserError.is(error)) {
-          return error;
-        }
-        // This is for errors that occur when calling `database.transaction` despite the provided `effect` succeeding.
-        // This can be caused by e.g. the database connection timing out or other database-related issues.
-        return new ZeroDatabaseError({ cause: Cause.fail(error) });
-      },
-    }).pipe(Effect.catchTag("ServerTransactionUserError", () => Effect.void));
-
-    return yield* Deferred.await(result);
-  }, ServerSynchronizationContext.guard);
-
-  const checkAndIncrementLastMutationId = Effect.gen(function* () {
-    const { transactionHooks } = yield* Context;
-    const { clientID, mutationID: receivedMutationID } = yield* ServerTransactionInput;
-
-    const { lastMutationID } = yield* Effect.tryPromise({
-      try: () => transactionHooks.updateClientMutationID(),
-      catch: (error) => new UpdateClientMutationIdError({ cause: Cause.fail(error) }),
-    });
-
-    if (receivedMutationID < lastMutationID) {
-      return yield* new MutationAlreadyProcessedError({
-        clientID,
-        received: receivedMutationID,
-        actual: lastMutationID,
-      });
-    }
-    if (receivedMutationID > lastMutationID) {
-      return yield* new OutOfOrderMutationError({
-        clientID,
-        receivedMutationID,
-        lastMutationID,
-      });
-    }
+    const { transact } = yield* ServerTransactionCallback;
+    return yield* transact((transaction) =>
+      effect.pipe(
+        // Provide the live transaction under both the server- and client-transaction tags.
+        Effect.provide([
+          Layer.succeed(Context, transaction),
+          Layer.succeed(clientTransaction[ClientTransaction.ContextSymbol], transaction),
+        ]),
+      ),
+    );
   });
 
-  return { Context, use, execute };
+  return {
+    use,
+    execute,
+    [DatabaseSymbol]: database,
+    [ServerTransactionCallbackSymbol]: ServerTransactionCallback,
+  };
 };
 
-class ServerTransactionError extends Data.TaggedError("ServerTransactionError")<{
+class TransactionUseError extends Data.TaggedError("TransactionUseError")<{
   readonly cause: Cause.Cause<unknown>;
-}> {}
-
-class UpdateClientMutationIdError extends Data.TaggedError("UpdateClientMutationIdError")<{
-  readonly cause: Cause.Cause<unknown>;
-}> {}
-class ZeroDatabaseError extends Data.TaggedError("ZeroDatabaseError")<{
-  readonly cause: Cause.Cause<unknown>;
-}> {}
-
-const ServerTransactionUserErrorTypeId = Symbol.for(prefixId("ServerTransactionUserError"));
-class ServerTransactionUserError extends Data.TaggedError("ServerTransactionUserError") {
-  readonly [ServerTransactionUserErrorTypeId] = ServerTransactionUserErrorTypeId;
-  static is(e: unknown): e is ServerTransactionUserError {
-    return Predicate.hasProperty(e, ServerTransactionUserErrorTypeId);
+}> {
+  override get message() {
+    const error = Cause.squash(this.cause);
+    return Predicate.isError(error) ? error.message : "Internal error";
   }
 }

package/src/server.ts

@@ -1,83 +1,148 @@
-import type { ReadonlyJSONValue, Schema as ZeroSchema } from "@rocicorp/zero";
-import { handleQueryRequest } from "@rocicorp/zero/server";
+import type {
+  ReadonlyJSONValue,
+  Schema as ZeroSchema,
+  ServerTransaction as ZeroServerTransaction,
+} from "@rocicorp/zero";
+import { ApplicationError, handleMutateRequest, handleQueryRequest, OutOfOrderMutation } from "@rocicorp/zero/server";
 import * as Arr from "effect/Array";
 import * as Cause from "effect/Cause";
 import * as Data from "effect/Data";
+import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Fn from "effect/Function";
 import type { NodeInspectSymbol } from "effect/Inspectable";
+import * as Layer from "effect/Layer";
 import * as Match from "effect/Match";
 import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
 import * as Rec from "effect/Record";
 import * as Schema from "effect/Schema";
-import * as Stream from "effect/Stream";
 import * as Str from "effect/String";
 import type * as Unify from "effect/Unify";
-import { MutationAlreadyProcessedError, OutOfOrderMutationError, ServerTransactionInput } from "./internal/server.js";
+import { TransactCallbackNotInvokedError, TransactInternalError } from "./internal/server.js";
 import * as ServerSynchronizationContext from "./internal/server-synchronization-context.js";
-import { normalizeArgs, prefixId } from "./internal/utils.js";
+import { normalizeArgs } from "./internal/utils.js";
 import * as Mutators from "./mutators.js";
 import { type MakeQueryResult, QueryNameSymbol, RunQuerySymbol } from "./query.js";
 import type * as ServerTransaction from "./server-transaction.js";
-import * as Types from "./types/push.js";
-import type { TransformRequestMessage } from "./types/queries.js";
+import { DatabaseSymbol, ServerTransactionCallbackSymbol } from "./server-transaction.js";
+import type { TransformRequestMessage } from "./types/custom-queries.js";
+import type { MutateParams } from "./types/mutate-server.js";
+import type { Mutation } from "./types/mutation.js";
+import type { PushBody } from "./types/push.js";
 
 // Updated to:
-// https://github.com/rocicorp/mono/blob/3082c9fa061891067b4bd7dc9fe74f798270d8d7/packages/zero-server/src/push-processor.ts
-// https://github.com/rocicorp/mono/blob/3082c9fa061891067b4bd7dc9fe74f798270d8d7/packages/zero-server/src/process-mutations.ts
+// https://github.com/rocicorp/mono/blob/0eeabd495a26d0d67b9a5a81c424d8a76ef004b7/packages/zero-server/src/process-mutations.ts#L214
 
 type _NodeInspectSymbol = NodeInspectSymbol;
 type _Unify = Unify.typeSymbol | Unify.unifySymbol | Unify.ignoreSymbol;
 
-export const processPush = Effect.fn(function* <
+// The userId type, pulled from the upstream handlers. We read it off the response type rather than
+// `Parameters<...>[0]` because the handlers are overloaded (so `Parameters` resolves to the wrong
+// overload) and their argument type isn't exported.
+type MutateUserId = Extract<Awaited<ReturnType<typeof handleMutateRequest>>, { kind: "MutateResponse" }>["userID"];
+type QueryUserId = Extract<Awaited<ReturnType<typeof handleQueryRequest>>, { kind: "QueryResponse" }>["userID"];
+
+export const handleMutate = Effect.fn(function* <
   TSchema extends ZeroSchema,
   TTransaction,
   TMutators extends Mutators.AnyMutators,
->(
-  transaction: ServerTransaction.Context<TSchema, TTransaction>,
-  mutators: TMutators,
-  params: Types.PushParams,
-  request: Types.PushBody,
-) {
-  if (request.pushVersion !== 1) {
-    return { error: "unsupportedPushVersion" as const };
-  }
+>({
+  transaction,
+  mutators,
+  query,
+  body,
+  userId,
+}: {
+  transaction: ServerTransaction.Context<TSchema, TTransaction>;
+  mutators: TMutators;
+  query: MutateParams;
+  body: PushBody;
+  userId: MutateUserId;
+}) {
+  const ctx =
+    yield* Effect.context<
+      Exclude<
+        Mutators.ExtractMutatorsRequirements<TMutators>,
+        | (typeof transaction)[typeof ServerTransactionCallbackSymbol]["Identifier"]
+        | ServerSynchronizationContext.ServerSynchronizationContext
+      >
+    >();
 
-  const responses = yield* Stream.fromIterable(request.mutations).pipe(
-    Stream.mapEffect(
-      Effect.fn(function* (mutation) {
-        if (mutation.type !== "custom") {
-          return yield* new CustomMutationExpectedError();
-        }
-
-        return yield* processMutation<Mutators.ExtractMutatorsRequirements<TMutators>>(mutators, mutation).pipe(
-          Effect.catch((e) => processMutationError(transaction, e)),
-          Effect.map((result) =>
-            Types.MutationResponse.make({ id: { id: mutation.id, clientID: mutation.clientID }, result }),
+  return yield* Effect.tryPromise({
+    try: () =>
+      handleMutateRequest({
+        dbProvider: transaction[DatabaseSymbol],
+        handler: (transact_, mutation) =>
+          Effect.gen(function* () {
+            const response = yield* Deferred.make<Awaited<ReturnType<typeof transact_>>>();
+
+            const transact = Effect.fn(function* <A, E, R>(
+              fn: (transaction: ZeroServerTransaction<TSchema, TTransaction>) => Effect.Effect<A, E, R>,
+            ) {
+              const innerCtx = yield* Effect.context<R>();
+              const exitDeferred = yield* Deferred.make<A, E>();
+
+              yield* Effect.tryPromise({
+                try: (signal) =>
+                  transact_((transaction) =>
+                    fn(transaction).pipe(
+                      Effect.onExit((exit) => Deferred.done(exitDeferred, exit)),
+                      Effect.catchCause((cause) => Effect.die(makeApplicationError(cause))),
+                      Effect.asVoid,
+                      Effect.provide(innerCtx),
+                      (effect) => Effect.runPromise(effect, { signal }),
+                    ),
+                  ),
+                catch: (error) => new TransactInternalError({ cause: Cause.fail(error) }),
+              }).pipe(Effect.flatMap((value) => Deferred.succeed(response, value)));
+
+              return yield* Deferred.poll(exitDeferred).pipe(
+                Effect.flatMap(Effect.fromOption),
+                Effect.catchTag("NoSuchElementError", () => Effect.fail(new TransactCallbackNotInvokedError())),
+                Effect.flatten,
+              );
+            }, ServerSynchronizationContext.guard);
+
+            const exit: Exit.Exit<unknown, unknown> = yield* runMutation<
+              Mutators.ExtractMutatorsRequirements<TMutators>
+            >(mutators, mutation).pipe(
+              ServerSynchronizationContext.finalize,
+              Effect.provide([
+                Layer.succeed(transaction[ServerTransactionCallbackSymbol], { transact }),
+                ServerSynchronizationContext.layer,
+              ]),
+              Effect.exit,
+            );
+
+            return yield* Deferred.poll(response).pipe(
+              Effect.flatMap(Effect.fromOption),
+              Effect.catchTag("NoSuchElementError", () =>
+                Effect.failCause(Exit.isFailure(exit) ? exit.cause : Cause.empty),
+              ),
+              Effect.flatten,
+            );
+          }).pipe(
+            Effect.catchCause((cause) => {
+              const error = cause.pipe(Cause.squash, (squashed) =>
+                TransactInternalError.is(squashed) ? Cause.squash(squashed.cause) : squashed,
+              );
+              // Split out-of-order mutations from application errors, as `handleMutateRequest` expects.
+              return Effect.fail(error instanceof OutOfOrderMutation ? error : makeApplicationError(Cause.fail(error)));
+            }),
+            Effect.provide(ctx),
+            Effect.runPromise,
           ),
-          Effect.provideService(ServerTransactionInput, {
-            clientID: mutation.clientID,
-            mutationID: mutation.id,
-            clientGroupID: request.clientGroupID,
-            upstreamSchema: params.schema,
-          }),
-          Effect.provide(ServerSynchronizationContext.layer),
-        );
+        query,
+        body: body as ReadonlyJSONValue,
+        userID: userId,
       }),
-    ),
-    // We only stop processing if the mutation is out of order.
-    // If the mutation has already been processed or if it returns an application error,
-    // we continue processing the next mutation.
-    Stream.takeUntil(({ result }) => Predicate.hasProperty(result, "error") && result.error === "oooMutation"),
-    Stream.runCollect,
-  );
-
-  return { mutations: responses } satisfies Types.PushResponse;
+    catch: (e) => new HandleMutateError({ cause: Cause.fail(e) }),
+  });
 });
 
-const processMutation = Effect.fn(function* <R>(mutators: Mutators.AnyMutators<R>, mutation: Types.Mutation) {
+const runMutation = Effect.fn(function* <R>(mutators: Mutators.AnyMutators<R>, mutation: Mutation) {
   // Support both "namespace|name" and "namespace.name" formats, and single-segment names.
   const [namespace, name] = mutation.name.includes("|") ? Str.split(mutation.name, "|") : Str.split(mutation.name, ".");
 
@@ -99,117 +164,58 @@ const processMutation = Effect.fn(function* <R>(mutators: Mutators.AnyMutators<R
     normalizeArgs(mutation.args[0]),
   ).pipe(Effect.catchTag("SchemaError", (e) => Effect.fail(new ServerArgsParseError({ cause: Cause.fail(e) }))));
 
-  return yield* mutator(args).pipe(
-    ServerSynchronizationContext.finalize,
-    Effect.as<Types.MutationResult>({}),
-    Effect.catchIf(OutOfOrderMutationError.is, (e) =>
-      Effect.logError(e.message).pipe(
-        Effect.as({ error: "oooMutation", details: e.message } satisfies Types.ZeroError),
-      ),
-    ),
-    Effect.catchIf(MutationAlreadyProcessedError.is, (e) =>
-      Effect.logWarning(e.message).pipe(
-        Effect.as({ error: "alreadyProcessed", details: e.message } satisfies Types.ZeroError),
-      ),
-    ),
-    // Case #5 "Zero transactions then fail" / #6 "Fail before transaction"
-    // Catches all errors that are produced before the transaction is executed
-    Effect.catchCause((cause) => Effect.fail(new MutationUserError({ cause }))),
-  );
+  return yield* mutator(args);
 });
 
-const processMutationError = Effect.fn(function* <TSchema extends ZeroSchema, TTransaction>(
-  transaction: ServerTransaction.Context<TSchema, TTransaction>,
-  e: unknown,
-) {
-  const { clientID, mutationID } = yield* ServerTransactionInput;
-
-  yield* Effect.logError(`Unexpected error processing mutation ${mutationID} for client ${clientID}`, Cause.fail(e));
-
-  const errorMessage = Match.value(e).pipe(
-    Match.when(MutationUserError.is, (e) => e.message),
-    Match.orElse(() => "Internal error"),
-  );
-
-  const appError = {
-    error: "app",
-    details: errorMessage,
-  } satisfies Types.AppError;
-
-  yield* transaction
-    .execute(
-      Effect.gen(function* () {
-        const { transactionHooks } = yield* transaction.Context;
-        return yield* Effect.tryPromise({
-          try: () => transactionHooks.writeMutationResult({ id: { id: mutationID, clientID }, result: appError }),
-          catch: (error) => new WriteMutationResultError({ cause: Cause.fail(error) }),
-        });
-      }),
-    )
-    .pipe(Effect.catchCause(Effect.logError));
-
-  yield* Effect.logWarning(`Mutation ${mutationID} for client ${clientID} was retried after an error: ${e}`);
-
-  return appError;
-});
+export const makeApplicationError = (cause: Cause.Cause<unknown>) => {
+  const error = Cause.squash(cause);
+  const message = Predicate.isError(error) ? error.message : "Internal error";
+  return new ApplicationError(message, { cause: error });
+};
 
-class WriteMutationResultError extends Data.TaggedError("WriteMutationResultError")<{
-  readonly cause: Cause.Cause<unknown>;
-}> {}
-class CustomMutationExpectedError extends Data.TaggedError("CustomMutationExpectedError") {}
 class MutatorNotFoundError extends Data.TaggedError("MutatorNotFoundError")<{
   readonly name: string;
-}> {}
-
-class ServerArgsParseError extends Data.TaggedError("ServerArgsParseError")<{
-  readonly cause: Cause.Cause<Schema.SchemaError>;
-}> {}
-
-const MutationUserErrorTypeId = Symbol.for(prefixId("MutationUserError"));
-class MutationUserError extends Data.TaggedError("MutationUserError")<{
-  readonly cause: Cause.Cause<unknown>;
 }> {
-  readonly [MutationUserErrorTypeId] = MutationUserErrorTypeId;
-  static is(e: unknown): e is MutationUserError {
-    return Predicate.hasProperty(e, MutationUserErrorTypeId);
-  }
-
   override get message() {
-    const err = Cause.squash(this.cause);
-    return err instanceof Error ? err.message : "exception was not of type `Error`";
+    return `Mutator not found: ${this.name}`;
   }
 }
 
-export const handleQuery = Effect.fn(function* <E, R1, R2>(
-  queries: MakeQueryResult<E, R1, R2>[],
-  schema: ZeroSchema,
-  payload: TransformRequestMessage,
-) {
+class ServerArgsParseError extends Data.TaggedError("ServerArgsParseError")<{
+  readonly cause: Cause.Cause<unknown>;
+}> {}
+
+class HandleMutateError extends Data.TaggedError("HandleMutateError")<{ readonly cause: Cause.Cause<unknown> }> {}
+
+export const handleQuery = Effect.fn(function* <E, R1, R2>({
+  queries,
+  schema,
+  body,
+  userId,
+}: {
+  queries: MakeQueryResult<E, R1, R2>[];
+  schema: ZeroSchema;
+  body: TransformRequestMessage;
+  userId: QueryUserId;
+}) {
   const ctx = yield* Effect.context<R1 | R2>();
   return yield* Effect.tryPromise({
     try: () =>
-      handleQueryRequest(
-        (name, args) =>
+      handleQueryRequest({
+        handler: (name, args) =>
           Arr.findFirst(queries, (q) => q[QueryNameSymbol] === name).pipe(
             Effect.fromOption,
             Effect.catchTag("NoSuchElementError", () => Effect.fail(new QueryNotFound({ name }))),
             Effect.flatMap((query) => query[RunQuerySymbol]({ _tag: "Encoded", args })),
-            Effect.runSyncExitWith(ctx),
-            (exit) => {
-              if (Exit.isFailure(exit)) {
-                throw new QueryUserError<E>({ cause: exit.cause });
-              }
-              return exit.value;
-            },
+            Effect.runSyncWith(ctx),
           ),
         schema,
-        payload as ReadonlyJSONValue,
-      ),
-    catch: (e) =>
-      Option.liftPredicate(e, QueryUserError.is<E>).pipe(
-        Option.flatMap((e) => Cause.findErrorOption(e.cause)),
-        Option.getOrElse(() => new QueryRequestError({ cause: Cause.fail(e) })),
-      ),
+        // `query` params are unused by the query endpoint at runtime but required by the options type.
+        query: {},
+        body: body as ReadonlyJSONValue,
+        userID: userId,
+      }),
+    catch: (e) => new HandleQueryError({ cause: Cause.fail(e) }),
   });
 });
 
@@ -219,14 +225,4 @@ class QueryNotFound extends Data.TaggedError("QueryNotFound")<{ name: string }>
   }
 }
 
-const QueryUserErrorTypeId = Symbol.for(prefixId("QueryUserError"));
-class QueryUserError<E> extends Data.TaggedError("QueryUserError")<{
-  cause: Cause.Cause<E | Schema.SchemaError | QueryNotFound>;
-}> {
-  readonly [QueryUserErrorTypeId] = QueryUserErrorTypeId;
-  static is<E>(e: unknown): e is QueryUserError<E> {
-    return Predicate.hasProperty(e, QueryUserErrorTypeId);
-  }
-}
-
-class QueryRequestError extends Data.TaggedError("QueryRequestError")<{ cause: Cause.Cause<unknown> }> {}
+class HandleQueryError extends Data.TaggedError("HandleQueryError")<{ cause: Cause.Cause<unknown> }> {}

package/src/types/ast.ts

@@ -0,0 +1,4 @@
+import * as Schema from "effect/Schema";
+
+/** TODO: Defined as unknown for now */
+export const Ast = Schema.Unknown;

package/src/types/{queries.ts → custom-queries.ts}

@@ -1,12 +1,10 @@
 import * as Schema from "effect/Schema";
+import { Ast } from "./ast.js";
 import { JsonSchema } from "./common.js";
 import { TransformFailedBody } from "./error.js";
 
 // The code below was converted to Effect Schema from:
-// https://github.com/rocicorp/mono/blob/8e0f600fb3a9185facf60cfd4971d260b266690e/packages/zero-protocol/src/custom-queries.ts
-
-/** TODO: Defined as unknown for now */
-const Ast = Schema.Unknown;
+// https://github.com/rocicorp/mono/blob/74273167af5d15ed07045e04165cb04d3983d44f/packages/zero-protocol/src/custom-queries.ts
 
 const TransformRequestBody = Schema.Array(
   Schema.Struct({
@@ -16,7 +14,7 @@ const TransformRequestBody = Schema.Array(
   }),
 );
 
-const TransformedQuery = Schema.Struct({
+export const TransformedQuery = Schema.Struct({
   id: Schema.String,
   name: Schema.String,
   ast: Ast,
@@ -39,7 +37,7 @@ const ParseErroredQuery = Schema.Struct({
   details: Schema.optional(JsonSchema),
 });
 
-const ErroredQuery = Schema.Union([AppErroredQuery, ParseErroredQuery]);
+export const ErroredQuery = Schema.Union([AppErroredQuery, ParseErroredQuery]);
 
 const TransformResponseBody = Schema.Array(Schema.Union([TransformedQuery, ErroredQuery]));
 

package/src/types/mutate-server.ts

@@ -0,0 +1,37 @@
+import * as Schema from "effect/Schema";
+import { PushFailedBody } from "./error.js";
+import { MutationResponse } from "./mutation.js";
+import { PushError } from "./push.js";
+
+// The code below was converted to Effect Schema from:
+// https://github.com/rocicorp/mono/blob/74273167af5d15ed07045e04165cb04d3983d44f/packages/zero-protocol/src/mutate-server.ts
+
+const LegacyPushSuccess = Schema.Struct({
+  mutations: Schema.Array(MutationResponse),
+});
+
+const LegacyPushResponse = Schema.Union([LegacyPushSuccess, PushError, PushFailedBody]);
+
+export const MutateSuccess = Schema.Struct({
+  kind: Schema.Literal("MutateResponse"),
+  userID: Schema.optional(Schema.NullOr(Schema.String)),
+  mutations: Schema.Array(MutationResponse),
+});
+export type MutateSuccess = typeof MutateSuccess.Type;
+
+export const MutateResponse = Schema.Union([
+  MutateSuccess,
+  PushFailedBody,
+  // for backwards compatibility
+  LegacyPushResponse,
+]);
+export type MutateResponse = typeof MutateResponse.Type;
+
+/**
+ * The schema for the querystring parameters of the custom mutate endpoint.
+ */
+export const MutateParams = Schema.Struct({
+  schema: Schema.String,
+  appID: Schema.String,
+});
+export type MutateParams = typeof MutateParams.Type;

package/src/types/mutation-id.ts

@@ -0,0 +1,10 @@
+import * as Schema from "effect/Schema";
+
+// The code below was converted to Effect Schema from:
+// https://github.com/rocicorp/mono/blob/74273167af5d15ed07045e04165cb04d3983d44f/packages/zero-protocol/src/mutation-id.ts
+
+export const MutationId = Schema.Struct({
+  id: Schema.Number,
+  clientID: Schema.String,
+});
+export type MutationId = typeof MutationId.Type;