@goatlab/fluent 0.6.6 → 0.6.9

package/dist/BaseConnector.d.ts

@@ -0,0 +1,79 @@
+import { TypedPathWrapper } from 'typed-path';
+import { Filter, DaoOutput, BaseDaoExtendedAttributes, LogicOperator, Primitives, PrimitivesArray } from './types';
+import { Collection } from '@goatlab/js-utils';
+export interface FluentConnectorInterface<InputDTO, OutputDTO> {
+    get(): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
+    all(filter: Filter): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
+    findById(id: string): Promise<DaoOutput<InputDTO, OutputDTO>>;
+    find(filter: Filter): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
+    deleteById(id: string): Promise<string>;
+    updateById(id: string, data: InputDTO): Promise<DaoOutput<InputDTO, OutputDTO>>;
+    insert(data: InputDTO): Promise<DaoOutput<InputDTO, OutputDTO>>;
+    insertMany(data: InputDTO[]): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
+}
+export declare abstract class BaseConnector<ModelDTO, InputDTO, OutputDTO> {
+    _keys: TypedPathWrapper<ModelDTO & InputDTO & OutputDTO, Record<never, never> & {
+        $path: (path: import("typed-path").TypedPathKey[]) => string;
+        $raw: (path: import("typed-path").TypedPathKey[]) => string[];
+        $rawPath: (path: import("typed-path").TypedPathKey[]) => import("typed-path").TypedPathKey[];
+        toString: (path: import("typed-path").TypedPathKey[]) => () => string;
+        valueOf: (path: import("typed-path").TypedPathKey[]) => () => string;
+        [Symbol.toStringTag]: (path: import("typed-path").TypedPathKey[]) => string;
+    }>;
+    protected outputKeys: string[];
+    protected chainReference: any[];
+    protected whereArray: any[];
+    protected orWhereArray: any[];
+    protected selectArray: any[];
+    protected forceSelectArray: any[];
+    protected orderByArray: any[];
+    protected limitNumber: number;
+    protected offsetNumber: number;
+    protected populateArray: any[];
+    protected chunk: any;
+    protected pullSize: any;
+    protected ownerId: any;
+    protected paginator: any;
+    protected rawQuery: any;
+    protected getFirst: boolean;
+    protected relations: any;
+    protected loadModels: boolean;
+    protected relationQuery: any;
+    protected modelRelations: any;
+    isMongoDB: boolean;
+    protected getExtendedCreateAttributes: () => BaseDaoExtendedAttributes;
+    constructor();
+    get(): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
+    insertMany(data: InputDTO[]): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
+    owner(user: string): this;
+    own(user: string): this;
+    first(): Promise<DaoOutput<InputDTO, OutputDTO> | null>;
+    collect(): Promise<Collection<DaoOutput<InputDTO, OutputDTO>>>;
+    select(...columns: TypedPathWrapper<Primitives, Primitives>[]): this;
+    forceSelect(...columns: TypedPathWrapper<Primitives, Primitives>[]): this;
+    offset(offset: number): this;
+    populate(...relations: any[]): this;
+    skip(offset: number): this;
+    where(path: TypedPathWrapper<Primitives, Primitives>, operator: LogicOperator, value: Primitives | PrimitivesArray): this;
+    andWhere(path: TypedPathWrapper<Primitives, Primitives>, operator: LogicOperator, value: Primitives | Primitives[]): this;
+    orWhere(path: TypedPathWrapper<Primitives, Primitives>, operator: LogicOperator, value: Primitives): this;
+    limit(limit: number): this;
+    take(limit: number): this;
+    pluck(path: TypedPathWrapper<Primitives, Primitives>): Promise<string[]>;
+    orderBy(path: TypedPathWrapper<Primitives, Primitives>, order?: 'asc' | 'desc', orderType?: 'string' | 'number' | 'date'): this;
+    protected jsApplySelect(data: any): any[];
+    protected jsApplyOrderBy(data: any): any[];
+    protected reset(): void;
+    load(): Promise<this>;
+    loadFirst(): Promise<this>;
+    getLoadedData(): DaoOutput<InputDTO, OutputDTO>[] | DaoOutput<InputDTO, OutputDTO>;
+    with(entities: any): this;
+    attach(data: InputDTO): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
+    associate(id: string): any;
+    protected hasMany<T>(Repository: any, relationName: string): T;
+    protected hasOne(): void;
+    protected belongsTo<T>(Repository: any, relationName: string): T;
+    protected belongsToMany<T, R>(Repository: any, Pivot: any, relationName: string): T;
+    protected hasManyThrough(): void;
+    private prepareInput;
+}

package/dist/BaseConnector.js

@@ -0,0 +1,361 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseConnector = void 0;
+const typed_path_1 = require("typed-path");
+const dates_1 = require("@goatlab/dates");
+const js_utils_1 = require("@goatlab/js-utils");
+class BaseConnector {
+    constructor() {
+        this._keys = (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.getExtendedCreateAttributes = () => {
+            const date = dates_1.Dates.currentIsoString();
+            return {
+                id: `${js_utils_1.Ids.objectIdString()}_local`,
+                updated: date,
+                created: date,
+                roles: []
+            };
+        };
+        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 get() {
+        throw new Error('get() method not implemented');
+    }
+    async insertMany(data) {
+        throw new Error('get() method not implemented');
+    }
+    owner(user) {
+        this.chainReference.push({ method: 'owner', args: user });
+        this.ownerId = user;
+        return this;
+    }
+    own(user) {
+        return this.owner(user);
+    }
+    async first() {
+        this.limit(1);
+        const data = await this.get();
+        if (!data[0]) {
+            return null;
+        }
+        return data[0];
+    }
+    async collect() {
+        const data = await this.get();
+        if (!Array.isArray(data)) {
+            throw new Error('Collect method only accepts arrays of data');
+        }
+        return new js_utils_1.Collection(data);
+    }
+    select(...columns) {
+        columns = this.prepareInput(columns);
+        this.chainReference.push({ method: 'select', args: columns });
+        this.selectArray = this.selectArray
+            .concat(columns)
+            .filter((elem, pos, arr) => arr.indexOf(elem) === pos);
+        return this;
+    }
+    forceSelect(...columns) {
+        if (typeof module === 'undefined' || !module.exports) {
+            throw new Error('forceSelect cant be used in frontend');
+        }
+        columns = this.prepareInput(columns);
+        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 stringPath = path.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 stringPath = path.toString();
+        const chainedWhere = [stringPath, operator, value];
+        this.chainReference.push({ method: 'andWhere', chainedWhere });
+        this.whereArray.push(chainedWhere);
+        return this;
+    }
+    orWhere(path, operator, value) {
+        const stringPath = path.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 stringPath = path.toString();
+        this.chainReference.push({ method: 'pluck', args: stringPath });
+        const data = await this.get();
+        const result = data.map(e => {
+            const extracted = js_utils_1.Objects.getFromPath(e, String(stringPath), undefined);
+            if (typeof extracted.value !== 'undefined') {
+                return extracted.value;
+            }
+        });
+        return result;
+    }
+    orderBy(path, order = 'desc', orderType = 'string') {
+        const stringPath = path.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);
+        });
+    }
+    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';
+        }
+        _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();
+            }
+        });
+        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');
+        }
+        if (this.relationQuery && this.relationQuery.data) {
+            const D = Array.isArray(this.relationQuery.data)
+                ? this.relationQuery.data
+                : [this.relationQuery.data];
+            const relatedData = D.map(d => ({
+                [this.relationQuery.relation.inverseSidePropertyPath]: this.isMongoDB
+                    ? js_utils_1.Ids.objectID(d.id)
+                    : d.id,
+                ...data
+            }));
+            return this.insertMany(relatedData);
+        }
+    }
+    associate(id) {
+        if (!this.relationQuery.relation || !this.relationQuery.data) {
+            throw new Error('Attached can only be called as a related model');
+        }
+        if (this.relationQuery && this.relationQuery.data) {
+            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
+            }));
+            return this.relationQuery.pivot.insertMany(relatedData);
+        }
+    }
+    hasMany(Repository, relationName) {
+        if (this.relationQuery) {
+            this.relationQuery.relation = this.relationQuery.relations[relationName];
+        }
+        const newClass = new Repository(this.relationQuery);
+        this.reset();
+        return newClass;
+    }
+    hasOne() {
+        throw new Error('Method not implemented');
+    }
+    belongsTo(Repository, relationName) {
+        if (this.relationQuery) {
+            this.relationQuery.relation = this.relationQuery.relations[relationName];
+        }
+        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;
+    }
+    hasManyThrough() {
+        throw new Error('Method not implemented');
+    }
+    prepareInput(columns) {
+        let cols = [];
+        columns.forEach(col => {
+            cols = cols.concat(col.toString().trim());
+        });
+        cols.filter((elem, pos, arr) => arr.indexOf(elem) === pos);
+        return cols;
+    }
+}
+exports.BaseConnector = BaseConnector;

package/dist/Fluent.d.ts

@@ -0,0 +1,26 @@
+import { DataSource } from 'typeorm';
+import { BaseDataElement, 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 models(Entities: any[]): Promise<DataSource>;
+}
+export {};

package/dist/Fluent.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fluent = void 0;
+const typed_path_1 = require("typed-path");
+const js_utils_1 = require("@goatlab/js-utils");
+const generatorDatasource_1 = require("./generatorDatasource");
+if (typeof window !== 'undefined' && window && !window._FLUENT_) {
+    window._FLUENT_ = {
+        models: {}
+    };
+}
+if (global && !global._FLUENT_) {
+    global._FLUENT_ = {
+        models: {}
+    };
+}
+class Fluent {
+    static registerModel(name) {
+        if (!name || name === 'baseModel') {
+            return;
+        }
+        if (typeof window !== 'undefined') {
+            window._FLUENT_.models[name] = true;
+            return;
+        }
+        global._FLUENT_.models[name] = true;
+    }
+    static model(name) {
+        this.registerModel(name);
+        return (0, typed_path_1.typedPath)();
+    }
+    static collect(data) {
+        return new js_utils_1.Collection(data);
+    }
+    static getConfig() {
+        if (typeof window !== 'undefined' && window) {
+            return window._FLUENT_;
+        }
+        if (typeof global !== 'undefined' && global) {
+            return global._FLUENT_;
+        }
+    }
+    static async models(Entities) {
+        generatorDatasource_1.modelGeneratorDataSource.setOptions({ entities: Entities });
+        if (generatorDatasource_1.modelGeneratorDataSource.isInitialized) {
+            return generatorDatasource_1.modelGeneratorDataSource;
+        }
+        await generatorDatasource_1.modelGeneratorDataSource.initialize();
+        return generatorDatasource_1.modelGeneratorDataSource;
+    }
+}
+exports.Fluent = Fluent;

package/dist/TypeOrmConnector/TypeOrmConnector.d.ts

@@ -1,6 +1,6 @@
 import { Repository } from 'typeorm';
-import { FluentConnectorInterface, BaseConnector } from '../index';
-import type { Filter, DaoOutput, BaseDataElement, PaginatedData, Paginator, Sure } from '../index';
+import { BaseConnector, FluentConnectorInterface } from '../BaseConnector';
+import type { Filter, DaoOutput, BaseDataElement, PaginatedData, Paginator, Sure } from '../types';
 export declare class GoatRepository<T> extends Repository<T> {
 }
 export declare const getRelations: (typeOrmRepo: any) => {