@reproapp/node-sdk 0.0.1

package/dist/integrations/sendgrid.d.ts

@@ -0,0 +1,20 @@
+type Ctx = {
+    sid?: string;
+    aid?: string;
+};
+export declare const getCtx: () => Ctx;
+export type SendgridPatchConfig = {
+    appId: string;
+    appSecret: string;
+    appName?: string;
+    resolveContext?: () => {
+        sid?: string;
+        aid?: string;
+    } | undefined;
+};
+/**
+ * Patch @sendgrid/mail's send() and sendMultiple() to capture outbound email.
+ * Idempotent. No behavior change for the app.
+ */
+export declare function patchSendgridMail(cfg: SendgridPatchConfig): void;
+export {};

package/dist/integrations/sendgrid.js

@@ -0,0 +1,177 @@
+"use strict";
+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 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) {
+    try {
+        const envBase = typeof process !== 'undefined' ? process?.env?.REPRO_API_BASE : undefined;
+        const legacyBase = cfg?.apiBase;
+        const apiBase = String(envBase || legacyBase || 'https://oozy-loreta-gully.ngrok-free.dev').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),
+        });
+    }
+    catch { /* swallow */ }
+}
+/**
+ * Patch @sendgrid/mail's send() and sendMultiple() to capture outbound email.
+ * Idempotent. No behavior change for the app.
+ */
+function patchSendgridMail(cfg) {
+    let sgMail;
+    try {
+        sgMail = require('@sendgrid/mail');
+    }
+    catch {
+        return;
+    } // not installed → no-op
+    if (!sgMail || sgMail.__repro_patched)
+        return;
+    sgMail.__repro_patched = true;
+    const origSend = sgMail.send?.bind(sgMail);
+    const origSendMultiple = sgMail.sendMultiple?.bind(sgMail);
+    if (origSend) {
+        sgMail.send = async function patchedSend(msg, isMultiple) {
+            const startedAt = Date.now();
+            let statusCode;
+            let headers;
+            try {
+                const res = await origSend(msg, isMultiple);
+                // sendgrid returns [response] as array in v7.x
+                const r = Array.isArray(res) ? res[0] : res;
+                statusCode = r?.statusCode ?? r?.status ?? undefined;
+                headers = r?.headers ?? undefined;
+                return res;
+            }
+            finally {
+                fireCapture('send', msg, startedAt, statusCode, headers);
+            }
+        };
+    }
+    if (origSendMultiple) {
+        sgMail.sendMultiple = async function patchedSendMultiple(msg) {
+            const startedAt = Date.now();
+            let statusCode;
+            let headers;
+            try {
+                const res = await origSendMultiple(msg);
+                const r = Array.isArray(res) ? res[0] : res;
+                statusCode = r?.statusCode ?? r?.status ?? undefined;
+                headers = r?.headers ?? undefined;
+                return res;
+            }
+            finally {
+                fireCapture('sendMultiple', msg, startedAt, statusCode, headers);
+            }
+        };
+    }
+    function fireCapture(kind, rawMsg, t0, statusCode, headers) {
+        const ctx = (0, exports.getCtx)();
+        const sid = ctx.sid ?? cfg.resolveContext?.()?.sid;
+        const aid = ctx.aid ?? cfg.resolveContext?.()?.aid;
+        if (!sid)
+            return; // no active session → skip
+        const norm = normalizeSendgridMessage(rawMsg);
+        const entry = {
+            actionId: aid ?? null,
+            email: {
+                provider: 'sendgrid',
+                kind,
+                to: norm.to,
+                cc: norm.cc,
+                bcc: norm.bcc,
+                from: norm.from,
+                subject: norm.subject,
+                text: norm.text, // you said privacy later → include now
+                html: norm.html, // idem
+                templateId: norm.templateId,
+                dynamicTemplateData: norm.dynamicTemplateData,
+                categories: norm.categories,
+                customArgs: norm.customArgs,
+                attachmentsMeta: norm.attachmentsMeta, // safe metadata only
+                statusCode,
+                durMs: Date.now() - t0,
+                headers: headers ?? {},
+            },
+            t: Date.now(),
+        };
+        post(cfg, sid, { entries: [entry] });
+    }
+    function normalizeAddress(a) {
+        if (!a)
+            return null;
+        if (typeof a === 'string')
+            return { email: a };
+        if (typeof a === 'object' && a.email)
+            return { email: String(a.email), name: a.name ? String(a.name) : undefined };
+        return null;
+    }
+    function normalizeAddressList(v) {
+        if (!v)
+            return undefined;
+        const arr = Array.isArray(v) ? v : [v];
+        const out = arr.map(normalizeAddress).filter(Boolean);
+        return out.length ? out : undefined;
+    }
+    function normalizeSendgridMessage(msg) {
+        // sendgrid supports "personalizations" & top-level fields; we’ll flatten the common pieces
+        const base = {
+            from: normalizeAddress(msg?.from) ?? undefined,
+            to: normalizeAddressList(msg?.to),
+            cc: normalizeAddressList(msg?.cc),
+            bcc: normalizeAddressList(msg?.bcc),
+            subject: msg?.subject ? String(msg.subject) : undefined,
+            text: typeof msg?.text === 'string' ? msg.text : undefined,
+            html: typeof msg?.html === 'string' ? msg.html : undefined,
+            templateId: msg?.templateId ? String(msg.templateId) : undefined,
+            dynamicTemplateData: msg?.dynamic_template_data ?? msg?.dynamicTemplateData ?? undefined,
+            categories: Array.isArray(msg?.categories) ? msg.categories.map(String) : undefined,
+            customArgs: msg?.customArgs ?? msg?.custom_args ?? undefined,
+            attachmentsMeta: Array.isArray(msg?.attachments)
+                ? msg.attachments.map((a) => ({
+                    filename: a?.filename ? String(a.filename) : undefined,
+                    type: a?.type ? String(a.type) : undefined,
+                    size: a?.content ? byteLen(a.content) : undefined, // base64 or string → approximate size
+                }))
+                : undefined,
+        };
+        // If personalizations exist, pull the FIRST one as representative (keeps MVP simple)
+        const p0 = Array.isArray(msg?.personalizations) ? msg.personalizations[0] : undefined;
+        if (p0) {
+            base.to = normalizeAddressList(p0.to) ?? base.to;
+            base.cc = normalizeAddressList(p0.cc) ?? base.cc;
+            base.bcc = normalizeAddressList(p0.bcc) ?? base.bcc;
+            if (!base.subject && p0.subject)
+                base.subject = String(p0.subject);
+            // template data can also live inside personalization
+            if (!base.dynamicTemplateData && p0.dynamic_template_data)
+                base.dynamicTemplateData = p0.dynamic_template_data;
+            if (!base.customArgs && p0.custom_args)
+                base.customArgs = p0.custom_args;
+        }
+        return base;
+    }
+    function byteLen(content) {
+        try {
+            if (typeof content === 'string')
+                return Buffer.byteLength(content, 'utf8');
+            if (content && typeof content === 'object' && 'length' in content)
+                return Number(content.length);
+        }
+        catch { }
+        return undefined;
+    }
+}
+exports.patchSendgridMail = patchSendgridMail;

package/dist/redaction.d.ts

@@ -0,0 +1,44 @@
+type RedactionStrategy = 'mask' | 'remove';
+export type RedactionRuleInput = string | RegExp | {
+    match?: string | RegExp;
+    field?: string | RegExp;
+    exact?: boolean;
+    strategy?: RedactionStrategy;
+    maskWith?: string;
+};
+type RedactionFieldMapKey = 'any' | 'headers' | 'body' | 'query' | 'params' | 'respBody' | 'response' | 'responseBody' | 'responseHeaders';
+export type TransportRedactionFields = Partial<Record<RedactionFieldMapKey, RedactionRuleInput[]>>;
+export interface TransportRedactionOptions {
+    /**
+     * Custom mask string for masked values. Default: "*****".
+     */
+    maskWith?: string;
+    /**
+     * Additional rules that apply to specific request/response sections.
+     * Provide field names (case-insensitive), dot-delimited paths, or
+     * regular expressions. Rules declared under `any` apply everywhere.
+     */
+    fields?: TransportRedactionFields;
+}
+type SectionKey = 'any' | 'headers' | 'body' | 'query' | 'params' | 'respBody' | 'responseHeaders';
+type NormalizedRule = {
+    kind: 'string';
+    needle: string;
+    exact: boolean;
+    action: RedactionStrategy;
+    maskWith?: string;
+} | {
+    kind: 'regex';
+    regex: RegExp;
+    action: RedactionStrategy;
+    maskWith?: string;
+};
+export type TransportRedactionState = {
+    maskWith: string;
+    rules: Record<SectionKey, NormalizedRule[]>;
+};
+export declare function configureTransportRedaction(options?: TransportRedactionOptions | null): TransportRedactionState;
+export declare function getTransportRedactionState(): TransportRedactionState;
+export declare function redactPayload<T>(payload: T, stateOverride?: TransportRedactionState | null): T;
+export declare function redactSection<T>(value: T, section: Exclude<SectionKey, 'any'>, stateOverride?: TransportRedactionState | null): T;
+export {};

package/dist/redaction.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactSection = exports.redactPayload = exports.getTransportRedactionState = exports.configureTransportRedaction = void 0;
+const SECTION_KEYS = ['any', 'headers', 'body', 'query', 'params', 'respBody', 'responseHeaders'];
+const DEFAULT_MASK = '*****';
+const DEFAULT_RULES = [
+    { match: /pass(word|phrase)?/i },
+    { match: /pwd/i },
+    { match: /secret/i },
+    { match: /token/i },
+    { match: /authorization/i },
+    { match: /api[_-]?key/i },
+];
+let CURRENT_STATE = buildState();
+function configureTransportRedaction(options) {
+    CURRENT_STATE = buildState(options);
+    return CURRENT_STATE;
+}
+exports.configureTransportRedaction = configureTransportRedaction;
+function getTransportRedactionState() {
+    return CURRENT_STATE;
+}
+exports.getTransportRedactionState = getTransportRedactionState;
+function redactPayload(payload, stateOverride) {
+    const state = stateOverride ?? CURRENT_STATE;
+    applyRules(payload, gatherRules('any', state), state.maskWith);
+    return payload;
+}
+exports.redactPayload = redactPayload;
+function redactSection(value, section, stateOverride) {
+    const state = stateOverride ?? CURRENT_STATE;
+    applyRules(value, gatherRules(section, state), state.maskWith);
+    return value;
+}
+exports.redactSection = redactSection;
+function buildState(options) {
+    const state = {
+        maskWith: typeof options?.maskWith === 'string' && options.maskWith ? options.maskWith : DEFAULT_MASK,
+        rules: SECTION_KEYS.reduce((acc, key) => {
+            acc[key] = [];
+            return acc;
+        }, {}),
+    };
+    appendRules(state.rules.any, DEFAULT_RULES);
+    if (!options?.fields) {
+        return state;
+    }
+    appendRules(state.rules.any, options.fields.any);
+    appendRules(state.rules.headers, options.fields.headers);
+    appendRules(state.rules.body, options.fields.body);
+    appendRules(state.rules.query, options.fields.query);
+    appendRules(state.rules.params, options.fields.params);
+    appendRules(state.rules.respBody, options.fields.respBody);
+    appendRules(state.rules.respBody, options.fields.response);
+    appendRules(state.rules.respBody, options.fields.responseBody);
+    appendRules(state.rules.responseHeaders, options.fields.responseHeaders);
+    return state;
+}
+function appendRules(bucket, inputs) {
+    if (!inputs || !Array.isArray(inputs))
+        return;
+    for (const entry of inputs) {
+        const normalized = normalizeRule(entry);
+        if (normalized)
+            bucket.push(normalized);
+    }
+}
+function normalizeRule(input) {
+    if (!input)
+        return null;
+    if (typeof input === 'string') {
+        const needle = input.trim().toLowerCase();
+        if (!needle)
+            return null;
+        return { kind: 'string', needle, exact: false, action: 'mask' };
+    }
+    if (input instanceof RegExp) {
+        return { kind: 'regex', regex: cloneRegex(input), action: 'mask' };
+    }
+    if (typeof input === 'object') {
+        const pattern = input.match ?? input.field;
+        const exact = !!input.exact;
+        const action = input.strategy === 'remove' ? 'remove' : 'mask';
+        const maskWith = typeof input.maskWith === 'string' && input.maskWith ? input.maskWith : undefined;
+        if (pattern instanceof RegExp) {
+            return { kind: 'regex', regex: cloneRegex(pattern), action, maskWith };
+        }
+        if (typeof pattern === 'string') {
+            const needle = pattern.trim().toLowerCase();
+            if (!needle)
+                return null;
+            return { kind: 'string', needle, exact, action, maskWith };
+        }
+    }
+    return null;
+}
+function cloneRegex(rx) {
+    const flags = rx.flags.includes('g') ? rx.flags.replace(/g/g, '') : rx.flags;
+    return new RegExp(rx.source, flags);
+}
+function gatherRules(section, state) {
+    if (section === 'any')
+        return state.rules.any;
+    return state.rules.any.concat(state.rules[section] ?? []);
+}
+function applyRules(value, rules, defaultMask) {
+    if (!rules.length)
+        return;
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            const item = value[i];
+            if (item && typeof item === 'object') {
+                applyRules(item, rules, defaultMask);
+            }
+        }
+        return;
+    }
+    if (!isRedactableObject(value))
+        return;
+    for (const key of Object.keys(value)) {
+        const decision = pickDecision(key, rules, defaultMask);
+        if (!decision) {
+            const child = value[key];
+            if (child && typeof child === 'object') {
+                applyRules(child, rules, defaultMask);
+            }
+            continue;
+        }
+        if (decision === 'remove') {
+            delete value[key];
+        }
+        else {
+            value[key] = decision;
+        }
+    }
+}
+function isRedactableObject(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    if (Buffer.isBuffer(value))
+        return false;
+    if (ArrayBuffer.isView(value))
+        return false;
+    if (value instanceof Date || value instanceof RegExp)
+        return false;
+    if (value instanceof Map || value instanceof Set)
+        return false;
+    return true;
+}
+function pickDecision(key, rules, defaultMask) {
+    const lower = key.toLowerCase();
+    for (const rule of rules) {
+        if (rule.kind === 'string') {
+            const match = rule.exact ? lower === rule.needle : lower.includes(rule.needle);
+            if (!match)
+                continue;
+        }
+        else {
+            if (!rule.regex.test(key))
+                continue;
+        }
+        if (rule.action === 'remove')
+            return 'remove';
+        return rule.maskWith ?? defaultMask;
+    }
+    return null;
+}

package/dist/server.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const express = require('express');
+const mongoose = require('mongoose');
+(0, index_1.initReproTracing)();
+const app = express();
+(async () => {
+    await mongoose.connect('mongodb://127.0.0.1:27018', { dbName: 'trace_demo' });
+    const userSchema = new mongoose.Schema({
+        name: String, email: String, age: Number
+    }, { timestamps: true });
+    const User = mongoose.model('User', userSchema);
+    // seed some data
+    // @ts-ignore
+    app.get('/seed', async (_req, res) => {
+        await User.deleteMany({});
+        await User.insertMany([
+            { name: 'Ada', email: 'ada@example.com', age: 27 },
+            { name: 'Lin', email: 'lin@example.com', age: 35 },
+            { name: 'Sam', email: 'sam@example.com', age: 17 },
+        ]);
+        res.json({ ok: true, count: await User.countDocuments() });
+    });
+    app.listen(3000, () => process.stdout.write('listening on http://localhost:3000\n'));
+})();

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@reproapp/node-sdk",
+  "version": "0.0.1",
+  "description": "Repro Nest SDK",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build",
+    "test": "npm run build && node tmp/unawaited.test.js && node tmp/integration-unawaited.js && node -r ./tracer/register tmp/promise-map.test.js && node tmp/disable-subtree.test.js"
+  },
+  "peerDependencies": {
+    "express": "^5.1.0",
+    "mongoose": ">=6"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@babel/core": "^7.28.4",
+    "@babel/generator": "^7.28.3",
+    "@babel/parser": "^7.28.4",
+    "@babel/plugin-transform-typescript": "^7.28.0",
+    "@babel/traverse": "^7.28.4",
+    "@babel/types": "^7.28.4",
+    "@jridgewell/trace-mapping": "^0.3.25",
+    "@nestjs/common": "^11.1.9",
+    "@nestjs/core": "^11.1.9",
+    "@nestjs/platform-express": "^11.1.9",
+    "express": "^5.1.0",
+    "import-in-the-middle": "^2.0.0",
+    "mongoose": ">=6",
+    "pirates": "^4.0.7",
+    "reflect-metadata": "^0.2.2",
+    "require-in-the-middle": "^8.0.1",
+    "rxjs": "^7.8.2",
+    "shimmer": "^1.2.1",
+    "testcontainers": "^11.8.1"
+  }
+}