ilana-orm 1.0.0

package/orm/Relation.js

@@ -0,0 +1,299 @@
+const QueryBuilder = require('./QueryBuilder');
+const Model = require('./Model');
+const ModelRegistry = require('./ModelRegistry');
+
+class Relation {
+  constructor(parent, related, foreignKey, localKey = 'id') {
+    this.parent = parent;
+    this.related = related;
+    this.foreignKey = foreignKey;
+    this.localKey = localKey;
+  }
+
+  getRelatedClass() {
+    // If it's a string, resolve from registry
+    if (typeof this.related === 'string') {
+      return this.parent.constructor.resolveRelatedModel(this.related);
+    }
+    
+    // If it's a function (class), check if it's properly initialized
+    if (typeof this.related === 'function') {
+      // For classes that might not be fully loaded, try to get from registry first
+      if (this.related.name && ModelRegistry.has(this.related.name)) {
+        return ModelRegistry.get(this.related.name);
+      }
+      
+      // If not in registry but has required methods, use it directly
+      if (this.related.getTableName && typeof this.related.getTableName === 'function') {
+        return this.related;
+      }
+      
+      // If it's a lazy loading function
+      if (this.related.length === 0) {
+        const resolved = this.related();
+        return resolved;
+      }
+    }
+    
+    return this.related;
+  }
+
+  newQuery() {
+    const relatedClass = this.getRelatedClass();
+    return new QueryBuilder(relatedClass.getTableName(), relatedClass, relatedClass.getConnectionName());
+  }
+}
+
+class HasOne extends Relation {
+  addConstraints() {
+    // Constraints added when executing query
+  }
+
+  getRelatedClass() {
+    return super.getRelatedClass();
+  }
+
+  async getResults() {
+    return this.newQuery()
+      .where(this.foreignKey, this.parent.getAttribute(this.localKey))
+      .first();
+  }
+}
+
+class HasMany extends Relation {
+  addConstraints() {
+    // Constraints added when executing query
+  }
+
+  getRelatedClass() {
+    return super.getRelatedClass();
+  }
+
+  async getResults() {
+    return this.newQuery()
+      .where(this.foreignKey, this.parent.getAttribute(this.localKey))
+      .get();
+  }
+}
+
+class BelongsTo extends Relation {
+  addConstraints() {
+    // Constraints added when executing query
+  }
+
+  getRelatedClass() {
+    return super.getRelatedClass();
+  }
+
+  async getResults() {
+    return this.newQuery()
+      .where(this.localKey, this.parent.getAttribute(this.foreignKey))
+      .first();
+  }
+}
+
+class BelongsToMany extends Relation {
+  constructor(
+    parent,
+    related,
+    pivotTable,
+    foreignPivotKey,
+    relatedPivotKey,
+    parentKey = 'id',
+    relatedKey = 'id'
+  ) {
+    super(parent, related, relatedKey, parentKey);
+    
+    const relatedClass = this.getRelatedClass();
+    
+    this.pivotTable = pivotTable || [
+      parent.constructor.getTableName(),
+      relatedClass.getTableName()
+    ].sort().join('_');
+    
+    this.parentPivotKey = foreignPivotKey || `${parent.constructor.getTableName().slice(0, -1)}_id`;
+    this.relatedPivotKey = relatedPivotKey || `${relatedClass.getTableName().slice(0, -1)}_id`;
+    this.parentKey = parentKey || parent.constructor.getPrimaryKey();
+    this.relatedKey = relatedKey || relatedClass.getPrimaryKey();
+    this.pivotColumns = [];
+    this.pivotTimestamps = false;
+  }
+
+  withPivot(...columns) {
+    this.pivotColumns.push(...columns);
+    return this;
+  }
+
+  withTimestamps() {
+    this.pivotTimestamps = true;
+    this.pivotColumns.push('created_at', 'updated_at');
+    return this;
+  }
+
+  addConstraints() {
+    // Constraints added when executing query
+  }
+
+  async getResults() {
+    const relatedClass = this.getRelatedClass();
+    const selectColumns = [`${relatedClass.getTableName()}.*`];
+    
+    // Add pivot columns
+    if (this.pivotColumns.length > 0) {
+      for (const column of this.pivotColumns) {
+        selectColumns.push(`${this.pivotTable}.${column} as pivot_${column}`);
+      }
+    }
+    
+    const query = this.newQuery()
+      .select(...selectColumns)
+      .join(this.pivotTable, `${relatedClass.getTableName()}.${this.relatedKey}`, `${this.pivotTable}.${this.relatedPivotKey}`)
+      .where(`${this.pivotTable}.${this.parentPivotKey}`, this.parent.getAttribute(this.parentKey));
+
+    const results = await query.get();
+    
+    // Convert Collection to array if needed
+    const resultsArray = Array.isArray(results) ? results : Array.from(results);
+    
+    // Add pivot data to models
+    return resultsArray.map((model) => {
+      const pivotData = {};
+      for (const column of this.pivotColumns) {
+        if (model.attributes[`pivot_${column}`] !== undefined) {
+          pivotData[column] = model.attributes[`pivot_${column}`];
+          delete model.attributes[`pivot_${column}`];
+        }
+      }
+      model.pivot = pivotData;
+      return model;
+    });
+  }
+
+  async attach(id, attributes = {}) {
+    const pivotData = {
+      [this.parentPivotKey]: this.parent.getAttribute(this.parentKey),
+      [this.relatedPivotKey]: id,
+      ...attributes
+    };
+
+    if (this.pivotTimestamps) {
+      const now = new Date();
+      pivotData.created_at = now;
+      pivotData.updated_at = now;
+    }
+
+    await new QueryBuilder(this.pivotTable).insert(pivotData);
+  }
+
+  async detach(id) {
+    const query = new QueryBuilder(this.pivotTable)
+      .where(this.parentPivotKey, this.parent.getAttribute(this.parentKey));
+
+    if (id !== undefined) {
+      query.where(this.relatedPivotKey, id);
+    }
+
+    return query.delete();
+  }
+
+  async sync(ids) {
+    await this.detach();
+    for (const id of ids) {
+      await this.attach(id);
+    }
+  }
+}
+
+class HasManyThrough extends Relation {
+  constructor(
+    parent,
+    related,
+    through,
+    firstKey,
+    secondKey,
+    localKey = 'id',
+    secondLocalKey = 'id'
+  ) {
+    super(parent, related, secondKey, localKey);
+    this.through = through;
+    this.firstKey = firstKey;
+    this.secondKey = secondKey;
+    this.localKey = localKey;
+    this.secondLocalKey = secondLocalKey;
+  }
+
+  addConstraints() {
+    // Constraints added when executing query
+  }
+
+  async getResults() {
+    return this.newQuery()
+      .select(`${this.related.getTableName()}.*`)
+      .join(this.through.getTableName(), `${this.related.getTableName()}.${this.secondLocalKey}`, `${this.through.getTableName()}.${this.secondKey}`)
+      .where(`${this.through.getTableName()}.${this.firstKey}`, this.parent.getAttribute(this.localKey))
+      .get();
+  }
+}
+
+// Polymorphic Relations
+class MorphTo extends Relation {
+  constructor(parent, morphType, morphId) {
+    super(parent, Model, morphId, 'id');
+    this.morphType = morphType;
+    this.morphId = morphId;
+  }
+
+  addConstraints() {
+    // Constraints added when executing query
+  }
+
+  async getResults() {
+    const morphType = this.parent.getAttribute(this.morphType);
+    const morphId = this.parent.getAttribute(this.morphId);
+
+    if (!morphType || !morphId) {
+      return null;
+    }
+
+    // Resolve model class from registry
+    const ModelClass = ModelRegistry.get(morphType);
+    if (!ModelClass) {
+      throw new Error(`Model '${morphType}' not found in registry. Register it using ModelRegistry.register()`);
+    }
+
+    return new QueryBuilder(ModelClass.getTableName(), ModelClass)
+      .where(ModelClass.getPrimaryKey(), morphId)
+      .first();
+  }
+}
+
+class MorphMany extends Relation {
+  constructor(parent, related, morphType, morphId, morphClass) {
+    super(parent, related, morphId, 'id');
+    this.morphType = morphType;
+    this.morphId = morphId;
+    this.morphClass = morphClass;
+  }
+
+  addConstraints() {
+    // Constraints added when executing query
+  }
+
+  async getResults() {
+    return this.newQuery()
+      .where(this.morphType, this.morphClass)
+      .where(this.morphId, this.parent.getAttribute(this.localKey))
+      .get();
+  }
+}
+
+module.exports = {
+  Relation,
+  HasOne,
+  HasMany,
+  BelongsTo,
+  BelongsToMany,
+  HasManyThrough,
+  MorphTo,
+  MorphMany
+};

package/orm/Seeder.js

@@ -0,0 +1,153 @@
+const Database = require('../database/connection');
+
+class Seeder {
+  constructor() {
+    this.db = Database;
+    this.batchSize = 1000;
+  }
+
+  // Batch processing utilities
+  async createInBatches(factory, count, attributes = {}) {
+    const results = [];
+    const batches = Math.ceil(count / this.batchSize);
+    
+    for (let i = 0; i < batches; i++) {
+      const currentBatchSize = Math.min(this.batchSize, count - (i * this.batchSize));
+      const batch = await factory.times(currentBatchSize).create(attributes);
+      results.push(...(Array.isArray(batch) ? batch : [batch]));
+      
+      if (batches > 1) {
+        console.log(`Batch ${i + 1}/${batches} completed (${results.length}/${count})`);
+      }
+    }
+    
+    return results;
+  }
+
+  async disableForeignKeyChecks() {
+    const client = this.db.connection(this.connection).client.config.client;
+    
+    if (client === 'mysql2') {
+      await this.db.raw('SET FOREIGN_KEY_CHECKS = 0');
+    } else if (client === 'pg') {
+      await this.db.raw('SET session_replication_role = replica');
+    }
+  }
+  
+  async enableForeignKeyChecks() {
+    const client = this.db.connection(this.connection).client.config.client;
+    
+    if (client === 'mysql2') {
+      await this.db.raw('SET FOREIGN_KEY_CHECKS = 1');
+    } else if (client === 'pg') {
+      await this.db.raw('SET session_replication_role = DEFAULT');
+    }
+  }
+
+  async call(seeders) {
+    // Handle both single seeder and array of seeders
+    const seederArray = Array.isArray(seeders) ? seeders : [seeders];
+    
+    for (const SeederClass of seederArray) {
+      const seeder = new SeederClass();
+      if (this.connection) {
+        seeder.connection = this.connection;
+      }
+      await seeder.run();
+      console.log(`Seeded: ${SeederClass.name}`);
+    }
+  }
+
+  async callWith(seeders, connection) {
+    for (const [name, SeederClass] of Object.entries(seeders)) {
+      const seeder = new SeederClass();
+      if (connection || this.connection) {
+        seeder.connection = connection || this.connection;
+      }
+      await seeder.run();
+      console.log(`Seeded: ${name}`);
+    }
+  }
+
+  async callOnce(SeederClass, identifier) {
+    const tableName = 'seeder_log';
+    
+    // Ensure seeder log table exists
+    const knex = this.db.getInstance();
+    const hasTable = await knex.schema.hasTable(tableName);
+    if (!hasTable) {
+      await knex.schema.createTable(tableName, (table) => {
+        table.increments('id');
+        table.string('seeder');
+        table.timestamp('executed_at').defaultTo(knex.fn.now());
+      });
+    }
+    
+    // Check if already executed
+    const exists = await this.db.table(tableName).where('seeder', identifier).first();
+    if (exists) {
+      console.log(`Skipped: ${identifier} (already executed)`);
+      return;
+    }
+    
+    // Execute seeder
+    const seeder = new SeederClass();
+    if (this.connection) {
+      seeder.connection = this.connection;
+    }
+    await seeder.run();
+    
+    // Log execution
+    await this.db.table(tableName).insert({
+      seeder: identifier,
+      executed_at: new Date()
+    });
+    
+    console.log(`Seeded: ${identifier}`);
+  }
+
+  async progress(total, callback) {
+    let completed = 0;
+    const updateProgress = (count) => {
+      completed += count;
+      const percentage = Math.round((completed / total) * 100);
+      console.log(`Progress: ${percentage}% (${completed}/${total})`);
+    };
+    
+    await callback(updateProgress);
+  }
+
+  async truncate(table) {
+    await this.db.table(table, this.connection).truncate();
+  }
+
+  async truncateInOrder(tables) {
+    await this.disableForeignKeyChecks();
+    
+    for (const table of tables) {
+      await this.truncate(table);
+    }
+    
+    await this.enableForeignKeyChecks();
+  }
+
+  async wipeDatabase() {
+    const knex = this.db.connection(this.connection);
+    let tables = [];
+    
+    if (knex.client.config.client === 'sqlite3') {
+      const result = await knex.raw("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'");
+      tables = result.map((row) => row.name);
+    } else if (knex.client.config.client === 'mysql2') {
+      const result = await knex.raw('SHOW TABLES');
+      tables = result[0].map((row) => Object.values(row)[0]);
+    } else if (knex.client.config.client === 'pg') {
+      const result = await knex.raw("SELECT tablename FROM pg_tables WHERE schemaname = 'public'");
+      tables = result.rows.map((row) => row.tablename);
+    }
+    
+    await this.truncateInOrder(tables);
+  }
+}
+
+module.exports = Seeder;

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "ilana-orm",
+  "version": "1.0.0",
+  "description": "A fully-featured, Eloquent-style ORM for Node.js with TypeScript support",
+  "main": "index.js",
+  "bin": {
+    "ilana": "cli/ilana.js"
+  },
+  "scripts": {
+    "build": "echo 'No build needed - using JavaScript files directly'",
+    "test": "jest",
+    "prepublishOnly": "echo 'Ready to publish'"
+  },
+  "keywords": [
+    "orm",
+    "nodejs",
+    "javascript",
+    "typescript-orm",
+    "typescript",
+    "database",
+    "eloquent",
+    "mysql",
+    "postgresql",
+    "sqlite",
+    "query-builder",
+    "migrations",
+    "relationships"
+  ],
+  "author": "Raphael Abayomi <raphyabak@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/raphyabak/ilana-orm.git"
+  },
+  "homepage": "https://github.com/raphyabak/ilana-orm#readme",
+  "bugs": {
+    "url": "https://github.com/raphyabak/ilana-orm/issues"
+  },
+  "files": [
+    "*.js",
+    "cli/**/*.js",
+    "database/**/*.js",
+    "orm/**/*.js",
+    "README.md",
+    "LICENSE",
+    "ilana.png"
+  ],
+  "dependencies": {
+    "knex": "^3.0.0",
+    "uuid": "^9.0.0",
+    "@faker-js/faker": "^8.0.0",
+    "pg": "^8.0.0",
+    "mysql2": "^3.0.0",
+    "sqlite3": "^5.0.0",
+    "dotenv": "^16.3.1",
+    "moment-timezone": "^0.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/uuid": "^9.0.0",
+    "typescript": "^5.0.0",
+    "ts-node": "^10.0.0",
+    "ts-node-dev": "^2.0.0",
+    "jest": "^29.0.0",
+    "@types/jest": "^29.0.0",
+    "ts-jest": "^29.0.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}

package/test-role.js

@@ -0,0 +1,26 @@
+const Model = require('./orm/Model');
+
+class Role extends Model {
+  static table = 'roles';
+  static timestamps = true;
+  static softDeletes = false;
+
+  fillable = ['name', 'description', 'permissions'];
+  hidden = [];
+  casts = {
+    permissions: 'json',
+    created_at: 'date',
+    updated_at: 'date'
+  };
+
+  // Use string reference instead of importing User
+  users() {
+    return this.belongsToMany('User', 'user_roles', 'role_id', 'user_id');
+  }
+
+  static {
+    this.register();
+  }
+}
+
+module.exports = Role;