@toiroakr/lines-db 0.9.0 → 0.9.2

package/src/database.test.ts

@@ -137,10 +137,7 @@ export const schema = defineSchema(rawSchema);
     });
 
     it('should find rows by condition', async () => {
-      await writeTable(
-        'users',
-        '{"id":1,"name":"Alice"}\n{"id":2,"name":"Bob"}\n{"id":3,"name":"Alice"}\n',
-      );
+      await writeTable('users', '{"id":1,"name":"Alice"}\n{"id":2,"name":"Bob"}\n{"id":3,"name":"Alice"}\n');
 
       type Tables = {
         users: { id: number; name: string };
@@ -278,10 +275,7 @@ export const schema = defineSchema(rawSchema);
 
   describe('update operations', () => {
     it('should update existing rows', async () => {
-      await writeTable(
-        'users',
-        '{"id":1,"name":"Alice","age":30}\n{"id":2,"name":"Bob","age":25}\n',
-      );
+      await writeTable('users', '{"id":1,"name":"Alice","age":30}\n{"id":2,"name":"Bob","age":25}\n');
 
       type Tables = {
         users: { id: number; name: string; age: number };
@@ -301,10 +295,7 @@ export const schema = defineSchema(rawSchema);
     });
 
     it('should update multiple rows', async () => {
-      await writeTable(
-        'users',
-        '{"id":1,"name":"Alice","active":true}\n{"id":2,"name":"Bob","active":true}\n',
-      );
+      await writeTable('users', '{"id":1,"name":"Alice","active":true}\n{"id":2,"name":"Bob","active":true}\n');
 
       type Tables = {
         users: { id: number; name: string; active: boolean };
@@ -321,10 +312,7 @@ export const schema = defineSchema(rawSchema);
     });
 
     it('should batch update rows with distinct values', async () => {
-      await writeTable(
-        'users',
-        '{"id":1,"name":"Alice","age":30}\n{"id":2,"name":"Bob","age":25}\n',
-      );
+      await writeTable('users', '{"id":1,"name":"Alice","age":30}\n{"id":2,"name":"Bob","age":25}\n');
 
       type Tables = {
         users: { id: number; name: string; age: number };
@@ -373,10 +361,7 @@ export const schema = defineSchema(rawSchema);
     });
 
     it('should delete multiple rows', async () => {
-      await writeTable(
-        'users',
-        '{"id":1,"name":"Alice"}\n{"id":2,"name":"Alice"}\n{"id":3,"name":"Bob"}\n',
-      );
+      await writeTable('users', '{"id":1,"name":"Alice"}\n{"id":2,"name":"Alice"}\n{"id":3,"name":"Bob"}\n');
 
       type Tables = {
         users: { id: number; name: string };
@@ -396,10 +381,7 @@ export const schema = defineSchema(rawSchema);
     });
 
     it('should batch delete rows by primary key', async () => {
-      await writeTable(
-        'users',
-        '{"id":1,"name":"Alice"}\n{"id":2,"name":"Bob"}\n{"id":3,"name":"Carol"}\n',
-      );
+      await writeTable('users', '{"id":1,"name":"Alice"}\n{"id":2,"name":"Bob"}\n{"id":3,"name":"Carol"}\n');
 
       type Tables = {
         users: { id: number; name: string };
@@ -477,10 +459,7 @@ export const schema = defineSchema(rawSchema);
 
   describe('raw SQL queries', () => {
     it('should execute raw queries', async () => {
-      await writeFile(
-        join(testDir, 'users.jsonl'),
-        '{"id":1,"name":"Alice"}\n{"id":2,"name":"Bob"}\n',
-      );
+      await writeFile(join(testDir, 'users.jsonl'), '{"id":1,"name":"Alice"}\n{"id":2,"name":"Bob"}\n');
 
       type Tables = {
         users: { id: number; name: string };
@@ -490,9 +469,7 @@ export const schema = defineSchema(rawSchema);
       const db = LinesDB.create(config);
       await db.initialize();
 
-      const result = db.query<{ id: number; name: string }>('SELECT * FROM users WHERE id > ?', [
-        1,
-      ]);
+      const result = db.query<{ id: number; name: string }>('SELECT * FROM users WHERE id > ?', [1]);
 
       expect(result).toHaveLength(1);
       expect(result[0].name).toBe('Bob');
@@ -518,4 +495,158 @@ export const schema = defineSchema(rawSchema);
       await db.close();
     });
   });
+
+  describe('circular foreign key validation', () => {
+    const writeSchemaWithFK = async (
+      tableName: string,
+      primaryKey: string,
+      foreignKeys: Array<{ column: string; references: { table: string; column: string } }>,
+      uniqueColumns: string[] = [],
+    ) => {
+      const fkJson = JSON.stringify(foreignKeys);
+      const indexDefs = uniqueColumns
+        .map((col) => `{ name: "${tableName}_${col}_idx", columns: ["${col}"], unique: true }`)
+        .join(', ');
+      const indexesLine = uniqueColumns.length > 0 ? `indexes: [${indexDefs}],` : '';
+      // Use inline StandardSchema without external imports (dynamic import from /tmp can't resolve npm packages)
+      const source = `
+const baseSchema = {
+  '~standard': {
+    version: 1,
+    vendor: 'test',
+    validate: (value) => ({ value })
+  }
+};
+
+export const schema = Object.assign(Object.create(baseSchema), {
+  '~standard': baseSchema['~standard'],
+  primaryKey: "${primaryKey}",
+  foreignKeys: ${fkJson},
+  ${indexesLine}
+});
+`;
+      await writeFile(join(testDir, `${tableName}.schema.ts`), source);
+    };
+
+    it('should validate circular foreign keys after all tables are loaded', async () => {
+      // authors and profiles reference each other bidirectionally
+      await writeFile(
+        join(testDir, 'authors.jsonl'),
+        '{"id":"1","name":"Alice","profile_code":"a-001"}\n{"id":"2","name":"Bob","profile_code":"b-001"}\n',
+      );
+      await writeSchemaWithFK(
+        'authors',
+        'id',
+        [{ column: 'profile_code', references: { table: 'profiles', column: 'code' } }],
+        ['profile_code'],
+      );
+
+      await writeFile(
+        join(testDir, 'profiles.jsonl'),
+        '{"code":"a-001","author_id":"1","bio":"Author A"}\n{"code":"b-001","author_id":"2","bio":"Author B"}\n',
+      );
+      await writeSchemaWithFK(
+        'profiles',
+        'code',
+        [{ column: 'author_id', references: { table: 'authors', column: 'id' } }],
+        ['code'],
+      );
+
+      type Tables = {
+        authors: { id: string; name: string; profile_code: string };
+        profiles: { code: string; author_id: string; bio: string };
+      };
+
+      const config: DatabaseConfig<Tables> = { dataDir: testDir };
+      const db = LinesDB.create(config);
+      const result = await db.initialize({ detailedValidate: true });
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+
+      await db.close();
+    });
+
+    it('should detect orphan in authors (no matching profile)', async () => {
+      await writeFile(
+        join(testDir, 'authors.jsonl'),
+        '{"id":"1","name":"Alice","profile_code":"a-001"}\n{"id":"2","name":"Orphan","profile_code":"missing"}\n',
+      );
+      await writeSchemaWithFK(
+        'authors',
+        'id',
+        [{ column: 'profile_code', references: { table: 'profiles', column: 'code' } }],
+        ['profile_code'],
+      );
+
+      await writeFile(join(testDir, 'profiles.jsonl'), '{"code":"a-001","author_id":"1","bio":"Author A"}\n');
+      await writeSchemaWithFK(
+        'profiles',
+        'code',
+        [{ column: 'author_id', references: { table: 'authors', column: 'id' } }],
+        ['code'],
+      );
+
+      type Tables = {
+        authors: { id: string; name: string; profile_code: string };
+        profiles: { code: string; author_id: string; bio: string };
+      };
+
+      const config: DatabaseConfig<Tables> = { dataDir: testDir };
+      const db = LinesDB.create(config);
+      const result = await db.initialize({ detailedValidate: true });
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].foreignKeyError).toMatchObject({
+        column: 'profile_code',
+        value: 'missing',
+        referencedTable: 'profiles',
+        referencedColumn: 'code',
+      });
+
+      await db.close();
+    });
+
+    it('should detect orphan in profiles (no matching author)', async () => {
+      await writeFile(join(testDir, 'authors.jsonl'), '{"id":"1","name":"Alice","profile_code":"a-001"}\n');
+      await writeSchemaWithFK(
+        'authors',
+        'id',
+        [{ column: 'profile_code', references: { table: 'profiles', column: 'code' } }],
+        ['profile_code'],
+      );
+
+      await writeFile(
+        join(testDir, 'profiles.jsonl'),
+        '{"code":"a-001","author_id":"1","bio":"Author A"}\n{"code":"x-999","author_id":"999","bio":"Orphan"}\n',
+      );
+      await writeSchemaWithFK(
+        'profiles',
+        'code',
+        [{ column: 'author_id', references: { table: 'authors', column: 'id' } }],
+        ['code'],
+      );
+
+      type Tables = {
+        authors: { id: string; name: string; profile_code: string };
+        profiles: { code: string; author_id: string; bio: string };
+      };
+
+      const config: DatabaseConfig<Tables> = { dataDir: testDir };
+      const db = LinesDB.create(config);
+      const result = await db.initialize({ detailedValidate: true });
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].foreignKeyError).toMatchObject({
+        column: 'author_id',
+        value: '999',
+        referencedTable: 'authors',
+        referencedColumn: 'id',
+      });
+
+      await db.close();
+    });
+  });
 });

package/src/database.ts

@@ -36,10 +36,7 @@ export class LinesDB<Tables extends TableDefs> {
     this.db = createDatabase(dbPath ?? ':memory:');
   }
 
-  static create<Tables extends TableDefs>(
-    config: DatabaseConfig<Tables>,
-    dbPath?: string,
-  ): LinesDB<Tables> {
+  static create<Tables extends TableDefs>(config: DatabaseConfig<Tables>, dbPath?: string): LinesDB<Tables> {
     return new LinesDB<Tables>(config, dbPath);
   }
 
@@ -73,9 +70,7 @@ export class LinesDB<Tables extends TableDefs> {
     // Validate that all requested tables exist BEFORE starting to load
     for (const tableNameToLoad of tablesToLoad) {
       if (!this.tables.has(tableNameToLoad)) {
-        throw new Error(
-          `Table '${tableNameToLoad}' not found in directory '${this.config.dataDir}'`,
-        );
+        throw new Error(`Table '${tableNameToLoad}' not found in directory '${this.config.dataDir}'`);
       }
     }
 
@@ -83,6 +78,11 @@ export class LinesDB<Tables extends TableDefs> {
     const loadedTables = new Set<string>();
     const loadingTables = new Set<string>();
     const attemptedTables = new Set<string>(); // Track all attempted tables (loaded or not)
+    const allDeferredForeignKeys: Array<{
+      tableName: string;
+      foreignKey: ForeignKeyDefinition;
+      filePath: string;
+    }> = [];
 
     // Load tables with dependency resolution
     for (const tableNameToLoad of tablesToLoad) {
@@ -93,6 +93,7 @@ export class LinesDB<Tables extends TableDefs> {
           errors,
           warnings,
           rowCounts: tableRowCounts,
+          deferredForeignKeys,
         } = await this.loadTableWithDependencies(
           tableNameToLoad,
           loadedTables,
@@ -103,12 +104,25 @@ export class LinesDB<Tables extends TableDefs> {
         );
         allErrors.push(...errors);
         allWarnings.push(...warnings);
+        allDeferredForeignKeys.push(...deferredForeignKeys);
         for (const [k, v] of tableRowCounts) {
           allRowCounts.set(k, v);
         }
       }
     }
 
+    // Validate deferred foreign keys (from circular dependencies) now that all tables are loaded
+    if (detailedValidate && allDeferredForeignKeys.length > 0) {
+      for (const { tableName: tName, foreignKey: fk, filePath } of allDeferredForeignKeys) {
+        // Only validate if the referenced table was actually loaded
+        if (!loadedTables.has(fk.references.table)) {
+          continue;
+        }
+        const deferredErrors = this.validateDeferredForeignKey(tName, fk, filePath);
+        allErrors.push(...deferredErrors);
+      }
+    }
+
     // Build per-table results
     const tableResults: TableValidationResult[] = tablesToLoad.map((name) => {
       const tableErrors = allErrors.filter((e) => e.tableName === name);
@@ -144,14 +158,24 @@ export class LinesDB<Tables extends TableDefs> {
     errors: ValidationErrorDetail[];
     warnings: string[];
     rowCounts: Map<string, number>;
+    deferredForeignKeys: Array<{
+      tableName: string;
+      foreignKey: ForeignKeyDefinition;
+      filePath: string;
+    }>;
   }> {
     const errors: ValidationErrorDetail[] = [];
     const warnings: string[] = [];
     const rowCounts = new Map<string, number>();
+    const deferredForeignKeys: Array<{
+      tableName: string;
+      foreignKey: ForeignKeyDefinition;
+      filePath: string;
+    }> = [];
 
     // Skip if already attempted (loaded or not)
     if (attemptedTables.has(tableName)) {
-      return { errors, warnings, rowCounts };
+      return { errors, warnings, rowCounts, deferredForeignKeys };
     }
 
     // Mark as attempted
@@ -218,6 +242,7 @@ export class LinesDB<Tables extends TableDefs> {
               );
               errors.push(...depResult.errors);
               warnings.push(...depResult.warnings);
+              deferredForeignKeys.push(...depResult.deferredForeignKeys);
               for (const [k, v] of depResult.rowCounts) {
                 rowCounts.set(k, v);
               }
@@ -230,14 +255,21 @@ export class LinesDB<Tables extends TableDefs> {
         }
       }
 
-      // Determine which FK dependencies failed validation (attempted but not loaded)
+      // Determine which FK dependencies failed or are circular (attempted but not loaded)
       const failedDependencies = new Set<string>();
+      const circularDependencies = new Set<string>();
       if (foreignKeys && foreignKeys.length > 0) {
         for (const fk of foreignKeys) {
           const referencedTable = fk.references.table;
           if (referencedTable === tableName) continue;
           if (attemptedTables.has(referencedTable) && !loadedTables.has(referencedTable)) {
-            failedDependencies.add(referencedTable);
+            if (loadingTables.has(referencedTable)) {
+              // Circular dependency: table is currently being loaded
+              circularDependencies.add(referencedTable);
+            } else {
+              // Actual failure: table attempted but not loaded
+              failedDependencies.add(referencedTable);
+            }
           }
         }
         if (failedDependencies.size > 0) {
@@ -249,23 +281,33 @@ export class LinesDB<Tables extends TableDefs> {
         }
       }
 
+      // Combine failed and circular dependencies for table loading (both need FK skipping)
+      const allSkippedDependencies = new Set([...failedDependencies, ...circularDependencies]);
+
       // Now load this table
       const {
         loaded,
         rowCount,
         errors: loadErrors,
-      } = await this.loadTable(
-        tableName,
-        tableConfig,
-        detailedValidate,
-        transform,
-        failedDependencies,
-      );
+      } = await this.loadTable(tableName, tableConfig, detailedValidate, transform, allSkippedDependencies);
       errors.push(...loadErrors);
       rowCounts.set(tableName, rowCount);
 
       if (loaded) {
         loadedTables.add(tableName);
+
+        // Track circular dependency FKs for deferred validation
+        if (foreignKeys && circularDependencies.size > 0) {
+          for (const fk of foreignKeys) {
+            if (circularDependencies.has(fk.references.table)) {
+              deferredForeignKeys.push({
+                tableName,
+                foreignKey: fk,
+                filePath: tableConfig.jsonlPath,
+              });
+            }
+          }
+        }
       } else {
         // Table was not loaded (e.g., empty data)
         warnings.push(`Table '${tableName}' was not loaded (no data or skipped)`);
@@ -276,7 +318,7 @@ export class LinesDB<Tables extends TableDefs> {
       loadingTables.delete(tableName);
     }
 
-    return { errors, warnings, rowCounts };
+    return { errors, warnings, rowCounts, deferredForeignKeys };
   }
 
   /**
@@ -320,10 +362,7 @@ export class LinesDB<Tables extends TableDefs> {
       // Only load if not already provided via config
       try {
         const { pathToFileURL } = await import('node:url');
-        const schemaPath = await findSchemaFile(
-          dirname(config.jsonlPath),
-          basename(config.jsonlPath, '.jsonl'),
-        );
+        const schemaPath = await findSchemaFile(dirname(config.jsonlPath), basename(config.jsonlPath, '.jsonl'));
         if (!schemaPath) throw new Error('Schema file not found');
         const schemaUrl = pathToFileURL(schemaPath).href;
         const schemaModule = await import(`${schemaUrl}?t=${Date.now()}`);
@@ -491,12 +530,7 @@ export class LinesDB<Tables extends TableDefs> {
 
     // Insert validated data (with detailed validation if requested)
     if (detailedValidate) {
-      const insertErrors = this.insertDataWithDetailedValidation(
-        tableName,
-        schema,
-        validatedData,
-        config.jsonlPath,
-      );
+      const insertErrors = this.insertDataWithDetailedValidation(tableName, schema, validatedData, config.jsonlPath);
       if (insertErrors.length > 0) {
         return { loaded: false, rowCount: data.length, errors: insertErrors };
       }
@@ -573,8 +607,7 @@ export class LinesDB<Tables extends TableDefs> {
         const index = schema.indexes[i];
         // Create safe index name by replacing special characters
         const safeTableName = schema.name.replace(/[^a-zA-Z0-9]/g, '_');
-        const resolvedIndexName =
-          index.name || `idx_${safeTableName}_${index.columns.join('_')}_${i}`;
+        const resolvedIndexName = index.name || `idx_${safeTableName}_${index.columns.join('_')}_${i}`;
         const uniqueKeyword = index.unique ? 'UNIQUE ' : '';
         const indexSql = `CREATE ${uniqueKeyword}INDEX IF NOT EXISTS ${this.quoteIdentifier(resolvedIndexName)} ON ${quotedTableName} (${index.columns
           .map((col) => this.quoteIdentifier(col))
@@ -738,13 +771,52 @@ export class LinesDB<Tables extends TableDefs> {
     };
   }
 
+  /**
+   * Validate a deferred foreign key constraint after all tables have been loaded.
+   * Used for circular dependency FK validation.
+   */
+  private validateDeferredForeignKey(
+    tableName: string,
+    fk: ForeignKeyDefinition,
+    filePath: string,
+  ): ValidationErrorDetail[] {
+    const errors: ValidationErrorDetail[] = [];
+    const quotedTable = this.quoteTableName(tableName);
+    const quotedColumn = this.quoteIdentifier(fk.column);
+    const quotedRefTable = this.quoteTableName(fk.references.table);
+    const quotedRefColumn = this.quoteIdentifier(fk.references.column);
+
+    // Find rows where the FK value does not exist in the referenced table
+    const sql = `SELECT rowid - 1 as idx, ${quotedColumn} as val FROM ${quotedTable} WHERE ${quotedColumn} IS NOT NULL AND ${quotedColumn} NOT IN (SELECT ${quotedRefColumn} FROM ${quotedRefTable})`;
+
+    try {
+      const rows = this.query<{ idx: number; val: string | number }>(sql);
+      for (const row of rows) {
+        errors.push({
+          file: filePath,
+          tableName,
+          rowIndex: row.idx,
+          issues: [],
+          type: 'foreignKey',
+          foreignKeyError: {
+            column: fk.column,
+            value: row.val,
+            referencedTable: fk.references.table,
+            referencedColumn: fk.references.column,
+          },
+        });
+      }
+    } catch (_) {
+      // Table might not exist - skip validation
+    }
+
+    return errors;
+  }
+
   /**
    * Execute a raw SQL query
    */
-  query<T = unknown>(
-    sql: string,
-    params: (string | number | bigint | null | Uint8Array)[] = [],
-  ): T[] {
+  query<T = unknown>(sql: string, params: (string | number | bigint | null | Uint8Array)[] = []): T[] {
     const stmt = this.db.prepare(sql);
     return stmt.all(...params) as T[];
   }
@@ -752,10 +824,7 @@ export class LinesDB<Tables extends TableDefs> {
   /**
    * Execute a SQL query that returns a single row
    */
-  queryOne<T = unknown>(
-    sql: string,
-    params: (string | number | bigint | null | Uint8Array)[] = [],
-  ): T | null {
+  queryOne<T = unknown>(sql: string, params: (string | number | bigint | null | Uint8Array)[] = []): T | null {
     const stmt = this.db.prepare(sql);
     const result = stmt.get(...params);
     return result === undefined ? null : (result as T);
@@ -801,10 +870,7 @@ export class LinesDB<Tables extends TableDefs> {
 
     // Normal case: use SQL WHERE clause
     if (sql) {
-      const rawRows = this.query(
-        `SELECT * FROM ${this.quoteTableName(tableName)} WHERE ${sql}`,
-        values,
-      );
+      const rawRows = this.query(`SELECT * FROM ${this.quoteTableName(tableName)} WHERE ${sql}`, values);
       rows = rawRows.map((row) => this.deserializeRow(tableName, row)) as Tables[K][];
     } else {
       // If only function filters (AND case), get all rows
@@ -824,10 +890,7 @@ export class LinesDB<Tables extends TableDefs> {
 
     let rows: Tables[K][];
     if (sql) {
-      const rawRows = this.query(
-        `SELECT * FROM ${this.quoteTableName(tableName)} WHERE ${sql}`,
-        values,
-      );
+      const rawRows = this.query(`SELECT * FROM ${this.quoteTableName(tableName)} WHERE ${sql}`, values);
       rows = rawRows.map((row) => this.deserializeRow(tableName, row)) as Tables[K][];
     } else {
       // If only function filters, get all rows
@@ -891,9 +954,7 @@ export class LinesDB<Tables extends TableDefs> {
 
     // Only synchronous validation is supported
     if (result instanceof Promise) {
-      throw new Error(
-        'Asynchronous validation is not supported. Please use synchronous validation schemas.',
-      );
+      throw new Error('Asynchronous validation is not supported. Please use synchronous validation schemas.');
     }
 
     if (result.issues && result.issues.length > 0) {
@@ -1114,9 +1175,7 @@ export class LinesDB<Tables extends TableDefs> {
     for (const record of records) {
       const pkValue = record[pkName];
       if (pkValue === undefined) {
-        throw new Error(
-          `Record is missing primary key '${String(pkName)}': ${JSON.stringify(record)}`,
-        );
+        throw new Error(`Record is missing primary key '${String(pkName)}': ${JSON.stringify(record)}`);
       }
       pkValues.push(pkValue);
     }
@@ -1155,9 +1214,7 @@ export class LinesDB<Tables extends TableDefs> {
         const existingRow = existingRowsMap.get(pkValue);
 
         if (!existingRow) {
-          throw new Error(
-            `No existing row found with ${String(pkName)}=${JSON.stringify(pkValue)}`,
-          );
+          throw new Error(`No existing row found with ${String(pkName)}=${JSON.stringify(pkValue)}`);
         }
 
         const mergedData = { ...existingRow, ...record };
@@ -1301,8 +1358,7 @@ export class LinesDB<Tables extends TableDefs> {
   private normalizeValue(value: unknown): string | number | bigint | null | Uint8Array {
     if (value === null || value === undefined) return null;
     if (typeof value === 'boolean') return value ? 1 : 0;
-    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'bigint')
-      return value;
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'bigint') return value;
     if (value instanceof Uint8Array) return value;
     // For objects, convert to JSON string
     return JSON.stringify(value);
@@ -1331,9 +1387,7 @@ export class LinesDB<Tables extends TableDefs> {
       if (Array.isArray(cond)) {
         const clauses = cond
           .map((item) => {
-            const clause = Array.isArray(item)
-              ? buildCondition(item, true)
-              : buildCondition(item, true);
+            const clause = Array.isArray(item) ? buildCondition(item, true) : buildCondition(item, true);
             return clause ? `(${clause})` : '';
           })
           .filter((clause) => clause !== ''); // Filter out empty clauses
@@ -1370,20 +1424,14 @@ export class LinesDB<Tables extends TableDefs> {
   /**
    * Apply OR condition with function filters by evaluating each row against the condition
    */
-  private applyOrConditionWithFilters<T extends Record<string, unknown>>(
-    rows: T[],
-    condition: WhereCondition<T>,
-  ): T[] {
+  private applyOrConditionWithFilters<T extends Record<string, unknown>>(rows: T[], condition: WhereCondition<T>): T[] {
     return rows.filter((row) => this.matchesOrCondition(row, condition));
   }
 
   /**
    * Check if a row matches an OR/AND condition (recursively)
    */
-  private matchesOrCondition<T extends Record<string, unknown>>(
-    row: T,
-    condition: WhereCondition<T>,
-  ): boolean {
+  private matchesOrCondition<T extends Record<string, unknown>>(row: T, condition: WhereCondition<T>): boolean {
     // Handle array (OR conditions)
     if (Array.isArray(condition)) {
       return condition.some((item) => this.matchesOrCondition(row, item));

package/src/directory-scanner.test.ts

@@ -59,9 +59,7 @@ describe('DirectoryScanner', () => {
     it('should throw error for non-existent directory', async () => {
       const nonExistentDir = join(testDir, 'nonexistent');
 
-      await expect(DirectoryScanner.scanDirectory(nonExistentDir)).rejects.toThrow(
-        'Failed to scan directory',
-      );
+      await expect(DirectoryScanner.scanDirectory(nonExistentDir)).rejects.toThrow('Failed to scan directory');
     });
 
     it('should handle multiple JSONL files', async () => {

package/src/directory-scanner.ts

@@ -30,9 +30,7 @@ export class DirectoryScanner {
 
       return tables;
     } catch (error) {
-      throw new Error(
-        `Failed to scan directory ${dataDir}: ${error instanceof Error ? error.message : String(error)}`,
-      );
+      throw new Error(`Failed to scan directory ${dataDir}: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
 }

package/src/index.ts

@@ -16,11 +16,7 @@ export {
 } from './schema-extensions.js';
 export type { SchemaExtension } from './schema-extensions.js';
 export { ErrorFormatter } from './error-formatter.js';
-export type {
-  ErrorFormatterOptions,
-  ValidationErrorInfo,
-  ForeignKeyErrorInfo,
-} from './error-formatter.js';
+export type { ErrorFormatterOptions, ValidationErrorInfo, ForeignKeyErrorInfo } from './error-formatter.js';
 export { detectRuntime, RUNTIME } from './runtime.js';
 export type { RuntimeEnvironment } from './runtime.js';
 export type { SQLiteDatabase, SQLiteStatement } from './sqlite-adapter.js';

package/src/jsonl-reader.test.ts

@@ -148,9 +148,7 @@ describe('JsonlReader', () => {
     });
 
     it('should throw error for empty data', () => {
-      expect(() => JsonlReader.inferSchema('empty', [])).toThrow(
-        'Cannot infer schema from empty data',
-      );
+      expect(() => JsonlReader.inferSchema('empty', [])).toThrow('Cannot infer schema from empty data');
     });
 
     it('should handle REAL numbers', () => {