@goatlab/fluent 0.7.21 → 0.7.22

package/dist/BaseConnector.d.ts

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,258 @@
+"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))
+            : [];
+        console.log({ existingData });
+        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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,22 @@
+"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

@@ -0,0 +1,17 @@
+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

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

package/dist/FluentEntity.d.ts

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

package/dist/FluentEntity.js

@@ -0,0 +1,28 @@
+"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

@@ -0,0 +1,38 @@
+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;
+}