@reproapp/node-sdk 0.0.38 → 0.0.41

package/test/postgresql-integration.test.js

@@ -0,0 +1,302 @@
+process.env.REPRO_INGEST_REQUEST_TIMEOUT_MS = '50';
+process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS = '25';
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = '0';
+
+const assert = require('assert');
+const { flushIngestQueue } = require('../dist/ingest/client');
+const { patchPostgreSql, __reproTestHooks } = require('../dist');
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function waitFor(predicate, timeoutMs = 2000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (predicate()) return;
+        await sleep(20);
+    }
+    assert(predicate(), 'timed out waiting for expected PostgreSQL evidence');
+}
+
+function flattenEvents(posts) {
+    return posts.flatMap((body) => Array.isArray(body?.events) ? body.events : []);
+}
+
+function dbChanges(posts) {
+    return flattenEvents(posts)
+        .filter((event) => event.event_type === 'db_change')
+        .flatMap((event) => Array.isArray(event.payload?.db) ? event.payload.db : []);
+}
+
+function dbValues(posts) {
+    return flattenEvents(posts)
+        .filter((event) => event.event_type === 'db_change')
+        .flatMap((event) => Array.isArray(event.payload?.dbValues) ? event.payload.dbValues : []);
+}
+
+async function drainSdk() {
+    await __reproTestHooks.drainSdkBackgroundQueueForTest();
+    await flushIngestQueue();
+}
+
+async function capture(fn) {
+    const posts = [];
+    const originalFetch = global.fetch;
+    global.fetch = async (_url, init) => {
+        posts.push(JSON.parse(String(init?.body ?? '{}')));
+        return {
+            ok: true,
+            status: 202,
+            json: async () => ({ ok: true }),
+            text: async () => '{"ok":true}',
+        };
+    };
+    try {
+        __reproTestHooks.resetSdkBackgroundQueuesForTest();
+        await fn(posts);
+        await waitFor(() => dbChanges(posts).length > 0);
+        await drainSdk();
+        return posts;
+    } finally {
+        await drainSdk().catch(() => {});
+        global.fetch = originalFetch;
+    }
+}
+
+function config() {
+    return {
+        tenantId: 'TENANT_postgresql_test',
+        appId: 'APP_postgresql_test',
+        appSecret: 'secret',
+        captureHeaders: false,
+        privacy: { environment: 'dev', captureRaw: true },
+        ingestBase: 'http://127.0.0.1:65535',
+    };
+}
+
+class FakePgClient {
+    query(input, values, callback) {
+        const cb = typeof values === 'function' ? values : callback;
+        const text = typeof input === 'string' ? input : input.text;
+        const params = Array.isArray(values) ? values : input.values || [];
+        const execute = () => {
+            if (text.includes('broken')) {
+                const error = Object.assign(new Error('relation does not exist'), {
+                    code: '42P01',
+                    severity: 'ERROR',
+                    table: 'missing_table',
+                });
+                if (cb) return void setImmediate(() => cb(error));
+                return Promise.reject(error);
+            }
+            const result = {
+                command: text.trim().split(/\s+/)[0].toUpperCase(),
+                rowCount: 1,
+                fields: [{ name: 'email', dataTypeID: 25 }],
+                rows: [{ email: params[0], nested: { complete: true } }],
+            };
+            if (cb) return void setImmediate(() => cb(null, result));
+            return Promise.resolve(result);
+        };
+        return execute();
+    }
+}
+
+class FakePostgresQuery extends Promise {
+    constructor(strings, args, result) {
+        let resolve;
+        let reject;
+        super((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        this.tagged = Array.isArray(strings?.raw);
+        this.strings = strings;
+        this.args = args;
+        this.result = result;
+        this.resolveQuery = resolve;
+        this.rejectQuery = reject;
+        this.executed = false;
+    }
+
+    static get [Symbol.species]() {
+        return Promise;
+    }
+
+    handle() {
+        if (this.executed) return;
+        this.executed = true;
+        setImmediate(() => this.resolveQuery(this.result));
+    }
+
+    then(...args) {
+        this.handle();
+        return super.then(...args);
+    }
+
+    catch(...args) {
+        this.handle();
+        return super.catch(...args);
+    }
+
+    finally(...args) {
+        this.handle();
+        return super.finally(...args);
+    }
+}
+
+function makeFakePostgresModule() {
+    const result = [{ id: 7, title: 'postgres.js row', details: { retained: true } }];
+    result.command = 'SELECT';
+    result.count = 1;
+    result.columns = [{ name: 'title', type: 25, table: 42, number: 2 }];
+
+    function postgres() {
+        const sql = (strings, ...args) => new FakePostgresQuery(strings, args, result);
+        sql.unsafe = (text, args = []) => new FakePostgresQuery([text], args, result);
+        sql.end = async () => {};
+        return sql;
+    }
+    postgres.__repro_postgres_factory = true;
+    return postgres;
+}
+
+async function testPgPromiseCallbackAndError() {
+    const cfg = config();
+    patchPostgreSql(cfg);
+    __reproTestHooks.patchPgModuleForTest({ Client: FakePgClient });
+    const posts = await capture(async (capturedPosts) => {
+        await __reproTestHooks.runWithRequestContextForTest(
+            { sid: 'S_pg', aid: 'A_pg', rid: 'R_pg' },
+            async () => {
+                const client = new FakePgClient();
+                const result = await client.query({
+                    text: 'SELECT email FROM app_users WHERE email = $1',
+                    values: ['pg-user@getrepro.local'],
+                    name: 'find-app-user',
+                });
+                assert.strictEqual(result.rows[0].nested.complete, true);
+
+                await new Promise((resolve, reject) => {
+                    client.query(
+                        'INSERT INTO app_users(email) VALUES($1) RETURNING email',
+                        ['callback@getrepro.local'],
+                        (error, callbackResult) => {
+                            if (error) reject(error);
+                            else {
+                                assert.strictEqual(callbackResult.rows[0].email, 'callback@getrepro.local');
+                                resolve();
+                            }
+                        },
+                    );
+                });
+
+                await assert.rejects(
+                    client.query('SELECT * FROM broken_table', []),
+                    (error) => error.code === '42P01',
+                );
+            },
+        );
+        await waitFor(() => dbChanges(capturedPosts).length === 3);
+    });
+
+    const changes = dbChanges(posts);
+    assert.strictEqual(changes.length, 3);
+    assert.deepStrictEqual(changes.map((change) => change.op), ['select', 'insert', 'select']);
+    assert.strictEqual(changes[0].type, 'postgresql');
+    assert.strictEqual(changes[0].collection, 'app_users');
+    assert.strictEqual(changes[0].query.library, 'pg');
+    assert.deepStrictEqual(changes[0].query.parameters, ['pg-user@getrepro.local']);
+    assert.strictEqual(changes[1].collection, 'app_users');
+    assert.strictEqual(changes[2].error.code, '42P01');
+    assert(dbValues(posts).some((entry) => (
+        entry.target === 'db.resultMeta' &&
+        entry.value?.rows?.[0]?.nested?.complete === true
+    )), JSON.stringify(dbValues(posts)));
+}
+
+async function testPostgresJsLazyExecution() {
+    const cfg = config();
+    patchPostgreSql(cfg);
+    const postgres = makeFakePostgresModule();
+    __reproTestHooks.patchPostgresJsModuleForTest(postgres);
+
+    const posts = await capture(async (capturedPosts) => {
+        await __reproTestHooks.runWithRequestContextForTest(
+            { sid: 'S_postgres_js', aid: 'A_postgres_js', rid: 'R_postgres_js' },
+            async () => {
+                const sql = postgres();
+                const title = 'lazy execution';
+                const query = sql`SELECT id, title, details FROM work_items WHERE title = ${title}`;
+                await sleep(20);
+                assert.strictEqual(dbChanges(capturedPosts).length, 0, 'unexecuted lazy query must not emit evidence');
+                const rows = await query;
+                assert.strictEqual(rows[0].details.retained, true);
+            },
+        );
+    });
+
+    const [change] = dbChanges(posts);
+    assert.strictEqual(change.type, 'postgresql');
+    assert.strictEqual(change.collection, 'work_items');
+    assert.strictEqual(change.query.library, 'postgres');
+    assert.strictEqual(change.query.driver, 'postgres');
+    assert.strictEqual(change.query.sql, 'SELECT id, title, details FROM work_items WHERE title = $1');
+    assert.deepStrictEqual(change.query.parameters, ['lazy execution']);
+    assert(dbValues(posts).some((entry) => (
+        entry.target === 'db.resultMeta' &&
+        entry.value?.rows?.[0]?.details?.retained === true
+    )), JSON.stringify(dbValues(posts)));
+}
+
+async function testTypeOrmDelegatesToPgWithoutDuplicateEvidence() {
+    const cfg = config();
+    patchPostgreSql(cfg);
+    __reproTestHooks.patchPgModuleForTest({ Client: FakePgClient });
+
+    class FakeDataSource {
+        constructor(client) {
+            this.client = client;
+        }
+
+        createQueryRunner() {
+            return {
+                query: (sql, parameters) => this.client.query(sql, parameters),
+            };
+        }
+    }
+
+    __reproTestHooks.patchTypeOrmModuleForTest({ DataSource: FakeDataSource });
+    const posts = await capture(async () => {
+        await __reproTestHooks.runWithRequestContextForTest(
+            { sid: 'S_typeorm', aid: 'A_typeorm', rid: 'R_typeorm' },
+            async () => {
+                const dataSource = new FakeDataSource(new FakePgClient());
+                const result = await dataSource
+                    .createQueryRunner()
+                    .query('UPDATE inventory SET quantity = $1 WHERE id = $2 RETURNING *', [19, 7]);
+                assert.strictEqual(result.rowCount, 1);
+            },
+        );
+    });
+
+    const changes = dbChanges(posts);
+    assert.strictEqual(changes.length, 1, JSON.stringify(changes));
+    assert.strictEqual(changes[0].op, 'update');
+    assert.strictEqual(changes[0].collection, 'inventory');
+    assert.strictEqual(changes[0].query.library, 'typeorm');
+    assert.strictEqual(changes[0].query.driver, 'pg');
+    assert.deepStrictEqual(changes[0].query.parameters, [19, 7]);
+}
+
+async function main() {
+    await testPgPromiseCallbackAndError();
+    await testPostgresJsLazyExecution();
+    await testTypeOrmDelegatesToPgWithoutDuplicateEvidence();
+    console.log('postgresql integration tests OK');
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/test/postgresql-integrations.testcontainers.test.js

@@ -0,0 +1,261 @@
+process.env.REPRO_INGEST_REQUEST_TIMEOUT_MS = '100';
+process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS = '25';
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = '0';
+
+const assert = require('assert');
+require('reflect-metadata');
+const { GenericContainer, Wait } = require('testcontainers');
+const { flushIngestQueue } = require('../dist/ingest/client');
+const { patchPostgreSql, __reproTestHooks } = require('../dist');
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function waitFor(predicate, timeoutMs = 5000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (predicate()) return;
+        await sleep(25);
+    }
+    assert(predicate(), 'timed out waiting for PostgreSQL evidence materialization');
+}
+
+function flattenEvents(posts) {
+    return posts.flatMap((body) => Array.isArray(body?.events) ? body.events : []);
+}
+
+function dbChanges(posts) {
+    return flattenEvents(posts)
+        .filter((event) => event.event_type === 'db_change')
+        .flatMap((event) => Array.isArray(event.payload?.db) ? event.payload.db : []);
+}
+
+function dbValues(posts) {
+    return flattenEvents(posts)
+        .filter((event) => event.event_type === 'db_change')
+        .flatMap((event) => Array.isArray(event.payload?.dbValues) ? event.payload.dbValues : []);
+}
+
+async function startPostgres() {
+    if (process.env.REPRO_POSTGRES_TEST_URL) {
+        return { url: process.env.REPRO_POSTGRES_TEST_URL, stop: async () => {} };
+    }
+    const container = await new GenericContainer('postgres:16-alpine')
+        .withEnvironment({
+            POSTGRES_USER: 'repro',
+            POSTGRES_PASSWORD: 'repro',
+            POSTGRES_DB: 'repro_sdk_test',
+        })
+        .withExposedPorts(5432)
+        .withTmpFs({ '/var/lib/postgresql/data': 'rw,noexec,nosuid,size=1g' })
+        .withWaitStrategy(Wait.forLogMessage(/database system is ready to accept connections/))
+        .start();
+    return {
+        url: `postgresql://repro:repro@${container.getHost()}:${container.getMappedPort(5432)}/repro_sdk_test`,
+        stop: () => container.stop(),
+    };
+}
+
+async function main() {
+    const posts = [];
+    const originalFetch = global.fetch;
+    global.fetch = async (_url, init) => {
+        posts.push(JSON.parse(String(init?.body ?? '{}')));
+        return {
+            ok: true,
+            status: 202,
+            json: async () => ({ ok: true }),
+            text: async () => '{"ok":true}',
+        };
+    };
+
+    let postgresContainer;
+    let pool;
+    let postgresSql;
+    let standaloneDataSource;
+    let nestContext;
+    try {
+        postgresContainer = await startPostgres();
+        const cfg = {
+            tenantId: 'TENANT_postgresql_container',
+            appId: 'APP_postgresql_container',
+            appSecret: 'secret',
+            captureHeaders: false,
+            privacy: { environment: 'dev', captureRaw: true },
+            ingestBase: 'http://127.0.0.1:65535',
+        };
+        patchPostgreSql(cfg);
+
+        const { Pool } = require('pg');
+        const postgres = require('postgres');
+        const { DataSource, EntitySchema } = require('typeorm');
+        const { Injectable, Module } = require('@nestjs/common');
+        const { NestFactory } = require('@nestjs/core');
+        const { InjectRepository, TypeOrmModule } = require('@nestjs/typeorm');
+
+        pool = new Pool({ connectionString: postgresContainer.url });
+        postgresSql = postgres(postgresContainer.url, { max: 2 });
+        await pool.query(`
+            CREATE TABLE IF NOT EXISTS pg_accounts (
+                id SERIAL PRIMARY KEY,
+                email TEXT NOT NULL,
+                profile JSONB NOT NULL
+            )
+        `);
+        await pool.query(`
+            CREATE TABLE IF NOT EXISTS postgres_jobs (
+                id SERIAL PRIMARY KEY,
+                title TEXT NOT NULL,
+                metadata JSONB NOT NULL
+            )
+        `);
+
+        const StandaloneRecord = new EntitySchema({
+            name: 'StandaloneRecord',
+            tableName: 'typeorm_standalone_records',
+            columns: {
+                id: { type: Number, primary: true, generated: true },
+                label: { type: String },
+                details: { type: 'jsonb' },
+            },
+        });
+        standaloneDataSource = new DataSource({
+            type: 'postgres',
+            url: postgresContainer.url,
+            synchronize: true,
+            entities: [StandaloneRecord],
+        });
+        await standaloneDataSource.initialize();
+
+        const NestRecord = new EntitySchema({
+            name: 'NestRecord',
+            tableName: 'typeorm_nest_records',
+            columns: {
+                id: { type: Number, primary: true, generated: true },
+                actorId: { type: String },
+                payload: { type: 'jsonb' },
+            },
+        });
+
+        class NestRecordService {
+            constructor(repository) {
+                this.repository = repository;
+            }
+            async create(actorId) {
+                return this.repository.save(this.repository.create({
+                    actorId,
+                    payload: { source: 'nestjs-typeorm', complete: true },
+                }));
+            }
+            async find(actorId) {
+                return this.repository.find({ where: { actorId } });
+            }
+        }
+        Injectable()(NestRecordService);
+        InjectRepository(NestRecord)(NestRecordService, undefined, 0);
+
+        class NestPgModule {}
+        Module({
+            imports: [
+                TypeOrmModule.forRoot({
+                    type: 'postgres',
+                    url: postgresContainer.url,
+                    synchronize: true,
+                    entities: [NestRecord],
+                }),
+                TypeOrmModule.forFeature([NestRecord]),
+            ],
+            providers: [NestRecordService],
+        })(NestPgModule);
+        nestContext = await NestFactory.createApplicationContext(NestPgModule, { logger: false });
+        const nestService = nestContext.get(NestRecordService);
+
+        await __reproTestHooks.runWithRequestContextForTest(
+            { sid: 'S_postgresql_all', aid: 'A_postgresql_all', rid: 'R_postgresql_all' },
+            async () => {
+                const pgInsert = await pool.query(
+                    'INSERT INTO pg_accounts(email, profile) VALUES($1, $2) RETURNING *',
+                    ['container@getrepro.local', { driver: 'pg', complete: true }],
+                );
+                assert.strictEqual(pgInsert.rows[0].profile.complete, true);
+
+                const pgSelected = await pool.query(
+                    'SELECT * FROM pg_accounts WHERE email = $1',
+                    ['container@getrepro.local'],
+                );
+                assert.strictEqual(pgSelected.rowCount, 1);
+
+                const [postgresJob] = await postgresSql`
+                    INSERT INTO postgres_jobs(title, metadata)
+                    VALUES (${'container job'}, ${postgresSql.json({ driver: 'postgres', complete: true })})
+                    RETURNING *
+                `;
+                assert.strictEqual(postgresJob.metadata.complete, true);
+
+                const standaloneRepository = standaloneDataSource.getRepository(StandaloneRecord);
+                await standaloneRepository.save(standaloneRepository.create({
+                    label: 'standalone typeorm',
+                    details: { source: 'typeorm', complete: true },
+                }));
+                const standaloneRows = await standaloneRepository.findBy({ label: 'standalone typeorm' });
+                assert.strictEqual(standaloneRows[0].details.complete, true);
+
+                await nestService.create('actor-nest-container');
+                const nestRows = await nestService.find('actor-nest-container');
+                assert.strictEqual(nestRows[0].payload.complete, true);
+            },
+        );
+
+        await waitFor(() => dbChanges(posts).length >= 12);
+        await __reproTestHooks.drainSdkBackgroundQueueForTest();
+        await flushIngestQueue();
+
+        const changes = dbChanges(posts);
+        const values = dbValues(posts);
+        const pgAccountInserts = changes.filter((change) => (
+            change.collection === 'pg_accounts' && change.op === 'insert'
+        ));
+        const postgresJobInserts = changes.filter((change) => (
+            change.collection === 'postgres_jobs' && change.op === 'insert'
+        ));
+        const standaloneInserts = changes.filter((change) => (
+            change.collection === 'typeorm_standalone_records' && change.op === 'insert'
+        ));
+        const nestInserts = changes.filter((change) => (
+            change.collection === 'typeorm_nest_records' && change.op === 'insert'
+        ));
+
+        assert.strictEqual(pgAccountInserts.length, 1, JSON.stringify(changes));
+        assert.strictEqual(pgAccountInserts[0].query.library, 'pg');
+        assert.strictEqual(postgresJobInserts.length, 1, JSON.stringify(postgresJobInserts));
+        assert.strictEqual(postgresJobInserts[0].query.library, 'postgres');
+        assert.strictEqual(standaloneInserts.length, 1, JSON.stringify(standaloneInserts));
+        assert.strictEqual(standaloneInserts[0].query.library, 'typeorm');
+        assert.strictEqual(nestInserts.length, 1, JSON.stringify(changes));
+        assert.strictEqual(nestInserts[0].query.library, 'typeorm');
+        assert(values.some((entry) => (
+            entry.target === 'db.resultMeta' &&
+            JSON.stringify(entry.value).includes('container@getrepro.local')
+        )), 'expected complete pg result rows in a DB value sidecar');
+        assert(values.some((entry) => (
+            entry.target === 'db.resultMeta' &&
+            JSON.stringify(entry.value).includes('actor-nest-container')
+        )), 'expected complete Nest TypeORM result rows in a DB value sidecar');
+
+        console.log(`postgresql testcontainers integrations OK (${changes.length} captured statements)`);
+    } finally {
+        await __reproTestHooks.drainSdkBackgroundQueueForTest().catch(() => {});
+        await flushIngestQueue().catch(() => {});
+        global.fetch = originalFetch;
+        if (nestContext) await nestContext.close().catch(() => {});
+        if (standaloneDataSource?.isInitialized) await standaloneDataSource.destroy().catch(() => {});
+        if (postgresSql) await postgresSql.end({ timeout: 1 }).catch(() => {});
+        if (pool) await pool.end().catch(() => {});
+        if (postgresContainer) await postgresContainer.stop().catch(() => {});
+    }
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/test/request-manifest-priority.test.js

@@ -124,11 +124,17 @@ async function main() {
             .some((event) => event?.event_type === 'request_capture_manifest'));
 
         const eventTypes = flattenEvents(capturedBodies).map((event) => event?.event_type);
+        const startIndex = eventTypes.indexOf('request_capture_start');
         const manifestIndex = eventTypes.indexOf('request_capture_manifest');
         const traceIndex = eventTypes.indexOf('trace_batch');
 
+        assert(startIndex >= 0, JSON.stringify(eventTypes));
         assert(manifestIndex >= 0, JSON.stringify(eventTypes));
         assert(traceIndex >= 0, JSON.stringify(eventTypes));
+        assert(
+            startIndex < manifestIndex,
+            `request_capture_start must be sent before request_capture_manifest; got ${JSON.stringify(eventTypes)}`,
+        );
         assert(
             manifestIndex < traceIndex,
             `request_capture_manifest must be sent before trace_batch; got ${JSON.stringify(eventTypes)}`,