effect-zero 0.3.3 → 0.4.1

package/src/query.ts

@@ -1,4 +1,5 @@
 import type { HumanReadable, ReadonlyJSONValue, Zero, Query as ZeroQuery, Schema as ZeroSchema } from "@rocicorp/zero";
+import { asQueryInternals } from "@rocicorp/zero/bindings";
 import * as Effect from "effect/Effect";
 import * as Equal from "effect/Equal";
 import * as Hash from "effect/Hash";
@@ -10,15 +11,8 @@ import * as QueryResult from "./internal/query-result.js";
 import { prefixId } from "./internal/utils.js";
 import { deepClone, getDefaultSnapshot, getSnapshot } from "./snapshot.js";
 
-export type Query<S extends ZeroSchema, T extends keyof S["tables"] & string, R> = ZeroQuery<S, T, R> & Equal.Equal;
-
-type QueryArgs<
-  A extends ReadonlyJSONValue[],
-  B extends unknown[],
-> = // biome-ignore lint/suspicious/noExplicitAny: handles "any query" case
-| { _tag: "Encoded"; args: any extends A ? any : readonly [...A] }
-// biome-ignore lint/suspicious/noExplicitAny: handles "any query" case
-| { _tag: "Decoded"; args: any extends B ? any : readonly [...B] };
+// biome-ignore lint/suspicious/noConfusingVoidType: necessary to allow Schema.Void
+type QueryArgs<A extends ReadonlyJSONValue | void, B> = { _tag: "Encoded"; args: A } | { _tag: "Decoded"; args: B };
 
 export const RunQuerySymbol = Symbol.for(prefixId("RunQuery"));
 export const QueryNameSymbol = Symbol.for(prefixId("QueryName"));
@@ -26,19 +20,20 @@ export const QueryNameSymbol = Symbol.for(prefixId("QueryName"));
 export const make = <
   N extends string,
   // The encoded format that is sent over the wire, must conform to JSON
-  A extends ReadonlyJSONValue[],
+  // biome-ignore lint/suspicious/noConfusingVoidType: necessary to allow Schema.Void
+  A extends ReadonlyJSONValue | void,
   // The decoded format, can be anything
-  B extends unknown[],
-  S extends ZeroSchema,
+  B,
   T extends keyof S["tables"] & string,
+  S extends ZeroSchema,
   R,
   E,
   R1,
   R2,
 >(options: {
   name: N;
-  payload: Schema.Schema<readonly [...B], readonly [...A], R1>;
-  query: (...args: NoInfer<B>) => Effect.Effect<ZeroQuery<S, T, R>, E, R2>;
+  payload: Schema.Schema<B, A, R1>;
+  query: (args: NoInfer<B>) => Effect.Effect<ZeroQuery<T, S, R>, E, R2>;
 }) => {
   const runQuery = Effect.fn(function* (args: QueryArgs<A, B>) {
     const { encoded, decoded } = yield* Match.valueTags(args, {
@@ -48,14 +43,14 @@ export const make = <
         Effect.map(Schema.encode(options.payload)(decoded), (encoded) => ({ encoded, decoded })),
     });
 
-    return yield* options.query(...decoded).pipe(
+    return yield* options.query(decoded).pipe(
       Effect.map((rawQuery) => {
-        const query = rawQuery.nameAndArgs(
+        const query = asQueryInternals(rawQuery).nameAndArgs(
           options.name,
           // We pass the encoded `args` to the `nameAndArgs` method, as that is the wire format which
           // is sent to the server.
-          encoded,
-        ) as Query<S, T, R>;
+          encoded !== undefined ? [encoded] : [],
+        ) as ZeroQuery<T, S, R> & Equal.Equal;
         // Adapted from https://github.com/rocicorp/mono/blob/17171f975e61f7ec93c61569da7bda1d962ac962/packages/zero-protocol/src/query-hash.ts#L17
         query[Hash.symbol] = () => Hash.string(`${options.name}:${JSON.stringify(encoded)}`);
         query[Equal.symbol] = function (that) {
@@ -70,7 +65,7 @@ export const make = <
   });
 
   // We return a callable object for ease of use on the frontend.
-  return Object.assign((...args: B) => runQuery({ _tag: "Decoded", args }), {
+  return Object.assign((args: B) => runQuery({ _tag: "Decoded", args }), {
     [QueryNameSymbol]: options.name,
     // Internally, we include the full `runQuery` function for use in library's server logic.
     [RunQuerySymbol]: runQuery,
@@ -80,13 +75,12 @@ export const make = <
 // biome-ignore lint/suspicious/noExplicitAny: accept any query
 export type MakeQueryResult<E = any, R1 = any, R2 = any> = ReturnType<
   // biome-ignore lint/suspicious/noExplicitAny: accept any query
-  typeof make<string, any, any, ZeroSchema, string, Record<string, any> | undefined, E, R1, R2>
+  typeof make<string, any, any, string, ZeroSchema, Record<string, any> | undefined, E, R1, R2>
 >;
 
-export const stream = <S extends ZeroSchema, T extends keyof S["tables"] & string, R>(
+export const stream = <T extends keyof S["tables"] & string, S extends ZeroSchema, R>(
   zero: Zero<S>,
-  // TODO: Look into why this is needed, instead of just `ZeroQuery<S, T, R>`
-  query: ZeroQuery<S, T, R> | Query<S, T, R>,
+  query: ZeroQuery<T, S, R>,
 ) =>
   Effect.gen(function* () {
     const view = yield* Effect.acquireRelease(
@@ -97,28 +91,36 @@ export const stream = <S extends ZeroSchema, T extends keyof S["tables"] & strin
     return Stream.asyncEffect<Parameters<Parameters<(typeof view)["addListener"]>[0]>>((emit) =>
       Effect.sync(() => view.addListener((...args) => emit.single(args))),
     ).pipe(
-      Stream.mapEffect(([data, resultType]) =>
+      Stream.mapEffect(([data, resultType, error]) =>
         Effect.sync(() => {
-          // logic here borrowed from: https://github.com/rocicorp/mono/blob/288b00ec94f5a9ae6e988513423af25c281dbb2a/packages/zero-react/src/use-query.tsx#L295
-          // TODO: Look into why cast needs to be applied to whole ternary here, unlike source.
-          const cloned = (data === undefined ? data : deepClone(data as ReadonlyJSONValue)) as HumanReadable<R>;
-          return getSnapshot<R>(query.format.singular, cloned, resultType);
+          // logic here borrowed from: https://github.com/rocicorp/mono/blob/8e0f600fb3a9185facf60cfd4971d260b266690e/packages/zero-react/src/use-query.tsx#L543
+          const cloned = data === undefined ? data : (deepClone(data as ReadonlyJSONValue) as HumanReadable<R>);
+          return getSnapshot<R>(
+            asQueryInternals(query).format.singular,
+            cloned,
+            resultType,
+            // TODO: Look into this. It seems like this is difficult but not impossible to model in the Effect paradigm.
+            // Likely need some kind of stateful piece between the publisher and and subscriber, allowing the subscriber to swap out
+            // the publisher when this function is called.
+            () => Effect.dieMessage("retry not available in `effect-zero`"),
+            error,
+          );
         }),
       ),
       Stream.map(QueryResult.make),
     );
   }).pipe(Stream.unwrapScoped);
 
-export const initialValue = <S extends ZeroSchema, T extends keyof S["tables"] & string, R>(
-  query: ZeroQuery<S, T, R> | Query<S, T, R>,
-) => QueryResult.make<R>(getDefaultSnapshot(query.format.singular));
+export const initialValue = <T extends keyof S["tables"] & string, S extends ZeroSchema, R>(
+  query: ZeroQuery<T, S, R>,
+) => QueryResult.make<R>(getDefaultSnapshot(asQueryInternals(query).format.singular));
 
-export const subscribable = <S extends ZeroSchema, T extends keyof S["tables"] & string, R>(
+export const subscribable = <T extends keyof S["tables"] & string, S extends ZeroSchema, R>(
   zero: Zero<S>,
-  query: ZeroQuery<S, T, R> | Query<S, T, R>,
+  query: ZeroQuery<T, S, R>,
 ) => {
   return Subscribable.make({
-    get: Effect.promise(() => zero.run(query as ZeroQuery<S, T, R>, { type: "unknown" })).pipe(
+    get: Effect.promise(() => zero.run(query, { type: "unknown" })).pipe(
       Effect.map((value) => ({ _tag: "Partial", value }) satisfies QueryResult.QueryResult.Partial<R>),
     ),
     changes: stream(zero, query),

package/src/result.ts

@@ -1,5 +1,5 @@
 import { Result as AtomResult } from "@effect-atom/atom";
-import type { HumanReadable } from "@rocicorp/zero/react";
+import type { HumanReadable } from "@rocicorp/zero";
 import * as Cause from "effect/Cause";
 import * as Data from "effect/Data";
 import * as Fn from "effect/Function";

package/src/server.ts

@@ -1,5 +1,5 @@
 import type { ReadonlyJSONValue, Schema as ZeroSchema } from "@rocicorp/zero";
-import { handleGetQueriesRequest } from "@rocicorp/zero/server";
+import { handleQueryRequest } from "@rocicorp/zero/server";
 import * as Arr from "effect/Array";
 import * as Cause from "effect/Cause";
 import * as Chunk from "effect/Chunk";
@@ -29,6 +29,10 @@ import type * as ServerTransaction from "./server-transaction.js";
 import * as Types from "./types/push.js";
 import type { TransformRequestMessage } from "./types/queries.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
+
 type ServerTransactionContext<TSchema extends ZeroSchema, TTransaction> = Omit<
   ReturnType<typeof ServerTransaction.make<string, TSchema, TTransaction>>,
   "use"
@@ -54,6 +58,7 @@ export const processPush = Effect.fn(function* <
         if (mutation.type !== "custom") {
           return yield* new CustomMutationExpectedError();
         }
+
         return yield* processMutation<Mutators.ExtractMutatorsRequirements<TMutators>>(mutators, mutation).pipe(
           Effect.catchAll((e) => processMutationError(transaction, e)),
           Effect.map((result) =>
@@ -65,6 +70,7 @@ export const processPush = Effect.fn(function* <
             clientGroupID: request.clientGroupID,
             upstreamSchema: params.schema,
           }),
+          Effect.provide(ServerSynchronizationContext.Default),
         );
       }),
     ),
@@ -76,7 +82,7 @@ export const processPush = Effect.fn(function* <
   );
 
   return { mutations: Chunk.toArray(responses) } satisfies Types.PushResponse;
-}, Effect.provide(ServerSynchronizationContext.Default));
+});
 
 const processMutation = Effect.fn(function* <R>(mutators: Mutators.AnyMutators<R>, mutation: Types.Mutation) {
   // Support both "namespace|name" and "namespace.name" formats, and single-segment names.
@@ -179,7 +185,7 @@ class MutationUserError extends Data.TaggedError("MutationUserError")<{
   }
 }
 
-export const handleGetQueries = Effect.fn(function* <E, R1, R2>(
+export const handleQuery = Effect.fn(function* <E, R1, R2>(
   queries: MakeQueryResult<E, R1, R2>[],
   schema: ZeroSchema,
   payload: TransformRequestMessage,
@@ -187,19 +193,15 @@ export const handleGetQueries = Effect.fn(function* <E, R1, R2>(
   const runtime = yield* Effect.runtime<R1 | R2>();
   return yield* Effect.tryPromise({
     try: () =>
-      handleGetQueriesRequest(
+      handleQueryRequest(
         (name, args) =>
           Arr.findFirst(queries, (q) => q[QueryNameSymbol] === name).pipe(
             Effect.catchTag("NoSuchElementException", () => new QueryNotFound({ name })),
             Effect.flatMap((query) => query[RunQuerySymbol]({ _tag: "Encoded", args })),
-            Effect.map((query) => ({ query })),
-            (effect) => Runtime.runPromiseExit(runtime, effect),
-            (exit) =>
-              exit.then(
-                Exit.getOrElse((cause) => {
-                  throw new QueryUserError<E>({ cause });
-                }),
-              ),
+            (effect) => Runtime.runSyncExit(runtime, effect),
+            Exit.getOrElse((cause) => {
+              throw new QueryUserError<E>({ cause });
+            }),
           ),
         schema,
         payload as ReadonlyJSONValue,
@@ -207,7 +209,7 @@ export const handleGetQueries = Effect.fn(function* <E, R1, R2>(
     catch: (e) =>
       Option.liftPredicate(e, QueryUserError.is<E>).pipe(
         Option.flatMap((e) => Cause.failureOption(e.cause)),
-        Option.getOrElse(() => new GetQueriesError({ cause: Cause.fail(e) })),
+        Option.getOrElse(() => new QueryRequestError({ cause: Cause.fail(e) })),
       ),
   });
 });
@@ -228,4 +230,4 @@ class QueryUserError<E> extends Data.TaggedError("QueryUserError")<{
   }
 }
 
-class GetQueriesError extends Data.TaggedError("GetQueriesError")<{ cause: Cause.Cause<unknown> }> {}
+class QueryRequestError extends Data.TaggedError("QueryRequestError")<{ cause: Cause.Cause<unknown> }> {}

package/src/snapshot.ts

@@ -1,19 +1,22 @@
 // Code borrowed from:
-// https://github.com/rocicorp/mono/blob/30f209f2946b4cf2cd2dee459849351498f11308/packages/zero-react/src/use-query.tsx
-// https://github.com/rocicorp/mono/blob/30f209f2946b4cf2cd2dee459849351498f11308/packages/shared/src/deep-clone.ts#L4
+// https://github.com/rocicorp/mono/blob/8e0f600fb3a9185facf60cfd4971d260b266690e/packages/zero-react/src/use-query.tsx
+// https://github.com/rocicorp/mono/blob/8e0f600fb3a9185facf60cfd4971d260b266690e/packages/shared/src/deep-clone.ts
 
-import type { JSONValue, ReadonlyJSONValue } from "@rocicorp/zero";
-import type { HumanReadable, QueryResult } from "@rocicorp/zero/react";
+import type { ErroredQuery, HumanReadable, JSONValue, QueryErrorDetails, ReadonlyJSONValue, ResultType } from "@rocicorp/zero";
+import type { QueryResult } from "@rocicorp/zero/react";
 
 const emptyArray: unknown[] = [];
 
 const resultTypeUnknown = { type: "unknown" } as const;
 const resultTypeComplete = { type: "complete" } as const;
+const resultTypeError = {type: 'error'} as const;
 
 const emptySnapshotSingularUnknown = [undefined, resultTypeUnknown] as const;
 const emptySnapshotSingularComplete = [undefined, resultTypeComplete] as const;
+const emptySnapshotSingularErrorUnknown = [undefined, resultTypeError] as const;
 const emptySnapshotPluralUnknown = [emptyArray, resultTypeUnknown] as const;
 const emptySnapshotPluralComplete = [emptyArray, resultTypeComplete] as const;
+const emptySnapshotErrorUnknown = [emptyArray, resultTypeError] as const;
 
 export function getDefaultSnapshot<TReturn>(singular: boolean): QueryResult<TReturn> {
   return (singular ? emptySnapshotSingularUnknown : emptySnapshotPluralUnknown) as QueryResult<TReturn>;
@@ -26,21 +29,77 @@ export function getDefaultSnapshot<TReturn>(singular: boolean): QueryResult<TRet
 export function getSnapshot<TReturn>(
   singular: boolean,
   data: HumanReadable<TReturn>,
-  resultType: string,
+  resultType: ResultType,
+  retryFn: () => void,
+  error?: ErroredQuery,
 ): QueryResult<TReturn> {
   if (singular && data === undefined) {
-    return (resultType === "complete"
-      ? emptySnapshotSingularComplete
-      : emptySnapshotSingularUnknown) as unknown as QueryResult<TReturn>;
+    switch (resultType) {
+      case 'error':
+        if (error) {
+          return [
+            undefined,
+            makeError(retryFn, error),
+          ] as unknown as QueryResult<TReturn>;
+        }
+        return emptySnapshotSingularErrorUnknown as unknown as QueryResult<TReturn>;
+      case 'complete':
+        return emptySnapshotSingularComplete as unknown as QueryResult<TReturn>;
+      case 'unknown':
+        return emptySnapshotSingularUnknown as unknown as QueryResult<TReturn>;
+    }
   }
 
   if (!singular && (data as unknown[]).length === 0) {
-    return (
-      resultType === "complete" ? emptySnapshotPluralComplete : emptySnapshotPluralUnknown
-    ) as QueryResult<TReturn>;
+    switch (resultType) {
+      case 'error':
+        if (error) {
+          return [
+            emptyArray,
+            makeError(retryFn, error),
+          ] as unknown as QueryResult<TReturn>;
+        }
+        return emptySnapshotErrorUnknown as unknown as QueryResult<TReturn>;
+      case 'complete':
+        return emptySnapshotPluralComplete as unknown as QueryResult<TReturn>;
+      case 'unknown':
+        return emptySnapshotPluralUnknown as unknown as QueryResult<TReturn>;
+    }
   }
 
-  return [data, resultType === "complete" ? resultTypeComplete : resultTypeUnknown];
+  switch (resultType) {
+    case 'error':
+      if (error) {
+        return [data, makeError(retryFn, error)];
+      }
+      return [
+        data,
+        makeError(retryFn, {
+          error: 'app',
+          id: 'unknown',
+          name: 'unknown',
+          message: 'An unknown error occurred',
+        }),
+      ];
+    case 'complete':
+      return [data, resultTypeComplete];
+    case 'unknown':
+      return [data, resultTypeUnknown];
+  }
+}
+
+function makeError(retry: () => void, error: ErroredQuery): QueryErrorDetails {
+  const message = error.message ?? 'An unknown error occurred';
+  return {
+    type: 'error',
+    retry,
+    refetch: retry,
+    error: {
+      type: error.error,
+      message,
+      ...(error.details ? {details: error.details} : {}),
+    },
+  };
 }
 
 export function deepClone(value: ReadonlyJSONValue): JSONValue {

package/src/types/error.ts

@@ -0,0 +1,71 @@
+import * as Schema from "effect/Schema";
+import { JsonSchema } from "./common.js";
+
+// The code below was converted to Effect Schema from:
+// https://github.com/rocicorp/mono/blob/8e0f600fb3a9185facf60cfd4971d260b266690e/packages/zero-protocol/src/error.ts
+
+const MutationId = Schema.Struct({
+  id: Schema.Number,
+  clientID: Schema.String,
+});
+
+const PushFailedBase = Schema.Struct({
+  kind: Schema.Literal("PushFailed"),
+  details: Schema.optional(JsonSchema),
+  /**
+   * The mutationIDs of the mutations that failed to process.
+   * This can be a subset of the mutationIDs in the request.
+   */
+  mutationIDs: Schema.Array(MutationId),
+  message: Schema.String,
+});
+
+export const PushFailedBody = Schema.Union(
+  Schema.Struct({
+    ...PushFailedBase.fields,
+    origin: Schema.Literal("server"),
+    reason: Schema.Literal("database", "parse", "oooMutation", "unsupportedPushVersion", "internal"),
+  }),
+  Schema.Struct({
+    ...PushFailedBase.fields,
+    origin: Schema.Literal("zeroCache"),
+    reason: Schema.Literal("http"),
+    status: Schema.Number,
+    bodyPreview: Schema.optional(Schema.String),
+  }),
+  Schema.Struct({
+    ...PushFailedBase.fields,
+    origin: Schema.Literal("zeroCache"),
+    reason: Schema.Literal("timeout", "parse", "internal"),
+  }),
+);
+
+const TransformFailedBase = Schema.Struct({
+  kind: Schema.Literal("TransformFailed"),
+  details: Schema.optional(JsonSchema),
+  /**
+   * The queryIDs of the queries that failed to transform.
+   */
+  queryIDs: Schema.Array(Schema.String),
+  message: Schema.String,
+});
+
+export const TransformFailedBody = Schema.Union(
+  Schema.Struct({
+    ...TransformFailedBase.fields,
+    origin: Schema.Literal("server"),
+    reason: Schema.Literal("database", "parse", "internal"),
+  }),
+  Schema.Struct({
+    ...TransformFailedBase.fields,
+    origin: Schema.Literal("zeroCache"),
+    reason: Schema.Literal("http"),
+    status: Schema.Number,
+    bodyPreview: Schema.optional(Schema.String),
+  }),
+  Schema.Struct({
+    ...TransformFailedBase.fields,
+    origin: Schema.Literal("zeroCache"),
+    reason: Schema.Literal("timeout", "parse", "internal"),
+  }),
+);

package/src/types/push.ts

@@ -1,8 +1,9 @@
 import * as Schema from "effect/Schema";
 import { JsonSchema } from "./common.js";
+import { PushFailedBody } from "./error.js";
 
 // The code below was converted to Effect Schema from:
-// https://github.com/rocicorp/mono/blob/30f209f2946b4cf2cd2dee459849351498f11308/packages/zero-protocol/src/push.ts
+// https://github.com/rocicorp/mono/blob/8e0f600fb3a9185facf60cfd4971d260b266690e/packages/zero-protocol/src/push.ts
 
 const PrimaryKey = Schema.Array(Schema.String);
 
@@ -15,6 +16,32 @@ const Row = Schema.Record({ key: Schema.String, value: Value });
 
 const CRUD_MUTATION_NAME = "_zero_crud";
 
+// biome-ignore lint/correctness/noUnusedVariables: borrowed code
+const CLEANUP_RESULTS_MUTATION_NAME = "_zero_cleanupResults";
+
+// biome-ignore lint/correctness/noUnusedVariables: borrowed code
+const CleanupResultsArg = Schema.Union(
+  // Legacy format (no type field) - treat as single
+  Schema.Struct({
+    clientGroupID: Schema.String,
+    clientID: Schema.String,
+    upToMutationID: Schema.Number,
+  }),
+  // Explicit single: delete up to a specific mutation ID for one client
+  Schema.Struct({
+    type: Schema.Literal("single"),
+    clientGroupID: Schema.String,
+    clientID: Schema.String,
+    upToMutationID: Schema.Number,
+  }),
+  // Bulk: delete all mutations for multiple clients
+  Schema.Struct({
+    type: Schema.Literal("bulk"),
+    clientGroupID: Schema.String,
+    clientIDs: Schema.NonEmptyArray(Schema.String),
+  }),
+);
+
 /**
  * Inserts if entity with id does not already exist.
  */
@@ -97,6 +124,11 @@ export const PushBody = Schema.Struct({
   schemaVersion: Schema.optional(Schema.Number),
   timestamp: Schema.Number,
   requestID: Schema.String,
+  /**
+   * @deprecated auth is managed at client-group scope via connect/updateAuth
+   * and should not be included in push messages.
+   */
+  auth: Schema.optional(Schema.String),
 });
 export type PushBody = typeof PushBody.Type;
 
@@ -111,13 +143,18 @@ const MutationId = Schema.Struct({
 export const AppError = Schema.Struct({
   error: Schema.Literal("app"),
   // The user can return any additional data here
+  message: Schema.optional(Schema.String),
   details: Schema.optional(JsonSchema),
 });
 
 export type AppError = typeof AppError.Type;
 
 export const ZeroError = Schema.Struct({
-  error: Schema.Union(Schema.Literal("oooMutation"), Schema.Literal("alreadyProcessed")),
+  error: Schema.Union(
+    /** @deprecated push oooMutation errors are now represented as ['error', { ... }] messages */
+    Schema.Literal("oooMutation"),
+    Schema.Literal("alreadyProcessed"),
+  ),
   details: Schema.optional(JsonSchema),
 });
 
@@ -147,42 +184,64 @@ const PushOk = Schema.Struct({
   mutations: Schema.Array(MutationResponse),
 });
 
+/**
+ * @deprecated push errors are now represented as ['error', { ... }] messages
+ */
 const UnsupportedPushVersion = Schema.Struct({
+  /** @deprecated */
   error: Schema.Literal("unsupportedPushVersion"),
-  // optional for backwards compatibility
-  // This field is included so the client knows which mutations
-  // were not processed by the server.
+  /** @deprecated */
   mutationIDs: Schema.optional(Schema.Array(MutationId)),
 });
 
+/**
+ * @deprecated push errors are now represented as ['error', { ... }] messages
+ */
 const UnsupportedSchemaVersion = Schema.Struct({
+  /** @deprecated */
   error: Schema.Literal("unsupportedSchemaVersion"),
-  // optional for backwards compatibility
-  // This field is included so the client knows which mutations
-  // were not processed by the server.
+  /** @deprecated */
   mutationIDs: Schema.optional(Schema.Array(MutationId)),
 });
 
+/**
+ * @deprecated push http errors are now represented as ['error', { ... }] messages
+ */
 const HttpError = Schema.Struct({
+  /** @deprecated */
   error: Schema.Literal("http"),
+  /** @deprecated */
   status: Schema.Number,
+  /** @deprecated */
   details: Schema.String,
+  /** @deprecated */
   mutationIDs: Schema.optional(Schema.Array(MutationId)),
 });
 
+/**
+ * @deprecated push zero errors are now represented as ['error', { ... }] messages
+ */
 const ZeroPusherError = Schema.Struct({
+  /** @deprecated */
   error: Schema.Literal("zeroPusher"),
+  /** @deprecated */
   details: Schema.String,
+  /** @deprecated */
   mutationIDs: Schema.optional(Schema.Array(MutationId)),
 });
 
+/**
+ * @deprecated push errors are now represented as ['error', { ... }] messages
+ */
 const PushError = Schema.Union(UnsupportedPushVersion, UnsupportedSchemaVersion, HttpError, ZeroPusherError);
 
-export const PushResponse = Schema.Union(PushOk, PushError);
+const PushResponseBody = Schema.Union(PushOk, PushError);
+
+export const PushResponse = Schema.Union(PushResponseBody, PushFailedBody);
 export type PushResponse = typeof PushResponse.Type;
 
 // biome-ignore lint/correctness/noUnusedVariables: borrowed code
-const PushResponseMessage = Schema.Tuple(Schema.Literal("pushResponse"), PushResponse);
+const PushResponseMessage = Schema.Tuple(Schema.Literal("pushResponse"), PushResponseBody);
 
 // biome-ignore lint/correctness/noUnusedVariables: borrowed code
 const AckMutationResponsesMessage = Schema.Tuple(Schema.Literal("ackMutationResponses"), MutationId);

package/src/types/queries.ts

@@ -1,8 +1,9 @@
 import * as Schema from "effect/Schema";
 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/9fe2b3cb770bad269ecaf12296c64a0739c23e4e/packages/zero-protocol/src/custom-queries.ts#L14
+// https://github.com/rocicorp/mono/blob/8e0f600fb3a9185facf60cfd4971d260b266690e/packages/zero-protocol/src/custom-queries.ts
 
 /** TODO: Defined as unknown for now */
 const Ast = Schema.Unknown;
@@ -21,29 +22,24 @@ const TransformedQuery = Schema.Struct({
   ast: Ast,
 });
 
-const AppQueryError = Schema.Struct({
+const AppErroredQuery = Schema.Struct({
   error: Schema.Literal("app"),
   id: Schema.String,
   name: Schema.String,
-  details: JsonSchema,
+  // optional for backwards compatibility
+  message: Schema.optional(Schema.String),
+  details: Schema.optional(JsonSchema),
 });
 
-const ErrorSchema = Schema.Struct({
-  error: Schema.Literal("zero"),
+const ParseErroredQuery = Schema.Struct({
+  error: Schema.Literal("parse"),
   id: Schema.String,
   name: Schema.String,
-  details: JsonSchema,
+  message: Schema.String,
+  details: Schema.optional(JsonSchema),
 });
 
-const HttpQueryError = Schema.Struct({
-  error: Schema.Literal("http"),
-  id: Schema.String,
-  name: Schema.String,
-  status: Schema.Number,
-  details: JsonSchema,
-});
-
-const ErroredQuery = Schema.Union(AppQueryError, HttpQueryError, ErrorSchema);
+const ErroredQuery = Schema.Union(AppErroredQuery, ParseErroredQuery);
 
 const TransformResponseBody = Schema.Array(Schema.Union(TransformedQuery, ErroredQuery));
 
@@ -53,4 +49,8 @@ export type TransformRequestMessage = typeof TransformRequestMessage.Type;
 // biome-ignore lint/correctness/noUnusedVariables: borrowed code
 const TransformErrorMessage = Schema.Tuple(Schema.Literal("transformError"), Schema.Array(ErroredQuery));
 
-export const TransformResponseMessage = Schema.Tuple(Schema.Literal("transformed"), TransformResponseBody);
+const TransformFailedMessage = Schema.Tuple(Schema.Literal("transformFailed"), TransformFailedBody);
+
+const TransformOkMessage = Schema.Tuple(Schema.Literal("transformed"), TransformResponseBody);
+
+export const TransformResponseMessage = Schema.Union(TransformOkMessage, TransformFailedMessage);