@goatlab/fluent 0.6.22 → 0.6.30

package/dist/core/Loopback/query.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.filterTemplate = exports.FilterBuilder = exports.WhereBuilder = exports.isFilter = void 0;
-const tslib_1 = require("tslib");
-const assert_1 = tslib_1.__importDefault(require("assert"));
 const nonWhereFields = ['fields', 'order', 'limit', 'skip', 'offset', 'include'];
 const filterFields = ['where', ...nonWhereFields];
 function isFilter(candidate) {
@@ -142,7 +140,9 @@ class FilterBuilder {
         this.filter = f ?? {};
     }
     limit(limit) {
-        (0, assert_1.default)(limit >= 1, `Limit ${limit} must a positive number`);
+        if (!(limit >= 1)) {
+            throw new Error(`Limit ${limit} must a positive number`);
+        }
         this.filter.limit = limit;
         return this;
     }
@@ -175,7 +175,9 @@ class FilterBuilder {
         return this;
     }
     validateOrder(order) {
-        (0, assert_1.default)(order.match(/^[^\s]+( (ASC|DESC))?$/), `Invalid order: ${order}`);
+        if (!(order.match(/^[^\s]+( (ASC|DESC))?$/))) {
+            throw new Error(`Invalid order: ${order}`);
+        }
     }
     order(...o) {
         if (!this.filter.order) {

package/dist/core/Loopback/type-resolver.d.ts

@@ -1,7 +1,7 @@
 import { Class } from './common-types';
 export declare type TypeResolver<Type extends Object, StaticMembers = Function> = () => Class<Type> & StaticMembers;
 export declare function isTypeResolver<T extends object>(fn: any): fn is TypeResolver<T>;
-export declare function Null(): any;
+export declare function Null(): null;
 export declare function isBuiltinType(fn: Function): boolean;
 export declare function resolveType<T extends Object>(fn: TypeResolver<T> | Class<T>): Class<T>;
 export declare function resolveType<T>(fn: T): T;

package/dist/core/Nestjs/applyDecorators.d.ts

@@ -1 +1 @@
-export declare function applyDecorators(...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator>): <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;
+export declare function applyDecorators(...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator>): <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;

package/dist/core/Nestjs/types/common.js

@@ -12,7 +12,9 @@ var ClassType;
 })(ClassType = exports.ClassType || (exports.ClassType = {}));
 function flatten(arr) {
     const flat = [].concat(...arr);
-    return flat.some(Array.isArray) ? flatten(flat) : flat;
+    return (flat.some(Array.isArray)
+        ? flatten(flat)
+        : flat);
 }
 exports.flatten = flatten;
 const isUndefined = (obj) => typeof obj === 'undefined';

package/dist/core/Nestjs/types/decorators/apply-is-optional.decorator.d.ts

@@ -1,5 +1,5 @@
 import { Type } from '../common';
 export declare function applyIsOptionalDecorator(targetClass: Function, propertyKey: string): void;
-export declare function inheritValidationMetadata(parentClass: Type<any>, targetClass: Function, isPropertyInherited?: (key: string) => boolean): string[];
+export declare function inheritValidationMetadata(parentClass: Type<any>, targetClass: Function, isPropertyInherited?: (key: string) => boolean): string[] | undefined;
 export declare function inheritTransformationMetadata(parentClass: Type<any>, targetClass: Function, isPropertyInherited?: (key: string) => boolean): void;
 export declare function inheritPropertyInitializers(target: Record<string, any>, sourceClass: Type<any>, isPropertyInherited?: (key: string) => boolean): void;

package/dist/core/Nestjs/types/decorators/create-property.decorator.js

@@ -1,9 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTypeIsArrayTuple = exports.createPropertyDecorator = void 0;
-const lodash_1 = require("lodash");
 const type_metadata_storage_1 = require("../type-metadata.storage");
 const api_property_decorator_1 = require("./api-property.decorator");
+const isUndefined = val => typeof val === 'undefined';
+const OmitBy = (obj, check) => {
+    obj = { ...obj };
+    Object.entries(obj).forEach(([key, value]) => check(value) && delete obj[key]);
+    return obj;
+};
 function createPropertyDecorator(metakey, metadata, overrideExisting = true) {
     return (target, propertyKey) => {
         const properties = Reflect.getMetadata(api_property_decorator_1.DECORATORS.API_MODEL_PROPERTIES_ARRAY, target) || [];
@@ -13,7 +18,7 @@ function createPropertyDecorator(metakey, metadata, overrideExisting = true) {
         }
         const existingMetadata = Reflect.getMetadata(metakey, target, propertyKey);
         if (existingMetadata) {
-            const newMetadata = (0, lodash_1.pickBy)(metadata, (0, lodash_1.negate)(lodash_1.isUndefined));
+            const newMetadata = OmitBy(metadata, isUndefined);
             const metadataToSave = overrideExisting
                 ? {
                     ...existingMetadata,
@@ -30,7 +35,7 @@ function createPropertyDecorator(metakey, metadata, overrideExisting = true) {
                 Reflect.getMetadata('design:type', target, propertyKey);
             Reflect.defineMetadata(metakey, {
                 type,
-                ...(0, lodash_1.pickBy)(metadata, (0, lodash_1.negate)(lodash_1.isUndefined))
+                ...OmitBy(metadata, isUndefined)
             }, target, propertyKey);
         }
     };
@@ -43,7 +48,7 @@ function getTypeIsArrayTuple(input, isArrayFlag) {
     if (isArrayFlag) {
         return [input, isArrayFlag];
     }
-    const isInputArray = (0, lodash_1.isArray)(input);
+    const isInputArray = Array.isArray(input);
     const type = isInputArray ? input[0] : input;
     return [type, isInputArray];
 }

package/dist/core/Nestjs/types/decorators/field.decorator.d.ts

@@ -12,4 +12,4 @@ export interface FieldOptions extends BaseTypeOptions {
 export declare function Field(): PropertyDecorator & MethodDecorator;
 export declare function Field(options: FieldOptions): PropertyDecorator & MethodDecorator;
 export declare function Field(returnTypeFunction?: ReturnTypeFunc, options?: FieldOptions): PropertyDecorator & MethodDecorator;
-export declare function addFieldMetadata(typeOrOptions: ReturnTypeFunc | FieldOptions, fieldOptions: FieldOptions, prototype: Object, propertyKey?: string, descriptor?: TypedPropertyDescriptor<any>, loadEagerly?: boolean): void;
+export declare function addFieldMetadata(typeOrOptions?: ReturnTypeFunc | FieldOptions, fieldOptions?: FieldOptions | undefined, prototype?: Object, propertyKey?: string, descriptor?: TypedPropertyDescriptor<any>, loadEagerly?: boolean): void;

package/dist/core/Nestjs/types/decorators/field.decorator.js

@@ -21,16 +21,16 @@ function addFieldMetadata(typeOrOptions, fieldOptions, prototype, propertyKey, d
         const { typeFn: getType, options: typeOptions } = (0, reflection_utils_1.reflectTypeFromMetadata)({
             metadataKey: isResolverMethod ? 'design:returntype' : 'design:type',
             prototype,
-            propertyKey,
+            propertyKey: propertyKey || '',
             explicitTypeFn: typeFunc,
             typeOptions: options
         });
         type_metadata_storage_1.TypeMetadataStorage.addClassFieldMetadata({
-            name: propertyKey,
+            name: propertyKey || '',
             schemaName: options.name || propertyKey,
             typeFn: getType,
             options: typeOptions,
-            target: prototype.constructor,
+            target: prototype?.constructor,
             description: options.description,
             deprecationReason: options.deprecationReason,
             complexity: options.complexity,
@@ -39,9 +39,9 @@ function addFieldMetadata(typeOrOptions, fieldOptions, prototype, propertyKey, d
         if (isResolver) {
             type_metadata_storage_1.TypeMetadataStorage.addResolverPropertyMetadata({
                 kind: 'internal',
-                methodName: propertyKey,
+                methodName: propertyKey || '',
                 schemaName: options.name || propertyKey,
-                target: prototype.constructor,
+                target: prototype?.constructor,
                 complexity: options.complexity
             });
         }
@@ -50,7 +50,7 @@ function addFieldMetadata(typeOrOptions, fieldOptions, prototype, propertyKey, d
         applyMetadataFn();
     }
     else {
-        lazy_metadata_storage_1.LazyMetadataStorage.store(prototype.constructor, applyMetadataFn, { isField: true });
+        lazy_metadata_storage_1.LazyMetadataStorage.store(prototype?.constructor, applyMetadataFn, { isField: true });
     }
 }
 exports.addFieldMetadata = addFieldMetadata;

package/dist/core/Nestjs/types/lazy-metadata.storage.js

@@ -27,11 +27,11 @@ class LazyMetadataStorageHost {
         let loadersToExecute = (0, common_1.flatten)(types
             .map(target => this.lazyMetadataByTarget.get(target))
             .filter(metadata => metadata));
-        loadersToExecute = loadersToExecute.concat(...(this.lazyMetadataByTarget.get(NO_TARGET_METADATA) || []));
+        loadersToExecute = loadersToExecute?.concat(...(this.lazyMetadataByTarget.get(NO_TARGET_METADATA) || []));
         if (!options.skipFieldLazyMetadata) {
-            loadersToExecute = loadersToExecute.concat(...(this.lazyMetadataByTarget.get(FIELD_LAZY_METADATA) || []));
+            loadersToExecute = loadersToExecute?.concat(...(this.lazyMetadataByTarget.get(FIELD_LAZY_METADATA) || []));
         }
-        loadersToExecute.forEach(func => func());
+        loadersToExecute?.forEach(func => func());
     }
     concatPrototypes(types) {
         const typesWithPrototypes = types

package/dist/core/Nestjs/types/omit-type.js

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OmitType = void 0;
-const lodash_1 = require("lodash");
 const api_property_decorator_1 = require("./decorators/api-property.decorator");
 const mapped_types_utils_1 = require("./utils/mapped-types.utils");
 const model_properties_accessor_1 = require("./utils/model-properties-accessor");
 const apply_is_optional_decorator_1 = require("./decorators/apply-is-optional.decorator");
+const omit = (obj, props) => {
+    obj = { ...obj };
+    props.forEach(prop => delete obj[prop]);
+    return obj;
+};
 const modelPropertiesAccessor = new model_properties_accessor_1.ModelPropertiesAccessor();
 function OmitType(classRef, keys) {
     const fields = modelPropertiesAccessor
@@ -19,7 +23,7 @@ function OmitType(classRef, keys) {
     }
     (0, apply_is_optional_decorator_1.inheritValidationMetadata)(classRef, OmitTypeClass, isInheritedPredicate);
     (0, apply_is_optional_decorator_1.inheritTransformationMetadata)(classRef, OmitTypeClass, isInheritedPredicate);
-    (0, mapped_types_utils_1.clonePluginMetadataFactory)(OmitTypeClass, classRef.prototype, (metadata) => (0, lodash_1.omit)(metadata, keys));
+    (0, mapped_types_utils_1.clonePluginMetadataFactory)(OmitTypeClass, classRef.prototype, (metadata) => omit(metadata, keys));
     fields.forEach(propertyKey => {
         const metadata = Reflect.getMetadata(api_property_decorator_1.DECORATORS.API_MODEL_PROPERTIES, classRef.prototype, propertyKey);
         const decoratorFactory = (0, api_property_decorator_1.ApiProperty)(metadata);

package/dist/core/Nestjs/types/reflection.utils.d.ts

@@ -2,7 +2,7 @@ import { GqlTypeReference, ReturnTypeFunc } from './interfaces/return-type-func.
 import { TypeOptions } from './interfaces/type-options.interface';
 export interface ReflectTypeOptions {
     metadataKey: 'design:type' | 'design:returntype' | 'design:paramtypes';
-    prototype: Object;
+    prototype?: Object;
     propertyKey: string;
     explicitTypeFn?: ReturnTypeFunc;
     typeOptions?: TypeOptions;

package/dist/core/Nestjs/types/reflection.utils.js

@@ -1,8 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.reflectTypeFromMetadata = void 0;
-const lodash_1 = require("lodash");
 const undefined_type_error_1 = require("./errors/undefined-type.error");
+const get = (obj, path, defaultValue = undefined) => {
+    const travel = regexp => String.prototype.split
+        .call(path, regexp)
+        .filter(Boolean)
+        .reduce((res, key) => (res !== null && res !== undefined ? res[key] : res), obj);
+    const result = travel(/[,[\]]+?/) || travel(/[,[\].]+?/);
+    return result === undefined || result === obj ? defaultValue : result;
+};
 const NOT_ALLOWED_TYPES = [Promise, Array, Object, Function];
 function reflectTypeFromMetadata(reflectOptions) {
     const { metadataKey, prototype, propertyKey, explicitTypeFn, typeOptions = {}, index } = reflectOptions;
@@ -12,7 +19,7 @@ function reflectTypeFromMetadata(reflectOptions) {
     const isNotAllowed = implicitType && NOT_ALLOWED_TYPES.includes(implicitType);
     if ((!explicitTypeFn && (!implicitType || isNotAllowed)) ||
         (!implicitType && !explicitTypeFn)) {
-        throw new undefined_type_error_1.UndefinedTypeError((0, lodash_1.get)(prototype, 'constructor.name'), propertyKey, index);
+        throw new undefined_type_error_1.UndefinedTypeError(get(prototype, 'constructor.name'), propertyKey, index);
     }
     if (explicitTypeFn) {
         return {

package/dist/core/Nestjs/types/type-metadata.storage.js

@@ -240,7 +240,7 @@ class TypeMetadataStorageHost {
                 .reduce((curr, acc) => ({ ...curr, ...acc.value }), {});
             item.objectTypeFn =
                 item.kind === 'external'
-                    ? this.resolvers.find(belongsToClass).typeFn
+                    ? this.resolvers?.find(belongsToClass)?.typeFn
                     : () => item.target;
             if (item.kind === 'external') {
                 this.compileExternalFieldResolverMetadata(item);
@@ -250,13 +250,13 @@ class TypeMetadataStorageHost {
     compileExternalFieldResolverMetadata(item) {
         const objectTypeRef = this.resolvers
             .find(el => (0, common_1.isTargetEqual)(el, item))
-            .typeFn();
+            ?.typeFn();
         const objectOrInterfaceTypeMetadata = this.objectTypes.find(objTypeDef => objTypeDef.target === objectTypeRef) ||
             this.interfaces.find(interfaceTypeDef => interfaceTypeDef.target === objectTypeRef);
         if (!objectOrInterfaceTypeMetadata) {
             throw new cannot_determine_host_type_error_1.CannotDetermineHostTypeError(item.schemaName, objectTypeRef?.name);
         }
-        const objectOrInterfaceTypeField = objectOrInterfaceTypeMetadata.properties.find(fieldDef => fieldDef.name === item.methodName);
+        const objectOrInterfaceTypeField = objectOrInterfaceTypeMetadata.properties?.find(fieldDef => fieldDef.name === item.methodName);
         if (!objectOrInterfaceTypeField) {
             if (!item.typeFn || !item.typeOptions) {
                 throw new undefined_type_error_1.UndefinedTypeError(item.target.name, item.methodName);
@@ -275,7 +275,7 @@ class TypeMetadataStorageHost {
                 complexity: item.complexity
             };
             this.addClassFieldMetadata(fieldMetadata);
-            objectOrInterfaceTypeMetadata.properties.push(fieldMetadata);
+            objectOrInterfaceTypeMetadata.properties?.push(fieldMetadata);
         }
         else {
             const isEmpty = (arr) => arr.length === 0;

package/dist/core/Nestjs/types/utils/get-fields-and-decorator.util.d.ts

@@ -1,13 +1,3 @@
 import 'reflect-metadata';
 import { Type } from '../common';
-import { ArgsType } from '../decorators/args-type.decorator';
-import { InputType } from '../decorators/input-type.decorator';
-import { InterfaceType } from '../decorators/interface-type.decorator';
-import { PropertyMetadata } from '../metadata';
-import { ObjectType } from '../object-type.decorator';
-export declare function getFieldsAndDecoratorForType<T>(objType: Type<T>): {
-    fields: PropertyMetadata[];
-    decoratorFactory: ClassDecorator;
-};
-declare type ClassDecorator = typeof ArgsType | typeof InterfaceType | typeof ObjectType | typeof InputType;
-export {};
+export declare function getFieldsAndDecoratorForType<T>(objType: Type<T>): any;

package/dist/core/Nestjs/types/utils/mapped-types.utils.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clonePluginMetadataFactory = void 0;
-const lodash_1 = require("lodash");
 const type_metadata_storage_1 = require("../type-metadata.storage");
-function clonePluginMetadataFactory(target, parent, transformFn = lodash_1.identity) {
+const identity = a => a;
+function clonePluginMetadataFactory(target, parent, transformFn = identity) {
     let targetMetadata = {};
     do {
         if (!parent.constructor) {