@3lineas/d1-orm 1.0.3

package/dist/cli/index.mjs

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+import {
+  __commonJS,
+  __esm
+} from "../chunk-X6BYQHVC.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 '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}`);
+  }
+}
+var init_init = __esm({
+  "src/cli/commands/init.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/commands/make-model.ts
+import * as fs2 from "fs";
+import * as path2 from "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}`);
+}
+var init_make_model = __esm({
+  "src/cli/commands/make-model.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/commands/make-migration.ts
+import * as fs3 from "fs";
+import * as path3 from "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}`);
+}
+var init_make_migration = __esm({
+  "src/cli/commands/make-migration.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/commands/migrate.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import { execSync } from "child_process";
+async function migrate(args) {
+  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 = 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(`Running: ${execCmd}`);
+            execSync(execCmd, { stdio: "inherit" });
+          } catch (e) {
+            console.error(`Failed to execute migration ${file}.`);
+            throw e;
+          }
+        }
+      }
+    } catch (error) {
+      console.error(`Error processing migration ${file}:`, error);
+    }
+  }
+}
+var init_migrate = __esm({
+  "src/cli/commands/migrate.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/index.ts
+var require_cli = __commonJS({
+  "src/cli/index.ts"() {
+    init_init();
+    init_make_model();
+    init_make_migration();
+    init_migrate();
+    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;
+    }
+  }
+});
+export default require_cli();

package/dist/index.d.mts

@@ -0,0 +1,155 @@
+interface D1Database {
+    prepare(query: string): D1PreparedStatement;
+    dump(): Promise<ArrayBuffer>;
+    batch<T = unknown>(statements: D1PreparedStatement[]): Promise<D1Result<T>[]>;
+    exec(query: string): Promise<D1ExecResult>;
+}
+interface D1PreparedStatement {
+    bind(...values: unknown[]): D1PreparedStatement;
+    first<T = unknown>(colName?: string): Promise<T | null>;
+    run<T = unknown>(): Promise<D1Result<T>>;
+    all<T = unknown>(): Promise<D1Result<T>>;
+    raw<T = unknown>(): Promise<T[]>;
+}
+interface D1Result<T = unknown> {
+    results: T[];
+    success: boolean;
+    meta: any;
+    error?: string;
+}
+interface D1ExecResult {
+    count: number;
+    duration: number;
+}
+
+declare class Connection {
+    protected db: D1Database;
+    constructor(database: D1Database);
+    select(query: string, bindings?: any[]): Promise<any[]>;
+    insert(query: string, bindings?: any[]): Promise<boolean>;
+    update(query: string, bindings?: any[]): Promise<boolean>;
+    delete(query: string, bindings?: any[]): Promise<boolean>;
+    statement(query: string, bindings?: any[]): Promise<boolean>;
+}
+
+type D1Value = string | number | boolean | null;
+declare class QueryBuilder {
+    protected connection: Connection;
+    protected table: string;
+    protected columns: string[];
+    protected wheres: string[];
+    protected bindings: D1Value[];
+    protected orders: string[];
+    protected limitValue: number | null;
+    protected offsetValue: number | null;
+    constructor(connection: Connection, table: string);
+    select(...columns: string[]): this;
+    where(column: string, operator: string, value?: D1Value): this;
+    orWhere(column: string, operator: string, value?: D1Value): this;
+    orderBy(column: string, direction?: "asc" | "desc"): this;
+    limit(limit: number): this;
+    offset(offset: number): this;
+    toSql(): {
+        sql: string;
+        bindings: D1Value[];
+    };
+    get<T = any>(): Promise<T[]>;
+    first<T = any>(): Promise<T | null>;
+    insert(data: Record<string, D1Value>): Promise<boolean>;
+    update(data: Record<string, D1Value>): Promise<boolean>;
+    delete(): Promise<boolean>;
+}
+
+declare class Database {
+    private static instance;
+    connection: Connection;
+    private constructor();
+    static setup(d1: D1Database): void;
+    static getInstance(): Database;
+}
+
+declare abstract class Relationship<Related extends Model> {
+    protected query: ModelQueryBuilder<Related>;
+    protected parent: Model;
+    constructor(query: ModelQueryBuilder<Related>, parent: Model);
+    abstract addConstraints(): void;
+    getQuery(): ModelQueryBuilder<Related>;
+    get(): Promise<Related[]>;
+    first(): Promise<Related | null>;
+}
+
+declare class HasOne<Related extends Model> extends Relationship<Related> {
+    protected foreignKey: string;
+    protected localKey: string;
+    constructor(query: ModelQueryBuilder<Related>, parent: Model, foreignKey: string, localKey: string);
+    addConstraints(): void;
+}
+
+declare class HasMany<Related extends Model> extends Relationship<Related> {
+    protected foreignKey: string;
+    protected localKey: string;
+    constructor(query: ModelQueryBuilder<Related>, parent: Model, foreignKey: string, localKey: string);
+    addConstraints(): void;
+}
+
+declare class BelongsTo<Related extends Model> extends Relationship<Related> {
+    protected foreignKey: string;
+    protected ownerKey: string;
+    constructor(query: ModelQueryBuilder<Related>, parent: Model, foreignKey: string, ownerKey: string);
+    addConstraints(): void;
+}
+
+declare class Model {
+    protected static table: string;
+    protected static connectionResolver: () => Database;
+    attributes: Record<string, D1Value>;
+    protected fillable: string[];
+    protected hidden: string[];
+    exists: boolean;
+    protected original: Record<string, D1Value>;
+    constructor(attributes?: Record<string, D1Value>);
+    static query<T extends Model>(this: new () => T): ModelQueryBuilder<T>;
+    static on(connectionName?: string): ModelQueryBuilder<Model>;
+    static all<T extends Model>(this: new () => T): Promise<T[]>;
+    static find<T extends Model>(this: new () => T, id: number | string): Promise<T | null>;
+    static create<T extends Model>(this: new () => T, attributes: Record<string, D1Value>): Promise<T>;
+    fill(attributes: Record<string, D1Value>): this;
+    save(): Promise<boolean>;
+    delete(): Promise<boolean>;
+    getTable(): string;
+    getDirty(): Record<string, D1Value>;
+    syncOriginal(): void;
+    hasOne<Related extends Model>(related: new () => Related, foreignKey?: string, localKey?: string): HasOne<Related>;
+    hasMany<Related extends Model>(related: new () => Related, foreignKey?: string, localKey?: string): HasMany<Related>;
+    belongsTo<Related extends Model>(related: new () => Related, foreignKey?: string, ownerKey?: string): BelongsTo<Related>;
+    getForeignKey(): string;
+    newQuery<T extends Model>(this: T): ModelQueryBuilder<T>;
+}
+
+declare class ModelQueryBuilder<T extends Model> extends QueryBuilder {
+    protected modelClass: typeof Model;
+    constructor(connection: any, table: string, modelClass: typeof Model);
+    get<M = T>(): Promise<M[]>;
+    first<M = T>(): Promise<M | null>;
+    getModel(): typeof Model;
+}
+
+declare class Blueprint {
+    protected table: string;
+    protected columns: string[];
+    protected commands: string[];
+    constructor(table: string);
+    id(): this;
+    string(column: string, length?: number): this;
+    integer(column: string): this;
+    boolean(column: string): this;
+    timestamps(): this;
+    toSql(): string[];
+}
+
+declare class Schema {
+    static create(table: string, callback: (table: Blueprint) => void): string;
+    static dropIfExists(table: string): string;
+}
+
+export { BelongsTo, Blueprint, Connection, type D1Database, type D1ExecResult, type D1PreparedStatement, type D1Result, type D1Value, Database, HasMany, HasOne, Model, ModelQueryBuilder, QueryBuilder, Relationship, Schema };

package/dist/index.d.ts

@@ -0,0 +1,155 @@
+interface D1Database {
+    prepare(query: string): D1PreparedStatement;
+    dump(): Promise<ArrayBuffer>;
+    batch<T = unknown>(statements: D1PreparedStatement[]): Promise<D1Result<T>[]>;
+    exec(query: string): Promise<D1ExecResult>;
+}
+interface D1PreparedStatement {
+    bind(...values: unknown[]): D1PreparedStatement;
+    first<T = unknown>(colName?: string): Promise<T | null>;
+    run<T = unknown>(): Promise<D1Result<T>>;
+    all<T = unknown>(): Promise<D1Result<T>>;
+    raw<T = unknown>(): Promise<T[]>;
+}
+interface D1Result<T = unknown> {
+    results: T[];
+    success: boolean;
+    meta: any;
+    error?: string;
+}
+interface D1ExecResult {
+    count: number;
+    duration: number;
+}
+
+declare class Connection {
+    protected db: D1Database;
+    constructor(database: D1Database);
+    select(query: string, bindings?: any[]): Promise<any[]>;
+    insert(query: string, bindings?: any[]): Promise<boolean>;
+    update(query: string, bindings?: any[]): Promise<boolean>;
+    delete(query: string, bindings?: any[]): Promise<boolean>;
+    statement(query: string, bindings?: any[]): Promise<boolean>;
+}
+
+type D1Value = string | number | boolean | null;
+declare class QueryBuilder {
+    protected connection: Connection;
+    protected table: string;
+    protected columns: string[];
+    protected wheres: string[];
+    protected bindings: D1Value[];
+    protected orders: string[];
+    protected limitValue: number | null;
+    protected offsetValue: number | null;
+    constructor(connection: Connection, table: string);
+    select(...columns: string[]): this;
+    where(column: string, operator: string, value?: D1Value): this;
+    orWhere(column: string, operator: string, value?: D1Value): this;
+    orderBy(column: string, direction?: "asc" | "desc"): this;
+    limit(limit: number): this;
+    offset(offset: number): this;
+    toSql(): {
+        sql: string;
+        bindings: D1Value[];
+    };
+    get<T = any>(): Promise<T[]>;
+    first<T = any>(): Promise<T | null>;
+    insert(data: Record<string, D1Value>): Promise<boolean>;
+    update(data: Record<string, D1Value>): Promise<boolean>;
+    delete(): Promise<boolean>;
+}
+
+declare class Database {
+    private static instance;
+    connection: Connection;
+    private constructor();
+    static setup(d1: D1Database): void;
+    static getInstance(): Database;
+}
+
+declare abstract class Relationship<Related extends Model> {
+    protected query: ModelQueryBuilder<Related>;
+    protected parent: Model;
+    constructor(query: ModelQueryBuilder<Related>, parent: Model);
+    abstract addConstraints(): void;
+    getQuery(): ModelQueryBuilder<Related>;
+    get(): Promise<Related[]>;
+    first(): Promise<Related | null>;
+}
+
+declare class HasOne<Related extends Model> extends Relationship<Related> {
+    protected foreignKey: string;
+    protected localKey: string;
+    constructor(query: ModelQueryBuilder<Related>, parent: Model, foreignKey: string, localKey: string);
+    addConstraints(): void;
+}
+
+declare class HasMany<Related extends Model> extends Relationship<Related> {
+    protected foreignKey: string;
+    protected localKey: string;
+    constructor(query: ModelQueryBuilder<Related>, parent: Model, foreignKey: string, localKey: string);
+    addConstraints(): void;
+}
+
+declare class BelongsTo<Related extends Model> extends Relationship<Related> {
+    protected foreignKey: string;
+    protected ownerKey: string;
+    constructor(query: ModelQueryBuilder<Related>, parent: Model, foreignKey: string, ownerKey: string);
+    addConstraints(): void;
+}
+
+declare class Model {
+    protected static table: string;
+    protected static connectionResolver: () => Database;
+    attributes: Record<string, D1Value>;
+    protected fillable: string[];
+    protected hidden: string[];
+    exists: boolean;
+    protected original: Record<string, D1Value>;
+    constructor(attributes?: Record<string, D1Value>);
+    static query<T extends Model>(this: new () => T): ModelQueryBuilder<T>;
+    static on(connectionName?: string): ModelQueryBuilder<Model>;
+    static all<T extends Model>(this: new () => T): Promise<T[]>;
+    static find<T extends Model>(this: new () => T, id: number | string): Promise<T | null>;
+    static create<T extends Model>(this: new () => T, attributes: Record<string, D1Value>): Promise<T>;
+    fill(attributes: Record<string, D1Value>): this;
+    save(): Promise<boolean>;
+    delete(): Promise<boolean>;
+    getTable(): string;
+    getDirty(): Record<string, D1Value>;
+    syncOriginal(): void;
+    hasOne<Related extends Model>(related: new () => Related, foreignKey?: string, localKey?: string): HasOne<Related>;
+    hasMany<Related extends Model>(related: new () => Related, foreignKey?: string, localKey?: string): HasMany<Related>;
+    belongsTo<Related extends Model>(related: new () => Related, foreignKey?: string, ownerKey?: string): BelongsTo<Related>;
+    getForeignKey(): string;
+    newQuery<T extends Model>(this: T): ModelQueryBuilder<T>;
+}
+
+declare class ModelQueryBuilder<T extends Model> extends QueryBuilder {
+    protected modelClass: typeof Model;
+    constructor(connection: any, table: string, modelClass: typeof Model);
+    get<M = T>(): Promise<M[]>;
+    first<M = T>(): Promise<M | null>;
+    getModel(): typeof Model;
+}
+
+declare class Blueprint {
+    protected table: string;
+    protected columns: string[];
+    protected commands: string[];
+    constructor(table: string);
+    id(): this;
+    string(column: string, length?: number): this;
+    integer(column: string): this;
+    boolean(column: string): this;
+    timestamps(): this;
+    toSql(): string[];
+}
+
+declare class Schema {
+    static create(table: string, callback: (table: Blueprint) => void): string;
+    static dropIfExists(table: string): string;
+}
+
+export { BelongsTo, Blueprint, Connection, type D1Database, type D1ExecResult, type D1PreparedStatement, type D1Result, type D1Value, Database, HasMany, HasOne, Model, ModelQueryBuilder, QueryBuilder, Relationship, Schema };