@decaf-ts/core 0.3.32 → 0.3.34

package/dist/lib/query/Condition.d.ts

@@ -0,0 +1,75 @@
+import { AttributeOption, ConditionBuilderOption } from "./options";
+import { Model, ModelErrorDefinition } from "@decaf-ts/decorator-validation";
+import { GroupOperator, Operator } from "./constants";
+/**
+ * @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 declare class Condition extends Model {
+    protected attr1?: string | Condition;
+    protected operator?: Operator | GroupOperator;
+    protected comparison?: any;
+    private constructor();
+    /**
+     * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation
+     * @param {Condition} condition
+     */
+    and(condition: Condition): Condition;
+    /**
+     * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation
+     * @param {Condition} condition
+     */
+    or(condition: Condition): Condition;
+    /**
+     * @summary excludes a valut from the result
+     * @param val
+     */
+    not(val: any): Condition;
+    /**
+     * @inheritDoc
+     */
+    hasErrors(...exceptions: string[]): ModelErrorDefinition | undefined;
+    /**
+     * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation
+     * @param {Condition} condition1
+     * @param {Condition} condition2
+     */
+    static and(condition1: Condition, condition2: Condition): Condition;
+    /**
+     * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation
+     * @param {Condition} condition1
+     * @param {Condition} condition2
+     */
+    static or(condition1: Condition, condition2: Condition): Condition;
+    /**
+     * @summary Groups 2 {@link Condition}s by the specified {@link GroupOperator}
+     * @param {Condition} condition1
+     * @param {GroupOperator} operator
+     * @param {Condition} condition2
+     */
+    private static group;
+    static attribute(attr: string): AttributeOption;
+    /**
+     * @summary Condition Builder Class
+     * @description provides a simple API to build {@link Condition}s
+     *
+     * @class ConditionBuilder
+     * @implements Builder
+     * @implements AttributeOption
+     *
+     * @category Query
+     * @subcategory Conditions
+     */
+    private static Builder;
+    static get builder(): ConditionBuilderOption;
+}

package/dist/lib/query/Paginator.d.ts

@@ -0,0 +1,22 @@
+import { Statement } from "./Statement";
+export declare abstract class Paginator<V, Q> {
+    protected stat: Statement<Q>;
+    readonly size: number;
+    protected readonly _rawStatement: Q;
+    protected _currentPage: number;
+    protected _totalPages: number;
+    protected _recordCount: number;
+    protected limit: number;
+    private _statement?;
+    get current(): number;
+    get total(): number;
+    get count(): number;
+    get statement(): Q;
+    protected get adapter(): import("..").Adapter<any, Q>;
+    protected constructor(stat: Statement<Q>, size: number, _rawStatement: Q);
+    protected abstract prepare(rawStatement: Q): Q;
+    next(): Promise<V[]>;
+    previous(): Promise<V[]>;
+    protected validatePage(page: number): void;
+    abstract page(page?: number, ...args: any[]): Promise<V[]>;
+}

package/dist/lib/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/dist/lib/query/Statement.d.ts

@@ -0,0 +1,55 @@
+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";
+import { Paginator } from "./Paginator";
+/**
+ * @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>;
+    /**
+     * @inheritDoc
+     */
+    abstract paginate<Y>(size: number): Promise<Paginator<Y, Q>>;
+    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;
+    getTarget(): Constructor<any>;
+    setFullRecord(): void;
+    setMode(type: StatementType): void;
+}

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

package/dist/lib/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/dist/lib/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/dist/lib/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/dist/lib/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/dist/lib/query/clauses/WhereClause.d.ts

@@ -0,0 +1,46 @@
+import { Clause } from "../Clause";
+import { Condition } from "../Condition";
+import { ModelArg, ModelErrorDefinition } from "@decaf-ts/decorator-validation";
+import { LimitOption, OffsetOption, OrderAndGroupOption } from "../options";
+import { GroupBySelector, LimitSelector, OffsetSelector, OrderBySelector } from "../selectors";
+import { Executor } from "../../interfaces";
+/**
+ * @summary The WHERE clause
+ *
+ * @param {ClauseArg} [clause]
+ *
+ * @class WhereClause
+ * @extends Clause
+ * @implements OrderAndGroupOption
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export declare abstract class WhereClause<Q> extends Clause<Q> implements OrderAndGroupOption {
+    condition?: Condition;
+    protected constructor(clause?: ModelArg<WhereClause<Q>>);
+    /**
+     * @inheritDoc
+     */
+    abstract build(query: Q): Q;
+    /**
+     * @inheritDoc
+     */
+    orderBy(...selector: OrderBySelector[]): LimitOption & OffsetOption;
+    /**
+     * @inheritDoc
+     */
+    groupBy(selector: GroupBySelector): Executor;
+    /**
+     * @inheritDoc
+     */
+    limit(selector: LimitSelector): OffsetOption;
+    /**
+     * @inheritDoc
+     */
+    offset(selector: OffsetSelector): Executor;
+    /**
+     * @inheritDoc
+     */
+    hasErrors(...exceptions: string[]): ModelErrorDefinition | undefined;
+}

package/dist/lib/query/clauses/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./FromClause";
+export * from "./GroupByClause";
+export * from "./InsertClause";
+export * from "./LimitClause";
+export * from "./OffsetClause";
+export * from "./OrderByClause";
+export * from "./SelectClause";
+export * from "./SelectorBasedClause";
+export * from "./ValuesClause";
+export * from "./WhereClause";

package/dist/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/dist/lib/query/errors.d.ts

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

package/dist/lib/query/index.d.ts

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