@goatlab/fluent 0.7.21 → 0.7.24

package/dist/core/Loopback/query.js

@@ -0,0 +1,292 @@
+"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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,13 @@
+"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

@@ -0,0 +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(): 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

@@ -0,0 +1,34 @@
+"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

@@ -0,0 +1,9 @@
+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

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

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

@@ -0,0 +1 @@
+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

@@ -0,0 +1,17 @@
+"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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,37 @@
+"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

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

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

@@ -0,0 +1,7 @@
+"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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,65 @@
+"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

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