@rvoh/dream 0.29.1

package/dist/cjs/src/decorators/ReplicaSafe.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ReplicaSafe;
+const StiChildIncompatibleWithReplicaSafeDecorator_js_1 = require("../errors/sti/StiChildIncompatibleWithReplicaSafeDecorator.js");
+function ReplicaSafe() {
+    return function (target) {
+        const dreamClass = target;
+        if (dreamClass['isSTIChild'])
+            throw new StiChildIncompatibleWithReplicaSafeDecorator_js_1.default(dreamClass);
+        dreamClass['replicaSafe'] = true;
+    };
+}

package/dist/cjs/src/decorators/STI.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STI_SCOPE_NAME = void 0;
+exports.default = STI;
+const StiChildCannotDefineNewAssociations_js_1 = require("../errors/sti/StiChildCannotDefineNewAssociations.js");
+const StiChildIncompatibleWithReplicaSafeDecorator_js_1 = require("../errors/sti/StiChildIncompatibleWithReplicaSafeDecorator.js");
+const StiChildIncompatibleWithSoftDeleteDecorator_js_1 = require("../errors/sti/StiChildIncompatibleWithSoftDeleteDecorator.js");
+const Scope_js_1 = require("./Scope.js");
+exports.STI_SCOPE_NAME = 'dream:STI';
+function STI(dreamClass, { value } = {}) {
+    return function (target) {
+        const stiChildClass = target;
+        const baseClass = dreamClass['sti'].baseClass || dreamClass;
+        if (Object.getOwnPropertyDescriptor(stiChildClass, 'associationMetadataByType'))
+            throw new StiChildCannotDefineNewAssociations_js_1.default(baseClass, stiChildClass);
+        if (Object.getOwnPropertyDescriptor(stiChildClass, 'replicaSafe'))
+            throw new StiChildIncompatibleWithReplicaSafeDecorator_js_1.default(stiChildClass);
+        if (Object.getOwnPropertyDescriptor(stiChildClass, 'softDelete'))
+            throw new StiChildIncompatibleWithSoftDeleteDecorator_js_1.default(stiChildClass);
+        if (!Object.getOwnPropertyDescriptor(stiChildClass, 'extendedBy'))
+            stiChildClass['extendedBy'] = [];
+        if (!Object.getOwnPropertyDescriptor(dreamClass, 'extendedBy'))
+            dreamClass['extendedBy'] = [];
+        dreamClass['extendedBy'].push(stiChildClass);
+        stiChildClass['sti'] = {
+            active: true,
+            baseClass,
+            value: value || stiChildClass.name,
+        };
+        stiChildClass[exports.STI_SCOPE_NAME] = function (query) {
+            return query.where({ type: stiChildClass['sti'].value });
+        };
+        (0, Scope_js_1.scopeImplementation)(stiChildClass, exports.STI_SCOPE_NAME, { default: true });
+    };
+}

package/dist/cjs/src/decorators/Scope.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Scope;
+exports.scopeImplementation = scopeImplementation;
+function Scope(opts = {}) {
+    return function (_, context) {
+        const key = context.name;
+        context.addInitializer(function () {
+            // this is already a typeof Dream here, because scopes
+            // can only be set on static methods
+            const t = this;
+            scopeImplementation(t, key, opts);
+        });
+    };
+}
+function scopeImplementation(t, key, opts = {}) {
+    const branch = opts.default ? 'default' : 'named';
+    if (!Object.getOwnPropertyDescriptor(t, 'scopes'))
+        t['scopes'] = {
+            default: [...(t['scopes']?.default || [])],
+            named: [...(t['scopes']?.named || [])],
+        };
+    const alreadyApplied = !!t['scopes'][branch].find(scope => scope.method === key);
+    if (!alreadyApplied) {
+        ;
+        t['scopes'][branch].push({
+            method: key,
+            default: opts.default || false,
+        });
+    }
+}

package/dist/cjs/src/decorators/SoftDelete.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOFT_DELETE_SCOPE_NAME = void 0;
+exports.default = SoftDelete;
+const StiChildIncompatibleWithSoftDeleteDecorator_js_1 = require("../errors/sti/StiChildIncompatibleWithSoftDeleteDecorator.js");
+const Scope_js_1 = require("./Scope.js");
+exports.SOFT_DELETE_SCOPE_NAME = 'dream:SoftDelete';
+/**
+ * Instructs the model to set a timestamp when deleting,
+ * rather than actually removing the record from the
+ * database.
+ *
+ * By default, the SoftDelete decorator will expect a
+ * `deletedAt` field to be set on your model, pointing
+ * to a `timestamp` field in the database, like so:
+ *
+ * ```ts
+ * export async function up(db: Kysely<any>): Promise<void> {
+ *   await db.schema
+ *     .createTable('posts')
+ *     .addColumn('id', 'bigserial', col => col.primaryKey())
+ *     .addColumn('deleted_at', 'timestamp', col => col.defaultTo(null))
+ *     .addColumn('created_at', 'timestamp', col => col.notNull())
+ *     .addColumn('updated_at', 'timestamp', col => col.notNull())
+ *     .execute()
+ * }
+ *
+ * @SoftDelete()
+ * class Post extends ApplicationModel {}
+ * ```
+ *
+ * If you would like to use a different column to hold the
+ * deleted status, you can specify a custom column in your model,
+ * like so:
+ *
+ * @SoftDelete()
+ * class Post extends ApplicationModel {
+ *   public get deletedAtField() {
+ *     return 'customDatetimeField' as const
+ *   }
+ * }
+ */
+function SoftDelete() {
+    return function (target) {
+        const dreamClass = target;
+        if (dreamClass['isSTIChild'])
+            throw new StiChildIncompatibleWithSoftDeleteDecorator_js_1.default(dreamClass);
+        dreamClass['softDelete'] = true;
+        target[exports.SOFT_DELETE_SCOPE_NAME] = function (query) {
+            return query.where({ [dreamClass.prototype.deletedAtField]: null });
+        };
+        (0, Scope_js_1.scopeImplementation)(target, exports.SOFT_DELETE_SCOPE_NAME, { default: true });
+    };
+}

package/dist/cjs/src/decorators/Virtual.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Virtual;
+function Virtual(type) {
+    return function (_, context) {
+        const key = context.name;
+        context.addInitializer(function () {
+            const t = this.constructor;
+            if (!t['globallyInitializingDecorators'])
+                return;
+            if (!Object.getOwnPropertyDescriptor(t, 'virtualAttributes')) {
+                // This pattern allows `virtualAttributes` on a base STI class and on
+                // child STI classes. The new `virtualAttributes` property will be created
+                // on the child STI class, but it will include all the `virtualAttributes`
+                // already declared on the base STI class.
+                t['virtualAttributes'] = [...t['virtualAttributes']];
+            }
+            ;
+            t['virtualAttributes'].push({
+                property: key,
+                type,
+            });
+        });
+        return function () {
+            return this[key];
+        };
+    };
+}

package/dist/cjs/src/decorators/associations/BelongsTo.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = BelongsTo;
+const lookupModelByGlobalNameOrNames_js_1 = require("../../dream-application/helpers/lookupModelByGlobalNameOrNames.js");
+const Validates_js_1 = require("../validations/Validates.js");
+const shared_js_1 = require("./shared.js");
+/**
+ * Establishes a "BelongsTo" association between the base dream
+ * and the child dream, where the base dream has a foreign key
+ * which points back to the child dream.
+ *
+ * ```ts
+ * class UserSettings extends ApplicationModel {
+ *   @Deco.BelongsTo('User')
+ *   public user: User
+ *   public userId: DreamColumn<UserSettings, 'userId'>
+ * }
+ *
+ * class User extends ApplicationModel {
+ *   @Deco.HasOne('UserSettings')
+ *   public userSettings: UserSettings
+ * }
+ * ```
+ *
+ * @param opts.foreignKey - A custom column name to use for the foreign key.
+ * @param opts.optional - Whether or not this association is optional. Defaults to false.
+ * @param opts.polymorphic - If true, this association will be treated as a polymorphic association.
+ * @param opts.primaryKeyOverride - A custom column name to use for the primary key.
+ * @param opts.withoutDefaultScopes - A list of default scopes to bypass when loading this association
+ */
+function BelongsTo(globalAssociationNameOrNames, opts = {}) {
+    const { foreignKey, optional = false, polymorphic = false, primaryKeyOverride = null, withoutDefaultScopes, } = opts;
+    return function (_, context) {
+        const key = context.name;
+        context.addInitializer(function () {
+            const target = this;
+            const dreamClass = target.constructor;
+            if (!dreamClass['globallyInitializingDecorators']) {
+                /**
+                 * Modern Javascript applies implicit accessors to instance properties
+                 * that don't have an accessor explicitly defined in the class definition.
+                 * The instance accessors shadow prototype accessors.
+                 * `addInitializer` is called by Decorators after an instance has been fully
+                 * constructed. We leverage this opportunity to delete the instance accessors
+                 * so that the prototype accessors applied by this decorator can be reached.
+                 */
+                delete this[key];
+                return;
+            }
+            const partialAssociation = (0, shared_js_1.associationPrimaryKeyAccessors)({
+                modelCB: () => (0, lookupModelByGlobalNameOrNames_js_1.default)(globalAssociationNameOrNames),
+                globalAssociationNameOrNames,
+                type: 'BelongsTo',
+                as: key,
+                optional,
+                polymorphic,
+                primaryKeyOverride,
+                withoutDefaultScopes,
+            }, dreamClass);
+            const association = {
+                ...partialAssociation,
+                foreignKey() {
+                    return (0, shared_js_1.finalForeignKey)(foreignKey, dreamClass, partialAssociation);
+                },
+                foreignKeyTypeField() {
+                    return (0, shared_js_1.foreignKeyTypeField)(foreignKey, dreamClass, partialAssociation);
+                },
+            };
+            if (!Object.getOwnPropertyDescriptor(dreamClass, 'associationMetadataByType'))
+                dreamClass['associationMetadataByType'] = (0, shared_js_1.blankAssociationsFactory)(dreamClass);
+            dreamClass['associationMetadataByType']['belongsTo'].push(association);
+            (0, shared_js_1.applyGetterAndSetter)(target, association, { isBelongsTo: true, foreignKeyBase: foreignKey });
+            if (!optional)
+                (0, Validates_js_1.validatesImplementation)(target, key, 'requiredBelongsTo');
+        });
+    };
+}

package/dist/cjs/src/decorators/associations/HasMany.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = HasMany;
+const lookupModelByGlobalNameOrNames_js_1 = require("../../dream-application/helpers/lookupModelByGlobalNameOrNames.js");
+const shared_js_1 = require("./shared.js");
+/**
+ * Establishes a "HasMany" association between the base dream
+ * and the child dream, where the child dream has a foreign key
+ * which points back to the base dream.
+ *
+ * ```ts
+ * class User extends ApplicationModel {
+ *   @Deco.HasMany('Post')
+ *   public posts: Post[]
+ * }
+ *
+ * class Post extends ApplicationModel {
+ *   @Deco.BelongsTo('User')
+ *   public user: User
+ *   public userId: DreamColumn<Post, 'userId'>
+ * }
+ * ```
+ *
+ * @param opts.dependent - Can be either "destroy" or undefined. If "destroy", this record will be cascade deleted if the base model is destroyed.
+ * @param opts.distinct - Can be a column name, or else a boolean. If a column name, a distinct clause will be applied to the column. If true, a distinct clause will be applied to the primary key.
+ * @param opts.foreignKey - A custom column name to use for the foreign key.
+ * @param opts.on - An on clause to be applied when this association is loaded
+ * @param opts.notOn - A not on clause to be applied when this association is loaded
+ * @param opts.onAny - An onAny clause to be applied when this association is loaded
+ * @param opts.order - A custom order statement to apply to this association.
+ * @param opts.polymorphic - If true, this association will be treated as a polymorphic association.
+ * @param opts.preloadThroughColumns - An array of columns to pluck off the through association attached to this association. Can only be set if `through` is also set.
+ * @param opts.primaryKeyOverride - A custom column name to use for the primary key.
+ * @param opts.selfOn - Adds an on clause to an association between a column on the associated model and a column on this model.
+ * @param opts.selfNotOn - Adds a not on clause to an association between a column on the associated model and a column on this model.
+ * @param opts.source - Used in conjunction with 'through' to specify the source association on a child model.
+ * @param opts.through - If passed, this association will travel through another association.
+ * @param opts.withoutDefaultScopes - A list of default scopes to bypass when loading this association
+ */
+function HasMany(globalAssociationNameOrNames, opts = {}) {
+    const { dependent, distinct, foreignKey, on, notOn, onAny, order, polymorphic = false, preloadThroughColumns, primaryKeyOverride = null, selfOn, selfNotOn, source, through, withoutDefaultScopes, } = opts;
+    return function (_, context) {
+        const key = context.name;
+        context.addInitializer(function () {
+            const target = this;
+            const dreamClass = target.constructor;
+            if (!dreamClass['globallyInitializingDecorators']) {
+                /**
+                 * Modern Javascript applies implicit accessors to instance properties
+                 * that don't have an accessor explicitly defined in the class definition.
+                 * The instance accessors shadow prototype accessors.
+                 * `addInitializer` is called by Decorators after an instance has been fully
+                 * constructed. We leverage this opportunity to delete the instance accessors
+                 * so that the prototype accessors applied by this decorator can be reached.
+                 */
+                delete this[key];
+                return;
+            }
+            (0, shared_js_1.validateHasStatementArgs)({
+                dreamClass,
+                dependent: dependent ?? null,
+                methodName: key,
+                on: on ?? null,
+            });
+            const partialAssociation = (0, shared_js_1.associationPrimaryKeyAccessors)({
+                modelCB: () => (0, lookupModelByGlobalNameOrNames_js_1.default)(globalAssociationNameOrNames),
+                as: key,
+                dependent,
+                globalAssociationNameOrNames,
+                on,
+                notOn,
+                onAny,
+                polymorphic,
+                preloadThroughColumns,
+                primaryKeyOverride,
+                selfOn,
+                selfNotOn,
+                source: source || key,
+                type: 'HasMany',
+                withoutDefaultScopes,
+            }, dreamClass);
+            const association = {
+                ...partialAssociation,
+                through,
+                distinct,
+                order,
+                foreignKey() {
+                    return (0, shared_js_1.finalForeignKey)(foreignKey, dreamClass, partialAssociation);
+                },
+                foreignKeyTypeField() {
+                    return (0, shared_js_1.foreignKeyTypeField)(foreignKey, dreamClass, partialAssociation);
+                },
+            };
+            if (!Object.getOwnPropertyDescriptor(dreamClass, 'associationMetadataByType'))
+                dreamClass['associationMetadataByType'] = (0, shared_js_1.blankAssociationsFactory)(dreamClass);
+            dreamClass['associationMetadataByType']['hasMany'].push(association);
+            (0, shared_js_1.applyGetterAndSetter)(target, association);
+        });
+    };
+}

package/dist/cjs/src/decorators/associations/HasOne.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = HasOne;
+const lookupModelByGlobalNameOrNames_js_1 = require("../../dream-application/helpers/lookupModelByGlobalNameOrNames.js");
+const shared_js_1 = require("./shared.js");
+/**
+ * Establishes a "HasOne" association between the base dream
+ * and the child dream, where the child dream has a foreign key
+ * which points back to the base dream.
+ *
+ * ```ts
+ * class User extends ApplicationModel {
+ *   @Deco.HasOne('UserSettings')
+ *   public userSettings: UserSettings
+ * }
+ *
+ * class UserSettings extends ApplicationModel {
+ *   @Deco.BelongsTo('User')
+ *   public user: User
+ *   public userId: DreamColumn<UserSettings, 'userId'>
+ * }
+ * ```
+ *
+ * @param opts.dependent - Can be either "destroy" or undefined. If "destroy", this record will be cascade deleted if the base model is destroyed.
+ * @param opts.foreignKey - A custom column name to use for the foreign key.
+ * @param opts.on - An on clause to be applied when this association is loaded
+ * @param opts.notOn - A not on clause to be applied when this association is loaded
+ * @param opts.onAny - An onAny clause to be applied when this association is loaded
+ * @param opts.polymorphic - If true, this association will be treated as a polymorphic association.
+ * @param opts.preloadThroughColumns - An array of columns to pluck off the through association attached to this association. Can only be set if `through` is also set.
+ * @param opts.primaryKeyOverride - A custom column name to use for the primary key.
+ * @param opts.selfOn - Adds an on clause to an association between a column on the associated model and a column on this model.
+ * @param opts.selfNotOn - Adds a not on clause to an association between a column on the associated model and a column on this model.
+ * @param opts.source - Used in conjunction with 'through' to specify the source association on a child model.
+ * @param opts.through - If passed, this association will travel through another association.
+ * @param opts.withoutDefaultScopes - A list of default scopes to bypass when loading this association
+ */
+function HasOne(globalAssociationNameOrNames, opts = {}) {
+    const { dependent, foreignKey, on, notOn, onAny, polymorphic = false, preloadThroughColumns, primaryKeyOverride = null, selfOn, selfNotOn, source, through, withoutDefaultScopes, } = opts;
+    return function (_, context) {
+        const key = context.name;
+        context.addInitializer(function () {
+            const target = this;
+            const dreamClass = target.constructor;
+            if (!dreamClass['globallyInitializingDecorators']) {
+                /**
+                 * Modern Javascript applies implicit accessors to instance properties
+                 * that don't have an accessor explicitly defined in the class definition.
+                 * The instance accessors shadow prototype accessors.
+                 * `addInitializer` is called by Decorators after an instance has been fully
+                 * constructed. We leverage this opportunity to delete the instance accessors
+                 * so that the prototype accessors applied by this decorator can be reached.
+                 */
+                delete this[key];
+                return;
+            }
+            (0, shared_js_1.validateHasStatementArgs)({
+                dreamClass,
+                dependent: dependent ?? null,
+                methodName: key,
+                on: on ?? null,
+            });
+            const partialAssociation = (0, shared_js_1.associationPrimaryKeyAccessors)({
+                modelCB: () => (0, lookupModelByGlobalNameOrNames_js_1.default)(globalAssociationNameOrNames),
+                as: key,
+                dependent,
+                globalAssociationNameOrNames,
+                on,
+                notOn,
+                onAny,
+                polymorphic,
+                preloadThroughColumns,
+                primaryKeyOverride,
+                selfOn,
+                selfNotOn,
+                source: source || key,
+                through,
+                type: 'HasOne',
+                withoutDefaultScopes,
+            }, dreamClass);
+            const association = {
+                ...partialAssociation,
+                foreignKey() {
+                    return (0, shared_js_1.finalForeignKey)(foreignKey, dreamClass, partialAssociation);
+                },
+                foreignKeyTypeField() {
+                    return (0, shared_js_1.foreignKeyTypeField)(foreignKey, dreamClass, partialAssociation);
+                },
+            };
+            if (!Object.getOwnPropertyDescriptor(dreamClass, 'associationMetadataByType'))
+                dreamClass['associationMetadataByType'] = (0, shared_js_1.blankAssociationsFactory)(dreamClass);
+            dreamClass['associationMetadataByType']['hasOne'].push(association);
+            (0, shared_js_1.applyGetterAndSetter)(target, association);
+        });
+    };
+}

package/dist/cjs/src/decorators/associations/associationToGetterSetterProp.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = associationToGetterSetterProp;
+function associationToGetterSetterProp(association) {
+    return `__${association.as}__`;
+}

package/dist/cjs/src/decorators/associations/shared.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blankAssociationsFactory = blankAssociationsFactory;
+exports.finalForeignKey = finalForeignKey;
+exports.foreignKeyTypeField = foreignKeyTypeField;
+exports.modelCBtoSingleDreamClass = modelCBtoSingleDreamClass;
+exports.applyGetterAndSetter = applyGetterAndSetter;
+exports.associationPrimaryKeyAccessors = associationPrimaryKeyAccessors;
+exports.validateHasStatementArgs = validateHasStatementArgs;
+const pluralize_esm_1 = require("pluralize-esm");
+const types_js_1 = require("../../dream/types.js");
+const InvalidComputedForeignKey_js_1 = require("../../errors/associations/InvalidComputedForeignKey.js");
+const NonLoadedAssociation_js_1 = require("../../errors/associations/NonLoadedAssociation.js");
+const CannotDefineAssociationWithBothDependentAndPassthrough_js_1 = require("../../errors/CannotDefineAssociationWithBothDependentAndPassthrough.js");
+const CannotDefineAssociationWithBothDependentAndRequiredOnClause_js_1 = require("../../errors/CannotDefineAssociationWithBothDependentAndRequiredOnClause.js");
+const camelize_js_1 = require("../../helpers/camelize.js");
+const freezeBaseClassArrayMap_js_1 = require("../helpers/freezeBaseClassArrayMap.js");
+const associationToGetterSetterProp_js_1 = require("./associationToGetterSetterProp.js");
+function blankAssociationsFactory(dreamClass, { freeze = false, } = {}) {
+    // This pattern allows associations to be defined on a base STI class and on
+    // child STI classes. The new `associationsMap` property will be created
+    // on the child STI class, but it will include all the associations already
+    // declared on the base STI class.
+    const associationsMap = {
+        belongsTo: [...(dreamClass['associationMetadataByType']?.belongsTo || [])],
+        hasMany: [...(dreamClass['associationMetadataByType']?.hasMany || [])],
+        hasOne: [...(dreamClass['associationMetadataByType']?.hasOne || [])],
+    };
+    if (freeze)
+        return (0, freezeBaseClassArrayMap_js_1.default)(associationsMap);
+    return associationsMap;
+}
+function finalForeignKey(foreignKey, dreamClass, partialAssociation) {
+    let computedForeignKey = foreignKey;
+    if (!computedForeignKey) {
+        const table = partialAssociation.type === 'BelongsTo'
+            ? modelCBtoSingleDreamClass(dreamClass, partialAssociation).table
+            : dreamClass.table;
+        computedForeignKey = (0, camelize_js_1.default)(pluralize_esm_1.default.singular(table)) + 'Id';
+    }
+    if (partialAssociation.type === 'BelongsTo' || !partialAssociation.through)
+        (0, InvalidComputedForeignKey_js_1.checkForeignKey)(foreignKey, computedForeignKey, dreamClass, partialAssociation);
+    return computedForeignKey;
+}
+function foreignKeyTypeField(foreignKey, dream, partialAssociation) {
+    return finalForeignKey(foreignKey, dream, partialAssociation).replace(/Id$/, 'Type');
+}
+function modelCBtoSingleDreamClass(dreamClass, partialAssociation) {
+    if (Array.isArray(partialAssociation.modelCB()))
+        throw new Error(`Polymorphic association ${partialAssociation.as} on model ${dreamClass.name} requires an explicit foreignKey`);
+    return partialAssociation.modelCB();
+}
+function applyGetterAndSetter(target, partialAssociation, { foreignKeyBase, isBelongsTo, } = {}) {
+    const dreamPrototype = Object.getPrototypeOf(target);
+    const dreamClass = target.constructor;
+    Object.defineProperty(dreamPrototype, partialAssociation.as, {
+        configurable: true,
+        get: function () {
+            const value = this[(0, associationToGetterSetterProp_js_1.default)(partialAssociation)];
+            if (value === undefined)
+                throw new NonLoadedAssociation_js_1.default({ dreamClass, associationName: partialAssociation.as });
+            else
+                return value;
+        },
+        set: function (associatedModel) {
+            /**
+             *
+             * Modern Javascript sets all properties that do not have an explicit
+             * assignment within the constructor to undefined in an implicit constructor.
+             * Since the Dream constructor sets the value of properties of instances of
+             * classes that extend Dream (e.g. when passing attributes to #new or #create
+             * or when loading a model via one of the #find methods or #all), we need to
+             * prevent those properties from being set back to undefined. Since all
+             * properties corresponding to a database column get a setter, we achieve this
+             * protection by including a guard in the setters that returns if this
+             * property is set.
+             *
+             */
+            if (this['columnSetterGuardActivated'])
+                return;
+            this[(0, associationToGetterSetterProp_js_1.default)(partialAssociation)] = associatedModel;
+            if (isBelongsTo) {
+                ;
+                this[finalForeignKey(foreignKeyBase, dreamClass, partialAssociation)] =
+                    partialAssociation.primaryKeyValue(associatedModel);
+                if (partialAssociation.polymorphic)
+                    this[foreignKeyTypeField(foreignKeyBase, dreamClass, partialAssociation)] =
+                        associatedModel?.constructor?.name;
+            }
+        },
+    });
+}
+function associationPrimaryKeyAccessors(partialAssociation, dreamClass) {
+    return {
+        ...partialAssociation,
+        primaryKey(associationInstance) {
+            if (this.primaryKeyOverride)
+                return this.primaryKeyOverride;
+            if (associationInstance)
+                return associationInstance.primaryKey;
+            const associationClass = this.modelCB();
+            if (Array.isArray(associationClass)) {
+                throw new Error(`
+Cannot lookup primaryKey on polymorphic association:
+dream class: ${dreamClass.name}
+association: ${this.as}
+          `);
+            }
+            return associationClass.primaryKey;
+        },
+        primaryKeyValue(associationInstance) {
+            if (associationInstance === undefined)
+                return undefined;
+            if (associationInstance === null)
+                return null;
+            return associationInstance[this.primaryKey(associationInstance)];
+        },
+    };
+}
+function validateHasStatementArgs({ dreamClass, dependent, methodName, on, }) {
+    const hasPassthroughOn = Object.values(on || {}).find(val => val === types_js_1.DreamConst.passthrough);
+    const hasRequiredOn = Object.values(on || {}).find(val => val === types_js_1.DreamConst.required);
+    if (dependent && hasPassthroughOn)
+        throw new CannotDefineAssociationWithBothDependentAndPassthrough_js_1.default(dreamClass, methodName);
+    if (dependent && hasRequiredOn)
+        throw new CannotDefineAssociationWithBothDependentAndRequiredOnClause_js_1.default(dreamClass, methodName);
+}
+// function hydratedSourceValue(dream: Dream | typeof Dream | undefined, sourceName: string) {
+//   if (!dream) return
+//   if (!sourceName) return
+//   return (dream as any)[sourceName] || (dream as any)[singular(sourceName)]
+// }

package/dist/cjs/src/decorators/helpers/freezeBaseClassArrayMap.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = freezeBaseClassArrayMap;
+function freezeBaseClassArrayMap(map) {
+    return Object.freeze(Object.keys(map).reduce((frozenMap, key) => {
+        ;
+        frozenMap[key] = Object.freeze(map[key]);
+        return frozenMap;
+    }, {}));
+}

package/dist/cjs/src/decorators/hooks/AfterCreate.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = AfterCreate;
+exports.afterCreateImplementation = afterCreateImplementation;
+const shared_js_1 = require("./shared.js");
+function AfterCreate(opts = {}) {
+    return function (_, context) {
+        context.addInitializer(function () {
+            afterCreateImplementation(this, context.name, opts);
+        });
+    };
+}
+function afterCreateImplementation(target, key, opts = {}) {
+    const dreamClass = target.constructor;
+    if (!dreamClass['globallyInitializingDecorators'])
+        return;
+    if (!Object.getOwnPropertyDescriptor(dreamClass, 'hooks'))
+        dreamClass['hooks'] = (0, shared_js_1.blankHooksFactory)(dreamClass);
+    const hookStatement = {
+        className: dreamClass.name,
+        method: key,
+        type: 'afterCreate',
+        ifChanged: opts.ifChanged,
+    };
+    dreamClass['addHook']('afterCreate', hookStatement);
+}

package/dist/cjs/src/decorators/hooks/AfterCreateCommit.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = AfterCreateCommit;
+exports.afterCreateCommitImplementation = afterCreateCommitImplementation;
+const shared_js_1 = require("./shared.js");
+/**
+ * Calls the decorated method whenever a dream has finished
+ * being created. If the save takes place within a transaction,
+ * this method will not be called until the transaction is
+ * committed. However, if the save is not taking place in
+ * a transaction, the method will be run after the save
+ * is complete.
+ *
+ * class User extends ApplicationModel {
+ *   @Deco.AfterCreateCommit()
+ *   public doSomething() {
+ *     ...
+ *   }
+ * }
+ *
+ * @param opts.ifChanged - Optional. A list of columns which should must change in order for this function to be called.
+ */
+function AfterCreateCommit(opts = {}) {
+    return function (_, context) {
+        context.addInitializer(function () {
+            afterCreateCommitImplementation(this, context.name, opts);
+        });
+    };
+}
+function afterCreateCommitImplementation(target, key, opts = {}) {
+    const dreamClass = target.constructor;
+    if (!dreamClass['globallyInitializingDecorators'])
+        return;
+    if (!Object.getOwnPropertyDescriptor(dreamClass, 'hooks'))
+        dreamClass['hooks'] = (0, shared_js_1.blankHooksFactory)(dreamClass);
+    const hookStatement = {
+        className: dreamClass.name,
+        method: key,
+        type: 'afterCreateCommit',
+        ifChanged: opts.ifChanged,
+    };
+    dreamClass['addHook']('afterCreateCommit', hookStatement);
+}