convex/dist/cjs/browser/sync/mutation_manager.js

Client for the Convex Cloud

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var mutation_manager_exports = {};
__export(mutation_manager_exports, {
  MutationManager: () => MutationManager
});
module.exports = __toCommonJS(mutation_manager_exports);
var import_values = require("../../values/index.js");
var import_logging = require("../logging.js");
class MutationManager {
  constructor() {
    this.inflightMutations = /* @__PURE__ */ new Map();
  }
  request(udfPath, args, mutationId) {
    const message = {
      type: "Mutation",
      mutationId,
      udfPath,
      args: (0, import_values.convexToJson)(args)
    };
    const result = new Promise((resolve, reject) => {
      this.inflightMutations.set(mutationId, {
        message,
        status: { status: "Requested", onResult: resolve, onFailure: reject }
      });
    });
    return { message, result };
  }
  onResponse(response) {
    const mutationInfo = this.inflightMutations.get(response.mutationId);
    if (mutationInfo === void 0) {
      return null;
    }
    if (mutationInfo.status.status === "Requested") {
      const udfPath = mutationInfo.message.udfPath;
      for (const line of response.logLines) {
        (0, import_logging.logToConsole)("info", "mutation", udfPath, line);
      }
      if (response.success) {
        const status = mutationInfo.status;
        const onResult = () => status.onResult((0, import_values.jsonToConvex)(response.result));
        mutationInfo.status = {
          status: "Committed",
          ts: response.ts,
          onResult
        };
        return null;
      } else {
        this.inflightMutations.delete(response.mutationId);
        (0, import_logging.logToConsole)("error", "mutation", udfPath, response.result);
        mutationInfo.status.onFailure(
          (0, import_logging.createError)("mutation", udfPath, response.result)
        );
        return response.mutationId;
      }
    }
    return null;
  }
  removeCompletedMutations(ts) {
    const completeMutations = /* @__PURE__ */ new Set();
    for (const [mutationId, mutationInfo] of this.inflightMutations.entries()) {
      const status = mutationInfo.status;
      if (status.status == "Committed" && status.ts.lessThanOrEqual(ts)) {
        status.onResult();
        completeMutations.add(mutationId);
        this.inflightMutations.delete(mutationId);
      }
    }
    return completeMutations;
  }
  hasUncommittedMutations() {
    for (const mutationInfo of this.inflightMutations.values()) {
      if (mutationInfo.status.status === "Requested") {
        return true;
      }
    }
    return false;
  }
  restart() {
    const allMessages = [];
    for (const value of this.inflightMutations.values()) {
      allMessages.push(value.message);
    }
    return allMessages;
  }
  hasInflightMutation() {
    return this.inflightMutations.size > 0;
  }
}
//# sourceMappingURL=mutation_manager.js.map