@goatlab/fluent 0.6.6 → 0.6.7

package/dist/TypeOrmConnector/TypeOrmConnector.d.ts

@@ -1,6 +1,6 @@
 import { Repository } from 'typeorm';
-import { FluentConnectorInterface, BaseConnector } from '../index';
-import type { Filter, DaoOutput, BaseDataElement, PaginatedData, Paginator, Sure } from '../index';
+import { BaseConnector, FluentConnectorInterface } from '../BaseConnector';
+import type { Filter, DaoOutput, BaseDataElement, PaginatedData, Paginator, Sure } from '../types';
 export declare class GoatRepository<T> extends Repository<T> {
 }
 export declare const getRelations: (typeOrmRepo: any) => {

package/dist/TypeOrmConnector/TypeOrmConnector.js

@@ -0,0 +1,511 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeOrmConnector = exports.getRelations = exports.GoatRepository = void 0;
+const typeorm_1 = require("typeorm");
+const mongodb_1 = require("mongodb");
+const js_utils_1 = require("@goatlab/js-utils");
+const loadRelations_1 = require("../loadRelations");
+const BaseConnector_1 = require("../BaseConnector");
+const generatorDatasource_1 = require("../generatorDatasource");
+const outputKeys_1 = require("../outputKeys");
+class GoatRepository extends typeorm_1.Repository {
+}
+exports.GoatRepository = GoatRepository;
+const getRelations = typeOrmRepo => {
+    const relations = {};
+    for (const relation of typeOrmRepo.metadata.relations) {
+        relations[relation.inverseEntityMetadata.givenTableName.toLowerCase()] = {
+            isOneToMany: relation.isOneToMany,
+            isManyToOne: relation.isManyToOne,
+            isManyToMany: relation.isManyToMany,
+            inverseSidePropertyPath: relation.inverseSidePropertyPath,
+            propertyPath: relation.propertyName,
+            entityName: relation.inverseEntityMetadata.name,
+            tableName: relation.inverseEntityMetadata.tableName,
+            targetClass: relation.inverseEntityMetadata.target,
+            joinColumns: relation.joinColumns,
+            inverseJoinColumns: relation.inverseJoinColumns
+        };
+    }
+    return {
+        relations
+    };
+};
+exports.getRelations = getRelations;
+class TypeOrmConnector extends BaseConnector_1.BaseConnector {
+    constructor(entity, relationQuery, connectionName) {
+        super();
+        this.connectionName = connectionName;
+        if (!generatorDatasource_1.modelGeneratorDataSource.isInitialized) {
+            throw new Error('Fluent model generator data source is not initialized');
+        }
+        this.repository = generatorDatasource_1.modelGeneratorDataSource.getRepository(entity);
+        this.relationQuery = relationQuery;
+        const { relations } = (0, exports.getRelations)(this.repository);
+        this.modelRelations = relations;
+        this.outputKeys = (0, outputKeys_1.getOutputKeys)(this.repository) || [];
+        this.isMongoDB =
+            this.repository.metadata.connection.driver.options.type === 'mongodb';
+    }
+    async get() {
+        const query = this.getGeneratedQuery();
+        const result = await this.repository.find(query);
+        let data = this.jsApplySelect(result);
+        data = await (0, loadRelations_1.loadRelations)({
+            data,
+            relations: this.relations,
+            modelRelations: this.modelRelations,
+            connectionName: this.connectionName,
+            provider: 'typeorm',
+            self: this
+        });
+        this.reset();
+        return data;
+    }
+    async getPaginated() {
+        const response = await this.get();
+        const results = {
+            current_page: response[0].meta.currentPage,
+            data: response[0].data,
+            first_page_url: response[0].meta.firstPageUrl,
+            next_page_url: response[0].meta.nextPageUrl,
+            path: response[0].meta.path,
+            per_page: response[0].meta.itemsPerPage,
+            prev_page_url: response[0].meta.previousPageUrl,
+            total: response[0].meta.totalItemCount
+        };
+        if (results && results.data && this.selectArray.length > 0) {
+            results.data = this.jsApplySelect(results.data);
+            return results;
+        }
+        return results;
+    }
+    async all() {
+        return this.get();
+    }
+    async find(filter = {}) {
+        const stringFilter = filter;
+        let parsedFilter = {};
+        try {
+            parsedFilter = JSON.parse(stringFilter);
+        }
+        catch (error) {
+            parsedFilter = {};
+        }
+        this.selectArray = (parsedFilter && parsedFilter.fields) || [];
+        this.whereArray =
+            (parsedFilter && parsedFilter.where && parsedFilter.where.and) || [];
+        this.orWhereArray =
+            (parsedFilter && parsedFilter.where && parsedFilter.where.or) || [];
+        this.limit((parsedFilter && (parsedFilter.limit || parsedFilter.take)) || 100);
+        this.offset((parsedFilter && (parsedFilter.offset || parsedFilter.skip)) || 0);
+        if (parsedFilter && parsedFilter.order) {
+            const orderB = [
+                parsedFilter.order.field,
+                parsedFilter.order.asc ? 'asc' : 'desc',
+                parsedFilter.order.type || 'string'
+            ];
+            this.chainReference.push({ method: 'orderBy', orderB });
+            this.orderByArray = orderB;
+        }
+        return this.get();
+    }
+    async paginate(paginator) {
+        if (!paginator) {
+            throw new Error('Paginator cannot be empty');
+        }
+        this.paginator = paginator;
+        const response = await this.getPaginated();
+        return response;
+    }
+    raw() {
+        return this.repository;
+    }
+    async insert(data) {
+        const datum = await this.repository.save(data);
+        const result = this.jsApplySelect([datum]);
+        this.reset();
+        return result[0];
+    }
+    async insertMany(data) {
+        const inserted = await this.repository.save(data, {
+            chunk: data.length / 300
+        });
+        this.reset();
+        const result = this.jsApplySelect(inserted);
+        return result;
+    }
+    async updateById(id, data) {
+        const parsedId = this.isMongoDB
+            ? new mongodb_1.ObjectId(id)
+            : id;
+        const dataToInsert = this.outputKeys.includes('updated')
+            ? {
+                ...data,
+                ...{ updated: new Date() }
+            }
+            : data;
+        const updated = await this.repository.update(id, dataToInsert);
+        const dbResult = await this.repository.findBy({
+            id: (0, typeorm_1.In)([parsedId])
+        });
+        const result = this.jsApplySelect(dbResult);
+        this.reset();
+        return result[0];
+    }
+    async replaceById(id, data) {
+        const parsedId = this.isMongoDB
+            ? new mongodb_1.ObjectId(id)
+            : id;
+        const value = await this.repository.findOneOrFail({
+            where: { id: parsedId }
+        });
+        const flatValue = js_utils_1.Objects.flatten(JSON.parse(JSON.stringify(value)));
+        Object.keys(flatValue).forEach(key => {
+            flatValue[key] = null;
+        });
+        const nullObject = js_utils_1.Objects.nest(flatValue);
+        const newValue = { ...nullObject, ...data };
+        delete newValue._id;
+        delete newValue.id;
+        delete newValue.created;
+        delete newValue.updated;
+        const dataToInsert = this.outputKeys.includes('updated')
+            ? {
+                ...data,
+                ...{ updated: new Date() }
+            }
+            : data;
+        await this.repository.update(id, dataToInsert);
+        const val = await this.repository.findOneOrFail({
+            where: {
+                id: parsedId
+            }
+        });
+        const returnValue = this.jsApplySelect([val]);
+        this.reset();
+        return returnValue[0];
+    }
+    async clear({ sure }) {
+        if (!sure || sure !== true) {
+            throw new Error('Clear() method will delete everything!, you must set the "sure" parameter "clear({sure:true})" to continue');
+        }
+        return;
+        const data = await this.repository.clear();
+        this.reset();
+        return true;
+    }
+    async deleteById(id) {
+        const parsedId = this.isMongoDB
+            ? new mongodb_1.ObjectId(id)
+            : id;
+        const removed = this.repository.delete(parsedId);
+        this.reset();
+        return id;
+    }
+    async findById(id) {
+        const parsedId = this.isMongoDB
+            ? new mongodb_1.ObjectId(id)
+            : id;
+        const data = await this.repository.findBy({
+            id: (0, typeorm_1.In)([parsedId])
+        });
+        const result = this.jsApplySelect(data);
+        this.reset();
+        return result[0];
+    }
+    getPage() {
+        const page = 'page=';
+        if (this.paginator && this.paginator.page) {
+            return `${page + this.paginator.page}&`;
+        }
+        return '';
+    }
+    getPaginatorLimit(filter) {
+        if (this.paginator && this.paginator.perPage) {
+            return { ...filter, limit: this.paginator.perPage };
+        }
+        return filter;
+    }
+    getPopulate() {
+        const populate = [];
+        this.populateArray.forEach(relation => {
+            if (typeof relation === 'string') {
+                populate.push({ relation });
+            }
+            else if (Array.isArray(relation)) {
+                relation.forEach(nestedRelation => {
+                    if (typeof nestedRelation === 'string') {
+                        populate.push({ relation: nestedRelation });
+                    }
+                    else if (typeof nestedRelation === 'object') {
+                        populate.push(nestedRelation);
+                    }
+                });
+            }
+            else if (typeof relation === 'object') {
+                populate.push(relation);
+            }
+        });
+        return populate;
+    }
+    getGeneratedQuery() {
+        let filter = {};
+        filter = this.isMongoDB
+            ? this.getMongoFilters(filter)
+            : this.getFilters(filter);
+        filter = this.getLimit(filter);
+        filter = this.getSkip(filter);
+        filter = this.getSelect(filter);
+        filter = this.getOrderBy(filter);
+        filter = this.getPaginatorLimit(filter);
+        const page = this.getPage();
+        const populate = this.getPopulate();
+        if (this.rawQuery) {
+            filter.relations = populate || this.rawQuery.populate;
+            filter.take = filter.take || this.rawQuery.limit;
+            filter.skip = filter.skip || this.rawQuery.skip;
+            filter.order = filter.order || this.rawQuery.order;
+            filter.select = { ...filter.select, ...this.rawQuery.fields };
+            filter.where = { ...this.rawQuery.where };
+        }
+        return filter;
+    }
+    getFilters(filters) {
+        const andFilters = this.whereArray;
+        const orFilters = this.orWhereArray;
+        if (this.relationQuery && this.relationQuery.data) {
+            const ids = this.relationQuery.data.map(d => d.id);
+            andFilters.push([
+                this.relationQuery.relation.inverseSidePropertyPath,
+                'in',
+                ids
+            ]);
+        }
+        if (!andFilters || andFilters.length === 0) {
+            return filters;
+        }
+        const Filters = { where: [{}] };
+        andFilters.forEach(condition => {
+            const element = condition[0];
+            const operator = condition[1];
+            const value = condition[2];
+            switch (operator) {
+                case '=':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.Equal)(value) }
+                    });
+                    break;
+                case '!=':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.Not)((0, typeorm_1.Equal)(value)) }
+                    });
+                    break;
+                case '>':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.MoreThan)(value) }
+                    });
+                    break;
+                case '>=':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.MoreThanOrEqual)(value) }
+                    });
+                    break;
+                case '<':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.LessThan)(value) }
+                    });
+                    break;
+                case '<=':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.LessThanOrEqual)(value) }
+                    });
+                    break;
+                case 'in':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.In)(value) }
+                    });
+                    break;
+                case 'nin':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.Not)((0, typeorm_1.In)(value)) }
+                    });
+                    break;
+                case 'exists':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.Not)((0, typeorm_1.IsNull)()) }
+                    });
+                    break;
+                case '!exists':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.IsNull)() }
+                    });
+                    break;
+                case 'regexp':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.Like)(value) }
+                    });
+                    break;
+            }
+        });
+        orFilters.forEach(condition => {
+            const element = condition[0];
+            const operator = condition[1];
+            const value = condition[2];
+            switch (operator) {
+                case '=':
+                    Filters.where.push({ [element]: (0, typeorm_1.Equal)(value) });
+                    break;
+                case '!=':
+                    Filters.where.push({ [element]: (0, typeorm_1.Not)((0, typeorm_1.Equal)(value)) });
+                    break;
+                case '>':
+                    Filters.where.push({ [element]: (0, typeorm_1.MoreThan)(value) });
+                    break;
+                case '>=':
+                    Filters.where.push(js_utils_1.Objects.nest({ [element]: (0, typeorm_1.MoreThanOrEqual)(value) }));
+                    break;
+                case '<':
+                    Filters.where.push({ [element]: (0, typeorm_1.LessThan)(value) });
+                    break;
+                case '<=':
+                    Filters.where.push({ [element]: (0, typeorm_1.LessThanOrEqual)(value) });
+                    break;
+                case 'in':
+                    Filters.where.push({ [element]: (0, typeorm_1.In)(value) });
+                    break;
+                case 'nin':
+                    Filters.where.push({ [element]: (0, typeorm_1.Not)((0, typeorm_1.In)(value)) });
+                    break;
+                case 'exists':
+                    Filters.where.push({ [element]: (0, typeorm_1.Not)((0, typeorm_1.IsNull)()) });
+                    break;
+                case '!exists':
+                    Filters.where.push({ [element]: (0, typeorm_1.IsNull)() });
+                    break;
+                case 'regexp':
+                    Filters.where.push({ [element]: (0, typeorm_1.Like)(value) });
+                    break;
+            }
+        });
+        return Filters;
+    }
+    getMongoFilters(filters) {
+        const andFilters = this.whereArray;
+        const orFilters = this.orWhereArray;
+        if (this.relationQuery && this.relationQuery.data) {
+            const ids = this.relationQuery.data.map(d => js_utils_1.Ids.objectID(d.id));
+            andFilters.push([
+                this.relationQuery.relation.inverseSidePropertyPath,
+                'in',
+                ids
+            ]);
+        }
+        if (!andFilters || andFilters.length === 0) {
+            return filters;
+        }
+        const Filters = { where: { $and: [] } };
+        andFilters.forEach(condition => {
+            let element = condition[0];
+            const operator = condition[1];
+            let value = condition[2];
+            if (element === 'id') {
+                element = '_id';
+                value = Array.isArray(value)
+                    ? value.map(v => js_utils_1.Ids.objectID(v))
+                    : js_utils_1.Ids.objectID(value);
+            }
+            switch (operator) {
+                case '=':
+                    Filters.where.$and.push({ [element]: { $eq: value } });
+                    break;
+                case '!=':
+                    Filters.where.$and.push({ [element]: { $neq: value } });
+                    break;
+                case '>':
+                    Filters.where.$and.push({ [element]: { $gt: value } });
+                    break;
+                case '>=':
+                    Filters.where.$and.push({ [element]: { $gte: value } });
+                    break;
+                case '<':
+                    Filters.where.$and.push({ [element]: { $lt: value } });
+                    break;
+                case '<=':
+                    Filters.where.$and.push({ [element]: { $lte: value } });
+                    break;
+                case 'in':
+                    Filters.where.$and.push({ [element]: { $in: value } });
+                    break;
+                case 'nin':
+                    Filters.where.$and.push({
+                        [element]: { $not: { $in: value } }
+                    });
+                    break;
+                case 'exists':
+                    Filters.where.$and.push({ [element]: { $exists: true } });
+                    break;
+                case '!exists':
+                    Filters.where.$and.push({ [element]: { $exists: false } });
+                    break;
+                case 'regex':
+                    Filters.where.$and.push({ [element]: { $regex: value } });
+                    break;
+            }
+        });
+        return Filters;
+    }
+    getOrderBy(filter) {
+        if (!this.orderByArray || this.orderByArray.length === 0) {
+            return filter;
+        }
+        return {
+            ...filter,
+            order: {
+                [this.orderByArray[0]]: this.orderByArray[1].toUpperCase()
+            }
+        };
+    }
+    getLimit(filter) {
+        if (!this.limitNumber || this.limitNumber === 0) {
+            this.limitNumber = (this.rawQuery && this.rawQuery.limit) || 50;
+        }
+        return { ...filter, take: this.limitNumber };
+    }
+    getSkip(filter) {
+        if (!this.offsetNumber) {
+            this.offsetNumber = (this.rawQuery && this.rawQuery.skip) || 0;
+        }
+        return { ...filter, skip: this.offsetNumber };
+    }
+    getSelect(filter) {
+        let select = this.selectArray;
+        if (Object.keys(select).length === 0 && select.constructor === Object) {
+            select = [''];
+        }
+        select = select.map(s => {
+            s = s.split(' as ')[0];
+            s = s.includes('id') ? 'id' : s;
+            return s;
+        });
+        if (select.find(e => e.startsWith('data.'))) {
+            select.unshift('data');
+        }
+        if (!select) {
+            return filter;
+        }
+        return { ...filter, fields: select };
+    }
+}
+exports.TypeOrmConnector = TypeOrmConnector;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goatlab/fluent",
-  "version": "0.6.6",
+  "version": "0.6.7",
   "description": "Readable query Interface & API generator for TS and Node",
   "scripts": {
     "prebuild": "rimraf dist",

package/dist/core/dtos/pagination.dto.d.ts

@@ -1,13 +0,0 @@
-export declare class PaginationMeta {
-    itemCount: number;
-    totalItems: number;
-    itemsPerPage: number;
-    totalPages: number;
-    currentPage: number;
-}
-export declare class PaginationLinks {
-    first?: string;
-    previous?: string;
-    next?: string;
-    last?: string;
-}

package/dist/core/dtos/pagination.dto.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PaginationLinks = exports.PaginationMeta = void 0;
-const tslib_1 = require("tslib");
-const types_1 = require("../types");
-let PaginationMeta = class PaginationMeta {
-};
-tslib_1.__decorate([
-    (0, types_1.Column)('number'),
-    (0, types_1.ApiProperty)(),
-    tslib_1.__metadata("design:type", Number)
-], PaginationMeta.prototype, "itemCount", void 0);
-tslib_1.__decorate([
-    (0, types_1.Column)('number'),
-    (0, types_1.ApiProperty)(),
-    tslib_1.__metadata("design:type", Number)
-], PaginationMeta.prototype, "totalItems", void 0);
-tslib_1.__decorate([
-    (0, types_1.Column)('number'),
-    (0, types_1.ApiProperty)(),
-    tslib_1.__metadata("design:type", Number)
-], PaginationMeta.prototype, "itemsPerPage", void 0);
-tslib_1.__decorate([
-    (0, types_1.Column)('number'),
-    (0, types_1.ApiProperty)(),
-    tslib_1.__metadata("design:type", Number)
-], PaginationMeta.prototype, "totalPages", void 0);
-tslib_1.__decorate([
-    (0, types_1.Column)('number'),
-    (0, types_1.ApiProperty)(),
-    tslib_1.__metadata("design:type", Number)
-], PaginationMeta.prototype, "currentPage", void 0);
-PaginationMeta = tslib_1.__decorate([
-    (0, types_1.InputType)()
-], PaginationMeta);
-exports.PaginationMeta = PaginationMeta;
-let PaginationLinks = class PaginationLinks {
-};
-tslib_1.__decorate([
-    (0, types_1.Column)('text'),
-    (0, types_1.ApiProperty)(),
-    tslib_1.__metadata("design:type", String)
-], PaginationLinks.prototype, "first", void 0);
-tslib_1.__decorate([
-    (0, types_1.Column)('text'),
-    (0, types_1.ApiProperty)(),
-    tslib_1.__metadata("design:type", String)
-], PaginationLinks.prototype, "previous", void 0);
-tslib_1.__decorate([
-    (0, types_1.Column)('text'),
-    (0, types_1.ApiProperty)(),
-    tslib_1.__metadata("design:type", String)
-], PaginationLinks.prototype, "next", void 0);
-tslib_1.__decorate([
-    (0, types_1.Column)('text'),
-    (0, types_1.ApiProperty)(),
-    tslib_1.__metadata("design:type", String)
-], PaginationLinks.prototype, "last", void 0);
-PaginationLinks = tslib_1.__decorate([
-    (0, types_1.InputType)()
-], PaginationLinks);
-exports.PaginationLinks = PaginationLinks;

package/dist/index.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PaginationMeta = exports.PaginationLinks = exports.loadRelations = exports.TypeOrmConnector = exports.HideField = exports.ObjectType = exports.getModelSchemaRef = exports.Column = exports.PartialType = exports.InputType = exports.OmitType = exports.ApiHideProperty = exports.ApiProperty = exports.modelGeneratorDataSource = exports.getOutputKeys = exports.Fluent = exports.Decorators = exports.createConnection = exports.Collection = exports.BaseConnector = void 0;
-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 Fluent_1 = require("./Fluent");
-Object.defineProperty(exports, "Fluent", { enumerable: true, get: function () { return Fluent_1.Fluent; } });
-const generatorDatasource_1 = require("./generatorDatasource");
-Object.defineProperty(exports, "modelGeneratorDataSource", { enumerable: true, get: function () { return generatorDatasource_1.modelGeneratorDataSource; } });
-const outputKeys_1 = require("./outputKeys");
-Object.defineProperty(exports, "getOutputKeys", { enumerable: true, get: function () { return outputKeys_1.getOutputKeys; } });
-const decorators_1 = require("./core/database/decorators");
-Object.defineProperty(exports, "Decorators", { enumerable: true, get: function () { return decorators_1.Decorators; } });
-const types_1 = require("./core/types");
-Object.defineProperty(exports, "ApiProperty", { enumerable: true, get: function () { return types_1.ApiProperty; } });
-Object.defineProperty(exports, "ApiHideProperty", { enumerable: true, get: function () { return types_1.ApiHideProperty; } });
-Object.defineProperty(exports, "OmitType", { enumerable: true, get: function () { return types_1.OmitType; } });
-Object.defineProperty(exports, "InputType", { enumerable: true, get: function () { return types_1.InputType; } });
-Object.defineProperty(exports, "PartialType", { enumerable: true, get: function () { return types_1.PartialType; } });
-Object.defineProperty(exports, "Column", { enumerable: true, get: function () { return types_1.Column; } });
-Object.defineProperty(exports, "getModelSchemaRef", { enumerable: true, get: function () { return types_1.getModelSchemaRef; } });
-Object.defineProperty(exports, "ObjectType", { enumerable: true, get: function () { return types_1.ObjectType; } });
-Object.defineProperty(exports, "HideField", { enumerable: true, get: function () { return types_1.HideField; } });
-const createConnection_1 = require("./core/database/createConnection");
-Object.defineProperty(exports, "createConnection", { enumerable: true, get: function () { return createConnection_1.createConnection; } });
-const TypeOrmConnector_1 = require("./TypeOrmConnector/TypeOrmConnector");
-Object.defineProperty(exports, "TypeOrmConnector", { enumerable: true, get: function () { return TypeOrmConnector_1.TypeOrmConnector; } });
-const loadRelations_1 = require("./loadRelations");
-Object.defineProperty(exports, "loadRelations", { enumerable: true, get: function () { return loadRelations_1.loadRelations; } });
-const pagination_dto_1 = require("./core/dtos/pagination.dto");
-Object.defineProperty(exports, "PaginationLinks", { enumerable: true, get: function () { return pagination_dto_1.PaginationLinks; } });
-Object.defineProperty(exports, "PaginationMeta", { enumerable: true, get: function () { return pagination_dto_1.PaginationMeta; } });