@decaf-ts/core 0.1.3 → 0.2.1

package/lib/query/constants.d.ts

@@ -0,0 +1,79 @@
+export declare enum Operator {
+    EQUAL = "EQUAL",
+    DIFFERENT = "DIFFERENT",
+    BIGGER = "BIGGER",
+    BIGGER_EQ = "BIGGER_EQ",
+    SMALLER = "SMALLER",
+    SMALLER_EQ = "SMALLER_EQ",
+    NOT = "NOT",
+    IN = "IN",
+    REGEXP = "REGEXP"
+}
+export declare enum GroupOperator {
+    AND = "AND",
+    OR = "OR"
+}
+export declare enum Const {
+    NULL = "NULL",
+    FULL_RECORD = "*"
+}
+/**
+ * @summary Defines execution order of Clauses in statements as defined in SQL.
+ *
+ * @description sub priorities where defined to better organize clauses within statements, eg From and Join Clauses
+ *
+ * @const Priority
+ *
+ * @category Clauses
+ * @subcategory Constants
+ */
+export declare enum Priority {
+    /**
+     * @summary Defines the priority for the FROM Clause
+     * @description From Clause in SELECT Statements.
+     * Values Clause in INSERT Statements
+     *
+     * @prop FROM
+     */
+    FROM = 1,
+    /**
+     * @summary Defines the priority for the JOIN Clause
+     *
+     * @property {number} JOIN
+     */
+    JOIN = 1.1,
+    /**
+     * Where Clause
+     */
+    WHERE = 2,
+    /**
+     * Group By Clause
+     */
+    GROUP_BY = 3,
+    /**
+     * Having Clause
+     */
+    HAVING = 4,
+    /**
+     * Select Clause in SELECT Statements
+     * Insert Clause in INSERT Statements
+     */
+    SELECT = 5,
+    /**
+     * Order By Clause
+     */
+    ORDER_BY = 6,
+    /**
+     * Limit Clause
+     */
+    LIMIT = 7,
+    /**
+     * Offset Clause
+     */
+    OFFSET = 7.1
+}
+export declare const MandatoryPriorities: Priority[];
+export declare enum StatementType {
+    QUERY = "query",
+    TRANSACTION = "transaction"
+}

package/lib/query/errors.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryError = void 0;
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+class QueryError extends db_decorators_1.BaseError {
+    constructor(msg) {
+        super(QueryError.name, msg);
+    }
+}
+exports.QueryError = QueryError;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9xdWVyeS9lcnJvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsMkRBQW9EO0FBRXBELE1BQWEsVUFBVyxTQUFRLHlCQUFTO0lBQ3ZDLFlBQVksR0FBbUI7UUFDN0IsS0FBSyxDQUFDLFVBQVUsQ0FBQyxJQUFJLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDOUIsQ0FBQztDQUNGO0FBSkQsZ0NBSUMiLCJmaWxlIjoicXVlcnkvZXJyb3JzLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQmFzZUVycm9yIH0gZnJvbSBcIkBkZWNhZi10cy9kYi1kZWNvcmF0b3JzXCI7XG5cbmV4cG9ydCBjbGFzcyBRdWVyeUVycm9yIGV4dGVuZHMgQmFzZUVycm9yIHtcbiAgY29uc3RydWN0b3IobXNnOiBzdHJpbmcgfCBFcnJvcikge1xuICAgIHN1cGVyKFF1ZXJ5RXJyb3IubmFtZSwgbXNnKTtcbiAgfVxufVxuIl19

package/lib/query/errors.d.ts

@@ -0,0 +1,4 @@
+import { BaseError } from "@decaf-ts/db-decorators";
+export declare class QueryError extends BaseError {
+    constructor(msg: string | Error);
+}

package/lib/query/index.cjs

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./clauses/index.cjs"), exports);
+__exportStar(require("./Clause.cjs"), exports);
+__exportStar(require("./ClauseFactory.cjs"), exports);
+__exportStar(require("./Condition.cjs"), exports);
+__exportStar(require("./constants.cjs"), exports);
+__exportStar(require("./errors.cjs"), exports);
+__exportStar(require("./options.cjs"), exports);
+__exportStar(require("./Query.cjs"), exports);
+__exportStar(require("./selectors.cjs"), exports);
+__exportStar(require("./Statement.cjs"), exports);
+__exportStar(require("./types.cjs"), exports);
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9xdWVyeS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsNENBQTBCO0FBQzFCLDJDQUF5QjtBQUN6QixrREFBZ0M7QUFDaEMsOENBQTRCO0FBQzVCLDhDQUE0QjtBQUM1QiwyQ0FBeUI7QUFDekIsNENBQTBCO0FBQzFCLDBDQUF3QjtBQUN4Qiw4Q0FBNEI7QUFDNUIsOENBQTRCO0FBQzVCLDBDQUF3QiIsImZpbGUiOiJxdWVyeS9pbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2NsYXVzZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0NsYXVzZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vQ2xhdXNlRmFjdG9yeVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vQ29uZGl0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2Vycm9yc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vb3B0aW9uc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vUXVlcnlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NlbGVjdG9yc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vU3RhdGVtZW50XCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuIl19

package/lib/query/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./clauses";
+export * from "./Clause";
+export * from "./ClauseFactory";
+export * from "./Condition";
+export * from "./constants";
+export * from "./errors";
+export * from "./options";
+export * from "./Query";
+export * from "./selectors";
+export * from "./Statement";
+export * from "./types";

package/lib/query/options.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/query/options.ts"],"names":[],"mappings":"","file":"query/options.js","sourcesContent":["/* eslint-disable @typescript-eslint/no-empty-object-type */\nimport {\n  GroupBySelector,\n  LimitSelector,\n  OffsetSelector,\n  OrderBySelector,\n  SelectSelector,\n} from \"./selectors\";\nimport { Executor } from \"../interfaces\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { Condition } from \"./Condition\";\n\n/**\n * @summary Statement Builder interface\n * @description Exposes the final method to build the statement\n *\n * @typedef Q The query object type to build\n * @interface QueryBuilder\n *\n * @category Query\n * @subcategory Options\n *\n */\nexport interface QueryBuilder<Q> extends Executor {\n  /**\n   * Method to build and validate the prepared statement before the execution;\n   *\n   * @throws {QueryError}  for invalid statements\n   * @method\n   */\n  build(previous: Q): Q;\n}\n\n/**\n * @summary GroupBy Option interface\n * @description Exposes the GROUP BY method and remaining options\n *\n * @interface GroupByOption\n * @extends QueryBuilder\n *\n * @category Query\n * @subcategory Options\n */\nexport interface GroupByOption extends Executor {\n  /**\n   * @summary Groups records by an attribute\n   *\n   * @param {GroupBySelector} selector\n   * @method\n   */\n  groupBy(selector: GroupBySelector): Executor;\n}\n/**\n * @summary Offset Option interface\n * @description Exposes the OFFSET method and remaining options\n *\n * @interface GroupByOption\n * @extends QueryBuilder\n *\n * @category Query\n * @subcategory Options\n */\nexport interface OffsetOption extends Executor {\n  /**\n   * @summary Offsets the results by the provided selector\n   *\n   * @param {OffsetSelector} selector\n   * @method\n   */\n  offset(selector: OffsetSelector): Executor;\n}\n/**\n * @summary Limit Option interface\n * @description Exposes the LIMIT method and remaining options\n *\n * @interface LimitOption\n * @extends QueryBuilder\n *\n * @category Query\n * @subcategory Options\n */\nexport interface LimitOption extends Executor {\n  /**\n   * @summary Limits the results to the provided number\n   *\n   * @param {LimitSelector} selector\n   * @method\n   */\n  limit(selector: LimitSelector): OffsetOption;\n}\n/**\n * @summary OrderpBy Option interface\n * @description Exposes the ORDER BY method and remaining options\n *\n * @interface OrderByOption\n * @extends QueryBuilder\n *\n * @category Query\n * @subcategory Options\n */\nexport interface OrderByOption extends Executor {\n  /**\n   * @summary Orders the results by the provided attribute and according to the provided direction\n   *\n   * @param {OrderBySelector} selector\n   * @method\n   */\n  orderBy(...selector: OrderBySelector[]): LimitOption & OffsetOption;\n}\n/**\n * @summary Groups several order and grouping options\n *\n * @interface OrderAndGroupOption\n * @extends OrderByOption\n * @extends GroupByOption\n * @extends LimitOption\n * @extends OffsetOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface OrderAndGroupOption\n  extends OrderByOption,\n    GroupByOption,\n    LimitOption,\n    OffsetOption {}\n/**\n * @summary Where Option interface\n * @description Exposes the WHERE method and remaining options\n *\n * @interface WhereOption\n * @extends OrderAndGroupOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface WhereOption extends OrderAndGroupOption {\n  /**\n   * @summary filter the records by a condition\n   *\n   * @param {Condition} condition\n   * @method\n   */\n  where(condition: Condition): OrderAndGroupOption;\n}\n\n/**\n * @summary From Option Interface\n * @description Exposes the FROM method and remaining options\n *\n * @interface FromOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface FromOption<M extends Model> {\n  /**\n   * @summary selects records from a table\n   *\n   * @param {Constructor} tableName\n   * @method\n   */\n  from(tableName: Constructor<M> | string): WhereOption;\n}\n\n/**\n * @summary Distinct Option Interface\n * @description Exposes the remaining options after a DISTINCT\n *\n * @interface DistinctOption\n * @extends FromOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface DistinctOption<M extends Model> extends FromOption<M> {}\n\n/**\n * @summary Max Option Interface\n * @description Exposes the remaining options after a MAX\n *\n * @interface MaxOption\n * @extends FromOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface MaxOption<M extends Model> extends FromOption<M> {}\n\n/**\n * @summary Min Option Interface\n * @description Exposes the remaining options after a MIN\n *\n * @interface MinOption\n * @extends FromOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface MinOption<M extends Model> extends FromOption<M> {}\n\n/**\n * @summary Count Option Interface\n * @description Exposes the remaining options after a COUNT\n *\n * @interface CountOption\n * @extends FromOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface CountOption<M extends Model> extends FromOption<M> {}\n\n/**\n * @summary Select Option Interface\n * @description Exposes the remaining options after a SELECT\n *\n * @interface SelectOption\n * @extends FromOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface SelectOption<M extends Model> extends FromOption<M> {\n  /**\n   * @summary selects distinct values\n   *\n   * @param {SelectSelector} selector\n   * @method\n   */\n  distinct(selector: SelectSelector): DistinctOption<M>;\n  /**\n   * @summary the maximum value\n   *\n   * @param {SelectSelector} selector\n   * @method\n   */\n  max(selector: SelectSelector): MaxOption<M>;\n  /**\n   * @summary selects the minimum value\n   *\n   * @param {SelectSelector} selector\n   * @method\n   */\n  min(selector: SelectSelector): MinOption<M>;\n  /**\n   * @summary counts the records\n   *\n   * @param {SelectSelector} selector\n   * @method\n   */\n  count(selector: SelectSelector): CountOption<M>;\n}\n\n/**\n * @summary Into Option Interface\n * @description Exposes the remaining options after an INTO\n *\n * @interface IntoOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface IntoOption<M extends Model> {\n  /**\n   * @summary sets the models to insert\n   *\n   * @param {T[]} models\n   * @method\n   */\n  values(...models: M[]): Executor;\n  /**\n   * @summary filter records to insert\n   *\n   * @param {Condition} condition\n   * @method\n   */\n  where(condition: Condition): Executor;\n}\n/**\n * @summary Valuest Option Interface\n * @description Exposes the remaining options after a VALUES\n *\n * @interface ValuesOption\n * @extends QueryBuilder\n *\n * @category Query\n * @subcategory Options\n */\nexport interface ValuesOption extends Executor {}\n/**\n * @summary Insert Option Interface\n * @description Exposes the remaining options after an INSERT\n *\n * @interface InsertOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface InsertOption<M extends Model> {\n  /**\n   * @summary selects the table to insert records into\n   *\n   * @param {string | Constructor} table\n   * @method\n   */\n  into(table: Constructor<M>): IntoOption<M>;\n}\n\n/**\n * @summary {@link Operator} Option Interface\n * @description Exposes the available operators for a {@link Condition}\n *\n * @interface AttributeOption\n *\n * @category Query\n * @subcategory Conditions\n */\nexport interface AttributeOption {\n  /**\n   * @summary Test equality\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  eq(val: any): Condition;\n  /**\n   * @summary Test difference\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  dif(val: any): Condition;\n  /**\n   * @summary Test greater than\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  gt(val: any): Condition;\n  /**\n   * @summary Test lower than\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  lt(val: any): Condition;\n  /**\n   * @summary Test greater or equal to\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  gte(val: any): Condition;\n  /**\n   * @summary Test lower or equal to\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  lte(val: any): Condition;\n  /**\n   * @summary Test value in a range of values\n   * @param {any[]} val\n   */\n  in(val: any[]): Condition;\n  /**\n   * @summary Test matches {@link RegExp}\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  regexp(val: string | RegExp): Condition;\n}\n/**\n * @summary The starting point for creating Conditions\n * @description Exposes the available operations for a {@link Condition}\n *\n * @interface ConditionBuilderOption\n *\n * @category Query\n * @subcategory Conditions\n */\nexport interface ConditionBuilderOption {\n  attribute(attr: string): AttributeOption;\n}\n"]}

package/lib/query/options.d.ts

@@ -0,0 +1,371 @@
+import { GroupBySelector, LimitSelector, OffsetSelector, OrderBySelector, SelectSelector } from "./selectors";
+import { Executor } from "../interfaces";
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+import { Condition } from "./Condition";
+/**
+ * @summary Statement Builder interface
+ * @description Exposes the final method to build the statement
+ *
+ * @typedef Q The query object type to build
+ * @interface QueryBuilder
+ *
+ * @category Query
+ * @subcategory Options
+ *
+ */
+export interface QueryBuilder<Q> extends Executor {
+    /**
+     * Method to build and validate the prepared statement before the execution;
+     *
+     * @throws {QueryError}  for invalid statements
+     * @method
+     */
+    build(previous: Q): Q;
+}
+/**
+ * @summary GroupBy Option interface
+ * @description Exposes the GROUP BY method and remaining options
+ *
+ * @interface GroupByOption
+ * @extends QueryBuilder
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface GroupByOption extends Executor {
+    /**
+     * @summary Groups records by an attribute
+     *
+     * @param {GroupBySelector} selector
+     * @method
+     */
+    groupBy(selector: GroupBySelector): Executor;
+}
+/**
+ * @summary Offset Option interface
+ * @description Exposes the OFFSET method and remaining options
+ *
+ * @interface GroupByOption
+ * @extends QueryBuilder
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface OffsetOption extends Executor {
+    /**
+     * @summary Offsets the results by the provided selector
+     *
+     * @param {OffsetSelector} selector
+     * @method
+     */
+    offset(selector: OffsetSelector): Executor;
+}
+/**
+ * @summary Limit Option interface
+ * @description Exposes the LIMIT method and remaining options
+ *
+ * @interface LimitOption
+ * @extends QueryBuilder
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface LimitOption extends Executor {
+    /**
+     * @summary Limits the results to the provided number
+     *
+     * @param {LimitSelector} selector
+     * @method
+     */
+    limit(selector: LimitSelector): OffsetOption;
+}
+/**
+ * @summary OrderpBy Option interface
+ * @description Exposes the ORDER BY method and remaining options
+ *
+ * @interface OrderByOption
+ * @extends QueryBuilder
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface OrderByOption extends Executor {
+    /**
+     * @summary Orders the results by the provided attribute and according to the provided direction
+     *
+     * @param {OrderBySelector} selector
+     * @method
+     */
+    orderBy(...selector: OrderBySelector[]): LimitOption & OffsetOption;
+}
+/**
+ * @summary Groups several order and grouping options
+ *
+ * @interface OrderAndGroupOption
+ * @extends OrderByOption
+ * @extends GroupByOption
+ * @extends LimitOption
+ * @extends OffsetOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface OrderAndGroupOption extends OrderByOption, GroupByOption, LimitOption, OffsetOption {
+}
+/**
+ * @summary Where Option interface
+ * @description Exposes the WHERE method and remaining options
+ *
+ * @interface WhereOption
+ * @extends OrderAndGroupOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface WhereOption extends OrderAndGroupOption {
+    /**
+     * @summary filter the records by a condition
+     *
+     * @param {Condition} condition
+     * @method
+     */
+    where(condition: Condition): OrderAndGroupOption;
+}
+/**
+ * @summary From Option Interface
+ * @description Exposes the FROM method and remaining options
+ *
+ * @interface FromOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface FromOption<M extends Model> {
+    /**
+     * @summary selects records from a table
+     *
+     * @param {Constructor} tableName
+     * @method
+     */
+    from(tableName: Constructor<M> | string): WhereOption;
+}
+/**
+ * @summary Distinct Option Interface
+ * @description Exposes the remaining options after a DISTINCT
+ *
+ * @interface DistinctOption
+ * @extends FromOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface DistinctOption<M extends Model> extends FromOption<M> {
+}
+/**
+ * @summary Max Option Interface
+ * @description Exposes the remaining options after a MAX
+ *
+ * @interface MaxOption
+ * @extends FromOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface MaxOption<M extends Model> extends FromOption<M> {
+}
+/**
+ * @summary Min Option Interface
+ * @description Exposes the remaining options after a MIN
+ *
+ * @interface MinOption
+ * @extends FromOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface MinOption<M extends Model> extends FromOption<M> {
+}
+/**
+ * @summary Count Option Interface
+ * @description Exposes the remaining options after a COUNT
+ *
+ * @interface CountOption
+ * @extends FromOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface CountOption<M extends Model> extends FromOption<M> {
+}
+/**
+ * @summary Select Option Interface
+ * @description Exposes the remaining options after a SELECT
+ *
+ * @interface SelectOption
+ * @extends FromOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface SelectOption<M extends Model> extends FromOption<M> {
+    /**
+     * @summary selects distinct values
+     *
+     * @param {SelectSelector} selector
+     * @method
+     */
+    distinct(selector: SelectSelector): DistinctOption<M>;
+    /**
+     * @summary the maximum value
+     *
+     * @param {SelectSelector} selector
+     * @method
+     */
+    max(selector: SelectSelector): MaxOption<M>;
+    /**
+     * @summary selects the minimum value
+     *
+     * @param {SelectSelector} selector
+     * @method
+     */
+    min(selector: SelectSelector): MinOption<M>;
+    /**
+     * @summary counts the records
+     *
+     * @param {SelectSelector} selector
+     * @method
+     */
+    count(selector: SelectSelector): CountOption<M>;
+}
+/**
+ * @summary Into Option Interface
+ * @description Exposes the remaining options after an INTO
+ *
+ * @interface IntoOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface IntoOption<M extends Model> {
+    /**
+     * @summary sets the models to insert
+     *
+     * @param {T[]} models
+     * @method
+     */
+    values(...models: M[]): Executor;
+    /**
+     * @summary filter records to insert
+     *
+     * @param {Condition} condition
+     * @method
+     */
+    where(condition: Condition): Executor;
+}
+/**
+ * @summary Valuest Option Interface
+ * @description Exposes the remaining options after a VALUES
+ *
+ * @interface ValuesOption
+ * @extends QueryBuilder
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface ValuesOption extends Executor {
+}
+/**
+ * @summary Insert Option Interface
+ * @description Exposes the remaining options after an INSERT
+ *
+ * @interface InsertOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface InsertOption<M extends Model> {
+    /**
+     * @summary selects the table to insert records into
+     *
+     * @param {string | Constructor} table
+     * @method
+     */
+    into(table: Constructor<M>): IntoOption<M>;
+}
+/**
+ * @summary {@link Operator} Option Interface
+ * @description Exposes the available operators for a {@link Condition}
+ *
+ * @interface AttributeOption
+ *
+ * @category Query
+ * @subcategory Conditions
+ */
+export interface AttributeOption {
+    /**
+     * @summary Test equality
+     *
+     * @param {any} val the value to test
+     * @method
+     */
+    eq(val: any): Condition;
+    /**
+     * @summary Test difference
+     *
+     * @param {any} val the value to test
+     * @method
+     */
+    dif(val: any): Condition;
+    /**
+     * @summary Test greater than
+     *
+     * @param {any} val the value to test
+     * @method
+     */
+    gt(val: any): Condition;
+    /**
+     * @summary Test lower than
+     *
+     * @param {any} val the value to test
+     * @method
+     */
+    lt(val: any): Condition;
+    /**
+     * @summary Test greater or equal to
+     *
+     * @param {any} val the value to test
+     * @method
+     */
+    gte(val: any): Condition;
+    /**
+     * @summary Test lower or equal to
+     *
+     * @param {any} val the value to test
+     * @method
+     */
+    lte(val: any): Condition;
+    /**
+     * @summary Test value in a range of values
+     * @param {any[]} val
+     */
+    in(val: any[]): Condition;
+    /**
+     * @summary Test matches {@link RegExp}
+     *
+     * @param {any} val the value to test
+     * @method
+     */
+    regexp(val: string | RegExp): Condition;
+}
+/**
+ * @summary The starting point for creating Conditions
+ * @description Exposes the available operations for a {@link Condition}
+ *
+ * @interface ConditionBuilderOption
+ *
+ * @category Query
+ * @subcategory Conditions
+ */
+export interface ConditionBuilderOption {
+    attribute(attr: string): AttributeOption;
+}

package/lib/query/selectors.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9xdWVyeS9zZWxlY3RvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsImZpbGUiOiJxdWVyeS9zZWxlY3RvcnMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPcmRlckRpcmVjdGlvbiB9IGZyb20gXCIuLi9yZXBvc2l0b3J5XCI7XG5pbXBvcnQgeyBDb25zdHJ1Y3RvciwgTW9kZWwgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5cbi8qKlxuICogQHR5cGVkZWYgRnJvbVNlbGVjdG9yXG4gKlxuICogQGNhdGVnb3J5IENsYXVzZXNcbiAqL1xuZXhwb3J0IHR5cGUgRnJvbVNlbGVjdG9yPE0gZXh0ZW5kcyBNb2RlbD4gPSBDb25zdHJ1Y3RvcjxNPiB8IHN0cmluZztcbi8qKlxuICogQHR5cGVkZWYgR3JvdXBCeVNlbGVjdG9yXG4gKlxuICogQGNhdGVnb3J5IENsYXVzZXNcbiAqL1xuZXhwb3J0IHR5cGUgR3JvdXBCeVNlbGVjdG9yID0gc3RyaW5nO1xuLyoqXG4gKiBAdHlwZWRlZiBPcmRlckJ5U2VsZWN0b3JcbiAqXG4gKiBAY2F0ZWdvcnkgQ2xhdXNlc1xuICovXG5leHBvcnQgdHlwZSBPcmRlckJ5U2VsZWN0b3IgPSBbc3RyaW5nLCBPcmRlckRpcmVjdGlvbl07XG4vKipcbiAqIEB0eXBlZGVmIExpbWl0U2VsZWN0b3JcbiAqXG4gKiBAY2F0ZWdvcnkgQ2xhdXNlc1xuICovXG5leHBvcnQgdHlwZSBMaW1pdFNlbGVjdG9yID0gbnVtYmVyO1xuLyoqXG4gKiBAdHlwZWRlZiBPZmZzZXRTZWxlY3RvclxuICpcbiAqIEBjYXRlZ29yeSBDbGF1c2VzXG4gKi9cbmV4cG9ydCB0eXBlIE9mZnNldFNlbGVjdG9yID0gbnVtYmVyO1xuXG4vLyBleHBvcnQgdHlwZSBTZWxlY3RGdW5jdGlvbjxUID0gYW55PiA9IChvYmo6IFQpID0+IFQgfCBhbnk7XG4vKipcbiAqIEB0eXBlZGVmIFNlbGVjdFNlbGVjdG9yXG4gKlxuICogQGNhdGVnb3J5IENsYXVzZXNcbiAqL1xuZXhwb3J0IHR5cGUgU2VsZWN0U2VsZWN0b3IgPSBzdHJpbmcgfCBzdHJpbmdbXTtcbiJdfQ==

package/lib/query/selectors.d.ts

@@ -0,0 +1,38 @@
+import { OrderDirection } from "../repository";
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+/**
+ * @typedef FromSelector
+ *
+ * @category Clauses
+ */
+export type FromSelector<M extends Model> = Constructor<M> | string;
+/**
+ * @typedef GroupBySelector
+ *
+ * @category Clauses
+ */
+export type GroupBySelector = string;
+/**
+ * @typedef OrderBySelector
+ *
+ * @category Clauses
+ */
+export type OrderBySelector = [string, OrderDirection];
+/**
+ * @typedef LimitSelector
+ *
+ * @category Clauses
+ */
+export type LimitSelector = number;
+/**
+ * @typedef OffsetSelector
+ *
+ * @category Clauses
+ */
+export type OffsetSelector = number;
+/**
+ * @typedef SelectSelector
+ *
+ * @category Clauses
+ */
+export type SelectSelector = string | string[];

package/lib/query/types.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9xdWVyeS90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwiZmlsZSI6InF1ZXJ5L3R5cGVzLmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgQXR0cmlidXRlUmVzdWx0ID0gUmVjb3JkPHN0cmluZywgc3RyaW5nPjtcblxuZXhwb3J0IHR5cGUgT3BlcmF0aW9uUmVzdWx0ID0gUmVjb3JkPHN0cmluZywgQXR0cmlidXRlUmVzdWx0IHwgYW55PjtcbiJdfQ==

package/lib/query/types.d.ts

@@ -0,0 +1,2 @@
+export type AttributeResult = Record<string, string>;
+export type OperationResult = Record<string, AttributeResult | any>;