@dbos-inc/pgnotifier-receiver 3.0.38-preview.g8bb2030562

package/tests/dbtriggers.test.ts

@@ -0,0 +1,188 @@
+import { DBOS, DBOSConfig } from '@dbos-inc/dbos-sdk';
+import { DBTrigger, TriggerOperation } from '../src';
+import { ClientBase, Pool, PoolClient } from 'pg';
+
+import { KnexDataSource } from '@dbos-inc/knex-datasource';
+
+const testTableName = 'dbos_test_orders';
+
+const config = {
+  host: process.env.PGHOST || 'localhost',
+  port: parseInt(process.env.PGPORT || '5432'),
+  database: process.env.PGDATABASE || 'postgres',
+  user: process.env.PGUSER || 'postgres',
+  password: process.env.PGPASSWORD || 'dbos',
+};
+const pool = new Pool(config);
+
+const kconfig = { client: 'pg', connection: config };
+
+const knexds = new KnexDataSource('app', kconfig);
+
+const trig = new DBTrigger({
+  connect: async () => {
+    const conn = pool.connect();
+    return conn;
+  },
+  disconnect: async (c: ClientBase) => {
+    (c as PoolClient).release();
+    return Promise.resolve();
+  },
+  query: async <R>(sql: string, params?: unknown[]) => {
+    return (await pool.query(sql, params)).rows as R[];
+  },
+});
+
+function sleepms(ms: number) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+class DBOSTriggerTestClass {
+  static nInserts = 0;
+  static nDeletes = 0;
+  static nUpdates = 0;
+  static recordMap: Map<number, TestTable> = new Map();
+
+  static nWFUpdates = 0;
+  static wfRecordMap: Map<number, TestTable> = new Map();
+
+  static reset() {
+    DBOSTriggerTestClass.nInserts = 0;
+    DBOSTriggerTestClass.nDeletes = 0;
+    DBOSTriggerTestClass.nUpdates = 0;
+    DBOSTriggerTestClass.recordMap = new Map();
+
+    DBOSTriggerTestClass.nWFUpdates = 0;
+    DBOSTriggerTestClass.wfRecordMap = new Map();
+  }
+
+  @trig.trigger({ tableName: testTableName, recordIDColumns: ['order_id'], installDBTrigger: true })
+  static async triggerNonWF(op: TriggerOperation, key: number[], rec: unknown) {
+    if (op === TriggerOperation.RecordDeleted) {
+      ++DBOSTriggerTestClass.nDeletes;
+      DBOSTriggerTestClass.recordMap.delete(key[0]);
+    }
+    if (op === TriggerOperation.RecordInserted) {
+      DBOSTriggerTestClass.recordMap.set(key[0], rec as TestTable);
+      ++DBOSTriggerTestClass.nInserts;
+    }
+    if (op === TriggerOperation.RecordUpdated) {
+      DBOSTriggerTestClass.recordMap.set(key[0], rec as TestTable);
+      ++DBOSTriggerTestClass.nUpdates;
+    }
+    return Promise.resolve();
+  }
+
+  @trig.triggerWorkflow({ tableName: testTableName, recordIDColumns: ['order_id'], installDBTrigger: true })
+  @DBOS.workflow()
+  static async triggerWF(op: TriggerOperation, key: number[], rec: unknown) {
+    DBOS.logger.debug(`WF ${op} - ${JSON.stringify(key)} / ${JSON.stringify(rec)}`);
+    expect(op).toBe(TriggerOperation.RecordUpserted);
+    if (op === TriggerOperation.RecordUpserted) {
+      DBOSTriggerTestClass.wfRecordMap.set(key[0], rec as TestTable);
+      ++DBOSTriggerTestClass.nWFUpdates;
+    }
+    return Promise.resolve();
+  }
+
+  @knexds.transaction()
+  static async insertRecord(rec: TestTable) {
+    await knexds.client<TestTable>(testTableName).insert(rec);
+  }
+
+  @knexds.transaction()
+  static async deleteRecord(order_id: number) {
+    await knexds.client<TestTable>(testTableName).where({ order_id }).delete();
+  }
+
+  @knexds.transaction()
+  static async updateRecordStatus(order_id: number, status: string) {
+    await knexds.client<TestTable>(testTableName).where({ order_id }).update({ status });
+  }
+}
+
+interface TestTable {
+  order_id: number;
+  order_date: Date;
+  price: number;
+  item: string;
+  status: string;
+}
+
+describe('test-db-triggers', () => {
+  beforeAll(async () => {});
+
+  beforeEach(async () => {
+    await KnexDataSource.initializeDBOSSchema(kconfig);
+    const config: DBOSConfig = {
+      name: 'dbtrigg',
+    };
+    DBOS.setConfig(config);
+    await trig.db.query(`DROP TABLE IF EXISTS ${testTableName};`);
+    await trig.db.query(`
+            CREATE TABLE IF NOT EXISTS ${testTableName}(
+              order_id SERIAL PRIMARY KEY,
+              order_date TIMESTAMP,
+              price DECIMAL(10,2),
+              item TEXT,
+              status VARCHAR(10)
+            );`);
+    DBOSTriggerTestClass.reset();
+    await DBOS.launch();
+  });
+
+  afterEach(async () => {
+    await DBOS.shutdown();
+    await trig.db.query(`DROP TABLE IF EXISTS ${testTableName};`);
+  });
+
+  test('trigger-nonwf', async () => {
+    await DBOSTriggerTestClass.insertRecord({
+      order_id: 1,
+      order_date: new Date(),
+      price: 10,
+      item: 'Spacely Sprocket',
+      status: 'Ordered',
+    });
+    while (DBOSTriggerTestClass.nInserts < 1) await sleepms(10);
+    expect(DBOSTriggerTestClass.nInserts).toBe(1);
+    expect(DBOSTriggerTestClass.recordMap.get(1)?.status).toBe('Ordered');
+    while (DBOSTriggerTestClass.nWFUpdates < 1) await sleepms(10);
+    expect(DBOSTriggerTestClass.nWFUpdates).toBe(1);
+    expect(DBOSTriggerTestClass.wfRecordMap.get(1)?.status).toBe('Ordered');
+
+    await DBOSTriggerTestClass.insertRecord({
+      order_id: 2,
+      order_date: new Date(),
+      price: 10,
+      item: 'Cogswell Cog',
+      status: 'Ordered',
+    });
+    while (DBOSTriggerTestClass.nInserts < 2) await sleepms(10);
+    expect(DBOSTriggerTestClass.nInserts).toBe(2);
+    expect(DBOSTriggerTestClass.nDeletes).toBe(0);
+    expect(DBOSTriggerTestClass.nUpdates).toBe(0);
+    expect(DBOSTriggerTestClass.recordMap.get(2)?.status).toBe('Ordered');
+    while (DBOSTriggerTestClass.nWFUpdates < 2) await sleepms(10);
+    expect(DBOSTriggerTestClass.nWFUpdates).toBe(2);
+    expect(DBOSTriggerTestClass.wfRecordMap.get(2)?.status).toBe('Ordered');
+
+    await DBOSTriggerTestClass.deleteRecord(2);
+    while (DBOSTriggerTestClass.nDeletes < 1) await sleepms(10);
+    expect(DBOSTriggerTestClass.nInserts).toBe(2);
+    expect(DBOSTriggerTestClass.nDeletes).toBe(1);
+    expect(DBOSTriggerTestClass.nUpdates).toBe(0);
+    expect(DBOSTriggerTestClass.recordMap.get(2)?.status).toBeUndefined();
+    expect(DBOSTriggerTestClass.nWFUpdates).toBe(2); // Workflow does not trigger on delete
+
+    await DBOSTriggerTestClass.updateRecordStatus(1, 'Shipped');
+    while (DBOSTriggerTestClass.nUpdates < 1) await sleepms(10);
+    expect(DBOSTriggerTestClass.nInserts).toBe(2);
+    expect(DBOSTriggerTestClass.nDeletes).toBe(1);
+    expect(DBOSTriggerTestClass.nUpdates).toBe(1);
+    expect(DBOSTriggerTestClass.recordMap.get(1)?.status).toBe('Shipped');
+    await sleepms(100);
+    // This update does not start a workflow as there is no update marker column.
+    expect(DBOSTriggerTestClass.nWFUpdates).toBe(2);
+  }, 15000);
+});

package/tests/dbtriggers_poll.test.ts

@@ -0,0 +1,285 @@
+import { DBOS, DBOSConfig, WorkflowQueue } from '@dbos-inc/dbos-sdk';
+
+import { DBTrigger, TriggerOperation } from '../src';
+import { ClientBase, Pool, PoolClient } from 'pg';
+import { KnexDataSource } from '@dbos-inc/knex-datasource';
+
+const config = {
+  host: process.env.PGHOST || 'localhost',
+  port: parseInt(process.env.PGPORT || '5432'),
+  database: process.env.PGDATABASE || 'postgres',
+  user: process.env.PGUSER || 'postgres',
+  password: process.env.PGPASSWORD || 'dbos',
+};
+const pool = new Pool(config);
+
+const kconfig = { client: 'pg', connection: config };
+
+const knexds = new KnexDataSource('app', kconfig);
+
+const trig = new DBTrigger({
+  connect: async () => {
+    const conn = pool.connect();
+    return conn;
+  },
+  disconnect: async (c: ClientBase) => {
+    (c as PoolClient).release();
+    return Promise.resolve();
+  },
+  query: async <R>(sql: string, params?: unknown[]) => {
+    return (await pool.query(sql, params)).rows as R[];
+  },
+});
+
+function sleepms(ms: number) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+const testTableName = 'dbos_test_trig_seq';
+
+const q = new WorkflowQueue('schedQ');
+
+class DBOSTriggerTestClassSN {
+  static nTSUpdates = 0;
+  static tsRecordMap: Map<number, TestTable> = new Map();
+
+  static nSNUpdates = 0;
+  static snRecordMap: Map<number, TestTable> = new Map();
+
+  static reset() {
+    DBOSTriggerTestClassSN.nTSUpdates = 0;
+    DBOSTriggerTestClassSN.tsRecordMap = new Map();
+
+    DBOSTriggerTestClassSN.nSNUpdates = 0;
+    DBOSTriggerTestClassSN.snRecordMap = new Map();
+  }
+
+  @trig.triggerWorkflow({
+    tableName: testTableName,
+    recordIDColumns: ['order_id'],
+    sequenceNumColumn: 'seqnum',
+    sequenceNumJitter: 2,
+    queueName: q.name,
+    dbPollingInterval: 1000,
+  })
+  @DBOS.workflow()
+  static async pollWFBySeq(op: TriggerOperation, key: number[], rec: unknown) {
+    DBOS.logger.debug(`WFSN Poll ${op} - ${JSON.stringify(key)} / ${JSON.stringify(rec)}`);
+    expect(op).toBe(TriggerOperation.RecordUpserted);
+    const trec = rec as TestTable;
+    if (
+      !DBOSTriggerTestClassSN.snRecordMap.has(key[0]) ||
+      trec.seqnum > DBOSTriggerTestClassSN.snRecordMap.get(key[0])!.seqnum
+    ) {
+      DBOSTriggerTestClassSN.snRecordMap.set(key[0], trec);
+      await DBOSTriggerTestClassSN.snUpdate();
+    }
+    return Promise.resolve();
+  }
+
+  @trig.triggerWorkflow({
+    tableName: testTableName,
+    recordIDColumns: ['order_id'],
+    timestampColumn: 'update_date',
+    timestampSkewMS: 60000,
+    dbPollingInterval: 1000,
+  })
+  @DBOS.workflow()
+  static async pollWFByTS(op: TriggerOperation, key: number[], rec: unknown) {
+    DBOS.logger.debug(`WFTS Poll ${op} - ${JSON.stringify(key)} / ${JSON.stringify(rec)}`);
+    expect(op).toBe(TriggerOperation.RecordUpserted);
+    if (op === TriggerOperation.RecordUpserted) {
+      const trec = rec as TestTable;
+      if (
+        !DBOSTriggerTestClassSN.tsRecordMap.has(key[0]) ||
+        trec.update_date > DBOSTriggerTestClassSN.tsRecordMap.get(key[0])!.update_date
+      ) {
+        DBOSTriggerTestClassSN.tsRecordMap.set(key[0], trec);
+        await DBOSTriggerTestClassSN.tsUpdate();
+      }
+    }
+    return Promise.resolve();
+  }
+
+  @DBOS.step()
+  static async snUpdate() {
+    ++DBOSTriggerTestClassSN.nSNUpdates;
+    return Promise.resolve();
+  }
+
+  @DBOS.step()
+  static async tsUpdate() {
+    ++DBOSTriggerTestClassSN.nTSUpdates;
+    return Promise.resolve();
+  }
+
+  @knexds.transaction()
+  static async insertRecord(rec: TestTable) {
+    await knexds.client<TestTable>(testTableName).insert(rec);
+  }
+
+  @knexds.transaction()
+  static async deleteRecord(order_id: number) {
+    await knexds.client<TestTable>(testTableName).where({ order_id }).delete();
+  }
+
+  @knexds.transaction()
+  static async updateRecordStatus(order_id: number, status: string, seqnum: number, update_date: Date) {
+    await knexds.client<TestTable>(testTableName).where({ order_id }).update({ status, seqnum, update_date });
+  }
+}
+
+interface TestTable {
+  order_id: number;
+  seqnum: number;
+  update_date: Date;
+  price: number;
+  item: string;
+  status: string;
+}
+
+describe('test-db-trigger-polling', () => {
+  beforeAll(async () => {});
+
+  beforeEach(async () => {
+    await KnexDataSource.initializeDBOSSchema(kconfig);
+    const config: DBOSConfig = {
+      name: 'dbtrig_poll',
+    };
+    DBOS.setConfig(config);
+    await trig.db.query(`DROP TABLE IF EXISTS ${testTableName};`);
+    await trig.db.query(`
+            CREATE TABLE IF NOT EXISTS ${testTableName}(
+              order_id SERIAL PRIMARY KEY,
+              seqnum INTEGER,
+              update_date TIMESTAMP,
+              price DECIMAL(10,2),
+              item TEXT,
+              status VARCHAR(10)
+            );`);
+    DBOSTriggerTestClassSN.reset();
+    await DBOS.launch();
+  });
+
+  afterEach(async () => {
+    await DBOS.shutdown();
+    await trig.db.query(`DROP TABLE IF EXISTS ${testTableName};`);
+  });
+
+  test('dbpoll-seqnum', async () => {
+    await DBOSTriggerTestClassSN.insertRecord({
+      order_id: 1,
+      seqnum: 1,
+      update_date: new Date('2024-01-01 11:11:11'),
+      price: 10,
+      item: 'Spacely Sprocket',
+      status: 'Ordered',
+    });
+    await DBOSTriggerTestClassSN.updateRecordStatus(1, 'Packed', 2, new Date('2024-01-01 11:11:12'));
+    while (DBOSTriggerTestClassSN.snRecordMap.get(1)?.status !== 'Packed') await sleepms(10);
+    while (DBOSTriggerTestClassSN.tsRecordMap.get(1)?.status !== 'Packed') await sleepms(10);
+    while (DBOSTriggerTestClassSN.nSNUpdates < 1 || DBOSTriggerTestClassSN.nTSUpdates < 1) await sleepms(10);
+
+    // If these occurred close together, we would not see the insert+update separately...
+    expect(DBOSTriggerTestClassSN.nSNUpdates).toBeGreaterThanOrEqual(1);
+    expect(DBOSTriggerTestClassSN.nSNUpdates).toBeLessThanOrEqual(2);
+    expect(DBOSTriggerTestClassSN.nTSUpdates).toBeGreaterThanOrEqual(1);
+    expect(DBOSTriggerTestClassSN.nTSUpdates).toBeLessThanOrEqual(2);
+    expect(DBOSTriggerTestClassSN.snRecordMap.get(1)?.status).toBe('Packed');
+    expect(DBOSTriggerTestClassSN.tsRecordMap.get(1)?.status).toBe('Packed');
+
+    await DBOSTriggerTestClassSN.insertRecord({
+      order_id: 2,
+      seqnum: 3,
+      update_date: new Date('2024-01-01 11:11:13'),
+      price: 10,
+      item: 'Cogswell Cog',
+      status: 'Ordered',
+    });
+    await DBOSTriggerTestClassSN.updateRecordStatus(1, 'Shipped', 5, new Date('2024-01-01 11:11:15'));
+    while (DBOSTriggerTestClassSN.snRecordMap.get(1)?.status !== 'Shipped') await sleepms(10);
+    while (DBOSTriggerTestClassSN.tsRecordMap.get(1)?.status !== 'Shipped') await sleepms(10);
+    while (DBOSTriggerTestClassSN.snRecordMap.get(2)?.status !== 'Ordered') await sleepms(10);
+    while (DBOSTriggerTestClassSN.tsRecordMap.get(2)?.status !== 'Ordered') await sleepms(10);
+
+    expect(DBOSTriggerTestClassSN.snRecordMap.get(1)?.status).toBe('Shipped');
+    expect(DBOSTriggerTestClassSN.tsRecordMap.get(1)?.status).toBe('Shipped');
+    expect(DBOSTriggerTestClassSN.snRecordMap.get(2)?.status).toBe('Ordered');
+    expect(DBOSTriggerTestClassSN.tsRecordMap.get(2)?.status).toBe('Ordered');
+
+    // Take down
+    await DBOS.deactivateEventReceivers();
+
+    // Do more stuff
+    // Invalid record, won't show up because it is well out of sequence
+    await DBOSTriggerTestClassSN.insertRecord({
+      order_id: 999,
+      seqnum: -999,
+      update_date: new Date('1900-01-01 11:11:13'),
+      price: 10,
+      item: 'Cogswell Cog',
+      status: 'Ordered',
+    });
+
+    // A few more valid records, back in time a little
+    await DBOSTriggerTestClassSN.insertRecord({
+      order_id: 3,
+      seqnum: 4,
+      update_date: new Date('2024-01-01 11:11:14'),
+      price: 10,
+      item: 'Griswold Gear',
+      status: 'Ordered',
+    });
+    await DBOSTriggerTestClassSN.insertRecord({
+      order_id: 4,
+      seqnum: 6,
+      update_date: new Date('2024-01-01 11:11:16'),
+      price: 10,
+      item: 'Wallace Wheel',
+      status: 'Ordered',
+    });
+    await DBOSTriggerTestClassSN.updateRecordStatus(4, 'Shipped', 7, new Date('2024-01-01 11:11:17'));
+
+    // Test restore
+    console.log(
+      '************************************************** Restart *****************************************************',
+    );
+    DBOSTriggerTestClassSN.reset();
+
+    await DBOS.initEventReceivers();
+
+    console.log(
+      '************************************************** Restarted *****************************************************',
+    );
+    DBOSTriggerTestClassSN.reset();
+
+    // Catchup may not be sequential, wait for the last update to get processed...
+    while (DBOSTriggerTestClassSN.snRecordMap.get(3)?.status !== 'Ordered') await sleepms(10);
+    while (DBOSTriggerTestClassSN.tsRecordMap.get(3)?.status !== 'Ordered') await sleepms(10);
+    while (DBOSTriggerTestClassSN.snRecordMap.get(4)?.status !== 'Shipped') await sleepms(10);
+    while (DBOSTriggerTestClassSN.tsRecordMap.get(4)?.status !== 'Shipped') await sleepms(10);
+    await sleepms(100);
+
+    console.log(
+      '************************************************** Catchup Complete *****************************************************',
+    );
+
+    expect(DBOSTriggerTestClassSN.snRecordMap.get(3)?.status).toBe('Ordered');
+    expect(DBOSTriggerTestClassSN.tsRecordMap.get(3)?.status).toBe('Ordered');
+    expect(DBOSTriggerTestClassSN.snRecordMap.get(4)?.status).toBe('Shipped');
+    expect(DBOSTriggerTestClassSN.tsRecordMap.get(4)?.status).toBe('Shipped');
+    expect(DBOSTriggerTestClassSN.snRecordMap.get(999)?.status).toBeUndefined();
+    expect(DBOSTriggerTestClassSN.tsRecordMap.get(999)?.status).toBeUndefined();
+
+    const wfs = await DBOS.getWorkflows({
+      workflowName: 'pollWFBySeq',
+    });
+
+    let foundQ = false;
+    for (const wfid of wfs.workflowUUIDs) {
+      const stat = await DBOS.retrieveWorkflow(wfid).getStatus();
+      if (stat?.queueName === q.name) foundQ = true;
+    }
+    expect(foundQ).toBeTruthy();
+  }, 15000);
+});