@goatlab/fluent 0.6.22 → 0.6.30

package/dist/BaseConnector.js

@@ -1,306 +1,86 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseConnector = void 0;
-const typed_path_1 = require("typed-path");
 const js_utils_1 = require("@goatlab/js-utils");
-const class_transformer_1 = require("class-transformer");
-const class_validator_1 = require("class-validator");
+const types_1 = require("./types");
+const bson_1 = require("bson");
 class BaseConnector {
     constructor() {
-        this.generatedKeyPath = (0, typed_path_1.typedPath)();
-        this.chainReference = [];
-        this.whereArray = [];
-        this.orWhereArray = [];
-        this.selectArray = [];
-        this.forceSelectArray = [];
-        this.orderByArray = [];
-        this.limitNumber = 0;
-        this.offsetNumber = 0;
-        this.populateArray = [];
         this.chunk = null;
         this.pullSize = null;
-        this.ownerId = undefined;
         this.paginator = undefined;
         this.rawQuery = undefined;
-        this.getFirst = false;
-        this.relations = undefined;
-        this.loadModels = false;
-        this.chainReference = [];
-        this.whereArray = [];
-        this.orWhereArray = [];
-        this.selectArray = [];
-        this.forceSelectArray = [];
-        this.orderByArray = [];
-        this.limitNumber = undefined;
-        this.offsetNumber = undefined;
-        this.populateArray = [];
         this.chunk = null;
         this.pullSize = null;
-        this.ownerId = undefined;
         this.paginator = undefined;
         this.rawQuery = undefined;
         this.outputKeys = [];
-        this.getFirst = false;
     }
-    async findByIds(ids) {
+    async findByIds(ids, q) {
         throw new Error('findByIds() method not implemented');
     }
-    async get() {
-        throw new Error('get() method not implemented');
-    }
     async insertMany(data) {
         throw new Error('get() method not implemented');
     }
     async updateById(id, data) {
         throw new Error('get() method not implemented');
     }
-    owner(user) {
-        this.chainReference.push({ method: 'owner', args: user });
-        this.ownerId = user;
-        return this;
+    async findMany(query) {
+        throw new Error('findMany() method not implemented');
     }
-    own(user) {
-        return this.owner(user);
-    }
-    async first() {
-        this.limit(1);
-        const data = await this.get();
+    async findFirst(query) {
+        const data = await this.findMany({ ...query, limit: 1 });
         if (!data[0]) {
             return null;
         }
         return data[0];
     }
-    async collect() {
-        const data = await this.get();
+    async collect(query) {
+        const data = await this.findMany(query);
         if (!Array.isArray(data)) {
-            throw new Error('Collect method only accepts arrays of data');
+            return new js_utils_1.Collection([data]);
         }
         return new js_utils_1.Collection(data);
     }
-    select(paths) {
-        const arrCols = paths(this.generatedKeyPath);
-        const cols = arrCols.map(c => c.toString());
-        const columns = this.prepareInput(cols);
-        this.chainReference.push({ method: 'select', args: columns });
-        this.selectArray = this.selectArray
-            .concat(columns)
-            .filter((elem, pos, arr) => arr.indexOf(elem) === pos);
-        return this;
-    }
-    forceSelect(paths) {
-        if (typeof module === 'undefined' || !module.exports) {
-            throw new Error('forceSelect cant be used in frontend');
-        }
-        const arrCols = paths(this.generatedKeyPath);
-        const cols = arrCols.map(c => c.toString());
-        const columns = this.prepareInput(cols);
-        this.chainReference.push({ method: 'forceSelect', args: columns });
-        this.forceSelectArray = this.forceSelectArray
-            .concat(columns)
-            .filter((elem, pos, arr) => arr.indexOf(elem) === pos);
-        return this;
-    }
-    offset(offset) {
-        this.chainReference.push({ method: 'offset', args: offset });
-        this.offsetNumber = offset;
-        return this;
-    }
-    populate(...relations) {
-        this.chainReference.push({ method: 'relations', args: relations });
-        this.populateArray = relations;
-        return this;
-    }
-    skip(offset) {
-        return this.offset(offset);
-    }
-    where(path, operator, value) {
-        const stringP = path(this.generatedKeyPath);
-        const stringPath = stringP.toString();
-        const chainedWhere = [stringPath, operator, value];
-        this.chainReference.push({ method: 'where', chainedWhere });
-        this.whereArray = [];
-        this.whereArray.push(chainedWhere);
-        return this;
-    }
-    andWhere(path, operator, value) {
-        const stringP = path(this.generatedKeyPath);
-        const stringPath = stringP.toString();
-        const chainedWhere = [stringPath, operator, value];
-        this.chainReference.push({ method: 'andWhere', chainedWhere });
-        this.whereArray.push(chainedWhere);
-        return this;
-    }
-    orWhere(path, operator, value) {
-        const stringP = path(this.generatedKeyPath);
-        const stringPath = stringP.toString();
-        const chainedWhere = [stringPath, operator, value];
-        this.chainReference.push({ method: 'orWhere', chainedWhere });
-        this.orWhereArray.push(chainedWhere);
-        return this;
-    }
-    limit(limit) {
-        this.chainReference.push({ method: 'limit', args: limit });
-        this.limitNumber = limit;
-        return this;
-    }
-    take(limit) {
-        return this.limit(limit);
-    }
-    async pluck(path) {
-        const stringP = path(this.generatedKeyPath);
-        const stringPath = stringP.toString();
-        this.chainReference.push({ method: 'pluck', args: stringPath });
-        const data = await this.get();
+    async pluck(path, query) {
+        const data = await this.findMany(query);
+        const paths = Object.keys(js_utils_1.Objects.flatten(path));
         const result = data.map(e => {
-            const extracted = js_utils_1.Objects.getFromPath(e, String(stringPath), undefined);
+            const extracted = js_utils_1.Objects.getFromPath(e, String(paths[0]), undefined);
             if (typeof extracted.value !== 'undefined') {
                 return extracted.value;
             }
         });
         return result;
     }
-    orderBy(path, order = 'desc', orderType = 'string') {
-        const stringP = path(this.generatedKeyPath);
-        const stringPath = stringP.toString();
-        const orderB = [stringPath, order, orderType];
-        this.chainReference.push({ method: 'orderBy', orderB });
-        this.orderByArray = orderB;
-        return this;
-    }
-    jsApplySelect(data) {
-        const _data = Array.isArray(data) ? [...data] : [data];
-        if (this.selectArray.length <= 0 && this.outputKeys.length <= 0) {
-            return _data;
-        }
-        const iterationArray = this.outputKeys.length === 0 && this.selectArray.length > 0
-            ? this.selectArray
-            : [...this.outputKeys, ...this.forceSelectArray];
-        const compareArray = this.outputKeys.length === 0 && this.selectArray.length > 0
-            ? [...this.outputKeys, ...this.forceSelectArray]
-            : this.selectArray;
-        return _data.map(element => {
-            const newElement = {};
-            iterationArray.forEach(attribute => {
-                if (compareArray.length > 0 && !compareArray.includes(attribute)) {
-                    return undefined;
-                }
-                const extract = js_utils_1.Objects.getFromPath(element, attribute, undefined);
-                let value = js_utils_1.Objects.get(() => extract.value, undefined);
-                if (typeof value !== 'undefined' && value !== null) {
-                    if (typeof value === 'object' &&
-                        value.hasOwnProperty('data') &&
-                        value.data.hasOwnProperty('name')) {
-                        newElement[extract.label] = value.data.name;
-                    }
-                    else {
-                        if (typeof value === 'object' && js_utils_1.Ids.isValidObjectID(value)) {
-                            value = js_utils_1.Ids.objectIdString(value);
-                        }
-                        newElement[extract.label] = value;
-                    }
-                }
-            });
-            return js_utils_1.Objects.nest(newElement);
-        });
+    setRelatedQuery(r) {
+        this.relatedQuery = r;
     }
-    jsApplyOrderBy(data) {
-        let _data = [...data];
-        if (this.orderByArray.length === 0) {
-            return _data;
-        }
-        const field = this.orderByArray[0];
-        if (this.selectArray.length > 0 &&
-            (field.includes('.') || field.includes('['))) {
-            throw new Error(`Cannot orderBy nested attribute "${field}" when using Select. You must rename the attribute`);
-        }
-        const order = this.orderByArray[1];
-        let type = this.orderByArray[2];
-        if (!type) {
-            type = 'string';
+    async associate(data) {
+        if (!this.relatedQuery?.entity || !this.relatedQuery.key) {
+            throw new Error('Associate can only be called as a related model');
         }
-        _data = _data.sort((a, b) => {
-            const A = js_utils_1.Objects.getFromPath(a, field, undefined).value;
-            const B = js_utils_1.Objects.getFromPath(b, field, undefined).value;
-            if (typeof A === 'undefined' || typeof B === 'undefined') {
-                throw new Error(`Cannot order by property "${field}" not all values have this property`);
-            }
-            if (type.includes('string') || type.includes('number')) {
-                if (order === 'asc') {
-                    return A > B ? 1 : A < B ? -1 : 0;
-                }
-                return A > B ? -1 : A < B ? 1 : 0;
-            }
-            if (type.includes('date')) {
-                if (order === 'asc') {
-                    return new Date(A).getTime() - new Date(B).getTime();
-                }
-                return new Date(B).getTime() - new Date(A).getTime();
-            }
+        const parentData = await this.relatedQuery.repository.findMany({
+            ...this.relatedQuery.query,
+            select: { id: true }
         });
-        return _data;
-    }
-    reset() {
-        this.chainReference = [];
-        this.whereArray = [];
-        this.orWhereArray = [];
-        this.selectArray = [];
-        this.forceSelectArray = [];
-        this.orderByArray = [];
-        this.limitNumber = undefined;
-        this.offsetNumber = undefined;
-        this.populateArray = [];
-        this.chunk = null;
-        this.pullSize = null;
-        this.ownerId = undefined;
-        this.paginator = undefined;
-        this.rawQuery = undefined;
-        this.getFirst = false;
-        this.relations = undefined;
-        this.loadModels = false;
-        this.relationQuery = undefined;
-    }
-    async load() {
-        const result = await this.get();
-        this.relationQuery = {
-            data: result,
-            relations: this.modelRelations
-        };
-        return this;
-    }
-    async loadFirst() {
-        const result = await this.first();
-        this.relationQuery = {
-            data: result,
-            relations: this.modelRelations
-        };
-        return this;
-    }
-    getLoadedData() {
-        return this.relationQuery.data;
-    }
-    with(entities) {
-        this.relations = entities;
-        return this;
-    }
-    async attach(data) {
-        if (!this.relationQuery.relation || !this.relationQuery.data) {
-            throw new Error('Attached can only be called as a related model');
+        const foreignKeyName = this.relatedQuery['repository']['modelRelations'][this.relatedQuery.key]
+            .inverseSidePropertyPath;
+        if (!foreignKeyName) {
+            throw new Error('The relationship was not properly defined. Please check that your Repository and Model relations have the same keys');
         }
-        const foreignKeyName = this.relationQuery.relation.inverseSidePropertyPath;
-        const D = Array.isArray(this.relationQuery.data)
-            ? this.relationQuery.data
-            : [this.relationQuery.data];
-        const relatedData = D.map(d => ({
-            [foreignKeyName]: this.isMongoDB
-                ? js_utils_1.Ids.objectID(d.id)
-                : d.id,
+        const relatedData = parentData.map(r => ({
+            [foreignKeyName]: r.id,
             ...data
         }));
-        const existingData = await this.findByIds(relatedData.map(r => r.id));
+        const existingIds = this.clearEmpties(relatedData.map(r => r.id));
+        const existingData = existingIds.length
+            ? await this.findByIds(relatedData.map(r => r.id))
+            : [];
         const updateQueries = [];
         const insertQueries = [];
         for (const related of relatedData) {
-            const exists = existingData.find(d => d.id === related.id);
+            const exists = existingData.find((d) => d.id === related.id);
             if (exists) {
                 updateQueries.push(this.updateById(exists.id, {
                     ...exists,
@@ -315,88 +95,208 @@ class BaseConnector {
         const insertedResult = await this.insertMany(insertQueries);
         return [...updateResult, ...insertedResult];
     }
-    associate(id) {
-        if (!this.relationQuery?.relation || !this.relationQuery.data) {
+    async attach(id) {
+        if (!this.relatedQuery?.entity || !this.relatedQuery.key) {
             throw new Error('Associate can only be called as a related model');
         }
-        const D = Array.isArray(this.relationQuery.data)
-            ? this.relationQuery.data
-            : [this.relationQuery.data];
-        const relatedData = D.map(d => ({
-            [this.relationQuery.relation.joinColumns[0].propertyName]: this
-                .isMongoDB
-                ? js_utils_1.Ids.objectID(d.id)
-                : d.id,
-            [this.relationQuery.relation.inverseJoinColumns[0].propertyName]: this
-                .isMongoDB
-                ? js_utils_1.Ids.objectID(id)
-                : id
+        const parentData = await this.relatedQuery.repository.findMany({
+            ...this.relatedQuery.query,
+            select: { id: true }
+        });
+        const foreignKeyName = this.relatedQuery['repository']['modelRelations'][this.relatedQuery.key]
+            .joinColumns[0].propertyPath;
+        const inverseKeyName = this.relatedQuery['repository']['modelRelations'][this.relatedQuery.key]
+            .inverseJoinColumns[0].propertyPath;
+        if (!foreignKeyName || !inverseKeyName) {
+            throw new Error(`The relationship was not properly defined. Please check that your Repository and Model relations have the same keys: Searching for: ${this.relatedQuery.key}`);
+        }
+        const relatedData = parentData.map(d => ({
+            [foreignKeyName]: d.id,
+            [inverseKeyName]: id
         }));
-        return this.relationQuery.pivot.insertMany(relatedData);
-    }
-    hasMany(Repository, relationName) {
-        if (this.relationQuery) {
-            this.relationQuery.relation = this.relationQuery.relations[relationName];
+        return this.relatedQuery.pivot.insertMany(relatedData);
+    }
+    hasMany(r) {
+        const newRepo = new r.repository();
+        const calleeName = new Error('dummy')
+            .stack.split('\n')[2]
+            .replace(/^\s+at\s+(.+?)\s.+/g, '$1')
+            .split('.')[1];
+        if (this.relatedQuery) {
+            newRepo.setRelatedQuery({
+                ...this.relatedQuery,
+                key: calleeName
+            });
         }
-        const newClass = new Repository(this.relationQuery);
-        this.reset();
-        return newClass;
+        return newRepo;
+    }
+    belongsTo(r) {
+        return this.hasMany(r);
     }
     hasOne() {
         throw new Error('Method not implemented');
     }
-    belongsTo(Repository, relationName) {
-        if (this.relationQuery) {
-            this.relationQuery.relation = this.relationQuery.relations[relationName];
+    belongsToMany(r) {
+        const newRepo = new r.repository();
+        const relationName = new Error('dummy')
+            .stack.split('\n')[2]
+            .replace(/^\s+at\s+(.+?)\s.+/g, '$1')
+            .split('.')[1];
+        const pivot = new r.pivot();
+        pivot.setRelatedQuery({
+            ...this.relatedQuery,
+            key: relationName
+        });
+        if (this.relatedQuery) {
+            newRepo.setRelatedQuery({
+                ...this.relatedQuery,
+                key: relationName,
+                pivot
+            });
         }
-        const newClass = new Repository(this.relationQuery);
-        this.reset();
-        return newClass;
-    }
-    belongsToMany(Repository, Pivot, relationName) {
-        this.relationQuery = !this.relationQuery
-            ? { pivot: new Pivot(this.relationQuery) }
-            : {
-                ...this.relationQuery,
-                ...{
-                    pivot: new Pivot(this.relationQuery),
-                    relation: this.relationQuery.relations[relationName]
-                }
-            };
-        const newClass = new Repository(this.relationQuery);
-        this.reset();
-        return newClass;
-    }
-    withPivot() {
-        if (this.relationQuery?.pivot) {
-            this.relationQuery.returnPivot = true;
+        else {
+            newRepo.setRelatedQuery({
+                key: relationName,
+                pivot
+            });
         }
-        return this;
+        return newRepo;
     }
     hasManyThrough() {
         throw new Error('Method not implemented');
     }
-    prepareInput(columns) {
-        let cols = [];
-        columns.forEach(col => {
-            cols = cols.concat(col.toString().trim());
+    clearEmpties(object) {
+        Object.entries(object).forEach(([k, v]) => {
+            if (v && typeof v === 'object')
+                this.clearEmpties(v);
+            if ((v && typeof v === 'object' && !Object.keys(v).length) ||
+                v === null ||
+                v === undefined ||
+                v.length === 0) {
+                if (Array.isArray(object)) {
+                    if (!(object[k] instanceof bson_1.ObjectId)) {
+                        object.splice(k, 1);
+                    }
+                }
+                else if (!(v instanceof Date) && !(v instanceof bson_1.ObjectId)) {
+                    delete object[k];
+                }
+            }
         });
-        cols.filter((elem, pos, arr) => arr.indexOf(elem) === pos);
-        return cols;
+        return object;
+    }
+    isAnyObject(val) {
+        return typeof val === 'object' && !Array.isArray(val) && val !== null;
+    }
+    extractConditions(conditions) {
+        const accumulatedClauses = [];
+        if (!conditions) {
+            return accumulatedClauses;
+        }
+        for (const clause of conditions) {
+            if (!clause) {
+                continue;
+            }
+            for (const el of Object.keys(clause)) {
+                const value = clause[el];
+                if (this.isAnyObject(value)) {
+                    const initialKey = el;
+                    const flatten = js_utils_1.Objects.flatten(value);
+                    for (const key of Object.keys(flatten)) {
+                        const transformedKey = key.replace(new RegExp('.[0-9]', 'g'), '');
+                        if (types_1.LogicOperator[transformedKey]) {
+                            if (types_1.LogicOperator[transformedKey] === types_1.LogicOperator.in ||
+                                types_1.LogicOperator[transformedKey] === types_1.LogicOperator.notIn) {
+                                accumulatedClauses.push({
+                                    operator: types_1.LogicOperator[transformedKey],
+                                    element: `${initialKey}`,
+                                    value: value[transformedKey]
+                                });
+                            }
+                            else {
+                                accumulatedClauses.push({
+                                    operator: types_1.LogicOperator[transformedKey],
+                                    element: `${initialKey}`,
+                                    value: flatten[key]
+                                });
+                            }
+                        }
+                        else if (transformedKey.includes('.')) {
+                            const op = key.split('.').slice(-1).pop();
+                            if (!op) {
+                                continue;
+                            }
+                            if (types_1.LogicOperator[op]) {
+                                accumulatedClauses.push({
+                                    operator: types_1.LogicOperator[op],
+                                    element: `${initialKey}.${key.replace(`.${op}`, '')}`,
+                                    value: flatten[key]
+                                });
+                            }
+                            else {
+                                accumulatedClauses.push({
+                                    operator: types_1.LogicOperator.equals,
+                                    element: `${initialKey}.${key}`,
+                                    value: flatten[key]
+                                });
+                            }
+                        }
+                        else {
+                            accumulatedClauses.push({
+                                operator: types_1.LogicOperator.equals,
+                                element: `${initialKey}.${transformedKey}`,
+                                value: flatten[key]
+                            });
+                        }
+                    }
+                }
+                else {
+                    accumulatedClauses.push({
+                        operator: types_1.LogicOperator.equals,
+                        element: el,
+                        value
+                    });
+                }
+            }
+        }
+        return accumulatedClauses;
     }
-    async validateInput(validationClass, input) {
-        const validationOptions = {
-            whitelist: true,
-            skipMissingProperties: false,
-            forbidUnknownValues: true,
-            stopAtFirstError: false,
-        };
-        const instance = (0, class_transformer_1.plainToInstance)(validationClass, { ...input });
-        const errors = await (0, class_validator_1.validate)(instance, validationOptions);
-        return {
-            errors: errors && errors.length ? errors : null,
-            result: errors && errors.length ? undefined : instance,
-        };
+    jsApplySelect(select, data) {
+        const _data = Array.isArray(data) ? [...data] : [data];
+        if (!select) {
+            return data;
+        }
+        const selectedAttributes = Object.keys(js_utils_1.Objects.flatten(select));
+        const iterationArray = this.outputKeys.length === 0 && selectedAttributes.length > 0
+            ? selectedAttributes
+            : [...this.outputKeys];
+        const compareArray = this.outputKeys.length === 0 && selectedAttributes.length > 0
+            ? [...this.outputKeys]
+            : selectedAttributes;
+        return _data.map(element => {
+            const newElement = {};
+            iterationArray.forEach(attribute => {
+                if (compareArray.length > 0 && !compareArray.includes(attribute)) {
+                    return undefined;
+                }
+                const extract = js_utils_1.Objects.getFromPath(element, attribute, undefined);
+                let value = js_utils_1.Objects.get(() => extract.value, undefined);
+                if (typeof value !== 'undefined' && value !== null) {
+                    if (typeof value === 'object' &&
+                        value.hasOwnProperty('data') &&
+                        value.data.hasOwnProperty('name')) {
+                        newElement[extract.label] = value.data.name;
+                    }
+                    else {
+                        if (typeof value === 'object' && js_utils_1.Ids.isValidObjectID(value)) {
+                            value = js_utils_1.Ids.objectIdString(value);
+                        }
+                        newElement[extract.label] = value;
+                    }
+                }
+            });
+            return js_utils_1.Objects.nest(newElement);
+        });
     }
 }
 exports.BaseConnector = BaseConnector;

package/dist/Fluent.d.ts

@@ -1,26 +1,7 @@
 import { DataSource } from 'typeorm';
-import { BaseDataElement, Primitives } from './types';
+import { AnyObject, Primitives } from './types';
 import { Collection } from '@goatlab/js-utils';
-interface _FLUENT_ {
-    models?: {
-        [key: string]: boolean;
-    };
-}
-declare global {
-    interface Window {
-        _FLUENT_: _FLUENT_;
-    }
-    namespace NodeJS {
-        interface Global {
-            _FLUENT_: _FLUENT_;
-        }
-    }
-}
 export declare class Fluent {
-    private static registerModel;
-    static model<T = BaseDataElement>(name: string): any;
-    static collect<T = BaseDataElement | Primitives>(data: T[]): Collection<T>;
-    static getConfig(): _FLUENT_;
+    static collect<T = AnyObject | Primitives>(data: T[]): Collection<T>;
     static initialize(dataSources: DataSource[], Entities: any[]): Promise<void>;
 }
-export {};