velocious 1.0.107 → 1.0.109

package/dist/src/database/record/instance-relationships/base.d.ts

@@ -0,0 +1,74 @@
+export default class VelociousDatabaseRecordBaseInstanceRelationship {
+    /**
+     * @param {object} args
+     * @param {import("../index.js").default} args.model
+     * @param {import("../relationships/base.js").default} args.relationship
+     */
+    constructor({ model, relationship }: {
+        model: import("../index.js").default;
+        relationship: import("../relationships/base.js").default;
+    });
+    /** @type {boolean | undefined} */
+    _autoSave: boolean | undefined;
+    _dirty: boolean;
+    model: import("../index.js").default;
+    relationship: import("../relationships/base.js").default;
+    /**
+     * @abstract
+     * @param {import("../index.js").default[] | import("../index.js").default} models
+     * @returns {void}
+     */
+    addToLoaded(models: import("../index.js").default[] | import("../index.js").default): void;
+    /**
+     * @abstract
+     * @param {Record<string, any>} attributes
+     * @returns {import("../index.js").default}
+     */
+    build(attributes: Record<string, any>): import("../index.js").default;
+    /** @returns {boolean | undefined} Whether the relationship should be auto-saved before saving the parent model */
+    getAutoSave(): boolean | undefined;
+    /**
+     * @param {boolean} newAutoSaveValue Whether the relationship should be auto-saved before saving the parent model
+     * @returns {void}
+     */
+    setAutoSave(newAutoSaveValue: boolean): void;
+    /**
+     * @param {boolean} newValue Whether the relationship is dirty (has been modified)
+     * @returns {void}
+     */
+    setDirty(newValue: boolean): void;
+    /** @returns {boolean} Whether the relationship is dirty (has been modified) */
+    getDirty(): boolean;
+    /**
+     * @abstract
+     * @returns {Promise<void>}
+     */
+    load(): Promise<void>;
+    /**  @returns {boolean} Whether the relationship has been preloaded */
+    isLoaded(): boolean;
+    /** @returns {import("../index.js").default | Array<import("../index.js").default> | undefined} The loaded model or models (depending on relationship type) */
+    loaded(): import("../index.js").default | Array<import("../index.js").default> | undefined;
+    /** @param {import("../index.js").default|Array<import("../index.js").default>|undefined} model */
+    setLoaded(model: import("../index.js").default | Array<import("../index.js").default> | undefined): void;
+    _loaded: import("../index.js").default | import("../index.js").default[];
+    /** @returns {import("../index.js").default | import("../index.js").default[] | undefined} */
+    getLoadedOrUndefined(): import("../index.js").default | import("../index.js").default[] | undefined;
+    /** @returns {boolean} The loaded model or models (depending on relationship type) */
+    getPreloaded(): boolean;
+    /** @param {boolean} isPreloaded */
+    setPreloaded(isPreloaded: boolean): void;
+    _preloaded: boolean;
+    /** @returns {string} The foreign key for this relationship */
+    getForeignKey(): string;
+    /** @returns {import("../index.js").default} model */
+    getModel(): import("../index.js").default;
+    /** @returns {string} The primary key for this relationship's model */
+    getPrimaryKey(): string;
+    /** @returns {import("../relationships/base.js").default} The relationship object that this instance relationship is based on */
+    getRelationship(): import("../relationships/base.js").default;
+    /** @returns {typeof import("../index.js").default | undefined} The model class that this instance relationship */
+    getTargetModelClass(): typeof import("../index.js").default | undefined;
+    /** @returns {string} The type of relationship (e.g. "has_many", "belongs_to", etc.) */
+    getType(): string;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/src/database/record/instance-relationships/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../../src/database/record/instance-relationships/base.js"],"names":[],"mappings":"AAEA;IAIE;;;;OAIG;IACH,qCAHG;QAA4C,KAAK,EAAzC,OAAO,aAAa,EAAE,OAAO;QACoB,YAAY,EAA7D,OAAO,0BAA0B,EAAE,OAAO;KACpD,EAKA;IAZD,kCAAkC;IAClC,WADW,OAAO,GAAG,SAAS,CACT;IAQnB,gBAAmB;IACnB,qCAAkB;IAClB,yDAAgC;IAGlC;;;;OAIG;IACH,oBAHW,OAAO,aAAa,EAAE,OAAO,EAAE,GAAG,OAAO,aAAa,EAAE,OAAO,GAC7D,IAAI,CAIhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,OAAO,aAAa,EAAE,OAAO,CAIzC;IAED,kHAAkH;IAClH,eADc,OAAO,GAAG,SAAS,CACM;IAEvC;;;OAGG;IACH,8BAHW,OAAO,GACL,IAAI,CAEkD;IAEnE;;;OAGG;IACH,mBAHW,OAAO,GACL,IAAI,CAE4B;IAE7C,+EAA+E;IAC/E,YADc,OAAO,CACY;IAEjC;;;OAGG;IACH,QAFa,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED,sEAAsE;IACtE,YADe,OAAO,CACqB;IAE3C,8JAA8J;IAC9J,UADc,OAAO,aAAa,EAAE,OAAO,GAAG,KAAK,CAAC,OAAO,aAAa,EAAE,OAAO,CAAC,GAAG,SAAS,CAO7F;IAED,kGAAkG;IAClG,iBADY,OAAO,aAAa,EAAE,OAAO,GAAC,KAAK,CAAC,OAAO,aAAa,EAAE,OAAO,CAAC,GAAC,SAAS,QAC/C;IAAtB,yEAAoB;IAEvC,6FAA6F;IAC7F,wBADc,OAAO,aAAa,EAAE,OAAO,GAAG,OAAO,aAAa,EAAE,OAAO,EAAE,GAAG,SAAS,CAC3C;IAE9C,qFAAqF;IACrF,gBADc,OAAO,CAC6B;IAElD,mCAAmC;IACnC,0BADY,OAAO,QACwC;IAA/B,oBAA6B;IAEzD,8DAA8D;IAC9D,iBADc,MAAM,CAC6C;IAEjE,qDAAqD;IACrD,YADc,OAAO,aAAa,EAAE,OAAO,CACX;IAEhC,sEAAsE;IACtE,iBADc,MAAM,CAC6C;IAEjE,gIAAgI;IAChI,mBADc,OAAO,0BAA0B,EAAE,OAAO,CACV;IAE9C,kHAAkH;IAClH,uBADc,cAAc,aAAa,EAAE,OAAO,GAAG,SAAS,CACe;IAE7E,uFAAuF;IACvF,WADc,MAAM,CACiC;CACtD"}

package/dist/src/database/record/instance-relationships/base.js

@@ -0,0 +1,81 @@
+// @ts-check
+export default class VelociousDatabaseRecordBaseInstanceRelationship {
+    /** @type {boolean | undefined} */
+    _autoSave = undefined;
+    /**
+     * @param {object} args
+     * @param {import("../index.js").default} args.model
+     * @param {import("../relationships/base.js").default} args.relationship
+     */
+    constructor({ model, relationship }) {
+        this._dirty = false;
+        this.model = model;
+        this.relationship = relationship;
+    }
+    /**
+     * @abstract
+     * @param {import("../index.js").default[] | import("../index.js").default} models
+     * @returns {void}
+     */
+    addToLoaded(models) {
+        throw new Error("addToLoaded not implemented");
+    }
+    /**
+     * @abstract
+     * @param {Record<string, any>} attributes
+     * @returns {import("../index.js").default}
+     */
+    build(attributes) {
+        throw new Error("'build' not implemented");
+    }
+    /** @returns {boolean | undefined} Whether the relationship should be auto-saved before saving the parent model */
+    getAutoSave() { return this._autoSave; }
+    /**
+     * @param {boolean} newAutoSaveValue Whether the relationship should be auto-saved before saving the parent model
+     * @returns {void}
+     */
+    setAutoSave(newAutoSaveValue) { this._autoSave = newAutoSaveValue; }
+    /**
+     * @param {boolean} newValue Whether the relationship is dirty (has been modified)
+     * @returns {void}
+     */
+    setDirty(newValue) { this._dirty = newValue; }
+    /** @returns {boolean} Whether the relationship is dirty (has been modified) */
+    getDirty() { return this._dirty; }
+    /**
+     * @abstract
+     * @returns {Promise<void>}
+     */
+    load() {
+        throw new Error("'load' not implemented");
+    }
+    /**  @returns {boolean} Whether the relationship has been preloaded */
+    isLoaded() { return Boolean(this._loaded); }
+    /** @returns {import("../index.js").default | Array<import("../index.js").default> | undefined} The loaded model or models (depending on relationship type) */
+    loaded() {
+        if (!this._preloaded && this.model.isPersisted()) {
+            throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`);
+        }
+        return this._loaded;
+    }
+    /** @param {import("../index.js").default|Array<import("../index.js").default>|undefined} model */
+    setLoaded(model) { this._loaded = model; }
+    /** @returns {import("../index.js").default | import("../index.js").default[] | undefined} */
+    getLoadedOrUndefined() { return this._loaded; }
+    /** @returns {boolean} The loaded model or models (depending on relationship type) */
+    getPreloaded() { return this._preloaded || false; }
+    /** @param {boolean} isPreloaded */
+    setPreloaded(isPreloaded) { this._preloaded = isPreloaded; }
+    /** @returns {string} The foreign key for this relationship */
+    getForeignKey() { return this.getRelationship().getForeignKey(); }
+    /** @returns {import("../index.js").default} model */
+    getModel() { return this.model; }
+    /** @returns {string} The primary key for this relationship's model */
+    getPrimaryKey() { return this.getRelationship().getPrimaryKey(); }
+    /** @returns {import("../relationships/base.js").default} The relationship object that this instance relationship is based on */
+    getRelationship() { return this.relationship; }
+    /** @returns {typeof import("../index.js").default | undefined} The model class that this instance relationship */
+    getTargetModelClass() { return this.getRelationship().getTargetModelClass(); }
+    /** @returns {string} The type of relationship (e.g. "has_many", "belongs_to", etc.) */
+    getType() { return this.getRelationship().getType(); }
+}

package/dist/src/database/record/instance-relationships/belongs-to.d.ts

@@ -0,0 +1,4 @@
+export default class VelociousDatabaseRecordBelongsToInstanceRelationship extends BaseInstanceRelationship {
+}
+import BaseInstanceRelationship from "./base.js";
+//# sourceMappingURL=belongs-to.d.ts.map

package/dist/src/database/record/instance-relationships/belongs-to.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"belongs-to.d.ts","sourceRoot":"","sources":["../../../../../src/database/record/instance-relationships/belongs-to.js"],"names":[],"mappings":"AAIA;CAgCC;qCAlCoC,WAAW"}

package/dist/src/database/record/instance-relationships/belongs-to.js

@@ -0,0 +1,28 @@
+// @ts-check
+import BaseInstanceRelationship from "./base.js";
+export default class VelociousDatabaseRecordBelongsToInstanceRelationship extends BaseInstanceRelationship {
+    /**
+     * @param {Record<string, any>} data
+     * @returns {import("../index.js").default}
+     */
+    build(data) {
+        const TargetModelClass = this.getTargetModelClass();
+        if (!TargetModelClass)
+            throw new Error("Can't build a new record without a target model");
+        const newInstance = new TargetModelClass(data);
+        this._loaded = newInstance;
+        return newInstance;
+    }
+    getLoadedOrUndefined() { return this._loaded; }
+    async load() {
+        const foreignKey = this.getForeignKey();
+        const foreignModelID = this.getModel().readColumn(foreignKey);
+        const TargetModelClass = this.getTargetModelClass();
+        if (!TargetModelClass)
+            throw new Error("Can't load without a target model");
+        const foreignModel = await TargetModelClass.find(foreignModelID);
+        this.setLoaded(foreignModel);
+        this.setDirty(false);
+        this.setPreloaded(true);
+    }
+}

package/dist/src/database/record/instance-relationships/has-many.d.ts

@@ -0,0 +1,8 @@
+export default class VelociousDatabaseRecordHasManyInstanceRelationship extends BaseInstanceRelationship {
+    /**
+     * @param {import("../index.js").default[]} models
+     */
+    setLoaded(models: import("../index.js").default[]): void;
+}
+import BaseInstanceRelationship from "./base.js";
+//# sourceMappingURL=has-many.d.ts.map

package/dist/src/database/record/instance-relationships/has-many.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-many.d.ts","sourceRoot":"","sources":["../../../../../src/database/record/instance-relationships/has-many.js"],"names":[],"mappings":"AAIA;IAuGE;;OAEG;IACH,kBAFW,OAAO,aAAa,EAAE,OAAO,EAAE,QAMzC;CACF;qCAjHoC,WAAW"}

package/dist/src/database/record/instance-relationships/has-many.js

@@ -0,0 +1,103 @@
+// @ts-check
+import BaseInstanceRelationship from "./base.js";
+export default class VelociousDatabaseRecordHasManyInstanceRelationship extends BaseInstanceRelationship {
+    /**
+     * @param {Record<string, any>} data
+     * @returns {import("../index.js").default}
+     */
+    build(data) {
+        // Spawn new model of the targeted class
+        const targetModelClass = this.getTargetModelClass();
+        if (!targetModelClass)
+            throw new Error("Can't build a new record without a taget model class");
+        const newInstance = new targetModelClass(data);
+        // Add it to the loaded models of this relationship
+        if (this._loaded === undefined) {
+            /** @type {import("../index.js").default[]} */
+            this._loaded = [newInstance];
+        }
+        else if (Array.isArray(this._loaded)) {
+            this._loaded.push(newInstance);
+        }
+        else {
+            throw new Error(`Loaded had an unexpected type: ${typeof this._loaded}`);
+        }
+        // Set loaded on the models inversed relationship
+        const inverseOf = this.getRelationship().getInverseOf();
+        if (inverseOf) {
+            const inverseInstanceRelationship = newInstance.getRelationshipByName(inverseOf);
+            inverseInstanceRelationship.setAutoSave(false);
+            inverseInstanceRelationship.setLoaded(this.getModel());
+        }
+        // Return the new contructed model
+        return newInstance;
+    }
+    async load() {
+        const foreignKey = this.getForeignKey();
+        const primaryKey = this.getPrimaryKey();
+        const primaryModelID = this.getModel().readColumn(primaryKey);
+        const TargetModelClass = this.getTargetModelClass();
+        if (!TargetModelClass)
+            throw new Error("Cannot load without a target model class");
+        /** @type {Record<string, any>} */
+        const whereArgs = {};
+        whereArgs[foreignKey] = primaryModelID;
+        const foreignModels = await TargetModelClass.where(whereArgs).toArray();
+        this.setLoaded(foreignModels);
+        this.setDirty(false);
+        this.setPreloaded(true);
+    }
+    /**
+     * @returns {import("../index.js").default | Array<import("../index.js").default> | undefined} The loaded model or models (depending on relationship type)
+     */
+    loaded() {
+        if (!this._preloaded && this.model.isPersisted()) {
+            throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`);
+        }
+        if (this._loaded === undefined && this.model.isNewRecord()) {
+            return [];
+        }
+        return this._loaded;
+    }
+    /**
+     * @param {import("../index.js").default[] | import("../index.js").default} models
+     * @returns {void}
+     */
+    addToLoaded(models) {
+        if (!models) {
+            throw new Error("Need to give something");
+        }
+        else if (Array.isArray(models)) {
+            for (const model of models) {
+                if (this._loaded === undefined) {
+                    this._loaded = [model];
+                }
+                else if (Array.isArray(this._loaded)) {
+                    this._loaded.push(model);
+                }
+                else {
+                    throw new Error(`Unexpected loaded type: ${typeof this._loaded}`);
+                }
+            }
+        }
+        else {
+            if (this._loaded === undefined) {
+                this._loaded = [models];
+            }
+            else if (Array.isArray(this._loaded)) {
+                this._loaded.push(models);
+            }
+            else {
+                throw new Error(`Unexpected loaded type: ${typeof this._loaded}`);
+            }
+        }
+    }
+    /**
+     * @param {import("../index.js").default[]} models
+     */
+    setLoaded(models) {
+        if (!Array.isArray(models))
+            throw new Error(`Argument given to setLoaded wasn't an array: ${typeof models}`);
+        this._loaded = models;
+    }
+}

package/dist/src/database/record/instance-relationships/has-one.d.ts

@@ -0,0 +1,7 @@
+export default class VelociousDatabaseRecordHasOneInstanceRelationship extends BaseInstanceRelationship {
+    /** @type {import("../index.js").default | undefined} */
+    _loaded: import("../index.js").default | undefined;
+    getLoadedOrUndefined(): import("../index.js").default;
+}
+import BaseInstanceRelationship from "./base.js";
+//# sourceMappingURL=has-one.d.ts.map

package/dist/src/database/record/instance-relationships/has-one.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-one.d.ts","sourceRoot":"","sources":["../../../../../src/database/record/instance-relationships/has-one.js"],"names":[],"mappings":"AAIA;IACE,wDAAwD;IACxD,SADW,OAAO,aAAa,EAAE,OAAO,GAAG,SAAS,CACjC;IAiDnB,sDAA8C;CAU/C;qCA/DoC,WAAW"}

package/dist/src/database/record/instance-relationships/has-one.js

@@ -0,0 +1,50 @@
+// @ts-check
+import BaseInstanceRelationship from "./base.js";
+export default class VelociousDatabaseRecordHasOneInstanceRelationship extends BaseInstanceRelationship {
+    /** @type {import("../index.js").default | undefined} */
+    _loaded = undefined;
+    /**
+     * @param {Record<string, any>} data
+     * @returns {import("../index.js").default}
+     */
+    build(data) {
+        const TargetModelClass = this.getTargetModelClass();
+        if (!TargetModelClass)
+            throw new Error("Can't build a new record without a target model class");
+        const newInstance = new TargetModelClass(data);
+        this._loaded = newInstance;
+        return newInstance;
+    }
+    async load() {
+        const foreignKey = this.getForeignKey();
+        const primaryKey = this.getPrimaryKey();
+        const primaryModelID = this.getModel().readColumn(primaryKey);
+        const TargetModelClass = this.getTargetModelClass();
+        if (!TargetModelClass)
+            throw new Error("Can't load without a target model class");
+        /** @type {Record<string, any>} */
+        const whereArgs = {};
+        whereArgs[foreignKey] = primaryModelID;
+        const foreignModel = await TargetModelClass.where(whereArgs).first();
+        this.setLoaded(foreignModel);
+        this.setDirty(false);
+        this.setPreloaded(true);
+    }
+    /**
+     * @returns {import("../index.js").default | Array<import("../index.js").default> | undefined} The loaded model or models (depending on relationship type)
+     */
+    loaded() {
+        if (!this._preloaded && this.model.isPersisted()) {
+            throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`);
+        }
+        return this._loaded;
+    }
+    getLoadedOrUndefined() { return this._loaded; }
+    /** @param {import("../index.js").default|Array<import("../index.js").default>} model */
+    setLoaded(model) {
+        if (Array.isArray(model))
+            throw new Error(`Argument given to setLoaded was an array: ${typeof model}`);
+        this._loaded = model;
+    }
+    getTargetModelClass() { return this.relationship.getTargetModelClass(); }
+}

package/dist/src/database/record/record-not-found-error.d.ts

@@ -0,0 +1,3 @@
+export default class RecordNotFoundError extends Error {
+}
+//# sourceMappingURL=record-not-found-error.d.ts.map

package/dist/src/database/record/record-not-found-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-not-found-error.d.ts","sourceRoot":"","sources":["../../../../src/database/record/record-not-found-error.js"],"names":[],"mappings":"AAEA;CAAyD"}

package/dist/src/database/record/record-not-found-error.js

@@ -0,0 +1,3 @@
+// @ts-check
+export default class RecordNotFoundError extends Error {
+}

package/dist/src/database/record/relationships/base.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @typedef {object} RelationshipBaseArgsType
+ * @property {string} [className]
+ * @property {string} [dependent]
+ * @property {string | undefined} [foreignKey]
+ * @property {string} [inverseOf]
+ * @property {typeof import("../index.js").default} [klass]
+ * @property {typeof import("../index.js").default} modelClass
+ * @property {string} [primaryKey]
+ * @property {boolean} [polymorphic]
+ * @property {string} relationshipName
+ * @property {string} [through]
+ * @property {string} type
+ */
+export default class VelociousDatabaseRecordBaseRelationship {
+    /** @param {RelationshipBaseArgsType} args */
+    constructor({ className, dependent, foreignKey, inverseOf, klass, modelClass, primaryKey, polymorphic, relationshipName, through, type, ...restArgs }: RelationshipBaseArgsType);
+    className: string;
+    _dependent: string;
+    foreignKey: string;
+    _inverseOf: string;
+    klass: typeof import("../index.js").default;
+    modelClass: typeof import("../index.js").default;
+    _polymorphic: boolean;
+    _primaryKey: string;
+    relationshipName: string;
+    through: string;
+    type: string;
+    getConfiguration(): import("../../../configuration.js").default;
+    /** @returns {string | undefined} What will be done when the parent record is destroyed. E.g. "destroy", "nullify", "restrict" etc. */
+    getDependent(): string | undefined;
+    /**
+     * @abstract
+     * @returns {string} The name of the foreign key, e.g. "user_id", "post_id" etc.
+     */
+    getForeignKey(): string;
+    /**
+     * @abstract
+     * @returns {string | undefined} The name of the inverse relationship, e.g. "posts", "comments" etc.
+     */
+    getInverseOf(): string | undefined;
+    /** @returns {typeof import("../index.js").default} */
+    getModelClass(): typeof import("../index.js").default;
+    /** @returns {string} The name of the relationship, e.g. "posts", "user", "comments" etc. */
+    getRelationshipName(): string;
+    /** @returns {boolean} */
+    getPolymorphic(): boolean;
+    /** @returns {string} The name of the foreign key, e.g. "id" etc. */
+    getPrimaryKey(): string;
+    /** @returns {string} The type of the relationship, e.g. "has_many", "belongs_to", "has_one", "has_and_belongs_to_many" etc. */
+    getType(): string;
+    /** @returns {typeof import("../index.js").default | undefined} The target model class for this relationship, e.g. if the relationship is "posts" then the target model class is the Post class. */
+    getTargetModelClass(): typeof import("../index.js").default | undefined;
+}
+export type RelationshipBaseArgsType = {
+    className?: string;
+    dependent?: string;
+    foreignKey?: string | undefined;
+    inverseOf?: string;
+    klass?: typeof import("../index.js").default;
+    modelClass: typeof import("../index.js").default;
+    primaryKey?: string;
+    polymorphic?: boolean;
+    relationshipName: string;
+    through?: string;
+    type: string;
+};
+//# sourceMappingURL=base.d.ts.map

package/dist/src/database/record/relationships/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../../src/database/record/relationships/base.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AAEH;IACE,6CAA6C;IAC7C,uJADY,wBAAwB,EAkBnC;IAXC,kBAA0B;IAC1B,mBAA2B;IAC3B,mBAA4B;IAC5B,mBAA2B;IAC3B,4CAAkB;IAClB,iDAA4B;IAC5B,sBAA+B;IAC/B,oBAA6B;IAC7B,yBAAwC;IACxC,gBAAsB;IACtB,aAAgB;IAGlB,gEAAiE;IAEjE,sIAAsI;IACtI,gBADc,MAAM,GAAG,SAAS,CACS;IAEzC;;;OAGG;IACH,iBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,gBAFa,MAAM,GAAG,SAAS,CAI9B;IAED,sDAAsD;IACtD,iBADc,cAAc,aAAa,EAAE,OAAO,CACR;IAE1C,4FAA4F;IAC5F,uBADc,MAAM,CACkC;IAEtD,yBAAyB;IACzB,kBADc,OAAO,CAGpB;IAED,oEAAoE;IACpE,iBADc,MAAM,CACuB;IAE3C,+HAA+H;IAC/H,WADc,MAAM,CACU;IAE9B,mMAAmM;IACnM,uBADc,cAAc,aAAa,EAAE,OAAO,GAAG,SAAS,CAW7D;CACF;;gBApFa,MAAM;gBACN,MAAM;iBACN,MAAM,GAAG,SAAS;gBAClB,MAAM;YACN,cAAc,aAAa,EAAE,OAAO;gBACpC,cAAc,aAAa,EAAE,OAAO;iBACpC,MAAM;kBACN,OAAO;sBACP,MAAM;cACN,MAAM;UACN,MAAM"}

package/dist/src/database/record/relationships/base.js

@@ -0,0 +1,79 @@
+// @ts-check
+import restArgsError from "../../../utils/rest-args-error.js";
+/**
+ * @typedef {object} RelationshipBaseArgsType
+ * @property {string} [className]
+ * @property {string} [dependent]
+ * @property {string | undefined} [foreignKey]
+ * @property {string} [inverseOf]
+ * @property {typeof import("../index.js").default} [klass]
+ * @property {typeof import("../index.js").default} modelClass
+ * @property {string} [primaryKey]
+ * @property {boolean} [polymorphic]
+ * @property {string} relationshipName
+ * @property {string} [through]
+ * @property {string} type
+ */
+export default class VelociousDatabaseRecordBaseRelationship {
+    /** @param {RelationshipBaseArgsType} args */
+    constructor({ className, dependent, foreignKey, inverseOf, klass, modelClass, primaryKey = "id", polymorphic, relationshipName, through, type, ...restArgs }) {
+        restArgsError(restArgs);
+        if (!modelClass)
+            throw new Error(`'modelClass' wasn't given for ${relationshipName}`);
+        if (!className && !klass)
+            throw new Error(`Neither 'className' or 'klass' was given for ${modelClass.name}#${relationshipName}`);
+        this.className = className;
+        this._dependent = dependent;
+        this.foreignKey = foreignKey;
+        this._inverseOf = inverseOf;
+        this.klass = klass;
+        this.modelClass = modelClass;
+        this._polymorphic = polymorphic;
+        this._primaryKey = primaryKey;
+        this.relationshipName = relationshipName;
+        this.through = through;
+        this.type = type;
+    }
+    getConfiguration() { return this.modelClass._getConfiguration(); }
+    /** @returns {string | undefined} What will be done when the parent record is destroyed. E.g. "destroy", "nullify", "restrict" etc. */
+    getDependent() { return this._dependent; }
+    /**
+     * @abstract
+     * @returns {string} The name of the foreign key, e.g. "user_id", "post_id" etc.
+     */
+    getForeignKey() {
+        throw new Error("getForeignKey not implemented");
+    }
+    /**
+     * @abstract
+     * @returns {string | undefined} The name of the inverse relationship, e.g. "posts", "comments" etc.
+     */
+    getInverseOf() {
+        throw new Error("getInverseOf not implemented");
+    }
+    /** @returns {typeof import("../index.js").default} */
+    getModelClass() { return this.modelClass; }
+    /** @returns {string} The name of the relationship, e.g. "posts", "user", "comments" etc. */
+    getRelationshipName() { return this.relationshipName; }
+    /** @returns {boolean} */
+    getPolymorphic() {
+        return this._polymorphic || false;
+    }
+    /** @returns {string} The name of the foreign key, e.g. "id" etc. */
+    getPrimaryKey() { return this._primaryKey; }
+    /** @returns {string} The type of the relationship, e.g. "has_many", "belongs_to", "has_one", "has_and_belongs_to_many" etc. */
+    getType() { return this.type; }
+    /** @returns {typeof import("../index.js").default | undefined} The target model class for this relationship, e.g. if the relationship is "posts" then the target model class is the Post class. */
+    getTargetModelClass() {
+        if (this.getPolymorphic()) {
+            return undefined;
+        }
+        else if (this.className) {
+            return this.getConfiguration().getModelClass(this.className);
+        }
+        else if (this.klass) {
+            return this.klass;
+        }
+        throw new Error("Couldn't figure out the target model class");
+    }
+}

package/dist/src/database/record/relationships/belongs-to.d.ts

@@ -0,0 +1,5 @@
+export default class VelociousDatabaseRecordBelongsToRelationship extends BaseRelationship {
+    _autoGenerateInverseOfAttempted: boolean;
+}
+import BaseRelationship from "./base.js";
+//# sourceMappingURL=belongs-to.d.ts.map

package/dist/src/database/record/relationships/belongs-to.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"belongs-to.d.ts","sourceRoot":"","sources":["../../../../../src/database/record/relationships/belongs-to.js"],"names":[],"mappings":"AAKA;IAiBM,yCAA2C;CAuBhD;6BA3C4B,WAAW"}

package/dist/src/database/record/relationships/belongs-to.js

@@ -0,0 +1,37 @@
+// @ts-check
+import BaseRelationship from "./base.js";
+import * as inflection from "inflection";
+export default class VelociousDatabaseRecordBelongsToRelationship extends BaseRelationship {
+    /** @returns {string} */
+    getForeignKey() {
+        if (!this.foreignKey) {
+            const targetModelClass = this.getTargetModelClass();
+            if (!targetModelClass)
+                throw new Error("Can't calculate foreign key without a target model class");
+            this.foreignKey = `${inflection.underscore(targetModelClass.name)}_id`;
+        }
+        return this.foreignKey;
+    }
+    /** @returns {string | undefined} */
+    getInverseOf() {
+        if (!this._inverseOf && !this._autoGenerateInverseOfAttempted) {
+            this._autoGenerateInverseOfAttempted = true;
+            // Only make auto-inverse-of if the relationships name matches the target model class's name
+            const targetClassSimpleName = `${this.getRelationshipName().substring(0, 1).toUpperCase()}${this.getRelationshipName().substring(1, this.getRelationshipName().length)}`;
+            const targetModelClass = this.getTargetModelClass();
+            if (targetModelClass && targetClassSimpleName == targetModelClass.name) {
+                // Only make auto-inverse-of if the expected relationship exist in a has-one or has-many form
+                const targetClassRelationshipNames = targetModelClass.getRelationshipNames();
+                const autoGeneratedHasOneInverseOfName = `${this.modelClass.name.substring(0, 1).toLowerCase()}${this.modelClass.name.substring(1, this.modelClass.name.length)}`;
+                const autoGeneratedHasManyInverseOfName = inflection.pluralize(autoGeneratedHasOneInverseOfName);
+                if (targetClassRelationshipNames.includes(autoGeneratedHasOneInverseOfName)) {
+                    this._inverseOf = autoGeneratedHasOneInverseOfName;
+                }
+                else if (targetClassRelationshipNames.includes(autoGeneratedHasManyInverseOfName)) {
+                    this._inverseOf = autoGeneratedHasManyInverseOfName;
+                }
+            }
+        }
+        return this._inverseOf;
+    }
+}

package/dist/src/database/record/relationships/has-many.d.ts

@@ -0,0 +1,5 @@
+export default class VelociousDatabaseRecordHasManyRelationship extends BaseRelationship {
+    _autoGenerateInverseOfAttempted: boolean;
+}
+import BaseRelationship from "./base.js";
+//# sourceMappingURL=has-many.d.ts.map

package/dist/src/database/record/relationships/has-many.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-many.d.ts","sourceRoot":"","sources":["../../../../../src/database/record/relationships/has-many.js"],"names":[],"mappings":"AAKA;IAaM,yCAA2C;CAoBhD;6BApC4B,WAAW"}

package/dist/src/database/record/relationships/has-many.js

@@ -0,0 +1,30 @@
+// @ts-check
+import BaseRelationship from "./base.js";
+import * as inflection from "inflection";
+export default class VelociousDatabaseRecordHasManyRelationship extends BaseRelationship {
+    /** @returns {string} */
+    getForeignKey() {
+        if (!this.foreignKey) {
+            this.foreignKey = `${inflection.underscore(this.modelClass.name)}_id`;
+        }
+        return this.foreignKey;
+    }
+    /** @returns {string | undefined} */
+    getInverseOf() {
+        if (!this._inverseOf && !this._autoGenerateInverseOfAttempted) {
+            this._autoGenerateInverseOfAttempted = true;
+            // Only make auto-inverse-of if the relationships name matches the target model class's name
+            const targetClassSimpleName = inflection.singularize(`${this.getRelationshipName().substring(0, 1).toUpperCase()}${this.getRelationshipName().substring(1, this.getRelationshipName().length)}`);
+            const targetModelClass = this.getTargetModelClass();
+            if (targetModelClass && targetClassSimpleName == targetModelClass.name) {
+                // Only make auto-inverse-of if the expected relationship exist in a has-one or has-many form
+                const targetClassRelationshipNames = targetModelClass.getRelationshipNames();
+                const autoGeneratedBelongsToInverseOfName = `${this.modelClass.name.substring(0, 1).toLowerCase()}${this.modelClass.name.substring(1, this.modelClass.name.length)}`;
+                if (targetClassRelationshipNames.includes(autoGeneratedBelongsToInverseOfName)) {
+                    this._inverseOf = autoGeneratedBelongsToInverseOfName;
+                }
+            }
+        }
+        return this._inverseOf;
+    }
+}

package/dist/src/database/record/relationships/has-one.d.ts

@@ -0,0 +1,5 @@
+export default class VelociousDatabaseRecordHasOneRelationship extends BaseRelationship {
+    _autoGenerateInverseOfAttempted: boolean;
+}
+import BaseRelationship from "./base.js";
+//# sourceMappingURL=has-one.d.ts.map

package/dist/src/database/record/relationships/has-one.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-one.d.ts","sourceRoot":"","sources":["../../../../../src/database/record/relationships/has-one.js"],"names":[],"mappings":"AAKA;IAaM,yCAA2C;CAoBhD;6BApC4B,WAAW"}