@goatlab/fluent 0.6.23 → 0.7.0

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

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 export declare class Breed {
     family?: string;
     members?: number;
@@ -8,3 +9,45 @@ export declare class GoatEntity {
     age?: number;
     breed?: Breed;
 }
+export declare const BreedSchema: z.ZodObject<{
+    family: z.ZodString;
+    members: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    family: string;
+    members: number;
+}, {
+    family: string;
+    members: number;
+}>;
+export declare const GoatSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    age: z.ZodNumber;
+    breed: z.ZodOptional<z.ZodObject<{
+        family: z.ZodString;
+        members: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        family: string;
+        members: number;
+    }, {
+        family: string;
+        members: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    id?: string | undefined;
+    breed?: {
+        family: string;
+        members: number;
+    } | undefined;
+    name: string;
+    age: number;
+}, {
+    id?: 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

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GoatEntity = exports.Breed = void 0;
+exports.GoatSchema = exports.BreedSchema = exports.GoatEntity = exports.Breed = void 0;
 const tslib_1 = require("tslib");
 const types_1 = require("../../../core/types");
 const decorators_1 = require("../../../decorators");
+const zod_1 = require("zod");
 let Breed = class Breed {
 };
 tslib_1.__decorate([
-    decorators_1.Decorators.property({ required: false }),
+    decorators_1.f.property({ required: false }),
     tslib_1.__metadata("design:type", String)
 ], Breed.prototype, "family", void 0);
 tslib_1.__decorate([
-    decorators_1.Decorators.property({ required: false }),
+    decorators_1.f.property({ required: false }),
     tslib_1.__metadata("design:type", Number)
 ], Breed.prototype, "members", void 0);
 Breed = tslib_1.__decorate([
@@ -21,22 +22,32 @@ exports.Breed = Breed;
 let GoatEntity = class GoatEntity {
 };
 tslib_1.__decorate([
-    decorators_1.Decorators.id(),
+    decorators_1.f.id(),
     tslib_1.__metadata("design:type", String)
 ], GoatEntity.prototype, "id", void 0);
 tslib_1.__decorate([
-    decorators_1.Decorators.property({ required: true }),
+    decorators_1.f.property({ required: true }),
     tslib_1.__metadata("design:type", String)
 ], GoatEntity.prototype, "name", void 0);
 tslib_1.__decorate([
-    decorators_1.Decorators.property({ required: false }),
+    decorators_1.f.property({ required: false }),
     tslib_1.__metadata("design:type", Number)
 ], GoatEntity.prototype, "age", void 0);
 tslib_1.__decorate([
-    decorators_1.Decorators.embed(Breed),
+    decorators_1.f.embed(Breed),
     tslib_1.__metadata("design:type", Breed)
 ], GoatEntity.prototype, "breed", void 0);
 GoatEntity = tslib_1.__decorate([
-    decorators_1.Decorators.entity('goat')
+    decorators_1.f.entity('goat')
 ], GoatEntity);
 exports.GoatEntity = GoatEntity;
+exports.BreedSchema = zod_1.z.object({
+    family: zod_1.z.string(),
+    members: zod_1.z.number()
+});
+exports.GoatSchema = zod_1.z.object({
+    id: zod_1.z.string().optional(),
+    name: zod_1.z.string(),
+    age: zod_1.z.number(),
+    breed: exports.BreedSchema.optional()
+});

package/dist/TypeOrmConnector/test/basic/goat.mongo.repository.d.ts

@@ -0,0 +1,5 @@
+import { GoatInputSchema, GoatEntity } from './goat.entity';
+import { TypeOrmConnector } from '../../TypeOrmConnector';
+export declare class GoatRepository extends TypeOrmConnector<GoatEntity, GoatInputSchema> {
+    constructor();
+}

package/dist/TypeOrmConnector/test/basic/goat.mongo.repository.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoatRepository = void 0;
+const goat_entity_1 = require("./goat.entity");
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const mongoDatasource_1 = require("../mongo/mongoDatasource");
+class GoatRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: goat_entity_1.GoatEntity,
+            dataSource: mongoDatasource_1.MongoDataSource,
+            inputSchema: goat_entity_1.GoatSchema
+        });
+    }
+}
+exports.GoatRepository = GoatRepository;

package/dist/TypeOrmConnector/test/basic/goat.mysql.repository.d.ts

@@ -0,0 +1,5 @@
+import { GoatEntity, GoatInputSchema } from './goat.entity';
+import { TypeOrmConnector } from '../../TypeOrmConnector';
+export declare class GoatRepository extends TypeOrmConnector<GoatEntity, GoatInputSchema> {
+    constructor();
+}

package/dist/TypeOrmConnector/test/basic/goat.mysql.repository.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoatRepository = void 0;
+const goat_entity_1 = require("./goat.entity");
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const mysqlDataSource_1 = require("../mysql/mysqlDataSource");
+class GoatRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: goat_entity_1.GoatEntity,
+            dataSource: mysqlDataSource_1.MYSQLDataSource,
+            inputSchema: goat_entity_1.GoatSchema
+        });
+    }
+}
+exports.GoatRepository = GoatRepository;

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

@@ -1,6 +1,5 @@
-import { GoatEntityIn, GoatEntityOut } from './goat.dto';
-import { GoatEntity } from './goat.entity';
+import { GoatEntity, GoatInputSchema } from './goat.entity';
 import { TypeOrmConnector } from '../../TypeOrmConnector';
-export declare class GoatRepository extends TypeOrmConnector<GoatEntity, GoatEntityIn, GoatEntityOut> {
-    constructor(relations?: any);
+export declare class GoatRepository extends TypeOrmConnector<GoatEntity, GoatInputSchema> {
+    constructor();
 }

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

@@ -3,10 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GoatRepository = void 0;
 const goat_entity_1 = require("./goat.entity");
 const TypeOrmConnector_1 = require("../../TypeOrmConnector");
-const memoryDataSource_1 = require("../memoryDataSource");
+const memoryDataSource_1 = require("../sqlite/memoryDataSource");
 class GoatRepository extends TypeOrmConnector_1.TypeOrmConnector {
-    constructor(relations) {
-        super(goat_entity_1.GoatEntity, memoryDataSource_1.MemoryDataSource, relations);
+    constructor() {
+        super({
+            entity: goat_entity_1.GoatEntity,
+            dataSource: memoryDataSource_1.MemoryDataSource,
+            inputSchema: goat_entity_1.GoatSchema
+        });
     }
 }
 exports.GoatRepository = GoatRepository;

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

@@ -1,6 +1,6 @@
-import { TypeORMDataModel } from "./advanced/typeOrm.entity";
-import { GoatEntity } from "./basic/goat.entity";
-import { CarsEntity } from "./relations/car/car.entity";
-import { RoleEntity } from "./relations/roles/roles.entity";
-import { RolesUser } from "./relations/roles/roles_user.entity";
-export declare const dbEntities: (typeof RoleEntity | typeof CarsEntity | typeof RolesUser | typeof TypeORMDataModel | typeof GoatEntity)[];
+import { TypeORMDataModel } from './advanced/typeOrm.entity';
+import { GoatEntity } from './basic/goat.entity';
+import { CarsEntity } from './relations/car/car.entity';
+import { RoleEntity } from './relations/roles/roles.entity';
+import { RolesUser } from './relations/roles/roles_user.entity';
+export declare const dbEntities: (typeof TypeORMDataModel | typeof GoatEntity | typeof RoleEntity | typeof CarsEntity | typeof RolesUser)[];

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

@@ -0,0 +1,35 @@
+export declare const detectPort: (defaultPort: number) => Promise<number>;
+export interface Options {
+    debug: boolean;
+    image: string;
+    containerName: string;
+    defaultExternalPort: number;
+    externalPort?: number;
+    internalPort: number;
+    connectTimeoutSeconds: number;
+    environment?: {
+        [key: string]: string;
+    };
+    command?: string[];
+    cap_add?: 'SYS_NICE' | 'IPC_LOCK';
+    refreshImage?: boolean;
+    detached?: boolean;
+    enableDebugInstructions?: string;
+    testConnection?: (opts: NormalizedOptions & {
+        testPortConnection: () => Promise<boolean>;
+    }) => Promise<boolean>;
+}
+export interface NormalizedOptions extends Pick<Options, Exclude<keyof Options, 'defaultExternalPort'>> {
+    detached: boolean;
+    externalPort: number;
+}
+export declare function imageExists(options: NormalizedOptions | Options): Promise<boolean>;
+export declare function pullDockerImage(options: NormalizedOptions | Options): Promise<void>;
+export declare function startDockerContainer(options: NormalizedOptions): any;
+export declare function waitForDatabaseToStart(options: NormalizedOptions): Promise<void>;
+export declare function killOldContainers(options: Pick<NormalizedOptions, 'debug' | 'containerName'>): Promise<void>;
+export default function startContainer(options: Options): Promise<{
+    proc: any;
+    externalPort: number;
+    kill(): Promise<void>;
+}>;

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.killOldContainers = exports.waitForDatabaseToStart = exports.startDockerContainer = exports.pullDockerImage = exports.imageExists = exports.detectPort = void 0;
+const net_1 = require("net");
+const spawn = require("cross-spawn");
+const modern_spawn_1 = require("modern-spawn");
+exports.detectPort = require('detect-port');
+async function imageExists(options) {
+    const stdout = await (0, modern_spawn_1.spawnBuffered)('docker', ['images', '--format', '{{json .}}'], {
+        debug: options.debug
+    }).getResult('utf8');
+    const existingImages = stdout
+        .trim()
+        .split('\n')
+        .map(str => {
+        try {
+            return JSON.parse(str);
+        }
+        catch (ex) {
+            console.log('Unable to parse: ' + str);
+            return null;
+        }
+    })
+        .filter(n => n != null);
+    const [Repository, Tag] = options.image.split(':');
+    return existingImages.some(i => i.Repository === Repository && (!Tag || i.Tag === Tag));
+}
+exports.imageExists = imageExists;
+async function pullDockerImage(options) {
+    if (!options.refreshImage &&
+        /.+\:.+/.test(options.image) &&
+        (await imageExists(options))) {
+        console.log(options.image +
+            ' already pulled (use mysql-test start --refresh or ops.refreshImage to refresh)');
+        return;
+    }
+    console.log('Pulling Docker Image ' + options.image);
+    await (0, modern_spawn_1.spawnBuffered)('docker', ['pull', options.image], {
+        debug: options.debug
+    }).getResult();
+}
+exports.pullDockerImage = pullDockerImage;
+function startDockerContainer(options) {
+    const env = options.environment || {};
+    const envArgs = [];
+    Object.keys(env).forEach(key => {
+        envArgs.push('--env');
+        envArgs.push(`${key}=${env[key]}`);
+    });
+    return spawn('docker', [
+        'run',
+        '--name',
+        options.containerName,
+        '-t',
+        '--rm',
+        '-p',
+        `${options.externalPort}:${options.internalPort}`,
+        ...(options.detached ? ['--detach'] : []),
+        ...envArgs,
+        options.image,
+        '--default_authentication_plugin=mysql_native_password'
+    ], {
+        stdio: options.debug ? 'inherit' : 'ignore'
+    });
+}
+exports.startDockerContainer = startDockerContainer;
+async function waitForDatabaseToStart(options) {
+    await new Promise((resolve, reject) => {
+        let finished = false;
+        const timeout = setTimeout(() => {
+            finished = true;
+            reject(new Error(`Unable to connect to database after ${options.connectTimeoutSeconds} seconds.${options.enableDebugInstructions
+                ? ` ${options.enableDebugInstructions}`
+                : ``}`));
+        }, options.connectTimeoutSeconds * 1000);
+        function test() {
+            console.log(`Waiting for ${options.containerName} on port ${options.externalPort}...`);
+            (options.testConnection
+                ? options.testConnection({
+                    ...options,
+                    testPortConnection: async () => await testConnection(options)
+                })
+                : testConnection(options)).then(isConnected => {
+                if (finished)
+                    return;
+                if (isConnected) {
+                    finished = true;
+                    clearTimeout(timeout);
+                    setTimeout(resolve, 1000);
+                }
+                else {
+                    setTimeout(test, 500);
+                }
+            }, err => {
+                reject(err);
+            });
+        }
+        test();
+    });
+}
+exports.waitForDatabaseToStart = waitForDatabaseToStart;
+async function testConnection(options) {
+    return new Promise(resolve => {
+        const connection = (0, net_1.connect)(options.externalPort)
+            .on('error', () => {
+            resolve(false);
+        })
+            .on('connect', () => {
+            connection.end();
+            resolve(true);
+        });
+    });
+}
+async function killOldContainers(options) {
+    await (0, modern_spawn_1.spawnBuffered)('docker', ['kill', options.containerName], {
+        debug: options.debug
+    });
+    await (0, modern_spawn_1.spawnBuffered)('docker', ['rm', options.containerName], {
+        debug: options.debug
+    });
+}
+exports.killOldContainers = killOldContainers;
+async function startContainer(options) {
+    if (isNaN(options.connectTimeoutSeconds)) {
+        throw new Error('connectTimeoutSeconds must be a valid integer.');
+    }
+    await Promise.all([pullDockerImage(options), killOldContainers(options)]);
+    const { defaultExternalPort, ...rawOptions } = options;
+    const externalPort = rawOptions.externalPort || (await (0, exports.detectPort)(defaultExternalPort));
+    if (typeof externalPort !== 'number') {
+        throw new Error('Expected external port to be a number');
+    }
+    const opts = {
+        detached: false,
+        ...rawOptions,
+        externalPort
+    };
+    console.log('Starting Docker Container ' + opts.containerName);
+    const proc = startDockerContainer(opts);
+    await waitForDatabaseToStart(opts);
+    return {
+        proc,
+        externalPort,
+        async kill() {
+            await killOldContainers(options);
+        }
+    };
+}
+exports.default = startContainer;

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-mysql-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/mongo/car.mongo.repository.d.ts

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

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

@@ -0,0 +1,23 @@
+"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_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.CarsEntitySchema
+        });
+        this.user = () => this.belongsTo({
+            repository: user_mongo_repository_1.UserRepository,
+            model: user_entity_1.UsersEntity
+        });
+    }
+}
+exports.CarsRepository = CarsRepository;

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

@@ -0,0 +1,4 @@
+import { MongoMemoryServer } from 'mongodb-memory-server';
+export declare const mongoMemory: Readonly<{
+    start: () => Promise<MongoMemoryServer>;
+}>;

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongoMemory = void 0;
+const mongodb_memory_server_1 = require("mongodb-memory-server");
+const mongoose_1 = require("mongoose");
+exports.mongoMemory = (() => {
+    const createExampleSchema = (url) => {
+        return new Promise((resolve, reject) => {
+            const db = (0, mongoose_1.createConnection)(url);
+            const testSchema = new mongoose_1.Schema({
+                age: Number,
+                name: String
+            });
+            const Test = db.model('test', testSchema);
+            const test = new Test({ name: 'Nacho', age: 31 });
+            db.once('connected', (err) => {
+                if (err) {
+                    return console.error(err);
+                }
+                Test.create(test, (error, doc) => {
+                    if (err) {
+                        return console.error(error);
+                    }
+                    resolve(doc);
+                    return;
+                });
+            });
+        });
+    };
+    const start = async () => {
+        const mongoServer = await mongodb_memory_server_1.MongoMemoryServer.create({
+            instance: {
+                storageEngine: 'wiredTiger'
+            }
+        });
+        const url = mongoServer.getUri();
+        await createExampleSchema(url);
+        return mongoServer;
+    };
+    return Object.freeze({
+        start
+    });
+})();

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,8 @@
+import { TypeOrmConnector } from '../../TypeOrmConnector';
+import { RoleEntityInputSchema } 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> {
+    constructor();
+    users: () => UserRepository;
+}