@dbos-inc/prisma-datasource 3.0.35-preview

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+import { FunctionName } from '@dbos-inc/dbos-sdk';
+import { DBOSDataSource } from '@dbos-inc/dbos-sdk/datasource';
+type PrismaLike = {
+    $connect: () => Promise<void>;
+    $disconnect: () => Promise<void>;
+    $queryRawUnsafe<T = unknown>(query: unknown, ...values: unknown[]): Promise<T>;
+    $executeRawUnsafe(query: unknown, ...values: unknown[]): Promise<number>;
+};
+type TransactionIsolationLevel = 'ReadUncommitted' | 'ReadCommitted' | 'RepeatableRead' | 'Serializable';
+export type TransactionConfig = {
+    isolationLevel?: TransactionIsolationLevel;
+    readOnly?: boolean;
+    name?: string;
+};
+export declare class PrismaDataSource<PrismaClient> implements DBOSDataSource<TransactionConfig> {
+    #private;
+    readonly name: string;
+    get client(): PrismaClient;
+    static initializeDBOSSchema(prisma: PrismaLike): Promise<void>;
+    static uninitializeDBOSSchema(prisma: PrismaLike): Promise<void>;
+    constructor(name: string, prismaAccess: PrismaLike | (() => PrismaLike));
+    runTransaction<T>(func: () => Promise<T>, config?: TransactionConfig): Promise<T>;
+    registerTransaction<This, Args extends unknown[], Return>(func: (this: This, ...args: Args) => Promise<Return>, config?: TransactionConfig & FunctionName): (this: This, ...args: Args) => Promise<Return>;
+    transaction(config?: TransactionConfig): <This, Args extends unknown[], Return>(target: object, propertyKey: PropertyKey, descriptor: TypedPropertyDescriptor<(this: This, ...args: Args) => Promise<Return>>) => TypedPropertyDescriptor<(this: This, ...args: Args) => Promise<Return>>;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AACA,OAAO,EAAmC,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACnF,OAAO,EAML,cAAc,EAIf,MAAM,+BAA+B,CAAC;AAIvC,KAAK,UAAU,GAAG;IAChB,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,WAAW,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC,eAAe,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC/E,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC1E,CAAC;AAaF,KAAK,yBAAyB,GAAG,iBAAiB,GAAG,eAAe,GAAG,gBAAgB,GAAG,cAAc,CAAC;AAEzG,MAAM,MAAM,iBAAiB,GAAG;IAC9B,cAAc,CAAC,EAAE,yBAAyB,CAAC;IAC3C,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAoKF,qBAAa,gBAAgB,CAAC,YAAY,CAAE,YAAW,cAAc,CAAC,iBAAiB,CAAC;;IA8BpF,QAAQ,CAAC,IAAI,EAAE,MAAM;IAjBvB,IAAI,MAAM,IAAI,YAAY,CAEzB;WAEY,oBAAoB,CAAC,MAAM,EAAE,UAAU;WAKvC,sBAAsB,CAAC,MAAM,EAAE,UAAU;gBAQ3C,IAAI,EAAE,MAAM,EACrB,YAAY,EAAE,UAAU,GAAG,CAAC,MAAM,UAAU,CAAC;IAMzC,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,iBAAiB;IAI1E,mBAAmB,CAAC,IAAI,EAAE,IAAI,SAAS,OAAO,EAAE,EAAE,MAAM,EACtD,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,EACpD,MAAM,CAAC,EAAE,iBAAiB,GAAG,YAAY,GACxC,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC;IAIjD,WAAW,CAAC,MAAM,CAAC,EAAE,iBAAiB,kDAI1B,MAAM,eACD,WAAW,cACZ,wBAAwB,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,IAAI,KAAK,QAAQ,MAAM,CAAC,CAAC,oCAAxC,IAAI,WAAW,IAAI,KAAK,QAAQ,MAAM,CAAC;CAevF"}

package/dist/index.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaDataSource = void 0;
+const dbos_sdk_1 = require("@dbos-inc/dbos-sdk");
+const datasource_1 = require("@dbos-inc/dbos-sdk/datasource");
+const async_hooks_1 = require("async_hooks");
+const superjson_1 = require("superjson");
+const asyncLocalCtx = new async_hooks_1.AsyncLocalStorage();
+class PrismaTransactionHandler {
+    name;
+    prismaAccess;
+    dsType = 'PrismaDataSource';
+    constructor(name, prismaAccess) {
+        this.name = name;
+        this.prismaAccess = prismaAccess;
+    }
+    get #prismaDB() {
+        if (!this.prismaAccess) {
+            throw new Error(`DataSource ${this.name} is not initialized.`);
+        }
+        if (typeof this.prismaAccess === 'function') {
+            const p = this.prismaAccess();
+            if (!p) {
+                throw new Error(`DataSource ${this.name} is not initialized.`);
+            }
+            return p;
+        }
+        return this.prismaAccess;
+    }
+    initialize() {
+        return Promise.resolve();
+    }
+    destroy() {
+        return Promise.resolve();
+    }
+    async #checkExecution(client, workflowID, stepID) {
+        const result = await client.$queryRawUnsafe(`SELECT output, error FROM dbos.transaction_completion
+      WHERE workflow_id = $1 AND function_num = $2`, workflowID, stepID);
+        if (result?.[0] === undefined) {
+            return undefined;
+        }
+        const { output, error } = result[0];
+        return error !== null ? { error } : { output };
+    }
+    async #recordError(workflowID, stepID, error) {
+        try {
+            await this.#prismaDB.$executeRawUnsafe(`INSERT INTO dbos.transaction_completion (workflow_id, function_num, error) 
+        VALUES ($1, $2, $3)`, workflowID, stepID, error);
+        }
+        catch (error) {
+            if ((0, datasource_1.isPGKeyConflictError)(error)) {
+                throw new dbos_sdk_1.DBOSWorkflowConflictError(workflowID);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    static async #recordOutput(client, workflowID, stepID, output) {
+        try {
+            await client.$executeRawUnsafe(`INSERT INTO dbos.transaction_completion (workflow_id, function_num, output) 
+         VALUES ($1, $2, $3)`, workflowID, stepID, output);
+        }
+        catch (error) {
+            if ((0, datasource_1.isPGKeyConflictError)(error)) {
+                throw new dbos_sdk_1.DBOSWorkflowConflictError(workflowID);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    async invokeTransactionFunction(config, target, func, ...args) {
+        const workflowID = dbos_sdk_1.DBOS.workflowID;
+        const stepID = dbos_sdk_1.DBOS.stepID;
+        if (workflowID !== undefined && stepID === undefined) {
+            throw new Error('DBOS.stepID is undefined inside a workflow.');
+        }
+        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.
+        while (true) {
+            // Check to see if this tx has already been executed
+            const previousResult = saveResults ? await this.#checkExecution(this.#prismaDB, workflowID, stepID) : undefined;
+            if (previousResult) {
+                dbos_sdk_1.DBOS.span?.setAttribute('cached', true);
+                if ('error' in previousResult) {
+                    throw superjson_1.SuperJSON.parse(previousResult.error);
+                }
+                return (previousResult.output ? superjson_1.SuperJSON.parse(previousResult.output) : null);
+            }
+            try {
+                const result = (await this.#prismaDB.$transaction(async (client) => {
+                    // execute user's transaction function
+                    const result = await asyncLocalCtx.run({ client, owner: this }, async () => {
+                        return (await func.call(target, ...args));
+                    });
+                    // save the output of read/write transactions
+                    if (saveResults) {
+                        await PrismaTransactionHandler.#recordOutput(client, workflowID, stepID, superjson_1.SuperJSON.stringify(result));
+                    }
+                    return result;
+                }, { isolationLevel: config?.isolationLevel }));
+                return result;
+            }
+            catch (error) {
+                if ((0, datasource_1.isPGRetriableTransactionError)(error)) {
+                    dbos_sdk_1.DBOS.span?.addEvent('TXN SERIALIZATION FAILURE', { retryWaitMillis: retryWaitMS }, performance.now());
+                    await new Promise((resolve) => setTimeout(resolve, retryWaitMS));
+                    retryWaitMS = Math.min(retryWaitMS * backoffFactor, maxRetryWaitMS);
+                    continue;
+                }
+                else {
+                    if (saveResults) {
+                        const message = superjson_1.SuperJSON.stringify(error);
+                        await this.#recordError(workflowID, stepID, message);
+                    }
+                    throw error;
+                }
+            }
+        }
+    }
+}
+class PrismaDataSource {
+    name;
+    static #getClient(p) {
+        if (!dbos_sdk_1.DBOS.isInTransaction()) {
+            throw new Error('invalid use of PrismaDataSource.client outside of a DBOS transaction.');
+        }
+        const ctx = asyncLocalCtx.getStore();
+        if (!ctx) {
+            throw new Error('invalid use of PrismaDataSource.client outside of a DBOS transaction.');
+        }
+        if (p && p !== ctx.owner)
+            throw new Error('Request of `PrismaDataSource.client` from the wrong object.');
+        return ctx.client;
+    }
+    get client() {
+        return PrismaDataSource.#getClient(this.#provider);
+    }
+    static async initializeDBOSSchema(prisma) {
+        await prisma.$queryRawUnsafe(datasource_1.createTransactionCompletionSchemaPG);
+        await prisma.$queryRawUnsafe(datasource_1.createTransactionCompletionTablePG);
+    }
+    static async uninitializeDBOSSchema(prisma) {
+        await prisma.$executeRawUnsafe('DROP TABLE IF EXISTS dbos.transaction_completion;');
+        await prisma.$executeRawUnsafe('DROP SCHEMA IF EXISTS dbos;');
+    }
+    #provider;
+    constructor(name, prismaAccess) {
+        this.name = name;
+        this.#provider = new PrismaTransactionHandler(name, prismaAccess);
+        (0, datasource_1.registerDataSource)(this.#provider);
+    }
+    async runTransaction(func, config) {
+        return await (0, datasource_1.runTransaction)(func, config?.name ?? func.name, { dsName: this.name, config });
+    }
+    registerTransaction(func, config) {
+        return (0, datasource_1.registerTransaction)(this.name, func, config);
+    }
+    transaction(config) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const ds = this;
+        return function decorator(target, propertyKey, descriptor) {
+            if (!descriptor.value) {
+                throw Error('Use of decorator when original method is undefined');
+            }
+            descriptor.value = ds.registerTransaction(descriptor.value, {
+                ...config,
+                name: config?.name ?? String(propertyKey),
+                ctorOrProto: target,
+            });
+            return descriptor;
+        };
+    }
+}
+exports.PrismaDataSource = PrismaDataSource;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"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"}

package/index.ts

@@ -0,0 +1,274 @@
+
+import { DBOS, DBOSWorkflowConflictError, FunctionName } from '@dbos-inc/dbos-sdk';
+import {
+  type DataSourceTransactionHandler,
+  isPGRetriableTransactionError,
+  isPGKeyConflictError,
+  registerTransaction,
+  runTransaction,
+  DBOSDataSource,
+  registerDataSource,
+  createTransactionCompletionSchemaPG,
+  createTransactionCompletionTablePG,
+} from '@dbos-inc/dbos-sdk/datasource';
+import { AsyncLocalStorage } from 'async_hooks';
+import { SuperJSON } from 'superjson';
+
+type PrismaLike = {
+  $connect: () => Promise<void>;
+  $disconnect: () => Promise<void>;
+  $queryRawUnsafe<T = unknown>(query: unknown, ...values: unknown[]): Promise<T>;
+  $executeRawUnsafe(query: unknown, ...values: unknown[]): Promise<number>;
+};
+
+type PrismaLikeTx = {
+  $queryRawUnsafe<T = unknown>(query: TemplateStringsArray | string, ...values: unknown[]): Promise<T>;
+  $executeRawUnsafe(query: TemplateStringsArray | string, ...values: unknown[]): Promise<number>;
+  $transaction: (tf: (tx: PrismaLike) => Promise<unknown>, config?: unknown) => Promise<unknown>;
+};
+
+interface PrismaDataSourceContext {
+  client: PrismaLike;
+  owner: PrismaTransactionHandler;
+}
+
+type TransactionIsolationLevel = 'ReadUncommitted' | 'ReadCommitted' | 'RepeatableRead' | 'Serializable';
+
+export type TransactionConfig = {
+  isolationLevel?: TransactionIsolationLevel;
+  readOnly?: boolean;
+  name?: string;
+};
+
+const asyncLocalCtx = new AsyncLocalStorage<PrismaDataSourceContext>();
+
+class PrismaTransactionHandler implements DataSourceTransactionHandler {
+  readonly dsType = 'PrismaDataSource';
+
+  constructor(
+    readonly name: string,
+    private readonly prismaAccess: PrismaLike | (() => PrismaLike),
+  ) {}
+
+  get #prismaDB() {
+    if (!this.prismaAccess) {
+      throw new Error(`DataSource ${this.name} is not initialized.`);
+    }
+    if (typeof this.prismaAccess === 'function') {
+      const p = this.prismaAccess();
+      if (!p) {
+        throw new Error(`DataSource ${this.name} is not initialized.`);
+      }
+      return p;
+    }
+    return this.prismaAccess;
+  }
+
+  initialize(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  destroy(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  async #checkExecution(
+    client: PrismaLike,
+    workflowID: string,
+    stepID: number,
+  ): Promise<{ output: string | null } | { error: string } | undefined> {
+    type Result = { output: string | null; error: string | null };
+    const result = await client.$queryRawUnsafe<Result[]>(
+      `SELECT output, error FROM dbos.transaction_completion
+      WHERE workflow_id = $1 AND function_num = $2`,
+      workflowID,
+      stepID,
+    );
+    if (result?.[0] === undefined) {
+      return undefined;
+    }
+    const { output, error } = result[0];
+    return error !== null ? { error } : { output };
+  }
+
+  async #recordError(workflowID: string, stepID: number, error: string): Promise<void> {
+    try {
+      await this.#prismaDB.$executeRawUnsafe(
+        `INSERT INTO dbos.transaction_completion (workflow_id, function_num, error) 
+        VALUES ($1, $2, $3)`,
+        workflowID,
+        stepID,
+        error,
+      );
+    } catch (error) {
+      if (isPGKeyConflictError(error)) {
+        throw new DBOSWorkflowConflictError(workflowID);
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  static async #recordOutput(
+    client: PrismaLike,
+    workflowID: string,
+    stepID: number,
+    output: string | null,
+  ): Promise<void> {
+    try {
+      await client.$executeRawUnsafe(
+        `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 invokeTransactionFunction<This, Args extends unknown[], Return>(
+    config: TransactionConfig | undefined,
+    target: This,
+    func: (this: This, ...args: Args) => Promise<Return>,
+    ...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.');
+    }
+
+    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.
+
+    while (true) {
+      // Check to see if this tx has already been executed
+      const previousResult = saveResults ? await this.#checkExecution(this.#prismaDB, 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.#prismaDB as unknown as PrismaLikeTx).$transaction(
+          async (client) => {
+            // execute user's transaction function
+            const result = await asyncLocalCtx.run({ client, owner: this }, async () => {
+              return (await func.call(target, ...args)) as Return;
+            });
+
+            // save the output of read/write transactions
+            if (saveResults) {
+              await PrismaTransactionHandler.#recordOutput(client, workflowID, stepID!, SuperJSON.stringify(result));
+            }
+
+            return result;
+          },
+          { isolationLevel: config?.isolationLevel },
+        )) as Return;
+
+        return result;
+      } catch (error) {
+        if (isPGRetriableTransactionError(error)) {
+          DBOS.span?.addEvent('TXN SERIALIZATION FAILURE', { retryWaitMillis: retryWaitMS }, 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);
+          }
+
+          throw error;
+        }
+      }
+    }
+  }
+}
+
+export class PrismaDataSource<PrismaClient> implements DBOSDataSource<TransactionConfig> {
+  static #getClient(p?: PrismaTransactionHandler) {
+    if (!DBOS.isInTransaction()) {
+      throw new Error('invalid use of PrismaDataSource.client outside of a DBOS transaction.');
+    }
+    const ctx = asyncLocalCtx.getStore();
+    if (!ctx) {
+      throw new Error('invalid use of PrismaDataSource.client outside of a DBOS transaction.');
+    }
+    if (p && p !== ctx.owner) throw new Error('Request of `PrismaDataSource.client` from the wrong object.');
+    return ctx.client;
+  }
+
+  get client(): PrismaClient {
+    return PrismaDataSource.#getClient(this.#provider) as PrismaClient;
+  }
+
+  static async initializeDBOSSchema(prisma: PrismaLike) {
+    await prisma.$queryRawUnsafe(createTransactionCompletionSchemaPG);
+    await prisma.$queryRawUnsafe(createTransactionCompletionTablePG);
+  }
+
+  static async uninitializeDBOSSchema(prisma: PrismaLike) {
+    await prisma.$executeRawUnsafe('DROP TABLE IF EXISTS dbos.transaction_completion;');
+    await prisma.$executeRawUnsafe('DROP SCHEMA IF EXISTS dbos;');
+  }
+
+  #provider: PrismaTransactionHandler;
+
+  constructor(
+    readonly name: string,
+    prismaAccess: PrismaLike | (() => PrismaLike),
+  ) {
+    this.#provider = new PrismaTransactionHandler(name, prismaAccess);
+    registerDataSource(this.#provider);
+  }
+
+  async runTransaction<T>(func: () => Promise<T>, config?: TransactionConfig) {
+    return await runTransaction(func, config?.name ?? func.name, { dsName: this.name, config });
+  }
+
+  registerTransaction<This, Args extends unknown[], Return>(
+    func: (this: This, ...args: Args) => Promise<Return>,
+    config?: TransactionConfig & FunctionName,
+  ): (this: This, ...args: Args) => Promise<Return> {
+    return registerTransaction(this.name, func, config);
+  }
+
+  transaction(config?: TransactionConfig) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const ds = this;
+    return function decorator<This, Args extends unknown[], Return>(
+      target: object,
+      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, {
+        ...config,
+        name: config?.name ?? String(propertyKey),
+        ctorOrProto: target,
+      });
+
+      return descriptor;
+    };
+  }
+}

package/jest.config.js

@@ -0,0 +1,8 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testRegex: '((\\.|/)(test|spec))\\.ts?$',
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  modulePaths: ['./'],
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@dbos-inc/prisma-datasource",
+  "version": "3.0.35-preview",
+  "description": "DBOS Data Source library for Prisma ORM with PostgreSQL support",
+  "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/prisma-datasource"
+  },
+  "prisma": {
+    "schema": "./tests/prisma/schema.prisma"
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.json",
+    "test": "npx prisma generate && tsc --project tsconfig.json && jest --detectOpenHandles"
+  },
+  "dependencies": {
+    "pg": "^8.11.3",
+    "superjson": "^1.13"
+  },
+  "peerDependencies": {
+    "@dbos-inc/dbos-sdk": "*"
+  },
+  "devDependencies": {
+    "@prisma/client": "^5.15.0",
+    "@types/jest": "^29.5.14",
+    "@types/pg": "^8.15.2",
+    "jest": "^29.7.0",
+    "prisma": "^5.15.0",
+    "typescript": "^5.4.5"
+  }
+}

package/tests/config.test.ts

@@ -0,0 +1,82 @@
+import { Client } from 'pg';
+import { PrismaDataSource } from '../index';
+import { dropDB, ensureDB } from './test-helpers';
+
+import { PrismaClient } from '@prisma/client';
+
+const config = { user: 'postgres', database: 'prisma_ds_test' };
+
+process.env['DATABASE_URL'] =
+  process.env['DATABSE_URL'] ||
+  `postgresql://${config.user}:${process.env['PGPASSWORD'] || 'dbos'}@${process.env['PGHOST'] || 'localhost'}:${process.env['PGPORT'] || '5432'}/${config.database}`;
+
+describe('PrismaDataSource.initializeDBOSSchema', () => {
+  const prisma = new PrismaClient();
+
+  beforeEach(async () => {
+    const client = new Client({ ...config, database: 'postgres' });
+    try {
+      await client.connect();
+      await dropDB(client, config.database, true);
+      await ensureDB(client, config.database);
+    } finally {
+      await client.end();
+    }
+    await prisma.$connect();
+  });
+
+  afterEach(async () => {
+    await prisma.$disconnect();
+  });
+
+  async function queryTxCompletionTable(client: Client) {
+    const result = await client.query(
+      /*sql*/
+      'SELECT workflow_id, function_num, output, error FROM dbos.transaction_completion',
+    );
+    return result.rowCount;
+  }
+
+  async function txCompletionTableExists(client: Client) {
+    const result = await client.query<{ exists: boolean }>(
+      /*sql*/
+      "SELECT EXISTS (SELECT 1 FROM information_schema.tables  WHERE table_schema = 'dbos' AND table_name = 'transaction_completion');",
+    );
+    if (result.rowCount !== 1) throw new Error(`unexpected rowcount ${result.rowCount}`);
+    return result.rows[0].exists;
+  }
+
+  test('initializeDBOSSchema-with-config', async () => {
+    await PrismaDataSource.initializeDBOSSchema(prisma);
+
+    const client = new Client(config);
+    try {
+      await client.connect();
+      await expect(txCompletionTableExists(client)).resolves.toBe(true);
+      await expect(queryTxCompletionTable(client)).resolves.toEqual(0);
+
+      await PrismaDataSource.uninitializeDBOSSchema(prisma);
+
+      await expect(txCompletionTableExists(client)).resolves.toBe(false);
+    } finally {
+      await client.end();
+    }
+  });
+
+  test('initializeDBOSSchema-with-prisma', async () => {
+    const client = new Client(config);
+    try {
+      await PrismaDataSource.initializeDBOSSchema(prisma);
+      await client.connect();
+
+      await expect(txCompletionTableExists(client)).resolves.toBe(true);
+      await expect(queryTxCompletionTable(client)).resolves.toEqual(0);
+
+      await PrismaDataSource.uninitializeDBOSSchema(prisma);
+
+      await expect(txCompletionTableExists(client)).resolves.toBe(false);
+    } finally {
+      await client.end();
+    }
+  });
+});

package/tests/datasource.test.ts

@@ -0,0 +1,464 @@
+import { DBOS } from '@dbos-inc/dbos-sdk';
+import { Client, Pool } from 'pg';
+import { PrismaDataSource } from '..';
+import { dropDB, ensureDB } from './test-helpers';
+import { randomUUID } from 'crypto';
+import SuperJSON from 'superjson';
+import { PrismaClient } from '@prisma/client';
+
+const config = { user: 'postgres', database: 'prisma_ds_test' };
+
+process.env['DATABASE_URL'] =
+  process.env['DATABSE_URL'] ||
+  `postgresql://${config.user}:${process.env['PGPASSWORD'] || 'dbos'}@${process.env['PGHOST'] || 'localhost'}:${process.env['PGPORT'] || '5432'}/${config.database}`;
+
+const prisma = new PrismaClient();
+
+const dataSource = new PrismaDataSource<PrismaClient>('app-db', prisma);
+
+interface transaction_completion {
+  workflow_id: string;
+  function_num: number;
+  output: string | null;
+  error: string | null;
+}
+
+describe('PrismaDataSource', () => {
+  const userDB = new Pool(config);
+
+  beforeAll(async () => {
+    {
+      const client = new Client({ ...config, database: 'postgres' });
+      try {
+        await client.connect();
+        await dropDB(client, 'prisma_ds_test', true);
+        await dropDB(client, 'prisma_ds_test_dbos_sys', true);
+        await dropDB(client, config.database, true);
+        await ensureDB(client, config.database);
+      } finally {
+        await client.end();
+      }
+    }
+
+    {
+      const client = await userDB.connect();
+      try {
+        await client.query(
+          'CREATE TABLE greetings(name text NOT NULL, greet_count integer DEFAULT 0, PRIMARY KEY(name))',
+        );
+      } finally {
+        client.release();
+      }
+    }
+
+    await PrismaDataSource.initializeDBOSSchema(prisma);
+  });
+
+  afterAll(async () => {
+    await userDB.end();
+  });
+
+  beforeEach(async () => {
+    DBOS.setConfig({ name: 'prisma-ds-test' });
+    await DBOS.launch();
+  });
+
+  afterEach(async () => {
+    await DBOS.shutdown();
+  });
+
+  test('insert dataSource.register function', async () => {
+    const user = 'helloTest1';
+
+    await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
+    const workflowID = randomUUID();
+
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorkflowReg(user))).resolves.toMatchObject({
+      user,
+      greet_count: 1,
+    });
+
+    const { rows } = await userDB.query<transaction_completion>(
+      'SELECT * FROM dbos.transaction_completion WHERE workflow_id = $1',
+      [workflowID],
+    );
+    expect(rows.length).toBe(1);
+    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);
+  });
+
+  test('insert dataSource.runAsTx function', async () => {
+    const user = 'helloTest2';
+
+    await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
+    const workflowID = randomUUID();
+
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorkflowRunTx(user))).resolves.toMatchObject({
+      user,
+      greet_count: 1,
+    });
+
+    const { rows } = await userDB.query<transaction_completion>(
+      'SELECT * FROM dbos.transaction_completion WHERE workflow_id = $1',
+      [workflowID],
+    );
+    expect(rows.length).toBe(1);
+    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,
+    );
+  });
+
+  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';
+
+    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 { 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 () => {
+    const user = 'errorTest2';
+
+    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 { 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.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 () => {
+    const user = 'readTest1';
+
+    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();
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regReadWorkflowReg(user))).resolves.toMatchObject({
+      user,
+      greet_count: 10,
+    });
+
+    const { rows } = await userDB.query('SELECT * FROM dbos.transaction_completion WHERE workflow_id = $1', [
+      workflowID,
+    ]);
+    expect(rows.length).toBe(0);
+  });
+
+  test('readonly dataSource.runAsTx function', async () => {
+    const user = 'readTest2';
+
+    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();
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regReadWorkflowRunTx(user))).resolves.toMatchObject({
+      user,
+      greet_count: 10,
+    });
+
+    const { rows } = await userDB.query('SELECT * FROM dbos.transaction_completion WHERE workflow_id = $1', [
+      workflowID,
+    ]);
+    expect(rows.length).toBe(0);
+  });
+
+  test('static dataSource.register methods', async () => {
+    const user = 'staticTest1';
+
+    await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
+
+    const workflowID = randomUUID();
+    await expect(DBOS.withNextWorkflowID(workflowID, () => regStaticWorkflow(user))).resolves.toMatchObject([
+      { user, greet_count: 1 },
+      { user, greet_count: 1 },
+    ]);
+  });
+
+  test('instance dataSource.register methods', async () => {
+    const user = 'instanceTest1';
+
+    await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
+
+    const workflowID = randomUUID();
+    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 {
+  name: string;
+  greet_count: number;
+}
+
+async function insertFunction(user: string) {
+  const existing = await dataSource.client.dbosHello.findUnique({
+    where: { name: user },
+    select: { greet_count: true },
+  });
+
+  let greet_count: number;
+
+  if (!existing) {
+    const created = await dataSource.client.dbosHello.create({
+      data: { name: user, greet_count: 1 },
+      select: { greet_count: true },
+    });
+    greet_count = created.greet_count;
+  } else {
+    const updated = await dataSource.client.dbosHello.update({
+      where: { name: user },
+      data: { greet_count: { increment: 1 } },
+      select: { greet_count: true },
+    });
+    greet_count = updated.greet_count;
+  }
+
+  return {
+    user,
+    greet_count,
+    now: Date.now(),
+  };
+}
+
+async function errorFunction(user: string) {
+  const _result = await insertFunction(user);
+  throw new Error(`test error ${Date.now()}`);
+}
+
+async function readFunction(user: string) {
+  const row = await dataSource.client.dbosHello.findUnique({
+    where: { name: user },
+    select: { greet_count: true },
+  });
+
+  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 });
+
+class StaticClass {
+  static async insertFunction(user: string) {
+    return await insertFunction(user);
+  }
+
+  static async readFunction(user: string) {
+    return await readFunction(user);
+  }
+}
+
+StaticClass.insertFunction = dataSource.registerTransaction(StaticClass.insertFunction);
+StaticClass.readFunction = dataSource.registerTransaction(StaticClass.readFunction, { readOnly: true });
+
+class InstanceClass {
+  async insertFunction(user: string) {
+    return await insertFunction(user);
+  }
+
+  async readFunction(user: string) {
+    return await readFunction(user);
+  }
+}
+
+InstanceClass.prototype.insertFunction = dataSource.registerTransaction(
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  InstanceClass.prototype.insertFunction,
+);
+InstanceClass.prototype.readFunction = dataSource.registerTransaction(
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  InstanceClass.prototype.readFunction,
+  { readOnly: true },
+);
+
+async function insertWorkflowReg(user: string) {
+  return await regInsertFunction(user);
+}
+
+async function insertWorkflowRunTx(user: string) {
+  return await dataSource.runTransaction(() => insertFunction(user), { name: 'insertFunction' });
+}
+
+async function errorWorkflowReg(user: string) {
+  return await regErrorFunction(user);
+}
+
+async function errorWorkflowRunTx(user: string) {
+  return await dataSource.runTransaction(() => errorFunction(user), { name: 'errorFunction' });
+}
+
+async function readWorkflowReg(user: string) {
+  return await regReadFunction(user);
+}
+
+async function readWorkflowRunTx(user: string) {
+  return await dataSource.runTransaction(() => readFunction(user), { name: 'readFunction', readOnly: true });
+}
+
+async function staticWorkflow(user: string) {
+  const result = await StaticClass.insertFunction(user);
+  const readResult = await StaticClass.readFunction(user);
+  return [result, readResult];
+}
+
+async function instanceWorkflow(user: string) {
+  const instance = new InstanceClass();
+  const result = await instance.insertFunction(user);
+  const readResult = await instance.readFunction(user);
+  return [result, readResult];
+}
+
+const regInsertWorkflowReg = DBOS.registerWorkflow(insertWorkflowReg);
+const regInsertWorkflowRunTx = DBOS.registerWorkflow(insertWorkflowRunTx);
+const regErrorWorkflowReg = DBOS.registerWorkflow(errorWorkflowReg);
+const regErrorWorkflowRunTx = DBOS.registerWorkflow(errorWorkflowRunTx);
+const regReadWorkflowReg = DBOS.registerWorkflow(readWorkflowReg);
+const regReadWorkflowRunTx = DBOS.registerWorkflow(readWorkflowRunTx);
+const regStaticWorkflow = DBOS.registerWorkflow(staticWorkflow);
+const regInstanceWorkflow = DBOS.registerWorkflow(instanceWorkflow);

package/tests/prisma/schema.prisma

@@ -0,0 +1,17 @@
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model DbosHello {
+  @@map("greetings")
+  name String @id
+  greet_count Int
+}

package/tests/test-helpers.ts

@@ -0,0 +1,13 @@
+import { Client } from 'pg';
+
+export async function ensureDB(client: Client, name: string) {
+  const results = await client.query('SELECT 1 FROM pg_database WHERE datname = $1', [name]);
+  if (results.rows.length === 0) {
+    await client.query(`CREATE DATABASE ${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}`);
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+/* Visit https://aka.ms/tsconfig to read more about this file */
+{
+  "extends": "../../tsconfig.shared.json",
+  "compilerOptions": {
+    "outDir": "./dist"
+  },
+  "include": ["index.ts"],
+  "exclude": ["dist", "tests"]
+}