ilana-orm 1.0.12 → 1.0.13

package/database/DB.mjs

@@ -0,0 +1,169 @@
+import Database from './connection.mjs';
+
+// DB facade - provides static methods for database operations
+class DB {
+  static connection(name) {
+    return Database.connection(name);
+  }
+
+  static table(tableName, connection) {
+    return Database.table(tableName, connection);
+  }
+
+  static raw(query, bindings, connection) {
+    return Database.raw(query, bindings, connection);
+  }
+
+  static select(query, bindings, connection) {
+    return Database.select(query, bindings, connection);
+  }
+
+  static insert(table, data, connection) {
+    return Database.insert(table, data, connection);
+  }
+
+  static update(table, data, where, connection) {
+    return Database.update(table, data, where, connection);
+  }
+
+  static delete(table, where, connection) {
+    return Database.delete(table, where, connection);
+  }
+
+  static transaction(callback, connection) {
+    return Database.transaction(callback, connection);
+  }
+
+  static beginTransaction(connection) {
+    return Database.beginTransaction(connection);
+  }
+
+  static commit(trx) {
+    return Database.commit(trx);
+  }
+
+  static rollback(trx) {
+    return Database.rollback(trx);
+  }
+
+  static schema(connection) {
+    return Database.schema(connection);
+  }
+
+  static migrate(connection) {
+    return Database.migrate(connection);
+  }
+
+  static seed(connection) {
+    return Database.seed(connection);
+  }
+
+  static destroy(connection) {
+    return Database.destroy(connection);
+  }
+
+  static destroyAll() {
+    return Database.destroyAll();
+  }
+
+  static configure(config) {
+    return Database.configure(config);
+  }
+
+  static getInstance(connection) {
+    return Database.getInstance(connection);
+  }
+
+  static getConfig() {
+    return Database.getConfig();
+  }
+
+  static setConfig(config) {
+    return Database.setConfig(config);
+  }
+
+  // Query builder methods
+  static query(connection) {
+    return Database.getInstance(connection);
+  }
+
+  static from(table, connection) {
+    return Database.table(table, connection);
+  }
+
+  // Aggregation methods
+  static count(table, column = '*', connection) {
+    return Database.table(table, connection).count(column);
+  }
+
+  static sum(table, column, connection) {
+    return Database.table(table, connection).sum(column);
+  }
+
+  static avg(table, column, connection) {
+    return Database.table(table, connection).avg(column);
+  }
+
+  static min(table, column, connection) {
+    return Database.table(table, connection).min(column);
+  }
+
+  static max(table, column, connection) {
+    return Database.table(table, connection).max(column);
+  }
+
+  // Utility methods
+  static listen(event, callback) {
+    return Database.listen(event, callback);
+  }
+
+  static unlisten(event, callback) {
+    return Database.unlisten(event, callback);
+  }
+
+  static enableQueryLog() {
+    return Database.enableQueryLog();
+  }
+
+  static disableQueryLog() {
+    return Database.disableQueryLog();
+  }
+
+  static getQueryLog() {
+    return Database.getQueryLog();
+  }
+
+  static flushQueryLog() {
+    return Database.flushQueryLog();
+  }
+
+  static pretend(callback, connection) {
+    return Database.pretend(callback, connection);
+  }
+
+  static reconnect(connection) {
+    return Database.reconnect(connection);
+  }
+
+  static disconnect(connection) {
+    return Database.disconnect(connection);
+  }
+
+  static getConnectionName() {
+    return Database.getConnectionName();
+  }
+
+  static setConnectionName(name) {
+    return Database.setConnectionName(name);
+  }
+
+  static getTablePrefix(connection) {
+    return Database.getTablePrefix(connection);
+  }
+
+  static setTablePrefix(prefix, connection) {
+    return Database.setTablePrefix(prefix, connection);
+  }
+}
+
+export default DB;

package/database/schema-builder.mjs

@@ -0,0 +1,219 @@
+import Database from './connection.mjs';
+
+class SchemaBuilder {
+  constructor(connection) {
+    this.knex = Database.connection(connection);
+    this.currentTable = '';
+  }
+
+  createTable(tableName, callback) {
+    return this.knex.schema.createTable(tableName, callback);
+  }
+
+  dropTable(tableName) {
+    return this.knex.schema.dropTable(tableName);
+  }
+
+  dropTableIfExists(tableName) {
+    return this.knex.schema.dropTableIfExists(tableName);
+  }
+
+  renameTable(from, to) {
+    return this.knex.schema.renameTable(from, to);
+  }
+
+  hasTable(tableName) {
+    return this.knex.schema.hasTable(tableName);
+  }
+
+  hasColumn(tableName, columnName) {
+    return this.knex.schema.hasColumn(tableName, columnName);
+  }
+
+  table(tableName, callback) {
+    return this.knex.schema.table(tableName, callback);
+  }
+
+  alterTable(tableName, callback) {
+    return this.knex.schema.alterTable(tableName, callback);
+  }
+
+  raw(statement) {
+    return this.knex.raw(statement);
+  }
+
+  // PostgreSQL specific
+  createSchema(schemaName) {
+    return this.knex.schema.createSchema(schemaName);
+  }
+
+  dropSchema(schemaName) {
+    return this.knex.schema.dropSchema(schemaName);
+  }
+
+  // Advanced column types
+  jsonb(columnName) {
+    if (this.knex.client.config.client === 'pg') {
+      return this.knex.schema.jsonb ? this.knex.schema.jsonb(columnName) : this.knex.schema.json(columnName);
+    }
+    return this.knex.schema.json(columnName);
+  }
+
+  geometry(columnName, geometryType) {
+    return this.knex.schema.specificType(columnName, geometryType || 'geometry');
+  }
+
+  point(columnName) {
+    return this.knex.schema.specificType(columnName, 'point');
+  }
+
+  lineString(columnName) {
+    return this.knex.schema.specificType(columnName, 'linestring');
+  }
+
+  polygon(columnName) {
+    return this.knex.schema.specificType(columnName, 'polygon');
+  }
+
+  inet(columnName) {
+    return this.knex.schema.specificType(columnName, 'inet');
+  }
+
+  macaddr(columnName) {
+    return this.knex.schema.specificType(columnName, 'macaddr');
+  }
+
+  specificType(columnName, type) {
+    return this.knex.schema.specificType(columnName, type);
+  }
+
+  // Enhanced column modifiers with database-specific implementations
+  after(columnName) {
+    if (this.knex.client.config.client === 'mysql2') {
+      return this.knex.schema.raw(`AFTER ${columnName}`);
+    }
+    return this;
+  }
+
+  first() {
+    if (this.knex.client.config.client === 'mysql2') {
+      return this.knex.schema.raw('FIRST');
+    }
+    return this;
+  }
+
+  checkPositive(column) {
+    const client = this.knex.client.config.client;
+    if (client === 'pg') {
+      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD CONSTRAINT ${column}_positive CHECK (${column} > 0)`);
+    } else if (client === 'mysql2') {
+      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD CONSTRAINT ${column}_positive CHECK (${column} > 0)`);
+    }
+    return Promise.resolve();
+  }
+
+  checkRegex(column, pattern) {
+    const client = this.knex.client.config.client;
+    if (client === 'pg') {
+      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD CONSTRAINT ${column}_regex CHECK (${column} ~ '${pattern}')`);
+    } else if (client === 'mysql2') {
+      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD CONSTRAINT ${column}_regex CHECK (${column} REGEXP '${pattern}')`);
+    }
+    return Promise.resolve();
+  }
+
+  generatedAs(column, expression) {
+    const client = this.knex.client.config.client;
+    if (client === 'mysql2') {
+      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD ${column} VARCHAR(255) GENERATED ALWAYS AS (${expression}) STORED`);
+    } else if (client === 'pg') {
+      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD ${column} TEXT GENERATED ALWAYS AS (${expression}) STORED`);
+    }
+    return Promise.resolve();
+  }
+
+  collate(tableName, collation) {
+    const client = this.knex.client.config.client;
+    if (client === 'mysql2') {
+      return this.knex.raw(`ALTER TABLE ${tableName} COLLATE ${collation}`);
+    } else if (client === 'pg') {
+      return this.knex.raw(`ALTER TABLE ${tableName} ALTER COLUMN name TYPE TEXT COLLATE "${collation}"`);
+    }
+    return Promise.resolve();
+  }
+
+  // Enhanced PostgreSQL types
+  array(columnName, type = 'text') {
+    if (this.knex.client.config.client === 'pg') {
+      return this.knex.schema.specificType(columnName, `${type}[]`);
+    }
+    return this.knex.schema.json(columnName);
+  }
+
+  numrange(columnName) {
+    return this.knex.schema.specificType(columnName, 'numrange');
+  }
+
+  daterange(columnName) {
+    return this.knex.schema.specificType(columnName, 'daterange');
+  }
+
+  tsvector(columnName) {
+    return this.knex.schema.specificType(columnName, 'tsvector');
+  }
+
+  // Enhanced MySQL types
+  fulltext(columns, indexName) {
+    if (this.knex.client.config.client === 'mysql2') {
+      const name = indexName || `${columns.join('_')}_fulltext`;
+      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD FULLTEXT INDEX ${name} (${columns.join(', ')})`);
+    }
+    return Promise.resolve();
+  }
+
+  spatial(column, indexName) {
+    if (this.knex.client.config.client === 'mysql2') {
+      const name = indexName || `${column}_spatial`;
+      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD SPATIAL INDEX ${name} (${column})`);
+    }
+    return Promise.resolve();
+  }
+
+  setCurrentTable(tableName) {
+    this.currentTable = tableName;
+    return this;
+  }
+
+  // Enhanced utility methods
+  get client() {
+    return this.knex.client;
+  }
+
+  get fn() {
+    return this.knex.fn;
+  }
+
+  // Database-specific utilities
+  enableExtension(name) {
+    if (this.knex.client.config.client === 'pg') {
+      return this.knex.raw(`CREATE EXTENSION IF NOT EXISTS "${name}"`);
+    }
+    return Promise.resolve();
+  }
+
+  createEnum(name, values) {
+    if (this.knex.client.config.client === 'pg') {
+      return this.knex.raw(`CREATE TYPE ${name} AS ENUM (${values.map(v => `'${v}'`).join(', ')})`);
+    }
+    return Promise.resolve();
+  }
+
+  dropEnum(name) {
+    if (this.knex.client.config.client === 'pg') {
+      return this.knex.raw(`DROP TYPE IF EXISTS ${name}`);
+    }
+    return Promise.resolve();
+  }
+}
+
+export default SchemaBuilder;

package/orm/Factory.mjs

@@ -0,0 +1,198 @@
+import { faker } from '@faker-js/faker';
+
+class Factory {
+  constructor(model, definition) {
+    this.model = model;
+    this.definition = definition;
+    this.states = new Map();
+    this.afterCreating = [];
+    this.afterMaking = [];
+    this.count = 1;
+    this.activeStates = [];
+  }
+
+  static define(model, definition) {
+    return new Factory(model, definition);
+  }
+
+  state(name, attributes) {
+    if (typeof attributes === 'function') {
+      this.states.set(name, attributes);
+    } else {
+      this.states.set(name, () => attributes);
+    }
+    return this;
+  }
+
+  times(count) {
+    this.count = count;
+    return this;
+  }
+
+  as(stateName) {
+    this.activeStates.push(stateName);
+    return this;
+  }
+
+  afterCreating(callback) {
+    this.afterCreating.push(callback);
+    return this;
+  }
+
+  afterMaking(callback) {
+    this.afterMaking.push(callback);
+    return this;
+  }
+
+  async make(attributes = {}) {
+    const instances = [];
+    
+    for (let i = 0; i < this.count; i++) {
+      const baseAttributes = this.definition(faker);
+      
+      // Apply states
+      let stateAttributes = {};
+      for (const stateName of this.activeStates) {
+        if (this.states.has(stateName)) {
+          const stateDefinition = this.states.get(stateName);
+          stateAttributes = { ...stateAttributes, ...stateDefinition(faker) };
+        }
+      }
+      
+      const finalAttributes = { ...baseAttributes, ...stateAttributes, ...attributes };
+      const instance = new this.model(finalAttributes);
+      
+      // Run after making callbacks
+      for (const callback of this.afterMaking) {
+        await callback(instance);
+      }
+      
+      instances.push(instance);
+    }
+    
+    return this.count === 1 ? instances[0] : instances;
+  }
+
+  async create(attributes = {}) {
+    const instances = await this.make(attributes);
+    const instancesToSave = Array.isArray(instances) ? instances : [instances];
+    const savedInstances = [];
+    
+    for (const instance of instancesToSave) {
+      const saved = await instance.save();
+      
+      // Run after creating callbacks
+      for (const callback of this.afterCreating) {
+        await callback(saved);
+      }
+      
+      savedInstances.push(saved);
+    }
+    
+    return this.count === 1 ? savedInstances[0] : savedInstances;
+  }
+
+  async createMany(count, attributes = {}) {
+    return this.times(count).create(attributes);
+  }
+
+  async makeMany(count, attributes = {}) {
+    return this.times(count).make(attributes);
+  }
+
+  // Relationship factories
+  for(model) {
+    return new RelationshipFactory(this, model);
+  }
+
+  // Sequence support
+  sequence(callback) {
+    let counter = 0;
+    const originalDefinition = this.definition;
+    
+    this.definition = (faker) => {
+      const baseAttributes = originalDefinition(faker);
+      const sequenceAttributes = callback(++counter, faker);
+      return { ...baseAttributes, ...sequenceAttributes };
+    };
+    
+    return this;
+  }
+
+  // Conditional attributes
+  when(condition, attributes) {
+    const originalDefinition = this.definition;
+    
+    this.definition = (faker) => {
+      const baseAttributes = originalDefinition(faker);
+      if (condition) {
+        const conditionalAttributes = typeof attributes === 'function' 
+          ? attributes(faker) 
+          : attributes;
+        return { ...baseAttributes, ...conditionalAttributes };
+      }
+      return baseAttributes;
+    };
+    
+    return this;
+  }
+
+  // Raw attributes (bypass model instantiation)
+  raw(attributes = {}) {
+    const baseAttributes = this.definition(faker);
+    
+    // Apply states
+    let stateAttributes = {};
+    for (const stateName of this.activeStates) {
+      if (this.states.has(stateName)) {
+        const stateDefinition = this.states.get(stateName);
+        stateAttributes = { ...stateAttributes, ...stateDefinition(faker) };
+      }
+    }
+    
+    return { ...baseAttributes, ...stateAttributes, ...attributes };
+  }
+}
+
+class RelationshipFactory {
+  constructor(parentFactory, model) {
+    this.parentFactory = parentFactory;
+    this.model = model;
+  }
+
+  create(attributes = {}) {
+    // This would create related models
+    // Implementation depends on relationship type
+    return this.model.factory().create(attributes);
+  }
+
+  make(attributes = {}) {
+    return this.model.factory().make(attributes);
+  }
+}
+
+// Global factory registry
+const factories = new Map();
+
+export function defineFactory(model, definition) {
+  const factory = new Factory(model, definition);
+  factories.set(model.name, factory);
+  
+  // Add factory method to model
+  model.factory = function(attributes) {
+    const factoryInstance = new Factory(model, definition);
+    if (attributes) {
+      return factoryInstance.make(attributes);
+    }
+    return factoryInstance;
+  };
+  
+  return factory;
+}
+
+export function getFactory(modelName) {
+  return factories.get(modelName);
+}
+
+export { Factory, faker };
+export default Factory;

package/orm/Seeder.mjs

@@ -0,0 +1,153 @@
+import Database from '../database/connection.mjs';
+
+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);
+  }
+}
+
+export default Seeder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ilana-orm",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "description": "A fully-featured, Eloquent-style ORM for Node.js with TypeScript support",
   "main": "index.js",
   "types": "index.d.ts",
@@ -36,12 +36,15 @@
       "types": "./database/connection.d.ts"
     },
     "./database/schema-builder": {
+      "import": "./database/schema-builder.mjs",
       "require": "./database/schema-builder.js"
     },
     "./orm/Seeder": {
+      "import": "./orm/Seeder.mjs",
       "require": "./orm/Seeder.js"
     },
     "./orm/Factory": {
+      "import": "./orm/Factory.mjs",
       "require": "./orm/Factory.js"
     },
     "./orm/ModelRegistry": {
@@ -58,6 +61,7 @@
       "require": "./orm/MigrationRunner.js"
     },
     "./database/DB": {
+      "import": "./database/DB.mjs",
       "require": "./database/DB.js"
     }
   },