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

package/index.ts

@@ -25,56 +25,41 @@ export { NodePostgresTransactionOptions };
 
 const asyncLocalCtx = new AsyncLocalStorage<NodePostgresDataSourceContext>();
 
-class NodePostgresTransactionHandler implements DataSourceTransactionHandler {
+class NodePGDSTH implements DataSourceTransactionHandler {
+  readonly name: string;
   readonly dsType = 'NodePostgresDataSource';
-  #poolField: Pool | undefined;
+  readonly #pool: Pool;
 
-  constructor(
-    readonly name: string,
-    private readonly config: PoolConfig,
-  ) {}
-
-  async initialize(): Promise<void> {
-    const pool = this.#poolField;
-    this.#poolField = new Pool(this.config);
-    await pool?.end();
+  constructor(name: string, config: PoolConfig) {
+    this.name = name;
+    this.#pool = new Pool(config);
   }
 
-  async destroy(): Promise<void> {
-    const pool = this.#poolField;
-    this.#poolField = undefined;
-    await pool?.end();
+  initialize(): Promise<void> {
+    return Promise.resolve();
   }
 
-  get #pool(): Pool {
-    if (!this.#poolField) {
-      throw new Error(`DataSource ${this.name} is not initialized.`);
-    }
-    return this.#poolField;
+  destroy(): Promise<void> {
+    return this.#pool.end();
   }
 
-  async #checkExecution(
+  static async #checkExecution(
+    client: ClientBase,
     workflowID: string,
-    stepID: number,
-  ): Promise<{ output: string | null } | { error: string } | undefined> {
-    type Result = { output: string | null; error: string | null };
-    const { rows } = await this.#pool.query<Result>(
-      /*sql*/
-      `SELECT output, error FROM dbos.transaction_completion
+    functionNum: number,
+  ): Promise<{ output: string | null } | undefined> {
+    const { rows } = await client.query<{ output: string }>(
+      /*sql*/ `SELECT output FROM dbos.transaction_completion
        WHERE workflow_id = $1 AND function_num = $2`,
-      [workflowID, stepID],
+      [workflowID, functionNum],
     );
-    if (rows.length === 0) {
-      return undefined;
-    }
-    const { output, error } = rows[0];
-    return error !== null ? { error } : { output };
+    return rows.length > 0 ? { output: rows[0].output } : undefined;
   }
 
   static async #recordOutput(
     client: ClientBase,
     workflowID: string,
-    stepID: number,
+    functionNum: number,
     output: string | null,
   ): Promise<void> {
     try {
@@ -82,24 +67,7 @@ class NodePostgresTransactionHandler implements DataSourceTransactionHandler {
         /*sql*/
         `INSERT INTO dbos.transaction_completion (workflow_id, function_num, output) 
          VALUES ($1, $2, $3)`,
-        [workflowID, stepID, output],
-      );
-    } catch (error) {
-      if (isPGKeyConflictError(error)) {
-        throw new DBOSWorkflowConflictError(workflowID);
-      } else {
-        throw error;
-      }
-    }
-  }
-
-  async #recordError(workflowID: string, stepID: number, error: string): Promise<void> {
-    try {
-      await this.#pool.query(
-        /*sql*/
-        `INSERT INTO dbos.transaction_completion (workflow_id, function_num, error) 
-         VALUES ($1, $2, $3)`,
-        [workflowID, stepID, error],
+        [workflowID, functionNum, output],
       );
     } catch (error) {
       if (isPGKeyConflictError(error)) {
@@ -139,64 +107,67 @@ class NodePostgresTransactionHandler 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 readOnly = config?.readOnly ?? false;
-    const saveResults = !readOnly && workflowID !== undefined;
-
-    // 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;
-      if (previousResult) {
-        DBOS.span?.setAttribute('cached', true);
-
-        if ('error' in previousResult) {
-          throw SuperJSON.parse(previousResult.error);
-        }
-
-        return (previousResult.output ? SuperJSON.parse(previousResult.output) : null) as Return;
-      }
-
       try {
-        const result = await this.#transaction<Return>(async (client) => {
-          // execute user's transaction function
-          const result = await asyncLocalCtx.run({ client }, async () => {
-            return (await func.call(target, ...args)) as Return;
-          });
-
-          // save the output of read/write transactions
-          if (saveResults) {
-            await NodePostgresTransactionHandler.#recordOutput(
-              client,
-              workflowID,
-              stepID!,
-              SuperJSON.stringify(result),
-            );
-          }
-
-          return result;
-        }, config);
+        const result = await this.#transaction<Return>(
+          async (client) => {
+            // Check to see if this tx has already been executed
+            const previousResult =
+              readOnly || !workflowID ? undefined : await NodePGDSTH.#checkExecution(client, workflowID, functionNum);
+            if (previousResult) {
+              return (previousResult.output ? SuperJSON.parse(previousResult.output) : null) as Return;
+            }
+
+            // execute user's transaction function
+            const result = await asyncLocalCtx.run({ client }, async () => {
+              return (await func.call(target, ...args)) as Return;
+            });
+
+            // save the output of read/write transactions
+            if (!readOnly && workflowID) {
+              await NodePGDSTH.#recordOutput(client, workflowID, functionNum, SuperJSON.stringify(result));
+
+              // Note, existing code wraps #recordOutput call in a try/catch block that
+              // converts DB error with code 25P02 to DBOSFailedSqlTransactionError.
+              // However, existing code doesn't make any logic decisions based on that error type.
+              // DBOSFailedSqlTransactionError does stored WF ID and function name, so I assume that info is logged out somewhere
+            }
+
+            return result;
+          },
+          { isolationLevel: config?.isolationLevel, readOnly: config?.readOnly },
+        );
+        // TODO: span.setStatus({ code: SpanStatusCode.OK });
+        // TODO: this.tracer.endSpan(span);
 
         return result;
       } catch (error) {
         if (isPGRetriableTransactionError(error)) {
-          DBOS.span?.addEvent('TXN SERIALIZATION FAILURE', { retryWaitMillis: retryWaitMS }, performance.now());
+          // TODO: span.addEvent('TXN SERIALIZATION FAILURE', { retryWaitMillis: retryWaitMillis }, performance.now());
           await new Promise((resolve) => setTimeout(resolve, retryWaitMS));
           retryWaitMS = Math.min(retryWaitMS * backoffFactor, maxRetryWaitMS);
           continue;
         } else {
-          if (saveResults) {
-            const message = SuperJSON.stringify(error);
-            await this.#recordError(workflowID, stepID!, message);
-          }
+          // TODO: span.setStatus({ code: SpanStatusCode.ERROR, message: e.message });
+          // TODO: this.tracer.endSpan(span);
+
+          // TODO: currently, we are *not* recording errors in the txOutput table.
+          // For normal execution, this is fine because we also store tx step results (output and error) in the sysdb operation output table.
+          // However, I'm concerned that we have a dueling execution hole where one tx fails while another succeeds.
+          // This implies that we can end up in a situation where the step output records an error but the txOutput table records success.
 
           throw error;
         }
@@ -212,7 +183,7 @@ export class NodePostgresDataSource implements DBOSDataSource<NodePostgresTransa
     }
     const ctx = asyncLocalCtx.getStore();
     if (!ctx) {
-      throw new Error('invalid use of NodePostgresDataSource.client outside of a DBOS transaction.');
+      throw new Error('No async local context found.');
     }
     return ctx.client;
   }
@@ -228,13 +199,12 @@ export class NodePostgresDataSource implements DBOSDataSource<NodePostgresTransa
     }
   }
 
-  #provider: NodePostgresTransactionHandler;
+  readonly name: string;
+  #provider: NodePGDSTH;
 
-  constructor(
-    readonly name: string,
-    config: PoolConfig,
-  ) {
-    this.#provider = new NodePostgresTransactionHandler(name, config);
+  constructor(name: string, config: PoolConfig) {
+    this.name = name;
+    this.#provider = new NodePGDSTH(name, config);
     registerDataSource(this.#provider);
   }
 
@@ -244,10 +214,10 @@ export class NodePostgresDataSource implements DBOSDataSource<NodePostgresTransa
 
   registerTransaction<This, Args extends unknown[], Return>(
     func: (this: This, ...args: Args) => Promise<Return>,
+    name: string,
     config?: NodePostgresTransactionOptions,
-    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?: NodePostgresTransactionOptions) {
@@ -255,14 +225,14 @@ export class NodePostgresDataSource implements DBOSDataSource<NodePostgresTransa
     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/node-pg-datasource",
-  "version": "3.0.10-preview",
-  "description": "DBOS DataSource library for Node-Postgres database client",
+  "version": "3.0.11-preview.gc9233b8190",
+  "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/nodepg-datasource"
+    "directory": "packages/knex-datasource"
   },
+  "homepage": "https://docs.dbos.dev/",
+  "main": "index.js",
   "scripts": {
     "build": "tsc --project tsconfig.json",
     "test": "jest --detectOpenHandles"

package/tests/config.test.ts

@@ -9,7 +9,7 @@ describe('NodePostgresDataSource.configure', () => {
     const client = new Client({ ...config, database: 'postgres' });
     try {
       await client.connect();
-      await dropDB(client, config.database, true);
+      await dropDB(client, config.database);
       await ensureDB(client, config.database);
     } finally {
       await client.end();