dbgate-tools/lib/nameTools.js

Auxiliary tools for other DbGate packages.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.DATA_FOLDER_NAMES = exports.fillConstraintNames = exports.makeUniqueColumnNames = exports.getConflictingColumnNames = exports.findForeignKeyForColumn = exports.findObjectLike = exports.equalFullName = exports.equalStringLike = exports.quoteFullName = exports.fullNameToLabel = exports.fullNameToString = exports.fullNameFromString = void 0;
const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
const uniq_1 = __importDefault(require("lodash/uniq"));
const isString_1 = __importDefault(require("lodash/isString"));
function fullNameFromString(name) {
    const m = name.match(/\[([^\]]+)\]\.\[([^\]]+)\]/);
    if (m) {
        return {
            schemaName: m[1],
            pureName: m[2],
        };
    }
    return {
        schemaName: null,
        pureName: name,
    };
}
exports.fullNameFromString = fullNameFromString;
function fullNameToString({ schemaName, pureName }) {
    if (schemaName) {
        return `[${schemaName}].[${pureName}]`;
    }
    return pureName;
}
exports.fullNameToString = fullNameToString;
function fullNameToLabel({ schemaName, pureName }) {
    if (schemaName) {
        return `${schemaName}.${pureName}`;
    }
    return pureName;
}
exports.fullNameToLabel = fullNameToLabel;
function quoteFullName(dialect, { schemaName, pureName }) {
    if (schemaName)
        return `${dialect.quoteIdentifier(schemaName)}.${dialect.quoteIdentifier(pureName)}`;
    return `${dialect.quoteIdentifier(pureName)}`;
}
exports.quoteFullName = quoteFullName;
function equalStringLike(s1, s2) {
    return (s1 || '').toLowerCase().trim() == (s2 || '').toLowerCase().trim();
}
exports.equalStringLike = equalStringLike;
function equalFullName(name1, name2) {
    if (!name1 || !name2)
        return name1 == name2;
    return name1.pureName == name2.pureName && name1.schemaName == name2.schemaName;
}
exports.equalFullName = equalFullName;
function findObjectLike({ pureName, schemaName }, dbinfo, objectTypeField) {
    var _a, _b;
    if (!dbinfo)
        return null;
    if (schemaName) {
        // @ts-ignore
        return (_a = dbinfo[objectTypeField]) === null || _a === void 0 ? void 0 : _a.find(x => equalStringLike(x.pureName, pureName) && equalStringLike(x.schemaName, schemaName));
    }
    // @ts-ignore
    return (_b = dbinfo[objectTypeField]) === null || _b === void 0 ? void 0 : _b.find(x => equalStringLike(x.pureName, pureName));
}
exports.findObjectLike = findObjectLike;
function findForeignKeyForColumn(table, column) {
    if ((0, isString_1.default)(column)) {
        return (table.foreignKeys || []).find(fk => fk.columns.find(col => col.columnName == column));
    }
    return (table.foreignKeys || []).find(fk => fk.columns.find(col => col.columnName == column.columnName));
}
exports.findForeignKeyForColumn = findForeignKeyForColumn;
function getConflictingColumnNames(columns) {
    const conflictingNames = new Set((0, uniq_1.default)(columns.map(x => x.columnName).filter((item, index, arr) => arr.indexOf(item) !== index)));
    return conflictingNames;
}
exports.getConflictingColumnNames = getConflictingColumnNames;
function makeUniqueColumnNames(res) {
    const usedNames = new Set();
    const conflictingNames = getConflictingColumnNames(res);
    for (let i = 0; i < res.length; i++) {
        if (conflictingNames.has(res[i].columnName) &&
            res[i].pureName &&
            !usedNames.has(`${res[i].pureName}_${res[i].columnName}`)) {
            res[i].columnName = `${res[i].pureName}_${res[i].columnName}`;
            usedNames.add(res[i].columnName);
            continue;
        }
        if (usedNames.has(res[i].columnName)) {
            let suffix = 2;
            while (usedNames.has(`${res[i].columnName}${suffix}`))
                suffix++;
            res[i].columnName = `${res[i].columnName}${suffix}`;
        }
        usedNames.add(res[i].columnName);
    }
}
exports.makeUniqueColumnNames = makeUniqueColumnNames;
function columnsConstraintName(prefix, table, columns) {
    return `${prefix}_${table.pureName}_${columns.map(x => x.columnName.replace(' ', '_')).join('_')}`;
}
function fillConstraintNames(table, dialect) {
    if (!table)
        return table;
    const res = (0, cloneDeep_1.default)(table);
    if (res.primaryKey && !res.primaryKey.constraintName && !dialect.anonymousPrimaryKey) {
        res.primaryKey.constraintName = `PK_${res.pureName}`;
    }
    for (const fk of res.foreignKeys || []) {
        if (fk.constraintName)
            continue;
        fk.constraintName = columnsConstraintName('FK', res, fk.columns);
    }
    for (const ix of res.indexes || []) {
        if (ix.constraintName)
            continue;
        ix.constraintName = columnsConstraintName('IX', res, ix.columns);
    }
    for (const uq of res.uniques || []) {
        if (uq.constraintName)
            continue;
        uq.constraintName = columnsConstraintName('UQ', res, uq.columns);
    }
    return res;
}
exports.fillConstraintNames = fillConstraintNames;
exports.DATA_FOLDER_NAMES = [
    { name: 'sql', label: 'SQL scripts' },
    { name: 'shell', label: 'Shell scripts' },
    { name: 'markdown', label: 'Markdown files' },
    { name: 'charts', label: 'Charts' },
    { name: 'query', label: 'Query designs' },
    { name: 'sqlite', label: 'SQLite files' },
    { name: 'duckdb', label: 'DuckDB files' },
    { name: 'diagrams', label: 'Diagrams' },
    { name: 'perspectives', label: 'Perspectives' },
    { name: 'impexp', label: 'Import/Export jobs' },
    { name: 'modtrans', label: 'Model transforms' },
    { name: 'datadeploy', label: 'Data deploy jobs' },
    { name: 'dbcompare', label: 'Database compare jobs' },
    { name: 'apps', label: 'Applications' },
    { name: 'themes', label: 'Themes' },
];