@3lineas/d1-orm 1.0.7 → 1.0.8

package/dist/cli/index.cjs

@@ -0,0 +1,781 @@
+#!/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
+));
+
+// src/cli/commands/init.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var p = __toESM(require("@clack/prompts"), 1);
+async function init() {
+  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 });
+      p.log.step(`Created directory: ${folder}`);
+    } else {
+      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 {
+    // protected static table = 'users';
+
+    declare id: number;
+    declare name: string;
+    declare email: string;
+    declare password?: string;
+    declare created_at: string;
+    declare updated_at: string;
+}
+`;
+  const userModelPath = path.join(process.cwd(), modelsPath, "User.ts");
+  if (!fs.existsSync(userModelPath)) {
+    fs.writeFileSync(userModelPath, userModelContent);
+    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 migrationContent = `import { Blueprint, Schema } from '@3lineas/d1-orm';
+
+export const up = async () => {
+    return Schema.create('users', (table: Blueprint) => {
+        table.id();
+        table.string('name');
+        table.string('email').unique();
+        table.string('password').nullable();
+        table.timestamps();
+    });
+};
+
+export const down = async () => {
+    return Schema.dropIfExists('users');
+};
+`;
+  const fullMigrationsPath = path.join(
+    process.cwd(),
+    migrationsPath,
+    migrationName
+  );
+  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({
+        name: 'John Doe',
+        email: 'john@example.com',
+        password: 'password'
+    });
+};
+`;
+  const fullSeederPath = path.join(process.cwd(), seedersPath, "UserSeeder.ts");
+  if (!fs.existsSync(fullSeederPath)) {
+    fs.writeFileSync(fullSeederPath, seederContent);
+    p.log.step(`Created seeder: ${seedersPath}/UserSeeder.ts`);
+  }
+  const configContent = `export default {
+    binding: 'DB', // Name of the D1 binding in wrangler.jsonc/toml
+};
+`;
+  const configFilePath = path.join(
+    process.cwd(),
+    baseDatabasePath,
+    "config.ts"
+  );
+  if (!fs.existsSync(configFilePath)) {
+    fs.writeFileSync(configFilePath, configContent);
+    p.log.step(`Created config: ${baseDatabasePath}/config.ts`);
+  }
+  const packageJsonPath = path.join(process.cwd(), "package.json");
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+      if (!packageJson.scripts) {
+        packageJson.scripts = {};
+      }
+      if (!packageJson.scripts.orm) {
+        packageJson.scripts.orm = "d1-orm";
+        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        p.log.step('Added "orm" script to package.json');
+      }
+    } catch (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"), 1);
+var path3 = __toESM(require("path"), 1);
+var p3 = __toESM(require("@clack/prompts"), 1);
+
+// src/cli/commands/make-migration.ts
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+var p2 = __toESM(require("@clack/prompts"), 1);
+async function makeMigration(name) {
+  const isStandalone = !name;
+  if (isStandalone) {
+    p2.intro("Creating a new migration...");
+  }
+  let migrationName = name;
+  if (!migrationName) {
+    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 (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(), migrationsDir, filename);
+  const template = `import { Blueprint, Schema } from '@3lineas/d1-orm';
+
+export const up = async () => {
+    return Schema.create('${migrationName.replace("create_", "").replace("_table", "")}', (table: Blueprint) => {
+        table.id();
+        table.timestamps();
+    });
+};
+
+export const down = async () => {
+    return Schema.dropIfExists('${migrationName.replace("create_", "").replace("_table", "")}');
+};
+`;
+  if (!fs2.existsSync(path2.join(process.cwd(), migrationsDir))) {
+    fs2.mkdirSync(path2.join(process.cwd(), migrationsDir), {
+      recursive: true
+    });
+  }
+  if (fs2.existsSync(targetPath)) {
+    p2.log.error(`Migration ${filename} already exists.`);
+    if (isStandalone) p2.outro("Process aborted.");
+    return;
+  }
+  fs2.writeFileSync(targetPath, template);
+  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 p3.text({
+      message: "What should the model be named?",
+      placeholder: "e.g. Flight",
+      validate: (value) => {
+        if (!value) return "Please enter a name.";
+      }
+    });
+    if (p3.isCancel(modelName)) {
+      p3.cancel("Operation cancelled.");
+      return;
+    }
+  }
+  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';
+
+export class ${modelName} extends Model {
+    // protected static table = '${modelName.toLowerCase()}s'; 
+    
+    // declare id: number;
+    // declare created_at: string;
+    // declare updated_at: string;
+}
+`;
+  if (fs3.existsSync(targetPath)) {
+    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);
+  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" },
+      { value: "seeder", label: "Database Seeder" }
+    ],
+    required: false
+  });
+  if (p3.isCancel(options)) {
+    p3.cancel("Operation cancelled.");
+    return;
+  }
+  if (options.includes("migration")) {
+    const migrationName = `create_${modelName.toLowerCase()}s_table`;
+    await makeMigration(migrationName);
+  }
+  if (options.includes("seeder")) {
+    await makeSeeder(modelName, modelPath);
+  }
+  p3.outro("Model generation complete!");
+}
+async function findModelsPath() {
+  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 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.ts`;
+  const targetPath = path3.join(seederDir, seederName);
+  if (!fs3.existsSync(seederDir)) {
+    fs3.mkdirSync(seederDir, { recursive: true });
+  }
+  const relativeModelPath = path3.relative(seederDir, path3.join(process.cwd(), modelPath, modelName)).replace(/\\/g, "/");
+  const template = `import { ${modelName} } from '${relativeModelPath}.ts';
+
+export const seed = async () => {
+    // await ${modelName}.create({ ... });
+};
+`;
+  if (fs3.existsSync(targetPath)) {
+    p3.log.warn(`Seeder ${seederName} already exists.`);
+    return;
+  }
+  fs3.writeFileSync(targetPath, template);
+  p3.log.success(`Created seeder: database/seeders/${seederName}`);
+}
+
+// src/cli/commands/migrate.ts
+var fs6 = __toESM(require("fs"), 1);
+var path6 = __toESM(require("path"), 1);
+var import_child_process2 = require("child_process");
+var p5 = __toESM(require("@clack/prompts"), 1);
+
+// src/cli/utils/config.ts
+var fs4 = __toESM(require("fs"), 1);
+var path4 = __toESM(require("path"), 1);
+var Config = class {
+  /**
+   * Detect the D1 database binding from Wrangler configuration or d1-orm config.
+   *
+   * @returns The binding name (e.g., "DB").
+   */
+  static getD1Binding() {
+    const srcConfig = path4.join(process.cwd(), "src/database/config.ts");
+    const rootConfig = path4.join(process.cwd(), "database/config.ts");
+    const configPath = fs4.existsSync(srcConfig) ? srcConfig : fs4.existsSync(rootConfig) ? rootConfig : 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";
+  }
+  /**
+   * Detect if the project is ESM.
+   */
+  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 false;
+  }
+};
+
+// src/cli/commands/seed.ts
+var fs5 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
+
+// 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;
+  }
+  /**
+   * Execute an UPDATE statement.
+   *
+   * @param query - The SQL query string.
+   * @param bindings - The parameter bindings.
+   * @returns A promise that resolves to true on success.
+   */
+  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 {
+  /**
+   * Symbol for global singleton access.
+   */
+  static INSTANCE_KEY = /* @__PURE__ */ Symbol.for("d1-orm-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);
+  }
+  /**
+   * Setup the database connection.
+   *
+   * @param d1 - The D1Database instance from Cloudflare environment (env.DB).
+   */
+  static setup(d1) {
+    globalThis[_Database.INSTANCE_KEY] = new _Database(d1);
+  }
+  /**
+   * Get the singleton Database instance.
+   *
+   * @throws Error if setup() has not been called and auto-init fails.
+   * @returns The Database instance.
+   */
+  static getInstance() {
+    const instance = globalThis[_Database.INSTANCE_KEY];
+    if (!instance) {
+      if (globalThis["DB"] && typeof globalThis["DB"].prepare === "function") {
+        _Database.setup(globalThis["DB"]);
+        return globalThis[_Database.INSTANCE_KEY];
+      }
+      throw new Error(
+        "Database not initialized. Call Database.setup(env.DB) first or ensure your D1 binding is named 'DB'."
+      );
+    }
+    return instance;
+  }
+};
+
+// src/cli/cli-connection.ts
+var import_child_process = require("child_process");
+var CLIConnection = class {
+  constructor(dbName = "DB", isRemote = false) {
+    this.dbName = dbName;
+    this.isRemote = isRemote;
+  }
+  prepare(query) {
+    return new CLIPREparedStatement(query, this.dbName, this.isRemote);
+  }
+  async dump() {
+    throw new Error("dump() is not supported in CLI mode.");
+  }
+  async batch(statements) {
+    const results = [];
+    for (const stmt of statements) {
+      results.push(await stmt.run());
+    }
+    return results;
+  }
+  async exec(query) {
+    const start = Date.now();
+    await this.executeWrangler(query);
+    return {
+      count: 1,
+      // Approximation
+      duration: Date.now() - start
+    };
+  }
+  executeWrangler(sql) {
+    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, {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "inherit"]
+      });
+      const jsonStart = output.indexOf("[");
+      if (jsonStart !== -1) {
+        return JSON.parse(output.substring(jsonStart));
+      }
+      return null;
+    } catch (e) {
+      console.error(`Error executing wrangler command: ${command2}`);
+      throw e;
+    }
+  }
+};
+var CLIPREparedStatement = class {
+  constructor(query, dbName, isRemote) {
+    this.query = query;
+    this.dbName = dbName;
+    this.isRemote = isRemote;
+  }
+  bindings = [];
+  bind(...values) {
+    this.bindings = values;
+    return this;
+  }
+  resolveQuery() {
+    let sql = this.query;
+    this.bindings.forEach((value) => {
+      const formattedValue = typeof value === "string" ? `'${value.replace(/'/g, "''")}'` : value;
+      sql = sql.replace("?", String(formattedValue));
+    });
+    return sql;
+  }
+  async first(colName) {
+    const result = await this.all();
+    const firstRow = result.results[0] || null;
+    if (firstRow && colName) {
+      return firstRow[colName];
+    }
+    return firstRow;
+  }
+  async run() {
+    return this.all();
+  }
+  async all() {
+    const sql = this.resolveQuery();
+    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, {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const jsonStart = output.indexOf("[");
+      if (jsonStart !== -1) {
+        const results = JSON.parse(output.substring(jsonStart));
+        const primaryResult = results[0];
+        return {
+          results: primaryResult.results || [],
+          success: primaryResult.success ?? true,
+          meta: primaryResult.meta || {}
+        };
+      }
+      return { results: [], success: true, meta: {} };
+    } catch (e) {
+      return { results: [], success: false, meta: {}, error: e.message };
+    }
+  }
+  async raw() {
+    const result = await this.all();
+    return result.results;
+  }
+};
+
+// src/cli/commands/seed.ts
+var p4 = __toESM(require("@clack/prompts"), 1);
+async function seed(args2) {
+  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 = 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")).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}`);
+      }
+    }
+    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) {
+  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 = fs6.readdirSync(migrationsDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js")).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) {
+    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 command2 = isRemote ? "--remote" : "--local";
+          try {
+            const execCmd = `npx wrangler d1 execute ${dbName} --command "${sql.replace(/"/g, '\\"')}" ${command2}`;
+            (0, import_child_process2.execSync)(execCmd, { stdio: "pipe" });
+            s.stop(`Migrated: ${file}`);
+          } catch (e) {
+            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) {
+      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");
+var p6 = __toESM(require("@clack/prompts"), 1);
+async function migrateFresh(args2) {
+  p6.intro("Resetting database...");
+  const isRemote = args2.includes("--remote");
+  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, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "inherit"]
+    });
+    const jsonStart = output.indexOf("[");
+    if (jsonStart !== -1) {
+      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}`;
+        (0, import_child_process3.execSync)(dropCmd, { stdio: "pipe" });
+        s.stop("All tables dropped successfully.");
+      } else {
+        s.stop("No tables found to drop.");
+      }
+    } else {
+      s.stop("Unexpected output from wrangler while listing tables.", 1);
+    }
+    await migrate(args2);
+  } catch (error) {
+    s.stop("Process failed.", 1);
+    p6.log.error(`Error during migrate:fresh: ${error}`);
+  }
+}
+
+// src/cli/index.ts
+var args = process.argv.slice(2);
+var command = args[0];
+var param = args[1];
+switch (command) {
+  case "init":
+    init();
+    break;
+  case "make:model":
+    makeModel(param);
+    break;
+  case "make:migration":
+    makeMigration(param);
+    break;
+  case "migrate":
+    migrate(args);
+    break;
+  case "migrate:fresh":
+    migrateFresh(args);
+    break;
+  case "db:seed":
+    seed(args);
+    break;
+  default:
+    console.log(
+      "Available commands: init, make:model, make:migration, migrate, migrate:fresh, db:seed"
+    );
+    break;
+}