@decaf-ts/core 0.1.2 → 0.2.0

package/lib/esm/query/clauses/FromClause.js

@@ -0,0 +1,60 @@
+import { Priority } from "../constants";
+import { SelectorBasedClause } from "./SelectorBasedClause";
+import { QueryError } from "../errors";
+import { Model, stringFormat, } from "@decaf-ts/decorator-validation";
+/**
+ * @summary The FROM clause
+ *
+ * @param {ModelArg} [clause]
+ *
+ * @class FromClause
+ * @extends SelectorBasedClause
+ * @implements WhereOption
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export class FromClause extends SelectorBasedClause {
+    constructor(clause) {
+        super(Object.assign({}, clause, { priority: Priority.FROM }));
+        this.selector =
+            typeof this.selector === "string"
+                ? Model.get(this.selector)
+                : this.selector;
+        if (!this.selector)
+            throw new QueryError(stringFormat("Could not find selector model: {0}"));
+        this.statement.setTarget(this.selector);
+    }
+    /**
+     * @inheritDoc
+     */
+    where(condition) {
+        return this.Clauses.where(this.statement, condition);
+    }
+    /**
+     * @inheritDoc
+     */
+    orderBy(...selector) {
+        return this.Clauses.orderBy(this.statement, selector);
+    }
+    /**
+     * @inheritDoc
+     */
+    groupBy(selector) {
+        return this.Clauses.groupBy(this.statement, selector);
+    }
+    /**
+     * @inheritDoc
+     */
+    limit(selector) {
+        return this.Clauses.limit(this.statement, selector);
+    }
+    /**
+     * @inheritDoc
+     */
+    offset(selector) {
+        return this.Clauses.offset(this.statement, selector);
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/esm/query/clauses/GroupByClause.d.ts

@@ -0,0 +1,21 @@
+import { ModelArg } from "@decaf-ts/decorator-validation";
+import { GroupBySelector } from "../selectors";
+import { SelectorBasedClause } from "./SelectorBasedClause";
+/**
+ * @summary The GROUP BY clause
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class GroupByClause
+ * @extends SelectorBasedClause
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export declare abstract class GroupByClause<Q> extends SelectorBasedClause<Q, GroupBySelector> {
+    protected constructor(clause?: ModelArg<GroupByClause<Q>>);
+    /**
+     * @inheritDoc
+     */
+    abstract build(query: Q): Q;
+}

package/lib/esm/query/clauses/GroupByClause.js

@@ -0,0 +1,20 @@
+import { Priority } from "../constants";
+import { SelectorBasedClause } from "./SelectorBasedClause";
+/**
+ * @summary The GROUP BY clause
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class GroupByClause
+ * @extends SelectorBasedClause
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export class GroupByClause extends SelectorBasedClause {
+    constructor(clause) {
+        super(Object.assign({}, clause, { priority: Priority.GROUP_BY }));
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9xdWVyeS9jbGF1c2VzL0dyb3VwQnlDbGF1c2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUN4QyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUU1RDs7Ozs7Ozs7OztHQVVHO0FBQ0gsTUFBTSxPQUFnQixhQUFpQixTQUFRLG1CQUc5QztJQUNDLFlBQXNCLE1BQW1DO1FBQ3ZELEtBQUssQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLEVBQUUsRUFBRSxNQUFNLEVBQUUsRUFBRSxRQUFRLEVBQUUsUUFBUSxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUMsQ0FBQztJQUNwRSxDQUFDO0NBS0YiLCJmaWxlIjoicXVlcnkvY2xhdXNlcy9Hcm91cEJ5Q2xhdXNlLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTW9kZWxBcmcgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5pbXBvcnQgeyBHcm91cEJ5U2VsZWN0b3IgfSBmcm9tIFwiLi4vc2VsZWN0b3JzXCI7XG5pbXBvcnQgeyBQcmlvcml0eSB9IGZyb20gXCIuLi9jb25zdGFudHNcIjtcbmltcG9ydCB7IFNlbGVjdG9yQmFzZWRDbGF1c2UgfSBmcm9tIFwiLi9TZWxlY3RvckJhc2VkQ2xhdXNlXCI7XG5cbi8qKlxuICogQHN1bW1hcnkgVGhlIEdST1VQIEJZIGNsYXVzZVxuICpcbiAqIEBwYXJhbSB7Q2xhdXNlQXJnfSBbY2xhdXNlXVxuICpcbiAqIEBjbGFzcyBHcm91cEJ5Q2xhdXNlXG4gKiBAZXh0ZW5kcyBTZWxlY3RvckJhc2VkQ2xhdXNlXG4gKlxuICogQGNhdGVnb3J5IFF1ZXJ5XG4gKiBAc3ViY2F0ZWdvcnkgQ2xhdXNlc1xuICovXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgR3JvdXBCeUNsYXVzZTxRPiBleHRlbmRzIFNlbGVjdG9yQmFzZWRDbGF1c2U8XG4gIFEsXG4gIEdyb3VwQnlTZWxlY3RvclxuPiB7XG4gIHByb3RlY3RlZCBjb25zdHJ1Y3RvcihjbGF1c2U/OiBNb2RlbEFyZzxHcm91cEJ5Q2xhdXNlPFE+Pikge1xuICAgIHN1cGVyKE9iamVjdC5hc3NpZ24oe30sIGNsYXVzZSwgeyBwcmlvcml0eTogUHJpb3JpdHkuR1JPVVBfQlkgfSkpO1xuICB9XG4gIC8qKlxuICAgKiBAaW5oZXJpdERvY1xuICAgKi9cbiAgYWJzdHJhY3QgYnVpbGQocXVlcnk6IFEpOiBRO1xufVxuIl19

package/lib/esm/query/clauses/InsertClause.d.ts

@@ -0,0 +1,37 @@
+import { Condition } from "../Condition";
+import { InsertOption, IntoOption, OrderAndGroupOption } from "../options";
+import { Clause } from "../Clause";
+import { Constructor, Model, ModelArg } from "@decaf-ts/decorator-validation";
+import { Executor } from "../../interfaces";
+/**
+ * @summary The INSERT/INTO clause
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class FromClause
+ * @extends Clause
+ * @implements IntoOption
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export declare abstract class InsertClause<Q, M extends Model> extends Clause<Q> implements InsertOption<M>, IntoOption<M> {
+    protected table?: string;
+    protected constructor(clause?: ModelArg<InsertClause<Q, M>>);
+    /**
+     * @inheritDoc
+     */
+    abstract build(query: Q): Q;
+    /**
+     * @inheritDoc
+     */
+    into(table: Constructor<M>): IntoOption<M>;
+    /**
+     * @inheritDoc
+     */
+    values(...models: M[]): Executor;
+    /**
+     * @inheritDoc
+     */
+    where(condition: Condition): OrderAndGroupOption;
+}

package/lib/esm/query/clauses/InsertClause.js

@@ -0,0 +1,56 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Priority } from "../constants";
+import { Clause } from "../Clause";
+import { required, } from "@decaf-ts/decorator-validation";
+/**
+ * @summary The INSERT/INTO clause
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class FromClause
+ * @extends Clause
+ * @implements IntoOption
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export class InsertClause extends Clause {
+    constructor(clause) {
+        super(Object.assign({}, clause, { priority: Priority.SELECT }));
+        this.table = undefined;
+    }
+    /**
+     * @inheritDoc
+     */
+    into(table) {
+        this.table = table.name; // TODO get mapped name
+        this.statement.setTarget(table);
+        return this;
+    }
+    /**
+     * @inheritDoc
+     */
+    values(...models) {
+        return this.Clauses.values(this.statement, models);
+    }
+    /**
+     * @inheritDoc
+     */
+    where(condition) {
+        return this.Clauses.where(this.statement, condition);
+    }
+}
+__decorate([
+    required(),
+    __metadata("design:type", String)
+], InsertClause.prototype, "table", void 0);
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/esm/query/clauses/LimitClause.d.ts

@@ -0,0 +1,29 @@
+import { SelectorBasedClause } from "./SelectorBasedClause";
+import { OffsetOption } from "../options";
+import { Executor } from "../../interfaces";
+import { LimitSelector, OffsetSelector } from "../selectors";
+import { ModelArg } from "@decaf-ts/decorator-validation";
+/**
+ * @summary Limit Clause
+ * @description Limits the results
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class LimitClause
+ * @extends SelectorBasedClause<T>
+ * @implements OffsetOption<T>
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export declare abstract class LimitClause<Q> extends SelectorBasedClause<Q, LimitSelector> implements OffsetOption {
+    protected constructor(clause?: ModelArg<LimitClause<Q>>);
+    /**
+     * @inheritDoc
+     */
+    abstract build(query: Q): Q;
+    /**
+     * @inheritDoc
+     */
+    offset(selector: OffsetSelector): Executor;
+}

package/lib/esm/query/clauses/LimitClause.js

@@ -0,0 +1,28 @@
+import { SelectorBasedClause } from "./SelectorBasedClause";
+import { Priority } from "../constants";
+/**
+ * @summary Limit Clause
+ * @description Limits the results
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class LimitClause
+ * @extends SelectorBasedClause<T>
+ * @implements OffsetOption<T>
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export class LimitClause extends SelectorBasedClause {
+    constructor(clause) {
+        super(Object.assign({}, clause, { priority: Priority.GROUP_BY }));
+    }
+    /**
+     * @inheritDoc
+     */
+    offset(selector) {
+        return this.Clauses.offset(this.statement, selector);
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/esm/query/clauses/OffsetClause.d.ts

@@ -0,0 +1,21 @@
+import { SelectorBasedClause } from "./SelectorBasedClause";
+import { OffsetSelector } from "../selectors";
+import { ModelArg } from "@decaf-ts/decorator-validation";
+/**
+ * @summary The OFFSET clause
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class FromClause
+ * @extends SelectorBasedClause
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export declare abstract class OffsetClause<Q> extends SelectorBasedClause<Q, OffsetSelector> {
+    protected constructor(clause?: ModelArg<OffsetClause<Q>>);
+    /**
+     * @inheritDoc
+     */
+    abstract build(query: Q): Q;
+}

package/lib/esm/query/clauses/OffsetClause.js

@@ -0,0 +1,20 @@
+import { SelectorBasedClause } from "./SelectorBasedClause";
+import { Priority } from "../constants";
+/**
+ * @summary The OFFSET clause
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class FromClause
+ * @extends SelectorBasedClause
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export class OffsetClause extends SelectorBasedClause {
+    constructor(clause) {
+        super(Object.assign({}, clause, { priority: Priority.GROUP_BY }));
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9xdWVyeS9jbGF1c2VzL09mZnNldENsYXVzZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUU1RCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBR3hDOzs7Ozs7Ozs7O0dBVUc7QUFDSCxNQUFNLE9BQWdCLFlBQWdCLFNBQVEsbUJBRzdDO0lBQ0MsWUFBc0IsTUFBa0M7UUFDdEQsS0FBSyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRSxFQUFFLE1BQU0sRUFBRSxFQUFFLFFBQVEsRUFBRSxRQUFRLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ3BFLENBQUM7Q0FLRiIsImZpbGUiOiJxdWVyeS9jbGF1c2VzL09mZnNldENsYXVzZS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNlbGVjdG9yQmFzZWRDbGF1c2UgfSBmcm9tIFwiLi9TZWxlY3RvckJhc2VkQ2xhdXNlXCI7XG5pbXBvcnQgeyBPZmZzZXRTZWxlY3RvciB9IGZyb20gXCIuLi9zZWxlY3RvcnNcIjtcbmltcG9ydCB7IFByaW9yaXR5IH0gZnJvbSBcIi4uL2NvbnN0YW50c1wiO1xuaW1wb3J0IHsgTW9kZWxBcmcgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5cbi8qKlxuICogQHN1bW1hcnkgVGhlIE9GRlNFVCBjbGF1c2VcbiAqXG4gKiBAcGFyYW0ge0NsYXVzZUFyZ30gW2NsYXVzZV1cbiAqXG4gKiBAY2xhc3MgRnJvbUNsYXVzZVxuICogQGV4dGVuZHMgU2VsZWN0b3JCYXNlZENsYXVzZVxuICpcbiAqIEBjYXRlZ29yeSBRdWVyeVxuICogQHN1YmNhdGVnb3J5IENsYXVzZXNcbiAqL1xuZXhwb3J0IGFic3RyYWN0IGNsYXNzIE9mZnNldENsYXVzZTxRPiBleHRlbmRzIFNlbGVjdG9yQmFzZWRDbGF1c2U8XG4gIFEsXG4gIE9mZnNldFNlbGVjdG9yXG4+IHtcbiAgcHJvdGVjdGVkIGNvbnN0cnVjdG9yKGNsYXVzZT86IE1vZGVsQXJnPE9mZnNldENsYXVzZTxRPj4pIHtcbiAgICBzdXBlcihPYmplY3QuYXNzaWduKHt9LCBjbGF1c2UsIHsgcHJpb3JpdHk6IFByaW9yaXR5LkdST1VQX0JZIH0pKTtcbiAgfVxuICAvKipcbiAgICogQGluaGVyaXREb2NcbiAgICovXG4gIGFic3RyYWN0IGJ1aWxkKHF1ZXJ5OiBRKTogUTtcbn1cbiJdfQ==

package/lib/esm/query/clauses/OrderByClause.d.ts

@@ -0,0 +1,37 @@
+import { SelectorBasedClause } from "./SelectorBasedClause";
+import { GroupBySelector, LimitSelector, OffsetSelector, OrderBySelector } from "../selectors";
+import { LimitOption, OffsetOption } from "../options";
+import { Executor } from "../../interfaces";
+import { ModelArg } from "@decaf-ts/decorator-validation";
+/**
+ * @summary The ORDER BY clause
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class OrderByClause
+ * @extends SelectorBasedClause
+ * @implements LimitOption
+ * @implements OffsetOption
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export declare abstract class OrderByClause<Q> extends SelectorBasedClause<Q, OrderBySelector[]> implements LimitOption, OffsetOption {
+    protected constructor(clause?: ModelArg<OrderByClause<Q>>);
+    /**
+     * @inheritDoc
+     */
+    abstract build(query: Q): Q;
+    /**
+     * @inheritDoc
+     */
+    groupBy(selector: GroupBySelector): Executor;
+    /**
+     * @inheritDoc
+     */
+    limit(selector: LimitSelector): OffsetOption;
+    /**
+     * @inheritDoc
+     */
+    offset(selector: OffsetSelector): Executor;
+}

package/lib/esm/query/clauses/OrderByClause.js

@@ -0,0 +1,40 @@
+import { SelectorBasedClause } from "./SelectorBasedClause";
+import { Priority } from "../constants";
+/**
+ * @summary The ORDER BY clause
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class OrderByClause
+ * @extends SelectorBasedClause
+ * @implements LimitOption
+ * @implements OffsetOption
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export class OrderByClause extends SelectorBasedClause {
+    constructor(clause) {
+        super(Object.assign({}, clause, { priority: Priority.ORDER_BY }));
+    }
+    /**
+     * @inheritDoc
+     */
+    groupBy(selector) {
+        return this.Clauses.groupBy(this.statement, selector);
+    }
+    /**
+     * @inheritDoc
+     */
+    limit(selector) {
+        return this.Clauses.limit(this.statement, selector);
+    }
+    /**
+     * @inheritDoc
+     */
+    offset(selector) {
+        return this.Clauses.offset(this.statement, selector);
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9xdWVyeS9jbGF1c2VzL09yZGVyQnlDbGF1c2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDNUQsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQVV4Qzs7Ozs7Ozs7Ozs7O0dBWUc7QUFDSCxNQUFNLE9BQWdCLGFBQ3BCLFNBQVEsbUJBQXlDO0lBR2pELFlBQXNCLE1BQW1DO1FBQ3ZELEtBQUssQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLEVBQUUsRUFBRSxNQUFNLEVBQUUsRUFBRSxRQUFRLEVBQUUsUUFBUSxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUMsQ0FBQztJQUNwRSxDQUFDO0lBS0Q7O09BRUc7SUFDSCxPQUFPLENBQUMsUUFBeUI7UUFDL0IsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFFLFFBQVEsQ0FBQyxDQUFDO0lBQ3hELENBQUM7SUFDRDs7T0FFRztJQUNILEtBQUssQ0FBQyxRQUF1QjtRQUMzQixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDdEQsQ0FBQztJQUNEOztPQUVHO0lBQ0gsTUFBTSxDQUFDLFFBQXdCO1FBQzdCLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBRSxRQUFRLENBQUMsQ0FBQztJQUN2RCxDQUFDO0NBQ0YiLCJmaWxlIjoicXVlcnkvY2xhdXNlcy9PcmRlckJ5Q2xhdXNlLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2VsZWN0b3JCYXNlZENsYXVzZSB9IGZyb20gXCIuL1NlbGVjdG9yQmFzZWRDbGF1c2VcIjtcbmltcG9ydCB7IFByaW9yaXR5IH0gZnJvbSBcIi4uL2NvbnN0YW50c1wiO1xuaW1wb3J0IHtcbiAgR3JvdXBCeVNlbGVjdG9yLFxuICBMaW1pdFNlbGVjdG9yLFxuICBPZmZzZXRTZWxlY3RvcixcbiAgT3JkZXJCeVNlbGVjdG9yLFxufSBmcm9tIFwiLi4vc2VsZWN0b3JzXCI7XG5pbXBvcnQgeyBMaW1pdE9wdGlvbiwgT2Zmc2V0T3B0aW9uIH0gZnJvbSBcIi4uL29wdGlvbnNcIjtcbmltcG9ydCB7IEV4ZWN1dG9yIH0gZnJvbSBcIi4uLy4uL2ludGVyZmFjZXNcIjtcbmltcG9ydCB7IE1vZGVsQXJnIH0gZnJvbSBcIkBkZWNhZi10cy9kZWNvcmF0b3ItdmFsaWRhdGlvblwiO1xuLyoqXG4gKiBAc3VtbWFyeSBUaGUgT1JERVIgQlkgY2xhdXNlXG4gKlxuICogQHBhcmFtIHtDbGF1c2VBcmd9IFtjbGF1c2VdXG4gKlxuICogQGNsYXNzIE9yZGVyQnlDbGF1c2VcbiAqIEBleHRlbmRzIFNlbGVjdG9yQmFzZWRDbGF1c2VcbiAqIEBpbXBsZW1lbnRzIExpbWl0T3B0aW9uXG4gKiBAaW1wbGVtZW50cyBPZmZzZXRPcHRpb25cbiAqXG4gKiBAY2F0ZWdvcnkgUXVlcnlcbiAqIEBzdWJjYXRlZ29yeSBDbGF1c2VzXG4gKi9cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBPcmRlckJ5Q2xhdXNlPFE+XG4gIGV4dGVuZHMgU2VsZWN0b3JCYXNlZENsYXVzZTxRLCBPcmRlckJ5U2VsZWN0b3JbXT5cbiAgaW1wbGVtZW50cyBMaW1pdE9wdGlvbiwgT2Zmc2V0T3B0aW9uXG57XG4gIHByb3RlY3RlZCBjb25zdHJ1Y3RvcihjbGF1c2U/OiBNb2RlbEFyZzxPcmRlckJ5Q2xhdXNlPFE+Pikge1xuICAgIHN1cGVyKE9iamVjdC5hc3NpZ24oe30sIGNsYXVzZSwgeyBwcmlvcml0eTogUHJpb3JpdHkuT1JERVJfQlkgfSkpO1xuICB9XG4gIC8qKlxuICAgKiBAaW5oZXJpdERvY1xuICAgKi9cbiAgYWJzdHJhY3QgYnVpbGQocXVlcnk6IFEpOiBRO1xuICAvKipcbiAgICogQGluaGVyaXREb2NcbiAgICovXG4gIGdyb3VwQnkoc2VsZWN0b3I6IEdyb3VwQnlTZWxlY3Rvcik6IEV4ZWN1dG9yIHtcbiAgICByZXR1cm4gdGhpcy5DbGF1c2VzLmdyb3VwQnkodGhpcy5zdGF0ZW1lbnQsIHNlbGVjdG9yKTtcbiAgfVxuICAvKipcbiAgICogQGluaGVyaXREb2NcbiAgICovXG4gIGxpbWl0KHNlbGVjdG9yOiBMaW1pdFNlbGVjdG9yKTogT2Zmc2V0T3B0aW9uIHtcbiAgICByZXR1cm4gdGhpcy5DbGF1c2VzLmxpbWl0KHRoaXMuc3RhdGVtZW50LCBzZWxlY3Rvcik7XG4gIH1cbiAgLyoqXG4gICAqIEBpbmhlcml0RG9jXG4gICAqL1xuICBvZmZzZXQoc2VsZWN0b3I6IE9mZnNldFNlbGVjdG9yKTogRXhlY3V0b3Ige1xuICAgIHJldHVybiB0aGlzLkNsYXVzZXMub2Zmc2V0KHRoaXMuc3RhdGVtZW50LCBzZWxlY3Rvcik7XG4gIH1cbn1cbiJdfQ==

package/lib/esm/query/clauses/SelectClause.d.ts

@@ -0,0 +1,47 @@
+import { SelectorBasedClause } from "./SelectorBasedClause";
+import { CountOption, DistinctOption, MaxOption, MinOption, SelectOption, WhereOption } from "../options";
+import { Constructor, ModelArg, Model } from "@decaf-ts/decorator-validation";
+import { SelectSelector } from "../selectors";
+/**
+ * @summary The SELECT clause
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class SelectClause
+ * @extends SelectorBasedClause
+ * @implements SelectOption
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export declare abstract class SelectClause<Q, M extends Model> extends SelectorBasedClause<Q, SelectSelector> implements SelectOption<M> {
+    private isDistinct;
+    private isCount;
+    private isMax;
+    private isMin;
+    protected constructor(clause?: ModelArg<SelectClause<Q, M>>);
+    /**
+     * @inheritDoc
+     */
+    abstract build(query: Q): Q;
+    /**
+     * @inheritDoc
+     */
+    distinct(selector: SelectSelector): DistinctOption<M>;
+    /**
+     * @inheritDoc
+     */
+    count(selector: SelectSelector): CountOption<M>;
+    /**
+     * @inheritDoc
+     */
+    min(selector: SelectSelector): MinOption<M>;
+    /**
+     * @inheritDoc
+     */
+    max(selector: SelectSelector): MaxOption<M>;
+    /**
+     * @inheritDoc
+     */
+    from(tableName: Constructor<M>): WhereOption;
+}

package/lib/esm/query/clauses/SelectClause.js

@@ -0,0 +1,63 @@
+import { SelectorBasedClause } from "./SelectorBasedClause";
+import { Const, Priority, StatementType } from "../constants";
+/**
+ * @summary The SELECT clause
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class SelectClause
+ * @extends SelectorBasedClause
+ * @implements SelectOption
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export class SelectClause extends SelectorBasedClause {
+    constructor(clause) {
+        super(Object.assign({}, clause, { priority: Priority.SELECT }));
+        this.isDistinct = false;
+        this.isCount = false;
+        this.isMax = false;
+        this.isMin = false;
+        if (this.selector === Const.FULL_RECORD)
+            this.statement.setFullRecord();
+        this.statement.setMode(StatementType.QUERY);
+    }
+    /**
+     * @inheritDoc
+     */
+    distinct(selector) {
+        this.isDistinct = true;
+        this.selector = selector;
+        return this;
+    }
+    /**
+     * @inheritDoc
+     */
+    count(selector) {
+        this.selector = selector;
+        return this;
+    }
+    /**
+     * @inheritDoc
+     */
+    min(selector) {
+        this.selector = selector;
+        return this;
+    }
+    /**
+     * @inheritDoc
+     */
+    max(selector) {
+        this.selector = selector;
+        return this;
+    }
+    /**
+     * @inheritDoc
+     */
+    from(tableName) {
+        return this.Clauses.from(this.statement, tableName);
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/esm/query/clauses/SelectorBasedClause.d.ts

@@ -0,0 +1,25 @@
+import { Clause } from "../Clause";
+import { ModelArg } from "@decaf-ts/decorator-validation";
+/**
+ * @summary The base Selector based clause
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class SelectorBasedClause
+ * @extends Clause
+ * @abstract
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export declare abstract class SelectorBasedClause<Q, S> extends Clause<Q> {
+    /**
+     * @summary Stores the selector
+     *
+     * @prop selector
+     * @protected
+     */
+    protected selector?: S;
+    protected constructor(clause?: ModelArg<SelectorBasedClause<Q, S>>);
+    toString(): string;
+}

package/lib/esm/query/clauses/SelectorBasedClause.js

@@ -0,0 +1,45 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Clause } from "../Clause";
+import { required } from "@decaf-ts/decorator-validation";
+/**
+ * @summary The base Selector based clause
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class SelectorBasedClause
+ * @extends Clause
+ * @abstract
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export class SelectorBasedClause extends Clause {
+    constructor(clause) {
+        super(clause);
+        /**
+         * @summary Stores the selector
+         *
+         * @prop selector
+         * @protected
+         */
+        this.selector = undefined;
+        this.selector = clause.selector;
+    }
+    toString() {
+        return this.constructor.name + `[${this.selector}]`;
+    }
+}
+__decorate([
+    required(),
+    __metadata("design:type", Object)
+], SelectorBasedClause.prototype, "selector", void 0);
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9xdWVyeS9jbGF1c2VzL1NlbGVjdG9yQmFzZWRDbGF1c2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O0FBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUNuQyxPQUFPLEVBQVksUUFBUSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFcEU7Ozs7Ozs7Ozs7O0dBV0c7QUFDSCxNQUFNLE9BQWdCLG1CQUEwQixTQUFRLE1BQVM7SUFVL0QsWUFBc0IsTUFBNEM7UUFDaEUsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBVmhCOzs7OztXQUtHO1FBRU8sYUFBUSxHQUFPLFNBQVMsQ0FBQztRQUlqQyxJQUFJLENBQUMsUUFBUSxHQUFJLE1BQTBCLENBQUMsUUFBUSxDQUFDO0lBQ3ZELENBQUM7SUFFRCxRQUFRO1FBQ04sT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksR0FBRyxJQUFJLElBQUksQ0FBQyxRQUFRLEdBQUcsQ0FBQztJQUN0RCxDQUFDO0NBQ0Y7QUFWVztJQURULFFBQVEsRUFBRTs7cURBQ3dCIiwiZmlsZSI6InF1ZXJ5L2NsYXVzZXMvU2VsZWN0b3JCYXNlZENsYXVzZS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENsYXVzZSB9IGZyb20gXCIuLi9DbGF1c2VcIjtcbmltcG9ydCB7IE1vZGVsQXJnLCByZXF1aXJlZCB9IGZyb20gXCJAZGVjYWYtdHMvZGVjb3JhdG9yLXZhbGlkYXRpb25cIjtcblxuLyoqXG4gKiBAc3VtbWFyeSBUaGUgYmFzZSBTZWxlY3RvciBiYXNlZCBjbGF1c2VcbiAqXG4gKiBAcGFyYW0ge0NsYXVzZUFyZ30gW2NsYXVzZV1cbiAqXG4gKiBAY2xhc3MgU2VsZWN0b3JCYXNlZENsYXVzZVxuICogQGV4dGVuZHMgQ2xhdXNlXG4gKiBAYWJzdHJhY3RcbiAqXG4gKiBAY2F0ZWdvcnkgUXVlcnlcbiAqIEBzdWJjYXRlZ29yeSBDbGF1c2VzXG4gKi9cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBTZWxlY3RvckJhc2VkQ2xhdXNlPFEsIFM+IGV4dGVuZHMgQ2xhdXNlPFE+IHtcbiAgLyoqXG4gICAqIEBzdW1tYXJ5IFN0b3JlcyB0aGUgc2VsZWN0b3JcbiAgICpcbiAgICogQHByb3Agc2VsZWN0b3JcbiAgICogQHByb3RlY3RlZFxuICAgKi9cbiAgQHJlcXVpcmVkKClcbiAgcHJvdGVjdGVkIHNlbGVjdG9yPzogUyA9IHVuZGVmaW5lZDtcblxuICBwcm90ZWN0ZWQgY29uc3RydWN0b3IoY2xhdXNlPzogTW9kZWxBcmc8U2VsZWN0b3JCYXNlZENsYXVzZTxRLCBTPj4pIHtcbiAgICBzdXBlcihjbGF1c2UpO1xuICAgIHRoaXMuc2VsZWN0b3IgPSAoY2xhdXNlIGFzIHsgc2VsZWN0b3I6IFMgfSkuc2VsZWN0b3I7XG4gIH1cblxuICB0b1N0cmluZygpIHtcbiAgICByZXR1cm4gdGhpcy5jb25zdHJ1Y3Rvci5uYW1lICsgYFske3RoaXMuc2VsZWN0b3J9XWA7XG4gIH1cbn1cbiJdfQ==

package/lib/esm/query/clauses/ValuesClause.d.ts

@@ -0,0 +1,21 @@
+import { Clause } from "../Clause";
+import { ModelArg } from "@decaf-ts/decorator-validation";
+/**
+ * @summary The VALUES clause
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class ValuesClause
+ * @extends Clause
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export declare abstract class ValuesClause<Q, M> extends Clause<Q> {
+    models?: M[];
+    protected constructor(clause?: ModelArg<ValuesClause<Q, M>>);
+    /**
+     * @inheritDoc
+     */
+    abstract build(query: Q): Q;
+}

package/lib/esm/query/clauses/ValuesClause.js

@@ -0,0 +1,37 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Clause } from "../Clause";
+import { Priority } from "../constants";
+import { required, type } from "@decaf-ts/decorator-validation";
+/**
+ * @summary The VALUES clause
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class ValuesClause
+ * @extends Clause
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export class ValuesClause extends Clause {
+    constructor(clause) {
+        super(Object.assign({}, clause, { priority: Priority.FROM }));
+        this.models = undefined;
+        this.models = clause?.models;
+    }
+}
+__decorate([
+    required(),
+    type(Array.name),
+    __metadata("design:type", Array)
+], ValuesClause.prototype, "models", void 0);
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9xdWVyeS9jbGF1c2VzL1ZhbHVlc0NsYXVzZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBQ25DLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFDeEMsT0FBTyxFQUFZLFFBQVEsRUFBRSxJQUFJLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUUxRTs7Ozs7Ozs7OztHQVVHO0FBQ0gsTUFBTSxPQUFnQixZQUFtQixTQUFRLE1BQVM7SUFLeEQsWUFBc0IsTUFBcUM7UUFDekQsS0FBSyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRSxFQUFFLE1BQU0sRUFBRSxFQUFFLFFBQVEsRUFBRSxRQUFRLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBSGhFLFdBQU0sR0FBUyxTQUFTLENBQUM7UUFJdkIsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLEVBQUUsTUFBTSxDQUFDO0lBQy9CLENBQUM7Q0FLRjtBQVZDO0lBRkMsUUFBUSxFQUFFO0lBQ1YsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUM7OzRDQUNRIiwiZmlsZSI6InF1ZXJ5L2NsYXVzZXMvVmFsdWVzQ2xhdXNlLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ2xhdXNlIH0gZnJvbSBcIi4uL0NsYXVzZVwiO1xuaW1wb3J0IHsgUHJpb3JpdHkgfSBmcm9tIFwiLi4vY29uc3RhbnRzXCI7XG5pbXBvcnQgeyBNb2RlbEFyZywgcmVxdWlyZWQsIHR5cGUgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5cbi8qKlxuICogQHN1bW1hcnkgVGhlIFZBTFVFUyBjbGF1c2VcbiAqXG4gKiBAcGFyYW0ge0NsYXVzZUFyZ30gW2NsYXVzZV1cbiAqXG4gKiBAY2xhc3MgVmFsdWVzQ2xhdXNlXG4gKiBAZXh0ZW5kcyBDbGF1c2VcbiAqXG4gKiBAY2F0ZWdvcnkgUXVlcnlcbiAqIEBzdWJjYXRlZ29yeSBDbGF1c2VzXG4gKi9cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBWYWx1ZXNDbGF1c2U8USwgTT4gZXh0ZW5kcyBDbGF1c2U8UT4ge1xuICBAcmVxdWlyZWQoKVxuICBAdHlwZShBcnJheS5uYW1lKVxuICBtb2RlbHM/OiBNW10gPSB1bmRlZmluZWQ7XG5cbiAgcHJvdGVjdGVkIGNvbnN0cnVjdG9yKGNsYXVzZT86IE1vZGVsQXJnPFZhbHVlc0NsYXVzZTxRLCBNPj4pIHtcbiAgICBzdXBlcihPYmplY3QuYXNzaWduKHt9LCBjbGF1c2UsIHsgcHJpb3JpdHk6IFByaW9yaXR5LkZST00gfSkpO1xuICAgIHRoaXMubW9kZWxzID0gY2xhdXNlPy5tb2RlbHM7XG4gIH1cbiAgLyoqXG4gICAqIEBpbmhlcml0RG9jXG4gICAqL1xuICBhYnN0cmFjdCBidWlsZChxdWVyeTogUSk6IFE7XG59XG4iXX0=