ts-db-helper
Version:
Simple ORM based on TypeScript
132 lines • 4.22 kB
JavaScript
import { CompositeClause } from './composite-clause.model';
import { ClauseOperators } from '../constants/clause-operators.constant';
import { QueryPart } from './query-part.model';
import { Clause } from './clause.model';
/**
* @public
* @class ClauseGroup
*
* @description
* is a group of clause computed at the same
* level. Clause group are used for where statement of Select, Update
* and Delete statement.
*
* @example
* ```typescript
* // Create a group of clauses
* const group = new ClauseGroup();
*
* // create clause to get Todo item where isDone === false
* const doneClause = new Clause();
* doneClause.key = 'isDone';
* doneClause.value = false;
* group.add(doneClause);
*
* // create clause to get Todo item where dueDate <= now
* const dueDateClause = new Clause();
* dueDateClause.key = 'dueDate';
* dueDateClause.value = (new Date()).getTime();
* dueDateClause.comparator = Clause.COMPARATORS.LTE;
* group.add(dueDateClause);
*
* // start select clause
* Select(Todo).where(group).exec().subscribe((QueryResult<Todo>) => {
* // do something with the result...
* }, (err) => {
* // do something with the error...
* });
* ```
*
* @author Olivier Margarit
*
* @since 0.1
*/
var ClauseGroup = /** @class */ (function () {
/**
* @public
* @constructor could take same parameters as add
*
* @param {ClauseGroup|Clause|Clause[]|CompositeClause|{[index: string]: any}} clauses clauses to add to the group
*/
function ClauseGroup(clauses) {
/**
* @private
* @property {Array<IClause>} clauses array of clause to append in the same group
*/
this.clauses = [];
if (clauses) {
this.add(clauses);
}
}
/**
* @public
* @method isEmpty check if clause group is empty
*
* @return {boolean} true if is empty
*/
ClauseGroup.prototype.isEmpty = function () {
return !this.clauses;
};
/**
* @public
* @method add add one or many clause
*
* @example
* // create group
* const group = new ClauseGroup();
*
* // clause with dict notation
* group.add({isDone: false, bar: 'foo'});
*
* // Adding a clause object
* const clause = new Clause();
* clause.key = 'isDone';
* clause.value = false;
* group.add(clause);
*
* @param {ClauseGroup|Clause|Clause[]|IClause[]|CompositeClause|{[index: string]: any}} clauses clauses to add to the clause group
*/
ClauseGroup.prototype.add = function (clauses) {
if (clauses instanceof ClauseGroup) {
this.add(clauses.clauses);
}
else if (clauses instanceof Clause || clauses instanceof CompositeClause) {
this.clauses.push(clauses);
}
else if (Array.isArray(clauses)) {
this.clauses = this.clauses.concat(clauses);
}
else {
for (var key in clauses) {
if (clauses.hasOwnProperty(key)) {
var clause = new Clause();
clause.key = key;
clause.value = clauses[key];
this.clauses.push(clause);
}
}
}
};
/**
* @public
* @method build is apart of private API, should move later...
* it build the clause group to the string part of the query
*
* @return {QueryPart} of the query with the string part and
* clauses params.
*/
ClauseGroup.prototype.build = function () {
var queryPart = new QueryPart;
for (var _i = 0, _a = this.clauses; _i < _a.length; _i++) {
var clause = _a[_i];
if (queryPart.content) {
queryPart.appendContent((clause.operator === ClauseOperators.AND) ? ClauseOperators.AND : ClauseOperators.OR);
}
queryPart.append(clause.build());
}
return queryPart;
};
return ClauseGroup;
}());
export { ClauseGroup };
//# sourceMappingURL=clause-group.model.js.map