@goatlab/fluent 0.7.6 → 0.7.9

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

@@ -0,0 +1,183 @@
+"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;
+    let Repository;
+    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];
+        const selectedGoats = await Repository.findByIds(ids);
+        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 → fluent/src/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 → fluent/src/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 → fluent/src/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 → fluent/src/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/fluent/src/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/fluent/src/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 → fluent/src/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 → fluent/src/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 → fluent/src/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 → fluent/src/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 → fluent/src/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 → fluent/src/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 → fluent/src/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({

package/dist/fluent/src/TypeOrmConnector/test/mysql/car.mysql.repository.d.ts

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

package/dist/{TypeOrmConnector → fluent/src/TypeOrmConnector}/test/mysql/car.mysql.repository.js

@@ -3,14 +3,23 @@ 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 mysqlDataSource_1 = require("./mysqlDataSource");
+const user_mysql_repository_1 = require("./user.mysql.repository");
 class CarsRepository extends TypeOrmConnector_1.TypeOrmConnector {
     constructor() {
         super({
             entity: car_entity_1.CarsEntity,
             dataSource: mysqlDataSource_1.MYSQLDataSource,
-            inputSchema: car_schema_1.CarsEntitySchema
+            inputSchema: car_schema_1.carInputSchema,
+            outputSchema: car_output_schema_1.carOutputSchema
+        });
+        this.user = () => this.belongsTo({
+            repository: user_mysql_repository_1.UserRepository
+        });
+        this.anotherRelation = () => this.belongsTo({
+            repository: user_mysql_repository_1.UserRepository
         });
     }
 }

package/dist/{TypeOrmConnector → fluent/src/TypeOrmConnector}/test/mysql/mysqlDataSource.js

@@ -9,7 +9,7 @@ exports.MYSQLDataSource = new typeorm_1.DataSource({
     username: 'root',
     password: 'password',
     host: '127.0.0.1',
-    port: 3307,
+    port: 3306,
     entities: dbEntities_1.dbEntities,
     synchronize: true,
     logging: false

package/dist/{TypeOrmConnector → fluent/src/TypeOrmConnector}/test/mysql/roles.mysql.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.mysql.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 → fluent/src/TypeOrmConnector}/test/mysql/roles.mysql.repository.js

@@ -7,12 +7,14 @@ const roles_entity_1 = require("../relations/roles/roles.entity");
 const mysqlDataSource_1 = require("./mysqlDataSource");
 const user_mysql_repository_1 = require("./user.mysql.repository");
 const roles_user_mysql_repository_1 = require("./roles_user.mysql.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: mysqlDataSource_1.MYSQLDataSource,
-            inputSchema: role_schema_1.RoleEntitySchema
+            inputSchema: role_schema_1.RoleInputSchema,
+            outputSchema: role_output_schema_1.RoleOuputSchema
         });
         this.users = () => this.belongsToMany({
             repository: user_mysql_repository_1.UserRepository,

package/dist/{TypeOrmConnector → fluent/src/TypeOrmConnector}/test/mysql/user.mysql.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.mysql.repository';
 import { RoleRepository } from './roles.mysql.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 → fluent/src/TypeOrmConnector}/test/mysql/user.mysql.repository.js

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

package/dist/{TypeOrmConnector → fluent/src/TypeOrmConnector}/test/relations/car/car.entity.d.ts

@@ -4,5 +4,4 @@ export declare class CarsEntity {
     name: string;
     userId?: string;
     user?: UsersEntity;
-    anotherRelation?: UsersEntity;
 }

package/dist/{TypeOrmConnector → fluent/src/TypeOrmConnector}/test/relations/car/car.entity.js

@@ -26,14 +26,6 @@ tslib_1.__decorate([
     }),
     tslib_1.__metadata("design:type", user_entity_1.UsersEntity)
 ], CarsEntity.prototype, "user", void 0);
-tslib_1.__decorate([
-    decorators_1.f.belongsTo({
-        entity: () => user_entity_1.UsersEntity,
-        inverse: user => user.cars,
-        pivotColumnName: 'userId'
-    }),
-    tslib_1.__metadata("design:type", user_entity_1.UsersEntity)
-], CarsEntity.prototype, "anotherRelation", void 0);
 CarsEntity = tslib_1.__decorate([
     decorators_1.f.entity('cars')
 ], CarsEntity);