ilana-orm 1.0.0

package/orm/Collection.js

@@ -0,0 +1,283 @@
+class Collection extends Array {
+  constructor(items = []) {
+    super();
+    if (items && items.length > 0) {
+      this.push(...items);
+    }
+    Object.setPrototypeOf(this, Collection.prototype);
+  }
+
+  // Static factory methods
+  static make(items = []) {
+    return new Collection(items);
+  }
+
+  static times(count, callback) {
+    const items = [];
+    for (let i = 0; i < count; i++) {
+      items.push(callback(i));
+    }
+    return new Collection(items);
+  }
+
+  static range(start, end) {
+    const items = [];
+    for (let i = start; i <= end; i++) {
+      items.push(i);
+    }
+    return new Collection(items);
+  }
+
+  // Collection methods
+  filter(callback) {
+    return new Collection(super.filter(callback));
+  }
+
+  map(callback) {
+    return new Collection(super.map(callback));
+  }
+
+  first() {
+    return this[0];
+  }
+
+  last() {
+    return this[this.length - 1];
+  }
+
+  pluck(key) {
+    return new Collection(this.map(item => item[key]));
+  }
+
+  unique(key) {
+    if (key) {
+      const seen = new Set();
+      return new Collection(this.filter(item => {
+        const value = item[key];
+        if (seen.has(value)) {
+          return false;
+        }
+        seen.add(value);
+        return true;
+      }));
+    }
+    return new Collection([...new Set(this)]);
+  }
+
+  groupBy(key) {
+    const groups = {};
+    
+    for (const item of this) {
+      const groupKey = item[key];
+      if (!groups[groupKey]) {
+        groups[groupKey] = [];
+      }
+      groups[groupKey].push(item);
+    }
+
+    const result = {};
+    for (const [k, v] of Object.entries(groups)) {
+      result[k] = new Collection(v);
+    }
+    
+    return result;
+  }
+
+  sortBy(key) {
+    return new Collection([...this].sort((a, b) => {
+      const aVal = a[key];
+      const bVal = b[key];
+      return aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+    }));
+  }
+
+  sortByDesc(key) {
+    return new Collection([...this].sort((a, b) => {
+      const aVal = a[key];
+      const bVal = b[key];
+      return aVal > bVal ? -1 : aVal < bVal ? 1 : 0;
+    }));
+  }
+
+  where(key, value) {
+    return new Collection(this.filter(item => item[key] === value));
+  }
+
+  firstWhere(key, value) {
+    return this.find(item => item[key] === value);
+  }
+
+  sum(key) {
+    if (key) {
+      return this.reduce((sum, item) => sum + (item[key] || 0), 0);
+    }
+    return this.reduce((sum, item) => sum + item, 0);
+  }
+
+  avg(key) {
+    if (this.length === 0) return 0;
+    return this.sum(key) / this.length;
+  }
+
+  min(key) {
+    if (this.length === 0) return undefined;
+    
+    if (key) {
+      return Math.min(...this.map(item => item[key]));
+    }
+    return Math.min(...this);
+  }
+
+  max(key) {
+    if (this.length === 0) return undefined;
+    
+    if (key) {
+      return Math.max(...this.map(item => item[key]));
+    }
+    return Math.max(...this);
+  }
+
+  chunk(size) {
+    const chunks = [];
+    for (let i = 0; i < this.length; i += size) {
+      chunks.push(new Collection(this.slice(i, i + size)));
+    }
+    return new Collection(chunks);
+  }
+
+
+
+  toJSON() {
+    return this.map(item => {
+      if (item && typeof item.toJSON === 'function') {
+        return item.toJSON();
+      }
+      return item;
+    });
+  }
+
+  // Advanced collection methods
+  reject(callback) {
+    return new Collection(super.filter((item, index) => !callback(item, index)));
+  }
+
+  partition(callback) {
+    const passed = new Collection();
+    const failed = new Collection();
+    
+    for (let i = 0; i < this.length; i++) {
+      if (callback(this[i], i)) {
+        passed.push(this[i]);
+      } else {
+        failed.push(this[i]);
+      }
+    }
+    
+    return [passed, failed];
+  }
+
+  keyBy(key) {
+    const result = {};
+    for (const item of this) {
+      result[item[key]] = item;
+    }
+    return result;
+  }
+
+  countBy(key) {
+    const result = {};
+    for (const item of this) {
+      const value = item[key];
+      result[value] = (result[value] || 0) + 1;
+    }
+    return result;
+  }
+
+  flatten() {
+    const result = [];
+    for (const item of this) {
+      if (Array.isArray(item)) {
+        result.push(...item);
+      } else {
+        result.push(item);
+      }
+    }
+    return new Collection(result);
+  }
+
+  take(count) {
+    return new Collection(this.slice(0, count));
+  }
+
+  skip(count) {
+    return new Collection(this.slice(count));
+  }
+
+  random(count = 1) {
+    const shuffled = [...this].sort(() => 0.5 - Math.random());
+    if (count === 1) {
+      return shuffled[0];
+    }
+    return new Collection(shuffled.slice(0, count));
+  }
+
+  shuffle() {
+    return new Collection([...this].sort(() => 0.5 - Math.random()));
+  }
+
+  tap(callback) {
+    callback(this);
+    return this;
+  }
+
+  pipe(callback) {
+    return callback(this);
+  }
+
+  whenEmpty(callback) {
+    if (this.isEmpty()) {
+      callback(this);
+    }
+    return this;
+  }
+
+  whenNotEmpty(callback) {
+    if (this.isNotEmpty()) {
+      callback(this);
+    }
+    return this;
+  }
+
+  unless(condition, callback) {
+    if (!condition) {
+      callback(this);
+    }
+    return this;
+  }
+
+  when(condition, callback) {
+    if (condition) {
+      callback(this);
+    }
+    return this;
+  }
+
+  toArray() {
+    return [...this];
+  }
+
+  isEmpty() {
+    return this.length === 0;
+  }
+
+  isNotEmpty() {
+    return this.length > 0;
+  }
+
+  // Ensure proper iterator implementation
+  [Symbol.iterator]() {
+    return super[Symbol.iterator]();
+  }
+}
+
+module.exports = Collection;

package/orm/CustomCasts.js

@@ -0,0 +1,75 @@
+class MoneyCast {
+  get(value) {
+    return value ? parseFloat(value) / 100 : null;
+  }
+  
+  set(value) {
+    return value ? Math.round(value * 100) : null;
+  }
+}
+
+class EncryptedCast {
+  constructor(key = 'default-key') {
+    this.key = key;
+  }
+  
+  get(value) {
+    if (!value) return null;
+    // Simple base64 decode for demo - use proper encryption in production
+    try {
+      return Buffer.from(value, 'base64').toString('utf8');
+    } catch {
+      return value;
+    }
+  }
+  
+  set(value) {
+    if (!value) return null;
+    // Simple base64 encode for demo - use proper encryption in production
+    return Buffer.from(value).toString('base64');
+  }
+}
+
+class JsonCast {
+  get(value) {
+    if (!value) return null;
+    return typeof value === 'string' ? JSON.parse(value) : value;
+  }
+  
+  set(value) {
+    if (value === null || value === undefined) return null;
+    return typeof value === 'string' ? value : JSON.stringify(value);
+  }
+}
+
+class ArrayCast {
+  get(value) {
+    if (!value) return null;
+    return Array.isArray(value) ? value : JSON.parse(value);
+  }
+  
+  set(value) {
+    if (!value) return null;
+    return Array.isArray(value) ? JSON.stringify(value) : value;
+  }
+}
+
+class DateCast {
+  get(value) {
+    if (!value) return null;
+    return new Date(value);
+  }
+  
+  set(value) {
+    if (!value) return null;
+    return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
+  }
+}
+
+module.exports = {
+  MoneyCast,
+  EncryptedCast,
+  JsonCast,
+  ArrayCast,
+  DateCast
+};

package/orm/Factory.js

@@ -0,0 +1,372 @@
+const { faker } = require('@faker-js/faker');
+const Model = require('./Model');
+
+class Factory {
+  constructor(model, definition) {
+    this.model = model;
+    this.definition = definition;
+    this.faker = faker;
+    this.states = new Map();
+    this.afterCreating = [];
+    this.afterMaking = [];
+    this.beforeCreating = [];
+    this.beforeMaking = [];
+    this.count = 1;
+    this.currentStates = [];
+    this.relationships = new Map();
+    this.sequence = 0;
+    this.sequences = new Map();
+  }
+
+  state(name, definition) {
+    if (definition) {
+      this.states.set(name, definition);
+    } else {
+      this.currentStates.push(name);
+    }
+    return this;
+  }
+
+  afterCreating(callback) {
+    this.afterCreating.push(callback);
+    return this;
+  }
+
+  afterMaking(callback) {
+    this.afterMaking.push(callback);
+    return this;
+  }
+
+  beforeCreating(callback) {
+    this.beforeCreating.push(callback);
+    return this;
+  }
+
+  beforeMaking(callback) {
+    this.beforeMaking.push(callback);
+    return this;
+  }
+
+  times(count) {
+    this.count = count;
+    return this;
+  }
+
+  as(state) {
+    this.currentStates.push(state);
+    return this;
+  }
+
+  for(relation, factory) {
+    this.relationships.set(relation, factory);
+    return this;
+  }
+
+  has(factory, relation) {
+    if (relation) {
+      this.relationships.set(relation, factory);
+    }
+    return this;
+  }
+
+  hasAttached(factory, relation) {
+    this.relationships.set(relation, factory);
+    return this;
+  }
+
+  sequence() {
+    return ++this.sequence;
+  }
+
+  // Enhanced sequence methods
+  sequenceFor(key) {
+    if (!this.sequences) this.sequences = new Map();
+    const current = this.sequences.get(key) || 0;
+    const next = current + 1;
+    this.sequences.set(key, next);
+    return next;
+  }
+
+  resetSequence(key) {
+    if (key) {
+      this.sequences?.set(key, 0);
+    } else {
+      this.sequences?.clear();
+      this.sequence = 0;
+    }
+    return this;
+  }
+
+  raw(attributes = {}) {
+    if (this.count === 1) {
+      return this.makeRaw(attributes);
+    }
+
+    const results = [];
+    for (let i = 0; i < this.count; i++) {
+      results.push(this.makeRaw(attributes));
+    }
+    return results;
+  }
+
+  async make(attributes = {}) {
+    if (this.count === 1) {
+      return this.makeOne(attributes);
+    }
+
+    const models = [];
+    for (let i = 0; i < this.count; i++) {
+      models.push(await this.makeOne(attributes));
+    }
+    return models;
+  }
+
+  async create(attributes = {}) {
+    if (this.count === 1) {
+      return this.createOne(attributes);
+    }
+
+    const models = [];
+    for (let i = 0; i < this.count; i++) {
+      models.push(await this.createOne(attributes));
+    }
+    return models;
+  }
+
+  makeRaw(attributes = {}) {
+    let modelAttributes;
+    
+    if (typeof this.definition === 'function') {
+      modelAttributes = this.definition(faker);
+    } else if (this.definition === undefined && typeof this.definition === 'function') {
+      modelAttributes = this.definition();
+    } else {
+      throw new Error('Factory must have a definition function');
+    }
+
+    for (const stateName of this.currentStates) {
+      const stateDefinition = this.states.get(stateName);
+      if (stateDefinition) {
+        modelAttributes = { ...modelAttributes, ...stateDefinition(faker) };
+      }
+    }
+
+    modelAttributes = { ...modelAttributes, ...attributes };
+
+    for (const callback of this.beforeMaking) {
+      modelAttributes = callback(modelAttributes) || modelAttributes;
+    }
+
+    return modelAttributes;
+  }
+
+  async makeOne(attributes = {}) {
+    const modelAttributes = this.makeRaw(attributes);
+
+    const model = new this.model();
+    model.fill(modelAttributes);
+
+    // Run afterMaking callbacks
+    for (const callback of this.afterMaking) {
+      await callback(model);
+    }
+
+    return model;
+  }
+
+  async createOne(attributes = {}) {
+    const model = await this.makeOne(attributes);
+    
+    // Run beforeCreating callbacks
+    for (const callback of this.beforeCreating) {
+      await callback(model);
+    }
+    
+    await model.save();
+
+    // Run afterCreating callbacks
+    for (const callback of this.afterCreating) {
+      await callback(model);
+    }
+
+    return model;
+  }
+
+  // Enhanced factory methods
+  configure(callback) {
+    callback(this);
+    return this;
+  }
+
+  when(condition, callback) {
+    if (condition) {
+      callback(this);
+    }
+    return this;
+  }
+
+  unless(condition, callback) {
+    if (!condition) {
+      callback(this);
+    }
+    return this;
+  }
+
+  // Advanced relationship creation
+  async createWithRelations(attributes = {}, relations = {}) {
+    const model = await this.createOne(attributes);
+    
+    for (const [relationName, relationData] of Object.entries(relations)) {
+      const relationMethod = model[relationName];
+      if (typeof relationMethod === 'function') {
+        const relation = relationMethod.call(model);
+        if (relation.constructor.name === 'BelongsToMany') {
+          if (Array.isArray(relationData)) {
+            for (const data of relationData) {
+              await relation.attach(data.id || data, data);
+            }
+          }
+        }
+      }
+    }
+    
+    return model;
+  }
+
+  // Batch operations
+  async createInBatches(batchSize = 100, attributes = {}) {
+    const results = [];
+    const totalBatches = Math.ceil(this.count / batchSize);
+    
+    for (let i = 0; i < totalBatches; i++) {
+      const currentBatchSize = Math.min(batchSize, this.count - (i * batchSize));
+      const batchFactory = new Factory(this.model, this.definition);
+      batchFactory.count = currentBatchSize;
+      batchFactory.currentStates = [...this.currentStates];
+      
+      const batch = await batchFactory.create(attributes);
+      results.push(...(Array.isArray(batch) ? batch : [batch]));
+    }
+    
+    return results;
+  }
+}
+
+// Factory registry
+const factories = new Map();
+
+function defineFactory(model, definition) {
+  const factory = new Factory(model, definition);
+  factories.set(model, factory);
+  return factory;
+}
+
+function factory(model) {
+  const factory = factories.get(model);
+  if (!factory) {
+    throw new Error(`No factory defined for model: ${model.name}`);
+  }
+  return factory;
+}
+
+// Enhanced factory utilities
+function factoryForModel(model) {
+  return factory(model);
+}
+
+function createFactory(model, definition) {
+  return defineFactory(model, definition);
+}
+
+// Global factory state management
+const globalSequences = new Map();
+
+function globalSequence(key) {
+  const current = globalSequences.get(key) || 0;
+  const next = current + 1;
+  globalSequences.set(key, next);
+  return next;
+}
+
+function resetGlobalSequence(key) {
+  if (key) {
+    globalSequences.set(key, 0);
+  } else {
+    globalSequences.clear();
+  }
+}
+
+// Factory trait system
+function trait(callback) {
+  return { apply: callback };
+}
+
+// Performance optimized factory
+class BulkFactory {
+  constructor(model, definition) {
+    this.model = model;
+    this.definition = definition;
+    this.batchSize = 1000;
+  }
+
+  setBatchSize(size) {
+    this.batchSize = size;
+    return this;
+  }
+
+  async create(count) {
+    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 batchData = [];
+      
+      for (let j = 0; j < currentBatchSize; j++) {
+        batchData.push(this.definition(faker));
+      }
+      
+      const insertedIds = await this.model.query().insert(batchData);
+      
+      for (let k = 0; k < batchData.length; k++) {
+        const model = new this.model();
+        model.fill({ ...batchData[k], id: insertedIds[k] });
+        model.exists = true;
+        results.push(model);
+      }
+    }
+    
+    return results;
+  }
+}
+
+function bulkFactory(model, definition) {
+  return new BulkFactory(model, definition);
+}
+
+// Add factory method to Model prototype
+if (typeof Model !== 'undefined') {
+  Model.factory = function() {
+    const existingFactory = factories.get(this);
+    if (existingFactory) {
+      // Return a new instance to avoid state pollution
+      const newFactory = new Factory(this, existingFactory.definition);
+      newFactory.states = new Map(existingFactory.states);
+      return newFactory;
+    }
+    throw new Error(`No factory defined for model: ${this.name}`);
+  };
+}
+
+module.exports = {
+  Factory,
+  defineFactory,
+  factory,
+  factoryForModel,
+  createFactory,
+  globalSequence,
+  resetGlobalSequence,
+  trait,
+  BulkFactory,
+  bulkFactory
+};