@happyvertical/smrt-vitest 0.30.0

package/dist/test-db.js

@@ -0,0 +1,887 @@
+/**
+ * Test database utilities for SMRT tests
+ *
+ * Automatically uses PostgreSQL when DATABASE_URL is set (CI environment),
+ * otherwise creates unique SQLite temp files to avoid concurrency issues.
+ *
+ * Supports transaction-based test isolation: each test runs in a transaction
+ * that gets rolled back, ensuring clean state between tests.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { getTestDbConfig, createTestDb } from '@happyvertical/smrt-vitest';
+ *
+ * const { config, cleanup } = await createTestDb();
+ * // Use config...
+ * await cleanup();
+ * ```
+ *
+ * @example Transaction isolation (recommended for parallel tests)
+ * ```typescript
+ * import { createIsolatedTestDb } from '@happyvertical/smrt-vitest';
+ *
+ * const { db, cleanup } = await createIsolatedTestDb({ schema: mySchema });
+ * // All operations run in a transaction
+ * await db.insert('users', { id: '1', name: 'Test' });
+ * // cleanup() rolls back the transaction - no data persists
+ * await cleanup();
+ * ```
+ *
+ * @packageDocumentation
+ */
+import { randomUUID } from 'node:crypto';
+import { existsSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+// Share the canonical collection-base detector with core instead of keeping a
+// local copy. A second copy is exactly how the #1342 junction schema-drop bug
+// half-survived: the core fix taught `collection-resolution.ts` to recognize
+// `SmrtJunction`, but this manifest-based test-db builder kept an older copy
+// that only knew `SmrtCollection`, so junction Collections filtered through
+// `createIsolatedTestDbFromManifest({ includeObjects: [...] })` were still
+// misclassified as table-bearing and lost their FK/junction columns.
+import { isSmrtCollectionExtendsName } from '@happyvertical/smrt-core';
+/**
+ * Detect the database adapter to use based on the current environment.
+ *
+ * Resolution order:
+ * 1. `TEST_DB_ADAPTER` env var — explicit override (`'sqlite'` or `'postgres'`)
+ * 2. `DATABASE_URL` env var set → `'postgres'`
+ * 3. Default → `'sqlite'`
+ *
+ * @returns The adapter identifier for the current environment.
+ * @see {@link getTestDbConfig} to obtain a full {@link TestDbConfig}.
+ */
+export function getTestAdapter() {
+    // Explicit adapter override
+    if (process.env.TEST_DB_ADAPTER) {
+        return process.env.TEST_DB_ADAPTER;
+    }
+    // Use Postgres if DATABASE_URL is set (CI environment)
+    if (process.env.DATABASE_URL) {
+        return 'postgres';
+    }
+    // Default to SQLite for local development
+    return 'sqlite';
+}
+/**
+ * Check whether PostgreSQL is available for the current test run.
+ *
+ * Returns `true` when the `DATABASE_URL` environment variable is set,
+ * which is the signal used by CI environments to opt into PostgreSQL.
+ *
+ * @returns `true` if `DATABASE_URL` is set, `false` otherwise.
+ * @see {@link getTestAdapter} for full adapter resolution logic.
+ */
+export function isPostgresAvailable() {
+    return Boolean(process.env.DATABASE_URL);
+}
+/**
+ * Get a {@link TestDbConfig} appropriate for the current environment.
+ *
+ * Uses PostgreSQL when `DATABASE_URL` is set (CI), otherwise generates
+ * a unique SQLite temp-file path to prevent concurrency conflicts between
+ * parallel test workers.
+ *
+ * @param prefix - Optional prefix used in the SQLite temp-file name.
+ *   Ignored when using PostgreSQL. Defaults to `'smrt-test'`.
+ * @returns A {@link TestDbConfig} ready to pass to `getDatabase()`.
+ * @see {@link getInMemoryDbConfig} for a non-persistent SQLite alternative.
+ * @see {@link createTestDb} to obtain the config alongside a cleanup function.
+ */
+export function getTestDbConfig(prefix = 'smrt-test') {
+    const adapter = getTestAdapter();
+    const testId = randomUUID().slice(0, 8);
+    switch (adapter) {
+        case 'postgres':
+            return {
+                type: 'postgres',
+                url: process.env.DATABASE_URL ||
+                    `postgresql://postgres:postgres@${process.env.POSTGRES_HOST || 'localhost'}:${process.env.POSTGRES_PORT || '5432'}/test_db`,
+            };
+        default:
+            // Use unique temp file to avoid concurrency issues
+            return {
+                type: 'sqlite',
+                url: join(tmpdir(), `${prefix}-${testId}.db`),
+            };
+    }
+}
+/**
+ * Get a {@link TestDbConfig} backed by an in-memory SQLite database.
+ *
+ * In-memory databases are isolated per connection — safe for concurrent
+ * tests within the same process, but the database cannot be shared across
+ * connections or workers.  No temp files are created or cleaned up.
+ *
+ * Prefer {@link getTestDbConfig} (file-based SQLite or PostgreSQL) when
+ * tests need to be shared or inspected after the run.
+ *
+ * @returns A `TestDbConfig` with `url: ':memory:'`.
+ */
+export function getInMemoryDbConfig() {
+    return {
+        type: 'sqlite',
+        url: ':memory:',
+    };
+}
+/**
+ * Create a test database and return a cleanup function.
+ *
+ * Determines the adapter automatically via {@link getTestDbConfig}.  For
+ * SQLite, a unique temp file is created; `cleanup()` removes it along with
+ * any WAL/SHM sidecar files.  For PostgreSQL, `cleanup()` is a no-op
+ * (table isolation must be handled by the test itself).
+ *
+ * Unlike {@link createIsolatedTestDb}, this function does **not** wrap
+ * operations in a transaction — mutations made during the test persist until
+ * the temp file is deleted.  Prefer {@link createIsolatedTestDb} for
+ * isolated, parallel-safe tests.
+ *
+ * @param prefix - Prefix for the SQLite temp-file name.  Ignored for
+ *   PostgreSQL.  Defaults to `'smrt-test'`.
+ * @returns An object containing the resolved {@link TestDbConfig} and an
+ *   async `cleanup()` function that removes the temp file on SQLite.
+ *
+ * @example
+ * ```typescript
+ * import { createTestDb } from '@happyvertical/smrt-vitest';
+ *
+ * const { config, cleanup } = await createTestDb();
+ * const db = await getDatabase(config);
+ * // ... run tests ...
+ * await cleanup();
+ * ```
+ *
+ * @see {@link createIsolatedTestDb} for transaction-isolated test databases.
+ */
+export async function createTestDb(prefix = 'smrt-test') {
+    const config = getTestDbConfig(prefix);
+    const cleanup = async () => {
+        // Clean up SQLite file-based databases
+        if (config.type === 'sqlite' &&
+            config.url !== ':memory:' &&
+            existsSync(config.url)) {
+            // Small delay to allow any pending writes
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            try {
+                rmSync(config.url, { force: true });
+                // Also remove -wal and -shm files if they exist
+                rmSync(`${config.url}-wal`, { force: true });
+                rmSync(`${config.url}-shm`, { force: true });
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        // For Postgres, we might want to clean up test tables
+        // but for now we'll rely on the test isolation
+    };
+    return { config, cleanup };
+}
+/**
+ * Get a human-readable display name for the current test database adapter.
+ *
+ * Useful for labelling `describe` blocks or test output so logs make clear
+ * which backend is under test.
+ *
+ * @returns `'PostgreSQL'` when the adapter is `'postgres'`, otherwise `'SQLite'`.
+ *
+ * @example
+ * ```typescript
+ * import { getAdapterDisplayName } from '@happyvertical/smrt-vitest';
+ *
+ * describe(`Product (${getAdapterDisplayName()})`, () => {
+ *   // ...
+ * });
+ * ```
+ *
+ * @see {@link getTestAdapter} to obtain the raw adapter identifier.
+ */
+export function getAdapterDisplayName() {
+    const adapter = getTestAdapter();
+    switch (adapter) {
+        case 'postgres':
+            return 'PostgreSQL';
+        default:
+            return 'SQLite';
+    }
+}
+/**
+ * Create a test database with transaction isolation.
+ *
+ * Each test runs in a transaction that gets rolled back on `cleanup()`,
+ * ensuring complete isolation between tests without the overhead of
+ * creating or dropping tables between runs.  Parallel test workers each
+ * receive their own temp database file (SQLite) or an independent
+ * transaction (PostgreSQL).
+ *
+ * Requires `@happyvertical/sql` with `beginTransaction()` support
+ * (SDK PR #722).  Throws if the adapter does not implement it.
+ *
+ * @param options - Optional schema DDL and SQLite prefix.
+ *   Pass `schema` to have the DDL applied before the transaction begins.
+ * @returns An {@link IsolatedTestDbResult} containing the transaction handle,
+ *   base connection, resolved config, and a `cleanup()` function.
+ *
+ * @see {@link createIsolatedTestDbFromManifest} to derive the schema
+ *   automatically from the generated manifest file.
+ *
+ * @example
+ * ```typescript
+ * import { createIsolatedTestDb } from '@happyvertical/smrt-vitest';
+ * import { beforeEach, afterEach, it } from 'vitest';
+ *
+ * let db: TransactionHandle;
+ * let cleanup: () => Promise<void>;
+ *
+ * beforeEach(async () => {
+ *   const result = await createIsolatedTestDb({
+ *     schema: `CREATE TABLE users (id TEXT PRIMARY KEY, name TEXT)`
+ *   });
+ *   db = result.db;
+ *   cleanup = result.cleanup;
+ * });
+ *
+ * afterEach(async () => {
+ *   await cleanup(); // Rolls back - no data persists
+ * });
+ *
+ * it('should insert and query', async () => {
+ *   await db.insert('users', { id: '1', name: 'Alice' });
+ *   const user = await db.get('users', { id: '1' });
+ *   expect(user?.name).toBe('Alice');
+ *   // After this test, cleanup() rolls back - Alice doesn't exist
+ * });
+ *
+ * it('should start with clean state', async () => {
+ *   // This test runs with a fresh transaction
+ *   const users = await db.list('users', {});
+ *   expect(users).toHaveLength(0); // Clean!
+ * });
+ * ```
+ */
+export async function createIsolatedTestDb(options = {}) {
+    const { schema, prefix = 'smrt-isolated' } = options;
+    // Dynamically import getDatabase to avoid circular dependencies
+    const { getDatabase, syncSchema } = await import('@happyvertical/sql');
+    const config = getTestDbConfig(prefix);
+    // Create the base database connection
+    // Cast to extended interface that includes beginTransaction (from SDK #722)
+    const baseDb = (await getDatabase({
+        ...config,
+        __smrtSkipVitestSchemaPreparation: true,
+    }));
+    // Sync schema if provided (must be done before transaction for DDL)
+    if (schema) {
+        await syncSchema({ db: baseDb, schema });
+    }
+    // Begin transaction for isolation
+    // Note: beginTransaction requires @happyvertical/sql with SDK PR #722 merged
+    if (!baseDb.beginTransaction) {
+        throw new Error(`Database adapter '${config.type}' does not support beginTransaction(). ` +
+            `This requires @happyvertical/sql with SDK PR #722 merged. ` +
+            `See: https://github.com/happyvertical/sdk/pull/722`);
+    }
+    const db = await baseDb.beginTransaction();
+    // Cleanup function rolls back transaction and closes connection
+    const cleanup = async () => {
+        try {
+            if (db.isActive()) {
+                await db.rollback();
+            }
+        }
+        catch {
+            // Ignore rollback errors (connection may be closed)
+        }
+        // Close base database connection to prevent connection leaks (Issue #858)
+        try {
+            if (baseDb &&
+                typeof baseDb.close ===
+                    'function') {
+                await baseDb
+                    .close();
+            }
+        }
+        catch {
+            // Ignore close errors
+        }
+        // Clean up SQLite temp files
+        if (config.type === 'sqlite' &&
+            config.url !== ':memory:' &&
+            existsSync(config.url)) {
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            try {
+                rmSync(config.url, { force: true });
+                rmSync(`${config.url}-wal`, { force: true });
+                rmSync(`${config.url}-shm`, { force: true });
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    };
+    return { db, baseDb, config, cleanup };
+}
+// ============================================================================
+// Manifest-based Test Database Helpers
+// ============================================================================
+/**
+ * Load a manifest file from common locations
+ *
+ * @param manifestPath - Optional explicit path to manifest
+ * @returns Parsed manifest or null if not found
+ */
+function loadManifest(manifestPath) {
+    const searchPaths = manifestPath
+        ? [manifestPath]
+        : [
+            join(process.cwd(), '.smrt', 'manifest.json'),
+            join(process.cwd(), 'dist', 'manifest.json'),
+            join(process.cwd(), 'src', 'manifest', 'manifest.json'),
+        ];
+    for (const path of searchPaths) {
+        if (existsSync(path)) {
+            try {
+                const content = readFileSync(path, 'utf-8');
+                return JSON.parse(content);
+            }
+            catch (error) {
+                // Log parse error but continue to next path
+                console.warn(`[smrt-vitest] Failed to parse manifest at "${path}":`, error);
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Generate CREATE INDEX statements from manifest indexes
+ *
+ * Generates both regular and UNIQUE indexes.
+ * UNIQUE indexes on conflict columns (like slug, context) are required
+ * for UPSERT/ON CONFLICT to work in SQLite.
+ */
+function generateIndexDDL(tableName, indexes) {
+    if (!indexes || indexes.length === 0)
+        return '';
+    const statements = [];
+    for (const index of indexes) {
+        if (!index.columns || index.columns.length === 0)
+            continue;
+        const indexType = index.unique ? 'UNIQUE INDEX' : 'INDEX';
+        const columns = index.columns.map((c) => `"${c}"`).join(', ');
+        statements.push(`CREATE ${indexType} IF NOT EXISTS "${index.name}" ON "${tableName}" (${columns});`);
+    }
+    return statements.join('\n');
+}
+/**
+ * Extract foreign key dependencies from DDL
+ *
+ * Parses REFERENCES tableName( patterns from CREATE TABLE statements
+ */
+function extractForeignKeyDependencies(ddl) {
+    const dependencies = [];
+    // Match REFERENCES "tablename"( or REFERENCES tablename(
+    const regex = /REFERENCES\s+"?([a-zA-Z_][a-zA-Z0-9_]*)"?\s*\(/gi;
+    for (const match of ddl.matchAll(regex)) {
+        const tableName = match[1];
+        if (!dependencies.includes(tableName)) {
+            dependencies.push(tableName);
+        }
+    }
+    return dependencies;
+}
+/**
+ * Tokenize CREATE TABLE body into individual column/constraint definitions.
+ *
+ * Splits on top-level commas (not inside parentheses or quotes) so it works
+ * for both multi-line and single-line DDL strings.
+ */
+function tokenizeDDLBody(body) {
+    const segments = [];
+    let current = '';
+    let parenDepth = 0;
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    let prevChar = '';
+    for (const ch of body) {
+        if (ch === "'" && !inDoubleQuote && prevChar !== '\\') {
+            inSingleQuote = !inSingleQuote;
+        }
+        else if (ch === '"' && !inSingleQuote && prevChar !== '\\') {
+            inDoubleQuote = !inDoubleQuote;
+        }
+        else if (!inSingleQuote && !inDoubleQuote) {
+            if (ch === '(')
+                parenDepth += 1;
+            else if (ch === ')' && parenDepth > 0)
+                parenDepth -= 1;
+        }
+        if (ch === ',' && parenDepth === 0 && !inSingleQuote && !inDoubleQuote) {
+            const trimmed = current.trim();
+            if (trimmed)
+                segments.push(trimmed);
+            current = '';
+        }
+        else {
+            current += ch;
+        }
+        prevChar = ch;
+    }
+    const last = current.trim();
+    if (last)
+        segments.push(last);
+    return segments;
+}
+/** Keywords that indicate a table-level constraint, not a column definition */
+const CONSTRAINT_KEYWORDS = new Set([
+    'CONSTRAINT',
+    'PRIMARY',
+    'FOREIGN',
+    'UNIQUE',
+    'CHECK',
+]);
+/**
+ * Parse column definitions from a CREATE TABLE DDL statement
+ *
+ * Returns a Map of column name → full column definition line.
+ * Skips table-level constraints (FOREIGN KEY, PRIMARY KEY, etc.).
+ */
+function parseColumnsFromDDL(ddl) {
+    const columns = new Map();
+    // Match the body between CREATE TABLE ... ( ... )
+    const bodyMatch = ddl.match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?"?\w+"?\s*\(([\s\S]+)\)/i);
+    if (!bodyMatch)
+        return columns;
+    const segments = tokenizeDDLBody(bodyMatch[1]);
+    for (const segment of segments) {
+        // Extract first identifier and check if it's a constraint keyword
+        const colMatch = segment.match(/^"?([a-zA-Z_][a-zA-Z0-9_]*)"?\s+/);
+        if (!colMatch)
+            continue;
+        const firstToken = colMatch[1].toUpperCase();
+        if (CONSTRAINT_KEYWORDS.has(firstToken))
+            continue;
+        columns.set(colMatch[1], segment);
+    }
+    return columns;
+}
+/**
+ * Merge two DDL statements for the same table (STI subclasses)
+ *
+ * Takes the union of all columns from both DDLs.
+ * When a column exists in both, the existing definition is kept.
+ */
+function mergeDDL(existingDDL, newDDL) {
+    const existingCols = parseColumnsFromDDL(existingDDL);
+    const newCols = parseColumnsFromDDL(newDDL);
+    // Find columns in newDDL that are missing from existingDDL
+    const missingCols = [];
+    for (const [name, def] of newCols) {
+        if (!existingCols.has(name)) {
+            missingCols.push(def);
+        }
+    }
+    if (missingCols.length === 0)
+        return existingDDL;
+    // Insert missing columns before the closing paren
+    const closingIdx = existingDDL.lastIndexOf(')');
+    if (closingIdx === -1)
+        return existingDDL;
+    const before = existingDDL.substring(0, closingIdx).trimEnd();
+    const after = existingDDL.substring(closingIdx);
+    const additions = missingCols.map((col) => `  ${col}`).join(',\n');
+    return `${before},\n${additions}\n${after}`;
+}
+/**
+ * Merge indexes from multiple STI subclasses sharing the same table
+ *
+ * Deduplicates by index name, keeping the first occurrence.
+ */
+function mergeIndexes(existing, incoming) {
+    const names = new Set(existing.map((i) => i.name));
+    const merged = [...existing];
+    for (const idx of incoming) {
+        if (!names.has(idx.name)) {
+            names.add(idx.name);
+            merged.push(idx);
+        }
+    }
+    return merged;
+}
+function getPackageNameFromKey(key) {
+    const separatorIndex = key.lastIndexOf(':');
+    if (separatorIndex <= 0) {
+        return undefined;
+    }
+    return key.slice(0, separatorIndex);
+}
+function getObjectPackageName(manifest, key, objectDef) {
+    return (objectDef.packageName || getPackageNameFromKey(key) || manifest.packageName);
+}
+function addManifestObjectIdentifiers(target, manifest, key, objectDef, options) {
+    target.add(key);
+    if (options.includeSimpleName && objectDef.className) {
+        target.add(objectDef.className);
+    }
+    const packageName = getObjectPackageName(manifest, key, objectDef);
+    if (packageName && objectDef.className) {
+        target.add(`${packageName}:${objectDef.className}`);
+    }
+}
+function findManifestObject(manifest, lookupName, packageName) {
+    const direct = manifest.objects[lookupName];
+    if (direct) {
+        return { key: lookupName, objectDef: direct };
+    }
+    const separatorIndex = lookupName.lastIndexOf(':');
+    const lookupPackage = separatorIndex > 0 ? lookupName.slice(0, separatorIndex) : packageName;
+    const simpleName = separatorIndex > 0 ? lookupName.slice(separatorIndex + 1) : lookupName;
+    const lowerSimpleName = simpleName.toLowerCase();
+    for (const [key, objectDef] of Object.entries(manifest.objects)) {
+        const objectPackageName = getObjectPackageName(manifest, key, objectDef);
+        if (lookupPackage &&
+            objectPackageName &&
+            objectPackageName !== lookupPackage) {
+            continue;
+        }
+        if (key === lookupName ||
+            objectDef.className === simpleName ||
+            objectDef.className?.toLowerCase() === lowerSimpleName) {
+            return { key, objectDef };
+        }
+    }
+    return undefined;
+}
+function getManifestCollectionAncestors(manifest, key, objectDef) {
+    const ancestors = [];
+    const visited = new Set();
+    let currentKey = key;
+    let currentDef = objectDef;
+    while (currentDef?.extends) {
+        if (isSmrtCollectionExtendsName(currentDef.extends)) {
+            break;
+        }
+        const currentPackage = getObjectPackageName(manifest, currentKey, currentDef);
+        const parent = findManifestObject(manifest, currentDef.extends, currentPackage);
+        if (!parent || visited.has(parent.key)) {
+            break;
+        }
+        visited.add(parent.key);
+        ancestors.push(parent);
+        currentKey = parent.key;
+        currentDef = parent.objectDef;
+    }
+    return ancestors;
+}
+function isManifestCollectionObject(manifest, key, objectDef) {
+    if (isSmrtCollectionExtendsName(objectDef.extends)) {
+        return true;
+    }
+    return getManifestCollectionAncestors(manifest, key, objectDef).some((ancestor) => isSmrtCollectionExtendsName(ancestor.objectDef.extends));
+}
+function resolveManifestCollectionItemClassName(manifest, key, objectDef) {
+    if (objectDef.extendsTypeArg) {
+        return objectDef.extendsTypeArg;
+    }
+    const inferredItemClassName = inferManifestCollectionItemClassName(manifest, key, objectDef);
+    if (inferredItemClassName) {
+        return inferredItemClassName;
+    }
+    for (const ancestor of getManifestCollectionAncestors(manifest, key, objectDef)) {
+        if (ancestor.objectDef.extendsTypeArg) {
+            return ancestor.objectDef.extendsTypeArg;
+        }
+    }
+    return undefined;
+}
+function getCollectionItemNameCandidates(className) {
+    const candidates = [];
+    const addCandidate = (candidate) => {
+        if (candidate &&
+            candidate !== className &&
+            !candidates.includes(candidate)) {
+            candidates.push(candidate);
+        }
+    };
+    if (className.endsWith('Collection')) {
+        addCandidate(className.slice(0, -'Collection'.length));
+    }
+    if (className.endsWith('ies')) {
+        addCandidate(`${className.slice(0, -3)}y`);
+    }
+    else if (className.endsWith('s')) {
+        addCandidate(className.slice(0, -1));
+    }
+    return candidates;
+}
+function inferManifestCollectionItemClassName(manifest, key, objectDef) {
+    const objectPackageName = getObjectPackageName(manifest, key, objectDef);
+    for (const candidate of getCollectionItemNameCandidates(objectDef.className)) {
+        const candidateEntry = findManifestObject(manifest, candidate, objectPackageName);
+        if (candidateEntry) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function buildEffectiveIncludeObjects(manifest, includeObjects) {
+    if (!includeObjects) {
+        return undefined;
+    }
+    const effectiveIncludes = new Set();
+    for (const includeObject of includeObjects) {
+        const includeSimpleName = !includeObject.includes(':');
+        const entry = findManifestObject(manifest, includeObject);
+        if (!entry) {
+            effectiveIncludes.add(includeObject);
+            continue;
+        }
+        const objectPackageName = getObjectPackageName(manifest, entry.key, entry.objectDef);
+        const itemClassName = isManifestCollectionObject(manifest, entry.key, entry.objectDef)
+            ? resolveManifestCollectionItemClassName(manifest, entry.key, entry.objectDef)
+            : undefined;
+        const itemEntry = itemClassName
+            ? findManifestObject(manifest, itemClassName, objectPackageName)
+            : undefined;
+        addManifestObjectIdentifiers(effectiveIncludes, manifest, itemEntry?.key || entry.key, itemEntry?.objectDef || entry.objectDef, { includeSimpleName });
+    }
+    return effectiveIncludes;
+}
+/**
+ * Extract DDL from manifest objects with STI deduplication
+ *
+ * Multiple classes may share the same table (STI), so we deduplicate by tableName.
+ * When STI subclasses add columns, DDLs are merged to include all columns.
+ * Also extracts indexes for generating CREATE INDEX statements.
+ */
+function extractDDLFromManifest(manifest, includeObjects) {
+    const tableMap = new Map();
+    const effectiveIncludes = buildEffectiveIncludeObjects(manifest, includeObjects);
+    for (const [key, objectDef] of Object.entries(manifest.objects)) {
+        // Skip if filter is specified and class not included
+        // Compare against both the key (e.g., '@dumm/models:Product') and className (e.g., 'Product')
+        // to support both namespaced and simple class names (Issue #860)
+        if (effectiveIncludes) {
+            const className = objectDef.className || key;
+            const matchesKey = effectiveIncludes.has(key);
+            const matchesClassName = effectiveIncludes.has(className);
+            if (!matchesKey && !matchesClassName) {
+                continue;
+            }
+        }
+        // Skip objects without schema (abstract classes, etc.)
+        if (!objectDef.schema?.ddl || !objectDef.schema?.tableName) {
+            continue;
+        }
+        const { tableName, ddl, indexes = [] } = objectDef.schema;
+        // Merge by tableName — STI subclasses may add columns to the same table
+        const existing = tableMap.get(tableName);
+        if (!existing) {
+            tableMap.set(tableName, {
+                tableName,
+                ddl,
+                indexes,
+                dependencies: extractForeignKeyDependencies(ddl),
+            });
+        }
+        else {
+            // Merge DDL columns and indexes from this STI subclass
+            existing.ddl = mergeDDL(existing.ddl, ddl);
+            existing.indexes = mergeIndexes(existing.indexes, indexes);
+            // Merge FK dependencies
+            const newDeps = extractForeignKeyDependencies(ddl);
+            for (const dep of newDeps) {
+                if (!existing.dependencies.includes(dep)) {
+                    existing.dependencies.push(dep);
+                }
+            }
+        }
+    }
+    return Array.from(tableMap.values());
+}
+/**
+ * Sort tables by foreign key dependencies using topological sort (Kahn's algorithm)
+ *
+ * Ensures referenced tables are created before tables that reference them
+ */
+function sortByDependencies(tables) {
+    const tableNames = new Set(tables.map((t) => t.tableName));
+    const inDegree = new Map();
+    const graph = new Map();
+    // Initialize
+    for (const table of tables) {
+        inDegree.set(table.tableName, 0);
+        graph.set(table.tableName, []);
+    }
+    // Build graph - only count dependencies that are in our table set
+    for (const table of tables) {
+        for (const dep of table.dependencies) {
+            if (tableNames.has(dep) && dep !== table.tableName) {
+                inDegree.set(table.tableName, (inDegree.get(table.tableName) || 0) + 1);
+                const edges = graph.get(dep) || [];
+                edges.push(table.tableName);
+                graph.set(dep, edges);
+            }
+        }
+    }
+    // Find all nodes with no incoming edges
+    const queue = [];
+    for (const [table, degree] of inDegree) {
+        if (degree === 0) {
+            queue.push(table);
+        }
+    }
+    // Process queue
+    const sorted = [];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current === undefined)
+            break;
+        sorted.push(current);
+        const neighbors = graph.get(current) || [];
+        for (const neighbor of neighbors) {
+            const newDegree = (inDegree.get(neighbor) ?? 0) - 1;
+            inDegree.set(neighbor, newDegree);
+            if (newDegree === 0) {
+                queue.push(neighbor);
+            }
+        }
+    }
+    // Handle any remaining tables (circular dependencies)
+    // Use Set for O(1) lookups instead of O(n) Array.includes()
+    const sortedSet = new Set(sorted);
+    for (const table of tables) {
+        if (!sortedSet.has(table.tableName)) {
+            sorted.push(table.tableName);
+            sortedSet.add(table.tableName);
+        }
+    }
+    return sorted;
+}
+/**
+ * Create an isolated test database with schema derived from a manifest file.
+ *
+ * Eliminates the need to manually write or maintain DDL in test files by
+ * reading table definitions directly from the generated manifest.  Handles:
+ *
+ * - **STI deduplication** — multiple classes that share the same table are
+ *   merged into a single `CREATE TABLE` statement that includes all columns.
+ * - **FK dependency ordering** — tables are created in topological order so
+ *   `REFERENCES` constraints are always satisfied.
+ * - **Auto-detection** — searches `.smrt/manifest.json`, `dist/manifest.json`,
+ *   and `src/manifest/manifest.json` when no `manifestPath` is given.
+ *
+ * @param options - Optional manifest path, class filter, and SQLite prefix.
+ * @returns An {@link IsolatedTestDbResult} — same shape as
+ *   {@link createIsolatedTestDb}, with a transaction-scoped `db` handle and
+ *   a `cleanup()` that rolls back and removes temp files.
+ *
+ * @throws When no manifest is found at any of the checked locations.
+ * @throws When the manifest contains no objects with a database schema (or
+ *   none of the filtered `includeObjects` have a schema).
+ *
+ * @see {@link createIsolatedTestDb} if you prefer to supply raw DDL directly.
+ * @see {@link ManifestTestDbOptions} for all available options.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { createIsolatedTestDbFromManifest } from '@happyvertical/smrt-vitest';
+ *
+ * let db, cleanup;
+ *
+ * beforeEach(async () => {
+ *   ({ db, cleanup } = await createIsolatedTestDbFromManifest());
+ * });
+ *
+ * afterEach(async () => {
+ *   await cleanup();
+ * });
+ * ```
+ *
+ * @example With tenant scoping
+ * ```typescript
+ * import { createIsolatedTestDbFromManifest } from '@happyvertical/smrt-vitest';
+ * import { withTenant, resetTenancy, setupTestTenancy } from '@happyvertical/smrt-tenancy';
+ *
+ * // In setup file
+ * setupTestTenancy({ enableInterceptors: true, rawQueryPolicy: 'allow' });
+ *
+ * // In test file
+ * let db, cleanup;
+ *
+ * beforeEach(async () => {
+ *   ({ db, cleanup } = await createIsolatedTestDbFromManifest());
+ * });
+ *
+ * afterEach(async () => {
+ *   resetTenancy();
+ *   await cleanup();
+ * });
+ *
+ * it('should auto-populate tenantId', async () => {
+ *   await withTenant({ tenantId: 'test-tenant' }, async () => {
+ *     const product = await collection.create({ name: 'Widget' });
+ *     expect(product.tenantId).toBe('test-tenant');
+ *   });
+ * });
+ * ```
+ *
+ * @example Filter to specific objects
+ * ```typescript
+ * const { db, cleanup } = await createIsolatedTestDbFromManifest({
+ *   includeObjects: ['Product', 'Order', 'OrderItem'],
+ * });
+ * ```
+ */
+export async function createIsolatedTestDbFromManifest(options = {}) {
+    const { manifestPath, includeObjects, prefix = 'smrt-manifest' } = options;
+    // 1. Load manifest
+    const manifest = loadManifest(manifestPath);
+    if (!manifest) {
+        const checkedPaths = manifestPath
+            ? [manifestPath]
+            : [
+                '.smrt/manifest.json',
+                'dist/manifest.json',
+                'src/manifest/manifest.json',
+            ];
+        throw new Error('No manifest found. Ensure smrtVitestPlugin() is configured in vitest.config.ts ' +
+            'or specify manifestPath. Checked: ' +
+            checkedPaths.join(', '));
+    }
+    // 2. Extract DDL with STI deduplication
+    const tables = extractDDLFromManifest(manifest, includeObjects);
+    if (tables.length === 0) {
+        throw new Error(includeObjects
+            ? `No objects with schema found matching: ${includeObjects.join(', ')}`
+            : 'No objects with schema found in manifest.');
+    }
+    // 3. Sort by FK dependencies and join DDL
+    // Use Map for O(1) lookups instead of O(n) Array.find()
+    const tableMap = new Map(tables.map((t) => [t.tableName, t]));
+    const sortedTableNames = sortByDependencies(tables);
+    // Generate CREATE TABLE statements first
+    const createTableDDL = sortedTableNames
+        .map((name) => tableMap.get(name)?.ddl)
+        .filter(Boolean)
+        .join('\n\n');
+    // Generate CREATE INDEX statements after tables exist
+    // This includes UNIQUE indexes required for UPSERT/ON CONFLICT to work
+    const createIndexDDL = sortedTableNames
+        .map((name) => {
+        const table = tableMap.get(name);
+        if (!table)
+            return '';
+        return generateIndexDDL(table.tableName, table.indexes);
+    })
+        .filter(Boolean)
+        .join('\n');
+    // Combine table DDL and index DDL
+    const sortedDDL = createIndexDDL
+        ? `${createTableDDL}\n\n${createIndexDDL}`
+        : createTableDDL;
+    // 4. Delegate to existing function
+    return createIsolatedTestDb({ schema: sortedDDL, prefix });
+}
+//# sourceMappingURL=test-db.js.map