@goatlab/fluent 0.7.1 → 0.7.4

package/dist/BaseConnector.d.ts

@@ -1,16 +1,20 @@
 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> {
-    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>>;
     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;
-    replaceById(id: string, data: InputDTO): Promise<OutputDTO>;
-    updateById(id: string, data: InputDTO): Promise<OutputDTO>;
-    clear(): Promise<boolean>;
-    requireById(id: string, q?: FindByIdFilter<ModelDTO>): Promise<SingleQueryOutput<FindByIdFilter<ModelDTO>, ModelDTO, OutputDTO>>;
+    raw(): any;
 }
 export declare abstract class BaseConnector<ModelDTO, InputDTO, OutputDTO> {
     protected outputKeys: string[];
@@ -28,11 +32,14 @@ export declare abstract class BaseConnector<ModelDTO, InputDTO, OutputDTO> {
     protected modelRelations: any;
     isMongoDB: boolean;
     constructor();
-    findByIds<T extends FindByIdFilter<ModelDTO>>(ids: string[], q?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
     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>;
     collect(query: FluentQuery<ModelDTO>): Promise<Collection<OutputDTO>>;
     pluck(path: QueryFieldSelector<ModelDTO>, query?: FluentQuery<ModelDTO>): Promise<Primitives[]>;
     protected setRelatedQuery(r: {

package/dist/BaseConnector.js

@@ -16,9 +16,6 @@ class BaseConnector {
         this.rawQuery = undefined;
         this.outputKeys = [];
     }
-    async findByIds(ids, q) {
-        throw new Error('findByIds() method not implemented');
-    }
     async insertMany(data) {
         throw new Error('get() method not implemented');
     }
@@ -35,6 +32,57 @@ class BaseConnector {
         }
         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();
+            }
+            this.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();
+            }
+            this.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)) {

package/dist/TypeOrmConnector/TypeOrmConnector.d.ts

@@ -1,4 +1,4 @@
-import { FindByIdFilter, LoadedResult, QueryOutput, SingleQueryOutput } from './../types';
+import { LoadedResult, QueryOutput } from './../types';
 import { FindManyOptions, Repository, MongoRepository } from 'typeorm';
 import { BaseConnector, FluentConnectorInterface } from '../BaseConnector';
 import type { AnyObject, FluentQuery } from '../types';
@@ -22,22 +22,21 @@ 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>>;
+    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>;
-    findMany<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
+    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'];
-    updateById(id: string, data: InputDTO): Promise<OutputDTO>;
-    replaceById(id: string, data: InputDTO): Promise<OutputDTO>;
-    clear(): Promise<boolean>;
-    loadFirst(query?: FluentQuery<ModelDTO>): TypeOrmConnector<ModelDTO, InputDTO, OutputDTO>;
-    loadById(id: string): LoadedResult<this>;
-    requireById(id: string, q?: FindByIdFilter<ModelDTO>): Promise<SingleQueryOutput<FindByIdFilter<ModelDTO>, ModelDTO, OutputDTO>>;
-    protected clone(): any;
-    findByIds<T extends FindByIdFilter<ModelDTO>>(ids: string[], q?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
-    private getOrderBy;
 }

package/dist/TypeOrmConnector/TypeOrmConnector.js

@@ -69,12 +69,6 @@ class TypeOrmConnector extends BaseConnector_1.BaseConnector {
             return this.clearEmpties(js_utils_1.Objects.deleteNulls(d));
         }));
     }
-    raw() {
-        return this.repository;
-    }
-    mongoRaw() {
-        return this.repository;
-    }
     async findMany(query) {
         if (this.isMongoDB && query?.include) {
             const mongoRelationResult = this.customMongoRelatedSearch(query);
@@ -108,6 +102,131 @@ class TypeOrmConnector extends BaseConnector_1.BaseConnector {
         }
         return this.outputSchema?.array().parse(found);
     }
+    async updateById(id, data) {
+        const parsedId = this.isMongoDB
+            ? js_utils_1.Ids.objectID(id)
+            : id;
+        const idFieldName = this.isMongoDB ? '_id' : 'id';
+        const dataToInsert = this.outputKeys.includes('updated')
+            ? {
+                ...data,
+                ...{ updated: new Date() }
+            }
+            : data;
+        const validatedData = this.inputSchema.parse(dataToInsert);
+        const updateResults = await this.repository.update(id, validatedData);
+        if (updateResults.affected === 0) {
+            throw new Error('No rows where affected');
+        }
+        const dbResult = await this.repository.findOneOrFail({
+            where: {
+                [idFieldName]: parsedId
+            }
+        });
+        if (this.isMongoDB) {
+            dbResult['id'] = dbResult['id'].toString();
+        }
+        return this.outputSchema?.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(dbResult)));
+    }
+    async replaceById(id, data) {
+        const parsedId = this.isMongoDB
+            ? js_utils_1.Ids.objectID(id)
+            : id;
+        const idFieldName = this.isMongoDB ? '_id' : 'id';
+        const value = await this.repository.findOneOrFail({
+            where: {
+                [idFieldName]: parsedId
+            }
+        });
+        const flatValue = js_utils_1.Objects.flatten(JSON.parse(JSON.stringify(value)));
+        Object.keys(flatValue).forEach(key => {
+            flatValue[key] = null;
+        });
+        const nullObject = js_utils_1.Objects.nest(flatValue);
+        const newValue = { ...nullObject, ...data };
+        delete newValue._id;
+        delete newValue.id;
+        delete newValue.created;
+        delete newValue.updated;
+        const dataToInsert = this.outputKeys.includes('updated')
+            ? {
+                ...data,
+                ...{ updated: new Date() }
+            }
+            : data;
+        const validatedData = this.inputSchema.parse(dataToInsert);
+        const updateResults = await this.repository.update(id, validatedData);
+        if (updateResults.affected === 0) {
+            throw new Error('No rows where affected');
+        }
+        const val = await this.repository.findOneOrFail({
+            where: {
+                [idFieldName]: parsedId
+            }
+        });
+        if (this.isMongoDB) {
+            val['id'] = val['id'].toString();
+        }
+        return this.outputSchema.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(val)));
+    }
+    async deleteById(id) {
+        const parsedId = this.isMongoDB
+            ? js_utils_1.Ids.objectID(id)
+            : id;
+        await this.repository.delete(parsedId);
+        return id;
+    }
+    async clear() {
+        await this.repository.clear();
+        return true;
+    }
+    loadFirst(query) {
+        const newInstance = this.clone();
+        newInstance.setRelatedQuery({
+            entity: this.entity,
+            repository: this,
+            query: {
+                ...query,
+                limit: 1
+            }
+        });
+        return newInstance;
+    }
+    loadById(id) {
+        const newInstance = this.clone();
+        newInstance.setRelatedQuery({
+            entity: this.entity,
+            repository: this,
+            query: {
+                where: {
+                    id
+                }
+            }
+        });
+        return newInstance;
+    }
+    raw() {
+        return this.repository;
+    }
+    mongoRaw() {
+        return this.repository;
+    }
+    clone() {
+        return new this.constructor();
+    }
+    getOrderBy(orderBy) {
+        if (!orderBy || orderBy.length === 0) {
+            return {};
+        }
+        const order = {};
+        for (const orderElement of orderBy) {
+            const flattenOrder = js_utils_1.Objects.flatten(orderElement);
+            for (const k of Object.keys(flattenOrder)) {
+                order[k] = flattenOrder[k];
+            }
+        }
+        return js_utils_1.Objects.nest(order);
+    }
     getMongoSelect(select) {
         const selected = js_utils_1.Objects.flatten(select || {});
         for (const k of Object.keys(selected)) {
@@ -268,7 +387,15 @@ class TypeOrmConnector extends BaseConnector_1.BaseConnector {
             filter.take = query.paginated.perPage;
             filter.skip = (query.paginated?.page - 1) * query?.paginated.perPage;
         }
-        filter.select = js_utils_1.Objects.flatten(query?.select || {});
+        if (query?.select) {
+            const selectQuery = js_utils_1.Objects.flatten(query?.select || {});
+            if (this.isMongoDB) {
+                filter.select = Object.keys(selectQuery);
+            }
+            else {
+                filter.select = selectQuery;
+            }
+        }
         filter.order = this.getOrderBy(query?.orderBy);
         filter.relations = query?.include;
         return filter;
@@ -629,144 +756,5 @@ class TypeOrmConnector extends BaseConnector_1.BaseConnector {
         const filtered = this.clearEmpties(Filters.where);
         return filtered;
     }
-    async updateById(id, data) {
-        const parsedId = this.isMongoDB
-            ? js_utils_1.Ids.objectID(id)
-            : id;
-        const idFieldName = this.isMongoDB ? '_id' : 'id';
-        const dataToInsert = this.outputKeys.includes('updated')
-            ? {
-                ...data,
-                ...{ updated: new Date() }
-            }
-            : data;
-        const validatedData = this.inputSchema.parse(dataToInsert);
-        const updateResults = await this.repository.update(id, validatedData);
-        if (updateResults.affected === 0) {
-            throw new Error('No rows where affected');
-        }
-        const dbResult = await this.repository.findOneOrFail({
-            where: {
-                [idFieldName]: parsedId
-            }
-        });
-        if (this.isMongoDB) {
-            dbResult['id'] = dbResult['id'].toString();
-        }
-        return this.outputSchema?.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(dbResult)));
-    }
-    async replaceById(id, data) {
-        const parsedId = this.isMongoDB
-            ? js_utils_1.Ids.objectID(id)
-            : id;
-        const idFieldName = this.isMongoDB ? '_id' : 'id';
-        const value = await this.repository.findOneOrFail({
-            where: {
-                [idFieldName]: parsedId
-            }
-        });
-        const flatValue = js_utils_1.Objects.flatten(JSON.parse(JSON.stringify(value)));
-        Object.keys(flatValue).forEach(key => {
-            flatValue[key] = null;
-        });
-        const nullObject = js_utils_1.Objects.nest(flatValue);
-        const newValue = { ...nullObject, ...data };
-        delete newValue._id;
-        delete newValue.id;
-        delete newValue.created;
-        delete newValue.updated;
-        const dataToInsert = this.outputKeys.includes('updated')
-            ? {
-                ...data,
-                ...{ updated: new Date() }
-            }
-            : data;
-        const validatedData = this.inputSchema.parse(dataToInsert);
-        const updateResults = await this.repository.update(id, validatedData);
-        if (updateResults.affected === 0) {
-            throw new Error('No rows where affected');
-        }
-        const val = await this.repository.findOneOrFail({
-            where: {
-                [idFieldName]: parsedId
-            }
-        });
-        if (this.isMongoDB) {
-            val['id'] = val['id'].toString();
-        }
-        return this.outputSchema.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(val)));
-    }
-    async clear() {
-        await this.repository.clear();
-        return true;
-    }
-    loadFirst(query) {
-        const detachedClass = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
-        detachedClass.setRelatedQuery({
-            entity: this.entity,
-            repository: this,
-            query
-        });
-        return detachedClass;
-    }
-    loadById(id) {
-        const newInstance = this.clone();
-        newInstance.setRelatedQuery({
-            entity: this.entity,
-            repository: this,
-            query: {
-                where: {
-                    id
-                }
-            }
-        });
-        return newInstance;
-    }
-    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();
-            }
-            this.clearEmpties(js_utils_1.Objects.deleteNulls(d));
-        });
-        if (!found[0]) {
-            throw new Error(`Object ${id} not found`);
-        }
-        return this.outputSchema?.parse(found[0]);
-    }
-    clone() {
-        return new this.constructor();
-    }
-    async findByIds(ids, q) {
-        let data = await this.findMany({
-            where: {
-                id: {
-                    in: ids
-                }
-            },
-            limit: q?.limit,
-            select: q?.select,
-            include: q?.include
-        });
-        return this.outputSchema?.array().parse(data);
-    }
-    getOrderBy(orderBy) {
-        if (!orderBy || orderBy.length === 0) {
-            return {};
-        }
-        const order = {};
-        for (const orderElement of orderBy) {
-            const flattenOrder = js_utils_1.Objects.flatten(orderElement);
-            for (const k of Object.keys(flattenOrder)) {
-                order[k] = flattenOrder[k];
-            }
-        }
-        return js_utils_1.Objects.nest(order);
-    }
 }
 exports.TypeOrmConnector = TypeOrmConnector;

package/dist/TypeOrmConnector/test/advanced/typeOrm.entity.d.ts

@@ -43,15 +43,15 @@ export declare const NestedSchema: z.ZodObject<{
         c: boolean;
         d: string[];
     } | undefined;
-    a: string[];
     c: number;
+    a: string[];
 }, {
     b?: {
         c: boolean;
         d: string[];
     } | undefined;
-    a: string[];
     c: number;
+    a: string[];
 }>;
 export declare const TypeORMDataModelSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
@@ -75,15 +75,15 @@ export declare const TypeORMDataModelSchema: z.ZodObject<{
             c: boolean;
             d: string[];
         } | undefined;
-        a: string[];
         c: number;
+        a: string[];
     }, {
         b?: {
             c: boolean;
             d: string[];
         } | undefined;
-        a: string[];
         c: number;
+        a: string[];
     }>>;
     test: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
@@ -95,8 +95,8 @@ export declare const TypeORMDataModelSchema: z.ZodObject<{
             c: boolean;
             d: string[];
         } | undefined;
-        a: string[];
         c: number;
+        a: string[];
     } | undefined;
     test: boolean;
 }, {
@@ -108,8 +108,8 @@ export declare const TypeORMDataModelSchema: z.ZodObject<{
             c: boolean;
             d: string[];
         } | undefined;
-        a: string[];
         c: number;
+        a: string[];
     } | undefined;
     test: boolean;
 }>;

package/dist/TypeOrmConnector/test/basic/basicTestSuite.d.ts

@@ -1 +1 @@
-export declare const basicTestSuite: (Repository: any) => void;
+export declare const basicTestSuite: (Repo: any) => void;