@decaf-ts/core 0.5.1 → 0.5.2

package/lib/query/Paginator.cjs

@@ -2,6 +2,62 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Paginator = void 0;
 const errors_1 = require("./errors.cjs");
+/**
+ * @description Handles pagination for database queries
+ * @summary Provides functionality for navigating through paginated query results
+ *
+ * This abstract class manages the state and navigation of paginated database query results.
+ * It tracks the current page, total pages, and record count, and provides methods for
+ * moving between pages.
+ *
+ * @template M - The model type this paginator operates on
+ * @template R - The return type of the paginated query (defaults to M[])
+ * @template Q - The query type (defaults to any)
+ * @param {Adapter<any, Q, any, any>} adapter - The database adapter to use for executing queries
+ * @param {Q} query - The query to paginate
+ * @param {number} size - The number of records per page
+ * @param {Constructor<M>} clazz - The constructor for the model type
+ * @class Paginator
+ * @example
+ * // Create a paginator for a user query
+ * const userQuery = db.select().from(User);
+ * const paginator = await userQuery.paginate(10); // 10 users per page
+ *
+ * // Get the first page of results
+ * const firstPage = await paginator.page(1);
+ *
+ * // Navigate to the next page
+ * const secondPage = await paginator.next();
+ *
+ * // Get information about the pagination
+ * console.log(`Page ${paginator.current} of ${paginator.total}, ${paginator.count} total records`);
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Paginator
+ *   participant Adapter
+ *   participant Database
+ *
+ *   Client->>Paginator: new Paginator(adapter, query, size, clazz)
+ *   Client->>Paginator: page(1)
+ *   Paginator->>Paginator: validatePage(1)
+ *   Paginator->>Paginator: prepare(query)
+ *   Paginator->>Adapter: execute query with pagination
+ *   Adapter->>Database: execute query
+ *   Database-->>Adapter: return results
+ *   Adapter-->>Paginator: return results
+ *   Paginator-->>Client: return page results
+ *
+ *   Client->>Paginator: next()
+ *   Paginator->>Paginator: page(current + 1)
+ *   Paginator->>Paginator: validatePage(current + 1)
+ *   Paginator->>Adapter: execute query with pagination
+ *   Adapter->>Database: execute query
+ *   Database-->>Adapter: return results
+ *   Adapter-->>Paginator: return results
+ *   Paginator-->>Client: return page results
+ */
 class Paginator {
     get current() {
         return this._currentPage;
@@ -38,4 +94,4 @@ class Paginator {
     }
 }
 exports.Paginator = Paginator;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/query/Paginator.d.ts

@@ -1,5 +1,61 @@
 import { Adapter } from "../persistence";
 import { Constructor, Model } from "@decaf-ts/decorator-validation";
+/**
+ * @description Handles pagination for database queries
+ * @summary Provides functionality for navigating through paginated query results
+ *
+ * This abstract class manages the state and navigation of paginated database query results.
+ * It tracks the current page, total pages, and record count, and provides methods for
+ * moving between pages.
+ *
+ * @template M - The model type this paginator operates on
+ * @template R - The return type of the paginated query (defaults to M[])
+ * @template Q - The query type (defaults to any)
+ * @param {Adapter<any, Q, any, any>} adapter - The database adapter to use for executing queries
+ * @param {Q} query - The query to paginate
+ * @param {number} size - The number of records per page
+ * @param {Constructor<M>} clazz - The constructor for the model type
+ * @class Paginator
+ * @example
+ * // Create a paginator for a user query
+ * const userQuery = db.select().from(User);
+ * const paginator = await userQuery.paginate(10); // 10 users per page
+ *
+ * // Get the first page of results
+ * const firstPage = await paginator.page(1);
+ *
+ * // Navigate to the next page
+ * const secondPage = await paginator.next();
+ *
+ * // Get information about the pagination
+ * console.log(`Page ${paginator.current} of ${paginator.total}, ${paginator.count} total records`);
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Paginator
+ *   participant Adapter
+ *   participant Database
+ *
+ *   Client->>Paginator: new Paginator(adapter, query, size, clazz)
+ *   Client->>Paginator: page(1)
+ *   Paginator->>Paginator: validatePage(1)
+ *   Paginator->>Paginator: prepare(query)
+ *   Paginator->>Adapter: execute query with pagination
+ *   Adapter->>Database: execute query
+ *   Database-->>Adapter: return results
+ *   Adapter-->>Paginator: return results
+ *   Paginator-->>Client: return page results
+ *
+ *   Client->>Paginator: next()
+ *   Paginator->>Paginator: page(current + 1)
+ *   Paginator->>Paginator: validatePage(current + 1)
+ *   Paginator->>Adapter: execute query with pagination
+ *   Adapter->>Database: execute query
+ *   Database-->>Adapter: return results
+ *   Adapter-->>Paginator: return results
+ *   Paginator-->>Client: return page results
+ */
 export declare abstract class Paginator<M extends Model, R = M[], Q = any> {
     protected readonly adapter: Adapter<any, Q, any, any>;
     protected readonly query: Q;

package/lib/query/Statement.cjs

@@ -16,6 +16,57 @@ const Condition_1 = require("./Condition.cjs");
 const db_decorators_1 = require("@decaf-ts/db-decorators");
 const decorators_1 = require("./../utils/decorators.cjs");
 const errors_1 = require("./errors.cjs");
+/**
+ * @description Base class for database query statements
+ * @summary Provides a foundation for building and executing database queries
+ *
+ * This abstract class implements the query builder pattern for constructing
+ * database queries. It supports various query operations like select, from,
+ * where, orderBy, groupBy, limit, and offset. It also provides methods for
+ * executing queries and handling pagination.
+ *
+ * @template Q - The query type specific to the database adapter
+ * @template M - The model type this statement operates on
+ * @template R - The return type of the query
+ * @param {Adapter<any, Q, any, any>} adapter - The database adapter to use for executing queries
+ * @class Statement
+ * @example
+ * // Create a statement to query users
+ * const statement = new SQLStatement(adapter);
+ * const users = await statement
+ *   .select()
+ *   .from(User)
+ *   .where(Condition.attribute("status").eq("active"))
+ *   .orderBy(["createdAt", "DESC"])
+ *   .limit(10)
+ *   .execute();
+ *
+ * // Use pagination
+ * const paginator = await statement
+ *   .select()
+ *   .from(User)
+ *   .paginate(20); // 20 users per page
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Statement
+ *   participant Adapter
+ *   participant Database
+ *
+ *   Client->>Statement: select()
+ *   Client->>Statement: from(Model)
+ *   Client->>Statement: where(condition)
+ *   Client->>Statement: orderBy([field, direction])
+ *   Client->>Statement: limit(value)
+ *   Client->>Statement: execute()
+ *   Statement->>Statement: build()
+ *   Statement->>Adapter: raw(query)
+ *   Adapter->>Database: execute query
+ *   Database-->>Adapter: return results
+ *   Adapter-->>Statement: return processed results
+ *   Statement-->>Client: return final results
+ */
 class Statement {
     constructor(adapter) {
         this.adapter = adapter;
@@ -165,4 +216,4 @@ __decorate([
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
 ], Statement.prototype, "execute", null);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Statement.js","sourceRoot":"","sources":["../../src/query/Statement.ts"],"names":[],"mappings":"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","sourcesContent":["import { type Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport type { Executor, RawExecutor } from \"../interfaces\";\nimport type {\n  FromSelector,\n  GroupBySelector,\n  OrderBySelector,\n  SelectSelector,\n} from \"./selectors\";\nimport { Condition } from \"./Condition\";\nimport { findPrimaryKey, InternalError } from \"@decaf-ts/db-decorators\";\nimport { final } from \"../utils/decorators\";\nimport type {\n  CountOption,\n  DistinctOption,\n  LimitOption,\n  MaxOption,\n  MinOption,\n  OffsetOption,\n  OrderAndGroupOption,\n  SelectOption,\n  WhereOption,\n} from \"./options\";\nimport { Paginatable } from \"../interfaces/Paginatable\";\nimport { Paginator } from \"./Paginator\";\nimport { Adapter } from \"../persistence\";\nimport { QueryError } from \"./errors\";\n\nexport abstract class Statement<Q, M extends Model, R>\n  implements Executor<R>, RawExecutor<Q>, Paginatable<M, R, Q>\n{\n  protected readonly selectSelector?: SelectSelector<M>[];\n  protected distinctSelector?: SelectSelector<M>;\n  protected maxSelector?: SelectSelector<M>;\n  protected minSelector?: SelectSelector<M>;\n  protected countSelector?: SelectSelector<M>;\n  protected fromSelector!: Constructor<M>;\n  protected whereCondition?: Condition<M>;\n  protected orderBySelector?: OrderBySelector<M>;\n  protected groupBySelector?: GroupBySelector<M>;\n  protected limitSelector?: number;\n  protected offsetSelector?: number;\n\n  protected constructor(protected adapter: Adapter<any, Q, any, any>) {}\n\n  select<\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    S extends readonly SelectSelector<M>[],\n  >(): SelectOption<M, M[]>;\n  select<S extends readonly SelectSelector<M>[]>(\n    selector: readonly [...S]\n  ): SelectOption<M, Pick<M, S[number]>[]>;\n\n  @final()\n  select<S extends readonly SelectSelector<M>[]>(\n    selector?: readonly [...S]\n  ): SelectOption<M, M[]> | SelectOption<M, Pick<M, S[number]>[]> {\n    Object.defineProperty(this, \"selectSelector\", {\n      value: selector,\n      writable: false,\n    });\n    return this as SelectOption<M, M[]> | SelectOption<M, Pick<M, S[number]>[]>;\n  }\n\n  @final()\n  distinct<S extends SelectSelector<M>>(\n    selector: S\n  ): DistinctOption<M, M[S][]> {\n    this.distinctSelector = selector;\n    return this as DistinctOption<M, M[S][]>;\n  }\n\n  @final()\n  max<S extends SelectSelector<M>>(selector: S): MaxOption<M, M[S]> {\n    this.maxSelector = selector;\n    return this as MaxOption<M, M[S]>;\n  }\n\n  @final()\n  min<S extends SelectSelector<M>>(selector: S): MinOption<M, M[S]> {\n    this.minSelector = selector;\n    return this as MinOption<M, M[S]>;\n  }\n\n  @final()\n  count<S extends SelectSelector<M>>(selector?: S): CountOption<M, number> {\n    this.countSelector = selector;\n    return this as CountOption<M, number>;\n  }\n\n  @final()\n  public from(selector: FromSelector<M>): WhereOption<M, R> {\n    this.fromSelector = (\n      typeof selector === \"string\" ? Model.get(selector) : selector\n    ) as Constructor<M>;\n    if (!this.fromSelector)\n      throw new QueryError(`Could not find selector model: ${selector}`);\n    return this;\n  }\n\n  @final()\n  public where(condition: Condition<M>): OrderAndGroupOption<M, R> {\n    this.whereCondition = condition;\n    return this;\n  }\n\n  @final()\n  public orderBy(\n    selector: OrderBySelector<M>\n  ): LimitOption<M, R> & OffsetOption<R> {\n    this.orderBySelector = selector;\n    return this;\n  }\n\n  @final()\n  public groupBy(selector: GroupBySelector<M>): LimitOption<M, R> {\n    this.groupBySelector = selector;\n    return this;\n  }\n\n  @final()\n  public limit(value: number): OffsetOption<R> {\n    this.limitSelector = value;\n    return this;\n  }\n\n  @final()\n  public offset(value: number): Executor<R> {\n    this.offsetSelector = value;\n    return this;\n  }\n\n  @final()\n  async execute(): Promise<R> {\n    try {\n      const query: Q = this.build();\n      return (await this.raw(query)) as R;\n    } catch (e: unknown) {\n      throw new InternalError(e as Error);\n    }\n  }\n\n  async raw<R>(rawInput: Q): Promise<R> {\n    const results = await this.adapter.raw<R>(rawInput);\n    if (!this.selectSelector) return results;\n    const pkAttr = findPrimaryKey(\n      new (this.fromSelector as Constructor<M>)()\n    ).id;\n\n    const processor = function recordProcessor(\n      this: Statement<Q, M, R>,\n      r: any\n    ) {\n      const id = r[pkAttr];\n      return this.adapter.revert(\n        r,\n        this.fromSelector as Constructor<any>,\n        pkAttr,\n        id\n      ) as any;\n    }.bind(this as any);\n\n    if (Array.isArray(results)) return results.map(processor) as R;\n    return processor(results) as R;\n  }\n\n  protected abstract build(): Q;\n  protected abstract parseCondition(condition: Condition<M>): Q;\n  abstract paginate(size: number): Promise<Paginator<M, R, Q>>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Statement.js","sourceRoot":"","sources":["../../src/query/Statement.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,yEAAyE;AAQzE,+CAAwC;AACxC,2DAAwE;AACxE,0DAA4C;AAe5C,yCAAsC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,MAAsB,SAAS;IAe7B,YAAgC,OAAkC;QAAlC,YAAO,GAAP,OAAO,CAA2B;IAAG,CAAC;IAWtE,MAAM,CACJ,QAA0B;QAE1B,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,gBAAgB,EAAE;YAC5C,KAAK,EAAE,QAAQ;YACf,QAAQ,EAAE,KAAK;SAChB,CAAC,CAAC;QACH,OAAO,IAAoE,CAAC;IAC9E,CAAC;IAGD,QAAQ,CACN,QAAW;QAEX,IAAI,CAAC,gBAAgB,GAAG,QAAQ,CAAC;QACjC,OAAO,IAAiC,CAAC;IAC3C,CAAC;IAGD,GAAG,CAA8B,QAAW;QAC1C,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC;QAC5B,OAAO,IAA0B,CAAC;IACpC,CAAC;IAGD,GAAG,CAA8B,QAAW;QAC1C,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC;QAC5B,OAAO,IAA0B,CAAC;IACpC,CAAC;IAGD,KAAK,CAA8B,QAAY;QAC7C,IAAI,CAAC,aAAa,GAAG,QAAQ,CAAC;QAC9B,OAAO,IAA8B,CAAC;IACxC,CAAC;IAGM,IAAI,CAAC,QAAyB;QACnC,IAAI,CAAC,YAAY,GAAG,CAClB,OAAO,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,4BAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAC5C,CAAC;QACpB,IAAI,CAAC,IAAI,CAAC,YAAY;YACpB,MAAM,IAAI,mBAAU,CAAC,kCAAkC,QAAQ,EAAE,CAAC,CAAC;QACrE,OAAO,IAAI,CAAC;IACd,CAAC;IAGM,KAAK,CAAC,SAAuB;QAClC,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC;QAChC,OAAO,IAAI,CAAC;IACd,CAAC;IAGM,OAAO,CACZ,QAA4B;QAE5B,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC;QAChC,OAAO,IAAI,CAAC;IACd,CAAC;IAGM,OAAO,CAAC,QAA4B;QACzC,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC;QAChC,OAAO,IAAI,CAAC;IACd,CAAC;IAGM,KAAK,CAAC,KAAa;QACxB,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;QAC3B,OAAO,IAAI,CAAC;IACd,CAAC;IAGM,MAAM,CAAC,KAAa;QACzB,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;QAC5B,OAAO,IAAI,CAAC;IACd,CAAC;IAGK,AAAN,KAAK,CAAC,OAAO;QACX,IAAI,CAAC;YACH,MAAM,KAAK,GAAM,IAAI,CAAC,KAAK,EAAE,CAAC;YAC9B,OAAO,CAAC,MAAM,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAM,CAAC;QACtC,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,MAAM,IAAI,6BAAa,CAAC,CAAU,CAAC,CAAC;QACtC,CAAC;IACH,CAAC;IAED,KAAK,CAAC,GAAG,CAAI,QAAW;QACtB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAI,QAAQ,CAAC,CAAC;QACpD,IAAI,CAAC,IAAI,CAAC,cAAc;YAAE,OAAO,OAAO,CAAC;QACzC,MAAM,MAAM,GAAG,IAAA,8BAAc,EAC3B,IAAK,IAAI,CAAC,YAA+B,EAAE,CAC5C,CAAC,EAAE,CAAC;QAEL,MAAM,SAAS,GAAG,SAAS,eAAe,CAExC,CAAM;YAEN,MAAM,EAAE,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC;YACrB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CACxB,CAAC,EACD,IAAI,CAAC,YAAgC,EACrC,MAAM,EACN,EAAE,CACI,CAAC;QACX,CAAC,CAAC,IAAI,CAAC,IAAW,CAAC,CAAC;QAEpB,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;YAAE,OAAO,OAAO,CAAC,GAAG,CAAC,SAAS,CAAM,CAAC;QAC/D,OAAO,SAAS,CAAC,OAAO,CAAM,CAAC;IACjC,CAAC;CAKF;AA7ID,8BA6IC;AAnHC;IADC,IAAA,kBAAK,GAAE;;;;uCASP;AAGD;IADC,IAAA,kBAAK,GAAE;;yDAEI,CAAC,oBAAD,CAAC;;yCAIZ;AAGD;IADC,IAAA,kBAAK,GAAE;;yDACmC,CAAC,oBAAD,CAAC;;oCAG3C;AAGD;IADC,IAAA,kBAAK,GAAE;;yDACmC,CAAC,oBAAD,CAAC;;oCAG3C;AAGD;IADC,IAAA,kBAAK,GAAE;;yDACsC,CAAC,oBAAD,CAAC;;sCAG9C;AAGM;IADN,IAAA,kBAAK,GAAE;;;;qCAQP;AAGM;IADN,IAAA,kBAAK,GAAE;;qCACgB,qBAAS;;sCAGhC;AAGM;IADN,IAAA,kBAAK,GAAE;;;;wCAMP;AAGM;IADN,IAAA,kBAAK,GAAE;;;;wCAIP;AAGM;IADN,IAAA,kBAAK,GAAE;;;;sCAIP;AAGM;IADN,IAAA,kBAAK,GAAE;;;;uCAIP;AAGK;IADL,IAAA,kBAAK,GAAE;;;;wCAQP","sourcesContent":["import { type Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport type { Executor, RawExecutor } from \"../interfaces\";\nimport type {\n  FromSelector,\n  GroupBySelector,\n  OrderBySelector,\n  SelectSelector,\n} from \"./selectors\";\nimport { Condition } from \"./Condition\";\nimport { findPrimaryKey, InternalError } from \"@decaf-ts/db-decorators\";\nimport { final } from \"../utils/decorators\";\nimport type {\n  CountOption,\n  DistinctOption,\n  LimitOption,\n  MaxOption,\n  MinOption,\n  OffsetOption,\n  OrderAndGroupOption,\n  SelectOption,\n  WhereOption,\n} from \"./options\";\nimport { Paginatable } from \"../interfaces/Paginatable\";\nimport { Paginator } from \"./Paginator\";\nimport { Adapter } from \"../persistence\";\nimport { QueryError } from \"./errors\";\n\n/**\n * @description Base class for database query statements\n * @summary Provides a foundation for building and executing database queries\n * \n * This abstract class implements the query builder pattern for constructing\n * database queries. It supports various query operations like select, from,\n * where, orderBy, groupBy, limit, and offset. It also provides methods for\n * executing queries and handling pagination.\n * \n * @template Q - The query type specific to the database adapter\n * @template M - The model type this statement operates on\n * @template R - The return type of the query\n * @param {Adapter<any, Q, any, any>} adapter - The database adapter to use for executing queries\n * @class Statement\n * @example\n * // Create a statement to query users\n * const statement = new SQLStatement(adapter);\n * const users = await statement\n *   .select()\n *   .from(User)\n *   .where(Condition.attribute(\"status\").eq(\"active\"))\n *   .orderBy([\"createdAt\", \"DESC\"])\n *   .limit(10)\n *   .execute();\n * \n * // Use pagination\n * const paginator = await statement\n *   .select()\n *   .from(User)\n *   .paginate(20); // 20 users per page\n * \n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Statement\n *   participant Adapter\n *   participant Database\n *   \n *   Client->>Statement: select()\n *   Client->>Statement: from(Model)\n *   Client->>Statement: where(condition)\n *   Client->>Statement: orderBy([field, direction])\n *   Client->>Statement: limit(value)\n *   Client->>Statement: execute()\n *   Statement->>Statement: build()\n *   Statement->>Adapter: raw(query)\n *   Adapter->>Database: execute query\n *   Database-->>Adapter: return results\n *   Adapter-->>Statement: return processed results\n *   Statement-->>Client: return final results\n */\nexport abstract class Statement<Q, M extends Model, R>\n  implements Executor<R>, RawExecutor<Q>, Paginatable<M, R, Q>\n{\n  protected readonly selectSelector?: SelectSelector<M>[];\n  protected distinctSelector?: SelectSelector<M>;\n  protected maxSelector?: SelectSelector<M>;\n  protected minSelector?: SelectSelector<M>;\n  protected countSelector?: SelectSelector<M>;\n  protected fromSelector!: Constructor<M>;\n  protected whereCondition?: Condition<M>;\n  protected orderBySelector?: OrderBySelector<M>;\n  protected groupBySelector?: GroupBySelector<M>;\n  protected limitSelector?: number;\n  protected offsetSelector?: number;\n\n  protected constructor(protected adapter: Adapter<any, Q, any, any>) {}\n\n  select<\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    S extends readonly SelectSelector<M>[],\n  >(): SelectOption<M, M[]>;\n  select<S extends readonly SelectSelector<M>[]>(\n    selector: readonly [...S]\n  ): SelectOption<M, Pick<M, S[number]>[]>;\n\n  @final()\n  select<S extends readonly SelectSelector<M>[]>(\n    selector?: readonly [...S]\n  ): SelectOption<M, M[]> | SelectOption<M, Pick<M, S[number]>[]> {\n    Object.defineProperty(this, \"selectSelector\", {\n      value: selector,\n      writable: false,\n    });\n    return this as SelectOption<M, M[]> | SelectOption<M, Pick<M, S[number]>[]>;\n  }\n\n  @final()\n  distinct<S extends SelectSelector<M>>(\n    selector: S\n  ): DistinctOption<M, M[S][]> {\n    this.distinctSelector = selector;\n    return this as DistinctOption<M, M[S][]>;\n  }\n\n  @final()\n  max<S extends SelectSelector<M>>(selector: S): MaxOption<M, M[S]> {\n    this.maxSelector = selector;\n    return this as MaxOption<M, M[S]>;\n  }\n\n  @final()\n  min<S extends SelectSelector<M>>(selector: S): MinOption<M, M[S]> {\n    this.minSelector = selector;\n    return this as MinOption<M, M[S]>;\n  }\n\n  @final()\n  count<S extends SelectSelector<M>>(selector?: S): CountOption<M, number> {\n    this.countSelector = selector;\n    return this as CountOption<M, number>;\n  }\n\n  @final()\n  public from(selector: FromSelector<M>): WhereOption<M, R> {\n    this.fromSelector = (\n      typeof selector === \"string\" ? Model.get(selector) : selector\n    ) as Constructor<M>;\n    if (!this.fromSelector)\n      throw new QueryError(`Could not find selector model: ${selector}`);\n    return this;\n  }\n\n  @final()\n  public where(condition: Condition<M>): OrderAndGroupOption<M, R> {\n    this.whereCondition = condition;\n    return this;\n  }\n\n  @final()\n  public orderBy(\n    selector: OrderBySelector<M>\n  ): LimitOption<M, R> & OffsetOption<R> {\n    this.orderBySelector = selector;\n    return this;\n  }\n\n  @final()\n  public groupBy(selector: GroupBySelector<M>): LimitOption<M, R> {\n    this.groupBySelector = selector;\n    return this;\n  }\n\n  @final()\n  public limit(value: number): OffsetOption<R> {\n    this.limitSelector = value;\n    return this;\n  }\n\n  @final()\n  public offset(value: number): Executor<R> {\n    this.offsetSelector = value;\n    return this;\n  }\n\n  @final()\n  async execute(): Promise<R> {\n    try {\n      const query: Q = this.build();\n      return (await this.raw(query)) as R;\n    } catch (e: unknown) {\n      throw new InternalError(e as Error);\n    }\n  }\n\n  async raw<R>(rawInput: Q): Promise<R> {\n    const results = await this.adapter.raw<R>(rawInput);\n    if (!this.selectSelector) return results;\n    const pkAttr = findPrimaryKey(\n      new (this.fromSelector as Constructor<M>)()\n    ).id;\n\n    const processor = function recordProcessor(\n      this: Statement<Q, M, R>,\n      r: any\n    ) {\n      const id = r[pkAttr];\n      return this.adapter.revert(\n        r,\n        this.fromSelector as Constructor<any>,\n        pkAttr,\n        id\n      ) as any;\n    }.bind(this as any);\n\n    if (Array.isArray(results)) return results.map(processor) as R;\n    return processor(results) as R;\n  }\n\n  protected abstract build(): Q;\n  protected abstract parseCondition(condition: Condition<M>): Q;\n  abstract paginate(size: number): Promise<Paginator<M, R, Q>>;\n}\n"]}

package/lib/query/Statement.d.ts

@@ -6,6 +6,57 @@ import type { CountOption, DistinctOption, LimitOption, MaxOption, MinOption, Of
 import { Paginatable } from "../interfaces/Paginatable";
 import { Paginator } from "./Paginator";
 import { Adapter } from "../persistence";
+/**
+ * @description Base class for database query statements
+ * @summary Provides a foundation for building and executing database queries
+ *
+ * This abstract class implements the query builder pattern for constructing
+ * database queries. It supports various query operations like select, from,
+ * where, orderBy, groupBy, limit, and offset. It also provides methods for
+ * executing queries and handling pagination.
+ *
+ * @template Q - The query type specific to the database adapter
+ * @template M - The model type this statement operates on
+ * @template R - The return type of the query
+ * @param {Adapter<any, Q, any, any>} adapter - The database adapter to use for executing queries
+ * @class Statement
+ * @example
+ * // Create a statement to query users
+ * const statement = new SQLStatement(adapter);
+ * const users = await statement
+ *   .select()
+ *   .from(User)
+ *   .where(Condition.attribute("status").eq("active"))
+ *   .orderBy(["createdAt", "DESC"])
+ *   .limit(10)
+ *   .execute();
+ *
+ * // Use pagination
+ * const paginator = await statement
+ *   .select()
+ *   .from(User)
+ *   .paginate(20); // 20 users per page
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Statement
+ *   participant Adapter
+ *   participant Database
+ *
+ *   Client->>Statement: select()
+ *   Client->>Statement: from(Model)
+ *   Client->>Statement: where(condition)
+ *   Client->>Statement: orderBy([field, direction])
+ *   Client->>Statement: limit(value)
+ *   Client->>Statement: execute()
+ *   Statement->>Statement: build()
+ *   Statement->>Adapter: raw(query)
+ *   Adapter->>Database: execute query
+ *   Database-->>Adapter: return results
+ *   Adapter-->>Statement: return processed results
+ *   Statement-->>Client: return final results
+ */
 export declare abstract class Statement<Q, M extends Model, R> implements Executor<R>, RawExecutor<Q>, Paginatable<M, R, Q> {
     protected adapter: Adapter<any, Q, any, any>;
     protected readonly selectSelector?: SelectSelector<M>[];

package/lib/query/constants.cjs

@@ -1,23 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupOperator = exports.Operator = void 0;
+/**
+ * @description Comparison operators for query conditions
+ * @summary Enum defining the available operators for comparing values in database queries
+ * @enum {string}
+ * @readonly
+ * @memberOf module:core
+ */
 var Operator;
 (function (Operator) {
+    /** Equal comparison (=) */
     Operator["EQUAL"] = "EQUAL";
+    /** Not equal comparison (!=) */
     Operator["DIFFERENT"] = "DIFFERENT";
+    /** Greater than comparison (>) */
     Operator["BIGGER"] = "BIGGER";
+    /** Greater than or equal comparison (>=) */
     Operator["BIGGER_EQ"] = "BIGGER_EQ";
+    /** Less than comparison (<) */
     Operator["SMALLER"] = "SMALLER";
+    /** Less than or equal comparison (<=) */
     Operator["SMALLER_EQ"] = "SMALLER_EQ";
     // BETWEEN = "BETWEEN",
+    /** Negation operator (NOT) */
     Operator["NOT"] = "NOT";
+    /** Inclusion operator (IN) */
     Operator["IN"] = "IN";
     // IS = "IS",
+    /** Regular expression matching */
     Operator["REGEXP"] = "REGEXP";
 })(Operator || (exports.Operator = Operator = {}));
+/**
+ * @description Logical operators for combining query conditions
+ * @summary Enum defining the available operators for grouping multiple conditions in database queries
+ * @enum {string}
+ * @readonly
+ * @memberOf module:core
+ */
 var GroupOperator;
 (function (GroupOperator) {
+    /** Logical AND operator - all conditions must be true */
     GroupOperator["AND"] = "AND";
+    /** Logical OR operator - at least one condition must be true */
     GroupOperator["OR"] = "OR";
 })(GroupOperator || (exports.GroupOperator = GroupOperator = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3F1ZXJ5L2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxJQUFZLFFBWVg7QUFaRCxXQUFZLFFBQVE7SUFDbEIsMkJBQWUsQ0FBQTtJQUNmLG1DQUF1QixDQUFBO0lBQ3ZCLDZCQUFpQixDQUFBO0lBQ2pCLG1DQUF1QixDQUFBO0lBQ3ZCLCtCQUFtQixDQUFBO0lBQ25CLHFDQUF5QixDQUFBO0lBQ3pCLHVCQUF1QjtJQUN2Qix1QkFBVyxDQUFBO0lBQ1gscUJBQVMsQ0FBQTtJQUNULGFBQWE7SUFDYiw2QkFBaUIsQ0FBQTtBQUNuQixDQUFDLEVBWlcsUUFBUSx3QkFBUixRQUFRLFFBWW5CO0FBRUQsSUFBWSxhQUdYO0FBSEQsV0FBWSxhQUFhO0lBQ3ZCLDRCQUFXLENBQUE7SUFDWCwwQkFBUyxDQUFBO0FBQ1gsQ0FBQyxFQUhXLGFBQWEsNkJBQWIsYUFBYSxRQUd4QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIE9wZXJhdG9yIHtcbiAgRVFVQUwgPSBcIkVRVUFMXCIsXG4gIERJRkZFUkVOVCA9IFwiRElGRkVSRU5UXCIsXG4gIEJJR0dFUiA9IFwiQklHR0VSXCIsXG4gIEJJR0dFUl9FUSA9IFwiQklHR0VSX0VRXCIsXG4gIFNNQUxMRVIgPSBcIlNNQUxMRVJcIixcbiAgU01BTExFUl9FUSA9IFwiU01BTExFUl9FUVwiLFxuICAvLyBCRVRXRUVOID0gXCJCRVRXRUVOXCIsXG4gIE5PVCA9IFwiTk9UXCIsXG4gIElOID0gXCJJTlwiLFxuICAvLyBJUyA9IFwiSVNcIixcbiAgUkVHRVhQID0gXCJSRUdFWFBcIixcbn1cblxuZXhwb3J0IGVudW0gR3JvdXBPcGVyYXRvciB7XG4gIEFORCA9IFwiQU5EXCIsXG4gIE9SID0gXCJPUlwiLFxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/lib/query/constants.d.ts

@@ -1,15 +1,40 @@
+/**
+ * @description Comparison operators for query conditions
+ * @summary Enum defining the available operators for comparing values in database queries
+ * @enum {string}
+ * @readonly
+ * @memberOf module:core
+ */
 export declare enum Operator {
+    /** Equal comparison (=) */
     EQUAL = "EQUAL",
+    /** Not equal comparison (!=) */
     DIFFERENT = "DIFFERENT",
+    /** Greater than comparison (>) */
     BIGGER = "BIGGER",
+    /** Greater than or equal comparison (>=) */
     BIGGER_EQ = "BIGGER_EQ",
+    /** Less than comparison (<) */
     SMALLER = "SMALLER",
+    /** Less than or equal comparison (<=) */
     SMALLER_EQ = "SMALLER_EQ",
+    /** Negation operator (NOT) */
     NOT = "NOT",
+    /** Inclusion operator (IN) */
     IN = "IN",
+    /** Regular expression matching */
     REGEXP = "REGEXP"
 }
+/**
+ * @description Logical operators for combining query conditions
+ * @summary Enum defining the available operators for grouping multiple conditions in database queries
+ * @enum {string}
+ * @readonly
+ * @memberOf module:core
+ */
 export declare enum GroupOperator {
+    /** Logical AND operator - all conditions must be true */
     AND = "AND",
+    /** Logical OR operator - at least one condition must be true */
     OR = "OR"
 }

package/lib/query/errors.cjs

@@ -2,16 +2,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PagingError = exports.QueryError = void 0;
 const db_decorators_1 = require("@decaf-ts/db-decorators");
+/**
+ * @description Error thrown during query operations
+ * @summary Represents errors that occur during query building or execution
+ * @param {string | Error} msg - The error message or Error object
+ * @class QueryError
+ * @category Errors
+ */
 class QueryError extends db_decorators_1.BaseError {
     constructor(msg) {
         super(QueryError.name, msg, 500);
     }
 }
 exports.QueryError = QueryError;
+/**
+ * @description Error thrown during pagination operations
+ * @summary Represents errors that occur during pagination setup or execution
+ * @param {string | Error} msg - The error message or Error object
+ * @class PagingError
+ * @category Errors
+ */
 class PagingError extends db_decorators_1.BaseError {
     constructor(msg) {
         super(PagingError.name, msg, 500);
     }
 }
 exports.PagingError = PagingError;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3F1ZXJ5L2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwyREFBb0Q7QUFFcEQsTUFBYSxVQUFXLFNBQVEseUJBQVM7SUFDdkMsWUFBWSxHQUFtQjtRQUM3QixLQUFLLENBQUMsVUFBVSxDQUFDLElBQUksRUFBRSxHQUFHLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDbkMsQ0FBQztDQUNGO0FBSkQsZ0NBSUM7QUFFRCxNQUFhLFdBQVksU0FBUSx5QkFBUztJQUN4QyxZQUFZLEdBQW1CO1FBQzdCLEtBQUssQ0FBQyxXQUFXLENBQUMsSUFBSSxFQUFFLEdBQUcsRUFBRSxHQUFHLENBQUMsQ0FBQztJQUNwQyxDQUFDO0NBQ0Y7QUFKRCxrQ0FJQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJhc2VFcnJvciB9IGZyb20gXCJAZGVjYWYtdHMvZGItZGVjb3JhdG9yc1wiO1xuXG5leHBvcnQgY2xhc3MgUXVlcnlFcnJvciBleHRlbmRzIEJhc2VFcnJvciB7XG4gIGNvbnN0cnVjdG9yKG1zZzogc3RyaW5nIHwgRXJyb3IpIHtcbiAgICBzdXBlcihRdWVyeUVycm9yLm5hbWUsIG1zZywgNTAwKTtcbiAgfVxufVxuXG5leHBvcnQgY2xhc3MgUGFnaW5nRXJyb3IgZXh0ZW5kcyBCYXNlRXJyb3Ige1xuICBjb25zdHJ1Y3Rvcihtc2c6IHN0cmluZyB8IEVycm9yKSB7XG4gICAgc3VwZXIoUGFnaW5nRXJyb3IubmFtZSwgbXNnLCA1MDApO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3F1ZXJ5L2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwyREFBb0Q7QUFFcEQ7Ozs7OztHQU1HO0FBQ0gsTUFBYSxVQUFXLFNBQVEseUJBQVM7SUFDdkMsWUFBWSxHQUFtQjtRQUM3QixLQUFLLENBQUMsVUFBVSxDQUFDLElBQUksRUFBRSxHQUFHLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDbkMsQ0FBQztDQUNGO0FBSkQsZ0NBSUM7QUFFRDs7Ozs7O0dBTUc7QUFDSCxNQUFhLFdBQVksU0FBUSx5QkFBUztJQUN4QyxZQUFZLEdBQW1CO1FBQzdCLEtBQUssQ0FBQyxXQUFXLENBQUMsSUFBSSxFQUFFLEdBQUcsRUFBRSxHQUFHLENBQUMsQ0FBQztJQUNwQyxDQUFDO0NBQ0Y7QUFKRCxrQ0FJQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJhc2VFcnJvciB9IGZyb20gXCJAZGVjYWYtdHMvZGItZGVjb3JhdG9yc1wiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBFcnJvciB0aHJvd24gZHVyaW5nIHF1ZXJ5IG9wZXJhdGlvbnNcbiAqIEBzdW1tYXJ5IFJlcHJlc2VudHMgZXJyb3JzIHRoYXQgb2NjdXIgZHVyaW5nIHF1ZXJ5IGJ1aWxkaW5nIG9yIGV4ZWN1dGlvblxuICogQHBhcmFtIHtzdHJpbmcgfCBFcnJvcn0gbXNnIC0gVGhlIGVycm9yIG1lc3NhZ2Ugb3IgRXJyb3Igb2JqZWN0XG4gKiBAY2xhc3MgUXVlcnlFcnJvclxuICogQGNhdGVnb3J5IEVycm9yc1xuICovXG5leHBvcnQgY2xhc3MgUXVlcnlFcnJvciBleHRlbmRzIEJhc2VFcnJvciB7XG4gIGNvbnN0cnVjdG9yKG1zZzogc3RyaW5nIHwgRXJyb3IpIHtcbiAgICBzdXBlcihRdWVyeUVycm9yLm5hbWUsIG1zZywgNTAwKTtcbiAgfVxufVxuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBFcnJvciB0aHJvd24gZHVyaW5nIHBhZ2luYXRpb24gb3BlcmF0aW9uc1xuICogQHN1bW1hcnkgUmVwcmVzZW50cyBlcnJvcnMgdGhhdCBvY2N1ciBkdXJpbmcgcGFnaW5hdGlvbiBzZXR1cCBvciBleGVjdXRpb25cbiAqIEBwYXJhbSB7c3RyaW5nIHwgRXJyb3J9IG1zZyAtIFRoZSBlcnJvciBtZXNzYWdlIG9yIEVycm9yIG9iamVjdFxuICogQGNsYXNzIFBhZ2luZ0Vycm9yXG4gKiBAY2F0ZWdvcnkgRXJyb3JzXG4gKi9cbmV4cG9ydCBjbGFzcyBQYWdpbmdFcnJvciBleHRlbmRzIEJhc2VFcnJvciB7XG4gIGNvbnN0cnVjdG9yKG1zZzogc3RyaW5nIHwgRXJyb3IpIHtcbiAgICBzdXBlcihQYWdpbmdFcnJvci5uYW1lLCBtc2csIDUwMCk7XG4gIH1cbn1cbiJdfQ==

package/lib/query/errors.d.ts

@@ -1,7 +1,21 @@
 import { BaseError } from "@decaf-ts/db-decorators";
+/**
+ * @description Error thrown during query operations
+ * @summary Represents errors that occur during query building or execution
+ * @param {string | Error} msg - The error message or Error object
+ * @class QueryError
+ * @category Errors
+ */
 export declare class QueryError extends BaseError {
     constructor(msg: string | Error);
 }
+/**
+ * @description Error thrown during pagination operations
+ * @summary Represents errors that occur during pagination setup or execution
+ * @param {string | Error} msg - The error message or Error object
+ * @class PagingError
+ * @category Errors
+ */
 export declare class PagingError extends BaseError {
     constructor(msg: string | Error);
 }

package/lib/query/options.cjs

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"options.js","sourceRoot":"","sources":["../../src/query/options.ts"],"names":[],"mappings":"","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\";\nimport { Paginatable } from \"../interfaces/Paginatable\";\n\n/**\n * @summary GroupBy Option interface\n * @description Exposes the GROUP BY method and remaining options\n *\n * @interface GroupByOption\n */\nexport interface GroupByOption<M extends Model, R> extends Executor<R> {\n  groupBy(selector: GroupBySelector<M>): Executor<R>;\n}\n/**\n * @summary Offset Option interface\n * @description Exposes the OFFSET method and remaining options\n *\n * @interface GroupByOption\n */\nexport interface OffsetOption<R> extends Executor<R> {\n  offset(selector: OffsetSelector): Executor<R>;\n}\n/**\n * @summary Limit Option interface\n * @description Exposes the LIMIT method and remaining options\n *\n * @interface LimitOption\n */\nexport interface LimitOption<M extends Model, R>\n  extends Executor<R>,\n    Paginatable<M, R, any> {\n  limit(selector: LimitSelector): OffsetOption<R>;\n}\n/**\n * @summary OrderBy Option interface\n * @description Exposes the ORDER BY method and remaining options\n *\n * @interface OrderByOption\n */\nexport interface OrderByOption<M extends Model, R>\n  extends Executor<R>,\n    Paginatable<M, R, any> {\n  orderBy(selector: OrderBySelector<M>): LimitOption<M, R> & OffsetOption<R>;\n}\n/**\n * @summary OrderBy Option interface\n * @description Exposes the ORDER BY method and remaining options\n *\n * @interface ThenByOption\n */\nexport interface ThenByOption<M extends Model, R>\n  extends LimitOption<M, R>,\n    OffsetOption<R>,\n    Executor<R>,\n    Paginatable<M, R, any> {\n  thenBy(selector: OrderBySelector<M>): ThenByOption<M, R>;\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 */\nexport interface OrderAndGroupOption<M extends Model, R>\n  extends OrderByOption<M, R>,\n    Executor<R>,\n    GroupByOption<M, R>,\n    LimitOption<M, R>,\n    OffsetOption<R> {}\n/**\n * @summary Where Option interface\n * @description Exposes the WHERE method and remaining options\n *\n * @interface WhereOption\n * @extends OrderAndGroupOption\n */\nexport interface WhereOption<M extends Model, R>\n  extends OrderAndGroupOption<M, R> {\n  /**\n   * @summary filter the records by a condition\n   *\n   * @param {Condition} condition\n   * @method\n   */\n  where(condition: Condition<M>): OrderAndGroupOption<M, R>;\n}\n\n/**\n * @summary From Option Interface\n * @description Exposes the FROM method and remaining options\n *\n * @interface FromOption\n */\nexport interface FromOption<M extends Model, R> {\n  /**\n   * @summary selects records from a table\n   *\n   * @param {Constructor} tableName\n   * @method\n   */\n  from(tableName: Constructor<M> | string): WhereOption<M, R>;\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 */\nexport interface DistinctOption<M extends Model, R> extends FromOption<M, R> {}\n\n/**\n * @summary Max Option Interface\n * @description Exposes the remaining options after a MAX\n *\n * @interface MaxOption\n * @extends FromOption\n */\nexport interface MaxOption<M extends Model, R> extends FromOption<M, R> {}\n\n/**\n * @summary Min Option Interface\n * @description Exposes the remaining options after a MIN\n *\n * @interface MinOption\n * @extends FromOption\n */\nexport interface MinOption<M extends Model, R> extends FromOption<M, R> {}\n\n/**\n * @summary Count Option Interface\n * @description Exposes the remaining options after a COUNT\n *\n * @interface CountOption\n * @extends FromOption\n */\nexport interface CountOption<M extends Model, R> extends FromOption<M, R> {}\n\n/**\n * @summary Select Option Interface\n * @description Exposes the remaining options after a SELECT\n *\n * @interface SelectOption\n * @extends FromOption\n */\nexport interface SelectOption<M extends Model, R> extends FromOption<M, R> {\n  distinct<S extends SelectSelector<M>>(selector: S): DistinctOption<M, M[S][]>;\n\n  max<S extends SelectSelector<M>>(selector: S): MaxOption<M, M[S]>;\n\n  min<S extends SelectSelector<M>>(selector: S): MinOption<M, M[S]>;\n\n  count<S extends SelectSelector<M>>(selector?: S): CountOption<M, number>;\n}\n\n/**\n * @summary Into Option Interface\n * @description Exposes the remaining options after an INTO\n *\n * @interface IntoOption\n */\nexport interface IntoOption<M extends Model, R> {\n  values(...models: M[]): Executor<R>;\n\n  where(condition: Condition<M>): Executor<R>;\n}\n/**\n * @summary Valuest Option Interface\n * @description Exposes the remaining options after a VALUES\n *\n * @interface ValuesOption\n */\nexport interface ValuesOption<M extends Model> extends Executor<M> {}\n/**\n * @summary Insert Option Interface\n * @description Exposes the remaining options after an INSERT\n *\n * @interface InsertOption\n */\nexport interface InsertOption<M extends Model, R = void> {\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, R>;\n}\n\n/**\n * @summary {@link Operator} Option Interface\n * @description Exposes the available operators for a {@link Condition}\n *\n * @interface AttributeOption\n */\nexport interface AttributeOption<M extends Model> {\n  /**\n   * @summary Test equality\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  eq(val: any): Condition<M>;\n  /**\n   * @summary Test difference\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  dif(val: any): Condition<M>;\n  /**\n   * @summary Test greater than\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  gt(val: any): Condition<M>;\n  /**\n   * @summary Test lower than\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  lt(val: any): Condition<M>;\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<M>;\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<M>;\n  /**\n   * @summary Test value in a range of values\n   * @param {any[]} val\n   */\n  in(val: any[]): Condition<M>;\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<M>;\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 */\nexport interface ConditionBuilderOption<M extends Model> {\n  attribute(attr: keyof M): AttributeOption<M>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"options.js","sourceRoot":"","sources":["../../src/query/options.ts"],"names":[],"mappings":"","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\";\nimport { Paginatable } from \"../interfaces/Paginatable\";\n\n/**\n * @summary GroupBy Option interface\n * @description Exposes the GROUP BY method and remaining options\n *\n * @interface GroupByOption\n * @memberOf module:core\n */\nexport interface GroupByOption<M extends Model, R> extends Executor<R> {\n  groupBy(selector: GroupBySelector<M>): Executor<R>;\n}\n/**\n * @summary Offset Option interface\n * @description Exposes the OFFSET method and remaining options\n *\n * @interface GroupByOption\n * @memberOf module:core\n */\nexport interface OffsetOption<R> extends Executor<R> {\n  offset(selector: OffsetSelector): Executor<R>;\n}\n/**\n * @summary Limit Option interface\n * @description Exposes the LIMIT method and remaining options\n *\n * @interface LimitOption\n * @memberOf module:core\n */\nexport interface LimitOption<M extends Model, R>\n  extends Executor<R>,\n    Paginatable<M, R, any> {\n  limit(selector: LimitSelector): OffsetOption<R>;\n}\n/**\n * @summary OrderBy Option interface\n * @description Exposes the ORDER BY method and remaining options\n *\n * @interface OrderByOption\n * @memberOf module:core\n */\nexport interface OrderByOption<M extends Model, R>\n  extends Executor<R>,\n    Paginatable<M, R, any> {\n  orderBy(selector: OrderBySelector<M>): LimitOption<M, R> & OffsetOption<R>;\n}\n/**\n * @summary OrderBy Option interface\n * @description Exposes the ORDER BY method and remaining options\n *\n * @interface ThenByOption\n * @memberOf module:core\n */\nexport interface ThenByOption<M extends Model, R>\n  extends LimitOption<M, R>,\n    OffsetOption<R>,\n    Executor<R>,\n    Paginatable<M, R, any> {\n  thenBy(selector: OrderBySelector<M>): ThenByOption<M, R>;\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 * @memberOf module:core\n */\nexport interface OrderAndGroupOption<M extends Model, R>\n  extends OrderByOption<M, R>,\n    Executor<R>,\n    GroupByOption<M, R>,\n    LimitOption<M, R>,\n    OffsetOption<R> {}\n/**\n * @summary Where Option interface\n * @description Exposes the WHERE method and remaining options\n *\n * @interface WhereOption\n * @extends OrderAndGroupOption\n * @memberOf module:core\n */\nexport interface WhereOption<M extends Model, R>\n  extends OrderAndGroupOption<M, R> {\n  /**\n   * @summary filter the records by a condition\n   *\n   * @param {Condition} condition\n   * @method\n   */\n  where(condition: Condition<M>): OrderAndGroupOption<M, R>;\n}\n\n/**\n * @summary From Option Interface\n * @description Exposes the FROM method and remaining options\n *\n * @interface FromOption\n * @memberOf module:core\n */\nexport interface FromOption<M extends Model, R> {\n  /**\n   * @summary selects records from a table\n   *\n   * @param {Constructor} tableName\n   * @method\n   */\n  from(tableName: Constructor<M> | string): WhereOption<M, R>;\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 * @memberOf module:core\n */\nexport interface DistinctOption<M extends Model, R> extends FromOption<M, R> {}\n\n/**\n * @summary Max Option Interface\n * @description Exposes the remaining options after a MAX\n *\n * @interface MaxOption\n * @extends FromOption\n * @memberOf module:core\n */\nexport interface MaxOption<M extends Model, R> extends FromOption<M, R> {}\n\n/**\n * @summary Min Option Interface\n * @description Exposes the remaining options after a MIN\n *\n * @interface MinOption\n * @extends FromOption\n * @memberOf module:core\n */\nexport interface MinOption<M extends Model, R> extends FromOption<M, R> {}\n\n/**\n * @summary Count Option Interface\n * @description Exposes the remaining options after a COUNT\n *\n * @interface CountOption\n * @extends FromOption\n * @memberOf module:core\n */\nexport interface CountOption<M extends Model, R> extends FromOption<M, R> {}\n\n/**\n * @summary Select Option Interface\n * @description Exposes the remaining options after a SELECT\n *\n * @interface SelectOption\n * @extends FromOption\n * @memberOf module:core\n */\nexport interface SelectOption<M extends Model, R> extends FromOption<M, R> {\n  distinct<S extends SelectSelector<M>>(selector: S): DistinctOption<M, M[S][]>;\n\n  max<S extends SelectSelector<M>>(selector: S): MaxOption<M, M[S]>;\n\n  min<S extends SelectSelector<M>>(selector: S): MinOption<M, M[S]>;\n\n  count<S extends SelectSelector<M>>(selector?: S): CountOption<M, number>;\n}\n\n/**\n * @summary Into Option Interface\n * @description Exposes the remaining options after an INTO\n *\n * @interface IntoOption\n * @memberOf module:core\n */\nexport interface IntoOption<M extends Model, R> {\n  values(...models: M[]): Executor<R>;\n\n  where(condition: Condition<M>): Executor<R>;\n}\n/**\n * @summary Valuest Option Interface\n * @description Exposes the remaining options after a VALUES\n *\n * @interface ValuesOption\n * @memberOf module:core\n */\nexport interface ValuesOption<M extends Model> extends Executor<M> {}\n/**\n * @summary Insert Option Interface\n * @description Exposes the remaining options after an INSERT\n *\n * @interface InsertOption\n * @memberOf module:core\n */\nexport interface InsertOption<M extends Model, R = void> {\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, R>;\n}\n\n/**\n * @summary {@link Operator} Option Interface\n * @description Exposes the available operators for a {@link Condition}\n *\n * @interface AttributeOption\n * @memberOf module:core\n */\nexport interface AttributeOption<M extends Model> {\n  /**\n   * @summary Test equality\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  eq(val: any): Condition<M>;\n  /**\n   * @summary Test difference\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  dif(val: any): Condition<M>;\n  /**\n   * @summary Test greater than\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  gt(val: any): Condition<M>;\n  /**\n   * @summary Test lower than\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  lt(val: any): Condition<M>;\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<M>;\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<M>;\n  /**\n   * @summary Test value in a range of values\n   * @param {any[]} val\n   */\n  in(val: any[]): Condition<M>;\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<M>;\n}\n/**\n * @description The starting point for creating query conditions\n * @summary Exposes the available operations for building database query conditions\n * @template M - The model type this condition builder operates on\n * @interface ConditionBuilderOption\n * @memberOf module:core\n */\nexport interface ConditionBuilderOption<M extends Model> {\n  attribute(attr: keyof M): AttributeOption<M>;\n}\n"]}