@decaf-ts/core 0.13.2 → 0.14.1

package/lib/query/options.d.ts

@@ -1,393 +0,0 @@
-import { GroupBySelector, LimitSelector, OffsetSelector, OrderBySelector, OrderDirectionInput, SelectSelector } from "./selectors";
-import { Executor } from "../interfaces";
-import { Model } from "@decaf-ts/decorator-validation";
-import { Condition } from "./Condition";
-import { Paginatable } from "../interfaces/Paginatable";
-import { Constructor } from "@decaf-ts/decoration";
-type NormalizedGroupKey<M extends Model, K extends keyof M> = M[K] extends PropertyKey ? M[K] : PropertyKey;
-type GroupByReturnValue<M extends Model, Keys extends readonly GroupBySelector<M>[]> = Keys extends [
-    infer Head extends keyof M,
-    ...infer Tail extends readonly GroupBySelector<M>[]
-] ? Record<NormalizedGroupKey<M, Head>, GroupByReturnValue<M, Tail>> : M[];
-export interface StatementExecutor<M extends Model, R> extends Executor<R>, Paginatable<M, R, any> {
-}
-export interface PreparableStatementExecutor<M extends Model, R> extends StatementExecutor<M, R> {
-    prepare(...args: any[]): Promise<StatementExecutor<M, R>>;
-}
-/**
- * @summary GroupBy Option interface
- * @description Exposes the GROUP BY method and remaining options
- *
- * @interface GroupByOption
- * @memberOf module:core
- */
-export interface GroupByResult<M extends Model, Keys extends readonly GroupBySelector<M>[] = readonly GroupBySelector<M>[]> extends PreparableStatementExecutor<M, GroupByReturnValue<M, Keys>>, OrderByOption<M, GroupByReturnValue<M, Keys>>, LimitOption<M, GroupByReturnValue<M, Keys>>, OffsetOption<M, GroupByReturnValue<M, Keys>> {
-    thenBy<Key extends GroupBySelector<M>>(selector: Key): GroupByResult<M, [...Keys, Key]>;
-}
-export interface GroupByOption<M extends Model> {
-    groupBy<Key extends GroupBySelector<M>>(selector: Key): GroupByResult<M, [Key]>;
-}
-/**
- * @summary Offset Option interface
- * @description Exposes the OFFSET method and remaining options
- *
- * @interface GroupByOption
- * @memberOf module:core
- */
-export interface OffsetOption<M extends Model, R> extends PreparableStatementExecutor<M, R> {
-    offset(selector: OffsetSelector): PreparableStatementExecutor<M, 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 PreparableStatementExecutor<M, R> {
-    limit(selector: LimitSelector): OffsetOption<M, R>;
-}
-/**
- * @summary OrderBy Option interface
- * @description Exposes the ORDER BY method and remaining options
- *
- * @interface OrderByOption
- * @memberOf module:core
- */
-export interface OrderByResult<M extends Model, R> extends LimitOption<M, R>, OffsetOption<M, R>, OrderByThenByStarterOption<M, R> {
-}
-export interface OrderByOption<M extends Model, R> extends PreparableStatementExecutor<M, R> {
-    orderBy(selector: OrderBySelector<M>): OrderByResult<M, R>;
-    orderBy(attribute: keyof M, direction: OrderDirectionInput): OrderByResult<M, R>;
-}
-/**
- * @summary OrderBy chaining starter interface
- * @description Exposes the thenBy methods for continuing orderBy chains
- *
- * @interface OrderByThenByStarterOption
- * @memberOf module:core
- */
-export interface OrderByThenByStarterOption<M extends Model, R> {
-    thenBy(selector: OrderBySelector<M>): OrderByThenByOption<M, R>;
-    thenBy(attribute: keyof M, direction: OrderDirectionInput): OrderByThenByOption<M, R>;
-}
-/**
- * @summary OrderBy chaining continuation interface
- * @description Exposes limit/offset and further thenBy chaining for multi-level sorts
- *
- * @interface OrderByThenByOption
- * @memberOf module:core
- */
-export interface OrderByThenByOption<M extends Model, R> extends LimitOption<M, R>, OffsetOption<M, R>, OrderByThenByStarterOption<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>, PreparableStatementExecutor<M, R>, GroupByOption<M>, LimitOption<M, R>, OffsetOption<M, 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 Distinct Where Option Interface
- * @description Exposes the remaining options after COUNT DISTINCT...FROM
- *
- * @interface CountDistinctWhereOption
- * @memberOf module:core
- */
-export interface CountDistinctWhereOption<M extends Model> extends OrderAndGroupOption<M, number> {
-    /**
-     * @summary filter the records by a condition
-     * @param {Condition} condition
-     */
-    where(condition: Condition<M>): CountDistinctWhereOption<M>;
-}
-/**
- * @summary Count Where Option Interface
- * @description Exposes the remaining options after COUNT...FROM with distinct() available
- *
- * @interface CountWhereOption
- * @memberOf module:core
- */
-export interface CountWhereOption<M extends Model> extends OrderAndGroupOption<M, number> {
-    /**
-     * @summary Makes the count distinct
-     * @description When chained after count(), counts only distinct values
-     * @return A count distinct query builder
-     */
-    distinct(): CountDistinctWhereOption<M>;
-    /**
-     * @summary filter the records by a condition
-     * @param {Condition} condition
-     */
-    where(condition: Condition<M>): CountWhereOption<M>;
-}
-/**
- * @summary Count Option Interface
- * @description Exposes the remaining options after a COUNT
- *
- * @interface CountOption
- * @memberOf module:core
- */
-export interface CountOption<M extends Model> {
-    /**
-     * @summary Makes the count distinct
-     * @description When chained after count(), counts only distinct values
-     * @return A count distinct query builder
-     */
-    distinct(): CountDistinctOption<M>;
-    /**
-     * @summary selects records from a table
-     * @param {Constructor} tableName
-     */
-    from(tableName: Constructor<M> | string): CountWhereOption<M>;
-}
-/**
- * @summary Count Distinct Option Interface
- * @description Exposes the remaining options after a COUNT DISTINCT
- *
- * @interface CountDistinctOption
- * @memberOf module:core
- */
-export interface CountDistinctOption<M extends Model> {
-    /**
-     * @summary selects records from a table
-     * @param {Constructor} tableName
-     */
-    from(tableName: Constructor<M> | string): CountWhereOption<M>;
-}
-/**
- * @summary Sum Option Interface
- * @description Exposes the remaining options after a SUM
- *
- * @interface SumOption
- * @extends FromOption
- * @memberOf module:core
- */
-export interface SumOption<M extends Model, R> extends FromOption<M, R> {
-}
-/**
- * @summary Avg Option Interface
- * @description Exposes the remaining options after an AVG
- *
- * @interface AvgOption
- * @extends FromOption
- * @memberOf module:core
- */
-export interface AvgOption<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>;
-    sum<S extends SelectSelector<M>>(selector: S): SumOption<M, number>;
-    avg<S extends SelectSelector<M>>(selector: S): AvgOption<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 value is between min and max (inclusive)
-     * @param {any} min the minimum value
-     * @param {any} max the maximum value
-     * @method
-     */
-    between(min: any, max: any): Condition<M>;
-    /**
-     * @summary Test matches {@link RegExp}
-     *
-     * @param {any} val the value to test
-     * @method
-     */
-    regexp(val: string | RegExp): Condition<M>;
-    /**
-     * @summary Test string starts with value
-     *
-     * @param {string} val the prefix to test
-     * @method
-     */
-    startsWith(val: string): Condition<M>;
-    /**
-     * @summary Test string ends with value
-     *
-     * @param {string} val the suffix to test
-     * @method
-     */
-    endsWith(val: string): 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>;
-    attr(attr: keyof M): AttributeOption<M>;
-}
-export {};

package/lib/query/selectors.d.ts

@@ -1,39 +0,0 @@
-import { Constructor } from "@decaf-ts/decoration";
-import { OrderDirection } from "../repository";
-import { Model } from "@decaf-ts/decorator-validation";
-export type OrderDirectionInput = OrderDirection | "asc" | "desc" | "ASC" | "DESC";
-/**
- * @description Type for selecting the data source in a query
- * @summary Defines the type for specifying the table or model to query from
- * @template M - The model type this selector operates on
- * @typedef {Constructor<M> | string} FromSelector
- * @memberOf module:core
- */
-export type FromSelector<M extends Model> = Constructor<M> | string;
-export type GroupBySelector<M extends Model> = keyof M;
-export type OrderBySelector<M extends Model> = [
-    keyof M,
-    OrderDirectionInput
-];
-/**
- * @description Type for limiting query results
- * @summary Defines the type for specifying the maximum number of results to return
- * @typedef {number} LimitSelector
- * @memberOf module:core
- */
-export type LimitSelector = number;
-/**
- * @description Type for offsetting query results
- * @summary Defines the type for specifying the number of results to skip
- * @typedef {number} OffsetSelector
- * @memberOf module:core
- */
-export type OffsetSelector = number;
-/**
- * @description Type for selecting fields in a query
- * @summary Defines the type for specifying which fields to select from a model
- * @template M - The model type this selector operates on
- * @typedef SelectSelector
- * @memberOf module:core
- */
-export type SelectSelector<M extends Model> = keyof M;

package/lib/query/types.d.ts

@@ -1,158 +0,0 @@
-import { Condition } from "./Condition";
-import { OrderBySelector } from "./selectors";
-import { Model } from "@decaf-ts/decorator-validation";
-import { Constructor } from "@decaf-ts/decoration";
-import { OrderDirection } from "../repository/constants";
-/**
- * @description
- * Options for configuring query building behavior.
- *
- * @summary
- * The `QueryOptions` type defines flags that determine whether certain clauses
- * (limit, offset, order by) are permitted, as well as whether violations
- * should throw an error during query construction.
- *
- * @memberOf module:query
- */
-export type QueryOptions = {
-    allowLimit?: boolean;
-    allowOffset?: boolean;
-    allowOrderBy?: boolean;
-    throws?: boolean;
-};
-export type OrderLimitOffsetExtract = {
-    orderBy?: OrderBySelector<any>[];
-    limit?: number;
-    offset?: number;
-};
-export type DirectionLimitOffset = {
-    direction?: OrderDirection;
-    order?: OrderBySelector<any>[];
-    limit?: number;
-    offset?: number;
-    bookmark?: string | number;
-};
-export type PreparedStatement<M extends Model> = {
-    class: Constructor<M>;
-    method: string;
-    args: any[];
-    params: DirectionLimitOffset;
-};
-/**
- * @description
- * Structured query object representing parsed query clauses.
- *
- * @summary
- * The `QueryAssist` interface defines the standard structure returned
- * by query builders. It includes actions such as find, optional clauses
- * like select, groupBy, and orderBy, and pagination controls (limit, offset).
- *
- * @template T The entity or record type that conditions may apply to.
- *
- * @interface QueryAssist
- * @memberOf module:query
- */
-/**
- * @description
- * Supported query action types for method-based queries.
- *
- * @summary
- * The `QueryAction` type defines the possible actions that can be
- * performed by a query built from a method name.
- *
- * @memberOf module:query
- */
-export type QueryAction = "find" | "page" | "count" | "sum" | "avg" | "min" | "max" | "distinct" | "group";
-export interface QueryAssist {
-    action: QueryAction;
-    select: undefined | string[];
-    selector?: string;
-    where?: Condition<any>;
-    groupBy?: string[];
-    orderBy?: OrderBySelector<any>[];
-    limit: number | undefined;
-    offset: number | undefined;
-}
-/**
- * @description
- * Enumeration of supported query clauses for building method-based queries.
- *
- * @summary
- * The `QueryClause` enum defines string literals that represent
- * different segments of a query (e.g., `findBy`, `Select`, `And`, `Or`).
- *
- * @enum QueryClause
- * @memberOf module:query
- */
-export declare enum QueryClause {
-    FIND_BY = "findBy",
-    PAGE_BY = "pageBy",
-    COUNT_BY = "countBy",
-    SUM_BY = "sumBy",
-    AVG_BY = "avgBy",
-    MIN_BY = "minBy",
-    MAX_BY = "maxBy",
-    DISTINCT_BY = "distinctBy",
-    GROUP_BY_PREFIX = "groupBy",
-    SELECT = "Select",
-    AND = "And",
-    OR = "Or",
-    GROUP_BY = "GroupBy",
-    ORDER_BY = "OrderBy",
-    THEN = "Then",
-    THEN_BY = "ThenBy"
-}
-/**
- * @description
- * Function signature for parsing operators in query building.
- *
- * @summary
- * The `OperatorParser` type represents a function that takes a field name
- * and arguments, then produces a `Condition` object that can be used in a query.
- *
- * @template T The type of the condition result.
- *
- * @param field {string} - The name of the field being parsed.
- * @param args {any[]} - Additional arguments for operator evaluation.
- *
- * @return {Condition<any>} A condition object representing the parsed operator.
- *
- * @memberOf module:query
- */
-export type OperatorParser = (field: string, ...args: any) => Condition<any>;
-/**
- * @description
- * Descriptor for fields and their associated operators in query parsing.
- *
- * @summary
- * The `FilterDescriptor` interface defines the structure used when parsing
- * method segments into filterable fields and associated operators.
- *
- * @interface FilterDescriptor
- * @memberOf module:query
- */
-export interface FilterDescriptor {
-    field: string;
-    operator?: string;
-}
-export type ViewKey = string | string[];
-export type ViewKind = "view" | "groupBy" | "count" | "sum" | "max" | "min" | "distinct";
-export interface ViewAuthOptions {
-    expression?: string;
-    field?: string;
-    roles?: string[];
-    mode?: "any" | "all";
-}
-export interface ViewOptions {
-    name?: string;
-    key?: ViewKey;
-    value?: ViewKey | null;
-    condition?: Condition<any> | string;
-    auth?: string | ViewAuthOptions;
-    compositions?: string[];
-    directions?: OrderDirection[];
-}
-export interface ViewMetadata extends ViewOptions {
-    kind: ViewKind;
-    attribute: string;
-}

package/lib/query/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/query/types.ts"],"names":[],"mappings":";;;AA2FA;;;;;;;;;;GAUG;AACH,IAAY,WAiBX;AAjBD,WAAY,WAAW;IACrB,iCAAkB,CAAA;IAClB,iCAAkB,CAAA;IAClB,mCAAoB,CAAA;IACpB,+BAAgB,CAAA;IAChB,+BAAgB,CAAA;IAChB,+BAAgB,CAAA;IAChB,+BAAgB,CAAA;IAChB,yCAA0B,CAAA;IAC1B,0CAA2B,CAAA;IAC3B,gCAAiB,CAAA;IACjB,0BAAW,CAAA;IACX,wBAAS,CAAA;IACT,mCAAoB,CAAA;IACpB,mCAAoB,CAAA;IACpB,4BAAa,CAAA;IACb,iCAAkB,CAAA;AACpB,CAAC,EAjBW,WAAW,2BAAX,WAAW,QAiBtB"}

package/lib/query/utils.d.ts

@@ -1,40 +0,0 @@
-import { OperatorParser } from "./types";
-/**
- * @description
- * Map of supported operators to their corresponding parser functions.
- *
- * @summary
- * The `OperatorsMap` defines a collection of operator names as keys
- * (such as `Equals`, `LessThan`, `Between`, etc.), each mapped to a
- * function that constructs a `Condition` object for that operator.
- * These functions translate query clauses into concrete condition
- * builders, enabling dynamic query construction from method names.
- *
- * @template T The type of the field values used in conditions.
- *
- * @param f {string} - The field name the condition applies to.
- * @param v1 {any} - The value to compare the field against or the lower bound value for range-based operators.
- * @param v2 {any} - The upper bound value for range-based operators.
- *
- * @return {Condition<any>} A condition object representing the operator applied to the field.
- *
- * @function OperatorsMap
- *
- * @mermaid
- * sequenceDiagram
- *   participant Client as Caller
- *   participant Map as OperatorsMap
- *   participant Parser as OperatorParser
- *   participant Cond as Condition
- *
- *   Client->>Map: Request operator parser ("Between", field, v1, v2)
- *   Map->>Parser: Call corresponding operator function
- *   Parser->>Cond: Condition.attribute(field)
- *   Cond-->>Parser: Condition instance
- *   Parser->>Cond: Apply gte(v1)
- *   Parser->>Cond: Apply and(lte(v2))
- *   Parser-->>Client: Return built Condition
- *
- * @memberOf module:query
- */
-export declare const OperatorsMap: Record<string, OperatorParser>;

package/lib/query/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/query/utils.ts"],"names":[],"mappings":";;;AAAA,+CAAwC;AAGxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACU,QAAA,YAAY,GAAmC;IAC1D,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,qBAAS,CAAC,SAAS,CAAC,CAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACrD,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,qBAAS,CAAC,SAAS,CAAC,CAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACpD,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,qBAAS,CAAC,SAAS,CAAC,CAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACvD,aAAa,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,qBAAS,CAAC,SAAS,CAAC,CAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7D,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,qBAAS,CAAC,SAAS,CAAC,CAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1D,gBAAgB,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,qBAAS,CAAC,SAAS,CAAC,CAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAChE,sDAAsD;IACtD,0BAA0B;IAC1B,kCAAkC;IAClC,eAAe;IACf,mDAAmD;IACnD,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,qBAAS,CAAC,SAAS,CAAC,CAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACjD,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,qBAAS,CAAC,SAAS,CAAC,CAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;CAC3D,CAAC"}