flint-orm 0.2.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flint-orm",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "bin": {
     "flint": "./src/cli.ts"
   },
@@ -10,42 +10,77 @@
     "README.md"
   ],
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./dist/src/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
+      "import": "./dist/src/index.js",
       "types": "./dist/index.d.ts"
     },
+    "./bun-sqlite": {
+      "import": "./dist/src/entries/bun-sqlite.js",
+      "types": "./dist/entries/bun-sqlite.d.ts"
+    },
+    "./better-sqlite3": {
+      "import": "./dist/src/entries/better-sqlite3.js",
+      "types": "./dist/entries/better-sqlite3.d.ts"
+    },
+    "./libsql": {
+      "import": "./dist/src/entries/libsql.js",
+      "types": "./dist/entries/libsql.d.ts"
+    },
+    "./libsql-web": {
+      "import": "./dist/src/entries/libsql-web.js",
+      "types": "./dist/entries/libsql-web.d.ts"
+    },
+    "./turso-sync": {
+      "import": "./dist/src/entries/turso-sync.js",
+      "types": "./dist/entries/turso-sync.d.ts"
+    },
+    "./turso": {
+      "import": "./dist/src/entries/turso.js",
+      "types": "./dist/entries/turso.d.ts"
+    },
     "./table": {
-      "import": "./dist/entries/table.js",
+      "import": "./dist/src/entries/table.js",
       "types": "./dist/entries/table.d.ts"
     },
     "./expressions": {
-      "import": "./dist/entries/expressions.js",
+      "import": "./dist/src/entries/expressions.js",
       "types": "./dist/entries/expressions.d.ts"
     },
     "./config": {
-      "import": "./dist/entries/config.js",
+      "import": "./dist/src/entries/config.js",
       "types": "./dist/entries/config.d.ts"
     },
     "./migration": {
       "import": "./dist/src/migration/index.js",
-      "types": "./dist/src/migration/index.d.ts"
+      "types": "./dist/migration/index.d.ts"
     }
   },
   "scripts": {
-    "build": "bun build ./src/index.ts ./src/entries/table.ts ./src/entries/expressions.ts ./src/entries/config.ts --outdir ./dist --target bun && tsc --project tsconfig.build.json",
+    "build": "bun build ./src/index.ts ./src/entries/bun-sqlite.ts ./src/entries/better-sqlite3.ts ./src/entries/libsql.ts ./src/entries/libsql-web.ts ./src/entries/turso-sync.ts ./src/entries/turso.ts ./src/entries/table.ts ./src/entries/expressions.ts ./src/entries/config.ts ./src/migration/index.ts --outdir ./dist --target bun && tsc --project tsconfig.build.json",
     "typecheck": "tsc --noEmit",
-    "lint": "oxlint",
-    "format": "oxfmt"
+    "lint": "oxlint --fix",
+    "format": "oxfmt --write",
+    "check": "oxlint && oxfmt"
+  },
+  "dependencies": {
+    "@clack/prompts": "1.7.0",
+    "@libsql/client": "0.17.4",
+    "@tursodatabase/database": "0.6.1",
+    "@tursodatabase/sync": "0.6.1",
+    "better-sqlite3": "12.11.1",
+    "picocolors": "1.1.1"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "7.6.13",
     "@types/bun": "1.3.14",
+    "@types/node": "26.1.1",
     "oxfmt": "0.57.0",
     "oxlint": "1.72.0"
   },
   "peerDependencies": {
-    "typescript": "7.0.1-rc"
+    "typescript": "7.0.2"
   }
 }

package/src/cli.ts

@@ -3,20 +3,26 @@
 // flint CLI — migration generation for flint-orm
 // ---------------------------------------------------------------------------
 
-import { parseArgs } from 'node:util';
+import { parseArgs, styleText } from 'node:util';
 import { statSync, readdirSync, existsSync, readFileSync } from 'node:fs';
 import { join, resolve, isAbsolute } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import type { AnyTable, TableDef } from './schema/table.js';
 import type { SchemaState } from './migration/types.js';
+import { outro, log, cancel, isCancel, select, pc, note } from './cli/ui.js';
+import { CancellationError } from './migration/diff.js';
+import type { RenamePrompt } from './migration/diff.js';
+import type { Executor } from './executor.js';
 
 // ---------------------------------------------------------------------------
 // Config loading
 // ---------------------------------------------------------------------------
 
 interface FlintConfig {
-  /** Path to the SQLite database file. */
-  url: string;
+  /** Which SQLite driver to use. */
+  driver: string;
+  /** Database connection details. */
+  database: { url: string; authToken?: string };
   /** Path to schema file or directory. */
   schema: string;
   /** Path to migrations directory (default: ./flint). */
@@ -93,24 +99,22 @@ async function importTableFolder(folderPath: string): Promise<unknown[]> {
 async function cmdGenerate(args: ReturnType<typeof parseArgs>['values'], config: FlintConfig): Promise<void> {
   const name = typeof args.name === 'string' ? args.name : undefined;
   const preview = args.preview === true;
+  const promptRename: RenamePrompt = (message, options) => select({ message: pc.bold(message), options }) as Promise<string | symbol>;
 
-  console.log(`🔍 Discovering schema from: ${config.schema}`);
+  log.info(`Discovering schema from: ${config.schema}`);
   const tables = await discoverTables(config.schema);
 
   if (tables.length === 0) {
-    console.error('❌ No table() definitions found in schema path.');
+    cancel('No table() definitions found in schema path.');
     process.exit(1);
   }
 
-  console.log(`📦 Found ${tables.length} table(s):`);
-  for (const t of tables) {
-    console.log(`   - ${(t as Record<string, Record<string, unknown>>)._?.name ?? 'unknown'}`);
-  }
+  log.info(`Found ${tables.length} table(s): ${tables.map((t) => (t as Record<string, Record<string, unknown>>)._?.name ?? 'unknown').join(', ')}`);
 
   if (preview) {
     // Dynamic import of migration functions
     const { serializeSchema } = await import('./migration/serialize.js');
-    const { diffSchemas, emptyState } = await import('./migration/diff.js');
+    const { diffSchemas, emptyState, resolveRenames } = await import('./migration/diff.js');
     const { generateSQL } = await import('./migration/sql.js');
 
     // Find latest state
@@ -132,20 +136,20 @@ async function cmdGenerate(args: ReturnType<typeof parseArgs>['values'], config:
     if (!previousState) previousState = emptyState();
 
     const currentState = serializeSchema(tables as AnyTable[]);
-    const operations = diffSchemas(previousState, currentState);
+    const rawOps = diffSchemas(previousState, currentState);
 
-    if (operations.length === 0) {
-      console.log('\n✅ No changes detected — schema is already up to date.');
+    if (rawOps.length === 0) {
+      outro('Schema is already up to date.');
       return;
     }
 
+    // Resolve renames interactively
+    const operations = await resolveRenames(rawOps, { interactive: true, prompt: promptRename });
+
     const sql = generateSQL(operations);
-    const previewLabel = name ? `${name}` : 'unnamed';
-    console.log(`\n--- Preview: ${previewLabel} ---`);
-    console.log(`   Operations: ${operations.length}`);
-    console.log(`   Migrations dir: ${config.migrations}`);
-    console.log(`\n--- SQL ---\n${sql}\n`);
-    console.log('(dry run, no files written)');
+    log.info(`Operations: ${operations.length}`);
+    note(sql, 'SQL', { format: (text) => styleText('dim', text) });
+    log.info('(dry run, no files written)');
     return;
   }
 
@@ -153,13 +157,18 @@ async function cmdGenerate(args: ReturnType<typeof parseArgs>['values'], config:
   const { generate } = await import('./migration/generate.js');
 
   try {
-    const result = generate(tables as TableDef<any>[], resolve(process.cwd(), (config.migrations ?? './flint') as string), name);
-    console.log(`\n✅ Migration generated: ${result.folderName}`);
-    console.log(`   Operations: ${result.operations.length}`);
-    console.log(`\n--- SQL Preview ---\n${result.sql}`);
+    const migrationsDir = resolve(process.cwd(), config.migrations ?? './flint');
+    const result = await generate(tables as TableDef<any>[], migrationsDir, {
+      name,
+      interactive: true,
+      prompt: promptRename,
+    });
+    log.info(`Operations: ${result.operations.length}`);
+    note(result.sql, 'SQL', { format: (text) => styleText('dim', text) });
+    log.success(`Migration generated: ${migrationsDir}/${result.folderName}`);
   } catch (err: unknown) {
     if (err instanceof Error && err.message.includes('No changes detected')) {
-      console.log('\n✅ No changes detected — schema is already up to date.');
+      outro('Schema is already up to date.');
     } else {
       throw err;
     }
@@ -167,64 +176,108 @@ async function cmdGenerate(args: ReturnType<typeof parseArgs>['values'], config:
 }
 
 async function cmdMigrate(args: ReturnType<typeof parseArgs>['values'], config: FlintConfig): Promise<void> {
-  const { Database } = await import('bun:sqlite');
   const { migrate, getMigrationStatus } = await import('./migration/migrate.js');
 
   const migrationsDir = resolve(process.cwd(), config.migrations ?? './flint');
   const dryRun = args['dry-run'] === true;
   const statusOnly = args.status === true;
-  const name = typeof args.name === 'string' ? args.name : undefined;
 
-  // Open database from config
-  const dbUrl = resolve(process.cwd(), config.url);
-  const db = new Database(dbUrl);
+  // Dynamically create executor based on configured driver
+  const isLocalDriver = config.driver === 'bun-sqlite' || config.driver === 'better-sqlite3';
+  const dbUrl = isLocalDriver ? resolve(process.cwd(), config.database.url) : config.database.url;
+
+  let executor: Executor;
+
+  switch (config.driver) {
+    case 'bun-sqlite': {
+      const { BunSqliteExecutor } = await import('./drivers/bun-sqlite');
+      const { Database } = await import('bun:sqlite');
+      executor = new BunSqliteExecutor(new Database(dbUrl));
+      break;
+    }
+    case 'better-sqlite3': {
+      const { BetterSqlite3Executor } = await import('./drivers/better-sqlite3');
+      const Database = (await import('better-sqlite3')).default;
+      executor = new BetterSqlite3Executor(new Database(dbUrl));
+      break;
+    }
+    case 'libsql': {
+      const { LibsqlExecutor } = await import('./drivers/libsql');
+      const { createClient: createLibsqlClient } = await import('@libsql/client');
+      executor = new LibsqlExecutor(createLibsqlClient({ url: dbUrl, authToken: config.database.authToken }));
+      break;
+    }
+    case 'libsql-web': {
+      const { LibsqlWebExecutor } = await import('./drivers/libsql-web');
+      const { createClient: createLibsqlWebClient } = await import('@libsql/client/web');
+      executor = new LibsqlWebExecutor(createLibsqlWebClient({ url: dbUrl, authToken: config.database.authToken }));
+      break;
+    }
+    case 'turso-sync': {
+      const { TursoSyncExecutor } = await import('./drivers/turso-sync');
+      const { connect } = await import('@tursodatabase/sync');
+      const db = await connect({ path: dbUrl, authToken: config.database.authToken });
+      executor = new TursoSyncExecutor(db);
+      break;
+    }
+    case 'turso': {
+      const { TursoExecutor } = await import('./drivers/turso');
+      const { connect } = await import('@tursodatabase/database');
+      const db = await connect(dbUrl);
+      executor = new TursoExecutor(db);
+      break;
+    }
+    default:
+      cancel(`Unsupported driver: ${config.driver}`);
+      process.exit(1);
+  }
 
   try {
     if (statusOnly) {
-      const status = getMigrationStatus(db, migrationsDir);
+      const status = await getMigrationStatus(executor, migrationsDir);
 
       if (status.applied.length === 0 && status.pending.length === 0) {
-        console.log('✅ No migrations found.');
+        outro('No migrations found.');
         return;
       }
 
       if (status.applied.length > 0) {
-        console.log('\n📋 Applied migrations:');
+        log.info('Applied migrations:');
         for (const m of status.applied) {
-          console.log(`   ✓ ${m.name} (${m.folderName})`);
+          log.success(`${m.name} (${m.folderName})`);
         }
       }
 
       if (status.pending.length > 0) {
-        console.log('\n⏳ Pending migrations:');
+        log.warn('Pending migrations:');
         for (const m of status.pending) {
-          console.log(`   ○ ${m.name} (${m.folderName})`);
+          log.message(`  ○ ${m.name} (${m.folderName})`);
         }
       }
 
-      console.log(`\n   ${status.applied.length} applied, ${status.pending.length} pending`);
+      log.info(`${status.applied.length} applied, ${status.pending.length} pending`);
       return;
     }
 
-    const result = await migrate(db, {
+    const result = await migrate(executor, {
       migrationsDir,
       dryRun,
     });
 
     if (result.applied.length === 0) {
-      console.log('\n✅ No pending migrations — database is up to date.');
+      outro('No pending migrations — database is up to date.');
     } else {
-      console.log(`\n🚀 ${dryRun ? 'Would apply' : 'Applied'} ${result.applied.length} migration(s):`);
-      for (const name of result.applied) {
-        console.log(`   ✓ ${name}`);
+      log.info(`${dryRun ? 'Would apply' : 'Applied'} ${result.applied.length} migration(s):`);
+      for (const appliedName of result.applied) {
+        log.success(appliedName);
       }
     }
 
     if (result.skipped.length > 0 && !dryRun) {
-      console.log(`\n⏭  Skipped ${result.skipped.length} already applied migration(s)`);
+      log.info(`Skipped ${result.skipped.length} already applied migration(s)`);
     }
   } finally {
-    db.close();
+    executor.close();
   }
 }
 
@@ -233,9 +286,7 @@ async function cmdMigrate(args: ReturnType<typeof parseArgs>['values'], config:
 // ---------------------------------------------------------------------------
 
 function printHelp(): void {
-  console.log(`
-flint — migration CLI for flint-orm
-
+  log.message(`
 Usage:
   flint <command> [options]
 
@@ -294,13 +345,17 @@ async function main(): Promise<void> {
       await cmdMigrate(values, config);
       break;
     default:
-      console.error(`❌ Unknown command: ${command}`);
+      cancel(`Unknown command: ${command}`);
       printHelp();
       process.exit(1);
   }
 }
 
 main().catch((err) => {
-  console.error(err);
+  if (isCancel(err) || err instanceof CancellationError) {
+    cancel('Operation cancelled.');
+  } else {
+    cancel(err.message ?? 'An error occurred');
+  }
   process.exit(1);
 });