database-builder
Version:
Library to assist in creating and maintaining SQL commands.
239 lines (238 loc) • 14.6 kB
JavaScript
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.MetadataTable = void 0;
var lambda_expression_1 = require("lambda-expression");
var utils_1 = require("./core/utils");
var mapper_table_1 = require("./mapper-table");
var mapper_column_1 = require("./mapper-column");
var field_type_1 = require("./core/enums/field-type");
var primary_key_type_1 = require("./core/enums/primary-key-type");
var errors_1 = require("./core/errors");
var dependency_definition_1 = require("./definitions/dependency-definition");
var metadata_table_base_1 = require("./metadata-table-base");
var where_builder_1 = require("./crud/where-builder");
var mapper_utils_1 = require("./mapper/mapper-utils");
var MetadataTable = /** @class */ (function (_super) {
__extends(MetadataTable, _super);
function MetadataTable(_newable, _databaseHelper, _getMapper, readOnly, tableName) {
if (readOnly === void 0) { readOnly = false; }
if (tableName === void 0) { tableName = _newable.name; }
var _this = _super.call(this, _newable) || this;
_this._databaseHelper = _databaseHelper;
_this._getMapper = _getMapper;
_this.readOnly = readOnly;
_this.tableName = tableName;
_this._autoMapperCalled = false;
_this._expressionUtils = new lambda_expression_1.ExpressionUtils();
mapper_utils_1.MapperUtils.setIdentifier(_newable, tableName);
_this.instance = new _newable();
_this.mapperTable = new mapper_table_1.MapperTable(tableName);
return _this;
}
MetadataTable.prototype.column = function (expression, type, primaryKeyType) {
var column = this.columnName(expression);
this.mapperTable.addColumn(column, type
? this._databaseHelper.getFieldType(type)
: this.getTypeByExpression(this.instance, this.validExpressionMapper(this.instance, expression)), primaryKeyType);
return this;
};
MetadataTable.prototype.hasQueryFilter = function (whereCallback) {
var instanceWhere = new where_builder_1.WhereBuilder(this.newable, utils_1.Utils.REPLACEABLE_ALIAS);
instanceWhere.scope(function (scope) {
whereCallback(scope);
});
this.mapperTable.queryFilter = instanceWhere.compile();
return this;
};
MetadataTable.prototype.hasMany = function (expression, type, tableName) {
var mapperColumn = {
column: this.columnName(expression),
fieldType: this._databaseHelper.getFieldType(type)
};
var instanceMapper = this.validInstanceMapper(type ? new type() : expression(this.instance), mapperColumn.column);
if (!this._databaseHelper.isTypeSimpleByType(mapperColumn.fieldType)) {
mapperColumn = this.getMapperColumnReference(instanceMapper, "".concat(mapperColumn.column, "[?]"));
}
this.addDependencyArray(mapperColumn.column, field_type_1.FieldType.ARRAY | mapperColumn.fieldType, tableName);
return this;
};
MetadataTable.prototype.referenceKey = function (expression, expressionKey, type) {
var columnReference = this.columnName(expression);
var columnKey = this.columnName(expressionKey);
var column = "".concat(columnReference, "_").concat(columnKey);
var instance = this.validInstanceMapper(this.instance, column);
var fieldType;
if (type) {
fieldType = this._databaseHelper.getFieldType(type);
}
else {
var referenceInstance = this.validExpressionMapper(instance, expression)(instance);
var mapperReference = this.getMapper(referenceInstance);
var mapperColumnReference = mapperReference.mapperTable.getColumnByField(expressionKey);
fieldType = mapperColumnReference
? mapperColumnReference.fieldType
: this.getTypeByExpression(referenceInstance, this.validExpressionMapper(referenceInstance, expressionKey));
}
this.addReference(column, fieldType);
return this;
};
MetadataTable.prototype.reference = function (expression, type) {
var column = this.columnName(expression);
this.mapperReference(this.validInstanceMapper(type ? new type() : expression(this.instance), column), column);
return this;
};
MetadataTable.prototype.key = function (expression, primaryKeyType, type) {
if (primaryKeyType === void 0) { primaryKeyType = primary_key_type_1.PrimaryKeyType.AutoIncrement; }
if (this._autoMapperCalled) {
throw new errors_1.DatabaseBuilderError("Mapper '".concat(this.tableName, "', column key must be informed before the call to 'autoMapper()'"));
}
return this.column(expression, type, primaryKeyType);
};
MetadataTable.prototype.ignore = function (expression) {
var instanceExpression = this.validExpressionMapper(this.instance, expression)(this.instance);
var mapperColumn = instanceExpression && (!this._databaseHelper.isTypeSimple(instanceExpression))
? this.getMapperColumnReference(instanceExpression, this.columnName(expression))
: new mapper_column_1.MapperColumn(this.columnName(expression));
if (mapperColumn) {
this.mapperTable.removeColumn(mapperColumn.column);
}
return this;
};
MetadataTable.prototype.autoMapper = function (references, referencesId, referencesIdRecursive) {
if (references === void 0) { references = true; }
if (referencesId === void 0) { referencesId = true; }
if (referencesIdRecursive === void 0) { referencesIdRecursive = true; }
if (this.mapperTable.keyColumns().length === 0) {
throw new errors_1.DatabaseBuilderError("Mapper '".concat(this.tableName, "', no column as key was informed to the Mapper"));
}
this.autoMapperColumns(references, referencesId, referencesIdRecursive);
this._autoMapperCalled = true;
return this;
};
MetadataTable.prototype.getTypeByValue = function (value) {
return this._databaseHelper.getType(value);
};
MetadataTable.prototype.validInstanceMapper = function (instance, propertyMapperForMessage) {
if (utils_1.Utils.isNull(instance)) {
throw new errors_1.DatabaseBuilderError("Mapper: ".concat(this.tableName, ", can not get instance of mapped property ('").concat(propertyMapperForMessage, "')"));
}
return instance;
};
MetadataTable.prototype.validExpressionMapper = function (instance, expression) {
var expressionByInstance = expression(instance);
if (utils_1.Utils.isNull(expression) || utils_1.Utils.isNull(expressionByInstance)) {
throw new errors_1.DatabaseBuilderError("Mapper: ".concat(this.tableName, ", can not get instance of mapped property ('").concat(this.columnName(expression), "')"));
}
return expression;
};
MetadataTable.prototype.columnName = function (expression) {
return this._expressionUtils.getColumnByExpression(expression, "_");
};
MetadataTable.prototype.getTypeByExpression = function (instance, expression) {
return this._databaseHelper.getType(this._databaseHelper.getValue(instance, this._expressionUtils.getColumnByExpression(expression, ".")));
};
MetadataTable.prototype.getMapper = function (mapper) {
return this._getMapper.get(mapper_utils_1.MapperUtils.resolveKey(mapper));
};
MetadataTable.prototype.isKeyColumn = function (key) {
return (this.mapperTable.keyColumns().filter(function (x) { return x.column === key; }).length > 0);
};
MetadataTable.prototype.autoMapperColumns = function (references, referencesId, referencesIdRecursive) {
if (references === void 0) { references = true; }
if (referencesId === void 0) { referencesId = true; }
if (referencesIdRecursive === void 0) { referencesIdRecursive = true; }
for (var key in this.instance) {
if (key !== "constructor" && typeof this.instance[key] !== "function" && !key.startsWith('__')) {
if (this._databaseHelper.isTypeSimple(this.instance[key])
|| references) {
if (!this.isKeyColumn(key)) {
this.mapperTable.addColumn(key, this.getTypeByValue(this.instance[key]));
}
}
}
}
if (referencesId) {
this.autoColumnsModelReferencesRecursive(this.instance, "", referencesIdRecursive);
}
};
MetadataTable.prototype.addReference = function (name, fieldType) {
this.mapperTable.addColumn(name, fieldType);
};
MetadataTable.prototype.mapperReference = function (instanceMapper, propertyName, ascendingRefName) {
if (ascendingRefName === void 0) { ascendingRefName = ""; }
var mapperColumn = this.getMapperColumnReference(instanceMapper, propertyName);
if (mapperColumn) {
this.addReference("".concat(ascendingRefName).concat(mapperColumn.column), mapperColumn.fieldType);
}
};
MetadataTable.prototype.getMapperColumnReference = function (instanceMapper, propertyName) {
if (this._databaseHelper.isTypeSimple(instanceMapper)) {
throw new errors_1.DatabaseBuilderError("Mapper '".concat(this.tableName, "', it is not allowed to map property '").concat(propertyName, "' of type '").concat(mapper_utils_1.MapperUtils.resolveKey(instanceMapper), "' as a reference. For it is not of a composite type (Ex: object)"));
}
var mapperKey = this.getMapper(instanceMapper);
if (!utils_1.Utils.isNull(mapperKey)) {
if (utils_1.Utils.isNull(mapperKey.mapperTable.keyColumns()) || mapperKey.mapperTable.keyColumns().length < 1) {
throw new errors_1.DatabaseBuilderError("Mapper '".concat(this.tableName, "', not key column for property '").concat(propertyName, "' of type '").concat(mapper_utils_1.MapperUtils.resolveKey(instanceMapper), "'"));
}
if (mapperKey.mapperTable.keyColumns().length > 1) {
throw new errors_1.DatabaseBuilderError("Mapper '".concat(this.tableName, "', composite Id not supported (property '").concat(propertyName, "' of type '").concat(mapper_utils_1.MapperUtils.resolveKey(instanceMapper), "')"));
}
var keyMapped = mapperKey.mapperTable.keyColumns()[0];
return new mapper_column_1.MapperColumn("".concat(propertyName, "_").concat(keyMapped.column), keyMapped.fieldType);
}
else {
if (!this._databaseHelper.isTypeIgnoredInMapper(instanceMapper)) {
throw new errors_1.DatabaseBuilderError("Mapper '".concat(this.tableName, "', key '").concat(propertyName, "' of type '").concat(mapper_utils_1.MapperUtils.resolveKey(instanceMapper), "' not before mapped"));
}
}
return void 0;
};
MetadataTable.prototype.autoColumnsModelReferencesRecursive = function (instanceMapper, ascendingRefName, recursive) {
for (var key in instanceMapper) {
if (instanceMapper.hasOwnProperty(key)) {
var keyInstanceMapper = instanceMapper[key];
if (key !== "constructor" && typeof keyInstanceMapper !== "function") {
if (!this._databaseHelper.isTypeSimple(keyInstanceMapper)) {
this.mapperReference(keyInstanceMapper, key, ascendingRefName);
}
if (recursive && !this._databaseHelper.isTypeSimple(keyInstanceMapper)) {
this.autoColumnsModelReferencesRecursive(keyInstanceMapper, "".concat(ascendingRefName).concat(key, "_"), recursive);
}
}
}
}
};
MetadataTable.prototype.addDependencyArray = function (name, fieldType, tablename) {
this.mapperTable.addColumn(name, fieldType, void 0, void 0, tablename);
var dependency = new mapper_table_1.MapperTable(tablename);
fieldType &= ~field_type_1.FieldType.ARRAY;
dependency.addColumn(dependency_definition_1.DEPENDENCY_LIST_SIMPLE_COLUMNS.INDEX, field_type_1.FieldType.NUMBER, primary_key_type_1.PrimaryKeyType.Assigned, utils_1.Utils.getFieldExpression(function (x) { return x.index; }));
dependency.addColumn(dependency_definition_1.DEPENDENCY_LIST_SIMPLE_COLUMNS.VALUE, fieldType, void 0, utils_1.Utils.getFieldExpression(function (x) { return x.value; }));
var keyColumns = this.mapperTable.keyColumns();
if (keyColumns.length < 1) {
throw new errors_1.DatabaseBuilderError("It is not possible to create a dependency mapper (\"".concat(name, "\") if the primary key of the parent entity (\"").concat(this.mapperTable.tableName, "\") is not yet mapped."));
}
if (keyColumns.length > 1) {
throw new errors_1.DatabaseBuilderError("Dependency mapper (\"".concat(name, "\") not support relation with entity (\"").concat(this.mapperTable.tableName, "\") with composite key [").concat(keyColumns.join(", "), "]!"));
}
dependency.addColumn(dependency_definition_1.DEPENDENCY_LIST_SIMPLE_COLUMNS.REFERENCE(this.mapperTable.tableName, keyColumns[0].column), keyColumns[0].fieldType, primary_key_type_1.PrimaryKeyType.Assigned, utils_1.Utils.getFieldExpression(function (x) { return x.reference; }));
this.mapperTable.dependencies.push(dependency);
};
return MetadataTable;
}(metadata_table_base_1.MetadataTableBase));
exports.MetadataTable = MetadataTable;