@reprova/sdk 0.4.0 → 0.6.0

package/dist/cjs/retryStorm.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PotentialRetryStorm = void 0;
+exports.detectRetryStorm = detectRetryStorm;
+exports.describeRetryStorm = describeRetryStorm;
+// A call counts as failed for this purpose if it never got a real response
+// (status 0, the SDK's convention for a network error or timeout — see
+// sdk.ts's patchedFetch) or the server itself reported failure (5xx). 4xx is
+// deliberately excluded: a repeated 404 or 401 is a caller bug, not a
+// struggling dependency being hammered.
+function isFailingCall(call) {
+    return call.status === 0 || call.status >= 500;
+}
+/**
+ * Groups a request's recorded outbound calls by (host, method, pathname —
+ * query string stripped) and flags any group that both repeats at or above
+ * the threshold AND includes at least one failing call.
+ *
+ * Both conditions matter: repetition alone doesn't distinguish a retry storm
+ * from legitimate pagination or batch fetching against a healthy dependency
+ * (all 200s) — requiring at least one failure targets specifically "the app
+ * kept calling a target that was failing," the actual retry-amplification
+ * pattern, not "the app called the same endpoint several times." Query
+ * string is stripped before grouping because a real retry commonly varies a
+ * request id or cache-busting param per attempt — grouping on the exact
+ * path would make every retry look like a distinct, one-off call and never
+ * cross the threshold.
+ */
+function detectRetryStorm(calls, threshold) {
+    if (threshold <= 0)
+        return [];
+    const groups = new Map();
+    for (const call of calls) {
+        const pathname = call.path.split('?')[0] ?? call.path;
+        const key = `${call.host} ${call.method} ${pathname}`;
+        let g = groups.get(key);
+        if (!g) {
+            g = { host: call.host, method: call.method, path: pathname, count: 0, failureCount: 0 };
+            groups.set(key, g);
+        }
+        g.count++;
+        if (isFailingCall(call))
+            g.failureCount++;
+    }
+    return [...groups.values()]
+        .filter((g) => g.count >= threshold && g.failureCount > 0)
+        .sort((a, b) => b.count - a.count);
+}
+/**
+ * A stable, digit-free description — same fingerprinting reasoning as
+ * describeNPlusOne: the exact count varies request to request, and must not
+ * appear in the message or two occurrences of the same underlying storm
+ * would never fingerprint into the same issue.
+ */
+function describeRetryStorm(finding) {
+    return `Repeated failing calls to ${finding.method} ${finding.host}${finding.path} — possible retry storm without backoff`;
+}
+/**
+ * A real Error subclass, not a plain Error with `.name` reassigned — same
+ * reasoning as PotentialNPlusOneQuery: capture() derives the payload's
+ * error.type (which becomes the issue title verbatim) from
+ * err.constructor.name, which for a plain Error is always "Error" no matter
+ * what `.name` gets set to afterward.
+ */
+class PotentialRetryStorm extends Error {
+    constructor(finding) {
+        super(describeRetryStorm(finding));
+    }
+}
+exports.PotentialRetryStorm = PotentialRetryStorm;

package/dist/cjs/rulesPoller.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RulesPoller = void 0;
+const httpFetch_js_1 = require("./httpFetch.js");
+const WARN_INTERVAL_MS = 60_000;
+// Periodically fetches the tenant's business-invariant rules from the
+// control plane and caches the enabled subset in memory — the mechanism
+// that lets a dashboard-authored rule take effect in a running process
+// without a recompile/redeploy. Same start()/stop()/setInterval+unref shape
+// as BatchTransport (transport.ts), the SDK's other background timer.
+class RulesPoller {
+    rules = [];
+    timer = null;
+    lastWarnAt = 0;
+    endpoint;
+    apiKey;
+    intervalMs;
+    constructor(opts) {
+        this.endpoint = opts.endpoint;
+        this.apiKey = opts.apiKey;
+        this.intervalMs = opts.intervalMs ?? 60_000;
+    }
+    start() {
+        void this.refresh(); // don't wait a full interval before rules are usable
+        this.timer = setInterval(() => void this.refresh(), this.intervalMs);
+        if (this.timer.unref)
+            this.timer.unref(); // don't block process exit
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    // The rules currently cached, already filtered to enabled — the control
+    // plane returns every rule (dashboard needs to see disabled ones to
+    // manage them), so the filtering happens once here rather than on every
+    // query in the Prisma extension.
+    getEnabledRules() {
+        return this.rules;
+    }
+    async refresh() {
+        try {
+            const res = await (0, httpFetch_js_1.httpFetch)(this.endpoint, {
+                headers: { 'X-Reprova-Key': this.apiKey },
+            });
+            if (!res.ok) {
+                this.warnOnce(`reprova: rules fetch returned ${res.status}`);
+                return;
+            }
+            const body = (await res.json());
+            this.applyResponse(body);
+        }
+        catch (err) {
+            this.warnOnce(`reprova: rules fetch error: ${err.message}`);
+        }
+    }
+    // Applies an already-fetched response body directly, with no network call
+    // — used by replay mode to seed a one-time snapshot the CLI fetched ahead
+    // of time (there's no live control plane to poll from inside a replayed
+    // app), so detection logic (invariantRules.ts) sees exactly the same
+    // shape it would from a real refresh().
+    seed(body) {
+        this.applyResponse(body);
+    }
+    applyResponse(body) {
+        this.rules = (body.rules ?? []).filter((r) => r.enabled);
+    }
+    warnOnce(msg) {
+        const now = Date.now();
+        if (now - this.lastWarnAt > WARN_INTERVAL_MS) {
+            this.lastWarnAt = now;
+            console.warn(msg);
+        }
+    }
+}
+exports.RulesPoller = RulesPoller;