@decaf-ts/core 0.1.3 → 0.2.1

package/lib/query/Statement.cjs

@@ -0,0 +1,162 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Statement = void 0;
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const constants_1 = require("./constants.cjs");
+const errors_1 = require("./errors.cjs");
+const validators_1 = require("../validators/index.cjs");
+const persistence_1 = require("../persistence/index.cjs");
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+/**
+ * @summary Statement Class
+ * @description holds all the clauses until they can be processed
+ *
+ * @param {ModelArg} [statement]
+ *
+ * @class Statement
+ * @extends Model
+ * @implements Executor
+ * @implements RawExecutor
+ *
+ * @category Query
+ */
+class Statement extends decorator_validation_1.Model {
+    constructor(db) {
+        super();
+        this.clauses = undefined;
+        this.target = undefined;
+        this.fullRecord = false;
+        this.type = undefined;
+        this.adapter = db;
+    }
+    build() {
+        if (!this.clauses)
+            throw new errors_1.QueryError((0, decorator_validation_1.sf)("Failed to build Statement:\n{0}", "No Clauses"));
+        this.clauses.sort((c1, c2) => {
+            return c1.getPriority() - c2.getPriority();
+        });
+        const errors = this.hasErrors();
+        if (errors)
+            throw new errors_1.QueryError((0, decorator_validation_1.sf)("Poorly built statement: {0}", errors.toString()));
+        let query;
+        try {
+            const iterator = function (clauses, previous = {}) {
+                const c = clauses.shift();
+                if (!c)
+                    return previous;
+                const results = c.build(previous);
+                return iterator(clauses, results);
+            };
+            query = iterator(new Array(...this.clauses));
+        }
+        catch (e) {
+            throw new errors_1.QueryError(e);
+        }
+        return query;
+    }
+    /**
+     * @inheritDoc
+     */
+    async execute() {
+        try {
+            const query = this.build();
+            return this.raw(query);
+        }
+        catch (e) {
+            throw new db_decorators_1.InternalError(e);
+        }
+    }
+    async raw(rawInput, ...args) {
+        const results = await this.adapter.raw(rawInput, ...args);
+        if (!this.fullRecord)
+            return results;
+        if (!this.target)
+            throw new db_decorators_1.InternalError("No target defined in statement. should never happen");
+        const pkAttr = (0, db_decorators_1.findPrimaryKey)(new this.target()).id;
+        const processor = function recordProcessor(r) {
+            const id = r[pkAttr];
+            return this.adapter.revert(r, this.target, pkAttr, id);
+        }.bind(this);
+        if (Array.isArray(results))
+            return results.map(processor);
+        return processor(results);
+    }
+    /**
+     * @inheritDoc
+     */
+    hasErrors(...exceptions) {
+        const errors = super.hasErrors(...exceptions);
+        if (errors)
+            return errors;
+        for (const i in this.clauses) {
+            const err = this.clauses[i].hasErrors();
+            if (err)
+                return err;
+        }
+    }
+    /**
+     * @summary Adds a clause to the Statement
+     * @param {Clause} clause
+     */
+    addClause(clause) {
+        if (!this.clauses)
+            this.clauses = [];
+        const priority = clause.getPriority();
+        const currentPriority = this.clauses
+            .map((c, i) => ({ index: i, clause: c }))
+            .find((c) => c.clause.getPriority() === priority);
+        if (currentPriority) {
+            this.clauses[currentPriority.index] = clause;
+        }
+        this.clauses.push(clause);
+    }
+    getAdapter() {
+        return this.adapter;
+    }
+    /**
+     * @summary Defines the output class (when existing)
+     * @param {Constructor} clazz
+     */
+    setTarget(clazz) {
+        if (this.target)
+            throw new errors_1.QueryError((0, decorator_validation_1.sf)("Output class already defined to {0}", this.target.name));
+        this.target = clazz;
+    }
+    setFullRecord() {
+        this.fullRecord = true;
+    }
+    setMode(type) {
+        this.type = type;
+    }
+}
+exports.Statement = Statement;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorator_validation_1.minlength)(constants_1.MandatoryPriorities.length),
+    (0, validators_1.clauseSequence)(),
+    __metadata("design:type", Array)
+], Statement.prototype, "clauses", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorator_validation_1.type)(["object"]),
+    __metadata("design:type", persistence_1.Adapter)
+], Statement.prototype, "adapter", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    __metadata("design:type", Object)
+], Statement.prototype, "target", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    __metadata("design:type", String)
+], Statement.prototype, "type", void 0);
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/query/Statement.ts"],"names":[],"mappings":"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","file":"query/Statement.js","sourcesContent":["import {\n  Constructor,\n  minlength,\n  Model,\n  ModelErrorDefinition,\n  required,\n  type,\n  sf,\n} from \"@decaf-ts/decorator-validation\";\nimport { Executor, RawExecutor } from \"../interfaces\";\nimport { MandatoryPriorities, StatementType } from \"./constants\";\nimport { QueryError } from \"./errors\";\nimport { Clause } from \"./Clause\";\nimport { clauseSequence } from \"../validators\";\nimport { Adapter } from \"../persistence\";\nimport { findPrimaryKey, InternalError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @summary Statement Class\n * @description holds all the clauses until they can be processed\n *\n * @param {ModelArg} [statement]\n *\n * @class Statement\n * @extends Model\n * @implements Executor\n * @implements RawExecutor\n *\n * @category Query\n */\nexport abstract class Statement<Q>\n  extends Model\n  implements Executor, RawExecutor<Q>\n{\n  @required()\n  @minlength(MandatoryPriorities.length)\n  @clauseSequence()\n  protected clauses?: Clause<any>[] = undefined;\n  @required()\n  @type([\"object\"])\n  protected adapter: Adapter<any, Q>;\n  @required()\n  protected target?: Constructor<any> = undefined;\n\n  protected fullRecord: boolean = false;\n\n  @required()\n  protected type?: string = undefined;\n\n  protected constructor(db: Adapter<any, Q>) {\n    super();\n    this.adapter = db;\n  }\n\n  protected build(): Q {\n    if (!this.clauses)\n      throw new QueryError(sf(\"Failed to build Statement:\\n{0}\", \"No Clauses\"));\n    this.clauses.sort((c1, c2) => {\n      return c1.getPriority() - c2.getPriority();\n    });\n\n    const errors = this.hasErrors();\n    if (errors)\n      throw new QueryError(\n        sf(\"Poorly built statement: {0}\", errors.toString())\n      );\n\n    let query: Q;\n    try {\n      const iterator = function (\n        clauses: Clause<any>[],\n        previous: any = {}\n      ): Q {\n        const c = clauses.shift();\n        if (!c) return previous as Q;\n        const results = c.build(previous);\n        return iterator(clauses, results as any);\n      };\n\n      query = iterator(new Array(...(this.clauses as Clause<Q>[]))) as Q;\n    } catch (e: any) {\n      throw new QueryError(e);\n    }\n\n    return query;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  async execute<Y>(): Promise<Y> {\n    try {\n      const query: Q = this.build();\n      return this.raw(query);\n    } catch (e: any) {\n      throw new InternalError(e);\n    }\n  }\n\n  async raw<R>(rawInput: Q, ...args: any[]): Promise<R> {\n    const results = await this.adapter.raw<R>(rawInput, ...args);\n    if (!this.fullRecord) return results;\n    if (!this.target)\n      throw new InternalError(\n        \"No target defined in statement. should never happen\"\n      );\n\n    const pkAttr = findPrimaryKey(new this.target() as any).id;\n\n    const processor = function recordProcessor(this: Statement<Q>, r: any) {\n      const id = r[pkAttr];\n      return this.adapter.revert(\n        r,\n        this.target as Constructor<any>,\n        pkAttr,\n        id\n      ) as any;\n    }.bind(this);\n\n    if (Array.isArray(results)) return results.map(processor) as R;\n    return processor(results) as R;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  hasErrors(...exceptions: string[]): ModelErrorDefinition | undefined {\n    const errors = super.hasErrors(...exceptions);\n    if (errors) return errors;\n\n    for (const i in this.clauses) {\n      const err = this.clauses[i as any].hasErrors();\n      if (err) return err;\n    }\n  }\n\n  /**\n   * @summary Adds a clause to the Statement\n   * @param {Clause} clause\n   */\n  addClause(clause: Clause<Q>) {\n    if (!this.clauses) this.clauses = [];\n\n    const priority = clause.getPriority();\n    const currentPriority = this.clauses\n      .map((c, i) => ({ index: i, clause: c }))\n      .find((c) => c.clause.getPriority() === priority);\n    if (currentPriority) {\n      this.clauses[currentPriority.index] = clause;\n    }\n    this.clauses.push(clause);\n  }\n\n  getAdapter(): Adapter<any, Q> {\n    return this.adapter;\n  }\n\n  /**\n   * @summary Defines the output class (when existing)\n   * @param {Constructor} clazz\n   */\n  setTarget(clazz: Constructor<any>) {\n    if (this.target)\n      throw new QueryError(\n        sf(\"Output class already defined to {0}\", this.target!.name)\n      );\n    this.target = clazz;\n  }\n\n  setFullRecord() {\n    this.fullRecord = true;\n  }\n\n  setMode(type: StatementType) {\n    this.type = type;\n  }\n}\n"]}

package/lib/query/Statement.d.ts

@@ -0,0 +1,49 @@
+import { Constructor, Model, ModelErrorDefinition } from "@decaf-ts/decorator-validation";
+import { Executor, RawExecutor } from "../interfaces";
+import { StatementType } from "./constants";
+import { Clause } from "./Clause";
+import { Adapter } from "../persistence";
+/**
+ * @summary Statement Class
+ * @description holds all the clauses until they can be processed
+ *
+ * @param {ModelArg} [statement]
+ *
+ * @class Statement
+ * @extends Model
+ * @implements Executor
+ * @implements RawExecutor
+ *
+ * @category Query
+ */
+export declare abstract class Statement<Q> extends Model implements Executor, RawExecutor<Q> {
+    protected clauses?: Clause<any>[];
+    protected adapter: Adapter<any, Q>;
+    protected target?: Constructor<any>;
+    protected fullRecord: boolean;
+    protected type?: string;
+    protected constructor(db: Adapter<any, Q>);
+    protected build(): Q;
+    /**
+     * @inheritDoc
+     */
+    execute<Y>(): Promise<Y>;
+    raw<R>(rawInput: Q, ...args: any[]): Promise<R>;
+    /**
+     * @inheritDoc
+     */
+    hasErrors(...exceptions: string[]): ModelErrorDefinition | undefined;
+    /**
+     * @summary Adds a clause to the Statement
+     * @param {Clause} clause
+     */
+    addClause(clause: Clause<Q>): void;
+    getAdapter(): Adapter<any, Q>;
+    /**
+     * @summary Defines the output class (when existing)
+     * @param {Constructor} clazz
+     */
+    setTarget(clazz: Constructor<any>): void;
+    setFullRecord(): void;
+    setMode(type: StatementType): void;
+}

package/lib/query/clauses/FromClause.cjs

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromClause = void 0;
+const constants_1 = require("../constants.cjs");
+const SelectorBasedClause_1 = require("./SelectorBasedClause.cjs");
+const errors_1 = require("../errors.cjs");
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+/**
+ * @summary The FROM clause
+ *
+ * @param {ModelArg} [clause]
+ *
+ * @class FromClause
+ * @extends SelectorBasedClause
+ * @implements WhereOption
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+class FromClause extends SelectorBasedClause_1.SelectorBasedClause {
+    constructor(clause) {
+        super(Object.assign({}, clause, { priority: constants_1.Priority.FROM }));
+        this.selector =
+            typeof this.selector === "string"
+                ? decorator_validation_1.Model.get(this.selector)
+                : this.selector;
+        if (!this.selector)
+            throw new errors_1.QueryError((0, decorator_validation_1.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);
+    }
+}
+exports.FromClause = FromClause;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/query/clauses/FromClause.d.ts

@@ -0,0 +1,45 @@
+import { FromSelector, GroupBySelector, LimitSelector, OffsetSelector, OrderBySelector } from "../selectors";
+import { LimitOption, OffsetOption, OrderAndGroupOption, WhereOption } from "../options";
+import { SelectorBasedClause } from "./SelectorBasedClause";
+import { Executor } from "../../interfaces";
+import { Condition } from "../Condition";
+import { Model, ModelArg } from "@decaf-ts/decorator-validation";
+/**
+ * @summary The FROM clause
+ *
+ * @param {ModelArg} [clause]
+ *
+ * @class FromClause
+ * @extends SelectorBasedClause
+ * @implements WhereOption
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export declare abstract class FromClause<Q, M extends Model> extends SelectorBasedClause<Q, FromSelector<M>> implements WhereOption {
+    protected constructor(clause?: ModelArg<FromClause<Q, M>>);
+    /**
+     * @inheritDoc
+     */
+    abstract build(query: Q): Q;
+    /**
+     * @inheritDoc
+     */
+    where(condition: Condition): OrderAndGroupOption;
+    /**
+     * @inheritDoc
+     */
+    orderBy(...selector: OrderBySelector[]): LimitOption & OffsetOption;
+    /**
+     * @inheritDoc
+     */
+    groupBy(selector: GroupBySelector): Executor;
+    /**
+     * @inheritDoc
+     */
+    limit(selector: LimitSelector): OffsetOption;
+    /**
+     * @inheritDoc
+     */
+    offset(selector: OffsetSelector): Executor;
+}

package/lib/query/clauses/GroupByClause.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupByClause = void 0;
+const constants_1 = require("../constants.cjs");
+const SelectorBasedClause_1 = require("./SelectorBasedClause.cjs");
+/**
+ * @summary The GROUP BY clause
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class GroupByClause
+ * @extends SelectorBasedClause
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+class GroupByClause extends SelectorBasedClause_1.SelectorBasedClause {
+    constructor(clause) {
+        super(Object.assign({}, clause, { priority: constants_1.Priority.GROUP_BY }));
+    }
+}
+exports.GroupByClause = GroupByClause;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9xdWVyeS9jbGF1c2VzL0dyb3VwQnlDbGF1c2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRUEsNENBQXdDO0FBQ3hDLCtEQUE0RDtBQUU1RDs7Ozs7Ozs7OztHQVVHO0FBQ0gsTUFBc0IsYUFBaUIsU0FBUSx5Q0FHOUM7SUFDQyxZQUFzQixNQUFtQztRQUN2RCxLQUFLLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxFQUFFLEVBQUUsTUFBTSxFQUFFLEVBQUUsUUFBUSxFQUFFLG9CQUFRLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ3BFLENBQUM7Q0FLRjtBQVhELHNDQVdDIiwiZmlsZSI6InF1ZXJ5L2NsYXVzZXMvR3JvdXBCeUNsYXVzZS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1vZGVsQXJnIH0gZnJvbSBcIkBkZWNhZi10cy9kZWNvcmF0b3ItdmFsaWRhdGlvblwiO1xuaW1wb3J0IHsgR3JvdXBCeVNlbGVjdG9yIH0gZnJvbSBcIi4uL3NlbGVjdG9yc1wiO1xuaW1wb3J0IHsgUHJpb3JpdHkgfSBmcm9tIFwiLi4vY29uc3RhbnRzXCI7XG5pbXBvcnQgeyBTZWxlY3RvckJhc2VkQ2xhdXNlIH0gZnJvbSBcIi4vU2VsZWN0b3JCYXNlZENsYXVzZVwiO1xuXG4vKipcbiAqIEBzdW1tYXJ5IFRoZSBHUk9VUCBCWSBjbGF1c2VcbiAqXG4gKiBAcGFyYW0ge0NsYXVzZUFyZ30gW2NsYXVzZV1cbiAqXG4gKiBAY2xhc3MgR3JvdXBCeUNsYXVzZVxuICogQGV4dGVuZHMgU2VsZWN0b3JCYXNlZENsYXVzZVxuICpcbiAqIEBjYXRlZ29yeSBRdWVyeVxuICogQHN1YmNhdGVnb3J5IENsYXVzZXNcbiAqL1xuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEdyb3VwQnlDbGF1c2U8UT4gZXh0ZW5kcyBTZWxlY3RvckJhc2VkQ2xhdXNlPFxuICBRLFxuICBHcm91cEJ5U2VsZWN0b3Jcbj4ge1xuICBwcm90ZWN0ZWQgY29uc3RydWN0b3IoY2xhdXNlPzogTW9kZWxBcmc8R3JvdXBCeUNsYXVzZTxRPj4pIHtcbiAgICBzdXBlcihPYmplY3QuYXNzaWduKHt9LCBjbGF1c2UsIHsgcHJpb3JpdHk6IFByaW9yaXR5LkdST1VQX0JZIH0pKTtcbiAgfVxuICAvKipcbiAgICogQGluaGVyaXREb2NcbiAgICovXG4gIGFic3RyYWN0IGJ1aWxkKHF1ZXJ5OiBRKTogUTtcbn1cbiJdfQ==

package/lib/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/query/clauses/InsertClause.cjs

@@ -0,0 +1,60 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsertClause = void 0;
+const constants_1 = require("../constants.cjs");
+const Clause_1 = require("../Clause.cjs");
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+/**
+ * @summary The INSERT/INTO clause
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class FromClause
+ * @extends Clause
+ * @implements IntoOption
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+class InsertClause extends Clause_1.Clause {
+    constructor(clause) {
+        super(Object.assign({}, clause, { priority: constants_1.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);
+    }
+}
+exports.InsertClause = InsertClause;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    __metadata("design:type", String)
+], InsertClause.prototype, "table", void 0);
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/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/query/clauses/LimitClause.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LimitClause = void 0;
+const SelectorBasedClause_1 = require("./SelectorBasedClause.cjs");
+const constants_1 = require("../constants.cjs");
+/**
+ * @summary Limit Clause
+ * @description Limits the results
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class LimitClause
+ * @extends SelectorBasedClause<T>
+ * @implements OffsetOption<T>
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+class LimitClause extends SelectorBasedClause_1.SelectorBasedClause {
+    constructor(clause) {
+        super(Object.assign({}, clause, { priority: constants_1.Priority.GROUP_BY }));
+    }
+    /**
+     * @inheritDoc
+     */
+    offset(selector) {
+        return this.Clauses.offset(this.statement, selector);
+    }
+}
+exports.LimitClause = LimitClause;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/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/query/clauses/OffsetClause.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OffsetClause = void 0;
+const SelectorBasedClause_1 = require("./SelectorBasedClause.cjs");
+const constants_1 = require("../constants.cjs");
+/**
+ * @summary The OFFSET clause
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class FromClause
+ * @extends SelectorBasedClause
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+class OffsetClause extends SelectorBasedClause_1.SelectorBasedClause {
+    constructor(clause) {
+        super(Object.assign({}, clause, { priority: constants_1.Priority.GROUP_BY }));
+    }
+}
+exports.OffsetClause = OffsetClause;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9xdWVyeS9jbGF1c2VzL09mZnNldENsYXVzZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwrREFBNEQ7QUFFNUQsNENBQXdDO0FBR3hDOzs7Ozs7Ozs7O0dBVUc7QUFDSCxNQUFzQixZQUFnQixTQUFRLHlDQUc3QztJQUNDLFlBQXNCLE1BQWtDO1FBQ3RELEtBQUssQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLEVBQUUsRUFBRSxNQUFNLEVBQUUsRUFBRSxRQUFRLEVBQUUsb0JBQVEsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFDcEUsQ0FBQztDQUtGO0FBWEQsb0NBV0MiLCJmaWxlIjoicXVlcnkvY2xhdXNlcy9PZmZzZXRDbGF1c2UuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTZWxlY3RvckJhc2VkQ2xhdXNlIH0gZnJvbSBcIi4vU2VsZWN0b3JCYXNlZENsYXVzZVwiO1xuaW1wb3J0IHsgT2Zmc2V0U2VsZWN0b3IgfSBmcm9tIFwiLi4vc2VsZWN0b3JzXCI7XG5pbXBvcnQgeyBQcmlvcml0eSB9IGZyb20gXCIuLi9jb25zdGFudHNcIjtcbmltcG9ydCB7IE1vZGVsQXJnIH0gZnJvbSBcIkBkZWNhZi10cy9kZWNvcmF0b3ItdmFsaWRhdGlvblwiO1xuXG4vKipcbiAqIEBzdW1tYXJ5IFRoZSBPRkZTRVQgY2xhdXNlXG4gKlxuICogQHBhcmFtIHtDbGF1c2VBcmd9IFtjbGF1c2VdXG4gKlxuICogQGNsYXNzIEZyb21DbGF1c2VcbiAqIEBleHRlbmRzIFNlbGVjdG9yQmFzZWRDbGF1c2VcbiAqXG4gKiBAY2F0ZWdvcnkgUXVlcnlcbiAqIEBzdWJjYXRlZ29yeSBDbGF1c2VzXG4gKi9cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBPZmZzZXRDbGF1c2U8UT4gZXh0ZW5kcyBTZWxlY3RvckJhc2VkQ2xhdXNlPFxuICBRLFxuICBPZmZzZXRTZWxlY3RvclxuPiB7XG4gIHByb3RlY3RlZCBjb25zdHJ1Y3RvcihjbGF1c2U/OiBNb2RlbEFyZzxPZmZzZXRDbGF1c2U8UT4+KSB7XG4gICAgc3VwZXIoT2JqZWN0LmFzc2lnbih7fSwgY2xhdXNlLCB7IHByaW9yaXR5OiBQcmlvcml0eS5HUk9VUF9CWSB9KSk7XG4gIH1cbiAgLyoqXG4gICAqIEBpbmhlcml0RG9jXG4gICAqL1xuICBhYnN0cmFjdCBidWlsZChxdWVyeTogUSk6IFE7XG59XG4iXX0=

package/lib/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;
+}