feat(core): infer configuration from environment variables (#1498)

It is now possible to set most of the ORM options via environment variables.
By default `.env` file from the root directory is loaded - it is also possible to
set full path to the env file you want to use via `MIKRO_ORM_ENV` environment variable.

> Environment variables always have precedence.

Example `.env` file:

```dotenv
MIKRO_ORM_TYPE = sqlite
MIKRO_ORM_ENTITIES = ./dist/foo/*.entity.js, ./dist/bar/*.entity.js
MIKRO_ORM_ENTITIES_TS = ./src/foo/*.entity.ts, ./src/bar/*.entity.ts
MIKRO_ORM_DB_NAME = test.db
MIKRO_ORM_MIGRATIONS_PATH = ./dist/migrations
MIKRO_ORM_MIGRATIONS_PATTERN = ^[\w-]+\d+\.js$
MIKRO_ORM_POPULATE_AFTER_FLUSH = true
MIKRO_ORM_FORCE_ENTITY_CONSTRUCTOR = true
MIKRO_ORM_FORCE_UNDEFINED = true
```

Full list of supported options:

| env variable | config key |
|--------------|------------|
| `MIKRO_ORM_BASE_DIR` | `baseDir` |
| `MIKRO_ORM_TYPE` | `type` |
| `MIKRO_ORM_ENTITIES` | `entities` |
| `MIKRO_ORM_ENTITIES_TS` | `entitiesTs` |
| `MIKRO_ORM_CLIENT_URL` | `clientUrl` |
| `MIKRO_ORM_HOST` | `host` |
| `MIKRO_ORM_PORT` | `port` |
| `MIKRO_ORM_USER` | `user` |
| `MIKRO_ORM_PASSWORD` | `password` |
| `MIKRO_ORM_DB_NAME` | `dbName` |
| `MIKRO_ORM_LOAD_STRATEGY` | `loadStrategy` |
| `MIKRO_ORM_BATCH_SIZE` | `batchSize` |
| `MIKRO_ORM_USE_BATCH_INSERTS` | `useBatchInserts` |
| `MIKRO_ORM_USE_BATCH_UPDATES` | `useBatchUpdates` |
| `MIKRO_ORM_STRICT` | `strict` |
| `MIKRO_ORM_VALIDATE` | `validate` |
| `MIKRO_ORM_AUTO_JOIN_ONE_TO_ONE_OWNER` | `autoJoinOneToOneOwner` |
| `MIKRO_ORM_PROPAGATE_TO_ONE_OWNER` | `propagateToOneOwner` |
| `MIKRO_ORM_POPULATE_AFTER_FLUSH` | `populateAfterFlush` |
| `MIKRO_ORM_FORCE_ENTITY_CONSTRUCTOR` | `forceEntityConstructor` |
| `MIKRO_ORM_FORCE_UNDEFINED` | `forceUndefined` |
| `MIKRO_ORM_FORCE_UTC_TIMEZONE` | `forceUtcTimezone` |
| `MIKRO_ORM_TIMEZONE` | `timezone` |
| `MIKRO_ORM_ENSURE_INDEXES` | `ensureIndexes` |
| `MIKRO_ORM_IMPLICIT_TRANSACTIONS` | `implicitTransactions` |
| `MIKRO_ORM_DEBUG` | `debug` |
| `MIKRO_ORM_VERBOSE` | `verbose` |
| `MIKRO_ORM_DISCOVERY_WARN_WHEN_NO_ENTITIES` | `discovery.warnWhenNoEntities` |
| `MIKRO_ORM_DISCOVERY_REQUIRE_ENTITIES_ARRAY` | `discovery.requireEntitiesArray` |
| `MIKRO_ORM_DISCOVERY_ALWAYS_ANALYSE_PROPERTIES` | `discovery.alwaysAnalyseProperties` |
| `MIKRO_ORM_DISCOVERY_DISABLE_DYNAMIC_FILE_ACCESS` | `discovery.disableDynamicFileAccess` |
| `MIKRO_ORM_MIGRATIONS_TABLE_NAME` | `migrations.tableName` |
| `MIKRO_ORM_MIGRATIONS_PATH` | `migrations.path` |
| `MIKRO_ORM_MIGRATIONS_PATTERN` | `migrations.pattern` |
| `MIKRO_ORM_MIGRATIONS_TRANSACTIONAL` | `migrations.transactional` |
| `MIKRO_ORM_MIGRATIONS_DISABLE_FOREIGN_KEYS` | `migrations.disableForeignKeys` |
| `MIKRO_ORM_MIGRATIONS_ALL_OR_NOTHING` | `migrations.allOrNothing` |
| `MIKRO_ORM_MIGRATIONS_DROP_TABLES` | `migrations.dropTables` |
| `MIKRO_ORM_MIGRATIONS_SAFE` | `migrations.safe` |
| `MIKRO_ORM_MIGRATIONS_EMIT` | `migrations.emit` |

Closes #1472

docs/docs/configuration.md

@@ -374,3 +374,70 @@ MikroORM.init({
   ...
 });
 ```
+
+## Using environment variables
+
+Since v4.5 it is possible to set most of the ORM options via environment variables.
+By default `.env` file from the root directory is loaded - it is also possible to
+set full path to the env file you want to use via `MIKRO_ORM_ENV` environment variable.
+
+> Environment variables always have precedence.
+
+Example `.env` file:
+
+```dotenv
+MIKRO_ORM_TYPE = sqlite
+MIKRO_ORM_ENTITIES = ./dist/foo/*.entity.js, ./dist/bar/*.entity.js
+MIKRO_ORM_ENTITIES_TS = ./src/foo/*.entity.ts, ./src/bar/*.entity.ts
+MIKRO_ORM_DB_NAME = test.db
+MIKRO_ORM_MIGRATIONS_PATH = ./dist/migrations
+MIKRO_ORM_MIGRATIONS_PATTERN = ^[\w-]+\d+\.js$
+MIKRO_ORM_POPULATE_AFTER_FLUSH = true
+MIKRO_ORM_FORCE_ENTITY_CONSTRUCTOR = true
+MIKRO_ORM_FORCE_UNDEFINED = true
+```
+
+Full list of supported options:
+
+| env variable | config key |
+|--------------|------------|
+| `MIKRO_ORM_BASE_DIR` | `baseDir` |
+| `MIKRO_ORM_TYPE` | `type` |
+| `MIKRO_ORM_ENTITIES` | `entities` |
+| `MIKRO_ORM_ENTITIES_TS` | `entitiesTs` |
+| `MIKRO_ORM_CLIENT_URL` | `clientUrl` |
+| `MIKRO_ORM_HOST` | `host` |
+| `MIKRO_ORM_PORT` | `port` |
+| `MIKRO_ORM_USER` | `user` |
+| `MIKRO_ORM_PASSWORD` | `password` |
+| `MIKRO_ORM_DB_NAME` | `dbName` |
+| `MIKRO_ORM_LOAD_STRATEGY` | `loadStrategy` |
+| `MIKRO_ORM_BATCH_SIZE` | `batchSize` |
+| `MIKRO_ORM_USE_BATCH_INSERTS` | `useBatchInserts` |
+| `MIKRO_ORM_USE_BATCH_UPDATES` | `useBatchUpdates` |
+| `MIKRO_ORM_STRICT` | `strict` |
+| `MIKRO_ORM_VALIDATE` | `validate` |
+| `MIKRO_ORM_AUTO_JOIN_ONE_TO_ONE_OWNER` | `autoJoinOneToOneOwner` |
+| `MIKRO_ORM_PROPAGATE_TO_ONE_OWNER` | `propagateToOneOwner` |
+| `MIKRO_ORM_POPULATE_AFTER_FLUSH` | `populateAfterFlush` |
+| `MIKRO_ORM_FORCE_ENTITY_CONSTRUCTOR` | `forceEntityConstructor` |
+| `MIKRO_ORM_FORCE_UNDEFINED` | `forceUndefined` |
+| `MIKRO_ORM_FORCE_UTC_TIMEZONE` | `forceUtcTimezone` |
+| `MIKRO_ORM_TIMEZONE` | `timezone` |
+| `MIKRO_ORM_ENSURE_INDEXES` | `ensureIndexes` |
+| `MIKRO_ORM_IMPLICIT_TRANSACTIONS` | `implicitTransactions` |
+| `MIKRO_ORM_DEBUG` | `debug` |
+| `MIKRO_ORM_VERBOSE` | `verbose` |
+| `MIKRO_ORM_DISCOVERY_WARN_WHEN_NO_ENTITIES` | `discovery.warnWhenNoEntities` |
+| `MIKRO_ORM_DISCOVERY_REQUIRE_ENTITIES_ARRAY` | `discovery.requireEntitiesArray` |
+| `MIKRO_ORM_DISCOVERY_ALWAYS_ANALYSE_PROPERTIES` | `discovery.alwaysAnalyseProperties` |
+| `MIKRO_ORM_DISCOVERY_DISABLE_DYNAMIC_FILE_ACCESS` | `discovery.disableDynamicFileAccess` |
+| `MIKRO_ORM_MIGRATIONS_TABLE_NAME` | `migrations.tableName` |
+| `MIKRO_ORM_MIGRATIONS_PATH` | `migrations.path` |
+| `MIKRO_ORM_MIGRATIONS_PATTERN` | `migrations.pattern` |
+| `MIKRO_ORM_MIGRATIONS_TRANSACTIONAL` | `migrations.transactional` |
+| `MIKRO_ORM_MIGRATIONS_DISABLE_FOREIGN_KEYS` | `migrations.disableForeignKeys` |
+| `MIKRO_ORM_MIGRATIONS_ALL_OR_NOTHING` | `migrations.allOrNothing` |
+| `MIKRO_ORM_MIGRATIONS_DROP_TABLES` | `migrations.dropTables` |
+| `MIKRO_ORM_MIGRATIONS_SAFE` | `migrations.safe` |
+| `MIKRO_ORM_MIGRATIONS_EMIT` | `migrations.emit` |

packages/cli/src/CLIHelper.ts

@@ -2,15 +2,15 @@ import { pathExists } from 'fs-extra';
 import CliTable3, { Table } from 'cli-table3';
 import c from 'ansi-colors';
 
-import { Configuration, ConfigurationLoader, IDatabaseDriver, MikroORM, Utils } from '@mikro-orm/core';
+import { Configuration, ConfigurationLoader, IDatabaseDriver, MikroORM, Options, Utils } from '@mikro-orm/core';
 
 export class CLIHelper {
 
-  static async getConfiguration<D extends IDatabaseDriver = IDatabaseDriver>(validate = true, options: Partial<Configuration> = {}): Promise<Configuration<D>> {
+  static async getConfiguration<D extends IDatabaseDriver = IDatabaseDriver>(validate = true, options: Partial<Options> = {}): Promise<Configuration<D>> {
     return ConfigurationLoader.getConfiguration(validate, options);
   }
 
-  static async getORM(warnWhenNoEntities?: boolean, opts: Partial<Configuration> = {}): Promise<MikroORM> {
+  static async getORM(warnWhenNoEntities?: boolean, opts: Partial<Options> = {}): Promise<MikroORM> {
     const options = await CLIHelper.getConfiguration(warnWhenNoEntities, opts);
     const settings = await ConfigurationLoader.getSettings();
     options.getLogger().setDebugMode(false);

packages/cli/src/commands/MigrationCommandFactory.ts

@@ -1,7 +1,7 @@
 import c from 'ansi-colors';
 import { Arguments, Argv, CommandModule } from 'yargs';
 import { MigrateOptions, Migrator } from '@mikro-orm/migrations';
-import { Configuration, MikroORM, Utils } from '@mikro-orm/core';
+import { Configuration, MikroORM, MikroORMOptions, Utils } from '@mikro-orm/core';
 import { AbstractSqlDriver } from '@mikro-orm/knex';
 import { CLIHelper } from '../CLIHelper';
 
@@ -78,7 +78,7 @@ export class MigrationCommandFactory {
   }
 
   static async handleMigrationCommand(args: Arguments<Options>, method: MigratorMethod): Promise<void> {
-    const options = { pool: { min: 1, max: 1 } } as Partial<Configuration>;
+    const options = { pool: { min: 1, max: 1 } } as Partial<MikroORMOptions>;
     const orm = await CLIHelper.getORM(undefined, options) as MikroORM<AbstractSqlDriver>;
     const migrator = new Migrator(orm.em);
 

packages/core/package.json

@@ -49,6 +49,7 @@
   "dependencies": {
     "ansi-colors": "4.1.1",
     "clone": "2.1.2",
+    "dotenv": "8.2.0",
     "escaya": "0.0.61",
     "fs-extra": "9.1.0",
     "globby": "11.0.2",

packages/core/src/MikroORM.ts

@@ -2,7 +2,7 @@ import c from 'ansi-colors';
 
 import { EntityManagerType, IDatabaseDriver } from './drivers';
 import { MetadataDiscovery, MetadataStorage, ReflectMetadataProvider } from './metadata';
-import { Configuration, ConfigurationLoader, Logger, Options } from './utils';
+import { Configuration, ConfigurationLoader, Logger, Options, Utils } from './utils';
 import { NullCacheAdapter } from './cache';
 import { EntityManager } from './EntityManager';
 import { IEntityGenerator, IMigrator, ISchemaGenerator } from './typings';
@@ -23,11 +23,14 @@ export class MikroORM<D extends IDatabaseDriver = IDatabaseDriver> {
    * If you omit the `options` parameter, your CLI config will be used.
    */
   static async init<D extends IDatabaseDriver = IDatabaseDriver>(options?: Options<D> | Configuration<D>, connect = true): Promise<MikroORM<D>> {
+    const env = ConfigurationLoader.loadEnvironmentVars<D>(options);
+
     if (!options) {
       options = await ConfigurationLoader.getConfiguration<D>();
     }
 
-    const orm = new MikroORM<D>(options!);
+    options = options instanceof Configuration ? options.getAll() : options;
+    const orm = new MikroORM<D>(Utils.merge(options, env));
     const discovery = new MetadataDiscovery(new MetadataStorage(), orm.driver.getPlatform(), orm.config);
     orm.metadata = await discovery.discover(orm.config.get('tsNode'));
     orm.driver.setMetadata(orm.metadata);

packages/core/src/utils/Configuration.ts

@@ -119,6 +119,10 @@ export class Configuration<D extends IDatabaseDriver = IDatabaseDriver> {
     return (Utils.isDefined(this.options[key]) ? this.options[key] : defaultValue) as U;
   }
 
+  getAll(): MikroORMOptions<D> {
+    return this.options;
+  }
+
   /**
    * Overrides specified configuration value.
    */

packages/core/src/utils/ConfigurationLoader.ts

@@ -1,15 +1,17 @@
+import dotenv from 'dotenv';
 import { pathExists, readFile } from 'fs-extra';
 import { join, isAbsolute } from 'path';
 import stripJsonComments from 'strip-json-comments';
 import { IDatabaseDriver } from '../drivers';
-import { Configuration } from './Configuration';
+import { Configuration, Options } from './Configuration';
 import { Utils } from './Utils';
 import { Dictionary } from '../typings';
 
 export class ConfigurationLoader {
 
-  static async getConfiguration<D extends IDatabaseDriver = IDatabaseDriver>(validate = true, options: Partial<Configuration> = {}): Promise<Configuration<D>> {
+  static async getConfiguration<D extends IDatabaseDriver = IDatabaseDriver>(validate = true, options?: Partial<Options>): Promise<Configuration<D>> {
     const paths = await ConfigurationLoader.getConfigPaths();
+    const env = ConfigurationLoader.loadEnvironmentVars(options);
 
     for (let path of paths) {
       path = Utils.absolutePath(path);
@@ -18,10 +20,14 @@ export class ConfigurationLoader {
       if (await pathExists(path)) {
         // eslint-disable-next-line @typescript-eslint/no-var-requires
         const config = require(path);
-        return new Configuration({ ...(await (config.default || config)), ...options }, validate);
+        return new Configuration({ ...(await (config.default || config)), ...options, ...env }, validate);
       }
     }
 
+    if (Utils.hasObjectKeys(env)) {
+      return new Configuration({ ...options, ...env }, validate);
+    }
+
     throw new Error(`MikroORM config file not found in ['${paths.join(`', '`)}']`);
   }
 
@@ -85,6 +91,75 @@ export class ConfigurationLoader {
     return JSON.parse(stripJsonComments(json.toString()));
   }
 
+  static loadEnvironmentVars<D extends IDatabaseDriver>(options?: Options<D> | Configuration<D>): Partial<Options<D>> {
+    const baseDir = options instanceof Configuration ? options.get('baseDir') : options?.baseDir;
+    const path = process.env.MIKRO_ORM_ENV ?? ((baseDir ?? process.cwd()) + '/.env');
+    dotenv.config({ path });
+    const ret: Dictionary = {};
+    const array = (v: string) => v.split(',').map(vv => vv.trim());
+    const bool = (v: string) => ['true', 't', '1'].includes(v.toLowerCase());
+    const re = (v: string) => new RegExp(v);
+    const num = (v: string) => +v;
+    const read = (o: Dictionary, envKey: string, key: string, mapper: (v: string) => unknown = v => v) => {
+      if (!(envKey in process.env)) {
+        return;
+      }
+
+      const val = process.env[envKey]!;
+      o[key] = mapper(val);
+    };
+    const cleanup = (o: Dictionary, k: string) => Utils.hasObjectKeys(o[k]) ? {} : delete o[k];
+
+    read(ret, 'MIKRO_ORM_BASE_DIR', 'baseDir');
+    read(ret, 'MIKRO_ORM_TYPE', 'type');
+    read(ret, 'MIKRO_ORM_ENTITIES', 'entities', array);
+    read(ret, 'MIKRO_ORM_ENTITIES_TS', 'entitiesTs', array);
+    read(ret, 'MIKRO_ORM_CLIENT_URL', 'clientUrl');
+    read(ret, 'MIKRO_ORM_HOST', 'host');
+    read(ret, 'MIKRO_ORM_PORT', 'port', num);
+    read(ret, 'MIKRO_ORM_USER', 'user');
+    read(ret, 'MIKRO_ORM_PASSWORD', 'password');
+    read(ret, 'MIKRO_ORM_DB_NAME', 'dbName');
+    read(ret, 'MIKRO_ORM_LOAD_STRATEGY', 'loadStrategy');
+    read(ret, 'MIKRO_ORM_BATCH_SIZE', 'batchSize', num);
+    read(ret, 'MIKRO_ORM_USE_BATCH_INSERTS', 'useBatchInserts', bool);
+    read(ret, 'MIKRO_ORM_USE_BATCH_UPDATES', 'useBatchUpdates', bool);
+    read(ret, 'MIKRO_ORM_STRICT', 'strict', bool);
+    read(ret, 'MIKRO_ORM_VALIDATE', 'validate', bool);
+    read(ret, 'MIKRO_ORM_AUTO_JOIN_ONE_TO_ONE_OWNER', 'autoJoinOneToOneOwner', bool);
+    read(ret, 'MIKRO_ORM_PROPAGATE_TO_ONE_OWNER', 'propagateToOneOwner', bool);
+    read(ret, 'MIKRO_ORM_POPULATE_AFTER_FLUSH', 'populateAfterFlush', bool);
+    read(ret, 'MIKRO_ORM_FORCE_ENTITY_CONSTRUCTOR', 'forceEntityConstructor', bool);
+    read(ret, 'MIKRO_ORM_FORCE_UNDEFINED', 'forceUndefined', bool);
+    read(ret, 'MIKRO_ORM_FORCE_UTC_TIMEZONE', 'forceUtcTimezone', bool);
+    read(ret, 'MIKRO_ORM_TIMEZONE', 'timezone');
+    read(ret, 'MIKRO_ORM_ENSURE_INDEXES', 'ensureIndexes', bool);
+    read(ret, 'MIKRO_ORM_IMPLICIT_TRANSACTIONS', 'implicitTransactions', bool);
+    read(ret, 'MIKRO_ORM_DEBUG', 'debug', bool);
+    read(ret, 'MIKRO_ORM_VERBOSE', 'verbose', bool);
+
+    ret.discovery = {};
+    read(ret.discovery, 'MIKRO_ORM_DISCOVERY_WARN_WHEN_NO_ENTITIES', 'warnWhenNoEntities', bool);
+    read(ret.discovery, 'MIKRO_ORM_DISCOVERY_REQUIRE_ENTITIES_ARRAY', 'requireEntitiesArray', bool);
+    read(ret.discovery, 'MIKRO_ORM_DISCOVERY_ALWAYS_ANALYSE_PROPERTIES', 'alwaysAnalyseProperties', bool);
+    read(ret.discovery, 'MIKRO_ORM_DISCOVERY_DISABLE_DYNAMIC_FILE_ACCESS', 'disableDynamicFileAccess', bool);
+    cleanup(ret, 'discovery');
+
+    ret.migrations = {};
+    read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_TABLE_NAME', 'tableName');
+    read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_PATH', 'path');
+    read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_PATTERN', 'pattern', re);
+    read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_TRANSACTIONAL', 'transactional', bool);
+    read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_DISABLE_FOREIGN_KEYS', 'disableForeignKeys', bool);
+    read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_ALL_OR_NOTHING', 'allOrNothing', bool);
+    read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_DROP_TABLES', 'dropTables', bool);
+    read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_SAFE', 'safe', bool);
+    read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_EMIT', 'emit');
+    cleanup(ret, 'migrations');
+
+    return ret;
+  }
+
 }
 
 export interface Settings {

tests/MikroORM.test.ts

@@ -124,4 +124,28 @@ describe('MikroORM', () => {
     expect(await orm.isConnected()).toBe(false);
   });
 
+  test('should prefer environment variables', async () => {
+    process.env.MIKRO_ORM_ENV = __dirname + '/mikro-orm.env';
+    const orm = await MikroORM.init({ type: 'mongo' }, false);
+    Object.keys(process.env).filter(k => k.startsWith('MIKRO_ORM_')).forEach(k => delete process.env[k]);
+
+    expect(orm).toBeInstanceOf(MikroORM);
+    expect(orm.em).toBeInstanceOf(EntityManager);
+    expect(orm.config.getAll()).toMatchObject({
+      type: 'sqlite', // env vars have preference
+      entities: [ './entities-schema' ],
+      host: '123.0.0.4',
+      port: 1234,
+      user: 'string',
+      password: 'lol',
+      dbName: ':memory:',
+      populateAfterFlush: true,
+      forceEntityConstructor: true,
+      forceUndefined: true,
+      discovery: {},
+      migrations: { path: './dist/migrations', pattern: /^[\w-]+\d+\.js$/ },
+    });
+    expect(Object.keys(orm.getMetadata().getAll()).sort()).toEqual(['Author4', 'Book4', 'BookTag4', 'FooBar4', 'FooBaz4', 'Publisher4', 'Test4', 'User4', 'publisher4_tests', 'tags_ordered', 'tags_unordered']);
+  });
+
 });

tests/cli/CLIHelper.test.ts

@@ -95,6 +95,10 @@ describe('CLIHelper', () => {
 
   test('gets ORM configuration [no mikro-orm.config]', async () => {
     await expect(CLIHelper.getConfiguration()).rejects.toThrowError(`MikroORM config file not found in ['./mikro-orm.config.js']`);
+
+    process.env.MIKRO_ORM_ENV = __dirname + '/../mikro-orm.env';
+    await expect(CLIHelper.getConfiguration()).resolves.toBeInstanceOf(Configuration);
+    Object.keys(process.env).filter(k => k.startsWith('MIKRO_ORM_')).forEach(k => delete process.env[k]);
   });
 
   test('registerTsNode works with tsconfig.json with comments', async () => {
@@ -276,6 +280,7 @@ describe('CLIHelper', () => {
     pkg['mikro-orm'] = undefined;
     pathExistsMock.mockResolvedValue(true);
     await expect(ConfigurationLoader.getSettings()).resolves.toEqual({});
+    await expect(ConfigurationLoader.getConfiguration()).resolves.toBeInstanceOf(Configuration);
     pathExistsMock.mockRestore();
   });
 

tests/mikro-orm.env

@@ -0,0 +1,13 @@
+MIKRO_ORM_BASE_DIR = ./tests
+MIKRO_ORM_TYPE = sqlite
+MIKRO_ORM_ENTITIES = ./entities-schema
+MIKRO_ORM_HOST = 123.0.0.4
+MIKRO_ORM_PORT = 1234
+MIKRO_ORM_USER = string
+MIKRO_ORM_PASSWORD = lol
+MIKRO_ORM_DB_NAME = :memory:
+MIKRO_ORM_MIGRATIONS_PATH = ./dist/migrations
+MIKRO_ORM_MIGRATIONS_PATTERN = ^[\w-]+\d+\.js$
+MIKRO_ORM_POPULATE_AFTER_FLUSH = true
+MIKRO_ORM_FORCE_ENTITY_CONSTRUCTOR = true
+MIKRO_ORM_FORCE_UNDEFINED = true