@goatlab/fluent 0.7.20 → 0.7.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goatlab/fluent",
-  "version": "0.7.20",
+  "version": "0.7.21",
   "description": "Readable query Interface & API generator for TS and Node",
   "scripts": {
     "install-p": "yarn",
@@ -16,7 +16,7 @@
     "build": "tsc"
   },
   "dependencies": {
-    "@goatlab/js-utils": "^0.8.16",
+    "@goatlab/js-utils": "^0.8.17",
     "@loopback/metadata": "^4.1.2",
     "bson": "^4.6.2",
     "graphql": "^16.3.0",

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 }
-        });
-        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 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;
-                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,38 +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 readonly repository;
-    private readonly dataSource;
-    private readonly inputSchema;
-    private readonly outputSchema;
-    private readonly entity;
-    constructor({ entity, dataSource, inputSchema, outputSchema }: TypeOrmConnectorParams<InputDTO, OutputDTO>);
-    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;
-}