@toiroakr/lines-db 0.6.1 → 0.8.0

package/src/schema-extensions.ts

@@ -0,0 +1,86 @@
+import { access } from 'node:fs/promises';
+import { join } from 'node:path';
+
+/**
+ * Supported schema file extensions, in priority order.
+ * The first match wins when discovering schema files.
+ */
+export const SCHEMA_EXTENSIONS = ['.schema.ts', '.schema.mts', '.schema.cts'] as const;
+export type SchemaExtension = (typeof SCHEMA_EXTENSIONS)[number];
+
+/**
+ * Map from schema extensions to their JavaScript import counterparts.
+ */
+const SCHEMA_TO_JS_IMPORT_MAP: Record<string, string> = {
+  '.schema.ts': '.schema.js',
+  '.schema.mts': '.schema.mjs',
+  '.schema.cts': '.schema.cjs',
+};
+
+/**
+ * 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> {
+  for (const ext of SCHEMA_EXTENSIONS) {
+    const candidate = join(dir, `${tableName}${ext}`);
+    try {
+      await access(candidate);
+      return candidate;
+    } catch {
+      // Continue to next extension
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Synchronously find a schema file among directory entries.
+ * Returns the full path of the first match, or undefined.
+ */
+export function findSchemaFileInEntries(
+  dataDirPath: string,
+  tableName: string,
+  entries: { isFile(): boolean; name: string }[],
+): string | undefined {
+  for (const ext of SCHEMA_EXTENSIONS) {
+    const candidateName = `${tableName}${ext}`;
+    if (entries.some((e) => e.isFile() && e.name === candidateName)) {
+      return join(dataDirPath, candidateName);
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Check if a filename matches any supported schema file pattern.
+ */
+export function isSchemaFile(fileName: string): boolean {
+  return SCHEMA_EXTENSIONS.some((ext) => fileName.endsWith(ext));
+}
+
+/**
+ * Extract table name from a schema filename.
+ * e.g., "users.schema.ts" -> "users", "users.schema.mts" -> "users"
+ */
+export function extractTableNameFromSchemaFile(fileName: string): string | null {
+  for (const ext of SCHEMA_EXTENSIONS) {
+    if (fileName.endsWith(ext)) {
+      return fileName.slice(0, -ext.length);
+    }
+  }
+  return null;
+}
+
+/**
+ * Rewrite a TypeScript path to its JavaScript counterpart for ESM imports.
+ * ".schema.ts" -> ".schema.js", ".schema.mts" -> ".schema.mjs", ".schema.cts" -> ".schema.cjs"
+ */
+export function rewriteExtensionForImport(filePath: string): string {
+  for (const [tsExt, jsExt] of Object.entries(SCHEMA_TO_JS_IMPORT_MAP)) {
+    if (filePath.endsWith(tsExt)) {
+      return filePath.slice(0, -tsExt.length) + jsExt;
+    }
+  }
+  return filePath;
+}

package/src/schema-loader.test.ts

@@ -65,6 +65,87 @@ describe('SchemaLoader', () => {
       expect(schema['~standard'].vendor).toBe('default-export');
     });
 
+    it('should load schema from .mts file', async () => {
+      const jsonlPath = join(testDir, 'users.jsonl');
+      const schemaPath = join(testDir, 'users.schema.mts');
+
+      await writeFile(jsonlPath, '{"id":1}\n');
+      await writeFile(
+        schemaPath,
+        `
+        export const schema = {
+          '~standard': {
+            version: 1,
+            vendor: 'mts-test',
+            validate: () => ({ value: {} })
+          }
+        };
+      `,
+      );
+
+      const schema = await SchemaLoader.loadSchema(jsonlPath);
+
+      expect(schema).toBeDefined();
+      expect(schema['~standard'].vendor).toBe('mts-test');
+    });
+
+    it('should load schema from .cts file', async () => {
+      const jsonlPath = join(testDir, 'users.jsonl');
+      const schemaPath = join(testDir, 'users.schema.cts');
+
+      await writeFile(jsonlPath, '{"id":1}\n');
+      await writeFile(
+        schemaPath,
+        `
+        export const schema = {
+          '~standard': {
+            version: 1,
+            vendor: 'cts-test',
+            validate: () => ({ value: {} })
+          }
+        };
+      `,
+      );
+
+      const schema = await SchemaLoader.loadSchema(jsonlPath);
+
+      expect(schema).toBeDefined();
+      expect(schema['~standard'].vendor).toBe('cts-test');
+    });
+
+    it('should prefer .schema.ts over .schema.mts when both exist', async () => {
+      const jsonlPath = join(testDir, 'users.jsonl');
+
+      await writeFile(jsonlPath, '{"id":1}\n');
+      await writeFile(
+        join(testDir, 'users.schema.ts'),
+        `
+        export const schema = {
+          '~standard': {
+            version: 1,
+            vendor: 'ts-priority',
+            validate: () => ({ value: {} })
+          }
+        };
+      `,
+      );
+      await writeFile(
+        join(testDir, 'users.schema.mts'),
+        `
+        export const schema = {
+          '~standard': {
+            version: 1,
+            vendor: 'mts-secondary',
+            validate: () => ({ value: {} })
+          }
+        };
+      `,
+      );
+
+      const schema = await SchemaLoader.loadSchema(jsonlPath);
+      expect(schema['~standard'].vendor).toBe('ts-priority');
+    });
+
     it('should throw when no schema file exists', async () => {
       const jsonlPath = join(testDir, 'users.jsonl');
       await writeFile(jsonlPath, '{"id":1}\n');
@@ -72,6 +153,15 @@ describe('SchemaLoader', () => {
       await expect(SchemaLoader.loadSchema(jsonlPath)).rejects.toThrow(/Schema file not found/);
     });
 
+    it('should list all supported extensions in error message', async () => {
+      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/,
+      );
+    });
+
     it('should throw for invalid schema export', async () => {
       const jsonlPath = join(testDir, 'users.jsonl');
       const schemaPath = join(testDir, 'users.schema.ts');

package/src/schema-loader.ts

@@ -1,7 +1,7 @@
 import { pathToFileURL } from 'node:url';
-import { access } from 'node:fs/promises';
-import { dirname, join, basename } from 'node:path';
+import { dirname, basename } from 'node:path';
 import type { StandardSchema } from './types.js';
+import { findSchemaFile, SCHEMA_EXTENSIONS } from './schema-extensions.js';
 
 export class SchemaLoader {
   /**
@@ -10,31 +10,23 @@ export class SchemaLoader {
   static async hasSchema(jsonlPath: string): Promise<boolean> {
     const dir = dirname(jsonlPath);
     const tableName = basename(jsonlPath, '.jsonl');
-    const schemaPath = join(dir, `${tableName}.schema.ts`);
-
-    try {
-      await access(schemaPath);
-      return true;
-    } catch {
-      return false;
-    }
+    const schemaPath = await findSchemaFile(dir, tableName);
+    return schemaPath !== undefined;
   }
 
   /**
    * Load a validation schema file for a table
-   * Requires ${tableName}.schema.ts to exist alongside the JSONL file
+   * Requires ${tableName}.schema.{ts,mts,cts} to exist alongside the JSONL file
    */
   static async loadSchema(jsonlPath: string): Promise<StandardSchema> {
     const dir = dirname(jsonlPath);
     const tableName = basename(jsonlPath, '.jsonl');
-    const schemaPath = join(dir, `${tableName}.schema.ts`);
+    const schemaPath = await findSchemaFile(dir, tableName);
 
-    try {
-      await access(schemaPath);
-    } catch (error) {
-      throw new Error(`Schema file not found for table '${tableName}'. Expected: ${schemaPath}`, {
-        cause: error instanceof Error ? error : undefined,
-      });
+    if (!schemaPath) {
+      throw new Error(
+        `Schema file not found for table '${tableName}'. Expected one of: ${SCHEMA_EXTENSIONS.map((ext) => `${tableName}${ext}`).join(', ')}`,
+      );
     }
 
     try {

package/src/type-generator.ts

@@ -1,10 +1,12 @@
 import { readdir } from 'node:fs/promises';
 import { join, relative, basename, dirname, isAbsolute } from 'node:path';
 import { writeFile, mkdir } from 'node:fs/promises';
+import { findSchemaFileInEntries, rewriteExtensionForImport } from './schema-extensions.js';
 
 export interface TypeGeneratorOptions {
   dataDir: string;
   projectRoot?: string; // Default: current working directory
+  output?: string; // Output file path (default: db.ts in dataDir)
 }
 
 interface TableInfo {
@@ -27,7 +29,11 @@ export class TypeGenerator {
     this.dataDirPath = isAbsolute(this.dataDir)
       ? this.dataDir
       : join(this.projectRoot, this.dataDir);
-    this.outputFile = join(this.dataDirPath, 'db.ts');
+    this.outputFile = options.output
+      ? isAbsolute(options.output)
+        ? options.output
+        : join(this.projectRoot, options.output)
+      : join(this.dataDirPath, 'db.ts');
   }
 
   /**
@@ -67,15 +73,11 @@ export class TypeGenerator {
       for (const entry of entries) {
         if (entry.isFile() && entry.name.endsWith('.jsonl')) {
           const tableName = basename(entry.name, '.jsonl');
-          const schemaFileName = `${tableName}.schema.ts`;
-          const schemaFilePath = join(this.dataDirPath, schemaFileName);
-
-          // Check if schema file exists
-          const hasSchema = entries.some((e) => e.isFile() && e.name === schemaFileName);
+          const schemaFilePath = findSchemaFileInEntries(this.dataDirPath, tableName, entries);
 
           tables.push({
             tableName,
-            schemaFile: hasSchema ? schemaFilePath : undefined,
+            schemaFile: schemaFilePath,
           });
         }
       }
@@ -108,9 +110,9 @@ export class TypeGenerator {
         usedAliases.add(schemaIdentifier);
 
         // Calculate relative path from output file to schema file
-        let relativePath = relative(join(this.outputFile, '..'), table.schemaFile)
-          .replace(/\\/g, '/') // Convert Windows paths to Unix-style
-          .replace('.ts', '.js'); // Import from .js (TypeScript module resolution)
+        let relativePath = rewriteExtensionForImport(
+          relative(join(this.outputFile, '..'), table.schemaFile).replace(/\\/g, '/'), // Convert Windows paths to Unix-style
+        );
 
         // Ensure relative path starts with './' or '../'
         if (!relativePath.startsWith('.')) {

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 {