@dbos-inc/knex-datasource 3.0.11-preview.gc9233b8190 → 3.0.16-preview

package/tests/datasource.test.ts

@@ -12,6 +12,7 @@ interface transaction_completion {
   workflow_id: string;
   function_num: number;
   output: string | null;
+  error: string | null;
 }
 
 describe('KnexDataSource', () => {
@@ -22,9 +23,9 @@ describe('KnexDataSource', () => {
       const client = new Client({ ...config.connection, database: 'postgres' });
       try {
         await client.connect();
-        await dropDB(client, 'knex_ds_test');
-        await dropDB(client, 'knex_ds_test_dbos_sys');
-        await dropDB(client, config.connection.database);
+        await dropDB(client, 'knex_ds_test', true);
+        await dropDB(client, 'knex_ds_test_dbos_sys', true);
+        await dropDB(client, config.connection.database, true);
         await ensureDB(client, config.connection.database);
       } finally {
         await client.end();
@@ -42,14 +43,20 @@ describe('KnexDataSource', () => {
       }
     }
 
-    await KnexDataSource.initializeInternalSchema(config);
+    await KnexDataSource.initializeDBOSSchema(config);
+  });
+
+  afterAll(async () => {
+    await userDB.end();
+  });
+
+  beforeEach(async () => {
     DBOS.setConfig({ name: 'knex-ds-test' });
     await DBOS.launch();
   });
 
-  afterAll(async () => {
+  afterEach(async () => {
     await DBOS.shutdown();
-    await userDB.end();
   });
 
   test('insert dataSource.register function', async () => {
@@ -58,7 +65,7 @@ describe('KnexDataSource', () => {
     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('KnexDataSource', () => {
     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('KnexDataSource', () => {
     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('KnexDataSource', () => {
     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,17 +145,42 @@ describe('KnexDataSource', () => {
     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 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(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.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 () => {
@@ -123,17 +190,42 @@ describe('KnexDataSource', () => {
     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 () => {
@@ -143,15 +235,14 @@ describe('KnexDataSource', () => {
     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);
   });
 
@@ -162,7 +253,7 @@ describe('KnexDataSource', () => {
     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,
     });
@@ -179,7 +270,7 @@ describe('KnexDataSource', () => {
     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('KnexDataSource', () => {
     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 {
@@ -204,30 +329,30 @@ export interface greetings {
 }
 
 async function insertFunction(user: string) {
-  const rows = await KnexDataSource.client<greetings>('greetings')
+  const rows = await dataSource
+    .client<greetings>('greetings')
     .insert({ name: user, greet_count: 1 })
     .onConflict('name')
-    .merge({ greet_count: KnexDataSource.client.raw('greetings.greet_count + 1') })
+    .merge({ greet_count: dataSource.client.raw('greetings.greet_count + 1') })
     .returning('greet_count');
   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 row = await KnexDataSource.client<greetings>('greetings').select('greet_count').where('name', user).first();
-  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) {
@@ -239,8 +364,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) {
@@ -255,12 +380,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) {
@@ -268,7 +392,7 @@ async function insertWorkflowReg(user: string) {
 }
 
 async function insertWorkflowRunTx(user: string) {
-  return await dataSource.runTransaction(() => insertFunction(user), 'insertFunction');
+  return await dataSource.runTransaction(() => insertFunction(user), { name: 'insertFunction' });
 }
 
 async function errorWorkflowReg(user: string) {
@@ -276,7 +400,7 @@ async function errorWorkflowReg(user: string) {
 }
 
 async function errorWorkflowRunTx(user: string) {
-  return await dataSource.runTransaction(() => errorFunction(user), 'errorFunction');
+  return await dataSource.runTransaction(() => errorFunction(user), { name: 'errorFunction' });
 }
 
 async function readWorkflowReg(user: string) {
@@ -284,7 +408,7 @@ async function readWorkflowReg(user: string) {
 }
 
 async function readWorkflowRunTx(user: string) {
-  return await dataSource.runTransaction(() => readFunction(user), 'readFunction', { readOnly: true });
+  return await dataSource.runTransaction(() => readFunction(user), { name: 'readFunction', readOnly: true });
 }
 
 async function staticWorkflow(user: string) {
@@ -300,8 +424,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}`);
 }