feat: add schema isolation infrastructure for parallel Jest workers

Add infrastructure for PostgreSQL schema isolation to enable parallel
Jest workers within CI jobs. Each worker gets its own schema to prevent
data conflicts between tests.

Changes:
- Add TYPEORM_SCHEMA env var support and auto-schema selection based on
  JEST_WORKER_ID when ENABLE_SCHEMA_ISOLATION=true
- Set PostgreSQL search_path at connection level for raw SQL queries
- Add createWorkerSchema() to copy table structures, views, and
  migrations data from public schema to worker schemas
- Use pg_get_serial_sequence() for sequence resets to handle different
  sequence naming conventions

Known limitation: Database triggers are not copied as they reference
functions in the public schema. Schema isolation is opt-in via
ENABLE_SCHEMA_ISOLATION=true environment variable.

Addresses ENG-283

Author: idoshamun

__tests__/setup.ts

@@ -1,6 +1,8 @@
 import * as matchers from 'jest-extended';
+import { DataSource } from 'typeorm';
 import '../src/config';
 import createOrGetConnection from '../src/db';
+import { testSchema } from '../src/data-source';
 import { remoteConfig } from '../src/remoteConfig';
 import { loadAuthKeys } from '../src/auth';
 
@@ -64,14 +66,24 @@ const cleanDatabase = async (): Promise<void> => {
   for (const entity of con.entityMetadatas) {
     const repository = con.getRepository(entity.name);
     if (repository.metadata.tableType === 'view') continue;
-    await repository.query(`DELETE
-                            FROM "${entity.tableName}";`);
+    await repository.query(`DELETE FROM "${entity.tableName}";`);
 
     for (const column of entity.primaryColumns) {
       if (column.generationStrategy === 'increment') {
-        await repository.query(
-          `ALTER SEQUENCE ${entity.tableName}_${column.databaseName}_seq RESTART WITH 1`,
-        );
+        // Use pg_get_serial_sequence to find the actual sequence name
+        // This handles both original and copied tables with different sequence naming
+        try {
+          const seqResult = await repository.query(
+            `SELECT pg_get_serial_sequence('"${entity.tableName}"', '${column.databaseName}') as seq_name`,
+          );
+          if (seqResult[0]?.seq_name) {
+            await repository.query(
+              `ALTER SEQUENCE ${seqResult[0].seq_name} RESTART WITH 1`,
+            );
+          }
+        } catch {
+          // Sequence might not exist, ignore
+        }
       }
     }
   }
@@ -82,6 +94,96 @@ jest.mock('file-type', () => ({
   fileTypeFromBuffer: () => fileTypeFromBuffer(),
 }));
 
+/**
+ * Create the worker schema for test isolation.
+ * Creates a new schema and copies all table structures from public schema.
+ * This is used when ENABLE_SCHEMA_ISOLATION=true for parallel Jest workers.
+ */
+const createWorkerSchema = async (): Promise<void> => {
+  // Only create non-public schemas (when running with multiple Jest workers)
+  if (testSchema === 'public') {
+    return;
+  }
+
+  // Bootstrap connection using public schema
+  const bootstrapDataSource = new DataSource({
+    type: 'postgres',
+    host: process.env.TYPEORM_HOST || 'localhost',
+    port: 5432,
+    username: process.env.TYPEORM_USERNAME || 'postgres',
+    password: process.env.TYPEORM_PASSWORD || '12345',
+    database:
+      process.env.TYPEORM_DATABASE ||
+      (process.env.NODE_ENV === 'test' ? 'api_test' : 'api'),
+    schema: 'public',
+  });
+
+  await bootstrapDataSource.initialize();
+
+  // Drop and create the worker schema
+  await bootstrapDataSource.query(
+    `DROP SCHEMA IF EXISTS "${testSchema}" CASCADE`,
+  );
+  await bootstrapDataSource.query(`CREATE SCHEMA "${testSchema}"`);
+
+  // Get all tables from public schema (excluding views and TypeORM metadata)
+  const tables = await bootstrapDataSource.query(`
+    SELECT tablename FROM pg_tables
+    WHERE schemaname = 'public'
+    AND tablename NOT LIKE 'pg_%'
+    AND tablename != 'typeorm_metadata'
+  `);
+
+  // Copy table structure from public to worker schema
+  for (const { tablename } of tables) {
+    await bootstrapDataSource.query(`
+      CREATE TABLE "${testSchema}"."${tablename}"
+      (LIKE "public"."${tablename}" INCLUDING ALL)
+    `);
+  }
+
+  // Copy migrations table so TypeORM knows migrations are already applied
+  await bootstrapDataSource.query(`
+    INSERT INTO "${testSchema}"."migrations" SELECT * FROM "public"."migrations"
+  `);
+
+  // Get all views from public schema and recreate them in worker schema
+  const views = await bootstrapDataSource.query(`
+    SELECT viewname, definition FROM pg_views
+    WHERE schemaname = 'public'
+  `);
+
+  for (const { viewname, definition } of views) {
+    // Replace public schema references with worker schema in view definition
+    const modifiedDefinition = definition.replace(
+      /public\./g,
+      `${testSchema}.`,
+    );
+    await bootstrapDataSource.query(`
+      CREATE OR REPLACE VIEW "${testSchema}"."${viewname}" AS ${modifiedDefinition}
+    `);
+  }
+
+  // Note: Triggers are NOT copied because they reference functions in public schema
+  // which would insert data into public schema tables instead of worker schema tables.
+  // This is a known limitation of schema isolation.
+
+  await bootstrapDataSource.destroy();
+};
+
+let schemaInitialized = false;
+
+beforeAll(async () => {
+  if (!schemaInitialized) {
+    // Create worker schema for parallel test isolation
+    // Public schema is set up by the pretest script
+    if (testSchema !== 'public') {
+      await createWorkerSchema();
+    }
+    schemaInitialized = true;
+  }
+});
+
 beforeEach(async () => {
   loadAuthKeys();
 

src/data-source.ts

@@ -1,13 +1,41 @@
 import 'reflect-metadata';
 import { DataSource } from 'typeorm';
 
+/**
+ * Determine schema for test isolation.
+ * Each Jest worker gets its own schema to enable parallel test execution.
+ * Schema isolation is enabled in CI when ENABLE_SCHEMA_ISOLATION=true,
+ * which allows parallel Jest workers to run without conflicts.
+ */
+const getSchema = (): string => {
+  if (process.env.TYPEORM_SCHEMA) {
+    return process.env.TYPEORM_SCHEMA;
+  }
+  // Enable schema isolation for parallel Jest workers in CI
+  if (
+    process.env.ENABLE_SCHEMA_ISOLATION === 'true' &&
+    process.env.JEST_WORKER_ID
+  ) {
+    return `test_worker_${process.env.JEST_WORKER_ID}`;
+  }
+  return 'public';
+};
+
+export const testSchema = getSchema();
+
+// PostgreSQL connection options to set search_path for raw SQL queries
+const pgOptions =
+  testSchema !== 'public' ? `-c search_path=${testSchema}` : undefined;
+
 export const AppDataSource = new DataSource({
   type: 'postgres',
-  schema: 'public',
+  schema: testSchema,
   synchronize: false,
   extra: {
     max: 30,
     idleTimeoutMillis: 0,
+    // Set search_path at connection level so raw SQL uses the correct schema
+    options: pgOptions,
   },
   logging: false,
   entities: ['src/entity/**/*.{js,ts}'],