@3lineas/d1-orm 1.0.3

package/dist/index.js

@@ -0,0 +1,474 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BelongsTo: () => BelongsTo,
+  Blueprint: () => Blueprint,
+  Connection: () => Connection,
+  Database: () => Database,
+  HasMany: () => HasMany,
+  HasOne: () => HasOne,
+  Model: () => Model,
+  ModelQueryBuilder: () => ModelQueryBuilder,
+  QueryBuilder: () => QueryBuilder,
+  Relationship: () => Relationship,
+  Schema: () => Schema
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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}`;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BelongsTo,
+  Blueprint,
+  Connection,
+  Database,
+  HasMany,
+  HasOne,
+  Model,
+  ModelQueryBuilder,
+  QueryBuilder,
+  Relationship,
+  Schema
+});