@3lineas/d1-orm 1.0.3

package/dist/index.mjs

@@ -0,0 +1,439 @@
+import "./chunk-X6BYQHVC.mjs";
+
+// src/core/connection.ts
+var Connection = class {
+  db;
+  constructor(database) {
+    this.db = database;
+  }
+  async select(query, bindings = []) {
+    const stmt = this.db.prepare(query).bind(...bindings);
+    const result = await stmt.all();
+    return result.results || [];
+  }
+  async insert(query, bindings = []) {
+    const stmt = this.db.prepare(query).bind(...bindings);
+    const result = await stmt.run();
+    return result.success;
+  }
+  async update(query, bindings = []) {
+    const stmt = this.db.prepare(query).bind(...bindings);
+    const result = await stmt.run();
+    return result.success;
+  }
+  async delete(query, bindings = []) {
+    const stmt = this.db.prepare(query).bind(...bindings);
+    const result = await stmt.run();
+    return result.success;
+  }
+  async statement(query, bindings = []) {
+    const stmt = this.db.prepare(query).bind(...bindings);
+    const result = await stmt.run();
+    return result.success;
+  }
+};
+
+// src/core/query-builder.ts
+var QueryBuilder = class {
+  connection;
+  table;
+  columns = ["*"];
+  wheres = [];
+  bindings = [];
+  orders = [];
+  limitValue = null;
+  offsetValue = null;
+  constructor(connection, table) {
+    this.connection = connection;
+    this.table = table;
+  }
+  select(...columns) {
+    this.columns = columns.length > 0 ? columns : ["*"];
+    return this;
+  }
+  where(column, operator, value) {
+    if (value === void 0) {
+      value = operator;
+      operator = "=";
+    }
+    this.wheres.push(`${column} ${operator} ?`);
+    this.bindings.push(value);
+    return this;
+  }
+  orWhere(column, operator, value) {
+    if (value === void 0) {
+      value = operator;
+      operator = "=";
+    }
+    this.wheres.push(`OR ${column} ${operator} ?`);
+    this.bindings.push(value);
+    return this;
+  }
+  orderBy(column, direction = "asc") {
+    this.orders.push(`${column} ${direction.toUpperCase()}`);
+    return this;
+  }
+  limit(limit) {
+    this.limitValue = limit;
+    return this;
+  }
+  offset(offset) {
+    this.offsetValue = offset;
+    return this;
+  }
+  toSql() {
+    let sql = `SELECT ${this.columns.join(", ")} FROM ${this.table}`;
+    if (this.wheres.length > 0) {
+      const constraints = this.wheres.map((w, i) => {
+        if (i === 0) return w.replace(/^OR\s+/, "");
+        return w.startsWith("OR") ? w : `AND ${w}`;
+      });
+      sql += ` WHERE ${constraints.join(" ")}`;
+    }
+    if (this.orders.length > 0) {
+      sql += ` ORDER BY ${this.orders.join(", ")}`;
+    }
+    if (this.limitValue !== null) {
+      sql += ` LIMIT ${this.limitValue}`;
+    }
+    if (this.offsetValue !== null) {
+      sql += ` OFFSET ${this.offsetValue}`;
+    }
+    return { sql, bindings: this.bindings };
+  }
+  async get() {
+    const { sql, bindings } = this.toSql();
+    return this.connection.select(sql, bindings);
+  }
+  async first() {
+    this.limit(1);
+    const results = await this.get();
+    return results.length > 0 ? results[0] : null;
+  }
+  async insert(data) {
+    const columns = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = values.map(() => "?").join(", ");
+    const sql = `INSERT INTO ${this.table} (${columns.join(", ")}) VALUES (${placeholders})`;
+    return this.connection.insert(sql, values);
+  }
+  async update(data) {
+    const columns = Object.keys(data);
+    const values = Object.values(data);
+    const sets = columns.map((col) => `${col} = ?`).join(", ");
+    let sql = `UPDATE ${this.table} SET ${sets}`;
+    if (this.wheres.length > 0) {
+      const constraints = this.wheres.map((w, i) => {
+        if (i === 0) return w.replace(/^OR\s+/, "");
+        return w.startsWith("OR") ? w : `AND ${w}`;
+      });
+      sql += ` WHERE ${constraints.join(" ")}`;
+    } else {
+    }
+    return this.connection.update(sql, [...values, ...this.bindings]);
+  }
+  async delete() {
+    let sql = `DELETE FROM ${this.table}`;
+    if (this.wheres.length > 0) {
+      const constraints = this.wheres.map((w, i) => {
+        if (i === 0) return w.replace(/^OR\s+/, "");
+        return w.startsWith("OR") ? w : `AND ${w}`;
+      });
+      sql += ` WHERE ${constraints.join(" ")}`;
+    }
+    return this.connection.delete(sql, this.bindings);
+  }
+};
+
+// src/core/model-query-builder.ts
+var ModelQueryBuilder = class extends QueryBuilder {
+  modelClass;
+  constructor(connection, table, modelClass) {
+    super(connection, table);
+    this.modelClass = modelClass;
+  }
+  async get() {
+    const { sql, bindings } = this.toSql();
+    const results = await this.connection.select(sql, bindings);
+    return results.map((result) => {
+      const instance = new this.modelClass(result);
+      instance.exists = true;
+      instance.syncOriginal();
+      return instance;
+    });
+  }
+  async first() {
+    this.limit(1);
+    const results = await this.get();
+    return results.length > 0 ? results[0] : null;
+  }
+  getModel() {
+    return this.modelClass;
+  }
+};
+
+// src/core/database.ts
+var Database = class _Database {
+  static instance;
+  connection;
+  constructor(d1) {
+    this.connection = new Connection(d1);
+  }
+  static setup(d1) {
+    _Database.instance = new _Database(d1);
+  }
+  static getInstance() {
+    if (!_Database.instance) {
+      throw new Error(
+        "Database not initialized. Call Database.setup(env.DB) first."
+      );
+    }
+    return _Database.instance;
+  }
+};
+
+// src/core/relationships/relationship.ts
+var Relationship = class {
+  query;
+  parent;
+  constructor(query, parent) {
+    this.query = query;
+    this.parent = parent;
+  }
+  getQuery() {
+    return this.query;
+  }
+  // Common methods proxying to query helper
+  async get() {
+    return this.query.get();
+  }
+  async first() {
+    return this.query.first();
+  }
+};
+
+// src/core/relationships/has-one.ts
+var HasOne = class extends Relationship {
+  foreignKey;
+  localKey;
+  constructor(query, parent, foreignKey, localKey) {
+    super(query, parent);
+    this.foreignKey = foreignKey;
+    this.localKey = localKey;
+    this.addConstraints();
+  }
+  addConstraints() {
+    const value = this.parent.attributes[this.localKey];
+    this.query.where(this.foreignKey, "=", value);
+    this.query.limit(1);
+  }
+};
+
+// src/core/relationships/has-many.ts
+var HasMany = class extends Relationship {
+  foreignKey;
+  localKey;
+  constructor(query, parent, foreignKey, localKey) {
+    super(query, parent);
+    this.foreignKey = foreignKey;
+    this.localKey = localKey;
+    this.addConstraints();
+  }
+  addConstraints() {
+    const value = this.parent.attributes[this.localKey];
+    this.query.where(this.foreignKey, "=", value);
+  }
+};
+
+// src/core/relationships/belongs-to.ts
+var BelongsTo = class extends Relationship {
+  foreignKey;
+  // on parent
+  ownerKey;
+  // on related
+  constructor(query, parent, foreignKey, ownerKey) {
+    super(query, parent);
+    this.foreignKey = foreignKey;
+    this.ownerKey = ownerKey;
+    this.addConstraints();
+  }
+  addConstraints() {
+    const value = this.parent.attributes[this.foreignKey];
+    this.query.where(this.ownerKey, "=", value);
+    this.query.limit(1);
+  }
+};
+
+// src/models/model.ts
+var Model = class {
+  static table;
+  static connectionResolver;
+  attributes = {};
+  fillable = [];
+  hidden = [];
+  exists = false;
+  original = {};
+  constructor(attributes = {}) {
+    this.fill(attributes);
+  }
+  // Static Query Builder
+  static query() {
+    const instance = new this();
+    const table = instance.getTable();
+    const connection = Database.getInstance().connection;
+    return new ModelQueryBuilder(connection, table, this);
+  }
+  static on(connectionName) {
+    return this.query();
+  }
+  static async all() {
+    return this.query().get();
+  }
+  static async find(id) {
+    return this.query().where("id", "=", id).first();
+  }
+  static async create(attributes) {
+    const instance = new this();
+    instance.fill(attributes);
+    await instance.save();
+    return instance;
+  }
+  // Instance Methods
+  fill(attributes) {
+    Object.assign(this.attributes, attributes);
+    return this;
+  }
+  async save() {
+    const query = this.constructor.query();
+    if (this.exists) {
+      const dirty = this.getDirty();
+      if (Object.keys(dirty).length === 0) return true;
+      const id = this.attributes["id"];
+      await query.where("id", "=", id).update(dirty);
+      this.syncOriginal();
+      return true;
+    } else {
+      const result = await query.insert(this.attributes);
+      if (result) {
+        this.exists = true;
+        this.syncOriginal();
+        return true;
+      }
+      return false;
+    }
+  }
+  async delete() {
+    if (!this.exists) return false;
+    const query = this.constructor.query();
+    const id = this.attributes["id"];
+    await query.where("id", "=", id).delete();
+    this.exists = false;
+    return true;
+  }
+  getTable() {
+    if (this.constructor.table) {
+      return this.constructor.table;
+    }
+    return this.constructor.name.toLowerCase() + "s";
+  }
+  getDirty() {
+    const dirty = {};
+    for (const key in this.attributes) {
+      if (this.attributes[key] !== this.original[key]) {
+        dirty[key] = this.attributes[key];
+      }
+    }
+    return dirty;
+  }
+  syncOriginal() {
+    this.original = { ...this.attributes };
+  }
+  // Relationships
+  hasOne(related, foreignKey, localKey) {
+    const instance = new related();
+    const fk = foreignKey || this.getForeignKey();
+    const lk = localKey || "id";
+    return new HasOne(instance.newQuery(), this, fk, lk);
+  }
+  hasMany(related, foreignKey, localKey) {
+    const instance = new related();
+    const fk = foreignKey || this.getForeignKey();
+    const lk = localKey || "id";
+    return new HasMany(instance.newQuery(), this, fk, lk);
+  }
+  belongsTo(related, foreignKey, ownerKey) {
+    const instance = new related();
+    const fk = foreignKey || instance.getForeignKey();
+    const ok = ownerKey || "id";
+    return new BelongsTo(instance.newQuery(), this, fk, ok);
+  }
+  getForeignKey() {
+    return this.getTable().slice(0, -1) + "_id";
+  }
+  newQuery() {
+    return this.constructor.query();
+  }
+};
+
+// src/database/blueprint.ts
+var Blueprint = class {
+  table;
+  columns = [];
+  commands = [];
+  constructor(table) {
+    this.table = table;
+  }
+  id() {
+    this.columns.push("id INTEGER PRIMARY KEY AUTOINCREMENT");
+    return this;
+  }
+  string(column, length) {
+    this.columns.push(`${column} TEXT`);
+    return this;
+  }
+  integer(column) {
+    this.columns.push(`${column} INTEGER`);
+    return this;
+  }
+  boolean(column) {
+    this.columns.push(`${column} BOOLEAN`);
+    return this;
+  }
+  timestamps() {
+    this.columns.push("created_at DATETIME DEFAULT CURRENT_TIMESTAMP");
+    this.columns.push("updated_at DATETIME DEFAULT CURRENT_TIMESTAMP");
+    return this;
+  }
+  toSql() {
+    if (this.columns.length > 0) {
+      const cols = this.columns.join(", ");
+      return [`CREATE TABLE IF NOT EXISTS ${this.table} (${cols})`];
+    }
+    return this.commands;
+  }
+};
+
+// src/database/schema.ts
+var Schema = class {
+  static create(table, callback) {
+    const blueprint = new Blueprint(table);
+    callback(blueprint);
+    return blueprint.toSql()[0];
+  }
+  static dropIfExists(table) {
+    return `DROP TABLE IF EXISTS ${table}`;
+  }
+};
+export {
+  BelongsTo,
+  Blueprint,
+  Connection,
+  Database,
+  HasMany,
+  HasOne,
+  Model,
+  ModelQueryBuilder,
+  QueryBuilder,
+  Relationship,
+  Schema
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@3lineas/d1-orm",
+  "version": "1.0.3",
+  "description": "",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "d1-orm": "./dist/cli/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/cli/index.ts --format cjs,esm --dts --clean",
+    "orm": "npx tsx src/cli/index.ts",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20260124.0",
+    "@types/node": "^25.0.10",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18",
+    "wrangler": "^4.60.0"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild",
+      "sharp",
+      "workerd"
+    ]
+  }
+}