better-typeorm-naming-strategies/dist/better-naming.strategy.js

Better naming strategies for typeorm

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BetterNamingStrategy = void 0;
const typeorm_1 = require("typeorm");
const StringUtils_1 = require("typeorm/util/StringUtils");
class BetterNamingStrategy extends typeorm_1.DefaultNamingStrategy {
    constructor(options = {}) {
        var _a, _b;
        super();
        this.snakeCase = (_a = options.snakeCase) !== null && _a !== void 0 ? _a : true;
        this.betterConstraintAndIndexNames =
            (_b = options.betterConstraintAndIndexNames) !== null && _b !== void 0 ? _b : true;
    }
    tableName(className, customName) {
        if (this.snakeCase) {
            return customName ? customName : (0, StringUtils_1.snakeCase)(className);
        }
        return super.tableName(className, customName);
    }
    columnName(propertyName, customName, embeddedPrefixes) {
        if (this.snakeCase) {
            const prefixes = embeddedPrefixes.map((p) => (0, StringUtils_1.snakeCase)(p)).join('_');
            const columnName = customName ? customName : (0, StringUtils_1.snakeCase)(propertyName);
            if (prefixes) {
                return `${prefixes}_${columnName}`;
            }
            else {
                return columnName;
            }
        }
        return super.columnName(propertyName, customName, embeddedPrefixes);
    }
    relationName(propertyName) {
        if (this.snakeCase) {
            return (0, StringUtils_1.snakeCase)(propertyName);
        }
        return super.relationName(propertyName);
    }
    primaryKeyName(tableOrName, columnNames) {
        if (this.betterConstraintAndIndexNames) {
            const table = typeof tableOrName === 'string' ? tableOrName : tableOrName.name;
            const columns = columnNames
                .map((c) => this.columnName(c, '', []))
                .join('_');
            return `PK_${table}_${columns}`;
        }
        return super.primaryKeyName(tableOrName, columnNames);
    }
    uniqueConstraintName(tableOrName, columnNames) {
        if (this.betterConstraintAndIndexNames) {
            const table = typeof tableOrName === 'string' ? tableOrName : tableOrName.name;
            const columns = columnNames
                .map((c) => this.columnName(c, '', []))
                .join('_');
            return `UQ_${table}_${columns}`;
        }
        return super.uniqueConstraintName(tableOrName, columnNames);
    }
    indexName(tableOrName, columnNames, where) {
        if (this.betterConstraintAndIndexNames) {
            const table = typeof tableOrName === 'string' ? tableOrName : tableOrName.name;
            const columns = columnNames
                .map((c) => this.columnName(c, '', []))
                .join('_');
            const base = `IDX_${table}_${columns}`;
            return where ? `${base}_${where}` : base;
        }
        return super.indexName(tableOrName, columnNames, where);
    }
    foreignKeyName(tableOrName, columnNames, referencedTablePath, referencedColumnNames) {
        if (this.betterConstraintAndIndexNames) {
            const table = typeof tableOrName === 'string' ? tableOrName : tableOrName.name;
            const columns = columnNames
                .map((c) => this.columnName(c, '', []))
                .join('_');
            return `FK_${table}_${columns}`;
        }
        return super.foreignKeyName(tableOrName, columnNames, referencedTablePath, referencedColumnNames);
    }
    joinColumnName(relationName, referencedColumnName) {
        if (this.snakeCase) {
            return (0, StringUtils_1.snakeCase)(`${relationName}_${referencedColumnName}`);
        }
        return super.joinColumnName(relationName, referencedColumnName);
    }
    joinTableName(firstTableName, secondTableName, firstPropertyName, secondPropertyName) {
        if (this.snakeCase) {
            return (0, StringUtils_1.snakeCase)(`${firstTableName}_${firstPropertyName.replace(/\./g, '_')}_${secondTableName}`);
        }
        return super.joinTableName(firstTableName, secondTableName, firstPropertyName, secondPropertyName);
    }
    joinTableColumnName(tableName, propertyName, columnName) {
        if (this.snakeCase) {
            return (0, StringUtils_1.snakeCase)(`${tableName}_${columnName !== null && columnName !== void 0 ? columnName : propertyName}`);
        }
        return super.joinTableColumnName(tableName, propertyName, columnName);
    }
}
exports.BetterNamingStrategy = BetterNamingStrategy;