outlet-orm 2.5.0

package/src/Relations/BelongsToManyRelation.js

@@ -0,0 +1,466 @@
+const Relation = require('./Relation');
+
+/**
+ * Belongs To Many Relation
+ * Represents a many-to-many relationship through a pivot table
+ */
+class BelongsToManyRelation extends Relation {
+  constructor(parent, related, pivot, foreignPivotKey, relatedPivotKey, parentKey, relatedKey) {
+    super(parent, related, null, null);
+    this.pivot = pivot;
+    this.foreignPivotKey = foreignPivotKey || `${parent.constructor.table.slice(0, -1)}_id`;
+    this.relatedPivotKey = relatedPivotKey || `${related.table.slice(0, -1)}_id`;
+    this.parentKey = parentKey || parent.constructor.primaryKey;
+    this.relatedKey = relatedKey || related.primaryKey;
+    this.pivotColumns = [];
+    this.withTimestamps = false;
+    this.pivotAlias = 'pivot';
+    this.wherePivotConditions = [];
+  }
+
+  /**
+   * Get the related models
+   * @returns {Promise<Array<Model>>}
+   */
+  async get() {
+    const parentKeyValue = this.parent.getAttribute(this.parentKey);
+
+    // Columns to select from pivot
+    const pivotSelectColumns = [this.relatedPivotKey, ...this.pivotColumns];
+    if (this.withTimestamps) {
+      pivotSelectColumns.push('created_at', 'updated_at');
+    }
+
+    // First, get the related IDs and pivot data
+    const pivotRecords = await this.parent.constructor.connection.select(
+      this.pivot,
+      {
+        columns: pivotSelectColumns,
+        wheres: [
+          {
+            column: this.foreignPivotKey,
+            operator: '=',
+            value: parentKeyValue,
+            type: 'basic',
+            boolean: 'and'
+          },
+          ...this.wherePivotConditions.map(cond => {
+            if (cond.type === 'in') {
+              return {
+                column: cond.column,
+                values: cond.values,
+                type: 'in',
+                boolean: 'and'
+              };
+            } else {
+              return {
+                column: cond.column,
+                operator: cond.operator || '=',
+                value: cond.value,
+                type: 'basic',
+                boolean: 'and'
+              };
+            }
+          })
+        ],
+        orders: [],
+        limit: null,
+        offset: null
+      }
+    );
+
+    if (pivotRecords.length === 0) {
+      return [];
+    }
+
+    const relatedIds = pivotRecords.map(record => record[this.relatedPivotKey]);
+
+    // Then get the related models
+    const relatedModels = await this.related
+      .whereIn(this.relatedKey, relatedIds)
+      .get();
+
+    // Attach pivot data
+    const pivotMap = {};
+    pivotRecords.forEach(record => {
+      const key = record[this.relatedPivotKey];
+      const pivotData = {};
+      this.pivotColumns.forEach(col => {
+        pivotData[col] = record[col];
+      });
+      if (this.withTimestamps) {
+        pivotData.created_at = record.created_at;
+        pivotData.updated_at = record.updated_at;
+      }
+      pivotMap[key] = pivotData;
+    });
+
+    relatedModels.forEach(model => {
+      const key = model.getAttribute(this.relatedKey);
+      model[this.pivotAlias] = pivotMap[key] || {};
+    });
+
+    return relatedModels;
+  }  /**
+   * Eager load the relationship for a collection of parent models
+   * @param {Array<Model>} models
+   * @param {string} relationName
+   * @returns {Promise<void>}
+   */
+  async eagerLoad(models, relationName, constraint) {
+    const parentKeys = models
+      .map(model => model.getAttribute(this.parentKey))
+      .filter(key => key !== null && key !== undefined);
+
+    if (parentKeys.length === 0) return;
+
+    // Columns to select from pivot
+    const pivotSelectColumns = [this.foreignPivotKey, this.relatedPivotKey, ...this.pivotColumns];
+    if (this.withTimestamps) {
+      pivotSelectColumns.push('created_at', 'updated_at');
+    }
+
+    // Get all pivot records
+    const pivotRecords = await this.parent.constructor.connection.select(
+      this.pivot,
+      {
+        columns: pivotSelectColumns,
+        wheres: [
+          {
+            column: this.foreignPivotKey,
+            values: parentKeys,
+            type: 'in',
+            boolean: 'and'
+          },
+          ...this.wherePivotConditions.map(cond => {
+            if (cond.type === 'in') {
+              return {
+                column: cond.column,
+                values: cond.values,
+                type: 'in',
+                boolean: 'and'
+              };
+            } else {
+              return {
+                column: cond.column,
+                operator: cond.operator || '=',
+                value: cond.value,
+                type: 'basic',
+                boolean: 'and'
+              };
+            }
+          })
+        ],
+        orders: [],
+        limit: null,
+        offset: null
+      }
+    );
+
+    if (pivotRecords.length === 0) {
+      models.forEach(model => {
+        model.relations[relationName] = [];
+      });
+      return;
+    }
+
+    // Get all related IDs
+    const relatedIds = [...new Set(pivotRecords.map(record => record[this.relatedPivotKey]))];
+
+    // Get all related models
+    const qb = this.related.whereIn(this.relatedKey, relatedIds);
+    if (typeof constraint === 'function') constraint(qb);
+    const relatedModels = await qb.get();
+
+    // Create a map of related models by their key
+    const relatedMap = {};
+    relatedModels.forEach(model => {
+      const keyValue = model.getAttribute(this.relatedKey);
+      relatedMap[keyValue] = model;
+    });
+
+    // Create a map of parent key to related models with pivot
+    const parentToRelatedMap = {};
+    pivotRecords.forEach(pivotRecord => {
+      const parentKeyValue = pivotRecord[this.foreignPivotKey];
+      const relatedKeyValue = pivotRecord[this.relatedPivotKey];
+
+      if (!parentToRelatedMap[parentKeyValue]) {
+        parentToRelatedMap[parentKeyValue] = [];
+      }
+
+      if (relatedMap[relatedKeyValue]) {
+        const model = relatedMap[relatedKeyValue];
+        // Attach pivot data
+        const pivotData = {};
+        this.pivotColumns.forEach(col => {
+          pivotData[col] = pivotRecord[col];
+        });
+        if (this.withTimestamps) {
+          pivotData.created_at = pivotRecord.created_at;
+          pivotData.updated_at = pivotRecord.updated_at;
+        }
+        model[this.pivotAlias] = pivotData;
+        parentToRelatedMap[parentKeyValue].push(model);
+      }
+    });
+
+    // Assign relations to parent models
+    models.forEach(model => {
+      const parentKeyValue = model.getAttribute(this.parentKey);
+      model.relations[relationName] = parentToRelatedMap[parentKeyValue] || [];
+    });
+  }
+
+  /**
+   * Attach a related model to the parent
+   * @param {number|Array<number>} ids
+   * @returns {Promise<void>}
+   */
+  async attach(ids) {
+    const parentKeyValue = this.parent.getAttribute(this.parentKey);
+    const idsArray = Array.isArray(ids) ? ids : [ids];
+
+    const pivotData = idsArray.map(id => {
+      const data = {
+        [this.foreignPivotKey]: parentKeyValue,
+        [this.relatedPivotKey]: id
+      };
+      if (this.withTimestamps) {
+        const now = new Date().toISOString().slice(0, 19).replace('T', ' ');
+        data.created_at = now;
+        data.updated_at = now;
+      }
+      return data;
+    });
+
+    await this.parent.constructor.connection.insertMany(this.pivot, pivotData);
+  }
+
+  /**
+   * Detach a related model from the parent
+   * @param {number|Array<number>|null} ids
+   * @returns {Promise<void>}
+   */
+  async detach(ids = null) {
+    const parentKeyValue = this.parent.getAttribute(this.parentKey);
+
+    const wheres = [{
+      column: this.foreignPivotKey,
+      operator: '=',
+      value: parentKeyValue,
+      type: 'basic',
+      boolean: 'and'
+    }];
+
+    if (ids !== null) {
+      const idsArray = Array.isArray(ids) ? ids : [ids];
+      wheres.push({
+        column: this.relatedPivotKey,
+        values: idsArray,
+        type: 'in',
+        boolean: 'and'
+      });
+    }
+
+    await this.parent.constructor.connection.delete(this.pivot, { wheres });
+  }
+
+  /**
+   * Sync the pivot table with the given IDs
+   * @param {Array<number>} ids
+   * @returns {Promise<void>}
+   */
+  async sync(ids) {
+    await this.detach();
+    await this.attach(ids);
+  }
+
+  /**
+   * Specify additional columns to select from the pivot table
+   * @param {...string} columns
+   * @returns {BelongsToManyRelation}
+   */
+  withPivot(...columns) {
+    this.pivotColumns = columns;
+    return this;
+  }
+
+  /**
+   * Include timestamps in the pivot table
+   * @returns {BelongsToManyRelation}
+   */
+  withTimestamps() {
+    this.withTimestamps = true;
+    return this;
+  }
+
+  /**
+   * Alias for the pivot attribute
+   * @param {string} alias
+   * @returns {BelongsToManyRelation}
+   */
+  as(alias) {
+    this.pivotAlias = alias;
+    return this;
+  }
+
+  /**
+   * Add a where condition on the pivot table
+   * @param {string} column
+   * @param {string} operator
+   * @param {*} value
+   * @returns {BelongsToManyRelation}
+   */
+  wherePivot(column, operator, value) {
+    this.wherePivotConditions.push({ column, operator, value });
+    return this;
+  }
+
+  /**
+   * Add a whereIn condition on the pivot table
+   * @param {string} column
+   * @param {Array} values
+   * @returns {BelongsToManyRelation}
+   */
+  wherePivotIn(column, values) {
+    this.wherePivotConditions.push({ column, values, type: 'in' });
+    return this;
+  }
+
+  /**
+   * Toggle attachment of related models
+   * @param {number|Array<number>} ids
+   * @returns {Promise<void>}
+   */
+  async toggle(ids) {
+    const parentKeyValue = this.parent.getAttribute(this.parentKey);
+    const idsArray = Array.isArray(ids) ? ids : [ids];
+
+    // Get currently attached
+    const attached = await this.parent.constructor.connection.select(
+      this.pivot,
+      {
+        columns: [this.relatedPivotKey],
+        wheres: [{
+          column: this.foreignPivotKey,
+          operator: '=',
+          value: parentKeyValue,
+          type: 'basic',
+          boolean: 'and'
+        }],
+        orders: [],
+        limit: null,
+        offset: null
+      }
+    );
+
+    const attachedIds = attached.map(r => r[this.relatedPivotKey]);
+
+    const toAttach = idsArray.filter(id => !attachedIds.includes(id));
+    const toDetach = attachedIds.filter(id => idsArray.includes(id));
+
+    if (toDetach.length > 0) await this.detach(toDetach);
+    if (toAttach.length > 0) await this.attach(toAttach);
+  }
+
+  /**
+   * Sync without detaching existing
+   * @param {Array<number>} ids
+   * @returns {Promise<void>}
+   */
+  async syncWithoutDetaching(ids) {
+    const parentKeyValue = this.parent.getAttribute(this.parentKey);
+
+    // Get currently attached
+    const attached = await this.parent.constructor.connection.select(
+      this.pivot,
+      {
+        columns: [this.relatedPivotKey],
+        wheres: [{
+          column: this.foreignPivotKey,
+          operator: '=',
+          value: parentKeyValue,
+          type: 'basic',
+          boolean: 'and'
+        }],
+        orders: [],
+        limit: null,
+        offset: null
+      }
+    );
+
+    const attachedIds = attached.map(r => r[this.relatedPivotKey]);
+    const toAttach = ids.filter(id => !attachedIds.includes(id));
+
+    if (toAttach.length > 0) await this.attach(toAttach);
+  }
+
+  /**
+   * Update existing pivot record
+   * @param {number} id
+   * @param {Object} attributes
+   * @returns {Promise<void>}
+   */
+  async updateExistingPivot(id, attributes) {
+    const parentKeyValue = this.parent.getAttribute(this.parentKey);
+
+    const wheres = [
+      {
+        column: this.foreignPivotKey,
+        operator: '=',
+        value: parentKeyValue,
+        type: 'basic',
+        boolean: 'and'
+      },
+      {
+        column: this.relatedPivotKey,
+        operator: '=',
+        value: id,
+        type: 'basic',
+        boolean: 'and'
+      }
+    ];
+
+    await this.parent.constructor.connection.update(this.pivot, attributes, { wheres });
+  }
+
+  /**
+   * Create a new related model and attach it
+   * @param {Object} attributes
+   * @param {Object} pivotAttributes
+   * @returns {Promise<Model>}
+   */
+  async create(attributes = {}, pivotAttributes = {}) {
+    const model = new this.related.model(attributes);
+    await model.save();
+    const id = model.getAttribute(this.relatedKey);
+    await this.attach(id);
+    // If pivot attributes, update the pivot
+    if (Object.keys(pivotAttributes).length > 0) {
+      await this.updateExistingPivot(id, pivotAttributes);
+    }
+    return model;
+  }
+
+  /**
+   * Create multiple related models and attach them
+   * @param {Array<Object>} attributesArray
+   * @param {Array<Object>} pivotAttributesArray
+   * @returns {Promise<Array<Model>>}
+   */
+  async createMany(attributesArray, pivotAttributesArray = []) {
+    const models = [];
+    const ids = [];
+    for (let i = 0; i < attributesArray.length; i++) {
+      const attributes = attributesArray[i];
+      const pivotAttributes = pivotAttributesArray[i] || {};
+      const model = await this.create(attributes, pivotAttributes);
+      models.push(model);
+      ids.push(model.getAttribute(this.relatedKey));
+    }
+    return models;
+  }
+}
+
+module.exports = BelongsToManyRelation;

package/src/Relations/BelongsToRelation.js

@@ -0,0 +1,127 @@
+const Relation = require('./Relation');
+
+/**
+ * Belongs To Relation
+ * Represents an inverse one-to-one or many relationship
+ */
+class BelongsToRelation extends Relation {
+  constructor(child, related, foreignKey, ownerKey) {
+    super(child, related, foreignKey, ownerKey);
+    this.child = child;
+    this.ownerKey = ownerKey;
+    this.defaultValue = null;
+    this.touchesParent = false;
+  }
+
+  /**
+   * Get the related model
+   * @returns {Promise<Model|null>}
+   */
+  async get() {
+    const foreignKeyValue = this.child.getAttribute(this.foreignKey);
+
+    if (!foreignKeyValue) {
+      return this.getDefault();
+    }
+
+    const result = await this.related
+      .where(this.ownerKey, foreignKeyValue)
+      .first();
+
+    return result || this.getDefault();
+  }
+
+  /**
+   * Get the default value
+   * @returns {Model|null}
+   */
+  getDefault() {
+    if (this.defaultValue === null) return null;
+    if (typeof this.defaultValue === 'function') return this.defaultValue();
+    return this.defaultValue;
+  }
+
+  /**
+   * Eager load the relationship for a collection of child models
+   * @param {Array<Model>} models
+   * @param {string} relationName
+   * @returns {Promise<void>}
+   */
+  async eagerLoad(models, relationName, constraint) {
+    const keys = models
+      .map(model => model.getAttribute(this.foreignKey))
+      .filter(key => key !== null && key !== undefined);
+
+    if (keys.length === 0) return;
+
+    const qb = this.related.whereIn(this.ownerKey, keys);
+    if (typeof constraint === 'function') constraint(qb);
+    const relatedModels = await qb.get();
+
+    const relatedMap = {};
+    relatedModels.forEach(model => {
+      const ownerKeyValue = model.getAttribute(this.ownerKey);
+      relatedMap[ownerKeyValue] = model;
+    });
+
+    models.forEach(model => {
+      const foreignKeyValue = model.getAttribute(this.foreignKey);
+      model.relations[relationName] = relatedMap[foreignKeyValue] || this.getDefault();
+    });
+  }
+
+  /**
+   * Add a where clause to the relation query
+   * @param {string} column
+   * @param {string|any} operator
+   * @param {any} value
+   * @returns {QueryBuilder}
+   */
+  where(column, operator, value) {
+    return this.related
+      .where(this.ownerKey, this.child.getAttribute(this.foreignKey))
+      .where(column, operator, value);
+  }
+
+  /**
+   * Set a default value for the relation
+   * @param {Model|function} value
+   * @returns {BelongsToRelation}
+   */
+  withDefault(value) {
+    this.defaultValue = value;
+    return this;
+  }
+
+  /**
+   * Associate the model with this relation
+   * @param {Model|number} modelOrId
+   * @returns {BelongsToRelation}
+   */
+  associate(modelOrId) {
+    const id = modelOrId instanceof this.related ? modelOrId.getAttribute(this.ownerKey) : modelOrId;
+    this.child.setAttribute(this.foreignKey, id);
+    return this;
+  }
+
+  /**
+   * Dissociate the model from this relation
+   * @returns {BelongsToRelation}
+   */
+  dissociate() {
+    this.child.setAttribute(this.foreignKey, null);
+    return this;
+  }
+
+  /**
+   * Enable touching the parent model's timestamp when this model is saved
+   * @returns {BelongsToRelation}
+   */
+  touches() {
+    this.touchesParent = true;
+    this.child.touches.push(this);
+    return this;
+  }
+}
+
+module.exports = BelongsToRelation;

package/src/Relations/HasManyRelation.js

@@ -0,0 +1,125 @@
+const Relation = require('./Relation');
+
+/**
+ * Has Many Relation
+ * Represents a one-to-many relationship
+ */
+class HasManyRelation extends Relation {
+  /**
+   * Get the related models
+   * @returns {Promise<Array<Model>>}
+   */
+  async get() {
+    return this.related
+      .where(this.foreignKey, this.parent.getAttribute(this.localKey))
+      .get();
+  }
+
+  /**
+   * Eager load the relationship for a collection of parent models
+   * @param {Array<Model>} models
+   * @param {string} relationName
+   * @returns {Promise<void>}
+   */
+  async eagerLoad(models, relationName, constraint) {
+    const keys = models
+      .map(model => model.getAttribute(this.localKey))
+      .filter(key => key !== null && key !== undefined);
+
+    if (keys.length === 0) return;
+
+    const qb = this.related.whereIn(this.foreignKey, keys);
+    if (typeof constraint === 'function') constraint(qb);
+    const relatedModels = await qb.get();
+
+    const relatedMap = {};
+    relatedModels.forEach(model => {
+      const foreignKeyValue = model.getAttribute(this.foreignKey);
+      if (!relatedMap[foreignKeyValue]) {
+        relatedMap[foreignKeyValue] = [];
+      }
+      relatedMap[foreignKeyValue].push(model);
+    });
+
+    models.forEach(model => {
+      const localKeyValue = model.getAttribute(this.localKey);
+      model.relations[relationName] = relatedMap[localKeyValue] || [];
+    });
+  }
+
+  /**
+   * Add a where clause to the relation query
+   * @param {string} column
+   * @param {string|any} operator
+   * @param {any} value
+   * @returns {QueryBuilder}
+   */
+  where(column, operator, value) {
+    return this.related
+      .where(this.foreignKey, this.parent.getAttribute(this.localKey))
+      .where(column, operator, value);
+  }
+
+  /**
+   * Count the related models
+   * @returns {Promise<number>}
+   */
+  async count() {
+    return this.related
+      .where(this.foreignKey, this.parent.getAttribute(this.localKey))
+      .count();
+  }
+
+  /**
+   * Create a new related model and associate it
+   * @param {Object} attributes
+   * @returns {Promise<Model>}
+   */
+  async create(attributes = {}) {
+    const model = new this.related.model(attributes);
+    model.setAttribute(this.foreignKey, this.parent.getAttribute(this.localKey));
+    await model.save();
+    return model;
+  }
+
+  /**
+   * Save an existing model and associate it
+   * @param {Model} model
+   * @returns {Promise<Model>}
+   */
+  async save(model) {
+    model.setAttribute(this.foreignKey, this.parent.getAttribute(this.localKey));
+    await model.save();
+    return model;
+  }
+
+  /**
+   * Create multiple related models and associate them
+   * @param {Array<Object>} attributesArray
+   * @returns {Promise<Array<Model>>}
+   */
+  async createMany(attributesArray) {
+    const models = [];
+    for (const attributes of attributesArray) {
+      const model = await this.create(attributes);
+      models.push(model);
+    }
+    return models;
+  }
+
+  /**
+   * Save multiple existing models and associate them
+   * @param {Array<Model>} models
+   * @returns {Promise<Array<Model>>}
+   */
+  async saveMany(models) {
+    const savedModels = [];
+    for (const model of models) {
+      const saved = await this.save(model);
+      savedModels.push(saved);
+    }
+    return savedModels;
+  }
+}
+
+module.exports = HasManyRelation;