@decaf-ts/core/lib/ram/RamPaginator.cjs

Core persistence module for the decaf framework

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.RamPaginator = void 0;
const query_1 = require("./../query/index.cjs");
/**
 * @description RAM-specific paginator implementation
 * @summary Extends the base Paginator class to provide pagination functionality for RAM adapter queries.
 * This class handles the pagination of query results from the in-memory storage, allowing
 * for efficient retrieval of large result sets in smaller chunks.
 * @template M - The model type being paginated
 * @template R - The result type returned by the paginator
 * @class RamPaginator
 * @category Ram
 * @example
 * ```typescript
 * // Create a query for User model
 * const query: RawRamQuery<User> = {
 *   select: undefined, // Select all fields
 *   from: User,
 *   where: (user) => user.active === true
 * };
 *
 * // Create a paginator with page size of 10
 * const paginator = new RamPaginator<User, User>(adapter, query, 10, User);
 *
 * // Get the first page of results
 * const firstPage = await paginator.page(1);
 *
 * // Get the next page
 * const secondPage = await paginator.page(2);
 * ```
 */
class RamPaginator extends query_1.Paginator {
    constructor(adapter, query, size, clazz) {
        super(adapter, query, size, clazz);
    }
    /**
     * @description Prepares a RAM query for pagination
     * @summary Modifies the raw query statement to include pagination parameters.
     * This protected method sets the limit parameter on the query to match the page size.
     * @param {RawRamQuery<M>} rawStatement - The original query statement
     * @return {RawRamQuery<M>} The modified query with pagination parameters
     */
    prepare(rawStatement) {
        const query = Object.assign({}, rawStatement);
        query.limit = this.size;
        return query;
    }
    /**
     * @description Retrieves a specific page of results
     * @summary Executes the query with pagination parameters to retrieve a specific page of results.
     * This method calculates the appropriate skip value based on the page number and page size,
     * executes the query, and updates the current page tracking.
     * @param {number} [page=1] - The page number to retrieve (1-based)
     * @return {Promise<R[]>} A promise that resolves to an array of results for the requested page
     */
    async page(page = 1) {
        const statement = this.prepare(this.statement);
        if (!this._recordCount || !this._totalPages) {
            this._totalPages = this._recordCount = 0;
            const results = await this.adapter.raw({ ...statement, limit: undefined }) || [];
            this._recordCount = results.length;
            if (this._recordCount > 0) {
                const size = statement?.limit || this.size;
                this._totalPages = Math.ceil(this._recordCount / size);
            }
        }
        page = this.validatePage(page);
        statement.skip = (page - 1) * this.size;
        const results = await this.adapter.raw(statement);
        this._currentPage = page;
        return results;
    }
}
exports.RamPaginator = RamPaginator;
//# sourceMappingURL=data:application/json;base64,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