@orchestr-sh/orchestr 1.10.0 → 1.11.0

package/dist/Database/Ensemble/Ensemble.js

@@ -1,755 +0,0 @@
-"use strict";
-/**
- * Ensemble Class
- *
- * Base class for Ensemble models with ActiveRecord pattern
- * In Orchestr, your data models are called Ensembles - groups that work in harmony
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Ensemble = void 0;
-const EnsembleBuilder_1 = require("./EnsembleBuilder");
-const HasRelationships_1 = require("./Concerns/HasRelationships");
-const Events_1 = require("./Events");
-class Ensemble extends HasRelationships_1.HasRelationshipsMixin {
-    /**
-     * The connection resolver instance
-     */
-    static connectionResolver;
-    /**
-     * The table associated with the model
-     */
-    table;
-    /**
-     * The primary key for the model
-     */
-    primaryKey = 'id';
-    /**
-     * Indicates if the IDs are auto-incrementing
-     */
-    incrementing = true;
-    /**
-     * The data type of the primary key
-     */
-    keyType = 'int';
-    /**
-     * The attributes that are mass assignable (instance property).
-     *
-     * Subclasses may also declare `static fillable: string[]` instead.
-     * Static properties are resolved at construction time so they are safe
-     * to use even when a subclass constructor has not yet run its own field
-     * initialisers.
-     */
-    fillable = [];
-    /**
-     * The attributes that aren't mass assignable (instance property).
-     *
-     * Subclasses may also declare `static guarded: string[]` instead of
-     * (or in addition to) the instance property.
-     */
-    guarded = ['*'];
-    /**
-     * Static fillable list.  Subclasses that declare `static fillable` here
-     * will have those attributes made mass-assignable without needing a
-     * constructor override.
-     */
-    static fillable;
-    /**
-     * Static guarded list.  Subclasses that declare `static guarded` here
-     * will have those attributes protected from mass assignment without
-     * needing a constructor override.
-     */
-    static guarded;
-    /**
-     * The attributes that should be hidden for serialization
-     */
-    hidden = [];
-    /**
-     * The attributes that should be visible for serialization
-     */
-    visible = [];
-    /**
-     * The accessors to append to the model's array form
-     */
-    appends = [];
-    /**
-     * The attributes that should be cast
-     */
-    casts = {};
-    /**
-     * Indicates if the model should be timestamped
-     */
-    timestamps = true;
-    /**
-     * The name of the "created at" column
-     */
-    static CREATED_AT = 'created_at';
-    /**
-     * The name of the "updated at" column
-     */
-    static UPDATED_AT = 'updated_at';
-    /**
-     * The name of the "deleted at" column (for soft deletes)
-     */
-    static DELETED_AT = 'deleted_at';
-    /**
-     * The model's attributes
-     */
-    attributes = {};
-    /**
-     * The model's original attributes
-     */
-    original = {};
-    /**
-     * Indicates if the model exists in the database
-     */
-    exists = false;
-    /**
-     * Indicates if the model was inserted during this request
-     */
-    wasRecentlyCreated = false;
-    /**
-     * The connection name for the model
-     */
-    connection;
-    /**
-     * Enable dynamic relationship access (user.posts instead of user.posts().get())
-     * Set to true to enable PHP-like __get behavior for relationships
-     */
-    dynamicRelations = false;
-    /**
-     * Create a new Eloquent model instance
-     */
-    constructor(attributes = {}, fromDatabase = false) {
-        super();
-        if (fromDatabase) {
-            // When hydrating from database, set all attributes directly
-            this.setRawAttributes(attributes);
-        }
-        else {
-            // When creating manually, respect fillable/guarded
-            this.fill(attributes);
-        }
-    }
-    /**
-     * Fill the model with an array of attributes
-     */
-    fill(attributes) {
-        for (const [key, value] of Object.entries(attributes)) {
-            if (this.isFillable(key)) {
-                this.setAttribute(key, value);
-            }
-        }
-        return this;
-    }
-    /**
-     * Set a given attribute on the model
-     */
-    setAttribute(key, value) {
-        // Check for mutator
-        const mutator = `set${this.studly(key)}Attribute`;
-        if (typeof this[mutator] === 'function') {
-            this[mutator](value);
-            return this;
-        }
-        this.attributes[key] = value;
-        return this;
-    }
-    /**
-     * Set the array of model attributes (bypasses fillable/guarded)
-     * Used when hydrating from database
-     */
-    setRawAttributes(attributes) {
-        this.attributes = attributes;
-        return this;
-    }
-    /**
-     * Get an attribute from the model
-     */
-    getAttribute(key) {
-        if (!key) {
-            return undefined;
-        }
-        // Check if we have an accessor
-        const accessor = `get${this.studly(key)}Attribute`;
-        if (typeof this[accessor] === 'function') {
-            return this[accessor]();
-        }
-        // Get the attribute value
-        const value = this.attributes[key];
-        // Cast the attribute if needed
-        if (this.hasCast(key)) {
-            return this.castAttribute(key, value);
-        }
-        return value;
-    }
-    /**
-     * Determine if the given attribute may be mass assigned.
-     *
-     * Resolution order for `fillable` and `guarded`:
-     *   1. Static property on the concrete class (e.g. `static fillable = [...]`)
-     *      – safe because static properties exist before any constructor runs.
-     *   2. Instance property (`this.fillable` / `this.guarded`) – populated either
-     *      by Ensemble's own field initialiser or by a subclass constructor
-     *      workaround that calls `this.fill()` a second time after `super()`.
-     *
-     * If the concrete class defines `static fillable`, it takes full precedence
-     * over the instance property (matching Laravel's behaviour where a non-empty
-     * fillable list is the authoritative allow-list).
-     */
-    isFillable(key) {
-        const ctor = this.constructor;
-        // Prefer static fillable if the subclass has defined one on itself
-        // (not inherited – check own property to avoid reading Ensemble's
-        //  `undefined` declaration as a truthy value).
-        const staticFillable = Object.prototype.hasOwnProperty.call(ctor, 'fillable')
-            ? ctor.fillable
-            : undefined;
-        const effectiveFillable = staticFillable ?? this.fillable;
-        if (effectiveFillable.length > 0) {
-            return effectiveFillable.includes(key);
-        }
-        // No fillable list – fall back to guarded logic.
-        const staticGuarded = Object.prototype.hasOwnProperty.call(ctor, 'guarded')
-            ? ctor.guarded
-            : undefined;
-        const effectiveGuarded = staticGuarded ?? this.guarded;
-        if (effectiveGuarded.length > 0 && !effectiveGuarded.includes('*')) {
-            return !effectiveGuarded.includes(key);
-        }
-        return effectiveGuarded[0] !== '*';
-    }
-    /**
-     * Determine if a get mutator exists for an attribute
-     */
-    hasGetMutator(key) {
-        return typeof this[`get${this.studly(key)}Attribute`] === 'function';
-    }
-    /**
-     * Determine if a set mutator exists for an attribute
-     */
-    hasSetMutator(key) {
-        return typeof this[`set${this.studly(key)}Attribute`] === 'function';
-    }
-    /**
-     * Determine if a cast is defined for an attribute
-     */
-    hasCast(key) {
-        return key in this.casts;
-    }
-    /**
-     * Cast an attribute to a native PHP type
-     */
-    castAttribute(key, value) {
-        if (value === null) {
-            return value;
-        }
-        const castType = this.casts[key];
-        switch (castType) {
-            case 'int':
-            case 'integer':
-                return parseInt(value);
-            case 'real':
-            case 'float':
-            case 'double':
-                return parseFloat(value);
-            case 'string':
-                return String(value);
-            case 'bool':
-            case 'boolean':
-                return Boolean(value);
-            case 'object':
-                return typeof value === 'string' ? JSON.parse(value) : value;
-            case 'array':
-            case 'json':
-                return typeof value === 'string' ? JSON.parse(value) : value;
-            case 'collection':
-                return typeof value === 'string' ? JSON.parse(value) : value;
-            case 'date':
-            case 'datetime':
-            case 'timestamp':
-                return value instanceof Date ? value : new Date(value);
-            default:
-                return value;
-        }
-    }
-    /**
-     * Convert the model to a plain object
-     */
-    toObject() {
-        const attributes = {};
-        for (const key of Object.keys(this.attributes)) {
-            if (this.isVisible(key)) {
-                attributes[key] = this.getAttribute(key);
-            }
-        }
-        // Add appended accessors
-        for (const key of this.appends) {
-            attributes[key] = this.getAttribute(key);
-        }
-        // Add loaded relationships
-        for (const [key, value] of Object.entries(this.relations)) {
-            if (Array.isArray(value)) {
-                attributes[key] = value.map((model) => model.toObject());
-            }
-            else if (value && typeof value.toObject === 'function') {
-                attributes[key] = value.toObject();
-            }
-            else {
-                attributes[key] = value;
-            }
-        }
-        return attributes;
-    }
-    /**
-     * Convert the model to JSON
-     */
-    toJSON() {
-        return this.toObject();
-    }
-    /**
-     * Determine if an attribute is visible
-     */
-    isVisible(key) {
-        if (this.visible.length > 0) {
-            return this.visible.includes(key);
-        }
-        return !this.hidden.includes(key);
-    }
-    /**
-     * Get the table associated with the model
-     */
-    getTable() {
-        if (this.table) {
-            return this.table;
-        }
-        // Convert class name to snake_case plural
-        // e.g., User -> users, BlogPost -> blog_posts
-        const className = this.constructor.name;
-        return this.pluralize(this.snake(className));
-    }
-    /**
-     * Get the primary key for the model
-     */
-    getKeyName() {
-        return this.primaryKey;
-    }
-    /**
-     * Get the value of the model's primary key
-     */
-    getKey() {
-        return this.getAttribute(this.getKeyName());
-    }
-    /**
-     * Set the connection resolver instance
-     */
-    static setConnectionResolver(resolver) {
-        Ensemble.connectionResolver = resolver;
-    }
-    /**
-     * Get the database connection for the model
-     */
-    getConnection() {
-        return this.constructor.connectionResolver.connection(this.connection);
-    }
-    /**
-     * Begin querying the model
-     */
-    static query() {
-        const instance = new this();
-        return new EnsembleBuilder_1.EnsembleBuilder(instance.getConnection().getAdapter(), instance);
-    }
-    /**
-     * Get all of the models from the database
-     */
-    static async all(columns = ['*']) {
-        return this
-            .query()
-            .select(...columns)
-            .get();
-    }
-    /**
-     * Find a model by its primary key
-     */
-    static async find(id, columns = ['*']) {
-        return this
-            .query()
-            .select(...columns)
-            .find(id);
-    }
-    /**
-     * Find a model by its primary key or throw an exception
-     */
-    static async findOrFail(id, columns = ['*']) {
-        const model = await this.find(id, columns);
-        if (!model) {
-            throw new Error(`Ensemble not found with id: ${id}`);
-        }
-        return model;
-    }
-    /**
-     * Find multiple models by their primary keys
-     */
-    static async findMany(ids, columns = ['*']) {
-        const instance = new this();
-        return this
-            .query()
-            .select(...columns)
-            .whereIn(instance.getKeyName(), ids)
-            .get();
-    }
-    /**
-     * Create a new instance and save it to the database
-     */
-    static async create(attributes) {
-        const instance = new this(attributes);
-        await instance.save();
-        return instance;
-    }
-    /**
-     * Update or create a model matching the attributes
-     */
-    static async updateOrCreate(attributes, values = {}) {
-        const instance = await this.query().where(attributes).first();
-        if (instance) {
-            instance.fill(values);
-            await instance.save();
-            return instance;
-        }
-        return this.create({ ...attributes, ...values });
-    }
-    /**
-     * Save the model to the database
-     */
-    async save() {
-        // Fire saving event
-        if ((await this.fireModelEvent('saving')) === false) {
-            return false;
-        }
-        if (this.exists) {
-            return this.performUpdate();
-        }
-        return this.performInsert();
-    }
-    /**
-     * Perform a model insert operation
-     */
-    async performInsert() {
-        // Fire creating event
-        if ((await this.fireModelEvent('creating')) === false) {
-            return false;
-        }
-        const attributes = this.getAttributesForInsert();
-        if (this.timestamps) {
-            this.updateTimestamps();
-        }
-        const connection = this.getConnection();
-        const table = this.getTable();
-        const id = await connection.table(table).insertGetId(attributes);
-        if (this.incrementing) {
-            this.setAttribute(this.getKeyName(), id);
-        }
-        this.exists = true;
-        this.wasRecentlyCreated = true;
-        this.syncOriginal();
-        // Fire created event
-        await this.fireModelEvent('created');
-        // Fire saved event
-        await this.fireModelEvent('saved');
-        return true;
-    }
-    /**
-     * Perform a model update operation
-     */
-    async performUpdate() {
-        const dirty = this.getDirty();
-        if (Object.keys(dirty).length === 0) {
-            return true;
-        }
-        // Fire updating event
-        if ((await this.fireModelEvent('updating')) === false) {
-            return false;
-        }
-        if (this.timestamps) {
-            this.updateTimestamps();
-        }
-        const connection = this.getConnection();
-        const table = this.getTable();
-        await connection.table(table).where(this.getKeyName(), '=', this.getKey()).update(dirty);
-        this.syncOriginal();
-        // Fire updated event
-        await this.fireModelEvent('updated');
-        // Fire saved event
-        await this.fireModelEvent('saved');
-        return true;
-    }
-    /**
-     * Update the model's timestamps
-     */
-    updateTimestamps() {
-        const time = new Date();
-        const updatedAtColumn = this.constructor.UPDATED_AT;
-        if (updatedAtColumn && !this.isDirty(updatedAtColumn)) {
-            this.setAttribute(updatedAtColumn, time);
-        }
-        const createdAtColumn = this.constructor.CREATED_AT;
-        if (!this.exists && createdAtColumn && !this.isDirty(createdAtColumn)) {
-            this.setAttribute(createdAtColumn, time);
-        }
-    }
-    /**
-     * Get the attributes that have been changed
-     */
-    getDirty() {
-        const dirty = {};
-        for (const [key, value] of Object.entries(this.attributes)) {
-            if (!this.originalIsEquivalent(key, value)) {
-                dirty[key] = value;
-            }
-        }
-        return dirty;
-    }
-    /**
-     * Determine if the given attribute has been changed
-     */
-    isDirty(attribute) {
-        if (!attribute) {
-            return Object.keys(this.getDirty()).length > 0;
-        }
-        return attribute in this.getDirty();
-    }
-    /**
-     * Determine if the original value is equivalent to the current value
-     */
-    originalIsEquivalent(key, current) {
-        if (!(key in this.original)) {
-            return false;
-        }
-        const original = this.original[key];
-        if (current === original) {
-            return true;
-        }
-        if (current === null) {
-            return false;
-        }
-        if (this.isDateAttribute(key)) {
-            return this.compareDates(current, original);
-        }
-        return String(current) === String(original);
-    }
-    /**
-     * Determine if the given attribute is a date or date castable
-     */
-    isDateAttribute(key) {
-        const cast = this.casts[key];
-        return cast === 'date' || cast === 'datetime' || cast === 'timestamp';
-    }
-    /**
-     * Compare two dates
-     */
-    compareDates(current, original) {
-        const currentDate = current instanceof Date ? current : new Date(current);
-        const originalDate = original instanceof Date ? original : new Date(original);
-        return currentDate.getTime() === originalDate.getTime();
-    }
-    /**
-     * Get the attributes for insert
-     */
-    getAttributesForInsert() {
-        return { ...this.attributes };
-    }
-    /**
-     * Sync the original attributes with the current
-     */
-    syncOriginal() {
-        this.original = { ...this.attributes };
-        return this;
-    }
-    /**
-     * Delete the model from the database
-     */
-    async delete() {
-        if (!this.exists) {
-            return false;
-        }
-        // Fire deleting event
-        if ((await this.fireModelEvent('deleting')) === false) {
-            return false;
-        }
-        const connection = this.getConnection();
-        const table = this.getTable();
-        await connection.table(table).where(this.getKeyName(), '=', this.getKey()).delete();
-        this.exists = false;
-        // Fire deleted event
-        await this.fireModelEvent('deleted');
-        return true;
-    }
-    /**
-     * Reload the current model instance from the database
-     */
-    async refresh() {
-        if (!this.exists) {
-            return this;
-        }
-        const fresh = await this.constructor.find(this.getKey());
-        if (!fresh) {
-            throw new Error('Ensemble not found');
-        }
-        this.attributes = fresh.attributes;
-        this.syncOriginal();
-        return this;
-    }
-    /**
-     * Convert a string to studly case
-     */
-    studly(value) {
-        return value
-            .split('_')
-            .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-            .join('');
-    }
-    /**
-     * Convert a string to snake case
-     */
-    snake(value) {
-        return value
-            .replace(/([A-Z])/g, '_$1')
-            .toLowerCase()
-            .replace(/^_/, '');
-    }
-    /**
-     * Pluralize a string (simple implementation)
-     */
-    pluralize(value) {
-        if (value.endsWith('y')) {
-            return value.slice(0, -1) + 'ies';
-        }
-        if (value.endsWith('s')) {
-            return value + 'es';
-        }
-        return value + 's';
-    }
-    /**
-     * Create a new query instance for the model
-     */
-    newQuery() {
-        return this.constructor.query();
-    }
-    /**
-     * Create a new instance of the given model
-     */
-    newInstance(attributes = {}, exists = false) {
-        const ModelClass = this.constructor;
-        const instance = new ModelClass(attributes, exists);
-        instance.exists = exists;
-        if (exists) {
-            instance.syncOriginal();
-        }
-        return instance;
-    }
-    /**
-     * Get the name of the "updated at" column
-     */
-    getUpdatedAtColumn() {
-        return this.timestamps ? this.constructor.UPDATED_AT : null;
-    }
-    /**
-     * Get the name of the "created at" column
-     */
-    getCreatedAtColumn() {
-        return this.timestamps ? this.constructor.CREATED_AT : null;
-    }
-    /**
-     * Fire the given model event
-     *
-     * @param event - Event name (saving, saved, creating, created, etc.)
-     * @returns false if event is halting and a listener returned false, undefined otherwise
-     */
-    async fireModelEvent(event) {
-        // Try to get the event dispatcher
-        let dispatcher;
-        try {
-            // Import the Dispatcher and get from static resolver if available
-            const { Dispatcher } = await Promise.resolve().then(() => __importStar(require('../../Events/Dispatcher')));
-            const { Facade } = await Promise.resolve().then(() => __importStar(require('../../Support/Facade')));
-            try {
-                dispatcher = Facade.getFacadeApplication()?.make?.('events');
-            }
-            catch {
-                // No dispatcher registered
-            }
-        }
-        catch (error) {
-            // Event system not set up, skip firing events
-            return undefined;
-        }
-        if (!dispatcher || typeof dispatcher.dispatch !== 'function') {
-            return undefined;
-        }
-        // Map event names to event classes
-        const eventMap = {
-            retrieved: Events_1.ModelRetrieved,
-            creating: Events_1.ModelCreating,
-            created: Events_1.ModelCreated,
-            updating: Events_1.ModelUpdating,
-            updated: Events_1.ModelUpdated,
-            saving: Events_1.ModelSaving,
-            saved: Events_1.ModelSaved,
-            deleting: Events_1.ModelDeleting,
-            deleted: Events_1.ModelDeleted,
-        };
-        const EventClass = eventMap[event];
-        if (!EventClass) {
-            return undefined;
-        }
-        const eventInstance = new EventClass(this);
-        // For halting events (creating, updating, saving, deleting), use until()
-        // which returns the first non-null result (false halts the operation)
-        if (['creating', 'updating', 'saving', 'deleting'].includes(event)) {
-            const result = await dispatcher.until?.(eventInstance);
-            // If any listener returns false, halt the operation
-            if (result === false) {
-                return false;
-            }
-        }
-        else {
-            // For non-halting events, just dispatch normally
-            await dispatcher.dispatch(eventInstance);
-        }
-        return undefined;
-    }
-}
-exports.Ensemble = Ensemble;
-//# sourceMappingURL=Ensemble.js.map