@dbos-inc/node-pg-datasource 3.0.10-preview → 3.0.11-preview.gc9233b8190

package/tests/datasource.test.ts

@@ -5,14 +5,13 @@ import { dropDB, ensureDB } from './test-helpers';
 import { randomUUID } from 'crypto';
 import { SuperJSON } from 'superjson';
 
-const config = { user: 'postgres', database: 'node_pg_ds_test_datasource' };
+const config = { user: 'postgres', database: 'nodepg_ds_test_userdb' };
 const dataSource = new NodePostgresDataSource('app-db', config);
 
 interface transaction_completion {
   workflow_id: string;
   function_num: number;
   output: string | null;
-  error: string | null;
 }
 
 describe('NodePostgresDataSource', () => {
@@ -23,9 +22,9 @@ describe('NodePostgresDataSource', () => {
       const client = new Client({ ...config, database: 'postgres' });
       try {
         await client.connect();
-        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 dropDB(client, 'knex_ds_test');
+        await dropDB(client, 'knex_ds_test_dbos_sys');
+        await dropDB(client, config.database);
         await ensureDB(client, config.database);
       } finally {
         await client.end();
@@ -44,19 +43,13 @@ describe('NodePostgresDataSource', () => {
     }
 
     await NodePostgresDataSource.initializeInternalSchema(config);
-  });
-
-  afterAll(async () => {
-    await userDB.end();
-  });
-
-  beforeEach(async () => {
-    DBOS.setConfig({ name: 'node-pg-ds-test' });
+    DBOS.setConfig({ name: 'knex-ds-test' });
     await DBOS.launch();
   });
 
-  afterEach(async () => {
+  afterAll(async () => {
     await DBOS.shutdown();
+    await userDB.end();
   });
 
   test('insert dataSource.register function', async () => {
@@ -65,7 +58,7 @@ describe('NodePostgresDataSource', () => {
     await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
     const workflowID = randomUUID();
 
-    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorkflowReg(user))).resolves.toMatchObject({
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorfklowReg(user))).resolves.toEqual({
       user,
       greet_count: 1,
     });
@@ -78,19 +71,7 @@ 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!)).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);
+    expect(SuperJSON.parse(rows[0].output!)).toEqual({ user, greet_count: 1 });
   });
 
   test('insert dataSource.runAsTx function', async () => {
@@ -99,7 +80,7 @@ describe('NodePostgresDataSource', () => {
     await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
     const workflowID = randomUUID();
 
-    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorkflowRunTx(user))).resolves.toMatchObject({
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorfklowRunTx(user))).resolves.toEqual({
       user,
       greet_count: 1,
     });
@@ -112,32 +93,9 @@ 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!)).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,
-    );
+    expect(SuperJSON.parse(rows[0].output!)).toEqual({ user, greet_count: 1 });
   });
 
-  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';
 
@@ -145,42 +103,16 @@ describe('NodePostgresDataSource', () => {
     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+$/);
+    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 { 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 () => {
@@ -190,42 +122,17 @@ describe('NodePostgresDataSource', () => {
     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 { rows } = await userDB.query<greetings>('SELECT * FROM greetings WHERE name = $1', [user]);
-    expect(rows.length).toBe(1);
-    expect(rows[0].greet_count).toBe(10);
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regErrorWorkflowRunTx(user))).rejects.toThrow('test error');
 
     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.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+$/);
+    expect(txOutput.length).toBe(0);
 
-    const error2 = await throws(() => DBOS.withNextWorkflowID(workflowID, () => regErrorWorkflowRunTx(user)));
-    expect(error2).toBeInstanceOf(Error);
-    expect((error2 as Error).message).toMatch((error as Error).message);
+    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('readonly dataSource.register function', async () => {
@@ -235,14 +142,15 @@ 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.toMatchObject({
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regReadWorkflowReg(user))).resolves.toEqual({
       user,
       greet_count: 10,
     });
 
-    const { rows } = await userDB.query('SELECT * FROM dbos.transaction_completion WHERE workflow_id = $1', [
-      workflowID,
-    ]);
+    const { rows } = await userDB.query<transaction_completion>(
+      'SELECT * FROM dbos.transaction_completion WHERE workflow_id = $1',
+      [workflowID],
+    );
     expect(rows.length).toBe(0);
   });
 
@@ -253,14 +161,15 @@ 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.toMatchObject({
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regReadWorkflowRunTx(user))).resolves.toEqual({
       user,
       greet_count: 10,
     });
 
-    const { rows } = await userDB.query('SELECT * FROM dbos.transaction_completion WHERE workflow_id = $1', [
-      workflowID,
-    ]);
+    const { rows } = await userDB.query<transaction_completion>(
+      'SELECT * FROM dbos.transaction_completion WHERE workflow_id = $1',
+      [workflowID],
+    );
     expect(rows.length).toBe(0);
   });
 
@@ -270,7 +179,7 @@ describe('NodePostgresDataSource', () => {
     await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
 
     const workflowID = randomUUID();
-    await expect(DBOS.withNextWorkflowID(workflowID, () => regStaticWorkflow(user))).resolves.toMatchObject([
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regStaticWorkflow(user))).resolves.toEqual([
       { user, greet_count: 1 },
       { user, greet_count: 1 },
     ]);
@@ -282,45 +191,11 @@ describe('NodePostgresDataSource', () => {
     await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
 
     const workflowID = randomUUID();
-    await expect(DBOS.withNextWorkflowID(workflowID, () => regInstanceWorkflow(user))).resolves.toMatchObject([
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regInstanceWorkflow(user))).resolves.toEqual([
       { 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 {
@@ -330,36 +205,39 @@ 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, now: Date.now() };
+  return { user, greet_count: row?.greet_count };
 }
 
 async function errorFunction(user: string) {
-  const _result = await insertFunction(user);
-  throw new Error(`test error ${Date.now()}`);
+  const result = await insertFunction(user);
+  throw new Error('test error');
+  return result;
 }
 
 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, now: Date.now() };
+  return { user, greet_count: row?.greet_count };
 }
 
-const regInsertFunction = dataSource.registerTransaction(insertFunction);
-const regErrorFunction = dataSource.registerTransaction(errorFunction);
-const regReadFunction = dataSource.registerTransaction(readFunction, { readOnly: true });
+const regInsertFunction = dataSource.registerTransaction(insertFunction, 'insertFunction');
+const regErrorFunction = dataSource.registerTransaction(errorFunction, 'errorFunction');
+const regReadFunction = dataSource.registerTransaction(readFunction, 'readFunction', { readOnly: true });
 
 class StaticClass {
   static async insertFunction(user: string) {
@@ -371,8 +249,8 @@ class StaticClass {
   }
 }
 
-StaticClass.insertFunction = dataSource.registerTransaction(StaticClass.insertFunction);
-StaticClass.readFunction = dataSource.registerTransaction(StaticClass.readFunction, { readOnly: true });
+StaticClass.insertFunction = dataSource.registerTransaction(StaticClass.insertFunction, 'insertFunction');
+StaticClass.readFunction = dataSource.registerTransaction(StaticClass.readFunction, 'readFunction');
 
 class InstanceClass {
   async insertFunction(user: string) {
@@ -387,11 +265,12 @@ 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,
-  { readOnly: true },
+  'readFunction',
 );
 
 async function insertWorkflowReg(user: string) {
@@ -431,8 +310,8 @@ async function instanceWorkflow(user: string) {
   return [result, readResult];
 }
 
-const regInsertWorkflowReg = DBOS.registerWorkflow(insertWorkflowReg, 'insertWorkflowReg');
-const regInsertWorkflowRunTx = DBOS.registerWorkflow(insertWorkflowRunTx, 'insertWorkflowRunTx');
+const regInsertWorfklowReg = DBOS.registerWorkflow(insertWorkflowReg, 'insertWorkflowReg');
+const regInsertWorfklowRunTx = 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,7 +7,6 @@ export async function ensureDB(client: Client, name: string) {
   }
 }
 
-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}`);
+export async function dropDB(client: Client, name: string) {
+  await client.query(`DROP DATABASE IF EXISTS ${name}`);
 }