@dbos-inc/drizzle-datasource 5.3.4-preview → 5.3.6-preview

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbos-inc/drizzle-datasource",
-  "version": "5.3.4-preview",
+  "version": "5.3.6-preview",
   "description": "DBOS DataSource library for Drizzle ORM with PostgreSQL support",
   "license": "MIT",
   "main": "dist/index.js",

package/index.ts

@@ -1,368 +0,0 @@
-import { Client, ClientConfig, Pool, PoolClient, PoolConfig } from 'pg';
-import { DBOS, FunctionName } from '@dbos-inc/dbos-sdk';
-import {
-  type DataSourceTransactionHandler,
-  isPGRetriableTransactionError,
-  DBOSError,
-  DBOSStepAlreadyRecordedError,
-  DBOSWorkflowConflictError,
-  assertStillOwnsWorkflow,
-  replayRecordedStep,
-  registerTransaction,
-  runTransaction,
-  DBOSDataSource,
-  registerDataSource,
-  DataSourceMigrationOptions,
-  DataSourceSQLExecutor,
-  initializeDataSourceSchemaPG,
-  migrateDataSourcePG,
-  verifyDataSourcePG,
-} from '@dbos-inc/dbos-sdk/datasource';
-import { drizzle, NodePgDatabase } from 'drizzle-orm/node-postgres';
-import { AsyncLocalStorage } from 'async_hooks';
-import { SuperJSON } from 'superjson';
-import { PgTransactionConfig } from 'drizzle-orm/pg-core';
-import { sql } from 'drizzle-orm';
-
-interface DrizzleLocalCtx {
-  client: NodePgDatabase<{ [key: string]: object }>;
-  owner: DrizzleTransactionHandler;
-}
-
-export type TransactionConfig = Pick<PgTransactionConfig, 'isolationLevel' | 'accessMode'> & { name?: string };
-
-const asyncLocalCtx = new AsyncLocalStorage<DrizzleLocalCtx>();
-
-function drizzleExecutor(db: Pick<NodePgDatabase<{ [key: string]: object }>, 'execute'>): DataSourceSQLExecutor {
-  return async (text) => (await db.execute<Record<string, unknown>>(sql.raw(text))).rows;
-}
-
-function clientExecutor(client: Pick<Client, 'query'>): DataSourceSQLExecutor {
-  return async (text) => (await client.query<Record<string, unknown>>(text)).rows;
-}
-
-export interface transaction_completion {
-  workflow_id: string;
-  function_num: number;
-  output: string | null;
-  error: string | null;
-}
-
-interface DrizzleConnection {
-  readonly db: NodePgDatabase<{ [key: string]: object }>;
-  end(): Promise<void>;
-}
-
-class DrizzleTransactionHandler implements DataSourceTransactionHandler {
-  #connection: DrizzleConnection | undefined;
-  readonly schemaName: string;
-  readonly #userProvidedPool: boolean;
-
-  constructor(
-    readonly name: string,
-    private readonly configOrPool: PoolConfig | Pool,
-    private readonly entities: { [key: string]: object } = {},
-    schemaName: string = 'dbos',
-    private readonly options: DataSourceMigrationOptions = {},
-  ) {
-    this.schemaName = schemaName;
-    this.#userProvidedPool = configOrPool instanceof Pool;
-  }
-
-  async initialize(): Promise<void> {
-    const conn = this.#connection;
-
-    const driver = this.configOrPool instanceof Pool ? this.configOrPool : new Pool(this.configOrPool);
-    const db = drizzle({ client: driver, schema: this.entities });
-    this.#connection = { db, end: this.#userProvidedPool ? async () => {} : () => driver.end() };
-    await conn?.end();
-
-    if (this.options.runMigrations === false) {
-      await verifyDataSourcePG(drizzleExecutor(db), this.schemaName, this.name);
-      return;
-    }
-
-    try {
-      await db.transaction((tx) => migrateDataSourcePG(drizzleExecutor(tx), this.schemaName));
-    } catch (err) {
-      throw new Error(
-        `In initialization of 'DrizzleDataSource' ${this.name}: The '${this.schemaName}' transaction schema could not be migrated: ${(err as Error).message}. This should be added to your database migrations.
-          See: https://docs.dbos.dev/typescript/tutorials/transaction-tutorial#installing-the-dbos-schema`,
-      );
-    }
-  }
-
-  async destroy(): Promise<void> {
-    const conn = this.#connection;
-
-    this.#connection = undefined;
-
-    await conn?.end();
-  }
-
-  get #drizzle(): NodePgDatabase<{ [key: string]: object }> {
-    if (!this.#connection) {
-      throw new Error(`DataSource ${this.name} is not initialized.`);
-    }
-    return this.#connection.db;
-  }
-
-  async deleteCheckpoints(workflowID: string, startStep: number, beforeCommit?: () => Promise<void>): Promise<void> {
-    await this.#drizzle.transaction(async (client) => {
-      await client.execute(sql`
-        DELETE FROM ${sql.identifier(this.schemaName)}.transaction_completion
-        WHERE workflow_id = ${workflowID} AND function_num >= ${startStep}`);
-      await beforeCommit?.();
-    });
-  }
-
-  async #checkExecution(
-    workflowID: string,
-    stepID: number,
-  ): Promise<{ output: string | null } | { error: string } | undefined> {
-    type Result = { output: string | null; error: string | null };
-
-    const statement = sql`
-        SELECT output, error FROM ${sql.identifier(this.schemaName)}.transaction_completion
-        WHERE workflow_id = ${workflowID} AND function_num = ${stepID}`;
-    const result = await this.#drizzle.execute<Result>(statement);
-
-    if (result.rows.length !== 1) {
-      return undefined;
-    }
-
-    const { output, error } = result.rows[0];
-    return error !== null ? { error } : { output };
-  }
-
-  static async #recordOutput(
-    client: NodePgDatabase<{ [key: string]: object }>,
-    workflowID: string,
-    stepID: number,
-    output: string,
-    schemaName: string,
-  ): Promise<void> {
-    const statement = sql`
-      INSERT INTO ${sql.identifier(schemaName)}.transaction_completion (workflow_id, function_num, output)
-      VALUES (${workflowID}, ${stepID}, ${output})
-      ON CONFLICT (workflow_id, function_num) DO NOTHING
-      RETURNING workflow_id`;
-    const { rows } = await client.execute(statement);
-    if (rows.length === 0) {
-      throw new DBOSStepAlreadyRecordedError(workflowID, stepID);
-    }
-    // Holding this step's row, so a later owner's insert waits on our commit.
-    await assertStillOwnsWorkflow(workflowID);
-  }
-
-  async #recordError(workflowID: string, stepID: number, error: string): Promise<void> {
-    const statement = sql`
-      INSERT INTO ${sql.identifier(this.schemaName)}.transaction_completion (workflow_id, function_num, error)
-      VALUES (${workflowID}, ${stepID}, ${error})
-      ON CONFLICT (workflow_id, function_num) DO NOTHING
-      RETURNING workflow_id`;
-    const { rows } = await this.#drizzle.execute(statement);
-    if (rows.length === 0) {
-      throw new DBOSStepAlreadyRecordedError(workflowID, stepID);
-    }
-  }
-
-  // A duplicate execution won the race, so its recorded outcome is the durable one.
-  async #replayConflictingStep<Return>(workflowID: string, stepID: number): Promise<Return> {
-    const recorded = await this.#checkExecution(workflowID, stepID);
-    if (recorded === undefined) {
-      throw new DBOSError(
-        `Step ${stepID} of workflow ${workflowID} conflicted with a concurrent execution, but no recorded outcome was found`,
-      );
-    }
-    return replayRecordedStep<Return>(recorded);
-  }
-
-  /* Invoke a transaction function, called by the framework */
-  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?.accessMode === 'read only' ? true : 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(workflowID, stepID!) : undefined;
-      if (previousResult) {
-        return replayRecordedStep<Return>(previousResult);
-      }
-
-      try {
-        const result = await this.#drizzle.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 DrizzleTransactionHandler.#recordOutput(
-                client,
-                workflowID,
-                stepID!,
-                SuperJSON.stringify(result),
-                this.schemaName,
-              );
-            }
-
-            return result;
-          },
-          { accessMode: config?.accessMode, isolationLevel: config?.isolationLevel },
-        );
-
-        return result;
-      } catch (error) {
-        if (saveResults && error instanceof DBOSStepAlreadyRecordedError) {
-          return await this.#replayConflictingStep<Return>(workflowID, stepID!);
-        }
-        // The new owner wins; recording an error here would replay it as this step's outcome.
-        if (error instanceof DBOSWorkflowConflictError) throw error;
-        if (isPGRetriableTransactionError(error)) {
-          DBOS.span?.addEvent('TXN SERIALIZATION FAILURE', { retryWaitMillis: retryWaitMS }, performance.now());
-          // Retry serialization failures.
-          await new Promise((resolve) => setTimeout(resolve, retryWaitMS));
-          retryWaitMS = Math.min(retryWaitMS * backoffFactor, maxRetryWaitMS);
-          continue;
-        } else {
-          if (saveResults) {
-            const message = SuperJSON.stringify(error);
-            try {
-              await this.#recordError(workflowID, stepID!, message);
-            } catch (recordError) {
-              if (recordError instanceof DBOSStepAlreadyRecordedError) {
-                return await this.#replayConflictingStep<Return>(workflowID, stepID!);
-              }
-              throw recordError;
-            }
-          }
-
-          throw error;
-        }
-      }
-    }
-  }
-}
-
-export class DrizzleDataSource<CT = NodePgDatabase<{ [key: string]: object }>>
-  implements DBOSDataSource<TransactionConfig>
-{
-  // User calls this... DBOS not directly involved...
-  static #getClient(p?: DrizzleTransactionHandler): NodePgDatabase<{ [key: string]: object }> {
-    if (!DBOS.isInTransaction()) {
-      throw new Error('Invalid use of DrizzleDataSource.client outside of a DBOS transaction');
-    }
-    const ctx = asyncLocalCtx.getStore();
-    if (!ctx) {
-      throw new Error('Invalid use of DrizzleDataSource.client outside of a DBOS transaction');
-    }
-    if (p && p !== ctx.owner) {
-      throw new Error('Invalid retrieval of `DrizzleDataSource.client` from the incorrect object');
-    }
-    return ctx.client;
-  }
-
-  static get client() {
-    return DrizzleDataSource.#getClient(undefined);
-  }
-
-  get client() {
-    return DrizzleDataSource.#getClient(this.#provider) as CT;
-  }
-
-  /**
-   * Create or migrate the DBOS transaction schema, typically with a privileged role,
-   * optionally granting `applicationRole` the minimal permissions to use it.
-   * A provided client runs the statements in its current transaction, if any; a config gets a fresh transaction.
-   */
-  static async initializeDBOSSchema(
-    configOrClient: ClientConfig | Client | PoolClient,
-    schemaName: string = 'dbos',
-    options: { applicationRole?: string } = {},
-  ): Promise<void> {
-    if (typeof configOrClient === 'object' && 'query' in configOrClient) {
-      await initializeDataSourceSchemaPG(clientExecutor(configOrClient), schemaName, options.applicationRole);
-    } else {
-      const client = new Client(configOrClient);
-      try {
-        await client.connect();
-        await client.query('BEGIN');
-        try {
-          await initializeDataSourceSchemaPG(clientExecutor(client), schemaName, options.applicationRole);
-          await client.query('COMMIT');
-        } catch (err) {
-          await client.query('ROLLBACK');
-          throw err;
-        }
-      } finally {
-        await client.end();
-      }
-    }
-  }
-
-  #provider: DrizzleTransactionHandler;
-
-  constructor(
-    readonly name: string,
-    configOrPool: PoolConfig | Pool,
-    entities: { [key: string]: object } = {},
-    schemaName: string = 'dbos',
-    options: DataSourceMigrationOptions = {},
-  ) {
-    this.#provider = new DrizzleTransactionHandler(name, configOrPool, entities, schemaName, options);
-    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);
-  }
-
-  // decorator
-  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 new Error('Use of decorator when original method is undefined');
-      }
-
-      descriptor.value = ds.registerTransaction(descriptor.value, {
-        ...config,
-        ctorOrProto: target,
-        name: config?.name ?? String(propertyKey),
-      });
-
-      return descriptor;
-    };
-  }
-}

package/jest.config.js

@@ -1,8 +0,0 @@
-/** @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/tests/config.test.ts

@@ -1,31 +0,0 @@
-import { Client } from 'pg';
-import { DrizzleDataSource } from '../index';
-import { dropDB, ensureDB } from './test-helpers';
-
-describe('DrizzleDataSource.configure', () => {
-  const config = { user: 'postgres', database: 'drizzle_ds_config_test' };
-
-  beforeAll(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();
-    }
-  });
-
-  test('configure creates tx outputs table', async () => {
-    await DrizzleDataSource.initializeDBOSSchema(config);
-
-    const client = new Client(config);
-    try {
-      await client.connect();
-      const result = await client.query('SELECT workflow_id, function_num, output FROM dbos.transaction_completion');
-      expect(result.rows.length).toBe(0);
-    } finally {
-      await client.end();
-    }
-  });
-});

package/tests/custom-pool.test.ts

@@ -1,130 +0,0 @@
-import { DBOS } from '@dbos-inc/dbos-sdk';
-import { Client, Pool } from 'pg';
-import { DrizzleDataSource } from '..';
-import { dropDB, ensureDB } from './test-helpers';
-import { randomUUID } from 'crypto';
-import { pgTable, text, integer } from 'drizzle-orm/pg-core';
-import { sql } from 'drizzle-orm';
-
-const config = { user: 'postgres', database: 'drizzle_pool_test_userdb' };
-
-const greetingsTable = pgTable('greetings', {
-  name: text('name').primaryKey().notNull(),
-  greet_count: integer('greet_count').default(0),
-});
-
-const customPool = new Pool(config);
-const poolDataSource = new DrizzleDataSource('pool-db', customPool);
-
-async function insertFunction(user: string) {
-  const result = await poolDataSource.client
-    .insert(greetingsTable)
-    .values({ name: user, greet_count: 1 })
-    .onConflictDoUpdate({
-      target: greetingsTable.name,
-      set: {
-        greet_count: sql`${greetingsTable.greet_count} + 1`,
-      },
-    })
-    .returning({ greet_count: greetingsTable.greet_count });
-  const row = result.length > 0 ? result[0] : undefined;
-  return { user, greet_count: row?.greet_count };
-}
-
-const regInsertFunction = poolDataSource.registerTransaction(insertFunction);
-
-async function insertWorkflow(user: string) {
-  return await regInsertFunction(user);
-}
-
-const regInsertWorkflow = DBOS.registerWorkflow(insertWorkflow);
-
-async function currentDatabaseFunction() {
-  const result = await poolDataSource.client.execute<{ current_database: string }>(sql`SELECT current_database()`);
-  return result.rows[0].current_database;
-}
-
-const regCurrentDatabaseFunction = poolDataSource.registerTransaction(currentDatabaseFunction);
-
-interface transaction_completion {
-  workflow_id: string;
-  function_num: number;
-  output: string | null;
-  error: string | null;
-}
-
-describe('DrizzleDataSource with custom Pool', () => {
-  beforeAll(async () => {
-    const client = new Client({ ...config, database: 'postgres' });
-    try {
-      await client.connect();
-      await dropDB(client, 'drizzle_pool_test', true);
-      await dropDB(client, 'drizzle_pool_test_dbos_sys', true);
-      await dropDB(client, config.database, true);
-      await ensureDB(client, config.database);
-    } finally {
-      await client.end();
-    }
-
-    const poolClient = await customPool.connect();
-    try {
-      await DrizzleDataSource.initializeDBOSSchema(poolClient);
-    } finally {
-      poolClient.release();
-    }
-
-    await customPool.query(
-      `CREATE TABLE IF NOT EXISTS greetings (name TEXT PRIMARY KEY NOT NULL, greet_count INTEGER DEFAULT 0)`,
-    );
-  });
-
-  afterAll(async () => {
-    await customPool.end();
-  });
-
-  beforeEach(async () => {
-    DBOS.setConfig({ name: 'drizzle-pool-test' });
-    await DBOS.launch();
-  });
-
-  afterEach(async () => {
-    await DBOS.shutdown();
-  });
-
-  test('insert with custom pool', async () => {
-    const user = 'poolTest1';
-    await customPool.query('DELETE FROM greetings WHERE name = $1', [user]);
-    const workflowID = randomUUID();
-
-    await expect(DBOS.withNextWorkflowID(workflowID, () => regInsertWorkflow(user))).resolves.toMatchObject({
-      user,
-      greet_count: 1,
-    });
-
-    const { rows } = await customPool.query<transaction_completion>(
-      'SELECT * FROM dbos.transaction_completion WHERE workflow_id = $1',
-      [workflowID],
-    );
-    // Completion cleared the checkpoint the transaction wrote.
-    expect(rows).toHaveLength(0);
-  });
-
-  test('transaction runs against the custom pool database', async () => {
-    // Guards against the datasource creating its own connection to the default database
-    // instead of using the caller's pool (drizzle-orm 1.0 positional-overload regression).
-    const dbName = await regCurrentDatabaseFunction();
-    expect(dbName).toBe(config.database);
-  });
-
-  test('custom pool is not closed after DBOS shutdown', async () => {
-    // Explicitly shut down DBOS to trigger destroy() on all datasources
-    await DBOS.shutdown();
-    // The custom pool should still be usable after DBOS.shutdown()
-    // because DrizzleDataSource should not close a user-provided pool
-    const { rows } = await customPool.query<{ val: number }>('SELECT 1 as val');
-    expect(rows[0].val).toBe(1);
-    // Re-launch so the afterEach shutdown doesn't fail
-    DBOS.setConfig({ name: 'drizzle-pool-test' });
-    await DBOS.launch();
-  });
-});

package/tests/datasource.test.ts

@@ -1,754 +0,0 @@
-import { DBOS, DBOSWorkflowConflictError } from '@dbos-inc/dbos-sdk';
-import { Client, Pool, PoolConfig } from 'pg';
-import { DrizzleDataSource } from '..';
-import { dropDB, ensureDB } from './test-helpers';
-import { randomUUID } from 'crypto';
-import SuperJSON from 'superjson';
-import { pgTable, text, integer } from 'drizzle-orm/pg-core';
-import { eq, sql } from 'drizzle-orm';
-
-const config = { user: 'postgres', database: 'drizzle_ds_test_userdb' };
-const dataSource = new DrizzleDataSource('app-db', config);
-
-interface transaction_completion {
-  workflow_id: string;
-  function_num: number;
-  output: string | null;
-  error: string | null;
-}
-
-async function createSchema(config: PoolConfig) {
-  const pool = new Pool(config);
-  try {
-    await pool.query(
-      `CREATE TABLE IF NOT EXISTS greetings (name TEXT PRIMARY KEY NOT NULL, greet_count INTEGER DEFAULT 0)`,
-    );
-    await pool.query(`CREATE TABLE IF NOT EXISTS race_side_effects (tag TEXT NOT NULL)`);
-  } finally {
-    await pool.end();
-  }
-}
-
-describe('DrizzleDataSource', () => {
-  const userDB = new Pool(config);
-
-  beforeAll(async () => {
-    await createDatabases(true);
-  });
-
-  afterAll(async () => {
-    await userDB.end();
-  });
-
-  beforeEach(async () => {
-    DBOS.setConfig({ name: 'drizzle-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],
-    );
-    // Completion cleared the checkpoint the transaction wrote.
-    expect(rows).toHaveLength(0);
-  });
-
-  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],
-    );
-    // Completion cleared the checkpoint the transaction wrote.
-    expect(rows).toHaveLength(0);
-  });
-
-  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+$/);
-
-    interface greetings {
-      name: string;
-      greet_count: number;
-    }
-    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],
-    );
-    // Completion cleared the checkpoint the transaction wrote.
-    expect(txOutput).toHaveLength(0);
-  });
-
-  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+$/);
-
-    interface greetings {
-      name: string;
-      greet_count: number;
-    }
-    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],
-    );
-    // Completion cleared the checkpoint the transaction wrote.
-    expect(txOutput).toHaveLength(0);
-  });
-
-  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);
-  });
-
-  test('duplicate execution replays the winner result', async () => {
-    await userDB.query('DELETE FROM race_side_effects');
-    raceState.callCount = 0;
-
-    // A loser whose body succeeds: the collision happens on the result-recording insert.
-    raceState.plantWinner = true;
-    raceState.plantWinnerError = false;
-    raceState.fail = false;
-    const wfid1 = randomUUID();
-    await expect(DBOS.withNextWorkflowID(wfid1, () => regRaceWorkflow())).resolves.toBe('winner-result');
-    expect(raceState.callCount).toBe(1); // the loser did run its body
-
-    // A loser whose body fails: the collision moves to the error-recording insert,
-    // and the winner's result still wins over the loser's own error.
-    raceState.plantWinner = true;
-    raceState.plantWinnerError = false;
-    raceState.fail = true;
-    const wfid2 = randomUUID();
-    await expect(DBOS.withNextWorkflowID(wfid2, () => regRaceWorkflow())).resolves.toBe('winner-result');
-    expect(raceState.callCount).toBe(2);
-
-    // A winner that recorded an error: the loser replays that throw instead of its own result.
-    raceState.plantWinner = true;
-    raceState.plantWinnerError = true;
-    raceState.fail = false;
-    const wfid3 = randomUUID();
-    const winnerError = await throws(() => DBOS.withNextWorkflowID(wfid3, () => regRaceWorkflow()));
-    expect((winnerError as Error).message).toBe('winner-error');
-    expect(raceState.callCount).toBe(3);
-
-    // Every loser's writes were discarded, and completion cleared the winners' checkpoints.
-    const { rows: tags } = await userDB.query<{ tag: string }>('SELECT tag FROM race_side_effects');
-    expect(tags).toHaveLength(0);
-    const { rows: txOutput } = await userDB.query<transaction_completion>(
-      'SELECT * FROM dbos.transaction_completion WHERE workflow_id = ANY($1)',
-      [[wfid1, wfid2, wfid3]],
-    );
-    expect(txOutput).toHaveLength(0);
-  });
-
-  /** Completion clears the checkpoints, so the workflow reads them back while it still runs. */
-  test('transactions record their outcomes as checkpoints', async () => {
-    const user = 'checkpointProbe';
-    await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
-    const workflowID = randomUUID();
-    const message = await DBOS.withNextWorkflowID(workflowID, () => regCheckpointProbeWorkflow(user));
-    expect(message).toMatch(/^test error \d+$/);
-
-    expect(probeState.rows).toHaveLength(2);
-    const [output, error] = probeState.rows;
-    expect(output).toMatchObject({ workflow_id: workflowID, function_num: 0, error: null });
-    expect(SuperJSON.parse(output.output!)).toMatchObject({ user, greet_count: 1 });
-    expect(error).toMatchObject({ workflow_id: workflowID, function_num: 1, output: null });
-    expect(SuperJSON.parse<Error>(error.error!).message).toBe(message);
-    expect(await readCompletions(workflowID)).toHaveLength(0);
-  });
-
-  /** The checkpoint may be the new owner's only record of the transaction, so a stale execution's cleanup rolls back. */
-  test('a stale execution keeps the checkpoints at completion', async () => {
-    const user = 'handOffTest';
-    await userDB.query('DELETE FROM greetings WHERE name = $1', [user]);
-    const handedOff = new Promise<void>((resolve) => (handOffState.signal = resolve));
-    const workflowID = randomUUID();
-    const execution = DBOS.withNextWorkflowID(workflowID, () => regHandOffWorkflow(user));
-    // Surfaces the workflow's own error if it fails before handing off.
-    await Promise.race([handedOff, execution]);
-
-    // Its outcome is refused too, so the execution parks until the workflow is cancelled.
-    await DBOS.cancelWorkflow(workflowID);
-    await expect(execution).rejects.toThrow(/has been cancelled/);
-    expect(await readCompletions(workflowID)).toHaveLength(1);
-  });
-
-  /** A stale execution cannot apply a step the new owner also runs, nor leave an outcome for it. */
-  test('an execution that loses the workflow mid-transaction rolls back', async () => {
-    await userDB.query('DELETE FROM race_side_effects');
-    const workflowID = randomUUID();
-    await expect(DBOS.withNextWorkflowID(workflowID, () => regStaleWorkflow())).resolves.toBe('conflicted');
-
-    const { rows: tags } = await userDB.query<{ tag: string }>('SELECT tag FROM race_side_effects');
-    expect(tags).toHaveLength(0);
-    expect(staleState.completionsAtConflict).toBe(0);
-    const sysDB = new Client(sysConfig);
-    try {
-      await sysDB.connect();
-      const { rows: steps } = await sysDB.query('SELECT * FROM dbos.operation_outputs WHERE workflow_uuid = $1', [
-        workflowID,
-      ]);
-      expect(steps).toHaveLength(0);
-    } finally {
-      await sysDB.end();
-    }
-  });
-});
-
-const greetingsTable = pgTable('greetings', {
-  name: text('name').primaryKey().notNull(),
-  greet_count: integer('greet_count').default(0),
-});
-
-async function createDatabases(createTxCompletions: boolean) {
-  {
-    const client = new Client({ ...config, database: 'postgres' });
-    try {
-      await client.connect();
-      await dropDB(client, 'drizzle_ds_test', true);
-      await dropDB(client, 'drizzle_ds_test_dbos_sys', true);
-      await dropDB(client, config.database, true);
-      await ensureDB(client, config.database);
-    } finally {
-      await client.end();
-    }
-  }
-
-  if (createTxCompletions) {
-    await DrizzleDataSource.initializeDBOSSchema(config);
-  }
-  await createSchema(config);
-}
-
-async function insertFunction(user: string) {
-  const result = await DrizzleDataSource.client
-    .insert(greetingsTable)
-    .values({ name: user, greet_count: 1 })
-    .onConflictDoUpdate({
-      target: greetingsTable.name,
-      set: {
-        greet_count: sql`${greetingsTable.greet_count} + 1`,
-      },
-    })
-    .returning({ greet_count: greetingsTable.greet_count });
-
-  const row = result.length > 0 ? result[0] : undefined;
-  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 ${Date.now()}`);
-}
-
-const raceState = { callCount: 0, plantWinner: false, plantWinnerError: false, fail: false };
-
-async function raceFunction() {
-  raceState.callCount += 1;
-  await dataSource.client.execute(sql`INSERT INTO race_side_effects(tag) VALUES (${`run-${raceState.callCount}`})`);
-  if (raceState.plantWinner) {
-    raceState.plantWinner = false;
-    await plantWinnerCompletion();
-  }
-  if (raceState.fail) {
-    throw new Error("loser's own failure");
-  }
-  return `result-${raceState.callCount}`;
-}
-
-// A duplicate execution commits its result while this transaction is still open, so this
-// execution's pre-check missed it but its completion insert will collide with it.
-async function plantWinnerCompletion() {
-  const winner = new Client(config);
-  try {
-    await winner.connect();
-    const [column, value] = raceState.plantWinnerError
-      ? ['error', SuperJSON.stringify(new Error('winner-error'))]
-      : ['output', SuperJSON.stringify('winner-result')];
-    await winner.query(
-      `INSERT INTO dbos.transaction_completion (workflow_id, function_num, ${column}) VALUES ($1, $2, $3)`,
-      [DBOS.workflowID, DBOS.stepID, value],
-    );
-  } finally {
-    await winner.end();
-  }
-}
-
-const regRaceFunction = dataSource.registerTransaction(raceFunction);
-
-async function raceWorkflow() {
-  return await regRaceFunction();
-}
-
-const regRaceWorkflow = DBOS.registerWorkflow(raceWorkflow);
-
-async function readFunction(user: string) {
-  const result = await dataSource.client
-    .select({ greet_count: greetingsTable.greet_count })
-    .from(greetingsTable)
-    .where(eq(greetingsTable.name, user));
-  const row = result.length > 0 ? result[0] : undefined;
-  return { user, greet_count: row?.greet_count, now: Date.now() };
-}
-
-const regInsertFunction = dataSource.registerTransaction(insertFunction);
-const regErrorFunction = dataSource.registerTransaction(errorFunction);
-
-const sysConfig = { ...config, database: 'drizzle_ds_test_dbos_sys' };
-
-/** Set the workflow's ownership token, returning the one it replaced. */
-async function setOwner(workflowID: string, ownerXid: string | null): Promise<string | null> {
-  const sysDB = new Client(sysConfig);
-  try {
-    await sysDB.connect();
-    const { rows } = await sysDB.query<{ owner_xid: string | null }>(
-      'SELECT owner_xid FROM dbos.workflow_status WHERE workflow_uuid = $1',
-      [workflowID],
-    );
-    await sysDB.query('UPDATE dbos.workflow_status SET owner_xid = $2 WHERE workflow_uuid = $1', [
-      workflowID,
-      ownerXid,
-    ]);
-    return rows[0].owner_xid;
-  } finally {
-    await sysDB.end();
-  }
-}
-
-/** The checkpoints this data source holds for the workflow, read on a connection of their own. */
-async function readCompletions(workflowID: string): Promise<transaction_completion[]> {
-  const client = new Client(config);
-  try {
-    await client.connect();
-    const { rows } = await client.query<transaction_completion>(
-      'SELECT * FROM dbos.transaction_completion WHERE workflow_id = $1 ORDER BY function_num',
-      [workflowID],
-    );
-    return rows;
-  } finally {
-    await client.end();
-  }
-}
-
-const probeState = { rows: [] as transaction_completion[] };
-
-// Reads back the checkpoints its transactions wrote, before completion clears them.
-async function checkpointProbeWorkflow(user: string) {
-  await regInsertFunction(user);
-  const error = await regErrorFunction(user).then(
-    () => undefined,
-    (e: Error) => e,
-  );
-  probeState.rows = await readCompletions(DBOS.workflowID!);
-  return error?.message;
-}
-
-const regCheckpointProbeWorkflow = DBOS.registerWorkflow(checkpointProbeWorkflow);
-
-const staleState = { originalOwner: null as string | null, completionsAtConflict: -1 };
-
-// Another execution claims the workflow while this transaction is still open.
-async function staleFunction() {
-  await dataSource.client.execute(sql`INSERT INTO race_side_effects(tag) VALUES ('stale')`);
-  staleState.originalOwner = await setOwner(DBOS.workflowID!, 'another-execution');
-  return 'stale';
-}
-
-const regStaleFunction = dataSource.registerTransaction(staleFunction);
-
-async function staleWorkflow() {
-  try {
-    return await regStaleFunction();
-  } catch (e) {
-    if (!(e instanceof DBOSWorkflowConflictError)) throw e;
-    // Read before completion clears it: the conflict must not have been recorded as the step's outcome.
-    staleState.completionsAtConflict = (await readCompletions(DBOS.workflowID!)).length;
-    // A real duplicate parks here instead; reclaimed so this execution's outcome lands.
-    await setOwner(DBOS.workflowID!, staleState.originalOwner);
-    return 'conflicted';
-  }
-}
-
-const regStaleWorkflow = DBOS.registerWorkflow(staleWorkflow);
-
-const handOffState = { signal: () => {} };
-
-// Loses the workflow after its transaction, so its completion is a stale execution's.
-async function handOffWorkflow(user: string) {
-  const result = await regInsertFunction(user);
-  await setOwner(DBOS.workflowID!, 'another-execution');
-  handOffState.signal();
-  return result;
-}
-
-const regHandOffWorkflow = DBOS.registerWorkflow(handOffWorkflow);
-const regReadFunction = dataSource.registerTransaction(readFunction, { accessMode: 'read only' });
-
-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, {
-  accessMode: 'read only',
-});
-
-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,
-  { accessMode: 'read only' },
-);
-
-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', accessMode: 'read only' });
-}
-
-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);
-
-describe('DrizzleDataSourceCreateTxC', () => {
-  const userDB = new Pool(config);
-
-  beforeAll(async () => {
-    await createDatabases(false);
-  });
-
-  afterAll(async () => {
-    await userDB.end();
-  });
-
-  beforeEach(async () => {
-    DBOS.setConfig({ name: 'drizzle-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],
-    );
-    // Completion cleared the checkpoint the transaction wrote.
-    expect(rows).toHaveLength(0);
-  });
-});
-
-describe('DrizzleDataSource migrations', () => {
-  const userDB = new Pool(config);
-
-  afterAll(async () => {
-    await userDB.end();
-  });
-
-  afterEach(async () => {
-    await DBOS.shutdown();
-  });
-
-  test('verify-only initialization requires the schema to be migrated out of band', async () => {
-    const suffix = randomUUID().replace(/-/g, '').slice(0, 8);
-    const schemaName = `ds_mig_${suffix}`;
-    const role = `ds_app_${suffix}`;
-    const admin = new Client({ ...config, database: 'postgres' });
-    await admin.connect();
-    try {
-      await ensureDB(admin, config.database);
-    } finally {
-      await admin.end();
-    }
-    await userDB.query(`CREATE ROLE "${role}"`);
-    try {
-      new DrizzleDataSource(`verify-only-${suffix}`, config, {}, schemaName, { runMigrations: false });
-      DBOS.setConfig({ name: 'drizzle-ds-test' });
-      await expect(DBOS.launch()).rejects.toThrow(/is at transaction schema version 0/);
-      await DBOS.shutdown();
-      const { rowCount } = await userDB.query('SELECT 1 FROM pg_namespace WHERE nspname = $1', [schemaName]);
-      expect(rowCount).toBe(0);
-
-      await DrizzleDataSource.initializeDBOSSchema(config, schemaName, { applicationRole: role });
-      await DBOS.launch();
-      const { rows } = await userDB.query<{ allowed: boolean }>(
-        `SELECT has_table_privilege($1, $2, 'INSERT') AS allowed`,
-        [role, `"${schemaName}".transaction_completion`],
-      );
-      expect(rows).toEqual([{ allowed: true }]);
-    } finally {
-      await userDB.query(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`);
-      await userDB.query(`DROP OWNED BY "${role}"`);
-      await userDB.query(`DROP ROLE "${role}"`);
-    }
-  });
-});

package/tests/esm-consumer.mts

@@ -1,8 +0,0 @@
-// Typechecked by esmtypes.test.ts, never executed: .mts makes it ESM regardless of the package type.
-import { DrizzleDataSource } from '@dbos-inc/drizzle-datasource';
-import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
-
-declare const dataSource: DrizzleDataSource;
-
-export const instanceClient: NodePgDatabase<{ [key: string]: object }> = dataSource.client;
-export const staticClient: NodePgDatabase<{ [key: string]: object }> = DrizzleDataSource.client;

package/tests/esmtypes.test.ts

@@ -1,27 +0,0 @@
-import { execFileSync } from 'child_process';
-import { readFileSync } from 'fs';
-import path from 'path';
-
-const packageRoot = path.join(__dirname, '..');
-
-describe('ESM type declarations', () => {
-  test('an ESM consumer under NodeNext typechecks against the built declarations', () => {
-    const tsc = require.resolve('typescript/bin/tsc');
-    const project = path.join(__dirname, 'tsconfig.esmcheck.json');
-    try {
-      execFileSync(process.execPath, [tsc, '--project', project], { cwd: packageRoot, stdio: 'pipe' });
-    } catch (error) {
-      const { stdout } = error as { stdout?: Buffer };
-      throw new Error(`ESM consumer failed to typecheck. Run 'npm run build' first.\n${stdout?.toString() ?? ''}`);
-    }
-  }, 120000);
-
-  test('the ESM declarations carry no reference to the CommonJS declaration map', () => {
-    const declarations = readFileSync(path.join(packageRoot, 'dist', 'index.d.mts'), 'utf8');
-    expect(declarations).not.toContain('sourceMappingURL');
-  });
-
-  test('the exports map still resolves the package manifest', () => {
-    expect(() => require.resolve('@dbos-inc/drizzle-datasource/package.json')).not.toThrow();
-  });
-});

package/tests/test-helpers.ts

@@ -1,13 +0,0 @@
-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/tests/tsconfig.esmcheck.json

@@ -1,11 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "nodenext",
-    "moduleResolution": "nodenext",
-    "target": "esnext",
-    "strict": true,
-    "skipLibCheck": true,
-    "noEmit": true
-  },
-  "files": ["esm-consumer.mts"]
-}

package/tsconfig.json

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