@3lineas/d1-orm 1.0.3

package/README.md

@@ -0,0 +1,207 @@
+# D1 ORM
+
+Un ORM ligero y potente diseñado específicamente para Cloudflare D1, inspirado en Eloquent de Laravel.
+
+## Características
+
+- 🚀 **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.
+
+## Instalación
+
+```bash
+npm install @3lineas/d1-orm
+# O usando pnpm
+pnpm add @3lineas/d1-orm
+```
+
+## Configuración Inicial
+
+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`).
+
+```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)
+    Database.setup(env.DB);
+
+    // ... tu código de manejo de rutas
+  },
+};
+```
+
+## Definición de Modelos
+
+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`).
+
+```typescript
+import { Model } from "@3lineas/d1-orm";
+
+export class User extends Model {
+  // Opcional: Definir tabla personalizada
+  // protected static table = 'my_users';
+
+  // Opcional: Definir atributos para tipado (recomendado)
+  declare id: number;
+  declare name: string;
+  declare email: string;
+  declare created_at: string;
+}
+```
+
+## Operaciones CRUD
+
+### Crear
+
+```typescript
+const user = await User.create({
+  name: "Juan Perez",
+  email: "juan@example.com",
+});
+```
+
+### Leer
+
+```typescript
+// Obtener todos los registros
+const users = await User.all();
+
+// Encontrar por ID
+const user = await User.find(1);
+
+// Consultas personalizadas
+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();
+```
+
+### Actualizar
+
+```typescript
+const user = await User.find(1);
+if (user) {
+  user.fill({ name: "Juan Actualizado" });
+  await user.save();
+}
+
+// O actualizar directamente desde una consulta
+await User.where("status", "inactive").update({ status: "active" });
+```
+
+### Eliminar
+
+```typescript
+const user = await User.find(1);
+if (user) {
+  await user.delete();
+}
+
+// O eliminar directamente desde una consulta
+await User.where("status", "banned").delete();
+```
+
+## Relaciones
+
+El ORM soporta relaciones básicas para estructurar tus datos.
+
+### Uno a Uno (HasOne)
+
+```typescript
+// Modelo User
+hasOne(Profile) {
+    return this.hasOne(Profile);
+}
+
+// Uso
+const profile = await user.hasOne(Profile).get();
+```
+
+### Uno a Muchos (HasMany)
+
+```typescript
+// Modelo User
+posts() {
+    return this.hasMany(Post);
+}
+
+// Uso
+const posts = await user.posts().get();
+```
+
+### Pertenece A (BelongsTo)
+
+```typescript
+// Modelo Post
+user() {
+    return this.belongsTo(User);
+}
+
+// Uso
+const author = await post.user().get();
+```
+
+## CLI y Migraciones
+
+El ORM incluye una CLI para facilitar la gestión de la base de datos.
+
+### Scripts Recomendados
+
+Agrega este script a tu `package.json` para facilitar el uso:
+
+```json
+"scripts": {
+    "orm": "npx tsx src/cli/index.ts"
+}
+```
+
+### Comandos Disponibles
+
+#### Inicializar Proyecto
+
+Crea las carpetas necesarias (`models`, `database/migrations`).
+
+```bash
+pnpm orm init
+```
+
+#### Crear un Modelo
+
+Genera un archivo de modelo en `src/models`.
+
+```bash
+pnpm orm make:model NombreModelo
+```
+
+#### Crear una Migración
+
+Genera un archivo de migración en `database/migrations`.
+
+```bash
+pnpm orm make:migration create_users_table
+```
+
+#### Ejecutar Migraciones
+
+Ejecuta las migraciones pendientes.
+
+```bash
+# Local (por defecto)
+pnpm orm migrate
+
+# Remoto (Producción)
+pnpm orm migrate -- --remote
+```
+
+> **Nota:** Las migraciones locales requieren que `wrangler` esté configurado y funcionando correctamente en tu entorno.
+
+---
+
+Desarrollado con ❤️ por **3Lineas**.

package/dist/chunk-X6BYQHVC.mjs

@@ -0,0 +1,12 @@
+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
+};

package/dist/cli/index.d.mts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/index.js

@@ -0,0 +1,250 @@
+#!/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"));
+var path = __toESM(require("path"));
+var readline = __toESM(require("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 '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 '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, "/")}';
+
+export const seed = async () => {
+    await User.create({
+        name: 'Juan Perez',
+        email: 'juan@perez.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}`);
+  }
+}
+
+// src/cli/commands/make-model.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);
+  }
+  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';
+
+export const up = async () => {
+    return Schema.create('${name}', (table: Blueprint) => {
+        table.id();
+        table.timestamps();
+    });
+};
+
+export const down = async () => {
+    return Schema.dropIfExists('${name}');
+};
+`;
+  if (fs3.existsSync(targetPath)) {
+    console.error(`Migration ${filename} already exists.`);
+    process.exit(1);
+  }
+  fs3.writeFileSync(targetPath, template);
+  console.log(`Created migration: database/migrations/${filename}`);
+}
+
+// src/cli/commands/migrate.ts
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var import_child_process = require("child_process");
+async function migrate(args2) {
+  console.log("Running migrations...");
+  const migrationsDir = path4.join(process.cwd(), "database/migrations");
+  if (!fs4.existsSync(migrationsDir)) {
+    console.log("No migrations directory found.");
+    return;
+  }
+  const files = fs4.readdirSync(migrationsDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js")).sort();
+  for (const file of files) {
+    console.log(`Processing ${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}`);
+            (0, import_child_process.execSync)(execCmd, { stdio: "inherit" });
+          } catch (e) {
+            console.error(`Failed to execute migration ${file}.`);
+            throw e;
+          }
+        }
+      }
+    } catch (error) {
+      console.error(`Error processing migration ${file}:`, 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":
+    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":
+    const isLocal = args.includes("--local");
+    const isRemote = args.includes("--remote");
+    migrate(args);
+    break;
+  default:
+    console.log(
+      "Available commands: init, make:model, make:migration, migrate"
+    );
+    break;
+}