orcaq 1.0.20

package/.output/server/node_modules/typeorm/migration/MigrationExecutor.js

@@ -0,0 +1,534 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationExecutor = void 0;
+const Table_1 = require("../schema-builder/table/Table");
+const Migration_1 = require("./Migration");
+const MssqlParameter_1 = require("../driver/sqlserver/MssqlParameter");
+const error_1 = require("../error");
+const InstanceChecker_1 = require("../util/InstanceChecker");
+/**
+ * Executes migrations: runs pending and reverts previously executed migrations.
+ */
+class MigrationExecutor {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(connection, queryRunner) {
+        this.connection = connection;
+        this.queryRunner = queryRunner;
+        // -------------------------------------------------------------------------
+        // Public Properties
+        // -------------------------------------------------------------------------
+        /**
+         * Indicates how migrations should be run in transactions.
+         *   all: all migrations are run in a single transaction
+         *   none: all migrations are run without a transaction
+         *   each: each migration is run in a separate transaction
+         */
+        this.transaction = "all";
+        const { schema } = this.connection.driver.options;
+        const database = this.connection.driver.database;
+        this.migrationsDatabase = database;
+        this.migrationsSchema = schema;
+        this.migrationsTableName =
+            connection.options.migrationsTableName || "migrations";
+        this.migrationsTable = this.connection.driver.buildTableName(this.migrationsTableName, schema, database);
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Tries to execute a single migration given.
+     */
+    async executeMigration(migration) {
+        return this.withQueryRunner(async (queryRunner) => {
+            await this.createMigrationsTableIfNotExist(queryRunner);
+            // create typeorm_metadata table if it's not created yet
+            const schemaBuilder = this.connection.driver.createSchemaBuilder();
+            if (InstanceChecker_1.InstanceChecker.isRdbmsSchemaBuilder(schemaBuilder)) {
+                await schemaBuilder.createMetadataTableIfNecessary(queryRunner);
+            }
+            await queryRunner.beforeMigration();
+            await migration.instance.up(queryRunner);
+            await queryRunner.afterMigration();
+            await this.insertExecutedMigration(queryRunner, migration);
+            return migration;
+        });
+    }
+    /**
+     * Returns an array of all migrations.
+     */
+    async getAllMigrations() {
+        return Promise.resolve(this.getMigrations());
+    }
+    /**
+     * Returns an array of all executed migrations.
+     */
+    async getExecutedMigrations() {
+        return this.withQueryRunner(async (queryRunner) => {
+            await this.createMigrationsTableIfNotExist(queryRunner);
+            return await this.loadExecutedMigrations(queryRunner);
+        });
+    }
+    /**
+     * Returns an array of all pending migrations.
+     */
+    async getPendingMigrations() {
+        const allMigrations = await this.getAllMigrations();
+        const executedMigrations = await this.getExecutedMigrations();
+        return allMigrations.filter((migration) => !executedMigrations.find((executedMigration) => executedMigration.name === migration.name));
+    }
+    /**
+     * Inserts an executed migration.
+     */
+    insertMigration(migration) {
+        return this.withQueryRunner((q) => this.insertExecutedMigration(q, migration));
+    }
+    /**
+     * Deletes an executed migration.
+     */
+    deleteMigration(migration) {
+        return this.withQueryRunner((q) => this.deleteExecutedMigration(q, migration));
+    }
+    /**
+     * Lists all migrations and whether they have been executed or not
+     * returns true if there are unapplied migrations
+     */
+    async showMigrations() {
+        let hasUnappliedMigrations = false;
+        const queryRunner = this.queryRunner || this.connection.createQueryRunner();
+        // create migrations table if its not created yet
+        await this.createMigrationsTableIfNotExist(queryRunner);
+        // get all migrations that are executed and saved in the database
+        const executedMigrations = await this.loadExecutedMigrations(queryRunner);
+        // get all user's migrations in the source code
+        const allMigrations = this.getMigrations();
+        for (const migration of allMigrations) {
+            const executedMigration = executedMigrations.find((executedMigration) => executedMigration.name === migration.name);
+            if (executedMigration) {
+                this.connection.logger.logSchemaBuild(`[X] ${executedMigration.id} ${migration.name}`);
+            }
+            else {
+                hasUnappliedMigrations = true;
+                this.connection.logger.logSchemaBuild(`[ ] ${migration.name}`);
+            }
+        }
+        // if query runner was created by us then release it
+        if (!this.queryRunner) {
+            await queryRunner.release();
+        }
+        return hasUnappliedMigrations;
+    }
+    /**
+     * Executes all pending migrations. Pending migrations are migrations that are not yet executed,
+     * thus not saved in the database.
+     */
+    async executePendingMigrations() {
+        const queryRunner = this.queryRunner || this.connection.createQueryRunner();
+        // create migrations table if it's not created yet
+        await this.createMigrationsTableIfNotExist(queryRunner);
+        // create the typeorm_metadata table if it's not created yet
+        const schemaBuilder = this.connection.driver.createSchemaBuilder();
+        if (InstanceChecker_1.InstanceChecker.isRdbmsSchemaBuilder(schemaBuilder)) {
+            await schemaBuilder.createMetadataTableIfNecessary(queryRunner);
+        }
+        // get all migrations that are executed and saved in the database
+        const executedMigrations = await this.loadExecutedMigrations(queryRunner);
+        // get the time when last migration was executed
+        const lastTimeExecutedMigration = this.getLatestTimestampMigration(executedMigrations);
+        // get all user's migrations in the source code
+        const allMigrations = this.getMigrations();
+        // variable to store all migrations we did successfully
+        const successMigrations = [];
+        // find all migrations that needs to be executed
+        const pendingMigrations = allMigrations.filter((migration) => {
+            // check if we already have executed migration
+            const executedMigration = executedMigrations.find((executedMigration) => executedMigration.name === migration.name);
+            if (executedMigration)
+                return false;
+            // migration is new and not executed. now check if its timestamp is correct
+            // if (lastTimeExecutedMigration && migration.timestamp < lastTimeExecutedMigration.timestamp)
+            //     throw new TypeORMError(`New migration found: ${migration.name}, however this migration's timestamp is not valid. Migration's timestamp should not be older then migrations already executed in the database.`);
+            // every check is passed means that migration was not run yet and we need to run it
+            return true;
+        });
+        // if no migrations are pending then nothing to do here
+        if (!pendingMigrations.length) {
+            this.connection.logger.logSchemaBuild(`No migrations are pending`);
+            // if query runner was created by us then release it
+            if (!this.queryRunner)
+                await queryRunner.release();
+            return [];
+        }
+        // log information about migration execution
+        this.connection.logger.logSchemaBuild(`${executedMigrations.length} migrations are already loaded in the database.`);
+        this.connection.logger.logSchemaBuild(`${allMigrations.length} migrations were found in the source code.`);
+        if (lastTimeExecutedMigration)
+            this.connection.logger.logSchemaBuild(`${lastTimeExecutedMigration.name} is the last executed migration. It was executed on ${new Date(lastTimeExecutedMigration.timestamp).toString()}.`);
+        this.connection.logger.logSchemaBuild(`${pendingMigrations.length} migrations are new migrations must be executed.`);
+        if (this.transaction === "all") {
+            // If we desire to run all migrations in a single transaction
+            // but there is a migration that explicitly overrides the transaction mode
+            // then we have to fail since we cannot properly resolve that intent
+            // In theory we could support overrides that are set to `true`,
+            // however to keep the interface more rigid, we fail those too
+            const migrationsOverridingTransactionMode = pendingMigrations.filter((migration) => !(migration.instance?.transaction === undefined));
+            if (migrationsOverridingTransactionMode.length > 0) {
+                const error = new error_1.ForbiddenTransactionModeOverrideError(migrationsOverridingTransactionMode);
+                this.connection.logger.logMigration(`Migrations failed, error: ${error.message}`);
+                throw error;
+            }
+        }
+        // Set the per-migration defaults for the transaction mode
+        // so that we have one centralized place that controls this behavior
+        // When transaction mode is `each` the default is to run in a transaction
+        // When transaction mode is `none` the default is to not run in a transaction
+        // When transaction mode is `all` the default is to not run in a transaction
+        // since all the migrations are already running in one single transaction
+        const txModeDefault = {
+            each: true,
+            none: false,
+            all: false,
+        }[this.transaction];
+        for (const migration of pendingMigrations) {
+            if (migration.instance) {
+                const instanceTx = migration.instance.transaction;
+                if (instanceTx === undefined) {
+                    migration.transaction = txModeDefault;
+                }
+                else {
+                    migration.transaction = instanceTx;
+                }
+            }
+        }
+        // start transaction if its not started yet
+        let transactionStartedByUs = false;
+        if (this.transaction === "all" && !queryRunner.isTransactionActive) {
+            await queryRunner.beforeMigration();
+            await queryRunner.startTransaction();
+            transactionStartedByUs = true;
+        }
+        // run all pending migrations in a sequence
+        try {
+            for (const migration of pendingMigrations) {
+                if (this.fake) {
+                    // directly insert migration record into the database if it is fake
+                    await this.insertExecutedMigration(queryRunner, migration);
+                    // nothing else needs to be done, continue to next migration
+                    continue;
+                }
+                if (migration.transaction && !queryRunner.isTransactionActive) {
+                    await queryRunner.beforeMigration();
+                    await queryRunner.startTransaction();
+                    transactionStartedByUs = true;
+                }
+                await migration
+                    .instance.up(queryRunner)
+                    .catch((error) => {
+                    // informative log about migration failure
+                    this.connection.logger.logMigration(`Migration "${migration.name}" failed, error: ${error?.message}`);
+                    throw error;
+                })
+                    .then(async () => {
+                    // now when migration is executed we need to insert record about it into the database
+                    await this.insertExecutedMigration(queryRunner, migration);
+                    // commit transaction if we started it
+                    if (migration.transaction && transactionStartedByUs) {
+                        await queryRunner.commitTransaction();
+                        await queryRunner.afterMigration();
+                    }
+                })
+                    .then(() => {
+                    // informative log about migration success
+                    successMigrations.push(migration);
+                    this.connection.logger.logSchemaBuild(`Migration ${migration.name} has been ${this.fake ? "(fake) " : ""}executed successfully.`);
+                });
+            }
+            // commit transaction if we started it
+            if (this.transaction === "all" && transactionStartedByUs) {
+                await queryRunner.commitTransaction();
+                await queryRunner.afterMigration();
+            }
+        }
+        catch (err) {
+            // rollback transaction if we started it
+            if (transactionStartedByUs) {
+                try {
+                    // we throw original error even if rollback thrown an error
+                    await queryRunner.rollbackTransaction();
+                }
+                catch (rollbackError) { }
+            }
+            throw err;
+        }
+        finally {
+            // if query runner was created by us then release it
+            if (!this.queryRunner)
+                await queryRunner.release();
+        }
+        return successMigrations;
+    }
+    /**
+     * Reverts last migration that were run.
+     */
+    async undoLastMigration() {
+        const queryRunner = this.queryRunner || this.connection.createQueryRunner();
+        // create migrations table if it's not created yet
+        await this.createMigrationsTableIfNotExist(queryRunner);
+        // create typeorm_metadata table if it's not created yet
+        const schemaBuilder = this.connection.driver.createSchemaBuilder();
+        if (InstanceChecker_1.InstanceChecker.isRdbmsSchemaBuilder(schemaBuilder)) {
+            await schemaBuilder.createMetadataTableIfNecessary(queryRunner);
+        }
+        // get all migrations that are executed and saved in the database
+        const executedMigrations = await this.loadExecutedMigrations(queryRunner);
+        // get the time when last migration was executed
+        const lastTimeExecutedMigration = this.getLatestExecutedMigration(executedMigrations);
+        // if no migrations found in the database then nothing to revert
+        if (!lastTimeExecutedMigration) {
+            this.connection.logger.logSchemaBuild(`No migrations were found in the database. Nothing to revert!`);
+            return;
+        }
+        // get all user's migrations in the source code
+        const allMigrations = this.getMigrations();
+        // find the instance of the migration we need to remove
+        const migrationToRevert = allMigrations.find((migration) => migration.name === lastTimeExecutedMigration.name);
+        // if no migrations found in the database then nothing to revert
+        if (!migrationToRevert)
+            throw new error_1.TypeORMError(`No migration ${lastTimeExecutedMigration.name} was found in the source code. Make sure you have this migration in your codebase and its included in the connection options.`);
+        // log information about migration execution
+        this.connection.logger.logSchemaBuild(`${executedMigrations.length} migrations are already loaded in the database.`);
+        this.connection.logger.logSchemaBuild(`${lastTimeExecutedMigration.name} is the last executed migration. It was executed on ${new Date(lastTimeExecutedMigration.timestamp).toString()}.`);
+        this.connection.logger.logSchemaBuild(`Now reverting it...`);
+        // start transaction if its not started yet
+        let transactionStartedByUs = false;
+        if (this.transaction !== "none" && !queryRunner.isTransactionActive) {
+            await queryRunner.startTransaction();
+            transactionStartedByUs = true;
+        }
+        try {
+            if (!this.fake) {
+                await queryRunner.beforeMigration();
+                await migrationToRevert.instance.down(queryRunner);
+                await queryRunner.afterMigration();
+            }
+            await this.deleteExecutedMigration(queryRunner, migrationToRevert);
+            this.connection.logger.logSchemaBuild(`Migration ${migrationToRevert.name} has been ${this.fake ? "(fake) " : ""}reverted successfully.`);
+            // commit transaction if we started it
+            if (transactionStartedByUs)
+                await queryRunner.commitTransaction();
+        }
+        catch (err) {
+            // rollback transaction if we started it
+            if (transactionStartedByUs) {
+                try {
+                    // we throw original error even if rollback thrown an error
+                    await queryRunner.rollbackTransaction();
+                }
+                catch (rollbackError) { }
+            }
+            throw err;
+        }
+        finally {
+            // if query runner was created by us then release it
+            if (!this.queryRunner)
+                await queryRunner.release();
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Protected Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Creates table "migrations" that will store information about executed migrations.
+     */
+    async createMigrationsTableIfNotExist(queryRunner) {
+        // If driver is mongo no need to create
+        if (this.connection.driver.options.type === "mongodb") {
+            return;
+        }
+        const tableExist = await queryRunner.hasTable(this.migrationsTable); // todo: table name should be configurable
+        if (!tableExist) {
+            await queryRunner.createTable(new Table_1.Table({
+                database: this.migrationsDatabase,
+                schema: this.migrationsSchema,
+                name: this.migrationsTable,
+                columns: [
+                    {
+                        name: "id",
+                        type: this.connection.driver.normalizeType({
+                            type: this.connection.driver.mappedDataTypes
+                                .migrationId,
+                        }),
+                        isGenerated: true,
+                        generationStrategy: "increment",
+                        isPrimary: true,
+                        isNullable: false,
+                    },
+                    {
+                        name: "timestamp",
+                        type: this.connection.driver.normalizeType({
+                            type: this.connection.driver.mappedDataTypes
+                                .migrationTimestamp,
+                        }),
+                        isPrimary: false,
+                        isNullable: false,
+                    },
+                    {
+                        name: "name",
+                        type: this.connection.driver.normalizeType({
+                            type: this.connection.driver.mappedDataTypes
+                                .migrationName,
+                        }),
+                        isNullable: false,
+                    },
+                ],
+            }));
+        }
+    }
+    /**
+     * Loads all migrations that were executed and saved into the database (sorts by id).
+     */
+    async loadExecutedMigrations(queryRunner) {
+        if (this.connection.driver.options.type === "mongodb") {
+            const mongoRunner = queryRunner;
+            return mongoRunner
+                .cursor(this.migrationsTableName, {})
+                .sort({ _id: -1 })
+                .toArray();
+        }
+        else {
+            const migrationsRaw = await this.connection.manager
+                .createQueryBuilder(queryRunner)
+                .select()
+                .orderBy(this.connection.driver.escape("id"), "DESC")
+                .from(this.migrationsTable, this.migrationsTableName)
+                .getRawMany();
+            return migrationsRaw.map((migrationRaw) => {
+                return new Migration_1.Migration(parseInt(migrationRaw["id"]), parseInt(migrationRaw["timestamp"]), migrationRaw["name"]);
+            });
+        }
+    }
+    /**
+     * Gets all migrations that setup for this connection.
+     */
+    getMigrations() {
+        const migrations = this.connection.migrations.map((migration) => {
+            const migrationClassName = migration.name || migration.constructor.name;
+            const migrationTimestamp = parseInt(migrationClassName.substr(-13), 10);
+            if (!migrationTimestamp || isNaN(migrationTimestamp)) {
+                throw new error_1.TypeORMError(`${migrationClassName} migration name is wrong. Migration class name should have a JavaScript timestamp appended.`);
+            }
+            return new Migration_1.Migration(undefined, migrationTimestamp, migrationClassName, migration);
+        });
+        this.checkForDuplicateMigrations(migrations);
+        // sort them by timestamp
+        return migrations.sort((a, b) => a.timestamp - b.timestamp);
+    }
+    checkForDuplicateMigrations(migrations) {
+        const migrationNames = migrations.map((migration) => migration.name);
+        const duplicates = Array.from(new Set(migrationNames.filter((migrationName, index) => migrationNames.indexOf(migrationName) < index)));
+        if (duplicates.length > 0) {
+            throw Error(`Duplicate migrations: ${duplicates.join(", ")}`);
+        }
+    }
+    /**
+     * Finds the latest migration (sorts by timestamp) in the given array of migrations.
+     */
+    getLatestTimestampMigration(migrations) {
+        const sortedMigrations = migrations
+            .map((migration) => migration)
+            .sort((a, b) => (a.timestamp - b.timestamp) * -1);
+        return sortedMigrations.length > 0 ? sortedMigrations[0] : undefined;
+    }
+    /**
+     * Finds the latest migration in the given array of migrations.
+     * PRE: Migration array must be sorted by descending id.
+     */
+    getLatestExecutedMigration(sortedMigrations) {
+        return sortedMigrations.length > 0 ? sortedMigrations[0] : undefined;
+    }
+    /**
+     * Inserts new executed migration's data into migrations table.
+     */
+    async insertExecutedMigration(queryRunner, migration) {
+        const values = {};
+        if (this.connection.driver.options.type === "mssql") {
+            values["timestamp"] = new MssqlParameter_1.MssqlParameter(migration.timestamp, this.connection.driver.normalizeType({
+                type: this.connection.driver.mappedDataTypes
+                    .migrationTimestamp,
+            }));
+            values["name"] = new MssqlParameter_1.MssqlParameter(migration.name, this.connection.driver.normalizeType({
+                type: this.connection.driver.mappedDataTypes.migrationName,
+            }));
+        }
+        else {
+            values["timestamp"] = migration.timestamp;
+            values["name"] = migration.name;
+        }
+        if (this.connection.driver.options.type === "mongodb") {
+            const mongoRunner = queryRunner;
+            await mongoRunner.databaseConnection
+                .db(this.connection.driver.database)
+                .collection(this.migrationsTableName)
+                .insertOne(values);
+        }
+        else {
+            const qb = queryRunner.manager.createQueryBuilder();
+            await qb
+                .insert()
+                .into(this.migrationsTable)
+                .values(values)
+                .execute();
+        }
+    }
+    /**
+     * Delete previously executed migration's data from the migrations table.
+     */
+    async deleteExecutedMigration(queryRunner, migration) {
+        const conditions = {};
+        if (this.connection.driver.options.type === "mssql") {
+            conditions["timestamp"] = new MssqlParameter_1.MssqlParameter(migration.timestamp, this.connection.driver.normalizeType({
+                type: this.connection.driver.mappedDataTypes
+                    .migrationTimestamp,
+            }));
+            conditions["name"] = new MssqlParameter_1.MssqlParameter(migration.name, this.connection.driver.normalizeType({
+                type: this.connection.driver.mappedDataTypes.migrationName,
+            }));
+        }
+        else {
+            conditions["timestamp"] = migration.timestamp;
+            conditions["name"] = migration.name;
+        }
+        if (this.connection.driver.options.type === "mongodb") {
+            const mongoRunner = queryRunner;
+            await mongoRunner.databaseConnection
+                .db(this.connection.driver.database)
+                .collection(this.migrationsTableName)
+                .deleteOne(conditions);
+        }
+        else {
+            const qb = queryRunner.manager.createQueryBuilder();
+            await qb
+                .delete()
+                .from(this.migrationsTable)
+                .where(`${qb.escape("timestamp")} = :timestamp`)
+                .andWhere(`${qb.escape("name")} = :name`)
+                .setParameters(conditions)
+                .execute();
+        }
+    }
+    async withQueryRunner(callback) {
+        const queryRunner = this.queryRunner || this.connection.createQueryRunner();
+        try {
+            return await callback(queryRunner);
+        }
+        finally {
+            if (!this.queryRunner) {
+                await queryRunner.release();
+            }
+        }
+    }
+}
+exports.MigrationExecutor = MigrationExecutor;
+
+//# sourceMappingURL=MigrationExecutor.js.map

package/.output/server/node_modules/typeorm/naming-strategy/DefaultNamingStrategy.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultNamingStrategy = void 0;
+const RandomGenerator_1 = require("../util/RandomGenerator");
+const StringUtils_1 = require("../util/StringUtils");
+/**
+ * Naming strategy that is used by default.
+ */
+class DefaultNamingStrategy {
+    constructor() {
+        this.nestedSetColumnNames = { left: "nsleft", right: "nsright" };
+        this.materializedPathColumnName = "mpath";
+    }
+    getTableName(tableOrName) {
+        if (typeof tableOrName !== "string") {
+            tableOrName = tableOrName.name;
+        }
+        return tableOrName.split(".").pop();
+    }
+    /**
+     * Normalizes table name.
+     *
+     * @param targetName Name of the target entity that can be used to generate a table name.
+     * @param userSpecifiedName For example if user specified a table name in a decorator, e.g. @Entity("name")
+     */
+    tableName(targetName, userSpecifiedName) {
+        return userSpecifiedName ? userSpecifiedName : (0, StringUtils_1.snakeCase)(targetName);
+    }
+    /**
+     * Creates a table name for a junction table of a closure table.
+     *
+     * @param originalClosureTableName Name of the closure table which owns this junction table.
+     */
+    closureJunctionTableName(originalClosureTableName) {
+        return originalClosureTableName + "_closure";
+    }
+    columnName(propertyName, customName, embeddedPrefixes) {
+        const name = customName || propertyName;
+        if (embeddedPrefixes.length)
+            return (0, StringUtils_1.camelCase)(embeddedPrefixes.join("_")) + (0, StringUtils_1.titleCase)(name);
+        return name;
+    }
+    relationName(propertyName) {
+        return propertyName;
+    }
+    primaryKeyName(tableOrName, columnNames) {
+        // sort incoming column names to avoid issue when ["id", "name"] and ["name", "id"] arrays
+        const clonedColumnNames = [...columnNames];
+        clonedColumnNames.sort();
+        const tableName = this.getTableName(tableOrName);
+        const replacedTableName = tableName.replace(".", "_");
+        const key = `${replacedTableName}_${clonedColumnNames.join("_")}`;
+        return "PK_" + RandomGenerator_1.RandomGenerator.sha1(key).substr(0, 27);
+    }
+    uniqueConstraintName(tableOrName, columnNames) {
+        // sort incoming column names to avoid issue when ["id", "name"] and ["name", "id"] arrays
+        const clonedColumnNames = [...columnNames];
+        clonedColumnNames.sort();
+        const tableName = this.getTableName(tableOrName);
+        const replacedTableName = tableName.replace(".", "_");
+        const key = `${replacedTableName}_${clonedColumnNames.join("_")}`;
+        return "UQ_" + RandomGenerator_1.RandomGenerator.sha1(key).substr(0, 27);
+    }
+    relationConstraintName(tableOrName, columnNames, where) {
+        // sort incoming column names to avoid issue when ["id", "name"] and ["name", "id"] arrays
+        const clonedColumnNames = [...columnNames];
+        clonedColumnNames.sort();
+        const tableName = this.getTableName(tableOrName);
+        const replacedTableName = tableName.replace(".", "_");
+        let key = `${replacedTableName}_${clonedColumnNames.join("_")}`;
+        if (where)
+            key += `_${where}`;
+        return "REL_" + RandomGenerator_1.RandomGenerator.sha1(key).substr(0, 26);
+    }
+    defaultConstraintName(tableOrName, columnName) {
+        const tableName = this.getTableName(tableOrName);
+        const replacedTableName = tableName.replace(".", "_");
+        const key = `${replacedTableName}_${columnName}`;
+        return "DF_" + RandomGenerator_1.RandomGenerator.sha1(key).substr(0, 27);
+    }
+    foreignKeyName(tableOrName, columnNames, _referencedTablePath, _referencedColumnNames) {
+        // sort incoming column names to avoid issue when ["id", "name"] and ["name", "id"] arrays
+        const clonedColumnNames = [...columnNames];
+        clonedColumnNames.sort();
+        const tableName = this.getTableName(tableOrName);
+        const replacedTableName = tableName.replace(".", "_");
+        const key = `${replacedTableName}_${clonedColumnNames.join("_")}`;
+        return "FK_" + RandomGenerator_1.RandomGenerator.sha1(key).substr(0, 27);
+    }
+    indexName(tableOrName, columnNames, where) {
+        // sort incoming column names to avoid issue when ["id", "name"] and ["name", "id"] arrays
+        const clonedColumnNames = [...columnNames];
+        clonedColumnNames.sort();
+        const tableName = this.getTableName(tableOrName);
+        const replacedTableName = tableName.replace(".", "_");
+        let key = `${replacedTableName}_${clonedColumnNames.join("_")}`;
+        if (where)
+            key += `_${where}`;
+        return "IDX_" + RandomGenerator_1.RandomGenerator.sha1(key).substr(0, 26);
+    }
+    checkConstraintName(tableOrName, expression, isEnum) {
+        const tableName = this.getTableName(tableOrName);
+        const replacedTableName = tableName.replace(".", "_");
+        const key = `${replacedTableName}_${expression}`;
+        const name = "CHK_" + RandomGenerator_1.RandomGenerator.sha1(key).substr(0, 26);
+        return isEnum ? `${name}_ENUM` : name;
+    }
+    exclusionConstraintName(tableOrName, expression) {
+        const tableName = this.getTableName(tableOrName);
+        const replacedTableName = tableName.replace(".", "_");
+        const key = `${replacedTableName}_${expression}`;
+        return "XCL_" + RandomGenerator_1.RandomGenerator.sha1(key).substr(0, 26);
+    }
+    joinColumnName(relationName, referencedColumnName) {
+        return (0, StringUtils_1.camelCase)(relationName + "_" + referencedColumnName);
+    }
+    joinTableName(firstTableName, secondTableName, firstPropertyName, secondPropertyName) {
+        return (0, StringUtils_1.snakeCase)(firstTableName +
+            "_" +
+            firstPropertyName.replace(/\./gi, "_") +
+            "_" +
+            secondTableName);
+    }
+    joinTableColumnDuplicationPrefix(columnName, index) {
+        return columnName + "_" + index;
+    }
+    joinTableColumnName(tableName, propertyName, columnName) {
+        return (0, StringUtils_1.camelCase)(tableName + "_" + (columnName ? columnName : propertyName));
+    }
+    joinTableInverseColumnName(tableName, propertyName, columnName) {
+        return this.joinTableColumnName(tableName, propertyName, columnName);
+    }
+    /**
+     * Adds globally set prefix to the table name.
+     * This method is executed no matter if prefix was set or not.
+     * Table name is either user's given table name, either name generated from entity target.
+     * Note that table name comes here already normalized by #tableName method.
+     */
+    prefixTableName(prefix, tableName) {
+        return prefix + tableName;
+    }
+}
+exports.DefaultNamingStrategy = DefaultNamingStrategy;
+
+//# sourceMappingURL=DefaultNamingStrategy.js.map