@toiroakr/lines-db 0.7.0 → 0.8.0

package/src/cli.ts

@@ -106,72 +106,135 @@ program
         await db.close();
       }
 
-      // Display warnings if any
-      if (result.warnings.length > 0) {
-        for (const warning of result.warnings) {
-          console.warn(styleText('yellow', `⚠ ${warning}`));
+      // Directory validation: display per-table results
+      if (!tableName) {
+        const formatter = new ErrorFormatter({ verbose: options.verbose });
+
+        for (const tableResult of result.tableResults) {
+          if (tableResult.valid && tableResult.warnings.length === 0) {
+            // Success
+            console.log(
+              styleText('green', `✓ ${tableResult.tableName} (${tableResult.rowCount} records)`),
+            );
+          } else if (tableResult.valid && tableResult.warnings.length > 0) {
+            // Warnings
+            for (const warning of tableResult.warnings) {
+              console.warn(styleText('yellow', `⚠ ${warning}`));
+            }
+          } else {
+            // Errors
+            const fileErrors = tableResult.errors;
+            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,
+            );
+
+            if (validationErrors.length > 0) {
+              console.error(
+                formatter.formatValidationErrors(
+                  validationErrors.map((e) => ({
+                    file: e.file,
+                    rowIndex: e.rowIndex,
+                    issues: e.issues,
+                  })),
+                ),
+              );
+            }
+
+            for (const error of foreignKeyErrors) {
+              if (error.foreignKeyError) {
+                console.error(
+                  formatter.formatForeignKeyError({
+                    file: error.file,
+                    rowIndex: error.rowIndex,
+                    column: error.foreignKeyError.column,
+                    value: error.foreignKeyError.value,
+                    referencedTable: error.foreignKeyError.referencedTable,
+                    referencedColumn: error.foreignKeyError.referencedColumn,
+                  }),
+                );
+              }
+            }
+
+            console.error('');
+          }
         }
-        console.log('');
-      }
 
-      if (result.valid) {
-        console.log('✓ All records are valid');
-        process.exit(0);
+        if (result.valid) {
+          console.log('');
+          console.log(styleText('green', '✓ All records are valid'));
+          process.exit(0);
+        } else {
+          process.exit(1);
+        }
       } else {
-        const formatter = new ErrorFormatter({ verbose: options.verbose });
-
-        // Group errors by file for header
-        const errorsByFile = new Map<string, typeof result.errors>();
-        for (const error of result.errors) {
-          const fileErrors = errorsByFile.get(error.file) || [];
-          fileErrors.push(error);
-          errorsByFile.set(error.file, fileErrors);
+        // Single file validation: existing behavior
+        if (result.warnings.length > 0) {
+          for (const warning of result.warnings) {
+            console.warn(styleText('yellow', `⚠ ${warning}`));
+          }
+          console.log('');
         }
 
-        // Format and display errors
-        for (const [file, fileErrors] of errorsByFile) {
-          console.error(formatter.formatErrorHeader(fileErrors.length, file));
-          console.error('');
-
-          // Separate validation errors and foreign key errors
-          const validationErrors = fileErrors.filter(
-            (e) => e.type !== 'foreignKey' || !e.foreignKeyError,
-          );
-          const foreignKeyErrors = fileErrors.filter(
-            (e) => e.type === 'foreignKey' && e.foreignKeyError,
-          );
-
-          // Format validation errors
-          if (validationErrors.length > 0) {
-            const formattedValidation = formatter.formatValidationErrors(
-              validationErrors.map((e) => ({
-                file: e.file,
-                rowIndex: e.rowIndex,
-                issues: e.issues,
-              })),
+        if (result.valid) {
+          console.log(styleText('green', '✓ All records are valid'));
+          process.exit(0);
+        } else {
+          const formatter = new ErrorFormatter({ verbose: options.verbose });
+
+          for (const [, fileErrors] of result.errors.reduce((map, error) => {
+            const errors = map.get(error.file) || [];
+            errors.push(error);
+            map.set(error.file, errors);
+            return map;
+          }, new Map<string, typeof result.errors>())) {
+            console.error(formatter.formatErrorHeader(fileErrors.length, fileErrors[0]?.file));
+            console.error('');
+
+            const validationErrors = fileErrors.filter(
+              (e) => e.type !== 'foreignKey' || !e.foreignKeyError,
             );
-            console.error(formattedValidation);
-          }
+            const foreignKeyErrors = fileErrors.filter(
+              (e) => e.type === 'foreignKey' && e.foreignKeyError,
+            );
+
+            if (validationErrors.length > 0) {
+              console.error(
+                formatter.formatValidationErrors(
+                  validationErrors.map((e) => ({
+                    file: e.file,
+                    rowIndex: e.rowIndex,
+                    issues: e.issues,
+                  })),
+                ),
+              );
+            }
 
-          // Format foreign key errors
-          for (const error of foreignKeyErrors) {
-            if (error.foreignKeyError) {
-              const formattedFk = formatter.formatForeignKeyError({
-                file: error.file,
-                rowIndex: error.rowIndex,
-                column: error.foreignKeyError.column,
-                value: error.foreignKeyError.value,
-                referencedTable: error.foreignKeyError.referencedTable,
-                referencedColumn: error.foreignKeyError.referencedColumn,
-              });
-              console.error(formattedFk);
+            for (const error of foreignKeyErrors) {
+              if (error.foreignKeyError) {
+                console.error(
+                  formatter.formatForeignKeyError({
+                    file: error.file,
+                    rowIndex: error.rowIndex,
+                    column: error.foreignKeyError.column,
+                    value: error.foreignKeyError.value,
+                    referencedTable: error.foreignKeyError.referencedTable,
+                    referencedColumn: error.foreignKeyError.referencedColumn,
+                  }),
+                );
+              }
             }
+
+            console.error('');
           }
 
-          console.error('');
+          process.exit(1);
         }
-
-        process.exit(1);
       }
     } catch (error) {
       console.error('Error:', error instanceof Error ? error.message : String(error));

package/src/database.ts

@@ -18,6 +18,7 @@ import type {
   WhereCondition,
   ValidationResult,
   ValidationErrorDetail,
+  TableValidationResult,
   ForeignKeyDefinition,
 } from './types.js';
 import type { BiDirectionalSchema } from './schema.js';
@@ -58,6 +59,7 @@ export class LinesDB<Tables extends TableDefs> {
   }): Promise<ValidationResult> {
     const allErrors: ValidationErrorDetail[] = [];
     const allWarnings: string[] = [];
+    const allRowCounts = new Map<string, number>();
     const tableName = options?.tableName;
     const detailedValidate = options?.detailedValidate ?? false;
     const transform = options?.transform;
@@ -87,7 +89,11 @@ export class LinesDB<Tables extends TableDefs> {
       if (!attemptedTables.has(tableNameToLoad)) {
         // Only apply transform to the specified table
         const tableTransform = tableNameToLoad === tableName ? transform : undefined;
-        const { errors, warnings } = await this.loadTableWithDependencies(
+        const {
+          errors,
+          warnings,
+          rowCounts: tableRowCounts,
+        } = await this.loadTableWithDependencies(
           tableNameToLoad,
           loadedTables,
           loadingTables,
@@ -97,13 +103,30 @@ export class LinesDB<Tables extends TableDefs> {
         );
         allErrors.push(...errors);
         allWarnings.push(...warnings);
+        for (const [k, v] of tableRowCounts) {
+          allRowCounts.set(k, v);
+        }
       }
     }
 
+    // Build per-table results
+    const tableResults: TableValidationResult[] = tablesToLoad.map((name) => {
+      const tableErrors = allErrors.filter((e) => e.tableName === name);
+      const tableWarnings = allWarnings.filter((w) => w.includes(`'${name}'`));
+      return {
+        tableName: name,
+        valid: tableErrors.length === 0,
+        rowCount: allRowCounts.get(name) ?? 0,
+        errors: tableErrors,
+        warnings: tableWarnings,
+      };
+    });
+
     return {
       valid: allErrors.length === 0,
       errors: allErrors,
       warnings: allWarnings,
+      tableResults,
     };
   }
 
@@ -117,13 +140,18 @@ export class LinesDB<Tables extends TableDefs> {
     attemptedTables: Set<string>,
     detailedValidate: boolean,
     transform?: (row: JsonObject) => JsonObject,
-  ): Promise<{ errors: ValidationErrorDetail[]; warnings: string[] }> {
+  ): Promise<{
+    errors: ValidationErrorDetail[];
+    warnings: string[];
+    rowCounts: Map<string, number>;
+  }> {
     const errors: ValidationErrorDetail[] = [];
     const warnings: string[] = [];
+    const rowCounts = new Map<string, number>();
 
     // Skip if already attempted (loaded or not)
     if (attemptedTables.has(tableName)) {
-      return { errors, warnings };
+      return { errors, warnings, rowCounts };
     }
 
     // Mark as attempted
@@ -190,6 +218,9 @@ export class LinesDB<Tables extends TableDefs> {
               );
               errors.push(...depResult.errors);
               warnings.push(...depResult.warnings);
+              for (const [k, v] of depResult.rowCounts) {
+                rowCounts.set(k, v);
+              }
             } else {
               throw new Error(
                 `Foreign key reference to non-existent table '${referencedTable}' in table '${tableName}'`,
@@ -199,14 +230,39 @@ export class LinesDB<Tables extends TableDefs> {
         }
       }
 
+      // Determine which FK dependencies failed validation (attempted but not loaded)
+      const failedDependencies = 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 (failedDependencies.size > 0) {
+          for (const dep of failedDependencies) {
+            warnings.push(
+              `Skipping foreign key validation for table '${tableName}': referenced table '${dep}' has validation errors`,
+            );
+          }
+        }
+      }
+
       // Now load this table
-      const { loaded, errors: loadErrors } = await this.loadTable(
+      const {
+        loaded,
+        rowCount,
+        errors: loadErrors,
+      } = await this.loadTable(
         tableName,
         tableConfig,
         detailedValidate,
         transform,
+        failedDependencies,
       );
       errors.push(...loadErrors);
+      rowCounts.set(tableName, rowCount);
 
       if (loaded) {
         loadedTables.add(tableName);
@@ -220,7 +276,7 @@ export class LinesDB<Tables extends TableDefs> {
       loadingTables.delete(tableName);
     }
 
-    return { errors, warnings };
+    return { errors, warnings, rowCounts };
   }
 
   /**
@@ -232,7 +288,8 @@ export class LinesDB<Tables extends TableDefs> {
     config: TableConfig,
     detailedValidate: boolean,
     transform?: (row: JsonObject) => JsonObject,
-  ): Promise<{ loaded: boolean; errors: ValidationErrorDetail[] }> {
+    failedDependencies?: Set<string>,
+  ): Promise<{ loaded: boolean; rowCount: number; errors: ValidationErrorDetail[] }> {
     // Read JSONL file
     let data = await JsonlReader.read(config.jsonlPath);
 
@@ -350,7 +407,7 @@ export class LinesDB<Tables extends TableDefs> {
 
     if (validationErrors.length > 0) {
       // Return errors instead of throwing
-      return { loaded: false, errors: validationErrorDetails };
+      return { loaded: false, rowCount: data.length, errors: validationErrorDetails };
     }
 
     // Determine schema - infer from validated data if auto-inference is enabled
@@ -375,7 +432,7 @@ export class LinesDB<Tables extends TableDefs> {
       }
     } else if (config.autoInferSchema !== false) {
       if (validatedData.length === 0) {
-        return { loaded: false, errors: [] };
+        return { loaded: false, rowCount: 0, errors: [] };
       }
       // Use inferred schema
       schema = inferredSchema!;
@@ -406,7 +463,10 @@ export class LinesDB<Tables extends TableDefs> {
       }
     }
     if (foreignKeys) {
-      schema.foreignKeys = foreignKeys;
+      schema.foreignKeys =
+        failedDependencies && failedDependencies.size > 0
+          ? foreignKeys.filter((fk) => !failedDependencies.has(fk.references.table))
+          : foreignKeys;
     }
     if (indexes) {
       schema.indexes = indexes;
@@ -438,13 +498,13 @@ export class LinesDB<Tables extends TableDefs> {
         config.jsonlPath,
       );
       if (insertErrors.length > 0) {
-        return { loaded: false, errors: insertErrors };
+        return { loaded: false, rowCount: data.length, errors: insertErrors };
       }
     } else {
       this.insertData(tableName, schema, validatedData);
     }
 
-    return { loaded: true, errors: [] };
+    return { loaded: true, rowCount: data.length, errors: [] };
   }
 
   /**

package/src/index.ts

@@ -32,6 +32,7 @@ export type {
   StandardSchemaIssue,
   ValidationError,
   ValidationResult,
+  TableValidationResult,
   ValidationErrorDetail,
   InferInput,
   InferOutput,

package/src/schema-extensions.ts

@@ -21,10 +21,7 @@ const SCHEMA_TO_JS_IMPORT_MAP: Record<string, string> = {
  * Try each supported schema extension and return the full path of the first
  * one that exists on disk. Returns undefined if none is found.
  */
-export async function findSchemaFile(
-  dir: string,
-  tableName: string,
-): Promise<string | undefined> {
+export async function findSchemaFile(dir: string, tableName: string): Promise<string | undefined> {
   for (const ext of SCHEMA_EXTENSIONS) {
     const candidate = join(dir, `${tableName}${ext}`);
     try {

package/src/type-generator.ts

@@ -30,7 +30,9 @@ export class TypeGenerator {
       ? this.dataDir
       : join(this.projectRoot, this.dataDir);
     this.outputFile = options.output
-      ? (isAbsolute(options.output) ? options.output : join(this.projectRoot, options.output))
+      ? isAbsolute(options.output)
+        ? options.output
+        : join(this.projectRoot, options.output)
       : join(this.dataDirPath, 'db.ts');
   }
 
@@ -109,8 +111,7 @@ export class TypeGenerator {
 
         // Calculate relative path from output file to schema file
         let relativePath = rewriteExtensionForImport(
-          relative(join(this.outputFile, '..'), table.schemaFile)
-            .replace(/\\/g, '/'), // Convert Windows paths to Unix-style
+          relative(join(this.outputFile, '..'), table.schemaFile).replace(/\\/g, '/'), // Convert Windows paths to Unix-style
         );
 
         // Ensure relative path starts with './' or '../'

package/src/types.ts

@@ -18,10 +18,19 @@ export type InferInput<T> = T extends StandardSchemaV1<infer I, unknown> ? I : n
 export type InferOutput<T> = T extends StandardSchemaV1<unknown, infer O> ? O : never;
 
 // Validation result types
+export interface TableValidationResult {
+  tableName: string;
+  valid: boolean;
+  rowCount: number;
+  errors: ValidationErrorDetail[];
+  warnings: string[];
+}
+
 export interface ValidationResult {
   valid: boolean;
   errors: ValidationErrorDetail[];
   warnings: string[];
+  tableResults: TableValidationResult[];
 }
 
 export interface ValidationErrorDetail {