@goatlab/fluent 0.7.31 → 0.7.33

package/dist/core/Loopback/query.js

@@ -1,292 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterTemplate = exports.FilterBuilder = exports.WhereBuilder = exports.isFilter = void 0;
-const nonWhereFields = ['fields', 'order', 'limit', 'skip', 'offset', 'include'];
-const filterFields = ['where', ...nonWhereFields];
-function isFilter(candidate) {
-    if (typeof candidate !== 'object')
-        return false;
-    for (const key in candidate) {
-        if (!filterFields.includes(key)) {
-            return false;
-        }
-    }
-    return true;
-}
-exports.isFilter = isFilter;
-class WhereBuilder {
-    constructor(w) {
-        this.where = w ?? {};
-    }
-    add(w) {
-        for (const k of Object.keys(w)) {
-            if (k in this.where) {
-                const where = { and: [this.where, w] };
-                this.where = where;
-                return this;
-            }
-        }
-        this.where = Object.assign(this.where, w);
-        return this;
-    }
-    cast(clause) {
-        return clause;
-    }
-    and(...w) {
-        let clauses = [];
-        w.forEach(where => {
-            clauses = clauses.concat(Array.isArray(where) ? where : [where]);
-        });
-        return this.add({ and: clauses });
-    }
-    or(...w) {
-        let clauses = [];
-        w.forEach(where => {
-            clauses = clauses.concat(Array.isArray(where) ? where : [where]);
-        });
-        return this.add({ or: clauses });
-    }
-    eq(key, val) {
-        const w = {};
-        w[key] = val;
-        return this.add(w);
-    }
-    neq(key, val) {
-        const w = {};
-        w[key] = { neq: val };
-        return this.add(w);
-    }
-    gt(key, val) {
-        const w = {};
-        w[key] = { gt: val };
-        return this.add(w);
-    }
-    gte(key, val) {
-        const w = {};
-        w[key] = { gte: val };
-        return this.add(w);
-    }
-    lt(key, val) {
-        const w = {};
-        w[key] = { lt: val };
-        return this.add(w);
-    }
-    lte(key, val) {
-        const w = {};
-        w[key] = { lte: val };
-        return this.add(w);
-    }
-    inq(key, val) {
-        const w = {};
-        w[key] = { inq: val };
-        return this.add(w);
-    }
-    nin(key, val) {
-        const w = {};
-        w[key] = { nin: val };
-        return this.add(w);
-    }
-    between(key, val1, val2) {
-        const w = {};
-        w[key] = { between: [val1, val2] };
-        return this.add(w);
-    }
-    exists(key, val) {
-        const w = {};
-        w[key] = { exists: !!val || val == null };
-        return this.add(w);
-    }
-    impose(where) {
-        if (!this.where) {
-            this.where = where || {};
-        }
-        else {
-            this.add(where);
-        }
-        return this;
-    }
-    like(key, val) {
-        const w = {};
-        w[key] = { like: val };
-        return this.add(w);
-    }
-    nlike(key, val) {
-        const w = {};
-        w[key] = { nlike: val };
-        return this.add(w);
-    }
-    ilike(key, val) {
-        const w = {};
-        w[key] = { ilike: val };
-        return this.add(w);
-    }
-    nilike(key, val) {
-        const w = {};
-        w[key] = { nilike: val };
-        return this.add(w);
-    }
-    regexp(key, val) {
-        const w = {};
-        w[key] = { regexp: val };
-        return this.add(w);
-    }
-    build() {
-        return this.where;
-    }
-}
-exports.WhereBuilder = WhereBuilder;
-class FilterBuilder {
-    constructor(f) {
-        this.filter = f ?? {};
-    }
-    limit(limit) {
-        if (!(limit >= 1)) {
-            throw new Error(`Limit ${limit} must a positive number`);
-        }
-        this.filter.limit = limit;
-        return this;
-    }
-    offset(offset) {
-        this.filter.offset = offset;
-        return this;
-    }
-    skip(skip) {
-        return this.offset(skip);
-    }
-    fields(...f) {
-        if (!this.filter.fields) {
-            this.filter.fields = {};
-        }
-        else if (Array.isArray(this.filter.fields)) {
-            this.filter.fields = this.filter.fields.reduce((prev, current) => ({ ...prev, [current]: true }), {});
-        }
-        const { fields } = this.filter;
-        for (const field of f) {
-            if (Array.isArray(field)) {
-                field.forEach(i => (fields[i] = true));
-            }
-            else if (typeof field === 'string') {
-                fields[field] = true;
-            }
-            else {
-                Object.assign(fields, field);
-            }
-        }
-        return this;
-    }
-    validateOrder(order) {
-        if (!(order.match(/^[^\s]+( (ASC|DESC))?$/))) {
-            throw new Error(`Invalid order: ${order}`);
-        }
-    }
-    order(...o) {
-        if (!this.filter.order) {
-            this.filter.order = [];
-        }
-        o.forEach(order => {
-            if (typeof order === 'string') {
-                this.validateOrder(order);
-                if (!order.endsWith(' ASC') && !order.endsWith(' DESC')) {
-                    order += ' ASC';
-                }
-                this.filter.order.push(order);
-                return this;
-            }
-            if (Array.isArray(order)) {
-                order.forEach(this.validateOrder);
-                order = order.map(i => {
-                    if (!i.endsWith(' ASC') && !i.endsWith(' DESC')) {
-                        i += ' ASC';
-                    }
-                    return i;
-                });
-                this.filter.order = this.filter.order.concat(order);
-                return this;
-            }
-            for (const i in order) {
-                this.filter.order.push(`${i} ${order[i]}`);
-            }
-        });
-        return this;
-    }
-    include(...i) {
-        if (this.filter.include == null) {
-            this.filter.include = [];
-        }
-        for (const include of i) {
-            if (typeof include === 'string') {
-                this.filter.include.push({ relation: include });
-            }
-            else if (Array.isArray(include)) {
-                for (const inc of include)
-                    this.filter.include.push({ relation: inc });
-            }
-            else {
-                this.filter.include.push(include);
-            }
-        }
-        return this;
-    }
-    where(w) {
-        this.filter.where = w;
-        return this;
-    }
-    impose(constraint) {
-        if (!this.filter) {
-            if (!isFilter(constraint)) {
-                constraint = { where: constraint };
-            }
-            this.filter = constraint || {};
-        }
-        else {
-            if (isFilter(constraint)) {
-                for (const key of Object.keys(constraint)) {
-                    if (nonWhereFields.includes(key)) {
-                        throw new Error('merging strategy for selection, pagination, and sorting not implemented');
-                    }
-                }
-            }
-            this.filter.where = isFilter(constraint)
-                ? new WhereBuilder(this.filter.where).impose(constraint.where).build()
-                : new WhereBuilder(this.filter.where).impose(constraint).build();
-        }
-        return this;
-    }
-    build() {
-        return this.filter;
-    }
-}
-exports.FilterBuilder = FilterBuilder;
-function getDeepProperty(value, path) {
-    const props = path.split('.');
-    for (const p of props) {
-        value = value[p];
-        if (value == null) {
-            return null;
-        }
-    }
-    return value;
-}
-function filterTemplate(strings, ...keys) {
-    return function filter(ctx) {
-        const tokens = [strings[0]];
-        keys.forEach((key, i) => {
-            if (typeof key === 'object' ||
-                typeof key === 'boolean' ||
-                typeof key === 'number') {
-                tokens.push(JSON.stringify(key), strings[i + 1]);
-                return;
-            }
-            const value = getDeepProperty(ctx, key);
-            tokens.push(JSON.stringify(value), strings[i + 1]);
-        });
-        const result = tokens.join('');
-        try {
-            return JSON.parse(result);
-        }
-        catch (e) {
-            throw new Error(`Invalid JSON: ${result}`);
-        }
-    };
-}
-exports.filterTemplate = filterTemplate;

package/dist/core/Loopback/relation.types.d.ts

@@ -1,45 +0,0 @@
-import { InclusionFilter } from './query';
-import { Options } from './common-types';
-import { Entity } from './model';
-import { TypeResolver } from './type-resolver';
-export declare enum RelationType {
-    belongsTo = "belongsTo",
-    hasOne = "hasOne",
-    hasMany = "hasMany",
-    embedsOne = "embedsOne",
-    embedsMany = "embedsMany",
-    referencesOne = "referencesOne",
-    referencesMany = "referencesMany"
-}
-export interface RelationDefinitionBase {
-    type: RelationType;
-    targetsMany: boolean;
-    name: string;
-    source: typeof Entity;
-    target: TypeResolver<Entity, typeof Entity>;
-}
-export interface HasManyDefinition extends RelationDefinitionBase {
-    type: RelationType.hasMany;
-    targetsMany: true;
-    keyTo?: string;
-    keyFrom?: string;
-    through?: {
-        model: TypeResolver<Entity, typeof Entity>;
-        keyFrom?: string;
-        keyTo?: string;
-    };
-}
-export interface BelongsToDefinition extends RelationDefinitionBase {
-    type: RelationType.belongsTo;
-    targetsMany: false;
-    keyFrom?: string;
-    keyTo?: string;
-}
-export interface HasOneDefinition extends RelationDefinitionBase {
-    type: RelationType.hasOne;
-    targetsMany: false;
-    keyTo?: string;
-    keyFrom?: string;
-}
-export declare type RelationMetadata = HasManyDefinition | BelongsToDefinition | HasOneDefinition | RelationDefinitionBase;
-export declare type InclusionResolver<S extends Entity, T extends Entity> = (sourceEntities: S[], inclusion: InclusionFilter, options?: Options) => Promise<(T | undefined)[] | (T[] | undefined)[]>;

package/dist/core/Loopback/relation.types.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RelationType = void 0;
-var RelationType;
-(function (RelationType) {
-    RelationType["belongsTo"] = "belongsTo";
-    RelationType["hasOne"] = "hasOne";
-    RelationType["hasMany"] = "hasMany";
-    RelationType["embedsOne"] = "embedsOne";
-    RelationType["embedsMany"] = "embedsMany";
-    RelationType["referencesOne"] = "referencesOne";
-    RelationType["referencesMany"] = "referencesMany";
-})(RelationType = exports.RelationType || (exports.RelationType = {}));

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

@@ -1,7 +0,0 @@
-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(): 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/Loopback/type-resolver.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveType = exports.isBuiltinType = exports.Null = exports.isTypeResolver = void 0;
-function isTypeResolver(fn) {
-    if (typeof fn !== 'function')
-        return false;
-    if (/^class/.test(fn.toString()))
-        return false;
-    if (isBuiltinType(fn))
-        return false;
-    return true;
-}
-exports.isTypeResolver = isTypeResolver;
-function Null() {
-    return null;
-}
-exports.Null = Null;
-function isBuiltinType(fn) {
-    return (fn === Number ||
-        fn === Boolean ||
-        fn === String ||
-        fn === Object ||
-        fn === Array ||
-        fn === Date ||
-        fn === RegExp ||
-        fn === Buffer ||
-        fn === Null ||
-        fn === Function);
-}
-exports.isBuiltinType = isBuiltinType;
-function resolveType(fn) {
-    return isTypeResolver(fn) ? fn() : fn;
-}
-exports.resolveType = resolveType;

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

@@ -1,9 +0,0 @@
-import { Options } from './common-types';
-export interface Type<T> {
-    name: string;
-    isInstance(value: any): boolean;
-    defaultValue(): T | null | undefined;
-    isCoercible(value: any, options?: Options): boolean;
-    coerce(value: any, options?: Options): T | null | undefined;
-    serialize(value: T | null | undefined, options?: Options): any;
-}

package/dist/core/Loopback/type.js

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

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

@@ -1 +0,0 @@
-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/applyDecorators.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyDecorators = void 0;
-function applyDecorators(...decorators) {
-    return (target, propertyKey, descriptor) => {
-        for (const decorator of decorators) {
-            if (target instanceof Function && !descriptor) {
-                ;
-                decorator(target);
-                continue;
-            }
-            ;
-            decorator(target, propertyKey, descriptor);
-        }
-    };
-}
-exports.applyDecorators = applyDecorators;

package/dist/core/Nestjs/types/common.d.ts

@@ -1,16 +0,0 @@
-export declare const isString: (fn: any) => fn is string;
-export declare enum ClassType {
-    ARGS = "args",
-    OBJECT = "objectType",
-    INPUT = "inputType",
-    INTERFACE = "interface"
-}
-export interface Type<T = any> extends Function {
-    new (...args: any[]): T;
-}
-export declare function flatten<T extends Array<unknown> = any>(arr: T): T extends Array<infer R> ? R : never;
-export declare const isUndefined: (obj: any) => obj is undefined;
-export declare const isFunction: (fn: any) => boolean;
-export declare type TargetHost = Record<'target', Function>;
-export declare function isTargetEqual<T extends TargetHost, U extends TargetHost>(a: T, b: U): boolean;
-export declare function isThrowing(func: () => unknown): boolean;

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

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isThrowing = exports.isTargetEqual = exports.isFunction = exports.isUndefined = exports.flatten = exports.ClassType = exports.isString = void 0;
-const isString = (fn) => typeof fn === 'string';
-exports.isString = isString;
-var ClassType;
-(function (ClassType) {
-    ClassType["ARGS"] = "args";
-    ClassType["OBJECT"] = "objectType";
-    ClassType["INPUT"] = "inputType";
-    ClassType["INTERFACE"] = "interface";
-})(ClassType = exports.ClassType || (exports.ClassType = {}));
-function flatten(arr) {
-    const flat = [].concat(...arr);
-    return (flat.some(Array.isArray)
-        ? flatten(flat)
-        : flat);
-}
-exports.flatten = flatten;
-const isUndefined = (obj) => typeof obj === 'undefined';
-exports.isUndefined = isUndefined;
-const isFunction = (fn) => typeof fn === 'function';
-exports.isFunction = isFunction;
-function isTargetEqual(a, b) {
-    return a.target === b.target;
-}
-exports.isTargetEqual = isTargetEqual;
-function isThrowing(func) {
-    try {
-        func();
-        return false;
-    }
-    catch {
-        return true;
-    }
-}
-exports.isThrowing = isThrowing;

package/dist/core/Nestjs/types/decorators/api-hide-property.decorator.d.ts

@@ -1 +0,0 @@
-export declare function ApiHideProperty(): PropertyDecorator;

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

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiHideProperty = void 0;
-function ApiHideProperty() {
-    return (target, propertyKey) => { };
-}
-exports.ApiHideProperty = ApiHideProperty;

package/dist/core/Nestjs/types/decorators/api-property.decorator.d.ts

@@ -1,27 +0,0 @@
-import { SchemaObjectMetadata } from '../interfaces/schema-object-metadata.interface';
-export declare const DECORATORS_PREFIX = "swagger";
-export declare const DECORATORS: {
-    API_OPERATION: string;
-    API_RESPONSE: string;
-    API_PRODUCES: string;
-    API_CONSUMES: string;
-    API_TAGS: string;
-    API_PARAMETERS: string;
-    API_HEADERS: string;
-    API_MODEL_PROPERTIES: string;
-    API_MODEL_PROPERTIES_ARRAY: string;
-    API_SECURITY: string;
-    API_EXCLUDE_ENDPOINT: string;
-    API_EXCLUDE_CONTROLLER: string;
-    API_EXTRA_MODELS: string;
-    API_EXTENSION: string;
-};
-export interface ApiPropertyOptions extends Omit<SchemaObjectMetadata, 'name' | 'enum'> {
-    name?: string;
-    enum?: any[] | Record<string, any>;
-    enumName?: string;
-}
-export declare function ApiProperty(options?: ApiPropertyOptions): PropertyDecorator;
-export declare function createApiPropertyDecorator(options?: ApiPropertyOptions, overrideExisting?: boolean): PropertyDecorator;
-export declare function ApiPropertyOptional(options?: ApiPropertyOptions): PropertyDecorator;
-export declare function ApiResponseProperty(options?: Pick<ApiPropertyOptions, 'type' | 'example' | 'format' | 'enum' | 'deprecated'>): PropertyDecorator;

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

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiResponseProperty = exports.ApiPropertyOptional = exports.createApiPropertyDecorator = exports.ApiProperty = exports.DECORATORS = exports.DECORATORS_PREFIX = void 0;
-const enum_utils_1 = require("../utils/enum.utils");
-const create_property_decorator_1 = require("./create-property.decorator");
-exports.DECORATORS_PREFIX = 'swagger';
-exports.DECORATORS = {
-    API_OPERATION: `${exports.DECORATORS_PREFIX}/apiOperation`,
-    API_RESPONSE: `${exports.DECORATORS_PREFIX}/apiResponse`,
-    API_PRODUCES: `${exports.DECORATORS_PREFIX}/apiProduces`,
-    API_CONSUMES: `${exports.DECORATORS_PREFIX}/apiConsumes`,
-    API_TAGS: `${exports.DECORATORS_PREFIX}/apiUseTags`,
-    API_PARAMETERS: `${exports.DECORATORS_PREFIX}/apiParameters`,
-    API_HEADERS: `${exports.DECORATORS_PREFIX}/apiHeaders`,
-    API_MODEL_PROPERTIES: `${exports.DECORATORS_PREFIX}/apiModelProperties`,
-    API_MODEL_PROPERTIES_ARRAY: `${exports.DECORATORS_PREFIX}/apiModelPropertiesArray`,
-    API_SECURITY: `${exports.DECORATORS_PREFIX}/apiSecurity`,
-    API_EXCLUDE_ENDPOINT: `${exports.DECORATORS_PREFIX}/apiExcludeEndpoint`,
-    API_EXCLUDE_CONTROLLER: `${exports.DECORATORS_PREFIX}/apiExcludeController`,
-    API_EXTRA_MODELS: `${exports.DECORATORS_PREFIX}/apiExtraModels`,
-    API_EXTENSION: `${exports.DECORATORS_PREFIX}/apiExtension`
-};
-const isEnumArray = (obj) => obj.isArray && !!obj.enum;
-function ApiProperty(options = {}) {
-    return createApiPropertyDecorator(options);
-}
-exports.ApiProperty = ApiProperty;
-function createApiPropertyDecorator(options = {}, overrideExisting = true) {
-    const [type, isArray] = (0, create_property_decorator_1.getTypeIsArrayTuple)(options.type, options.isArray);
-    options = {
-        ...options,
-        type,
-        isArray
-    };
-    if (isEnumArray(options)) {
-        options.type = 'array';
-        const enumValues = (0, enum_utils_1.getEnumValues)(options.enum);
-        options.items = {
-            type: (0, enum_utils_1.getEnumType)(enumValues),
-            enum: enumValues
-        };
-        delete options.enum;
-    }
-    else if (options.enum) {
-        const enumValues = (0, enum_utils_1.getEnumValues)(options.enum);
-        options.enum = enumValues;
-        options.type = (0, enum_utils_1.getEnumType)(enumValues);
-    }
-    return (0, create_property_decorator_1.createPropertyDecorator)(exports.DECORATORS.API_MODEL_PROPERTIES, options, overrideExisting);
-}
-exports.createApiPropertyDecorator = createApiPropertyDecorator;
-function ApiPropertyOptional(options = {}) {
-    return ApiProperty({
-        ...options,
-        required: false
-    });
-}
-exports.ApiPropertyOptional = ApiPropertyOptional;
-function ApiResponseProperty(options = {}) {
-    return ApiProperty({
-        readOnly: true,
-        ...options
-    });
-}
-exports.ApiResponseProperty = ApiResponseProperty;

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

@@ -1,5 +0,0 @@
-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[] | 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;