@bunnykit/orm 0.1.0

package/dist/src/model/Model.js

@@ -0,0 +1,763 @@
+import { Builder } from "../query/Builder.js";
+import { snakeCase } from "../utils.js";
+import { ObserverRegistry } from "./Observer.js";
+import { MorphTo, MorphOne, MorphMany, MorphToMany } from "./MorphRelations.js";
+import { BelongsToMany } from "./BelongsToMany.js";
+const globalScopes = new WeakMap();
+function getGlobalScopes(model) {
+    const scopes = new Map();
+    const chain = [];
+    let current = model;
+    while (current && current.prototype instanceof Model) {
+        chain.unshift(current);
+        current = Object.getPrototypeOf(current);
+    }
+    for (const item of chain) {
+        const ownScopes = globalScopes.get(item);
+        if (ownScopes) {
+            for (const [name, scope] of ownScopes)
+                scopes.set(name, scope);
+        }
+    }
+    return scopes;
+}
+export class Relation {
+    builder;
+    parent;
+    related;
+    foreignKey;
+    localKey;
+    constructor(parent, related, foreignKey, localKey) {
+        this.parent = parent;
+        this.related = related;
+        this.builder = related.query();
+        this.foreignKey = foreignKey || this.defaultForeignKey();
+        this.localKey = localKey || related.primaryKey;
+    }
+    defaultForeignKey() {
+        return `${snakeCase(this.parent.constructor.name)}_id`;
+    }
+    getQuery() {
+        return this.builder;
+    }
+    qualifyRelatedColumn(column) {
+        return column.includes(".") ? column : `${this.related.getTable()}.${column}`;
+    }
+    newExistenceQuery(parentQuery, aggregate, callback) {
+        const query = this.related.query().select(aggregate);
+        query.whereColumn(`${this.related.getTable()}.${this.foreignKey}`, "=", `${parentQuery.tableName}.${this.localKey}`);
+        if (callback)
+            callback(query);
+        return query;
+    }
+    getRelationExistenceSql(parentQuery, callback) {
+        return this.newExistenceQuery(parentQuery, "1", callback).toSql();
+    }
+    getRelationCountSql(parentQuery, callback) {
+        return this.getRelationAggregateSql(parentQuery, "COUNT(*)", callback);
+    }
+    getRelationAggregateSql(parentQuery, aggregate, callback) {
+        return this.newExistenceQuery(parentQuery, aggregate, callback).toSql();
+    }
+}
+export class HasMany extends Relation {
+    constructor(parent, related, foreignKey, localKey) {
+        super(parent, related, foreignKey, localKey);
+        this.localKey = localKey || parent.constructor.primaryKey;
+        this.foreignKey = foreignKey || this.defaultForeignKey();
+        this.addConstraints();
+    }
+    addConstraints() {
+        const parentValue = this.parent.getAttribute(this.localKey);
+        this.builder.where(this.foreignKey, parentValue);
+    }
+    addEagerConstraints(models) {
+        this.builder = this.related.query();
+        const keys = models.map((m) => m.getAttribute(this.localKey));
+        this.builder.whereIn(this.foreignKey, keys);
+    }
+    async getEager() {
+        return this.builder.get();
+    }
+    match(models, results, relationName) {
+        const dictionary = {};
+        for (const result of results) {
+            const key = result.$attributes[this.foreignKey];
+            if (!dictionary[key])
+                dictionary[key] = [];
+            dictionary[key].push(result);
+        }
+        for (const model of models) {
+            const key = model.getAttribute(this.localKey);
+            model.setRelation(relationName, dictionary[String(key)] || []);
+        }
+    }
+    async getResults() {
+        return this.builder.get();
+    }
+    latestOfMany(column = this.related.primaryKey) {
+        return this.ofMany(column, "max");
+    }
+    oldestOfMany(column = this.related.primaryKey) {
+        return this.ofMany(column, "min");
+    }
+    ofMany(column, aggregate = "max") {
+        const relation = new HasOne(this.parent, this.related, this.foreignKey, this.localKey);
+        relation.getQuery().orderBy(column, aggregate === "max" ? "desc" : "asc");
+        return relation;
+    }
+}
+export class BelongsTo extends Relation {
+    constructor(parent, related, foreignKey, ownerKey) {
+        super(parent, related, foreignKey, ownerKey);
+        this.foreignKey = foreignKey || `${snakeCase(related.name)}_id`;
+        this.localKey = ownerKey || related.primaryKey;
+        this.addConstraints();
+    }
+    addConstraints() {
+        const childValue = this.parent.getAttribute(this.foreignKey);
+        this.builder.where(this.localKey, childValue);
+    }
+    addEagerConstraints(models) {
+        this.builder = this.related.query();
+        const keys = models.map((m) => m.getAttribute(this.foreignKey));
+        this.builder.whereIn(this.localKey, keys);
+    }
+    async getEager() {
+        return this.builder.get();
+    }
+    match(models, results, relationName) {
+        const dictionary = {};
+        for (const result of results) {
+            const key = result.$attributes[this.localKey];
+            dictionary[String(key)] = result;
+        }
+        for (const model of models) {
+            const key = model.getAttribute(this.foreignKey);
+            model.setRelation(relationName, dictionary[String(key)] || null);
+        }
+    }
+    async getResults() {
+        return this.builder.first();
+    }
+    associate(model) {
+        const value = model instanceof Model ? model.getAttribute(this.localKey) : model;
+        this.parent.setAttribute(this.foreignKey, value);
+        return this.parent;
+    }
+    dissociate() {
+        this.parent.setAttribute(this.foreignKey, null);
+        return this.parent;
+    }
+    newExistenceQuery(parentQuery, aggregate, callback) {
+        const query = this.related.query().select(aggregate);
+        query.whereColumn(`${this.related.getTable()}.${this.localKey}`, "=", `${parentQuery.tableName}.${this.foreignKey}`);
+        if (callback)
+            callback(query);
+        return query;
+    }
+}
+export class HasManyThrough extends Relation {
+    through;
+    firstKey;
+    secondKey;
+    secondLocalKey;
+    constructor(parent, related, through, firstKey, secondKey, localKey, secondLocalKey) {
+        super(parent, related, secondKey, localKey);
+        this.through = through;
+        this.localKey = localKey || parent.constructor.primaryKey;
+        this.firstKey = firstKey || `${snakeCase(parent.constructor.name)}_id`;
+        this.secondKey = secondKey || `${snakeCase(through.name)}_id`;
+        this.secondLocalKey = secondLocalKey || through.primaryKey;
+        this.addConstraints();
+    }
+    addConstraints() {
+        const throughTable = this.through.getTable();
+        const relatedTable = this.related.getTable();
+        this.builder.select(`${relatedTable}.*`);
+        this.builder.join(throughTable, `${throughTable}.${this.secondLocalKey}`, "=", `${relatedTable}.${this.secondKey}`);
+        this.builder.where(`${throughTable}.${this.firstKey}`, this.parent.getAttribute(this.localKey));
+    }
+    addEagerConstraints(models) {
+        const throughTable = this.through.getTable();
+        const relatedTable = this.related.getTable();
+        const keys = models.map((m) => m.getAttribute(this.localKey));
+        this.builder = this.related.query();
+        this.builder.select(`${relatedTable}.*`, `${throughTable}.${this.firstKey}`);
+        this.builder.join(throughTable, `${throughTable}.${this.secondLocalKey}`, "=", `${relatedTable}.${this.secondKey}`);
+        this.builder.whereIn(`${throughTable}.${this.firstKey}`, keys);
+    }
+    async getEager() {
+        return this.builder.get();
+    }
+    match(models, results, relationName) {
+        const dictionary = {};
+        for (const result of results) {
+            const key = result.$attributes[this.firstKey];
+            if (!dictionary[key])
+                dictionary[key] = [];
+            delete result.$attributes[this.firstKey];
+            dictionary[key].push(result);
+        }
+        for (const model of models) {
+            const key = model.getAttribute(this.localKey);
+            model.setRelation(relationName, dictionary[String(key)] || []);
+        }
+    }
+    async getResults() {
+        return this.builder.get();
+    }
+    newExistenceQuery(parentQuery, aggregate, callback) {
+        const throughTable = this.through.getTable();
+        const relatedTable = this.related.getTable();
+        const query = this.related.query().select(aggregate);
+        query.join(throughTable, `${throughTable}.${this.secondLocalKey}`, "=", `${relatedTable}.${this.secondKey}`);
+        query.whereColumn(`${throughTable}.${this.firstKey}`, "=", `${parentQuery.tableName}.${this.localKey}`);
+        if (callback)
+            callback(query);
+        return query;
+    }
+}
+export class HasOneThrough extends HasManyThrough {
+    async getResults() {
+        return this.builder.first();
+    }
+    match(models, results, relationName) {
+        const dictionary = {};
+        for (const result of results) {
+            const key = result.$attributes[this.firstKey];
+            delete result.$attributes[this.firstKey];
+            if (!dictionary[key])
+                dictionary[key] = result;
+        }
+        for (const model of models) {
+            const key = model.getAttribute(this.localKey);
+            model.setRelation(relationName, dictionary[String(key)] || null);
+        }
+    }
+}
+export class HasOne extends Relation {
+    constructor(parent, related, foreignKey, localKey) {
+        super(parent, related, foreignKey, localKey);
+        this.localKey = localKey || parent.constructor.primaryKey;
+        this.foreignKey = foreignKey || this.defaultForeignKey();
+        this.addConstraints();
+    }
+    addConstraints() {
+        const parentValue = this.parent.getAttribute(this.localKey);
+        this.builder.where(this.foreignKey, parentValue);
+    }
+    addEagerConstraints(models) {
+        this.builder = this.related.query();
+        const keys = models.map((m) => m.getAttribute(this.localKey));
+        this.builder.whereIn(this.foreignKey, keys);
+    }
+    async getEager() {
+        return this.builder.get();
+    }
+    match(models, results, relationName) {
+        const dictionary = {};
+        for (const result of results) {
+            const key = result.$attributes[this.foreignKey];
+            dictionary[String(key)] = result;
+        }
+        for (const model of models) {
+            const key = model.getAttribute(this.localKey);
+            model.setRelation(relationName, dictionary[String(key)] || null);
+        }
+    }
+    async getResults() {
+        return this.builder.first();
+    }
+}
+export class Model {
+    static table;
+    static primaryKey = "id";
+    static timestamps = true;
+    static connection;
+    static dateFormat = "YYYY-MM-DD HH:mm:ss";
+    static morphName;
+    static casts = {};
+    static fillable = [];
+    static guarded = [];
+    static attributes = {};
+    static softDeletes = false;
+    static deletedAtColumn = "deleted_at";
+    $attributes = {};
+    $original = {};
+    $exists = false;
+    $relations = {};
+    $casts = {};
+    constructor(attributes) {
+        const defaults = this.constructor.attributes;
+        if (Object.keys(defaults).length > 0) {
+            this.fill({ ...defaults });
+        }
+        if (attributes) {
+            this.fill(attributes);
+        }
+        return new Proxy(this, {
+            get(target, prop, receiver) {
+                if (typeof prop === "string" && !(prop in target) && prop in target.$attributes) {
+                    return target.getAttribute(prop);
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+            set(target, prop, value, receiver) {
+                if (typeof prop === "string" && !prop.startsWith("$") && !(prop in target)) {
+                    target.setAttribute(prop, value);
+                    return true;
+                }
+                return Reflect.set(target, prop, value, receiver);
+            },
+            has(target, prop) {
+                return prop in target || (typeof prop === "string" && prop in target.$attributes);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (typeof prop === "string" && !(prop in target) && prop in target.$attributes) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                        value: target.getAttribute(prop),
+                    };
+                }
+                return Reflect.getOwnPropertyDescriptor(target, prop);
+            },
+            ownKeys(target) {
+                return [...new Set([...Reflect.ownKeys(target), ...Object.keys(target.$attributes)])];
+            },
+        });
+    }
+    static getTable() {
+        return this.table || snakeCase(this.name) + "s";
+    }
+    static getConnection() {
+        if (!this.connection) {
+            throw new Error(`No connection set on model ${this.name}`);
+        }
+        return this.connection;
+    }
+    static setConnection(connection) {
+        this.connection = connection;
+    }
+    static query() {
+        const builder = new Builder(this.getConnection(), this.getTable());
+        builder.setModel(this);
+        this.applyGlobalScopes(builder);
+        return builder;
+    }
+    static addGlobalScope(name, scope) {
+        const scopes = globalScopes.get(this) || new Map();
+        scopes.set(name, scope);
+        globalScopes.set(this, scopes);
+    }
+    static removeGlobalScope(name) {
+        globalScopes.get(this)?.delete(name);
+    }
+    static applyGlobalScopes(builder) {
+        if (this.softDeletes) {
+            builder.whereNull(this.getQualifiedDeletedAtColumn(), "and", "softDeletes");
+        }
+        for (const [name, scope] of getGlobalScopes(this)) {
+            scope(builder, this);
+            for (const where of builder.wheres) {
+                if (!where.scope)
+                    where.scope = name;
+            }
+        }
+    }
+    static getQualifiedDeletedAtColumn() {
+        return `${this.getTable()}.${this.deletedAtColumn}`;
+    }
+    static async create(attributes) {
+        const instance = new this();
+        instance.fill(attributes);
+        await instance.save();
+        return instance;
+    }
+    static async find(id) {
+        return this.query().find(id, this.primaryKey);
+    }
+    static async first() {
+        return this.query().first();
+    }
+    static where(column, operator, value) {
+        return this.query().where(column, operator, value);
+    }
+    static whereIn(column, values) {
+        return this.query().whereIn(column, values);
+    }
+    static whereNull(column) {
+        return this.query().whereNull(column);
+    }
+    static whereNotNull(column) {
+        return this.query().whereNotNull(column);
+    }
+    static orWhere(column, operator, value) {
+        return this.query().orWhere(column, operator, value);
+    }
+    static with(...relations) {
+        return this.query().with(...relations);
+    }
+    static withTrashed() {
+        return this.query().withTrashed();
+    }
+    static onlyTrashed() {
+        return this.query().onlyTrashed();
+    }
+    static withoutGlobalScope(scope) {
+        return this.query().withoutGlobalScope(scope);
+    }
+    static withoutGlobalScopes() {
+        return this.query().withoutGlobalScopes();
+    }
+    static scope(name, ...args) {
+        return this.query().scope(name, ...args);
+    }
+    static has(relationName, operator, count) {
+        return this.query().has(relationName, operator, count);
+    }
+    static whereHas(relationName, callback, operator, count) {
+        return this.query().whereHas(relationName, callback, operator, count);
+    }
+    static doesntHave(relationName) {
+        return this.query().doesntHave(relationName);
+    }
+    static withCount(relationName, alias) {
+        return this.query().withCount(relationName, alias);
+    }
+    static withSum(relationName, column, alias) {
+        return this.query().withSum(relationName, column, alias);
+    }
+    static withAvg(relationName, column, alias) {
+        return this.query().withAvg(relationName, column, alias);
+    }
+    static withMin(relationName, column, alias) {
+        return this.query().withMin(relationName, column, alias);
+    }
+    static withMax(relationName, column, alias) {
+        return this.query().withMax(relationName, column, alias);
+    }
+    static async all() {
+        return this.query().get();
+    }
+    static async paginate(perPage, page) {
+        return this.query().paginate(perPage, page);
+    }
+    static async eagerLoadRelations(models, relations) {
+        for (const relationName of relations) {
+            if (relationName.includes(".")) {
+                const [first, ...rest] = relationName.split(".");
+                await this.eagerLoadRelation(models, first);
+                const nestedModels = [];
+                for (const model of models) {
+                    const related = model.getRelation(first);
+                    if (Array.isArray(related))
+                        nestedModels.push(...related);
+                    else if (related)
+                        nestedModels.push(related);
+                }
+                if (nestedModels.length > 0) {
+                    await this.eagerLoadRelations(nestedModels, [rest.join(".")]);
+                }
+            }
+            else {
+                await this.eagerLoadRelation(models, relationName);
+            }
+        }
+    }
+    static async eagerLoadRelation(models, relationName) {
+        if (models.length === 0)
+            return;
+        const firstModel = models[0];
+        const relation = firstModel[relationName]();
+        relation.addEagerConstraints(models);
+        const results = await relation.getEager();
+        relation.match(models, results, relationName);
+    }
+    fill(attributes) {
+        for (const [key, value] of Object.entries(attributes)) {
+            if (this.isFillable(key)) {
+                this.setAttribute(key, value);
+            }
+        }
+        return this;
+    }
+    isFillable(key) {
+        const constructor = this.constructor;
+        if (constructor.fillable.length > 0) {
+            return constructor.fillable.includes(key);
+        }
+        if (constructor.guarded.length > 0) {
+            return !constructor.guarded.includes(key);
+        }
+        return true;
+    }
+    getAttribute(key) {
+        const value = this.$attributes[key];
+        return this.castAttribute(key, value);
+    }
+    setAttribute(key, value) {
+        this.$attributes[key] = this.serializeCastAttribute(key, value);
+    }
+    castAttribute(key, value) {
+        const cast = this.getCastDefinition(key);
+        if (!cast || value === null || value === undefined)
+            return value;
+        const custom = this.resolveCustomCast(cast);
+        if (custom)
+            return custom.get(this, key, value, this.$attributes);
+        const [type, argument] = String(cast).split(":");
+        switch (type) {
+            case "boolean":
+            case "bool":
+                return !!value;
+            case "number":
+            case "integer":
+            case "int":
+            case "float":
+            case "double":
+                return Number(value);
+            case "decimal":
+                return Number(value).toFixed(Number(argument || 2));
+            case "string":
+                return String(value);
+            case "date":
+            case "datetime":
+                return new Date(value);
+            case "json":
+            case "array":
+                return typeof value === "string" ? JSON.parse(value) : value;
+            case "object":
+                return typeof value === "string" ? JSON.parse(value) : value;
+            case "enum":
+                return value;
+            case "encrypted":
+                return typeof value === "string" ? Buffer.from(value, "base64").toString("utf8") : value;
+            default:
+                return value;
+        }
+    }
+    serializeCastAttribute(key, value) {
+        const cast = this.getCastDefinition(key);
+        if (!cast || value === null || value === undefined)
+            return value;
+        const custom = this.resolveCustomCast(cast);
+        if (custom)
+            return custom.set(this, key, value, this.$attributes);
+        const [type, argument] = String(cast).split(":");
+        switch (type) {
+            case "boolean":
+            case "bool":
+                return value ? 1 : 0;
+            case "number":
+            case "integer":
+            case "int":
+            case "float":
+            case "double":
+                return Number(value);
+            case "decimal":
+                return Number(value).toFixed(Number(argument || 2));
+            case "string":
+                return String(value);
+            case "date":
+            case "datetime":
+                return value instanceof Date ? value.toISOString() : value;
+            case "json":
+            case "array":
+            case "object":
+                return typeof value === "string" ? value : JSON.stringify(value);
+            case "enum":
+                return typeof value === "object" && "value" in value ? value.value : value;
+            case "encrypted":
+                return Buffer.from(String(value), "utf8").toString("base64");
+            default:
+                return value;
+        }
+    }
+    mergeCasts(casts) {
+        this.$casts = { ...this.$casts, ...casts };
+        return this;
+    }
+    getCastDefinition(key) {
+        const constructor = this.constructor;
+        return this.$casts[key] || constructor.casts[key];
+    }
+    resolveCustomCast(cast) {
+        if (typeof cast === "string")
+            return null;
+        if (typeof cast === "function")
+            return new cast();
+        if (typeof cast.get === "function" && typeof cast.set === "function")
+            return cast;
+        return null;
+    }
+    getDirty() {
+        const dirty = {};
+        for (const [key, value] of Object.entries(this.$attributes)) {
+            if (this.$original[key] !== value) {
+                dirty[key] = value;
+            }
+        }
+        return dirty;
+    }
+    isDirty() {
+        return Object.keys(this.getDirty()).length > 0;
+    }
+    async save() {
+        const constructor = this.constructor;
+        if (this.$exists) {
+            await ObserverRegistry.dispatch("updating", this);
+            await ObserverRegistry.dispatch("saving", this);
+            if (constructor.timestamps) {
+                this.$attributes["updated_at"] = this.freshTimestamp();
+            }
+            const dirty = this.getDirty();
+            if (Object.keys(dirty).length > 0) {
+                const pk = this.getAttribute(constructor.primaryKey);
+                await new Builder(constructor.getConnection(), constructor.getTable())
+                    .where(constructor.primaryKey, pk)
+                    .update(dirty);
+            }
+            this.$original = { ...this.$attributes };
+            await ObserverRegistry.dispatch("updated", this);
+            await ObserverRegistry.dispatch("saved", this);
+        }
+        else {
+            await ObserverRegistry.dispatch("creating", this);
+            await ObserverRegistry.dispatch("saving", this);
+            if (constructor.timestamps) {
+                const now = this.freshTimestamp();
+                this.$attributes["created_at"] = now;
+                this.$attributes["updated_at"] = now;
+            }
+            const result = await new Builder(constructor.getConnection(), constructor.getTable()).insertGetId(this.$attributes);
+            if (result) {
+                this.$attributes[constructor.primaryKey] = result;
+            }
+            this.$exists = true;
+            this.$original = { ...this.$attributes };
+            await ObserverRegistry.dispatch("created", this);
+            await ObserverRegistry.dispatch("saved", this);
+        }
+        return this;
+    }
+    async delete() {
+        const constructor = this.constructor;
+        await ObserverRegistry.dispatch("deleting", this);
+        const pk = this.getAttribute(constructor.primaryKey);
+        if (!pk)
+            return false;
+        if (constructor.softDeletes) {
+            const deletedAt = this.freshTimestamp();
+            await new Builder(constructor.getConnection(), constructor.getTable())
+                .where(constructor.primaryKey, pk)
+                .update({ [constructor.deletedAtColumn]: deletedAt });
+            this.$attributes[constructor.deletedAtColumn] = deletedAt;
+            this.$original = { ...this.$attributes };
+        }
+        else {
+            await new Builder(constructor.getConnection(), constructor.getTable())
+                .where(constructor.primaryKey, pk)
+                .delete();
+            this.$exists = false;
+        }
+        await ObserverRegistry.dispatch("deleted", this);
+        return true;
+    }
+    async restore() {
+        const constructor = this.constructor;
+        if (!constructor.softDeletes)
+            return false;
+        const pk = this.getAttribute(constructor.primaryKey);
+        if (!pk)
+            return false;
+        await new Builder(constructor.getConnection(), constructor.getTable())
+            .where(constructor.primaryKey, pk)
+            .update({ [constructor.deletedAtColumn]: null });
+        this.$attributes[constructor.deletedAtColumn] = null;
+        this.$original = { ...this.$attributes };
+        this.$exists = true;
+        return true;
+    }
+    async forceDelete() {
+        const constructor = this.constructor;
+        const pk = this.getAttribute(constructor.primaryKey);
+        if (!pk)
+            return false;
+        await new Builder(constructor.getConnection(), constructor.getTable())
+            .where(constructor.primaryKey, pk)
+            .delete();
+        this.$exists = false;
+        return true;
+    }
+    async refresh() {
+        const constructor = this.constructor;
+        const pk = this.getAttribute(constructor.primaryKey);
+        if (!pk)
+            return this;
+        const result = await constructor.find(pk);
+        if (result) {
+            this.$attributes = result.$attributes;
+            this.$original = { ...result.$attributes };
+        }
+        return this;
+    }
+    toJSON() {
+        const result = {};
+        for (const key of Object.keys(this.$attributes)) {
+            result[key] = this.getAttribute(key);
+        }
+        return result;
+    }
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
+    freshTimestamp() {
+        return new Date().toISOString();
+    }
+    setRelation(name, value) {
+        this.$relations[name] = value;
+    }
+    getRelation(name) {
+        return this.$relations[name];
+    }
+    // Relations
+    hasMany(related, foreignKey, localKey) {
+        return new HasMany(this, related, foreignKey, localKey);
+    }
+    belongsTo(related, foreignKey, ownerKey) {
+        return new BelongsTo(this, related, foreignKey, ownerKey);
+    }
+    hasOne(related, foreignKey, localKey) {
+        return new HasOne(this, related, foreignKey, localKey);
+    }
+    hasManyThrough(related, through, firstKey, secondKey, localKey, secondLocalKey) {
+        return new HasManyThrough(this, related, through, firstKey, secondKey, localKey, secondLocalKey);
+    }
+    hasOneThrough(related, through, firstKey, secondKey, localKey, secondLocalKey) {
+        return new HasOneThrough(this, related, through, firstKey, secondKey, localKey, secondLocalKey);
+    }
+    belongsToMany(related, table, foreignPivotKey, relatedPivotKey, parentKey, relatedKey) {
+        return new BelongsToMany(this, related, table, foreignPivotKey, relatedPivotKey, parentKey, relatedKey);
+    }
+    // Polymorphic relations
+    morphTo(name, typeMap) {
+        return new MorphTo(this, name, typeMap);
+    }
+    morphOne(related, name, typeColumn, idColumn, localKey) {
+        return new MorphOne(this, related, name, typeColumn, idColumn, localKey);
+    }
+    morphMany(related, name, typeColumn, idColumn, localKey) {
+        return new MorphMany(this, related, name, typeColumn, idColumn, localKey);
+    }
+    morphToMany(related, name, table, foreignPivotKey, relatedPivotKey, parentKey, relatedKey) {
+        const type = this.constructor.morphName || this.constructor.name;
+        return new MorphToMany(this, related, name, table, foreignPivotKey || `${snakeCase(name)}_id`, relatedPivotKey || `${snakeCase(related.name)}_id`, parentKey, relatedKey, type);
+    }
+    morphedByMany(related, name, table, foreignPivotKey, relatedPivotKey, parentKey, relatedKey) {
+        const type = related.morphName || related.name;
+        return new MorphToMany(this, related, name, table, foreignPivotKey || `${snakeCase(this.constructor.name)}_id`, relatedPivotKey || `${snakeCase(name)}_id`, parentKey, relatedKey, type);
+    }
+}