@rvoh/dream 1.2.1 → 1.3.0

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

@@ -31,6 +31,7 @@ import _dropDb from '../../helpers/db/dropDb.js';
 import loadPgClient from '../../helpers/db/loadPgClient.js';
 import runMigration from '../../helpers/db/runMigration.js';
 import EnvInternal from '../../helpers/EnvInternal.js';
+import groupBy from '../../helpers/groupBy.js';
 import isEmpty from '../../helpers/isEmpty.js';
 import namespaceColumn from '../../helpers/namespaceColumn.js';
 import normalizeUnicode from '../../helpers/normalizeUnicode.js';
@@ -1202,7 +1203,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
         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);
             }
         }
@@ -1697,18 +1698,10 @@ export default class KyselyQueryDriver extends QueryDriverBase {
      *
      * 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 compact(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;
@@ -1727,7 +1720,6 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                 [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
             //////////////////////////////////////////////////////////////////////////////////////////////
@@ -1742,6 +1734,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             // end: Associate each loaded association with each dream based on primary key and foreign key type
             ///////////////////////////////////////////////////////////////////////////////////////////////////
+            return loadedAssociations;
         }
     }
     /**
@@ -1780,12 +1773,18 @@ export default class KyselyQueryDriver extends QueryDriverBase {
      *
      * 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 } = associationStringToNameAndAlias(associationNameAndMaybeAlias);
+        dreams = dreams.filter(dream => dream.hasAssociation(associationName));
+        const groupedDreams = groupBy(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 } = associationStringToNameAndAlias(associationName);
         const alias = _alias || name;
         const association = dream['getAssociationMetadata'](name);
@@ -1793,8 +1792,10 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             throw new UnexpectedUndefined();
         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/esm/src/dream/internal/printSerializerHierarchyLevel.js

@@ -0,0 +1,14 @@
+import yoctocolors from 'yoctocolors';
+import { indent } from '../../helpers/indent.js';
+export default function printSerializerHierarchyLevel({ serializerAssociationType, serializerAssociationName, associationSerializer, forDisplayDepth, }) {
+    const hierarchyLine = '└───';
+    const indentation = indent((hierarchyLine.length + 1) * forDisplayDepth, {
+        tabWidth: 1,
+    });
+    const prefix = `${hierarchyLine} `;
+    const nestedAssociationDisplay = indentation + `${prefix}${serializerAssociationType} ${yoctocolors.cyan(serializerAssociationName)}`;
+    console.log(nestedAssociationDisplay);
+    console.log(yoctocolors.gray(indentation +
+        indent(prefix.length, { tabWidth: 1 }) +
+        associationSerializer.globalName));
+}

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

@@ -1,9 +1,19 @@
+import EnvInternal from '../helpers/EnvInternal.js';
 let _dreamApp = undefined;
 export function cacheDreamApp(dreamconf) {
     _dreamApp = dreamconf;
 }
 export 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.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/esm/src/helpers/cli/generateMigration.js

@@ -19,6 +19,7 @@ export default async function generateMigration({ migrationName, columnsWithType
             table: snakeify(pluralize(pascalizePath(fullyQualifiedParentName))),
             columnsWithTypes,
             primaryKeyType: primaryKeyType(),
+            stiChildClassName: pascalizePath(fullyQualifiedModelName),
         });
     }
     else if (fullyQualifiedModelName) {

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

@@ -5,13 +5,17 @@ import foreignKeyTypeFromPrimaryKey from '../db/foreignKeyTypeFromPrimaryKey.js'
 import snakeify from '../snakeify.js';
 const STI_TYPE_COLUMN_NAME = 'type';
 const COLUMNS_TO_INDEX = [STI_TYPE_COLUMN_NAME];
-export default function generateMigrationContent({ table, columnsWithTypes = [], primaryKeyType = 'bigserial', createOrAlter = 'create', } = {}) {
+export default 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 = snakeify(nonStandardAttributeName);
         if (attributeName === undefined)
@@ -20,6 +24,17 @@ export default function generateMigrationContent({ table, columnsWithTypes = [],
             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, {
@@ -96,7 +111,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/esm/src/helpers/cli/generateStiMigrationContent.js

@@ -1,4 +1,10 @@
 import generateMigrationContent from './generateMigrationContent.js';
-export default function generateStiMigrationContent({ table, columnsWithTypes = [], primaryKeyType = 'bigserial', } = {}) {
-    return generateMigrationContent({ table, columnsWithTypes, primaryKeyType, createOrAlter: 'alter' });
+export default function generateStiMigrationContent({ table, columnsWithTypes = [], primaryKeyType = 'bigserial', stiChildClassName, }) {
+    return generateMigrationContent({
+        table,
+        columnsWithTypes,
+        primaryKeyType,
+        createOrAlter: 'alter',
+        stiChildClassName,
+    });
 }

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

@@ -11,7 +11,8 @@ export 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 inferSerializersFromDreamClassOrViewModelClass(associatedClass, options.serializerKey)[0] ?? null;
 }

package/dist/types/src/Dream.d.ts

@@ -1,22 +1,17 @@
 import { CompiledQuery, Updateable } from 'kysely';
-import { VirtualAttributeStatement } from './decorators/field-or-getter/Virtual.js';
-import { SortableFieldConfig } from './decorators/field/sortable/Sortable.js';
-import { ScopeStatement } from './decorators/static-method/Scope.js';
 import DreamClassTransactionBuilder from './dream/DreamClassTransactionBuilder.js';
 import DreamInstanceTransactionBuilder from './dream/DreamInstanceTransactionBuilder.js';
 import DreamTransaction from './dream/DreamTransaction.js';
 import { DestroyOptions } from './dream/internal/destroyOptions.js';
-import { RecursiveSerializerInfo } from './dream/internal/extractNestedPaths.js';
 import LeftJoinLoadBuilder from './dream/LeftJoinLoadBuilder.js';
 import LoadBuilder from './dream/LoadBuilder.js';
 import Query from './dream/Query.js';
-import { AssociationStatementsMap, PassthroughOnClause, WhereStatement } from './types/associations/shared.js';
+import { PassthroughOnClause, WhereStatement } from './types/associations/shared.js';
 import { AssociationTableNames, DbConnectionType } from './types/db.js';
 import { AllDefaultScopeNames, AssociationNameToDream, AttributeKeys, CreateOrFindByExtraOpts, DefaultOrNamedScopeName, DreamAssociationNames, DreamAssociationNamesWithoutRequiredOnClauses, DreamAttributes, DreamColumnNames, DreamParamSafeColumnNames, DreamSerializerKey, IdType, JoinAndStatements, NextPreloadArgumentType, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, TableColumnNames, UpdateableAssociationProperties, UpdateableProperties, UpdateablePropertiesForClass, UpdateOrCreateByExtraOpts } from './types/dream.js';
-import { HookStatement, HookStatementMap } from './types/lifecycle.js';
 import { BaseModelColumnTypes, DefaultQueryTypeOptions, FindEachOpts, LoadForModifierFn, PaginatedDreamQueryOptions, PaginatedDreamQueryResult, QueryWithJoinedAssociationsType, QueryWithJoinedAssociationsTypeAndNoPreload } from './types/query.js';
 import { DreamModelSerializerType, SimpleObjectSerializerType } from './types/serializer.js';
-import { ValidationStatement, ValidationType } from './types/validation.js';
+import { ValidationType } from './types/validation.js';
 import { JoinedAssociation, JoinedAssociationsTypeFromAssociations, RequiredOnClauseKeys, VariadicJoinsArgs, VariadicLeftJoinLoadArgs, VariadicLoadArgs } from './types/variadic.js';
 export default class Dream {
     DB: any;
@@ -43,7 +38,7 @@ export default class Dream {
      * property is set.
      *
      */
-    protected columnSetterGuardActivated: boolean;
+    private columnSetterGuardActivated;
     /**
      * @internal
      *
@@ -152,7 +147,7 @@ export default class Dream {
      *   @deco.HasMany
      *   @deco.BelongsTo
      */
-    protected static associationMetadataByType: AssociationStatementsMap;
+    private static associationMetadataByType;
     /**
      * @internal
      *
@@ -161,10 +156,7 @@ export default class Dream {
      * always an array rather than undefined,
      * freezing ensures that we never modify the static array on the inherited Dream class)
      */
-    protected static scopes: {
-        default: readonly ScopeStatement[] | ScopeStatement[];
-        named: readonly ScopeStatement[] | ScopeStatement[];
-    };
+    private static scopes;
     /**
      * @internal
      *
@@ -173,7 +165,7 @@ export default class Dream {
      * always an array rather than undefined,
      * freezing ensures that we never modify the static array on the inherited Dream class)
      */
-    protected static virtualAttributes: readonly VirtualAttributeStatement[] | VirtualAttributeStatement[];
+    private static virtualAttributes;
     /**
      * @internal
      *
@@ -181,7 +173,7 @@ export default class Dream {
      * methods. Set on the inheriting class when using the Virtual decorator (this default
      * assignment simply ensures that it is always an array rather than undefined)
      */
-    protected static explicitUnsafeParamColumns: readonly string[] | string[];
+    private static explicitUnsafeParamColumns;
     /**
      * @internal
      *
@@ -190,13 +182,13 @@ export default class Dream {
      * freezing ensures that we never modify the static array on the inherited Dream class)
      *
      */
-    protected static sortableFields: readonly SortableFieldConfig[] | SortableFieldConfig[];
+    private static sortableFields;
     /**
      * @internal
      *
      * Model storage for STI metadata, set when using the STI decorator
      */
-    protected static extendedBy: (typeof Dream)[] | null;
+    private static extendedBy;
     /**
      * @internal
      *
@@ -204,11 +196,7 @@ export default class Dream {
      *  (this default assignment simply ensures that it is always a valid object rather than undefined,
      * freezing ensures that we never modify the static array on the inherited Dream class)
      */
-    protected static sti: {
-        active: boolean;
-        baseClass: typeof Dream | null;
-        value: string | null;
-    };
+    private static sti;
     /**
      * @internal
      *
@@ -226,7 +214,7 @@ export default class Dream {
      *   AfterDestroy
      *   AfterDestroyCommit
      */
-    protected static hooks: Readonly<HookStatementMap>;
+    private static hooks;
     /**
      * @internal
      *
@@ -234,7 +222,7 @@ export default class Dream {
      * (this default assignment simply ensures that it is always an array rather than undefined,
      * freezing ensures that we never modify the static array on the inherited Dream class)
      */
-    protected static validations: readonly ValidationStatement[] | ValidationStatement[];
+    private static validations;
     /**
      * @internal
      *
@@ -243,19 +231,19 @@ export default class Dream {
      * freezing ensures that we never modify the static array on the inherited Dream class)
      *
      */
-    protected static customValidations: readonly string[] | string[];
+    private static customValidations;
     /**
      * @internal
      *
      * Model storage for replica-safe metadata, set when using the ReplicaSafe decorator
      */
-    protected static replicaSafe: boolean;
+    private static replicaSafe;
     /**
      * @internal
      *
      * Model storage for soft-delete metadata, set when using the SoftDelete decorator
      */
-    protected static softDelete: boolean;
+    private static softDelete;
     /**
      * @internal
      *
@@ -271,7 +259,7 @@ export default class Dream {
      *
      * @returns boolean
      */
-    protected static get isSTIBase(): boolean;
+    private static get isSTIBase();
     /**
      * @internal
      *
@@ -279,7 +267,7 @@ export default class Dream {
      *
      * @returns boolean
      */
-    protected static get isSTIChild(): boolean;
+    private static get isSTIChild();
     /**
      * @internal
      *
@@ -287,7 +275,7 @@ export default class Dream {
      *
      * @returns A dream class
      */
-    protected static get stiBaseClassOrOwnClass(): typeof Dream;
+    private static get stiBaseClassOrOwnClass();
     /**
      * @internal
      *
@@ -308,7 +296,7 @@ export default class Dream {
      *
      * @returns string
      */
-    protected static get stiBaseClassOrOwnClassName(): string;
+    private static get stiBaseClassOrOwnClassName();
     /**
      * @internal
      *
@@ -328,7 +316,7 @@ export default class Dream {
      *
      * @returns A dream class
      */
-    protected get stiBaseClassOrOwnClass(): typeof Dream;
+    private get stiBaseClassOrOwnClass();
     /**
      * @internal
      *
@@ -336,7 +324,7 @@ export default class Dream {
      *
      * @returns A string
      */
-    protected get stiBaseClassOrOwnClassName(): string;
+    private get stiBaseClassOrOwnClassName();
     /**
      * this.constructor.name may be prefixed with an underscore during conversion to Javascript.
      * This method returns the constructor name without a leading underscore.
@@ -353,7 +341,7 @@ export default class Dream {
      * @param statement - the statement to couple to the provided hookType
      * @returns void
      */
-    protected static addHook(hookType: keyof typeof this.hooks, statement: HookStatement): void;
+    private static addHook;
     /**
      * @internal
      *
@@ -372,12 +360,9 @@ export default class Dream {
      * name of that model.
      */
     private static setGlobalName;
-    protected static serializationMap<T extends typeof Dream, I extends InstanceType<T>, SerializerKey extends DreamSerializerKey<I>>(this: T, serializerKey?: SerializerKey): RecursiveSerializerInfo;
-    protected static displaySerialization<T extends typeof Dream, I extends InstanceType<T>, SerializerKey extends DreamSerializerKey<I>>(this: T, serializerKey?: SerializerKey): RecursiveSerializerInfo;
-    protected static recursiveSerializationMap(serializer: DreamModelSerializerType | SimpleObjectSerializerType, { forDisplay, forDisplayDepth, }?: {
-        forDisplay?: boolean;
-        forDisplayDepth?: number;
-    }): RecursiveSerializerInfo;
+    private static serializationMap;
+    private static displaySerialization;
+    private static recursiveSerializationMap;
     /**
      * Returns the column names for the given model
      *
@@ -400,7 +385,7 @@ export default class Dream {
      * @returns A subset of columns for the given dream class
      */
     static paramSafeColumnsOrFallback<T extends typeof Dream, I extends InstanceType<T>, ParamSafeColumnsOverride extends InstanceType<T>['paramSafeColumns' & keyof InstanceType<T>] extends never ? undefined : InstanceType<T>['paramSafeColumns' & keyof InstanceType<T>] & string[], ReturnVal extends ParamSafeColumnsOverride extends string[] ? Extract<DreamParamSafeColumnNames<I>, ParamSafeColumnsOverride[number] & DreamParamSafeColumnNames<I>>[] : DreamParamSafeColumnNames<I>[]>(this: T): ReturnVal;
-    protected static defaultParamSafeColumns<T extends typeof Dream, I extends InstanceType<T>>(this: T): DreamParamSafeColumnNames<I>[];
+    private static defaultParamSafeColumns;
     /**
      * @internal
      *
@@ -453,11 +438,53 @@ export default class Dream {
      */
     private static associationMetadataMap;
     /**
-     * @internal
+     * Checks whether the specified association has been defined on this Dream model.
      *
-     * Returns all of the association names for this dream class
+     * ```ts
+     * const user = User.new()
+     *
+     * user.hasAssociation('posts')
+     * // true (if User has a posts association defined)
      *
-     * @returns All of the association names for this dream class
+     * 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: string): boolean;
+    /**
+     * Returns all of the association names for this Dream class.
+     * This includes all BelongsTo, HasOne, and HasMany associations
+     * defined on the model.
+     *
+     * 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 An array containing all association names defined on this Dream class
      */
     static get associationNames(): string[];
     /**
@@ -1764,7 +1791,7 @@ export default class Dream {
      * @returns A boolean
      */
     get isPersisted(): boolean;
-    protected set isPersisted(val: boolean);
+    private set isPersisted(value);
     /**
      * Since typescript prevents constructor functions
      * from absorbing type generics, we provide the `new`
@@ -1806,9 +1833,7 @@ export default class Dream {
      *
      * Used for determining which attributes to update
      */
-    protected static extractAttributesFromUpdateableProperties<T extends typeof Dream>(this: T, attributes: UpdateablePropertiesForClass<T>, dreamInstance?: InstanceType<T>, { bypassUserDefinedSetters }?: {
-        bypassUserDefinedSetters?: boolean;
-    }): WhereStatement<InstanceType<T>['DB'], InstanceType<T>['schema'], InstanceType<T>['table']>;
+    private static extractAttributesFromUpdateableProperties;
     /**
      * @internal
      *
@@ -1824,8 +1849,8 @@ export default class Dream {
      * every Dream model is initialized to delete the instance accessors so that
      * the prototype accessors can be reached.
      */
-    protected unshadowColumnPropertyPrototypeAccessors(): void;
-    protected finalizeConstruction(): void;
+    private unshadowColumnPropertyPrototypeAccessors;
+    private finalizeConstruction;
     /**
      * @internal
      *
@@ -1923,7 +1948,7 @@ export default class Dream {
      *
      * Returns the db type stored within the database
      */
-    protected static cachedTypeFor<T extends typeof Dream, DB extends InstanceType<T>['DB'], TableName extends keyof DB = InstanceType<T>['table'] & keyof DB, Table extends DB[keyof DB] = DB[TableName]>(this: T, attribute: keyof Table): string;
+    private static cachedTypeFor;
     /**
      * Returns the attributes that have changed since
      * being persisted to the database, with the values
@@ -2167,7 +2192,7 @@ export default class Dream {
      *
      * Used for changes API
      */
-    protected freezeAttributes(): void;
+    private freezeAttributes;
     /**
      * Deep clones the model and its non-association attributes.
      * Unsets primaryKey, created and updated fields.

package/dist/types/src/dream/QueryDriver/Kysely.d.ts

@@ -381,4 +381,5 @@ export default class KyselyQueryDriver<DreamInstance extends Dream> extends Quer
      * Applies a preload statement
      */
     private applyOnePreload;
+    private _applyOnePreload;
 }

package/dist/types/src/dream/internal/printSerializerHierarchyLevel.d.ts

@@ -0,0 +1,7 @@
+import { DreamModelSerializerType, InternalAnyTypedSerializerDelegatedAttribute, InternalAnyTypedSerializerRendersMany, InternalAnyTypedSerializerRendersOne, SimpleObjectSerializerType } from '../../types/serializer.js';
+export default function printSerializerHierarchyLevel({ serializerAssociationType, serializerAssociationName, associationSerializer, forDisplayDepth, }: {
+    serializerAssociationType: (InternalAnyTypedSerializerRendersMany<any> | InternalAnyTypedSerializerRendersOne<any> | InternalAnyTypedSerializerDelegatedAttribute)['type'];
+    serializerAssociationName: string;
+    associationSerializer: DreamModelSerializerType | SimpleObjectSerializerType;
+    forDisplayDepth: number;
+}): void;

package/dist/types/src/helpers/cli/generateMigrationContent.d.ts

@@ -1,8 +1,9 @@
 import { PrimaryKeyType } from '../../types/dream.js';
-export default function generateMigrationContent({ table, columnsWithTypes, primaryKeyType, createOrAlter, }?: {
+export default function generateMigrationContent({ table, columnsWithTypes, primaryKeyType, createOrAlter, stiChildClassName, }?: {
     table?: string | undefined;
     columnsWithTypes?: string[] | undefined;
     primaryKeyType?: PrimaryKeyType | undefined;
     createOrAlter?: 'create' | 'alter' | undefined;
+    stiChildClassName?: string | undefined;
 }): string;
 export declare function optionalFromDescriptors(descriptors: string[]): boolean;

package/dist/types/src/helpers/cli/generateStiMigrationContent.d.ts

@@ -1,6 +1,7 @@
 import { PrimaryKeyType } from '../../types/dream.js';
-export default function generateStiMigrationContent({ table, columnsWithTypes, primaryKeyType, }?: {
+export default function generateStiMigrationContent({ table, columnsWithTypes, primaryKeyType, stiChildClassName, }: {
     table?: string;
     columnsWithTypes?: string[];
     primaryKeyType?: PrimaryKeyType;
+    stiChildClassName?: string;
 }): string;

package/dist/types/src/serializer/builders/DreamSerializerBuilder.d.ts

@@ -36,7 +36,7 @@ export default class DreamSerializerBuilder<DataTypeForOpenapi extends typeof Dr
      *
      * See: {@link https://your-docs-url.com/docs/serializers/attributes | Serializer Attributes Documentation}
      */
-    attribute<MaybeAttributeName extends NonJsonDreamColumnNames<DataType> | (keyof DataType & string), AttributeName extends MaybeAttributeName extends NonJsonDreamColumnNames<DataType> ? never : keyof DataType & string, Options extends NonAutomaticSerializerAttributeOptionsWithPossibleDecimalRenderOption>(name: AttributeName, options: Options): DreamSerializerBuilder<DataTypeForOpenapi, MaybeNullDataType, PassthroughDataType, DataType>;
+    attribute<MaybeAttributeName extends NonJsonDreamColumnNames<DataType> | (keyof DataType & string), AttributeName extends MaybeAttributeName extends NonJsonDreamColumnNames<DataType> ? never : Exclude<keyof DataType, keyof Dream> & string, Options extends NonAutomaticSerializerAttributeOptionsWithPossibleDecimalRenderOption>(name: AttributeName, options: Options): DreamSerializerBuilder<DataTypeForOpenapi, MaybeNullDataType, PassthroughDataType, DataType>;
     attribute<AttributeName extends NonJsonDreamColumnNames<DataType> & keyof DataType & string, Options extends AutomaticSerializerAttributeOptions<DataType, AttributeName>>(name: AttributeName, options?: Options): DreamSerializerBuilder<DataTypeForOpenapi, MaybeNullDataType, PassthroughDataType, DataType>;
     /**
      * Includes an attribute from a nested object in the serialized output.

package/dist/types/src/types/dream.d.ts

@@ -22,7 +22,7 @@ export interface SortableOptions<T extends Dream> {
 }
 export type PrimaryKeyForFind<I extends Dream, Schema extends I['schema'] = I['schema'], TableName extends keyof Schema = I['table'] & keyof Schema> = Schema[TableName]['columns'][I['primaryKey'] & keyof Schema[TableName]['columns']]['coercedType'] | string | null | undefined;
 export type DreamColumnNames<DreamInstance extends Dream, DB = DreamInstance['DB'], TableName extends keyof DB = DreamInstance['table'] & keyof DB, Table extends DB[keyof DB] = DB[TableName], AttributeName extends keyof Table & string = keyof Table & string> = AttributeName;
-export type NonJsonDreamColumnNames<DreamInstance extends Dream, Schema extends DreamInstance['schema'] = DreamInstance['schema'], TableName extends DreamInstance['table'] & keyof Schema = DreamInstance['table'] & keyof Schema, AttributeName extends Schema[TableName]['nonJsonColumnNames'][number] & string = Schema[TableName]['nonJsonColumnNames'][number] & string> = AttributeName;
+export type NonJsonDreamColumnNames<DreamInstance extends Dream, Schema extends DreamInstance['schema'] = DreamInstance['schema'], TableName extends DreamInstance['table'] & keyof Schema = DreamInstance['table'] & keyof Schema, AttributeName extends Exclude<Schema[TableName]['nonJsonColumnNames'][number], keyof Dream> & string = Exclude<Schema[TableName]['nonJsonColumnNames'][number], keyof Dream> & string> = AttributeName;
 export type DreamParamSafeColumnNames<DreamInstance extends Dream, BelongsToForeignKeys = DreamBelongsToForeignKeys<DreamInstance>, Schema = DreamInstance['schema'], TableSchema = Schema[DreamInstance['table'] & keyof Schema]> = Exclude<keyof UpdateableProperties<DreamInstance>, BelongsToForeignKeys | TableSchema['primaryKey' & keyof TableSchema] | TableSchema['createdAtField' & keyof TableSchema] | TableSchema['updatedAtField' & keyof TableSchema] | TableSchema['deletedAtField' & keyof TableSchema] | 'type'>;
 export type DreamBelongsToForeignKeys<DreamInstance extends Dream, Schema = DreamInstance['schema'], TableSchema = Schema[DreamInstance['table'] & keyof Schema], AssociationSchema = TableSchema['associations' & keyof TableSchema], BelongsToAssociationSchema = AssociationSchema[keyof DreamBelongsToAssociationMetadata<DreamInstance> & keyof AssociationSchema], BelongsToForeignKeys = Exclude<BelongsToAssociationSchema['foreignKey' & keyof BelongsToAssociationSchema], null>> = BelongsToForeignKeys;
 export type TableColumnNames<DB, TableName extends keyof DB, Table extends DB[keyof DB] = DB[TableName]> = keyof Table & string;

package/dist/types/src/types/dream.ts

@@ -61,8 +61,8 @@ export type NonJsonDreamColumnNames<
   DreamInstance extends Dream,
   Schema extends DreamInstance['schema'] = DreamInstance['schema'],
   TableName extends DreamInstance['table'] & keyof Schema = DreamInstance['table'] & keyof Schema,
-  AttributeName extends Schema[TableName]['nonJsonColumnNames'][number] &
-    string = Schema[TableName]['nonJsonColumnNames'][number] & string,
+  AttributeName extends Exclude<Schema[TableName]['nonJsonColumnNames'][number], keyof Dream> &
+    string = Exclude<Schema[TableName]['nonJsonColumnNames'][number], keyof Dream> & string,
 > = AttributeName
 
 export type DreamParamSafeColumnNames<