@goatlab/fluent 0.7.31 → 0.7.33

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) GOAT, SPA. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,59 +1,43 @@
 {
-  "name": "@goatlab/fluent",
-  "version": "0.7.31",
-  "description": "Readable query Interface & API generator for TS and Node",
-  "scripts": {
-    "install-p": "yarn",
-    "prebuild": "rimraf dist",
-    "prestart": "rimraf dist",
-    "predev": "rimraf dist",
-    "test": "jest --forceExit",
-    "dev": "tsc --watch",
-    "lint": "eslint src --fix",
-    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
-    "update:packages": "npm-check-updates -u && yarn",
-    "serve": "tsc -w",
-    "build": "tsc"
-  },
+  "author": "ignacio.cabrera@goatlab.io",
   "dependencies": {
-    "@goatlab/js-utils": "^0.8.24",
-    "@loopback/metadata": "^4.1.2",
+    "@loopback/metadata": "^7.0.8",
     "bson": "^4.6.2",
     "graphql": "^16.3.0",
     "keyv": "^4.2.2",
     "openapi3-ts": "^2.0.2",
     "reflect-metadata": "^0.1.13",
     "typeorm": "^0.3.9",
-    "zod": "^3.17.10"
+    "zod": "^3.17.10",
+    "@goatlab/js-utils": "0.8.35"
   },
+  "description": "Readable query Interface & API generator for TS and Node",
   "devDependencies": {
     "@types/node": "^18.7.13",
     "cross-spawn": "^7.0.3",
     "detect-port": "^1.3.0",
     "dotenv-cli": "^5.1.0",
     "eslint": "^8.5.0",
-    "jest": "^27.5.1",
+    "jest": "^29.7.0",
     "modern-spawn": "^1.0.0",
     "mongodb": "^4.9.0",
     "mysql2": "^2.3.3",
     "net": "^1.0.2",
     "prettier": "^2.6.1",
     "pretty-quick": "^3.1.3",
-    "ts-jest": "^27.1.4",
-    "ts-node": "^10.7.0",
+    "ts-jest": "^29.2.6",
+    "ts-node": "^10.9.2",
     "turbo": "^1.1.10",
-    "typescript": "^4.6.3"
+    "typescript": "^4.6.3",
+    "@goatlab/tsconfig": "0.0.11"
+  },
+  "engines": {
+    "node": ">=14.16.0"
   },
-  "homepage": "https://docs.goatlab.io",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],
-  "private": false,
-  "publishConfig": {
-    "access": "public"
-  },
+  "homepage": "https://docs.goatlab.io",
   "keywords": [
     "goat",
     "fluent",
@@ -64,9 +48,25 @@
     "typescript",
     "TS"
   ],
-  "author": "ignacio.cabrera@goatlab.io",
   "license": "MIT",
-  "engines": {
-    "node": ">=14.16.0"
+  "main": "dist/index.js",
+  "name": "@goatlab/fluent",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "types": "dist/index.d.ts",
+  "version": "0.7.33",
+  "scripts": {
+    "build": "echo 'skip'",
+    "dev": "tsc --watch",
+    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
+    "lint": "echo 'skip'",
+    "prebuild": "rimraf dist",
+    "predev": "rimraf dist",
+    "prestart": "rimraf dist",
+    "serve": "tsc -w",
+    "test": "echo 'skip'",
+    "update:packages": "npm-check-updates -u && yarn"
   }
-}
+}

package/dist/BaseConnector.d.ts

@@ -1,43 +0,0 @@
-import { Collection } from '@goatlab/js-utils';
-import { FindByIdFilter, FluentHasManyParams, FluentBelongsToParams, FluentBelongsToManyParams, FluentQuery, Primitives, QueryFieldSelector, QueryOutput, AnyObject } from './types';
-export declare abstract class BaseConnector<ModelDTO, InputDTO, OutputDTO> {
-    protected outputKeys: string[];
-    protected relatedQuery?: {
-        entity: new () => ModelDTO;
-        query?: FluentQuery<ModelDTO>;
-        repository?: any;
-        key?: string;
-        pivot?: any;
-    };
-    protected chunk: null;
-    protected pullSize: null;
-    protected paginator: undefined;
-    protected rawQuery: undefined;
-    protected modelRelations: any;
-    isMongoDB: boolean;
-    constructor();
-    insertMany(data: InputDTO[]): Promise<OutputDTO[]>;
-    updateById(id: string, data: InputDTO): Promise<OutputDTO>;
-    findMany<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO>[]>;
-    findFirst<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO> | null>;
-    requireById(id: string, q?: FindByIdFilter<ModelDTO>): Promise<QueryOutput<FindByIdFilter<ModelDTO>, ModelDTO>>;
-    requireFirst<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO>>;
-    findByIds<T extends FindByIdFilter<ModelDTO>>(ids: string[], q?: T): Promise<QueryOutput<T, ModelDTO>[]>;
-    findById<T extends FindByIdFilter<ModelDTO>>(id: string, q?: T): Promise<QueryOutput<T, ModelDTO> | null>;
-    collect(query: FluentQuery<ModelDTO>): Promise<Collection<OutputDTO>>;
-    pluck(path: QueryFieldSelector<ModelDTO>, query?: FluentQuery<ModelDTO>): Promise<Primitives[]>;
-    protected setRelatedQuery(r: {
-        entity: new () => ModelDTO;
-        query?: FluentQuery<ModelDTO>;
-        repository?: any;
-        key?: string;
-    }): void;
-    associate(data: InputDTO | OutputDTO): Promise<OutputDTO[]>;
-    attach(id: string, pivot?: AnyObject): Promise<any[]>;
-    protected hasMany<T extends FluentHasManyParams<T>>(r: T): InstanceType<T['repository']>;
-    protected belongsTo<T extends FluentBelongsToParams<T>>(r: T): InstanceType<T['repository']>;
-    protected hasOne(): void;
-    protected belongsToMany<T extends FluentBelongsToManyParams<T>>(r: T): InstanceType<T['repository']>;
-    protected hasManyThrough(): void;
-    protected jsApplySelect(select: FluentQuery<ModelDTO>['select'], data: ModelDTO[]): ModelDTO[];
-}

package/dist/BaseConnector.js

@@ -1,257 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseConnector = void 0;
-const js_utils_1 = require("@goatlab/js-utils");
-const clearEmpties_1 = require("./TypeOrmConnector/util/clearEmpties");
-class BaseConnector {
-    constructor() {
-        this.chunk = null;
-        this.pullSize = null;
-        this.paginator = undefined;
-        this.rawQuery = undefined;
-        this.chunk = null;
-        this.pullSize = null;
-        this.paginator = undefined;
-        this.rawQuery = undefined;
-        this.outputKeys = [];
-    }
-    async insertMany(data) {
-        throw new Error('get() method not implemented');
-    }
-    async updateById(id, data) {
-        throw new Error('get() method not implemented');
-    }
-    async findMany(query) {
-        throw new Error('findMany() method not implemented');
-    }
-    async findFirst(query) {
-        const data = await this.findMany({ ...query, limit: 1 });
-        if (!data[0]) {
-            return null;
-        }
-        return data[0];
-    }
-    async requireById(id, q) {
-        const found = await this.findByIds([id], {
-            select: q?.select,
-            include: q?.include,
-            limit: 1
-        });
-        found.map(d => {
-            if (this.isMongoDB) {
-                d['id'] = d['id'].toString();
-            }
-            (0, clearEmpties_1.clearEmpties)(js_utils_1.Objects.deleteNulls(d));
-        });
-        if (!found[0]) {
-            throw new Error(`Object ${id} not found`);
-        }
-        return found[0];
-    }
-    async requireFirst(query) {
-        const found = await this.findMany({ ...query, limit: 1 });
-        found.map(d => {
-            if (this.isMongoDB) {
-                d['id'] = d['id'].toString();
-            }
-            (0, clearEmpties_1.clearEmpties)(js_utils_1.Objects.deleteNulls(d));
-        });
-        if (!found[0]) {
-            const stringQuery = query ? JSON.stringify(query) : '';
-            throw new Error(`No objects found matching:  ${stringQuery}`);
-        }
-        return found[0];
-    }
-    async findByIds(ids, q) {
-        let data = await this.findMany({
-            where: {
-                id: {
-                    in: ids
-                }
-            },
-            limit: q?.limit,
-            select: q?.select,
-            include: q?.include
-        });
-        return data;
-    }
-    async findById(id, q) {
-        const result = await this.findByIds([id], { ...q, limit: 1 });
-        if (!result[0]) {
-            return null;
-        }
-        return result[0];
-    }
-    async collect(query) {
-        const data = await this.findMany(query);
-        if (!Array.isArray(data)) {
-            return new js_utils_1.Collection([data]);
-        }
-        return new js_utils_1.Collection(data);
-    }
-    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(paths[0]), undefined);
-            if (typeof extracted.value !== 'undefined') {
-                return extracted.value;
-            }
-        });
-        return result;
-    }
-    setRelatedQuery(r) {
-        this.relatedQuery = r;
-    }
-    async associate(data) {
-        if (!this.relatedQuery?.entity || !this.relatedQuery.key) {
-            throw new Error('Associate can only be called as a related model');
-        }
-        const parentData = await this.relatedQuery.repository.findMany({
-            ...this.relatedQuery.query,
-            select: { id: true }
-        });
-        let 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 relatedData = parentData.map(r => ({
-            [foreignKeyName]: r.id,
-            ...data
-        }));
-        const existingIds = (0, clearEmpties_1.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) => {
-                const p = d;
-                return p.id === related.id;
-            });
-            if (exists) {
-                updateQueries.push(this.updateById(exists.id, {
-                    ...exists,
-                    [foreignKeyName]: related[foreignKeyName]
-                }));
-            }
-            else {
-                insertQueries.push(related);
-            }
-        }
-        const updateResult = await Promise.all(updateQueries);
-        const insertedResult = await this.insertMany(insertQueries);
-        return [...updateResult, ...insertedResult];
-    }
-    async attach(id, pivot) {
-        if (!this.relatedQuery?.entity || !this.relatedQuery.key) {
-            throw new Error('Associate can only be called as a related model');
-        }
-        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,
-            ...pivot
-        }));
-        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
-            });
-        }
-        return newRepo;
-    }
-    belongsTo(r) {
-        return this.hasMany(r);
-    }
-    hasOne() {
-        throw new Error('Method not implemented');
-    }
-    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
-            });
-        }
-        else {
-            newRepo.setRelatedQuery({
-                key: relationName,
-                pivot
-            });
-        }
-        return newRepo;
-    }
-    hasManyThrough() {
-        throw new Error('Method not implemented');
-    }
-    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,7 +0,0 @@
-import { DataSource } from 'typeorm';
-import { AnyObject, Primitives } from './types';
-import { Collection } from '@goatlab/js-utils';
-export declare class Fluent {
-    static collect<T = AnyObject | Primitives>(data: T[]): Collection<T>;
-    static initialize(dataSources: DataSource[], Entities: any[]): Promise<void>;
-}

package/dist/Fluent.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Fluent = void 0;
-const js_utils_1 = require("@goatlab/js-utils");
-const generatorDatasource_1 = require("./generatorDatasource");
-class Fluent {
-    static collect(data) {
-        return new js_utils_1.Collection(data);
-    }
-    static async initialize(dataSources, Entities) {
-        generatorDatasource_1.modelGeneratorDataSource.setOptions({ entities: Entities });
-        if (!generatorDatasource_1.modelGeneratorDataSource.isInitialized) {
-            await generatorDatasource_1.modelGeneratorDataSource.initialize();
-        }
-        for (const dataSource of dataSources) {
-            if (!dataSource.isInitialized) {
-                await dataSource.initialize();
-            }
-        }
-    }
-}
-exports.Fluent = Fluent;

package/dist/FluentConnectorInterface.d.ts

@@ -1,17 +0,0 @@
-import { FindByIdFilter, FluentQuery, QueryOutput } from './types';
-export interface FluentConnectorInterface<ModelDTO, InputDTO, OutputDTO> {
-    insert(data: InputDTO): Promise<OutputDTO>;
-    insertMany(data: InputDTO[]): Promise<OutputDTO[]>;
-    findById<T extends FindByIdFilter<ModelDTO>>(id: string, q?: T): Promise<QueryOutput<T, ModelDTO> | null>;
-    findByIds<T extends FindByIdFilter<ModelDTO>>(ids: string[], q?: T): Promise<QueryOutput<T, ModelDTO>[]>;
-    findMany<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO>[]>;
-    findFirst<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO> | null>;
-    requireById(id: string, q?: FindByIdFilter<ModelDTO>): Promise<QueryOutput<FindByIdFilter<ModelDTO>, ModelDTO>>;
-    requireFirst<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO>>;
-    updateById(id: string, data: InputDTO): Promise<OutputDTO>;
-    replaceById(id: string, data: InputDTO): Promise<OutputDTO>;
-    deleteById(id: string): Promise<string>;
-    loadFirst(query?: FluentQuery<ModelDTO>): any;
-    loadById(id: string): any;
-    raw(): any;
-}

package/dist/FluentConnectorInterface.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/FluentEntity.d.ts

@@ -1,7 +0,0 @@
-export declare class FluentEntity {
-    type?: string;
-    roles?: string[];
-    created?: Date;
-    updated?: Date;
-    deleted?: Date;
-}

package/dist/FluentEntity.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FluentEntity = void 0;
-const tslib_1 = require("tslib");
-const decorators_1 = require("./decorators");
-class FluentEntity {
-}
-tslib_1.__decorate([
-    decorators_1.f.property({ required: false }),
-    tslib_1.__metadata("design:type", String)
-], FluentEntity.prototype, "type", void 0);
-tslib_1.__decorate([
-    decorators_1.f.stringArray(String, { required: false }),
-    tslib_1.__metadata("design:type", Array)
-], FluentEntity.prototype, "roles", void 0);
-tslib_1.__decorate([
-    decorators_1.f.created(),
-    tslib_1.__metadata("design:type", Date)
-], FluentEntity.prototype, "created", void 0);
-tslib_1.__decorate([
-    decorators_1.f.updated(),
-    tslib_1.__metadata("design:type", Date)
-], FluentEntity.prototype, "updated", void 0);
-tslib_1.__decorate([
-    decorators_1.f.deleted(),
-    tslib_1.__metadata("design:type", Date)
-], FluentEntity.prototype, "deleted", void 0);
-exports.FluentEntity = FluentEntity;

package/dist/TypeOrmConnector/TypeOrmConnector.d.ts

@@ -1,39 +0,0 @@
-import { LoadedResult, QueryOutput } from './../types';
-import { Repository, MongoRepository } from 'typeorm';
-import { BaseConnector } from '../BaseConnector';
-import { FluentConnectorInterface } from '../FluentConnectorInterface';
-import type { AnyObject, FluentQuery } from '../types';
-import { DataSource } from 'typeorm';
-import { z } from 'zod';
-export interface TypeOrmConnectorParams<Input, Output> {
-    entity: any;
-    dataSource: DataSource;
-    inputSchema: z.ZodType<Input>;
-    outputSchema?: z.ZodType<Output>;
-}
-export declare class TypeOrmConnector<ModelDTO = AnyObject, InputDTO = ModelDTO, OutputDTO = InputDTO> extends BaseConnector<ModelDTO, InputDTO, OutputDTO> implements FluentConnectorInterface<ModelDTO, InputDTO, OutputDTO> {
-    private repository;
-    private readonly dataSource;
-    private readonly inputSchema;
-    private readonly outputSchema;
-    private readonly entity;
-    constructor({ entity, dataSource, inputSchema, outputSchema }: TypeOrmConnectorParams<InputDTO, OutputDTO>);
-    initDB(): number;
-    insert(data: InputDTO): Promise<OutputDTO>;
-    insertMany(data: InputDTO[]): Promise<OutputDTO[]>;
-    findMany<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO>[]>;
-    updateById(id: string, data: InputDTO): Promise<OutputDTO>;
-    replaceById(id: string, data: InputDTO): Promise<OutputDTO>;
-    deleteById(id: string): Promise<string>;
-    clear(): Promise<boolean>;
-    loadFirst(query?: FluentQuery<ModelDTO>): LoadedResult<this>;
-    loadById(id: string): LoadedResult<this>;
-    raw(): Repository<ModelDTO>;
-    mongoRaw(): MongoRepository<ModelDTO>;
-    protected clone(): any;
-    private generateTypeOrmQuery;
-    private customTypeOrmRelatedFind;
-    private getTypeOrmQueryBuilderSelect;
-    private getTypeOrmQueryBuilderSubqueries;
-    private customMongoRelatedFind;
-}