@marktiderman/genesis-forms 0.9.0 → 0.9.2

package/dist/destinations.d.cts

@@ -1,4 +1,4 @@
-import { J as Json, F as FormDefinition, a as FieldBlock, C as Condition } from './types-C0pUfew3.cjs';
+import { J as Json, F as FormDefinition, a as FieldBlock, C as Condition } from './types-BBDa8oXu.cjs';
 
 /**
  * The contract every destination keeps. A destination sends one checked
@@ -733,30 +733,6 @@ declare function sealSecret(key: WebCryptoKey, plaintext: string, aad: string):
  */
 declare function openSecret(key: WebCryptoKey, sealed: string, aad: string): Promise<string>;
 
-/**
- * The outbox runner: claim a batch of due deliveries, send each to its
- * destination, and record what happened. The store is the app's (a SQL
- * outbox, a queue, a KV list): it hands over claimed deliveries and takes
- * back outcomes, and decides how claims and leases work. The runner owns the
- * rest: the destination's condition (`config.when`), batching deliveries to
- * one destination into one request where the destination can, keeping its
- * state, and turning each result into an outcome with a retry time.
- *
- * Outcomes:
- * - `sent`: delivered (or already there, on a redelivery).
- * - `filtered`: the submission doesn't match the destination's condition; nothing was sent, nothing to retry.
- * - `skipped`: the destination deliberately sent nothing (`notSent`); never retried.
- * - `retry`: a retryable failure. With the service's own Retry-After it is
- *   deferred without counting an attempt (`counted: false`); otherwise it backs
- *   off by attempt (`counted: true`), until `maxAttempts`.
- * - `failed`: permanent, an unknown kind, or out of attempts. With `disable:
- *   true` the receiver asked to be switched off (a webhook's 410 Gone): the
- *   app should disable the destination rather than keep sending to it.
- *
- * It never throws for a delivery's failure, and never logs answers, contact
- * details or secrets: only ids, kinds and the destinations' safe messages.
- */
-
 /** One claimed delivery, as the app's store hands it over. */
 interface ClaimedDelivery {
     /** The delivery's id: stable across its retries (the email idempotency key, the webhook-id). */
@@ -874,9 +850,9 @@ interface DeliveryRunner<Filter = undefined> {
     /** One claim, its sends and their records. Never rejects for a delivery's failure; a failing `claim` rejects. */
     run(options?: RunOptions<Filter>): Promise<DeliveryReport>;
 }
-declare const DEFAULT_MAX_ATTEMPTS = 8;
-declare const DEFAULT_MAX_DEFERRALS = 24;
-declare const DEFAULT_BATCH_SIZE = 25;
+declare const DEFAULT_MAX_ATTEMPTS: number;
+declare const DEFAULT_MAX_DEFERRALS: number;
+declare const DEFAULT_BATCH_SIZE: number;
 /**
  * 5 minutes, quadrupling each attempt, at most 24 hours: 5m, 20m, 80m, 5h20m,
  * 21h20m, then 24h. Across the default 8 attempts that is about 3 days, as
@@ -884,7 +860,7 @@ declare const DEFAULT_BATCH_SIZE = 25;
  * deliveries that failed together (a receiver's outage) don't all come back
  * at once. `random` (default `Math.random`) is for tests.
  */
-declare function defaultBackoff(attempt: number, random?: () => number): number;
+declare const defaultBackoff: (attempt: number, random?: () => number) => number;
 /** Turns a destination's result into an outcome for a delivery on its `attempt`. */
 declare function deliveryOutcome(result: DeliveryResult, attempt: number, options?: {
     now?: number | undefined;

package/dist/destinations.d.ts

@@ -1,4 +1,4 @@
-import { J as Json, F as FormDefinition, a as FieldBlock, C as Condition } from './types-C0pUfew3.js';
+import { J as Json, F as FormDefinition, a as FieldBlock, C as Condition } from './types-BBDa8oXu.js';
 
 /**
  * The contract every destination keeps. A destination sends one checked
@@ -733,30 +733,6 @@ declare function sealSecret(key: WebCryptoKey, plaintext: string, aad: string):
  */
 declare function openSecret(key: WebCryptoKey, sealed: string, aad: string): Promise<string>;
 
-/**
- * The outbox runner: claim a batch of due deliveries, send each to its
- * destination, and record what happened. The store is the app's (a SQL
- * outbox, a queue, a KV list): it hands over claimed deliveries and takes
- * back outcomes, and decides how claims and leases work. The runner owns the
- * rest: the destination's condition (`config.when`), batching deliveries to
- * one destination into one request where the destination can, keeping its
- * state, and turning each result into an outcome with a retry time.
- *
- * Outcomes:
- * - `sent`: delivered (or already there, on a redelivery).
- * - `filtered`: the submission doesn't match the destination's condition; nothing was sent, nothing to retry.
- * - `skipped`: the destination deliberately sent nothing (`notSent`); never retried.
- * - `retry`: a retryable failure. With the service's own Retry-After it is
- *   deferred without counting an attempt (`counted: false`); otherwise it backs
- *   off by attempt (`counted: true`), until `maxAttempts`.
- * - `failed`: permanent, an unknown kind, or out of attempts. With `disable:
- *   true` the receiver asked to be switched off (a webhook's 410 Gone): the
- *   app should disable the destination rather than keep sending to it.
- *
- * It never throws for a delivery's failure, and never logs answers, contact
- * details or secrets: only ids, kinds and the destinations' safe messages.
- */
-
 /** One claimed delivery, as the app's store hands it over. */
 interface ClaimedDelivery {
     /** The delivery's id: stable across its retries (the email idempotency key, the webhook-id). */
@@ -874,9 +850,9 @@ interface DeliveryRunner<Filter = undefined> {
     /** One claim, its sends and their records. Never rejects for a delivery's failure; a failing `claim` rejects. */
     run(options?: RunOptions<Filter>): Promise<DeliveryReport>;
 }
-declare const DEFAULT_MAX_ATTEMPTS = 8;
-declare const DEFAULT_MAX_DEFERRALS = 24;
-declare const DEFAULT_BATCH_SIZE = 25;
+declare const DEFAULT_MAX_ATTEMPTS: number;
+declare const DEFAULT_MAX_DEFERRALS: number;
+declare const DEFAULT_BATCH_SIZE: number;
 /**
  * 5 minutes, quadrupling each attempt, at most 24 hours: 5m, 20m, 80m, 5h20m,
  * 21h20m, then 24h. Across the default 8 attempts that is about 3 days, as
@@ -884,7 +860,7 @@ declare const DEFAULT_BATCH_SIZE = 25;
  * deliveries that failed together (a receiver's outage) don't all come back
  * at once. `random` (default `Math.random`) is for tests.
  */
-declare function defaultBackoff(attempt: number, random?: () => number): number;
+declare const defaultBackoff: (attempt: number, random?: () => number) => number;
 /** Turns a destination's result into an outcome for a delivery on its `attempt`. */
 declare function deliveryOutcome(result: DeliveryResult, attempt: number, options?: {
     now?: number | undefined;

package/dist/destinations.js

@@ -2093,7 +2093,7 @@ function padded(text) {
   return fromBase64(text + "=".repeat((4 - text.length % 4) % 4));
 }
 
-// src/destinations/runner.ts
+// ../notifications/src/runner/index.ts
 var DEFAULT_MAX_ATTEMPTS = 8;
 var DEFAULT_MAX_DEFERRALS = 24;
 var DEFAULT_BATCH_SIZE = 25;
@@ -2102,8 +2102,11 @@ function defaultBackoff(attempt, random) {
   const r = typeof random === "function" ? random() : Math.random();
   return Math.round(nominal * (0.8 + 0.4 * Math.min(1, Math.max(0, r))));
 }
-function deliveryOutcome(result, attempt, options = {}) {
-  if (result.ok) return result.notSent ? { status: "skipped", reason: result.notSent.slice(0, 500) } : { status: "sent" };
+function jobOutcome(result, attempt, options = {}) {
+  if (result.ok) {
+    if (result.notSent) return { status: "skipped", reason: result.notSent.slice(0, 500) };
+    return result.alreadyThere ? { status: "sent", alreadyThere: true } : { status: "sent" };
+  }
   const http = result.status !== void 0 ? { httpStatus: result.status } : {};
   if (result.disable) return { status: "failed", error: result.error, ...http, disable: true };
   if (!result.retryable) return { status: "failed", error: result.error, ...http };
@@ -2117,14 +2120,109 @@ function deliveryOutcome(result, attempt, options = {}) {
   const seconds = Math.max(1, Math.ceil((options.backoff ?? defaultBackoff)(attempt)));
   return { status: "retry", error: result.error, retryAt: new Date(now + seconds * 1e3), retryAfterSeconds: seconds, counted: true, ...http };
 }
-function createDeliveryRunner(options) {
+function failureOf(error) {
+  const e = error;
+  if (e && typeof e === "object" && typeof e.retryable === "boolean" && typeof e.message === "string") {
+    return {
+      ok: false,
+      retryable: e.disable === true ? false : e.retryable,
+      error: e.message.slice(0, 500),
+      ...typeof e.retryAfterSeconds === "number" ? { retryAfterSeconds: e.retryAfterSeconds } : {},
+      ...typeof e.status === "number" ? { status: e.status } : {},
+      ...e.disable === true ? { disable: true } : {}
+    };
+  }
+  const timeout = e && typeof e === "object" && (e.name === "TimeoutError" || e.name === "AbortError");
+  return { ok: false, retryable: true, error: timeout ? "Timed out" : "Unexpected error" };
+}
+function createRunner(options) {
   const log = (message) => {
     try {
       options.log?.(message);
     } catch {
     }
   };
+  const label = (job) => options.label?.(job) ?? `Job ${job.id}`;
+  const recordLabel = (job) => options.recordLabel?.(job) ?? `job ${job.id}`;
   const now = () => options.now?.() ?? Date.now();
+  return {
+    async run(runOptions = {}) {
+      const report = { claimed: 0, sent: 0, filtered: 0, skipped: 0, retrying: 0, deferred: 0, failed: 0, stale: 0, unrecorded: 0 };
+      const limit = runOptions.limit ?? options.batchSize ?? DEFAULT_BATCH_SIZE;
+      const claimed = await options.claim({ limit, filter: runOptions.filter });
+      report.claimed = claimed.length;
+      const groups = /* @__PURE__ */ new Map();
+      claimed.forEach((job, i) => {
+        const key = options.group ? options.group(job) : `\0${i}`;
+        const list = groups.get(key) ?? [];
+        list.push(job);
+        groups.set(key, list);
+      });
+      await Promise.all(
+        [...groups.values()].map(async (group) => {
+          let results;
+          try {
+            results = await options.send(group, { signal: runOptions.signal });
+            if (results.length !== group.length) throw new Error("send answered the wrong number of results");
+          } catch (error) {
+            const failure = failureOf(error);
+            results = group.map(() => failure);
+          }
+          const at = now();
+          await Promise.all(
+            group.map(async (job, i) => {
+              const result = results[i];
+              const outcome = result === "filtered" ? { status: "filtered" } : jobOutcome(result, job.attempt, {
+                now: at,
+                maxAttempts: options.maxAttempts,
+                backoff: options.backoff,
+                deferrals: job.deferrals,
+                maxDeferrals: options.maxDeferrals
+              });
+              if (outcome.status === "failed" || outcome.status === "retry") {
+                log(`${label(job)} ${outcome.status === "failed" ? "failed" : "will be retried"}: ${outcome.error}`);
+              } else if (outcome.status === "skipped") {
+                log(`${label(job)} skipped: ${outcome.reason}`);
+              }
+              let recorded;
+              try {
+                recorded = await options.record(job, outcome);
+              } catch {
+                report.unrecorded++;
+                log(`Recording ${recordLabel(job)} failed`);
+                return;
+              }
+              if (recorded === false) report.stale++;
+              else if (outcome.status === "sent") report.sent++;
+              else if (outcome.status === "filtered") report.filtered++;
+              else if (outcome.status === "skipped") report.skipped++;
+              else if (outcome.status === "failed") report.failed++;
+              else if (outcome.counted) report.retrying++;
+              else report.deferred++;
+            })
+          );
+        })
+      );
+      return report;
+    }
+  };
+}
+
+// src/destinations/runner.ts
+var DEFAULT_MAX_ATTEMPTS2 = DEFAULT_MAX_ATTEMPTS;
+var DEFAULT_MAX_DEFERRALS2 = DEFAULT_MAX_DEFERRALS;
+var DEFAULT_BATCH_SIZE2 = DEFAULT_BATCH_SIZE;
+var defaultBackoff2 = defaultBackoff;
+function deliveryOutcome(result, attempt, options = {}) {
+  return jobOutcome(result.ok ? { ok: true, notSent: result.notSent } : result, attempt, options);
+}
+function createDeliveryRunner(options) {
+  const log = (message) => {
+    try {
+      options.log?.(message);
+    } catch {
+    }
+  };
   async function send(group, signal) {
     const first = group[0];
     const destination = options.destinations[first.kind];
@@ -2185,74 +2283,30 @@ function createDeliveryRunner(options) {
     let next = 0;
     return results.map((r) => r ?? sent[next++]);
   }
-  return {
-    async run(runOptions = {}) {
-      const report = {
-        claimed: 0,
-        sent: 0,
-        filtered: 0,
-        skipped: 0,
-        retrying: 0,
-        deferred: 0,
-        failed: 0,
-        stale: 0,
-        unrecorded: 0
-      };
-      const limit = runOptions.limit ?? options.batchSize ?? DEFAULT_BATCH_SIZE;
-      const claimed = await options.claim({ limit, filter: runOptions.filter });
-      report.claimed = claimed.length;
-      const groups = /* @__PURE__ */ new Map();
-      for (const delivery of claimed) {
-        const list = groups.get(delivery.destinationId) ?? [];
-        list.push(delivery);
-        groups.set(delivery.destinationId, list);
-      }
-      await Promise.all(
-        [...groups.values()].map(async (group) => {
-          const results = await send(group, runOptions.signal);
-          const at = now();
-          await Promise.all(
-            group.map(async (delivery, i) => {
-              const result = results[i];
-              const outcome = result === "filtered" ? { status: "filtered" } : deliveryOutcome(result, delivery.attempt, {
-                now: at,
-                maxAttempts: options.maxAttempts,
-                backoff: options.backoff,
-                deferrals: delivery.deferrals,
-                maxDeferrals: options.maxDeferrals
-              });
-              if (outcome.status === "sent" && result !== "filtered" && result.ok && result.skipped?.includes(delivery.submission.id)) {
-                outcome.alreadyThere = true;
-              }
-              if (outcome.status === "failed" || outcome.status === "retry") {
-                log(`Delivery ${delivery.id} (${delivery.kind}) ${outcome.status === "failed" ? "failed" : "will be retried"}: ${outcome.error}`);
-              } else if (outcome.status === "skipped") {
-                log(`Delivery ${delivery.id} (${delivery.kind}) skipped: ${outcome.reason}`);
-              }
-              let recorded;
-              try {
-                recorded = await options.record(delivery, outcome);
-              } catch {
-                report.unrecorded++;
-                log(`Recording delivery ${delivery.id} failed`);
-                return;
-              }
-              if (recorded === false) report.stale++;
-              else if (outcome.status === "sent") report.sent++;
-              else if (outcome.status === "filtered") report.filtered++;
-              else if (outcome.status === "skipped") report.skipped++;
-              else if (outcome.status === "failed") report.failed++;
-              else if (outcome.counted) report.retrying++;
-              else report.deferred++;
-            })
-          );
-        })
-      );
-      return report;
-    }
-  };
+  return createRunner({
+    claim: options.claim,
+    // One group per destination: a sheet gets one append for all its rows.
+    group: (delivery) => delivery.destinationId,
+    async send(group, { signal }) {
+      const results = await send(group, signal);
+      return results.map((result, i) => {
+        if (result === "filtered") return result;
+        if (!result.ok) return result;
+        return { ok: true, notSent: result.notSent, alreadyThere: result.skipped?.includes(group[i].submission.id) && !result.notSent };
+      });
+    },
+    record: options.record,
+    now: options.now,
+    log: options.log,
+    label: (delivery) => `Delivery ${delivery.id} (${delivery.kind})`,
+    recordLabel: (delivery) => `delivery ${delivery.id}`,
+    batchSize: options.batchSize,
+    maxAttempts: options.maxAttempts,
+    maxDeferrals: options.maxDeferrals,
+    backoff: options.backoff
+  });
 }
 
-export { DEDUPE_WINDOW, DEFAULT_BATCH_SIZE, DEFAULT_MAX_ATTEMPTS, DEFAULT_MAX_DEFERRALS, DEFAULT_SHEET_NAME, DRIVE_FILE_SCOPE, DeliveryError, GOOGLE_TOKEN_URL, HEADER_SCAN_ROWS, HookUrlError, MAX_CONDITION_DEPTH, MAX_HOOK_URL_LENGTH, MAX_RECIPIENTS, MIN_WEBHOOK_SECRET_BYTES, REQUEST_TIMEOUT_MS, RESEND_API, SENSITIVE_MASK, SHEETS_API, SHEETS_SCOPE, SLACK_HOSTS, SLACK_VALUE_LIMIT, answerCell, checkHookHost, checkWebhookUrl, clearGoogleOAuthTokenCache, clearGoogleTokenCache, columnLetter, conditionOf, createDeliveryRunner, defaultBackoff, deliveryFailure, deliveryOutcome, deriveSecretKey, emailBody, emailDestination, escapeFormula, escapeHtml, escapeSlack, googleAccessToken, googleOAuthAccessToken, headerSafe, hookHost, httpError, idempotencyKey, isCondition, isPrivateHost, isPublicAddress, isRetryableStatus, isSafeAddress, isSafeFrom, mergeHeader, newWebhookSecret, openSecret, parseHookUrl, passesCondition, refreshGoogleAccessToken, renderEmail, resendProvider, responseRow, retryAfterSeconds, rowFor, sealSecret, secretKeyBytes, sheetsDestination, signJwt, signWebhook, slackDestination, slackMessage, verifyWebhook, visibleInputs, webhookDestination, webhookPayload };
+export { DEDUPE_WINDOW, DEFAULT_BATCH_SIZE2 as DEFAULT_BATCH_SIZE, DEFAULT_MAX_ATTEMPTS2 as DEFAULT_MAX_ATTEMPTS, DEFAULT_MAX_DEFERRALS2 as DEFAULT_MAX_DEFERRALS, DEFAULT_SHEET_NAME, DRIVE_FILE_SCOPE, DeliveryError, GOOGLE_TOKEN_URL, HEADER_SCAN_ROWS, HookUrlError, MAX_CONDITION_DEPTH, MAX_HOOK_URL_LENGTH, MAX_RECIPIENTS, MIN_WEBHOOK_SECRET_BYTES, REQUEST_TIMEOUT_MS, RESEND_API, SENSITIVE_MASK, SHEETS_API, SHEETS_SCOPE, SLACK_HOSTS, SLACK_VALUE_LIMIT, answerCell, checkHookHost, checkWebhookUrl, clearGoogleOAuthTokenCache, clearGoogleTokenCache, columnLetter, conditionOf, createDeliveryRunner, defaultBackoff2 as defaultBackoff, deliveryFailure, deliveryOutcome, deriveSecretKey, emailBody, emailDestination, escapeFormula, escapeHtml, escapeSlack, googleAccessToken, googleOAuthAccessToken, headerSafe, hookHost, httpError, idempotencyKey, isCondition, isPrivateHost, isPublicAddress, isRetryableStatus, isSafeAddress, isSafeFrom, mergeHeader, newWebhookSecret, openSecret, parseHookUrl, passesCondition, refreshGoogleAccessToken, renderEmail, resendProvider, responseRow, retryAfterSeconds, rowFor, sealSecret, secretKeyBytes, sheetsDestination, signJwt, signWebhook, slackDestination, slackMessage, verifyWebhook, visibleInputs, webhookDestination, webhookPayload };
 //# sourceMappingURL=destinations.js.map
 //# sourceMappingURL=destinations.js.map