@rvoh/dream 1.10.0 → 1.11.0-beta.1

package/dist/cjs/src/Dream.js

@@ -909,6 +909,37 @@ class Dream {
     static async paginate(opts) {
         return await this.query().paginate(opts);
     }
+    /**
+     * Fast paginates the results of your query using cursor-based pagination,
+     * accepting a pageSize and cursor argument. This method
+     * provides better performance for large datasets by using cursor-based
+     * pagination instead of offset-based pagination.
+     *
+     * ```ts
+     * // First page
+     * const firstPage = await User.order('email').fastPaginate({ pageSize: 100 })
+     * firstPage.results
+     * // [ { User{id: 1}, User{id: 2}, ...}]
+     *
+     * firstPage.cursor
+     * // "100" (or null if no more pages)
+     *
+     * // Next page using cursor from previous result
+     * const nextPage = await User.order('email').fastPaginate({
+     *   pageSize: 100,
+     *   cursor: firstPage.cursor
+     * })
+     * ```
+     *
+     * @param opts - Fast pagination options
+     * @param opts.pageSize - the number of results per page (optional)
+     * @param opts.cursor - identifier of where to start the next page; undefined to start from the beginning; null when no more pages
+     * @returns results.cursor - identifier for the next page, or null if no more pages
+     * @returns results.results - An array of records for the current page
+     */
+    static async fastPaginate(opts) {
+        return await this.query().fastPaginate(opts);
+    }
     /**
      * Forces use of a database connection (e.g. 'primary') during the query.
      *
@@ -3221,61 +3252,31 @@ class Dream {
     load(...args) {
         return new LoadBuilder_js_1.default(this).load(...args);
     }
-    /**
-     * If the association is already loaded on the instance, it returns the loaded value
-     * immediately without making a database query. If the association is not loaded,
-     * it performs a database query to fetch the association.
-     *
-     * If a query is performed, the association is set on the model so that future calls to
-     * access this association can access the already loaded value.
-     *
-     * ```ts
-     * // return the already loaded user if it exists or fetch it from the database otherwise
-     * const user = await post.associationOrFail('user')
-     * ```
-     *
-     * @param associationName - The name of the BelongsTo or HasOne association
-     * @returns The associated model instance or null
-     */
-    async association(associationName) {
+    async association(associationName, options) {
         if (!this.loaded(associationName)) {
             const association = this.getAssociationMetadata(associationName);
+            const associationQueryOptions = options?.required && { and: options.required };
+            let scope = this.associationQuery(associationName, associationQueryOptions);
+            if (options?.passthrough)
+                scope = scope.passthrough(options.passthrough);
             if (association?.type === 'HasMany') {
-                this[associationName] = (await this.associationQuery(associationName).all());
+                this[associationName] = (await scope.all());
             }
             else {
-                this[associationName] = (await this.associationQuery(associationName).first());
+                this[associationName] = (await scope.first());
             }
         }
         return this[associationName];
     }
-    /**
-     * If the association is already loaded on the instance, it returns the loaded value
-     * immediately without making a database query. If the association is not loaded,
-     * it performs a database query to fetch the association.
-     *
-     * Unlike `association`, this method throws an exception if no associated
-     * record is found, guaranteeing a non-null result.
-     *
-     * If a query is performed, the association is set on the model so that future calls to
-     * access this association can access the already loaded value.
-     *
-     * ```ts
-     * // return the already loaded user if it exists or fetch it from the database otherwise,
-     * // throwing RecordNotFound either way if the associated model does not exist
-     * const user = await post.associationOrFail('user')
-     * ```
-     *
-     * @param associationName - The name of the BelongsTo or HasOne association
-     * @returns The associated model instance (never null)
-     * @throws RecordNotFound if no associated record exists
-     */
-    async associationOrFail(associationName) {
-        const response = await this.association(associationName);
+    async associationOrFail(associationName, options) {
+        const response = await this.association(associationName, options);
         if (this[associationName] === null)
             throw new RecordNotFound_js_1.default(this['sanitizedConstructorName']);
         return response;
     }
+    ///////////////////
+    // end:associationOrFail
+    ///////////////////
     /**
      * Recursively loads all Dream associations referenced by `rendersOne` and `rendersMany`
      * in a DreamSerializer. This traverses the entire content tree of serializers to automatically

package/dist/cjs/src/dream/DreamClassTransactionBuilder.js

@@ -38,38 +38,6 @@ class DreamClassTransactionBuilder {
     async all(options = {}) {
         return this.queryInstance().all(options);
     }
-    /**
-     * Paginates the results of your query, accepting a pageSize and page argument,
-     * which it uses to segment your query into pages, leveraging limit and offset
-     * to deliver your query to you in pages.
-     *
-     * ```ts
-     * await ApplicationModel.transaction(async txn => {
-     *   const paginated = await User.txn(txn).paginate({ pageSize: 100, page: 2 })
-     *   paginated.results
-     *   // [ { User{id: 101}, User{id: 102}, ...}]
-     *
-     *   paginated.recordCount
-     *   // 350
-     *
-     *   paginated.pageCount
-     *   // 4
-     *
-     *   paginated.currentPage
-     *   // 2
-     * })
-     * ```
-     *
-     * @param opts.page - the page number that you want to fetch results for
-     * @param opts.pageSize - the number of results per page (optional)
-     * @returns results.recordCount - A number representing the total number of records matching your query
-     * @returns results.pageCount - The number of pages needed to encapsulate all the matching records
-     * @returns results.currentPage - The current page (same as what is provided in the paginate args)
-     * @returns results.results - An array of records matching the current record
-     */
-    async paginate(opts) {
-        return await this.queryInstance().paginate(opts);
-    }
     /**
      * Retrieves the number of records corresponding
      * to this model.

package/dist/cjs/src/dream/DreamInstanceTransactionBuilder.js

@@ -4,6 +4,7 @@ const CannotAssociationQueryOnUnpersistedDream_js_1 = require("../errors/associa
 const CannotCreateAssociationOnUnpersistedDream_js_1 = require("../errors/associations/CannotCreateAssociationOnUnpersistedDream.js");
 const CannotDestroyAssociationOnUnpersistedDream_js_1 = require("../errors/associations/CannotDestroyAssociationOnUnpersistedDream.js");
 const CannotUpdateAssociationOnUnpersistedDream_js_1 = require("../errors/associations/CannotUpdateAssociationOnUnpersistedDream.js");
+const RecordNotFound_js_1 = require("../errors/RecordNotFound.js");
 const associationQuery_js_1 = require("./internal/associations/associationQuery.js");
 const associationUpdateQuery_js_1 = require("./internal/associations/associationUpdateQuery.js");
 const createAssociation_js_1 = require("./internal/associations/createAssociation.js");
@@ -398,6 +399,28 @@ class DreamInstanceTransactionBuilder {
     async save({ skipHooks } = {}) {
         await (0, saveDream_js_1.default)(this.dreamInstance, this.dreamTransaction, skipHooks ? { skipHooks } : undefined);
     }
+    async association(associationName, options) {
+        if (!this.dreamInstance.loaded(associationName)) {
+            const association = this.dreamInstance['getAssociationMetadata'](associationName);
+            const associationQueryOptions = options?.required && { and: options.required };
+            let scope = this.associationQuery(associationName, associationQueryOptions);
+            if (options?.passthrough)
+                scope = scope.passthrough(options.passthrough);
+            if (association?.type === 'HasMany') {
+                this.dreamInstance[associationName] = (await scope.all());
+            }
+            else {
+                this.dreamInstance[associationName] = (await scope.first());
+            }
+        }
+        return this.dreamInstance[associationName];
+    }
+    async associationOrFail(associationName, options) {
+        const response = await this.association(associationName, options);
+        if (this.dreamInstance[associationName] === null)
+            throw new RecordNotFound_js_1.default(this.dreamInstance['sanitizedConstructorName']);
+        return response;
+    }
     /**
      * Returns a Query instance for the specified
      * association on the current instance.

package/dist/cjs/src/dream/Query.js

@@ -809,7 +809,8 @@ class Query {
      * @returns A cloned Query with the passthrough data
      */
     passthrough(passthroughOnStatement) {
-        return this.clone({ passthroughOnStatement: passthroughOnStatement });
+        const baseSelectQuery = this.baseSelectQuery && this.baseSelectQuery.clone({ passthroughOnStatement: passthroughOnStatement });
+        return this.clone({ passthroughOnStatement: passthroughOnStatement, baseSelectQuery });
     }
     /**
      * Applies a where statement to the Query instance
@@ -1209,20 +1210,21 @@ class Query {
      * @returns results.results - An array of records matching the current record
      */
     async paginate(opts) {
+        const options = opts;
         if (this.limitStatement)
             throw new CannotPaginateWithLimit_js_1.default();
         if (this.offsetStatement)
             throw new CannotPaginateWithOffset_js_1.default();
-        const page = (0, computedPaginatePage_js_1.default)(opts.page);
+        const page = (0, computedPaginatePage_js_1.default)(options.page);
         const recordCount = await this.count();
-        const pageSize = opts.pageSize || index_js_1.default.getOrFail().paginationPageSize;
+        const pageSize = Math.max(0, options.pageSize ?? 0) || index_js_1.default.getOrFail().paginationPageSize;
         const pageCount = Math.ceil(recordCount / pageSize);
         const query = this.orderStatements.length
             ? this
             : this.order({ [this.namespacedPrimaryKey]: 'asc' });
         const results = await query
             .limit(pageSize)
-            .offset((page - 1) * pageSize)
+            .offset(((page - 1) * pageSize))
             .all();
         return {
             recordCount,
@@ -1231,6 +1233,75 @@ class Query {
             results,
         };
     }
+    /**
+     * Fast paginates the results of your query using cursor-based pagination,
+     * accepting a pageSize and cursor argument. This method
+     * provides better performance for large datasets by using cursor-based
+     * pagination instead of offset-based pagination.
+     *
+     * ```ts
+     * // First page
+     * const firstPage = await User.order('email').fastPaginate({ pageSize: 100 })
+     * firstPage.results
+     * // [ { User{id: 1}, User{id: 2}, ...}]
+     *
+     * firstPage.cursor
+     * // "100" (or null if no more pages)
+     *
+     * // Next page using cursor from previous result
+     * const nextPage = await User.order('email').fastPaginate({
+     *   pageSize: 100,
+     *   cursor: firstPage.cursor
+     * })
+     * ```
+     *
+     * @param opts - Fast pagination options
+     * @param opts.pageSize - the number of results per page (optional)
+     * @param opts.cursor - identifier of where to start the next page; undefined to start from the beginning; null when no more pages
+     * @returns results.cursor - identifier for the next page, or null if no more pages
+     * @returns results.results - An array of records for the current page
+     */
+    async fastPaginate(opts) {
+        const options = opts;
+        const pageSize = Math.max(0, options.pageSize ?? 0) || index_js_1.default.getOrFail().paginationPageSize;
+        if (options === null)
+            return { cursor: null, results: [] };
+        if (this.limitStatement)
+            throw new CannotPaginateWithLimit_js_1.default();
+        if (this.offsetStatement)
+            throw new CannotPaginateWithOffset_js_1.default();
+        const explicitOrdering = !!this.orderStatements.length;
+        let query = explicitOrdering ? this : this.order({ [this.namespacedPrimaryKey]: 'asc' });
+        if (options.cursor) {
+            if (explicitOrdering) {
+                const lastItem = await query
+                    .where({ [this.dreamClass.primaryKey]: options.cursor })
+                    .firstOrFail();
+                this.orderStatements.forEach(orderStatement => {
+                    const column = orderStatement.column;
+                    const direction = orderStatement.direction;
+                    switch (direction) {
+                        case 'asc':
+                            query = query.where({ [column]: index_js_2.default.greaterThan(lastItem[column]) });
+                            break;
+                        case 'desc':
+                            query = query.where({ [column]: index_js_2.default.lessThan(lastItem[column]) });
+                            break;
+                    }
+                });
+            }
+            else {
+                query = query.where({
+                    [this.dreamClass.primaryKey]: index_js_2.default.greaterThan(options.cursor),
+                });
+            }
+        }
+        const results = await query.limit(pageSize).all();
+        return {
+            cursor: (results.length === pageSize && results.at(-1)?.primaryKeyValue().toString()) || null,
+            results,
+        };
+    }
     /**
      * Forces use of a database connection (e.g. 'primary') during the query.
      *

package/dist/cjs/src/helpers/cli/SchemaBuilder.js

@@ -132,24 +132,22 @@ ${tableName}: {
                 const associationMetadata = tableData.associations[associationName];
                 if (associationMetadata === undefined)
                     return '';
-                const whereStatement = associationMetadata.where;
-                const requiredOnClauses = whereStatement === null
+                const andStatement = associationMetadata.and;
+                const requiredAndClauses = andStatement === null
                     ? []
-                    : Object.keys(whereStatement).filter(column => whereStatement[column] === constants_js_1.DreamConst.required);
-                passthroughColumns =
-                    whereStatement === null
-                        ? passthroughColumns
-                        : [
-                            ...passthroughColumns,
-                            ...Object.keys(whereStatement).filter(column => whereStatement[column] === constants_js_1.DreamConst.passthrough),
-                        ];
+                    : Object.keys(andStatement).filter(column => andStatement[column] === constants_js_1.DreamConst.required);
+                const passthroughAndClauses = andStatement === null
+                    ? []
+                    : Object.keys(andStatement).filter(column => andStatement[column] === constants_js_1.DreamConst.passthrough);
+                passthroughColumns = [...passthroughColumns, ...passthroughAndClauses];
                 return `${associationName}: {
         type: '${associationMetadata.type}',
         foreignKey: ${associationMetadata.foreignKey ? `'${associationMetadata.foreignKey}'` : 'null'},
         foreignKeyTypeColumn: ${associationMetadata.foreignKeyTypeColumn ? `'${associationMetadata.foreignKeyTypeColumn}'` : 'null'},
         tables: ${stringifyArray(associationMetadata.tables)},
         optional: ${associationMetadata.optional},
-        requiredOnClauses: ${requiredOnClauses.length === 0 ? 'null' : stringifyArray(requiredOnClauses)},
+        requiredAndClauses: ${requiredAndClauses.length === 0 ? 'null' : stringifyArray(requiredAndClauses)},
+        passthroughAndClauses: ${passthroughAndClauses.length === 0 ? 'null' : stringifyArray(passthroughAndClauses)},
       },`;
             })
                 .join('\n      ')}
@@ -276,7 +274,7 @@ may need to update the table getter in the corresponding Dream.
                             ? associationMetaData?.foreignKeyTypeField?.() || null
                             : null,
                         optional,
-                        where,
+                        and: where,
                     };
                     if (foreignKey)
                         tableAssociationData[associationName]['foreignKey'] = foreignKey;

package/dist/esm/src/Dream.js

@@ -907,6 +907,37 @@ export default class Dream {
     static async paginate(opts) {
         return await this.query().paginate(opts);
     }
+    /**
+     * Fast paginates the results of your query using cursor-based pagination,
+     * accepting a pageSize and cursor argument. This method
+     * provides better performance for large datasets by using cursor-based
+     * pagination instead of offset-based pagination.
+     *
+     * ```ts
+     * // First page
+     * const firstPage = await User.order('email').fastPaginate({ pageSize: 100 })
+     * firstPage.results
+     * // [ { User{id: 1}, User{id: 2}, ...}]
+     *
+     * firstPage.cursor
+     * // "100" (or null if no more pages)
+     *
+     * // Next page using cursor from previous result
+     * const nextPage = await User.order('email').fastPaginate({
+     *   pageSize: 100,
+     *   cursor: firstPage.cursor
+     * })
+     * ```
+     *
+     * @param opts - Fast pagination options
+     * @param opts.pageSize - the number of results per page (optional)
+     * @param opts.cursor - identifier of where to start the next page; undefined to start from the beginning; null when no more pages
+     * @returns results.cursor - identifier for the next page, or null if no more pages
+     * @returns results.results - An array of records for the current page
+     */
+    static async fastPaginate(opts) {
+        return await this.query().fastPaginate(opts);
+    }
     /**
      * Forces use of a database connection (e.g. 'primary') during the query.
      *
@@ -3219,61 +3250,31 @@ export default class Dream {
     load(...args) {
         return new LoadBuilder(this).load(...args);
     }
-    /**
-     * If the association is already loaded on the instance, it returns the loaded value
-     * immediately without making a database query. If the association is not loaded,
-     * it performs a database query to fetch the association.
-     *
-     * If a query is performed, the association is set on the model so that future calls to
-     * access this association can access the already loaded value.
-     *
-     * ```ts
-     * // return the already loaded user if it exists or fetch it from the database otherwise
-     * const user = await post.associationOrFail('user')
-     * ```
-     *
-     * @param associationName - The name of the BelongsTo or HasOne association
-     * @returns The associated model instance or null
-     */
-    async association(associationName) {
+    async association(associationName, options) {
         if (!this.loaded(associationName)) {
             const association = this.getAssociationMetadata(associationName);
+            const associationQueryOptions = options?.required && { and: options.required };
+            let scope = this.associationQuery(associationName, associationQueryOptions);
+            if (options?.passthrough)
+                scope = scope.passthrough(options.passthrough);
             if (association?.type === 'HasMany') {
-                this[associationName] = (await this.associationQuery(associationName).all());
+                this[associationName] = (await scope.all());
             }
             else {
-                this[associationName] = (await this.associationQuery(associationName).first());
+                this[associationName] = (await scope.first());
             }
         }
         return this[associationName];
     }
-    /**
-     * If the association is already loaded on the instance, it returns the loaded value
-     * immediately without making a database query. If the association is not loaded,
-     * it performs a database query to fetch the association.
-     *
-     * Unlike `association`, this method throws an exception if no associated
-     * record is found, guaranteeing a non-null result.
-     *
-     * If a query is performed, the association is set on the model so that future calls to
-     * access this association can access the already loaded value.
-     *
-     * ```ts
-     * // return the already loaded user if it exists or fetch it from the database otherwise,
-     * // throwing RecordNotFound either way if the associated model does not exist
-     * const user = await post.associationOrFail('user')
-     * ```
-     *
-     * @param associationName - The name of the BelongsTo or HasOne association
-     * @returns The associated model instance (never null)
-     * @throws RecordNotFound if no associated record exists
-     */
-    async associationOrFail(associationName) {
-        const response = await this.association(associationName);
+    async associationOrFail(associationName, options) {
+        const response = await this.association(associationName, options);
         if (this[associationName] === null)
             throw new RecordNotFound(this['sanitizedConstructorName']);
         return response;
     }
+    ///////////////////
+    // end:associationOrFail
+    ///////////////////
     /**
      * Recursively loads all Dream associations referenced by `rendersOne` and `rendersMany`
      * in a DreamSerializer. This traverses the entire content tree of serializers to automatically

package/dist/esm/src/dream/DreamClassTransactionBuilder.js

@@ -36,38 +36,6 @@ export default class DreamClassTransactionBuilder {
     async all(options = {}) {
         return this.queryInstance().all(options);
     }
-    /**
-     * Paginates the results of your query, accepting a pageSize and page argument,
-     * which it uses to segment your query into pages, leveraging limit and offset
-     * to deliver your query to you in pages.
-     *
-     * ```ts
-     * await ApplicationModel.transaction(async txn => {
-     *   const paginated = await User.txn(txn).paginate({ pageSize: 100, page: 2 })
-     *   paginated.results
-     *   // [ { User{id: 101}, User{id: 102}, ...}]
-     *
-     *   paginated.recordCount
-     *   // 350
-     *
-     *   paginated.pageCount
-     *   // 4
-     *
-     *   paginated.currentPage
-     *   // 2
-     * })
-     * ```
-     *
-     * @param opts.page - the page number that you want to fetch results for
-     * @param opts.pageSize - the number of results per page (optional)
-     * @returns results.recordCount - A number representing the total number of records matching your query
-     * @returns results.pageCount - The number of pages needed to encapsulate all the matching records
-     * @returns results.currentPage - The current page (same as what is provided in the paginate args)
-     * @returns results.results - An array of records matching the current record
-     */
-    async paginate(opts) {
-        return await this.queryInstance().paginate(opts);
-    }
     /**
      * Retrieves the number of records corresponding
      * to this model.

package/dist/esm/src/dream/DreamInstanceTransactionBuilder.js

@@ -2,6 +2,7 @@ import CannotAssociationQueryOnUnpersistedDream from '../errors/associations/Can
 import CannotCreateAssociationOnUnpersistedDream from '../errors/associations/CannotCreateAssociationOnUnpersistedDream.js';
 import CannotDestroyAssociationOnUnpersistedDream from '../errors/associations/CannotDestroyAssociationOnUnpersistedDream.js';
 import CannotUpdateAssociationOnUnpersistedDream from '../errors/associations/CannotUpdateAssociationOnUnpersistedDream.js';
+import RecordNotFound from '../errors/RecordNotFound.js';
 import associationQuery from './internal/associations/associationQuery.js';
 import associationUpdateQuery from './internal/associations/associationUpdateQuery.js';
 import createAssociation from './internal/associations/createAssociation.js';
@@ -396,6 +397,28 @@ export default class DreamInstanceTransactionBuilder {
     async save({ skipHooks } = {}) {
         await saveDream(this.dreamInstance, this.dreamTransaction, skipHooks ? { skipHooks } : undefined);
     }
+    async association(associationName, options) {
+        if (!this.dreamInstance.loaded(associationName)) {
+            const association = this.dreamInstance['getAssociationMetadata'](associationName);
+            const associationQueryOptions = options?.required && { and: options.required };
+            let scope = this.associationQuery(associationName, associationQueryOptions);
+            if (options?.passthrough)
+                scope = scope.passthrough(options.passthrough);
+            if (association?.type === 'HasMany') {
+                this.dreamInstance[associationName] = (await scope.all());
+            }
+            else {
+                this.dreamInstance[associationName] = (await scope.first());
+            }
+        }
+        return this.dreamInstance[associationName];
+    }
+    async associationOrFail(associationName, options) {
+        const response = await this.association(associationName, options);
+        if (this.dreamInstance[associationName] === null)
+            throw new RecordNotFound(this.dreamInstance['sanitizedConstructorName']);
+        return response;
+    }
     /**
      * Returns a Query instance for the specified
      * association on the current instance.

package/dist/esm/src/dream/Query.js

@@ -807,7 +807,8 @@ export default class Query {
      * @returns A cloned Query with the passthrough data
      */
     passthrough(passthroughOnStatement) {
-        return this.clone({ passthroughOnStatement: passthroughOnStatement });
+        const baseSelectQuery = this.baseSelectQuery && this.baseSelectQuery.clone({ passthroughOnStatement: passthroughOnStatement });
+        return this.clone({ passthroughOnStatement: passthroughOnStatement, baseSelectQuery });
     }
     /**
      * Applies a where statement to the Query instance
@@ -1207,20 +1208,21 @@ export default class Query {
      * @returns results.results - An array of records matching the current record
      */
     async paginate(opts) {
+        const options = opts;
         if (this.limitStatement)
             throw new CannotPaginateWithLimit();
         if (this.offsetStatement)
             throw new CannotPaginateWithOffset();
-        const page = computedPaginatePage(opts.page);
+        const page = computedPaginatePage(options.page);
         const recordCount = await this.count();
-        const pageSize = opts.pageSize || DreamApp.getOrFail().paginationPageSize;
+        const pageSize = Math.max(0, options.pageSize ?? 0) || DreamApp.getOrFail().paginationPageSize;
         const pageCount = Math.ceil(recordCount / pageSize);
         const query = this.orderStatements.length
             ? this
             : this.order({ [this.namespacedPrimaryKey]: 'asc' });
         const results = await query
             .limit(pageSize)
-            .offset((page - 1) * pageSize)
+            .offset(((page - 1) * pageSize))
             .all();
         return {
             recordCount,
@@ -1229,6 +1231,75 @@ export default class Query {
             results,
         };
     }
+    /**
+     * Fast paginates the results of your query using cursor-based pagination,
+     * accepting a pageSize and cursor argument. This method
+     * provides better performance for large datasets by using cursor-based
+     * pagination instead of offset-based pagination.
+     *
+     * ```ts
+     * // First page
+     * const firstPage = await User.order('email').fastPaginate({ pageSize: 100 })
+     * firstPage.results
+     * // [ { User{id: 1}, User{id: 2}, ...}]
+     *
+     * firstPage.cursor
+     * // "100" (or null if no more pages)
+     *
+     * // Next page using cursor from previous result
+     * const nextPage = await User.order('email').fastPaginate({
+     *   pageSize: 100,
+     *   cursor: firstPage.cursor
+     * })
+     * ```
+     *
+     * @param opts - Fast pagination options
+     * @param opts.pageSize - the number of results per page (optional)
+     * @param opts.cursor - identifier of where to start the next page; undefined to start from the beginning; null when no more pages
+     * @returns results.cursor - identifier for the next page, or null if no more pages
+     * @returns results.results - An array of records for the current page
+     */
+    async fastPaginate(opts) {
+        const options = opts;
+        const pageSize = Math.max(0, options.pageSize ?? 0) || DreamApp.getOrFail().paginationPageSize;
+        if (options === null)
+            return { cursor: null, results: [] };
+        if (this.limitStatement)
+            throw new CannotPaginateWithLimit();
+        if (this.offsetStatement)
+            throw new CannotPaginateWithOffset();
+        const explicitOrdering = !!this.orderStatements.length;
+        let query = explicitOrdering ? this : this.order({ [this.namespacedPrimaryKey]: 'asc' });
+        if (options.cursor) {
+            if (explicitOrdering) {
+                const lastItem = await query
+                    .where({ [this.dreamClass.primaryKey]: options.cursor })
+                    .firstOrFail();
+                this.orderStatements.forEach(orderStatement => {
+                    const column = orderStatement.column;
+                    const direction = orderStatement.direction;
+                    switch (direction) {
+                        case 'asc':
+                            query = query.where({ [column]: ops.greaterThan(lastItem[column]) });
+                            break;
+                        case 'desc':
+                            query = query.where({ [column]: ops.lessThan(lastItem[column]) });
+                            break;
+                    }
+                });
+            }
+            else {
+                query = query.where({
+                    [this.dreamClass.primaryKey]: ops.greaterThan(options.cursor),
+                });
+            }
+        }
+        const results = await query.limit(pageSize).all();
+        return {
+            cursor: (results.length === pageSize && results.at(-1)?.primaryKeyValue().toString()) || null,
+            results,
+        };
+    }
     /**
      * Forces use of a database connection (e.g. 'primary') during the query.
      *