@toiroakr/lines-db 0.9.1 → 0.9.2

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@toiroakr/lines-db",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "A database implementation that treats JSONL files as tables using SQLite",
   "type": "module",
   "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "bin": {
-    "lines-db": "./bin/cli.js"
+    "lines-db": "./bin/cli.mjs"
   },
   "exports": {
     ".": {
       "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
       },
       "require": {
         "types": "./dist/index.d.cts",
@@ -22,7 +22,7 @@
     }
   },
   "scripts": {
-    "build": "tsdown && cp dist/index.d.ts dist/index.d.cts",
+    "build": "tsdown",
     "typecheck": "tsc --noEmit",
     "test": "vitest run"
   },
@@ -43,12 +43,12 @@
   },
   "homepage": "https://github.com/toiroakr/lines-db#readme",
   "devDependencies": {
-    "@types/node": "^22.0.0",
-    "tsdown": "^0.15.12",
-    "type-fest": "^5.2.0",
-    "typescript": "^5.6.0",
-    "valibot": "^1.1.0",
-    "vitest": "^4.0.6"
+    "@types/node": "24.12.2",
+    "tsdown": "0.21.10",
+    "type-fest": "5.6.0",
+    "typescript": "6.0.3",
+    "valibot": "1.3.1",
+    "vitest": "4.1.5"
   },
   "peerDependencies": {
     "valibot": ">=1.0.0"

package/src/cli.ts

@@ -16,12 +16,7 @@ import { runInNewContext } from 'node:vm';
 
 const originalEmitWarning = process.emitWarning;
 process.emitWarning = (warning, ...args) => {
-  if (
-    typeof warning === 'string' &&
-    warning.startsWith('SQLite') &&
-    args[0] === 'ExperimentalWarning'
-  )
-    return;
+  if (typeof warning === 'string' && warning.startsWith('SQLite') && args[0] === 'ExperimentalWarning') return;
   originalEmitWarning(warning, ...(args as any[]));
 };
 
@@ -52,10 +47,7 @@ function runInSandbox<T>(expression: string, context: Record<string, unknown> =
 
 const program = new Command();
 
-program
-  .name('@toiroakr/lines-db')
-  .description('Database utilities for JSONL files')
-  .version('1.0.0');
+program.name('@toiroakr/lines-db').description('Database utilities for JSONL files').version('1.0.0');
 
 // Generate command
 program
@@ -113,9 +105,7 @@ program
         for (const tableResult of result.tableResults) {
           if (tableResult.valid && tableResult.warnings.length === 0) {
             // Success
-            console.log(
-              styleText('green', `✓ ${tableResult.tableName} (${tableResult.rowCount} records)`),
-            );
+            console.log(styleText('green', `✓ ${tableResult.tableName} (${tableResult.rowCount} records)`));
           } else if (tableResult.valid && tableResult.warnings.length > 0) {
             // Warnings
             for (const warning of tableResult.warnings) {
@@ -127,12 +117,8 @@ program
             console.error(formatter.formatErrorHeader(fileErrors.length, fileErrors[0]?.file));
             console.error('');
 
-            const validationErrors = fileErrors.filter(
-              (e) => e.type !== 'foreignKey' || !e.foreignKeyError,
-            );
-            const foreignKeyErrors = fileErrors.filter(
-              (e) => e.type === 'foreignKey' && e.foreignKeyError,
-            );
+            const validationErrors = fileErrors.filter((e) => e.type !== 'foreignKey' || !e.foreignKeyError);
+            const foreignKeyErrors = fileErrors.filter((e) => e.type === 'foreignKey' && e.foreignKeyError);
 
             if (validationErrors.length > 0) {
               console.error(
@@ -196,12 +182,8 @@ program
             console.error(formatter.formatErrorHeader(fileErrors.length, fileErrors[0]?.file));
             console.error('');
 
-            const validationErrors = fileErrors.filter(
-              (e) => e.type !== 'foreignKey' || !e.foreignKeyError,
-            );
-            const foreignKeyErrors = fileErrors.filter(
-              (e) => e.type === 'foreignKey' && e.foreignKeyError,
-            );
+            const validationErrors = fileErrors.filter((e) => e.type !== 'foreignKey' || !e.foreignKeyError);
+            const foreignKeyErrors = fileErrors.filter((e) => e.type === 'foreignKey' && e.foreignKeyError);
 
             if (validationErrors.length > 0) {
               console.error(
@@ -271,11 +253,7 @@ program
           process.exit(1);
         }
       } catch (error) {
-        if (
-          error instanceof Error &&
-          'code' in error &&
-          (error as NodeJS.ErrnoException).code === 'ENOENT'
-        ) {
+        if (error instanceof Error && 'code' in error && (error as NodeJS.ErrnoException).code === 'ENOENT') {
           console.error(`Error: Path not found: ${path}`);
         } else {
           console.error(`Error: ${String(error)}`);
@@ -374,9 +352,7 @@ async function migrateDirectory(
         console.log(`Processing table '${tableName}'...`);
 
         // Get rows to migrate
-        const rowsToMigrate = filter
-          ? db.find(tableName, filter as Parameters<typeof db.find>[1])
-          : db.find(tableName);
+        const rowsToMigrate = filter ? db.find(tableName, filter as Parameters<typeof db.find>[1]) : db.find(tableName);
 
         if (rowsToMigrate.length === 0) {
           console.log(`  No rows to migrate`);
@@ -414,23 +390,19 @@ async function migrateDirectory(
           };
 
           if (validationError.validationErrors) {
-            console.error(
-              `  Found ${validationError.validationErrors.length} validation error(s):\n`,
-            );
+            console.error(`  Found ${validationError.validationErrors.length} validation error(s):\n`);
 
             const rowsToMigrate = filter
               ? db.find(tableName, filter as Parameters<typeof db.find>[1])
               : db.find(tableName);
 
-            const errorInfos = validationError.validationErrors.map(
-              ({ rowIndex, rowData, error: rowError }) => ({
-                file: `${dirPath}/${tableName}.jsonl`,
-                rowIndex,
-                issues: rowError.issues,
-                data: rowData,
-                originalData: rowsToMigrate[rowIndex],
-              }),
-            );
+            const errorInfos = validationError.validationErrors.map(({ rowIndex, rowData, error: rowError }) => ({
+              file: `${dirPath}/${tableName}.jsonl`,
+              rowIndex,
+              issues: rowError.issues,
+              data: rowData,
+              originalData: rowsToMigrate[rowIndex],
+            }));
 
             const formatted = formatter.formatValidationErrors(errorInfos);
             console.error(formatted);
@@ -622,15 +594,13 @@ async function migrateFile(
               `\nFound ${validationError.validationErrors.length} validation error(s) in transformed data:\n`,
             );
 
-            const errorInfos = validationError.validationErrors.map(
-              ({ rowIndex, rowData, error: rowError }) => ({
-                file: filePath,
-                rowIndex,
-                issues: rowError.issues,
-                data: rowData,
-                originalData: rowsToMigrate[rowIndex],
-              }),
-            );
+            const errorInfos = validationError.validationErrors.map(({ rowIndex, rowData, error: rowError }) => ({
+              file: filePath,
+              rowIndex,
+              issues: rowError.issues,
+              data: rowData,
+              originalData: rowsToMigrate[rowIndex],
+            }));
 
             const formatted = formatter.formatValidationErrors(errorInfos);
             console.error(formatted);

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');
@@ -602,10 +579,7 @@ export const schema = Object.assign(Object.create(baseSchema), {
         ['profile_code'],
       );
 
-      await writeFile(
-        join(testDir, 'profiles.jsonl'),
-        '{"code":"a-001","author_id":"1","bio":"Author A"}\n',
-      );
+      await writeFile(join(testDir, 'profiles.jsonl'), '{"code":"a-001","author_id":"1","bio":"Author A"}\n');
       await writeSchemaWithFK(
         'profiles',
         'code',
@@ -635,10 +609,7 @@ export const schema = Object.assign(Object.create(baseSchema), {
     });
 
     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 writeFile(join(testDir, 'authors.jsonl'), '{"id":"1","name":"Alice","profile_code":"a-001"}\n');
       await writeSchemaWithFK(
         'authors',
         'id',

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}'`);
       }
     }
 
@@ -294,13 +289,7 @@ export class LinesDB<Tables extends TableDefs> {
         loaded,
         rowCount,
         errors: loadErrors,
-      } = await this.loadTable(
-        tableName,
-        tableConfig,
-        detailedValidate,
-        transform,
-        allSkippedDependencies,
-      );
+      } = await this.loadTable(tableName, tableConfig, detailedValidate, transform, allSkippedDependencies);
       errors.push(...loadErrors);
       rowCounts.set(tableName, rowCount);
 
@@ -373,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()}`);
@@ -544,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 };
       }
@@ -626,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))
@@ -836,10 +816,7 @@ export class LinesDB<Tables extends TableDefs> {
   /**
    * 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[];
   }
@@ -847,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);
@@ -896,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
@@ -919,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
@@ -986,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) {
@@ -1209,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);
     }
@@ -1250,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 };
@@ -1396,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);
@@ -1426,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
@@ -1465,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', () => {

package/src/jsonl-reader.ts

@@ -9,10 +9,7 @@ export class JsonlReader {
    * Temporarily override the data returned for specific JSONL files.
    * Useful for scenarios like migration validation where in-memory data should be used.
    */
-  static async withOverrides<T>(
-    overrides: Map<string, JsonObject[]>,
-    fn: () => Promise<T>,
-  ): Promise<T> {
+  static async withOverrides<T>(overrides: Map<string, JsonObject[]>, fn: () => Promise<T>): Promise<T> {
     const normalized = new Map<string, JsonObject[]>();
     for (const [filePath, rows] of overrides) {
       normalized.set(normalize(filePath), rows);

package/src/schema-loader.test.ts

@@ -157,9 +157,7 @@ describe('SchemaLoader', () => {
       const jsonlPath = join(testDir, 'users.jsonl');
       await writeFile(jsonlPath, '{"id":1}\n');
 
-      await expect(SchemaLoader.loadSchema(jsonlPath)).rejects.toThrow(
-        /\.schema\.ts.*\.schema\.mts.*\.schema\.cts/,
-      );
+      await expect(SchemaLoader.loadSchema(jsonlPath)).rejects.toThrow(/\.schema\.ts.*\.schema\.mts.*\.schema\.cts/);
     });
 
     it('should throw for invalid schema export', async () => {
@@ -176,9 +174,7 @@ describe('SchemaLoader', () => {
       `,
       );
 
-      await expect(SchemaLoader.loadSchema(jsonlPath)).rejects.toThrow(
-        /does not export a valid StandardSchema/,
-      );
+      await expect(SchemaLoader.loadSchema(jsonlPath)).rejects.toThrow(/does not export a valid StandardSchema/);
     });
 
     it('should validate StandardSchema structure', async () => {
@@ -200,9 +196,7 @@ describe('SchemaLoader', () => {
       `,
       );
 
-      await expect(SchemaLoader.loadSchema(jsonlPath)).rejects.toThrow(
-        /does not export a valid StandardSchema/,
-      );
+      await expect(SchemaLoader.loadSchema(jsonlPath)).rejects.toThrow(/does not export a valid StandardSchema/);
 
       // Wrong version
       await writeFile(
@@ -218,9 +212,7 @@ describe('SchemaLoader', () => {
       `,
       );
 
-      await expect(SchemaLoader.loadSchema(jsonlPath)).rejects.toThrow(
-        /does not export a valid StandardSchema/,
-      );
+      await expect(SchemaLoader.loadSchema(jsonlPath)).rejects.toThrow(/does not export a valid StandardSchema/);
     });
   });
 });

package/src/schema-loader.ts

@@ -64,9 +64,7 @@ export class SchemaLoader {
     const standardObj = standard as Record<string, unknown>;
 
     return (
-      standardObj.version === 1 &&
-      typeof standardObj.vendor === 'string' &&
-      typeof standardObj.validate === 'function'
+      standardObj.version === 1 && typeof standardObj.vendor === 'string' && typeof standardObj.validate === 'function'
     );
   }
 }

package/src/schema.ts

@@ -37,8 +37,10 @@ export type SchemaOptions<Input extends Table, Output extends Table> = {
  * BiDirectional Schema interface
  * Extends StandardSchema with optional backward transformation and schema metadata
  */
-export interface BiDirectionalSchema<Input extends Table = Table, Output extends Table = Input>
-  extends StandardSchema<Input, Output> {
+export interface BiDirectionalSchema<Input extends Table = Table, Output extends Table = Input> extends StandardSchema<
+  Input,
+  Output
+> {
   /**
    * Backward transformation from Output to Input
    * Required when Input and Output types differ (e.g., with transformations)
@@ -96,9 +98,7 @@ export interface BiDirectionalSchema<Input extends Table = Table, Output extends
  */
 export function defineSchema<Input extends Table, Output extends Table>(
   schema: StandardSchema<Input, Output>,
-  ...args: Output extends Input
-    ? [options?: SchemaOptions<Input, Output>]
-    : [options: SchemaOptions<Input, Output>]
+  ...args: Output extends Input ? [options?: SchemaOptions<Input, Output>] : [options: SchemaOptions<Input, Output>]
 ): BiDirectionalSchema<Input, Output> {
   const options = args[0];
   // Create a new object that extends the schema