@decaf-ts/core 0.1.2 → 0.2.0

package/lib/esm/query/Condition.js

@@ -0,0 +1,248 @@
+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 { Model, required, sf, } from "@decaf-ts/decorator-validation";
+import { GroupOperator, Operator } from "./constants";
+import { QueryError } from "./errors";
+/**
+ * @summary Condition Class
+ * @description Represents a logical condition
+ *
+ * @param {string | Condition} attr1
+ * @param {Operator | GroupOperator} operator
+ * @param {string | Condition} comparison
+ *
+ * @class Condition
+ * @implements Executor
+ *
+ * @category Query
+ * @subcategory Conditions
+ */
+export class Condition extends Model {
+    constructor(attr1, operator, comparison) {
+        super();
+        this.attr1 = undefined;
+        this.operator = undefined;
+        this.comparison = undefined;
+        this.attr1 = attr1;
+        this.operator = operator;
+        this.comparison = comparison;
+    }
+    /**
+     * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation
+     * @param {Condition} condition
+     */
+    and(condition) {
+        return Condition.and(this, condition);
+    }
+    /**
+     * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation
+     * @param {Condition} condition
+     */
+    or(condition) {
+        return Condition.or(this, condition);
+    }
+    /**
+     * @summary excludes a valut from the result
+     * @param val
+     */
+    not(val) {
+        return new Condition(this, Operator.NOT, val);
+    }
+    /**
+     * @inheritDoc
+     */
+    hasErrors(...exceptions) {
+        const errors = super.hasErrors(...exceptions);
+        if (errors)
+            return errors;
+        if (typeof this.attr1 === "string") {
+            if (this.comparison instanceof Condition)
+                return {
+                    comparison: {
+                        condition: "Both sides of the comparison must be of the same type",
+                    },
+                };
+            if (Object.values(Operator).indexOf(this.operator) === -1)
+                return {
+                    operator: {
+                        condition: sf("Invalid operator {0}", this.operator),
+                    },
+                };
+        }
+        if (this.attr1 instanceof Condition) {
+            if (!(this.comparison instanceof Condition) &&
+                this.operator !== Operator.NOT)
+                return {
+                    comparison: {
+                        condition: sf("Invalid operator {0}", this.operator),
+                    },
+                };
+            if (Object.values(GroupOperator).indexOf(this.operator) ===
+                -1 &&
+                this.operator !== Operator.NOT)
+                return {
+                    operator: {
+                        condition: sf("Invalid operator {0}", this.operator),
+                    },
+                };
+            // if (this.operator !== Operator.NOT && typeof this.attr1.attr1 !== "string")
+            //     return {
+            //         attr1: {
+            //             condition: stringFormat("Parent condition attribute must be a string")
+            //         }
+            //     } as ModelErrorDefinition
+        }
+    }
+    /**
+     * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation
+     * @param {Condition} condition1
+     * @param {Condition} condition2
+     */
+    static and(condition1, condition2) {
+        return Condition.group(condition1, GroupOperator.AND, condition2);
+    }
+    /**
+     * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation
+     * @param {Condition} condition1
+     * @param {Condition} condition2
+     */
+    static or(condition1, condition2) {
+        return Condition.group(condition1, GroupOperator.OR, condition2);
+    }
+    /**
+     * @summary Groups 2 {@link Condition}s by the specified {@link GroupOperator}
+     * @param {Condition} condition1
+     * @param {GroupOperator} operator
+     * @param {Condition} condition2
+     */
+    static group(condition1, operator, condition2) {
+        return new Condition(condition1, operator, condition2);
+    }
+    static attribute(attr) {
+        return new Condition.Builder().attribute(attr);
+    }
+    /**
+     * @summary Condition Builder Class
+     * @description provides a simple API to build {@link Condition}s
+     *
+     * @class ConditionBuilder
+     * @implements Builder
+     * @implements AttributeOption
+     *
+     * @category Query
+     * @subcategory Conditions
+     */
+    static { this.Builder = class ConditionBuilder {
+        constructor() {
+            this.attr1 = undefined;
+            this.operator = undefined;
+            this.comparison = undefined;
+        }
+        /**
+         * @inheritDoc
+         */
+        attribute(attr) {
+            this.attr1 = attr;
+            return this;
+        }
+        /**
+         * @summary Creates an Equality Comparison
+         * @param {any} val
+         */
+        eq(val) {
+            return this.setOp(Operator.EQUAL, val);
+        }
+        /**
+         * @summary Creates a Different Comparison
+         * @param {any} val
+         */
+        dif(val) {
+            return this.setOp(Operator.DIFFERENT, val);
+        }
+        /**
+         * @summary Creates a Greater Than Comparison
+         * @param {any} val
+         */
+        gt(val) {
+            return this.setOp(Operator.BIGGER, val);
+        }
+        /**
+         * @summary Creates a Lower Than Comparison
+         * @param {any} val
+         */
+        lt(val) {
+            return this.setOp(Operator.SMALLER, val);
+        }
+        /**
+         * @summary Creates a Greater or Equal to Comparison
+         * @param {any} val
+         */
+        gte(val) {
+            return this.setOp(Operator.BIGGER_EQ, val);
+        }
+        /**
+         * @summary Creates a Lower or Equal to Comparison
+         * @param {any} val
+         */
+        lte(val) {
+            return this.setOp(Operator.SMALLER_EQ, val);
+        }
+        in(arr) {
+            return this.setOp(Operator.IN, arr);
+        }
+        /**
+         * @summary Creates a Regexpo Comparison
+         * @param {any} val
+         */
+        regexp(val) {
+            return this.setOp(Operator.REGEXP, typeof val === "string" ? new RegExp(val) : val);
+        }
+        /**
+         * @summary Creates an {@link Operator} based Comparison
+         * @param {Operator} op
+         * @param {any} val
+         */
+        setOp(op, val) {
+            this.operator = op;
+            this.comparison = val;
+            return this.build();
+        }
+        /**
+         * @summary Builds the Database Object
+         * @throws {QueryError} if it fails to build the {@link Condition}
+         * @private
+         */
+        build() {
+            try {
+                return new Condition(this.attr1, this.operator, this.comparison);
+            }
+            catch (e) {
+                throw new QueryError(e);
+            }
+        }
+    }; }
+    static get builder() {
+        return new Condition.Builder();
+    }
+}
+__decorate([
+    required(),
+    __metadata("design:type", Object)
+], Condition.prototype, "attr1", void 0);
+__decorate([
+    required(),
+    __metadata("design:type", String)
+], Condition.prototype, "operator", void 0);
+__decorate([
+    required(),
+    __metadata("design:type", Object)
+], Condition.prototype, "comparison", void 0);
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/query/Condition.ts"],"names":[],"mappings":"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","file":"query/Condition.js","sourcesContent":["import { AttributeOption, ConditionBuilderOption } from \"./options\";\nimport {\n  Model,\n  ModelErrorDefinition,\n  required,\n  sf,\n} from \"@decaf-ts/decorator-validation\";\nimport { GroupOperator, Operator } from \"./constants\";\nimport { QueryError } from \"./errors\";\n\n/**\n * @summary Condition Class\n * @description Represents a logical condition\n *\n * @param {string | Condition} attr1\n * @param {Operator | GroupOperator} operator\n * @param {string | Condition} comparison\n *\n * @class Condition\n * @implements Executor\n *\n * @category Query\n * @subcategory Conditions\n */\n\nexport class Condition extends Model {\n  @required()\n  protected attr1?: string | Condition = undefined;\n  @required()\n  protected operator?: Operator | GroupOperator = undefined;\n  @required()\n  protected comparison?: any = undefined;\n\n  private constructor(\n    attr1: string | Condition,\n    operator: Operator | GroupOperator,\n    comparison: any,\n  ) {\n    super();\n    this.attr1 = attr1;\n    this.operator = operator;\n    this.comparison = comparison;\n  }\n\n  /**\n   * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation\n   * @param {Condition} condition\n   */\n  and(condition: Condition): Condition {\n    return Condition.and(this, condition);\n  }\n\n  /**\n   * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation\n   * @param {Condition} condition\n   */\n  or(condition: Condition): Condition {\n    return Condition.or(this, condition);\n  }\n\n  /**\n   * @summary excludes a valut from the result\n   * @param val\n   */\n  not(val: any): Condition {\n    return new Condition(this, Operator.NOT, val);\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    if (typeof this.attr1 === \"string\") {\n      if (this.comparison instanceof Condition)\n        return {\n          comparison: {\n            condition: \"Both sides of the comparison must be of the same type\",\n          },\n        } as ModelErrorDefinition;\n      if (Object.values(Operator).indexOf(this.operator as Operator) === -1)\n        return {\n          operator: {\n            condition: sf(\"Invalid operator {0}\", this.operator as string),\n          },\n        } as ModelErrorDefinition;\n    }\n\n    if (this.attr1 instanceof Condition) {\n      if (\n        !(this.comparison instanceof Condition) &&\n        this.operator !== Operator.NOT\n      )\n        return {\n          comparison: {\n            condition: sf(\"Invalid operator {0}\", this.operator as string),\n          },\n        } as ModelErrorDefinition;\n      if (\n        Object.values(GroupOperator).indexOf(this.operator as GroupOperator) ===\n          -1 &&\n        this.operator !== Operator.NOT\n      )\n        return {\n          operator: {\n            condition: sf(\"Invalid operator {0}\", this.operator as string),\n          },\n        } as ModelErrorDefinition;\n      // if (this.operator !== Operator.NOT && typeof this.attr1.attr1 !== \"string\")\n      //     return {\n      //         attr1: {\n      //             condition: stringFormat(\"Parent condition attribute must be a string\")\n      //         }\n      //     } as ModelErrorDefinition\n    }\n  }\n\n  /**\n   * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation\n   * @param {Condition} condition1\n   * @param {Condition} condition2\n   */\n  static and(condition1: Condition, condition2: Condition): Condition {\n    return Condition.group(condition1, GroupOperator.AND, condition2);\n  }\n\n  /**\n   * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation\n   * @param {Condition} condition1\n   * @param {Condition} condition2\n   */\n  static or(condition1: Condition, condition2: Condition): Condition {\n    return Condition.group(condition1, GroupOperator.OR, condition2);\n  }\n\n  /**\n   * @summary Groups 2 {@link Condition}s by the specified {@link GroupOperator}\n   * @param {Condition} condition1\n   * @param {GroupOperator} operator\n   * @param {Condition} condition2\n   */\n  private static group(\n    condition1: Condition,\n    operator: GroupOperator,\n    condition2: Condition,\n  ): Condition {\n    return new Condition(condition1, operator, condition2);\n  }\n\n  static attribute(attr: string) {\n    return new Condition.Builder().attribute(attr);\n  }\n\n  /**\n   * @summary Condition Builder Class\n   * @description provides a simple API to build {@link Condition}s\n   *\n   * @class ConditionBuilder\n   * @implements Builder\n   * @implements AttributeOption\n   *\n   * @category Query\n   * @subcategory Conditions\n   */\n  private static Builder = class ConditionBuilder\n    implements ConditionBuilderOption, AttributeOption\n  {\n    attr1?: string | Condition = undefined;\n    operator?: Operator | GroupOperator = undefined;\n    comparison?: any = undefined;\n\n    /**\n     * @inheritDoc\n     */\n    attribute(attr: string): AttributeOption {\n      this.attr1 = attr;\n      return this;\n    }\n\n    /**\n     * @summary Creates an Equality Comparison\n     * @param {any} val\n     */\n    eq(val: any) {\n      return this.setOp(Operator.EQUAL, val);\n    }\n\n    /**\n     * @summary Creates a Different Comparison\n     * @param {any} val\n     */\n    dif(val: any) {\n      return this.setOp(Operator.DIFFERENT, val);\n    }\n\n    /**\n     * @summary Creates a Greater Than Comparison\n     * @param {any} val\n     */\n    gt(val: any) {\n      return this.setOp(Operator.BIGGER, val);\n    }\n\n    /**\n     * @summary Creates a Lower Than Comparison\n     * @param {any} val\n     */\n    lt(val: any) {\n      return this.setOp(Operator.SMALLER, val);\n    }\n\n    /**\n     * @summary Creates a Greater or Equal to Comparison\n     * @param {any} val\n     */\n    gte(val: any) {\n      return this.setOp(Operator.BIGGER_EQ, val);\n    }\n\n    /**\n     * @summary Creates a Lower or Equal to Comparison\n     * @param {any} val\n     */\n    lte(val: any) {\n      return this.setOp(Operator.SMALLER_EQ, val);\n    }\n\n    in(arr: any[]) {\n      return this.setOp(Operator.IN, arr);\n    }\n\n    /**\n     * @summary Creates a Regexpo Comparison\n     * @param {any} val\n     */\n    regexp(val: any) {\n      return this.setOp(\n        Operator.REGEXP,\n        typeof val === \"string\" ? new RegExp(val) : val,\n      );\n    }\n\n    /**\n     * @summary Creates an {@link Operator} based Comparison\n     * @param {Operator} op\n     * @param {any} val\n     */\n    private setOp(op: Operator, val: any) {\n      this.operator = op;\n      this.comparison = val;\n      return this.build();\n    }\n\n    /**\n     * @summary Builds the Database Object\n     * @throws {QueryError} if it fails to build the {@link Condition}\n     * @private\n     */\n    private build(): Condition {\n      try {\n        return new Condition(\n          this.attr1 as string | Condition,\n          this.operator as Operator,\n          this.comparison as any,\n        );\n      } catch (e: any) {\n        throw new QueryError(e);\n      }\n    }\n  };\n\n  static get builder(): ConditionBuilderOption {\n    return new Condition.Builder();\n  }\n}\n"]}

package/lib/esm/query/Query.d.ts

@@ -0,0 +1,43 @@
+import { CountOption, DistinctOption, InsertOption, MaxOption, MinOption, SelectOption } from "./options";
+import { SelectSelector } from "./selectors";
+import { Adapter } from "../persistence";
+import { Model } from "@decaf-ts/decorator-validation";
+/**
+ * @summary Helper Class to build queries
+ *
+ * @param {Database} db
+ *
+ * @class Query
+ *
+ * @category Query
+ */
+export declare class Query<Q, M extends Model> {
+    private adapter;
+    constructor(adapter: Adapter<any, Q>);
+    /**
+     * @summary Creates a Select Clause
+     * @param {SelectSelector} [selector]
+     */
+    select(selector?: SelectSelector): SelectOption<M>;
+    /**
+     * @summary Creates a Min Clause
+     * @param {SelectSelector} selector
+     */
+    min(selector: SelectSelector): MinOption<M>;
+    /**
+     * @summary Creates a Max Clause
+     * @param {SelectSelector} selector
+     */
+    max(selector: SelectSelector): MaxOption<M>;
+    /**
+     * @summary Creates a Distinct Clause
+     * @param {SelectSelector} selector
+     */
+    distinct(selector: SelectSelector): DistinctOption<M>;
+    /**
+     * @summary Creates a Count Clause
+     * @param {SelectSelector} selector
+     */
+    count(selector: SelectSelector): CountOption<M>;
+    insert(): InsertOption<M>;
+}

package/lib/esm/query/Query.js

@@ -0,0 +1,55 @@
+import { Const } from "./constants";
+/**
+ * @summary Helper Class to build queries
+ *
+ * @param {Database} db
+ *
+ * @class Query
+ *
+ * @category Query
+ */
+export class Query {
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    /**
+     * @summary Creates a Select Clause
+     * @param {SelectSelector} [selector]
+     */
+    select(selector = Const.FULL_RECORD) {
+        return this.adapter.Clauses.select(selector);
+    }
+    /**
+     * @summary Creates a Min Clause
+     * @param {SelectSelector} selector
+     */
+    min(selector) {
+        return this.select().min(selector);
+    }
+    /**
+     * @summary Creates a Max Clause
+     * @param {SelectSelector} selector
+     */
+    max(selector) {
+        return this.select().max(selector);
+    }
+    /**
+     * @summary Creates a Distinct Clause
+     * @param {SelectSelector} selector
+     */
+    distinct(selector) {
+        return this.select().distinct(selector);
+    }
+    /**
+     * @summary Creates a Count Clause
+     * @param {SelectSelector} selector
+     */
+    count(selector) {
+        return this.select().count(selector);
+    }
+    insert() {
+        return this.adapter.Clauses.insert();
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/esm/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/esm/query/Statement.js

@@ -0,0 +1,163 @@
+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 { minlength, Model, required, type, sf, } from "@decaf-ts/decorator-validation";
+import { MandatoryPriorities } from "./constants";
+import { QueryError } from "./errors";
+import { clauseSequence } from "../validators";
+import { Adapter } from "../persistence";
+import { findPrimaryKey, InternalError } from "@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
+ */
+export class Statement extends 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 QueryError(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 QueryError(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 QueryError(e);
+        }
+        return query;
+    }
+    /**
+     * @inheritDoc
+     */
+    async execute() {
+        const query = this.build();
+        try {
+            const results = (await this.raw(query));
+            if (!this.fullRecord)
+                return results;
+            return Array.isArray(results)
+                ? results.map((el) => new this.target(el))
+                : new this.target(results);
+        }
+        catch (e) {
+            throw new InternalError(e);
+        }
+    }
+    async raw(rawInput, ...args) {
+        const results = await this.adapter.raw(rawInput, ...args);
+        if (!this.fullRecord)
+            return results;
+        if (!this.target)
+            throw new InternalError("No target defined in statement. should never happen");
+        const pkAttr = 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 QueryError(sf("Output class already defined to {0}", this.target.name));
+        this.target = clazz;
+    }
+    setFullRecord() {
+        this.fullRecord = true;
+    }
+    setMode(type) {
+        this.type = type;
+    }
+}
+__decorate([
+    required(),
+    minlength(MandatoryPriorities.length),
+    clauseSequence(),
+    __metadata("design:type", Array)
+], Statement.prototype, "clauses", void 0);
+__decorate([
+    required(),
+    type(["object"]),
+    __metadata("design:type", Adapter)
+], Statement.prototype, "adapter", void 0);
+__decorate([
+    required(),
+    __metadata("design:type", Object)
+], Statement.prototype, "target", void 0);
+__decorate([
+    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\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    const query: Q = this.build();\n    try {\n      const results: Y = (await this.raw(query)) as Y;\n      if (!this.fullRecord) return results;\n      return Array.isArray(results)\n        ? results.map((el) => new (this.target as Constructor<any>)(el))\n        : new (this.target as Constructor<any>)(results);\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/esm/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;
+}