@dbos-inc/node-pg-datasource 3.0.8-preview.g493d2d1c2b → 3.0.10-preview

package/tests/datasource.test.ts

@@ -5,13 +5,14 @@ import { dropDB, ensureDB } from './test-helpers';
 import { randomUUID } from 'crypto';
 import { SuperJSON } from 'superjson';
 
-const config = { user: 'postgres', database: 'nodepg_ds_test_userdb' };
+const config = { user: 'postgres', database: 'node_pg_ds_test_datasource' };
 const dataSource = new NodePostgresDataSource('app-db', config);
 
 interface transaction_completion {
   workflow_id: string;
   function_num: number;
   output: string | null;
+  error: string | null;
 }
 
 describe('NodePostgresDataSource', () => {
@@ -22,9 +23,9 @@ describe('NodePostgresDataSource', () => {
       const client = new Client({ ...config, database: 'postgres' });
       try {
         await client.connect();
-        await dropDB(client, 'knex_ds_test');
-        await dropDB(client, 'knex_ds_test_dbos_sys');
-        await dropDB(client, config.database);
+        await dropDB(client, 'node_pg_ds_test', true);
+        await dropDB(client, 'node_pg_ds_test_dbos_sys', true);
+        await dropDB(client, config.database, true);
         await ensureDB(client, config.database);
       } finally {
         await client.end();
@@ -43,22 +44,28 @@ describe('NodePostgresDataSource', () => {
     }
 
     await NodePostgresDataSource.initializeInternalSchema(config);
-    DBOS.setConfig({ name: 'knex-ds-test' });
-    await DBOS.launch();
   });
 
   afterAll(async () => {
-    await DBOS.shutdown();
     await userDB.end();
   });
 
+  beforeEach(async () => {
+    DBOS.setConfig({ name: 'node-pg-ds-test' });
+    await DBOS.launch();
+  });
+
+  afterEach(async () => {
+    await DBOS.shutdown();
+  });
+
   test('insert dataSource.register function', async () => {
     const user = 'helloTest1';
 
     await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
     const workflowID = randomUUID();
 
-    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorfklowReg(user))).resolves.toEqual({
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorkflowReg(user))).resolves.toMatchObject({
       user,
       greet_count: 1,
     });
@@ -71,7 +78,19 @@ describe('NodePostgresDataSource', () => {
     expect(rows[0].workflow_id).toBe(workflowID);
     expect(rows[0].function_num).toBe(0);
     expect(rows[0].output).not.toBeNull();
-    expect(SuperJSON.parse(rows[0].output!)).toEqual({ user, greet_count: 1 });
+    expect(SuperJSON.parse(rows[0].output!)).toMatchObject({ user, greet_count: 1 });
+  });
+
+  test('rerun insert dataSource.register function', async () => {
+    const user = 'rerunTest1';
+
+    await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
+    const workflowID = randomUUID();
+
+    const result = await DBOS.withNextWorkflowID(workflowID, () => regInsertWorkflowReg(user));
+    expect(result).toMatchObject({ user, greet_count: 1 });
+
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorkflowReg(user))).resolves.toMatchObject(result);
   });
 
   test('insert dataSource.runAsTx function', async () => {
@@ -80,7 +99,7 @@ describe('NodePostgresDataSource', () => {
     await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
     const workflowID = randomUUID();
 
-    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorfklowRunTx(user))).resolves.toEqual({
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorkflowRunTx(user))).resolves.toMatchObject({
       user,
       greet_count: 1,
     });
@@ -93,9 +112,32 @@ describe('NodePostgresDataSource', () => {
     expect(rows[0].workflow_id).toBe(workflowID);
     expect(rows[0].function_num).toBe(0);
     expect(rows[0].output).not.toBeNull();
-    expect(SuperJSON.parse(rows[0].output!)).toEqual({ user, greet_count: 1 });
+    expect(SuperJSON.parse(rows[0].output!)).toMatchObject({ user, greet_count: 1 });
+  });
+
+  test('rerun insert dataSource.runAsTx function', async () => {
+    const user = 'rerunTest2';
+
+    await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
+    const workflowID = randomUUID();
+
+    const result = await DBOS.withNextWorkflowID(workflowID, () => regInsertWorkflowRunTx(user));
+    expect(result).toMatchObject({ user, greet_count: 1 });
+
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorkflowRunTx(user))).resolves.toMatchObject(
+      result,
+    );
   });
 
+  async function throws<R>(func: () => Promise<R>): Promise<unknown> {
+    try {
+      await func();
+      fail('Expected function to throw an error');
+    } catch (error) {
+      return error;
+    }
+  }
+
   test('error dataSource.register function', async () => {
     const user = 'errorTest1';
 
@@ -103,16 +145,42 @@ describe('NodePostgresDataSource', () => {
     await userDB.query('INSERT INTO greetings("name","greet_count") VALUES($1,10);', [user]);
     const workflowID = randomUUID();
 
-    await expect(DBOS.withNextWorkflowID(workflowID, () => regErrorWorkflowReg(user))).rejects.toThrow('test error');
-
-    const { rows: txOutput } = await userDB.query('SELECT * FROM dbos.transaction_completion WHERE workflow_id = $1', [
-      workflowID,
-    ]);
-    expect(txOutput.length).toBe(0);
+    const error = await throws(() => DBOS.withNextWorkflowID(workflowID, () => regErrorWorkflowReg(user)));
+    expect(error).toBeInstanceOf(Error);
+    expect((error as Error).message).toMatch(/^test error \d+$/);
 
     const { rows } = await userDB.query<greetings>('SELECT * FROM greetings WHERE name = $1', [user]);
     expect(rows.length).toBe(1);
     expect(rows[0].greet_count).toBe(10);
+
+    const { rows: txOutput } = await userDB.query<transaction_completion>(
+      'SELECT * FROM dbos.transaction_completion WHERE workflow_id = $1',
+      [workflowID],
+    );
+    expect(txOutput.length).toBe(1);
+    expect(txOutput[0].workflow_id).toBe(workflowID);
+    expect(txOutput[0].function_num).toBe(0);
+    expect(txOutput[0].output).toBeNull();
+    expect(txOutput[0].error).not.toBeNull();
+    const $error = SuperJSON.parse(txOutput[0].error!);
+    expect($error).toBeInstanceOf(Error);
+    expect(($error as Error).message).toMatch(/^test error \d+$/);
+  });
+
+  test('rerun error dataSource.register function', async () => {
+    const user = 'rerunErrorTest1';
+
+    await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
+    await userDB.query('INSERT INTO greetings("name","greet_count") VALUES($1,10);', [user]);
+    const workflowID = randomUUID();
+
+    const error = await throws(() => DBOS.withNextWorkflowID(workflowID, () => regErrorWorkflowReg(user)));
+    expect(error).toBeInstanceOf(Error);
+    expect((error as Error).message).toMatch(/^test error \d+$/);
+
+    const error2 = await throws(() => DBOS.withNextWorkflowID(workflowID, () => regErrorWorkflowReg(user)));
+    expect(error2).toBeInstanceOf(Error);
+    expect((error2 as Error).message).toMatch((error as Error).message);
   });
 
   test('error dataSource.runAsTx function', async () => {
@@ -122,17 +190,42 @@ describe('NodePostgresDataSource', () => {
     await userDB.query('INSERT INTO greetings("name","greet_count") VALUES($1,10);', [user]);
     const workflowID = randomUUID();
 
-    await expect(DBOS.withNextWorkflowID(workflowID, () => regErrorWorkflowRunTx(user))).rejects.toThrow('test error');
+    const error = await throws(() => DBOS.withNextWorkflowID(workflowID, () => regErrorWorkflowRunTx(user)));
+    expect(error).toBeInstanceOf(Error);
+    expect((error as Error).message).toMatch(/^test error \d+$/);
+
+    const { rows } = await userDB.query<greetings>('SELECT * FROM greetings WHERE name = $1', [user]);
+    expect(rows.length).toBe(1);
+    expect(rows[0].greet_count).toBe(10);
 
     const { rows: txOutput } = await userDB.query<transaction_completion>(
       'SELECT * FROM dbos.transaction_completion WHERE workflow_id = $1',
       [workflowID],
     );
-    expect(txOutput.length).toBe(0);
+    expect(txOutput.length).toBe(1);
+    expect(txOutput[0].workflow_id).toBe(workflowID);
+    expect(txOutput[0].function_num).toBe(0);
+    expect(txOutput[0].output).toBeNull();
+    expect(txOutput[0].error).not.toBeNull();
+    const $error = SuperJSON.parse(txOutput[0].error!);
+    expect($error).toBeInstanceOf(Error);
+    expect(($error as Error).message).toMatch(/^test error \d+$/);
+  });
 
-    const { rows } = await userDB.query<greetings>('SELECT * FROM greetings WHERE name = $1', [user]);
-    expect(rows.length).toBe(1);
-    expect(rows[0].greet_count).toBe(10);
+  test('rerun error dataSource.runAsTx function', async () => {
+    const user = 'rerunErrorTest2';
+
+    await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
+    await userDB.query('INSERT INTO greetings("name","greet_count") VALUES($1,10);', [user]);
+    const workflowID = randomUUID();
+
+    const error = await throws(() => DBOS.withNextWorkflowID(workflowID, () => regErrorWorkflowRunTx(user)));
+    expect(error).toBeInstanceOf(Error);
+    expect((error as Error).message).toMatch(/^test error \d+$/);
+
+    const error2 = await throws(() => DBOS.withNextWorkflowID(workflowID, () => regErrorWorkflowRunTx(user)));
+    expect(error2).toBeInstanceOf(Error);
+    expect((error2 as Error).message).toMatch((error as Error).message);
   });
 
   test('readonly dataSource.register function', async () => {
@@ -142,15 +235,14 @@ describe('NodePostgresDataSource', () => {
     await userDB.query('INSERT INTO greetings("name","greet_count") VALUES($1,10);', [user]);
 
     const workflowID = randomUUID();
-    await expect(DBOS.withNextWorkflowID(workflowID, () => regReadWorkflowReg(user))).resolves.toEqual({
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regReadWorkflowReg(user))).resolves.toMatchObject({
       user,
       greet_count: 10,
     });
 
-    const { rows } = await userDB.query<transaction_completion>(
-      'SELECT * FROM dbos.transaction_completion WHERE workflow_id = $1',
-      [workflowID],
-    );
+    const { rows } = await userDB.query('SELECT * FROM dbos.transaction_completion WHERE workflow_id = $1', [
+      workflowID,
+    ]);
     expect(rows.length).toBe(0);
   });
 
@@ -161,15 +253,14 @@ describe('NodePostgresDataSource', () => {
     await userDB.query('INSERT INTO greetings("name","greet_count") VALUES($1,10);', [user]);
 
     const workflowID = randomUUID();
-    await expect(DBOS.withNextWorkflowID(workflowID, () => regReadWorkflowRunTx(user))).resolves.toEqual({
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regReadWorkflowRunTx(user))).resolves.toMatchObject({
       user,
       greet_count: 10,
     });
 
-    const { rows } = await userDB.query<transaction_completion>(
-      'SELECT * FROM dbos.transaction_completion WHERE workflow_id = $1',
-      [workflowID],
-    );
+    const { rows } = await userDB.query('SELECT * FROM dbos.transaction_completion WHERE workflow_id = $1', [
+      workflowID,
+    ]);
     expect(rows.length).toBe(0);
   });
 
@@ -179,7 +270,7 @@ describe('NodePostgresDataSource', () => {
     await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
 
     const workflowID = randomUUID();
-    await expect(DBOS.withNextWorkflowID(workflowID, () => regStaticWorkflow(user))).resolves.toEqual([
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regStaticWorkflow(user))).resolves.toMatchObject([
       { user, greet_count: 1 },
       { user, greet_count: 1 },
     ]);
@@ -191,11 +282,45 @@ describe('NodePostgresDataSource', () => {
     await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
 
     const workflowID = randomUUID();
-    await expect(DBOS.withNextWorkflowID(workflowID, () => regInstanceWorkflow(user))).resolves.toEqual([
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regInstanceWorkflow(user))).resolves.toMatchObject([
       { user, greet_count: 1 },
       { user, greet_count: 1 },
     ]);
   });
+
+  test('invoke-reg-tx-fun-outside-wf', async () => {
+    const user = 'outsideWfUser' + Date.now();
+    const result = await regInsertFunction(user);
+    expect(result).toMatchObject({ user, greet_count: 1 });
+
+    const txResults = await userDB.query('SELECT * FROM dbos.transaction_completion WHERE output LIKE $1', [
+      `%${user}%`,
+    ]);
+    expect(txResults.rows.length).toBe(0);
+  });
+
+  test('invoke-reg-tx-static-method-outside-wf', async () => {
+    const user = 'outsideWfUser' + Date.now();
+    const result = await StaticClass.insertFunction(user);
+    expect(result).toMatchObject({ user, greet_count: 1 });
+
+    const txResults = await userDB.query('SELECT * FROM dbos.transaction_completion WHERE output LIKE $1', [
+      `%${user}%`,
+    ]);
+    expect(txResults.rows.length).toBe(0);
+  });
+
+  test('invoke-reg-tx-inst-method-outside-wf', async () => {
+    const user = 'outsideWfUser' + Date.now();
+    const instance = new InstanceClass();
+    const result = await instance.insertFunction(user);
+    expect(result).toMatchObject({ user, greet_count: 1 });
+
+    const txResults = await userDB.query('SELECT * FROM dbos.transaction_completion WHERE output LIKE $1', [
+      `%${user}%`,
+    ]);
+    expect(txResults.rows.length).toBe(0);
+  });
 });
 
 export interface greetings {
@@ -205,39 +330,36 @@ export interface greetings {
 
 async function insertFunction(user: string) {
   const { rows } = await NodePostgresDataSource.client.query<Pick<greetings, 'greet_count'>>(
-    `
-    INSERT INTO greetings(name, greet_count) 
-    VALUES($1, 1) 
-    ON CONFLICT(name)
-    DO UPDATE SET greet_count = greetings.greet_count + 1
-    RETURNING greet_count`,
+    `INSERT INTO greetings(name, greet_count) 
+     VALUES($1, 1) 
+     ON CONFLICT(name)
+     DO UPDATE SET greet_count = greetings.greet_count + 1
+     RETURNING greet_count`,
     [user],
   );
   const row = rows.length > 0 ? rows[0] : undefined;
-  return { user, greet_count: row?.greet_count };
+  return { user, greet_count: row?.greet_count, now: Date.now() };
 }
 
 async function errorFunction(user: string) {
-  const result = await insertFunction(user);
-  throw new Error('test error');
-  return result;
+  const _result = await insertFunction(user);
+  throw new Error(`test error ${Date.now()}`);
 }
 
 async function readFunction(user: string) {
   const { rows } = await NodePostgresDataSource.client.query<Pick<greetings, 'greet_count'>>(
-    `
-    SELECT greet_count
-    FROM greetings
-    WHERE name = $1`,
+    `SELECT greet_count
+     FROM greetings
+     WHERE name = $1`,
     [user],
   );
   const row = rows.length > 0 ? rows[0] : undefined;
-  return { user, greet_count: row?.greet_count };
+  return { user, greet_count: row?.greet_count, now: Date.now() };
 }
 
-const regInsertFunction = dataSource.registerTransaction(insertFunction, 'insertFunction');
-const regErrorFunction = dataSource.registerTransaction(errorFunction, 'errorFunction');
-const regReadFunction = dataSource.registerTransaction(readFunction, 'readFunction', { readOnly: true });
+const regInsertFunction = dataSource.registerTransaction(insertFunction);
+const regErrorFunction = dataSource.registerTransaction(errorFunction);
+const regReadFunction = dataSource.registerTransaction(readFunction, { readOnly: true });
 
 class StaticClass {
   static async insertFunction(user: string) {
@@ -249,8 +371,8 @@ class StaticClass {
   }
 }
 
-StaticClass.insertFunction = dataSource.registerTransaction(StaticClass.insertFunction, 'insertFunction');
-StaticClass.readFunction = dataSource.registerTransaction(StaticClass.readFunction, 'readFunction');
+StaticClass.insertFunction = dataSource.registerTransaction(StaticClass.insertFunction);
+StaticClass.readFunction = dataSource.registerTransaction(StaticClass.readFunction, { readOnly: true });
 
 class InstanceClass {
   async insertFunction(user: string) {
@@ -265,12 +387,11 @@ class InstanceClass {
 InstanceClass.prototype.insertFunction = dataSource.registerTransaction(
   // eslint-disable-next-line @typescript-eslint/unbound-method
   InstanceClass.prototype.insertFunction,
-  'insertFunction',
 );
 InstanceClass.prototype.readFunction = dataSource.registerTransaction(
   // eslint-disable-next-line @typescript-eslint/unbound-method
   InstanceClass.prototype.readFunction,
-  'readFunction',
+  { readOnly: true },
 );
 
 async function insertWorkflowReg(user: string) {
@@ -310,8 +431,8 @@ async function instanceWorkflow(user: string) {
   return [result, readResult];
 }
 
-const regInsertWorfklowReg = DBOS.registerWorkflow(insertWorkflowReg, 'insertWorkflowReg');
-const regInsertWorfklowRunTx = DBOS.registerWorkflow(insertWorkflowRunTx, 'insertWorkflowRunTx');
+const regInsertWorkflowReg = DBOS.registerWorkflow(insertWorkflowReg, 'insertWorkflowReg');
+const regInsertWorkflowRunTx = DBOS.registerWorkflow(insertWorkflowRunTx, 'insertWorkflowRunTx');
 const regErrorWorkflowReg = DBOS.registerWorkflow(errorWorkflowReg, 'errorWorkflowReg');
 const regErrorWorkflowRunTx = DBOS.registerWorkflow(errorWorkflowRunTx, 'errorWorkflowRunTx');
 const regReadWorkflowReg = DBOS.registerWorkflow(readWorkflowReg, 'readWorkflowReg');

package/tests/test-helpers.ts

@@ -7,6 +7,7 @@ export async function ensureDB(client: Client, name: string) {
   }
 }
 
-export async function dropDB(client: Client, name: string) {
-  await client.query(`DROP DATABASE IF EXISTS ${name}`);
+export async function dropDB(client: Client, name: string, force: boolean = false) {
+  const withForce = force ? ' WITH (FORCE)' : '';
+  await client.query(`DROP DATABASE IF EXISTS ${name} ${withForce}`);
 }