@decaf-ts/core/lib/query/options.d.ts

Core persistence module for the decaf framework

import { GroupBySelector, LimitSelector, OffsetSelector, OrderBySelector, SelectSelector } from "./selectors";
import { Executor } from "../interfaces";
import { Constructor, Model } from "@decaf-ts/decorator-validation";
import { Condition } from "./Condition";
import { Paginatable } from "../interfaces/Paginatable";
/**
 * @summary GroupBy Option interface
 * @description Exposes the GROUP BY method and remaining options
 *
 * @interface GroupByOption
 * @memberOf module:core
 */
export interface GroupByOption<M extends Model, R> extends Executor<R> {
    groupBy(selector: GroupBySelector<M>): Executor<R>;
}
/**
 * @summary Offset Option interface
 * @description Exposes the OFFSET method and remaining options
 *
 * @interface GroupByOption
 * @memberOf module:core
 */
export interface OffsetOption<R> extends Executor<R> {
    offset(selector: OffsetSelector): Executor<R>;
}
/**
 * @summary Limit Option interface
 * @description Exposes the LIMIT method and remaining options
 *
 * @interface LimitOption
 * @memberOf module:core
 */
export interface LimitOption<M extends Model, R> extends Executor<R>, Paginatable<M, R, any> {
    limit(selector: LimitSelector): OffsetOption<R>;
}
/**
 * @summary OrderBy Option interface
 * @description Exposes the ORDER BY method and remaining options
 *
 * @interface OrderByOption
 * @memberOf module:core
 */
export interface OrderByOption<M extends Model, R> extends Executor<R>, Paginatable<M, R, any> {
    orderBy(selector: OrderBySelector<M>): LimitOption<M, R> & OffsetOption<R>;
}
/**
 * @summary OrderBy Option interface
 * @description Exposes the ORDER BY method and remaining options
 *
 * @interface ThenByOption
 * @memberOf module:core
 */
export interface ThenByOption<M extends Model, R> extends LimitOption<M, R>, OffsetOption<R>, Executor<R>, Paginatable<M, R, any> {
    thenBy(selector: OrderBySelector<M>): ThenByOption<M, R>;
}
/**
 * @summary Groups several order and grouping options
 *
 * @interface OrderAndGroupOption
 * @extends OrderByOption
 * @extends GroupByOption
 * @extends LimitOption
 * @extends OffsetOption
 * @memberOf module:core
 */
export interface OrderAndGroupOption<M extends Model, R> extends OrderByOption<M, R>, Executor<R>, GroupByOption<M, R>, LimitOption<M, R>, OffsetOption<R> {
}
/**
 * @summary Where Option interface
 * @description Exposes the WHERE method and remaining options
 *
 * @interface WhereOption
 * @extends OrderAndGroupOption
 * @memberOf module:core
 */
export interface WhereOption<M extends Model, R> extends OrderAndGroupOption<M, R> {
    /**
     * @summary filter the records by a condition
     *
     * @param {Condition} condition
     * @method
     */
    where(condition: Condition<M>): OrderAndGroupOption<M, R>;
}
/**
 * @summary From Option Interface
 * @description Exposes the FROM method and remaining options
 *
 * @interface FromOption
 * @memberOf module:core
 */
export interface FromOption<M extends Model, R> {
    /**
     * @summary selects records from a table
     *
     * @param {Constructor} tableName
     * @method
     */
    from(tableName: Constructor<M> | string): WhereOption<M, R>;
}
/**
 * @summary Distinct Option Interface
 * @description Exposes the remaining options after a DISTINCT
 *
 * @interface DistinctOption
 * @extends FromOption
 * @memberOf module:core
 */
export interface DistinctOption<M extends Model, R> extends FromOption<M, R> {
}
/**
 * @summary Max Option Interface
 * @description Exposes the remaining options after a MAX
 *
 * @interface MaxOption
 * @extends FromOption
 * @memberOf module:core
 */
export interface MaxOption<M extends Model, R> extends FromOption<M, R> {
}
/**
 * @summary Min Option Interface
 * @description Exposes the remaining options after a MIN
 *
 * @interface MinOption
 * @extends FromOption
 * @memberOf module:core
 */
export interface MinOption<M extends Model, R> extends FromOption<M, R> {
}
/**
 * @summary Count Option Interface
 * @description Exposes the remaining options after a COUNT
 *
 * @interface CountOption
 * @extends FromOption
 * @memberOf module:core
 */
export interface CountOption<M extends Model, R> extends FromOption<M, R> {
}
/**
 * @summary Select Option Interface
 * @description Exposes the remaining options after a SELECT
 *
 * @interface SelectOption
 * @extends FromOption
 * @memberOf module:core
 */
export interface SelectOption<M extends Model, R> extends FromOption<M, R> {
    distinct<S extends SelectSelector<M>>(selector: S): DistinctOption<M, M[S][]>;
    max<S extends SelectSelector<M>>(selector: S): MaxOption<M, M[S]>;
    min<S extends SelectSelector<M>>(selector: S): MinOption<M, M[S]>;
    count<S extends SelectSelector<M>>(selector?: S): CountOption<M, number>;
}
/**
 * @summary Into Option Interface
 * @description Exposes the remaining options after an INTO
 *
 * @interface IntoOption
 * @memberOf module:core
 */
export interface IntoOption<M extends Model, R> {
    values(...models: M[]): Executor<R>;
    where(condition: Condition<M>): Executor<R>;
}
/**
 * @summary Valuest Option Interface
 * @description Exposes the remaining options after a VALUES
 *
 * @interface ValuesOption
 * @memberOf module:core
 */
export interface ValuesOption<M extends Model> extends Executor<M> {
}
/**
 * @summary Insert Option Interface
 * @description Exposes the remaining options after an INSERT
 *
 * @interface InsertOption
 * @memberOf module:core
 */
export interface InsertOption<M extends Model, R = void> {
    /**
     * @summary selects the table to insert records into
     *
     * @param {string | Constructor} table
     * @method
     */
    into(table: Constructor<M>): IntoOption<M, R>;
}
/**
 * @summary {@link Operator} Option Interface
 * @description Exposes the available operators for a {@link Condition}
 *
 * @interface AttributeOption
 * @memberOf module:core
 */
export interface AttributeOption<M extends Model> {
    /**
     * @summary Test equality
     *
     * @param {any} val the value to test
     * @method
     */
    eq(val: any): Condition<M>;
    /**
     * @summary Test difference
     *
     * @param {any} val the value to test
     * @method
     */
    dif(val: any): Condition<M>;
    /**
     * @summary Test greater than
     *
     * @param {any} val the value to test
     * @method
     */
    gt(val: any): Condition<M>;
    /**
     * @summary Test lower than
     *
     * @param {any} val the value to test
     * @method
     */
    lt(val: any): Condition<M>;
    /**
     * @summary Test greater or equal to
     *
     * @param {any} val the value to test
     * @method
     */
    gte(val: any): Condition<M>;
    /**
     * @summary Test lower or equal to
     *
     * @param {any} val the value to test
     * @method
     */
    lte(val: any): Condition<M>;
    /**
     * @summary Test value in a range of values
     * @param {any[]} val
     */
    in(val: any[]): Condition<M>;
    /**
     * @summary Test matches {@link RegExp}
     *
     * @param {any} val the value to test
     * @method
     */
    regexp(val: string | RegExp): Condition<M>;
}
/**
 * @description The starting point for creating query conditions
 * @summary Exposes the available operations for building database query conditions
 * @template M - The model type this condition builder operates on
 * @interface ConditionBuilderOption
 * @memberOf module:core
 */
export interface ConditionBuilderOption<M extends Model> {
    attribute(attr: keyof M): AttributeOption<M>;
}