flint-orm 0.1.0 → 0.2.0

package/dist/index.js

@@ -1144,6 +1144,9 @@ function flint(details) {
     avg: (table, column, condition) => avg(client, table, column, condition),
     min: (table, column, condition) => min(client, table, column, condition),
     max: (table, column, condition) => max(client, table, column, condition),
+    $run(sql, ...params) {
+      return client.prepare(sql).run(...params);
+    },
     $client: client
   };
 }
@@ -1329,7 +1332,7 @@ function real(name) {
   });
 }
 // src/schema/table.ts
-function table(name, columns) {
+function table(name, columns, indexFn) {
   const stamped = Object.create(null);
   for (const [key, col] of Object.entries(columns)) {
     const columnName = col.name || key;
@@ -1383,14 +1386,22 @@ function table(name, columns) {
     }
     stamped[key] = stampedCol;
   }
-  return Object.assign(stamped, {
+  const result = Object.assign(stamped, {
     _: { name }
   });
+  if (indexFn) {
+    const raw = indexFn(result);
+    if (raw.length > 0) {
+      const tableObj = result;
+      tableObj.__indexes = raw.map((item) => item.build());
+    }
+  }
+  return result;
 }
 function toSnakeCase(str) {
   return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 }
-function snakeCaseTable(tableName, columns) {
+function snakeCaseTable(tableName, columns, indexFn) {
   const converted = {};
   for (const [key, col] of Object.entries(columns)) {
     const sqlName = toSnakeCase(key);
@@ -1445,11 +1456,141 @@ function snakeCaseTable(tableName, columns) {
     }
     converted[key] = stampedCol;
   }
-  return table(tableName, converted);
+  return table(tableName, converted, indexFn);
 }
 var snakeCase = {
   table: snakeCaseTable
 };
+function index(name) {
+  let columns = [];
+  let isUnique = false;
+  const builder = {
+    on(...cols) {
+      columns = cols;
+      return builder;
+    },
+    unique() {
+      isUnique = true;
+      return builder;
+    },
+    build() {
+      if (columns.length === 0) {
+        throw new Error(`Index "${name}" has no columns \u2014 call .on() before returning`);
+      }
+      return {
+        name,
+        columns: columns.map((c) => c.name),
+        unique: isUnique
+      };
+    }
+  };
+  return builder;
+}
+// src/sqlite/introspect.ts
+var TEXT_TYPES = new Set(["text", "varchar", "character", "char", "clob", "native character", "nvarchar", "nchar", "nyclob", "numeric"]);
+var INTEGER_TYPES = new Set(["integer", "int", "smallint", "tinyint", "bigint", "unsigned big int", "int2", "int8", "mediumint"]);
+var REAL_TYPES = new Set(["real", "float", "double", "double precision", "decimal"]);
+function normalizeType(rawType) {
+  const t = rawType.toLowerCase().trim();
+  const base = t.replace(/\(.*\)/, "").trim();
+  if (INTEGER_TYPES.has(base))
+    return "integer";
+  if (REAL_TYPES.has(base))
+    return "real";
+  if (TEXT_TYPES.has(base))
+    return "text";
+  if (base === "blob")
+    return "blob";
+  return "text";
+}
+function parseDefault(dfltValue) {
+  if (dfltValue === null || dfltValue === undefined) {
+    return { hasDefault: false };
+  }
+  const raw = String(dfltValue);
+  if (raw.toUpperCase() === "NULL") {
+    return { hasDefault: true, defaultValue: null };
+  }
+  if (/^-?\d+$/.test(raw)) {
+    return { hasDefault: true, defaultValue: Number(raw) };
+  }
+  if (/^-?\d+\.\d+$/.test(raw)) {
+    return { hasDefault: true, defaultValue: Number(raw) };
+  }
+  if (raw.startsWith("'") && raw.endsWith("'") || raw.startsWith('"') && raw.endsWith('"')) {
+    return { hasDefault: true, defaultValue: raw.slice(1, -1) };
+  }
+  return { hasDefault: true, defaultValue: raw };
+}
+function introspectColumns(client, tableName) {
+  const rows = client.query(`PRAGMA table_info('${tableName}')`).all();
+  const fkRows = client.query(`PRAGMA foreign_key_list('${tableName}')`).all();
+  const indexRows = client.query(`PRAGMA index_list('${tableName}')`).all();
+  const fkMap = new Map;
+  for (const fk of fkRows) {
+    fkMap.set(fk.from, { referencesTable: fk.table, referencesColumn: fk.to });
+  }
+  const uniqueColumns = new Set;
+  for (const idx of indexRows) {
+    if (idx.unique === 1 && (idx.origin === "u" || idx.origin === "c")) {
+      const colInfo = client.query(`PRAGMA index_info('${idx.name}')`).all();
+      if (colInfo.length === 1) {
+        uniqueColumns.add(colInfo[0].name);
+      }
+    }
+  }
+  const columns = rows.map((row) => {
+    const fk = fkMap.get(row.name);
+    const { hasDefault, defaultValue } = parseDefault(row.dflt_value);
+    const col = {
+      name: row.name,
+      sqlType: normalizeType(row.type),
+      isPrimaryKey: row.pk === 1,
+      isNotNull: row.notnull === 1,
+      isUnique: uniqueColumns.has(row.name),
+      hasDefault,
+      defaultValue
+    };
+    if (fk) {
+      col.referencesTable = fk.referencesTable;
+      col.referencesColumn = fk.referencesColumn;
+    }
+    return col;
+  });
+  return { columns, indexRows };
+}
+function introspectIndexes(client, indexRows) {
+  const indexes = [];
+  for (const idx of indexRows) {
+    if (idx.name.startsWith("sqlite_autoindex_"))
+      continue;
+    const colRows = client.query(`PRAGMA index_info('${idx.name}')`).all();
+    const columns = colRows.map((c) => c.name);
+    indexes.push({
+      name: idx.name,
+      columns,
+      unique: idx.unique === 1
+    });
+  }
+  return indexes;
+}
+function introspect(client) {
+  const tableRows = client.query(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name != '__flint_migrations'`).all();
+  const tables = {};
+  for (const { name } of tableRows) {
+    const { columns, indexRows } = introspectColumns(client, name);
+    const indexes = introspectIndexes(client, indexRows);
+    tables[name] = {
+      name,
+      columns,
+      indexes
+    };
+  }
+  return {
+    version: 1,
+    tables
+  };
+}
 export {
   text,
   table,
@@ -1469,7 +1610,9 @@ export {
   isNotNull,
   isNotIn,
   isIn,
+  introspect,
   integer,
+  index,
   gte,
   gt,
   glob,

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "flint-orm",
-  "version": "0.1.0",
+  "version": "0.2.0",
+  "bin": {
+    "flint": "./src/cli.ts"
+  },
   "files": [
     "dist",
     "API.md",
@@ -21,10 +24,18 @@
     "./expressions": {
       "import": "./dist/entries/expressions.js",
       "types": "./dist/entries/expressions.d.ts"
+    },
+    "./config": {
+      "import": "./dist/entries/config.js",
+      "types": "./dist/entries/config.d.ts"
+    },
+    "./migration": {
+      "import": "./dist/src/migration/index.js",
+      "types": "./dist/src/migration/index.d.ts"
     }
   },
   "scripts": {
-    "build": "bun build ./src/index.ts ./src/entries/table.ts ./src/entries/expressions.ts --outdir ./dist --target bun && tsc --project tsconfig.build.json",
+    "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",
     "typecheck": "tsc --noEmit",
     "lint": "oxlint",
     "format": "oxfmt"

package/src/cli.ts

@@ -0,0 +1,306 @@
+#!/usr/bin/env bun
+// ---------------------------------------------------------------------------
+// flint CLI — migration generation for flint-orm
+// ---------------------------------------------------------------------------
+
+import { parseArgs } 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';
+
+// ---------------------------------------------------------------------------
+// Config loading
+// ---------------------------------------------------------------------------
+
+interface FlintConfig {
+  /** Path to the SQLite database file. */
+  url: string;
+  /** Path to schema file or directory. */
+  schema: string;
+  /** Path to migrations directory (default: ./flint). */
+  migrations?: string;
+}
+
+async function loadConfig(): Promise<FlintConfig> {
+  const configPath = resolve(process.cwd(), 'flint.config.ts');
+  const configUrl = pathToFileURL(configPath).href;
+  const mod = await import(configUrl);
+  return mod.default as FlintConfig;
+}
+
+// ---------------------------------------------------------------------------
+// Schema discovery — import table() exports from schema path
+// ---------------------------------------------------------------------------
+
+function isTableDef(value: unknown): boolean {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    '_' in value &&
+    typeof (value as Record<string, unknown>)._ === 'object' &&
+    typeof ((value as Record<string, Record<string, unknown>>)._ as Record<string, unknown>).name === 'string'
+  );
+}
+
+async function discoverTables(schemaPath: string): Promise<unknown[]> {
+  const abs = isAbsolute(schemaPath) ? schemaPath : resolve(process.cwd(), schemaPath);
+  const stat = statSync(abs);
+
+  if (stat.isFile()) {
+    return importTableFile(abs);
+  }
+
+  if (stat.isDirectory()) {
+    return importTableFolder(abs);
+  }
+
+  throw new Error(`Schema path does not exist: ${abs}`);
+}
+
+async function importTableFile(filePath: string): Promise<unknown[]> {
+  const url = pathToFileURL(filePath).href;
+  const mod = await import(url);
+  const tables: unknown[] = [];
+
+  for (const exportValue of Object.values(mod)) {
+    if (isTableDef(exportValue)) {
+      tables.push(exportValue);
+    }
+  }
+
+  return tables;
+}
+
+async function importTableFolder(folderPath: string): Promise<unknown[]> {
+  const entries = readdirSync(folderPath).filter((e) => e.endsWith('.ts'));
+  const tables: unknown[] = [];
+
+  for (const entry of entries) {
+    const filePath = join(folderPath, entry);
+    const discovered = await importTableFile(filePath);
+    tables.push(...discovered);
+  }
+
+  return tables;
+}
+
+// ---------------------------------------------------------------------------
+// Commands
+// ---------------------------------------------------------------------------
+
+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;
+
+  console.log(`🔍 Discovering schema from: ${config.schema}`);
+  const tables = await discoverTables(config.schema);
+
+  if (tables.length === 0) {
+    console.error('❌ 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'}`);
+  }
+
+  if (preview) {
+    // Dynamic import of migration functions
+    const { serializeSchema } = await import('./migration/serialize.js');
+    const { diffSchemas, emptyState } = await import('./migration/diff.js');
+    const { generateSQL } = await import('./migration/sql.js');
+
+    // Find latest state
+    const migrationsDir = resolve(process.cwd(), config.migrations ?? './flint');
+    let previousState: SchemaState | null = null;
+    if (existsSync(migrationsDir)) {
+      const folders = readdirSync(migrationsDir)
+        .filter((e) => /^\d{10}_/.test(e))
+        .sort()
+        .reverse();
+      for (const folder of folders) {
+        const statePath = join(migrationsDir, folder, 'state.json');
+        if (existsSync(statePath)) {
+          previousState = JSON.parse(readFileSync(statePath, 'utf-8'));
+          break;
+        }
+      }
+    }
+    if (!previousState) previousState = emptyState();
+
+    const currentState = serializeSchema(tables as AnyTable[]);
+    const operations = diffSchemas(previousState, currentState);
+
+    if (operations.length === 0) {
+      console.log('\n✅ No changes detected — schema is already up to date.');
+      return;
+    }
+
+    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)');
+    return;
+  }
+
+  // Dynamic import of the generate function
+  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}`);
+  } 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.');
+    } else {
+      throw err;
+    }
+  }
+}
+
+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);
+
+  try {
+    if (statusOnly) {
+      const status = getMigrationStatus(db, migrationsDir);
+
+      if (status.applied.length === 0 && status.pending.length === 0) {
+        console.log('✅ No migrations found.');
+        return;
+      }
+
+      if (status.applied.length > 0) {
+        console.log('\n📋 Applied migrations:');
+        for (const m of status.applied) {
+          console.log(`   ✓ ${m.name} (${m.folderName})`);
+        }
+      }
+
+      if (status.pending.length > 0) {
+        console.log('\n⏳ Pending migrations:');
+        for (const m of status.pending) {
+          console.log(`   ○ ${m.name} (${m.folderName})`);
+        }
+      }
+
+      console.log(`\n   ${status.applied.length} applied, ${status.pending.length} pending`);
+      return;
+    }
+
+    const result = await migrate(db, {
+      migrationsDir,
+      dryRun,
+    });
+
+    if (result.applied.length === 0) {
+      console.log('\n✅ 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}`);
+      }
+    }
+
+    if (result.skipped.length > 0 && !dryRun) {
+      console.log(`\n⏭  Skipped ${result.skipped.length} already applied migration(s)`);
+    }
+  } finally {
+    db.close();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Help
+// ---------------------------------------------------------------------------
+
+function printHelp(): void {
+  console.log(`
+flint — migration CLI for flint-orm
+
+Usage:
+  flint <command> [options]
+
+Commands:
+  generate   Generate a new migration from schema changes
+  migrate    Apply pending migrations to the database
+
+Options for generate:
+  --name <name>     Migration name (optional)
+  --preview         Show what would be generated without writing files
+
+Options for migrate:
+  --status          Show applied and pending migrations
+  --dry-run         Show what would be applied without executing
+  --name <name>     Apply only the named migration
+
+Examples:
+  flint generate --name init_schema
+  flint generate --preview
+  flint migrate
+  flint migrate --status
+  flint migrate --dry-run
+`);
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main(): Promise<void> {
+  const { values, positionals } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+      name: { type: 'string', short: 'n' },
+      preview: { type: 'boolean', short: 'p' },
+      help: { type: 'boolean', short: 'h' },
+      status: { type: 'boolean', short: 's' },
+      'dry-run': { type: 'boolean', short: 'd' },
+    },
+    allowPositionals: true,
+  });
+
+  if (values.help || positionals.length === 0) {
+    printHelp();
+    process.exit(0);
+  }
+
+  const command = positionals[0];
+  const config = await loadConfig();
+
+  switch (command) {
+    case 'generate':
+      await cmdGenerate(values, config);
+      break;
+    case 'migrate':
+      await cmdMigrate(values, config);
+      break;
+    default:
+      console.error(`❌ Unknown command: ${command}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/dist/entries/expressions.d.ts

@@ -1,5 +0,0 @@
-export { eq, and, or, gt, gte, lt, lte, neq, isIn, isNotIn, isNull, isNotNull, like, glob, between } from '../query/conditions';
-export type { Condition } from '../query/conditions';
-export { sql } from '../flint';
-export type { SQLExpression } from '../flint';
-export { count, countColumn, sum, avg, min, max } from '../query/aggregates';