@reproapp/node-sdk 0.0.3 → 0.0.4

package/dist/ingest/client.d.ts

@@ -0,0 +1,10 @@
+import type { IngestClientConfig, LegacyEntry } from './types';
+export declare const configureIngestQueueDrain: (options: {
+    shouldDefer?: (() => boolean) | null;
+    deferMs?: number;
+}) => void;
+export declare const kickIngestQueueDrain: () => void;
+export declare const postIngestEntries: (config: IngestClientConfig, sessionId: string, entries: LegacyEntry[]) => Promise<void>;
+export declare const enqueueIngestEntries: (config: IngestClientConfig, sessionId: string, entries: LegacyEntry[]) => void;
+export declare const flushIngestQueue: () => Promise<void>;
+export type { IngestClientConfig, LegacyEntry } from './types';

package/dist/ingest/client.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flushIngestQueue = exports.enqueueIngestEntries = exports.postIngestEntries = exports.kickIngestQueueDrain = exports.configureIngestQueueDrain = void 0;
+const mapper_1 = require("./mapper");
+const DEFAULT_INGEST_BASE = 'http://localhost:8080';
+const DEFAULT_INGEST_PATH = '/v1/ingest/events';
+const DEFAULT_QUEUE_MAX_ITEMS = 1000;
+const DEFAULT_QUEUE_MAX_ATTEMPTS = 5;
+const DEFAULT_QUEUE_BACKOFF_MAX_MS = 4000;
+const DEFAULT_DEFER_DRAIN_MS = 25;
+const ingestQueue = [];
+let drainTimer = null;
+let draining = false;
+let backoffMs = 0;
+let shouldDeferDrain = null;
+let deferDrainMs = DEFAULT_DEFER_DRAIN_MS;
+const configureIngestQueueDrain = (options) => {
+    shouldDeferDrain = options.shouldDefer ?? null;
+    if (Number.isFinite(options.deferMs) && Number(options.deferMs) >= 0) {
+        deferDrainMs = Number(options.deferMs);
+    }
+};
+exports.configureIngestQueueDrain = configureIngestQueueDrain;
+const kickIngestQueueDrain = () => {
+    if (ingestQueue.length > 0 && !drainTimer) {
+        scheduleDrain(shouldDeferDrain?.() ? deferDrainMs : 0);
+    }
+};
+exports.kickIngestQueueDrain = kickIngestQueueDrain;
+const resolveIngestUrl = (config) => {
+    const envBase = typeof process !== 'undefined' ? process?.env?.REPRO_INGEST_BASE : undefined;
+    const ingestBase = String(envBase || config.ingestBase || DEFAULT_INGEST_BASE).replace(/\/+$/, '');
+    const ingestPath = config.ingestPath || DEFAULT_INGEST_PATH;
+    const normalizedPath = ingestPath.startsWith('/') ? ingestPath : `/${ingestPath}`;
+    return `${ingestBase}${normalizedPath}`;
+};
+const toHeaders = (config) => {
+    const headers = {
+        'Content-Type': 'application/json',
+        'X-App-Id': config.appId,
+    };
+    if (config.appSecret) {
+        headers['X-App-Secret'] = config.appSecret;
+    }
+    if (config.appName) {
+        headers['X-App-Name'] = config.appName;
+    }
+    return headers;
+};
+const postIngestEntries = async (config, sessionId, entries) => {
+    await sendIngestEntries(config, sessionId, entries);
+};
+exports.postIngestEntries = postIngestEntries;
+const sendIngestEntries = async (config, sessionId, entries) => {
+    if (!sessionId || !Array.isArray(entries) || entries.length === 0) {
+        return true;
+    }
+    const events = (0, mapper_1.mapLegacyEntriesToCanonicalEvents)(config, sessionId, entries);
+    if (!events.length) {
+        return true;
+    }
+    try {
+        const response = await fetch(resolveIngestUrl(config), {
+            method: 'POST',
+            headers: toHeaders(config),
+            body: JSON.stringify({ events }),
+        });
+        return response.ok;
+    }
+    catch {
+        // swallow in SDK
+        return false;
+    }
+};
+const scheduleDrain = (delayMs = 0) => {
+    if (drainTimer) {
+        return;
+    }
+    const nextDelay = shouldDeferDrain?.()
+        ? Math.max(delayMs, deferDrainMs)
+        : delayMs;
+    drainTimer = setTimeout(() => {
+        drainTimer = null;
+        if (shouldDeferDrain?.()) {
+            scheduleDrain(deferDrainMs);
+            return;
+        }
+        void drainIngestQueue();
+    }, nextDelay);
+    try {
+        drainTimer.unref?.();
+    }
+    catch { }
+};
+const drainIngestQueue = async () => {
+    if (draining) {
+        return;
+    }
+    if (shouldDeferDrain?.()) {
+        scheduleDrain(deferDrainMs);
+        return;
+    }
+    draining = true;
+    try {
+        while (ingestQueue.length > 0) {
+            if (shouldDeferDrain?.()) {
+                scheduleDrain(deferDrainMs);
+                return;
+            }
+            const batch = ingestQueue[0];
+            const ok = await sendIngestEntries(batch.config, batch.sessionId, batch.entries);
+            if (ok) {
+                ingestQueue.shift();
+                backoffMs = 0;
+                continue;
+            }
+            batch.attempts += 1;
+            if (batch.attempts >= DEFAULT_QUEUE_MAX_ATTEMPTS) {
+                ingestQueue.shift();
+                backoffMs = 0;
+                continue;
+            }
+            backoffMs = Math.min(DEFAULT_QUEUE_BACKOFF_MAX_MS, backoffMs ? backoffMs * 2 : 250);
+            scheduleDrain(backoffMs);
+            return;
+        }
+    }
+    finally {
+        draining = false;
+        if (ingestQueue.length > 0 && !drainTimer) {
+            scheduleDrain(backoffMs || deferDrainMs);
+        }
+    }
+};
+const enqueueIngestEntries = (config, sessionId, entries) => {
+    if (!sessionId || !Array.isArray(entries) || entries.length === 0) {
+        return;
+    }
+    ingestQueue.push({
+        config: { ...config },
+        sessionId,
+        entries: entries.slice(),
+        attempts: 0,
+    });
+    if (ingestQueue.length > DEFAULT_QUEUE_MAX_ITEMS) {
+        ingestQueue.splice(0, ingestQueue.length - DEFAULT_QUEUE_MAX_ITEMS);
+    }
+    scheduleDrain(shouldDeferDrain?.() ? deferDrainMs : 0);
+};
+exports.enqueueIngestEntries = enqueueIngestEntries;
+const flushIngestQueue = async () => {
+    if (drainTimer) {
+        clearTimeout(drainTimer);
+        drainTimer = null;
+    }
+    await drainIngestQueue();
+};
+exports.flushIngestQueue = flushIngestQueue;

package/dist/ingest/mapper.d.ts

@@ -0,0 +1,2 @@
+import type { CanonicalEvent, IngestClientConfig, LegacyEntry } from './types';
+export declare const mapLegacyEntriesToCanonicalEvents: (config: IngestClientConfig, sessionId: string, entries: LegacyEntry[]) => CanonicalEvent[];

package/dist/ingest/mapper.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapLegacyEntriesToCanonicalEvents = void 0;
+const toIso = (timestamp) => {
+    const numeric = typeof timestamp === 'number' && Number.isFinite(timestamp) ? timestamp : Date.now();
+    return new Date(numeric).toISOString();
+};
+const inferEventType = (entry) => {
+    if (entry.request !== undefined)
+        return 'backend_request';
+    if (entry.db !== undefined)
+        return 'db_change';
+    if (entry.trace !== undefined)
+        return 'trace_batch';
+    if (entry.email !== undefined)
+        return 'email_event';
+    return 'backend_event';
+};
+const toActorLabels = (config) => {
+    if (!config.actorLabels)
+        return undefined;
+    const labels = Object.entries(config.actorLabels).reduce((acc, [key, value]) => {
+        if (!key)
+            return acc;
+        if (typeof value !== 'string')
+            return acc;
+        acc[key] = value;
+        return acc;
+    }, {});
+    return Object.keys(labels).length ? labels : undefined;
+};
+const resolveServiceName = (config) => {
+    const candidate = config.serviceName ?? config.appName;
+    if (typeof candidate !== 'string') {
+        return undefined;
+    }
+    const normalized = candidate.trim();
+    return normalized.length ? normalized : undefined;
+};
+const toPayload = (entry) => {
+    const payload = {
+        action_id: entry.actionId ?? null,
+    };
+    const normalizeFieldValue = (key, value) => {
+        if (key !== 'trace' || typeof value !== 'string') {
+            return value;
+        }
+        try {
+            const parsed = JSON.parse(value);
+            return Array.isArray(parsed) ? parsed : [];
+        }
+        catch {
+            return [];
+        }
+    };
+    for (const [key, value] of Object.entries(entry)) {
+        if (key === 't' || key === 'actionId')
+            continue;
+        payload[key] = normalizeFieldValue(key, value);
+    }
+    return payload;
+};
+const mapLegacyEntriesToCanonicalEvents = (config, sessionId, entries) => {
+    const actorLabels = toActorLabels(config);
+    const actorId = config.actorId ?? config.appId;
+    const actorType = config.actorType ?? 'service';
+    const schemaVersion = config.schemaVersion ?? 1;
+    const serviceName = resolveServiceName(config);
+    return entries.map((entry) => {
+        const payload = toPayload(entry);
+        if (serviceName &&
+            (typeof payload.serviceName !== 'string' || !String(payload.serviceName).trim().length)) {
+            payload.serviceName = serviceName;
+        }
+        const canonical = {
+            schema_version: schemaVersion,
+            tenant_id: config.tenantId,
+            app_id: config.appId,
+            session_id: sessionId,
+            event_type: inferEventType(entry),
+            event_ts: toIso(entry.t),
+            actor_id: actorId,
+            actor_type: actorType,
+            payload,
+        };
+        if (actorLabels) {
+            canonical.actor_labels = actorLabels;
+        }
+        return canonical;
+    });
+};
+exports.mapLegacyEntriesToCanonicalEvents = mapLegacyEntriesToCanonicalEvents;

package/dist/ingest/types.d.ts

@@ -0,0 +1,40 @@
+export interface IngestClientConfig {
+    appId: string;
+    tenantId: string;
+    appSecret?: string;
+    appName?: string;
+    serviceName?: string;
+    ingestBase?: string;
+    ingestPath?: string;
+    actorId?: string;
+    actorType?: string;
+    actorLabels?: Record<string, string>;
+    source?: string;
+    schemaVersion?: number;
+}
+export interface LegacyEntry {
+    actionId?: string | null;
+    requestRid?: string | null;
+    request?: unknown;
+    requestValues?: unknown[];
+    db?: unknown;
+    dbValues?: unknown[];
+    trace?: unknown[];
+    traceBatch?: unknown;
+    traceValues?: unknown[];
+    email?: unknown;
+    t?: number;
+    [key: string]: unknown;
+}
+export interface CanonicalEvent {
+    schema_version: number;
+    tenant_id: string;
+    app_id: string;
+    session_id: string;
+    event_type: string;
+    event_ts: string;
+    actor_id: string;
+    actor_type: string;
+    actor_labels?: Record<string, string>;
+    payload: Record<string, unknown>;
+}

package/dist/ingest/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ingest/worker.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_worker_threads_1 = require("node:worker_threads");
+const client_1 = require("./client");
+const isObject = (value) => value !== null && typeof value === 'object';
+const isMessage = (value) => {
+    if (!isObject(value)) {
+        return false;
+    }
+    return (isObject(value.config) &&
+        typeof value.sessionId === 'string' &&
+        Array.isArray(value.entries));
+};
+node_worker_threads_1.parentPort?.on('message', (message) => {
+    if (!isMessage(message)) {
+        return;
+    }
+    void (0, client_1.postIngestEntries)(message.config, message.sessionId, message.entries).catch(() => undefined);
+});

package/dist/integrations/sendgrid.d.ts

@@ -1,12 +1,10 @@
+import { type IngestClientConfig } from '../ingest/client';
 type Ctx = {
     sid?: string;
     aid?: string;
 };
 export declare const getCtx: () => Ctx;
-export type SendgridPatchConfig = {
-    appId: string;
-    appSecret: string;
-    appName?: string;
+export type SendgridPatchConfig = IngestClientConfig & {
     resolveContext?: () => {
         sid?: string;
         aid?: string;

package/dist/integrations/sendgrid.js

@@ -3,25 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.patchSendgridMail = exports.getCtx = void 0;
 // repro-node/src/integrations/sendgrid.ts
 const async_hooks_1 = require("async_hooks");
+const client_1 = require("../ingest/client");
 const als = new async_hooks_1.AsyncLocalStorage();
 const getCtx = () => als.getStore() || {};
 exports.getCtx = getCtx;
 // If you already export als/getCtx from repro-node, reuse that instead of re-declaring.
-async function post(cfg, sessionId, body) {
+function post(cfg, sessionId, body) {
     try {
-        const envBase = typeof process !== 'undefined' ? process?.env?.REPRO_API_BASE : undefined;
-        const legacyBase = cfg?.apiBase;
-        const apiBase = String(envBase || legacyBase || 'https://repro-api-d7288.ondigitalocean.app/api').replace(/\/+$/, '');
-        await fetch(`${apiBase}/v1/sessions/${sessionId}/backend`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'X-App-Id': cfg.appId,
-                'X-App-Secret': cfg.appSecret,
-                ...(cfg.appName ? { 'X-App-Name': cfg.appName } : {}),
-            },
-            body: JSON.stringify(body),
-        });
+        const entries = Array.isArray(body?.entries) ? body.entries : [];
+        (0, client_1.enqueueIngestEntries)(cfg, sessionId, entries);
     }
     catch { /* swallow */ }
 }

package/dist/privacy-fallback.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeUnknownBoundaryTextWithDetectors(value: string): Promise<string>;

package/dist/privacy-fallback.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeUnknownBoundaryTextWithDetectors = void 0;
+const SANITIZED_TEXT_CACHE = new Map();
+const SANITIZED_TEXT_CACHE_MAX = 500;
+async function sanitizeUnknownBoundaryTextWithDetectors(value) {
+    if (!value) {
+        return value;
+    }
+    const cached = SANITIZED_TEXT_CACHE.get(value);
+    if (cached !== undefined) {
+        return cached;
+    }
+    rememberSanitizedText(value, value);
+    return value;
+}
+exports.sanitizeUnknownBoundaryTextWithDetectors = sanitizeUnknownBoundaryTextWithDetectors;
+function rememberSanitizedText(input, output) {
+    SANITIZED_TEXT_CACHE.set(input, output);
+    if (SANITIZED_TEXT_CACHE.size <= SANITIZED_TEXT_CACHE_MAX) {
+        return;
+    }
+    const oldestKey = SANITIZED_TEXT_CACHE.keys().next().value;
+    if (typeof oldestKey === 'string') {
+        SANITIZED_TEXT_CACHE.delete(oldestKey);
+    }
+}

package/dist/privacy-redaction.d.ts

@@ -0,0 +1,3 @@
+export declare function redactEmailDeterministic(value: string): string;
+export declare function redactEmailsInText(value: string): string;
+export declare function collectEmailsInText(value: string): string[];

package/dist/privacy-redaction.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectEmailsInText = exports.redactEmailsInText = exports.redactEmailDeterministic = void 0;
+const crypto_1 = require("crypto");
+const EMAIL_PATTERN = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
+const EMAIL_TOKEN_PREFIX = 'email_tok_';
+const EMAIL_TOKEN_LENGTH = 12;
+function redactEmailDeterministic(value) {
+    const normalized = String(value ?? '').trim().toLowerCase();
+    if (!normalized) {
+        return `${EMAIL_TOKEN_PREFIX}unknown`;
+    }
+    const token = (0, crypto_1.createHash)('sha256').update(normalized).digest('hex').slice(0, EMAIL_TOKEN_LENGTH);
+    return `${EMAIL_TOKEN_PREFIX}${token}`;
+}
+exports.redactEmailDeterministic = redactEmailDeterministic;
+function redactEmailsInText(value) {
+    if (!value) {
+        return value;
+    }
+    return value.replace(EMAIL_PATTERN, (match) => isAlreadyMaskedEmail(match) ? match : redactEmailDeterministic(match));
+}
+exports.redactEmailsInText = redactEmailsInText;
+function collectEmailsInText(value) {
+    if (!value) {
+        return [];
+    }
+    const matches = value.match(EMAIL_PATTERN);
+    return Array.isArray(matches) ? matches : [];
+}
+exports.collectEmailsInText = collectEmailsInText;
+function isAlreadyMaskedEmail(value) {
+    if (/^email_tok_[a-z0-9]+$/i.test(value)) {
+        return true;
+    }
+    const [local = '', domain = ''] = String(value).split('@');
+    return local.includes('...') || domain.includes('...');
+}

package/dist/privacy.d.ts

@@ -0,0 +1,108 @@
+export type RuntimePrivacyAction = 'KEEP_EXACT' | 'TOKENIZE' | 'SUMMARIZE' | 'DROP';
+export type RuntimePrivacyScope = 'FIELD' | 'FUNCTION' | 'ROUTE' | 'SCHEMA' | 'QUERY' | 'PATTERN';
+export type RuntimePrivacyTextAction = 'KEEP_EXACT' | 'TOKENIZE' | 'PARTIAL_MASK' | 'DROP';
+export type RuntimePrivacyRawTextMode = 'SAFE_PARTIAL_MASK' | 'REGEX_ASSISTED_EXACT';
+export type RuntimePrivacyRawTextHintAction = 'TOKENIZE' | 'DROP';
+export type RuntimePrivacySurface = 'db.pk' | 'db.before' | 'db.after' | 'db.query' | 'db.resultMeta' | 'db.error' | 'request.headers' | 'request.body' | 'request.params' | 'request.query' | 'response.body' | 'trace.args' | 'trace.returnValue' | 'trace.error';
+export type RuntimePrivacyConfig = {
+    enabled?: boolean;
+    /** Bypass privacy policy and masking entirely and store raw captured values. */
+    captureRaw?: boolean;
+    environment?: string;
+    apiBase?: string;
+    /** Timeout for runtime privacy policy fetches in milliseconds. */
+    fetchTimeoutMs?: number;
+    /** Maximum total time initRepro should wait for policy fetch before failing startup. */
+    startupMaxWaitMs?: number;
+    /** Delay between startup fetch retries in milliseconds. */
+    startupRetryDelayMs?: number;
+    policy?: Record<string, any> | null;
+};
+export type RuntimePrivacyTraceContext = {
+    fn?: string | null;
+    file?: string | null;
+    functionType?: string | null;
+};
+export type RuntimePrivacyDbContext = {
+    type?: string | null;
+    collection?: string | null;
+    op?: string | null;
+};
+export type RuntimePrivacyApplyContext = {
+    routeKey?: string | null;
+    trace?: RuntimePrivacyTraceContext | null;
+    db?: RuntimePrivacyDbContext | null;
+    appId?: string;
+    appSecret?: string;
+};
+type TargetMatcher = {
+    surfaces: RuntimePrivacySurface[];
+    path: string[] | null;
+};
+type NormalizedStatement = {
+    sid: string;
+    scope: RuntimePrivacyScope;
+    selector: string;
+    action: RuntimePrivacyAction;
+    priority: number;
+    pattern?: RegExp;
+    selectorTokens: string[];
+    selectorLeaves: string[];
+    targetMatchers: TargetMatcher[];
+    textPolicy?: RuntimePrivacyTextPolicy;
+    rawTextMode?: RuntimePrivacyRawTextMode;
+    rawTextHintNames?: string[];
+    descendantRawTextMode?: RuntimePrivacyRawTextMode;
+};
+type NormalizedRawTextHint = {
+    name: string;
+    action: RuntimePrivacyRawTextHintAction;
+    pattern: RegExp;
+    tokenLabel: string;
+};
+type RuntimePrivacyTextFragment = {
+    kind: 'literal';
+    text: string;
+} | {
+    kind: 'slot';
+    label?: string;
+    action: RuntimePrivacyTextAction;
+};
+type RuntimePrivacyTextPolicy = {
+    mode: 'KNOWN_TEMPLATE';
+    fragments: RuntimePrivacyTextFragment[];
+};
+export type NormalizedRuntimePrivacyPolicy = {
+    environment?: string;
+    strength?: 'weak' | 'medium' | 'strict';
+    statements: NormalizedStatement[];
+    rawTextHints: NormalizedRawTextHint[];
+};
+export declare function clearRuntimePrivacyProvenance(): void;
+export type RuntimePrivacyFetchResult = {
+    status: 'ok';
+    policy: NormalizedRuntimePrivacyPolicy;
+} | {
+    status: 'disabled';
+    reason: 'missing_config' | 'missing_credentials' | 'no_policy' | 'empty_policy';
+} | {
+    status: 'http_error';
+    httpStatus: number;
+} | {
+    status: 'network_error';
+    error: string;
+};
+export declare function normalizePrivacyEnvironment(input?: string | null): string;
+export declare function resolvePrivacyApiBase(cfg?: RuntimePrivacyConfig | null): string | null;
+export declare function fetchApprovedRuntimePrivacyPolicy(params: {
+    appId: string;
+    appSecret?: string;
+    appName?: string;
+    apiBase: string;
+    environment: string;
+    fetchTimeoutMs?: number;
+}): Promise<RuntimePrivacyFetchResult>;
+export declare function normalizeRuntimePrivacyPolicy(raw: unknown): NormalizedRuntimePrivacyPolicy | null;
+export declare function applyRuntimePrivacyPolicy(policy: NormalizedRuntimePrivacyPolicy | null, surface: RuntimePrivacySurface, value: any, context: RuntimePrivacyApplyContext): any;
+export declare function applyRuntimePrivacyPolicyAsync(policy: NormalizedRuntimePrivacyPolicy | null, surface: RuntimePrivacySurface, value: any, context: RuntimePrivacyApplyContext): Promise<any>;
+export {};