@3lineas/d1-orm 1.0.7 → 1.0.9

package/dist/cli/index.js

@@ -1,58 +1,33 @@
 #!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
+import {
+  Database
+} from "../chunk-N3G6NOJP.js";
 
 // src/cli/commands/init.ts
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-var readline = __toESM(require("readline"));
+import * as fs from "fs";
+import * as path from "path";
+import * as p from "@clack/prompts";
 async function init() {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  const question = (query) => {
-    return new Promise((resolve) => {
-      rl.question(query, resolve);
-    });
-  };
-  console.log("Initializing D1 ORM...");
-  const defaultModelsPath = "src/models";
-  const userModelsPath = await question(
-    `Where would you like to install your models? (default: ${defaultModelsPath}): `
-  ) || defaultModelsPath;
-  rl.close();
-  const folders = [userModelsPath, "database/migrations", "database/seeders"];
+  p.intro("Initializing D1 ORM...");
+  const s = p.spinner();
+  s.start("Scanning project structure...");
+  const srcPath = path.join(process.cwd(), "src");
+  const useSrc = fs.existsSync(srcPath) && fs.lstatSync(srcPath).isDirectory();
+  const baseDatabasePath = useSrc ? "src/database" : "database";
+  const modelsPath = path.join(baseDatabasePath, "models");
+  const migrationsPath = path.join(baseDatabasePath, "migrations");
+  const seedersPath = path.join(baseDatabasePath, "seeders");
+  const folders = [modelsPath, migrationsPath, seedersPath];
   folders.forEach((folder) => {
     const fullPath = path.join(process.cwd(), folder);
     if (!fs.existsSync(fullPath)) {
       fs.mkdirSync(fullPath, { recursive: true });
-      console.log(`Created directory: ${folder}`);
+      p.log.step(`Created directory: ${folder}`);
     } else {
-      console.log(`Directory already exists: ${folder}`);
+      p.log.info(`Directory already exists: ${folder}`);
     }
   });
+  s.message("Generating example files...");
   const userModelContent = `import { Model } from '@3lineas/d1-orm';
 
 export class User extends Model {
@@ -66,13 +41,13 @@ export class User extends Model {
     declare updated_at: string;
 }
 `;
-  const userModelPath = path.join(process.cwd(), userModelsPath, "User.ts");
+  const userModelPath = path.join(process.cwd(), modelsPath, "User.ts");
   if (!fs.existsSync(userModelPath)) {
     fs.writeFileSync(userModelPath, userModelContent);
-    console.log(`Created model: ${userModelPath}`);
+    p.log.step(`Created model: ${modelsPath}/User.ts`);
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").split(".")[0].replace("T", "_");
-  const migrationName = `${timestamp}_create_users_table.ts`;
+  const migrationName = `${timestamp}_create_users_table.mts`;
   const migrationContent = `import { Blueprint, Schema } from '@3lineas/d1-orm';
 
 export const up = async () => {
@@ -89,19 +64,16 @@ export const down = async () => {
     return Schema.dropIfExists('users');
 };
 `;
-  const migrationPath = path.join(
+  const fullMigrationsPath = path.join(
     process.cwd(),
-    "database/migrations",
+    migrationsPath,
     migrationName
   );
-  if (!fs.existsSync(migrationPath)) {
-    fs.writeFileSync(migrationPath, migrationContent);
-    console.log(`Created migration: ${migrationPath}`);
-  }
-  const seederContent = `import { User } from '${path.relative(
-    path.join(process.cwd(), "database/seeders"),
-    path.join(process.cwd(), userModelsPath, "User")
-  ).replace(/\\/g, "/")}.ts';
+  if (!fs.existsSync(fullMigrationsPath)) {
+    fs.writeFileSync(fullMigrationsPath, migrationContent);
+    p.log.step(`Created migration: ${migrationsPath}/${migrationName}`);
+  }
+  const seederContent = `import { User } from '../models/User.ts';
 
 export const seed = async () => {
     await User.create({
@@ -111,14 +83,27 @@ export const seed = async () => {
     });
 };
 `;
-  const seederPath = path.join(
+  const fullSeederPath = path.join(
+    process.cwd(),
+    seedersPath,
+    "UserSeeder.mts"
+  );
+  if (!fs.existsSync(fullSeederPath)) {
+    fs.writeFileSync(fullSeederPath, seederContent);
+    p.log.step(`Created seeder: ${seedersPath}/UserSeeder.mts`);
+  }
+  const configContent = `export default {
+    binding: 'DB', // Name of the D1 binding in wrangler.jsonc/toml
+};
+`;
+  const configFilePath = path.join(
     process.cwd(),
-    "database/seeders",
-    "UserSeeder.ts"
+    baseDatabasePath,
+    "config.mts"
   );
-  if (!fs.existsSync(seederPath)) {
-    fs.writeFileSync(seederPath, seederContent);
-    console.log(`Created seeder: ${seederPath}`);
+  if (!fs.existsSync(configFilePath)) {
+    fs.writeFileSync(configFilePath, configContent);
+    p.log.step(`Created config: ${baseDatabasePath}/config.mts`);
   }
   const packageJsonPath = path.join(process.cwd(), "package.json");
   if (fs.existsSync(packageJsonPath)) {
@@ -130,43 +115,50 @@ export const seed = async () => {
       if (!packageJson.scripts.orm) {
         packageJson.scripts.orm = "d1-orm";
         fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
-        console.log('Added "orm" script to package.json');
-      } else {
-        console.log('"orm" script already exists in package.json');
+        p.log.step('Added "orm" script to package.json');
       }
     } catch (e) {
-      console.error("Failed to update package.json:", e);
+      p.log.error(`Failed to update package.json: ${e}`);
     }
   }
+  s.stop("Initialization complete!");
+  p.outro("D1 ORM is ready to use.");
 }
 
 // src/cli/commands/make-model.ts
-var fs3 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
-var p2 = __toESM(require("@clack/prompts"));
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as p3 from "@clack/prompts";
 
 // src/cli/commands/make-migration.ts
-var fs2 = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
-var p = __toESM(require("@clack/prompts"));
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as p2 from "@clack/prompts";
 async function makeMigration(name) {
+  const isStandalone = !name;
+  if (isStandalone) {
+    p2.intro("Creating a new migration...");
+  }
   let migrationName = name;
   if (!migrationName) {
-    migrationName = await p.text({
+    migrationName = await p2.text({
       message: "What should the migration be named?",
       placeholder: "e.g. create_users_table",
       validate: (value) => {
         if (!value) return "Please enter a name.";
       }
     });
-    if (p.isCancel(migrationName)) {
-      p.cancel("Operation cancelled.");
+    if (p2.isCancel(migrationName)) {
+      p2.cancel("Operation cancelled.");
       return;
     }
   }
+  const srcMigrationsDir = path2.join(process.cwd(), "src/database/migrations");
+  const rootMigrationsDir = path2.join(process.cwd(), "database/migrations");
+  const migrationsDir = fs2.existsSync(srcMigrationsDir) ? "src/database/migrations" : "database/migrations";
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").split(".")[0].replace("T", "_");
-  const filename = `${timestamp}_${migrationName}.ts`;
-  const targetPath = path2.join(process.cwd(), "database/migrations", filename);
+  const filename = `${timestamp}_${migrationName}.mts`;
+  const targetPath = path2.join(process.cwd(), migrationsDir, filename);
   const template = `import { Blueprint, Schema } from '@3lineas/d1-orm';
 
 export const up = async () => {
@@ -180,36 +172,41 @@ export const down = async () => {
     return Schema.dropIfExists('${migrationName.replace("create_", "").replace("_table", "")}');
 };
 `;
-  if (!fs2.existsSync(path2.join(process.cwd(), "database/migrations"))) {
-    fs2.mkdirSync(path2.join(process.cwd(), "database/migrations"), {
+  if (!fs2.existsSync(path2.join(process.cwd(), migrationsDir))) {
+    fs2.mkdirSync(path2.join(process.cwd(), migrationsDir), {
       recursive: true
     });
   }
   if (fs2.existsSync(targetPath)) {
-    p.log.error(`Migration ${filename} already exists.`);
+    p2.log.error(`Migration ${filename} already exists.`);
+    if (isStandalone) p2.outro("Process aborted.");
     return;
   }
   fs2.writeFileSync(targetPath, template);
-  p.log.success(`Created migration: database/migrations/${filename}`);
+  p2.log.success(`Created migration: ${migrationsDir}/${filename}`);
+  if (isStandalone) {
+    p2.outro("Migration generated successfully!");
+  }
 }
 
 // src/cli/commands/make-model.ts
 async function makeModel(name) {
+  p3.intro("Creating a new model...");
   let modelName = name;
   if (!modelName) {
-    modelName = await p2.text({
+    modelName = await p3.text({
       message: "What should the model be named?",
       placeholder: "e.g. Flight",
       validate: (value) => {
         if (!value) return "Please enter a name.";
       }
     });
-    if (p2.isCancel(modelName)) {
-      p2.cancel("Operation cancelled.");
+    if (p3.isCancel(modelName)) {
+      p3.cancel("Operation cancelled.");
       return;
     }
   }
-  const modelPath = await findModelsPath() || "src/models";
+  const modelPath = await findModelsPath() || "src/database/models";
   const filename = `${modelName}.ts`;
   const targetPath = path3.join(process.cwd(), modelPath, filename);
   const template = `import { Model } from '@3lineas/d1-orm';
@@ -223,15 +220,16 @@ export class ${modelName} extends Model {
 }
 `;
   if (fs3.existsSync(targetPath)) {
-    p2.log.error(`Model ${filename} already exists at ${modelPath}.`);
+    p3.log.error(`Model ${filename} already exists at ${modelPath}.`);
+    p3.outro("Process aborted.");
     return;
   }
   if (!fs3.existsSync(path3.join(process.cwd(), modelPath))) {
     fs3.mkdirSync(path3.join(process.cwd(), modelPath), { recursive: true });
   }
   fs3.writeFileSync(targetPath, template);
-  p2.log.success(`Created model: ${modelPath}/${filename}`);
-  const options = await p2.multiselect({
+  p3.log.success(`Created model: ${modelPath}/${filename}`);
+  const options = await p3.multiselect({
     message: "Would you like to create any of the following?",
     options: [
       { value: "migration", label: "Migration" },
@@ -239,8 +237,8 @@ export class ${modelName} extends Model {
     ],
     required: false
   });
-  if (p2.isCancel(options)) {
-    p2.cancel("Operation cancelled.");
+  if (p3.isCancel(options)) {
+    p3.cancel("Operation cancelled.");
     return;
   }
   if (options.includes("migration")) {
@@ -250,19 +248,26 @@ export class ${modelName} extends Model {
   if (options.includes("seeder")) {
     await makeSeeder(modelName, modelPath);
   }
+  p3.outro("Model generation complete!");
 }
 async function findModelsPath() {
-  const packageJsonPath = path3.join(process.cwd(), "package.json");
-  if (!fs3.existsSync(packageJsonPath)) return null;
-  const commonPaths = ["src/models", "models", "app/Models"];
-  for (const p3 of commonPaths) {
-    if (fs3.existsSync(path3.join(process.cwd(), p3))) return p3;
+  const commonPaths = [
+    "src/database/models",
+    "database/models",
+    "src/models",
+    "models",
+    "app/Models"
+  ];
+  for (const p7 of commonPaths) {
+    if (fs3.existsSync(path3.join(process.cwd(), p7))) return p7;
   }
   return null;
 }
 async function makeSeeder(modelName, modelPath) {
-  const seederDir = path3.join(process.cwd(), "database/seeders");
-  const seederName = `${modelName}Seeder.ts`;
+  const srcPath = path3.join(process.cwd(), "src");
+  const useSrc = fs3.existsSync(srcPath) && fs3.lstatSync(srcPath).isDirectory();
+  const seederDir = useSrc ? path3.join(process.cwd(), "src/database/seeders") : path3.join(process.cwd(), "database/seeders");
+  const seederName = `${modelName}Seeder.mts`;
   const targetPath = path3.join(seederDir, seederName);
   if (!fs3.existsSync(seederDir)) {
     fs3.mkdirSync(seederDir, { recursive: true });
@@ -275,142 +280,86 @@ export const seed = async () => {
 };
 `;
   if (fs3.existsSync(targetPath)) {
-    p2.log.warn(`Seeder ${seederName} already exists.`);
+    p3.log.warn(`Seeder ${seederName} already exists.`);
     return;
   }
   fs3.writeFileSync(targetPath, template);
-  p2.log.success(`Created seeder: database/seeders/${seederName}`);
+  p3.log.success(`Created seeder: database/seeders/${seederName}`);
 }
 
 // src/cli/commands/migrate.ts
-var fs5 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
-var import_child_process2 = require("child_process");
-
-// src/cli/commands/seed.ts
-var fs4 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
+import * as fs6 from "fs";
+import * as path6 from "path";
+import { execSync as execSync2 } from "child_process";
+import * as p5 from "@clack/prompts";
 
-// src/core/connection.ts
-var Connection = class {
-  /**
-   * The underlying D1Database instance.
-   */
-  db;
-  /**
-   * Create a new Connection instance.
-   *
-   * @param database - The D1Database instance.
-   */
-  constructor(database) {
-    this.db = database;
-  }
-  /**
-   * Execute a SELECT statement.
-   *
-   * @param query - The SQL query string.
-   * @param bindings - The parameter bindings.
-   * @returns A promise that resolves to an array of results.
-   */
-  async select(query, bindings = []) {
-    const stmt = this.db.prepare(query).bind(...bindings);
-    const result = await stmt.all();
-    return result.results || [];
-  }
-  /**
-   * Execute an INSERT statement.
-   *
-   * @param query - The SQL query string.
-   * @param bindings - The parameter bindings.
-   * @returns A promise that resolves to true on success.
-   */
-  async insert(query, bindings = []) {
-    const stmt = this.db.prepare(query).bind(...bindings);
-    const result = await stmt.run();
-    return result.success;
-  }
+// src/cli/utils/config.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+var Config = class {
   /**
-   * Execute an UPDATE statement.
+   * Detect the D1 database binding from Wrangler configuration or d1-orm config.
    *
-   * @param query - The SQL query string.
-   * @param bindings - The parameter bindings.
-   * @returns A promise that resolves to true on success.
+   * @returns The binding name (e.g., "DB").
    */
-  async update(query, bindings = []) {
-    const stmt = this.db.prepare(query).bind(...bindings);
-    const result = await stmt.run();
-    return result.success;
-  }
-  /**
-   * Execute a DELETE statement.
-   *
-   * @param query - The SQL query string.
-   * @param bindings - The parameter bindings.
-   * @returns A promise that resolves to true on success.
-   */
-  async delete(query, bindings = []) {
-    const stmt = this.db.prepare(query).bind(...bindings);
-    const result = await stmt.run();
-    return result.success;
-  }
-  /**
-   * Execute an arbitrary SQL statement.
-   *
-   * @param query - The SQL query string.
-   * @param bindings - The parameter bindings.
-   * @returns A promise that resolves to true on success.
-   */
-  async statement(query, bindings = []) {
-    const stmt = this.db.prepare(query).bind(...bindings);
-    const result = await stmt.run();
-    return result.success;
-  }
-};
-
-// src/core/database.ts
-var Database = class _Database {
-  /**
-   * The singleton instance of the Database.
-   */
-  static instance;
-  /**
-   * The active database connection.
-   */
-  connection;
-  /**
-   * Private constructor to enforce singleton pattern.
-   *
-   * @param d1 - The D1Database instance from Cloudflare.
-   */
-  constructor(d1) {
-    this.connection = new Connection(d1);
+  static getD1Binding() {
+    const srcConfig = path4.join(process.cwd(), "src/database/config.mts");
+    const srcConfigTs = path4.join(process.cwd(), "src/database/config.ts");
+    const rootConfig = path4.join(process.cwd(), "database/config.mts");
+    const rootConfigTs = path4.join(process.cwd(), "database/config.ts");
+    const configPath = fs4.existsSync(srcConfig) ? srcConfig : fs4.existsSync(srcConfigTs) ? srcConfigTs : fs4.existsSync(rootConfig) ? rootConfig : fs4.existsSync(rootConfigTs) ? rootConfigTs : null;
+    if (configPath) {
+      const content = fs4.readFileSync(configPath, "utf-8");
+      const match = content.match(/binding\s*:\s*["'](.+?)["']/);
+      if (match) return match[1];
+    }
+    const wranglerPaths = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"];
+    for (const configName of wranglerPaths) {
+      const fullPath = path4.join(process.cwd(), configName);
+      if (fs4.existsSync(fullPath)) {
+        const content = fs4.readFileSync(fullPath, "utf-8");
+        if (configName.endsWith(".json") || configName.endsWith(".jsonc")) {
+          try {
+            const jsonStr = content.replace(/\/\/.*|\/\*[\s\S]*?\*\//g, "");
+            const config = JSON.parse(jsonStr);
+            const d1Databases = config.d1_databases;
+            if (Array.isArray(d1Databases) && d1Databases.length > 0) {
+              return d1Databases[0].binding || "DB";
+            }
+          } catch (e) {
+          }
+        }
+        if (configName.endsWith(".toml")) {
+          const match = content.match(/binding\s*=\s*["'](.+?)["']/);
+          if (match) return match[1];
+        }
+      }
+    }
+    return "DB";
   }
   /**
-   * Setup the database connection.
-   *
-   * @param d1 - The D1Database instance from Cloudflare environment (env.DB).
+   * Detect if the project is ESM.
    */
-  static setup(d1) {
-    _Database.instance = new _Database(d1);
-  }
-  /**
-   * Get the singleton Database instance.
-   *
-   * @throws Error if setup() has not been called.
-   * @returns The Database instance.
-   */
-  static getInstance() {
-    if (!_Database.instance) {
-      throw new Error(
-        "Database not initialized. Call Database.setup(env.DB) first."
-      );
+  static isESM() {
+    const pkgPath = path4.join(process.cwd(), "package.json");
+    if (fs4.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+        return pkg.type === "module";
+      } catch (e) {
+        return false;
+      }
     }
-    return _Database.instance;
+    return false;
   }
 };
 
+// src/cli/commands/seed.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+
 // src/cli/cli-connection.ts
-var import_child_process = require("child_process");
+import { execSync } from "child_process";
 var CLIConnection = class {
   constructor(dbName = "DB", isRemote = false) {
     this.dbName = dbName;
@@ -442,7 +391,7 @@ var CLIConnection = class {
     const flag = this.isRemote ? "--remote" : "--local";
     const command2 = `npx wrangler d1 execute ${this.dbName} --command "${sql.replace(/"/g, '\\"')}" ${flag} --json`;
     try {
-      const output = (0, import_child_process.execSync)(command2, {
+      const output = execSync(command2, {
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "inherit"]
       });
@@ -492,7 +441,7 @@ var CLIPREparedStatement = class {
     const flag = this.isRemote ? "--remote" : "--local";
     const command2 = `npx wrangler d1 execute ${this.dbName} --command "${sql.replace(/"/g, '\\"')}" ${flag} --json`;
     try {
-      const output = (0, import_child_process.execSync)(command2, {
+      const output = execSync(command2, {
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -518,83 +467,133 @@ var CLIPREparedStatement = class {
 };
 
 // src/cli/commands/seed.ts
+import * as p4 from "@clack/prompts";
 async function seed(args2) {
-  console.log("Seeding database...");
-  const seedersDir = path4.join(process.cwd(), "database/seeders");
-  if (!fs4.existsSync(seedersDir)) {
-    console.log("No seeders directory found.");
+  p4.intro("Seeding database...");
+  const srcSeedersDir = path5.join(process.cwd(), "src/database/seeders");
+  const rootSeedersDir = path5.join(process.cwd(), "database/seeders");
+  const seedersDir = fs5.existsSync(srcSeedersDir) ? srcSeedersDir : rootSeedersDir;
+  if (!fs5.existsSync(seedersDir)) {
+    p4.log.warn(
+      `No seeders directory found (checked ${srcSeedersDir} and ${rootSeedersDir}).`
+    );
+    p4.outro("Nothing to seed.");
     return;
   }
   const isRemote = args2.includes("--remote");
-  const dbName = "DB";
-  Database.setup(new CLIConnection(dbName, isRemote));
-  const files = fs4.readdirSync(seedersDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js")).sort();
-  for (const file of files) {
-    console.log(`Running seeder: ${file}`);
-    const filePath = path4.join(seedersDir, file);
-    try {
-      const seeder = await import(filePath);
-      if (seeder.seed) {
-        await seeder.seed();
-        console.log(`Seeder ${file} completed successfully.`);
-      } else {
-        console.warn(`Seeder ${file} does not export a seed function.`);
+  const dbName = Config.getD1Binding();
+  const s = p4.spinner();
+  s.start(`Initializing ORM (Binding: ${dbName})...`);
+  try {
+    const connection = new CLIConnection(dbName, isRemote);
+    Database.setup(connection);
+    s.stop(`ORM initialized successfully with binding "${dbName}".`);
+    const files = fs5.readdirSync(seedersDir).filter(
+      (f) => f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".mts") || f.endsWith(".mjs")
+    ).sort();
+    if (files.length === 0) {
+      p4.log.info("No seeder files found.");
+      p4.outro("Seeding complete.");
+      return;
+    }
+    for (const file of files) {
+      s.start(`Running seeder: ${file}`);
+      const filePath = path5.join(seedersDir, file);
+      try {
+        const seeder = await import(filePath);
+        if (seeder.seed) {
+          await seeder.seed(Database.getInstance());
+          s.stop(`Completed: ${file}`);
+        } else {
+          s.stop(`Skipped: ${file} (no seed function)`, 1);
+        }
+      } catch (error) {
+        s.stop(`Failed: ${file}`, 1);
+        p4.log.error(`Error running seeder ${file}: ${error}`);
       }
-    } catch (error) {
-      console.error(`Error running seeder ${file}:`, error);
     }
+    p4.outro("Seeding completed successfully.");
+  } catch (error) {
+    s.stop("Initialization failed.", 1);
+    p4.log.error(`Seeding error: ${error}`);
   }
 }
 
 // src/cli/commands/migrate.ts
 async function migrate(args2) {
-  console.log("Running migrations...");
-  const migrationsDir = path5.join(process.cwd(), "database/migrations");
-  if (!fs5.existsSync(migrationsDir)) {
-    console.log("No migrations directory found.");
+  p5.intro("Running migrations...");
+  const srcMigrationsDir = path6.join(process.cwd(), "src/database/migrations");
+  const rootMigrationsDir = path6.join(process.cwd(), "database/migrations");
+  const migrationsDir = fs6.existsSync(srcMigrationsDir) ? srcMigrationsDir : rootMigrationsDir;
+  if (!fs6.existsSync(migrationsDir)) {
+    p5.log.warn(
+      `No migrations directory found (checked ${srcMigrationsDir} and ${rootMigrationsDir}).`
+    );
+    p5.outro("Nothing to migrate.");
     return;
   }
-  const files = fs5.readdirSync(migrationsDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js")).sort();
+  const files = fs6.readdirSync(migrationsDir).filter(
+    (f) => f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".mts") || f.endsWith(".mjs")
+  ).sort();
+  if (files.length === 0) {
+    p5.log.info("No migration files found.");
+    p5.outro("Migrations complete.");
+    return;
+  }
+  const s = p5.spinner();
+  const dbName = Config.getD1Binding();
   for (const file of files) {
-    console.log(`Processing migration: ${file}`);
-    const filePath = path5.join(migrationsDir, file);
+    s.start(`Processing migration: ${file} (Binding: ${dbName})`);
+    const filePath = path6.join(migrationsDir, file);
     try {
       const migration = await import(filePath);
       if (migration.up) {
         const sql = await migration.up();
         if (sql) {
           const isRemote = args2.includes("--remote");
-          const dbName = "DB";
           const command2 = isRemote ? "--remote" : "--local";
           try {
             const execCmd = `npx wrangler d1 execute ${dbName} --command "${sql.replace(/"/g, '\\"')}" ${command2}`;
-            console.log(`Executing: ${execCmd}`);
-            (0, import_child_process2.execSync)(execCmd, { stdio: "inherit" });
+            execSync2(execCmd, {
+              stdio: "pipe",
+              env: { ...process.env, NODE_NO_WARNINGS: "1" }
+            });
+            s.stop(`Migrated: ${file}`);
           } catch (e) {
-            console.error(`Failed to execute migration: ${file}`);
+            s.stop(`Failed: ${file}`, 1);
+            p5.log.error(`Failed to execute migration: ${file}`);
             throw e;
           }
+        } else {
+          s.stop(`Skipped (no SQL): ${file}`);
         }
+      } else {
+        s.stop(`Skipped (no up function): ${file}`);
       }
     } catch (error) {
-      console.error(`Error processing migration ${file}:`, error);
+      s.stop(`Error: ${file}`, 1);
+      p5.log.error(`Error processing migration ${file}: ${error}`);
     }
   }
+  p5.outro("All migrations executed.");
   if (args2.includes("--seed")) {
     await seed(args2);
   }
 }
 
 // src/cli/commands/migrate-fresh.ts
-var import_child_process3 = require("child_process");
+import { execSync as execSync3 } from "child_process";
+import * as p6 from "@clack/prompts";
 async function migrateFresh(args2) {
-  console.log("Dropping all tables...");
+  p6.intro("Resetting database...");
   const isRemote = args2.includes("--remote");
-  const dbName = "DB";
+  const dbName = Config.getD1Binding();
   const flag = isRemote ? "--remote" : "--local";
+  const s = p6.spinner();
+  s.start("Scanning for tables to drop...");
   try {
     const listTablesCmd = `npx wrangler d1 execute ${dbName} --command "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '_cf_%'" ${flag} --json`;
-    const output = (0, import_child_process3.execSync)(listTablesCmd, {
+    const output = execSync3(listTablesCmd, {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "inherit"]
     });
@@ -603,17 +602,21 @@ async function migrateFresh(args2) {
       const results = JSON.parse(output.substring(jsonStart));
       const tables = results[0]?.results || [];
       if (tables.length > 0) {
+        s.message(`Dropping ${tables.length} tables...`);
         const dropCommands = tables.map((t) => `DROP TABLE IF EXISTS ${t.name};`).join(" ");
         const dropCmd = `npx wrangler d1 execute ${dbName} --command "${dropCommands}" ${flag}`;
-        console.log("Executing drop tables...");
-        (0, import_child_process3.execSync)(dropCmd, { stdio: "inherit" });
+        execSync3(dropCmd, { stdio: "pipe" });
+        s.stop("All tables dropped successfully.");
       } else {
-        console.log("No tables found to drop.");
+        s.stop("No tables found to drop.");
       }
+    } else {
+      s.stop("Unexpected output from wrangler while listing tables.", 1);
     }
     await migrate(args2);
   } catch (error) {
-    console.error("Error during migrate:fresh:", error);
+    s.stop("Process failed.", 1);
+    p6.log.error(`Error during migrate:fresh: ${error}`);
   }
 }