@rvoh/dream 1.2.1 → 1.3.1

package/dist/cjs/src/Dream.js

@@ -21,6 +21,7 @@ const destroyDream_js_1 = require("./dream/internal/destroyDream.js");
 const destroyOptions_js_1 = require("./dream/internal/destroyOptions.js");
 const ensureSTITypeFieldIsSet_js_1 = require("./dream/internal/ensureSTITypeFieldIsSet.js");
 const findOrCreateBy_js_1 = require("./dream/internal/findOrCreateBy.js");
+const printSerializerHierarchyLevel_js_1 = require("./dream/internal/printSerializerHierarchyLevel.js");
 const reload_js_1 = require("./dream/internal/reload.js");
 const runValidations_js_1 = require("./dream/internal/runValidations.js");
 const saveDream_js_1 = require("./dream/internal/saveDream.js");
@@ -49,10 +50,8 @@ 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 indent_js_1 = require("./helpers/indent.js");
 const notEqual_js_1 = require("./helpers/notEqual.js");
 const inferSerializerFromDreamOrViewModel_js_1 = require("./serializer/helpers/inferSerializerFromDreamOrViewModel.js");
-const serializerForAssociatedClass_js_1 = require("./serializer/helpers/serializerForAssociatedClass.js");
 class Dream {
     DB;
     /**
@@ -489,42 +488,65 @@ class Dream {
     static recursiveSerializationMap(serializer, { forDisplay = false, forDisplayDepth = 0, } = {}) {
         const serializerBuilder = serializer(undefined, undefined);
         const serializerAssociations = serializerBuilder['attributes'].filter(attribute => ['rendersOne', 'rendersMany', 'delegatedAttribute'].includes(attribute.type));
-        return serializerAssociations.reduce((acc, serializerAssociation) => {
+        return serializerAssociations.reduce((accumulator, serializerAssociation) => {
             const serializerAssociationName = serializerAssociation.targetName ??
                 serializerAssociation.name;
             const serializerAssociationType = serializerAssociation.type;
             const association = this['getAssociationMetadata'](serializerAssociationName);
             if (!association)
-                return acc;
-            const associatedClasses = association.modelCB();
-            const associatedClass = Array.isArray(associatedClasses) ? associatedClasses[0] : associatedClasses;
-            if (!associatedClass)
+                return accumulator;
+            const maybeAssociatedClasses = association.modelCB();
+            if (!maybeAssociatedClasses)
                 throw new Error(`No class defined on ${serializerAssociationName} association on ${this.sanitizedName}`);
-            const associationSerializer = (0, serializerForAssociatedClass_js_1.serializerForAssociatedClass)(this.prototype, serializerAssociationName, serializerAssociation.options);
-            if (!associationSerializer)
-                throw new Error(`No serializer found to render ${serializerAssociationName} on ${this.sanitizedName}`);
-            if (forDisplay && serializerAssociationType !== 'delegatedAttribute') {
-                const hierarchyLine = '└───';
-                const indentation = (0, indent_js_1.indent)((hierarchyLine.length + 1) * forDisplayDepth, {
-                    tabWidth: 1,
-                });
-                const prefix = `${hierarchyLine} `;
-                const nestedAssociationDisplay = indentation + `${prefix}${serializerAssociationType} ${yoctocolors_1.default.cyan(serializerAssociationName)}`;
-                console.log(nestedAssociationDisplay);
-                console.log(yoctocolors_1.default.gray(indentation +
-                    (0, indent_js_1.indent)(prefix.length, { tabWidth: 1 }) +
-                    associationSerializer.globalName));
-            }
-            acc[association.as] = {
-                parentDreamClass: this,
-                nestedSerializerInfo: serializerAssociation.type === 'delegatedAttribute'
-                    ? {}
-                    : associatedClass['recursiveSerializationMap'](associationSerializer, {
+            const associatedClasses = Array.isArray(maybeAssociatedClasses)
+                ? maybeAssociatedClasses
+                : [maybeAssociatedClasses];
+            /////////////////////////////////////////////////
+            // map associated classes to their serializers //
+            /////////////////////////////////////////////////
+            const associatedClassSerializerTuples = associatedClasses.flatMap(associatedClass => {
+                /**
+                 * `serializers` is an array because `associatedClass` may be an STI
+                 * base, with each of its STI children having its own serializer
+                 */
+                const serializers = serializerAssociation.options.serializer
+                    ? [serializerAssociation.options.serializer]
+                    : (0, inferSerializerFromDreamOrViewModel_js_1.inferSerializersFromDreamClassOrViewModelClass)(associatedClass, serializerAssociation.options.serializerKey);
+                if (!serializers.length)
+                    throw new Error(`No serializer found to render ${serializerAssociationName} on ${this.sanitizedName}`);
+                return serializers.map(serializer => [associatedClass, serializer]);
+            });
+            /////////////////////////////////////////////////////
+            // end:map associated classes to their serializers //
+            /////////////////////////////////////////////////////
+            ///////////////////////////////////////////////////////////////////////////////////////////////////
+            // reduce over all associated serializers, recursively building out their associated serializers //
+            ///////////////////////////////////////////////////////////////////////////////////////////////////
+            const innerAssociationSerializerInfo = associatedClassSerializerTuples.reduce((innerAccumulator, [associatedClass, associatedSerializer]) => {
+                if (forDisplay && serializerAssociationType !== 'delegatedAttribute') {
+                    (0, printSerializerHierarchyLevel_js_1.default)({
+                        serializerAssociationType,
+                        serializerAssociationName,
+                        associationSerializer: associatedSerializer,
+                        forDisplayDepth,
+                    });
+                }
+                return {
+                    ...innerAccumulator,
+                    ...associatedClass['recursiveSerializationMap'](associatedSerializer, {
                         forDisplay,
                         forDisplayDepth: forDisplayDepth + 1,
                     }),
+                };
+            }, {});
+            ///////////////////////////////////////////////////////////////////////////////////////////////////////
+            // end:reduce over all associated serializers, recursively building out their associated serializers //
+            ///////////////////////////////////////////////////////////////////////////////////////////////////////
+            accumulator[association.as] = {
+                parentDreamClass: this,
+                nestedSerializerInfo: serializerAssociation.type === 'delegatedAttribute' ? {} : innerAssociationSerializerInfo,
             };
-            return acc;
+            return accumulator;
         }, {});
     }
     /**
@@ -659,11 +681,57 @@ class Dream {
         return map;
     }
     /**
-     * @internal
+     * Checks whether the specified association has been defined on this Dream model.
+     *
+     * ```ts
+     * const user = User.new()
+     *
+     * user.hasAssociation('posts')
+     * // true (if User has a posts association defined)
+     *
+     * user.hasAssociation('nonExistentAssociation')
+     * // false
+     *
+     * // Useful for conditional association handling
+     * if (user.hasAssociation('posts')) {
+     *   user = await user.load('posts').execute()
+     * }
+     * ```
+     *
+     * @param associationName - The name of the association to check for
+     * @returns `true` if the association exists on this model, `false` otherwise
+     */
+    hasAssociation(associationName) {
+        return !!(this.associationMetadataByType.belongsTo.find(association => association.as === associationName) ||
+            this.associationMetadataByType.hasOne.find(association => association.as === associationName) ||
+            this.associationMetadataByType.hasMany.find(association => association.as === associationName));
+    }
+    /**
+     * Returns all of the association names for this Dream class.
+     * This includes all BelongsTo, HasOne, and HasMany associations
+     * defined on the model.
      *
-     * Returns all of the association names for this dream class
+     * This is useful for introspection, debugging, or dynamically working
+     * with all associations on a model.
+     *
+     * ```ts
+     * class User extends ApplicationModel {
+     *   @deco.HasMany('Post')
+     *   public posts: Post[]
+     *
+     *   @deco.HasOne('Profile')
+     *   public profile: Profile
+     *
+     *   @deco.BelongsTo('Company')
+     *   public company: Company
+     * }
+     *
+     * User.associationNames
+     * // ['posts', 'profile', 'company']
+     * })
+     * ```
      *
-     * @returns All of the association names for this dream class
+     * @returns An array containing all association names defined on this Dream class
      */
     static get associationNames() {
         const allAssociations = [
@@ -855,7 +923,7 @@ class Dream {
             return dreamModel;
         }
         catch (err) {
-            if ((0, errors_js_1.pgErrorType)(err) === 'UNIQUE_CONSTRAINT_VIOLATION') {
+            if ((0, errors_js_1.pgErrorType)(err) === errors_js_1.UNIQUE_VIOLATION) {
                 const dreamModel = await this.findBy(this.extractAttributesFromUpdateableProperties(attributes));
                 if (!dreamModel)
                     throw new CreateOrFindByFailedToCreateAndFind_js_1.default(this);
@@ -909,7 +977,7 @@ class Dream {
             }, skipHooks ? { skipHooks } : undefined);
         }
         catch (err) {
-            if ((0, errors_js_1.pgErrorType)(err) === 'UNIQUE_CONSTRAINT_VIOLATION') {
+            if ((0, errors_js_1.pgErrorType)(err) === errors_js_1.UNIQUE_VIOLATION) {
                 const existingRecord = await this.findBy(this.extractAttributesFromUpdateableProperties(attributes));
                 if (!existingRecord)
                     throw new CreateOrUpdateByFailedToCreateAndUpdate_js_1.default(this);

package/dist/cjs/src/db/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PG_ERRORS = void 0;
+exports.PG_ERRORS = exports.UNIQUE_VIOLATION = exports.RESTRICT_VIOLATION = exports.NOT_NULL_VIOLATION = exports.INVALID_INPUT_SYNTAX = exports.INTEGRITY_CONSTRAINT_VIOLATION = exports.FOREIGN_KEY_VIOLATION = exports.CHECK_VIOLATION = void 0;
 exports.pgErrorType = pgErrorType;
 // after building for esm, importing pg using the following:
 //
@@ -11,12 +11,22 @@ exports.pgErrorType = pgErrorType;
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 const pg_1 = require("pg");
-const UNIQUE_CONSTRAINT_VIOLATION = 'UNIQUE_CONSTRAINT_VIOLATION';
-const INVALID_INPUT_SYNTAX = 'INVALID_INPUT_SYNTAX';
+exports.CHECK_VIOLATION = 'CHECK_VIOLATION';
+exports.FOREIGN_KEY_VIOLATION = 'FOREIGN_KEY_VIOLATION';
+exports.INTEGRITY_CONSTRAINT_VIOLATION = 'INTEGRITY_CONSTRAINT_VIOLATION';
+exports.INVALID_INPUT_SYNTAX = 'INVALID_INPUT_SYNTAX';
+exports.NOT_NULL_VIOLATION = 'NOT_NULL_VIOLATION';
+exports.RESTRICT_VIOLATION = 'RESTRICT_VIOLATION';
+exports.UNIQUE_VIOLATION = 'UNIQUE_VIOLATION';
 exports.PG_ERRORS = {
-    '23505': UNIQUE_CONSTRAINT_VIOLATION,
-    '22P02': INVALID_INPUT_SYNTAX,
-    '22007': INVALID_INPUT_SYNTAX,
+    '23505': exports.UNIQUE_VIOLATION,
+    '22007': exports.INVALID_INPUT_SYNTAX,
+    '22P02': exports.INVALID_INPUT_SYNTAX,
+    '23502': exports.NOT_NULL_VIOLATION,
+    '23514': exports.CHECK_VIOLATION,
+    '23000': exports.INTEGRITY_CONSTRAINT_VIOLATION,
+    '23001': exports.RESTRICT_VIOLATION,
+    '23503': exports.FOREIGN_KEY_VIOLATION,
 };
 function pgErrorFromCode(code) {
     return exports.PG_ERRORS[code] || null;

package/dist/cjs/src/dream/QueryDriver/Kysely.js

@@ -20,7 +20,9 @@ const MissingThroughAssociationSource_js_1 = require("../../errors/associations/
 const ThroughAssociationConditionsIncompatibleWithThroughAssociationSource_js_1 = require("../../errors/associations/ThroughAssociationConditionsIncompatibleWithThroughAssociationSource.js");
 const CannotNegateSimilarityClause_js_1 = require("../../errors/CannotNegateSimilarityClause.js");
 const CannotPassUndefinedAsAValueToAWhereClause_js_1 = require("../../errors/CannotPassUndefinedAsAValueToAWhereClause.js");
+const CheckConstraintViolation_js_1 = require("../../errors/db/CheckConstraintViolation.js");
 const DataTypeColumnTypeMismatch_js_1 = require("../../errors/db/DataTypeColumnTypeMismatch.js");
+const NotNullViolation_js_1 = require("../../errors/db/NotNullViolation.js");
 const UnexpectedUndefined_js_1 = require("../../errors/UnexpectedUndefined.js");
 const CalendarDate_js_1 = require("../../helpers/CalendarDate.js");
 const camelize_js_1 = require("../../helpers/camelize.js");
@@ -33,6 +35,7 @@ const dropDb_js_1 = require("../../helpers/db/dropDb.js");
 const loadPgClient_js_1 = require("../../helpers/db/loadPgClient.js");
 const runMigration_js_1 = require("../../helpers/db/runMigration.js");
 const EnvInternal_js_1 = require("../../helpers/EnvInternal.js");
+const groupBy_js_1 = require("../../helpers/groupBy.js");
 const isEmpty_js_1 = require("../../helpers/isEmpty.js");
 const namespaceColumn_js_1 = require("../../helpers/namespaceColumn.js");
 const normalizeUnicode_js_1 = require("../../helpers/normalizeUnicode.js");
@@ -435,11 +438,21 @@ class KyselyQueryDriver extends Base_js_1.default {
         }
         catch (error) {
             switch ((0, errors_js_1.pgErrorType)(error)) {
-                case 'INVALID_INPUT_SYNTAX':
+                case errors_js_1.INVALID_INPUT_SYNTAX:
                     throw new DataTypeColumnTypeMismatch_js_1.default({
                         dream,
                         error: error instanceof Error ? error : new Error('database column type error'),
                     });
+                case errors_js_1.NOT_NULL_VIOLATION:
+                    throw new NotNullViolation_js_1.default({
+                        dream,
+                        error: error instanceof Error ? error : new Error('not null violation'),
+                    });
+                case errors_js_1.CHECK_VIOLATION:
+                    throw new CheckConstraintViolation_js_1.default({
+                        dream,
+                        error: error instanceof Error ? error : new Error('check constraint violation'),
+                    });
             }
             throw error;
         }
@@ -1204,7 +1217,7 @@ class KyselyQueryDriver extends Base_js_1.default {
         const keys = Object.keys(preloadStatement);
         for (const key of keys) {
             const nestedDreams = await this.applyOnePreload(key, dream, this.applyablePreloadOnStatements(preloadOnStatements[key]));
-            if (nestedDreams) {
+            if (nestedDreams.length) {
                 await this.applyPreload(preloadStatement[key], preloadOnStatements[key], nestedDreams);
             }
         }
@@ -1699,18 +1712,10 @@ class KyselyQueryDriver extends Base_js_1.default {
      *
      * Used to preload polymorphic belongs to associations
      */
-    async preloadPolymorphicBelongsTo(association, dreams) {
-        if (!association.polymorphic)
-            throw new Error(`Association ${association.as} points to an array of models but is not designated polymorphic`);
-        if (association.type !== 'BelongsTo')
-            throw new Error(`Polymorphic association ${association.as} points to an array of models but is ${association.type}. Only BelongsTo associations may point to an array of models.`);
-        const nestedDreamsForNextRoundOfPreloading = [];
-        for (const associatedModel of association.modelCB()) {
-            await this.preloadPolymorphicAssociationModel(dreams, association, associatedModel, nestedDreamsForNextRoundOfPreloading);
-        }
-        return nestedDreamsForNextRoundOfPreloading;
+    async preloadPolymorphicBelongsTo(association, associatedModels, dreams) {
+        return (0, compact_js_1.default)(await Promise.all(associatedModels.map(associatedModel => this.preloadPolymorphicAssociationModel(dreams, association, associatedModel)))).flat();
     }
-    async preloadPolymorphicAssociationModel(dreams, association, associatedDreamClass, nestedDreamsForNextRoundOfPreloading) {
+    async preloadPolymorphicAssociationModel(dreams, association, associatedDreamClass) {
         const relevantAssociatedModels = dreams.filter((dream) => {
             const field = association.foreignKeyTypeField();
             return dream[field] === associatedDreamClass['stiBaseClassOrOwnClassName'] || dream[field] === null;
@@ -1729,7 +1734,6 @@ class KyselyQueryDriver extends Base_js_1.default {
                 [associatedDreamClass.primaryKey]: relevantAssociatedModels.map((dream) => dream[association.foreignKey()]),
             })
                 .all();
-            loadedAssociations.forEach((loadedAssociation) => nestedDreamsForNextRoundOfPreloading.push(loadedAssociation));
             //////////////////////////////////////////////////////////////////////////////////////////////
             // Associate each loaded association with each dream based on primary key and foreign key type
             //////////////////////////////////////////////////////////////////////////////////////////////
@@ -1744,6 +1748,7 @@ class KyselyQueryDriver extends Base_js_1.default {
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             // end: Associate each loaded association with each dream based on primary key and foreign key type
             ///////////////////////////////////////////////////////////////////////////////////////////////////
+            return loadedAssociations;
         }
     }
     /**
@@ -1782,12 +1787,18 @@ class KyselyQueryDriver extends Base_js_1.default {
      *
      * Applies a preload statement
      */
-    async applyOnePreload(associationName, dreams, onStatement = {}) {
+    async applyOnePreload(associationNameAndMaybeAlias, dreams, onStatement = {}) {
         if (!Array.isArray(dreams))
             dreams = [dreams];
-        const dream = dreams.find(dream => dream['getAssociationMetadata'](associationName));
-        if (!dream)
-            return;
+        const { name: associationName } = (0, associationStringToNameAndAlias_js_1.default)(associationNameAndMaybeAlias);
+        dreams = dreams.filter(dream => dream.hasAssociation(associationName));
+        const groupedDreams = (0, groupBy_js_1.default)(dreams, dream => dream.sanitizedConstructorName);
+        return (await Promise.all(Object.keys(groupedDreams).map(key => this._applyOnePreload(associationName, groupedDreams[key], onStatement)))).flat();
+    }
+    async _applyOnePreload(associationName, dreams, onStatement = {}) {
+        if (!dreams.length)
+            return [];
+        const dream = dreams[0];
         const { name, alias: _alias } = (0, associationStringToNameAndAlias_js_1.default)(associationName);
         const alias = _alias || name;
         const association = dream['getAssociationMetadata'](name);
@@ -1795,8 +1806,10 @@ class KyselyQueryDriver extends Base_js_1.default {
             throw new UnexpectedUndefined_js_1.default();
         const dreamClass = dream.constructor;
         const dreamClassToHydrate = association.modelCB();
-        if ((association.polymorphic && association.type === 'BelongsTo') || Array.isArray(dreamClassToHydrate))
-            return this.preloadPolymorphicBelongsTo(association, dreams);
+        if (Array.isArray(dreamClassToHydrate)) {
+            const preloadedPolymorphicBelongsTos = await this.preloadPolymorphicBelongsTo(association, dreamClassToHydrate, dreams);
+            return preloadedPolymorphicBelongsTos;
+        }
         const dreamClassToHydrateColumns = [...dreamClassToHydrate.columns()];
         const columnsToPluck = dreamClassToHydrateColumns.map(column => this.namespaceColumn(column.toString(), alias));
         columnsToPluck.push(this.namespaceColumn(dreamClass.primaryKey, dreamClass.table));

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = printSerializerHierarchyLevel;
+const yoctocolors_1 = require("yoctocolors");
+const indent_js_1 = require("../../helpers/indent.js");
+function printSerializerHierarchyLevel({ serializerAssociationType, serializerAssociationName, associationSerializer, forDisplayDepth, }) {
+    const hierarchyLine = '└───';
+    const indentation = (0, indent_js_1.indent)((hierarchyLine.length + 1) * forDisplayDepth, {
+        tabWidth: 1,
+    });
+    const prefix = `${hierarchyLine} `;
+    const nestedAssociationDisplay = indentation + `${prefix}${serializerAssociationType} ${yoctocolors_1.default.cyan(serializerAssociationName)}`;
+    console.log(nestedAssociationDisplay);
+    console.log(yoctocolors_1.default.gray(indentation +
+        (0, indent_js_1.indent)(prefix.length, { tabWidth: 1 }) +
+        associationSerializer.globalName));
+}

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

@@ -2,12 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cacheDreamApp = cacheDreamApp;
 exports.getCachedDreamAppOrFail = getCachedDreamAppOrFail;
+const EnvInternal_js_1 = require("../helpers/EnvInternal.js");
 let _dreamApp = undefined;
 function cacheDreamApp(dreamconf) {
     _dreamApp = dreamconf;
 }
 function getCachedDreamAppOrFail() {
-    if (!_dreamApp)
-        throw new Error('Must call `initializeDreamApp` or `initializePsychicApp` before loading cached DreamApp.getOrFail()');
+    if (!_dreamApp) {
+        const baseErrorMessage = 'Must call `initializeDreamApp` or `initializePsychicApp` before loading cached DreamApp.getOrFail().';
+        if (EnvInternal_js_1.default.isTest) {
+            throw new Error(`${baseErrorMessage}
+
+Check for specs running directly in a \`describe\` or \`context\` block rather than nested within an \`it\` block.`);
+        }
+        else {
+            throw new Error(baseErrorMessage);
+        }
+    }
     return _dreamApp;
 }

package/dist/cjs/src/errors/db/CheckConstraintViolation.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CheckConstraintViolation extends Error {
+    dream;
+    error;
+    constructor({ dream, error }) {
+        super();
+        this.dream = dream;
+        this.error = error;
+    }
+    get message() {
+        return this.error.message;
+    }
+}
+exports.default = CheckConstraintViolation;

package/dist/cjs/src/errors/db/DataTypeColumnTypeMismatch.js

@@ -9,11 +9,7 @@ class DataTypeColumnTypeMismatch extends Error {
         this.error = error;
     }
     get message() {
-        return `\
-Failed to save ${this.dream.sanitizedConstructorName}:
-
-${this.error.message}
-`;
+        return this.error.message;
     }
 }
 exports.default = DataTypeColumnTypeMismatch;

package/dist/cjs/src/errors/db/NotNullViolation.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class NotNullViolation extends Error {
+    dream;
+    error;
+    constructor({ dream, error }) {
+        super();
+        this.dream = dream;
+        this.error = error;
+    }
+    get message() {
+        return this.error.message;
+    }
+}
+exports.default = NotNullViolation;

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

@@ -22,6 +22,7 @@ async function generateMigration({ migrationName, columnsWithTypes, fullyQualifi
             table: (0, snakeify_js_1.default)((0, pluralize_esm_1.default)((0, pascalizePath_js_1.default)(fullyQualifiedParentName))),
             columnsWithTypes,
             primaryKeyType: (0, primaryKeyType_js_1.default)(),
+            stiChildClassName: (0, pascalizePath_js_1.default)(fullyQualifiedModelName),
         });
     }
     else if (fullyQualifiedModelName) {

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

@@ -9,13 +9,17 @@ const foreignKeyTypeFromPrimaryKey_js_1 = require("../db/foreignKeyTypeFromPrima
 const snakeify_js_1 = require("../snakeify.js");
 const STI_TYPE_COLUMN_NAME = 'type';
 const COLUMNS_TO_INDEX = [STI_TYPE_COLUMN_NAME];
-function generateMigrationContent({ table, columnsWithTypes = [], primaryKeyType = 'bigserial', createOrAlter = 'create', } = {}) {
+function generateMigrationContent({ table, columnsWithTypes = [], primaryKeyType = 'bigserial', createOrAlter = 'create', stiChildClassName, } = {}) {
     const altering = createOrAlter === 'alter';
     let requireCitextExtension = false;
-    const { columnDefs, columnDrops, indexDefs, indexDrops } = columnsWithTypes.reduce((acc, attribute) => {
+    const checkConstraints = [];
+    const { columnDefs, columnDrops, indexDefs, indexDrops } = columnsWithTypes.reduce((acc, attributeDeclaration) => {
         const { columnDefs, columnDrops, indexDefs, indexDrops } = acc;
-        const [nonStandardAttributeName, attributeType, ...descriptors] = attribute.split(':');
-        const optional = optionalFromDescriptors(descriptors);
+        const [nonStandardAttributeName, attributeType, ...descriptors] = attributeDeclaration.split(':');
+        const userWantsThisOptional = optionalFromDescriptors(descriptors);
+        // when creating a migration for an STI child, we don't want to include notNull;
+        // instead, we'll add a check constraint that uses the STI child class name
+        const optional = userWantsThisOptional || !!stiChildClassName;
         const sqlAttributeType = getAttributeType(attributeType, descriptors);
         let attributeName = (0, snakeify_js_1.default)(nonStandardAttributeName);
         if (attributeName === undefined)
@@ -24,6 +28,17 @@ function generateMigrationContent({ table, columnsWithTypes = [], primaryKeyType
             return acc;
         if (attributeType === 'citext')
             requireCitextExtension = true;
+        if (stiChildClassName && !userWantsThisOptional) {
+            checkConstraints.push(`
+
+  await db.schema
+    .alterTable('${table}')
+    .addCheckConstraint(
+      '${table}_not_null_${attributeName}',
+      sql\`type != '${stiChildClassName}' OR ${attributeName} IS NOT NULL\`,
+    )
+    .execute()`);
+        }
         switch (attributeType) {
             case 'belongs_to':
                 columnDefs.push(generateBelongsToStr(attributeName, {
@@ -100,7 +115,7 @@ ${citextExtension}${generateEnumStatements(columnsWithTypes)}  await db.schema
             ".addColumn('created_at', 'timestamp', col => col.notNull())" +
             newlineDoubleIndent +
             ".addColumn('updated_at', 'timestamp', col => col.notNull())"}
-    .execute()${indexDefs.length ? `\n${newlineIndent}` : ''}${indexDefs.join(newlineDoubleIndent)}
+    .execute()${indexDefs.length ? `\n${newlineIndent}` : ''}${indexDefs.join(newlineDoubleIndent)}${checkConstraints.join('')}
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any

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

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = generateStiMigrationContent;
 const generateMigrationContent_js_1 = require("./generateMigrationContent.js");
-function generateStiMigrationContent({ table, columnsWithTypes = [], primaryKeyType = 'bigserial', } = {}) {
-    return (0, generateMigrationContent_js_1.default)({ table, columnsWithTypes, primaryKeyType, createOrAlter: 'alter' });
+function generateStiMigrationContent({ table, columnsWithTypes = [], primaryKeyType = 'bigserial', stiChildClassName, }) {
+    return (0, generateMigrationContent_js_1.default)({
+        table,
+        columnsWithTypes,
+        primaryKeyType,
+        createOrAlter: 'alter',
+        stiChildClassName,
+    });
 }

package/dist/cjs/src/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dreamPath = exports.pascalize = exports.normalizeUnicode = exports.loadRepl = exports.isEmpty = exports.intersection = exports.hyphenize = exports.groupBy = exports.globalClassNameFromFullyQualifiedModelName = exports.Env = exports.DreamLogos = exports.DateTime = exports.compact = exports.cloneDeepSafe = exports.generateDream = exports.capitalize = exports.camelize = exports.CalendarDate = exports.Benchmark = exports.ValidationError = exports.RecordNotFound = exports.GlobalNameNotSet = exports.DataTypeColumnTypeMismatch = exports.CreateOrFindByFailedToCreateAndFind = exports.NonLoadedAssociation = exports.Encrypt = exports.Query = exports.DreamTransaction = exports.openapiShorthandPrimitiveTypes = exports.openapiPrimitiveTypes = exports.DreamConst = exports.Dream = exports.DreamAppAllowedPackageManagersEnumValues = exports.DreamApp = exports.lookupClassByGlobalName = exports.DreamImporter = exports.Decorators = exports.STI = exports.SoftDelete = exports.ReplicaSafe = exports.validateTable = exports.validateColumn = exports.DreamMigrationHelpers = exports.untypedDb = exports.pgErrorType = exports.dreamDbConnections = exports.closeAllDbConnections = exports.DreamCLI = exports.CliFileWriter = exports.DreamBin = void 0;
-exports.ObjectSerializerBuilder = exports.DreamSerializerBuilder = exports.ObjectSerializer = exports.DreamSerializer = exports.serializerNameFromFullyQualifiedModelName = exports.isDreamSerializer = exports.inferSerializersFromDreamClassOrViewModelClass = exports.inferSerializerFromDreamOrViewModel = exports.ops = exports.uniq = exports.uncapitalize = exports.expandStiClasses = exports.standardizeFullyQualifiedModelName = exports.sortObjectByValue = exports.sortObjectByKey = exports.sortBy = exports.sort = exports.snakeify = exports.round = exports.range = exports.Range = exports.sharedPathPrefix = exports.relativeDreamPath = void 0;
+exports.normalizeUnicode = exports.loadRepl = exports.isEmpty = exports.intersection = exports.hyphenize = exports.groupBy = exports.globalClassNameFromFullyQualifiedModelName = exports.Env = exports.DreamLogos = exports.DateTime = exports.compact = exports.cloneDeepSafe = exports.generateDream = exports.capitalize = exports.camelize = exports.CalendarDate = exports.Benchmark = exports.ValidationError = exports.RecordNotFound = exports.GlobalNameNotSet = exports.NotNullViolation = exports.DataTypeColumnTypeMismatch = exports.CheckConstraintViolation = exports.CreateOrFindByFailedToCreateAndFind = exports.NonLoadedAssociation = exports.Encrypt = exports.Query = exports.DreamTransaction = exports.openapiShorthandPrimitiveTypes = exports.openapiPrimitiveTypes = exports.DreamConst = exports.Dream = exports.DreamAppAllowedPackageManagersEnumValues = exports.DreamApp = exports.lookupClassByGlobalName = exports.DreamImporter = exports.Decorators = exports.STI = exports.SoftDelete = exports.ReplicaSafe = exports.validateTable = exports.validateColumn = exports.DreamMigrationHelpers = exports.untypedDb = exports.pgErrorType = exports.dreamDbConnections = exports.closeAllDbConnections = exports.DreamCLI = exports.CliFileWriter = exports.DreamBin = void 0;
+exports.ObjectSerializerBuilder = exports.DreamSerializerBuilder = exports.ObjectSerializer = exports.DreamSerializer = exports.serializerNameFromFullyQualifiedModelName = exports.isDreamSerializer = exports.inferSerializersFromDreamClassOrViewModelClass = exports.inferSerializerFromDreamOrViewModel = exports.ops = exports.uniq = exports.uncapitalize = exports.expandStiClasses = exports.standardizeFullyQualifiedModelName = exports.sortObjectByValue = exports.sortObjectByKey = exports.sortBy = exports.sort = exports.snakeify = exports.round = exports.range = exports.Range = exports.sharedPathPrefix = exports.relativeDreamPath = exports.dreamPath = exports.pascalize = void 0;
 var index_js_1 = require("./bin/index.js");
 Object.defineProperty(exports, "DreamBin", { enumerable: true, get: function () { return index_js_1.default; } });
 var CliFileWriter_js_1 = require("./cli/CliFileWriter.js");
@@ -52,8 +52,12 @@ var NonLoadedAssociation_js_1 = require("./errors/associations/NonLoadedAssociat
 Object.defineProperty(exports, "NonLoadedAssociation", { enumerable: true, get: function () { return NonLoadedAssociation_js_1.default; } });
 var CreateOrFindByFailedToCreateAndFind_js_1 = require("./errors/CreateOrFindByFailedToCreateAndFind.js");
 Object.defineProperty(exports, "CreateOrFindByFailedToCreateAndFind", { enumerable: true, get: function () { return CreateOrFindByFailedToCreateAndFind_js_1.default; } });
+var CheckConstraintViolation_js_1 = require("./errors/db/CheckConstraintViolation.js");
+Object.defineProperty(exports, "CheckConstraintViolation", { enumerable: true, get: function () { return CheckConstraintViolation_js_1.default; } });
 var DataTypeColumnTypeMismatch_js_1 = require("./errors/db/DataTypeColumnTypeMismatch.js");
 Object.defineProperty(exports, "DataTypeColumnTypeMismatch", { enumerable: true, get: function () { return DataTypeColumnTypeMismatch_js_1.default; } });
+var NotNullViolation_js_1 = require("./errors/db/NotNullViolation.js");
+Object.defineProperty(exports, "NotNullViolation", { enumerable: true, get: function () { return NotNullViolation_js_1.default; } });
 var GlobalNameNotSet_js_1 = require("./errors/dream-app/GlobalNameNotSet.js");
 Object.defineProperty(exports, "GlobalNameNotSet", { enumerable: true, get: function () { return GlobalNameNotSet_js_1.default; } });
 var RecordNotFound_js_1 = require("./errors/RecordNotFound.js");

package/dist/cjs/src/serializer/helpers/serializerForAssociatedClass.js

@@ -14,7 +14,8 @@ function serializerForAssociatedClass(object, associationName, options) {
         return null;
     const dream = object;
     const association = dream['getAssociationMetadata'](associationName);
-    const associatedClasses = association.modelCB();
-    const associatedClass = Array.isArray(associatedClasses) ? associatedClasses[0] : associatedClasses;
+    const associatedClass = association.modelCB();
+    if (Array.isArray(associatedClass))
+        throw new Error('rendersOne flatten is incompatible with a polymorphic belongs-to association');
     return (0, inferSerializerFromDreamOrViewModel_js_1.inferSerializersFromDreamClassOrViewModelClass)(associatedClass, options.serializerKey)[0] ?? null;
 }