TypeORM CamelCase Naming Strategy

typeorm-camelcase-naming-strategy.ts

import {DefaultNamingStrategy, Table, VersionColumn, CreateDateColumn, UpdateDateColumn} from 'typeorm';
import {camelCase} from 'typeorm/util/StringUtils';

export class NamingStrategy extends DefaultNamingStrategy {
    name: string;

    columnName(propertyName: string, customName: string | undefined, embeddedPrefixes: string[]): string {
        let name = [customName || propertyName];
        if (embeddedPrefixes.length > 0) {
            name = embeddedPrefixes.concat(name);
        }
        return camelCase(name.join('_'), false);
    }

    eagerJoinRelationAlias(alias: string, propertyPath: string): string {
        return alias + '__' + propertyPath.replace('.', '_');
    }

    exclusionConstraintName(tableOrName: Table | string, expression: string): string {
        return `EXCLUDE_${this.nameOfTable(tableOrName)}`;
    }

    foreignKeyName(tableOrName: Table | string, columnNames: string[]): string {
        return this.genericRule('FOREIGN', tableOrName, columnNames);
    }

    indexName(tableOrName: Table | string, columnNames: string[], where?: string): string {
        return this.genericRule('INDEX', tableOrName, columnNames);
    }

    joinColumnName(relationName: string, referencedColumnName: string): string {
        return camelCase(`${relationName}_${referencedColumnName}`, false);
    }

    // joinTableColumnName(tableName: string, propertyName: string, columnName?: string): string {
    //     return columnName || ;
    // }
    //
    // joinTableInverseColumnName(tableName: string, propertyName: string, columnName?: string): string {
    //     return "";
    // }

    joinTableName(firstTableName: string, secondTableName: string, firstPropertyName: string, secondPropertyName: string): string {
        return camelCase(`${firstTableName}_${firstPropertyName}_${secondTableName}_${secondTableName}`, true);
    }

    primaryKeyName(tableOrName: Table | string, columnNames: string[]): string {
        return this.genericRule('PRIMARY', tableOrName, columnNames);
    }

    relationConstraintName(tableOrName: Table | string, columnNames: string[], where?: string): string {
        return this.genericRule('CONSTRAINT', tableOrName, columnNames);
    }

    tableName(targetName: string, userSpecifiedName?: string): string {
        return userSpecifiedName || targetName;
    }

    uniqueConstraintName(tableOrName: Table | string, columnNames: string[]): string {
        return this.genericRule('UNIQUE', tableOrName, columnNames);
    }

    nameOfTable(tableOrName: Table | string) {
        return tableOrName instanceof Table ? tableOrName.name : tableOrName;
    }

    genericRule(prefix: string, tableOrName: Table | string, columnNames: string[]) {
        return `${prefix}_${this.nameOfTable(tableOrName)}_${columnNames.join('_')}`;
    }
}