@decaf-ts/core 0.5.0 → 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;
@@ -14,16 +70,14 @@ class Paginator {
     }
     get statement() {
         if (!this._statement)
-            this._statement = this.prepare(this._rawStatement);
+            this._statement = this.prepare(this.query);
         return this._statement;
     }
-    get adapter() {
-        return this.stat.getAdapter();
-    }
-    constructor(stat, size, _rawStatement) {
-        this.stat = stat;
+    constructor(adapter, query, size, clazz) {
+        this.adapter = adapter;
+        this.query = query;
         this.size = size;
-        this._rawStatement = _rawStatement;
+        this.clazz = clazz;
     }
     async next() {
         return this.page(this.current + 1);
@@ -33,11 +87,11 @@ class Paginator {
     }
     validatePage(page) {
         if (page < 1 || !Number.isInteger(page))
-            throw new errors_1.PagingError("page number cannot be under 1 and must be an integer");
+            throw new errors_1.PagingError("Page number cannot be under 1 and must be an integer");
         if (typeof this._totalPages !== "undefined" && page > this._totalPages)
-            throw new errors_1.PagingError(`Requested more pages than available. Total pages: ${this._totalPages}`);
+            throw new errors_1.PagingError(`Only ${this._totalPages} are available. Cannot go to page ${page}`);
         return page;
     }
 }
 exports.Paginator = Paginator;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUGFnaW5hdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3F1ZXJ5L1BhZ2luYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx5Q0FBdUM7QUFJdkM7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0F1REc7QUFDSCxNQUFzQixTQUFTO0lBUTdCLElBQUksT0FBTztRQUNULE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQztJQUMzQixDQUFDO0lBRUQsSUFBSSxLQUFLO1FBQ1AsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDO0lBQzFCLENBQUM7SUFFRCxJQUFJLEtBQUs7UUFDUCxPQUFPLElBQUksQ0FBQyxZQUFZLENBQUM7SUFDM0IsQ0FBQztJQUVELElBQWMsU0FBUztRQUNyQixJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVU7WUFBRSxJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ2pFLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQztJQUN6QixDQUFDO0lBRUQsWUFDcUIsT0FBa0MsRUFDbEMsS0FBUSxFQUNsQixJQUFZLEVBQ0YsS0FBcUI7UUFIckIsWUFBTyxHQUFQLE9BQU8sQ0FBMkI7UUFDbEMsVUFBSyxHQUFMLEtBQUssQ0FBRztRQUNsQixTQUFJLEdBQUosSUFBSSxDQUFRO1FBQ0YsVUFBSyxHQUFMLEtBQUssQ0FBZ0I7SUFDdkMsQ0FBQztJQUlKLEtBQUssQ0FBQyxJQUFJO1FBQ1IsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDckMsQ0FBQztJQUVELEtBQUssQ0FBQyxRQUFRO1FBQ1osT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDckMsQ0FBQztJQUVTLFlBQVksQ0FBQyxJQUFZO1FBQ2pDLElBQUksSUFBSSxHQUFHLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDO1lBQ3JDLE1BQU0sSUFBSSxvQkFBVyxDQUNuQixzREFBc0QsQ0FDdkQsQ0FBQztRQUNKLElBQUksT0FBTyxJQUFJLENBQUMsV0FBVyxLQUFLLFdBQVcsSUFBSSxJQUFJLEdBQUcsSUFBSSxDQUFDLFdBQVc7WUFDcEUsTUFBTSxJQUFJLG9CQUFXLENBQ25CLFFBQVEsSUFBSSxDQUFDLFdBQVcscUNBQXFDLElBQUksRUFBRSxDQUNwRSxDQUFDO1FBQ0osT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0NBR0Y7QUF2REQsOEJBdURDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGFnaW5nRXJyb3IgfSBmcm9tIFwiLi9lcnJvcnNcIjtcbmltcG9ydCB7IEFkYXB0ZXIgfSBmcm9tIFwiLi4vcGVyc2lzdGVuY2VcIjtcbmltcG9ydCB7IENvbnN0cnVjdG9yLCBNb2RlbCB9IGZyb20gXCJAZGVjYWYtdHMvZGVjb3JhdG9yLXZhbGlkYXRpb25cIjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gSGFuZGxlcyBwYWdpbmF0aW9uIGZvciBkYXRhYmFzZSBxdWVyaWVzXG4gKiBAc3VtbWFyeSBQcm92aWRlcyBmdW5jdGlvbmFsaXR5IGZvciBuYXZpZ2F0aW5nIHRocm91Z2ggcGFnaW5hdGVkIHF1ZXJ5IHJlc3VsdHNcbiAqIFxuICogVGhpcyBhYnN0cmFjdCBjbGFzcyBtYW5hZ2VzIHRoZSBzdGF0ZSBhbmQgbmF2aWdhdGlvbiBvZiBwYWdpbmF0ZWQgZGF0YWJhc2UgcXVlcnkgcmVzdWx0cy5cbiAqIEl0IHRyYWNrcyB0aGUgY3VycmVudCBwYWdlLCB0b3RhbCBwYWdlcywgYW5kIHJlY29yZCBjb3VudCwgYW5kIHByb3ZpZGVzIG1ldGhvZHMgZm9yXG4gKiBtb3ZpbmcgYmV0d2VlbiBwYWdlcy5cbiAqIFxuICogQHRlbXBsYXRlIE0gLSBUaGUgbW9kZWwgdHlwZSB0aGlzIHBhZ2luYXRvciBvcGVyYXRlcyBvblxuICogQHRlbXBsYXRlIFIgLSBUaGUgcmV0dXJuIHR5cGUgb2YgdGhlIHBhZ2luYXRlZCBxdWVyeSAoZGVmYXVsdHMgdG8gTVtdKVxuICogQHRlbXBsYXRlIFEgLSBUaGUgcXVlcnkgdHlwZSAoZGVmYXVsdHMgdG8gYW55KVxuICogQHBhcmFtIHtBZGFwdGVyPGFueSwgUSwgYW55LCBhbnk+fSBhZGFwdGVyIC0gVGhlIGRhdGFiYXNlIGFkYXB0ZXIgdG8gdXNlIGZvciBleGVjdXRpbmcgcXVlcmllc1xuICogQHBhcmFtIHtRfSBxdWVyeSAtIFRoZSBxdWVyeSB0byBwYWdpbmF0ZVxuICogQHBhcmFtIHtudW1iZXJ9IHNpemUgLSBUaGUgbnVtYmVyIG9mIHJlY29yZHMgcGVyIHBhZ2VcbiAqIEBwYXJhbSB7Q29uc3RydWN0b3I8TT59IGNsYXp6IC0gVGhlIGNvbnN0cnVjdG9yIGZvciB0aGUgbW9kZWwgdHlwZVxuICogQGNsYXNzIFBhZ2luYXRvclxuICogQGV4YW1wbGVcbiAqIC8vIENyZWF0ZSBhIHBhZ2luYXRvciBmb3IgYSB1c2VyIHF1ZXJ5XG4gKiBjb25zdCB1c2VyUXVlcnkgPSBkYi5zZWxlY3QoKS5mcm9tKFVzZXIpO1xuICogY29uc3QgcGFnaW5hdG9yID0gYXdhaXQgdXNlclF1ZXJ5LnBhZ2luYXRlKDEwKTsgLy8gMTAgdXNlcnMgcGVyIHBhZ2VcbiAqIFxuICogLy8gR2V0IHRoZSBmaXJzdCBwYWdlIG9mIHJlc3VsdHNcbiAqIGNvbnN0IGZpcnN0UGFnZSA9IGF3YWl0IHBhZ2luYXRvci5wYWdlKDEpO1xuICogXG4gKiAvLyBOYXZpZ2F0ZSB0byB0aGUgbmV4dCBwYWdlXG4gKiBjb25zdCBzZWNvbmRQYWdlID0gYXdhaXQgcGFnaW5hdG9yLm5leHQoKTtcbiAqIFxuICogLy8gR2V0IGluZm9ybWF0aW9uIGFib3V0IHRoZSBwYWdpbmF0aW9uXG4gKiBjb25zb2xlLmxvZyhgUGFnZSAke3BhZ2luYXRvci5jdXJyZW50fSBvZiAke3BhZ2luYXRvci50b3RhbH0sICR7cGFnaW5hdG9yLmNvdW50fSB0b3RhbCByZWNvcmRzYCk7XG4gKiBcbiAqIEBtZXJtYWlkXG4gKiBzZXF1ZW5jZURpYWdyYW1cbiAqICAgcGFydGljaXBhbnQgQ2xpZW50XG4gKiAgIHBhcnRpY2lwYW50IFBhZ2luYXRvclxuICogICBwYXJ0aWNpcGFudCBBZGFwdGVyXG4gKiAgIHBhcnRpY2lwYW50IERhdGFiYXNlXG4gKiAgIFxuICogICBDbGllbnQtPj5QYWdpbmF0b3I6IG5ldyBQYWdpbmF0b3IoYWRhcHRlciwgcXVlcnksIHNpemUsIGNsYXp6KVxuICogICBDbGllbnQtPj5QYWdpbmF0b3I6IHBhZ2UoMSlcbiAqICAgUGFnaW5hdG9yLT4+UGFnaW5hdG9yOiB2YWxpZGF0ZVBhZ2UoMSlcbiAqICAgUGFnaW5hdG9yLT4+UGFnaW5hdG9yOiBwcmVwYXJlKHF1ZXJ5KVxuICogICBQYWdpbmF0b3ItPj5BZGFwdGVyOiBleGVjdXRlIHF1ZXJ5IHdpdGggcGFnaW5hdGlvblxuICogICBBZGFwdGVyLT4+RGF0YWJhc2U6IGV4ZWN1dGUgcXVlcnlcbiAqICAgRGF0YWJhc2UtLT4+QWRhcHRlcjogcmV0dXJuIHJlc3VsdHNcbiAqICAgQWRhcHRlci0tPj5QYWdpbmF0b3I6IHJldHVybiByZXN1bHRzXG4gKiAgIFBhZ2luYXRvci0tPj5DbGllbnQ6IHJldHVybiBwYWdlIHJlc3VsdHNcbiAqICAgXG4gKiAgIENsaWVudC0+PlBhZ2luYXRvcjogbmV4dCgpXG4gKiAgIFBhZ2luYXRvci0+PlBhZ2luYXRvcjogcGFnZShjdXJyZW50ICsgMSlcbiAqICAgUGFnaW5hdG9yLT4+UGFnaW5hdG9yOiB2YWxpZGF0ZVBhZ2UoY3VycmVudCArIDEpXG4gKiAgIFBhZ2luYXRvci0+PkFkYXB0ZXI6IGV4ZWN1dGUgcXVlcnkgd2l0aCBwYWdpbmF0aW9uXG4gKiAgIEFkYXB0ZXItPj5EYXRhYmFzZTogZXhlY3V0ZSBxdWVyeVxuICogICBEYXRhYmFzZS0tPj5BZGFwdGVyOiByZXR1cm4gcmVzdWx0c1xuICogICBBZGFwdGVyLS0+PlBhZ2luYXRvcjogcmV0dXJuIHJlc3VsdHNcbiAqICAgUGFnaW5hdG9yLS0+PkNsaWVudDogcmV0dXJuIHBhZ2UgcmVzdWx0c1xuICovXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgUGFnaW5hdG9yPE0gZXh0ZW5kcyBNb2RlbCwgUiA9IE1bXSwgUSA9IGFueT4ge1xuICBwcm90ZWN0ZWQgX2N1cnJlbnRQYWdlITogbnVtYmVyO1xuICBwcm90ZWN0ZWQgX3RvdGFsUGFnZXMhOiBudW1iZXI7XG4gIHByb3RlY3RlZCBfcmVjb3JkQ291bnQhOiBudW1iZXI7XG4gIHByb3RlY3RlZCBsaW1pdCE6IG51bWJlcjtcblxuICBwcml2YXRlIF9zdGF0ZW1lbnQ/OiBRO1xuXG4gIGdldCBjdXJyZW50KCkge1xuICAgIHJldHVybiB0aGlzLl9jdXJyZW50UGFnZTtcbiAgfVxuXG4gIGdldCB0b3RhbCgpIHtcbiAgICByZXR1cm4gdGhpcy5fdG90YWxQYWdlcztcbiAgfVxuXG4gIGdldCBjb3VudCgpOiBudW1iZXIge1xuICAgIHJldHVybiB0aGlzLl9yZWNvcmRDb3VudDtcbiAgfVxuXG4gIHByb3RlY3RlZCBnZXQgc3RhdGVtZW50KCkge1xuICAgIGlmICghdGhpcy5fc3RhdGVtZW50KSB0aGlzLl9zdGF0ZW1lbnQgPSB0aGlzLnByZXBhcmUodGhpcy5xdWVyeSk7XG4gICAgcmV0dXJuIHRoaXMuX3N0YXRlbWVudDtcbiAgfVxuXG4gIHByb3RlY3RlZCBjb25zdHJ1Y3RvcihcbiAgICBwcm90ZWN0ZWQgcmVhZG9ubHkgYWRhcHRlcjogQWRhcHRlcjxhbnksIFEsIGFueSwgYW55PixcbiAgICBwcm90ZWN0ZWQgcmVhZG9ubHkgcXVlcnk6IFEsXG4gICAgcmVhZG9ubHkgc2l6ZTogbnVtYmVyLFxuICAgIHByb3RlY3RlZCByZWFkb25seSBjbGF6ejogQ29uc3RydWN0b3I8TT5cbiAgKSB7fVxuXG4gIHByb3RlY3RlZCBhYnN0cmFjdCBwcmVwYXJlKHJhd1N0YXRlbWVudDogUSk6IFE7XG5cbiAgYXN5bmMgbmV4dCgpIHtcbiAgICByZXR1cm4gdGhpcy5wYWdlKHRoaXMuY3VycmVudCArIDEpO1xuICB9XG5cbiAgYXN5bmMgcHJldmlvdXMoKSB7XG4gICAgcmV0dXJuIHRoaXMucGFnZSh0aGlzLmN1cnJlbnQgLSAxKTtcbiAgfVxuXG4gIHByb3RlY3RlZCB2YWxpZGF0ZVBhZ2UocGFnZTogbnVtYmVyKSB7XG4gICAgaWYgKHBhZ2UgPCAxIHx8ICFOdW1iZXIuaXNJbnRlZ2VyKHBhZ2UpKVxuICAgICAgdGhyb3cgbmV3IFBhZ2luZ0Vycm9yKFxuICAgICAgICBcIlBhZ2UgbnVtYmVyIGNhbm5vdCBiZSB1bmRlciAxIGFuZCBtdXN0IGJlIGFuIGludGVnZXJcIlxuICAgICAgKTtcbiAgICBpZiAodHlwZW9mIHRoaXMuX3RvdGFsUGFnZXMgIT09IFwidW5kZWZpbmVkXCIgJiYgcGFnZSA+IHRoaXMuX3RvdGFsUGFnZXMpXG4gICAgICB0aHJvdyBuZXcgUGFnaW5nRXJyb3IoXG4gICAgICAgIGBPbmx5ICR7dGhpcy5fdG90YWxQYWdlc30gYXJlIGF2YWlsYWJsZS4gQ2Fubm90IGdvIHRvIHBhZ2UgJHtwYWdlfWBcbiAgICAgICk7XG4gICAgcmV0dXJuIHBhZ2U7XG4gIH1cblxuICBhYnN0cmFjdCBwYWdlKHBhZ2U/OiBudW1iZXIpOiBQcm9taXNlPFJbXT47XG59XG4iXX0=

package/lib/query/Paginator.d.ts

@@ -1,8 +1,66 @@
-import { Statement } from "./Statement";
-export declare abstract class Paginator<V, Q> {
-    protected stat: Statement<Q>;
+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;
     readonly size: number;
-    protected readonly _rawStatement: Q;
+    protected readonly clazz: Constructor<M>;
     protected _currentPage: number;
     protected _totalPages: number;
     protected _recordCount: number;
@@ -11,12 +69,11 @@ export declare abstract class Paginator<V, Q> {
     get current(): number;
     get total(): number;
     get count(): number;
-    get statement(): Q;
-    protected get adapter(): import("..").Adapter<any, Q, any, any>;
-    protected constructor(stat: Statement<Q>, size: number, _rawStatement: Q);
+    protected get statement(): Q;
+    protected constructor(adapter: Adapter<any, Q, any, any>, query: Q, size: number, clazz: Constructor<M>);
     protected abstract prepare(rawStatement: Q): Q;
-    next(): Promise<V[]>;
-    previous(): Promise<V[]>;
+    next(): Promise<R[]>;
+    previous(): Promise<R[]>;
     protected validatePage(page: number): number;
-    abstract page(page?: number, ...args: any[]): Promise<V[]>;
+    abstract page(page?: number): Promise<R[]>;
 }

package/lib/query/Statement.cjs

@@ -8,159 +8,212 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var _a, _b, _c, _d;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Statement = void 0;
 const decorator_validation_1 = require("@decaf-ts/decorator-validation");
-const constants_1 = require("./constants.cjs");
-const errors_1 = require("./errors.cjs");
-const validators_1 = require("./../validators/index.cjs");
-const persistence_1 = require("./../persistence/index.cjs");
+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");
 /**
- * @summary Statement Class
- * @description holds all the clauses until they can be processed
+ * @description Base class for database query statements
+ * @summary Provides a foundation for building and executing database queries
  *
- * @param {ModelArg} [statement]
+ * 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
- * @extends Model
- * @implements Executor
- * @implements RawExecutor
+ * @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
  *
- * @category Query
+ * @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 extends decorator_validation_1.Model {
-    constructor(db) {
-        super();
-        this.clauses = undefined;
-        this.target = undefined;
-        this.fullRecord = false;
-        this.type = undefined;
-        this.adapter = db;
+class Statement {
+    constructor(adapter) {
+        this.adapter = adapter;
     }
-    build() {
-        if (!this.clauses)
-            throw new errors_1.QueryError((0, decorator_validation_1.sf)("Failed to build Statement:\n{0}", "No Clauses"));
-        this.clauses.sort((c1, c2) => {
-            return c1.getPriority() - c2.getPriority();
+    select(selector) {
+        Object.defineProperty(this, "selectSelector", {
+            value: selector,
+            writable: false,
         });
-        const errors = this.hasErrors();
-        if (errors)
-            throw new errors_1.QueryError((0, decorator_validation_1.sf)("Poorly built statement: {0}", errors.toString()));
-        let query;
-        try {
-            const iterator = function (clauses, previous = {}) {
-                const c = clauses.shift();
-                if (!c)
-                    return previous;
-                const results = c.build(previous);
-                return iterator(clauses, results);
-            };
-            query = iterator(new Array(...this.clauses));
-        }
-        catch (e) {
-            throw new errors_1.QueryError(e);
-        }
-        return query;
+        return this;
+    }
+    distinct(selector) {
+        this.distinctSelector = selector;
+        return this;
+    }
+    max(selector) {
+        this.maxSelector = selector;
+        return this;
+    }
+    min(selector) {
+        this.minSelector = selector;
+        return this;
+    }
+    count(selector) {
+        this.countSelector = selector;
+        return this;
+    }
+    from(selector) {
+        this.fromSelector = (typeof selector === "string" ? decorator_validation_1.Model.get(selector) : selector);
+        if (!this.fromSelector)
+            throw new errors_1.QueryError(`Could not find selector model: ${selector}`);
+        return this;
+    }
+    where(condition) {
+        this.whereCondition = condition;
+        return this;
+    }
+    orderBy(selector) {
+        this.orderBySelector = selector;
+        return this;
+    }
+    groupBy(selector) {
+        this.groupBySelector = selector;
+        return this;
+    }
+    limit(value) {
+        this.limitSelector = value;
+        return this;
+    }
+    offset(value) {
+        this.offsetSelector = value;
+        return this;
     }
-    /**
-     * @inheritDoc
-     */
     async execute() {
         try {
             const query = this.build();
-            return this.raw(query);
+            return (await this.raw(query));
         }
         catch (e) {
             throw new db_decorators_1.InternalError(e);
         }
     }
-    async raw(rawInput, ...args) {
-        const results = await this.adapter.raw(rawInput, true, ...args);
-        if (!this.fullRecord)
+    async raw(rawInput) {
+        const results = await this.adapter.raw(rawInput);
+        if (!this.selectSelector)
             return results;
-        if (!this.target)
-            throw new db_decorators_1.InternalError("No target defined in statement. should never happen");
-        const pkAttr = (0, db_decorators_1.findPrimaryKey)(new this.target()).id;
+        const pkAttr = (0, db_decorators_1.findPrimaryKey)(new this.fromSelector()).id;
         const processor = function recordProcessor(r) {
             const id = r[pkAttr];
-            return this.adapter.revert(r, this.target, pkAttr, id);
+            return this.adapter.revert(r, this.fromSelector, pkAttr, id);
         }.bind(this);
         if (Array.isArray(results))
             return results.map(processor);
         return processor(results);
     }
-    /**
-     * @inheritDoc
-     */
-    hasErrors(...exceptions) {
-        const errors = super.hasErrors(...exceptions);
-        if (errors)
-            return errors;
-        for (const i in this.clauses) {
-            const err = this.clauses[i].hasErrors();
-            if (err)
-                return err;
-        }
-    }
-    /**
-     * @summary Adds a clause to the Statement
-     * @param {Clause} clause
-     */
-    addClause(clause) {
-        if (!this.clauses)
-            this.clauses = [];
-        const priority = clause.getPriority();
-        const currentPriority = this.clauses
-            .map((c, i) => ({ index: i, clause: c }))
-            .find((c) => c.clause.getPriority() === priority);
-        if (currentPriority) {
-            this.clauses[currentPriority.index] = clause;
-        }
-        this.clauses.push(clause);
-    }
-    getAdapter() {
-        return this.adapter;
-    }
-    /**
-     * @summary Defines the output class (when existing)
-     * @param {Constructor} clazz
-     */
-    setTarget(clazz) {
-        if (this.target)
-            throw new errors_1.QueryError((0, decorator_validation_1.sf)("Output class already defined to {0}", this.target.name));
-        this.target = clazz;
-    }
-    getTarget() {
-        if (!this.target)
-            throw new db_decorators_1.InternalError("No target defined for statement");
-        return this.target;
-    }
-    setFullRecord() {
-        this.fullRecord = true;
-    }
-    setMode(type) {
-        this.type = type;
-    }
 }
 exports.Statement = Statement;
 __decorate([
-    (0, decorator_validation_1.required)(),
-    (0, decorator_validation_1.minlength)(constants_1.MandatoryPriorities.length),
-    (0, validators_1.clauseSequence)(),
-    __metadata("design:type", Array)
-], Statement.prototype, "clauses", void 0);
+    (0, decorators_1.final)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Object)
+], Statement.prototype, "select", null);
+__decorate([
+    (0, decorators_1.final)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [typeof (_a = typeof S !== "undefined" && S) === "function" ? _a : Object]),
+    __metadata("design:returntype", Object)
+], Statement.prototype, "distinct", null);
+__decorate([
+    (0, decorators_1.final)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [typeof (_b = typeof S !== "undefined" && S) === "function" ? _b : Object]),
+    __metadata("design:returntype", Object)
+], Statement.prototype, "max", null);
+__decorate([
+    (0, decorators_1.final)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [typeof (_c = typeof S !== "undefined" && S) === "function" ? _c : Object]),
+    __metadata("design:returntype", Object)
+], Statement.prototype, "min", null);
+__decorate([
+    (0, decorators_1.final)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [typeof (_d = typeof S !== "undefined" && S) === "function" ? _d : Object]),
+    __metadata("design:returntype", Object)
+], Statement.prototype, "count", null);
+__decorate([
+    (0, decorators_1.final)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], Statement.prototype, "from", null);
+__decorate([
+    (0, decorators_1.final)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Condition_1.Condition]),
+    __metadata("design:returntype", Object)
+], Statement.prototype, "where", null);
+__decorate([
+    (0, decorators_1.final)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Object)
+], Statement.prototype, "orderBy", null);
+__decorate([
+    (0, decorators_1.final)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], Statement.prototype, "groupBy", null);
 __decorate([
-    (0, decorator_validation_1.required)(),
-    (0, decorator_validation_1.type)(["object"]),
-    __metadata("design:type", persistence_1.Adapter)
-], Statement.prototype, "adapter", void 0);
+    (0, decorators_1.final)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Object)
+], Statement.prototype, "limit", null);
 __decorate([
-    (0, decorator_validation_1.required)(),
-    __metadata("design:type", Object)
-], Statement.prototype, "target", void 0);
+    (0, decorators_1.final)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Object)
+], Statement.prototype, "offset", null);
 __decorate([
-    (0, decorator_validation_1.required)(),
-    __metadata("design:type", String)
-], Statement.prototype, "type", void 0);
-//# 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 } from \"@decaf-ts/decorator-validation\";\nimport {\n  minlength,\n  Model,\n  ModelErrorDefinition,\n  required,\n  type,\n  sf,\n} from \"@decaf-ts/decorator-validation\";\nimport { Executor, RawExecutor } from \"../interfaces\";\nimport { MandatoryPriorities, StatementType } from \"./constants\";\nimport { QueryError } from \"./errors\";\nimport { Clause } from \"./Clause\";\nimport { clauseSequence } from \"../validators\";\nimport { Adapter } from \"../persistence\";\nimport { findPrimaryKey, InternalError } from \"@decaf-ts/db-decorators\";\nimport { Paginator } from \"./Paginator\";\n\n/**\n * @summary Statement Class\n * @description holds all the clauses until they can be processed\n *\n * @param {ModelArg} [statement]\n *\n * @class Statement\n * @extends Model\n * @implements Executor\n * @implements RawExecutor\n *\n * @category Query\n */\nexport abstract class Statement<Q>\n  extends Model\n  implements Executor, RawExecutor<Q>\n{\n  @required()\n  @minlength(MandatoryPriorities.length)\n  @clauseSequence()\n  protected clauses?: Clause<any>[] = undefined;\n  @required()\n  @type([\"object\"])\n  protected adapter: Adapter<any, Q, any, any>;\n  @required()\n  protected target?: Constructor<any> = undefined;\n\n  protected fullRecord: boolean = false;\n\n  @required()\n  protected type?: string = undefined;\n\n  protected constructor(db: Adapter<any, Q, any, any>) {\n    super();\n    this.adapter = db;\n  }\n\n  protected build(): Q {\n    if (!this.clauses)\n      throw new QueryError(sf(\"Failed to build Statement:\\n{0}\", \"No Clauses\"));\n    this.clauses.sort((c1, c2) => {\n      return c1.getPriority() - c2.getPriority();\n    });\n\n    const errors = this.hasErrors();\n    if (errors)\n      throw new QueryError(\n        sf(\"Poorly built statement: {0}\", errors.toString())\n      );\n\n    let query: Q;\n    try {\n      const iterator = function (\n        clauses: Clause<any>[],\n        previous: any = {}\n      ): Q {\n        const c = clauses.shift();\n        if (!c) return previous as Q;\n        const results = c.build(previous);\n        return iterator(clauses, results as any);\n      };\n\n      query = iterator(new Array(...(this.clauses as Clause<Q>[]))) as Q;\n    } catch (e: any) {\n      throw new QueryError(e);\n    }\n\n    return query;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  async execute<Y>(): Promise<Y> {\n    try {\n      const query: Q = this.build();\n      return this.raw(query);\n    } catch (e: any) {\n      throw new InternalError(e);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  abstract paginate<Y>(size: number): Promise<Paginator<Y, Q>>;\n\n  async raw<R>(rawInput: Q, ...args: any[]): Promise<R> {\n    const results = await this.adapter.raw<R>(rawInput, true, ...args);\n    if (!this.fullRecord) return results;\n    if (!this.target)\n      throw new InternalError(\n        \"No target defined in statement. should never happen\"\n      );\n\n    const pkAttr = findPrimaryKey(new this.target() as any).id;\n\n    const processor = function recordProcessor(this: Statement<Q>, r: any) {\n      const id = r[pkAttr];\n      return this.adapter.revert(\n        r,\n        this.target as Constructor<any>,\n        pkAttr,\n        id\n      ) as any;\n    }.bind(this);\n\n    if (Array.isArray(results)) return results.map(processor) as R;\n    return processor(results) as R;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  hasErrors(...exceptions: string[]): ModelErrorDefinition | undefined {\n    const errors = super.hasErrors(...exceptions);\n    if (errors) return errors;\n\n    for (const i in this.clauses) {\n      const err = this.clauses[i as any].hasErrors();\n      if (err) return err;\n    }\n  }\n\n  /**\n   * @summary Adds a clause to the Statement\n   * @param {Clause} clause\n   */\n  addClause(clause: Clause<Q>) {\n    if (!this.clauses) this.clauses = [];\n\n    const priority = clause.getPriority();\n    const currentPriority = this.clauses\n      .map((c, i) => ({ index: i, clause: c }))\n      .find((c) => c.clause.getPriority() === priority);\n    if (currentPriority) {\n      this.clauses[currentPriority.index] = clause;\n    }\n    this.clauses.push(clause);\n  }\n\n  getAdapter(): Adapter<any, Q, any, any> {\n    return this.adapter;\n  }\n\n  /**\n   * @summary Defines the output class (when existing)\n   * @param {Constructor} clazz\n   */\n  setTarget(clazz: Constructor<any>) {\n    if (this.target)\n      throw new QueryError(\n        sf(\"Output class already defined to {0}\", this.target!.name)\n      );\n    this.target = clazz;\n  }\n\n  getTarget() {\n    if (!this.target)\n      throw new InternalError(\"No target defined for statement\");\n    return this.target;\n  }\n\n  setFullRecord() {\n    this.fullRecord = true;\n  }\n\n  setMode(type: StatementType) {\n    this.type = type;\n  }\n}\n"]}
+    (0, decorators_1.final)(),
+    __metadata("design:type", Function),
+    __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\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"]}