@depup/typeorm-extension 3.9.0-depup.0

package/dist/index.cjs

@@ -0,0 +1,3258 @@
+'use strict';
+
+var locter = require('locter');
+var rapiq = require('rapiq');
+var process$1 = require('node:process');
+var typeorm = require('typeorm');
+var path = require('node:path');
+var fs = require('node:fs');
+var consola = require('consola');
+var envix = require('envix');
+var smob = require('smob');
+var DriverUtils = require('typeorm/driver/DriverUtils');
+var DriverFactory = require('typeorm/driver/DriverFactory');
+var pascalCase = require('pascal-case');
+var MigrationGenerateCommand = require('typeorm/commands/MigrationGenerateCommand');
+
+class TypeormExtensionError extends Error {
+}
+
+class DriverError extends TypeormExtensionError {
+    constructor(message){
+        super(message || 'A database driver related error has occurred.');
+    }
+    static undeterminable() {
+        return new DriverError('The driver could not be determined.');
+    }
+    static notSupported(driverName) {
+        return new DriverError(`The driver ${driverName} is not supported yet.`);
+    }
+}
+
+class OptionsError extends TypeormExtensionError {
+    constructor(message){
+        super(message || 'A database options related error has occurred');
+    }
+    static undeterminable() {
+        return new OptionsError('The database options could not be determined.');
+    }
+    static notFound() {
+        return new OptionsError('The database options could not be located/loaded.');
+    }
+    static databaseNotDefined() {
+        return new OptionsError('The database name to connect to is not defined.');
+    }
+}
+
+var CodeTransformation = /*#__PURE__*/ function(CodeTransformation) {
+    CodeTransformation["JUST_IN_TIME"] = "jit";
+    CodeTransformation["NONE"] = "none";
+    return CodeTransformation;
+}({});
+
+function detectCodeTransformation() {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    if (process$1[Symbol.for('ts-node.register.instance')]) {
+        return CodeTransformation.JUST_IN_TIME;
+    }
+    return CodeTransformation.NONE;
+}
+function isCodeTransformation(input) {
+    return detectCodeTransformation() === input;
+}
+
+function getEntityName(entity) {
+    if (typeof entity === 'function') {
+        return entity.name;
+    }
+    if (typeorm.InstanceChecker.isEntitySchema(entity)) {
+        return entity.options.name;
+    }
+    return new entity().constructor.name;
+}
+
+function canReplaceWindowsSeparator(input) {
+    // https://superuser.com/questions/176388/why-does-windows-use-backslashes-for-paths-and-unix-forward-slashes/176395#176395
+    if (input.startsWith('\\\\?\\')) {
+        return false;
+    }
+    let characterIndex;
+    const specialCharacters = [
+        '[',
+        '{',
+        '(',
+        '^',
+        '$',
+        '.',
+        '|',
+        '?',
+        '*',
+        '+'
+    ];
+    for(let i = 0; i < specialCharacters.length; i++){
+        characterIndex = input.indexOf(specialCharacters[i]);
+        if (characterIndex !== -1) {
+            // special character is prefixed with \, no transformation allowed
+            if (characterIndex !== 0 && input[characterIndex - 1] === '\\') {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function replaceWindowSeparator(input) {
+    return input.replace(/\\/g, '/');
+}
+function safeReplaceWindowsSeparator(input) {
+    if (input.indexOf('\\') === -1 || !canReplaceWindowsSeparator(input)) {
+        return input;
+    }
+    return replaceWindowSeparator(input);
+}
+
+const TRAILING_SLASH_RE = /\/$|\/\?/;
+function hasTrailingSlash(input = '', queryParams = false) {
+    if (!queryParams) {
+        return input.endsWith('/');
+    }
+    return TRAILING_SLASH_RE.test(input);
+}
+function withoutTrailingSlash(input = '', queryParams = false) {
+    if (!queryParams) {
+        return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || '/';
+    }
+    if (!hasTrailingSlash(input, true)) {
+        return input || '/';
+    }
+    const [s0, ...s] = input.split('?');
+    return (s0.slice(0, -1) || '/') + (s.length ? `?${s.join('?')}` : '');
+}
+
+async function readTSConfig(input) {
+    input = input || process.cwd();
+    input = path.isAbsolute(input) ? input : path.resolve(process.cwd(), input);
+    const filePath = input.indexOf('.json') === -1 ? path.join(input, 'tsconfig.json') : input;
+    try {
+        const tsConfig = await locter.load(filePath);
+        if (locter.isObject(tsConfig)) {
+            return tsConfig;
+        }
+    } catch (e) {
+    // don't do anything ;)
+    }
+    return {};
+}
+
+const stripLeadingModifier = (text)=>{
+    if (text.startsWith('./')) {
+        text = text.substring(2);
+    }
+    return text;
+};
+function transformFilePath(input, dist, src) {
+    let separator = path.sep;
+    const windowsSeparatorReplaceable = canReplaceWindowsSeparator(input);
+    if (windowsSeparatorReplaceable) {
+        separator = '/';
+        input = replaceWindowSeparator(input);
+    }
+    let base = input;
+    let baseIndex = input.lastIndexOf(separator);
+    if (baseIndex !== -1) {
+        base = base.substring(baseIndex + 1);
+    }
+    if (src) {
+        if (windowsSeparatorReplaceable) {
+            src = replaceWindowSeparator(src);
+        }
+        src = withoutTrailingSlash(stripLeadingModifier(src));
+    }
+    src = src || 'src';
+    if (dist) {
+        if (windowsSeparatorReplaceable) {
+            dist = replaceWindowSeparator(dist);
+        }
+        dist = withoutTrailingSlash(stripLeadingModifier(dist));
+    }
+    dist = dist || 'dist';
+    if (input.indexOf(src) !== -1 && input.indexOf(dist) === -1) {
+        const lastIndex = input.lastIndexOf(src);
+        const prevCharacter = input.substring(lastIndex - 1, lastIndex);
+        if (!prevCharacter || prevCharacter === separator) {
+            input = input.substring(0, lastIndex) + dist + input.substring(lastIndex + src.length);
+            baseIndex = input.lastIndexOf(separator);
+        }
+    }
+    // if the path already contains a js file extension, we are done
+    const jsExtensions = [
+        'js',
+        'cjs',
+        'mjs'
+    ];
+    for(let i = 0; i < jsExtensions.length; i++){
+        if (base.indexOf(jsExtensions[i]) !== -1) {
+            return input;
+        }
+    }
+    const tsExtensions = [
+        'ts',
+        'cts',
+        'mts'
+    ];
+    for(let i = 0; i < tsExtensions.length; i++){
+        const regex = new RegExp(`(\\.${tsExtensions[i]}|${tsExtensions[i]})`, 'g');
+        let matchesSum;
+        const matches = base.match(regex);
+        if (Array.isArray(matches)) {
+            matchesSum = matches.length;
+        }
+        let matchesCounter = 0;
+        const bracketIndex = base.lastIndexOf('{');
+        base = base.replace(regex, (...args)=>{
+            matchesCounter++;
+            // if the file extension name comes after the last bracket index,
+            // we can be pretty sure that the extension name is not part of a filename
+            if (args[2] >= bracketIndex && bracketIndex !== -1 || bracketIndex === -1 && matchesCounter === matchesSum) {
+                return args[0].startsWith('.') ? `.${jsExtensions[i]}` : jsExtensions[i];
+            }
+            return args[0];
+        });
+    }
+    if (baseIndex !== -1) {
+        base = input.substring(0, baseIndex + 1) + base;
+    }
+    return stripLeadingModifier(base);
+}
+async function adjustFilePath(input, tsconfig) {
+    if (isCodeTransformation(CodeTransformation.JUST_IN_TIME)) {
+        return input;
+    }
+    if (!locter.isObject(tsconfig)) {
+        tsconfig = await readTSConfig(tsconfig);
+    }
+    const { compilerOptions } = tsconfig;
+    if (typeof input === 'string') {
+        return transformFilePath(input, compilerOptions?.outDir);
+    }
+    if (Array.isArray(input)) {
+        for(let i = 0; i < input.length; i++){
+            if (typeof input[i] === 'string') {
+                input[i] = transformFilePath(input[i], compilerOptions?.outDir);
+            }
+        }
+    }
+    return input;
+}
+async function adjustFilePaths(input, keys, tsconfig) {
+    if (isCodeTransformation(CodeTransformation.JUST_IN_TIME)) {
+        return input;
+    }
+    if (!locter.isObject(tsconfig)) {
+        tsconfig = await readTSConfig(tsconfig);
+    }
+    keys = keys || Object.keys(input);
+    for(let i = 0; i < keys.length; i++){
+        input[keys[i]] = await adjustFilePath(input[keys[i]], tsconfig);
+    }
+    return input;
+}
+function resolveFilePath(filePath, root) {
+    if (path.isAbsolute(filePath)) {
+        return filePath;
+    }
+    return filePath.startsWith('/') ? filePath : path.resolve(root || process.cwd(), filePath);
+}
+function parseFilePath(filePath, root) {
+    const fullPath = resolveFilePath(filePath, root);
+    const directory = path.dirname(fullPath);
+    const name = path.basename(fullPath);
+    return {
+        directory,
+        name
+    };
+}
+
+async function isDirectory(input) {
+    try {
+        const stat = await fs.promises.stat(input);
+        return stat.isDirectory();
+    } catch (e) {
+        return false;
+    }
+}
+
+function hasOwnProperty(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+function hasStringProperty(obj, prop) {
+    return hasOwnProperty(obj, prop) && typeof obj[prop] === 'string';
+}
+
+function pickRecord(data, keys) {
+    const output = {};
+    for(let i = 0; i < keys.length; i++){
+        output[keys[i]] = data[keys[i]];
+    }
+    return output;
+}
+function extendObject(target, source) {
+    const keys = Object.keys(source);
+    for(let i = 0; i < keys.length; i++){
+        target[keys[i]] = source[keys[i]];
+    }
+    return target;
+}
+
+function isPromise(p) {
+    return locter.isObject(p) && (p instanceof Promise || // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    typeof p.then === 'function');
+}
+
+function getAliasForPath(items, path) {
+    if (typeof path === 'undefined' || typeof items === 'undefined') {
+        return undefined;
+    }
+    for(let i = 0; i < items.length; i++){
+        if (items[i].key === path) {
+            return items[i].value;
+        }
+    }
+    return undefined;
+}
+
+function buildKeyWithPrefix(name, prefix) {
+    if (prefix) {
+        return `${prefix}.${name}`;
+    }
+    return name;
+}
+
+function isQueryOptionDefined(input, option) {
+    if (typeof input === 'boolean') {
+        return false;
+    }
+    const options = Array.isArray(option) ? option : [
+        option
+    ];
+    for(let i = 0; i < options.length; i++){
+        if (hasOwnProperty(input, options[i])) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * Apply parsed fields parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ */ /* istanbul ignore next */ function applyQueryFieldsParseOutput(query, data, options = {}) {
+    if (data.length === 0) {
+        return data;
+    }
+    query.select(data.map((field)=>{
+        const alias = getAliasForPath(options.relations, field.path) || options.defaultAlias || options.defaultPath;
+        return buildKeyWithPrefix(field.key, alias);
+    }));
+    return data;
+}
+/**
+ * Apply raw fields parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */ function applyQueryFields(query, data, options) {
+    options = options || {};
+    if (options.defaultAlias) {
+        options.defaultPath = options.defaultAlias;
+    }
+    return applyQueryFieldsParseOutput(query, rapiq.parseQueryFields(data, options), options);
+}
+/**
+ * Apply raw fields parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */ function applyFields(query, data, options) {
+    return applyQueryFields(query, data, options);
+}
+
+// --------------------------------------------------
+function transformParsedFilters(data, options = {}) {
+    const items = [];
+    for(let i = 0; i < data.length; i++){
+        const alias = getAliasForPath(options.relations, data[i].path) || options.defaultAlias || options.defaultPath;
+        const fullKey = buildKeyWithPrefix(data[i].key, alias);
+        const filter = data[i];
+        const statement = [
+            fullKey
+        ];
+        let bindingKey;
+        if (options.bindingKey) {
+            bindingKey = options.bindingKey(fullKey).replace('.', '_');
+        } else {
+            bindingKey = `filter_${fullKey.replace('.', '_')}`;
+        }
+        if (filter.value === null || typeof filter.value === 'undefined') {
+            statement.push('IS');
+            if (filter.operator === rapiq.FilterComparisonOperator.NOT_EQUAL) {
+                statement.push('NOT');
+            }
+            statement.push('NULL');
+            items.push({
+                statement: statement.join(' '),
+                binding: {}
+            });
+            continue;
+        }
+        switch(filter.operator){
+            case rapiq.FilterComparisonOperator.EQUAL:
+            case rapiq.FilterComparisonOperator.NOT_EQUAL:
+                {
+                    if (filter.operator === rapiq.FilterComparisonOperator.EQUAL) {
+                        statement.push('=');
+                    } else {
+                        statement.push('!=');
+                    }
+                    statement.push(`:${bindingKey}`);
+                    break;
+                }
+            case rapiq.FilterComparisonOperator.LIKE:
+            case rapiq.FilterComparisonOperator.NOT_LIKE:
+                {
+                    if (filter.operator === rapiq.FilterComparisonOperator.NOT_LIKE) {
+                        statement.push('NOT');
+                    }
+                    statement.push('LIKE');
+                    statement.push(`:${bindingKey}`);
+                    filter.value += '%';
+                    break;
+                }
+            case rapiq.FilterComparisonOperator.IN:
+            case rapiq.FilterComparisonOperator.NOT_IN:
+                {
+                    if (filter.operator === rapiq.FilterComparisonOperator.NOT_IN) {
+                        statement.push('NOT');
+                    }
+                    statement.push('IN');
+                    statement.push(`(:...${bindingKey})`);
+                    if (Array.isArray(filter.value)) {
+                        const nullIndex = filter.value.indexOf(null);
+                        if (nullIndex !== -1) {
+                            filter.value.splice(nullIndex, 1);
+                            statement.unshift('(');
+                            if (filter.operator === rapiq.FilterComparisonOperator.NOT_IN) {
+                                statement.push('AND');
+                            } else {
+                                statement.push('OR');
+                            }
+                            statement.push(fullKey);
+                            statement.push('IS');
+                            if (filter.operator === rapiq.FilterComparisonOperator.NOT_IN) {
+                                statement.push('NOT');
+                            }
+                            statement.push('NULL');
+                            statement.push(')');
+                        }
+                    }
+                    break;
+                }
+            case rapiq.FilterComparisonOperator.LESS_THAN:
+            case rapiq.FilterComparisonOperator.LESS_THAN_EQUAL:
+            case rapiq.FilterComparisonOperator.GREATER_THAN:
+            case rapiq.FilterComparisonOperator.GREATER_THAN_EQUAL:
+                {
+                    if (filter.operator === rapiq.FilterComparisonOperator.LESS_THAN) {
+                        statement.push('<');
+                    } else if (filter.operator === rapiq.FilterComparisonOperator.LESS_THAN_EQUAL) {
+                        statement.push('<=');
+                    } else if (filter.operator === rapiq.FilterComparisonOperator.GREATER_THAN) {
+                        statement.push('>');
+                    } else {
+                        statement.push('>=');
+                    }
+                    statement.push(`:${bindingKey}`);
+                    break;
+                }
+        }
+        items.push({
+            statement: statement.join(' '),
+            binding: {
+                [bindingKey]: filter.value
+            }
+        });
+    }
+    return items;
+}
+/**
+ * Apply transformed filter[s] parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ */ function applyFiltersTransformed(query, data) {
+    if (data.length === 0) {
+        return data;
+    }
+    /* istanbul ignore next */ query.andWhere(new typeorm.Brackets((qb)=>{
+        for(let i = 0; i < data.length; i++){
+            if (i === 0) {
+                qb.where(data[i].statement, data[i].binding);
+            } else {
+                qb.andWhere(data[i].statement, data[i].binding);
+            }
+        }
+    }));
+    return data;
+}
+/**
+ * Apply parsed filter[s] parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */ function applyQueryFiltersParseOutput(query, data, options) {
+    applyFiltersTransformed(query, transformParsedFilters(data, options));
+    return data;
+}
+// --------------------------------------------------
+/**
+ * Apply raw filter[s] parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */ function applyQueryFilters(query, data, options) {
+    options = options || {};
+    if (options.defaultAlias) {
+        options.defaultPath = options.defaultAlias;
+    }
+    return applyQueryFiltersParseOutput(query, rapiq.parseQueryFilters(data, options), options);
+}
+/**
+ * Apply raw filter[s] parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */ function applyFilters(query, data, options) {
+    return applyQueryFilters(query, data, options);
+}
+
+/**
+ * Apply parsed page/pagination parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ */ function applyQueryPaginationParseOutput(query, data) {
+    /* istanbul ignore next */ if (typeof data.limit !== 'undefined') {
+        query.take(data.limit);
+        if (typeof data.offset === 'undefined') {
+            query.skip(0);
+        }
+    }
+    /* istanbul ignore next */ if (typeof data.offset !== 'undefined') {
+        query.skip(data.offset);
+    }
+    return data;
+}
+/**
+ * Apply raw page/pagination parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */ function applyQueryPagination(query, data, options) {
+    return applyQueryPaginationParseOutput(query, rapiq.parseQueryPagination(data, options));
+}
+/**
+ * Apply raw page/pagination parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */ function applyPagination(query, data, options) {
+    return applyQueryPagination(query, data, options);
+}
+
+/**
+ * Apply parsed include/relation parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */ function applyQueryRelationsParseOutput(query, data, options = {}) {
+    for(let i = 0; i < data.length; i++){
+        const parts = data[i].key.split('.');
+        let key;
+        if (parts.length > 1) {
+            key = parts.slice(-2).join('.');
+        } else {
+            key = buildKeyWithPrefix(data[i].key, options.defaultAlias);
+        }
+        data[i].key = key;
+        /* istanbul ignore next */ query.leftJoinAndSelect(key, data[i].value);
+        if (options.onJoin) {
+            options.onJoin(key, data[i].value, query);
+        }
+    }
+    return data;
+}
+/**
+ * Apply raw include/relations parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */ function applyQueryRelations(query, data, options = {}) {
+    return applyQueryRelationsParseOutput(query, rapiq.parseQueryRelations(data, options), options);
+}
+/**
+ * Apply raw include/relations parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */ function applyRelations(query, data, options = {}) {
+    return applyQueryRelations(query, data, options);
+}
+
+// --------------------------------------------------
+/**
+ * Apply parsed sort parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ */ function applyQuerySortParseOutput(query, data) {
+    if (data.length === 0) {
+        return data;
+    }
+    const sort = {};
+    for(let i = 0; i < data.length; i++){
+        const key = buildKeyWithPrefix(data[i].key, data[i].path);
+        sort[key] = data[i].value;
+    }
+    query.orderBy(sort);
+    return data;
+}
+/**
+ * Apply raw sort parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */ function applyQuerySort(query, data, options) {
+    options = options || {};
+    if (options.defaultAlias) {
+        options.defaultPath = options.defaultAlias;
+    }
+    return applyQuerySortParseOutput(query, rapiq.parseQuerySort(data, options));
+}
+/**
+ * Apply raw sort parameter data on the db query.
+ *
+ * @param query
+ * @param data
+ * @param options
+ */ function applySort(query, data, options) {
+    return applyQuerySort(query, data, options);
+}
+
+function applyQueryParseOutput(query, context, options = {}) {
+    if (context.fields) {
+        applyQueryFieldsParseOutput(query, context.fields, {
+            defaultAlias: context.defaultPath,
+            relations: context.relations
+        });
+    }
+    if (context.filters) {
+        applyQueryFiltersParseOutput(query, context.filters, {
+            defaultAlias: context.defaultPath,
+            relations: context.relations
+        });
+    }
+    if (context.pagination) {
+        applyQueryPaginationParseOutput(query, context.pagination);
+    }
+    if (context.relations) {
+        const relations = {
+            defaultAlias: context.defaultPath
+        };
+        if (locter.isObject(options.relations)) {
+            extendObject(relations, options.relations);
+        }
+        applyQueryRelationsParseOutput(query, context.relations, relations);
+    }
+    if (context.sort) {
+        applyQuerySortParseOutput(query, context.sort);
+    }
+    return context;
+}
+function applyQuery(query, input, options = {}) {
+    if (options.defaultAlias) {
+        options.defaultPath = options.defaultAlias;
+    }
+    if (typeof options.fields === 'undefined' || !isQueryOptionDefined(options.fields, [
+        'allowed',
+        'default'
+    ])) {
+        options.fields = false;
+    }
+    if (typeof options.filters === 'undefined' || !isQueryOptionDefined(options.filters, [
+        'allowed',
+        'default'
+    ])) {
+        options.filters = false;
+    }
+    if (options.pagination) {
+        if (!input.pagination && !input.page) {
+            input.pagination = input.pagination || {};
+        }
+    } else {
+        options.pagination = false;
+    }
+    if (typeof options.relations === 'undefined' || !isQueryOptionDefined(options.relations, [
+        'allowed'
+    ])) {
+        options.relations = false;
+    }
+    if (typeof options.sort === 'undefined' || !isQueryOptionDefined(options.sort, [
+        'allowed',
+        'default'
+    ])) {
+        options.sort = false;
+    }
+    const output = applyQueryParseOutput(query, rapiq.parseQuery(input, options), options);
+    return {
+        ...output,
+        ...options.defaultAlias ? {
+            defaultAlias: options.defaultAlias
+        } : {}
+    };
+}
+
+async function findDataSource(context = {}) {
+    let tsconfig;
+    if (!context.preserveFilePaths) {
+        if (locter.isObject(context.tsconfig)) {
+            tsconfig = context.tsconfig;
+        } else {
+            tsconfig = await readTSConfig(context.tsconfig);
+        }
+    }
+    const files = [
+        'data-source'
+    ];
+    if (context.fileName) {
+        context.fileName = locter.removeFileNameExtension(context.fileName, [
+            '.ts',
+            '.mts',
+            '.cts',
+            '.js',
+            '.mjs',
+            '.cjs'
+        ]);
+        if (context.fileName !== 'data-source') {
+            files.unshift(context.fileName);
+        }
+    }
+    let { directory } = context;
+    let directoryIsPattern = false;
+    if (context.directory) {
+        if (path.isAbsolute(context.directory)) {
+            directory = context.directory;
+        } else {
+            directoryIsPattern = true;
+            directory = safeReplaceWindowsSeparator(context.directory);
+        }
+        if (!context.preserveFilePaths) {
+            directory = await adjustFilePath(directory, tsconfig);
+        }
+    }
+    const lookupPaths = [];
+    for(let j = 0; j < files.length; j++){
+        if (directory && directoryIsPattern) {
+            lookupPaths.push(path.posix.join(directory, files[j]));
+        }
+        lookupPaths.push(...[
+            path.posix.join('src', files[j]),
+            path.posix.join('src/{db,database}', files[j])
+        ]);
+    }
+    files.push(...lookupPaths);
+    if (!context.preserveFilePaths) {
+        for(let j = 0; j < files.length; j++){
+            files[j] = await adjustFilePath(files[j], tsconfig);
+        }
+    }
+    for(let i = 0; i < files.length; i++){
+        const info = await locter.locate(`${files[i]}.{js,cjs,mjs,ts,cts,mts}`, {
+            path: [
+                process.cwd(),
+                ...directory && !directoryIsPattern ? [
+                    directory
+                ] : []
+            ],
+            ignore: [
+                '**/*.d.ts'
+            ]
+        });
+        if (info) {
+            let moduleRecord = await locter.load(info);
+            if (isPromise(moduleRecord)) {
+                moduleRecord = await moduleRecord;
+            }
+            if (typeorm.InstanceChecker.isDataSource(moduleRecord)) {
+                return moduleRecord;
+            }
+            if (!locter.isObject(moduleRecord)) {
+                continue;
+            }
+            const keys = Object.keys(moduleRecord);
+            for(let j = 0; j < keys.length; j++){
+                let value = moduleRecord[keys[j]];
+                if (isPromise(value)) {
+                    value = await value;
+                }
+                if (typeorm.InstanceChecker.isDataSource(value)) {
+                    return value;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+
+/*
+ * Copyright (c) 2023-2023.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ var EnvironmentName = /*#__PURE__*/ function(EnvironmentName) {
+    EnvironmentName["DEVELOPMENT"] = "development";
+    EnvironmentName["PRODUCTION"] = "production";
+    EnvironmentName["TEST"] = "test";
+    return EnvironmentName;
+}({});
+var EnvironmentVariableName = /*#__PURE__*/ function(EnvironmentVariableName) {
+    EnvironmentVariableName["ENV"] = "NODE_ENV";
+    // Seeder
+    EnvironmentVariableName["SEEDS"] = "DB_SEEDS";
+    EnvironmentVariableName["SEEDS_ALT"] = "TYPEORM_SEEDING_SEEDS";
+    EnvironmentVariableName["FACTORIES"] = "DB_FACTORIES";
+    EnvironmentVariableName["FACTORIES_ALT"] = "TYPEORM_SEEDING_FACTORIES";
+    // Database
+    EnvironmentVariableName["TYPE"] = "DB_TYPE";
+    EnvironmentVariableName["TYPE_ALT"] = "TYPEORM_CONNECTION";
+    EnvironmentVariableName["URL"] = "DB_URL";
+    EnvironmentVariableName["URL_ALT"] = "TYPEORM_URL";
+    EnvironmentVariableName["HOST"] = "DB_HOST";
+    EnvironmentVariableName["HOST_ALT"] = "TYPEORM_HOST";
+    EnvironmentVariableName["PORT"] = "DB_PORT";
+    EnvironmentVariableName["PORT_ALT"] = "TYPEORM_PORT";
+    EnvironmentVariableName["USERNAME"] = "DB_USERNAME";
+    EnvironmentVariableName["USERNAME_ALT"] = "TYPEORM_USERNAME";
+    EnvironmentVariableName["PASSWORD"] = "DB_PASSWORD";
+    EnvironmentVariableName["PASSWORD_ALT"] = "TYPEORM_PASSWORD";
+    EnvironmentVariableName["DATABASE"] = "DB_DATABASE";
+    EnvironmentVariableName["DATABASE_ALT"] = "TYPEORM_DATABASE";
+    EnvironmentVariableName["SID"] = "DB_SID";
+    EnvironmentVariableName["SID_ALT"] = "TYPEORM_SID";
+    EnvironmentVariableName["SCHEMA"] = "DB_SCHEMA";
+    EnvironmentVariableName["SCHEMA_ALT"] = "TYPEORM_SCHEMA";
+    EnvironmentVariableName["SCHEMA_DROP"] = "DB_DROP_SCHEMA";
+    EnvironmentVariableName["SCHEMA_DROP_ALT"] = "TYPEORM_DROP_SCHEMA";
+    EnvironmentVariableName["DRIVER_EXTRA"] = "DB_DRIVER_EXTRA";
+    EnvironmentVariableName["DRIVER_EXTRA_ALT"] = "TYPEORM_DRIVER_EXTRA";
+    EnvironmentVariableName["SYNCHRONIZE"] = "DB_SYNCHRONIZE";
+    EnvironmentVariableName["SYNCHRONIZE_ALT"] = "TYPEORM_SYNCHRONIZE";
+    EnvironmentVariableName["MIGRATIONS"] = "DB_MIGRATIONS";
+    EnvironmentVariableName["MIGRATIONS_ALT"] = "TYPEORM_MIGRATIONS";
+    EnvironmentVariableName["MIGRATIONS_RUN"] = "DB_MIGRATIONS_RUN";
+    EnvironmentVariableName["MIGRATIONS_RUN_ALT"] = "TYPEORM_MIGRATIONS_RUN";
+    EnvironmentVariableName["MIGRATIONS_TABLE_NAME"] = "DB_MIGRATIONS_TABLE_NAME";
+    EnvironmentVariableName["MIGRATIONS_TABLE_NAME_ALT"] = "TYPEORM_MIGRATIONS_TABLE_NAME";
+    EnvironmentVariableName["ENTITIES"] = "DB_ENTITIES";
+    EnvironmentVariableName["ENTITIES_ALT"] = "TYPEORM_ENTITIES";
+    EnvironmentVariableName["ENTITY_PREFIX"] = "DB_ENTITY_PREFIX";
+    EnvironmentVariableName["ENTITY_PREFIX_ALT"] = "TYPEORM_ENTITY_PREFIX";
+    EnvironmentVariableName["METADATA_TABLE_NAME"] = "DB_METADATA_TABLE_NAME";
+    EnvironmentVariableName["METADATA_TABLE_NAME_ALT"] = "TYPEORM_METADATA_TABLE_NAME";
+    EnvironmentVariableName["SUBSCRIBERS"] = "DB_SUBSCRIBERS";
+    EnvironmentVariableName["SUBSCRIBERS_ALT"] = "TYPEORM_SUBSCRIBERS";
+    EnvironmentVariableName["LOGGING"] = "DB_LOGGING";
+    EnvironmentVariableName["LOGGING_ALT"] = "TYPEORM_LOGGING";
+    EnvironmentVariableName["LOGGER"] = "DB_LOGGER";
+    EnvironmentVariableName["LOGGER_ALT"] = "TYPEORM_LOGGER";
+    EnvironmentVariableName["MAX_QUERY_EXECUTION_TIME"] = "DB_MAX_QUERY_EXECUTION_TIME";
+    EnvironmentVariableName["MAX_QUERY_EXECUTION_TIME_ALT"] = "TYPEORM_MAX_QUERY_EXECUTION_TIME";
+    EnvironmentVariableName["DEBUG"] = "DB_DEBUG";
+    EnvironmentVariableName["DEBUG_ALT"] = "TYPEORM_DEBUG";
+    EnvironmentVariableName["UUID_EXTENSION"] = "DB_UUID_EXTENSION";
+    EnvironmentVariableName["UUID_EXTENSION_ALT"] = "TYPEORM_UUID_EXTENSION";
+    EnvironmentVariableName["CACHE"] = "DB_CACHE";
+    EnvironmentVariableName["CACHE_ALT"] = "TYPEORM_CACHE";
+    EnvironmentVariableName["CACHE_ALWAYS_ENABLED"] = "DB_CACHE_ALWAYS_ENABLED";
+    EnvironmentVariableName["CACHE_ALWAYS_ENABLED_ALT"] = "TYPEORM_CACHE_ALWAYS_ENABLED";
+    EnvironmentVariableName["CACHE_OPTIONS"] = "DB_CACHE_OPTIONS";
+    EnvironmentVariableName["CACHE_OPTIONS_ALT"] = "TYPEORM_CACHE_OPTIONS";
+    EnvironmentVariableName["CACHE_DURATION"] = "DB_CACHE_DURATION";
+    EnvironmentVariableName["CACHE_DURATION_ALT"] = "TYPEORM_CACHE_DURATION";
+    return EnvironmentVariableName;
+}({});
+
+function transformLogging(input) {
+    const value = envix.toBool(input);
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (input === 'all') {
+        return 'all';
+    }
+    return envix.toArray(input) ?? [];
+}
+function transformCache(input) {
+    const value = envix.toBool(input);
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (input === 'redis' || input === 'ioredis' || input === 'database' || input === 'ioredis/cluster') {
+        let options;
+        const envCacheOptions = envix.oneOf([
+            envix.read(EnvironmentVariableName.CACHE_OPTIONS),
+            envix.read(EnvironmentVariableName.CACHE_OPTIONS_ALT)
+        ]);
+        if (envCacheOptions) {
+            options = JSON.parse(envCacheOptions);
+        }
+        return {
+            type: input,
+            options,
+            alwaysEnabled: envix.oneOf([
+                envix.readBool(EnvironmentVariableName.CACHE_ALWAYS_ENABLED),
+                envix.readBool(EnvironmentVariableName.CACHE_ALWAYS_ENABLED_ALT)
+            ]),
+            duration: envix.oneOf([
+                envix.readInt(EnvironmentVariableName.CACHE_DURATION),
+                envix.readInt(EnvironmentVariableName.CACHE_DURATION_ALT)
+            ])
+        };
+    }
+    return undefined;
+}
+
+let instance$1;
+function useEnv(key) {
+    if (typeof instance$1 !== 'undefined') {
+        if (typeof key === 'string') {
+            return instance$1[key];
+        }
+        return instance$1;
+    }
+    const output = {
+        env: envix.read(EnvironmentVariableName.ENV, EnvironmentName.DEVELOPMENT),
+        // Seeder
+        seeds: envix.oneOf([
+            envix.readArray(EnvironmentVariableName.SEEDS),
+            envix.readArray(EnvironmentVariableName.SEEDS_ALT)
+        ]) ?? [],
+        factories: envix.oneOf([
+            envix.readArray(EnvironmentVariableName.FACTORIES),
+            envix.readArray(EnvironmentVariableName.FACTORIES_ALT)
+        ]) ?? [],
+        // Database
+        url: envix.oneOf([
+            envix.read(EnvironmentVariableName.URL),
+            envix.read(EnvironmentVariableName.URL_ALT)
+        ]),
+        host: envix.oneOf([
+            envix.read(EnvironmentVariableName.HOST),
+            envix.read(EnvironmentVariableName.HOST_ALT)
+        ]),
+        port: envix.oneOf([
+            envix.readInt(EnvironmentVariableName.PORT),
+            envix.readInt(EnvironmentVariableName.PORT_ALT)
+        ]),
+        username: envix.oneOf([
+            envix.read(EnvironmentVariableName.USERNAME),
+            envix.read(EnvironmentVariableName.USERNAME_ALT)
+        ]),
+        password: envix.oneOf([
+            envix.read(EnvironmentVariableName.PASSWORD),
+            envix.read(EnvironmentVariableName.PASSWORD_ALT)
+        ]),
+        database: envix.oneOf([
+            envix.read(EnvironmentVariableName.DATABASE),
+            envix.read(EnvironmentVariableName.DATABASE_ALT)
+        ]),
+        sid: envix.oneOf([
+            envix.read(EnvironmentVariableName.SID),
+            envix.read(EnvironmentVariableName.SID_ALT)
+        ]),
+        schema: envix.oneOf([
+            envix.read(EnvironmentVariableName.SCHEMA),
+            envix.read(EnvironmentVariableName.SCHEMA_ALT)
+        ]),
+        extra: envix.oneOf([
+            envix.read(EnvironmentVariableName.DRIVER_EXTRA),
+            envix.read(EnvironmentVariableName.DRIVER_EXTRA_ALT)
+        ]),
+        synchronize: envix.oneOf([
+            envix.readBool(EnvironmentVariableName.SYNCHRONIZE),
+            envix.readBool(EnvironmentVariableName.SYNCHRONIZE_ALT)
+        ]),
+        schemaDrop: envix.oneOf([
+            envix.readBool(EnvironmentVariableName.SCHEMA_DROP),
+            envix.readBool(EnvironmentVariableName.SCHEMA_DROP_ALT)
+        ]),
+        migrationsRun: envix.oneOf([
+            envix.readBool(EnvironmentVariableName.MIGRATIONS_RUN),
+            envix.readBool(EnvironmentVariableName.MIGRATIONS_RUN_ALT)
+        ]),
+        entities: envix.oneOf([
+            envix.readArray(EnvironmentVariableName.ENTITIES),
+            envix.readArray(EnvironmentVariableName.ENTITIES_ALT)
+        ]) ?? [],
+        migrations: envix.oneOf([
+            envix.readArray(EnvironmentVariableName.MIGRATIONS),
+            envix.readArray(EnvironmentVariableName.MIGRATIONS_ALT)
+        ]) ?? [],
+        migrationsTableName: envix.oneOf([
+            envix.read(EnvironmentVariableName.MIGRATIONS_TABLE_NAME),
+            envix.read(EnvironmentVariableName.MIGRATIONS_TABLE_NAME_ALT)
+        ]),
+        metadataTableName: envix.oneOf([
+            envix.read(EnvironmentVariableName.METADATA_TABLE_NAME),
+            envix.read(EnvironmentVariableName.METADATA_TABLE_NAME_ALT)
+        ]),
+        subscribers: envix.oneOf([
+            envix.readArray(EnvironmentVariableName.SUBSCRIBERS),
+            envix.readArray(EnvironmentVariableName.SUBSCRIBERS_ALT)
+        ]) ?? [],
+        logging: transformLogging(envix.oneOf([
+            envix.read(EnvironmentVariableName.LOGGING),
+            envix.read(EnvironmentVariableName.LOGGING_ALT)
+        ])),
+        logger: envix.oneOf([
+            envix.read(EnvironmentVariableName.LOGGER),
+            envix.read(EnvironmentVariableName.LOGGER_ALT)
+        ]),
+        entityPrefix: envix.oneOf([
+            envix.read(EnvironmentVariableName.ENTITY_PREFIX),
+            envix.read(EnvironmentVariableName.ENTITY_PREFIX_ALT)
+        ]),
+        maxQueryExecutionTime: envix.oneOf([
+            envix.readInt(EnvironmentVariableName.MAX_QUERY_EXECUTION_TIME),
+            envix.readInt(EnvironmentVariableName.MAX_QUERY_EXECUTION_TIME_ALT)
+        ]),
+        debug: envix.oneOf([
+            envix.read(EnvironmentVariableName.DEBUG),
+            envix.read(EnvironmentVariableName.DEBUG_ALT)
+        ]),
+        cache: transformCache(envix.oneOf([
+            envix.read(EnvironmentVariableName.CACHE),
+            envix.read(EnvironmentVariableName.CACHE_ALT)
+        ])),
+        uuidExtension: envix.oneOf([
+            envix.read(EnvironmentVariableName.UUID_EXTENSION),
+            envix.read(EnvironmentVariableName.UUID_EXTENSION_ALT)
+        ])
+    };
+    if (output.extra) {
+        output.extra = JSON.parse(output.extra); // todo: ensure record<string,any> ??
+    }
+    let type;
+    const envType = envix.oneOf([
+        envix.read(EnvironmentVariableName.TYPE),
+        envix.read(EnvironmentVariableName.TYPE_ALT)
+    ]);
+    if (envType) {
+        type = envType;
+    } else {
+        const envURL = envix.oneOf([
+            envix.read(EnvironmentVariableName.URL),
+            envix.read(EnvironmentVariableName.URL_ALT)
+        ]);
+        if (envURL) {
+            [type] = envURL.split('://');
+        }
+    }
+    if (type) {
+        output.type = type; // todo: maybe validation here
+    }
+    instance$1 = output;
+    if (typeof key === 'string') {
+        return output[key];
+    }
+    return instance$1;
+}
+function resetEnv() {
+    if (typeof instance$1 !== 'undefined') {
+        instance$1 = undefined;
+    }
+}
+
+const merge = smob.createMerger({
+    strategy: (target, key, value)=>{
+        if (typeof target[key] === 'undefined') {
+            target[key] = value;
+            return target;
+        }
+        return undefined;
+    }
+});
+function mergeDataSourceOptions(target, source) {
+    if (target.type !== source.type) {
+        return target;
+    }
+    return merge(target, source);
+}
+
+function hasEnvDataSourceOptions() {
+    return !!useEnv('type');
+}
+/* istanbul ignore next */ function readDataSourceOptionsFromEnv() {
+    if (!hasEnvDataSourceOptions()) {
+        return undefined;
+    }
+    // todo: include seeder options
+    const base = {
+        type: useEnv('type'),
+        entities: useEnv('entities'),
+        subscribers: useEnv('subscribers'),
+        migrations: useEnv('migrations'),
+        migrationsTableName: useEnv('migrationsTableName'),
+        // migrationsTransactionMode: useEnv('migra')
+        metadataTableName: useEnv('metadataTableName'),
+        logging: useEnv('logging'),
+        logger: useEnv('logger'),
+        maxQueryExecutionTime: useEnv('maxQueryExecutionTime'),
+        synchronize: useEnv('synchronize'),
+        migrationsRun: useEnv('migrationsRun'),
+        dropSchema: useEnv('schemaDrop'),
+        entityPrefix: useEnv('entityPrefix'),
+        extra: useEnv('extra'),
+        cache: useEnv('cache')
+    };
+    const credentialOptions = {
+        url: useEnv('url'),
+        host: useEnv('host'),
+        port: useEnv('port'),
+        username: useEnv('username'),
+        password: useEnv('password'),
+        database: useEnv('database')
+    };
+    if (base.type === 'mysql' || base.type === 'mariadb') {
+        return {
+            ...base,
+            ...credentialOptions,
+            type: base.type
+        };
+    }
+    if (base.type === 'postgres') {
+        return {
+            ...base,
+            ...credentialOptions,
+            type: base.type,
+            schema: useEnv('schema'),
+            uuidExtension: useEnv('uuidExtension')
+        };
+    }
+    if (base.type === 'cockroachdb') {
+        return {
+            ...base,
+            ...credentialOptions,
+            type: base.type,
+            schema: useEnv('schema'),
+            timeTravelQueries: true
+        };
+    }
+    if (base.type === 'sqlite') {
+        return {
+            ...base,
+            type: base.type,
+            database: useEnv('database') || 'db.sqlite'
+        };
+    }
+    if (base.type === 'better-sqlite3') {
+        return {
+            ...base,
+            type: base.type,
+            database: useEnv('database') || 'db.sqlite'
+        };
+    }
+    if (base.type === 'mssql') {
+        return {
+            ...base,
+            ...credentialOptions,
+            type: base.type,
+            schema: useEnv('schema')
+        };
+    }
+    if (base.type === 'oracle') {
+        return {
+            ...base,
+            ...credentialOptions,
+            type: base.type,
+            sid: useEnv('sid')
+        };
+    }
+    return {
+        ...base,
+        ...credentialOptions
+    };
+}
+function mergeDataSourceOptionsWithEnv(options) {
+    const env = readDataSourceOptionsFromEnv();
+    if (!env) {
+        return options;
+    }
+    return mergeDataSourceOptions(env, options);
+}
+
+/**
+ * Build DataSourceOptions from DataSource or from configuration.
+ *
+ * @param context
+ */ async function buildDataSourceOptions(context = {}) {
+    const directory = context.directory || process.cwd();
+    let tsconfig;
+    if (!context.preserveFilePaths) {
+        if (locter.isObject(context.tsconfig)) {
+            tsconfig = context.tsconfig;
+        } else {
+            tsconfig = await readTSConfig(context.tsconfig);
+        }
+    }
+    const dataSource = await findDataSource({
+        directory,
+        fileName: context.dataSourceName,
+        tsconfig
+    });
+    if (dataSource) {
+        if (context.preserveFilePaths) {
+            return mergeDataSourceOptionsWithEnv(dataSource.options);
+        }
+        const options = await adjustFilePaths(dataSource.options, [
+            'entities',
+            'migrations',
+            'subscribers'
+        ], tsconfig);
+        return mergeDataSourceOptionsWithEnv(options);
+    }
+    const options = readDataSourceOptionsFromEnv();
+    if (options) {
+        if (context.preserveFilePaths) {
+            return options;
+        }
+        return adjustFilePaths(options, [
+            'entities',
+            'migrations',
+            'subscribers'
+        ], tsconfig);
+    }
+    throw OptionsError.notFound();
+}
+
+const instances$1 = {};
+const instancePromises = {};
+function setDataSourceOptions(options, alias) {
+    instances$1[alias || 'default'] = options;
+}
+function hasDataSourceOptions(alias) {
+    return Object.prototype.hasOwnProperty.call(instances$1, alias || 'default');
+}
+async function useDataSourceOptions(alias) {
+    alias = alias || 'default';
+    if (Object.prototype.hasOwnProperty.call(instances$1, alias)) {
+        return instances$1[alias];
+    }
+    /* istanbul ignore next */ if (!Object.prototype.hasOwnProperty.call(instancePromises, alias)) {
+        instancePromises[alias] = buildDataSourceOptions().catch((e)=>{
+            if (alias) {
+                delete instancePromises[alias];
+            }
+            throw e;
+        });
+    }
+    instances$1[alias] = await instancePromises[alias];
+    return instances$1[alias];
+}
+
+const instances = {};
+const initializePromises = {};
+const optionsPromises = {};
+function setDataSource(dataSource, alias) {
+    alias = alias || 'default';
+    instances[alias] = dataSource;
+}
+function hasDataSource(alias) {
+    alias = alias || 'default';
+    return Object.prototype.hasOwnProperty.call(instances, alias);
+}
+function unsetDataSource(alias) {
+    alias = alias || 'default';
+    if (Object.prototype.hasOwnProperty.call(instances, alias)) {
+        delete instances[alias];
+    }
+    /* istanbul ignore next */ if (Object.prototype.hasOwnProperty.call(optionsPromises, alias)) {
+        delete optionsPromises[alias];
+    }
+    /* istanbul ignore next */ if (Object.prototype.hasOwnProperty.call(initializePromises, alias)) {
+        delete initializePromises[alias];
+    }
+}
+async function useDataSource(alias) {
+    alias = alias || 'default';
+    if (Object.prototype.hasOwnProperty.call(instances, alias)) {
+        if (!instances[alias].isInitialized) {
+            /* istanbul ignore next */ if (!Object.prototype.hasOwnProperty.call(initializePromises, alias)) {
+                initializePromises[alias] = instances[alias].initialize().catch((e)=>{
+                    if (alias) {
+                        delete initializePromises[alias];
+                    }
+                    throw e;
+                });
+            }
+            await initializePromises[alias];
+        }
+        return instances[alias];
+    }
+    /* istanbul ignore next */ if (!Object.prototype.hasOwnProperty.call(optionsPromises, alias)) {
+        optionsPromises[alias] = useDataSourceOptions(alias).catch((e)=>{
+            if (alias) {
+                delete optionsPromises[alias];
+            }
+            throw e;
+        });
+    }
+    const options = await optionsPromises[alias];
+    const dataSource = new typeorm.DataSource(options);
+    /* istanbul ignore next */ if (!Object.prototype.hasOwnProperty.call(initializePromises, alias)) {
+        initializePromises[alias] = dataSource.initialize().catch((e)=>{
+            if (alias) {
+                delete initializePromises[alias];
+            }
+            throw e;
+        });
+    }
+    await initializePromises[alias];
+    instances[alias] = dataSource;
+    return dataSource;
+}
+
+/**
+ * Check database setup progress.
+ *
+ * @param context
+ */ async function checkDatabase(context = {}) {
+    const result = {
+        exists: true,
+        schema: false,
+        migrationsPending: []
+    };
+    let dataSource;
+    let dataSourceCleanup;
+    if (typeof context.dataSource === 'undefined' && typeof context.options === 'undefined' && hasDataSource(context.alias)) {
+        dataSource = await useDataSource(context.alias);
+        if (dataSource.options.synchronize || dataSource.options.migrationsRun) {
+            dataSource = new typeorm.DataSource({
+                ...dataSource.options,
+                synchronize: false,
+                migrationsRun: false
+            });
+            dataSourceCleanup = true;
+        } else {
+            dataSourceCleanup = false;
+        }
+    } else {
+        let dataSourceOptions;
+        if (context.options) {
+            dataSourceOptions = context.options;
+        } else {
+            dataSourceOptions = await useDataSourceOptions(context.alias);
+        }
+        dataSource = new typeorm.DataSource({
+            ...dataSourceOptions,
+            synchronize: false,
+            migrationsRun: false
+        });
+        dataSourceCleanup = context.dataSourceCleanup ?? true;
+    }
+    try {
+        if (!dataSource.isInitialized) {
+            await dataSource.initialize();
+        }
+    } catch (e) {
+        result.exists = false;
+        return result;
+    }
+    const queryRunner = dataSource.createQueryRunner();
+    if (dataSource.migrations && dataSource.migrations.length > 0) {
+        const migrationExecutor = new typeorm.MigrationExecutor(dataSource, queryRunner);
+        result.migrationsPending = await migrationExecutor.getPendingMigrations();
+        result.schema = result.migrationsPending.length === 0;
+    } else {
+        let schema;
+        if (hasStringProperty(dataSource.driver.options, 'schema')) {
+            schema = dataSource.driver.options.schema;
+        }
+        const migrationsTableName = dataSource.driver.buildTableName(dataSource.options.migrationsTableName || 'migrations', schema, dataSource.driver.database);
+        const migrationsTableExists = await queryRunner.hasTable(migrationsTableName);
+        if (migrationsTableExists) {
+            result.schema = dataSource.entityMetadatas.length === 0;
+        } else {
+            const tableNames = dataSource.entityMetadatas.map((entityMetadata)=>entityMetadata.tablePath);
+            const tables = await queryRunner.getTables(tableNames);
+            if (tables.length === dataSource.entityMetadatas.length) {
+                const { upQueries } = await dataSource.driver.createSchemaBuilder().log();
+                result.schema = upQueries.length === 0;
+            } else {
+                result.schema = false;
+            }
+        }
+    }
+    await queryRunner.release();
+    if (dataSourceCleanup) {
+        await dataSource.destroy();
+    }
+    return result;
+}
+
+function getCharsetFromDataSourceOptions(options) {
+    if (hasOwnProperty(options, 'charset') && typeof options.charset === 'string') {
+        return options.charset;
+    }
+    if (typeof options?.extra?.charset === 'string') {
+        return options.extra.charset;
+    }
+    return undefined;
+}
+
+function getCharacterSetFromDataSourceOptions(options) {
+    if (hasOwnProperty(options, 'characterSet') && typeof options.characterSet === 'string') {
+        return options.characterSet;
+    }
+    if (typeof options?.extra?.characterSet === 'string') {
+        return options.extra.characterSet;
+    }
+    return undefined;
+}
+
+function buildDriverOptions(options) {
+    let driverOptions;
+    switch(options.type){
+        case 'mysql':
+        case 'mariadb':
+        case 'postgres':
+        case 'cockroachdb':
+        case 'mssql':
+        case 'oracle':
+            driverOptions = DriverUtils.DriverUtils.buildDriverOptions(options.replication ? options.replication.master : options);
+            break;
+        case 'mongodb':
+            driverOptions = DriverUtils.DriverUtils.buildMongoDBDriverOptions(options);
+            break;
+        default:
+            driverOptions = DriverUtils.DriverUtils.buildDriverOptions(options);
+    }
+    const charset = getCharsetFromDataSourceOptions(options);
+    const characterSet = getCharacterSetFromDataSourceOptions(options);
+    return {
+        host: driverOptions.host,
+        user: driverOptions.user || driverOptions.username,
+        password: driverOptions.password,
+        database: driverOptions.database,
+        port: driverOptions.port,
+        ...charset ? {
+            charset
+        } : {},
+        ...characterSet ? {
+            characterSet
+        } : {},
+        ...driverOptions.ssl ? {
+            ssl: driverOptions.ssl
+        } : {},
+        ...driverOptions.url ? {
+            url: driverOptions.url
+        } : {},
+        ...driverOptions.connectString ? {
+            connectString: driverOptions.connectString
+        } : {},
+        ...driverOptions.sid ? {
+            sid: driverOptions.sid
+        } : {},
+        ...driverOptions.serviceName ? {
+            serviceName: driverOptions.serviceName
+        } : {},
+        ...driverOptions.template ? {
+            template: driverOptions.template
+        } : {},
+        ...options.extra ? {
+            extra: options.extra
+        } : {},
+        ...driverOptions.domain ? {
+            domain: driverOptions.domain
+        } : {},
+        ...driverOptions.schema ? {
+            schema: driverOptions.schema
+        } : {}
+    };
+}
+
+const driversRequireDatabaseOption = [
+    'sqlite',
+    'better-sqlite3'
+];
+function createDriver(connectionOptions) {
+    const fakeConnection = {
+        options: {
+            type: connectionOptions.type,
+            ...driversRequireDatabaseOption.indexOf(connectionOptions.type) !== -1 ? {
+                database: connectionOptions.database
+            } : {}
+        }
+    };
+    const driverFactory = new DriverFactory.DriverFactory();
+    return driverFactory.create(fakeConnection);
+}
+
+async function normalizeDataSourceOptions(context) {
+    let options;
+    if (context.options) {
+        options = {
+            ...context.options
+        };
+    } else {
+        const dataSource = await findDataSource(context.findOptions);
+        if (dataSource) {
+            options = {
+                ...dataSource.options
+            };
+        }
+        if (!options) {
+            options = {
+                ...await buildDataSourceOptions()
+            };
+        }
+    }
+    return {
+        ...options,
+        subscribers: [],
+        synchronize: false,
+        migrationsRun: false,
+        dropSchema: false
+    };
+}
+async function buildDatabaseCreateContext(input = {}) {
+    return {
+        ...input,
+        options: await normalizeDataSourceOptions(input),
+        synchronize: input.synchronize ?? true,
+        ifNotExist: input.ifNotExist ?? true
+    };
+}
+async function buildDatabaseDropContext(input = {}) {
+    return {
+        ...input,
+        options: await normalizeDataSourceOptions(input),
+        ifExist: input.ifExist ?? true
+    };
+}
+
+class GenerateCommand extends MigrationGenerateCommand.MigrationGenerateCommand {
+    static prettify(query) {
+        return this.prettifyQuery(query);
+    }
+}
+function queryParams(parameters) {
+    if (!parameters || !parameters.length) {
+        return '';
+    }
+    return `, ${JSON.stringify(parameters)}`;
+}
+function buildTemplate(name, timestamp, upStatements, downStatements) {
+    const migrationName = `${pascalCase.pascalCase(name)}${timestamp}`;
+    const up = upStatements.map((statement)=>`        ${statement}`);
+    const down = downStatements.map((statement)=>`        ${statement}`);
+    return `import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class ${migrationName} implements MigrationInterface {
+    name = '${migrationName}';
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+${up.join(`
+`)}
+    }
+    public async down(queryRunner: QueryRunner): Promise<void> {
+${down.join(`
+`)}
+    }
+}
+`;
+}
+async function generateMigration(context) {
+    context.name = context.name || 'Default';
+    const timestamp = context.timestamp || new Date().getTime();
+    const fileName = `${timestamp}-${context.name}.ts`;
+    const { dataSource } = context;
+    const up = [];
+    const down = [];
+    const sqlInMemory = await dataSource.driver.createSchemaBuilder().log();
+    if (context.prettify) {
+        sqlInMemory.upQueries.forEach((upQuery)=>{
+            upQuery.query = GenerateCommand.prettify(upQuery.query);
+        });
+        sqlInMemory.downQueries.forEach((downQuery)=>{
+            downQuery.query = GenerateCommand.prettify(downQuery.query);
+        });
+    }
+    sqlInMemory.upQueries.forEach((upQuery)=>{
+        up.push(`await queryRunner.query(\`${upQuery.query.replace(/`/g, '\\`')}\`${queryParams(upQuery.parameters)});`);
+    });
+    sqlInMemory.downQueries.forEach((downQuery)=>{
+        down.push(`await queryRunner.query(\`${downQuery.query.replace(/`/g, '\\`')}\`${queryParams(downQuery.parameters)});`);
+    });
+    if (up.length === 0 && down.length === 0) {
+        return {
+            up,
+            down
+        };
+    }
+    const content = buildTemplate(context.name, timestamp, up, down.reverse());
+    if (!context.preview) {
+        let directoryPath;
+        if (context.directoryPath) {
+            if (!path.isAbsolute(context.directoryPath)) {
+                directoryPath = path.join(process$1.cwd(), context.directoryPath);
+            } else {
+                directoryPath = context.directoryPath;
+            }
+        } else {
+            directoryPath = path.join(process$1.cwd(), 'migrations');
+        }
+        try {
+            await fs.promises.access(directoryPath, fs.constants.R_OK | fs.constants.W_OK);
+        } catch (e) {
+            await fs.promises.mkdir(directoryPath, {
+                recursive: true
+            });
+        }
+        await fs.promises.writeFile(path.join(directoryPath, fileName), content, {
+            encoding: 'utf-8'
+        });
+    }
+    return {
+        up,
+        down,
+        content
+    };
+}
+
+/* istanbul ignore next */ function existsQuery(builder, inverse = false) {
+    return `${inverse ? 'not ' : ''}exists (${builder.getQuery()})`;
+}
+
+async function synchronizeDatabaseSchema(input) {
+    let dataSource;
+    let options;
+    if (typeorm.InstanceChecker.isDataSource(input)) {
+        dataSource = input;
+        options = dataSource.options;
+    } else {
+        options = input;
+        dataSource = new typeorm.DataSource(options);
+    }
+    if (!dataSource.isInitialized) {
+        await dataSource.initialize();
+    }
+    let migrationsCount = 0;
+    if (options.migrations) {
+        migrationsCount = Array.isArray(options.migrations) ? options.migrations.length : Object.keys(options.migrations).length;
+    }
+    let migrations = [];
+    if (migrationsCount > 0) {
+        migrations = await dataSource.runMigrations({
+            transaction: options.migrationsTransactionMode
+        });
+    } else {
+        await dataSource.synchronize(false);
+    }
+    if (!typeorm.InstanceChecker.isDataSource(input)) {
+        await dataSource.destroy();
+    }
+    return migrations;
+}
+
+async function createSimplePostgresConnection(driver, options, operationContext) {
+    /**
+     * pg library
+     */ const { Client } = driver.postgres;
+    const data = {
+        host: options.host,
+        port: options.port,
+        user: options.user,
+        password: options.password,
+        ssl: options.ssl,
+        schema: options.schema,
+        ...options.extra ? options.extra : {}
+    };
+    if (typeof operationContext.initialDatabase === 'string') {
+        data.database = operationContext.initialDatabase;
+    }
+    const client = new Client(data);
+    await client.connect();
+    return client;
+}
+async function executeSimplePostgresQuery(connection, query, endConnection = true) {
+    return new Promise((resolve, reject)=>{
+        connection.query(query, (queryErr, queryResult)=>{
+            if (endConnection) {
+                connection.end();
+            }
+            if (queryErr) {
+                reject(queryErr);
+            }
+            resolve(queryResult);
+        });
+    });
+}
+async function createPostgresDatabase(input = {}) {
+    const context = await buildDatabaseCreateContext(input);
+    const options = buildDriverOptions(context.options);
+    const driver = createDriver(context.options);
+    const connection = await createSimplePostgresConnection(driver, options, context);
+    if (context.ifNotExist) {
+        const existQuery = `SELECT * FROM pg_database WHERE lower(datname) = lower('${options.database}');`;
+        const existResult = await executeSimplePostgresQuery(connection, existQuery, false);
+        if (locter.isObject(existResult) && hasOwnProperty(existResult, 'rows') && Array.isArray(existResult.rows) && existResult.rows.length > 0) {
+            await connection.end();
+            return Promise.resolve();
+        }
+    }
+    /**
+     * @link https://github.com/typeorm/typeorm/blob/master/src/driver/postgres/PostgresQueryRunner.ts#L326
+     */ let query = `CREATE DATABASE "${options.database}"`;
+    if (typeof options.template === 'string') {
+        query += ` TEMPLATE "${options.template}"`;
+    } else if (typeof options.characterSet === 'string') {
+        query += ` WITH ENCODING '${options.characterSet}'`;
+    }
+    const result = await executeSimplePostgresQuery(connection, query);
+    if (typeof options.schema === 'string' && options.schema !== 'public') {
+        const schemaConnection = await createSimplePostgresConnection(driver, options, {
+            ...context,
+            initialDatabase: options.database
+        });
+        const schemaQuery = `CREATE SCHEMA IF NOT EXISTS "${options.schema}"`;
+        await executeSimplePostgresQuery(schemaConnection, schemaQuery);
+    }
+    if (context.synchronize) {
+        await synchronizeDatabaseSchema(context.options);
+    }
+    return result;
+}
+async function dropPostgresDatabase(input = {}) {
+    const context = await buildDatabaseDropContext(input);
+    const options = buildDriverOptions(context.options);
+    const driver = createDriver(context.options);
+    const connection = await createSimplePostgresConnection(driver, options, context);
+    /**
+     * @link https://github.com/typeorm/typeorm/blob/master/src/driver/postgres/PostgresQueryRunner.ts#L343
+     */ const query = context.ifExist ? `DROP DATABASE IF EXISTS "${options.database}"` : `DROP DATABASE "${options.database}"`;
+    return executeSimplePostgresQuery(connection, query);
+}
+
+async function executeSimpleCockroachDBQuery(connection, query, endConnection = true) {
+    return new Promise((resolve, reject)=>{
+        connection.query(query, (queryErr, queryResult)=>{
+            if (endConnection) {
+                connection.end();
+            }
+            if (queryErr) {
+                reject(queryErr);
+            }
+            resolve(queryResult);
+        });
+    });
+}
+async function createCockroachDBDatabase(input = {}) {
+    const context = await buildDatabaseCreateContext(input);
+    const options = buildDriverOptions(context.options);
+    const driver = createDriver(context.options);
+    const connection = await createSimplePostgresConnection(driver, options, context);
+    /**
+     * @link https://github.com/typeorm/typeorm/blob/master/src/driver/cockroachdb/CockroachQueryRunner.ts#L347
+     */ const query = `CREATE DATABASE ${context.ifNotExist ? 'IF NOT EXISTS ' : ''} "${options.database}"`;
+    const result = await executeSimpleCockroachDBQuery(connection, query);
+    if (context.synchronize) {
+        await synchronizeDatabaseSchema(context.options);
+    }
+    return result;
+}
+async function dropCockroachDBDatabase(input = {}) {
+    const context = await buildDatabaseDropContext(input);
+    const options = buildDriverOptions(context.options);
+    const driver = createDriver(context.options);
+    const connection = await createSimplePostgresConnection(driver, options, context);
+    /**
+     * @link https://github.com/typeorm/typeorm/blob/master/src/driver/cockroachdb/CockroachQueryRunner.ts#L356
+     */ const query = `DROP DATABASE ${context.ifExist ? 'IF EXISTS ' : ''} "${options.database}"`;
+    return executeSimpleCockroachDBQuery(connection, query);
+}
+
+async function createSimpleMongoDBConnection(driver, options) {
+    /**
+     * mongodb library
+     */ const { MongoClient } = driver.mongodb;
+    let url = 'mongodb://';
+    if (options.user && options.password) {
+        url += `${options.user}:${options.password}@`;
+    }
+    url += `${options.host || '127.0.0.1'}:${options.port || 27017}/${options.database}`;
+    if (options.ssl) {
+        url += '?tls=true';
+    }
+    const client = new MongoClient(url);
+    await client.connect();
+    return client;
+}
+async function createMongoDBDatabase(input = {}) {
+    const context = await buildDatabaseCreateContext(input);
+    const options = buildDriverOptions(context.options);
+    const driver = createDriver(context.options);
+    // connection setup, will create the database on the fly.
+    const client = await createSimpleMongoDBConnection(driver, options);
+    await client.close();
+    if (context.synchronize) {
+        await synchronizeDatabaseSchema(context.options);
+    }
+}
+async function dropMongoDBDatabase(input = {}) {
+    const context = await buildDatabaseDropContext(input);
+    const options = buildDriverOptions(context.options);
+    const driver = createDriver(context.options);
+    const client = await createSimpleMongoDBConnection(driver, options);
+    const result = await client.dropDatabase();
+    await client.close();
+    return result;
+}
+
+async function createSimpleMsSQLConnection(driver, options) {
+    const option = {
+        user: options.user,
+        password: options.password,
+        server: options.host,
+        port: options.port || 1433,
+        ...options.extra ? options.extra : {},
+        ...options.domain ? {
+            domain: options.domain
+        } : {}
+    };
+    await driver.mssql.connect(option);
+    return driver.mssql;
+}
+async function createMsSQLDatabase(input = {}) {
+    const context = await buildDatabaseCreateContext(input);
+    const options = buildDriverOptions(context.options);
+    const driver = createDriver(context.options);
+    const connection = await createSimpleMsSQLConnection(driver, options);
+    /**
+     * @link https://github.com/typeorm/typeorm/blob/master/src/driver/sqlserver/SqlServerQueryRunner.ts#L416
+     */ let query = context.ifNotExist ? `IF DB_ID('${options.database}') IS NULL CREATE DATABASE "${options.database}"` : `CREATE DATABASE "${options.database}"`;
+    if (typeof options.characterSet === 'string') {
+        query += ` CHARACTER SET ${options.characterSet}`;
+    }
+    const result = await connection.query(query);
+    if (context.synchronize) {
+        await synchronizeDatabaseSchema(context.options);
+    }
+    return result;
+}
+async function dropMsSQLDatabase(input = {}) {
+    const context = await buildDatabaseDropContext(input);
+    const options = buildDriverOptions(context.options);
+    const driver = createDriver(context.options);
+    const connection = await createSimpleMsSQLConnection(driver, options);
+    /**
+     * @link https://github.com/typeorm/typeorm/blob/master/src/driver/sqlserver/SqlServerQueryRunner.ts#L425
+     */ const query = context.ifExist ? `IF DB_ID('${options.database}') IS NOT NULL DROP DATABASE "${options.database}"` : `DROP DATABASE "${options.database}"`;
+    return connection.query(query);
+}
+
+async function createSimpleMySQLConnection(driver, options) {
+    /**
+     * mysql|mysql2 library
+     */ const { createConnection } = driver.mysql;
+    const option = {
+        host: options.host,
+        user: options.user,
+        password: options.password,
+        port: options.port,
+        ssl: options.ssl,
+        ...options.extra ? options.extra : {}
+    };
+    return createConnection(option);
+}
+async function executeSimpleMysqlQuery(connection, query, endConnection = true) {
+    return new Promise((resolve, reject)=>{
+        connection.query(query, (queryErr, queryResult)=>{
+            if (endConnection) connection.end();
+            if (queryErr) {
+                reject(queryErr);
+            }
+            resolve(queryResult);
+        });
+    });
+}
+async function createMySQLDatabase(input = {}) {
+    const context = await buildDatabaseCreateContext(input);
+    const options = buildDriverOptions(context.options);
+    const driver = createDriver(context.options);
+    const connection = await createSimpleMySQLConnection(driver, options);
+    /**
+     * @link https://github.com/typeorm/typeorm/blob/master/src/driver/mysql/MysqlQueryRunner.ts#L297
+     */ let query = context.ifNotExist ? `CREATE DATABASE IF NOT EXISTS \`${options.database}\`` : `CREATE DATABASE \`${options.database}\``;
+    if (typeof options.charset === 'string') {
+        const { charset } = options;
+        let { characterSet } = options;
+        if (typeof characterSet === 'undefined') {
+            if (charset.toLowerCase().startsWith('utf8mb4')) {
+                characterSet = 'utf8mb4';
+            } else if (charset.toLowerCase().startsWith('utf8')) {
+                characterSet = 'utf8';
+            }
+        }
+        if (typeof characterSet === 'string') {
+            query += ` CHARACTER SET ${characterSet} COLLATE ${charset}`;
+        }
+    }
+    const result = await executeSimpleMysqlQuery(connection, query);
+    if (context.synchronize) {
+        await synchronizeDatabaseSchema(context.options);
+    }
+    return result;
+}
+async function dropMySQLDatabase(input = {}) {
+    const context = await buildDatabaseDropContext(input);
+    const options = buildDriverOptions(context.options);
+    const driver = createDriver(context.options);
+    const connection = await createSimpleMySQLConnection(driver, options);
+    /**
+     * @link https://github.com/typeorm/typeorm/blob/master/src/driver/mysql/MysqlQueryRunner.ts#L306
+     */ const query = context.ifExist ? `DROP DATABASE IF EXISTS \`${options.database}\`` : `DROP DATABASE \`${options.database}\``;
+    await executeSimpleMysqlQuery(connection, 'SET FOREIGN_KEY_CHECKS=0;', false);
+    const result = await executeSimpleMysqlQuery(connection, query, false);
+    await executeSimpleMysqlQuery(connection, 'SET FOREIGN_KEY_CHECKS=1;');
+    return result;
+}
+
+function createSimpleOracleConnection(driver, options) {
+    const { getConnection } = driver.oracle;
+    if (!options.connectString) {
+        let address = '(PROTOCOL=TCP)';
+        if (options.host) {
+            address += `(HOST=${options.host})`;
+        }
+        if (options.port) {
+            address += `(PORT=${options.port})`;
+        }
+        let connectData = '(SERVER=DEDICATED)';
+        if (options.sid) {
+            connectData += `(SID=${options.sid})`;
+        }
+        if (options.serviceName) {
+            connectData += `(SERVICE_NAME=${options.serviceName})`;
+        }
+        options.connectString = `(DESCRIPTION=(ADDRESS=${address})(CONNECT_DATA=${connectData}))`;
+    }
+    return getConnection({
+        user: options.user,
+        password: options.password,
+        connectString: options.connectString || options.url,
+        ...options.extra ? options.extra : {}
+    });
+}
+async function createOracleDatabase(input = {}) {
+    const context = await buildDatabaseCreateContext(input);
+    const options = buildDriverOptions(context.options);
+    const driver = createDriver(context.options);
+    const connection = createSimpleOracleConnection(driver, options);
+    /**
+     * @link https://github.com/typeorm/typeorm/blob/master/src/driver/oracle/OracleQueryRunner.ts#L295
+     */ const query = `CREATE DATABASE IF NOT EXISTS ${options.database}`;
+    const result = await connection.execute(query);
+    if (context.synchronize) {
+        await synchronizeDatabaseSchema(context.options);
+    }
+    return result;
+}
+async function dropOracleDatabase(_context = {}) {
+    /**
+     * @link https://github.com/typeorm/typeorm/blob/master/src/driver/oracle/OracleQueryRunner.ts#L295
+     */ return Promise.resolve();
+}
+
+async function createSQLiteDatabase(input = {}) {
+    const context = await buildDatabaseCreateContext(input);
+    const options = buildDriverOptions(context.options);
+    if (!options.database) {
+        throw OptionsError.databaseNotDefined();
+    }
+    const filePath = path.isAbsolute(options.database) ? options.database : path.join(process.cwd(), options.database);
+    const directoryPath = path.dirname(filePath);
+    await fs.promises.access(directoryPath, fs.constants.W_OK);
+    if (context.synchronize) {
+        await synchronizeDatabaseSchema(context.options);
+    }
+}
+async function dropSQLiteDatabase(input = {}) {
+    const context = await buildDatabaseDropContext(input);
+    const options = buildDriverOptions(context.options);
+    if (!options.database) {
+        throw OptionsError.databaseNotDefined();
+    }
+    const filePath = path.isAbsolute(options.database) ? options.database : path.join(process.cwd(), options.database);
+    try {
+        await fs.promises.access(filePath, fs.constants.F_OK | fs.constants.W_OK);
+        if (context.ifExist) {
+            await fs.promises.unlink(filePath);
+        }
+    } catch (e) {
+    // ...
+    }
+}
+
+/**
+ * Create database for specified driver in ConnectionOptions.
+ *
+ * @throws DriverError
+ * @throws OptionsError
+ *
+ * @param input
+ */ async function createDatabase(input = {}) {
+    const context = await buildDatabaseCreateContext(input);
+    let output;
+    switch(context.options.type){
+        case 'mongodb':
+            output = await createMongoDBDatabase(context);
+            break;
+        case 'mysql':
+        case 'mariadb':
+            output = await createMySQLDatabase(context);
+            break;
+        case 'postgres':
+            output = await createPostgresDatabase(context);
+            break;
+        case 'cockroachdb':
+            output = await createCockroachDBDatabase(context);
+            break;
+        case 'sqlite':
+        case 'better-sqlite3':
+            output = await createSQLiteDatabase(context);
+            break;
+        case 'oracle':
+            output = await createOracleDatabase(context);
+            break;
+        case 'mssql':
+            output = await createMsSQLDatabase(context);
+            break;
+        default:
+            throw DriverError.notSupported(context.options.type);
+    }
+    return output;
+}
+
+/**
+ * Drop database for specified driver in ConnectionOptions.
+ *
+ * @throws DriverError
+ * @throws OptionsError
+ *
+ * @param input
+ */ async function dropDatabase(input = {}) {
+    const context = await buildDatabaseDropContext(input);
+    let output;
+    switch(context.options.type){
+        case 'mongodb':
+            output = await dropMongoDBDatabase(context);
+            break;
+        case 'mysql':
+        case 'mariadb':
+            output = await dropMySQLDatabase(context);
+            break;
+        case 'postgres':
+            output = await dropPostgresDatabase(context);
+            break;
+        case 'cockroachdb':
+            output = await dropCockroachDBDatabase(context);
+            break;
+        case 'sqlite':
+        case 'better-sqlite3':
+            output = await dropSQLiteDatabase(context);
+            break;
+        case 'oracle':
+            output = await dropOracleDatabase(context);
+            break;
+        case 'mssql':
+            output = await dropMsSQLDatabase(context);
+            break;
+        default:
+            throw DriverError.notSupported(context.options.type);
+    }
+    return output;
+}
+
+class DatabaseCreateCommand {
+    builder(args) {
+        return args.option('preserveFilePaths', {
+            default: false,
+            type: 'boolean',
+            describe: 'This option indicates if file paths should be preserved.'
+        }).option('root', {
+            alias: 'r',
+            default: process.cwd(),
+            describe: 'Root directory of the project.'
+        }).option('tsconfig', {
+            alias: 'tc',
+            default: 'tsconfig.json',
+            describe: 'Name (or relative path incl. name) of the tsconfig file.'
+        }).option('dataSource', {
+            alias: 'd',
+            default: 'data-source',
+            describe: 'Name (or relative path incl. name) of the data-source file.'
+        }).option('synchronize', {
+            alias: 's',
+            default: 'yes',
+            describe: 'Create database schema for all entities.',
+            choices: [
+                'yes',
+                'no'
+            ]
+        }).option('initialDatabase', {
+            describe: 'Specify the initial database to connect to.'
+        });
+    }
+    async handler(raw) {
+        const args = raw;
+        let tsconfig;
+        let sourcePath = resolveFilePath(args.dataSource, args.root);
+        if (!args.preserveFilePaths) {
+            tsconfig = await readTSConfig(resolveFilePath(args.root, args.tsconfig));
+            sourcePath = await adjustFilePath(sourcePath, tsconfig);
+        }
+        const source = parseFilePath(sourcePath);
+        consola.consola.info(`DataSource Directory: ${source.directory}`);
+        consola.consola.info(`DataSource Name: ${source.name}`);
+        const dataSourceOptions = await buildDataSourceOptions({
+            directory: source.directory,
+            dataSourceName: source.name,
+            tsconfig,
+            preserveFilePaths: args.preserveFilePaths
+        });
+        const context = {
+            ifNotExist: true,
+            options: dataSourceOptions,
+            synchronize: args.synchronize === 'yes'
+        };
+        if (typeof args.initialDatabase === 'string' && args.initialDatabase !== '') {
+            context.initialDatabase = args.initialDatabase;
+        }
+        try {
+            await createDatabase(context);
+            consola.consola.success('Created database.');
+            process.exit(0);
+        } catch (e) {
+            consola.consola.warn('Failed to create database.');
+            consola.consola.error(e);
+            process.exit(1);
+        }
+    }
+    constructor(){
+        this.command = 'db:create';
+        this.describe = 'Create database.';
+    }
+}
+
+class DatabaseDropCommand {
+    builder(args) {
+        return args.option('preserveFilePaths', {
+            default: false,
+            type: 'boolean',
+            describe: 'This option indicates if file paths should be preserved.'
+        }).option('root', {
+            alias: 'r',
+            default: process.cwd(),
+            describe: 'Root directory of the project.'
+        }).option('tsconfig', {
+            alias: 'tc',
+            default: 'tsconfig.json',
+            describe: 'Name (or relative path incl. name) of the tsconfig file.'
+        }).option('dataSource', {
+            alias: 'd',
+            default: 'data-source',
+            describe: 'Name (or relative path incl. name) of the data-source file.'
+        }).option('initialDatabase', {
+            describe: 'Specify the initial database to connect to.'
+        });
+    }
+    async handler(raw) {
+        const args = raw;
+        let tsconfig;
+        let sourcePath = resolveFilePath(args.dataSource, args.root);
+        if (!args.preserveFilePaths) {
+            tsconfig = await readTSConfig(resolveFilePath(args.root, args.tsconfig));
+            sourcePath = await adjustFilePath(sourcePath, tsconfig);
+        }
+        const source = parseFilePath(sourcePath);
+        consola.consola.info(`DataSource Directory: ${source.directory}`);
+        consola.consola.info(`DataSource Name: ${source.name}`);
+        const dataSourceOptions = await buildDataSourceOptions({
+            directory: source.directory,
+            dataSourceName: source.name,
+            tsconfig,
+            preserveFilePaths: args.preserveFilePaths
+        });
+        const context = {
+            ifExist: true,
+            options: dataSourceOptions
+        };
+        if (typeof args.initialDatabase === 'string' && args.initialDatabase !== '') {
+            context.initialDatabase = args.initialDatabase;
+        }
+        try {
+            await dropDatabase(context);
+            consola.consola.success('Dropped database.');
+            process.exit(0);
+        } catch (e) {
+            consola.consola.warn('Failed to drop database.');
+            consola.consola.error(e);
+            process.exit(1);
+        }
+    }
+    constructor(){
+        this.command = 'db:drop';
+        this.describe = 'Drop database.';
+    }
+}
+
+class SeederEntity {
+    constructor(ctx){
+        this.id = ctx.id;
+        this.timestamp = ctx.timestamp;
+        this.name = ctx.name;
+        if (ctx.constructor) {
+            this.instance = new ctx.constructor();
+        }
+        this.fileName = ctx.fileName;
+        this.filePath = ctx.filePath;
+    }
+    get trackExecution() {
+        if (typeof this.instance === 'undefined') {
+            return undefined;
+        }
+        return this.instance.track;
+    }
+}
+
+class SeederFactory {
+    // --------------------------------------------------------------
+    constructor(context){
+        this.context = context;
+    }
+    // --------------------------------------------------------------
+    setMeta(value) {
+        this.meta = value;
+        return this;
+    }
+    setLocale(value) {
+        this.faker = undefined;
+        this.locale = Array.isArray(value) ? value : [
+            value
+        ];
+    }
+    // --------------------------------------------------------------
+    async make(params, save) {
+        const faker = await this.useFaker();
+        const factoryFn = this.context.factoryFn(faker, this.meta);
+        let entity;
+        if (isPromise(factoryFn)) {
+            entity = await this.resolve(await factoryFn, save);
+        } else {
+            entity = await this.resolve(factoryFn, save);
+        }
+        if (params) {
+            const keys = Object.keys(params);
+            for(let i = 0; i < keys.length; i++){
+                entity[keys[i]] = params[keys[i]];
+            }
+        }
+        return entity;
+    }
+    // --------------------------------------------------------------
+    async save(params, options) {
+        const dataSource = await useDataSource();
+        const entity = await this.make(params, true);
+        const entityManager = dataSource.getRepository(this.context.entity);
+        return entityManager.save(entity, options);
+    }
+    async saveMany(amount, params, options) {
+        const promises = [];
+        for(let i = 0; i < amount; i++){
+            const item = this.save(params, options);
+            promises.push(item);
+        }
+        return Promise.all(promises);
+    }
+    // --------------------------------------------------------------
+    async resolve(entity, save) {
+        const keys = Object.keys(entity);
+        for(let i = 0; i < keys.length; i++){
+            const key = keys[i];
+            const value = entity[key];
+            if (!hasOwnProperty(entity, key)) {
+                continue;
+            }
+            if (typeof value === 'object' && // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            value instanceof SeederFactory) {
+                if (save) {
+                    entity[key] = await value.save();
+                } else {
+                    entity[key] = await value.make();
+                }
+            }
+            if (value && hasOwnProperty(value, 'then') && typeof value.then === 'function') {
+                entity[key] = await value;
+            }
+        }
+        return entity;
+    }
+    async useFaker() {
+        if (typeof this.faker !== 'undefined') {
+            return this.faker;
+        }
+        const options = {
+            locale: []
+        };
+        const fakerExports = await locter.load('@faker-js/faker');
+        let names;
+        if (this.locale) {
+            names = Array.isArray(this.locale) ? this.locale : [
+                this.locale
+            ];
+        } else {
+            names = [
+                'en'
+            ];
+        }
+        for(let i = 0; i < names.length; i++){
+            if (hasOwnProperty(fakerExports, 'default') && locter.isObject(fakerExports.default) && hasOwnProperty(fakerExports.default, names[i])) {
+                options.locale.push(fakerExports.default[names[i]]);
+                continue;
+            }
+            if (hasOwnProperty(fakerExports, names[i])) {
+                options.locale.push(fakerExports[names[i]]);
+            }
+        }
+        this.faker = new fakerExports.Faker(options);
+        return this.faker;
+    }
+}
+
+class SeederFactoryManager {
+    set(entity, factoryFn) {
+        const name = getEntityName(entity);
+        this.items[name] = {
+            factoryFn,
+            entity
+        };
+        return this.items[name];
+    }
+    get(entity) {
+        const name = getEntityName(entity);
+        if (!hasOwnProperty(this.items, name)) {
+            throw new Error(`No seeder factory is registered for the entity: ${name}`);
+        }
+        return new SeederFactory({
+            factoryFn: this.items[name].factoryFn,
+            entity,
+            name
+        });
+    }
+    constructor(){
+        this.items = {};
+    }
+}
+
+async function resolveFilePatterns(filesPattern, root) {
+    return locter.locateMany(filesPattern, {
+        ...root ? {
+            path: root
+        } : {},
+        ignore: [
+            '**/*.d.ts'
+        ]
+    }).then(buildFilePathname);
+}
+function resolveFilePaths(filePaths, root) {
+    return filePaths.map((filePath)=>path.isAbsolute(filePath) ? filePath : path.resolve(root || process.cwd(), filePath));
+}
+/**
+ * Exported only for testing purposes
+ */ function buildFilePathname(files) {
+    return(// sorting by name so that we can define the order of execution using file names
+    files.sort((a, b)=>a.name > b.name ? 1 : -1).map((el)=>path.join(el.path, el.name + el.extension)));
+}
+
+async function prepareSeederSeeds(input, root) {
+    const items = [];
+    let seedFiles = [];
+    const seedConstructors = [];
+    for(let i = 0; i < input.length; i++){
+        const value = input[i];
+        if (typeof value === 'string') {
+            seedFiles.push(value);
+        } else {
+            seedConstructors.push(value);
+        }
+    }
+    if (seedFiles.length > 0) {
+        seedFiles = await resolveFilePatterns(seedFiles, root);
+        seedFiles = resolveFilePaths(seedFiles, root);
+        for(let i = 0; i < seedFiles.length; i++){
+            const moduleExports = await locter.load(seedFiles[i]);
+            let clazzConstructor;
+            const exportKeys = Object.keys(moduleExports);
+            for(let j = 0; j < exportKeys.length; j++){
+                const moduleExport = moduleExports[exportKeys[j]];
+                if (typeof moduleExport === 'function' && moduleExport.prototype) {
+                    clazzConstructor = moduleExport;
+                }
+            }
+            if (clazzConstructor) {
+                const fileName = path.basename(seedFiles[i]);
+                const filePath = seedFiles[i];
+                const match = fileName.match(/^([0-9]{13,})-(.*)$/);
+                let timestamp;
+                if (match) {
+                    timestamp = parseInt(match[1], 10);
+                }
+                items.push({
+                    constructor: clazzConstructor,
+                    fileName,
+                    filePath,
+                    ...timestamp ? {
+                        timestamp
+                    } : {}
+                });
+            }
+        }
+    }
+    if (seedConstructors.length > 0) {
+        for(let i = 0; i < seedConstructors.length; i++){
+            items.push({
+                constructor: seedConstructors[i]
+            });
+        }
+    }
+    return items;
+}
+
+function buildSeederFileTemplate(name, timestamp) {
+    const className = `${pascalCase.pascalCase(name)}${timestamp}`;
+    return `import { DataSource } from 'typeorm';
+import { Seeder, SeederFactoryManager } from 'typeorm-extension';
+
+export class ${className} implements Seeder {
+    track = false;
+
+    public async run(
+        dataSource: DataSource,
+        factoryManager: SeederFactoryManager
+    ): Promise<any> {
+
+    }
+}
+`;
+}
+
+let instance;
+function useSeederFactoryManager() {
+    if (typeof instance !== 'undefined') {
+        return instance;
+    }
+    instance = new SeederFactoryManager();
+    return instance;
+}
+function setSeederFactory(entity, factoryFn) {
+    const manager = useSeederFactoryManager();
+    return manager.set(entity, factoryFn);
+}
+function useSeederFactory(entity) {
+    const manager = useSeederFactoryManager();
+    return manager.get(entity);
+}
+async function prepareSeederFactories(items, root) {
+    let factoryFiles = [];
+    const factoryConfigs = [];
+    for(let i = 0; i < items.length; i++){
+        const value = items[i];
+        if (typeof value === 'string') {
+            factoryFiles.push(value);
+        } else {
+            factoryConfigs.push(value);
+        }
+    }
+    if (factoryFiles.length > 0) {
+        factoryFiles = await resolveFilePatterns(factoryFiles, root);
+        factoryFiles = resolveFilePaths(factoryFiles, root);
+        for(let i = 0; i < factoryFiles.length; i++){
+            await locter.load(factoryFiles[i]);
+        }
+    }
+    if (factoryConfigs.length > 0) {
+        const factoryManager = useSeederFactoryManager();
+        for(let i = 0; i < factoryConfigs.length; i++){
+            factoryManager.set(factoryConfigs[i].entity, factoryConfigs[i].factoryFn);
+        }
+    }
+}
+
+class SeederExecutor {
+    constructor(dataSource, options){
+        this.dataSource = dataSource;
+        this.options = options || {};
+        setDataSource(dataSource);
+        this.tableName = this.dataSourceOptions.seedTableName || 'seeds';
+    }
+    async execute(input = {}) {
+        const options = await this.buildOptions(input);
+        if (!options.seeds || options.seeds.length === 0) {
+            return [];
+        }
+        if (options.factories) {
+            await prepareSeederFactories(options.factories, this.options.root);
+        }
+        const seederElements = await prepareSeederSeeds(options.seeds, this.options.root);
+        const all = await this.buildEntities(seederElements);
+        let tracking = !!options.seedTracking;
+        if (!tracking) {
+            tracking = all.some((seed)=>!!seed.trackExecution);
+        }
+        let queryRunner;
+        let existing = [];
+        if (tracking) {
+            queryRunner = this.dataSource.createQueryRunner();
+            await this.createTableIfNotExist(queryRunner);
+            existing = await this.loadExisting(queryRunner);
+        }
+        const isMatch = (seed)=>{
+            if (!options.seedName) {
+                return true;
+            }
+            if (seed.name === options.seedName || seed.fileName === options.seedName) {
+                return true;
+            }
+            if (!seed.filePath) {
+                return false;
+            }
+            if (seed.filePath === options.seedName) {
+                return true;
+            }
+            return resolveFilePath(options.seedName, this.options.root) === seed.filePath;
+        };
+        const pending = all.filter((seed)=>{
+            if (!isMatch(seed)) {
+                return false;
+            }
+            const index = existing.findIndex((el)=>el.name === seed.name);
+            if (index === -1) {
+                return true;
+            }
+            let seedTracking;
+            if (typeof seed.trackExecution !== 'undefined') {
+                seedTracking = seed.trackExecution;
+            } else {
+                seedTracking = options.seedTracking;
+            }
+            return !seedTracking;
+        });
+        if (pending.length === 0) {
+            if (queryRunner) {
+                await queryRunner.release();
+            }
+            return [];
+        }
+        this.dataSource.logger.logSchemaBuild(`${existing.length} seeds are already present in the database.`);
+        this.dataSource.logger.logSchemaBuild(`${all.length} seeds were found in the source code.`);
+        const factoryManager = useSeederFactoryManager();
+        const executed = [];
+        try {
+            for(let i = 0; i < pending.length; i++){
+                const seeder = pending[i].instance;
+                if (!seeder) {
+                    continue;
+                }
+                pending[i].result = await seeder.run(this.dataSource, factoryManager);
+                let seedTracking;
+                if (typeof pending[i].trackExecution !== 'undefined') {
+                    seedTracking = pending[i].trackExecution;
+                } else {
+                    seedTracking = options.seedTracking;
+                }
+                if (queryRunner && seedTracking) {
+                    await this.track(queryRunner, pending[i]);
+                }
+                this.dataSource.logger.logSchemaBuild(`Seed ${pending[i].name} has been executed successfully.`);
+                executed.push(pending[i]);
+            }
+        } finally{
+            if (queryRunner) {
+                await queryRunner.release();
+            }
+        }
+        return executed;
+    }
+    async loadExisting(queryRunner) {
+        if (this.dataSource.driver.options.type === 'mongodb') {
+            const mongoRunner = queryRunner;
+            return mongoRunner.cursor(this.tableName, {}).sort({
+                _id: -1
+            }).toArray();
+        }
+        const raw = await this.dataSource.manager.createQueryBuilder(queryRunner).select().orderBy(this.dataSource.driver.escape('id'), 'DESC').from(this.table, this.tableName).getRawMany();
+        return raw.map((migrationRaw)=>new SeederEntity({
+                id: parseInt(migrationRaw.id, 10),
+                timestamp: parseInt(migrationRaw.timestamp, 10),
+                name: migrationRaw.name,
+                constructor: undefined
+            }));
+    }
+    /**
+     * Gets all migrations that setup for this connection.
+     */ async buildEntities(seeds) {
+        if (!seeds) {
+            return [];
+        }
+        let timestampCounter = 0;
+        const entities = seeds.map((element)=>{
+            const { constructor: seed, fileName, filePath } = element;
+            let { timestamp } = element;
+            const className = seed.name || seed.constructor.name;
+            if (!timestamp) {
+                timestamp = this.classNameToTimestamp(className);
+            }
+            const entity = new SeederEntity({
+                fileName,
+                filePath,
+                timestamp: timestamp || timestampCounter,
+                name: className,
+                constructor: seed
+            });
+            timestampCounter++;
+            return entity;
+        });
+        this.checkForDuplicates(entities);
+        // sort them by file name than by timestamp
+        return entities.sort((a, b)=>{
+            if (typeof a.fileName !== 'undefined' && typeof b.fileName !== 'undefined') {
+                return a.fileName > b.fileName ? 1 : -1;
+            }
+            return a.timestamp - b.timestamp;
+        });
+    }
+    checkForDuplicates(entities) {
+        const names = entities.map((migration)=>migration.name);
+        const duplicates = Array.from(new Set(names.filter((migrationName, index)=>names.indexOf(migrationName) < index)));
+        if (duplicates.length > 0) {
+            throw Error(`Duplicate seeds: ${duplicates.join(', ')}`);
+        }
+    }
+    async createTableIfNotExist(queryRunner) {
+        // If driver is mongo no need to create
+        if (this.dataSource.driver.options.type === 'mongodb') {
+            return;
+        }
+        const tableExist = await queryRunner.hasTable(this.table);
+        if (!tableExist) {
+            await queryRunner.createTable(new typeorm.Table({
+                database: this.database,
+                schema: this.schema,
+                name: this.table,
+                columns: [
+                    {
+                        name: 'id',
+                        type: this.dataSource.driver.normalizeType({
+                            type: this.dataSource.driver.mappedDataTypes.migrationId
+                        }),
+                        isGenerated: true,
+                        generationStrategy: 'increment',
+                        isPrimary: true,
+                        isNullable: false
+                    },
+                    {
+                        name: 'timestamp',
+                        type: this.dataSource.driver.normalizeType({
+                            type: this.dataSource.driver.mappedDataTypes.migrationTimestamp
+                        }),
+                        isPrimary: false,
+                        isNullable: false
+                    },
+                    {
+                        name: 'name',
+                        type: this.dataSource.driver.normalizeType({
+                            type: this.dataSource.driver.mappedDataTypes.migrationName
+                        }),
+                        isNullable: false
+                    }
+                ]
+            }));
+        }
+    }
+    async track(queryRunner, seederEntity) {
+        const values = {};
+        if (this.dataSource.driver.options.type === 'mssql') {
+            values.timestamp = new typeorm.MssqlParameter(seederEntity.timestamp, this.dataSource.driver.normalizeType({
+                type: this.dataSource.driver.mappedDataTypes.migrationTimestamp
+            }));
+            values.name = new typeorm.MssqlParameter(seederEntity.name, this.dataSource.driver.normalizeType({
+                type: this.dataSource.driver.mappedDataTypes.migrationName
+            }));
+        } else {
+            values.timestamp = seederEntity.timestamp;
+            values.name = seederEntity.name;
+        }
+        if (this.dataSource.driver.options.type === 'mongodb') {
+            const mongoRunner = queryRunner;
+            await mongoRunner.databaseConnection.db(this.dataSource.driver.database).collection(this.tableName).insertOne(values);
+        } else {
+            const qb = queryRunner.manager.createQueryBuilder();
+            await qb.insert().into(this.table).values(values).execute();
+        }
+    }
+    get dataSourceOptions() {
+        return this.dataSource.options;
+    }
+    get database() {
+        return this.dataSource.driver.database;
+    }
+    get schema() {
+        return this.dataSource.driver.schema;
+    }
+    get table() {
+        return this.dataSource.driver.buildTableName(this.tableName, this.schema, this.database);
+    }
+    async buildOptions(input = {}) {
+        const options = {
+            ...input,
+            seeds: input.seeds || [],
+            factories: input.factories || [],
+            seedTracking: input.seedTracking ?? false
+        };
+        if (!options.seeds || options.seeds.length === 0) {
+            options.seeds = this.dataSourceOptions.seeds;
+        }
+        if (!options.seeds || options.seeds.length === 0) {
+            options.seeds = useEnv('seeds');
+        }
+        if (!options.seeds || options.seeds.length === 0) {
+            options.seeds = [
+                'src/database/seeds/**/*{.ts,.js}'
+            ];
+        }
+        if (!options.factories || options.factories.length === 0) {
+            options.factories = this.dataSourceOptions.factories;
+        }
+        if (!options.factories || options.factories.length === 0) {
+            options.factories = useEnv('factories');
+        }
+        if (!options.factories || options.factories.length === 0) {
+            options.factories = [
+                'src/database/factories/**/*{.ts,.js}'
+            ];
+        }
+        if (typeof options.seedTracking === 'undefined') {
+            options.seedTracking = this.dataSourceOptions.seedTracking;
+        }
+        if (!this.options.preserveFilePaths) {
+            let tsConfig;
+            if (locter.isObject(this.options.tsconfig)) {
+                tsConfig = this.options.tsconfig;
+            } else {
+                tsConfig = await readTSConfig(resolveFilePath(this.options.tsconfig || 'tsconfig.json', this.options.root));
+            }
+            await adjustFilePaths(options, [
+                'seeds',
+                'seedName',
+                'factories'
+            ], tsConfig);
+        }
+        return options;
+    }
+    classNameToTimestamp(className) {
+        const match = className.match(/^(.*)([0-9]{13,})$/);
+        if (match) {
+            return parseInt(match[2], 10);
+        }
+        return undefined;
+    }
+}
+
+async function runSeeder(dataSource, seeder, options = {}) {
+    if (typeof seeder === 'string') {
+        options.seedName = seeder;
+    } else {
+        options.seeds = [
+            seeder
+        ];
+    }
+    const executor = new SeederExecutor(dataSource);
+    const output = await executor.execute(options);
+    return output.pop();
+}
+async function runSeeders(dataSource, options) {
+    const executor = new SeederExecutor(dataSource);
+    return executor.execute(options);
+}
+
+class SeedCreateCommand {
+    builder(args) {
+        return args.option('root', {
+            alias: 'r',
+            default: process.cwd(),
+            describe: 'Root directory of the project.'
+        }).option('timestamp', {
+            alias: 't',
+            type: 'number',
+            describe: 'Custom timestamp for the seeder name.'
+        }).option('javascript', {
+            alias: 'j',
+            type: 'boolean',
+            default: false,
+            describe: 'Generate a seeder file for JavaScript instead of TypeScript.'
+        }).option('name', {
+            alias: 'n',
+            describe: 'Name (or relative path incl. name) of the seeder.',
+            demandOption: true
+        });
+    }
+    async handler(raw) {
+        const args = raw;
+        let timestamp;
+        if (Number.isNaN(args.timestamp) || !args.timestamp) {
+            timestamp = Date.now();
+        } else {
+            timestamp = args.timestamp;
+        }
+        const sourcePath = parseFilePath(args.name, args.root);
+        const dirNameIsDirectory = await isDirectory(sourcePath.directory);
+        if (!dirNameIsDirectory) {
+            consola.consola.warn(`The output directory ${sourcePath.directory} does not exist.`);
+            process.exit(1);
+        }
+        const extension = args.javascript ? '.js' : '.ts';
+        const nameExtension = locter.getFileNameExtension(sourcePath.name);
+        const nameWithoutExtension = locter.removeFileNameExtension(sourcePath.name);
+        let fileName;
+        if (nameExtension) {
+            fileName = `${timestamp}-${sourcePath.name}`;
+        } else {
+            fileName = `${timestamp}-${sourcePath.name}${extension}`;
+        }
+        const filePath = sourcePath.directory + path.sep + fileName;
+        const template = buildSeederFileTemplate(nameWithoutExtension, timestamp);
+        consola.consola.info(`Seed Directory: ${sourcePath.directory}`);
+        consola.consola.info(`Seed FileName: ${fileName}`);
+        consola.consola.info(`Seed Name: ${pascalCase.pascalCase(nameWithoutExtension)}`);
+        try {
+            await fs.promises.writeFile(filePath, template, {
+                encoding: 'utf-8'
+            });
+        } catch (e) {
+            consola.consola.warn(`The seed could not be written to the path ${filePath}.`);
+            process.exit(1);
+        }
+        process.exit(0);
+    }
+    constructor(){
+        this.command = 'seed:create';
+        this.describe = 'Create a seeder file.';
+    }
+}
+
+class SeedRunCommand {
+    builder(args) {
+        return args.option('preserveFilePaths', {
+            default: false,
+            type: 'boolean',
+            describe: 'This option indicates if file paths should be preserved.'
+        }).option('root', {
+            alias: 'r',
+            default: process.cwd(),
+            describe: 'Root directory of the project.'
+        }).option('tsconfig', {
+            alias: 'tc',
+            default: 'tsconfig.json',
+            describe: 'Name (or relative path incl. name) of the tsconfig file.'
+        }).option('dataSource', {
+            alias: 'd',
+            default: 'data-source',
+            describe: 'Name (or relative path incl. name) of the data-source file.'
+        }).option('name', {
+            alias: 'n',
+            describe: 'Name (or relative path incl. name) of the seeder.'
+        });
+    }
+    async handler(raw) {
+        const args = raw;
+        let tsconfig;
+        let sourcePath = resolveFilePath(args.dataSource, args.root);
+        if (!args.preserveFilePaths) {
+            tsconfig = await readTSConfig(args.root);
+            sourcePath = await adjustFilePath(sourcePath, tsconfig);
+            args.name = await adjustFilePath(args.name, tsconfig);
+        }
+        const source = parseFilePath(sourcePath);
+        consola.consola.info(`DataSource Directory: ${source.directory}`);
+        consola.consola.info(`DataSource Name: ${source.name}`);
+        const dataSourceOptions = await buildDataSourceOptions({
+            dataSourceName: source.name,
+            directory: source.directory,
+            tsconfig,
+            preserveFilePaths: args.preserveFilePaths
+        });
+        setDataSourceOptions(dataSourceOptions);
+        if (args.name) {
+            consola.consola.info(`Seed Name: ${args.name}`);
+        }
+        const dataSource = await useDataSource();
+        const executor = new SeederExecutor(dataSource, {
+            root: args.root,
+            tsconfig,
+            preserveFilePaths: args.preserveFilePaths
+        });
+        await executor.execute({
+            seedName: args.name
+        });
+        process.exit(0);
+    }
+    constructor(){
+        this.command = 'seed:run';
+        this.describe = 'Populate the database with an initial data set or generated data by a factory.';
+    }
+}
+
+class EntityRelationLookupError extends TypeormExtensionError {
+    constructor(options){
+        super(options.message);
+        this.relation = options.relation;
+        this.columns = options.columns;
+    }
+    static notReferenced(relation, columns) {
+        return new EntityRelationLookupError({
+            message: `${relation} entity is not referenced by ${columns.join(', ')}`,
+            relation,
+            columns
+        });
+    }
+    static notFound(relation, columns) {
+        return new EntityRelationLookupError({
+            message: `Can't find ${relation} entity by ${columns.join(', ')}`,
+            relation,
+            columns
+        });
+    }
+}
+
+/**
+ * Receive metadata for a given repository or entity-target.
+ *
+ * @experimental
+ * @param input
+ * @param dataSource
+ */ async function getEntityMetadata(input, dataSource) {
+    if (input instanceof typeorm.Repository) {
+        return input.metadata;
+    }
+    dataSource = dataSource || await useDataSource();
+    const index = dataSource.entityMetadatas.findIndex((entityMetadata)=>entityMetadata.target === input);
+    if (index === -1) {
+        throw new Error(`The entity ${input} is not registered.`);
+    }
+    return dataSource.entityMetadatas[index];
+}
+
+/**
+ * Get (relation-) property names of a given entity.
+ *
+ * @experimental
+ * @param input
+ * @param dataSource
+ */ async function getEntityPropertyNames(input, dataSource) {
+    let entityMetadata;
+    if (input instanceof typeorm.Repository) {
+        entityMetadata = input.metadata;
+    } else {
+        entityMetadata = await getEntityMetadata(input, dataSource);
+    }
+    const items = [];
+    for(let i = 0; i < entityMetadata.columns.length; i++){
+        items.push(entityMetadata.columns[i].propertyName);
+    }
+    for(let i = 0; i < entityMetadata.relations.length; i++){
+        items.push(entityMetadata.relations[i].propertyName);
+    }
+    return items;
+}
+
+/**
+ * Validate join columns of a given entity.
+ * It will look up and append the referenced entities to the input entity.
+ *
+ * @experimental
+ * @param entity
+ * @param options
+ */ async function validateEntityJoinColumns(entity, options) {
+    const dataSource = options.dataSource || await useDataSource();
+    const entityMetadata = await getEntityMetadata(options.entityTarget, dataSource);
+    const relations = {};
+    for(let i = 0; i < entityMetadata.relations.length; i++){
+        const relation = entityMetadata.relations[i];
+        let skipRelation = false;
+        const where = {};
+        const columns = [];
+        for(let j = 0; j < relation.joinColumns.length; j++){
+            const joinColumn = relation.joinColumns[j];
+            if (typeof entity[joinColumn.propertyName] === 'undefined') {
+                continue;
+            }
+            if (joinColumn.isNullable && entity[joinColumn.propertyName] === null) {
+                skipRelation = true;
+                break;
+            }
+            if (joinColumn.referencedColumn) {
+                where[joinColumn.referencedColumn.propertyName] = entity[joinColumn.propertyName];
+                columns.push(joinColumn.propertyName);
+            } else {
+                throw EntityRelationLookupError.notReferenced(relation.propertyName, [
+                    joinColumn.propertyName
+                ]);
+            }
+        }
+        if (skipRelation || columns.length === 0) {
+            continue;
+        }
+        const repository = dataSource.getRepository(relation.type);
+        const item = await repository.findOne({
+            where
+        });
+        if (!item) {
+            throw EntityRelationLookupError.notFound(relation.propertyName, columns);
+        }
+        relations[relation.propertyName] = item;
+    }
+    const relationKeys = Object.keys(relations);
+    for(let i = 0; i < relationKeys.length; i++){
+        const relationKey = relationKeys[i];
+        entity[relationKey] = relations[relationKey];
+    }
+    return entity;
+}
+
+function transformUndefinedToNull(input) {
+    if (typeof input === 'undefined') {
+        return null;
+    }
+    return input;
+}
+function applyWhereExpression(qb, data, type) {
+    const elements = [];
+    const keys = Object.keys(data);
+    for(let i = 0; i < keys.length; i++){
+        elements.push({
+            key: keys[i],
+            value: transformUndefinedToNull(data[keys[i]]),
+            operator: type === 'target' ? rapiq.FilterComparisonOperator.EQUAL : rapiq.FilterComparisonOperator.NOT_EQUAL
+        });
+    }
+    const queryFilters = transformParsedFilters(elements, {
+        bindingKey (key) {
+            if (type === 'source') {
+                return `filter_source_${key}`;
+            }
+            return `filter_target_${key}`;
+        }
+    });
+    applyFiltersTransformed(qb, queryFilters);
+    return queryFilters;
+}
+/**
+ * Check if a given entity does not already exist.
+ * Composite unique keys on a null column can only be present once.
+ *
+ * @experimental
+ * @param options
+ */ async function isEntityUnique(options) {
+    const dataSource = options.dataSource || await useDataSource();
+    const metadata = await getEntityMetadata(options.entityTarget, dataSource);
+    const repository = dataSource.getRepository(metadata.target);
+    const primaryColumnNames = metadata.primaryColumns.map((c)=>c.propertyName);
+    const columnGroups = [];
+    if (metadata.ownUniques && metadata.ownUniques.length > 0) {
+        for(let i = 0; i < metadata.ownUniques.length; i++){
+            columnGroups.push(metadata.ownUniques[i].columns.map((column)=>column.propertyName));
+        }
+    } else {
+        for(let i = 0; i < metadata.indices.length; i++){
+            const index = metadata.indices[i];
+            if (!index.isUnique || index.entityMetadata.target !== metadata.target) {
+                continue;
+            }
+            columnGroups.push(index.columns.map((column)=>column.propertyName));
+        }
+    }
+    for(let i = 0; i < columnGroups.length; i++){
+        const queryBuilder = repository.createQueryBuilder('entity');
+        queryBuilder.where(new typeorm.Brackets((qb)=>{
+            applyWhereExpression(qb, pickRecord(options.entity, columnGroups[i]), 'target');
+        }));
+        if (options.entityExisting) {
+            queryBuilder.andWhere(new typeorm.Brackets((qb)=>{
+                applyWhereExpression(qb, pickRecord(options.entityExisting, primaryColumnNames), 'source');
+            }));
+        }
+        const entity = await queryBuilder.getOne();
+        if (entity) {
+            return false;
+        }
+    }
+    return true;
+}
+
+exports.CodeTransformation = CodeTransformation;
+exports.DatabaseCreateCommand = DatabaseCreateCommand;
+exports.DatabaseDropCommand = DatabaseDropCommand;
+exports.DriverError = DriverError;
+exports.EntityRelationLookupError = EntityRelationLookupError;
+exports.EnvironmentName = EnvironmentName;
+exports.EnvironmentVariableName = EnvironmentVariableName;
+exports.OptionsError = OptionsError;
+exports.SeedCreateCommand = SeedCreateCommand;
+exports.SeedRunCommand = SeedRunCommand;
+exports.SeederEntity = SeederEntity;
+exports.SeederExecutor = SeederExecutor;
+exports.SeederFactory = SeederFactory;
+exports.SeederFactoryManager = SeederFactoryManager;
+exports.TypeormExtensionError = TypeormExtensionError;
+exports.adjustFilePath = adjustFilePath;
+exports.adjustFilePaths = adjustFilePaths;
+exports.applyFields = applyFields;
+exports.applyFilters = applyFilters;
+exports.applyFiltersTransformed = applyFiltersTransformed;
+exports.applyPagination = applyPagination;
+exports.applyQuery = applyQuery;
+exports.applyQueryFields = applyQueryFields;
+exports.applyQueryFieldsParseOutput = applyQueryFieldsParseOutput;
+exports.applyQueryFilters = applyQueryFilters;
+exports.applyQueryFiltersParseOutput = applyQueryFiltersParseOutput;
+exports.applyQueryPagination = applyQueryPagination;
+exports.applyQueryPaginationParseOutput = applyQueryPaginationParseOutput;
+exports.applyQueryParseOutput = applyQueryParseOutput;
+exports.applyQueryRelations = applyQueryRelations;
+exports.applyQueryRelationsParseOutput = applyQueryRelationsParseOutput;
+exports.applyQuerySort = applyQuerySort;
+exports.applyQuerySortParseOutput = applyQuerySortParseOutput;
+exports.applyRelations = applyRelations;
+exports.applySort = applySort;
+exports.buildDataSourceOptions = buildDataSourceOptions;
+exports.buildDatabaseCreateContext = buildDatabaseCreateContext;
+exports.buildDatabaseDropContext = buildDatabaseDropContext;
+exports.buildDriverOptions = buildDriverOptions;
+exports.buildFilePathname = buildFilePathname;
+exports.buildKeyWithPrefix = buildKeyWithPrefix;
+exports.buildSeederFileTemplate = buildSeederFileTemplate;
+exports.canReplaceWindowsSeparator = canReplaceWindowsSeparator;
+exports.checkDatabase = checkDatabase;
+exports.createCockroachDBDatabase = createCockroachDBDatabase;
+exports.createDatabase = createDatabase;
+exports.createDriver = createDriver;
+exports.createMongoDBDatabase = createMongoDBDatabase;
+exports.createMsSQLDatabase = createMsSQLDatabase;
+exports.createMySQLDatabase = createMySQLDatabase;
+exports.createOracleDatabase = createOracleDatabase;
+exports.createPostgresDatabase = createPostgresDatabase;
+exports.createSQLiteDatabase = createSQLiteDatabase;
+exports.createSimpleMongoDBConnection = createSimpleMongoDBConnection;
+exports.createSimpleMsSQLConnection = createSimpleMsSQLConnection;
+exports.createSimpleMySQLConnection = createSimpleMySQLConnection;
+exports.createSimpleOracleConnection = createSimpleOracleConnection;
+exports.createSimplePostgresConnection = createSimplePostgresConnection;
+exports.detectCodeTransformation = detectCodeTransformation;
+exports.dropCockroachDBDatabase = dropCockroachDBDatabase;
+exports.dropDatabase = dropDatabase;
+exports.dropMongoDBDatabase = dropMongoDBDatabase;
+exports.dropMsSQLDatabase = dropMsSQLDatabase;
+exports.dropMySQLDatabase = dropMySQLDatabase;
+exports.dropOracleDatabase = dropOracleDatabase;
+exports.dropPostgresDatabase = dropPostgresDatabase;
+exports.dropSQLiteDatabase = dropSQLiteDatabase;
+exports.executeSimpleCockroachDBQuery = executeSimpleCockroachDBQuery;
+exports.executeSimpleMysqlQuery = executeSimpleMysqlQuery;
+exports.executeSimplePostgresQuery = executeSimplePostgresQuery;
+exports.existsQuery = existsQuery;
+exports.extendObject = extendObject;
+exports.findDataSource = findDataSource;
+exports.generateMigration = generateMigration;
+exports.getAliasForPath = getAliasForPath;
+exports.getCharacterSetFromDataSourceOptions = getCharacterSetFromDataSourceOptions;
+exports.getCharsetFromDataSourceOptions = getCharsetFromDataSourceOptions;
+exports.getEntityMetadata = getEntityMetadata;
+exports.getEntityName = getEntityName;
+exports.getEntityPropertyNames = getEntityPropertyNames;
+exports.hasDataSource = hasDataSource;
+exports.hasDataSourceOptions = hasDataSourceOptions;
+exports.hasEnvDataSourceOptions = hasEnvDataSourceOptions;
+exports.hasOwnProperty = hasOwnProperty;
+exports.hasStringProperty = hasStringProperty;
+exports.hasTrailingSlash = hasTrailingSlash;
+exports.isCodeTransformation = isCodeTransformation;
+exports.isDirectory = isDirectory;
+exports.isEntityUnique = isEntityUnique;
+exports.isPromise = isPromise;
+exports.isQueryOptionDefined = isQueryOptionDefined;
+exports.mergeDataSourceOptions = mergeDataSourceOptions;
+exports.mergeDataSourceOptionsWithEnv = mergeDataSourceOptionsWithEnv;
+exports.parseFilePath = parseFilePath;
+exports.pickRecord = pickRecord;
+exports.prepareSeederFactories = prepareSeederFactories;
+exports.prepareSeederSeeds = prepareSeederSeeds;
+exports.readDataSourceOptionsFromEnv = readDataSourceOptionsFromEnv;
+exports.readTSConfig = readTSConfig;
+exports.replaceWindowSeparator = replaceWindowSeparator;
+exports.resetEnv = resetEnv;
+exports.resolveFilePath = resolveFilePath;
+exports.resolveFilePaths = resolveFilePaths;
+exports.resolveFilePatterns = resolveFilePatterns;
+exports.runSeeder = runSeeder;
+exports.runSeeders = runSeeders;
+exports.safeReplaceWindowsSeparator = safeReplaceWindowsSeparator;
+exports.setDataSource = setDataSource;
+exports.setDataSourceOptions = setDataSourceOptions;
+exports.setSeederFactory = setSeederFactory;
+exports.synchronizeDatabaseSchema = synchronizeDatabaseSchema;
+exports.transformFilePath = transformFilePath;
+exports.transformParsedFilters = transformParsedFilters;
+exports.unsetDataSource = unsetDataSource;
+exports.useDataSource = useDataSource;
+exports.useDataSourceOptions = useDataSourceOptions;
+exports.useEnv = useEnv;
+exports.useSeederFactory = useSeederFactory;
+exports.useSeederFactoryManager = useSeederFactoryManager;
+exports.validateEntityJoinColumns = validateEntityJoinColumns;
+exports.withoutTrailingSlash = withoutTrailingSlash;
+//# sourceMappingURL=index.cjs.map