@reproapp/node-sdk 0.0.39 → 0.0.41

package/src/index.ts

@@ -1223,6 +1223,35 @@ function buildRequestCaptureManifestPayload(
     };
 }
 
+function emitRequestCaptureStart(
+    cfg: IngestClientConfig,
+    sessionId: string | null | undefined,
+    actionId: string | null | undefined,
+    scope: RequestCaptureScopeState,
+    openedAtMs?: number | null,
+): void {
+    if (!sessionId) {
+        return;
+    }
+    const openedAt =
+        typeof openedAtMs === 'number' && Number.isFinite(openedAtMs)
+            ? openedAtMs
+            : alignedNow();
+    post(cfg, sessionId, {
+        entries: [{
+            actionId: actionId ?? null,
+            requestRid: scope.requestRid,
+            requestCaptureStart: {
+                scopeId: `req:${scope.requestRid}`,
+                requestRid: scope.requestRid,
+                transport: scope.transport,
+                openedAt,
+            },
+            t: openedAt,
+        }],
+    }, { priority: 'high' });
+}
+
 const als = new AsyncLocalStorage<Ctx>();
 const getCtx = () => als.getStore() || {};
 
@@ -5712,6 +5741,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
         const clockSkewMs = headerTs !== null ? headerTs - requestStartRaw : 0;
         const rid = nextRequestId(requestEpochMs);
         const captureScope = createRequestCaptureScope(rid, 'http');
+        emitRequestCaptureStart(captureCfg, sid, aid, captureScope, requestEpochMs);
         const t0 = requestStartRaw;
         const url = (req as any).originalUrl || req.url || '/';
         const urlPathOnly = (url || '/').split('?')[0] || '/';
@@ -7810,6 +7840,7 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
             const span = captureSpanContextFromTracer();
             const publishRid = nextRequestId(alignedNow());
             const captureScope = createRequestCaptureScope(publishRid, 'kafka');
+            emitRequestCaptureStart(cfg, sid, aid, captureScope);
             const payloadObj = payload && typeof payload === 'object' ? payload : {};
             const topic = sanitizeKafkaTopic((payloadObj as any).topic);
             const rawMessages = Array.isArray((payloadObj as any).messages) ? (payloadObj as any).messages : [];
@@ -7924,6 +7955,7 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
             const span = captureSpanContextFromTracer();
             const publishRid = nextRequestId(alignedNow());
             const captureScope = createRequestCaptureScope(publishRid, 'kafka');
+            emitRequestCaptureStart(cfg, sid, aid, captureScope);
 
             const payloadObj = payload && typeof payload === 'object' ? payload : {};
             const topicMessages = Array.isArray((payloadObj as any).topicMessages)
@@ -8074,6 +8106,7 @@ function wrapKafkaEachMessageHandler(eachMessage: any, cfg: KafkaJsPatchConfig,
         const consumeRid = nextRequestId(`${topic}-${message?.offset ?? alignedNow()}`);
         const traceId = consumeRid;
         const captureScope = createRequestCaptureScope(consumeRid, 'kafka');
+        emitRequestCaptureStart(cfg, sid, aid, captureScope);
         const rawTraceEvents: any[] = [];
         const maskReq: MaskRequestContext = {
             method: 'KAFKA_CONSUME',
@@ -8184,6 +8217,7 @@ function wrapKafkaEachBatchHandler(eachBatch: any, cfg: KafkaJsPatchConfig, cons
         const consumeRid = nextRequestId(`${topic}-batch-${alignedNow()}`);
         const traceId = consumeRid;
         const captureScope = createRequestCaptureScope(consumeRid, 'kafka');
+        emitRequestCaptureStart(cfg, sid, aid, captureScope);
         const rawTraceEvents: any[] = [];
         const maskReq: MaskRequestContext = {
             method: 'KAFKA_CONSUME_BATCH',
@@ -8891,6 +8925,7 @@ function patchAmqplibPublishMethod(
         const key = `${method} ${methodName === 'publish' ? `${exchange || 'default'}/${routingKey}` : queue}`;
         const content = methodName === 'publish' ? args[2] : args[1];
         const captureScope = createRequestCaptureScope(publishRid, 'amqp');
+        emitRequestCaptureStart(cfg, sid, aid, captureScope);
         const t0 = Date.now();
         let finished = false;
 
@@ -8980,6 +9015,7 @@ function wrapAmqplibConsumeHandler(onMessage: any, cfg: AmqplibPatchConfig, queu
         const consumeRid = nextRequestId(`${queueName}-${deliveryTag}`);
         const traceId = consumeRid;
         const captureScope = createRequestCaptureScope(consumeRid, 'amqp');
+        emitRequestCaptureStart(cfg, sid, aid, captureScope);
         const rawTraceEvents: any[] = [];
         const maskReq: MaskRequestContext = {
             method: 'AMQP_CONSUME',
@@ -9583,6 +9619,616 @@ export function patchRedis(cfg: RedisPatchConfig) {
     }
 }
 
+// ===================================================================
+// PostgreSQL integrations: pg, postgres.js, and TypeORM
+// ===================================================================
+export type PostgreSqlPatchConfig = ReproMiddlewareConfig & {
+    resolveContext?: () => { sid?: string; aid?: string } | undefined;
+};
+
+type PostgreSqlSource = {
+    library: 'pg' | 'postgres' | 'typeorm';
+    driver: 'pg' | 'postgres';
+};
+
+type PostgreSqlCaptureContext = {
+    cfg: PostgreSqlPatchConfig;
+    sid: string;
+    aid: string | null;
+    spanContext: SpanContext | null;
+    source: PostgreSqlSource;
+};
+
+const postgresSqlPatchConfigs: PostgreSqlPatchConfig[] = [];
+const postgresSqlSourceAls = new AsyncLocalStorage<PostgreSqlSource>();
+const pgPoolQueryAls = new AsyncLocalStorage<boolean>();
+let pgRequireHookInstalled = false;
+let postgresJsRequireHookInstalled = false;
+let typeOrmRequireHookInstalled = false;
+
+const PG_CLIENT_PATCHED = Symbol.for('@reproapp/node-sdk/pg-client-patched');
+const PG_POOL_PATCHED = Symbol.for('@reproapp/node-sdk/pg-pool-patched');
+const POSTGRES_JS_QUERY_PATCHED = Symbol.for('@reproapp/node-sdk/postgres-js-query-patched');
+const TYPEORM_DATASOURCE_PATCHED = Symbol.for('@reproapp/node-sdk/typeorm-datasource-patched');
+const TYPEORM_QUERY_RUNNER_PATCHED = Symbol.for('@reproapp/node-sdk/typeorm-query-runner-patched');
+
+function registerPostgreSqlPatchConfig(cfg: PostgreSqlPatchConfig): void {
+    if (!postgresSqlPatchConfigs.includes(cfg)) {
+        postgresSqlPatchConfigs.push(cfg);
+    }
+}
+
+function resolvePostgreSqlCaptureContext(defaultSource: PostgreSqlSource, source?: any): PostgreSqlCaptureContext | null {
+    const ctx = getCtx();
+    const contextualSource = postgresSqlSourceAls.getStore();
+    for (let i = postgresSqlPatchConfigs.length - 1; i >= 0; i -= 1) {
+        const cfg = postgresSqlPatchConfigs[i];
+        if (!cfg) continue;
+        const fallback = cfg.resolveContext?.() ?? {};
+        const sid = ctx.sid ?? fallback.sid ?? null;
+        if (!sid) continue;
+        return {
+            cfg,
+            sid,
+            aid: ctx.aid ?? fallback.aid ?? null,
+            spanContext: captureSpanContextFromTracer(source),
+            source: contextualSource ?? defaultSource,
+        };
+    }
+    return null;
+}
+
+function stripSqlComments(sql: string): string {
+    let remaining = sql.trimStart();
+    while (remaining.length) {
+        if (remaining.startsWith('--')) {
+            const newline = remaining.indexOf('\n');
+            remaining = newline < 0 ? '' : remaining.slice(newline + 1).trimStart();
+            continue;
+        }
+        if (remaining.startsWith('/*')) {
+            const end = remaining.indexOf('*/', 2);
+            remaining = end < 0 ? '' : remaining.slice(end + 2).trimStart();
+            continue;
+        }
+        break;
+    }
+    return remaining;
+}
+
+function normalizeSqlOperation(sql: string): string {
+    const normalized = stripSqlComments(sql);
+    const first = normalized.match(/^([a-z]+)/i)?.[1]?.toLowerCase() ?? 'query';
+    if (first !== 'with') return first;
+
+    // CTEs can wrap any DML statement. The last top-level DML keyword is the
+    // operation users care about, while nested SELECTs only build the CTE.
+    const matches = Array.from(normalized.matchAll(/\b(select|insert|update|delete|merge)\b/gi));
+    return matches.length ? String(matches[matches.length - 1][1]).toLowerCase() : 'query';
+}
+
+function cleanSqlIdentifier(value: string | undefined): string | undefined {
+    if (!value) return undefined;
+    const cleaned = value
+        .trim()
+        .replace(/[;,]$/, '')
+        .split('.')
+        .map((part) => part.replace(/^['"`]|['"`]$/g, ''))
+        .join('.');
+    return cleaned || undefined;
+}
+
+function resolveSqlTable(sql: string, op: string): string {
+    const normalized = stripSqlComments(sql);
+    let match: RegExpMatchArray | null = null;
+    if (op === 'insert') match = normalized.match(/\binsert\s+into\s+([^\s(]+)/i);
+    else if (op === 'update') match = normalized.match(/\bupdate\s+([^\s(]+)/i);
+    else if (op === 'delete') match = normalized.match(/\bdelete\s+from\s+([^\s(]+)/i);
+    else if (op === 'merge') match = normalized.match(/\bmerge\s+into\s+([^\s(]+)/i);
+    else match = normalized.match(/\bfrom\s+([^\s(]+)/i);
+    return cleanSqlIdentifier(match?.[1]) ?? 'unknown';
+}
+
+function buildPostgresQueryPayload(
+    sql: string,
+    parameters: any[],
+    source: PostgreSqlSource,
+    extra?: Record<string, any>,
+): Record<string, any> {
+    return {
+        sql,
+        parameters,
+        library: source.library,
+        driver: source.driver,
+        ...(extra ?? {}),
+    };
+}
+
+function summarizePostgresError(error: any): Record<string, any> {
+    return {
+        name: error?.name ?? 'Error',
+        message: error?.message ?? String(error),
+        code: error?.code,
+        severity: error?.severity,
+        detail: error?.detail,
+        hint: error?.hint,
+        position: error?.position,
+        internalPosition: error?.internalPosition,
+        internalQuery: error?.internalQuery,
+        where: error?.where,
+        schema: error?.schema,
+        table: error?.table,
+        column: error?.column,
+        dataType: error?.dataType,
+        constraint: error?.constraint,
+        file: error?.file,
+        line: error?.line,
+        routine: error?.routine,
+    };
+}
+
+function normalizePgQueryInput(config: any, values: any): { sql: string; parameters: any[]; extra?: Record<string, any> } {
+    if (typeof config === 'string') {
+        return { sql: config, parameters: Array.isArray(values) ? values : [] };
+    }
+    const sql = typeof config?.text === 'string' ? config.text : '';
+    const parameters = Array.isArray(config?.values)
+        ? config.values
+        : Array.isArray(values)
+            ? values
+            : [];
+    return {
+        sql,
+        parameters,
+        extra: {
+            name: typeof config?.name === 'string' ? config.name : undefined,
+            rowMode: config?.rowMode,
+            binary: config?.binary,
+        },
+    };
+}
+
+function normalizePgResult(result: any): any {
+    if (Array.isArray(result)) return result.map(normalizePgResult);
+    if (!result || typeof result !== 'object') return result;
+    return {
+        command: result.command,
+        rowCount: result.rowCount,
+        oid: result.oid,
+        fields: Array.isArray(result.fields)
+            ? result.fields.map((field: any) => ({
+                name: field?.name,
+                tableID: field?.tableID,
+                columnID: field?.columnID,
+                dataTypeID: field?.dataTypeID,
+                dataTypeSize: field?.dataTypeSize,
+                dataTypeModifier: field?.dataTypeModifier,
+                format: field?.format,
+            }))
+            : undefined,
+        rows: result.rows,
+    };
+}
+
+function emitPostgreSqlResult(
+    capture: PostgreSqlCaptureContext,
+    sql: string,
+    parameters: any[],
+    startedAt: number,
+    result: any,
+    error?: any,
+    extra?: Record<string, any>,
+): void {
+    const op = normalizeSqlOperation(sql);
+    emitDbQuery(capture.cfg, capture.sid, capture.aid ?? undefined, {
+        type: 'postgresql',
+        collection: resolveSqlTable(sql, op),
+        op,
+        queryRaw: buildPostgresQueryPayload(sql, parameters, capture.source, extra),
+        resultMetaRaw: error ? undefined : result,
+        error: error ? summarizePostgresError(error) : undefined,
+        durMs: Date.now() - startedAt,
+        t: alignedNow(),
+        spanContext: capture.spanContext,
+    });
+}
+
+function findPgCallbackIndex(args: any[]): number {
+    for (let i = args.length - 1; i >= 1; i -= 1) {
+        if (typeof args[i] === 'function') return i;
+    }
+    return -1;
+}
+
+function patchPgClientPrototype(proto: any): void {
+    if (!proto || proto[PG_CLIENT_PATCHED]) return;
+    const original = proto.query;
+    if (typeof original !== 'function') return;
+    try {
+        Object.defineProperty(proto, PG_CLIENT_PATCHED, { value: true, configurable: true });
+    } catch {
+        return;
+    }
+
+    proto.query = function reproPatchedPgQuery(this: any, ...args: any[]) {
+        if (pgPoolQueryAls.getStore()) return original.apply(this, args);
+        const capture = resolvePostgreSqlCaptureContext({ library: 'pg', driver: 'pg' }, this);
+        if (!capture) return original.apply(this, args);
+
+        const input = normalizePgQueryInput(args[0], args[1]);
+        const startedAt = Date.now();
+        const callbackIndex = findPgCallbackIndex(args);
+        const actualArgs = callbackIndex >= 0 ? [...args] : args;
+        let emitted = false;
+        const emitSuccess = (result: any) => {
+            if (emitted) return;
+            emitted = true;
+            emitPostgreSqlResult(
+                capture,
+                input.sql,
+                input.parameters,
+                startedAt,
+                normalizePgResult(result),
+                undefined,
+                input.extra,
+            );
+        };
+        const emitFailure = (error: any) => {
+            if (emitted) return;
+            emitted = true;
+            emitPostgreSqlResult(capture, input.sql, input.parameters, startedAt, undefined, error, input.extra);
+        };
+
+        if (callbackIndex >= 0) {
+            const callback = args[callbackIndex];
+            actualArgs[callbackIndex] = function reproPgQueryCallback(this: any, error: any, result: any, ...rest: any[]) {
+                if (error) emitFailure(error);
+                else emitSuccess(result);
+                return callback.call(this, error, result, ...rest);
+            };
+        }
+
+        try {
+            const returned = original.apply(this, actualArgs);
+            if (returned && typeof returned.then === 'function') {
+                return returned.then(
+                    (result: any) => {
+                        emitSuccess(result);
+                        return result;
+                    },
+                    (error: any) => {
+                        emitFailure(error);
+                        throw error;
+                    },
+                );
+            }
+            if (returned && callbackIndex < 0 && typeof returned.once === 'function') {
+                returned.once('end', emitSuccess);
+                returned.once('error', emitFailure);
+            }
+            return returned;
+        } catch (error) {
+            emitFailure(error);
+            throw error;
+        }
+    };
+}
+
+function patchPgPoolPrototype(proto: any): void {
+    if (!proto || proto[PG_POOL_PATCHED]) return;
+    const original = proto.query;
+    if (typeof original !== 'function') return;
+    try {
+        Object.defineProperty(proto, PG_POOL_PATCHED, { value: true, configurable: true });
+    } catch {
+        return;
+    }
+
+    proto.query = function reproPatchedPgPoolQuery(this: any, ...args: any[]) {
+        const capture = resolvePostgreSqlCaptureContext({ library: 'pg', driver: 'pg' }, this);
+        if (!capture) return original.apply(this, args);
+
+        const input = normalizePgQueryInput(args[0], args[1]);
+        const startedAt = Date.now();
+        const callbackIndex = findPgCallbackIndex(args);
+        const actualArgs = callbackIndex >= 0 ? [...args] : args;
+        let emitted = false;
+        const emitSuccess = (result: any) => {
+            if (emitted) return;
+            emitted = true;
+            emitPostgreSqlResult(
+                capture,
+                input.sql,
+                input.parameters,
+                startedAt,
+                normalizePgResult(result),
+                undefined,
+                input.extra,
+            );
+        };
+        const emitFailure = (error: any) => {
+            if (emitted) return;
+            emitted = true;
+            emitPostgreSqlResult(capture, input.sql, input.parameters, startedAt, undefined, error, input.extra);
+        };
+
+        if (callbackIndex >= 0) {
+            const callback = args[callbackIndex];
+            actualArgs[callbackIndex] = function reproPgPoolQueryCallback(this: any, error: any, result: any, ...rest: any[]) {
+                if (error) emitFailure(error);
+                else emitSuccess(result);
+                return callback.call(this, error, result, ...rest);
+            };
+        }
+
+        try {
+            const returned = pgPoolQueryAls.run(true, () => original.apply(this, actualArgs));
+            if (returned && typeof returned.then === 'function') {
+                return returned.then(
+                    (result: any) => {
+                        emitSuccess(result);
+                        return result;
+                    },
+                    (error: any) => {
+                        emitFailure(error);
+                        throw error;
+                    },
+                );
+            }
+            return returned;
+        } catch (error) {
+            emitFailure(error);
+            throw error;
+        }
+    };
+}
+
+function patchPgFromModuleExports(pgModule: any): void {
+    if (!pgModule) return;
+    const candidates = [pgModule, pgModule.default];
+    for (const candidate of candidates) {
+        patchPgClientPrototype(candidate?.Client?.prototype);
+        patchPgClientPrototype(candidate?.native?.Client?.prototype);
+        patchPgPoolPrototype(candidate?.Pool?.prototype);
+        patchPgPoolPrototype(candidate?.native?.Pool?.prototype);
+    }
+}
+
+function installPgRequireHook(): void {
+    if (pgRequireHookInstalled) return;
+    pgRequireHookInstalled = true;
+    try {
+        const rim = requireOptionalHostModule('require-in-the-middle');
+        const Hook = rim?.Hook ?? rim;
+        if (typeof Hook !== 'function') return;
+        // eslint-disable-next-line no-new
+        new Hook(['pg'], (exports: any) => {
+            patchPgFromModuleExports(exports);
+            return exports;
+        });
+    } catch {}
+}
+
+function normalizePostgresJsInput(query: any): { sql: string; parameters: any[]; extra: Record<string, any> } {
+    if (typeof query?.statement?.string === 'string') {
+        return {
+            sql: query.statement.string,
+            parameters: Array.isArray(query?.parameters) ? query.parameters : [],
+            extra: {
+                tagged: query?.tagged === true,
+                parameterTypes: Array.isArray(query?.statement?.types) ? query.statement.types : undefined,
+            },
+        };
+    }
+    const strings = Array.isArray(query?.strings) ? query.strings : [];
+    const parameters = Array.isArray(query?.args) ? query.args : [];
+    if (query?.tagged) {
+        return {
+            sql: strings.map((part: any, index: number) => `${String(part)}${index < parameters.length ? `$${index + 1}` : ''}`).join(''),
+            parameters,
+            extra: { tagged: true },
+        };
+    }
+    return {
+        sql: typeof strings[0] === 'string' ? strings[0] : '',
+        parameters,
+        extra: { tagged: false },
+    };
+}
+
+function normalizePostgresJsResult(result: any): any {
+    if (!Array.isArray(result)) return result;
+    const metadata = result as any;
+    return {
+        command: metadata.command,
+        count: metadata.count,
+        columns: Array.isArray(metadata.columns)
+            ? metadata.columns.map((column: any) => ({
+                name: column?.name,
+                type: column?.type,
+                table: column?.table,
+                number: column?.number,
+            }))
+            : undefined,
+        rows: Array.from(result),
+    };
+}
+
+function patchPostgresJsQueryPrototype(proto: any): void {
+    if (!proto || proto[POSTGRES_JS_QUERY_PATCHED]) return;
+    const originalHandle = proto.handle;
+    if (typeof originalHandle !== 'function') return;
+    try {
+        Object.defineProperty(proto, POSTGRES_JS_QUERY_PATCHED, { value: true, configurable: true });
+    } catch {
+        return;
+    }
+
+    proto.handle = function reproPatchedPostgresJsHandle(this: any, ...args: any[]) {
+        if (!this.__repro_postgres_capture_attached) {
+            const capture = resolvePostgreSqlCaptureContext({ library: 'postgres', driver: 'postgres' }, this);
+            if (capture) {
+                try {
+                    Object.defineProperty(this, '__repro_postgres_capture_attached', { value: true, configurable: true });
+                } catch {
+                    this.__repro_postgres_capture_attached = true;
+                }
+                const input = normalizePostgresJsInput(this);
+                const startedAt = Date.now();
+                Promise.prototype.then.call(
+                    this,
+                    (result: any) => {
+                        const executedInput = normalizePostgresJsInput(this);
+                        emitPostgreSqlResult(
+                            capture,
+                            executedInput.sql || input.sql,
+                            executedInput.parameters,
+                            startedAt,
+                            normalizePostgresJsResult(result),
+                            undefined,
+                            executedInput.extra,
+                        );
+                        return result;
+                    },
+                    (error: any) => {
+                        const executedInput = normalizePostgresJsInput(this);
+                        emitPostgreSqlResult(
+                            capture,
+                            executedInput.sql || input.sql,
+                            executedInput.parameters.length ? executedInput.parameters : input.parameters,
+                            startedAt,
+                            undefined,
+                            error,
+                            executedInput.extra,
+                        );
+                    },
+                );
+            }
+        }
+        return originalHandle.apply(this, args);
+    };
+}
+
+function patchPostgresJsFromModuleExports(postgresModule: any): void {
+    const factories = new Set<any>();
+    const addFactory = (candidate: any) => {
+        if (typeof candidate !== 'function') return;
+        // getLoadedModuleExportsByPackage also returns internal postgres.js
+        // helpers. Only the public factory carries these static exports.
+        if (!candidate.PostgresError && !candidate.BigInt && !candidate.__repro_postgres_factory) return;
+        factories.add(candidate);
+    };
+    addFactory(postgresModule);
+    addFactory(postgresModule?.default);
+
+    for (const factory of factories) {
+        let sql: any;
+        try {
+            sql = factory({ max: 1, idle_timeout: 1, connect_timeout: 1 });
+            const query = sql.unsafe('select 1');
+            patchPostgresJsQueryPrototype(Object.getPrototypeOf(query));
+        } catch {}
+        try {
+            const ended = sql?.end?.({ timeout: 0 });
+            if (ended && typeof ended.catch === 'function') ended.catch(() => undefined);
+        } catch {}
+    }
+}
+
+function installPostgresJsRequireHook(): void {
+    if (postgresJsRequireHookInstalled) return;
+    postgresJsRequireHookInstalled = true;
+    try {
+        const rim = requireOptionalHostModule('require-in-the-middle');
+        const Hook = rim?.Hook ?? rim;
+        if (typeof Hook !== 'function') return;
+        // eslint-disable-next-line no-new
+        new Hook(['postgres'], (exports: any) => {
+            patchPostgresJsFromModuleExports(exports);
+            return exports;
+        });
+    } catch {}
+}
+
+function patchTypeOrmQueryRunner(queryRunner: any): any {
+    if (!queryRunner || queryRunner[TYPEORM_QUERY_RUNNER_PATCHED]) return queryRunner;
+    const original = queryRunner.query;
+    if (typeof original !== 'function') return queryRunner;
+    try {
+        Object.defineProperty(queryRunner, TYPEORM_QUERY_RUNNER_PATCHED, { value: true, configurable: true });
+    } catch {
+        return queryRunner;
+    }
+    queryRunner.query = function reproPatchedTypeOrmQuery(this: any, ...args: any[]) {
+        return postgresSqlSourceAls.run(
+            { library: 'typeorm', driver: 'pg' },
+            () => original.apply(this, args),
+        );
+    };
+    return queryRunner;
+}
+
+function patchTypeOrmDataSourcePrototype(proto: any): void {
+    if (!proto || proto[TYPEORM_DATASOURCE_PATCHED]) return;
+    const original = proto.createQueryRunner;
+    if (typeof original !== 'function') return;
+    try {
+        Object.defineProperty(proto, TYPEORM_DATASOURCE_PATCHED, { value: true, configurable: true });
+    } catch {
+        return;
+    }
+    proto.createQueryRunner = function reproPatchedCreateQueryRunner(this: any, ...args: any[]) {
+        return patchTypeOrmQueryRunner(original.apply(this, args));
+    };
+}
+
+function patchTypeOrmFromModuleExports(typeOrmModule: any): void {
+    if (!typeOrmModule) return;
+    patchTypeOrmDataSourcePrototype(typeOrmModule?.DataSource?.prototype);
+    patchTypeOrmDataSourcePrototype(typeOrmModule?.Connection?.prototype);
+    patchTypeOrmDataSourcePrototype(typeOrmModule?.default?.DataSource?.prototype);
+}
+
+function installTypeOrmRequireHook(): void {
+    if (typeOrmRequireHookInstalled) return;
+    typeOrmRequireHookInstalled = true;
+    try {
+        const rim = requireOptionalHostModule('require-in-the-middle');
+        const Hook = rim?.Hook ?? rim;
+        if (typeof Hook !== 'function') return;
+        // eslint-disable-next-line no-new
+        new Hook(['typeorm'], (exports: any) => {
+            patchTypeOrmFromModuleExports(exports);
+            return exports;
+        });
+    } catch {}
+}
+
+export function patchPostgreSql(cfg: PostgreSqlPatchConfig): void {
+    registerPostgreSqlPatchConfig(cfg);
+    installPgRequireHook();
+    installPostgresJsRequireHook();
+    installTypeOrmRequireHook();
+
+    const pgModules = new Set<any>();
+    const pg = requireOptionalHostModule('pg');
+    if (pg) pgModules.add(pg);
+    for (const loaded of getLoadedModuleExportsByPackage('pg')) pgModules.add(loaded);
+    for (const loaded of pgModules) patchPgFromModuleExports(loaded);
+
+    const postgresModules = new Set<any>();
+    const postgres = requireOptionalHostModule('postgres');
+    if (postgres) postgresModules.add(postgres);
+    for (const loaded of getLoadedModuleExportsByPackage('postgres')) postgresModules.add(loaded);
+    for (const loaded of postgresModules) patchPostgresJsFromModuleExports(loaded);
+
+    const typeOrmModules = new Set<any>();
+    const typeOrm = requireOptionalHostModule('typeorm');
+    if (typeOrm) typeOrmModules.add(typeOrm);
+    for (const loaded of getLoadedModuleExportsByPackage('typeorm')) typeOrmModules.add(loaded);
+    for (const loaded of typeOrmModules) patchTypeOrmFromModuleExports(loaded);
+}
+
 // ===================================================================
 // Native MongoDB driver integration
 // ===================================================================
@@ -10713,6 +11359,7 @@ export async function initRepro(cfg: ReproInitConfig): Promise<void> {
     patchKafkaJs(integrationCfg);
     patchAmqplib(integrationCfg);
     patchRedis(integrationCfg);
+    patchPostgreSql(integrationCfg);
     patchMongoDb(integrationCfg);
     await installMongoDbImportHook();
     patchSendgridMail(integrationCfg);
@@ -10779,6 +11426,9 @@ export const __reproTestHooks = {
     patchAmqplibConnectionForTest: patchAmqplibConnection,
     patchAmqplibChannelForTest: patchAmqplibChannel,
     wrapAmqplibConsumeHandlerForTest: wrapAmqplibConsumeHandler,
+    patchPgModuleForTest: patchPgFromModuleExports,
+    patchPostgresJsModuleForTest: patchPostgresJsFromModuleExports,
+    patchTypeOrmModuleForTest: patchTypeOrmFromModuleExports,
     patchMongoDbModuleForTest: patchMongoDbFromModuleExports,
     patchMongoCollectionPrototypeForTest: patchMongoCollectionPrototype,
     chunkTraceEventsForTransportForTest: chunkTraceEventsForTransport,