@dbos-inc/postgres-datasource 3.0.7-preview → 3.0.8-preview

package/index.ts

@@ -21,40 +21,50 @@ import { SuperJSON } from 'superjson';
 export { IsolationLevel, PostgresTransactionOptions };
 
 interface PostgresDataSourceContext {
-  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-  client: postgres.TransactionSql<{}>;
+  client: postgres.TransactionSql;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+type Options = postgres.Options<{}>;
+
 const asyncLocalCtx = new AsyncLocalStorage<PostgresDataSourceContext>();
 
 class PostgresTransactionHandler implements DataSourceTransactionHandler {
   readonly dsType = 'PostgresDataSource';
-  readonly #db: Sql;
+  #dbField: Sql | undefined;
 
   constructor(
     readonly name: string,
-    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-    options: postgres.Options<{}> = {},
-  ) {
-    this.#db = postgres(options);
+    private readonly options: Options = {},
+  ) {}
+
+  async initialize(): Promise<void> {
+    const db = this.#dbField;
+    this.#dbField = postgres(this.options);
+    await db?.end();
   }
 
-  initialize(): Promise<void> {
-    return Promise.resolve();
+  async destroy(): Promise<void> {
+    const db = this.#dbField;
+    this.#dbField = undefined;
+    await db?.end();
   }
 
-  destroy(): Promise<void> {
-    return this.#db.end();
+  get #db(): Sql {
+    if (!this.#dbField) {
+      throw new Error(`DataSource ${this.name} is not initialized.`);
+    }
+    return this.#dbField;
   }
 
   async #checkExecution(
     workflowID: string,
-    functionNum: number,
+    stepID: number,
   ): Promise<{ output: string | null } | { error: string } | undefined> {
     type Result = { output: string | null; error: string | null };
     const result = await this.#db<Result[]>/*sql*/ `
       SELECT output, error FROM dbos.transaction_completion
-      WHERE workflow_id = ${workflowID} AND function_num = ${functionNum}`;
+      WHERE workflow_id = ${workflowID} AND function_num = ${stepID}`;
     if (result.length === 0) {
       return undefined;
     }
@@ -63,16 +73,15 @@ class PostgresTransactionHandler implements DataSourceTransactionHandler {
   }
 
   static async #recordOutput(
-    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-    client: postgres.TransactionSql<{}>,
+    client: postgres.TransactionSql,
     workflowID: string,
-    functionNum: number,
+    stepID: number,
     output: string | null,
   ): Promise<void> {
     try {
       await client/*sql*/ `
         INSERT INTO dbos.transaction_completion (workflow_id, function_num, output)
-        VALUES (${workflowID}, ${functionNum}, ${output})`;
+        VALUES (${workflowID}, ${stepID}, ${output})`;
     } catch (error) {
       if (isPGKeyConflictError(error)) {
         throw new DBOSWorkflowConflictError(workflowID);
@@ -82,11 +91,11 @@ class PostgresTransactionHandler implements DataSourceTransactionHandler {
     }
   }
 
-  async #recordError(workflowID: string, functionNum: number, error: string): Promise<void> {
+  async #recordError(workflowID: string, stepID: number, error: string): Promise<void> {
     try {
       await this.#db/*sql*/ `
         INSERT INTO dbos.transaction_completion (workflow_id, function_num, error)
-        VALUES (${workflowID}, ${functionNum}, ${error})`;
+        VALUES (${workflowID}, ${stepID}, ${error})`;
     } catch (error) {
       if (isPGKeyConflictError(error)) {
         throw new DBOSWorkflowConflictError(workflowID);
@@ -103,26 +112,24 @@ class PostgresTransactionHandler implements DataSourceTransactionHandler {
     ...args: Args
   ): Promise<Return> {
     const workflowID = DBOS.workflowID;
-    if (workflowID === undefined) {
-      throw new Error('Workflow ID is not set.');
-    }
-    const functionNum = DBOS.stepID;
-    if (functionNum === undefined) {
-      throw new Error('Function Number is not set.');
+    const stepID = DBOS.stepID;
+    if (workflowID !== undefined && stepID === undefined) {
+      throw new Error('DBOS.stepID is undefined inside a workflow.');
     }
 
     const isolationLevel = config?.isolationLevel ? `ISOLATION LEVEL ${config.isolationLevel}` : '';
     const readOnly = config?.readOnly ?? false;
     const accessMode = config?.readOnly === undefined ? '' : readOnly ? 'READ ONLY' : 'READ WRITE';
-    const saveResults = !readOnly && workflowID;
+    const saveResults = !readOnly && workflowID !== undefined;
 
+    // Retry loop if appropriate
     let retryWaitMS = 1;
     const backoffFactor = 1.5;
-    const maxRetryWaitMS = 2000;
+    const maxRetryWaitMS = 2000; // Maximum wait 2 seconds.
 
     while (true) {
       // Check to see if this tx has already been executed
-      const previousResult = saveResults ? await this.#checkExecution(workflowID, functionNum) : undefined;
+      const previousResult = saveResults ? await this.#checkExecution(workflowID, stepID!) : undefined;
       if (previousResult) {
         DBOS.span?.setAttribute('cached', true);
 
@@ -141,12 +148,7 @@ class PostgresTransactionHandler implements DataSourceTransactionHandler {
 
           // save the output of read/write transactions
           if (saveResults) {
-            await PostgresTransactionHandler.#recordOutput(
-              client,
-              workflowID,
-              functionNum,
-              SuperJSON.stringify(result),
-            );
+            await PostgresTransactionHandler.#recordOutput(client, workflowID, stepID!, SuperJSON.stringify(result));
           }
 
           return result;
@@ -162,7 +164,7 @@ class PostgresTransactionHandler implements DataSourceTransactionHandler {
         } else {
           if (saveResults) {
             const message = SuperJSON.stringify(error);
-            await this.#recordError(workflowID, functionNum, message);
+            await this.#recordError(workflowID, stepID!, message);
           }
 
           throw error;
@@ -173,20 +175,18 @@ class PostgresTransactionHandler implements DataSourceTransactionHandler {
 }
 
 export class PostgresDataSource implements DBOSDataSource<PostgresTransactionOptions> {
-  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-  static get client(): postgres.TransactionSql<{}> {
+  static get client(): postgres.TransactionSql {
     if (!DBOS.isInTransaction()) {
       throw new Error('invalid use of PostgresDataSource.client outside of a DBOS transaction.');
     }
     const ctx = asyncLocalCtx.getStore();
     if (!ctx) {
-      throw new Error('No async local context found.');
+      throw new Error('invalid use of PostgresDataSource.client outside of a DBOS transaction.');
     }
     return ctx.client;
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-  static async initializeInternalSchema(options: postgres.Options<{}> = {}): Promise<void> {
+  static async initializeInternalSchema(options: Options = {}): Promise<void> {
     const pg = postgres({ ...options, onnotice: () => {} });
     try {
       await pg.unsafe(createTransactionCompletionSchemaPG);
@@ -196,12 +196,12 @@ export class PostgresDataSource implements DBOSDataSource<PostgresTransactionOpt
     }
   }
 
-  readonly name: string;
   #provider: PostgresTransactionHandler;
 
-  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-  constructor(name: string, options: postgres.Options<{}> = {}) {
-    this.name = name;
+  constructor(
+    readonly name: string,
+    options: Options = {},
+  ) {
     this.#provider = new PostgresTransactionHandler(name, options);
     registerDataSource(this.#provider);
   }
@@ -212,10 +212,10 @@ export class PostgresDataSource implements DBOSDataSource<PostgresTransactionOpt
 
   registerTransaction<This, Args extends unknown[], Return>(
     func: (this: This, ...args: Args) => Promise<Return>,
-    name: string,
     config?: PostgresTransactionOptions,
+    name?: string,
   ): (this: This, ...args: Args) => Promise<Return> {
-    return registerTransaction(this.name, func, { name }, config);
+    return registerTransaction(this.name, func, { name: name ?? func.name }, config);
   }
 
   transaction(config?: PostgresTransactionOptions) {
@@ -223,14 +223,14 @@ export class PostgresDataSource implements DBOSDataSource<PostgresTransactionOpt
     const ds = this;
     return function decorator<This, Args extends unknown[], Return>(
       _target: object,
-      propertyKey: string,
+      propertyKey: PropertyKey,
       descriptor: TypedPropertyDescriptor<(this: This, ...args: Args) => Promise<Return>>,
     ) {
       if (!descriptor.value) {
         throw Error('Use of decorator when original method is undefined');
       }
 
-      descriptor.value = ds.registerTransaction(descriptor.value, propertyKey.toString(), config);
+      descriptor.value = ds.registerTransaction(descriptor.value, config, String(propertyKey));
 
       return descriptor;
     };

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "@dbos-inc/postgres-datasource",
-  "version": "3.0.7-preview",
-  "description": "",
+  "version": "3.0.8-preview",
+  "description": "DBOS DataSource library for Postgres database client",
   "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "homepage": "https://docs.dbos.dev/",
   "repository": {
     "type": "git",
     "url": "https://github.com/dbos-inc/dbos-transact-ts",
-    "directory": "packages/knex-datasource"
+    "directory": "packages/postgres-datasource"
   },
-  "homepage": "https://docs.dbos.dev/",
-  "main": "index.js",
   "scripts": {
     "build": "tsc --project tsconfig.json",
     "test": "jest --detectOpenHandles"

package/tests/datasource.test.ts

@@ -44,13 +44,19 @@ describe('PostgresDataSource', () => {
     }
 
     await PostgresDataSource.initializeInternalSchema(config);
+  });
+
+  afterAll(async () => {
+    await userDB.end();
+  });
+
+  beforeEach(async () => {
     DBOS.setConfig({ name: 'pg-ds-test' });
     await DBOS.launch();
   });
 
-  afterAll(async () => {
+  afterEach(async () => {
     await DBOS.shutdown();
-    await userDB.end();
   });
 
   test('insert dataSource.register function', async () => {
@@ -59,7 +65,7 @@ describe('PostgresDataSource', () => {
     await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
     const workflowID = randomUUID();
 
-    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorfklowReg(user))).resolves.toMatchObject({
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorkflowReg(user))).resolves.toMatchObject({
       user,
       greet_count: 1,
     });
@@ -81,10 +87,10 @@ describe('PostgresDataSource', () => {
     await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
     const workflowID = randomUUID();
 
-    const result = await DBOS.withNextWorkflowID(workflowID, () => regInsertWorfklowReg(user));
+    const result = await DBOS.withNextWorkflowID(workflowID, () => regInsertWorkflowReg(user));
     expect(result).toMatchObject({ user, greet_count: 1 });
 
-    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorfklowReg(user))).resolves.toMatchObject(result);
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorkflowReg(user))).resolves.toMatchObject(result);
   });
 
   test('insert dataSource.runAsTx function', async () => {
@@ -93,7 +99,7 @@ describe('PostgresDataSource', () => {
     await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
     const workflowID = randomUUID();
 
-    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorfklowRunTx(user))).resolves.toMatchObject({
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorkflowRunTx(user))).resolves.toMatchObject({
       user,
       greet_count: 1,
     });
@@ -115,10 +121,10 @@ describe('PostgresDataSource', () => {
     await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
     const workflowID = randomUUID();
 
-    const result = await DBOS.withNextWorkflowID(workflowID, () => regInsertWorfklowRunTx(user));
+    const result = await DBOS.withNextWorkflowID(workflowID, () => regInsertWorkflowRunTx(user));
     expect(result).toMatchObject({ user, greet_count: 1 });
 
-    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorfklowRunTx(user))).resolves.toMatchObject(
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorkflowRunTx(user))).resolves.toMatchObject(
       result,
     );
   });
@@ -281,6 +287,40 @@ describe('PostgresDataSource', () => {
       { 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 {
@@ -300,9 +340,8 @@ async function insertFunction(user: string) {
 }
 
 async function errorFunction(user: string) {
-  const result = await insertFunction(user);
+  const _result = await insertFunction(user);
   throw new Error(`test error ${Date.now()}`);
-  return result;
 }
 
 async function readFunction(user: string) {
@@ -314,9 +353,9 @@ async function readFunction(user: string) {
   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) {
@@ -328,8 +367,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) {
@@ -344,12 +383,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) {
@@ -389,8 +427,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');