database-builder
Version:
Library to assist in creating and maintaining SQL commands.
403 lines (402 loc) • 17.1 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.Utils = void 0;
var expression_or_value_enum_1 = require("./enums/expression-or-value-enum");
var moment = require("moment");
var where_builder_1 = require("../crud/where-builder");
var database_helper_1 = require("../database-helper");
var projection_builder_1 = require("../crud/projection-builder");
var lambda_expression_1 = require("lambda-expression");
var expression_or_column_enum_1 = require("./enums/expression-or-column-enum");
var field_type_1 = require("./enums/field-type");
var projection_compiled_1 = require("../crud/projection-compiled");
var condition_1 = require("../crud/enums/condition");
var errors_1 = require("./errors");
var projections_helper_1 = require("./projections-helper");
var column_ref_1 = require("./column-ref");
var plan_ref_1 = require("./plan-ref");
var uuid = require("uuid");
var crud_1 = require("../crud");
var metadata_table_base_1 = require("../metadata-table-base");
var projection_compile_1 = require("../crud/projection-compile");
var lodash = require("lodash");
var Utils = /** @class */ (function () {
function Utils() {
}
// Fonte: https://www.npmjs.com/package/uuid
Utils.GUID = function () {
return uuid.v4();
};
Utils.isFlag = function (value, flag) {
return this.getDatabaseHelper().isFlag(value, flag);
};
Utils.is = function (value, type) {
return typeof value === type;
};
Utils.isArray = function (value) {
return Array.isArray(value);
};
Utils.isString = function (value) {
return this.is(value, "string");
};
Utils.isObject = function (value) {
return this.is(value, "object");
};
Utils.isNumber = function (value) {
return this.is(value, "number");
};
Utils.isBoolean = function (value) {
return this.is(value, "boolean");
};
Utils.isOnlyNumber = function (value) {
return !this.isNull(value) && value.length > 0 && /^(?:-?\d+)?$/.test(value);
// return !this.isNull(value) && value.length > 0 && /^[0-9]*$/.test(value);
};
Utils.isNull = function (value) {
return value === void 0 || value === null || (this.isNumber(value) && isNaN(value));
};
Utils.isStartWithNumber = function (value) {
return /^[0-9]/.test(value);
};
Utils.isValueNumber = function (value) {
return this.isNumber(value) || this.isOnlyNumber(value);
};
Utils.isValueBoolean = function (value) {
return this.isBoolean(value) || this.isReservedBoolean(value);
};
Utils.isReservedBoolean = function (value) {
return value === "true" || value === "false" || value === 0 || value === 1;
};
Utils.isFunction = function (value) {
return this.is(value, "function");
};
Utils.isDate = function (value) {
return value instanceof Date;
};
Utils.isMoment = function (value) {
return moment.isMoment(value);
};
Utils.isQuery = function (instance) {
return instance instanceof crud_1.Query;
};
Utils.isQueryBuilder = function (instance) {
return instance instanceof crud_1.QueryBuilder;
};
Utils.isProjectionBuilder = function (projectionCandidate) {
return projectionCandidate instanceof projection_builder_1.ProjectionBuilder;
};
Utils.isProjectionCompiled = function (projectionCandidate) {
return projectionCandidate instanceof projection_compiled_1.ProjectionCompiled;
};
Utils.isProjectionsHelper = function (projectionCandidate) {
return projectionCandidate instanceof projections_helper_1.ProjectionsHelper;
};
Utils.isValueType = function (value) {
return this.isNumber(value) || this.isString(value) || this.isBoolean(value);
};
Utils.isValueTypeToParse = function (value) {
return this.isValueType(value) || this.isDate(value) || this.isMoment(value) || this.isObject(value);
};
Utils.isWhereBuilder = function (whereCandidate) {
return whereCandidate instanceof where_builder_1.WhereBuilder;
};
Utils.isColumnRef = function (instance) {
return instance instanceof column_ref_1.ColumnRef;
};
Utils.isPlanRef = function (instance) {
return instance instanceof plan_ref_1.PlanRef;
};
Utils.isResultable = function (instance) {
return instance
&& this.isObject(instance)
&& "result" in instance
&& this.isFunction(instance.result);
};
Utils.isEmpty = function (value) {
if (this.isBoolean(value) || this.isDate(value)) {
return this.isNull(value);
}
return lodash.isEmpty(value);
};
Utils.isQueryCompiled = function (value) {
return value && this.isString(value.query) && this.isArray(value.params);
};
Utils.isQueryCompiledArray = function (value) {
var _this = this;
return (this.isArray(value)
&& value.filter(function (v) { return _this.isQueryCompiled(v) === false; }).length === 0);
};
Utils.isQueryCompilable = function (value) {
return value.compile && this.isFunction(value.compile);
};
Utils.isTQuery = function (value) {
return this.isQueryCompilable(value) || this.isQueryCompiledArray(value);
};
Utils.getMapperTable = function (typeT, getMapper) {
return Utils.isNull(typeT)
? new metadata_table_base_1.MetadataTableBase(void 0)
: Utils.isQueryBuilder(typeT)
? typeT
: getMapper(typeT);
};
Utils.expressionOrColumn = function (value) {
return this.isString(value)
? expression_or_column_enum_1.ExpressionOrColumnEnum.Column
: expression_or_column_enum_1.ExpressionOrColumnEnum.Expression;
};
Utils.expressionOrValue = function (value) {
return Utils.isNull(value)
? expression_or_value_enum_1.ExpressionOrValueEnum.Null
: this.isProjectionsHelper(value)
? expression_or_value_enum_1.ExpressionOrValueEnum.Projection
: this.isColumnRef(value)
? expression_or_value_enum_1.ExpressionOrValueEnum.Ref
: this.isPlanRef(value)
? expression_or_value_enum_1.ExpressionOrValueEnum.Plan
: this.isValue(value)
? expression_or_value_enum_1.ExpressionOrValueEnum.Value
: expression_or_value_enum_1.ExpressionOrValueEnum.Expression;
};
Utils.getColumn = function (expression, separator) {
var type = this.expressionOrColumn(expression);
switch (type) {
case (expression_or_column_enum_1.ExpressionOrColumnEnum.Expression):
return this.getExpressionUtils().getColumnByExpression(expression, separator);
case (expression_or_column_enum_1.ExpressionOrColumnEnum.Column):
return expression;
}
};
Utils.getColumnWhere = function (expression) {
var type = this.expressionOrValue(expression);
switch (type) {
case (expression_or_value_enum_1.ExpressionOrValueEnum.Expression):
return {
column: this.getExpressionUtils().getColumnByExpression(expression),
params: []
};
case (expression_or_value_enum_1.ExpressionOrValueEnum.Ref):
case (expression_or_value_enum_1.ExpressionOrValueEnum.Plan):
return {
column: expression,
params: []
};
case (expression_or_value_enum_1.ExpressionOrValueEnum.Value):
return {
column: "?",
params: [expression]
};
case (expression_or_value_enum_1.ExpressionOrValueEnum.Projection):
var compiled = this.resolveExpressionProjection(expression);
return {
column: compiled.projection,
params: compiled.params
};
case (expression_or_value_enum_1.ExpressionOrValueEnum.Null):
return {
column: condition_1.Condition.IsNull,
params: []
};
}
};
Utils.resolveExpressionProjection = function (projection) {
if (this.isProjectionsHelper(projection)) {
return projection_compile_1.ProjectionCompile.compile(projection._result());
}
if (this.isColumnRef(projection)) {
return new projection_compiled_1.ProjectionCompiled(projection.result());
}
if (this.isPlanRef(projection)) {
return new projection_compiled_1.ProjectionCompiled(projection.result());
}
return new projection_compiled_1.ProjectionCompiled(this.getColumn(projection));
};
Utils.getFieldExpression = function (expression) {
return this.getExpressionUtils().getColumnByExpression(expression, ".");
};
Utils.getValue = function (instance, expression) {
return this.getValues(Utils.isArray(instance) ? instance : [instance], expression);
};
Utils.getValues = function (instance, expression) {
var _this = this;
return this.expressionOrColumn(expression) === expression_or_column_enum_1.ExpressionOrColumnEnum.Expression
? instance.map(function (item) { return _this.getExpressionUtils().getValueByExpression(item, expression); })
: instance.map(function (item) { return _this.getExpressionUtils().getValue(item, expression); });
};
Utils.getTypeByValue = function (value) {
return this.getDatabaseHelper().getType(value);
};
Utils.getType = function (instance, expression) {
var _this = this;
if (this.isArray(instance)) {
return this.getType(instance.find(function (x) { return !_this.isNull(x) && _this.isValue(x); }));
}
if (this.isNull(instance)) {
return void 0;
}
if (expression) {
return this.getTypeByValue(this.getValue(instance, expression));
}
return this.getTypeByValue(instance);
};
Utils.getValueType = function (value, type) {
if (type === void 0) { type = void 0; }
return this.getValuesType(Utils.isArray(value) ? value : [value], type);
};
Utils.getValuesType = function (values, type) {
var _this = this;
if (type === void 0) { type = void 0; }
if (this.isFlag(type, field_type_1.FieldType.ARRAY)) {
// se o campo for do type ARRAY, passar o array para o tratamento e não tratar cada valor individualmente
var t = this.getDatabaseHelper().parseToValueType(values === null || values === void 0 ? void 0 : values[0], type);
return [t];
}
return values.map(function (value) { return _this.getDatabaseHelper().parseToValueType(value, type); });
};
Utils.parseColumnType = function (type) {
return this.getDatabaseHelper().parseToColumnType(type);
};
Utils.isNameColumn = function (column) {
var isNameColumn = /^[a-zA-Z0-9_\*]*$/;
return isNameColumn.test(column) && !this.isColumnReservedNameOrNotAllowed(column);
};
Utils.isValue = function (value) {
return this.isValueNumber(value)
|| this.isString(value)
|| this.isValueBoolean(value)
|| this.isDate(value)
|| this.isMoment(value);
};
Utils.isValueDefault = function (value) {
// tslint:disable-next-line: forin
for (var key in this.DEFAULT_VALUES) {
var valueDefault = this.DEFAULT_VALUES[key];
if (valueDefault === value || (this.isValueNumber(value) && this.isValueNumber(valueDefault) ? value < valueDefault : false)) {
return true;
}
}
return false;
};
Utils.normalizeSqlString = function (inputSql) {
return inputSql.replace(/\s+/g, " ").trim();
};
Utils.getLambdaMetadata = function (expression) {
var columnMetadata = this.getLambdaColumnMetadata(expression);
return {
left: columnMetadata.columnLeft,
condition: this.conditionSql(columnMetadata),
right: columnMetadata.columnRight,
};
};
Utils.clearParam = function (param) {
if (Utils.isString(param)) {
// remove possiveis " ou ' (aspas duplas ou simples) no inicio ou fim de uma string de valor de parametro
return param.replace(/(^["']|["']$)/mg, "");
}
return param;
};
Utils.clearParamLambda = function (param) {
// Somente quando for uma expressão lambda que deve ser convertido os tipos numericos e booleans que estejam no formato string
if (Utils.isString(param)) {
if (Utils.isOnlyNumber(param)) {
return +param;
}
if (Utils.isReservedBoolean(param)) {
return param === "true";
}
}
return param;
};
Utils.addAlias = function (column, alias) {
if (this.isResultable(column)) {
return column.result();
}
if (column && alias && Utils.isNameColumn(column)) {
return "".concat(alias, ".").concat(column);
}
return column;
};
Utils.isColumnReservedNameOrNotAllowed = function (columnName) {
return this.isStartWithNumber(columnName) || this.isReservedBoolean(columnName);
};
Utils.getLambdaColumnMetadata = function (expression) {
return this.getExpressionUtils().getColumnByLambdaExpression(expression);
};
Utils.conditionSql = function (metadata) {
switch (metadata.operator) {
case "==":
case "===":
if (this.isEquivalentNullExpression(metadata.columnRight)) {
return [condition_1.Condition.IsNull];
}
return [condition_1.Condition.Equal];
case ">":
return [condition_1.Condition.Great];
case ">=":
return [condition_1.Condition.GreatAndEqual];
case "<":
return [condition_1.Condition.Less];
case "<=":
return [condition_1.Condition.LessAndEqual];
case "!":
return [condition_1.Condition.Not];
case "!=":
case "!==":
if (this.isEquivalentNullExpression(metadata.columnRight)) {
return [condition_1.Condition.Not, condition_1.Condition.IsNull];
}
return [condition_1.Condition.Not, condition_1.Condition.Equal];
case "XX":
// TODO: not implemented
return [condition_1.Condition.Between];
case "XXX":
// TODO: not implemented
return [condition_1.Condition.In];
// case '':
// return Condition.
default:
throw new errors_1.DatabaseBuilderError("Not found condition (".concat(metadata.operator, ")"));
}
};
Utils.isEquivalentNullExpression = function (value) {
switch (value) {
case "null":
case "void 0":
case "void":
case "undefined":
case "nil":
return true;
default:
return false;
}
};
Utils.getExpressionUtils = function () {
return this._expressionUtils = this._expressionUtils ? this._expressionUtils : new lambda_expression_1.ExpressionUtils();
};
Utils.getDatabaseHelper = function () {
return this._databaseHelper = this._databaseHelper ? this._databaseHelper : new database_helper_1.DatabaseHelper();
};
Utils.objectToDatabaseResult = function (rows, rowsAffected, insertId) {
if (rowsAffected === void 0) { rowsAffected = 0; }
if (insertId === void 0) { insertId = void 0; }
return {
rows: {
length: rows.length,
item: function (index) {
return rows[index];
}
},
rowsAffected: rowsAffected,
insertId: insertId
};
};
Utils.REPLACEABLE_ALIAS = "{<replaceableAlias>}";
Utils.DEFAULT_VALUES = {
BOOLEAN: false,
NUMBER: 0,
STRING: "",
MOMENT: moment(),
DATE: new Date()
};
return Utils;
}());
exports.Utils = Utils;