@goatlab/fluent 0.7.6 → 0.7.11

package/dist/TypeOrmConnector/queryBuilder/sql/getTypeOrmWhere.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeOrmWhere = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+const typeorm_1 = require("typeorm");
+const clearEmpties_1 = require("../..//util/clearEmpties");
+const types_1 = require("../../../types");
+const extractConditions_1 = require("../../util/extractConditions");
+const getTypeOrmWhere = ({ where }) => {
+    if (!where || Object.keys(where).length === 0) {
+        return {};
+    }
+    const Filters = { where: [{}] };
+    const orConditions = (0, extractConditions_1.extractConditions)(where['OR']);
+    const andConditions = (0, extractConditions_1.extractConditions)(where['AND']);
+    const copy = js_utils_1.Objects.clone(where);
+    if (!!copy['AND']) {
+        delete copy['AND'];
+    }
+    if (!!copy['OR']) {
+        delete copy['OR'];
+    }
+    const rootLevelConditions = (0, extractConditions_1.extractConditions)([copy]);
+    for (const condition of andConditions) {
+        const { element, operator, value } = condition;
+        switch (operator) {
+            case types_1.LogicOperator.equals:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.Equal)(value) }
+                });
+                break;
+            case types_1.LogicOperator.isNot:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.Not)((0, typeorm_1.Equal)(value)) }
+                });
+                break;
+            case types_1.LogicOperator.greaterThan:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.MoreThan)(value) }
+                });
+                break;
+            case types_1.LogicOperator.greaterOrEqualThan:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.MoreThanOrEqual)(value) }
+                });
+                break;
+            case types_1.LogicOperator.lessThan:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.LessThan)(value) }
+                });
+                break;
+            case types_1.LogicOperator.lessOrEqualThan:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.LessThanOrEqual)(value) }
+                });
+                break;
+            case types_1.LogicOperator.in:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.In)(value) }
+                });
+                break;
+            case types_1.LogicOperator.notIn:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.Not)((0, typeorm_1.In)(value)) }
+                });
+                break;
+            case types_1.LogicOperator.exists:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.Not)((0, typeorm_1.IsNull)()) }
+                });
+                break;
+            case types_1.LogicOperator.notExists:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.IsNull)() }
+                });
+                break;
+            case types_1.LogicOperator.regexp:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.Like)(value) }
+                });
+                break;
+        }
+    }
+    for (const condition of rootLevelConditions) {
+        const { element, operator, value } = condition;
+        switch (operator) {
+            case types_1.LogicOperator.equals:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.Equal)(value) }
+                });
+                break;
+            case types_1.LogicOperator.isNot:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.Not)((0, typeorm_1.Equal)(value)) }
+                });
+                break;
+            case types_1.LogicOperator.greaterThan:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.MoreThan)(value) }
+                });
+                break;
+            case types_1.LogicOperator.greaterOrEqualThan:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.MoreThanOrEqual)(value) }
+                });
+                break;
+            case types_1.LogicOperator.lessThan:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.LessThan)(value) }
+                });
+                break;
+            case types_1.LogicOperator.lessOrEqualThan:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.LessThanOrEqual)(value) }
+                });
+                break;
+            case types_1.LogicOperator.in:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.In)(value) }
+                });
+                break;
+            case types_1.LogicOperator.notIn:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.Not)((0, typeorm_1.In)(value)) }
+                });
+                break;
+            case types_1.LogicOperator.exists:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.Not)((0, typeorm_1.IsNull)()) }
+                });
+                break;
+            case types_1.LogicOperator.notExists:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.IsNull)() }
+                });
+                break;
+            case types_1.LogicOperator.regexp:
+                Filters.where[0] = js_utils_1.Objects.nest({
+                    ...Filters.where[0],
+                    ...{ [element]: (0, typeorm_1.Like)(value) }
+                });
+                break;
+        }
+    }
+    for (const condition of orConditions) {
+        const { element, operator, value } = condition;
+        switch (operator) {
+            case types_1.LogicOperator.equals:
+                Filters.where.push({ [element]: (0, typeorm_1.Equal)(value) });
+                break;
+            case types_1.LogicOperator.isNot:
+                Filters.where.push({ [element]: (0, typeorm_1.Not)((0, typeorm_1.Equal)(value)) });
+                break;
+            case types_1.LogicOperator.greaterThan:
+                Filters.where.push({ [element]: (0, typeorm_1.MoreThan)(value) });
+                break;
+            case types_1.LogicOperator.greaterOrEqualThan:
+                Filters.where.push({ [element]: (0, typeorm_1.MoreThanOrEqual)(value) });
+                break;
+            case types_1.LogicOperator.lessThan:
+                Filters.where.push({ [element]: (0, typeorm_1.LessThan)(value) });
+                break;
+            case types_1.LogicOperator.lessOrEqualThan:
+                Filters.where.push({ [element]: (0, typeorm_1.LessThanOrEqual)(value) });
+                break;
+            case types_1.LogicOperator.in:
+                Filters.where.push({ [element]: (0, typeorm_1.In)(value) });
+                break;
+            case types_1.LogicOperator.notIn:
+                Filters.where.push({ [element]: (0, typeorm_1.Not)((0, typeorm_1.In)(value)) });
+                break;
+            case types_1.LogicOperator.exists:
+                Filters.where.push({ [element]: (0, typeorm_1.Not)((0, typeorm_1.IsNull)()) });
+                break;
+            case types_1.LogicOperator.notExists:
+                Filters.where.push({ [element]: (0, typeorm_1.IsNull)() });
+                break;
+            case types_1.LogicOperator.regexp:
+                Filters.where.push({ [element]: (0, typeorm_1.Like)(value) });
+                break;
+        }
+    }
+    const filtered = (0, clearEmpties_1.clearEmpties)(Filters.where);
+    return filtered;
+};
+exports.getTypeOrmWhere = getTypeOrmWhere;

package/dist/TypeOrmConnector/test/basic/basicTestSuite.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.basicTestSuite = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
 const flock_1 = require("../flock");
 const basicTestSuite = Repo => {
     let storedId;
@@ -8,6 +9,35 @@ const basicTestSuite = Repo => {
     beforeAll(() => {
         Repository = new Repo();
     });
+    test('insert - Should  insert data', async () => {
+        const a = await Repository.insert({ name: 'myGoat', age: 13 });
+        expect(typeof a.id).toBe('string');
+        expect(a.name).toBe('myGoat');
+        expect(0).toBe(0);
+    });
+    it('insertMany - Should insert Multiple elements', async () => {
+        const insertedFlock = await Repository.insertMany(flock_1.flock);
+        expect(insertedFlock[0].name).toBe('Goatee');
+        storedId = insertedFlock[0].id;
+    });
+    test('findById - Should  GET an object by its ID', async () => {
+        const goats = await Repository.insertMany(flock_1.flock);
+        const goat = await Repository.findById(goats[0].id);
+        expect(goat?.id).toBe(goats[0].id);
+        expect(typeof goat?.id).toBe('string');
+        const anotherGoat = await Repository.findById('507f1f77bcf86cd799439011');
+        expect(anotherGoat).toBe(null);
+    });
+    test('findById - Should  GET selected Data', async () => {
+        const goats = await Repository.insertMany(flock_1.flock);
+        const goat = await Repository.findById(goats[0].id, {
+            select: {
+                age: true
+            }
+        });
+        expect(goat).not.toHaveProperty('name');
+        expect(goat?.age).toBe(goats[0].age);
+    });
     test('findByIds - Should  GET data', async () => {
         const goats = await Repository.insertMany(flock_1.flock);
         const ids = [goats[0].id, goats[1].id];
@@ -15,5 +45,139 @@ const basicTestSuite = Repo => {
         expect(selectedGoats.length).toBe(2);
         expect(selectedGoats[0].id === ids[0] || selectedGoats[1].id === ids[0]).toBe(true);
     });
+    test('findByIds - Should  GET selectedData', async () => {
+        const goats = await Repository.insertMany(flock_1.flock);
+        const ids = [goats[0].id, goats[1].id];
+        const ages = [goats[0].age, goats[1].age];
+        const selectedGoats = await Repository.findByIds(ids, {
+            select: {
+                age: true
+            }
+        });
+        expect(selectedGoats.length).toBe(2);
+        expect(selectedGoats[0].age === ages[0] || selectedGoats[1].age === ages[0]).toBe(true);
+        expect(selectedGoats[0]).not.toHaveProperty('name');
+    });
+    test('findMany - Should  GET data', async () => {
+        await Repository.insertMany(flock_1.flock);
+        const storedGoats = await Repository.findMany();
+        expect(Array.isArray(storedGoats)).toBe(true);
+        expect(typeof storedGoats[0].id).toBe('string');
+    });
+    test('findMany - Should  FILTER data', async () => {
+        await Repository.insertMany(flock_1.flock);
+        const storedGoats = await Repository.findMany({
+            where: {
+                name: 'Goatee'
+            }
+        });
+        expect(Array.isArray(storedGoats)).toBe(true);
+        for (const goat of storedGoats) {
+            expect(goat.name).toBe('Goatee');
+        }
+        expect(typeof storedGoats[0].id).toBe('string');
+    });
+    test('findMany - Should  FILTER not existing data', async () => {
+        await Repository.insertMany(flock_1.flock);
+        const storedGoats = await Repository.findMany({
+            where: {
+                name: 'SOMENOTEXISTINGGOAT'
+            }
+        });
+        expect(Array.isArray(storedGoats)).toBe(true);
+        expect(storedGoats.length).toBe(0);
+    });
+    test('findMany - Should  SELECT attributes', async () => {
+        await Repository.insertMany(flock_1.flock);
+        const storedGoats = await Repository.findMany({
+            where: {
+                name: 'Goatee'
+            },
+            select: {
+                age: true
+            }
+        });
+        expect(Array.isArray(storedGoats)).toBe(true);
+        expect(storedGoats.length > 0).toBe(true);
+        expect(storedGoats[0]).not.toHaveProperty('name');
+    });
+    test('findFirst - Should  get only 1 object back', async () => {
+        await Repository.insertMany(flock_1.flock);
+        const storedGoats = await Repository.findFirst({
+            where: {
+                name: 'Goatee'
+            }
+        });
+        expect(Array.isArray(storedGoats)).toBe(false);
+        expect(typeof storedGoats.id).toBe('string');
+    });
+    test('findFirst - Should  FILTER AND SELECT DATA', async () => {
+        await Repository.insertMany(flock_1.flock);
+        const storedGoats = await Repository.findFirst({
+            where: {
+                name: 'Goatee'
+            },
+            select: {
+                name: true
+            }
+        });
+        expect(Array.isArray(storedGoats)).toBe(false);
+        expect(storedGoats.name).toBe('Goatee');
+        expect(storedGoats).not.toHaveProperty('age');
+    });
+    test('requireFirst - Should fail if not found', async () => {
+        const insertedUser = await Repository.insert({
+            name: 'testGoat',
+            age: 20
+        });
+        const [error] = await js_utils_1.Promises.try(Repository.requireFirst({
+            where: {
+                name: 'noneExistingGoat'
+            }
+        }));
+        expect(error?.message).toBe('No objects found matching:  {"where":{"name":"noneExistingGoat"}}');
+    });
+    test('requireFirst - Should find first item', async () => {
+        const insertedUser = await Repository.insert({
+            name: 'testGoat',
+            age: 20
+        });
+        const [error, goat] = await js_utils_1.Promises.try(Repository.requireFirst({
+            where: {
+                name: 'testGoat'
+            }
+        }));
+        expect(error).toBe(null);
+        expect(goat.name).toBe(insertedUser.name);
+    });
+    it('UpdateById - Should Update a single element', async () => {
+        await Repository.insertMany(flock_1.flock);
+        const goats = await Repository.findMany();
+        const data = await Repository.updateById(goats[0].id, {
+            age: 99,
+            name: 'MyUpdatedGoat'
+        });
+        expect(data.name).toBe('MyUpdatedGoat');
+        expect(data.id).toBe(goats[0].id);
+    });
+    it('ReplaceById - Should Update a single element', async () => {
+        await Repository.insertMany(flock_1.flock);
+        const goats = await Repository.findMany();
+        const data = await Repository.replaceById(goats[0].id, {
+            age: 2,
+            name: 'MyReplacedGoat'
+        });
+        expect(data.name).toBe('MyReplacedGoat');
+        expect(data.id).toBe(goats[0].id);
+    });
+    it('deleteById - Should delete an item', async () => {
+        await Repository.insertMany(flock_1.flock);
+        const goats = await Repository.findMany();
+        const foundGoat = await Repository.requireById(goats[0].id);
+        expect(foundGoat.id).toBe(goats[0].id);
+        await Repository.deleteById(foundGoat.id);
+        const [error] = await js_utils_1.Promises.try(Repository.requireById(goats[0].id));
+        expect(error?.message).toBe(`Object ${goats[0].id} not found`);
+    });
 };
 exports.basicTestSuite = basicTestSuite;

package/dist/TypeOrmConnector/test/basic/goat.entity.d.ts

@@ -21,7 +21,7 @@ export declare const BreedSchema: z.ZodObject<{
 }>;
 export declare const GoatSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
-    name: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
     age: z.ZodNumber;
     breed: z.ZodOptional<z.ZodObject<{
         family: z.ZodString;
@@ -35,19 +35,19 @@ export declare const GoatSchema: z.ZodObject<{
     }>>;
 }, "strip", z.ZodTypeAny, {
     id?: string | undefined;
+    name?: string | undefined;
     breed?: {
         family: string;
         members: number;
     } | undefined;
-    name: string;
     age: number;
 }, {
     id?: string | undefined;
+    name?: string | undefined;
     breed?: {
         family: string;
         members: number;
     } | undefined;
-    name: string;
     age: number;
 }>;
 export declare type GoatInputSchema = z.infer<typeof GoatSchema>;

package/dist/TypeOrmConnector/test/basic/goat.entity.js

@@ -47,7 +47,7 @@ exports.BreedSchema = zod_1.z.object({
 });
 exports.GoatSchema = zod_1.z.object({
     id: zod_1.z.string().optional(),
-    name: zod_1.z.string(),
+    name: zod_1.z.string().optional(),
     age: zod_1.z.number(),
     breed: exports.BreedSchema.optional()
 });

package/dist/TypeOrmConnector/test/docker/docker.d.ts

@@ -31,5 +31,5 @@ export declare function killOldContainers(options: Pick<NormalizedOptions, 'debu
 export default function startContainer(options: Options): Promise<{
     proc: any;
     externalPort: number;
-    kill(): Promise<void>;
+    kill: () => Promise<void>;
 }>;

package/dist/TypeOrmConnector/test/docker/docker.js

@@ -57,8 +57,7 @@ function startDockerContainer(options) {
         `${options.externalPort}:${options.internalPort}`,
         ...(options.detached ? ['--detach'] : []),
         ...envArgs,
-        options.image,
-        '--default_authentication_plugin=mysql_native_password'
+        options.image
     ], {
         stdio: options.debug ? 'inherit' : 'ignore'
     });
@@ -141,8 +140,8 @@ async function startContainer(options) {
     return {
         proc,
         externalPort,
-        async kill() {
-            await killOldContainers(options);
+        kill: async () => {
+            return await killOldContainers(options);
         }
     };
 }

package/dist/TypeOrmConnector/test/docker/mongo.d.ts

@@ -0,0 +1,16 @@
+import { Options as WithContainerOptions } from './docker';
+export interface Options extends Omit<WithContainerOptions, 'internalPort' | 'enableDebugInstructions' | 'testConnection'> {
+    mongoUser: string;
+    mongoPassword: string;
+    mongoDb: string;
+}
+export declare function waitForConnection(databaseURL: string, timeoutSeconds: number): Promise<void>;
+export default function getDatabase(options?: Partial<Options>): Promise<{
+    proc: any;
+    databaseURL: string;
+    kill: () => Promise<void>;
+    user: string;
+    password: string;
+    port: number;
+    dbName: string;
+}>;

package/dist/TypeOrmConnector/test/docker/mongo.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForConnection = void 0;
+const tslib_1 = require("tslib");
+const docker_1 = tslib_1.__importDefault(require("./docker"));
+const mongodb_1 = require("mongodb");
+const DEFAULT_IMAGE = 'mongo:6.0.1';
+const DEFAULT_CONTAINER_NAME = `fluent-${DEFAULT_IMAGE.replace(':', '-')}-test`;
+const DEFAULT_CONNECT_TIMEOUT_SECONDS = 10;
+const DEFAULT_MONGO_PORT = 27017;
+const DEFAULT_MONGO_USER = 'test-user';
+const DEFAULT_MONGO_PASSWORD = 'password';
+const DEFAULT_MONGO_DB = 'test-db';
+const DEFAULT_MONGO_DEBUG = false;
+async function waitForConnection(databaseURL, timeoutSeconds) {
+    const start = Date.now();
+    const timeoutMilliseconds = timeoutSeconds * 1000;
+    let lastAttempt = false;
+    while (true) {
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        const conn = new mongodb_1.MongoClient(databaseURL);
+        try {
+            try {
+                await conn.connect();
+                const db = conn.db('anyDB');
+                const result = await db.command({
+                    ping: 1
+                });
+                if (result.ok) {
+                    break;
+                }
+                else {
+                    if (lastAttempt) {
+                        throw new Error('Got unexpected result: ' + JSON.stringify(result));
+                    }
+                }
+            }
+            catch (ex) {
+                console.log(ex);
+                if (lastAttempt) {
+                    throw ex;
+                }
+            }
+        }
+        finally {
+            await conn.close();
+        }
+        if (Date.now() - timeoutMilliseconds > start) {
+            lastAttempt = true;
+        }
+    }
+}
+exports.waitForConnection = waitForConnection;
+async function getDatabase(options = {}) {
+    const { mongoUser, mongoPassword, mongoDb, environment, ...rawOptions } = {
+        debug: DEFAULT_MONGO_DEBUG,
+        image: DEFAULT_IMAGE,
+        containerName: DEFAULT_CONTAINER_NAME,
+        connectTimeoutSeconds: DEFAULT_CONNECT_TIMEOUT_SECONDS,
+        mongoUser: DEFAULT_MONGO_USER,
+        mongoPassword: DEFAULT_MONGO_PASSWORD,
+        mongoDb: DEFAULT_MONGO_DB,
+        defaultExternalPort: DEFAULT_MONGO_PORT,
+        ...options
+    };
+    const { proc, externalPort, kill } = await (0, docker_1.default)({
+        ...rawOptions,
+        internalPort: DEFAULT_MONGO_PORT,
+        environment: {
+            MONGO_HOST: '127.0.0.1',
+            ...environment,
+            MONGO_INITDB_ROOT_USERNAME: mongoUser,
+            MONGO_INITDB_ROOT_PASSWORD: mongoPassword,
+            MONGO_DB_USER: mongoUser,
+            MONGO_DB_PASSWORD: mongoPassword,
+            MONGO_PASSWORD: mongoPassword,
+            MONGO_INITDB_DATABASE: mongoDb
+        },
+        enableDebugInstructions: `To view logs, run with MONGO_TEST_DEBUG=true environment variable.`
+    });
+    const databaseURL = `mongodb://${mongoUser}:${mongoPassword}@localhost:${externalPort}`;
+    await waitForConnection(databaseURL, rawOptions.connectTimeoutSeconds);
+    return {
+        proc,
+        databaseURL,
+        kill,
+        user: mongoUser,
+        password: mongoPassword,
+        port: externalPort,
+        dbName: mongoDb
+    };
+}
+exports.default = getDatabase;

package/dist/TypeOrmConnector/test/docker/mysql.js

@@ -5,7 +5,7 @@ const tslib_1 = require("tslib");
 const docker_1 = tslib_1.__importStar(require("./docker"));
 const { createConnection } = require('mysql2');
 const DEFAULT_IMAGE = 'mysql:8.0';
-const DEFAULT_CONTAINER_NAME = 'fluent-mysql-test';
+const DEFAULT_CONTAINER_NAME = `fluent-${DEFAULT_IMAGE.replace(':', '-')}-test`;
 const DEFAULT_CONNECT_TIMEOUT_SECONDS = 10;
 const DEFAULT_MYSQL_PORT = 3306;
 const DEFAULT_MYSQL_USER = 'test-user';

package/dist/TypeOrmConnector/test/mongo/car.mongo.repository.d.ts

@@ -1,8 +1,10 @@
 import { TypeOrmConnector } from '../../TypeOrmConnector';
 import { CarsEntity } from '../relations/car/car.entity';
-import { CarsEntityInputSchema } from '../relations/car/car.schema';
+import { CarDtoOutput } from '../relations/car/car.output.schema';
+import { CarDtoInput } from '../relations/car/car.schema';
 import { UserRepository } from './user.mongo.repository';
-export declare class CarsRepository extends TypeOrmConnector<CarsEntity, CarsEntityInputSchema> {
+export declare class CarsRepository extends TypeOrmConnector<CarsEntity, CarDtoInput, CarDtoOutput> {
     constructor();
     user: () => UserRepository;
+    anotherRelation: () => UserRepository;
 }

package/dist/TypeOrmConnector/test/mongo/car.mongo.repository.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CarsRepository = void 0;
 const TypeOrmConnector_1 = require("../../TypeOrmConnector");
 const car_entity_1 = require("../relations/car/car.entity");
+const car_output_schema_1 = require("../relations/car/car.output.schema");
 const car_schema_1 = require("../relations/car/car.schema");
 const user_entity_1 = require("../relations/user/user.entity");
 const mongoDatasource_1 = require("./mongoDatasource");
@@ -12,12 +13,16 @@ class CarsRepository extends TypeOrmConnector_1.TypeOrmConnector {
         super({
             entity: car_entity_1.CarsEntity,
             dataSource: mongoDatasource_1.MongoDataSource,
-            inputSchema: car_schema_1.CarsEntitySchema
+            inputSchema: car_schema_1.carInputSchema,
+            outputSchema: car_output_schema_1.carOutputSchema
         });
         this.user = () => this.belongsTo({
             repository: user_mongo_repository_1.UserRepository,
             model: user_entity_1.UsersEntity
         });
+        this.anotherRelation = () => this.belongsTo({
+            repository: user_mongo_repository_1.UserRepository
+        });
     }
 }
 exports.CarsRepository = CarsRepository;

package/dist/TypeOrmConnector/test/mongo/roles.mongo.repository.d.ts

@@ -1,8 +1,9 @@
 import { TypeOrmConnector } from '../../TypeOrmConnector';
-import { RoleEntityInputSchema } from '../relations/roles/role.schema';
+import { RoleDtoInput } from '../relations/roles/role.schema';
 import { RoleEntity } from '../relations/roles/roles.entity';
 import { UserRepository } from './user.mongo.repository';
-export declare class RoleRepository extends TypeOrmConnector<RoleEntity, RoleEntityInputSchema> {
+import { RoleDtoOut } from '../relations/roles/role.output.schema';
+export declare class RoleRepository extends TypeOrmConnector<RoleEntity, RoleDtoInput, RoleDtoOut> {
     constructor();
     users: () => UserRepository;
 }

package/dist/TypeOrmConnector/test/mongo/roles.mongo.repository.js

@@ -7,12 +7,14 @@ const roles_user_mongo_repository_1 = require("./roles_user.mongo.repository");
 const roles_entity_1 = require("../relations/roles/roles.entity");
 const mongoDatasource_1 = require("./mongoDatasource");
 const user_mongo_repository_1 = require("./user.mongo.repository");
+const role_output_schema_1 = require("../relations/roles/role.output.schema");
 class RoleRepository extends TypeOrmConnector_1.TypeOrmConnector {
     constructor() {
         super({
             entity: roles_entity_1.RoleEntity,
             dataSource: mongoDatasource_1.MongoDataSource,
-            inputSchema: role_schema_1.RoleEntitySchema
+            inputSchema: role_schema_1.RoleInputSchema,
+            outputSchema: role_output_schema_1.RoleOuputSchema
         });
         this.users = () => this.belongsToMany({
             repository: user_mongo_repository_1.UserRepository,

package/dist/TypeOrmConnector/test/mongo/user.mongo.repository.d.ts

@@ -1,9 +1,9 @@
 import { TypeOrmConnector } from '../../TypeOrmConnector';
 import { UsersEntity } from '../relations/user/user.entity';
-import { UsersEntityInputSchema } from '../relations/user/user.schema';
+import { UsersDtoIn, UsersDtoOut } from '../relations/user/user.schema';
 import { CarsRepository } from './car.mongo.repository';
 import { RoleRepository } from './roles.mongo.repository';
-export declare class UserRepository extends TypeOrmConnector<UsersEntity, UsersEntityInputSchema> {
+export declare class UserRepository extends TypeOrmConnector<UsersEntity, UsersDtoIn, UsersDtoOut> {
     constructor();
     cars: () => CarsRepository;
     roles: () => RoleRepository;

package/dist/TypeOrmConnector/test/mongo/user.mongo.repository.js

@@ -14,7 +14,8 @@ class UserRepository extends TypeOrmConnector_1.TypeOrmConnector {
         super({
             entity: user_entity_1.UsersEntity,
             dataSource: mongoDatasource_1.MongoDataSource,
-            inputSchema: user_schema_1.UsersEntitySchema
+            inputSchema: user_schema_1.userInputSchema,
+            outputSchema: user_schema_1.userOutputSchema
         });
         this.cars = () => {
             return this.hasMany({