@goatlab/fluent 0.7.21 → 0.7.24

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.d.ts

@@ -0,0 +1,17 @@
+import { Options as WithContainerOptions } from './docker';
+export interface Options extends Omit<WithContainerOptions, 'internalPort' | 'enableDebugInstructions' | 'testConnection'> {
+    mysqlUser: string;
+    mysqlPassword: string;
+    mysqlDb: string;
+}
+export declare function waitForConnection(databaseURL: string, timeoutSeconds: number): Promise<void>;
+export declare function killDatabase(options?: Partial<Options>): 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/mysql.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.killDatabase = exports.waitForConnection = void 0;
+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-${DEFAULT_IMAGE.replace(':', '-')}-test`;
+const DEFAULT_CONNECT_TIMEOUT_SECONDS = 10;
+const DEFAULT_MYSQL_PORT = 3306;
+const DEFAULT_MYSQL_USER = 'test-user';
+const DEFAULT_MYSQL_PASSWORD = 'password';
+const DEFAULT_MYSQL_DB = 'test-db';
+const DEFAULT_MYSQL_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));
+        let conn;
+        try {
+            try {
+                await new Promise((resolve, reject) => {
+                    let errored = false;
+                    conn = createConnection(databaseURL);
+                    const createConnectionErr = new Error();
+                    conn.once('connect', () => {
+                        resolve();
+                    });
+                    conn.on('error', (err) => {
+                        if (errored)
+                            return;
+                        errored = true;
+                        createConnectionErr.message = err.message;
+                        createConnectionErr.code = err.code;
+                        createConnectionErr.errno = err.errno;
+                        createConnectionErr.sqlState = err.sqlState;
+                        reject(createConnectionErr);
+                    });
+                });
+                const result = await new Promise((resolve, reject) => {
+                    const queryErr = new Error();
+                    conn.query(`SELECT 1 + 1 AS foo;`, (err, result) => {
+                        if (err) {
+                            queryErr.message = err.message;
+                            reject(queryErr);
+                        }
+                        else {
+                            resolve(result);
+                        }
+                    });
+                });
+                if (result && result[0] && result[0].foo === 2) {
+                    break;
+                }
+                else {
+                    if (lastAttempt) {
+                        throw new Error('Got unexpected result: ' + JSON.stringify(result));
+                    }
+                }
+            }
+            catch (ex) {
+                if (lastAttempt) {
+                    throw ex;
+                }
+            }
+        }
+        finally {
+            conn.end(() => {
+            });
+        }
+        if (Date.now() - timeoutMilliseconds > start) {
+            lastAttempt = true;
+        }
+    }
+}
+exports.waitForConnection = waitForConnection;
+async function killDatabase(options = {}) {
+    await (0, docker_1.killOldContainers)({
+        debug: DEFAULT_MYSQL_DEBUG,
+        containerName: DEFAULT_CONTAINER_NAME,
+        ...options,
+    });
+}
+exports.killDatabase = killDatabase;
+async function getDatabase(options = {}) {
+    const { mysqlUser, mysqlPassword, mysqlDb, environment, ...rawOptions } = {
+        debug: DEFAULT_MYSQL_DEBUG,
+        image: DEFAULT_IMAGE,
+        containerName: DEFAULT_CONTAINER_NAME,
+        connectTimeoutSeconds: DEFAULT_CONNECT_TIMEOUT_SECONDS,
+        mysqlUser: DEFAULT_MYSQL_USER,
+        mysqlPassword: DEFAULT_MYSQL_PASSWORD,
+        mysqlDb: DEFAULT_MYSQL_DB,
+        defaultExternalPort: DEFAULT_MYSQL_PORT,
+        ...options,
+    };
+    const { proc, externalPort, kill } = await (0, docker_1.default)({
+        ...rawOptions,
+        internalPort: DEFAULT_MYSQL_PORT,
+        environment: {
+            MYSQL_ALLOW_EMPTY_PASSWORD: 'true',
+            MYSQL_HOST: '127.0.0.1',
+            MYSQL_ROOT_HOST: '%',
+            ...environment,
+            MYSQL_USER: mysqlUser,
+            MYSQL_ROOT_PASSWORD: mysqlPassword,
+            MYSQL_PASSWORD: mysqlPassword,
+            MYSQL_DATABASE: mysqlDb,
+        },
+        enableDebugInstructions: `To view logs, run with MYSQL_TEST_DEBUG=true environment variable.`,
+        command: [
+            '--default_authentication_plugin=mysql_native_password',
+            '--character-set-server=utf8mb4',
+            '--collation-server=utf8mb4_unicode_ci'
+        ],
+        cap_add: 'SYS_NICE'
+    });
+    const databaseURL = `mysql://${mysqlUser}:${mysqlPassword}@localhost:${externalPort}/${mysqlDb}`;
+    await waitForConnection(databaseURL, rawOptions.connectTimeoutSeconds);
+    return {
+        proc,
+        databaseURL,
+        kill,
+        user: mysqlUser,
+        password: mysqlPassword,
+        port: externalPort,
+        dbName: mysqlDb
+    };
+}
+exports.default = getDatabase;

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

@@ -0,0 +1,4 @@
+export declare const flock: {
+    age: number;
+    name: string;
+}[];

package/dist/TypeOrmConnector/test/flock.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flock = void 0;
+exports.flock = [
+    {
+        age: 3,
+        name: 'Goatee'
+    },
+    {
+        age: 4,
+        name: 'GoaToHell'
+    },
+    {
+        age: 5,
+        name: 'Oh!MyGoat'
+    },
+    {
+        age: 3,
+        name: 'A'
+    },
+    {
+        age: 2,
+        name: 'B'
+    }
+];

package/dist/TypeOrmConnector/test/mongo/car.mongo.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.mongo.repository';
+export declare class CarsRepository extends TypeOrmConnector<CarsEntity, CarDtoInput, CarDtoOutput> {
+    constructor();
+    user: () => UserRepository;
+    anotherRelation: () => UserRepository;
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+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");
+const user_mongo_repository_1 = require("./user.mongo.repository");
+class CarsRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: car_entity_1.CarsEntity,
+            dataSource: mongoDatasource_1.MongoDataSource,
+            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/mongoDatasource.d.ts

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

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoDataSource = void 0;
+const typeorm_1 = require("typeorm");
+const dbEntities_1 = require("../dbEntities");
+exports.MongoDataSource = new typeorm_1.DataSource({
+    type: 'mongodb',
+    useNewUrlParser: true,
+    useUnifiedTopology: true,
+    entities: dbEntities_1.dbEntities,
+    logging: false
+});

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

@@ -0,0 +1,9 @@
+import { TypeOrmConnector } from '../../TypeOrmConnector';
+import { RoleDtoInput } from '../relations/roles/role.schema';
+import { RoleEntity } from '../relations/roles/roles.entity';
+import { UserRepository } from './user.mongo.repository';
+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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleRepository = void 0;
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const role_schema_1 = require("../relations/roles/role.schema");
+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.RoleInputSchema,
+            outputSchema: role_output_schema_1.RoleOuputSchema
+        });
+        this.users = () => this.belongsToMany({
+            repository: user_mongo_repository_1.UserRepository,
+            pivot: roles_user_mongo_repository_1.RoleUsersRepository
+        });
+    }
+}
+exports.RoleRepository = RoleRepository;

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

@@ -0,0 +1,6 @@
+import { RolesUser } from '../relations/roles/roles_user.entity';
+import { RolesUserInputSchema } from '../relations/roles/roles_user.schema';
+import { TypeOrmConnector } from '../../TypeOrmConnector';
+export declare class RoleUsersRepository extends TypeOrmConnector<RolesUser, RolesUserInputSchema> {
+    constructor();
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleUsersRepository = void 0;
+const roles_user_entity_1 = require("../relations/roles/roles_user.entity");
+const roles_user_schema_1 = require("../relations/roles/roles_user.schema");
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const mongoDatasource_1 = require("./mongoDatasource");
+class RoleUsersRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: roles_user_entity_1.RolesUser,
+            dataSource: mongoDatasource_1.MongoDataSource,
+            inputSchema: roles_user_schema_1.RolesUserSchema
+        });
+    }
+}
+exports.RoleUsersRepository = RoleUsersRepository;

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

@@ -0,0 +1,10 @@
+import { TypeOrmConnector } from '../../TypeOrmConnector';
+import { UsersEntity } from '../relations/user/user.entity';
+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, UsersDtoIn, UsersDtoOut> {
+    constructor();
+    cars: () => CarsRepository;
+    roles: () => RoleRepository;
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserRepository = void 0;
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const car_entity_1 = require("../relations/car/car.entity");
+const user_entity_1 = require("../relations/user/user.entity");
+const user_schema_1 = require("../relations/user/user.schema");
+const car_mongo_repository_1 = require("./car.mongo.repository");
+const mongoDatasource_1 = require("./mongoDatasource");
+const roles_mongo_repository_1 = require("./roles.mongo.repository");
+const roles_user_mongo_repository_1 = require("./roles_user.mongo.repository");
+class UserRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: user_entity_1.UsersEntity,
+            dataSource: mongoDatasource_1.MongoDataSource,
+            inputSchema: user_schema_1.userInputSchema,
+            outputSchema: user_schema_1.userOutputSchema
+        });
+        this.cars = () => {
+            return this.hasMany({
+                repository: car_mongo_repository_1.CarsRepository,
+                model: car_entity_1.CarsEntity
+            });
+        };
+        this.roles = () => this.belongsToMany({
+            repository: roles_mongo_repository_1.RoleRepository,
+            pivot: roles_user_mongo_repository_1.RoleUsersRepository
+        });
+    }
+}
+exports.UserRepository = UserRepository;

package/dist/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/test/mysql/car.mysql.repository.js

@@ -0,0 +1,26 @@
+"use strict";
+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.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
+        });
+    }
+}
+exports.CarsRepository = CarsRepository;

package/dist/TypeOrmConnector/test/mysql/mysqlDataSource.d.ts

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

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MYSQLDataSource = void 0;
+const typeorm_1 = require("typeorm");
+const dbEntities_1 = require("../dbEntities");
+exports.MYSQLDataSource = new typeorm_1.DataSource({
+    type: 'mysql',
+    database: 'test-db',
+    username: 'root',
+    password: 'password',
+    host: '127.0.0.1',
+    port: 3306,
+    entities: dbEntities_1.dbEntities,
+    synchronize: true,
+    logging: false
+});

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

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

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleRepository = void 0;
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const role_schema_1 = require("../relations/roles/role.schema");
+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.RoleInputSchema,
+            outputSchema: role_output_schema_1.RoleOuputSchema
+        });
+        this.users = () => this.belongsToMany({
+            repository: user_mysql_repository_1.UserRepository,
+            pivot: roles_user_mysql_repository_1.RoleUsersRepository
+        });
+    }
+}
+exports.RoleRepository = RoleRepository;

package/dist/TypeOrmConnector/test/mysql/roles_user.mysql.repository.d.ts

@@ -0,0 +1,6 @@
+import { RolesUser } from '../relations/roles/roles_user.entity';
+import { RolesUserInputSchema } from '../relations/roles/roles_user.schema';
+import { TypeOrmConnector } from '../../TypeOrmConnector';
+export declare class RoleUsersRepository extends TypeOrmConnector<RolesUser, RolesUserInputSchema> {
+    constructor();
+}

package/dist/TypeOrmConnector/test/mysql/roles_user.mysql.repository.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleUsersRepository = void 0;
+const roles_user_entity_1 = require("../relations/roles/roles_user.entity");
+const roles_user_schema_1 = require("../relations/roles/roles_user.schema");
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const mysqlDataSource_1 = require("./mysqlDataSource");
+class RoleUsersRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: roles_user_entity_1.RolesUser,
+            dataSource: mysqlDataSource_1.MYSQLDataSource,
+            inputSchema: roles_user_schema_1.RolesUserSchema
+        });
+    }
+}
+exports.RoleUsersRepository = RoleUsersRepository;

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

@@ -0,0 +1,10 @@
+import { TypeOrmConnector } from '../../TypeOrmConnector';
+import { UsersEntity } from '../relations/user/user.entity';
+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, UsersDtoIn, UsersDtoOut> {
+    constructor();
+    cars: () => CarsRepository;
+    roles: () => RoleRepository;
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserRepository = void 0;
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const car_entity_1 = require("../relations/car/car.entity");
+const user_entity_1 = require("../relations/user/user.entity");
+const user_schema_1 = require("../relations/user/user.schema");
+const car_mysql_repository_1 = require("./car.mysql.repository");
+const mysqlDataSource_1 = require("./mysqlDataSource");
+const roles_mysql_repository_1 = require("./roles.mysql.repository");
+const roles_user_mysql_repository_1 = require("./roles_user.mysql.repository");
+class UserRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: user_entity_1.UsersEntity,
+            dataSource: mysqlDataSource_1.MYSQLDataSource,
+            inputSchema: user_schema_1.userInputSchema,
+            outputSchema: user_schema_1.userOutputSchema
+        });
+        this.cars = () => {
+            return this.hasMany({
+                repository: car_mysql_repository_1.CarsRepository,
+                model: car_entity_1.CarsEntity,
+                relationKey: { user: true }
+            });
+        };
+        this.roles = () => this.belongsToMany({
+            repository: roles_mysql_repository_1.RoleRepository,
+            pivot: roles_user_mysql_repository_1.RoleUsersRepository
+        });
+    }
+}
+exports.UserRepository = UserRepository;

package/dist/TypeOrmConnector/test/relations/car/car.entity.d.ts

@@ -0,0 +1,7 @@
+import { UsersEntity } from '../user/user.entity';
+export declare class CarsEntity {
+    id: string;
+    name: string;
+    userId?: string;
+    user?: UsersEntity;
+}

package/dist/TypeOrmConnector/test/relations/car/car.entity.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarsEntity = void 0;
+const tslib_1 = require("tslib");
+const decorators_1 = require("../../../../decorators");
+const user_entity_1 = require("../user/user.entity");
+let CarsEntity = class CarsEntity {
+};
+tslib_1.__decorate([
+    decorators_1.f.id(),
+    tslib_1.__metadata("design:type", String)
+], CarsEntity.prototype, "id", void 0);
+tslib_1.__decorate([
+    decorators_1.f.property({ required: true }),
+    tslib_1.__metadata("design:type", String)
+], CarsEntity.prototype, "name", void 0);
+tslib_1.__decorate([
+    decorators_1.f.property({ required: true }),
+    tslib_1.__metadata("design:type", String)
+], CarsEntity.prototype, "userId", 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, "user", void 0);
+CarsEntity = tslib_1.__decorate([
+    decorators_1.f.entity('cars')
+], CarsEntity);
+exports.CarsEntity = CarsEntity;