@goatlab/fluent 0.7.21 → 0.7.22

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

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

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

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

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

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

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

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

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

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

package/dist/generatorDatasource.js

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

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

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

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

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

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

package/dist/outputKeys.js

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