@goatlab/fluent 0.7.21 → 0.7.22

package/dist/TypeOrmConnector/util/extractConditions.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractConditions = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+const types_1 = require("../../types");
+const isAnyObject_1 = require("./isAnyObject");
+const extractConditions = (conditions) => {
+    const accumulatedClauses = [];
+    if (!conditions) {
+        return accumulatedClauses;
+    }
+    for (const clause of conditions) {
+        if (!clause) {
+            continue;
+        }
+        for (const el of Object.keys(clause)) {
+            const value = clause[el];
+            if ((0, isAnyObject_1.isAnyObject)(value)) {
+                const initialKey = el;
+                const flatten = js_utils_1.Objects.flatten(value);
+                for (const key of Object.keys(flatten)) {
+                    const transformedKey = key.replace(new RegExp('.[0-9]', 'g'), '');
+                    if (types_1.LogicOperator[transformedKey]) {
+                        if (types_1.LogicOperator[transformedKey] === types_1.LogicOperator.in ||
+                            types_1.LogicOperator[transformedKey] === types_1.LogicOperator.notIn) {
+                            accumulatedClauses.push({
+                                operator: types_1.LogicOperator[transformedKey],
+                                element: `${initialKey}`,
+                                value: value[transformedKey]
+                            });
+                        }
+                        else {
+                            accumulatedClauses.push({
+                                operator: types_1.LogicOperator[transformedKey],
+                                element: `${initialKey}`,
+                                value: flatten[key]
+                            });
+                        }
+                    }
+                    else if (transformedKey.includes('.')) {
+                        const op = key.split('.').slice(-1).pop();
+                        if (!op) {
+                            continue;
+                        }
+                        if (types_1.LogicOperator[op]) {
+                            accumulatedClauses.push({
+                                operator: types_1.LogicOperator[op],
+                                element: `${initialKey}.${key.replace(`.${op}`, '')}`,
+                                value: flatten[key]
+                            });
+                        }
+                        else {
+                            accumulatedClauses.push({
+                                operator: types_1.LogicOperator.equals,
+                                element: `${initialKey}.${key}`,
+                                value: flatten[key]
+                            });
+                        }
+                    }
+                    else {
+                        accumulatedClauses.push({
+                            operator: types_1.LogicOperator.equals,
+                            element: `${initialKey}.${transformedKey}`,
+                            value: flatten[key]
+                        });
+                    }
+                }
+            }
+            else {
+                accumulatedClauses.push({
+                    operator: types_1.LogicOperator.equals,
+                    element: el,
+                    value
+                });
+            }
+        }
+    }
+    return accumulatedClauses.filter((v, i, a) => a.findIndex(v2 => JSON.stringify(v2) === JSON.stringify(v)) === i);
+};
+exports.extractConditions = extractConditions;

package/dist/TypeOrmConnector/util/extractInclude.d.ts

@@ -0,0 +1,2 @@
+import { AnyObject, FluentQuery } from '../../types';
+export declare const extractInclude: <T>(include?: import("../../types").QueryIncludeRelation<T> | undefined) => AnyObject | undefined;

package/dist/TypeOrmConnector/util/extractInclude.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractInclude = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+const extractInclude = (include) => {
+    if (!include) {
+        return undefined;
+    }
+    const flatten = js_utils_1.Objects.flatten(include);
+    const extractedInclude = {};
+    for (const key of Object.keys(flatten)) {
+        if (key.includes('include')) {
+            const parsedKey = key.split('.include');
+            let acc = '';
+            for (const entity of parsedKey) {
+                extractedInclude[`${acc}${entity}`] = true;
+                acc = acc + entity;
+            }
+            continue;
+        }
+        extractedInclude[key] = true;
+    }
+    return extractedInclude;
+};
+exports.extractInclude = extractInclude;

package/dist/TypeOrmConnector/util/extractMetadataFromKeys.d.ts

@@ -0,0 +1,12 @@
+export interface KeysMetadata {
+    keyName: string;
+    nestableKey: string;
+    relation?: string;
+    parentRelation?: string;
+    level?: number;
+    cardinality?: string;
+}
+export interface KeysMetadataResponse {
+    [key: string]: KeysMetadata;
+}
+export declare const extractMetadataFromKeys: (keys: string[]) => KeysMetadataResponse;

package/dist/TypeOrmConnector/util/extractMetadataFromKeys.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractMetadataFromKeys = void 0;
+const extractMetadataFromKeys = (keys) => {
+    const keyToNestedKeyMap = {};
+    for (const key of keys) {
+        const preAttributeIndex = key.lastIndexOf('_');
+        const fullTableAlias = key.slice(0, preAttributeIndex).replace('_', '');
+        const keyName = key.slice(preAttributeIndex + 1, key.length);
+        const flattened = fullTableAlias
+            .replace(/___XXManyToOneXX/g, '')
+            .replace(/___XXOneToManyXX/g, '')
+            .replace(/___/g, '.')
+            .replace('__', '.')
+            .replace('.XXOneToManyXX', '');
+        const possibleCurrentTableKey = key.lastIndexOf('___');
+        const relation = possibleCurrentTableKey <= 0
+            ? undefined
+            : key.slice(possibleCurrentTableKey + 3, preAttributeIndex);
+        const possibleParentTableKeyInit = key.lastIndexOf('___XX');
+        const possibleParentTableKeyEnd = key.lastIndexOf('XX__');
+        const cardinality = key.slice(possibleParentTableKeyInit, possibleParentTableKeyEnd) ||
+            undefined;
+        const parentRelationKey = key
+            .substring(0, possibleParentTableKeyInit)
+            .lastIndexOf('___');
+        const parentRelation = key
+            .substring(parentRelationKey, possibleParentTableKeyInit)
+            .replace(/___/g, '') || undefined;
+        var level = (key.match(/XX___/g) || []).length;
+        keyToNestedKeyMap[key] = {
+            keyName,
+            nestableKey: `${flattened}.${keyName}`,
+            relation,
+            parentRelation,
+            level,
+            cardinality: cardinality && cardinality.replace(/XX/g, '').replace(/___/g, '')
+        };
+    }
+    return keyToNestedKeyMap;
+};
+exports.extractMetadataFromKeys = extractMetadataFromKeys;

package/dist/TypeOrmConnector/util/extractOrderBy.d.ts

@@ -0,0 +1,4 @@
+import { FluentQuery } from '../../types';
+export declare const extractOrderBy: <T>(orderBy?: Partial<{ [K in keyof import("../../types").Concrete<T>]: import("../../types").Concrete<T>[K] extends object ? Partial<Partial<{ [K_1 in keyof import("../../types").Concrete<import("../../types").Concrete<T>[K]>]: import("../../types").Concrete<import("../../types").Concrete<T>[K]>[K_1] extends object ? Partial<Partial<{ [K_2 in keyof import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<T>[K]>[K_1]>]: import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<T>[K]>[K_1]>[K_2] extends object ? Partial<Partial<{ [K_3 in keyof import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<T>[K]>[K_1]>[K_2]>]: import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<T>[K]>[K_1]>[K_2]>[K_3] extends object ? Partial<Partial<{ [K_4 in keyof import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>]: import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4] extends object ? Partial<Partial<{ [K_5 in keyof import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>]: import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>[K_5] extends object ? Partial<Partial<{ [K_6 in keyof import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>[K_5]>]: import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6] extends object ? Partial<Partial<{ [K_7 in keyof import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>]: import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7] extends object ? Partial<Partial<{ [K_8 in keyof import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>]: import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8] extends object ? Partial<Partial<{ [K_9 in keyof import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>]: import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<import("../../types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9] extends object ? any : "asc" | "desc" | undefined; }>> : "asc" | "desc" | undefined; }>> : "asc" | "desc" | undefined; }>> : "asc" | "desc" | undefined; }>> : "asc" | "desc" | undefined; }>> : "asc" | "desc" | undefined; }>> : "asc" | "desc" | undefined; }>> : "asc" | "desc" | undefined; }>> : "asc" | "desc" | undefined; }>> : "asc" | "desc" | undefined; }>[] | undefined) => {
+    [key: string]: any;
+};

package/dist/TypeOrmConnector/util/extractOrderBy.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractOrderBy = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+const extractOrderBy = (orderBy) => {
+    if (!orderBy || !Array.isArray(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.extractOrderBy = extractOrderBy;

package/dist/TypeOrmConnector/util/getRelationsFromModelGenerator.d.ts

@@ -0,0 +1,19 @@
+import { Repository } from 'typeorm';
+export interface GeneratedModelRelations {
+    relations: {
+        [key: string]: {
+            isOneToMany: boolean;
+            isManyToOne: boolean;
+            isManyToMany: boolean;
+            inverseSidePropertyRelationPath?: string;
+            inverseSidePropertyPath?: string;
+            propertyName: string;
+            entityName: string;
+            tableName: string;
+            targetClass: string;
+            joinColumns: any[];
+            inverseJoinColumns: any[];
+        };
+    };
+}
+export declare const getRelationsFromModelGenerator: (typeOrmRepo: Repository<any>) => GeneratedModelRelations;

package/dist/TypeOrmConnector/util/getRelationsFromModelGenerator.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelationsFromModelGenerator = void 0;
+const getRelationsFromModelGenerator = (typeOrmRepo) => {
+    const relations = {};
+    for (const relation of typeOrmRepo.metadata.relations) {
+        const pPath = relation.inverseRelation?.joinColumns[0];
+        relations[relation.propertyName] = {
+            isOneToMany: relation.isOneToMany,
+            isManyToOne: relation.isManyToOne,
+            isManyToMany: relation.isManyToMany,
+            inverseSidePropertyRelationPath: relation.inverseSidePropertyPath,
+            inverseSidePropertyPath: pPath?.propertyPath,
+            propertyName: relation.propertyName,
+            entityName: relation.inverseEntityMetadata.name,
+            tableName: relation.inverseEntityMetadata.tableName,
+            targetClass: relation.inverseEntityMetadata.target,
+            joinColumns: relation.joinColumns,
+            inverseJoinColumns: relation.inverseJoinColumns
+        };
+    }
+    return {
+        relations
+    };
+};
+exports.getRelationsFromModelGenerator = getRelationsFromModelGenerator;

package/dist/TypeOrmConnector/util/getSelectedKeysFromRawSql.d.ts

@@ -0,0 +1 @@
+export declare const getSelectedKeysFromRawSql: (sql: string) => string[];

package/dist/TypeOrmConnector/util/getSelectedKeysFromRawSql.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSelectedKeysFromRawSql = void 0;
+const getSelectedKeysFromRawSql = (sql) => {
+    const possibleKeys = sql.split('AS');
+    const keys = new Set([]);
+    for (const stringKey of possibleKeys) {
+        if (stringKey.includes('SELECT')) {
+            const key = stringKey.split('"')[1];
+            if (key.includes('___') || !key.includes('_')) {
+                continue;
+            }
+            keys.add(key.replace('_id', 'id').replace('_', '.'));
+            continue;
+        }
+        keys.add(stringKey.split('"')[1].replace('_id', 'id').replace('_', '.'));
+    }
+    return Array.from(keys);
+};
+exports.getSelectedKeysFromRawSql = getSelectedKeysFromRawSql;

package/dist/TypeOrmConnector/util/isAnyObject.d.ts

@@ -0,0 +1 @@
+export declare const isAnyObject: (val: any) => boolean;

package/dist/TypeOrmConnector/util/isAnyObject.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAnyObject = void 0;
+const isAnyObject = (val) => {
+    return typeof val === 'object' && !Array.isArray(val) && val !== null;
+};
+exports.isAnyObject = isAnyObject;

package/dist/TypeOrmConnector/util/nestQueryResults.d.ts

@@ -0,0 +1,2 @@
+import { AnyObject } from '../../types';
+export declare const nestQueryResults: (results: AnyObject[], keyToNestedKeyMap: AnyObject) => AnyObject[];

package/dist/TypeOrmConnector/util/nestQueryResults.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nestQueryResults = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+const nestQueryResults = (results, keyToNestedKeyMap) => {
+    let nestableObject = {};
+    let currentLevel = 0;
+    for (const key of Object.keys(keyToNestedKeyMap)) {
+        if (!key.endsWith('_id')) {
+            continue;
+        }
+        const currentLevelMetadata = keyToNestedKeyMap[key];
+        currentLevel = currentLevelMetadata.level;
+        const grouped = js_utils_1.Arrays.groupBy(results, r => r[key]);
+        const resultCount = Object.keys(grouped)?.length || 0;
+        for (const [index, k] of Object.keys(grouped).entries()) {
+            const prefixindex = currentLevelMetadata.nestableKey.lastIndexOf('.');
+            const prefix = currentLevelMetadata.nestableKey.substring(0, prefixindex);
+            const currentIndex = `${prefix}.${index}.${currentLevelMetadata.keyName}`;
+            const results = grouped[k];
+            console.log(currentLevelMetadata);
+            if (currentLevelMetadata.level === currentLevel) {
+                nestableObject[`${currentIndex}`] = k;
+            }
+            for (const result of results) {
+            }
+        }
+    }
+    return results;
+};
+exports.nestQueryResults = nestQueryResults;

package/dist/cache.d.ts

@@ -0,0 +1,9 @@
+import Keyv from 'keyv';
+export declare class Cache extends Keyv {
+    has(key: string): Promise<boolean>;
+    remember(key: string, ms: number, fx: () => Promise<any>): Promise<any>;
+    rememberForever(key: string, fx: () => Promise<any>): Promise<any>;
+    pull(key: string): Promise<any>;
+    forget(key: string): Promise<boolean>;
+    flush(): Promise<void>;
+}

package/dist/cache.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = void 0;
+const tslib_1 = require("tslib");
+const keyv_1 = tslib_1.__importDefault(require("keyv"));
+class Cache extends keyv_1.default {
+    async has(key) {
+        const value = await this.get(key);
+        return value ? true : false;
+    }
+    async remember(key, ms, fx) {
+        const value = await this.get(key);
+        if (value) {
+            return value;
+        }
+        const result = await fx();
+        await this.set(key, result, ms);
+        return result;
+    }
+    async rememberForever(key, fx) {
+        const value = await this.get(key);
+        if (value) {
+            return value;
+        }
+        const result = await fx();
+        await this.set(key, result);
+        return result;
+    }
+    async pull(key) {
+        const value = await this.get(key);
+        if (value) {
+            this.delete(key);
+        }
+        return value;
+    }
+    async forget(key) {
+        return await this.delete(key);
+    }
+    async flush() {
+        return await this.clear();
+    }
+}
+exports.Cache = Cache;

package/dist/core/Loopback/build-schema.d.ts

@@ -0,0 +1,31 @@
+import { MetadataAccessor } from '@loopback/metadata';
+import { SchemaObject as JsonSchema } from 'openapi3-ts';
+import { RelationMetadata } from './relation.types';
+import { PropertyDefinition, PropertyType } from './model';
+export declare const JSON_SCHEMA_KEY: MetadataAccessor<{
+    [key: string]: JsonSchema;
+}, ClassDecorator>;
+export interface JsonSchemaOptions<T extends object> {
+    title?: string;
+    includeRelations?: boolean;
+    partial?: boolean | 'deep';
+    exclude?: (keyof T)[];
+    optional?: (keyof T)[];
+    visited?: {
+        [key: string]: JsonSchema;
+    };
+}
+export declare function buildModelCacheKey<T extends object>(options?: JsonSchemaOptions<T>): string;
+export declare function getJsonSchema<T extends object>(ctor: Function & {
+    prototype: T;
+}, options?: JsonSchemaOptions<T>): JsonSchema;
+export declare function getJsonSchemaRef<T extends object>(modelCtor: Function & {
+    prototype: T;
+}, options?: JsonSchemaOptions<T>): JsonSchema;
+export declare function stringTypeToWrapper(type: string | Function): Function;
+export declare function isArrayType(type: string | Function | PropertyType): boolean;
+export declare function metaToJsonProperty(meta: PropertyDefinition): JsonSchema;
+export declare function getNavigationalPropertyForRelation(relMeta: RelationMetadata, targetRef: JsonSchema): JsonSchema;
+export declare function modelToJsonSchema<T extends object>(ctor: Function & {
+    prototype: T;
+}, jsonSchemaOptions?: JsonSchemaOptions<T>): JsonSchema;