@goatlab/fluent 0.7.31 → 0.7.32

package/dist/core/Nestjs/types/utils/model-properties-accessor.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelPropertiesAccessor = void 0;
-const common_1 = require("../common");
-require("reflect-metadata");
-const api_property_decorator_1 = require("../decorators/api-property.decorator");
-const type_metadata_storage_1 = require("../type-metadata.storage");
-class ModelPropertiesAccessor {
-    getModelProperties(prototype) {
-        const properties = Reflect.getMetadata(api_property_decorator_1.DECORATORS.API_MODEL_PROPERTIES_ARRAY, prototype) ||
-            [];
-        return properties
-            .filter(common_1.isString)
-            .filter((key) => key.charAt(0) === ':' && !(0, common_1.isFunction)(prototype[key]))
-            .map((key) => key.slice(1));
-    }
-    applyMetadataFactory(prototype) {
-        const classPrototype = prototype;
-        do {
-            if (!prototype.constructor) {
-                return;
-            }
-            if (!prototype.constructor[type_metadata_storage_1.METADATA_FACTORY_NAME]) {
-                continue;
-            }
-            const metadata = prototype.constructor[type_metadata_storage_1.METADATA_FACTORY_NAME]();
-            const properties = Object.keys(metadata);
-            properties.forEach(key => {
-                (0, api_property_decorator_1.createApiPropertyDecorator)(metadata[key], false)(classPrototype, key);
-            });
-        } while ((prototype = Reflect.getPrototypeOf(prototype)) &&
-            prototype !== Object.prototype &&
-            prototype);
-    }
-}
-exports.ModelPropertiesAccessor = ModelPropertiesAccessor;

package/dist/core/Nestjs/types/utils/type-helpers.utils.d.ts

@@ -1,2 +0,0 @@
-import { PropertyMetadata } from '../metadata';
-export declare function applyFieldDecorators(targetClass: Function, item: PropertyMetadata): void;

package/dist/core/Nestjs/types/utils/type-helpers.utils.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyFieldDecorators = void 0;
-const directive_decorator_1 = require("../decorators/directive.decorator");
-const extensions_decorator_1 = require("../decorators/extensions.decorator");
-function applyFieldDecorators(targetClass, item) {
-    if (item.extensions) {
-        (0, extensions_decorator_1.Extensions)(item.extensions)(targetClass.prototype, item.name);
-    }
-    if (item.directives?.length) {
-        item.directives.map(directive => {
-            (0, directive_decorator_1.Directive)(directive.sdl)(targetClass.prototype, item.name);
-        });
-    }
-}
-exports.applyFieldDecorators = applyFieldDecorators;

package/dist/core/types.d.ts

@@ -1,23 +0,0 @@
-import { Column as TypeORMColumn } from 'typeorm';
-import { SchemaObject as LBSchemaObject } from 'openapi3-ts';
-import { InputType as NestInputType } from './Nestjs/types/decorators/input-type.decorator';
-import { PartialType as NestjsPartialType } from './Nestjs/types/decorators/partial-type.helper';
-import { ObjectType as NestObjectType } from './Nestjs/types/object-type.decorator';
-import { ApiProperty as NEstJSApiProperty } from './Nestjs/types/decorators/api-property.decorator';
-import { OmitType as NEstJSOmitType } from './Nestjs/types/omit-type';
-import { ApiHideProperty as NEstApiHideProperty } from './Nestjs/types/decorators/api-hide-property.decorator';
-import { SchemaRef } from './Loopback/json-to-schema';
-import { JsonSchemaOptions } from './Loopback/build-schema';
-export declare function LBgetModelSchemaRef<T extends object>(modelCtor: Function & {
-    prototype: T;
-}, options?: JsonSchemaOptions<T>): SchemaRef;
-export declare const ApiProperty: typeof NEstJSApiProperty;
-export declare const ApiHideProperty: typeof NEstApiHideProperty;
-export declare const OmitType: typeof NEstJSOmitType;
-export declare const InputType: typeof NestInputType;
-export declare const PartialType: typeof NestjsPartialType;
-export declare const Column: typeof TypeORMColumn;
-export declare const getModelSchemaRef: typeof LBgetModelSchemaRef;
-export declare const ObjectType: typeof NestObjectType;
-export declare type SchemaObject = LBSchemaObject;
-export declare function HideField(): PropertyDecorator;

package/dist/core/types.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HideField = exports.ObjectType = exports.getModelSchemaRef = exports.Column = exports.PartialType = exports.InputType = exports.OmitType = exports.ApiHideProperty = exports.ApiProperty = exports.LBgetModelSchemaRef = void 0;
-const typeorm_1 = require("typeorm");
-const input_type_decorator_1 = require("./Nestjs/types/decorators/input-type.decorator");
-const partial_type_helper_1 = require("./Nestjs/types/decorators/partial-type.helper");
-const object_type_decorator_1 = require("./Nestjs/types/object-type.decorator");
-const api_property_decorator_1 = require("./Nestjs/types/decorators/api-property.decorator");
-const omit_type_1 = require("./Nestjs/types/omit-type");
-const api_hide_property_decorator_1 = require("./Nestjs/types/decorators/api-hide-property.decorator");
-const json_to_schema_1 = require("./Loopback/json-to-schema");
-const build_schema_1 = require("./Loopback/build-schema");
-function LBgetModelSchemaRef(modelCtor, options) {
-    const jsonSchema = (0, build_schema_1.getJsonSchemaRef)(modelCtor, options);
-    return (0, json_to_schema_1.jsonToSchemaObject)(jsonSchema);
-}
-exports.LBgetModelSchemaRef = LBgetModelSchemaRef;
-exports.ApiProperty = api_property_decorator_1.ApiProperty;
-exports.ApiHideProperty = api_hide_property_decorator_1.ApiHideProperty;
-exports.OmitType = omit_type_1.OmitType;
-exports.InputType = input_type_decorator_1.InputType;
-exports.PartialType = partial_type_helper_1.PartialType;
-exports.Column = typeorm_1.Column;
-exports.getModelSchemaRef = LBgetModelSchemaRef;
-exports.ObjectType = object_type_decorator_1.ObjectType;
-function HideField() {
-    return (target, propertyKey) => { };
-}
-exports.HideField = HideField;

package/dist/decorators.d.ts

@@ -1,47 +0,0 @@
-import { ColumnType } from 'typeorm';
-import { Primitives } from './types';
-interface PropertyInterface {
-    required?: boolean;
-    unique?: boolean;
-    hidden?: boolean;
-    type?: ColumnType;
-}
-interface EnumProperty {
-    enum: any[];
-    default?: Primitives;
-}
-export declare type DbEntity<T> = new () => T;
-interface ManyToManyInterface<T> {
-    entity: (type?: any) => DbEntity<T>;
-    joinTableName: string;
-    foreignKey: string;
-    inverseForeignKey: string;
-}
-interface BelongsToInterface<T> {
-    entity: (type?: any) => DbEntity<T>;
-    inverse: string | ((object: T) => any);
-    pivotColumnName?: string;
-}
-interface hasManyInterface<T> {
-    entity: (type?: any) => DbEntity<T>;
-    inverse: string | ((object: T) => any);
-}
-export declare class DecoratorsClass {
-    id(): PropertyDecorator;
-    mongoId(): PropertyDecorator;
-    entity(name: string): ClassDecorator;
-    property(params?: PropertyInterface): PropertyDecorator;
-    embed(e: any): PropertyDecorator;
-    embedArray(e: any, params?: PropertyInterface): PropertyDecorator;
-    stringArray(e: any, params?: PropertyInterface): PropertyDecorator;
-    Enum(e: EnumProperty, params?: PropertyInterface): PropertyDecorator;
-    created(e?: any): PropertyDecorator;
-    updated(e?: any): PropertyDecorator;
-    deleted(e?: any): PropertyDecorator;
-    version(e?: any): PropertyDecorator;
-    belongsToMany<T>({ entity, joinTableName, foreignKey, inverseForeignKey }: ManyToManyInterface<T>): PropertyDecorator;
-    belongsTo<T>({ entity, inverse, pivotColumnName }: BelongsToInterface<T>): PropertyDecorator;
-    hasMany<T>({ entity, inverse }: hasManyInterface<T>): PropertyDecorator;
-}
-export declare const f: DecoratorsClass;
-export {};

package/dist/decorators.js

@@ -1,104 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.f = exports.DecoratorsClass = void 0;
-const typeorm_1 = require("typeorm");
-const graphql_1 = require("graphql");
-const types_1 = require("./core/types");
-const applyDecorators_1 = require("./core/Nestjs/applyDecorators");
-const field_decorator_1 = require("./core/Nestjs/types/decorators/field.decorator");
-const js_utils_1 = require("@goatlab/js-utils");
-class DecoratorsClass {
-    id() {
-        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.ObjectIdColumn)({ type: 'uuid' }), (0, typeorm_1.PrimaryGeneratedColumn)('uuid'), (0, types_1.ApiProperty)(), (0, field_decorator_1.Field)(() => graphql_1.GraphQLID));
-    }
-    mongoId() {
-        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.ObjectIdColumn)(), (0, types_1.ApiProperty)(), (0, field_decorator_1.Field)(() => graphql_1.GraphQLID));
-    }
-    entity(name) {
-        const PascalCase = name;
-        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Entity)({ name: PascalCase }), (0, types_1.ObjectType)());
-    }
-    property(params) {
-        if (params && params.hidden) {
-            return (0, applyDecorators_1.applyDecorators)((0, types_1.HideField)(), (0, typeorm_1.Column)({
-                select: false,
-                nullable: !params.required,
-                type: params.type
-            }), (0, types_1.ApiProperty)({
-                nullable: !params.required,
-                required: !!params.required
-            }), (0, types_1.ApiHideProperty)());
-        }
-        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)({
-            nullable: !params?.required
-        }), (0, types_1.ApiProperty)({
-            nullable: !params?.required,
-            required: !!params?.required
-        }), (0, field_decorator_1.Field)());
-    }
-    embed(e) {
-        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)(type => e), (0, types_1.ApiProperty)({ type: e }));
-    }
-    embedArray(e, params) {
-        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)(type => e), (0, types_1.ApiProperty)({
-            isArray: true,
-            type: e,
-            nullable: !params?.required,
-            required: !!params?.required
-        }));
-    }
-    stringArray(e, params) {
-        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)({
-            type: 'simple-array',
-            nullable: !params?.required
-        }), (0, types_1.ApiProperty)({
-            type: [e],
-            nullable: !params?.required,
-            required: !!params?.required
-        }));
-    }
-    Enum(e, params) {
-        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)({
-            type: 'enum',
-            enum: e.enum,
-            default: e.default,
-            nullable: !params?.required
-        }), (0, types_1.ApiProperty)({
-            enum: e.enum,
-            default: e.default,
-            nullable: !params?.required,
-            required: !!params?.required
-        }));
-    }
-    created(e) {
-        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.CreateDateColumn)(), (0, types_1.ApiProperty)());
-    }
-    updated(e) {
-        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.UpdateDateColumn)(), (0, types_1.ApiProperty)());
-    }
-    deleted(e) {
-        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.DeleteDateColumn)(), (0, types_1.ApiProperty)());
-    }
-    version(e) {
-        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.VersionColumn)(), (0, types_1.ApiProperty)());
-    }
-    belongsToMany({ entity, joinTableName, foreignKey, inverseForeignKey }) {
-        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.ManyToMany)(entity), (0, typeorm_1.JoinTable)({
-            name: joinTableName,
-            joinColumns: [{ name: foreignKey }],
-            inverseJoinColumns: [{ name: inverseForeignKey }]
-        }));
-    }
-    belongsTo({ entity, inverse, pivotColumnName }) {
-        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.ManyToOne)(entity, inverse), (0, typeorm_1.JoinColumn)({
-            name: pivotColumnName,
-            referencedColumnName: 'id',
-            foreignKeyConstraintName: `${pivotColumnName}_id_${js_utils_1.Ids.nanoId()}`
-        }));
-    }
-    hasMany({ entity, inverse }) {
-        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.OneToMany)(entity, inverse));
-    }
-}
-exports.DecoratorsClass = DecoratorsClass;
-exports.f = new DecoratorsClass();

package/dist/generatorDatasource.d.ts

@@ -1,2 +0,0 @@
-import { DataSource } from 'typeorm';
-export declare const modelGeneratorDataSource: DataSource;

package/dist/generatorDatasource.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.modelGeneratorDataSource = void 0;
-const typeorm_1 = require("typeorm");
-exports.modelGeneratorDataSource = new typeorm_1.DataSource({
-    name: '_goat_model_generator',
-    type: 'sqlite',
-    database: ':memory:',
-    logging: false,
-    synchronize: true,
-    dropSchema: true
-});

package/dist/index.d.ts

@@ -1,30 +0,0 @@
-import { ApiHideProperty, ApiProperty, Column, HideField, InputType, ObjectType, OmitType, PartialType, getModelSchemaRef } from './core/types';
-import type { AnyObject, Deleted, PaginatedData, Paginator, Primitives, PrimitivesArray, FluentQuery, QueryOutput, LoadedResult, FindByIdFilter } from './types';
-import { LogicOperator } from './types';
-import { BaseConnector } from './BaseConnector';
-import { Collection } from '@goatlab/js-utils';
-import { f } from './decorators';
-import { Fluent } from './Fluent';
-import type { FluentConnectorInterface } from './FluentConnectorInterface';
-import type { SchemaObject } from './core/types';
-import { TypeOrmConnector } from './TypeOrmConnector/TypeOrmConnector';
-import { getOutputKeys } from './outputKeys';
-import { loadRelations } from './loadRelations';
-import { modelGeneratorDataSource } from './generatorDatasource';
-import { Cache } from './cache';
-import { ValidationError } from 'class-validator';
-import { extractConditions } from './TypeOrmConnector/util/extractConditions';
-import { extractInclude } from './TypeOrmConnector/util/extractInclude';
-import { extractMetadataFromKeys } from './TypeOrmConnector/util/extractMetadataFromKeys';
-import { extractOrderBy } from './TypeOrmConnector/util/extractOrderBy';
-import { getRelationsFromModelGenerator } from './TypeOrmConnector/util/getRelationsFromModelGenerator';
-import { getSelectedKeysFromRawSql } from './TypeOrmConnector/util/getSelectedKeysFromRawSql';
-import { nestQueryResults } from './TypeOrmConnector/util/nestQueryResults';
-export { DataSource } from 'typeorm';
-export type { Relation } from 'typeorm';
-export { ApiHideProperty, ApiProperty, BaseConnector, Collection, Column, f, Fluent, getModelSchemaRef, getOutputKeys, HideField, InputType, loadRelations, modelGeneratorDataSource, ObjectType, OmitType, PartialType, TypeOrmConnector, Cache, getRelationsFromModelGenerator, LogicOperator, extractConditions, extractInclude, extractMetadataFromKeys, extractOrderBy, getSelectedKeysFromRawSql, nestQueryResults };
-interface ValidatedInput<T> {
-    errors: ValidationError[] | null;
-    result: Awaited<T>;
-}
-export type { AnyObject, Deleted, FluentConnectorInterface, PaginatedData, Paginator, Primitives, PrimitivesArray, SchemaObject, ValidatedInput, FluentQuery, QueryOutput, LoadedResult, FindByIdFilter };

package/dist/index.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nestQueryResults = exports.getSelectedKeysFromRawSql = exports.extractOrderBy = exports.extractMetadataFromKeys = exports.extractInclude = exports.extractConditions = exports.LogicOperator = exports.getRelationsFromModelGenerator = exports.Cache = exports.TypeOrmConnector = exports.PartialType = exports.OmitType = exports.ObjectType = exports.modelGeneratorDataSource = exports.loadRelations = exports.InputType = exports.HideField = exports.getOutputKeys = exports.getModelSchemaRef = exports.Fluent = exports.f = exports.Column = exports.Collection = exports.BaseConnector = exports.ApiProperty = exports.ApiHideProperty = exports.DataSource = void 0;
-const types_1 = require("./core/types");
-Object.defineProperty(exports, "ApiHideProperty", { enumerable: true, get: function () { return types_1.ApiHideProperty; } });
-Object.defineProperty(exports, "ApiProperty", { enumerable: true, get: function () { return types_1.ApiProperty; } });
-Object.defineProperty(exports, "Column", { enumerable: true, get: function () { return types_1.Column; } });
-Object.defineProperty(exports, "HideField", { enumerable: true, get: function () { return types_1.HideField; } });
-Object.defineProperty(exports, "InputType", { enumerable: true, get: function () { return types_1.InputType; } });
-Object.defineProperty(exports, "ObjectType", { enumerable: true, get: function () { return types_1.ObjectType; } });
-Object.defineProperty(exports, "OmitType", { enumerable: true, get: function () { return types_1.OmitType; } });
-Object.defineProperty(exports, "PartialType", { enumerable: true, get: function () { return types_1.PartialType; } });
-Object.defineProperty(exports, "getModelSchemaRef", { enumerable: true, get: function () { return types_1.getModelSchemaRef; } });
-const types_2 = require("./types");
-Object.defineProperty(exports, "LogicOperator", { enumerable: true, get: function () { return types_2.LogicOperator; } });
-const BaseConnector_1 = require("./BaseConnector");
-Object.defineProperty(exports, "BaseConnector", { enumerable: true, get: function () { return BaseConnector_1.BaseConnector; } });
-const js_utils_1 = require("@goatlab/js-utils");
-Object.defineProperty(exports, "Collection", { enumerable: true, get: function () { return js_utils_1.Collection; } });
-const decorators_1 = require("./decorators");
-Object.defineProperty(exports, "f", { enumerable: true, get: function () { return decorators_1.f; } });
-const Fluent_1 = require("./Fluent");
-Object.defineProperty(exports, "Fluent", { enumerable: true, get: function () { return Fluent_1.Fluent; } });
-const TypeOrmConnector_1 = require("./TypeOrmConnector/TypeOrmConnector");
-Object.defineProperty(exports, "TypeOrmConnector", { enumerable: true, get: function () { return TypeOrmConnector_1.TypeOrmConnector; } });
-const outputKeys_1 = require("./outputKeys");
-Object.defineProperty(exports, "getOutputKeys", { enumerable: true, get: function () { return outputKeys_1.getOutputKeys; } });
-const loadRelations_1 = require("./loadRelations");
-Object.defineProperty(exports, "loadRelations", { enumerable: true, get: function () { return loadRelations_1.loadRelations; } });
-const generatorDatasource_1 = require("./generatorDatasource");
-Object.defineProperty(exports, "modelGeneratorDataSource", { enumerable: true, get: function () { return generatorDatasource_1.modelGeneratorDataSource; } });
-const cache_1 = require("./cache");
-Object.defineProperty(exports, "Cache", { enumerable: true, get: function () { return cache_1.Cache; } });
-const extractConditions_1 = require("./TypeOrmConnector/util/extractConditions");
-Object.defineProperty(exports, "extractConditions", { enumerable: true, get: function () { return extractConditions_1.extractConditions; } });
-const extractInclude_1 = require("./TypeOrmConnector/util/extractInclude");
-Object.defineProperty(exports, "extractInclude", { enumerable: true, get: function () { return extractInclude_1.extractInclude; } });
-const extractMetadataFromKeys_1 = require("./TypeOrmConnector/util/extractMetadataFromKeys");
-Object.defineProperty(exports, "extractMetadataFromKeys", { enumerable: true, get: function () { return extractMetadataFromKeys_1.extractMetadataFromKeys; } });
-const extractOrderBy_1 = require("./TypeOrmConnector/util/extractOrderBy");
-Object.defineProperty(exports, "extractOrderBy", { enumerable: true, get: function () { return extractOrderBy_1.extractOrderBy; } });
-const getRelationsFromModelGenerator_1 = require("./TypeOrmConnector/util/getRelationsFromModelGenerator");
-Object.defineProperty(exports, "getRelationsFromModelGenerator", { enumerable: true, get: function () { return getRelationsFromModelGenerator_1.getRelationsFromModelGenerator; } });
-const getSelectedKeysFromRawSql_1 = require("./TypeOrmConnector/util/getSelectedKeysFromRawSql");
-Object.defineProperty(exports, "getSelectedKeysFromRawSql", { enumerable: true, get: function () { return getSelectedKeysFromRawSql_1.getSelectedKeysFromRawSql; } });
-const nestQueryResults_1 = require("./TypeOrmConnector/util/nestQueryResults");
-Object.defineProperty(exports, "nestQueryResults", { enumerable: true, get: function () { return nestQueryResults_1.nestQueryResults; } });
-var typeorm_1 = require("typeorm");
-Object.defineProperty(exports, "DataSource", { enumerable: true, get: function () { return typeorm_1.DataSource; } });

package/dist/loadRelations.d.ts

@@ -1,12 +0,0 @@
-import { DataSource } from 'typeorm';
-interface RelationshipLoader {
-    data: any[];
-    relations: any;
-    modelRelations: any;
-    dataSource?: DataSource;
-    provider?: 'typeorm' | 'firebase';
-    self: any;
-    returnPivot?: boolean;
-}
-export declare const loadRelations: ({ data, relations, modelRelations, provider, self, returnPivot }: RelationshipLoader) => Promise<any[]>;
-export {};

package/dist/loadRelations.js

@@ -1,133 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadRelations = void 0;
-const js_utils_1 = require("@goatlab/js-utils");
-const loadRelations = async ({ data, relations, modelRelations, provider, self, returnPivot }) => {
-    if (!relations) {
-        return data;
-    }
-    const chunkSize = provider === 'typeorm' ? 100 : 10;
-    for (const relation of Object.keys(relations)) {
-        if (!modelRelations[relation]) {
-            throw new Error(`Relationship does not exist: ${relation}. Did you create it in your DB entity?`);
-        }
-        if (!self[relation]) {
-            throw new Error(`Relationship does not exist: ${relation}. Did you create it in your Repository?`);
-        }
-        const relationModel = modelRelations[relation];
-        const Repository = self[relation]();
-        if (relationModel.isOneToMany) {
-            const ids = new Set(data.map(d => d.id));
-            const chunks = js_utils_1.Arrays.chunk(Array.from(ids), chunkSize);
-            const promises = [];
-            for (const relatedIds of chunks) {
-                promises.push(Repository.findMany({
-                    where: {
-                        [relationModel.inverseSidePropertyPath]: {
-                            in: relatedIds
-                        }
-                    }
-                }));
-            }
-            const relatedResults = js_utils_1.Arrays.collapse(await Promise.all(promises));
-            const grouped = js_utils_1.Arrays.groupBy(relatedResults, r => r[relationModel.inverseSidePropertyPath]);
-            data.map(d => {
-                if (grouped[d.id]) {
-                    d[relationModel.propertyName] = grouped[d.id];
-                }
-                return d;
-            });
-            return data;
-        }
-        if (relationModel.isManyToOne) {
-            const ids = js_utils_1.Arrays.deDuplicate(data.map(d => d[relationModel.joinColumns[0].propertyPath]));
-            const chunks = js_utils_1.Arrays.chunk(ids, chunkSize);
-            const promises = [];
-            for (const relatedIds of chunks) {
-                promises.push(Repository.findMany({
-                    where: {
-                        id: {
-                            in: relatedIds
-                        }
-                    }
-                }));
-            }
-            const relatedResults = js_utils_1.Arrays.collapse(await Promise.all(promises));
-            const grouped = js_utils_1.Arrays.groupBy(relatedResults, r => r.id);
-            data.map(d => {
-                if (grouped[d[relationModel.joinColumns[0].propertyPath]]) {
-                    d[relationModel.propertyName] =
-                        grouped[d[relationModel.joinColumns[0].propertyPath]][0];
-                }
-            });
-            return data;
-        }
-        if (relationModel.isManyToMany) {
-            const ids = js_utils_1.Arrays.deDuplicate(data.map(d => d.id));
-            const chunks = js_utils_1.Arrays.chunk(ids, chunkSize);
-            if (relationModel.joinColumns.length === 0) {
-                return data;
-            }
-            const pivotForeignField = self.modelRelations[relationModel.propertyName].joinColumns[0]
-                .propertyPath;
-            const inverseForeignField = self.modelRelations[relationModel.propertyName].inverseJoinColumns[0]
-                .propertyPath;
-            const pivotRepository = Repository?.relatedQuery.pivot;
-            const calleeKey = Repository?.relatedQuery.key;
-            if (!pivotForeignField ||
-                !inverseForeignField ||
-                !pivotRepository ||
-                !calleeKey) {
-                throw new Error('The Many-to-Many relationship is not properly defined.Please check both your Model and Repository');
-            }
-            const promises = [];
-            for (const pivotIds of chunks) {
-                const results = await pivotRepository.findMany({
-                    where: {
-                        [pivotForeignField]: {
-                            in: pivotIds
-                        }
-                    }
-                });
-                promises.push(results);
-            }
-            const pivotResults = js_utils_1.Arrays.collapse(await Promise.all(promises));
-            const uniquePivotIds = pivotResults.map(p => p[inverseForeignField]);
-            const relationChunks = js_utils_1.Arrays.chunk(uniquePivotIds, chunkSize);
-            const relationPromises = [];
-            for (const relatedIds of relationChunks) {
-                const results = await Repository.findMany({
-                    where: {
-                        id: {
-                            in: relatedIds
-                        }
-                    }
-                });
-                relationPromises.push(results);
-            }
-            let relatedResults = js_utils_1.Arrays.collapse(await Promise.all(relationPromises));
-            relatedResults = relatedResults.map(r => {
-                return {
-                    ...r,
-                    pivot: pivotResults.find(p => p[inverseForeignField] === r.id)
-                };
-            });
-            const groupedPivot = js_utils_1.Arrays.groupBy(pivotResults, r => r[relationModel.joinColumns[0].propertyName]);
-            const groupedRelated = js_utils_1.Arrays.groupBy(relatedResults, r => r.id);
-            data.map(d => {
-                groupedPivot[d.id]?.forEach(gp => {
-                    if (!d[calleeKey]) {
-                        d[calleeKey] = [];
-                    }
-                    const mapped = groupedRelated[gp[relationModel.inverseJoinColumns[0].propertyName]];
-                    if (mapped) {
-                        d[calleeKey] = [...d[calleeKey], ...mapped];
-                    }
-                });
-            });
-            return data;
-        }
-    }
-    return data;
-};
-exports.loadRelations = loadRelations;

package/dist/outputKeys.d.ts

@@ -1,2 +0,0 @@
-import { Repository } from 'typeorm';
-export declare const getOutputKeys: (repository: Repository<any>) => string[];

package/dist/outputKeys.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOutputKeys = void 0;
-const js_utils_1 = require("@goatlab/js-utils");
-const getOutputKeys = (repository) => {
-    const excludedCols = [];
-    repository.metadata.columns.forEach(c => {
-        if (!c.isSelect) {
-            excludedCols.push(c.propertyName);
-        }
-    });
-    const keys = repository.metadata.propertiesMap;
-    const flatKeys = js_utils_1.Objects.flatten(keys, true);
-    const outputKeys = Object.keys(flatKeys).filter(e => !excludedCols.includes(e));
-    return outputKeys;
-};
-exports.getOutputKeys = getOutputKeys;