@3lineas/d1-orm 1.0.3 → 1.0.5

package/README.md

@@ -1,52 +1,52 @@
 # D1 ORM
 
-Un ORM ligero y potente diseñado específicamente para Cloudflare D1, inspirado en Eloquent de Laravel.
+A lightweight and powerful ORM designed specifically for Cloudflare D1, inspired by Laravel's Eloquent.
 
-## Características
+## Features
 
-- 🚀 **Ligero y Rápido**: Optimizado para Cloudflare Workers.
-- 🛠 **Basado en Eloquent**: Sintaxis familiar para desarrolladores de Laravel.
-- 📦 **TypeScript**: Tipado estático completo para mayor seguridad.
-- relations **Relaciones**: Soporte para `hasOne`, `hasMany` y `belongsTo`.
-- ⌨️ **CLI Integrado**: Herramientas para migraciones y generación de modelos.
+- 🚀 **Lightweight & Fast**: Optimized for Cloudflare Workers environment.
+- 🛠 **Eloquent-based**: Familiar syntax for Laravel developers.
+- 📦 **TypeScript**: Full static typing for enhanced security.
+- 🔗 **Relationships**: Built-in support for `hasOne`, `hasMany`, and `belongsTo`.
+- ⌨️ **Integrated CLI**: Tools for migrations, model generation, and seeding.
 
-## Instalación
+## Installation
 
 ```bash
 npm install @3lineas/d1-orm
-# O usando pnpm
+# Or using pnpm
 pnpm add @3lineas/d1-orm
 ```
 
-## Configuración Inicial
+## Initial Setup
 
-Para comenzar, debes configurar la conexión a tu base de datos D1 en tu Worker. Normalmente esto se hace en el punto de entrada de tu aplicación (por ejemplo, `index.ts` o `server.ts`).
+To get started, configure the database connection in your Worker. This is typically done in your application's entry point (e.g., `index.ts` or `server.ts`).
 
 ```typescript
 import { Database } from "@3lineas/d1-orm";
 
 export default {
   async fetch(request, env, ctx) {
-    // Inicializa la conexión con tu base de datos D1 (asumiendo que se llama DB en wrangler.toml)
+    // Initialize the D1 connection (assuming it's named DB in wrangler.toml)
     Database.setup(env.DB);
 
-    // ... tu código de manejo de rutas
+    // ... your routing logic
   },
 };
 ```
 
-## Definición de Modelos
+## Defining Models
 
-Los modelos se definen extendiendo la clase `Model`. Por defecto, el ORM asumirá que la tabla es el nombre de la clase en plural y minúsculas (ej: `User` -> `users`).
+Define your models by extending the `Model` class. By default, the ORM assumes the table name is the lowercase plural form of the class name (e.g., `User` -> `users`).
 
 ```typescript
 import { Model } from "@3lineas/d1-orm";
 
 export class User extends Model {
-  // Opcional: Definir tabla personalizada
+  // Optional: Custom table name
   // protected static table = 'my_users';
 
-  // Opcional: Definir atributos para tipado (recomendado)
+  // Optional: Define attributes for typing (recommended)
   declare id: number;
   declare name: string;
   declare email: string;
@@ -54,49 +54,49 @@ export class User extends Model {
 }
 ```
 
-## Operaciones CRUD
+## CRUD Operations
 
-### Crear
+### Create
 
 ```typescript
 const user = await User.create({
-  name: "Juan Perez",
-  email: "juan@example.com",
+  name: "John Doe",
+  email: "john@example.com",
 });
 ```
 
-### Leer
+### Read
 
 ```typescript
-// Obtener todos los registros
+// Get all records
 const users = await User.all();
 
-// Encontrar por ID
+// Find by ID
 const user = await User.find(1);
 
-// Consultas personalizadas
+// Custom queries
 const activeUsers = await User.where("status", "=", "active")
   .orderBy("created_at", "desc")
   .get();
 
-// Obtener el primer resultado
-const firstUser = await User.where("email", "juan@example.com").first();
+// Get the first result
+const firstUser = await User.where("email", "john@example.com").first();
 ```
 
-### Actualizar
+### Update
 
 ```typescript
 const user = await User.find(1);
 if (user) {
-  user.fill({ name: "Juan Actualizado" });
+  user.fill({ name: "Updated Name" });
   await user.save();
 }
 
-// O actualizar directamente desde una consulta
+// Or update directly via query
 await User.where("status", "inactive").update({ status: "active" });
 ```
 
-### Eliminar
+### Delete
 
 ```typescript
 const user = await User.find(1);
@@ -104,104 +104,114 @@ if (user) {
   await user.delete();
 }
 
-// O eliminar directamente desde una consulta
+// Or delete directly via query
 await User.where("status", "banned").delete();
 ```
 
-## Relaciones
+## Relationships
 
-El ORM soporta relaciones básicas para estructurar tus datos.
+Support for basic relationships to structure your data.
 
-### Uno a Uno (HasOne)
+### One to One (HasOne)
 
 ```typescript
-// Modelo User
-hasOne(Profile) {
+// In User Model
+hasOneProfile() {
     return this.hasOne(Profile);
 }
 
-// Uso
-const profile = await user.hasOne(Profile).get();
+// Usage
+const profile = await user.hasOneProfile().get();
 ```
 
-### Uno a Muchos (HasMany)
+### One to Many (HasMany)
 
 ```typescript
-// Modelo User
+// In User Model
 posts() {
     return this.hasMany(Post);
 }
 
-// Uso
+// Usage
 const posts = await user.posts().get();
 ```
 
-### Pertenece A (BelongsTo)
+### Belongs To (BelongsTo)
 
 ```typescript
-// Modelo Post
+// In Post Model
 user() {
     return this.belongsTo(User);
 }
 
-// Uso
+// Usage
 const author = await post.user().get();
 ```
 
-## CLI y Migraciones
+## CLI & Migrations
 
-El ORM incluye una CLI para facilitar la gestión de la base de datos.
+The ORM includes a CLI to simplify database management.
 
-### Scripts Recomendados
+### Automatic Configuration
 
-Agrega este script a tu `package.json` para facilitar el uso:
+The `init` command will automatically configure the `orm` script in your `package.json`.
+
+To run the initial command (before the script is added):
+
+```bash
+npx d1-orm init
+```
+
+Once executed, the `orm` script will be added to your `package.json`:
 
 ```json
 "scripts": {
-    "orm": "npx tsx src/cli/index.ts"
+    "orm": "d1-orm"
 }
 ```
 
-### Comandos Disponibles
-
-#### Inicializar Proyecto
-
-Crea las carpetas necesarias (`models`, `database/migrations`).
+From then on, you can use:
 
 ```bash
-pnpm orm init
+pnpm orm ...
 ```
 
-#### Crear un Modelo
+### Available Commands
+
+#### Initialize Project
+
+An interactive command that sets up your project. It will ask where you want to keep your models and will automatically generate the directory structure, an example `User` model, its migration, and a seeder.
+
+#### Create a Model
 
-Genera un archivo de modelo en `src/models`.
+Generate a model file interactively. It allows you to optionally create a linked migration and seeder.
 
 ```bash
-pnpm orm make:model NombreModelo
+pnpm orm make:model
 ```
 
-#### Crear una Migración
+#### Create a Migration
 
-Genera un archivo de migración en `database/migrations`.
+Generate a migration file interactively in `database/migrations`.
 
 ```bash
-pnpm orm make:migration create_users_table
+pnpm orm make:migration
 ```
 
-#### Ejecutar Migraciones
+#### Run Migrations
 
-Ejecuta las migraciones pendientes.
+Run pending migrations.
 
 ```bash
-# Local (por defecto)
+# Local (default)
 pnpm orm migrate
 
-# Remoto (Producción)
-pnpm orm migrate -- --remote
+# Remote (Production)
+pnpm orm migrate --remote
 ```
 
-> **Nota:** Las migraciones locales requieren que `wrangler` esté configurado y funcionando correctamente en tu entorno.
+> **Note:** Local migrations require `wrangler` to be configured and running in your environment.
 
 ---
 
-Desarrollado con ❤️ por **3Lineas**.
+Crafted with ❤️ by **3Lineas**.

package/dist/cli/index.js

@@ -53,7 +53,7 @@ async function init() {
       console.log(`Directory already exists: ${folder}`);
     }
   });
-  const userModelContent = `import { Model } from 'd1-orm';
+  const userModelContent = `import { Model } from '@3lineas/d1-orm';
 
 export class User extends Model {
     // protected static table = 'users';
@@ -73,7 +73,7 @@ export class User extends Model {
   }
   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 'd1-orm';
+  const migrationContent = `import { Blueprint, Schema } from '@3lineas/d1-orm';
 
 export const up = async () => {
     return Schema.create('users', (table: Blueprint) => {
@@ -105,8 +105,8 @@ export const down = async () => {
 
 export const seed = async () => {
     await User.create({
-        name: 'Juan Perez',
-        email: 'juan@perez.com',
+        name: 'John Doe',
+        email: 'john@example.com',
         password: 'password'
     });
 };
@@ -120,59 +120,166 @@ export const seed = async () => {
     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);
+    }
+  }
 }
 
 // src/cli/commands/make-model.ts
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var p2 = __toESM(require("@clack/prompts"));
+
+// src/cli/commands/make-migration.ts
 var fs2 = __toESM(require("fs"));
 var path2 = __toESM(require("path"));
-function makeModel(name) {
-  const filename = `${name}.ts`;
-  const targetPath = path2.join(process.cwd(), "models", filename);
-  const template = `import { Model } from 'd1-orm';
-
-export class ${name} extends Model {
-    // protected static table = '${name.toLowerCase()}s'; 
-    
-    // Define attributes explicitly for type safety if desired
-    // declare id: number;
-    // declare created_at: string;
-    // declare updated_at: string;
-}
-`;
-  if (fs2.existsSync(targetPath)) {
-    console.error(`Model ${filename} already exists.`);
-    process.exit(1);
+var p = __toESM(require("@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;
+    }
   }
-  fs2.writeFileSync(targetPath, template);
-  console.log(`Created model: models/${filename}`);
-}
-
-// src/cli/commands/make-migration.ts
-var fs3 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
-function makeMigration(name) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").split(".")[0].replace("T", "_");
-  const filename = `${timestamp}_${name}.ts`;
-  const targetPath = path3.join(process.cwd(), "database/migrations", filename);
-  const template = `import { Blueprint, Schema } from 'd1-orm';
+  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('${name}', (table: Blueprint) => {
+    return Schema.create('${migrationName.replace("create_", "").replace("_table", "")}', (table: Blueprint) => {
         table.id();
         table.timestamps();
     });
 };
 
 export const down = async () => {
-    return Schema.dropIfExists('${name}');
+    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}`);
+}
+
+// src/cli/commands/make-model.ts
+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)) {
-    console.error(`Migration ${filename} already exists.`);
-    process.exit(1);
+    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);
-  console.log(`Created migration: database/migrations/${filename}`);
+  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}';
+
+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}`);
 }
 
 // src/cli/commands/migrate.ts
@@ -188,23 +295,22 @@ async function migrate(args2) {
   }
   const files = fs4.readdirSync(migrationsDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js")).sort();
   for (const file of files) {
-    console.log(`Processing ${file}...`);
+    console.log(`Processing migration: ${file}`);
     const filePath = path4.join(migrationsDir, file);
     try {
       const migration = await import(filePath);
       if (migration.up) {
         const sql = await migration.up();
         if (sql) {
-          console.log(`Executing SQL: ${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(`Running: ${execCmd}`);
+            console.log(`Executing: ${execCmd}`);
             (0, import_child_process.execSync)(execCmd, { stdio: "inherit" });
           } catch (e) {
-            console.error(`Failed to execute migration ${file}.`);
+            console.error(`Failed to execute migration: ${file}`);
             throw e;
           }
         }
@@ -224,17 +330,9 @@ switch (command) {
     init();
     break;
   case "make:model":
-    if (!param) {
-      console.error("Usage: d1-orm make:model <Name>");
-      process.exit(1);
-    }
     makeModel(param);
     break;
   case "make:migration":
-    if (!param) {
-      console.error("Usage: d1-orm make:migration <Name>");
-      process.exit(1);
-    }
     makeMigration(param);
     break;
   case "migrate":