database-builder/src/core/columns-base-builder.js

Library to assist in creating and maintaining SQL commands.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ColumnsBaseBuilder = void 0;
var utils_1 = require("./utils");
var database_helper_1 = require("../database-helper");
var ColumnsBaseBuilder = /** @class */ (function () {
    function ColumnsBaseBuilder(mapperTable, toSave) {
        this.mapperTable = mapperTable;
        this.toSave = toSave;
        this._columns = [];
        this._databaseHelper = new database_helper_1.DatabaseHelper();
    }
    Object.defineProperty(ColumnsBaseBuilder.prototype, "columns", {
        get: function () { return this._columns; },
        enumerable: false,
        configurable: true
    });
    ;
    ColumnsBaseBuilder.prototype.allColumns = function () {
        // clear columns
        this._columns = [];
        this.setAllColumns(this.mapperTable, this.toSave);
    };
    ColumnsBaseBuilder.prototype.setColumn = function (column, type, primaryKeyType) {
        this._columns.push({
            name: column,
            type: type,
            primaryKeyType: primaryKeyType
        });
        return this.getInstance();
    };
    ColumnsBaseBuilder.prototype.set = function (columnExpression, primaryKeyType, type) {
        return this.setColumn(utils_1.Utils.getColumn(columnExpression), this.getFieldType(columnExpression, type), primaryKeyType);
    };
    ColumnsBaseBuilder.prototype.compile = function () {
        var result = {
            columns: [],
            keyColumns: [],
            params: [],
        };
        for (var key in this._columns) {
            if (this._columns.hasOwnProperty(key)) {
                var column = this._columns[key];
                if (column.primaryKeyType) {
                    result.keyColumns.push(column.name);
                }
                var columnFormat = this.columnFormat(column);
                if (columnFormat) {
                    result.columns.push(columnFormat);
                }
            }
        }
        return result;
    };
    ColumnsBaseBuilder.prototype.isCompositeKey = function () {
        return this.mapperTable && this.mapperTable.columns.filter(function (x) { return !!x.primaryKeyType; }).length > 1;
    };
    ColumnsBaseBuilder.prototype.setAllColumns = function (mapper, modelWithValue) {
        for (var key in mapper.columns) {
            if (mapper.columns.hasOwnProperty(key)) {
                var column = mapper.columns[key];
                this.setColumnValue(column.column, utils_1.Utils.getValue(modelWithValue, column.fieldReference), column.fieldType, column.primaryKeyType);
            }
        }
    };
    ColumnsBaseBuilder.prototype.getFieldType = function (columnExpression, type) {
        if (type) {
            return this._databaseHelper.getFieldType(type);
        }
        var fieldTypeByMapper = this.mapperTable
            ? this.mapperTable.getColumnByField(columnExpression)
            : void 0;
        return fieldTypeByMapper
            ? fieldTypeByMapper.fieldType
            : utils_1.Utils.getType(this.toSave, columnExpression);
    };
    return ColumnsBaseBuilder;
}());
exports.ColumnsBaseBuilder = ColumnsBaseBuilder;