@rocicorp/zero 0.25.0-canary.6 → 0.25.0-canary.8

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

@@ -1,300 +1,319 @@
 import { assert } from "../../shared/src/asserts.js";
-import { getErrorDetails, getErrorMessage } from "../../shared/src/error.js";
-import * as v from "../../shared/src/valita.js";
+import { getErrorMessage, getErrorDetails } from "../../shared/src/error.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 { createLogContext } from "./logging.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';
-        }
+async function handleMutationRequest(cb, queryOrQueryString, body, logLevel) {
+  if (logLevel === void 0) {
+    if (queryOrQueryString instanceof Request && typeof body === "string") {
+      logLevel = body;
+    } else {
+      logLevel = "info";
     }
-    const lc = createLogContext(logLevel).withContext('PushProcessor');
-    let mutationIDs = [];
-    let req;
-    try {
-        let rawBody;
-        if (queryOrQueryString instanceof Request) {
-            rawBody = await queryOrQueryString.json();
-        }
-        else {
-            rawBody = body;
-        }
-        req = v.parse(rawBody, pushBodySchema);
-        mutationIDs = req.mutations.map(m => ({
-            id: m.id,
-            clientID: m.clientID,
-        }));
+  }
+  const lc = createLogContext(logLevel).withContext("PushProcessor");
+  let mutationIDs = [];
+  let req;
+  try {
+    let rawBody;
+    if (queryOrQueryString instanceof Request) {
+      rawBody = await queryOrQueryString.json();
+    } else {
+      rawBody = body;
     }
-    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 } : {}),
-        };
-    }
-    let queryParams;
-    try {
-        let queryString;
-        if (queryOrQueryString instanceof Request) {
-            const url = new URL(queryOrQueryString.url);
-            queryString = url.searchParams;
-        }
-        else {
-            queryString = queryOrQueryString;
-        }
-        if (queryString instanceof URLSearchParams) {
-            queryString = Object.fromEntries(queryString);
-        }
-        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 } : {}),
-        };
+    req = 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: PushFailed,
+      origin: Server,
+      reason: Parse,
+      message,
+      mutationIDs,
+      ...details ? { details } : {}
+    };
+  }
+  let queryParams;
+  try {
+    let queryString;
+    if (queryOrQueryString instanceof Request) {
+      const url = new URL(queryOrQueryString.url);
+      queryString = url.searchParams;
+    } else {
+      queryString = queryOrQueryString;
     }
-    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 (queryString instanceof URLSearchParams) {
+      queryString = Object.fromEntries(queryString);
     }
-    const responses = [];
-    let processedCount = 0;
-    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)));
-            try {
-                const res = await applicationErrorWrapper(() => cb(transactProxy, m));
-                responses.push(res);
-                processedCount++;
-            }
-            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++;
-            }
+    queryParams = 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: PushFailed,
+      origin: Server,
+      reason: Parse,
+      message,
+      mutationIDs,
+      ...details ? { details } : {}
+    };
+  }
+  if (req.pushVersion !== 1) {
+    const response = {
+      kind: PushFailed,
+      origin: Server,
+      reason: UnsupportedPushVersion,
+      mutationIDs,
+      message: `Unsupported push version: ${req.pushVersion}`
+    };
+    return response;
+  }
+  const responses = [];
+  let processedCount = 0;
+  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))
+      );
+      try {
+        const res = await applicationErrorWrapper(() => cb(transactProxy, m));
+        responses.push(res);
+        processedCount++;
+      } catch (error) {
+        if (!isApplicationError(error)) {
+          throw error;
         }
-        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 } : {}),
-        };
+        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);
+    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 {
-    #req;
-    #params;
-    #lc;
-    constructor(req, params, lc) {
-        this.#req = req;
-        this.#params = params;
-        this.#lc = lc;
-    }
-    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;
-            }
+  #req;
+  #params;
+  #lc;
+  constructor(req, params, lc) {
+    this.#req = req;
+    this.#params = params;
+    this.#lc = lc;
+  }
+  transact = async (dbProvider, mutation, cb) => {
+    let appError = void 0;
+    for (; ; ) {
+      try {
+        const ret = await this.#transactImpl(
+          dbProvider,
+          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);
         }
-    };
-    #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;
+        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
             }
-            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);
+          };
+        }
+        if (isApplicationError(error)) {
+          appError = error;
+          this.#lc.warn?.(
+            `Application error processing mutation ${mutation.id} for client ${mutation.clientID}`,
+            appError
+          );
+          continue;
         }
-        else if (receivedMutationID > lastMutationID) {
-            throw new OutOfOrderMutation(clientID, receivedMutationID, lastMutationID);
+        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;
+      }
     }
-}
-export class OutOfOrderMutation extends Error {
-    constructor(clientID, receivedMutationID, lastMutationID) {
-        super(`Client ${clientID} sent mutation ID ${receivedMutationID} but expected ${lastMutationID}`);
+  };
+  #transactImpl(dbProvider, mutation, cb, appError) {
+    let transactionPhase = "open";
+    return dbProvider.transaction(
+      async (dbTx, transactionHooks) => {
+        transactionPhase = "execute";
+        await this.#checkAndIncrementLastMutationID(
+          transactionHooks,
+          mutation.clientID,
+          mutation.id
+        );
+        if (appError === void 0) {
+          try {
+            await cb(dbTx, mutation.name, mutation.args[0]);
+          } catch (appError2) {
+            throw wrapWithApplicationError(appError2);
+          }
+        } 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
+      );
     }
+  }
 }
-function makeAppErrorResponse(m, error) {
-    return {
-        id: {
-            clientID: m.clientID,
-            id: m.id,
-        },
-        result: {
-            error: 'app',
-            message: error.message,
-            ...(error.details ? { details: error.details } : {}),
-        },
-    };
+class OutOfOrderMutation extends Error {
+  constructor(clientID, receivedMutationID, lastMutationID) {
+    super(
+      `Client ${clientID} sent mutation ID ${receivedMutationID} but expected ${lastMutationID}`
+    );
+  }
 }
-export function getMutation(
-// oxlint-disable-next-line @typescript-eslint/no-explicit-any
-mutators, name) {
-    let path;
-    if (name.includes('|')) {
-        path = name.split('|');
-    }
-    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 makeAppErrorResponse(m, error) {
+  return {
+    id: {
+      clientID: m.clientID,
+      id: m.id
+    },
+    result: {
+      error: "app",
+      message: error.message,
+      ...error.details ? { details: error.details } : {}
     }
-    assert(typeof mutator === 'function', () => `could not find mutator ${name}`);
-    return mutator;
+  };
+}
+function getMutation(mutators, name) {
+  let path;
+  if (name.includes("|")) {
+    path = name.split("|");
+  } else {
+    path = name.split(".");
+  }
+  let mutator;
+  if (path.length === 1) {
+    mutator = mutators[path[0]];
+  } else {
+    const nextMap = mutators[path[0]];
+    assert(
+      typeof nextMap === "object" && nextMap !== void 0,
+      `could not find mutator map for ${name}`
+    );
+    mutator = nextMap[path[1]];
+  }
+  assert(typeof mutator === "function", () => `could not find mutator ${name}`);
+  return mutator;
 }
 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,
+  handleMutationRequest
+};
+//# sourceMappingURL=process-mutations.js.map