@teleporthq/teleport-plugin-next-workflows 0.44.11 → 0.45.0

package/dist/esm/automations/dispatcher-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatcher-source.js","sourceRoot":"","sources":["../../../src/automations/dispatcher-source.ts"],"names":[],"mappings":"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"}

package/dist/esm/automations/event-bus-source.d.ts

@@ -0,0 +1,44 @@
+/** Where the dispatch route remembers the signed requests it took (see `takeSignedRequest`). */
+export declare const SIGNED_REQUESTS_TABLE = "teleport_automation_requests";
+/** The ledger row every emitter writes; a replayed dedupe key writes nothing. */
+export declare const INSERT_EVENT_SQL: string;
+/**
+ * `lib/automations/store.js`: one connection per call (`withClient`), with
+ * every statement bounded in time so a stuck database cannot hold the queue;
+ * the Wait writer; the signed requests the dispatch route has taken (each
+ * once, `takeSignedRequest`); where and with which credentials the app calls
+ * itself;
+ * and the small value helpers the dispatcher and the hydrators share. The
+ * database is the TeleportHQ one (`TELEPORT_DB_*`, the data API's client):
+ * the only one automations run on (v1).
+ */
+export declare const generateAutomationStoreCode: () => string;
+/**
+ * `lib/automations/wait-until.js`: on Vercel, the platform's `waitUntil`
+ * (`@vercel/functions`, a dependency of every project with automations),
+ * published as `globalThis.__tqWaitUntil` unless the app set one of its own.
+ * Anywhere else it is null and the bus calls its own dispatch route: a
+ * `waitUntil` that is not the host's would keep nothing alive.
+ */
+export declare const generateAutomationWaitUntilCode: () => string;
+/**
+ * `lib/automations/event-bus.js`:
+ *
+ * - `emitBusinessEvent({ type, entityType, entityId, orderId?, payload,
+ *   actor, actorType, dedupeKey }, req?)` writes the `teleport_events` row (a
+ *   replayed dedupe key writes nothing) and, for a new row, schedules the
+ *   queue. `req` is the request being served, when there is one: a local
+ *   server's own address is read from it (see `appBaseUrl` in store.js; never
+ *   a URL a caller hands in). Never throws: it resolves `{ recorded, id }`.
+ * - `scheduleDispatch(req?)` runs `dispatch()` off the request path: on
+ *   Vercel inside its `waitUntil`, elsewhere through a non-awaited call to
+ *   the app's own dispatch route. The visitor's request never waits for a
+ *   handler.
+ * - `runTestEvent({ workflowId, event }, req)` runs one automation once for
+ *   the editor's "send a test" (see the dispatcher).
+ * - `takeSignedRequest(key, expiresAt)` resolves true the first time the
+ *   dispatch route takes a signed request, false for the same request again.
+ * - `dispatch({ req })` is the queue worker (./dispatcher.js).
+ */
+export declare const generateAutomationEventBusCode: () => string;
+//# sourceMappingURL=event-bus-source.d.ts.map

package/dist/esm/automations/event-bus-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-bus-source.d.ts","sourceRoot":"","sources":["../../../src/automations/event-bus-source.ts"],"names":[],"mappings":"AAcA,gGAAgG;AAChG,eAAO,MAAM,qBAAqB,iCAAiC,CAAA;AAEnE,iFAAiF;AACjF,eAAO,MAAM,gBAAgB,QAA4I,CAAA;AAEzK;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B,QAAO,MA8P9C,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B,QAAO,MAoBlD,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,8BAA8B,QAAO,MA6FjD,CAAA"}

package/dist/esm/automations/event-bus-source.js

@@ -0,0 +1,421 @@
+import { generateLazyPgClientCode } from '../pg-client-code';
+import { AUTOMATIONS_DISPATCH_URL } from './automations-scope';
+import { generateSelfCallHeadersCode } from '../self-call-headers';
+/**
+ * The automations' shared runtime: the database access (`store.js`), the
+ * platform's `waitUntil` (`wait-until.js`) and the event bus
+ * (`event-bus.js`). All three live in `lib/automations/` and are generated
+ * only for a project with at least one automation.
+ */
+const EVENT_COLUMNS = 'event_type, dedupe_key, order_id, entity_type, entity_id, payload, actor, actor_type';
+/** Where the dispatch route remembers the signed requests it took (see `takeSignedRequest`). */
+export const SIGNED_REQUESTS_TABLE = 'teleport_automation_requests';
+/** The ledger row every emitter writes; a replayed dedupe key writes nothing. */
+export const INSERT_EVENT_SQL = `INSERT INTO teleport_events (${EVENT_COLUMNS}) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) ON CONFLICT (dedupe_key) DO NOTHING RETURNING id`;
+/**
+ * `lib/automations/store.js`: one connection per call (`withClient`), with
+ * every statement bounded in time so a stuck database cannot hold the queue;
+ * the Wait writer; the signed requests the dispatch route has taken (each
+ * once, `takeSignedRequest`); where and with which credentials the app calls
+ * itself;
+ * and the small value helpers the dispatcher and the hydrators share. The
+ * database is the TeleportHQ one (`TELEPORT_DB_*`, the data API's client):
+ * the only one automations run on (v1).
+ */
+export const generateAutomationStoreCode = () => `'use strict';
+/**
+ * Automations: database access and shared helpers (generated).
+ */
+${generateLazyPgClientCode()}
+
+var QUERY_TIMEOUT_MS = 15000;
+
+var SAVE_WAIT_SQL = 'INSERT INTO teleport_automation_waits (event_id, workflow_id, resume_node_id, context, run_at, status) ' +
+  "VALUES ($1, $2, $3, $4, $5, 'waiting')";
+
+// What a table the project does not have, or a column it never gained, fails
+// with: the record then reads as missing. Every other error is real.
+var MISSING_RELATION_CODES = ['42P01', '42703'];
+
+function errorMessage(error) {
+  return error && error.message ? String(error.message) : String(error);
+}
+
+function withTimeout(promise, ms, what) {
+  var timer;
+  var timeout = new Promise(function (_resolve, reject) {
+    timer = setTimeout(function () { reject(new Error('[automations] ' + what + ' timed out after ' + ms + 'ms')); }, ms);
+  });
+  return Promise.race([promise, timeout]).then(
+    function (value) { clearTimeout(timer); return value; },
+    function (error) { clearTimeout(timer); throw error; }
+  );
+}
+
+// Runs fn(client) on a connection of its own, closed afterwards.
+async function withClient(fn) {
+  if (!process.env.TELEPORT_DB_CONNECTION_STRING && !process.env.TELEPORT_DB_HOST) {
+    throw new Error('[automations] no database is configured (TELEPORT_DB_CONNECTION_STRING)');
+  }
+  if (!__loadPg()) {
+    throw new Error('[automations] the pg driver is not installed');
+  }
+  var raw = getClient();
+  var client = {
+    query: function (sql, values) {
+      return withTimeout(raw.query(sql, values), QUERY_TIMEOUT_MS, 'a query');
+    },
+  };
+  try {
+    await withTimeout(raw.connect(), QUERY_TIMEOUT_MS, 'connecting to the database');
+    return await fn(client);
+  } finally {
+    try { await raw.end(); } catch (_e) {}
+  }
+}
+
+// Stores a run parked at a Wait (see the general-wait node).
+async function saveWait(wait) {
+  await withClient(function (client) {
+    return client.query(SAVE_WAIT_SQL, [wait.eventId, wait.workflowId, wait.resumeNodeId, wait.context, wait.runAt]);
+  });
+}
+
+// The signed requests the dispatch route has taken, each kept until its
+// signature can no longer verify: the same request again is refused. The
+// table (and its expiry index) is made on first use, two instances taking
+// turns under the lock. The rows that are over are deleted at most once per
+// instance every SIGNED_REQUESTS_CLEANUP_MS, a bounded batch at a time.
+var SIGNED_REQUESTS_TABLE = '${SIGNED_REQUESTS_TABLE}';
+var LOCK_SIGNED_REQUESTS_SQL = 'SELECT pg_advisory_xact_lock(hashtext($1))';
+var CREATE_SIGNED_REQUESTS_SQL = 'CREATE TABLE IF NOT EXISTS ' + SIGNED_REQUESTS_TABLE +
+  ' (request_key TEXT PRIMARY KEY, expires_at BIGINT NOT NULL)';
+var INDEX_SIGNED_REQUESTS_SQL = 'CREATE INDEX IF NOT EXISTS ' + SIGNED_REQUESTS_TABLE + '_expires_at ON ' +
+  SIGNED_REQUESTS_TABLE + ' (expires_at)';
+var FORGET_SIGNED_REQUESTS_SQL = 'DELETE FROM ' + SIGNED_REQUESTS_TABLE + ' WHERE request_key IN (SELECT request_key FROM ' +
+  SIGNED_REQUESTS_TABLE + ' WHERE expires_at < $1 LIMIT 1000)';
+var TAKE_SIGNED_REQUEST_SQL = 'INSERT INTO ' + SIGNED_REQUESTS_TABLE + ' (request_key, expires_at) VALUES ($1, $2) ' +
+  'ON CONFLICT (request_key) DO NOTHING RETURNING request_key';
+var SIGNED_REQUESTS_CLEANUP_MS = 600000;
+var __signedRequestsReady = false;
+var __signedRequestsCleanedAt = 0;
+
+// true the first time a signed request (its key) is taken, false every time
+// after while it is kept (until expiresAt, unix seconds). Throws when the
+// database cannot say: the route then refuses.
+async function takeSignedRequest(key, expiresAt) {
+  return withClient(async function (client) {
+    if (!__signedRequestsReady) {
+      await client.query('BEGIN');
+      try {
+        await client.query(LOCK_SIGNED_REQUESTS_SQL, [SIGNED_REQUESTS_TABLE]);
+        await client.query(CREATE_SIGNED_REQUESTS_SQL);
+        await client.query(INDEX_SIGNED_REQUESTS_SQL);
+        await client.query('COMMIT');
+      } catch (error) {
+        try { await client.query('ROLLBACK'); } catch (_e) {}
+        throw error;
+      }
+      __signedRequestsReady = true;
+    }
+    var nowMs = Date.now();
+    if (nowMs - __signedRequestsCleanedAt >= SIGNED_REQUESTS_CLEANUP_MS) {
+      __signedRequestsCleanedAt = nowMs;
+      await client.query(FORGET_SIGNED_REQUESTS_SQL, [Math.floor(nowMs / 1000)]);
+    }
+    var taken = await client.query(TAKE_SIGNED_REQUEST_SQL, [key, expiresAt]);
+    return !!(taken && taken.rows && taken.rows[0]);
+  });
+}
+
+function isLoopbackHost(host) {
+  var name = String(host || '').replace(/:[0-9]+$/, '').toLowerCase();
+  return name === 'localhost' || name === '127.0.0.1' || name === '[::1]' || name === '0.0.0.0';
+}
+
+// The origin of an absolute http(s) URL, or of a bare host ("shop.com", as
+// Vercel's own variables hold it, taken as https); '' for anything else.
+function originOf(value, bareHostScheme) {
+  var text = typeof value === 'string' ? value.trim() : '';
+  if (!text) return '';
+  if (!/^https?:[/][/]/i.test(text)) {
+    if (!bareHostScheme || text.indexOf('/') !== -1) return '';
+    text = bareHostScheme + '://' + text;
+  }
+  try { return new URL(text).origin; } catch (_e) { return ''; }
+}
+
+// NEXTAUTH_URL as the deployment configured it. The auth route rewrites
+// process.env.NEXTAUTH_URL on every request (to the request's own origin when
+// the configured one is local or unset), after keeping the configured value
+// on globalThis.__tqConfiguredNextAuthUrl, once per process: that value is
+// read here, never the rewritten one. Kept the same way (and by the same rule:
+// a placeholder or anything but an http(s) URL is unset) when this module
+// reads it first.
+function configuredNextAuthUrl() {
+  var scope = globalThis;
+  if (typeof scope.__tqConfiguredNextAuthUrl !== 'string') {
+    var raw = process.env.NEXTAUTH_URL;
+    var usable = typeof raw === 'string' && raw.indexOf('teleporthq.secrets.') !== 0 && /^https?:[/][/]/i.test(raw);
+    scope.__tqConfiguredNextAuthUrl = usable ? raw : '';
+  }
+  return scope.__tqConfiguredNextAuthUrl;
+}
+
+// The site's address when one is configured: NEXTAUTH_URL naming a real
+// (non-local) origin. The generated default (http://localhost:3000) counts as
+// unset.
+function configuredSiteOrigin() {
+  var origin = originOf(configuredNextAuthUrl());
+  return origin && !isLoopbackHost(new URL(origin).host) ? origin : '';
+}
+
+function firstValue(value) {
+  return String(Array.isArray(value) ? value[0] : value || '').split(',')[0].trim();
+}
+
+// The app's own origin, where it calls its own routes with the app secret:
+// - the configured site address (a real NEXTAUTH_URL), whatever a request says;
+// - on Vercel, the origin the request reached (Vercel routes only this
+//   deployment's domains to it), else the production domain, else the
+//   deployment's own URL;
+// - anywhere else a request's Host is whatever its caller sent: it is used
+//   only when it names this machine (a local server, which keeps its own
+//   port), never to send the secret to a host a caller picked.
+function appBaseUrl(req) {
+  var configured = configuredSiteOrigin();
+  if (configured) return configured;
+  var headers = (req && req.headers) || {};
+  var host = firstValue(headers.host);
+  var proto = firstValue(headers['x-forwarded-proto']);
+  if (process.env.VERCEL) {
+    if (host) {
+      var reached = originOf((proto || (isLoopbackHost(host) ? 'http' : 'https')) + '://' + host);
+      if (reached) return reached;
+    }
+    var deployed =
+      originOf(process.env.VERCEL_PROJECT_PRODUCTION_URL, 'https') || originOf(process.env.VERCEL_URL, 'https');
+    if (deployed) return deployed;
+  }
+  if (host && isLoopbackHost(host)) {
+    return (proto === 'https' ? 'https' : 'http') + '://' + host;
+  }
+  return 'http://localhost:' + (process.env.PORT || '3000');
+}
+
+${generateSelfCallHeadersCode()}
+
+// What the app presents to its own routes: the app secret, and the Vercel
+// deployment-protection bypass where one is set.
+function internalHeaders() {
+  return __selfCallHeaders({ 'Content-Type': 'application/json' });
+}
+
+function isPlainObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date);
+}
+
+// JSON columns are TEXT (see teleport_events.payload): parsed, or null.
+function parseJson(value) {
+  if (isPlainObject(value) || Array.isArray(value)) return value;
+  if (typeof value !== 'string' || !value) return null;
+  try { return JSON.parse(value); } catch (_e) { return null; }
+}
+
+function toNumber(value) {
+  if (value === null || value === undefined || value === '') return null;
+  var n = Number(value);
+  return isFinite(n) ? n : null;
+}
+
+function toIso(value) {
+  if (value === null || value === undefined || value === '') return null;
+  var date = value instanceof Date ? value : new Date(value);
+  return isNaN(date.getTime()) ? null : date.toISOString();
+}
+
+function toText(value) {
+  return value === null || value === undefined || value === '' ? null : String(value);
+}
+
+function isMissingRelation(error) {
+  return !!error && MISSING_RELATION_CODES.indexOf(error.code) !== -1;
+}
+
+// The first row a statement returns, or null. A table or column the project
+// lacks also reads as no row; any other failure is thrown, so the event is
+// retried instead of being delivered without its record.
+async function firstRow(client, sql, values) {
+  var rows = await allRows(client, sql, values);
+  return rows[0] || null;
+}
+
+async function allRows(client, sql, values) {
+  try {
+    var result = await client.query(sql, values);
+    return (result && result.rows) || [];
+  } catch (error) {
+    if (!isMissingRelation(error)) throw error;
+    console.warn('[automations] ' + errorMessage(error));
+    return [];
+  }
+}
+
+module.exports = {
+  firstRow: firstRow,
+  allRows: allRows,
+  withClient: withClient,
+  saveWait: saveWait,
+  takeSignedRequest: takeSignedRequest,
+  appBaseUrl: appBaseUrl,
+  internalHeaders: internalHeaders,
+  errorMessage: errorMessage,
+  isPlainObject: isPlainObject,
+  parseJson: parseJson,
+  toNumber: toNumber,
+  toIso: toIso,
+  toText: toText,
+};
+`;
+/**
+ * `lib/automations/wait-until.js`: on Vercel, the platform's `waitUntil`
+ * (`@vercel/functions`, a dependency of every project with automations),
+ * published as `globalThis.__tqWaitUntil` unless the app set one of its own.
+ * Anywhere else it is null and the bus calls its own dispatch route: a
+ * `waitUntil` that is not the host's would keep nothing alive.
+ */
+export const generateAutomationWaitUntilCode = () => `'use strict';
+/**
+ * Automations: the platform's waitUntil, on Vercel (generated).
+ */
+var waitUntil = null;
+if (process.env.VERCEL) {
+  try {
+    var vercelFunctions = require('@vercel/functions');
+    if (vercelFunctions && typeof vercelFunctions.waitUntil === 'function') {
+      waitUntil = vercelFunctions.waitUntil;
+    }
+  } catch (_e) {
+    waitUntil = null;
+  }
+}
+if (waitUntil && typeof globalThis.__tqWaitUntil !== 'function') {
+  globalThis.__tqWaitUntil = waitUntil;
+}
+
+module.exports = { waitUntil: waitUntil };
+`;
+/**
+ * `lib/automations/event-bus.js`:
+ *
+ * - `emitBusinessEvent({ type, entityType, entityId, orderId?, payload,
+ *   actor, actorType, dedupeKey }, req?)` writes the `teleport_events` row (a
+ *   replayed dedupe key writes nothing) and, for a new row, schedules the
+ *   queue. `req` is the request being served, when there is one: a local
+ *   server's own address is read from it (see `appBaseUrl` in store.js; never
+ *   a URL a caller hands in). Never throws: it resolves `{ recorded, id }`.
+ * - `scheduleDispatch(req?)` runs `dispatch()` off the request path: on
+ *   Vercel inside its `waitUntil`, elsewhere through a non-awaited call to
+ *   the app's own dispatch route. The visitor's request never waits for a
+ *   handler.
+ * - `runTestEvent({ workflowId, event }, req)` runs one automation once for
+ *   the editor's "send a test" (see the dispatcher).
+ * - `takeSignedRequest(key, expiresAt)` resolves true the first time the
+ *   dispatch route takes a signed request, false for the same request again.
+ * - `dispatch({ req })` is the queue worker (./dispatcher.js).
+ */
+export const generateAutomationEventBusCode = () => `'use strict';
+/**
+ * Automations: the in-app event bus (generated).
+ */
+if (typeof globalThis.fetch === 'undefined') {
+  globalThis.fetch = require('node-fetch');
+}
+var crypto = require('crypto');
+var store = require('./store');
+require('./wait-until');
+
+var DISPATCH_PATH = '${AUTOMATIONS_DISPATCH_URL}';
+var INSERT_EVENT_SQL = '${INSERT_EVENT_SQL}';
+
+function column(value, maxLength) {
+  if (value === undefined || value === null || value === '') return null;
+  return String(value).slice(0, maxLength);
+}
+
+function eventValues(input) {
+  var type = column(input.type, 100);
+  if (!type) throw new Error('An event needs its type');
+  var payload = input.payload !== undefined ? input.payload : input.details;
+  return [
+    type,
+    column(input.dedupeKey, 255) || type + ':' + crypto.randomUUID(),
+    column(input.orderId, 64),
+    column(input.entityType, 40),
+    column(input.entityId, 64),
+    payload === undefined || payload === null ? null : JSON.stringify(payload),
+    column(input.actor, 255),
+    column(input.actorType, 50) || 'system',
+  ];
+}
+
+async function emitBusinessEvent(input, req) {
+  var event = input || {};
+  try {
+    var values = eventValues(event);
+    var result = await store.withClient(function (client) {
+      return client.query(INSERT_EVENT_SQL, values);
+    });
+    var row = result && result.rows && result.rows[0];
+    if (!row) return { recorded: false, id: null };
+    scheduleDispatch(req);
+    return { recorded: true, id: String(row.id) };
+  } catch (error) {
+    console.error('[automations] could not record the ' + String(event.type) + ' event: ' + store.errorMessage(error));
+    return { recorded: false, id: null };
+  }
+}
+
+function scheduleDispatch(req) {
+  var waitUntil = process.env.VERCEL && typeof globalThis.__tqWaitUntil === 'function' ? globalThis.__tqWaitUntil : null;
+  if (waitUntil) {
+    try {
+      waitUntil(dispatch({ req: req }).catch(function (error) {
+        console.error('[automations] dispatch failed: ' + store.errorMessage(error));
+      }));
+      return 'wait-until';
+    } catch (_e) {}
+  }
+  try {
+    globalThis.fetch(store.appBaseUrl(req) + DISPATCH_PATH, {
+      method: 'POST',
+      headers: store.internalHeaders(),
+      body: '{}',
+    }).catch(function () {});
+    return 'fetch';
+  } catch (_e) {
+    return 'none';
+  }
+}
+
+function dispatch(options) {
+  return require('./dispatcher').dispatch(options);
+}
+
+function runTestEvent(input, req) {
+  return require('./dispatcher').runTest(input, { req: req });
+}
+
+function takeSignedRequest(key, expiresAt) {
+  return store.takeSignedRequest(key, expiresAt);
+}
+
+module.exports = {
+  emitBusinessEvent: emitBusinessEvent,
+  scheduleDispatch: scheduleDispatch,
+  dispatch: dispatch,
+  runTestEvent: runTestEvent,
+  takeSignedRequest: takeSignedRequest,
+};
+`;
+//# sourceMappingURL=event-bus-source.js.map

package/dist/esm/automations/event-bus-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-bus-source.js","sourceRoot":"","sources":["../../../src/automations/event-bus-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAA;AAC5D,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAA;AAC9D,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAA;AAElE;;;;;GAKG;AAEH,MAAM,aAAa,GACjB,sFAAsF,CAAA;AAExF,gGAAgG;AAChG,MAAM,CAAC,MAAM,qBAAqB,GAAG,8BAA8B,CAAA;AAEnE,iFAAiF;AACjF,MAAM,CAAC,MAAM,gBAAgB,GAAG,gCAAgC,aAAa,4FAA4F,CAAA;AAEzK;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,GAAW,EAAE,CAAC;;;;EAIvD,wBAAwB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BA4DG,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqHlD,2BAA2B,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyE9B,CAAA;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,GAAW,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;CAoB5D,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,GAAW,EAAE,CAAC;;;;;;;;;;;uBAWrC,wBAAwB;0BACrB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiFzC,CAAA"}

package/dist/esm/automations/handler-module-generator.d.ts

@@ -0,0 +1,25 @@
+import type { UIDLCustomWorkflowNode, UIDLWorkflow } from '@teleporthq/teleport-types';
+/**
+ * One handler module per automation (`lib/automations/handlers/<file>.js`,
+ * exporting `run(event, context, resumeFrom)`, see generateHandlerFunction)
+ * and the registry the dispatcher reads them from.
+ */
+export interface AutomationRegistryEntry {
+    eventType: string;
+    workflowId: string;
+    name: string;
+    fileName: string;
+}
+/**
+ * `<slug of the name>-<first 8 of the id>`, unique within the project: a
+ * name taken already gets the whole id, then a counter.
+ */
+export declare const resolveAutomationHandlerFileNames: (workflows: UIDLWorkflow[]) => Map<string, string>;
+export declare const generateAutomationHandlerModule: (workflow: UIDLWorkflow, customNodes?: Record<string, UIDLCustomWorkflowNode>) => string;
+export declare const toRegistryEntry: (workflow: UIDLWorkflow, fileName: string) => AutomationRegistryEntry;
+/**
+ * `lib/automations/registry.js`: `{ '<event-type>': [{ workflowId, name, run }] }`,
+ * in the order the workflows are listed.
+ */
+export declare const generateAutomationRegistryCode: (entries: AutomationRegistryEntry[]) => string;
+//# sourceMappingURL=handler-module-generator.d.ts.map

package/dist/esm/automations/handler-module-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler-module-generator.d.ts","sourceRoot":"","sources":["../../../src/automations/handler-module-generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAKtF;;;;GAIG;AAEH,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;CACjB;AAUD;;;GAGG;AACH,eAAO,MAAM,iCAAiC,cACjC,YAAY,EAAE,KACxB,IAAI,MAAM,EAAE,MAAM,CAoBpB,CAAA;AAED,eAAO,MAAM,+BAA+B,aAChC,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,KACnD,MAOF,CAAA;AAED,eAAO,MAAM,eAAe,aAChB,YAAY,YACZ,MAAM,KACf,uBAKD,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,8BAA8B,YAAa,uBAAuB,EAAE,KAAG,MA0BnF,CAAA"}

package/dist/esm/automations/handler-module-generator.js

@@ -0,0 +1,71 @@
+import { generateHandlerFunction } from '../api-route-generator';
+import { escapeSlackMessageBindings } from '../slack-message-values';
+import { automationEventType } from './automations-scope';
+const slugOf = (value) => value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 50)
+    .replace(/-+$/g, '');
+/**
+ * `<slug of the name>-<first 8 of the id>`, unique within the project: a
+ * name taken already gets the whole id, then a counter.
+ */
+export const resolveAutomationHandlerFileNames = (workflows) => {
+    const taken = new Set();
+    const names = new Map();
+    for (const workflow of workflows) {
+        const nameSlug = slugOf(workflow.name || '');
+        const idSlug = slugOf(workflow.id);
+        const join = (idPart) => [nameSlug, idPart].filter(Boolean).join('-').replace(/-+$/g, '') || 'automation';
+        let fileName = join(idSlug.slice(0, 8));
+        if (taken.has(fileName)) {
+            fileName = join(idSlug);
+        }
+        const base = fileName;
+        for (let counter = 2; taken.has(fileName); counter++) {
+            fileName = `${base}-${counter}`;
+        }
+        taken.add(fileName);
+        names.set(workflow.id, fileName);
+    }
+    return names;
+};
+export const generateAutomationHandlerModule = (workflow, customNodes) => {
+    const nodes = workflow.nodes || [];
+    const escaped = escapeSlackMessageBindings(nodes);
+    return generateHandlerFunction(escaped === nodes ? workflow : Object.assign(Object.assign({}, workflow), { nodes: escaped }), customNodes);
+};
+export const toRegistryEntry = (workflow, fileName) => ({
+    eventType: automationEventType(workflow),
+    workflowId: workflow.id,
+    name: workflow.name || workflow.id,
+    fileName,
+});
+/**
+ * `lib/automations/registry.js`: `{ '<event-type>': [{ workflowId, name, run }] }`,
+ * in the order the workflows are listed.
+ */
+export const generateAutomationRegistryCode = (entries) => {
+    const byType = new Map();
+    for (const entry of entries) {
+        const list = byType.get(entry.eventType) || [];
+        list.push(entry);
+        byType.set(entry.eventType, list);
+    }
+    const blocks = Array.from(byType.entries()).map(([eventType, list]) => {
+        const lines = list.map((entry) => `    { workflowId: ${JSON.stringify(entry.workflowId)}, name: ${JSON.stringify(entry.name)}, run: require('./handlers/${entry.fileName}.js').run },`);
+        return `  ${JSON.stringify(eventType)}: [\n${lines.join('\n')}\n  ],`;
+    });
+    return `'use strict';
+/**
+ * The project's automations by the event they react to (generated). The
+ * dispatcher (./dispatcher.js) runs the handlers of an event's type that are
+ * switched on in teleport_automations.
+ */
+module.exports = {
+${blocks.join('\n')}
+};
+`;
+};
+//# sourceMappingURL=handler-module-generator.js.map

package/dist/esm/automations/handler-module-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler-module-generator.js","sourceRoot":"","sources":["../../../src/automations/handler-module-generator.ts"],"names":[],"mappings":"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"}

package/dist/esm/automations/hydrators-source.d.ts

@@ -0,0 +1,33 @@
+/**
+ * `lib/automations/hydrate/<entity>.js`: the record an event is about, read
+ * from the database when the event is delivered, in the shape of the
+ * business-event catalog's details (teleport-gui
+ * `packages/workflow-schema/src/constants/business-events.ts`). Every module
+ * exports `hydrate(client, row, payload, context)` (`context.baseUrl`: the
+ * app's origin, for links), which resolves the envelope blocks
+ * it read (`{ order }`, `{ giftCards, order }`, …).
+ *
+ * The record is the truth: the dispatcher lays the hydrated block OVER the
+ * payload (a ledger row can be written by a caller, the record cannot), and
+ * an event whose record is not there (a deleted row, a forged id, a table the
+ * project lacks) is refused — "No such <entity>", no automation runs. A module
+ * therefore returns no entity block when it finds no record. Any other failed
+ * read throws, and the event is retried.
+ *
+ * Credentials and codes never leave the tables: every block names its
+ * fields. A form submission has no row of its own (its block is the
+ * submission, recorded whole), so `form` has no module.
+ */
+export interface HydratorOptions {
+    /** The auth users table (`resolveAuthUsersTableName`), for the user block. */
+    usersTable: string;
+    /**
+     * Where the order details page is served (`/orders`, its `[order_number]`
+     * slot dropped), for `order.pageUrl`; null when the project has no order
+     * details page, and the link is then left out.
+     */
+    orderPagePrefix: string | null;
+}
+/** The module source for `entity`, or null when it has no table to read. */
+export declare const generateAutomationHydratorCode: (entity: string, options: HydratorOptions) => string | null;
+//# sourceMappingURL=hydrators-source.d.ts.map

package/dist/esm/automations/hydrators-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydrators-source.d.ts","sourceRoot":"","sources":["../../../src/automations/hydrators-source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,WAAW,eAAe;IAC9B,8EAA8E;IAC9E,UAAU,EAAE,MAAM,CAAA;IAClB;;;;OAIG;IACH,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B;AAimBD,4EAA4E;AAC5E,eAAO,MAAM,8BAA8B,WACjC,MAAM,WACL,eAAe,KACvB,MAAM,GAAG,IAGX,CAAA"}