@3lineas/d1-orm 1.0.5 → 1.0.7

package/README.md

@@ -208,6 +208,31 @@ pnpm orm migrate
 
 # Remote (Production)
 pnpm orm migrate --remote
+
+# Run migrations and then seed
+pnpm orm migrate --seed
+```
+
+#### Reset Database
+
+Drop all tables and re-run all migrations.
+
+```bash
+pnpm orm migrate:fresh
+
+# Reset and seed
+pnpm orm migrate:fresh --seed
+```
+
+#### Seed Database
+
+Run seeders defined in `database/seeders`.
+
+```bash
+pnpm orm db:seed
+
+# Remote
+pnpm orm db:seed --remote
 ```
 
 > **Note:** Local migrations require `wrangler` to be configured and running in your environment.

package/dist/chunk-5BBZKUNZ.mjs

@@ -0,0 +1,147 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// src/core/connection.ts
+var Connection;
+var init_connection = __esm({
+  "src/core/connection.ts"() {
+    "use strict";
+    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;
+var init_database = __esm({
+  "src/core/database.ts"() {
+    "use strict";
+    init_connection();
+    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);
+      }
+      /**
+       * Setup the database connection.
+       *
+       * @param d1 - The D1Database instance from Cloudflare environment (env.DB).
+       */
+      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."
+          );
+        }
+        return _Database.instance;
+      }
+    };
+  }
+});
+
+export {
+  __esm,
+  __commonJS,
+  Connection,
+  init_connection,
+  Database,
+  init_database
+};

package/dist/cli/index.js

@@ -101,7 +101,7 @@ export const down = async () => {
   const seederContent = `import { User } from '${path.relative(
     path.join(process.cwd(), "database/seeders"),
     path.join(process.cwd(), userModelsPath, "User")
-  ).replace(/\\/g, "/")}';
+  ).replace(/\\/g, "/")}.ts';
 
 export const seed = async () => {
     await User.create({
@@ -268,7 +268,7 @@ async function makeSeeder(modelName, modelPath) {
     fs3.mkdirSync(seederDir, { recursive: true });
   }
   const relativeModelPath = path3.relative(seederDir, path3.join(process.cwd(), modelPath, modelName)).replace(/\\/g, "/");
-  const template = `import { ${modelName} } from '${relativeModelPath}';
+  const template = `import { ${modelName} } from '${relativeModelPath}.ts';
 
 export const seed = async () => {
     // await ${modelName}.create({ ... });
@@ -283,20 +283,281 @@ export const seed = async () => {
 }
 
 // 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"));
+
+// 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 {
+  /**
+   * 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);
+  }
+  /**
+   * Setup the database connection.
+   *
+   * @param d1 - The D1Database instance from Cloudflare environment (env.DB).
+   */
+  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."
+      );
+    }
+    return _Database.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
+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.");
+    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.`);
+      }
+    } catch (error) {
+      console.error(`Error running seeder ${file}:`, error);
+    }
+  }
+}
+
+// src/cli/commands/migrate.ts
 async function migrate(args2) {
   console.log("Running migrations...");
-  const migrationsDir = path4.join(process.cwd(), "database/migrations");
-  if (!fs4.existsSync(migrationsDir)) {
+  const migrationsDir = path5.join(process.cwd(), "database/migrations");
+  if (!fs5.existsSync(migrationsDir)) {
     console.log("No migrations directory found.");
     return;
   }
-  const files = fs4.readdirSync(migrationsDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js")).sort();
+  const files = fs5.readdirSync(migrationsDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js")).sort();
   for (const file of files) {
     console.log(`Processing migration: ${file}`);
-    const filePath = path4.join(migrationsDir, file);
+    const filePath = path5.join(migrationsDir, file);
     try {
       const migration = await import(filePath);
       if (migration.up) {
@@ -308,7 +569,7 @@ async function migrate(args2) {
           try {
             const execCmd = `npx wrangler d1 execute ${dbName} --command "${sql.replace(/"/g, '\\"')}" ${command2}`;
             console.log(`Executing: ${execCmd}`);
-            (0, import_child_process.execSync)(execCmd, { stdio: "inherit" });
+            (0, import_child_process2.execSync)(execCmd, { stdio: "inherit" });
           } catch (e) {
             console.error(`Failed to execute migration: ${file}`);
             throw e;
@@ -319,6 +580,41 @@ async function migrate(args2) {
       console.error(`Error processing migration ${file}:`, error);
     }
   }
+  if (args2.includes("--seed")) {
+    await seed(args2);
+  }
+}
+
+// src/cli/commands/migrate-fresh.ts
+var import_child_process3 = require("child_process");
+async function migrateFresh(args2) {
+  console.log("Dropping all tables...");
+  const isRemote = args2.includes("--remote");
+  const dbName = "DB";
+  const flag = isRemote ? "--remote" : "--local";
+  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) {
+        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" });
+      } else {
+        console.log("No tables found to drop.");
+      }
+    }
+    await migrate(args2);
+  } catch (error) {
+    console.error("Error during migrate:fresh:", error);
+  }
 }
 
 // src/cli/index.ts
@@ -336,13 +632,17 @@ switch (command) {
     makeMigration(param);
     break;
   case "migrate":
-    const isLocal = args.includes("--local");
-    const isRemote = args.includes("--remote");
     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"
+      "Available commands: init, make:model, make:migration, migrate, migrate:fresh, db:seed"
     );
     break;
 }

package/dist/cli/index.mjs

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 import {
+  Database,
   __commonJS,
-  __esm
-} from "../chunk-X6BYQHVC.mjs";
+  __esm,
+  init_database
+} from "../chunk-5BBZKUNZ.mjs";
 
 // src/cli/commands/init.ts
 import * as fs from "fs";
@@ -82,7 +84,7 @@ export const down = async () => {
   const seederContent = `import { User } from '${path.relative(
     path.join(process.cwd(), "database/seeders"),
     path.join(process.cwd(), userModelsPath, "User")
-  ).replace(/\\/g, "/")}';
+  ).replace(/\\/g, "/")}.ts';
 
 export const seed = async () => {
     await User.create({
@@ -257,7 +259,7 @@ async function makeSeeder(modelName, modelPath) {
     fs3.mkdirSync(seederDir, { recursive: true });
   }
   const relativeModelPath = path3.relative(seederDir, path3.join(process.cwd(), modelPath, modelName)).replace(/\\/g, "/");
-  const template = `import { ${modelName} } from '${relativeModelPath}';
+  const template = `import { ${modelName} } from '${relativeModelPath}.ts';
 
 export const seed = async () => {
     // await ${modelName}.create({ ... });
@@ -277,21 +279,173 @@ var init_make_model = __esm({
   }
 });
 
-// src/cli/commands/migrate.ts
+// src/cli/cli-connection.ts
+import { execSync } from "child_process";
+var CLIConnection, CLIPREparedStatement;
+var init_cli_connection = __esm({
+  "src/cli/cli-connection.ts"() {
+    "use strict";
+    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 command = `npx wrangler d1 execute ${this.dbName} --command "${sql.replace(/"/g, '\\"')}" ${flag} --json`;
+        try {
+          const output = execSync(command, {
+            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: ${command}`);
+          throw e;
+        }
+      }
+    };
+    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 command = `npx wrangler d1 execute ${this.dbName} --command "${sql.replace(/"/g, '\\"')}" ${flag} --json`;
+        try {
+          const output = execSync(command, {
+            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
 import * as fs4 from "fs";
 import * as path4 from "path";
-import { execSync } from "child_process";
+async function seed(args) {
+  console.log("Seeding database...");
+  const seedersDir = path4.join(process.cwd(), "database/seeders");
+  if (!fs4.existsSync(seedersDir)) {
+    console.log("No seeders directory found.");
+    return;
+  }
+  const isRemote = args.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.`);
+      }
+    } catch (error) {
+      console.error(`Error running seeder ${file}:`, error);
+    }
+  }
+}
+var init_seed = __esm({
+  "src/cli/commands/seed.ts"() {
+    "use strict";
+    init_database();
+    init_cli_connection();
+  }
+});
+
+// src/cli/commands/migrate.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+import { execSync as execSync2 } from "child_process";
 async function migrate(args) {
   console.log("Running migrations...");
-  const migrationsDir = path4.join(process.cwd(), "database/migrations");
-  if (!fs4.existsSync(migrationsDir)) {
+  const migrationsDir = path5.join(process.cwd(), "database/migrations");
+  if (!fs5.existsSync(migrationsDir)) {
     console.log("No migrations directory found.");
     return;
   }
-  const files = fs4.readdirSync(migrationsDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js")).sort();
+  const files = fs5.readdirSync(migrationsDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js")).sort();
   for (const file of files) {
     console.log(`Processing migration: ${file}`);
-    const filePath = path4.join(migrationsDir, file);
+    const filePath = path5.join(migrationsDir, file);
     try {
       const migration = await import(filePath);
       if (migration.up) {
@@ -303,7 +457,7 @@ async function migrate(args) {
           try {
             const execCmd = `npx wrangler d1 execute ${dbName} --command "${sql.replace(/"/g, '\\"')}" ${command}`;
             console.log(`Executing: ${execCmd}`);
-            execSync(execCmd, { stdio: "inherit" });
+            execSync2(execCmd, { stdio: "inherit" });
           } catch (e) {
             console.error(`Failed to execute migration: ${file}`);
             throw e;
@@ -314,10 +468,52 @@ async function migrate(args) {
       console.error(`Error processing migration ${file}:`, error);
     }
   }
+  if (args.includes("--seed")) {
+    await seed(args);
+  }
 }
 var init_migrate = __esm({
   "src/cli/commands/migrate.ts"() {
     "use strict";
+    init_seed();
+  }
+});
+
+// src/cli/commands/migrate-fresh.ts
+import { execSync as execSync3 } from "child_process";
+async function migrateFresh(args) {
+  console.log("Dropping all tables...");
+  const isRemote = args.includes("--remote");
+  const dbName = "DB";
+  const flag = isRemote ? "--remote" : "--local";
+  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 = execSync3(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) {
+        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...");
+        execSync3(dropCmd, { stdio: "inherit" });
+      } else {
+        console.log("No tables found to drop.");
+      }
+    }
+    await migrate(args);
+  } catch (error) {
+    console.error("Error during migrate:fresh:", error);
+  }
+}
+var init_migrate_fresh = __esm({
+  "src/cli/commands/migrate-fresh.ts"() {
+    "use strict";
+    init_migrate();
   }
 });
 
@@ -328,6 +524,8 @@ var require_cli = __commonJS({
     init_make_model();
     init_make_migration();
     init_migrate();
+    init_migrate_fresh();
+    init_seed();
     var args = process.argv.slice(2);
     var command = args[0];
     var param = args[1];
@@ -342,13 +540,17 @@ var require_cli = __commonJS({
         makeMigration(param);
         break;
       case "migrate":
-        const isLocal = args.includes("--local");
-        const isRemote = args.includes("--remote");
         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"
+          "Available commands: init, make:model, make:migration, migrate, migrate:fresh, db:seed"
         );
         break;
     }

package/dist/index.mjs

@@ -1,80 +1,12 @@
-import "./chunk-X6BYQHVC.mjs";
+import {
+  Connection,
+  Database,
+  init_connection,
+  init_database
+} from "./chunk-5BBZKUNZ.mjs";
 
-// 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/index.ts
+init_connection();
 
 // src/core/query-builder.ts
 var QueryBuilder = class {
@@ -342,47 +274,11 @@ var ModelQueryBuilder = class extends QueryBuilder {
   }
 };
 
-// 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);
-  }
-  /**
-   * Setup the database connection.
-   *
-   * @param d1 - The D1Database instance from Cloudflare environment (env.DB).
-   */
-  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."
-      );
-    }
-    return _Database.instance;
-  }
-};
+// src/index.ts
+init_database();
+
+// src/models/model.ts
+init_database();
 
 // src/core/relationships/relationship.ts
 var Relationship = class {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@3lineas/d1-orm",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "A lightweight and powerful ORM for Cloudflare D1, inspired by Laravel Eloquent.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/dist/chunk-X6BYQHVC.mjs

@@ -1,12 +0,0 @@
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-
-export {
-  __esm,
-  __commonJS
-};