@dbos-inc/postgres-datasource 3.0.8-preview → 3.0.8-preview.g493d2d1c2b

package/index.ts

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

package/package.json

@@ -1,16 +1,15 @@
 {
   "name": "@dbos-inc/postgres-datasource",
-  "version": "3.0.8-preview",
-  "description": "DBOS DataSource library for Postgres database client",
+  "version": "3.0.8-preview.g493d2d1c2b",
+  "description": "",
   "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/postgres-datasource"
+    "directory": "packages/knex-datasource"
   },
+  "homepage": "https://docs.dbos.dev/",
+  "main": "index.js",
   "scripts": {
     "build": "tsc --project tsconfig.json",
     "test": "jest --detectOpenHandles"

package/tests/datasource.test.ts

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