@goatlab/fluent 0.7.5 → 0.7.10

package/dist/BaseConnector.d.ts

@@ -1,21 +1,5 @@
 import { Collection } from '@goatlab/js-utils';
-import { FindByIdFilter, FluentHasManyParams, FluentBelongsToParams, FluentBelongsToManyParams, FluentQuery, LogicOperator, Primitives, PrimitivesArray, QueryFieldSelector, QueryOutput, SingleQueryOutput } 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<SingleQueryOutput<T, ModelDTO, OutputDTO> | null>;
-    findByIds<T extends FindByIdFilter<ModelDTO>>(ids: string[], q?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
-    findMany<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
-    findFirst<T extends FluentQuery<ModelDTO>>(query?: T): Promise<SingleQueryOutput<T, ModelDTO, OutputDTO> | null>;
-    requireById(id: string, q?: FindByIdFilter<ModelDTO>): Promise<SingleQueryOutput<FindByIdFilter<ModelDTO>, ModelDTO, OutputDTO>>;
-    requireFirst<T extends FluentQuery<ModelDTO>>(query?: T): Promise<SingleQueryOutput<T, ModelDTO, OutputDTO>>;
-    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;
-}
+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?: {
@@ -34,12 +18,12 @@ export declare abstract class BaseConnector<ModelDTO, InputDTO, OutputDTO> {
     constructor();
     insertMany(data: InputDTO[]): Promise<OutputDTO[]>;
     updateById(id: string, data: InputDTO): Promise<OutputDTO>;
-    findMany<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
-    findFirst<T extends FluentQuery<ModelDTO>>(query?: T): Promise<SingleQueryOutput<T, ModelDTO, OutputDTO> | null>;
-    requireById(id: string, q?: FindByIdFilter<ModelDTO>): Promise<SingleQueryOutput<FindByIdFilter<ModelDTO>, ModelDTO, OutputDTO>>;
-    requireFirst<T extends FluentQuery<ModelDTO>>(query?: T): Promise<SingleQueryOutput<T, ModelDTO, OutputDTO>>;
-    findByIds<T extends FindByIdFilter<ModelDTO>>(ids: string[], q?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
-    findById<T extends FindByIdFilter<ModelDTO>>(id: string, q?: T): Promise<SingleQueryOutput<T, ModelDTO, OutputDTO> | null>;
+    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: {
@@ -49,18 +33,11 @@ export declare abstract class BaseConnector<ModelDTO, InputDTO, OutputDTO> {
         key?: string;
     }): void;
     associate(data: InputDTO | OutputDTO): Promise<OutputDTO[]>;
-    attach(id: string): Promise<any>;
+    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 clearEmpties(object: any): any;
-    private isAnyObject;
-    protected extractConditions(conditions: FluentQuery<ModelDTO>['where'][]): {
-        operator: LogicOperator;
-        element: string;
-        value: Primitives | PrimitivesArray;
-    }[];
     protected jsApplySelect(select: FluentQuery<ModelDTO>['select'], data: ModelDTO[]): ModelDTO[];
 }

package/dist/BaseConnector.js

@@ -2,8 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseConnector = void 0;
 const js_utils_1 = require("@goatlab/js-utils");
-const types_1 = require("./types");
-const bson_1 = require("bson");
+const clearEmpties_1 = require("./TypeOrmConnector/util/clearEmpties");
 class BaseConnector {
     constructor() {
         this.chunk = null;
@@ -42,7 +41,7 @@ class BaseConnector {
             if (this.isMongoDB) {
                 d['id'] = d['id'].toString();
             }
-            this.clearEmpties(js_utils_1.Objects.deleteNulls(d));
+            (0, clearEmpties_1.clearEmpties)(js_utils_1.Objects.deleteNulls(d));
         });
         if (!found[0]) {
             throw new Error(`Object ${id} not found`);
@@ -55,7 +54,7 @@ class BaseConnector {
             if (this.isMongoDB) {
                 d['id'] = d['id'].toString();
             }
-            this.clearEmpties(js_utils_1.Objects.deleteNulls(d));
+            (0, clearEmpties_1.clearEmpties)(js_utils_1.Objects.deleteNulls(d));
         });
         if (!found[0]) {
             const stringQuery = query ? JSON.stringify(query) : '';
@@ -121,14 +120,17 @@ class BaseConnector {
             [foreignKeyName]: r.id,
             ...data
         }));
-        const existingIds = this.clearEmpties(relatedData.map(r => r.id));
+        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) => d.id === related.id);
+            const exists = existingData.find((d) => {
+                const p = d;
+                p.id === related.id;
+            });
             if (exists) {
                 updateQueries.push(this.updateById(exists.id, {
                     ...exists,
@@ -143,7 +145,7 @@ class BaseConnector {
         const insertedResult = await this.insertMany(insertQueries);
         return [...updateResult, ...insertedResult];
     }
-    async attach(id) {
+    async attach(id, pivot) {
         if (!this.relatedQuery?.entity || !this.relatedQuery.key) {
             throw new Error('Associate can only be called as a related model');
         }
@@ -160,7 +162,8 @@ class BaseConnector {
         }
         const relatedData = parentData.map(d => ({
             [foreignKeyName]: d.id,
-            [inverseKeyName]: id
+            [inverseKeyName]: id,
+            ...pivot
         }));
         return this.relatedQuery.pivot.insertMany(relatedData);
     }
@@ -213,102 +216,6 @@ class BaseConnector {
     hasManyThrough() {
         throw new Error('Method not implemented');
     }
-    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];
-                }
-            }
-        });
-        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;
-    }
     jsApplySelect(select, data) {
         const _data = Array.isArray(data) ? [...data] : [data];
         if (!select) {

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/TypeOrmConnector/TypeOrmConnector.d.ts

@@ -1,12 +1,10 @@
 import { LoadedResult, QueryOutput } from './../types';
-import { FindManyOptions, Repository, MongoRepository } from 'typeorm';
-import { BaseConnector, FluentConnectorInterface } from '../BaseConnector';
+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 declare const getRelationsFromModelGenerator: (typeOrmRepo: Repository<any>) => {
-    relations: {};
-};
 export interface TypeOrmConnectorParams<Input, Output> {
     entity: any;
     dataSource: DataSource;
@@ -22,7 +20,7 @@ export declare class TypeOrmConnector<ModelDTO = AnyObject, InputDTO = ModelDTO,
     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, 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>;
@@ -32,11 +30,9 @@ export declare class TypeOrmConnector<ModelDTO = AnyObject, InputDTO = ModelDTO,
     raw(): Repository<ModelDTO>;
     mongoRaw(): MongoRepository<ModelDTO>;
     protected clone(): any;
-    private getOrderBy;
-    private getMongoSelect;
-    private getMongoLookup;
-    private customMongoRelatedSearch;
     private generateTypeOrmQuery;
-    protected getTypeOrmWhere(where?: FluentQuery<ModelDTO>['where']): FindManyOptions['where'];
-    protected getTypeOrmMongoWhere(where?: FluentQuery<ModelDTO>['where']): FindManyOptions['where'];
+    private customTypeOrmRelatedFind;
+    private getTypeOrmQueryBuilderSelect;
+    private getTypeOrmQueryBuilderSubqueries;
+    private customMongoRelatedFind;
 }