@rvoh/dream 0.42.2 → 0.43.0-beta.1

package/README.md

@@ -1,4 +1,4 @@
-> ATTENTION: we are currently in the process of releasing this code to the world, as of the afternoon of March 10th, 2025. This notice will be removed, and the version of this repo will be bumped to 1.0.0, once all of the repos have been migrated to the new spaces and we can verify that it is all working. This is anticipated to take 1 day.
+> ATTENTION: we are currently in the process of releasing this code to the world, as of the afternoon of May 21st, 2025. This notice will be removed, and the version of this repo will be bumped to 1.0.0, once all of the repos have been migrated to the new spaces and we can verify that it is all working. This should happen sometime in the next month.
 
 Dream is a typescript-driven, esm-first ORM built on top of [kysely](http://kysely.dev). It is built to operate within the [Psychic web framework](https://psychic-docs.netlify.app), but can be brought into other projects and used without the encapsulating framework (though this is theoretical, and we do not encourage it at this time). It is actively being developed to support production-grade applications in use within the [RVOHealth organization](https://www.rvohealth.com), who has kindly sponsored the continued development of this ORM, as well as the Psychic web framework as a whole.
 

package/dist/cjs/src/Dream.js

@@ -41,14 +41,12 @@ const CreateOrFindByFailedToCreateAndFind_js_1 = require("./errors/CreateOrFindB
 const CreateOrUpdateByFailedToCreateAndUpdate_js_1 = require("./errors/CreateOrUpdateByFailedToCreateAndUpdate.js");
 const GlobalNameNotSet_js_1 = require("./errors/dream-app/GlobalNameNotSet.js");
 const DreamMissingRequiredOverride_js_1 = require("./errors/DreamMissingRequiredOverride.js");
-const MissingSerializersDefinition_js_1 = require("./errors/MissingSerializersDefinition.js");
 const NonExistentScopeProvidedToResort_js_1 = require("./errors/NonExistentScopeProvidedToResort.js");
 const CalendarDate_js_1 = require("./helpers/CalendarDate.js");
 const cloneDeepSafe_js_1 = require("./helpers/cloneDeepSafe.js");
 const DateTime_js_1 = require("./helpers/DateTime.js");
 const cachedTypeForAttribute_js_1 = require("./helpers/db/cachedTypeForAttribute.js");
 const isJsonColumn_js_1 = require("./helpers/db/types/isJsonColumn.js");
-const inferSerializerFromDreamOrViewModel_js_1 = require("./helpers/inferSerializerFromDreamOrViewModel.js");
 const notEqual_js_1 = require("./helpers/notEqual.js");
 const typechecks_js_1 = require("./helpers/typechecks.js");
 class Dream {
@@ -489,6 +487,17 @@ class Dream {
             ...new Set([...columns, ...this.virtualAttributes.map(attr => attr.property)]),
         ];
     }
+    /**
+     * @internal
+     *
+     * Returns true if the column is a column in the database
+     *
+     * @param columnName - the name of the property you are checking for
+     * @returns boolean
+     */
+    static isColumn(columnName) {
+        return this.prototype.isColumn(columnName);
+    }
     /**
      * @internal
      *
@@ -596,6 +605,36 @@ class Dream {
     static async all(options = {}) {
         return await this.query().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
+     * const paginated = await User.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
+     */
+    static async paginate(opts) {
+        return await this.query().paginate(opts);
+    }
     /**
      * Forces use of a database connection (e.g. 'primary') during the query.
      *
@@ -690,7 +729,7 @@ class Dream {
         try {
             const dreamModel = this.new({
                 ...attributes,
-                ...(extraOpts?.createWith || {}),
+                ...extraOpts?.createWith,
             });
             await dreamModel.save();
             return dreamModel;
@@ -744,7 +783,7 @@ class Dream {
         try {
             return await this.create({
                 ...attributes,
-                ...(extraOpts?.with || {}),
+                ...extraOpts?.with,
             }, skipHooks ? { skipHooks } : undefined);
         }
         catch (err) {
@@ -2112,6 +2151,17 @@ class Dream {
          */
         this.unshadowColumnPropertyPrototypeAccessors();
     }
+    /**
+     * @internal
+     *
+     * Returns true if the column is a column in the database
+     *
+     * @param columnName - the name of the property you are checking for
+     * @returns boolean
+     */
+    isColumn(columnName) {
+        return this.columns().has(columnName);
+    }
     /**
      * Returns true if the columnName passed is marked by a
      * Virtual attribute decorator
@@ -2120,9 +2170,7 @@ class Dream {
      * @returns A boolean
      */
     isVirtualColumn(columnName) {
-        return this.constructor.virtualAttributes
-            .map(attr => attr.property)
-            .includes(columnName);
+        return !!this.constructor.virtualAttributes.find(attr => attr.property === columnName);
     }
     /**
      * Returns an object with column names for keys, and an
@@ -2896,31 +2944,6 @@ class Dream {
     async reload() {
         await (0, reload_js_1.default)(this);
     }
-    /**
-     * Serializes an instance. You can specify a serializer key,
-     * or else the default will be used
-     *
-     * ```ts
-     * // uses the default serializer provided in the model's `serializers` getter
-     * await user.serialize()
-     *
-     * // uses the summary serializer provided in the model's `serializers` getter
-     * await user.serialize({ serializerKey: 'summary' })
-     * ```
-     *
-     * @param args.casing - Which casing to use when serializing (camel or snake, default camel)
-     * @param args.serializerKey - The key to use when referencing the object returned by the `serializers` getter on the given model instance (defaults to "default")
-     * @returns A serialized representation of the model
-     */
-    serialize({ casing = null, serializerKey } = {}) {
-        const serializerClass = (0, inferSerializerFromDreamOrViewModel_js_1.default)(this, serializerKey?.toString());
-        if (!serializerClass)
-            throw new MissingSerializersDefinition_js_1.default(this.constructor);
-        const serializer = new serializerClass(this);
-        if (casing)
-            serializer.casing(casing);
-        return serializer.render();
-    }
     /**
      * Takes the attributes passed in and sets their values,
      * leveraging any custom setters defined for these attributes.

package/dist/cjs/src/bin/index.js

@@ -81,7 +81,12 @@ class DreamBin {
         await (0, generateDream_js_1.default)({ fullyQualifiedModelName, columnsWithTypes, options });
     }
     static async generateStiChild(fullyQualifiedModelName, fullyQualifiedParentName, columnsWithTypes, options) {
-        await (0, generateDream_js_1.default)({ fullyQualifiedModelName, columnsWithTypes, options, fullyQualifiedParentName });
+        await (0, generateDream_js_1.default)({
+            fullyQualifiedModelName,
+            columnsWithTypes,
+            options: { ...options, stiBaseSerializer: false },
+            fullyQualifiedParentName,
+        });
     }
     static async generateMigration(migrationName, columnsWithTypes) {
         await (0, generateMigration_js_1.default)({ migrationName, columnsWithTypes });

package/dist/cjs/src/cli/index.js

@@ -46,6 +46,7 @@ class DreamCLI {
             .alias('generate:dream')
             .alias('g:dream')
             .option('--no-serializer')
+            .option('--sti-base-serializer', 'Omits the serializer from the dream model, but does create the serializer so it can be extended by STI children')
             .description('create a new Dream model')
             .argument('<modelName>', 'the name of the model to create, e.g. Post or Settings/CommunicationPreferences')
             .argument('[columnsWithTypes...]', 'properties of the model property1:text/string/enum/etc. property2:text/string/enum/etc. ... propertyN:text/string/enum/etc.')

package/dist/cjs/src/decorators/field/validation/Validates.js

@@ -61,8 +61,11 @@ function extractValidationOptionsFromArgs(type, args) {
             }
         case 'requiredBelongsTo':
             return {};
-        default:
-            throw new Error(`Unhandled validation type when caching options: ${type}`);
+        default: {
+            // protection so that if a new ValidationType is ever added, this will throw a type error at build time
+            const _never = type;
+            throw new Error(`Unhandled ValidationType: ${_never}`);
+        }
     }
 }
 class ValidationInstantiationError extends Error {

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

@@ -38,6 +38,38 @@ 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/Query.js

@@ -5,6 +5,7 @@ const pluralize_esm_1 = require("pluralize-esm");
 const ConnectedToDB_js_1 = require("../db/ConnectedToDB.js");
 const SoftDelete_js_1 = require("../decorators/class/SoftDelete.js");
 const associationToGetterSetterProp_js_1 = require("../decorators/field/association/associationToGetterSetterProp.js");
+const index_js_1 = require("../dream-app/index.js");
 const AssociationDeclaredWithoutAssociatedDreamClass_js_1 = require("../errors/associations/AssociationDeclaredWithoutAssociatedDreamClass.js");
 const CannotAssociateThroughPolymorphic_js_1 = require("../errors/associations/CannotAssociateThroughPolymorphic.js");
 const CannotJoinPolymorphicBelongsToError_js_1 = require("../errors/associations/CannotJoinPolymorphicBelongsToError.js");
@@ -21,6 +22,8 @@ const LeftJoinPreloadIncompatibleWithFindEach_js_1 = require("../errors/LeftJoin
 const MissingRequiredCallbackFunctionToPluckEach_js_1 = require("../errors/MissingRequiredCallbackFunctionToPluckEach.js");
 const NoUpdateAllOnJoins_js_1 = require("../errors/NoUpdateAllOnJoins.js");
 const NoUpdateOnAssociationQuery_js_1 = require("../errors/NoUpdateOnAssociationQuery.js");
+const CannotPaginateWithLimit_js_1 = require("../errors/pagination/CannotPaginateWithLimit.js");
+const CannotPaginateWithOffset_js_1 = require("../errors/pagination/CannotPaginateWithOffset.js");
 const RecordNotFound_js_1 = require("../errors/RecordNotFound.js");
 const UnexpectedUndefined_js_1 = require("../errors/UnexpectedUndefined.js");
 const CalendarDate_js_1 = require("../helpers/CalendarDate.js");
@@ -38,9 +41,10 @@ const snakeify_js_1 = require("../helpers/snakeify.js");
 const typechecks_js_1 = require("../helpers/typechecks.js");
 const uniq_js_1 = require("../helpers/uniq.js");
 const curried_ops_statement_js_1 = require("../ops/curried-ops-statement.js");
-const index_js_1 = require("../ops/index.js");
+const index_js_2 = require("../ops/index.js");
 const ops_statement_js_1 = require("../ops/ops-statement.js");
 const constants_js_1 = require("./constants.js");
+const computedPaginatePage_js_1 = require("./internal/computedPaginatePage.js");
 const executeDatabaseQuery_js_1 = require("./internal/executeDatabaseQuery.js");
 const extractAssociationMetadataFromAssociationName_js_1 = require("./internal/extractAssociationMetadataFromAssociationName.js");
 const orderByDirection_js_1 = require("./internal/orderByDirection.js");
@@ -297,7 +301,7 @@ class Query extends ConnectedToDB_js_1.default {
             baseSelectQuery: opts.baseSelectQuery || this.baseSelectQuery,
             passthroughOnStatement: {
                 ...this.passthroughOnStatement,
-                ...(opts.passthroughOnStatement || {}),
+                ...opts.passthroughOnStatement,
             },
             where: opts.where === null ? [] : [...this.whereStatements, ...(opts.where || [])],
             whereNot: opts.whereNot === null ? [] : [...this.whereNotStatements, ...(opts.whereNot || [])],
@@ -438,13 +442,13 @@ class Query extends ConnectedToDB_js_1.default {
         let lastId = null;
         do {
             if (lastId)
-                records = await query.where({ [this.dreamInstance.primaryKey]: index_js_1.default.greaterThan(lastId) }).all();
+                records = await query.where({ [this.dreamInstance.primaryKey]: index_js_2.default.greaterThan(lastId) }).all();
             else
                 records = await query.all();
             for (const record of records) {
                 await cb(record);
             }
-            lastId = records[records.length - 1]?.primaryKeyValue;
+            lastId = records.at(-1)?.primaryKeyValue;
         } while (records.length > 0 && records.length === batchSize);
     }
     /**
@@ -999,8 +1003,11 @@ class Query extends ConnectedToDB_js_1.default {
                 return this.buildUpdate({});
             // TODO: in the future, we should support insert type, but don't yet, since inserts are done outside
             // the query class for some reason.
-            default:
-                throw new Error('never');
+            default: {
+                // protection so that if a new QueryType is ever added, this will throw a type error at build time
+                const _never = type;
+                throw new Error(`Unhandled QueryType: ${_never}`);
+            }
         }
     }
     /**
@@ -1414,6 +1421,52 @@ class Query extends ConnectedToDB_js_1.default {
         await this.applyPreload(this.preloadStatements, this.preloadOnStatements, theAll);
         return theAll;
     }
+    /**
+     * 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
+     * const paginated = await User.order('email').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) {
+        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 recordCount = await this.count();
+        const pageSize = opts.pageSize || index_js_1.default.getOrFail().paginationPageSize;
+        const pageCount = Math.ceil(recordCount / pageSize);
+        const results = await this.limit(pageSize)
+            .offset((page - 1) * pageSize)
+            .all();
+        return {
+            recordCount,
+            pageCount,
+            currentPage: page,
+            results,
+        };
+    }
     /**
      * Forces use of a database connection (e.g. 'primary') during the query.
      *
@@ -1924,7 +1977,7 @@ class Query extends ConnectedToDB_js_1.default {
                 pluckedData[dreamClassToHydrateColumns.length + index]));
             return {
                 dream: hydratedDream,
-                pointsToPrimaryKey: pluckedData[pluckedData.length - 1],
+                pointsToPrimaryKey: pluckedData.at(-1),
             };
         });
         this.hydrateAssociation(dreams, association, preloadedDreamsAndWhatTheyPointTo);
@@ -2430,7 +2483,7 @@ class Query extends ConnectedToDB_js_1.default {
             val = val();
         }
         else if (val === constants_js_1.DreamConst.passthrough) {
-            const column = attr.split('.').pop();
+            const column = attr.split('.').at(-1);
             if (this.passthroughOnStatement[column] === undefined)
                 throw new MissingRequiredPassthroughForAssociationAndClause_js_1.default(column);
             val = this.passthroughOnStatement[column];

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

@@ -14,25 +14,23 @@ exports.DreamConst = {
     required: RequiredAttribute,
 };
 exports.openapiPrimitiveTypes = [
-    'string',
     'boolean',
-    'number',
-    'date',
     'date-time',
-    'double',
+    'date',
     'integer',
     'null',
+    'number',
+    'string',
 ];
 exports.openapiShorthandPrimitiveTypes = [
     ...exports.openapiPrimitiveTypes,
-    'decimal',
-    'string[]',
     'boolean[]',
-    'number[]',
-    'date[]',
     'date-time[]',
+    'date[]',
+    'decimal',
     'decimal[]',
-    'double[]',
     'integer[]',
     'json',
+    'number[]',
+    'string[]',
 ];

package/dist/cjs/src/dream/internal/checkSingleValidation.js

@@ -50,8 +50,11 @@ function checkSingleValidation(dream, validation) {
             if (associationMetadata === undefined)
                 throw new UnexpectedUndefined_js_1.default();
             return !!(value || dream[associationMetadata.foreignKey()]);
-        default:
-            throw new Error(`Unhandled validation type found while running validations: ${validation.type}`);
+        default: {
+            // protection so that if a new ValidationType is ever added, this will throw a type error at build time
+            const _never = validation.type;
+            throw new Error(`Unhandled ValidationType: ${_never}`);
+        }
     }
 }
 function isBlank(value) {

package/dist/cjs/src/dream/internal/computedPaginatePage.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = computedPaginatePage;
+function computedPaginatePage(page) {
+    if (page === null)
+        return 1;
+    if (page === undefined)
+        return 1;
+    return page <= 1 ? 1 : Math.floor(page);
+}

package/dist/cjs/src/dream/internal/findOrCreateBy.js

@@ -9,7 +9,7 @@ async function findOrCreateBy(dreamClass, txn = null, attributes, extraOpts = {}
         return existingRecord;
     const dreamModel = dreamClass.new({
         ...attributes,
-        ...(extraOpts?.createWith || {}),
+        ...extraOpts?.createWith,
     });
     await dreamModel.txn(txn).save();
     return dreamModel;

package/dist/cjs/src/dream/internal/orderByDirection.js

@@ -9,7 +9,10 @@ function orderByDirection(dir) {
             return (0, kysely_1.sql) `asc nulls first`;
         case 'desc':
             return (0, kysely_1.sql) `desc nulls last`;
-        default:
-            throw new Error(`Unrecognized orderBy direction: ${dir}`);
+        default: {
+            // protection so that if a new OrderDir is ever added, this will throw a type error at build time
+            const _never = dir;
+            throw new Error(`Unhandled OrderDir: ${_never}`);
+        }
     }
 }

package/dist/cjs/src/dream/internal/updateOrCreateBy.js

@@ -13,6 +13,6 @@ async function updateOrCreateBy(dreamClass, txn = null, attributes, extraOpts =
     }
     return await dreamClass.txn(txn).create({
         ...attributes,
-        ...(extraOpts?.with || {}),
+        ...extraOpts?.with,
     }, skipHooks ? { skipHooks } : undefined);
 }

package/dist/cjs/src/dream-app/helpers/DreamImporter.js

@@ -31,11 +31,11 @@ class DreamImporter {
     }
     static async importSerializers(pathToSerializers, importCb) {
         const serializerPaths = await DreamImporter.ls(pathToSerializers);
-        const serializerClasses = (await Promise.all(serializerPaths.map(serializerPath => importCb(serializerPath).then(serializerClass => [
+        const pathsNamesAndSerializers = (await Promise.all(serializerPaths.map(serializerPath => importCb(serializerPath).then(serializerClass => [
             serializerPath,
             serializerClass,
         ]))));
-        return serializerClasses;
+        return pathsNamesAndSerializers;
     }
 }
 exports.default = DreamImporter;

package/dist/cjs/src/dream-app/helpers/importers/importModels.js

@@ -73,7 +73,7 @@ function setCachedModels(models) {
 }
 function getModelsOrFail() {
     if (!_models)
-        throw new Error('Must call loadModels before calling getModelsOrFail');
+        throw new Error('Must call importModels before calling getModelsOrFail');
     return _models;
 }
 function getModelsOrBlank() {

package/dist/cjs/src/dream-app/helpers/importers/importSerializers.js

@@ -5,7 +5,7 @@ exports.setCachedSerializers = setCachedSerializers;
 exports.getSerializersOrFail = getSerializersOrFail;
 exports.getSerializersOrBlank = getSerializersOrBlank;
 const SerializerNameConflict_js_1 = require("../../../errors/dream-app/SerializerNameConflict.js");
-const index_js_1 = require("../../../serializer/index.js");
+const isDreamSerializer_js_1 = require("../../../serializer/helpers/isDreamSerializer.js");
 const DreamImporter_js_1 = require("../DreamImporter.js");
 const globalSerializerKeyFromPath_js_1 = require("../globalSerializerKeyFromPath.js");
 let _serializers;
@@ -13,41 +13,20 @@ async function importSerializers(serializersPath, serializerImportCb) {
     if (_serializers)
         return _serializers;
     const serializerClasses = await DreamImporter_js_1.default.importSerializers(serializersPath, serializerImportCb);
-    /**
-     * Certain features (e.g. building OpenAPI specs from Attribute and RendersOne/Many decorators)
-     * need static access to things set up by decorators. Stage 3 Decorators change the context that is available
-     * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
-     * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on DreamSerializer, and all serializers are instantiated.
-     */
-    index_js_1.default['globallyInitializingDecorators'] = true;
     _serializers = {};
     for (const [serializerPath, allSerializers] of serializerClasses) {
         Object.keys(allSerializers).forEach(key => {
             const potentialSerializer = allSerializers[key];
-            if (potentialSerializer?.isDreamSerializer) {
+            if (potentialSerializer && (0, isDreamSerializer_js_1.default)(potentialSerializer)) {
                 const serializerKey = (0, globalSerializerKeyFromPath_js_1.default)(serializerPath, serializersPath, key);
                 if (_serializers[serializerKey])
                     throw new SerializerNameConflict_js_1.default(serializerKey);
-                const serializerClass = potentialSerializer;
-                serializerClass['setGlobalName'](serializerKey);
-                /**
-                 * Certain features (e.g. building OpenAPI specs from Attribute and RendersOne/Many decorators)
-                 * need static access to things set up by decorators. Stage 3 Decorators change the context that is available
-                 * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
-                 * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on DreamSerializer, and all serializers are instantiated.
-                 */
-                new serializerClass({});
+                const serializer = potentialSerializer;
+                serializer['globalName'] = serializerKey;
                 _serializers[serializerKey] = potentialSerializer;
             }
         });
     }
-    /**
-     * Certain features (e.g. building OpenAPI specs from Attribute and RendersOne/Many decorators)
-     * need static access to things set up by decorators. Stage 3 Decorators change the context that is available
-     * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
-     * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on DreamSerializer, and all serializers are instantiated.
-     */
-    index_js_1.default['globallyInitializingDecorators'] = false;
     return _serializers;
 }
 function setCachedSerializers(serializers) {
@@ -55,7 +34,7 @@ function setCachedSerializers(serializers) {
 }
 function getSerializersOrFail() {
     if (!_serializers)
-        throw new Error('Must call loadSerializers before calling getSerializersOrFail');
+        throw new Error('Must call importSerializers before calling getSerializersOrFail');
     return _serializers;
 }
 function getSerializersOrBlank() {

package/dist/cjs/src/dream-app/index.js

@@ -179,6 +179,10 @@ Try setting it to something valid, like:
     get unicodeNormalization() {
         return this._unicodeNormalization;
     }
+    _paginationPageSize = 25;
+    get paginationPageSize() {
+        return this._paginationPageSize;
+    }
     _primaryKeyType = 'bigserial';
     get primaryKeyType() {
         return this._primaryKeyType;
@@ -310,8 +314,14 @@ Try setting it to something valid, like:
             case 'unicodeNormalization':
                 this._unicodeNormalization = options;
                 break;
-            default:
-                throw new Error(`Unhandled applyOption encountered in Dreamconf: ${applyOption}`);
+            case 'paginationPageSize':
+                this._paginationPageSize = options;
+                break;
+            default: {
+                // protection so that if a new ApplyOpt is ever added, this will throw a type error at build time
+                const _never = applyOption;
+                throw new Error(`Unhandled ApplyOpt: ${_never}`);
+            }
         }
     }
     on(hookEventType, cb) {

package/dist/cjs/src/encrypt/index.js

@@ -15,8 +15,11 @@ class Encrypt {
             case 'aes-192-gcm':
             case 'aes-128-gcm':
                 return (0, encryptAESGCM_js_1.default)(algorithm, data, key);
-            default:
-                throw new Error(`unrecognized algorith provided to encrypt: ${algorithm}`);
+            default: {
+                // protection so that if a new EncryptAlgorithm is ever added, this will throw a type error at build time
+                const _never = algorithm;
+                throw new Error(`Unhandled EncryptAlgorithm: ${_never}`);
+            }
         }
     }
     static decrypt(encrypted, { algorithm, key }, legacyOpts) {
@@ -36,8 +39,11 @@ class Encrypt {
                 catch {
                     return null;
                 }
-            default:
-                throw new Error(`unrecognized algorith provided to decrypt: ${algorithm}`);
+            default: {
+                // protection so that if a new EncryptAlgorithm is ever added, this will throw a type error at build time
+                const _never = algorithm;
+                throw new Error(`Unhandled EncryptAlgorithm: ${_never}`);
+            }
         }
     }
     static attemptDecryptionWithLegacyKeys(encrypted, { algorithm, key }, legacyOpts) {
@@ -54,8 +60,11 @@ class Encrypt {
                 return (0, generateKeyAESGCM_js_1.default)(192);
             case 'aes-128-gcm':
                 return (0, generateKeyAESGCM_js_1.default)(128);
-            default:
-                throw new Error(`unrecognized algorithm provided to generateKey: ${algorithm}`);
+            default: {
+                // protection so that if a new EncryptAlgorithm is ever added, this will throw a type error at build time
+                const _never = algorithm;
+                throw new Error(`Unhandled EncryptAlgorithm: ${_never}`);
+            }
         }
     }
     static validateKey(base64EncodedKey, algorithm) {
@@ -66,8 +75,11 @@ class Encrypt {
                 return (0, validateKeyAESGCM_js_1.default)(base64EncodedKey, 192);
             case 'aes-128-gcm':
                 return (0, validateKeyAESGCM_js_1.default)(base64EncodedKey, 128);
-            default:
-                throw new Error(`unrecognized algorith provided to validateKey: ${algorithm}`);
+            default: {
+                // protection so that if a new EncryptAlgorithm is ever added, this will throw a type error at build time
+                const _never = algorithm;
+                throw new Error(`Unhandled EncryptAlgorithm: ${_never}`);
+            }
         }
     }
 }

package/dist/cjs/src/errors/pagination/CannotPaginateWithLimit.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CannotPaginateWithLimit extends Error {
+    get message() {
+        return `\
+Cannot call paginate on a query which has a limit applied.
+
+Limit statements are automatically generated by the paginate method,
+and adding custom limits interferes with paginate's ability to provide
+a total count.
+
+fix:
+  remove the limit statement from your query
+`;
+    }
+}
+exports.default = CannotPaginateWithLimit;