@cronwatch/sdk 0.8.0 → 0.9.0

package/dist/index.cjs

@@ -272,6 +272,11 @@ function stateVersion(state) {
   const version = state?.version;
   return typeof version === "number" && Number.isSafeInteger(version) && version >= 0 ? version + 0 : 0;
 }
+function failureCount(state) {
+  const count = state?.consecutiveFailures;
+  if (typeof count !== "number" || !Number.isInteger(count) || count <= 0) return 0;
+  return Math.min(count, MAX_DURATION_MS);
+}
 function emptyState(job) {
   return { job, open: {}, consecutiveFailures: 0, silencedUntil: null, lastAlertAt: null, pendingRecovery: [], undelivered: [] };
 }
@@ -281,6 +286,7 @@ function normalizeState(state, job) {
     ...emptyState(job),
     ...state,
     open: { ...state.open },
+    consecutiveFailures: failureCount(state),
     pendingRecovery: [...state.pendingRecovery ?? []],
     undelivered: [...state.undelivered ?? []]
   };
@@ -379,7 +385,7 @@ function onRunFinish(def, run, state, history, now) {
     }
     return { state: next, alerts };
   }
-  next.consecutiveFailures += 1;
+  next.consecutiveFailures = Math.min(next.consecutiveFailures + 1, MAX_DURATION_MS);
   closeCondition(next, "missed");
   const threshold = Math.max(1, def.failuresBeforeAlert ?? 1);
   const condition = run.status === "timeout" ? "stuck" : "failed";
@@ -593,6 +599,9 @@ function capOutput(text) {
 function stripNul(text) {
   return text.includes("\0") ? text.replace(/\u0000/g, "") : text;
 }
+function stripJsonNul(json2) {
+  return json2.includes("\\u0000") ? json2.replace(/\\(u0000|[\s\S])/g, (escape, next) => next === "u0000" ? "" : escape) : json2;
+}
 function errorMessage(error) {
   return capOutput(describeError(error));
 }
@@ -1845,13 +1854,21 @@ function memory() {
   const states = /* @__PURE__ */ new Map();
   let seq = 0;
   const clone = (v) => JSON.parse(JSON.stringify(v));
+  const kept = (v) => JSON.parse(stripJsonNul(JSON.stringify(v)));
+  const keptRun = (run) => ({
+    ...clone(run),
+    trigger: stripNul(run.trigger),
+    output: run.output === null ? null : stripNul(run.output),
+    error: run.error === null ? null : stripNul(run.error),
+    metrics: kept(run.metrics)
+  });
   const byName = (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
   return {
     async upsertJob(definition, now) {
       const existing = jobs.get(definition.name);
       jobs.set(definition.name, {
         name: definition.name,
-        definition: clone(definition),
+        definition: kept(definition),
         createdAt: existing?.createdAt ?? now,
         updatedAt: now
       });
@@ -1873,19 +1890,19 @@ function memory() {
     },
     async insertRun(run) {
       if (runs.has(run.id)) throw new Error(`run ${run.id} already exists`);
-      runs.set(run.id, clone(run));
+      runs.set(run.id, keptRun(run));
       order.set(run.id, ++seq);
     },
     async updateRun(run) {
       const existing = runs.get(run.id);
       if (!existing) return;
-      const { status, finishedAt, durationMs, error, output, metrics } = clone(run);
+      const { status, finishedAt, durationMs, error, output, metrics } = keptRun(run);
       runs.set(run.id, { ...existing, status, finishedAt, durationMs, error, output, metrics });
     },
     async updateRunIf(run, fromStatuses) {
       const existing = runs.get(run.id);
       if (!existing || !fromStatuses.includes(existing.status)) return false;
-      const { status, finishedAt, durationMs, error, output, metrics } = clone(run);
+      const { status, finishedAt, durationMs, error, output, metrics } = keptRun(run);
       runs.set(run.id, { ...existing, status, finishedAt, durationMs, error, output, metrics });
       return true;
     },
@@ -1908,11 +1925,11 @@ function memory() {
       return s ? clone(s) : null;
     },
     async setState(state) {
-      states.set(state.job, clone(state));
+      states.set(state.job, kept(state));
     },
     async compareAndSetState(state, expectedVersion) {
       if (stateVersion(states.get(state.job)) !== expectedVersion) return false;
-      states.set(state.job, clone(state));
+      states.set(state.job, kept(state));
       return true;
     },
     async prune(before) {
@@ -2000,6 +2017,8 @@ var CronWatch = class {
   synced = /* @__PURE__ */ new Set();
   /** The tail of each job's queue of state updates. See serial(). */
   queues = /* @__PURE__ */ new Map();
+  /** The tail of each job's queue of declaration writes. See sync(). */
+  syncing = /* @__PURE__ */ new Map();
   /** start() calls with an id still in flight, so two at once in this process record one run. */
   starting = /* @__PURE__ */ new Map();
   ready = null;
@@ -2138,26 +2157,40 @@ var CronWatch = class {
     }
     await this.ready;
   }
+  /**
+   * Writes the declaration of `definition`'s name as it stands, unless the
+   * store has it. A handle kept from an earlier declaration writes the one
+   * that replaced it, never its own over it, and one forgotten since writes
+   * its own. The writes of one name take turns, in the order they were asked
+   * for, so one still under way cannot land after a later one; and a name
+   * declared again while its write was under way is still to be written.
+   */
   async sync(definition) {
     await this.ensureReady();
-    if (this.synced.has(definition.name)) return;
-    await this.store.upsertJob(toStored(definition), this.now());
-    this.synced.add(definition.name);
+    const name = definition.name;
+    if (this.synced.has(name)) return;
+    await this.serial(name, async () => {
+      if (this.synced.has(name)) return;
+      const standing = this.definitions.get(name) ?? definition;
+      await this.store.upsertJob(toStored(standing), this.now());
+      if ((this.definitions.get(name) ?? standing) === standing) this.synced.add(name);
+    }, this.syncing);
   }
   /**
    * Runs `fn` after every earlier state update for the same job has settled,
    * so two runs (or a run and a check) in this process never read and write
    * the job's state over each other. Other processes are coordinated by
-   * updateState() instead.
+   * updateState() instead. sync() queues a job's declaration writes the same
+   * way, in `syncing`.
    */
-  serial(job, fn) {
-    const result = (this.queues.get(job) ?? Promise.resolve()).then(fn);
+  serial(job, fn, queues = this.queues) {
+    const result = (queues.get(job) ?? Promise.resolve()).then(fn);
     const tail2 = result.then(() => {
     }, () => {
     });
-    this.queues.set(job, tail2);
+    queues.set(job, tail2);
     void tail2.then(() => {
-      if (this.queues.get(job) === tail2) this.queues.delete(job);
+      if (queues.get(job) === tail2) queues.delete(job);
     });
     return result;
   }
@@ -2557,6 +2590,7 @@ ${id}`;
   async recordRun(input, options = {}) {
     const declared = this.definitions.get(input.job);
     if (!declared) throw new Error(`recordRun: job "${input.job}" is not declared; call job() first`);
+    if (input.id.includes("\0")) throw new Error(`recordRun: run ids cannot contain a NUL character (job "${input.job}")`);
     await this.sync(declared);
     const run = { ...input, metrics: { ...input.metrics } };
     if (run.status === "ok") {
@@ -2927,6 +2961,7 @@ function checkRunId(job, id, method) {
   if (typeof id !== "string" || id.length === 0 || id.length > 200) {
     throw new Error(`job "${job}": ${method}() needs a run id of 1 to 200 characters (got ${typeof id === "string" ? `${id.length} characters` : typeof id})`);
   }
+  if (id.includes("\0")) throw new Error(`job "${job}": ${method}() cannot take a run id containing a NUL character`);
   if (id.startsWith(RESERVED_RUN_ID_PREFIX)) {
     throw new Error(`job "${job}": ${method}() cannot take a run id starting with "${RESERVED_RUN_ID_PREFIX}", which the pg_cron source uses for its runs`);
   }