on-zero 0.7.10 → 0.8.0

package/dist/cjs/helpers/mutationLifecycle.native.js

@@ -0,0 +1,392 @@
+"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 mutationLifecycle_exports = {};
+__export(mutationLifecycle_exports, {
+  MutationResultError: () => MutationResultError,
+  MutationTimeoutError: () => MutationTimeoutError,
+  StaleGenerationError: () => StaleGenerationError,
+  createMutationLifecycle: () => createMutationLifecycle,
+  isStaleGenerationError: () => isStaleGenerationError,
+  mutationErrorMessage: () => mutationErrorMessage
+});
+module.exports = __toCommonJS(mutationLifecycle_exports);
+function _assert_this_initialized(self) {
+  if (self === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return self;
+}
+function _call_super(_this, derived, args) {
+  derived = _get_prototype_of(derived);
+  return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function _construct(Parent, args, Class) {
+  if (_is_native_reflect_construct()) _construct = Reflect.construct;else {
+    _construct = function construct(Parent2, args2, Class2) {
+      var a = [null];
+      a.push.apply(a, args2);
+      var Constructor = Function.bind.apply(Parent2, a);
+      var instance = new Constructor();
+      if (Class2) _set_prototype_of(instance, Class2.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
+}
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else obj[key] = value;
+  return obj;
+}
+function _get_prototype_of(o) {
+  _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _instanceof(left, right) {
+  "@swc/helpers - instanceof";
+
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+    return !!right[Symbol.hasInstance](left);
+  } else return left instanceof right;
+}
+function _is_native_function(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _is_native_reflect_construct() {
+  try {
+    var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (_) {}
+  return (_is_native_reflect_construct = function () {
+    return !!result;
+  })();
+}
+function _possible_constructor_return(self, call) {
+  if (call && (_type_of(call) === "object" || typeof call === "function")) return call;
+  return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+  _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_native_super(Class) {
+  var _cache = typeof Map === "function" ? /* @__PURE__ */new Map() : void 0;
+  _wrap_native_super = function (Class2) {
+    if (Class2 === null || !_is_native_function(Class2)) return Class2;
+    if (typeof Class2 !== "function") throw new TypeError("Super expression must either be null or a function");
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class2)) return _cache.get(Class2);
+      _cache.set(Class2, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class2, arguments, _get_prototype_of(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class2.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _set_prototype_of(Wrapper, Class2);
+  };
+  return _wrap_native_super(Class);
+}
+var StaleGenerationError = /* @__PURE__ */function (Error1) {
+  "use strict";
+
+  _inherits(StaleGenerationError2, Error1);
+  function StaleGenerationError2(label) {
+    _class_call_check(this, StaleGenerationError2);
+    var _this;
+    _this = _call_super(this, StaleGenerationError2, [`${label} stopped because its Zero instance was replaced or recovered`]), _define_property(_this, "label", void 0);
+    _this.name = "StaleGenerationError";
+    _this.label = label;
+    return _this;
+  }
+  return StaleGenerationError2;
+}(_wrap_native_super(Error));
+var MutationTimeoutError = /* @__PURE__ */function (Error1) {
+  "use strict";
+
+  _inherits(MutationTimeoutError2, Error1);
+  function MutationTimeoutError2(label, phase, timeoutMs) {
+    _class_call_check(this, MutationTimeoutError2);
+    var _this;
+    _this = _call_super(this, MutationTimeoutError2, [phase === "server" ? `${label} server acknowledgement did not complete within ${timeoutMs}ms` : `${label} did not complete within ${timeoutMs}ms`]), _define_property(_this, "label", void 0), _define_property(_this, "phase", void 0), _define_property(_this, "timeoutMs", void 0);
+    _this.name = "MutationTimeoutError";
+    _this.label = label;
+    _this.phase = phase;
+    _this.timeoutMs = timeoutMs;
+    return _this;
+  }
+  return MutationTimeoutError2;
+}(_wrap_native_super(Error));
+var MutationResultError = /* @__PURE__ */function (Error1) {
+  "use strict";
+
+  _inherits(MutationResultError2, Error1);
+  function MutationResultError2(label, phase, result, message) {
+    _class_call_check(this, MutationResultError2);
+    var _this;
+    _this = _call_super(this, MutationResultError2, [`${label} failed${phase === "server" ? " on server" : ""}: ${message}`]), _define_property(_this, "label", void 0), _define_property(_this, "phase", void 0), _define_property(_this, "result", void 0);
+    _this.name = "MutationResultError";
+    _this.label = label;
+    _this.phase = phase;
+    _this.result = result;
+    return _this;
+  }
+  return MutationResultError2;
+}(_wrap_native_super(Error));
+function isStaleGenerationError(error) {
+  return _instanceof(error, StaleGenerationError);
+}
+function mutationErrorMessage(result) {
+  if (!result || (typeof result === "undefined" ? "undefined" : _type_of(result)) !== "object") return null;
+  var typed = result;
+  if (typed.type !== "error") return null;
+  return describeMutationError(typed.error);
+}
+function describeMutationError(error) {
+  if (_instanceof(error, Error)) return error.message;
+  if (error && (typeof error === "undefined" ? "undefined" : _type_of(error)) === "object") {
+    var typed = error;
+    var parts = [typed.type, typed.message].filter(function (part) {
+      return typeof part === "string" && part.length > 0;
+    });
+    if (parts.length) return parts.join(": ");
+  }
+  return String(error);
+}
+function createMutationLifecycle(options) {
+  var queue = {
+    tail: Promise.resolve(),
+    lastErrorMessage: null,
+    coalesceSequence: /* @__PURE__ */new Map()
+  };
+  var waiters = /* @__PURE__ */new Set();
+  var generation = 0;
+  var active = false;
+  var consecutiveServerAckTimeouts = 0;
+  function stale(label) {
+    return new StaleGenerationError(label);
+  }
+  function fence() {
+    if (!active) return;
+    active = false;
+    generation += 1;
+    consecutiveServerAckTimeouts = 0;
+    queue.coalesceSequence.clear();
+    for (var _i = 0, _iter = [...waiters]; _i < _iter.length; _i++) {
+      var waiter = _iter[_i];
+      waiters.delete(waiter);
+      waiter.reject();
+    }
+  }
+  function activate() {
+    if (active) return;
+    generation += 1;
+    active = true;
+    consecutiveServerAckTimeouts = 0;
+    queue.lastErrorMessage = null;
+  }
+  function observeGeneration(capturedGeneration, label) {
+    var waiter;
+    var promise = new Promise(function (_, reject) {
+      if (!active || capturedGeneration !== generation) {
+        reject(stale(label));
+        return;
+      }
+      waiter = {
+        reject: function reject1() {
+          return reject(stale(label));
+        }
+      };
+      waiters.add(waiter);
+      if (!active || capturedGeneration !== generation) {
+        waiters.delete(waiter);
+        waiter = void 0;
+        reject(stale(label));
+      }
+    });
+    return {
+      promise,
+      dispose() {
+        if (waiter) waiters.delete(waiter);
+      }
+    };
+  }
+  async function awaitInGeneration(input) {
+    if (!active || input.generation !== generation) throw stale(input.label);
+    var timer;
+    var generationChange = observeGeneration(input.generation, input.label);
+    try {
+      return await Promise.race([input.promise, generationChange.promise, new Promise(function (_, reject) {
+        timer = setTimeout(function () {
+          return reject(new MutationTimeoutError(input.label, input.phase, input.timeoutMs));
+        }, input.timeoutMs);
+      })]);
+    } finally {
+      generationChange.dispose();
+      if (timer) clearTimeout(timer);
+    }
+  }
+  async function settleMutationClient(mutation, label, timeoutMs, capturedGeneration, observeServerFailure) {
+    var result = await awaitInGeneration({
+      promise: mutation.client,
+      label,
+      phase: "client",
+      timeoutMs,
+      generation: capturedGeneration
+    });
+    var message = mutationErrorMessage(result);
+    if (message) throw new MutationResultError(label, "client", result, message);
+    if (observeServerFailure) {
+      var _mutation_server;
+      (_mutation_server = mutation.server) === null || _mutation_server === void 0 ? void 0 : _mutation_server.catch(function (error) {
+        if (!active || capturedGeneration !== generation) return;
+        console.warn(`[on-zero] ${label} server replication failed:`, error);
+      });
+    }
+    return result;
+  }
+  function awaitMutationClient(mutation, label) {
+    var timeoutMs = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 3e4;
+    return settleMutationClient(mutation, label, timeoutMs, generation, true);
+  }
+  async function awaitMutationServer(mutation, label) {
+    var timeoutMs = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 3e4;
+    var capturedGeneration = generation;
+    var clientResult = await settleMutationClient(mutation, label, timeoutMs, capturedGeneration, false);
+    if (!mutation.server) return clientResult;
+    try {
+      var serverResult = await awaitInGeneration({
+        promise: mutation.server,
+        label,
+        phase: "server",
+        timeoutMs,
+        generation: capturedGeneration
+      });
+      consecutiveServerAckTimeouts = 0;
+      var message = mutationErrorMessage(serverResult);
+      if (message) throw new MutationResultError(label, "server", serverResult, message);
+      return serverResult;
+    } catch (error) {
+      if (_instanceof(error, MutationTimeoutError) && error.phase === "server") {
+        consecutiveServerAckTimeouts += 1;
+        if (consecutiveServerAckTimeouts >= options.ackTimeoutRecoveryThreshold) {
+          options.recoverFromAckTimeout({
+            label,
+            timeoutMs,
+            consecutiveTimeouts: consecutiveServerAckTimeouts
+          });
+        }
+      }
+      throw error;
+    }
+  }
+  function enqueueBackgroundMutation(label, create) {
+    var mutationOptions = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    var _queue_coalesceSequence_get;
+    var capturedGeneration = generation;
+    var {
+      coalesceKey = "",
+      settle = "client",
+      timeoutMs = 12e4
+    } = mutationOptions;
+    var sequence = coalesceKey ? ((_queue_coalesceSequence_get = queue.coalesceSequence.get(coalesceKey)) !== null && _queue_coalesceSequence_get !== void 0 ? _queue_coalesceSequence_get : 0) + 1 : 0;
+    if (coalesceKey) queue.coalesceSequence.set(coalesceKey, sequence);
+    var queued = queue.tail.then(async function () {
+      if (!active || capturedGeneration !== generation) throw stale(label);
+      if (coalesceKey) {
+        if (queue.coalesceSequence.get(coalesceKey) !== sequence) return;
+        queue.coalesceSequence.delete(coalesceKey);
+      }
+      var result2 = await create();
+      if (result2 && (typeof result2 === "undefined" ? "undefined" : _type_of(result2)) === "object" && "client" in result2) {
+        var mutation = result2;
+        if (settle === "server" && mutation.server) {
+          await awaitMutationServer(mutation, label, timeoutMs);
+        } else {
+          await settleMutationClient(mutation, label, timeoutMs, capturedGeneration, true);
+        }
+      } else {
+        await result2;
+      }
+      queue.lastErrorMessage = null;
+    });
+    var result = queued.catch(function (error) {
+      if (isStaleGenerationError(error)) return;
+      if (!active || capturedGeneration !== generation) return;
+      var message = describeMutationError(error);
+      var alreadyLogged = queue.lastErrorMessage === message;
+      queue.lastErrorMessage = message;
+      if (!alreadyLogged) {
+        console.warn(`[on-zero] ${label} background mutation failed:`, error);
+      }
+      throw error;
+    });
+    queue.tail = result.catch(function () {});
+    return result;
+  }
+  return {
+    activate,
+    fence,
+    enqueueBackgroundMutation,
+    awaitMutationClient,
+    awaitMutationServer
+  };
+}
+//# sourceMappingURL=mutationLifecycle.native.js.map

package/dist/cjs/helpers/mutationLifecycle.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","mutationLifecycle_exports","__export","MutationResultError","MutationTimeoutError","StaleGenerationError","createMutationLifecycle","isStaleGenerationError","mutationErrorMessage","module","exports","_assert_this_initialized","self","ReferenceError","_call_super","_this","derived","args","_get_prototype_of","_possible_constructor_return","_is_native_reflect_construct","Reflect","construct","constructor","apply","_class_call_check","instance","Constructor","TypeError","_construct","Parent","Class","Parent2","args2","Class2","a","push","Function","bind","_set_prototype_of","prototype","arguments","_define_property","obj","key","Object","defineProperty","enumerable","configurable","writable","o","setPrototypeOf","getPrototypeOf","o2","__proto__","_inherits","subClass","superClass","create","_instanceof","left","right","Symbol","hasInstance","_is_native_function","fn","toString","call","indexOf","result","Boolean","valueOf","_","_type_of","p","p2","_wrap_native_super","_cache","Map","has","get","set","Wrapper","Error1","StaleGenerationError2","label","name","Error","MutationTimeoutError2","phase","timeoutMs","MutationResultError2","message","error","typed","type","describeMutationError","parts","filter","part","length","join","String","options","queue","tail","Promise","resolve","lastErrorMessage","coalesceSequence","waiters","Set","generation","active","consecutiveServerAckTimeouts","stale","fence","clear","_i","_iter","waiter","delete","reject","activate","observeGeneration","capturedGeneration","promise","reject1"],"sources":["../../../src/helpers/mutationLifecycle.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/cjs/helpers/mutationLifecycle.test.cjs

@@ -0,0 +1,174 @@
+var import_vitest = require("vitest");
+var import_mutationLifecycle = require("./mutationLifecycle.cjs");
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return {
+    promise,
+    reject,
+    resolve
+  };
+}
+function setup(threshold = 2) {
+  const recoverFromAckTimeout = import_vitest.vi.fn();
+  const lifecycle = (0, import_mutationLifecycle.createMutationLifecycle)({
+    ackTimeoutRecoveryThreshold: threshold,
+    recoverFromAckTimeout
+  });
+  lifecycle.activate();
+  return {
+    lifecycle,
+    recoverFromAckTimeout
+  };
+}
+(0, import_vitest.beforeEach)(() => {
+  import_vitest.vi.restoreAllMocks();
+});
+(0, import_vitest.describe)("mutation lifecycle", () => {
+  (0, import_vitest.test)("extracts typed mutation errors and times out each settlement phase", async () => {
+    import_vitest.vi.useFakeTimers();
+    try {
+      const {
+        lifecycle
+      } = setup();
+      await (0, import_vitest.expect)(lifecycle.awaitMutationClient({
+        client: Promise.resolve({
+          type: "error",
+          error: {
+            message: "denied"
+          }
+        })
+      }, "save note")).rejects.toMatchObject({
+        name: "MutationResultError",
+        label: "save note",
+        phase: "client"
+      });
+      const waiting = lifecycle.awaitMutationClient({
+        client: new Promise(() => {})
+      }, "stuck note", 20);
+      const timedOut = (0, import_vitest.expect)(waiting).rejects.toMatchObject({
+        name: "MutationTimeoutError",
+        phase: "client",
+        timeoutMs: 20
+      });
+      await import_vitest.vi.advanceTimersByTimeAsync(20);
+      await timedOut;
+    } finally {
+      import_vitest.vi.useRealTimers();
+    }
+  });
+  (0, import_vitest.test)("serializes work and skips superseded coalesced writes", async () => {
+    const {
+      lifecycle
+    } = setup();
+    const blocker = deferred();
+    const first = lifecycle.enqueueBackgroundMutation("blocker", () => blocker.promise);
+    const superseded = import_vitest.vi.fn();
+    const latest = import_vitest.vi.fn(async () => {});
+    const oldWrite = lifecycle.enqueueBackgroundMutation("old row", superseded, {
+      coalesceKey: "message:1"
+    });
+    const newWrite = lifecycle.enqueueBackgroundMutation("new row", latest, {
+      coalesceKey: "message:1"
+    });
+    blocker.resolve();
+    await Promise.all([first, oldWrite, newWrite]);
+    (0, import_vitest.expect)(superseded).not.toHaveBeenCalled();
+    (0, import_vitest.expect)(latest).toHaveBeenCalledOnce();
+  });
+  (0, import_vitest.test)("one failed background mutation does not poison later work", async () => {
+    const {
+      lifecycle
+    } = setup();
+    import_vitest.vi.spyOn(console, "warn").mockImplementation(() => {});
+    const denied = lifecycle.enqueueBackgroundMutation("stamp", async () => {
+      throw new Error("PermissionError: stale task");
+    });
+    await (0, import_vitest.expect)(denied).rejects.toThrow("PermissionError");
+    const next = import_vitest.vi.fn(async () => {});
+    await lifecycle.enqueueBackgroundMutation("clear stamp", next);
+    (0, import_vitest.expect)(next).toHaveBeenCalledOnce();
+  });
+  (0, import_vitest.test)("recovery or close quietly drops in-flight and queued background work", async () => {
+    const {
+      lifecycle
+    } = setup();
+    const client = deferred();
+    const queuedCreate = import_vitest.vi.fn(async () => {});
+    const inFlight = lifecycle.enqueueBackgroundMutation("in flight", () => ({
+      client: client.promise
+    }));
+    const queued = lifecycle.enqueueBackgroundMutation("queued", queuedCreate);
+    lifecycle.fence();
+    await (0, import_vitest.expect)(inFlight).resolves.toBeUndefined();
+    await (0, import_vitest.expect)(queued).resolves.toBeUndefined();
+    (0, import_vitest.expect)(queuedCreate).not.toHaveBeenCalled();
+    const direct = lifecycle.awaitMutationClient({
+      client: Promise.resolve({})
+    }, "direct after close");
+    await (0, import_vitest.expect)(direct).rejects.toBeInstanceOf(import_mutationLifecycle.StaleGenerationError);
+  });
+  (0, import_vitest.test)("recovers only after consecutive server acknowledgement timeouts", async () => {
+    import_vitest.vi.useFakeTimers();
+    try {
+      const {
+        lifecycle,
+        recoverFromAckTimeout
+      } = setup();
+      const timeout = async label => {
+        const result = lifecycle.awaitMutationServer({
+          client: Promise.resolve({}),
+          server: new Promise(() => {})
+        }, label, 10);
+        const timedOut = (0, import_vitest.expect)(result).rejects.toMatchObject({
+          name: "MutationTimeoutError",
+          phase: "server"
+        });
+        await import_vitest.vi.advanceTimersByTimeAsync(10);
+        await timedOut;
+      };
+      await timeout("first");
+      (0, import_vitest.expect)(recoverFromAckTimeout).not.toHaveBeenCalled();
+      await timeout("second");
+      (0, import_vitest.expect)(recoverFromAckTimeout).toHaveBeenCalledOnce();
+      (0, import_vitest.expect)(recoverFromAckTimeout).toHaveBeenCalledWith({
+        label: "second",
+        timeoutMs: 10,
+        consecutiveTimeouts: 2
+      });
+    } finally {
+      import_vitest.vi.useRealTimers();
+    }
+  });
+  (0, import_vitest.test)("a server response resets the consecutive timeout count", async () => {
+    import_vitest.vi.useFakeTimers();
+    try {
+      const {
+        lifecycle,
+        recoverFromAckTimeout
+      } = setup();
+      const timeout = async () => {
+        const result = lifecycle.awaitMutationServer({
+          client: Promise.resolve({}),
+          server: new Promise(() => {})
+        }, "write", 10);
+        const timedOut = (0, import_vitest.expect)(result).rejects.toBeInstanceOf(import_mutationLifecycle.MutationTimeoutError);
+        await import_vitest.vi.advanceTimersByTimeAsync(10);
+        await timedOut;
+      };
+      await timeout();
+      await (0, import_vitest.expect)(lifecycle.awaitMutationServer({
+        client: Promise.resolve({}),
+        server: Promise.resolve({})
+      }, "acked write", 10)).resolves.toEqual({});
+      await timeout();
+      (0, import_vitest.expect)(recoverFromAckTimeout).not.toHaveBeenCalled();
+    } finally {
+      import_vitest.vi.useRealTimers();
+    }
+  });
+});