@3lineas/d1-orm 1.0.7 → 1.0.8

package/dist/cli/index.mjs

@@ -1,559 +0,0 @@
-#!/usr/bin/env node
-import {
-  Database,
-  __commonJS,
-  __esm,
-  init_database
-} from "../chunk-5BBZKUNZ.mjs";
-
-// src/cli/commands/init.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as readline from "readline";
-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"];
-  folders.forEach((folder) => {
-    const fullPath = path.join(process.cwd(), folder);
-    if (!fs.existsSync(fullPath)) {
-      fs.mkdirSync(fullPath, { recursive: true });
-      console.log(`Created directory: ${folder}`);
-    } else {
-      console.log(`Directory already exists: ${folder}`);
-    }
-  });
-  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(), userModelsPath, "User.ts");
-  if (!fs.existsSync(userModelPath)) {
-    fs.writeFileSync(userModelPath, userModelContent);
-    console.log(`Created model: ${userModelPath}`);
-  }
-  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 migrationPath = path.join(
-    process.cwd(),
-    "database/migrations",
-    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';
-
-export const seed = async () => {
-    await User.create({
-        name: 'John Doe',
-        email: 'john@example.com',
-        password: 'password'
-    });
-};
-`;
-  const seederPath = path.join(
-    process.cwd(),
-    "database/seeders",
-    "UserSeeder.ts"
-  );
-  if (!fs.existsSync(seederPath)) {
-    fs.writeFileSync(seederPath, seederContent);
-    console.log(`Created seeder: ${seederPath}`);
-  }
-  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));
-        console.log('Added "orm" script to package.json');
-      } else {
-        console.log('"orm" script already exists in package.json');
-      }
-    } catch (e) {
-      console.error("Failed to update package.json:", e);
-    }
-  }
-}
-var init_init = __esm({
-  "src/cli/commands/init.ts"() {
-    "use strict";
-  }
-});
-
-// src/cli/commands/make-migration.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as p from "@clack/prompts";
-async function makeMigration(name) {
-  let migrationName = name;
-  if (!migrationName) {
-    migrationName = await p.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.");
-      return;
-    }
-  }
-  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 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(), "database/migrations"))) {
-    fs2.mkdirSync(path2.join(process.cwd(), "database/migrations"), {
-      recursive: true
-    });
-  }
-  if (fs2.existsSync(targetPath)) {
-    p.log.error(`Migration ${filename} already exists.`);
-    return;
-  }
-  fs2.writeFileSync(targetPath, template);
-  p.log.success(`Created migration: database/migrations/${filename}`);
-}
-var init_make_migration = __esm({
-  "src/cli/commands/make-migration.ts"() {
-    "use strict";
-  }
-});
-
-// src/cli/commands/make-model.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-import * as p2 from "@clack/prompts";
-async function makeModel(name) {
-  let modelName = name;
-  if (!modelName) {
-    modelName = await p2.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.");
-      return;
-    }
-  }
-  const modelPath = await findModelsPath() || "src/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)) {
-    p2.log.error(`Model ${filename} already exists at ${modelPath}.`);
-    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({
-    message: "Would you like to create any of the following?",
-    options: [
-      { value: "migration", label: "Migration" },
-      { value: "seeder", label: "Database Seeder" }
-    ],
-    required: false
-  });
-  if (p2.isCancel(options)) {
-    p2.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);
-  }
-}
-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;
-  }
-  return null;
-}
-async function makeSeeder(modelName, modelPath) {
-  const seederDir = 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)) {
-    p2.log.warn(`Seeder ${seederName} already exists.`);
-    return;
-  }
-  fs3.writeFileSync(targetPath, template);
-  p2.log.success(`Created seeder: database/seeders/${seederName}`);
-}
-var init_make_model = __esm({
-  "src/cli/commands/make-model.ts"() {
-    "use strict";
-    init_make_migration();
-  }
-});
-
-// 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";
-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 = path5.join(process.cwd(), "database/migrations");
-  if (!fs5.existsSync(migrationsDir)) {
-    console.log("No migrations directory found.");
-    return;
-  }
-  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 = path5.join(migrationsDir, file);
-    try {
-      const migration = await import(filePath);
-      if (migration.up) {
-        const sql = await migration.up();
-        if (sql) {
-          const isRemote = args.includes("--remote");
-          const dbName = "DB";
-          const command = isRemote ? "--remote" : "--local";
-          try {
-            const execCmd = `npx wrangler d1 execute ${dbName} --command "${sql.replace(/"/g, '\\"')}" ${command}`;
-            console.log(`Executing: ${execCmd}`);
-            execSync2(execCmd, { stdio: "inherit" });
-          } catch (e) {
-            console.error(`Failed to execute migration: ${file}`);
-            throw e;
-          }
-        }
-      }
-    } catch (error) {
-      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();
-  }
-});
-
-// src/cli/index.ts
-var require_cli = __commonJS({
-  "src/cli/index.ts"() {
-    init_init();
-    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];
-    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;
-    }
-  }
-});
-export default require_cli();