effect-zero 0.1.0 → 0.2.0

package/dist/server.d.ts

@@ -1,188 +1,131 @@
-import type { Database, TransactionProviderHooks, TransactionProviderInput } from "@rocicorp/zero/pg";
+import type { ReadonlyJSONValue, Schema as ZeroSchema } from "@rocicorp/zero";
 import * as Cause from "effect/Cause";
-import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
-import * as SynchronizedRef from "effect/SynchronizedRef";
-import { type AnyMutators, type ExtractMutatorsRequirements } from "./mutators.js";
-export interface ZeroServerTransactionContext {
-    readonly _tag: unique symbol;
-}
-export declare const makeServer: <T, I = never>(options: {
-    database: Database<T>;
-    clientTransaction?: Context.Tag<I, T>;
-}) => {
-    Transaction: Context.TagClass<ZeroServerTransactionContext, "effect-zero/ZeroServerTransactionContext", {
-        transaction: T;
-        transactionHooks: TransactionProviderHooks;
-    }> & {
-        execute: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect.AsEffect<Effect.Effect<A, ZeroDatabaseError | UpdateClientMutationIDError | MultipleTransactionsError | OutOfOrderMutationError | MutationAlreadyProcessedError | E, ZeroTransactionInput | ZeroServerMutationContext | Exclude<Exclude<R, ZeroServerTransactionContext>, I>>>;
-        use: <A>(fn: (transaction: T, options: {
-            readonly signal: AbortSignal;
-        }) => PromiseLike<A>) => Effect.Effect<A, unknown, ZeroServerTransactionContext>;
-    };
-    processPush: <T_1 extends AnyMutators>(mutators: T_1, params: {
-        readonly schema: string;
-        readonly appID: string;
-    }, request: {
+import type * as ParseResult from "effect/ParseResult";
+import { ServerSynchronizationContext, ServerTransactionInput } from "./internal/server.js";
+import * as Mutators from "./mutators.js";
+import { type MakeQueryResult } from "./query.js";
+import type * as ServerTransaction from "./server-transaction.js";
+type ServerTransactionContext<TSchema extends ZeroSchema, TTransaction> = Omit<ReturnType<typeof ServerTransaction.make<string, TSchema, TTransaction>>, "use">;
+export declare const processPush: <TSchema extends ZeroSchema, TTransaction, TMutators extends Mutators.AnyMutators>(transaction: ServerTransactionContext<TSchema, TTransaction>, mutators: TMutators, params: {
+    readonly schema: string;
+    readonly appID: string;
+}, request: {
+    readonly timestamp: number;
+    readonly clientGroupID: string;
+    readonly mutations: readonly ({
+        readonly name: "_zero_crud";
+        readonly type: "crud";
+        readonly id: number;
+        readonly args: readonly [{
+            readonly ops: readonly ({
+                readonly value: {
+                    readonly [x: string]: unknown;
+                };
+                readonly primaryKey: readonly string[];
+                readonly op: "insert";
+                readonly tableName: string;
+            } | {
+                readonly value: {
+                    readonly [x: string]: unknown;
+                };
+                readonly primaryKey: readonly string[];
+                readonly op: "upsert";
+                readonly tableName: string;
+            } | {
+                readonly value: {
+                    readonly [x: string]: unknown;
+                };
+                readonly primaryKey: readonly string[];
+                readonly op: "update";
+                readonly tableName: string;
+            } | {
+                readonly value: {
+                    readonly [x: string]: string | number | boolean;
+                };
+                readonly primaryKey: readonly string[];
+                readonly op: "delete";
+                readonly tableName: string;
+            })[];
+        }];
+        readonly clientID: string;
         readonly timestamp: number;
-        readonly clientGroupID: string;
-        readonly mutations: readonly ({
-            readonly name: "_zero_crud";
-            readonly type: "crud";
+    } | {
+        readonly name: string;
+        readonly type: "custom";
+        readonly id: number;
+        readonly args: readonly unknown[];
+        readonly clientID: string;
+        readonly timestamp: number;
+    })[];
+    readonly pushVersion: number;
+    readonly schemaVersion?: number | undefined;
+    readonly requestID: string;
+}) => Effect.Effect<{
+    error: "unsupportedPushVersion";
+    mutations?: undefined;
+} | {
+    mutations: {
+        readonly id: {
             readonly id: number;
             readonly clientID: string;
-            readonly args: readonly [{
-                readonly ops: readonly ({
-                    readonly value: {
-                        readonly [x: string]: unknown;
-                    };
-                    readonly primaryKey: readonly string[];
-                    readonly op: "insert";
-                    readonly tableName: string;
-                } | {
-                    readonly value: {
-                        readonly [x: string]: unknown;
-                    };
-                    readonly primaryKey: readonly string[];
-                    readonly op: "upsert";
-                    readonly tableName: string;
-                } | {
-                    readonly value: {
-                        readonly [x: string]: unknown;
-                    };
-                    readonly primaryKey: readonly string[];
-                    readonly op: "update";
-                    readonly tableName: string;
-                } | {
-                    readonly value: {
-                        readonly [x: string]: string | number | boolean;
-                    };
-                    readonly primaryKey: readonly string[];
-                    readonly op: "delete";
-                    readonly tableName: string;
-                })[];
-            }];
-            readonly timestamp: number;
+        };
+        readonly result: {
+            readonly error: "app";
+            readonly details?: unknown;
         } | {
-            readonly name: string;
-            readonly type: "custom";
-            readonly id: number;
-            readonly clientID: string;
-            readonly args: readonly unknown[];
-            readonly timestamp: number;
-        })[];
-        readonly pushVersion: number;
-        readonly schemaVersion?: number | undefined;
-        readonly requestID: string;
-    }) => Effect.Effect<{
-        error: "unsupportedPushVersion";
-        mutations?: undefined;
-    } | {
-        mutations: {
-            readonly id: {
-                readonly id: number;
-                readonly clientID: string;
-            };
-            readonly result: {
-                readonly error: "app";
-                readonly details?: unknown;
-            } | {
-                readonly error: "oooMutation" | "alreadyProcessed";
-                readonly details?: unknown;
-            } | {
-                readonly data?: unknown;
-            };
-        }[];
-        error?: undefined;
-    }, CustomMutationExpectedError, Exclude<Exclude<ExtractMutatorsRequirements<T_1>, ZeroServerMutationContext>, ZeroTransactionInput>>;
-};
-declare const ZeroTransactionInput_base: Context.TagClass<ZeroTransactionInput, "effect-zero/ZeroTransactionInput", TransactionProviderInput>;
-declare class ZeroTransactionInput extends ZeroTransactionInput_base {
-}
-declare const ZeroServerMutationContext_base: Effect.Service.Class<ZeroServerMutationContext, "effect-zero/ZeroServerMutationContext", {
-    readonly effect: Effect.Effect<{
-        wasTransactionExecuted: SynchronizedRef.SynchronizedRef<boolean>;
-    }, never, never>;
-}>;
-declare class ZeroServerMutationContext extends ZeroServerMutationContext_base {
-    static wasTransactionExecuted: Effect.Effect<boolean, never, ZeroServerMutationContext>;
-    static guard: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | MultipleTransactionsError, ZeroServerMutationContext | R>;
-}
-declare const ZeroDatabaseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Cause.YieldableError & {
-    readonly _tag: "ZeroDatabaseError";
-} & Readonly<A>;
-declare class ZeroDatabaseError extends ZeroDatabaseError_base<{
-    cause: Cause.Cause<unknown>;
-}> {
-}
-declare const UpdateClientMutationIDError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Cause.YieldableError & {
-    readonly _tag: "UpdateClientMutationIDError";
-} & Readonly<A>;
-declare class UpdateClientMutationIDError extends UpdateClientMutationIDError_base<{
-    readonly cause: Cause.Cause<unknown>;
-}> {
-}
+            readonly error: "oooMutation" | "alreadyProcessed";
+            readonly details?: unknown;
+        } | {
+            readonly data?: unknown;
+        };
+    }[];
+    error?: undefined;
+}, CustomMutationExpectedError, Exclude<Exclude<Mutators.ExtractMutatorsRequirements<TMutators>, ServerTransactionInput>, ServerSynchronizationContext>>;
 declare const CustomMutationExpectedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Cause.YieldableError & {
     readonly _tag: "CustomMutationExpectedError";
 } & Readonly<A>;
-declare class CustomMutationExpectedError extends CustomMutationExpectedError_base<object> {
-}
-declare const MultipleTransactionsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Cause.YieldableError & {
-    readonly _tag: "MultipleTransactionsError";
-} & Readonly<A>;
-export declare class MultipleTransactionsError extends MultipleTransactionsError_base {
-    message: string;
-}
-declare const NoTransactionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Cause.YieldableError & {
-    readonly _tag: "NoTransactionError";
-} & Readonly<A>;
-export declare class NoTransactionError extends NoTransactionError_base {
-    message: string;
-}
-declare const OutOfOrderMutationErrorTypeId: unique symbol;
-declare const OutOfOrderMutationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Cause.YieldableError & {
-    readonly _tag: "OutOfOrderMutationError";
-} & Readonly<A>;
-export declare class OutOfOrderMutationError extends OutOfOrderMutationError_base<{
-    readonly clientID: string;
-    readonly receivedMutationID: number;
-    readonly lastMutationID: number | bigint;
-}> {
-    readonly [OutOfOrderMutationErrorTypeId]: symbol;
-    get message(): string;
-    static is(e: unknown): e is OutOfOrderMutationError;
+declare class CustomMutationExpectedError extends CustomMutationExpectedError_base {
 }
-declare const MutationAlreadyProcessedErrorTypeId: unique symbol;
-declare const MutationAlreadyProcessedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Cause.YieldableError & {
-    readonly _tag: "MutationAlreadyProcessedError";
+export declare const handleGetQueries: <E, R1, R2>(queries: MakeQueryResult<E, R1, R2>[], schema: ZeroSchema, payload: readonly ["transform", readonly {
+    readonly name: string;
+    readonly id: string;
+    readonly args: readonly unknown[];
+}[]]) => Effect.Effect<["transformed", ({
+    id: string;
+    name: string;
+    ast: import("@rocicorp/zero").AST;
+} | {
+    error: "app";
+    id: string;
+    name: string;
+    details: ReadonlyJSONValue;
+} | {
+    error: "http";
+    id: string;
+    name: string;
+    status: number;
+    details: ReadonlyJSONValue;
+} | {
+    error: "zero";
+    id: string;
+    name: string;
+    details: ReadonlyJSONValue;
+})[]], ParseResult.ParseError | E | QueryNotFound | GetQueriesError, R1 | R2>;
+declare const QueryNotFound_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Cause.YieldableError & {
+    readonly _tag: "QueryNotFound";
 } & Readonly<A>;
-export declare class MutationAlreadyProcessedError extends MutationAlreadyProcessedError_base<{
-    readonly clientID: string;
-    readonly received: number;
-    readonly actual: number | bigint;
+declare class QueryNotFound extends QueryNotFound_base<{
+    name: string;
 }> {
-    readonly [MutationAlreadyProcessedErrorTypeId]: symbol;
     get message(): string;
-    static is(e: unknown): e is MutationAlreadyProcessedError;
-}
-declare const ZeroTransactionUserErrorTypeId: unique symbol;
-declare const ZeroTransactionUserError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Cause.YieldableError & {
-    readonly _tag: "ZeroTransactionUserError";
-} & Readonly<A>;
-export declare class ZeroTransactionUserError extends ZeroTransactionUserError_base {
-    readonly [ZeroTransactionUserErrorTypeId]: symbol;
-    static is(e: unknown): e is ZeroTransactionUserError;
 }
-declare const ZeroMutationUserErrorTypeId: unique symbol;
-declare const ZeroMutationUserError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Cause.YieldableError & {
-    readonly _tag: "ZeroMutationUserError";
+declare const GetQueriesError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Cause.YieldableError & {
+    readonly _tag: "GetQueriesError";
 } & Readonly<A>;
-export declare class ZeroMutationUserError extends ZeroMutationUserError_base<{
+declare class GetQueriesError extends GetQueriesError_base<{
     cause: Cause.Cause<unknown>;
 }> {
-    readonly [ZeroMutationUserErrorTypeId]: symbol;
-    static is(e: unknown): e is ZeroMutationUserError;
-    get message(): string;
 }
 export {};
 //# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAG9E,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAGtC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAKxC,OAAO,KAAK,KAAK,WAAW,MAAM,oBAAoB,CAAC;AAOvD,OAAO,EAGL,4BAA4B,EAC5B,sBAAsB,EACvB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,KAAK,eAAe,EAAmC,MAAM,YAAY,CAAC;AACnF,OAAO,KAAK,KAAK,iBAAiB,MAAM,yBAAyB,CAAC;AAIlE,KAAK,wBAAwB,CAAC,OAAO,SAAS,UAAU,EAAE,YAAY,IAAI,IAAI,CAC5E,UAAU,CAAC,OAAO,iBAAiB,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,EACxE,KAAK,CACN,CAAC;AAEF,eAAO,MAAM,WAAW,GACtB,OAAO,SAAS,UAAU,EAC1B,YAAY,EACZ,SAAS,SAAS,QAAQ,CAAC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wJAuCgB,CAAC;;;;AA+EzD,cAAM,2BAA4B,SAAQ,gCAA+C;CAAG;AAwB5F,eAAO,MAAM,gBAAgB,GAAwB,CAAC,EAAE,EAAE,EAAE,EAAE;;;;;;;;;;;;;;;;;;;;;;;;6EA+B5D,CAAC;;;;AAEH,cAAM,aAAc,SAAQ,mBAAkC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;IAC7E,IAAa,OAAO,WAEnB;CACF;;;;AAYD,cAAM,eAAgB,SAAQ,qBAAoC;IAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC;CAAG"}

package/dist/server.js

@@ -1,8 +1,8 @@
+import { handleGetQueriesRequest } from "@rocicorp/zero/server";
+import * as Arr from "effect/Array";
 import * as Cause from "effect/Cause";
 import * as Chunk from "effect/Chunk";
-import * as Context 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 * as Fn from "effect/Function";
@@ -14,222 +14,101 @@ import * as Runtime from "effect/Runtime";
 import * as Schema from "effect/Schema";
 import * as Stream from "effect/Stream";
 import * as Str from "effect/String";
-import * as SynchronizedRef from "effect/SynchronizedRef";
-import { MutatorArgsSchemaSym } from "./mutators.js";
-import { ZeroMutationResponse, } from "./types.js";
-import { prefixId } from "./utils.js";
-// NOTE(zero): Using the "Lifting the Generic" technique.
-// NOTE(zero): Could choose to not accept `Database<T>` as a param and instead create some `ZeroDatabase` service inside the
-// `make` function, which various other functions require. However, this means that the user will have to manually
-// specify the `T` type parameter which seemed a bit clunky.
-export const makeServer = (options) => {
-    const ZeroServerTransactionContext = Context.Tag(prefixId("ZeroServerTransactionContext"))();
-    // TODO: Maybe prefix this / suffix this with a tag passed in to `make`?
-    const execute = Effect.fn(function* (effect) {
-        const runtime = 
-        // TODO: Is there a cleaner way to write this?
-        yield* Effect.runtime();
-        const result = yield* Deferred.make();
-        const transactionInput = yield* ZeroTransactionInput;
-        yield* Effect.tryPromise({
-            try: (signal) => options.database.transaction(async (transaction, transactionHooks) => {
-                const exit = await Effect.zipRight(checkAndIncrementLastMutationID, effect).pipe(Effect.provideService(ZeroServerTransactionContext, { transaction, transactionHooks }), options.clientTransaction
-                    ? Effect.provideService(options.clientTransaction, transaction)
-                    : // TODO: Is there a cleaner way to write this?
-                        (effect) => effect, (effect) => Runtime.runPromiseExit(runtime, effect, { signal }));
-                Deferred.unsafeDone(result, exit);
-                return Exit.getOrElse(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 ZeroTransactionUserError silenced below in the pipe.
-                    throw new ZeroTransactionUserError();
-                });
-            }, transactionInput),
-            catch: (error) => {
-                if (ZeroTransactionUserError.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("ZeroTransactionUserError", () => Effect.void));
-        return yield* result;
-    }, ZeroServerMutationContext.guard);
-    const use = (fn) => Effect.flatMap(ZeroServerTransactionContext, (ctx) => Effect.tryPromise({
-        try: (signal) => fn(ctx.transaction, { signal }),
-        catch: Fn.identity,
-    }));
-    const checkAndIncrementLastMutationID = Effect.gen(function* () {
-        const { transactionHooks } = yield* ZeroServerTransactionContext;
-        const { clientID, mutationID: receivedMutationID } = yield* ZeroTransactionInput;
-        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 processPush = Effect.fn(function* (mutators, params, request) {
-        if (request.pushVersion !== 1) {
-            return { error: "unsupportedPushVersion" };
+import { MutationAlreadyProcessedError, OutOfOrderMutationError, ServerSynchronizationContext, ServerTransactionInput, } from "./internal/server.js";
+import { prefixId } from "./internal/utils.js";
+import * as Mutators from "./mutators.js";
+import { QueryNameSymbol, RunQuerySymbol } from "./query.js";
+import * as Types from "./types/push.js";
+export const processPush = Effect.fn(function* (transaction, mutators, params, request) {
+    if (request.pushVersion !== 1) {
+        return { error: "unsupportedPushVersion" };
+    }
+    const responses = yield* Stream.fromIterable(request.mutations).pipe(Stream.mapEffect(Effect.fn(function* (mutation) {
+        if (mutation.type !== "custom") {
+            return yield* new CustomMutationExpectedError();
         }
-        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, mutation).pipe(Effect.map((result) => ZeroMutationResponse.make({ id: { id: mutation.id, clientID: mutation.clientID }, result })), Effect.provideService(ZeroTransactionInput, {
-                clientID: mutation.clientID,
-                mutationID: mutation.id,
-                clientGroupID: request.clientGroupID,
-                upstreamSchema: params.schema,
-            }));
-        })), 
-        // 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, Effect.annotateLogs({ module: prefixId("ZeroServer"), method: "processPush" }));
-        return { mutations: Chunk.toArray(responses) };
-    });
-    const processMutation = Effect.fn(function* (mutators, 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, ".");
-        const mutator = yield* Fn.pipe(mutators, Rec.get(namespace), Option.flatMap((mutator) => Match.value([mutator, name]).pipe(Match.when([Predicate.isRecord, Predicate.isString], ([mutator, name]) => Rec.get(name)(mutator)), Match.when([Predicate.isFunction, Predicate.isUndefined], ([mutator]) => Option.some(mutator)), Match.orElse(() => Option.none()))), Effect.catchTag("NoSuchElementException", () => new MutatorNotFoundError({ mutationName: mutation.name })));
-        const args = yield* Schema.decode(mutator[MutatorArgsSchemaSym])(mutation.args[0]).pipe(Effect.catchTag("ParseError", (e) => new ZeroServerArgsParseError({ cause: Cause.fail(e) })));
-        return yield* mutator(args).pipe(
-        // Case #2 "One transaction then fail"
-        // If the transaction was executed successfully, swallow the error and just log it, otherwise re-throw it
-        Effect.catchAllCause(Effect.fn(function* (e) {
-            const wasTransactionExecuted = yield* ZeroServerMutationContext.wasTransactionExecuted;
-            if (wasTransactionExecuted) {
-                return yield* Effect.logError("Error occurred after transaction execution completed", e);
-            }
-            return yield* Effect.failCause(e);
-        })), 
-        // Case #4 "Zero transactions then succeed"
-        // Check that the transaction was executed during the mutation
-        Effect.tap(Effect.gen(function* () {
-            const wasTransactionExecuted = yield* ZeroServerMutationContext.wasTransactionExecuted;
-            if (!wasTransactionExecuted) {
-                return yield* new NoTransactionError();
-            }
-        })), Effect.as({}), Effect.catchIf(OutOfOrderMutationError.is, (e) => Effect.logError(e.message).pipe(Effect.as({ error: "oooMutation", details: e.message }))), Effect.catchIf(MutationAlreadyProcessedError.is, (e) => Effect.logWarning(e.message).pipe(Effect.as({ error: "alreadyProcessed", details: e.message }))), 
-        // Case #5 "Zero transactions then fail" / #6 "Fail before transaction"
-        // Catches all errors that are produced before the transaction is executed
-        Effect.catchAllCause((cause) => new ZeroMutationUserError({ cause })));
-    }, Effect.catchAll((e) => processMutationError(e)), Effect.provide(ZeroServerMutationContext.Default));
-    const processMutationError = Effect.fn(function* (e) {
-        const { clientID, mutationID } = yield* ZeroTransactionInput;
-        yield* Effect.logError(`Unexpected error processing mutation ${mutationID} for client ${clientID}`, Cause.fail(e));
-        const errorMessage = Match.value(e).pipe(Match.when(ZeroMutationUserError.is, (e) => e.message), Match.orElse(() => "Internal error"));
-        const appError = {
-            error: "app",
-            details: errorMessage,
-        };
-        yield* execute(Effect.flatMap(ZeroServerTransactionContext, ({ transactionHooks }) => {
-            return Effect.tryPromise({
-                try: () => transactionHooks.writeMutationResult({ id: { id: mutationID, clientID }, result: appError }),
-                catch: (error) => new WriteMutationResultError({ cause: Cause.fail(error) }),
-            });
-        })).pipe(Effect.catchAllCause(Effect.logError));
-        yield* Effect.logWarning(`Mutation ${mutationID} for client ${clientID} was retried after an error: ${e}`);
-        return appError;
-    });
-    return {
-        Transaction: Object.assign(ZeroServerTransactionContext, { execute, use }),
-        processPush,
+        return yield* processMutation(mutators, mutation).pipe(Effect.catchAll((e) => processMutationError(transaction, e)), Effect.map((result) => Types.MutationResponse.make({ id: { id: mutation.id, clientID: mutation.clientID }, result })), Effect.provideService(ServerTransactionInput, {
+            clientID: mutation.clientID,
+            mutationID: mutation.id,
+            clientGroupID: request.clientGroupID,
+            upstreamSchema: params.schema,
+        }));
+    })), 
+    // 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: Chunk.toArray(responses) };
+}, Effect.provide(ServerSynchronizationContext.Default));
+const processMutation = Effect.fn(function* (mutators, 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, ".");
+    const mutator = yield* Fn.pipe(mutators, Rec.get(namespace), Option.flatMap((mutator) => Match.value([mutator, name]).pipe(Match.when([Predicate.isRecord, Predicate.isString], ([mutator, name]) => Rec.get(name)(mutator)), Match.when([Predicate.isFunction, Predicate.isUndefined], ([mutator]) => Option.some(mutator)), Match.orElse(() => Option.none()))), Effect.catchTag("NoSuchElementException", () => new MutatorNotFoundError({ name: mutation.name })));
+    const args = yield* Schema.decode(mutator[Mutators.MutatorSchemaSymbol])(mutation.args[0]).pipe(Effect.catchTag("ParseError", (e) => new ServerArgsParseError({ cause: Cause.fail(e) })));
+    return yield* mutator(args).pipe(ServerSynchronizationContext.finalize, Effect.as({}), Effect.catchIf(OutOfOrderMutationError.is, (e) => Effect.logError(e.message).pipe(Effect.as({ error: "oooMutation", details: e.message }))), Effect.catchIf(MutationAlreadyProcessedError.is, (e) => Effect.logWarning(e.message).pipe(Effect.as({ error: "alreadyProcessed", details: e.message }))), 
+    // Case #5 "Zero transactions then fail" / #6 "Fail before transaction"
+    // Catches all errors that are produced before the transaction is executed
+    Effect.catchAllCause((cause) => new MutationUserError({ cause })));
+});
+const processMutationError = Effect.fn(function* (transaction, e) {
+    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,
     };
-};
-class ZeroTransactionInput extends Context.Tag(prefixId("ZeroTransactionInput"))() {
-}
-class ZeroServerMutationContext extends Effect.Service()(prefixId("ZeroServerMutationContext"), {
-    effect: Effect.gen(function* () {
-        return { wasTransactionExecuted: yield* SynchronizedRef.make(false) };
-    }),
-}) {
-    static wasTransactionExecuted = Effect.flatMap(ZeroServerMutationContext, (ctx) => ctx.wasTransactionExecuted);
-    // Ensures that only one transaction is executed at a time and checks that another transaction wasn't already executed.
-    static guard = (effect) => Effect.flatMap(this, ({ wasTransactionExecuted }) => SynchronizedRef.modifyEffect(wasTransactionExecuted, Effect.fn(function* (wasTransactionExecuted) {
-        if (wasTransactionExecuted) {
-            return yield* new MultipleTransactionsError();
-        }
-        const result = yield* effect;
-        return [result, true];
-    })));
-}
-class ZeroDatabaseError extends Data.TaggedError("ZeroDatabaseError") {
-}
-class UpdateClientMutationIDError extends Data.TaggedError("UpdateClientMutationIDError") {
-}
-class MutatorNotFoundError extends Data.TaggedError("MutatorNotFoundError") {
-    message = `Mutator not found for mutation ${this.mutationName}`;
-}
+    yield* transaction
+        .execute(Effect.flatMap(transaction, ({ transactionHooks }) => {
+        return Effect.tryPromise({
+            try: () => transactionHooks.writeMutationResult({ id: { id: mutationID, clientID }, result: appError }),
+            catch: (error) => new WriteMutationResultError({ cause: Cause.fail(error) }),
+        });
+    }))
+        .pipe(Effect.catchAllCause(Effect.logError));
+    yield* Effect.logWarning(`Mutation ${mutationID} for client ${clientID} was retried after an error: ${e}`);
+    return appError;
+});
 class WriteMutationResultError extends Data.TaggedError("WriteMutationResultError") {
 }
 class CustomMutationExpectedError extends Data.TaggedError("CustomMutationExpectedError") {
 }
-export class MultipleTransactionsError extends Data.TaggedError("MultipleTransactionsError") {
-    message = "Multiple transactions detected in a mutation, only one transaction is allowed.";
+class MutatorNotFoundError extends Data.TaggedError("MutatorNotFoundError") {
 }
-export class NoTransactionError extends Data.TaggedError("NoTransactionError") {
-    message = "No transaction detected in a mutation, a transaction is required.";
+class ServerArgsParseError extends Data.TaggedError("ServerArgsParseError") {
 }
-const OutOfOrderMutationErrorTypeId = Symbol.for(prefixId("OutOfOrderMutationError"));
-export class OutOfOrderMutationError extends Data.TaggedError("OutOfOrderMutationError") {
-    [OutOfOrderMutationErrorTypeId] = OutOfOrderMutationErrorTypeId;
-    get message() {
-        return `Client ${this.clientID} sent mutation ID ${this.receivedMutationID} but expected ${this.lastMutationID}`;
-    }
+const MutationUserErrorTypeId = Symbol.for(prefixId("MutationUserError"));
+class MutationUserError extends Data.TaggedError("MutationUserError") {
+    [MutationUserErrorTypeId] = MutationUserErrorTypeId;
     static is(e) {
-        return Predicate.hasProperty(e, OutOfOrderMutationErrorTypeId);
+        return Predicate.hasProperty(e, MutationUserErrorTypeId);
     }
-}
-const MutationAlreadyProcessedErrorTypeId = Symbol.for(prefixId("MutationAlreadyProcessedError"));
-export class MutationAlreadyProcessedError extends Data.TaggedError("MutationAlreadyProcessedError") {
-    [MutationAlreadyProcessedErrorTypeId] = MutationAlreadyProcessedErrorTypeId;
     get message() {
-        return `Ignoring mutation from ${this.clientID} with ID ${this.received} as it was already processed. Expected: ${this.actual}`;
-    }
-    static is(e) {
-        return Predicate.hasProperty(e, MutationAlreadyProcessedErrorTypeId);
+        const err = Cause.squash(this.cause);
+        return err instanceof Error ? err.message : "exception was not of type `Error`";
     }
 }
-const ZeroTransactionUserErrorTypeId = Symbol.for(prefixId("ZeroTransactionUserError"));
-export class ZeroTransactionUserError extends Data.TaggedError("ZeroTransactionUserError") {
-    [ZeroTransactionUserErrorTypeId] = ZeroTransactionUserErrorTypeId;
-    static is(e) {
-        return Predicate.hasProperty(e, ZeroTransactionUserErrorTypeId);
+export const handleGetQueries = Effect.fn(function* (queries, schema, payload) {
+    const runtime = yield* Effect.runtime();
+    return yield* Effect.tryPromise({
+        try: () => handleGetQueriesRequest((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({ cause });
+        }))), schema, payload),
+        catch: (e) => Option.liftPredicate(e, (QueryUserError.is)).pipe(Option.flatMap((e) => Cause.failureOption(e.cause)), Option.getOrElse(() => new GetQueriesError({ cause: Cause.fail(e) }))),
+    });
+});
+class QueryNotFound extends Data.TaggedError("QueryNotFound") {
+    get message() {
+        return `Query not found: ${this.name}`;
     }
 }
-const ZeroMutationUserErrorTypeId = Symbol.for(prefixId("ZeroMutationUserError"));
-export class ZeroMutationUserError extends Data.TaggedError("ZeroMutationUserError") {
-    [ZeroMutationUserErrorTypeId] = ZeroMutationUserErrorTypeId;
+const QueryUserErrorTypeId = Symbol.for(prefixId("QueryUserError"));
+class QueryUserError extends Data.TaggedError("QueryUserError") {
+    [QueryUserErrorTypeId] = QueryUserErrorTypeId;
     static is(e) {
-        return Predicate.hasProperty(e, ZeroMutationUserErrorTypeId);
-    }
-    get message() {
-        const err = Cause.squash(this.cause);
-        return err instanceof Error ? err.message : "exception was not of type `Error`";
+        return Predicate.hasProperty(e, QueryUserErrorTypeId);
     }
 }
-class ZeroServerArgsParseError extends Data.TaggedError("ZeroServerArgsParseError") {
+class GetQueriesError extends Data.TaggedError("GetQueriesError") {
 }
 //# sourceMappingURL=server.js.map