@bpmnkit/proxy 0.0.17 → 0.0.21

package/dist/triggers/timer.js

@@ -0,0 +1,239 @@
+/**
+ * Timer trigger — scans deployed processes for BPMN timer start events and
+ * fires `POST /v2/process-instances` at the appropriate times.
+ *
+ * Supports:
+ *   timeDuration  ISO 8601 duration  (PT1H → repeat every 1 hour)
+ *   timeDate      ISO 8601 datetime  (2026-01-01T00:00:00Z → fire once)
+ *   timeCycle     ISO 8601 repeating (R/PT30M or R3/PT1H → repeat N or ∞ times)
+ *
+ * Last-fired timestamps are persisted to `~/.bpmnkit/timer-state.json` to
+ * survive proxy restarts.
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getActiveProfile, getAuthHeader } from "@bpmnkit/profiles";
+// ── Persistence ───────────────────────────────────────────────────────────────
+const STATE_PATH = join(homedir(), ".bpmnkit", "timer-state.json");
+function loadState() {
+    try {
+        if (existsSync(STATE_PATH)) {
+            return JSON.parse(readFileSync(STATE_PATH, "utf8"));
+        }
+    }
+    catch {
+        // corrupt file — start fresh
+    }
+    return { lastFired: {} };
+}
+function saveState(state) {
+    try {
+        writeFileSync(STATE_PATH, JSON.stringify(state, null, 2), "utf8");
+    }
+    catch {
+        // best-effort
+    }
+}
+// ── ISO 8601 duration parser ──────────────────────────────────────────────────
+const DURATION_RE = /^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;
+function parseDurationMs(iso) {
+    const m = DURATION_RE.exec(iso);
+    if (!m)
+        return null;
+    const years = Number(m[1] ?? 0);
+    const months = Number(m[2] ?? 0);
+    const days = Number(m[3] ?? 0);
+    const hours = Number(m[4] ?? 0);
+    const minutes = Number(m[5] ?? 0);
+    const seconds = Number(m[6] ?? 0);
+    // Approximate: 1 year = 365 days, 1 month = 30 days
+    return ((years * 365 * 24 * 60 * 60 +
+        months * 30 * 24 * 60 * 60 +
+        days * 24 * 60 * 60 +
+        hours * 60 * 60 +
+        minutes * 60 +
+        seconds) *
+        1000);
+}
+/**
+ * Parse an ISO 8601 repeating interval: `R<n>/<duration>` or `R/<duration>`.
+ * Returns { durationMs, remaining } where remaining=undefined means infinite.
+ */
+function parseCycle(value) {
+    const m = /^R(\d*)\/(.+)$/.exec(value);
+    if (!m)
+        return null;
+    const durationMs = parseDurationMs(m[2] ?? "");
+    if (!durationMs)
+        return null;
+    const n = m[1] ? Number(m[1]) : undefined;
+    return { durationMs, remaining: n };
+}
+async function fetchDeployedProcesses(baseUrl, authHeader) {
+    const res = await fetch(`${baseUrl}/v2/process-definitions/search`, {
+        method: "POST",
+        headers: { authorization: authHeader, "content-type": "application/json" },
+        body: JSON.stringify({ pageSize: 100 }),
+    });
+    if (!res.ok)
+        return [];
+    const data = (await res.json());
+    return data.items ?? [];
+}
+async function fetchProcessXml(baseUrl, authHeader, processId) {
+    const res = await fetch(`${baseUrl}/v2/process-definitions/${encodeURIComponent(processId)}/xml`, {
+        headers: { authorization: authHeader },
+    });
+    if (!res.ok)
+        return null;
+    const data = (await res.json());
+    return data.bpmnXml ?? null;
+}
+/** Extract timer start event definitions from BPMN XML (simple regex approach). */
+function extractTimerDefs(processId, xml) {
+    const defs = [];
+    // Match <timerEventDefinition> children: timeDuration, timeDate, timeCycle
+    const timerRe = /<timerEventDefinition[^>]*>[\s\S]*?<(timeDuration|timeDate|timeCycle)[^>]*>\s*([^<]+)\s*<\/\1>/g;
+    let m;
+    // biome-ignore lint/suspicious/noAssignInExpressions: standard regex loop
+    while ((m = timerRe.exec(xml)) !== null) {
+        const kind = m[1];
+        const raw = m[2]?.trim() ?? "";
+        // Strip FEEL expression wrapper if present (e.g. = "PT1H" or = PT1H)
+        const value = raw
+            .replace(/^=\s*["']?/, "")
+            .replace(/["']$/, "")
+            .trim();
+        if (!value)
+            continue;
+        if (kind === "timeDuration") {
+            defs.push({ processId, type: "duration", value });
+        }
+        else if (kind === "timeDate") {
+            defs.push({ processId, type: "date", value });
+        }
+        else {
+            const cycle = parseCycle(value);
+            if (cycle) {
+                defs.push({ processId, type: "cycle", value, remaining: cycle.remaining });
+            }
+        }
+    }
+    return defs;
+}
+// ── Firing ────────────────────────────────────────────────────────────────────
+async function fireProcess(baseUrl, authHeader, processId) {
+    const res = await fetch(`${baseUrl}/v2/process-instances`, {
+        method: "POST",
+        headers: { authorization: authHeader, "content-type": "application/json" },
+        body: JSON.stringify({ processDefinitionId: processId, variables: {} }),
+    });
+    if (res.ok) {
+        const data = (await res.json());
+        console.log(`[trigger:timer] fired ${processId} → instance ${data.processInstanceKey ?? "?"}`);
+    }
+    else {
+        console.error(`[trigger:timer] failed to start ${processId}: ${res.status}`);
+    }
+}
+// ── Scheduler ─────────────────────────────────────────────────────────────────
+let timerDefs = [];
+const timerState = loadState();
+async function scanAndSchedule() {
+    const profile = getActiveProfile();
+    if (!profile?.config.baseUrl)
+        return;
+    const baseUrl = profile.config.baseUrl.replace(/\/$/, "");
+    if (!baseUrl.startsWith("http"))
+        return;
+    let authHeader = "";
+    try {
+        authHeader = await getAuthHeader(profile.config);
+    }
+    catch {
+        // proceed unauthenticated
+    }
+    let processes;
+    try {
+        processes = await fetchDeployedProcesses(baseUrl, authHeader);
+    }
+    catch {
+        return;
+    }
+    const defs = [];
+    for (const proc of processes) {
+        const xml = await fetchProcessXml(baseUrl, authHeader, proc.processDefinitionId);
+        if (xml) {
+            defs.push(...extractTimerDefs(proc.processDefinitionId, xml));
+        }
+    }
+    timerDefs = defs;
+    if (defs.length > 0) {
+        console.log(`[trigger:timer] tracking ${defs.length} timer(s)`);
+    }
+}
+async function tickTimers() {
+    const profile = getActiveProfile();
+    if (!profile?.config.baseUrl)
+        return;
+    const baseUrl = profile.config.baseUrl.replace(/\/$/, "");
+    if (!baseUrl.startsWith("http"))
+        return;
+    let authHeader = "";
+    try {
+        authHeader = await getAuthHeader(profile.config);
+    }
+    catch {
+        // proceed unauthenticated
+    }
+    const now = Date.now();
+    for (const def of timerDefs) {
+        const lastFired = timerState.lastFired[def.processId] ?? 0;
+        if (def.type === "date") {
+            const target = new Date(def.value).getTime();
+            if (Number.isNaN(target))
+                continue;
+            if (now >= target && lastFired < target) {
+                await fireProcess(baseUrl, authHeader, def.processId);
+                timerState.lastFired[def.processId] = now;
+                saveState(timerState);
+            }
+            continue;
+        }
+        if (def.type === "duration" || def.type === "cycle") {
+            const durationMs = def.type === "duration"
+                ? parseDurationMs(def.value)
+                : (parseCycle(def.value)?.durationMs ?? null);
+            if (!durationMs || durationMs <= 0)
+                continue;
+            // Skip if this process has exhausted its repeat count
+            if (def.remaining !== undefined && def.remaining <= 0)
+                continue;
+            const due = lastFired + durationMs;
+            if (now >= due) {
+                await fireProcess(baseUrl, authHeader, def.processId);
+                timerState.lastFired[def.processId] = now;
+                if (def.remaining !== undefined)
+                    def.remaining--;
+                saveState(timerState);
+            }
+        }
+    }
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+const SCAN_INTERVAL_MS = 60_000;
+const TICK_INTERVAL_MS = 5_000;
+export function startTimerTrigger() {
+    // Initial scan
+    void scanAndSchedule();
+    // Re-scan every 60 s for newly deployed processes
+    setInterval(() => {
+        void scanAndSchedule();
+    }, SCAN_INTERVAL_MS);
+    // Tick every 5 s to check for due timers
+    setInterval(() => {
+        void tickTimers();
+    }, TICK_INTERVAL_MS);
+}
+//# sourceMappingURL=timer.js.map

package/dist/triggers/webhook.js

@@ -0,0 +1,76 @@
+import { getActiveProfile, getAuthHeader } from "@bpmnkit/profiles";
+// ── Request matcher ───────────────────────────────────────────────────────────
+/** Returns the processId if the request matches `POST /webhooks/:processId`. */
+export function matchWebhookRoute(req) {
+    if (req.method !== "POST")
+        return null;
+    const m = /^\/webhooks\/([^/?]+)/.exec(req.url ?? "");
+    if (!m || !m[1])
+        return null;
+    return { processId: m[1] };
+}
+// ── Handler ───────────────────────────────────────────────────────────────────
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        req.on("error", reject);
+    });
+}
+function sendJson(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, { "content-type": "application/json" });
+    res.end(payload);
+}
+export async function handleWebhook(req, res, processId) {
+    // Token guard (optional)
+    const token = process.env.WEBHOOK_TOKEN;
+    if (token) {
+        const auth = req.headers.authorization ?? "";
+        if (auth !== `Bearer ${token}`) {
+            sendJson(res, 401, { error: "Unauthorized" });
+            return;
+        }
+    }
+    // Parse body
+    let variables = {};
+    try {
+        const raw = await readBody(req);
+        if (raw.trim()) {
+            variables = JSON.parse(raw);
+        }
+    }
+    catch {
+        sendJson(res, 400, { error: "Invalid JSON body" });
+        return;
+    }
+    // Start process instance via reebe
+    const profile = getActiveProfile();
+    if (!profile?.config.baseUrl) {
+        sendJson(res, 503, { error: "No active reebe profile" });
+        return;
+    }
+    const baseUrl = profile.config.baseUrl.replace(/\/$/, "");
+    let authHeader = "";
+    try {
+        authHeader = await getAuthHeader(profile.config);
+    }
+    catch {
+        // proceed without auth
+    }
+    const startRes = await fetch(`${baseUrl}/v2/process-instances`, {
+        method: "POST",
+        headers: { authorization: authHeader, "content-type": "application/json" },
+        body: JSON.stringify({ processDefinitionId: processId, variables }),
+    });
+    if (!startRes.ok) {
+        const text = await startRes.text();
+        sendJson(res, startRes.status, { error: text });
+        return;
+    }
+    const data = (await startRes.json());
+    console.log(`[trigger:webhook] started ${processId} → instance ${data.processInstanceKey ?? "?"}`);
+    sendJson(res, 200, { processInstanceKey: data.processInstanceKey });
+}
+//# sourceMappingURL=webhook.js.map