@rocicorp/zero 0.25.0 → 0.26.0-canary.0

package/out/zero-server/src/process-mutations.js

@@ -1,300 +1,356 @@
 import { assert } from "../../shared/src/asserts.js";
-import * as v from "../../shared/src/valita.js";
+import { getErrorMessage, getErrorDetails } from "../../shared/src/error.js";
+import { promiseVoid } from "../../shared/src/resolved-promises.js";
+import { parse } from "../../shared/src/valita.js";
 import { MutationAlreadyProcessedError } from "../../zero-cache/src/services/mutagen/error.js";
-import { ApplicationError, isApplicationError, wrapWithApplicationError, } from "../../zero-protocol/src/application-error.js";
-import { ErrorKind } from "../../zero-protocol/src/error-kind.js";
-import { ErrorOrigin } from "../../zero-protocol/src/error-origin.js";
-import { ErrorReason } from "../../zero-protocol/src/error-reason.js";
-import { pushBodySchema, pushParamsSchema, } from "../../zero-protocol/src/push.js";
+import { isApplicationError, wrapWithApplicationError } from "../../zero-protocol/src/application-error.js";
+import { PushFailed } from "../../zero-protocol/src/error-kind-enum.js";
+import { Server } from "../../zero-protocol/src/error-origin-enum.js";
+import { Parse, UnsupportedPushVersion, OutOfOrderMutation as OutOfOrderMutation$1, Database, Internal } from "../../zero-protocol/src/error-reason-enum.js";
+import { pushBodySchema, pushParamsSchema } from "../../zero-protocol/src/push.js";
+import { isMutator } from "../../zql/src/mutate/mutator.js";
 import { createLogContext } from "./logging.js";
-import { getErrorDetails, getErrorMessage } from "../../shared/src/error.js";
 const applicationErrorWrapper = async (fn) => {
-    try {
-        return await fn();
-    }
-    catch (error) {
-        if (error instanceof DatabaseTransactionError ||
-            error instanceof OutOfOrderMutation ||
-            error instanceof MutationAlreadyProcessedError ||
-            isApplicationError(error)) {
-            throw error;
-        }
-        throw wrapWithApplicationError(error);
+  try {
+    return await fn();
+  } catch (error) {
+    if (error instanceof DatabaseTransactionError || error instanceof OutOfOrderMutation || error instanceof MutationAlreadyProcessedError || isApplicationError(error)) {
+      throw error;
     }
+    throw wrapWithApplicationError(error);
+  }
 };
-export async function handleMutationRequest(cb, queryOrQueryString, body, logLevel) {
-    if (logLevel === undefined) {
-        if (queryOrQueryString instanceof Request && typeof body === 'string') {
-            logLevel = body;
-        }
-        else {
-            logLevel = 'info';
-        }
-    }
-    const lc = createLogContext(logLevel).withContext('PushProcessor');
-    let mutationIDs = [];
-    let req;
+const handleMutationRequest = handleMutateRequest;
+async function handleMutateRequest(dbProvider, cb, queryStringOrRequest, bodyOrLogLevel, logLevel) {
+  const isRequestOverload = queryStringOrRequest instanceof Request;
+  let request;
+  let queryString;
+  let jsonBody;
+  let lc;
+  if (isRequestOverload) {
+    request = queryStringOrRequest;
+    const level = bodyOrLogLevel ?? "info";
+    lc = createLogContext(level).withContext("PushProcessor");
+    const url = new URL(request.url);
+    queryString = url.searchParams;
     try {
-        let rawBody;
-        if (queryOrQueryString instanceof Request) {
-            rawBody = await queryOrQueryString.json();
+      jsonBody = await request.json();
+    } catch (error) {
+      lc.error?.("Failed to parse push body", error);
+      const message = `Failed to parse push body: ${getErrorMessage(error)}`;
+      const details = getErrorDetails(error);
+      return {
+        kind: PushFailed,
+        origin: Server,
+        reason: Parse,
+        message,
+        mutationIDs: [],
+        ...details ? { details } : {}
+      };
+    }
+  } else {
+    queryString = queryStringOrRequest;
+    jsonBody = bodyOrLogLevel;
+    const level = logLevel ?? "info";
+    lc = createLogContext(level).withContext("PushProcessor");
+  }
+  let mutationIDs = [];
+  let pushBody;
+  try {
+    pushBody = parse(jsonBody, pushBodySchema);
+    mutationIDs = pushBody.mutations.map((m) => ({
+      id: m.id,
+      clientID: m.clientID
+    }));
+  } catch (error) {
+    lc.error?.("Failed to parse push body", error);
+    const message = `Failed to parse push body: ${getErrorMessage(error)}`;
+    const details = getErrorDetails(error);
+    return {
+      kind: PushFailed,
+      origin: Server,
+      reason: Parse,
+      message,
+      mutationIDs,
+      ...details ? { details } : {}
+    };
+  }
+  let queryParams;
+  try {
+    const queryStringObj = queryString instanceof URLSearchParams ? Object.fromEntries(queryString) : queryString;
+    queryParams = parse(queryStringObj, pushParamsSchema, "passthrough");
+  } catch (error) {
+    lc.error?.("Failed to parse push query parameters", error);
+    const message = `Failed to parse push query parameters: ${getErrorMessage(error)}`;
+    const details = getErrorDetails(error);
+    return {
+      kind: PushFailed,
+      origin: Server,
+      reason: Parse,
+      message,
+      mutationIDs,
+      ...details ? { details } : {}
+    };
+  }
+  if (pushBody.pushVersion !== 1) {
+    const response = {
+      kind: PushFailed,
+      origin: Server,
+      reason: UnsupportedPushVersion,
+      mutationIDs,
+      message: `Unsupported push version: ${pushBody.pushVersion}`
+    };
+    return response;
+  }
+  const responses = [];
+  let processedCount = 0;
+  try {
+    const transactor = new Transactor(dbProvider, pushBody, queryParams, lc);
+    for (const m of pushBody.mutations) {
+      assert(m.type === "custom", "Expected custom mutation");
+      lc.debug?.(
+        `Processing mutation '${m.name}' (id=${m.id}, clientID=${m.clientID})`,
+        m.args
+      );
+      let mutationPhase = "preTransaction";
+      const transactProxy = async (innerCb) => {
+        mutationPhase = "transactionPending";
+        const result = await transactor.transact(
+          m,
+          (tx, name, args) => applicationErrorWrapper(() => innerCb(tx, name, args))
+        );
+        mutationPhase = "postCommit";
+        return result;
+      };
+      try {
+        const res = await applicationErrorWrapper(() => cb(transactProxy, m));
+        responses.push(res);
+        lc.debug?.(`Mutation '${m.name}' (id=${m.id}) completed successfully`);
+        processedCount++;
+      } catch (error) {
+        if (!isApplicationError(error)) {
+          throw error;
         }
-        else {
-            rawBody = body;
+        if (mutationPhase === "preTransaction") {
+          await transactor.persistPreTransactionFailure(m, error);
+        } else if (mutationPhase === "postCommit") {
+          lc.error?.(
+            `Post-commit mutation handler failed for mutation ${m.id} for client ${m.clientID}`,
+            error
+          );
         }
-        req = v.parse(rawBody, pushBodySchema);
-        mutationIDs = req.mutations.map(m => ({
-            id: m.id,
-            clientID: m.clientID,
-        }));
-    }
-    catch (error) {
-        lc.error?.('Failed to parse push body', error);
-        const message = `Failed to parse push body: ${getErrorMessage(error)}`;
-        const details = getErrorDetails(error);
-        return {
-            kind: ErrorKind.PushFailed,
-            origin: ErrorOrigin.Server,
-            reason: ErrorReason.Parse,
-            message,
-            mutationIDs,
-            ...(details ? { details } : {}),
-        };
+        lc.warn?.(
+          `Application error processing mutation ${m.id} for client ${m.clientID}`,
+          error
+        );
+        responses.push(makeAppErrorResponse(m, error));
+        processedCount++;
+      }
     }
-    let queryParams;
-    try {
-        let queryString;
-        if (queryOrQueryString instanceof Request) {
-            const url = new URL(queryOrQueryString.url);
-            queryString = url.searchParams;
+    return {
+      mutations: responses
+    };
+  } catch (error) {
+    lc.error?.("Failed to process push request", error);
+    const unprocessedMutationIDs = mutationIDs.slice(processedCount);
+    const message = getErrorMessage(error);
+    const details = getErrorDetails(error);
+    return {
+      kind: PushFailed,
+      origin: Server,
+      reason: error instanceof OutOfOrderMutation ? OutOfOrderMutation$1 : error instanceof DatabaseTransactionError ? Database : Internal,
+      message,
+      mutationIDs: unprocessedMutationIDs,
+      ...details ? { details } : {}
+    };
+  }
+}
+class Transactor {
+  #dbProvider;
+  #req;
+  #params;
+  #lc;
+  constructor(dbProvider, req, params, lc) {
+    this.#dbProvider = dbProvider;
+    this.#req = req;
+    this.#params = params;
+    this.#lc = lc;
+  }
+  transact = async (mutation, cb) => {
+    let appError = void 0;
+    for (; ; ) {
+      try {
+        const ret = await this.#transactImpl(mutation, cb, appError);
+        if (appError !== void 0) {
+          this.#lc.warn?.(
+            `Mutation ${mutation.id} for client ${mutation.clientID} was retried after an error`,
+            appError
+          );
+          return makeAppErrorResponse(mutation, appError);
         }
-        else {
-            queryString = queryOrQueryString;
+        return ret;
+      } catch (error) {
+        if (error instanceof OutOfOrderMutation) {
+          this.#lc.error?.(error);
+          throw error;
         }
-        if (queryString instanceof URLSearchParams) {
-            queryString = Object.fromEntries(queryString);
+        if (error instanceof MutationAlreadyProcessedError) {
+          this.#lc.warn?.(error);
+          return {
+            id: {
+              clientID: mutation.clientID,
+              id: mutation.id
+            },
+            result: {
+              error: "alreadyProcessed",
+              details: error.message
+            }
+          };
         }
-        queryParams = v.parse(queryString, pushParamsSchema, 'passthrough');
-    }
-    catch (error) {
-        lc.error?.('Failed to parse push query parameters', error);
-        const message = `Failed to parse push query parameters: ${getErrorMessage(error)}`;
-        const details = getErrorDetails(error);
-        return {
-            kind: ErrorKind.PushFailed,
-            origin: ErrorOrigin.Server,
-            reason: ErrorReason.Parse,
-            message,
-            mutationIDs,
-            ...(details ? { details } : {}),
-        };
-    }
-    if (req.pushVersion !== 1) {
-        const response = {
-            kind: ErrorKind.PushFailed,
-            origin: ErrorOrigin.Server,
-            reason: ErrorReason.UnsupportedPushVersion,
-            mutationIDs,
-            message: `Unsupported push version: ${req.pushVersion}`,
-        };
-        return response;
+        if (isApplicationError(error)) {
+          appError = error;
+          this.#lc.warn?.(
+            `Application error processing mutation ${mutation.id} for client ${mutation.clientID}`,
+            appError
+          );
+          continue;
+        }
+        this.#lc.error?.(
+          `Unexpected error processing mutation ${mutation.id} for client ${mutation.clientID}`,
+          error
+        );
+        throw error;
+      }
     }
-    const responses = [];
-    let processedCount = 0;
+  };
+  async persistPreTransactionFailure(mutation, appError) {
+    const ret = await this.#transactImpl(
+      mutation,
+      // noop callback since there's no transaction to execute
+      () => promiseVoid,
+      appError
+    );
+    return ret;
+  }
+  async #transactImpl(mutation, cb, appError) {
+    let transactionPhase = "open";
     try {
-        const transactor = new Transactor(req, queryParams, lc);
-        for (const m of req.mutations) {
-            assert(m.type === 'custom', 'Expected custom mutation');
-            const transactProxy = (dbProvider, innerCb) => transactor.transact(dbProvider, m, (tx, name, args) => applicationErrorWrapper(() => innerCb(tx, name, args)));
+      const ret = await this.#dbProvider.transaction(
+        async (dbTx, transactionHooks) => {
+          transactionPhase = "execute";
+          await this.#checkAndIncrementLastMutationID(
+            transactionHooks,
+            mutation.clientID,
+            mutation.id
+          );
+          if (appError === void 0) {
+            this.#lc.debug?.(
+              `Executing mutator '${mutation.name}' (id=${mutation.id})`
+            );
             try {
-                const res = await applicationErrorWrapper(() => cb(transactProxy, m));
-                responses.push(res);
-                processedCount++;
+              await cb(dbTx, mutation.name, mutation.args[0]);
+            } catch (appError2) {
+              throw wrapWithApplicationError(appError2);
             }
-            catch (error) {
-                if (!isApplicationError(error)) {
-                    throw error;
-                }
-                lc.warn?.(`Application error processing mutation ${m.id} for client ${m.clientID}`, error);
-                responses.push(makeAppErrorResponse(m, error));
-                processedCount++;
-            }
-        }
-        return {
-            mutations: responses,
-        };
-    }
-    catch (error) {
-        lc.error?.('Failed to process push request', error);
-        // only include mutationIDs for mutations that were not processed
-        const unprocessedMutationIDs = mutationIDs.slice(processedCount);
-        const message = getErrorMessage(error);
-        const details = getErrorDetails(error);
-        return {
-            kind: ErrorKind.PushFailed,
-            origin: ErrorOrigin.Server,
-            reason: error instanceof OutOfOrderMutation
-                ? ErrorReason.OutOfOrderMutation
-                : error instanceof DatabaseTransactionError
-                    ? ErrorReason.Database
-                    : ErrorReason.Internal,
-            message,
-            mutationIDs: unprocessedMutationIDs,
-            ...(details ? { details } : {}),
-        };
-    }
-}
-class Transactor {
-    #req;
-    #params;
-    #lc;
-    constructor(req, params, lc) {
-        this.#req = req;
-        this.#params = params;
-        this.#lc = lc;
+          } else {
+            const mutationResult = makeAppErrorResponse(mutation, appError);
+            await transactionHooks.writeMutationResult(mutationResult);
+          }
+          return {
+            id: {
+              clientID: mutation.clientID,
+              id: mutation.id
+            },
+            result: {}
+          };
+        },
+        this.#getTransactionInput(mutation)
+      );
+      return ret;
+    } catch (error) {
+      if (isApplicationError(error) || error instanceof OutOfOrderMutation || error instanceof MutationAlreadyProcessedError) {
+        throw error;
+      }
+      throw new DatabaseTransactionError(transactionPhase, { cause: error });
     }
-    transact = async (dbProvider, mutation, cb) => {
-        let appError = undefined;
-        for (;;) {
-            try {
-                const ret = await this.#transactImpl(dbProvider, mutation, cb, appError);
-                if (appError !== undefined) {
-                    this.#lc.warn?.(`Mutation ${mutation.id} for client ${mutation.clientID} was retried after an error`, appError);
-                    return makeAppErrorResponse(mutation, appError);
-                }
-                return ret;
-            }
-            catch (error) {
-                if (error instanceof OutOfOrderMutation) {
-                    this.#lc.error?.(error);
-                    throw error;
-                }
-                if (error instanceof MutationAlreadyProcessedError) {
-                    this.#lc.warn?.(error);
-                    return {
-                        id: {
-                            clientID: mutation.clientID,
-                            id: mutation.id,
-                        },
-                        result: {
-                            error: 'alreadyProcessed',
-                            details: error.message,
-                        },
-                    };
-                }
-                if (isApplicationError(error)) {
-                    appError = error;
-                    this.#lc.warn?.(`Application error processing mutation ${mutation.id} for client ${mutation.clientID}`, appError);
-                    continue;
-                }
-                if (error instanceof DatabaseTransactionError) {
-                    this.#lc.error?.(`Database error processing mutation ${mutation.id} for client ${mutation.clientID}`, error);
-                }
-                else {
-                    this.#lc.error?.(`Unexpected error processing mutation ${mutation.id} for client ${mutation.clientID}`, error);
-                }
-                throw error;
-            }
-        }
+  }
+  #getTransactionInput(mutation) {
+    return {
+      upstreamSchema: this.#params.schema,
+      clientGroupID: this.#req.clientGroupID,
+      clientID: mutation.clientID,
+      mutationID: mutation.id
     };
-    #transactImpl(dbProvider, mutation, cb, appError) {
-        let transactionPhase = 'open';
-        return dbProvider
-            .transaction(async (dbTx, transactionHooks) => {
-            // update the transaction phase to 'execute' after the transaction is opened
-            transactionPhase = 'execute';
-            await this.#checkAndIncrementLastMutationID(transactionHooks, mutation.clientID, mutation.id);
-            if (appError === undefined) {
-                try {
-                    await cb(dbTx, mutation.name, mutation.args[0]);
-                }
-                catch (appError) {
-                    throw wrapWithApplicationError(appError);
-                }
-            }
-            else {
-                const mutationResult = makeAppErrorResponse(mutation, appError);
-                await transactionHooks.writeMutationResult(mutationResult);
-            }
-            return {
-                id: {
-                    clientID: mutation.clientID,
-                    id: mutation.id,
-                },
-                result: {},
-            };
-        }, {
-            upstreamSchema: this.#params.schema,
-            clientGroupID: this.#req.clientGroupID,
-            clientID: mutation.clientID,
-            mutationID: mutation.id,
-        })
-            .catch(error => {
-            if (isApplicationError(error) ||
-                error instanceof OutOfOrderMutation ||
-                error instanceof MutationAlreadyProcessedError) {
-                throw error;
-            }
-            throw new DatabaseTransactionError(transactionPhase, { cause: error });
-        });
-    }
-    async #checkAndIncrementLastMutationID(transactionHooks, clientID, receivedMutationID) {
-        const { lastMutationID } = await transactionHooks.updateClientMutationID();
-        if (receivedMutationID < lastMutationID) {
-            throw new MutationAlreadyProcessedError(clientID, receivedMutationID, lastMutationID);
-        }
-        else if (receivedMutationID > lastMutationID) {
-            throw new OutOfOrderMutation(clientID, receivedMutationID, lastMutationID);
-        }
+  }
+  async #checkAndIncrementLastMutationID(transactionHooks, clientID, receivedMutationID) {
+    const { lastMutationID } = await transactionHooks.updateClientMutationID();
+    if (receivedMutationID < lastMutationID) {
+      throw new MutationAlreadyProcessedError(
+        clientID,
+        receivedMutationID,
+        lastMutationID
+      );
+    } else if (receivedMutationID > lastMutationID) {
+      throw new OutOfOrderMutation(
+        clientID,
+        receivedMutationID,
+        lastMutationID
+      );
     }
+  }
 }
-export class OutOfOrderMutation extends Error {
-    constructor(clientID, receivedMutationID, lastMutationID) {
-        super(`Client ${clientID} sent mutation ID ${receivedMutationID} but expected ${lastMutationID}`);
-    }
+class OutOfOrderMutation extends Error {
+  constructor(clientID, receivedMutationID, lastMutationID) {
+    super(
+      `Client ${clientID} sent mutation ID ${receivedMutationID} but expected ${lastMutationID}`
+    );
+  }
 }
 function makeAppErrorResponse(m, error) {
-    return {
-        id: {
-            clientID: m.clientID,
-            id: m.id,
-        },
-        result: {
-            error: 'app',
-            message: error.message,
-            ...(error.details ? { details: error.details } : {}),
-        },
-    };
-}
-export function getMutation(
-// oxlint-disable-next-line @typescript-eslint/no-explicit-any
-mutators, name) {
-    let path;
-    if (name.includes('|')) {
-        path = name.split('|');
+  return {
+    id: {
+      clientID: m.clientID,
+      id: m.id
+    },
+    result: {
+      error: "app",
+      message: error.message,
+      ...error.details ? { details: error.details } : {}
     }
-    else {
-        path = name.split('.');
-    }
-    // oxlint-disable-next-line @typescript-eslint/no-explicit-any
-    let mutator;
-    if (path.length === 1) {
-        mutator = mutators[path[0]];
-    }
-    else {
-        const nextMap = mutators[path[0]];
-        assert(typeof nextMap === 'object' && nextMap !== undefined, `could not find mutator map for ${name}`);
-        mutator = nextMap[path[1]];
+  };
+}
+function getMutation(mutators, name) {
+  const path = name.split(/\.|\|/);
+  const mutator = getObjectAtPath(mutators, path);
+  assert(typeof mutator === "function", `could not find mutator ${name}`);
+  if (isMutator(mutator)) {
+    return (tx, args, ctx) => mutator.fn({ args, ctx, tx });
+  }
+  return mutator;
+}
+function getObjectAtPath(obj, path) {
+  let current = obj;
+  for (const part of path) {
+    if (typeof current !== "object" || current === null || !(part in current)) {
+      return void 0;
     }
-    assert(typeof mutator === 'function', () => `could not find mutator ${name}`);
-    return mutator;
+    current = current[part];
+  }
+  return current;
 }
 class DatabaseTransactionError extends Error {
-    constructor(phase, options) {
-        super(phase === 'open'
-            ? `Failed to open database transaction: ${getErrorMessage(options?.cause)}`
-            : `Database transaction failed after opening: ${getErrorMessage(options?.cause)}`, options);
-        this.name = 'DatabaseTransactionError';
-    }
+  constructor(phase, options) {
+    super(
+      phase === "open" ? `Failed to open database transaction: ${getErrorMessage(options?.cause)}` : `Database transaction failed after opening: ${getErrorMessage(options?.cause)}`,
+      options
+    );
+    this.name = "DatabaseTransactionError";
+  }
 }
-//# sourceMappingURL=process-mutations.js.map
+export {
+  OutOfOrderMutation,
+  getMutation,
+  handleMutateRequest,
+  handleMutationRequest
+};
+//# sourceMappingURL=process-mutations.js.map