@goatlab/fluent 0.6.20 → 0.6.21

package/dist/BaseConnector.d.ts

@@ -1,6 +1,10 @@
 import { TypedPathWrapper } from 'typed-path';
 import { Collection } from '@goatlab/js-utils';
 import { Filter, DaoOutput, LogicOperator, Primitives, PrimitivesArray } from './types';
+import { ValidationError } from 'class-validator';
+export declare type Newable<T> = {
+    new (...args: any[]): T;
+};
 export interface FluentConnectorInterface<InputDTO, OutputDTO> {
     get(): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
     all(filter: Filter): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
@@ -79,4 +83,10 @@ export declare abstract class BaseConnector<ModelDTO, InputDTO, OutputDTO> {
     withPivot(): this;
     protected hasManyThrough(): void;
     private prepareInput;
+    validateInput(validationClass: {
+        new (): ModelDTO;
+    }, input: InputDTO): Promise<{
+        errors: ValidationError[] | null;
+        result: Awaited<InputDTO>;
+    }>;
 }

package/dist/BaseConnector.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseConnector = void 0;
 const typed_path_1 = require("typed-path");
 const js_utils_1 = require("@goatlab/js-utils");
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
 class BaseConnector {
     constructor() {
         this.generatedKeyPath = (0, typed_path_1.typedPath)();
@@ -382,5 +384,19 @@ class BaseConnector {
         cols.filter((elem, pos, arr) => arr.indexOf(elem) === pos);
         return cols;
     }
+    async validateInput(validationClass, input) {
+        const validationOptions = {
+            whitelist: true,
+            skipMissingProperties: false,
+            forbidUnknownValues: true,
+            stopAtFirstError: false,
+        };
+        const instance = (0, class_transformer_1.plainToInstance)(validationClass, { ...input });
+        const errors = await (0, class_validator_1.validate)(instance, validationOptions);
+        return {
+            errors: errors && errors.length ? errors : null,
+            result: errors && errors.length ? undefined : instance,
+        };
+    }
 }
 exports.BaseConnector = BaseConnector;

package/dist/index.d.ts

@@ -13,6 +13,11 @@ import { getOutputKeys } from './outputKeys';
 import { loadRelations } from './loadRelations';
 import { modelGeneratorDataSource } from './generatorDatasource';
 import { Cache } from './cache';
+import { ValidationError } from 'class-validator';
 export { DataSource } from 'typeorm';
 export { Access, ApiHideProperty, ApiProperty, BaseConnector, Collection, Column, Decorators, Fluent, getModelSchemaRef, getOutputKeys, HideField, InputType, loadRelations, modelGeneratorDataSource, ObjectType, OmitType, PaginationLinks, PaginationMeta, PartialType, TypeOrmConnector, Cache };
-export type { BaseDataElement, DaoOutput, Deleted, Filter, FluentConnectorInterface, LogicOperator, PaginatedData, Paginator, Paths, Primitives, PrimitivesArray, Sure, WhereClause, SchemaObject };
+interface ValidatedInput<T> {
+    errors: ValidationError[] | null;
+    result: Awaited<T>;
+}
+export type { BaseDataElement, DaoOutput, Deleted, Filter, FluentConnectorInterface, LogicOperator, PaginatedData, Paginator, Paths, Primitives, PrimitivesArray, Sure, WhereClause, SchemaObject, ValidatedInput };

package/dist/loadRelations.js

@@ -69,14 +69,22 @@ const loadRelations = async ({ data, relations, modelRelations, provider, self,
                 let relatedResults = js_utils_1.Arrays.collapse(await Promise.all(relationPromises));
                 const pivotInverseKey = relationModel.inverseJoinColumns[0].propertyName;
                 relatedResults = relatedResults.map(r => {
-                    return { ...r, pivot: pivotResults.find(p => p[pivotInverseKey] === r.id) };
+                    return {
+                        ...r,
+                        pivot: pivotResults.find(p => p[pivotInverseKey] === r.id)
+                    };
                 });
                 const groupedPivot = js_utils_1.Arrays.groupBy(pivotResults, r => r[relationModel.joinColumns[0].propertyName]);
                 const groupedRelated = js_utils_1.Arrays.groupBy(relatedResults, r => r.id);
                 data.forEach(d => {
                     groupedPivot[d.id]?.forEach(gp => {
-                        d[relationModel.propertyPath] =
-                            groupedRelated[gp[relationModel.inverseJoinColumns[0].propertyName]];
+                        if (!d[relationModel.propertyPath]) {
+                            d[relationModel.propertyPath] = [];
+                        }
+                        d[relationModel.propertyPath] = [
+                            ...d[relationModel.propertyPath],
+                            ...groupedRelated[gp[relationModel.inverseJoinColumns[0].propertyName]]
+                        ];
                     });
                 });
             }