ilana-orm 1.0.12 → 1.0.14

package/cli/ilana.js

@@ -90,6 +90,17 @@ function isESModuleProject() {
   return false;
 }
 
+function getProjectStructure() {
+  const hasSrc = fs.existsSync(path.join(process.cwd(), 'src'));
+  return {
+    hasSrc,
+    modelsDir: hasSrc ? 'src/models' : 'models',
+    databaseDir: hasSrc ? 'src/database' : 'database',
+    observersDir: hasSrc ? 'src/observers' : 'observers',
+    castsDir: hasSrc ? 'src/casts' : 'casts'
+  };
+}
+
 function getFileExtension() {
   return isTypeScriptProject() ? '.ts' : '.js';
 }
@@ -109,8 +120,9 @@ function pluralize(str) {
 }
 
 function getESModuleConfigTemplate() {
+  const structure = getProjectStructure();
   return `import 'dotenv/config';
-import Database from 'ilana-orm/database/connection';
+import Database from 'ilana-orm/database/connection.js';
 
 const config = {
   default: process.env.DB_CONNECTION || 'mysql',
@@ -150,12 +162,12 @@ const config = {
   },
   
   migrations: {
-    directory: './database/migrations',
+    directory: './${structure.databaseDir}/migrations',
     tableName: 'migrations'
   },
   
   seeds: {
-    directory: './database/seeds'
+    directory: './${structure.databaseDir}/seeds'
   }
 };
 
@@ -167,6 +179,7 @@ export default config;
 }
 
 function getCommonJSConfigTemplate() {
+  const structure = getProjectStructure();
   return `require('dotenv').config();
 const Database = require('ilana-orm/database/connection');
 
@@ -208,12 +221,12 @@ const config = {
   },
   
   migrations: {
-    directory: './database/migrations',
+    directory: './${structure.databaseDir}/migrations',
     tableName: 'migrations'
   },
   
   seeds: {
-    directory: './database/seeds'
+    directory: './${structure.databaseDir}/seeds'
   }
 };
 
@@ -228,7 +241,8 @@ function generateModel(name, options = {}) {
   const className = toPascalCase(name);
   const tableName = pluralize(toSnakeCase(name));
   const fileName = `${className}${getFileExtension()}`;
-  const filePath = path.join(process.cwd(), 'models', fileName);
+  const structure = getProjectStructure();
+  const filePath = path.join(process.cwd(), structure.modelsDir, fileName);
 
   if (fs.existsSync(filePath)) {
     console.error(`Model ${className} already exists at models/${fileName}`);
@@ -241,7 +255,7 @@ function generateModel(name, options = {}) {
 
   const template = options.pivot ? getPivotModelTemplate(className, tableName) : getModelTemplate(className, tableName);
   fs.writeFileSync(filePath, template);
-  console.log(`Created model: models/${fileName}`);
+  console.log(`Created model: ${structure.modelsDir}/${fileName}`);
 
   if (options.migration || options.all) {
     const migrationName = `create_${tableName}_table`;
@@ -449,15 +463,17 @@ module.exports = ${className};
 
 function generateFactory(className) {
   const fileName = `${className}Factory${getFileExtension()}`;
-  const filePath = path.join(process.cwd(), 'database/factories', fileName);
+  const structure = getProjectStructure();
+  const filePath = path.join(process.cwd(), structure.databaseDir, 'factories', fileName);
 
   if (!fs.existsSync(path.dirname(filePath))) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
   }
 
+  const modelPath = structure.hasSrc ? `../models/${className}.js` : `../../models/${className}.js`;
   const template = isTypeScriptProject() ?
     `import { defineFactory } from 'ilana-orm/orm/Factory.js';
-import ${className} from '../../models/${className}.js';
+import ${className} from '${modelPath}';
 
 export default defineFactory(${className}, (faker) => ({
   // Define your factory attributes here
@@ -469,7 +485,7 @@ export default defineFactory(${className}, (faker) => ({
 }));
 ` :
     `const { defineFactory } = require('ilana-orm/orm/Factory');
-const ${className} = require('../../models/${className}');
+const ${className} = require('${modelPath.replace('.js', '')}');
 
 module.exports = defineFactory(${className}, (faker) => ({
   // Define your factory attributes here
@@ -482,20 +498,22 @@ module.exports = defineFactory(${className}, (faker) => ({
 `;
 
   fs.writeFileSync(filePath, template);
-  console.log(`Created factory: factories/${fileName}`);
+  console.log(`Created factory: ${structure.databaseDir}/factories/${fileName}`);
 }
 
 function generateSeeder(className) {
   const fileName = `${className}Seeder${getFileExtension()}`;
-  const filePath = path.join(process.cwd(), 'database/seeds', fileName);
+  const structure = getProjectStructure();
+  const filePath = path.join(process.cwd(), structure.databaseDir, 'seeds', fileName);
 
   if (!fs.existsSync(path.dirname(filePath))) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
   }
 
+  const modelPath = structure.hasSrc ? `../models/${className}.js` : `../../models/${className}.js`;
   const template = isTypeScriptProject() ?
     `import Seeder from 'ilana-orm/orm/Seeder.js';
-import ${className} from '../../models/${className}.js';
+import ${className} from '${modelPath}';
 import '../factories/${className}Factory.js';
 
 export default class ${className}Seeder extends Seeder {
@@ -510,7 +528,7 @@ export default class ${className}Seeder extends Seeder {
 }
 ` :
     `const Seeder = require('ilana-orm/orm/Seeder');
-const ${className} = require('../../models/${className}');
+const ${className} = require('${modelPath.replace('.js', '')}');
 require('../factories/${className}Factory');
 
 class ${className}Seeder extends Seeder {
@@ -528,16 +546,16 @@ module.exports = ${className}Seeder;
 `;
 
   fs.writeFileSync(filePath, template);
-  console.log(`Created seeder: seeds/${fileName}`);
+  console.log(`Created seeder: ${structure.databaseDir}/seeds/${fileName}`);
 }
 
 function getObserverTemplate(className, modelName) {
   const isESModule = isESModuleProject();
-  
+
   if (isTypeScriptProject()) {
     const importStatement = modelName ? `import ${modelName} from '../models/${modelName}.js';\n\n` : '';
     const modelType = modelName || 'any';
-    
+
     return `${importStatement}export default class ${className}Observer {
   async creating(model: ${modelType}): Promise<void> {
     // Logic before creating model
@@ -581,10 +599,10 @@ function getObserverTemplate(className, modelName) {
 }
 `;
   }
-  
+
   if (isESModule) {
     const importStatement = modelName ? `import ${modelName} from '../models/${modelName}.js';\n\n` : '';
-    
+
     return `${importStatement}class ${className}Observer {
   async creating(model) {
     // Logic before creating model
@@ -630,9 +648,9 @@ function getObserverTemplate(className, modelName) {
 export default ${className}Observer;
 `;
   }
-  
+
   const importStatement = modelName ? `const ${modelName} = require('../models/${modelName}');\n\n` : '';
-  
+
   return `${importStatement}class ${className}Observer {
   async creating(model) {
     // Logic before creating model
@@ -681,7 +699,7 @@ module.exports = ${className}Observer;
 
 function getCastTemplate(className) {
   const isESModule = isESModuleProject();
-  
+
   if (isTypeScriptProject()) {
     return `export default class ${className}Cast {
   get(value: any): any {
@@ -696,7 +714,7 @@ function getCastTemplate(className) {
 }
 `;
   }
-  
+
   if (isESModule) {
     return `class ${className}Cast {
   get(value) {
@@ -713,7 +731,7 @@ function getCastTemplate(className) {
 export default ${className}Cast;
 `;
   }
-  
+
   return `class ${className}Cast {
   get(value) {
     // Transform value when retrieving from database
@@ -736,7 +754,13 @@ const commands = {
     console.log('Setting up Ilana ORM...');
 
     // Create directories
-    const dirs = ['models', 'database/migrations', 'database/factories', 'database/seeds'];
+    const structure = getProjectStructure();
+    const dirs = [
+      structure.modelsDir,
+      `${structure.databaseDir}/migrations`,
+      `${structure.databaseDir}/factories`,
+      `${structure.databaseDir}/seeds`
+    ];
     for (const dir of dirs) {
       if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
@@ -1053,7 +1077,8 @@ DB_TIMEZONE=UTC
       }
     }
 
-    const seedsPath = path.join(process.cwd(), 'database/seeds');
+    const structure = getProjectStructure();
+    const seedsPath = path.join(process.cwd(), structure.databaseDir, 'seeds');
     if (!fs.existsSync(seedsPath)) {
       console.log('No seeds directory found');
       process.exit(0);
@@ -1125,7 +1150,8 @@ DB_TIMEZONE=UTC
 
     const className = toPascalCase(name.replace('Observer', ''));
     const fileName = `${className}Observer${getFileExtension()}`;
-    const filePath = path.join(process.cwd(), 'observers', fileName);
+    const structure = getProjectStructure();
+    const filePath = path.join(process.cwd(), structure.observersDir, fileName);
 
     if (!fs.existsSync(path.dirname(filePath))) {
       fs.mkdirSync(path.dirname(filePath), { recursive: true });
@@ -1133,7 +1159,7 @@ DB_TIMEZONE=UTC
 
     const template = getObserverTemplate(className, modelName);
     fs.writeFileSync(filePath, template);
-    console.log(`Created observer: observers/${fileName}`);
+    console.log(`Created observer: ${structure.observersDir}/${fileName}`);
 
     if (modelName) {
       console.log(`Observer configured for model: ${modelName}`);
@@ -1149,7 +1175,8 @@ DB_TIMEZONE=UTC
 
     const className = toPascalCase(name.replace('Cast', ''));
     const fileName = `${className}Cast${getFileExtension()}`;
-    const filePath = path.join(process.cwd(), 'casts', fileName);
+    const structure = getProjectStructure();
+    const filePath = path.join(process.cwd(), structure.castsDir, fileName);
 
     if (!fs.existsSync(path.dirname(filePath))) {
       fs.mkdirSync(path.dirname(filePath), { recursive: true });
@@ -1157,7 +1184,7 @@ DB_TIMEZONE=UTC
 
     const template = getCastTemplate(className);
     fs.writeFileSync(filePath, template);
-    console.log(`Created cast: casts/${fileName}`);
+    console.log(`Created cast: ${structure.castsDir}/${fileName}`);
   },
 
   help() {

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.14",
   "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"
     }
   },