@spinajs/orm 2.0.179 → 2.0.181

package/lib/mjs/middlewares.d.ts

@@ -1,63 +1,63 @@
-import { IRelationDescriptor, IModelDescriptor, IBuilderMiddleware, ISelectQueryBuilder } from './interfaces.js';
-import { ModelBase } from './model.js';
-import { BelongsToRelation } from './relations.js';
-export declare class HasManyRelationMiddleware implements IBuilderMiddleware {
-    protected _relationQuery: ISelectQueryBuilder;
-    protected _description: IRelationDescriptor;
-    protected _path: string;
-    constructor(_relationQuery: ISelectQueryBuilder, _description: IRelationDescriptor, _path: string);
-    afterQuery(data: any[]): any[];
-    modelCreation(_: any): ModelBase;
-    afterHydration(data: ModelBase[]): Promise<any[]>;
-}
-export declare class BelongsToRelationRecursiveMiddleware implements IBuilderMiddleware {
-    protected _relationQuery: ISelectQueryBuilder;
-    protected _description: IRelationDescriptor;
-    protected _targetModelDescriptor: IModelDescriptor;
-    constructor(_relationQuery: ISelectQueryBuilder, _description: IRelationDescriptor, _targetModelDescriptor: IModelDescriptor);
-    afterQuery(data: any[]): any[];
-    modelCreation(_: any): ModelBase;
-    afterHydration(data: ModelBase[]): Promise<any[]>;
-}
-export declare class HasManyToManyRelationMiddleware implements IBuilderMiddleware {
-    protected _relationQuery: ISelectQueryBuilder;
-    protected _description: IRelationDescriptor;
-    protected _targetModelDescriptor: IModelDescriptor;
-    constructor(_relationQuery: ISelectQueryBuilder, _description: IRelationDescriptor, _targetModelDescriptor: IModelDescriptor);
-    afterQuery(data: any[]): any[];
-    modelCreation(_: any): ModelBase;
-    afterHydration(data: ModelBase[]): Promise<any[]>;
-    private pickProps;
-}
-export declare class BelongsToPopulateDataMiddleware implements IBuilderMiddleware {
-    protected _description: IRelationDescriptor;
-    protected relation: BelongsToRelation;
-    constructor(_description: IRelationDescriptor, relation: BelongsToRelation);
-    afterQuery(data: any[]): any[];
-    modelCreation(_: any): ModelBase<unknown>;
-    afterHydration(data: ModelBase<unknown>[]): Promise<void | any[]>;
-}
-export declare class BelongsToRelationResultTransformMiddleware implements IBuilderMiddleware {
-    afterQuery(data: any[]): any[];
-    modelCreation(_: any): ModelBase;
-    afterHydration(_data: Array<ModelBase>): Promise<void>;
-    /**
-     * Dynamically sets a deeply nested value in an object.
-     * Optionally "bores" a path to it if its undefined.
-     *
-     * @param obj  - The object which contains the value you want to change/set.
-     * @param path  - The array representation of path to the value you want to change/set.
-     * @param value - The value you want to set it to.
-     * @param setrecursively - If true, will set value of non-existing path as well.
-     */
-    protected setDeep(obj: any, path: any[], value: any, setrecursively?: boolean): void;
-    protected keyTransform(key: string): string[];
-}
-export declare class DiscriminationMapMiddleware implements IBuilderMiddleware {
-    protected _description: IModelDescriptor;
-    constructor(_description: IModelDescriptor);
-    afterQuery(data: any[]): any[];
-    modelCreation(data: any): ModelBase;
-    afterHydration(_data: ModelBase[]): Promise<void>;
-}
+import { IRelationDescriptor, IModelDescriptor, IBuilderMiddleware, ISelectQueryBuilder } from './interfaces.js';
+import { ModelBase } from './model.js';
+import { BelongsToRelation } from './relations.js';
+export declare class HasManyRelationMiddleware implements IBuilderMiddleware {
+    protected _relationQuery: ISelectQueryBuilder;
+    protected _description: IRelationDescriptor;
+    protected _path: string;
+    constructor(_relationQuery: ISelectQueryBuilder, _description: IRelationDescriptor, _path: string);
+    afterQuery(data: any[]): any[];
+    modelCreation(_: any): ModelBase;
+    afterHydration(data: ModelBase[]): Promise<any[]>;
+}
+export declare class BelongsToRelationRecursiveMiddleware implements IBuilderMiddleware {
+    protected _relationQuery: ISelectQueryBuilder;
+    protected _description: IRelationDescriptor;
+    protected _targetModelDescriptor: IModelDescriptor;
+    constructor(_relationQuery: ISelectQueryBuilder, _description: IRelationDescriptor, _targetModelDescriptor: IModelDescriptor);
+    afterQuery(data: any[]): any[];
+    modelCreation(_: any): ModelBase;
+    afterHydration(data: ModelBase[]): Promise<any[]>;
+}
+export declare class HasManyToManyRelationMiddleware implements IBuilderMiddleware {
+    protected _relationQuery: ISelectQueryBuilder;
+    protected _description: IRelationDescriptor;
+    protected _targetModelDescriptor: IModelDescriptor;
+    constructor(_relationQuery: ISelectQueryBuilder, _description: IRelationDescriptor, _targetModelDescriptor: IModelDescriptor);
+    afterQuery(data: any[]): any[];
+    modelCreation(_: any): ModelBase;
+    afterHydration(data: ModelBase[]): Promise<any[]>;
+    private pickProps;
+}
+export declare class BelongsToPopulateDataMiddleware implements IBuilderMiddleware {
+    protected _description: IRelationDescriptor;
+    protected relation: BelongsToRelation;
+    constructor(_description: IRelationDescriptor, relation: BelongsToRelation);
+    afterQuery(data: any[]): any[];
+    modelCreation(_: any): ModelBase<unknown>;
+    afterHydration(data: ModelBase<unknown>[]): Promise<void | any[]>;
+}
+export declare class BelongsToRelationResultTransformMiddleware implements IBuilderMiddleware {
+    afterQuery(data: any[]): any[];
+    modelCreation(_: any): ModelBase;
+    afterHydration(_data: Array<ModelBase>): Promise<void>;
+    /**
+     * Dynamically sets a deeply nested value in an object.
+     * Optionally "bores" a path to it if its undefined.
+     *
+     * @param obj  - The object which contains the value you want to change/set.
+     * @param path  - The array representation of path to the value you want to change/set.
+     * @param value - The value you want to set it to.
+     * @param setrecursively - If true, will set value of non-existing path as well.
+     */
+    protected setDeep(obj: any, path: any[], value: any, setrecursively?: boolean): void;
+    protected keyTransform(key: string): string[];
+}
+export declare class DiscriminationMapMiddleware implements IBuilderMiddleware {
+    protected _description: IModelDescriptor;
+    constructor(_description: IModelDescriptor);
+    afterQuery(data: any[]): any[];
+    modelCreation(data: any): ModelBase;
+    afterHydration(_data: ModelBase[]): Promise<void>;
+}
 //# sourceMappingURL=middlewares.d.ts.map

package/lib/mjs/middlewares.js

@@ -1,250 +1,250 @@
-/* eslint-disable prettier/prettier */
-import { RelationType } from './interfaces.js';
-import { ManyToManyRelationList, OneToManyRelationList } from './relation-objects.js';
-export class HasManyRelationMiddleware {
-    constructor(_relationQuery, _description, _path) {
-        this._relationQuery = _relationQuery;
-        this._description = _description;
-        this._path = _path;
-    }
-    afterQuery(data) {
-        return data;
-    }
-    modelCreation(_) {
-        return null;
-    }
-    async afterHydration(data) {
-        const self = this;
-        const pks = data.map((d) => {
-            return d[this._description.PrimaryKey];
-        });
-        const hydrateMiddleware = {
-            afterQuery(data) {
-                return data;
-            },
-            modelCreation() {
-                return null;
-            },
-            async afterHydration(relationData) {
-                relationData.forEach((d) => (d.__relationKey__ = self._description.Name));
-                data.forEach((d) => {
-                    const relData = relationData.filter((rd) => {
-                        return d[self._description.PrimaryKey] === rd[self._description.ForeignKey];
-                    });
-                    d[self._description.Name] = new OneToManyRelationList(d, self._description.TargetModel, self._description, relData);
-                });
-            },
-        };
-        if (pks.length !== 0) {
-            this._relationQuery.whereIn(this._description.ForeignKey, pks);
-            this._relationQuery.middleware(hydrateMiddleware);
-            return await this._relationQuery;
-        }
-        return [];
-    }
-}
-export class BelongsToRelationRecursiveMiddleware {
-    constructor(_relationQuery, _description, _targetModelDescriptor) {
-        this._relationQuery = _relationQuery;
-        this._description = _description;
-        this._targetModelDescriptor = _targetModelDescriptor;
-    }
-    afterQuery(data) {
-        return data;
-    }
-    modelCreation(_) {
-        return null;
-    }
-    async afterHydration(data) {
-        const self = this;
-        const pks = data.map((d) => d[this._description.PrimaryKey]);
-        const fKey = this._description.ForeignKey;
-        const key = this._description.PrimaryKey;
-        const name = this._description.Name;
-        const hydrateMiddleware = {
-            afterQuery(data) {
-                return data;
-            },
-            modelCreation(_) {
-                return null;
-            },
-            async afterHydration(relationData) {
-                relationData.forEach((d) => (d.__relationKey__ = self._description.Name));
-                function buildRelationTree(_d, parent) {
-                    const branch = [];
-                    _d.forEach((d) => {
-                        if (d[fKey] === parent) {
-                            const children = buildRelationTree(_d, d[key]);
-                            if (children) {
-                                // TODO:
-                                // implement RecursiveRelation list to allow for
-                                // manipulation of the recursive data
-                                d[name] = new OneToManyRelationList(d, d.Model, {
-                                    Name: name,
-                                    Type: RelationType.Many,
-                                    TargetModelType: d.Model,
-                                    TargetModel: d.Model,
-                                    SourceModel: d.Model,
-                                    ForeignKey: fKey,
-                                    PrimaryKey: key,
-                                    Recursive: false,
-                                }, children);
-                            }
-                            branch.push(d);
-                        }
-                    });
-                    return branch;
-                }
-                const result = buildRelationTree(relationData, null);
-                data.forEach((d) => {
-                    d[name] = result.find((r) => r[key] === d[key])[name];
-                });
-            },
-        };
-        this._relationQuery.whereIn(this._description.PrimaryKey, pks);
-        this._relationQuery.middleware(new DiscriminationMapMiddleware(this._targetModelDescriptor));
-        this._relationQuery.middleware(hydrateMiddleware);
-        return await this._relationQuery;
-    }
-}
-export class HasManyToManyRelationMiddleware {
-    constructor(_relationQuery, _description, _targetModelDescriptor) {
-        this._relationQuery = _relationQuery;
-        this._description = _description;
-        this._targetModelDescriptor = _targetModelDescriptor;
-    }
-    afterQuery(data) {
-        return data;
-    }
-    modelCreation(_) {
-        return null;
-    }
-    async afterHydration(data) {
-        const self = this;
-        const pks = data.map((d) => d[this._description.PrimaryKey]);
-        const hydrateMiddleware = {
-            afterQuery(data) {
-                return data.map((d) => Object.assign({}, d[self._description.Name], { JunctionModel: self.pickProps(d, [self._description.Name]) }));
-            },
-            modelCreation(_) {
-                return null;
-            },
-            async afterHydration(relationData) {
-                relationData.forEach((d) => (d.__relationKey__ = self._description.Name));
-                data.forEach((d) => {
-                    const relData = relationData.filter((rd) => rd.JunctionModel[self._description.ForeignKey] === d[self._description.PrimaryKey]);
-                    d[self._description.Name] = new ManyToManyRelationList(d, self._description.TargetModel, self._description, relData);
-                });
-                relationData.forEach((d) => delete d.JunctionModel);
-            },
-        };
-        if (pks.length !== 0) {
-            this._relationQuery.whereIn(this._description.ForeignKey, pks);
-            this._relationQuery.middleware(new BelongsToRelationResultTransformMiddleware());
-            this._relationQuery.middleware(new DiscriminationMapMiddleware(this._targetModelDescriptor));
-            this._relationQuery.middleware(hydrateMiddleware);
-            return await this._relationQuery;
-        }
-        return [];
-    }
-    pickProps(source, except) {
-        const obj = {};
-        for (const p in source) {
-            if (except.indexOf(p) === -1) {
-                obj[p] = source[p];
-            }
-        }
-        return obj;
-    }
-}
-export class BelongsToPopulateDataMiddleware {
-    constructor(_description, relation) {
-        this._description = _description;
-        this.relation = relation;
-    }
-    afterQuery(data) {
-        return data;
-    }
-    modelCreation(_) {
-        return null;
-    }
-    afterHydration(data) {
-        const relData = data.map((d) => d[this._description.Name].Value).filter((x) => x !== null && x !== undefined);
-        const middlewares = this.relation._relationQuery.Relations
-            .map((x) => {
-            return x._query._middlewares;
-        })
-            .reduce((prev, current) => {
-            return prev.concat(current);
-        }, []);
-        return Promise.all(middlewares.map((x) => {
-            return x.afterHydration(relData);
-        }));
-    }
-}
-export class BelongsToRelationResultTransformMiddleware {
-    afterQuery(data) {
-        return data.map((d) => {
-            const transformedData = Object.assign(d);
-            for (const key in transformedData) {
-                if (key.startsWith('$')) {
-                    this.setDeep(transformedData, this.keyTransform(key), d[key]);
-                    delete transformedData[key];
-                }
-            }
-            return transformedData;
-        });
-    }
-    modelCreation(_) {
-        return null;
-    }
-    // tslint:disable-next-line: no-empty
-    async afterHydration(_data) { }
-    /**
-     * Dynamically sets a deeply nested value in an object.
-     * Optionally "bores" a path to it if its undefined.
-     *
-     * @param obj  - The object which contains the value you want to change/set.
-     * @param path  - The array representation of path to the value you want to change/set.
-     * @param value - The value you want to set it to.
-     * @param setrecursively - If true, will set value of non-existing path as well.
-     */
-    setDeep(obj, path, value, setrecursively = true) {
-        path.reduce((a, b, level) => {
-            if (setrecursively && typeof a[b] === 'undefined' && level !== path.length - 1) {
-                a[b] = {};
-                return a[b];
-            }
-            if (level === path.length - 1) {
-                a[b] = value;
-                return value;
-            }
-            return a[b];
-        }, obj);
-    }
-    keyTransform(key) {
-        return key.replace(/\$+/g, '').split('.');
-    }
-}
-export class DiscriminationMapMiddleware {
-    constructor(_description) {
-        this._description = _description;
-    }
-    afterQuery(data) {
-        return data;
-    }
-    modelCreation(data) {
-        if (this._description.DiscriminationMap && this._description.DiscriminationMap.Field) {
-            const distValue = data[this._description.DiscriminationMap.Field];
-            if (distValue && this._description.DiscriminationMap.Models.has(distValue)) {
-                const result = new (this._description.DiscriminationMap.Models.get(distValue))();
-                result.hydrate(data);
-                return result;
-            }
-        }
-        return null;
-    }
-    // tslint:disable-next-line: no-empty
-    async afterHydration(_data) { }
-}
+/* eslint-disable prettier/prettier */
+import { RelationType } from './interfaces.js';
+import { ManyToManyRelationList, OneToManyRelationList } from './relation-objects.js';
+export class HasManyRelationMiddleware {
+    constructor(_relationQuery, _description, _path) {
+        this._relationQuery = _relationQuery;
+        this._description = _description;
+        this._path = _path;
+    }
+    afterQuery(data) {
+        return data;
+    }
+    modelCreation(_) {
+        return null;
+    }
+    async afterHydration(data) {
+        const self = this;
+        const pks = data.map((d) => {
+            return d[this._description.PrimaryKey];
+        });
+        const hydrateMiddleware = {
+            afterQuery(data) {
+                return data;
+            },
+            modelCreation() {
+                return null;
+            },
+            async afterHydration(relationData) {
+                relationData.forEach((d) => (d.__relationKey__ = self._description.Name));
+                data.forEach((d) => {
+                    const relData = relationData.filter((rd) => {
+                        return d[self._description.PrimaryKey] === rd[self._description.ForeignKey];
+                    });
+                    d[self._description.Name] = new OneToManyRelationList(d, self._description.TargetModel, self._description, relData);
+                });
+            },
+        };
+        if (pks.length !== 0) {
+            this._relationQuery.whereIn(this._description.ForeignKey, pks);
+            this._relationQuery.middleware(hydrateMiddleware);
+            return await this._relationQuery;
+        }
+        return [];
+    }
+}
+export class BelongsToRelationRecursiveMiddleware {
+    constructor(_relationQuery, _description, _targetModelDescriptor) {
+        this._relationQuery = _relationQuery;
+        this._description = _description;
+        this._targetModelDescriptor = _targetModelDescriptor;
+    }
+    afterQuery(data) {
+        return data;
+    }
+    modelCreation(_) {
+        return null;
+    }
+    async afterHydration(data) {
+        const self = this;
+        const pks = data.map((d) => d[this._description.PrimaryKey]);
+        const fKey = this._description.ForeignKey;
+        const key = this._description.PrimaryKey;
+        const name = this._description.Name;
+        const hydrateMiddleware = {
+            afterQuery(data) {
+                return data;
+            },
+            modelCreation(_) {
+                return null;
+            },
+            async afterHydration(relationData) {
+                relationData.forEach((d) => (d.__relationKey__ = self._description.Name));
+                function buildRelationTree(_d, parent) {
+                    const branch = [];
+                    _d.forEach((d) => {
+                        if (d[fKey] === parent) {
+                            const children = buildRelationTree(_d, d[key]);
+                            if (children) {
+                                // TODO:
+                                // implement RecursiveRelation list to allow for
+                                // manipulation of the recursive data
+                                d[name] = new OneToManyRelationList(d, d.Model, {
+                                    Name: name,
+                                    Type: RelationType.Many,
+                                    TargetModelType: d.Model,
+                                    TargetModel: d.Model,
+                                    SourceModel: d.Model,
+                                    ForeignKey: fKey,
+                                    PrimaryKey: key,
+                                    Recursive: false,
+                                }, children);
+                            }
+                            branch.push(d);
+                        }
+                    });
+                    return branch;
+                }
+                const result = buildRelationTree(relationData, null);
+                data.forEach((d) => {
+                    d[name] = result.find((r) => r[key] === d[key])[name];
+                });
+            },
+        };
+        this._relationQuery.whereIn(this._description.PrimaryKey, pks);
+        this._relationQuery.middleware(new DiscriminationMapMiddleware(this._targetModelDescriptor));
+        this._relationQuery.middleware(hydrateMiddleware);
+        return await this._relationQuery;
+    }
+}
+export class HasManyToManyRelationMiddleware {
+    constructor(_relationQuery, _description, _targetModelDescriptor) {
+        this._relationQuery = _relationQuery;
+        this._description = _description;
+        this._targetModelDescriptor = _targetModelDescriptor;
+    }
+    afterQuery(data) {
+        return data;
+    }
+    modelCreation(_) {
+        return null;
+    }
+    async afterHydration(data) {
+        const self = this;
+        const pks = data.map((d) => d[this._description.PrimaryKey]);
+        const hydrateMiddleware = {
+            afterQuery(data) {
+                return data.map((d) => Object.assign({}, d[self._description.Name], { JunctionModel: self.pickProps(d, [self._description.Name]) }));
+            },
+            modelCreation(_) {
+                return null;
+            },
+            async afterHydration(relationData) {
+                relationData.forEach((d) => (d.__relationKey__ = self._description.Name));
+                data.forEach((d) => {
+                    const relData = relationData.filter((rd) => rd.JunctionModel[self._description.ForeignKey] === d[self._description.PrimaryKey]);
+                    d[self._description.Name] = new ManyToManyRelationList(d, self._description.TargetModel, self._description, relData);
+                });
+                relationData.forEach((d) => delete d.JunctionModel);
+            },
+        };
+        if (pks.length !== 0) {
+            this._relationQuery.whereIn(this._description.ForeignKey, pks);
+            this._relationQuery.middleware(new BelongsToRelationResultTransformMiddleware());
+            this._relationQuery.middleware(new DiscriminationMapMiddleware(this._targetModelDescriptor));
+            this._relationQuery.middleware(hydrateMiddleware);
+            return await this._relationQuery;
+        }
+        return [];
+    }
+    pickProps(source, except) {
+        const obj = {};
+        for (const p in source) {
+            if (except.indexOf(p) === -1) {
+                obj[p] = source[p];
+            }
+        }
+        return obj;
+    }
+}
+export class BelongsToPopulateDataMiddleware {
+    constructor(_description, relation) {
+        this._description = _description;
+        this.relation = relation;
+    }
+    afterQuery(data) {
+        return data;
+    }
+    modelCreation(_) {
+        return null;
+    }
+    afterHydration(data) {
+        const relData = data.map((d) => d[this._description.Name].Value).filter((x) => x !== null && x !== undefined);
+        const middlewares = this.relation._relationQuery.Relations
+            .map((x) => {
+            return x._query._middlewares;
+        })
+            .reduce((prev, current) => {
+            return prev.concat(current);
+        }, []);
+        return Promise.all(middlewares.map((x) => {
+            return x.afterHydration(relData);
+        }));
+    }
+}
+export class BelongsToRelationResultTransformMiddleware {
+    afterQuery(data) {
+        return data.map((d) => {
+            const transformedData = Object.assign(d);
+            for (const key in transformedData) {
+                if (key.startsWith('$')) {
+                    this.setDeep(transformedData, this.keyTransform(key), d[key]);
+                    delete transformedData[key];
+                }
+            }
+            return transformedData;
+        });
+    }
+    modelCreation(_) {
+        return null;
+    }
+    // tslint:disable-next-line: no-empty
+    async afterHydration(_data) { }
+    /**
+     * Dynamically sets a deeply nested value in an object.
+     * Optionally "bores" a path to it if its undefined.
+     *
+     * @param obj  - The object which contains the value you want to change/set.
+     * @param path  - The array representation of path to the value you want to change/set.
+     * @param value - The value you want to set it to.
+     * @param setrecursively - If true, will set value of non-existing path as well.
+     */
+    setDeep(obj, path, value, setrecursively = true) {
+        path.reduce((a, b, level) => {
+            if (setrecursively && typeof a[b] === 'undefined' && level !== path.length - 1) {
+                a[b] = {};
+                return a[b];
+            }
+            if (level === path.length - 1) {
+                a[b] = value;
+                return value;
+            }
+            return a[b];
+        }, obj);
+    }
+    keyTransform(key) {
+        return key.replace(/\$+/g, '').split('.');
+    }
+}
+export class DiscriminationMapMiddleware {
+    constructor(_description) {
+        this._description = _description;
+    }
+    afterQuery(data) {
+        return data;
+    }
+    modelCreation(data) {
+        if (this._description.DiscriminationMap && this._description.DiscriminationMap.Field) {
+            const distValue = data[this._description.DiscriminationMap.Field];
+            if (distValue && this._description.DiscriminationMap.Models.has(distValue)) {
+                const result = new (this._description.DiscriminationMap.Models.get(distValue))();
+                result.hydrate(data);
+                return result;
+            }
+        }
+        return null;
+    }
+    // tslint:disable-next-line: no-empty
+    async afterHydration(_data) { }
+}
 //# sourceMappingURL=middlewares.js.map