@toiroakr/lines-db 0.6.0 → 0.7.0

package/src/database.ts

@@ -4,6 +4,8 @@ import { JsonlWriter } from './jsonl-writer.js';
 import { SchemaLoader } from './schema-loader.js';
 import { DirectoryScanner } from './directory-scanner.js';
 import { hasBackward } from './schema.js';
+import { findSchemaFile } from './schema-extensions.js';
+import { dirname, basename } from 'node:path';
 import type {
   DatabaseConfig,
   TableSchema,
@@ -148,13 +150,18 @@ export class LinesDB<Tables extends TableDefs> {
 
       try {
         const { pathToFileURL } = await import('node:url');
-        const schemaPath = tableConfig.jsonlPath.replace('.jsonl', '.schema.ts');
-        const schemaUrl = pathToFileURL(schemaPath).href;
-        const schemaModule = await import(`${schemaUrl}?t=${Date.now()}`);
+        const schemaPath = await findSchemaFile(
+          dirname(tableConfig.jsonlPath),
+          basename(tableConfig.jsonlPath, '.jsonl'),
+        );
+        if (schemaPath) {
+          const schemaUrl = pathToFileURL(schemaPath).href;
+          const schemaModule = await import(`${schemaUrl}?t=${Date.now()}`);
 
-        // Try to get foreign keys from exported 'schema' or directly from module
-        const schemaExport = schemaModule.schema || schemaModule.default;
-        foreignKeys = schemaExport?.foreignKeys || schemaModule.foreignKeys;
+          // Try to get foreign keys from exported 'schema' or directly from module
+          const schemaExport = schemaModule.schema || schemaModule.default;
+          foreignKeys = schemaExport?.foreignKeys || schemaModule.foreignKeys;
+        }
       } catch {
         // Schema file not found - will continue without validation
       }
@@ -256,7 +263,11 @@ export class LinesDB<Tables extends TableDefs> {
       // Only load if not already provided via config
       try {
         const { pathToFileURL } = await import('node:url');
-        const schemaPath = config.jsonlPath.replace('.jsonl', '.schema.ts');
+        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()}`);
 
@@ -280,8 +291,23 @@ export class LinesDB<Tables extends TableDefs> {
         } else if (schemaModule.indexes) {
           schemaMetadata.indexes = schemaModule.indexes;
         }
+
+        // Debug: log loaded metadata
+        if (process.env.DEBUG_LINES_DB) {
+          console.log(`[lines-db] Schema metadata for ${tableName}:`);
+          console.log(`  primaryKey: ${schemaMetadata.primaryKey}`);
+          console.log(`  foreignKeys: ${JSON.stringify(schemaMetadata.foreignKeys)}`);
+          console.log(`  indexes: ${JSON.stringify(schemaMetadata.indexes)}`);
+        }
       } catch (_error) {
         // Schema file not found - this is OK
+        // Debug: log error for investigation
+        if (process.env.DEBUG_LINES_DB) {
+          console.warn(
+            `[lines-db] Failed to load schema metadata for ${tableName}:`,
+            _error instanceof Error ? _error.message : String(_error),
+          );
+        }
       }
     }
 
@@ -384,6 +410,18 @@ export class LinesDB<Tables extends TableDefs> {
     }
     if (indexes) {
       schema.indexes = indexes;
+
+      // Apply unique constraint from single-column unique indexes to column definitions
+      // This is required for foreign key references, as SQLite requires the referenced column
+      // to have a UNIQUE constraint in the table definition (not just an index)
+      for (const index of indexes) {
+        if (index.unique && index.columns.length === 1) {
+          const col = schema.columns.find((c) => c.name === index.columns[0]);
+          if (col && !col.unique && !col.primaryKey) {
+            col.unique = true;
+          }
+        }
+      }
     }
 
     this.schemas.set(tableName, schema);
@@ -419,13 +457,31 @@ export class LinesDB<Tables extends TableDefs> {
     // Quote table name to handle special characters
     const quotedTableName = this.quoteTableName(schema.name);
 
+    // Build a set of columns that should have UNIQUE constraint
+    // This includes columns marked as unique in schema AND single-column unique indexes
+    // The latter is required for foreign key references, as SQLite requires the referenced column
+    // to have a UNIQUE constraint in the table definition (not just a separately created index)
+    const uniqueColumns = new Set<string>();
+    for (const col of schema.columns) {
+      if (col.unique) {
+        uniqueColumns.add(col.name);
+      }
+    }
+    if (schema.indexes) {
+      for (const index of schema.indexes) {
+        if (index.unique && index.columns.length === 1) {
+          uniqueColumns.add(index.columns[0]);
+        }
+      }
+    }
+
     const columnDefs = schema.columns.map((col) => {
       // JSON type is stored as TEXT in SQLite
       const sqlType = col.type === 'JSON' ? 'TEXT' : col.type;
       const parts = [this.quoteIdentifier(col.name), sqlType];
       if (col.primaryKey) parts.push('PRIMARY KEY');
       if (col.notNull) parts.push('NOT NULL');
-      if (col.unique) parts.push('UNIQUE');
+      if (uniqueColumns.has(col.name) && !col.primaryKey) parts.push('UNIQUE');
       return parts.join(' ');
     });
 

package/src/index.ts

@@ -7,6 +7,14 @@ export { defineSchema, hasBackward } from './schema.js';
 export { TypeGenerator } from './type-generator.js';
 export { ensureTableRowsValid } from './jsonl-migration.js';
 export type { TableValidationOptions } from './jsonl-migration.js';
+export {
+  SCHEMA_EXTENSIONS,
+  findSchemaFile,
+  isSchemaFile,
+  extractTableNameFromSchemaFile,
+  rewriteExtensionForImport,
+} from './schema-extensions.js';
+export type { SchemaExtension } from './schema-extensions.js';
 export { detectRuntime, RUNTIME } from './runtime.js';
 export type { RuntimeEnvironment } from './runtime.js';
 export type { SQLiteDatabase, SQLiteStatement } from './sqlite-adapter.js';

package/src/schema-extensions.test.ts

@@ -0,0 +1,155 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  isSchemaFile,
+  extractTableNameFromSchemaFile,
+  rewriteExtensionForImport,
+  findSchemaFile,
+  findSchemaFileInEntries,
+  SCHEMA_EXTENSIONS,
+} from './schema-extensions.js';
+import { writeFile, mkdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+describe('schema-extensions', () => {
+  describe('isSchemaFile', () => {
+    it('should recognize .schema.ts', () => {
+      expect(isSchemaFile('users.schema.ts')).toBe(true);
+    });
+
+    it('should recognize .schema.mts', () => {
+      expect(isSchemaFile('users.schema.mts')).toBe(true);
+    });
+
+    it('should recognize .schema.cts', () => {
+      expect(isSchemaFile('users.schema.cts')).toBe(true);
+    });
+
+    it('should reject non-schema files', () => {
+      expect(isSchemaFile('users.ts')).toBe(false);
+      expect(isSchemaFile('db.ts')).toBe(false);
+      expect(isSchemaFile('schema.ts')).toBe(false);
+    });
+  });
+
+  describe('extractTableNameFromSchemaFile', () => {
+    it('should extract from .schema.ts', () => {
+      expect(extractTableNameFromSchemaFile('users.schema.ts')).toBe('users');
+    });
+
+    it('should extract from .schema.mts', () => {
+      expect(extractTableNameFromSchemaFile('users.schema.mts')).toBe('users');
+    });
+
+    it('should extract from .schema.cts', () => {
+      expect(extractTableNameFromSchemaFile('users.schema.cts')).toBe('users');
+    });
+
+    it('should return null for non-schema files', () => {
+      expect(extractTableNameFromSchemaFile('users.ts')).toBeNull();
+      expect(extractTableNameFromSchemaFile('db.ts')).toBeNull();
+    });
+  });
+
+  describe('rewriteExtensionForImport', () => {
+    it('.schema.ts -> .schema.js', () => {
+      expect(rewriteExtensionForImport('./users.schema.ts')).toBe('./users.schema.js');
+    });
+
+    it('.schema.mts -> .schema.mjs', () => {
+      expect(rewriteExtensionForImport('./users.schema.mts')).toBe('./users.schema.mjs');
+    });
+
+    it('.schema.cts -> .schema.cjs', () => {
+      expect(rewriteExtensionForImport('./users.schema.cts')).toBe('./users.schema.cjs');
+    });
+
+    it('should not modify paths without matching extensions', () => {
+      expect(rewriteExtensionForImport('./users.js')).toBe('./users.js');
+    });
+  });
+
+  describe('findSchemaFile', () => {
+    let testDir: string;
+
+    beforeEach(async () => {
+      testDir = join(tmpdir(), `schema-ext-test-${Date.now()}`);
+      await mkdir(testDir, { recursive: true });
+    });
+
+    afterEach(async () => {
+      await rm(testDir, { recursive: true, force: true });
+    });
+
+    it('should find .schema.ts file', async () => {
+      await writeFile(join(testDir, 'users.schema.ts'), 'export const schema = {};');
+      const result = await findSchemaFile(testDir, 'users');
+      expect(result).toBe(join(testDir, 'users.schema.ts'));
+    });
+
+    it('should find .schema.mts file', async () => {
+      await writeFile(join(testDir, 'users.schema.mts'), 'export const schema = {};');
+      const result = await findSchemaFile(testDir, 'users');
+      expect(result).toBe(join(testDir, 'users.schema.mts'));
+    });
+
+    it('should find .schema.cts file', async () => {
+      await writeFile(join(testDir, 'users.schema.cts'), 'export const schema = {};');
+      const result = await findSchemaFile(testDir, 'users');
+      expect(result).toBe(join(testDir, 'users.schema.cts'));
+    });
+
+    it('should prefer .schema.ts over .schema.mts', async () => {
+      await writeFile(join(testDir, 'users.schema.ts'), 'export const schema = {};');
+      await writeFile(join(testDir, 'users.schema.mts'), 'export const schema = {};');
+      const result = await findSchemaFile(testDir, 'users');
+      expect(result).toBe(join(testDir, 'users.schema.ts'));
+    });
+
+    it('should return undefined when no schema file exists', async () => {
+      const result = await findSchemaFile(testDir, 'users');
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('findSchemaFileInEntries', () => {
+    it('should find .schema.ts in entries', () => {
+      const entries = [
+        { isFile: () => true, name: 'users.jsonl' },
+        { isFile: () => true, name: 'users.schema.ts' },
+      ];
+      const result = findSchemaFileInEntries('/data', 'users', entries);
+      expect(result).toBe(join('/data', 'users.schema.ts'));
+    });
+
+    it('should find .schema.mts in entries', () => {
+      const entries = [
+        { isFile: () => true, name: 'users.jsonl' },
+        { isFile: () => true, name: 'users.schema.mts' },
+      ];
+      const result = findSchemaFileInEntries('/data', 'users', entries);
+      expect(result).toBe(join('/data', 'users.schema.mts'));
+    });
+
+    it('should prefer .schema.ts over .schema.mts in entries', () => {
+      const entries = [
+        { isFile: () => true, name: 'users.schema.ts' },
+        { isFile: () => true, name: 'users.schema.mts' },
+      ];
+      const result = findSchemaFileInEntries('/data', 'users', entries);
+      expect(result).toBe(join('/data', 'users.schema.ts'));
+    });
+
+    it('should return undefined when no schema file in entries', () => {
+      const entries = [{ isFile: () => true, name: 'users.jsonl' }];
+      const result = findSchemaFileInEntries('/data', 'users', entries);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('SCHEMA_EXTENSIONS', () => {
+    it('should have correct priority order', () => {
+      expect(SCHEMA_EXTENSIONS).toEqual(['.schema.ts', '.schema.mts', '.schema.cts']);
+    });
+  });
+});

package/src/schema-extensions.ts

@@ -0,0 +1,89 @@
+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,9 @@ 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 +71,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 +108,10 @@ 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('.')) {