@tstdl/base 0.93.144 → 0.93.146

package/testing/integration-setup.js

@@ -1,5 +1,6 @@
+/** biome-ignore-all lint/nursery/useExpect: helper file */
 import { sql } from 'drizzle-orm';
-import { afterAll } from 'vitest';
+import { afterAll, test } from 'vitest';
 import { configureApiServer } from '../api/server/index.js';
 import { configureAudit } from '../audit/index.js';
 import { AuthenticationApiClient } from '../authentication/client/api.client.js';
@@ -26,7 +27,8 @@ import { configureDefaultSignalsImplementation } from '../signals/implementation
 import { configurePostgresTaskQueue } from '../task-queue/postgres/index.js';
 import * as configParser from '../utils/config-parser.js';
 import { objectEntries } from '../utils/object/object.js';
-import { assertDefinedPass, isDefined, isNotNull, isString } from '../utils/type-guards.js';
+import { assertDefinedPass, isDefined, isNotNull, isNumber, isString, isUndefined } from '../utils/type-guards.js';
+import { resolveValueOrProvider } from '../utils/value-or-provider.js';
 /**
  * Standard setup for integration tests.
  */
@@ -167,16 +169,22 @@ export async function setupIntegrationTest(options = {}) {
     return { injector, database };
 }
 /**
- * Helper to run a migration safely with a database advisory lock to prevent race conditions.
+ * A wrapper for vitest's `test` that automatically runs the test function in the provided injector's context.
+ * @param name The name of the test.
+ * @param injector The injector to use for the context.
+ * @param fn The test function.
+ * @param options Vitest test options.
  */
-async function runMigrationSafely(database, migration) {
-    const lockId = 123456789; // Fixed lock ID for migrations
-    await database.execute(sql `SELECT pg_advisory_lock(${lockId})`);
-    try {
-        await migration();
+export function testInInjector(name, injector, fn, options) {
+    if (isUndefined(options) || isNumber(options)) {
+        test(name, async () => {
+            await runInInjectionContext(resolveValueOrProvider(injector), fn);
+        }, options);
     }
-    finally {
-        await database.execute(sql `SELECT pg_advisory_unlock(${lockId})`);
+    else {
+        test(name, options, async () => {
+            await runInInjectionContext(resolveValueOrProvider(injector), fn);
+        });
     }
 }
 /**
@@ -187,19 +195,15 @@ export async function truncateTables(database, schema, tables) {
     if (tables.length == 0) {
         return;
     }
-    const lockId = 987654321; // Different lock ID for table maintenance
-    await database.execute(sql `SELECT pg_advisory_lock(${lockId})`);
-    try {
+    const lockName = `tstdl:maintenance:${schema}`;
+    await runWithAdvisoryLock(database, lockName, async () => {
         // Using CASCADE to handle foreign keys automatically
         for (const table of tables) {
             const tableName = isString(table) ? table : getEntityTableName(table);
             const tableSchema = isString(table) ? schema : getEntitySchema(table, schema);
             await database.execute(sql `TRUNCATE TABLE ${sql.identifier(tableSchema)}.${sql.identifier(tableName)} CASCADE`);
         }
-    }
-    finally {
-        await database.execute(sql `SELECT pg_advisory_unlock(${lockId})`);
-    }
+    });
 }
 /**
  * Helper to delete data for a specific tenant from specific tables.
@@ -209,18 +213,15 @@ export async function clearTenantData(database, schema, tables, tenantId) {
     if (tables.length == 0) {
         return;
     }
-    const lockId = 987654321;
-    await database.execute(sql `SELECT pg_advisory_lock(${lockId})`);
-    try {
+    // Use a lock that is specific to both the schema AND the tenant
+    const lockName = `tstdl:maintenance:${schema ?? 'default'}:${tenantId}`;
+    await runWithAdvisoryLock(database, lockName, async () => {
         for (const table of tables) {
             const tableName = isString(table) ? table : getEntityTableName(table);
             const tableSchema = isString(table) ? assertDefinedPass(schema, 'Schema not provided') : getEntitySchema(table, schema);
             await database.execute(sql `DELETE FROM ${sql.identifier(tableSchema)}.${sql.identifier(tableName)} WHERE tenant_id = ${tenantId}`);
         }
-    }
-    finally {
-        await database.execute(sql `SELECT pg_advisory_unlock(${lockId})`);
-    }
+    });
 }
 /**
  * Helper to drop specific tables.
@@ -230,16 +231,42 @@ export async function dropTables(database, schema, tables) {
     if (tables.length == 0) {
         return;
     }
-    const lockId = 987654321;
-    await database.execute(sql `SELECT pg_advisory_lock(${lockId})`);
-    try {
+    const lockName = `tstdl:maintenance:${schema ?? 'default'}`;
+    await runWithAdvisoryLock(database, lockName, async () => {
         for (const table of tables) {
             const tableName = isString(table) ? table : getEntityTableName(table);
             const tableSchema = isString(table) ? assertDefinedPass(schema, 'Schema not provided') : getEntitySchema(table, schema);
             await database.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(tableSchema)}.${sql.identifier(tableName)} CASCADE`);
         }
-    }
-    finally {
-        await database.execute(sql `SELECT pg_advisory_unlock(${lockId})`);
+    });
+}
+/**
+ * Helper to run a migration safely with a database advisory lock to prevent race conditions.
+ */
+async function runMigrationSafely(database, migration) {
+    const lockName = 'tstdl:migration';
+    await runWithAdvisoryLock(database, lockName, migration);
+}
+async function runWithAdvisoryLock(database, lockName, fn) {
+    // We use pg_try_advisory_lock in a loop with small random delays to avoid deadlocks
+    // which sometimes happen with pg_advisory_lock under very high parallelism in Vitest
+    const start = Date.now();
+    const timeout = 30000; // 30s timeout for maintenance tasks
+    while (true) {
+        const { rows: [result] } = await database.execute(sql `SELECT pg_try_advisory_lock(hashtext(${lockName})) as locked`);
+        if (result?.locked) {
+            try {
+                await fn();
+                return;
+            }
+            finally {
+                await database.execute(sql `SELECT pg_advisory_unlock(hashtext(${lockName}))`);
+            }
+        }
+        if (Date.now() - start > timeout) {
+            throw new Error(`Timeout while waiting for advisory lock: ${lockName}`);
+        }
+        // Small random delay between 10ms and 100ms
+        await new Promise((resolve) => setTimeout(resolve, 10 + Math.random() * 90));
     }
 }