stabilize-orm 1.1.4 → 1.1.5

package/index.ts

@@ -1,8 +1,8 @@
-
 /**
  * @file stabilize.ts
  * @description The main entry point for the Stabilize ORM, tying together the client, cache, and repositories.
  * @author ElectronSz
+ * @date 2025-10-15 20:35:34
  */
 import { Cache } from "./cache";
 import { DBClient } from "./client";
@@ -31,6 +31,7 @@ import {
   type CacheConfig,
   type LoggerConfig,
   DBType,
+  DataTypes, // --- FIX: Import DataTypes here ---
   StabilizeError,
   type PoolMetrics,
   type QueryHint,
@@ -149,6 +150,7 @@ export {
   Cache,
   ConsoleLogger,
   DBType,
+  DataTypes, 
   LogLevel,
   RelationType,
   StabilizeError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stabilize-orm",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "description": "A lightweight, type-safe ORM for Bun.js with support for SQLite, MySQL, PostgreSQL, and Redis caching",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/cli/stabilize-cli.ts

@@ -1,431 +0,0 @@
-#!/usr/bin/env bun
-/**
- * @file stabilize-cli.ts
- * @description The command-line interface for the Stabilize ORM.
- * @author ElectronSz
- */
-
-import 'reflect-metadata';
-
-import { program } from "commander";
-import { generateMigration, runMigrations, Stabilize, ModelKey, DBClient } from "../";
-import { LogLevel, type DBConfig, type LoggerConfig, DBType, type Migration } from "../types";
-import * as fs from "fs/promises";
-import * as path from "path";
-import { glob } from "glob";
-import readline from "readline";
-
-// --- CLI UI Toolkit ---
-const C = {
-  RESET: "\x1b[0m", BRIGHT: "\x1b[1m", DIM: "\x1b[2m",
-  RED: "\x1b[31m", GREEN: "\x1b[32m", YELLOW: "\x1b[33m", BLUE: "\x1b[34m",
-  MAGENTA: "\x1b[35m", CYAN: "\x1b[36m", WHITE: "\x1b[37m",
-  BG_GREEN: "\x1b[42m\x1b[30m", BG_RED: "\x1b[41m\x1b[37m", BG_YELLOW: "\x1b[43m\x1b[30m",
-};
-
-const CLILogger = {
-  info: (message: string) => console.log(`${C.BLUE}ℹ${C.RESET} ${message}`),
-  success: (message: string) => console.log(`${C.GREEN}✔${C.RESET} ${C.GREEN}${message}${C.RESET}`),
-  warn: (message: string) => console.log(`${C.YELLOW}⚠${C.RESET} ${message}`),
-  error: (message: string, details?: string) => {
-    console.error(`\n${C.BG_RED} ERROR ${C.RESET} ${C.RED}${message}${C.RESET}`);
-    if (details) console.error(`${C.DIM}${details}${C.RESET}`);
-    console.log();
-  },
-  panic: (error: Error, command: string) => {
-    CLILogger.error(`A fatal error occurred in the '${command}' command.`, error.stack);
-    process.exit(1);
-  },
-};
-
-const spinner = {
-  chars: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
-  interval: 80,
-  _timer: null as Timer | null,
-  start: (message: string) => {
-    let i = 0;
-    process.stdout.write("\n");
-    spinner._timer = setInterval(() => {
-      process.stdout.write(`\r${C.CYAN}${spinner.chars[i++ % spinner.chars.length]}${C.RESET} ${message}`);
-    }, spinner.interval);
-  },
-  stop: (success: boolean, message: string) => {
-    if (spinner._timer) clearInterval(spinner._timer);
-    process.stdout.write(`\r${success ? `${C.GREEN}✔` : `${C.RED}✖`} ${message}\n\n`);
-  },
-};
-
-// --- Core CLI Logic ---
-
-async function loadConfig(configPath: string): Promise<{ config: DBConfig; orm: Stabilize }> {
-  try {
-    const absoluteConfigPath = path.resolve(process.cwd(), configPath);
-    const configModule = await import(absoluteConfigPath);
-    const config: DBConfig = configModule.default || configModule;
-    const logLevelKey = program.opts().logLevel as keyof typeof LogLevel;
-    const loggerConfig: LoggerConfig = { level: LogLevel[logLevelKey] };
-    const orm = new Stabilize(config, { enabled: false, ttl: 60 }, loggerConfig);
-    return { config, orm };
-  } catch (error) {
-    throw new Error(`Failed to load database configuration from '${configPath}'. Make sure the file exists and is valid.`);
-  }
-}
-
-async function confirm(question: string): Promise<boolean> {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(`${C.YELLOW}⚠${C.RESET} ${question} ${C.DIM}(y/N)${C.RESET} `, (answer) => {
-      rl.close();
-      resolve(answer.toLowerCase() === 'y');
-    });
-  });
-}
-
-// --------------------------------------------------------------------------------------------------
-// COMMAND: GENERATE
-// --------------------------------------------------------------------------------------------------
-program
-  .command("generate <type> <name>")
-  .description("Generate a new model, migration, or seed file.")
-  .action(async (type: string, name: string) => {
-    const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
-    try {
-      if (type === "migration") {
-        const modelPath = path.resolve(process.cwd(), "models", `${name}.ts`);
-        const { config } = await loadConfig("config/database.ts");
-        const modelModule = await import(modelPath).catch(() => { throw new Error(`Model file not found at '${modelPath}'.`); });
-        const modelClass = modelModule[capitalizedName];
-        if (!modelClass || !Reflect.getMetadata(ModelKey, modelClass)) {
-          throw new Error(`Class '${capitalizedName}' in '${modelPath}' is not a valid @Model.`);
-        }
-        const migration = await generateMigration(modelClass, `create_${name}_table`, config.type);
-        const migrationDir = path.resolve(process.cwd(), "migrations");
-        await fs.mkdir(migrationDir, { recursive: true });
-        const timestamp = new Date().toISOString().replace(/[-:T.]/g, "").slice(0, 14);
-        const fileName = `${timestamp}_create_${name}_table.json`;
-        migration.name = path.basename(fileName, ".json");
-        const filePath = path.join(migrationDir, fileName);
-        await fs.writeFile(filePath, JSON.stringify(migration, null, 2));
-        CLILogger.success(`Migration generated: ${filePath}`);
-      } else if (type === "model") {
-        const modelDir = path.resolve(process.cwd(), "models");
-        await fs.mkdir(modelDir, { recursive: true });
-        const filePath = path.join(modelDir, `${name}.ts`);
-        const content = `
-              import 'reflect-metadata';
-              import { Model, Column, DataTypes } from 'stabilize-orm';
-
-              @Model('${name.toLowerCase()}s')
-              export class ${capitalizedName} {
-                @Column({ type: DataTypes.INTEGER, name: 'id' })
-                id!: number;
-
-                @Column({ type: DataTypes.STRING, length: 100 })
-                name!: string;
-
-                @Column({ type: DataTypes.DATETIME, name: 'created_at' })
-                createdAt!: Date;
-
-                @Column({ type: DataTypes.DATETIME, name: 'updated_at' })
-                updatedAt!: Date;
-              }
-          `.trim() + "\n";
-        await fs.writeFile(filePath, content);
-        CLILogger.success(`Model generated: ${filePath}`);
-      } else if (type === "seed") {
-        const seedDir = path.resolve(process.cwd(), "seeds");
-        await fs.mkdir(seedDir, { recursive: true });
-        const timestamp = new Date().toISOString().replace(/[-:T.]/g, "").slice(0, 14);
-        const fileName = `${timestamp}_${name}.ts`;
-        const filePath = path.join(seedDir, fileName);
-        const content = `
-            import { Stabilize } from 'stabilize-orm';
-            import { ${capitalizedName} } from './models/${name}';
-
-            export const dependencies: string[] = [];
-
-            export async function seed(orm: Stabilize): Promise<void> {
-              const repo = orm.getRepository(${capitalizedName});
-              await repo.bulkCreate([
-                { name: '${capitalizedName} One' },
-                { name: '${capitalizedName} Two' },
-              ]);
-            }
-
-            export async function rollback(orm: Stabilize): Promise<void> {
-              await orm.client.query('DELETE FROM ${name.toLowerCase()}s WHERE name LIKE ?', ['${capitalizedName} %']);
-            }
-      `.trim() + "\n";
-        await fs.writeFile(filePath, content);
-        CLILogger.success(`Seed generated: ${filePath}`);
-      } else {
-        CLILogger.error(`Invalid type '${type}'. Use 'model', 'migration', or 'seed'.`);
-      }
-    } catch (error) {
-      CLILogger.panic(error as Error, "generate");
-    }
-  });
-
-// --------------------------------------------------------------------------------------------------
-// COMMANDS: MIGRATE & ROLLBACK
-// --------------------------------------------------------------------------------------------------
-program
-  .command("migrate")
-  .description("Apply all pending database migrations.")
-  .option("-c, --config <path>", "Path to database config file", "config/database.ts")
-  .action(async (options) => {
-    let orm: Stabilize | null = null;
-    try {
-      const { orm: loadedOrm, config } = await loadConfig(options.config);
-      orm = loadedOrm;
-      const migrationDir = path.resolve(process.cwd(), "migrations");
-      const migrationFiles = (await glob(`${migrationDir}/*.json`)).sort();
-      const migrations: Migration[] = await Promise.all(
-        migrationFiles.map(async file => JSON.parse(await fs.readFile(file, 'utf-8')))
-      );
-      if (migrations.length === 0) {
-        CLILogger.warn("No migration files found.");
-        return;
-      }
-      spinner.start("Applying migrations...");
-      await runMigrations(config, migrations);
-      spinner.stop(true, "All pending migrations applied.");
-    } catch (error) {
-      spinner.stop(false, "Migration process failed.");
-      CLILogger.panic(error as Error, "migrate");
-    } finally {
-      if (orm) await orm.close();
-    }
-  });
-
-program
-  .command("migrate:rollback")
-  .description("Roll back the most recently applied migration.")
-  .option("-c, --config <path>", "Path to database config file", "config/database.ts")
-  .action(async (options) => {
-    let orm: Stabilize | null = null;
-    try {
-      const { orm: loadedOrm } = await loadConfig(options.config);
-      orm = loadedOrm;
-      spinner.start("Rolling back last migration...");
-      const [latest] = await orm.client.query<{ name: string }>(`SELECT name FROM migrations ORDER BY applied_at DESC, name DESC LIMIT 1`);
-      if (!latest) {
-        spinner.stop(false, "No migrations to roll back.");
-        return;
-      }
-      const migrationFile = path.resolve(process.cwd(), "migrations", `${latest.name}.json`);
-      const migration: Migration = JSON.parse(await fs.readFile(migrationFile, 'utf-8'));
-      await orm.transaction(async (txClient) => {
-        for (const query of migration.down) await txClient.query(query);
-        await txClient.query(`DELETE FROM migrations WHERE name = ?`, [latest.name]);
-      });
-      spinner.stop(true, `Rolled back: ${latest.name}`);
-    } catch (error) {
-      spinner.stop(false, "Rollback failed.");
-      CLILogger.panic(error as Error, "migrate:rollback");
-    } finally {
-      if (orm) await orm.close();
-    }
-  });
-
-// --------------------------------------------------------------------------------------------------
-// COMMANDS: SEED & ROLLBACK
-// --------------------------------------------------------------------------------------------------
-program
-    .command("seed")
-    .description("Run all pending seed files.")
-    .option("-c, --config <path>", "Path to db config file", "config/database.ts")
-    .action(async (options) => {
-        let orm: Stabilize | null = null;
-        try {
-            const { orm: loadedOrm } = await loadConfig(options.config);
-            orm = loadedOrm;
-            await orm.client.query(`CREATE TABLE IF NOT EXISTS seed_history (name TEXT PRIMARY KEY, applied_at TEXT NOT NULL)`);
-            const seedDir = path.resolve(process.cwd(), "seeds");
-            const seedFiles = await glob(`${seedDir}/*.ts`);
-            const graph = new Map<string, { file: string; dependencies: string[] }>();
-            for (const file of seedFiles) {
-                const name = path.basename(file, ".ts");
-                const mod = await import(file);
-                graph.set(name, { file, dependencies: mod.dependencies || [] });
-            }
-            const orderedSeeds = topologicalSort(graph);
-            const appliedSeeds = new Set((await orm.client.query<{ name: string }>(`SELECT name FROM seed_history`)).map(r => r.name));
-            const pendingSeeds = orderedSeeds.filter(s => !appliedSeeds.has(s));
-            if (pendingSeeds.length === 0) {
-                CLILogger.warn("No pending seeds to run.");
-                return;
-            }
-            spinner.start(`Running ${pendingSeeds.length} seed(s)...`);
-            for (const seedName of pendingSeeds) {
-                const mod = await import(graph.get(seedName)!.file);
-                await orm.transaction(async (txClient) => {
-                    const txOrm = new Stabilize(orm!.client.config, { enabled: false, ttl: 60 }, { level: LogLevel.Error }, txClient);
-                    await mod.seed(txOrm);
-                    await txClient.query(`INSERT INTO seed_history (name, applied_at) VALUES (?, ?)`, [seedName, new Date().toISOString()]);
-                });
-            }
-            spinner.stop(true, `Successfully applied ${pendingSeeds.length} seed(s).`);
-        } catch (error) {
-            spinner.stop(false, "Seeding process failed.");
-            CLILogger.panic(error as Error, "seed");
-        } finally {
-            if (orm) await orm.close();
-        }
-    });
-
-program
-    .command("seed:rollback")
-    .description("Roll back the most recently applied seed.")
-    .option("-c, --config <path>", "Path to db config file", "config/database.ts")
-    .action(async (options) => {
-        let orm: Stabilize | null = null;
-        try {
-            const { orm: loadedOrm } = await loadConfig(options.config);
-            orm = loadedOrm;
-            spinner.start("Rolling back last seed...");
-            const [latest] = await orm!.client.query<{ name: string }>(`SELECT name FROM seed_history ORDER BY applied_at DESC, name DESC LIMIT 1`);
-            if (!latest) {
-                spinner.stop(false, "No seeds to roll back.");
-                return;
-            }
-            const seedFile = path.resolve(process.cwd(), "seeds", `${latest.name}.ts`);
-            const mod = await import(seedFile);
-            if (typeof mod.rollback !== 'function') {
-                throw new Error(`Rollback function not found in '${latest.name}.ts'`);
-            }
-            await orm.transaction(async (txClient) => {
-                const txOrm = new Stabilize(orm!.client.config, { enabled: false, ttl: 60 }, { level: LogLevel.Error });
-                await mod.rollback(txOrm);
-                await txClient.query(`DELETE FROM seed_history WHERE name = ?`, [latest.name]);
-            });
-            spinner.stop(true, `Rolled back seed: ${latest.name}`);
-        } catch (error) {
-            spinner.stop(false, "Seed rollback failed.");
-            CLILogger.panic(error as Error, "seed:rollback");
-        } finally {
-            if (orm) await orm.close();
-        }
-    });
-
-// --------------------------------------------------------------------------------------------------
-// COMMANDS: DB & STATUS
-// --------------------------------------------------------------------------------------------------
-program
-  .command("db:drop")
-  .description("Drop the database. USE WITH CAUTION.")
-  .option("-c, --config <path>", "Path to db config file", "config/database.ts")
-  .action(async (options) => {
-    try {
-      const { config } = await loadConfig(options.config);
-      const dbName = new URL(config.connectionString).pathname.substring(1);
-      if (!await confirm(`This will permanently delete the '${dbName}' database. Are you sure?`)) {
-        CLILogger.warn("Database drop cancelled.");
-        return;
-      }
-      spinner.start(`Dropping database '${dbName}'...`);
-      if (config.type === DBType.SQLite) {
-        await fs.unlink(dbName).catch(() => {});
-      } else {
-        const adminConfig = { ...config };
-        const url = new URL(adminConfig.connectionString);
-        url.pathname = config.type === DBType.Postgres ? '/postgres' : '';
-        adminConfig.connectionString = url.toString();
-        const adminOrm = new Stabilize(adminConfig);
-        await adminOrm.client.query(`DROP DATABASE IF EXISTS "${dbName}"`);
-        await adminOrm.close();
-      }
-      spinner.stop(true, `Database '${dbName}' dropped successfully.`);
-    } catch (error) {
-      spinner.stop(false, "Failed to drop database.");
-      CLILogger.panic(error as Error, "db:drop");
-    }
-  });
-
-program
-  .command("db:reset")
-  .description("Drop, create, migrate, and seed the database.")
-  .option("-c, --config <path>", "Path to db config file", "config/database.ts")
-  .action(async (options) => {
-    CLILogger.warn("This command will destroy and rebuild your database.");
-    try {
-      await program.commands.find(c => c.name() === 'db:drop')?.parseAsync(process.argv, { from: 'user' });
-      CLILogger.info("Creating database... (This is handled automatically by the driver on first connection)");
-      await program.commands.find(c => c.name() === 'migrate')?.parseAsync(process.argv, { from: 'user' });
-      await program.commands.find(c => c.name() === 'seed')?.parseAsync(process.argv, { from: 'user' });
-      CLILogger.success("Database reset complete.");
-    } catch (error) {
-      CLILogger.panic(error as Error, "db:reset");
-    }
-  });
-
-program
-  .command("status")
-  .description("Show the status of all migrations and seeds.")
-  .option("-c, --config <path>", "Path to db config file", "config/database.ts")
-  .action(async (options) => {
-    let orm: Stabilize | null = null;
-    try {
-      const { orm: loadedOrm } = await loadConfig(options.config);
-      orm = loadedOrm;
-      await orm.client.query(`CREATE TABLE IF NOT EXISTS migrations (name TEXT PRIMARY KEY, applied_at TEXT)`);
-      await orm.client.query(`CREATE TABLE IF NOT EXISTS seed_history (name TEXT PRIMARY KEY, applied_at TEXT)`);
-
-      console.log(`\n${C.BRIGHT}Migration Status${C.RESET}`);
-      console.log(`---------------------------------`);
-      const migrationFiles = (await glob(`migrations/*.json`)).map(f => path.basename(f, ".json")).sort();
-      const appliedMigrations = new Set((await orm.client.query<{ name: string }>(`SELECT name FROM migrations`)).map(r => r.name));
-      migrationFiles.forEach(name => {
-        const status = appliedMigrations.has(name) ? `${C.BG_GREEN} APPLIED ${C.RESET}` : `${C.BG_YELLOW} PENDING ${C.RESET}`;
-        console.log(`${status} ${C.WHITE}${name}${C.RESET}`);
-      });
-      if (migrationFiles.length === 0) console.log(C.DIM + "  No migration files found." + C.RESET);
-
-      console.log(`\n${C.BRIGHT}Seed Status${C.RESET}`);
-      console.log(`---------------------------------`);
-      const seedFiles = (await glob(`seeds/*.ts`)).map(f => path.basename(f, ".ts")).sort();
-      const appliedSeeds = new Set((await orm.client.query<{ name: string }>(`SELECT name FROM seed_history`)).map(r => r.name));
-      seedFiles.forEach(name => {
-        const status = appliedSeeds.has(name) ? `${C.BG_GREEN} APPLIED ${C.RESET}` : `${C.BG_YELLOW} PENDING ${C.RESET}`;
-        console.log(`${status} ${C.WHITE}${name}${C.RESET}`);
-      });
-      if (seedFiles.length === 0) console.log(C.DIM + "  No seed files found." + C.RESET);
-      console.log();
-
-    } catch (error) {
-      CLILogger.panic(error as Error, "status");
-    } finally {
-      if (orm) await orm.close();
-    }
-  });
-
-// --------------------------------------------------------------------------------------------------
-// TOPOLOGICAL SORT HELPER for seeding
-// --------------------------------------------------------------------------------------------------
-function topologicalSort(graph: Map<string, { file: string; dependencies: string[] }>): string[] {
-  const result: string[] = [];
-  const visited = new Set<string>();
-  const temp = new Set<string>();
-  function visit(node: string) {
-    if (temp.has(node)) throw new Error(`Circular dependency detected: ${node}`);
-    if (!visited.has(node)) {
-      temp.add(node);
-      const deps = graph.get(node)?.dependencies || [];
-      for (const dep of deps) {
-        if (!graph.has(dep)) throw new Error(`Dependency '${dep}' not found for seed '${node}'`);
-        visit(dep);
-      }
-      temp.delete(node);
-      visited.add(node);
-      result.push(node);
-    }
-  }
-  for (const node of graph.keys()) {
-    if (!visited.has(node)) visit(node);
-  }
-  return result;
-}
-
-program
-  .option("-l, --log-level <level>", "Global log level", "Info")
-  .parse(process.argv);