@goatlab/fluent 0.7.4 → 0.7.9

package/dist/fluent/src/TypeOrmConnector/test/relations/user/user.schema.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userOutputSchema = exports.userWithRoles = exports.rolesWithPivot = exports.userInputSchema = exports.BreedSchema = void 0;
+const zod_1 = require("zod");
+const car_schema_1 = require("../car/car.schema");
+const role_schema_1 = require("../roles/role.schema");
+const roles_user_schema_1 = require("../roles/roles_user.schema");
+const ZodManyToOne = ({ manySchema, oneSchema, manyKey, oneKey }) => {
+    return manySchema
+        .extend({
+        [oneKey]: oneSchema.extend({
+            [manyKey]: manySchema
+                .extend({
+                [oneKey]: oneSchema
+                    .extend({
+                    [manyKey]: manySchema
+                        .extend({
+                        [oneKey]: oneSchema.extend({
+                            [manyKey]: manySchema
+                                .extend({
+                                [oneKey]: oneSchema
+                                    .extend({
+                                    [manyKey]: manySchema.optional().array()
+                                })
+                                    .optional()
+                            })
+                                .optional()
+                                .array()
+                        })
+                    })
+                        .array()
+                        .optional()
+                })
+                    .optional()
+            })
+                .optional()
+                .array()
+        }).optional()
+    })
+        .array()
+        .optional();
+};
+exports.BreedSchema = zod_1.z.object({
+    family: zod_1.z.string().optional(),
+    members: zod_1.z.number().optional()
+});
+exports.userInputSchema = zod_1.z.object({
+    id: zod_1.z.string().optional(),
+    name: zod_1.z.string(),
+    age: zod_1.z.number().optional(),
+    breed: exports.BreedSchema.optional()
+});
+exports.rolesWithPivot = role_schema_1.RoleInputSchema.extend({
+    pivot: roles_user_schema_1.RolesUserSchema.optional()
+});
+exports.userWithRoles = exports.userInputSchema.extend({
+    id: zod_1.z.string(),
+    roles: exports.rolesWithPivot.array().optional()
+});
+exports.userOutputSchema = exports.userWithRoles.extend({
+    cars: ZodManyToOne({
+        manySchema: car_schema_1.carInputSchema,
+        oneSchema: exports.userWithRoles,
+        manyKey: 'cars',
+        oneKey: 'user'
+    })
+});

package/dist/fluent/src/TypeOrmConnector/util/clearEmpties.d.ts

@@ -0,0 +1 @@
+export declare const clearEmpties: (object: any) => any;

package/dist/fluent/src/TypeOrmConnector/util/clearEmpties.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearEmpties = void 0;
+const bson_1 = require("bson");
+const clearEmpties = object => {
+    Object.entries(object).forEach(([k, v]) => {
+        if (v && typeof v === 'object')
+            (0, exports.clearEmpties)(v);
+        if ((v && typeof v === 'object' && !Object.keys(v).length) ||
+            v === null ||
+            v === undefined ||
+            v.length === 0) {
+            if (Array.isArray(object)) {
+                if (!(object[k] instanceof bson_1.ObjectId)) {
+                    object.splice(k, 1);
+                }
+            }
+            else if (!(v instanceof Date) && !(v instanceof bson_1.ObjectId)) {
+                delete object[k];
+            }
+        }
+    });
+    return object;
+};
+exports.clearEmpties = clearEmpties;

package/dist/fluent/src/TypeOrmConnector/util/extractConditions.d.ts

@@ -0,0 +1,6 @@
+import { FluentQuery, LogicOperator, Primitives, PrimitivesArray } from '../../types';
+export declare const extractConditions: (conditions: FluentQuery<any>['where'][]) => {
+    operator: LogicOperator;
+    element: string;
+    value: Primitives | PrimitivesArray;
+}[];

package/dist/fluent/src/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/fluent/src/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/fluent/src/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/fluent/src/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/fluent/src/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/fluent/src/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/fluent/src/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/fluent/src/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/fluent/src/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/fluent/src/TypeOrmConnector/util/getSelectedKeysFromRawSql.d.ts

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

package/dist/fluent/src/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/fluent/src/TypeOrmConnector/util/isAnyObject.d.ts

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

package/dist/fluent/src/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/fluent/src/TypeOrmConnector/util/nestQueryResults.d.ts

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

package/dist/fluent/src/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;