@rvoh/dream 0.29.1

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

@@ -0,0 +1,31 @@
+import StiChildCannotDefineNewAssociations from '../errors/sti/StiChildCannotDefineNewAssociations.js';
+import StiChildIncompatibleWithReplicaSafeDecorator from '../errors/sti/StiChildIncompatibleWithReplicaSafeDecorator.js';
+import StiChildIncompatibleWithSoftDeleteDecorator from '../errors/sti/StiChildIncompatibleWithSoftDeleteDecorator.js';
+import { scopeImplementation } from './Scope.js';
+export const STI_SCOPE_NAME = 'dream:STI';
+export default function STI(dreamClass, { value } = {}) {
+    return function (target) {
+        const stiChildClass = target;
+        const baseClass = dreamClass['sti'].baseClass || dreamClass;
+        if (Object.getOwnPropertyDescriptor(stiChildClass, 'associationMetadataByType'))
+            throw new StiChildCannotDefineNewAssociations(baseClass, stiChildClass);
+        if (Object.getOwnPropertyDescriptor(stiChildClass, 'replicaSafe'))
+            throw new StiChildIncompatibleWithReplicaSafeDecorator(stiChildClass);
+        if (Object.getOwnPropertyDescriptor(stiChildClass, 'softDelete'))
+            throw new StiChildIncompatibleWithSoftDeleteDecorator(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[STI_SCOPE_NAME] = function (query) {
+            return query.where({ type: stiChildClass['sti'].value });
+        };
+        scopeImplementation(stiChildClass, STI_SCOPE_NAME, { default: true });
+    };
+}

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

@@ -0,0 +1,27 @@
+export default 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);
+        });
+    };
+}
+export 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/esm/src/decorators/SoftDelete.js

@@ -0,0 +1,50 @@
+import StiChildIncompatibleWithSoftDeleteDecorator from '../errors/sti/StiChildIncompatibleWithSoftDeleteDecorator.js';
+import { scopeImplementation } from './Scope.js';
+export const 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
+ *   }
+ * }
+ */
+export default function SoftDelete() {
+    return function (target) {
+        const dreamClass = target;
+        if (dreamClass['isSTIChild'])
+            throw new StiChildIncompatibleWithSoftDeleteDecorator(dreamClass);
+        dreamClass['softDelete'] = true;
+        target[SOFT_DELETE_SCOPE_NAME] = function (query) {
+            return query.where({ [dreamClass.prototype.deletedAtField]: null });
+        };
+        scopeImplementation(target, SOFT_DELETE_SCOPE_NAME, { default: true });
+    };
+}

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

@@ -0,0 +1,25 @@
+export default 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/esm/src/decorators/associations/BelongsTo.js

@@ -0,0 +1,74 @@
+import lookupModelByGlobalNameOrNames from '../../dream-application/helpers/lookupModelByGlobalNameOrNames.js';
+import { validatesImplementation } from '../validations/Validates.js';
+import { applyGetterAndSetter, associationPrimaryKeyAccessors, blankAssociationsFactory, finalForeignKey, foreignKeyTypeField, } from './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
+ */
+export default 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 = associationPrimaryKeyAccessors({
+                modelCB: () => lookupModelByGlobalNameOrNames(globalAssociationNameOrNames),
+                globalAssociationNameOrNames,
+                type: 'BelongsTo',
+                as: key,
+                optional,
+                polymorphic,
+                primaryKeyOverride,
+                withoutDefaultScopes,
+            }, dreamClass);
+            const association = {
+                ...partialAssociation,
+                foreignKey() {
+                    return finalForeignKey(foreignKey, dreamClass, partialAssociation);
+                },
+                foreignKeyTypeField() {
+                    return foreignKeyTypeField(foreignKey, dreamClass, partialAssociation);
+                },
+            };
+            if (!Object.getOwnPropertyDescriptor(dreamClass, 'associationMetadataByType'))
+                dreamClass['associationMetadataByType'] = blankAssociationsFactory(dreamClass);
+            dreamClass['associationMetadataByType']['belongsTo'].push(association);
+            applyGetterAndSetter(target, association, { isBelongsTo: true, foreignKeyBase: foreignKey });
+            if (!optional)
+                validatesImplementation(target, key, 'requiredBelongsTo');
+        });
+    };
+}

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

@@ -0,0 +1,97 @@
+import lookupModelByGlobalNameOrNames from '../../dream-application/helpers/lookupModelByGlobalNameOrNames.js';
+import { applyGetterAndSetter, associationPrimaryKeyAccessors, blankAssociationsFactory, finalForeignKey, foreignKeyTypeField, validateHasStatementArgs, } from './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
+ */
+export default 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;
+            }
+            validateHasStatementArgs({
+                dreamClass,
+                dependent: dependent ?? null,
+                methodName: key,
+                on: on ?? null,
+            });
+            const partialAssociation = associationPrimaryKeyAccessors({
+                modelCB: () => lookupModelByGlobalNameOrNames(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 finalForeignKey(foreignKey, dreamClass, partialAssociation);
+                },
+                foreignKeyTypeField() {
+                    return foreignKeyTypeField(foreignKey, dreamClass, partialAssociation);
+                },
+            };
+            if (!Object.getOwnPropertyDescriptor(dreamClass, 'associationMetadataByType'))
+                dreamClass['associationMetadataByType'] = blankAssociationsFactory(dreamClass);
+            dreamClass['associationMetadataByType']['hasMany'].push(association);
+            applyGetterAndSetter(target, association);
+        });
+    };
+}

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

@@ -0,0 +1,93 @@
+import lookupModelByGlobalNameOrNames from '../../dream-application/helpers/lookupModelByGlobalNameOrNames.js';
+import { applyGetterAndSetter, associationPrimaryKeyAccessors, blankAssociationsFactory, finalForeignKey, foreignKeyTypeField, validateHasStatementArgs, } from './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
+ */
+export default 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;
+            }
+            validateHasStatementArgs({
+                dreamClass,
+                dependent: dependent ?? null,
+                methodName: key,
+                on: on ?? null,
+            });
+            const partialAssociation = associationPrimaryKeyAccessors({
+                modelCB: () => lookupModelByGlobalNameOrNames(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 finalForeignKey(foreignKey, dreamClass, partialAssociation);
+                },
+                foreignKeyTypeField() {
+                    return foreignKeyTypeField(foreignKey, dreamClass, partialAssociation);
+                },
+            };
+            if (!Object.getOwnPropertyDescriptor(dreamClass, 'associationMetadataByType'))
+                dreamClass['associationMetadataByType'] = blankAssociationsFactory(dreamClass);
+            dreamClass['associationMetadataByType']['hasOne'].push(association);
+            applyGetterAndSetter(target, association);
+        });
+    };
+}

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

@@ -0,0 +1,3 @@
+export default function associationToGetterSetterProp(association) {
+    return `__${association.as}__`;
+}

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

@@ -0,0 +1,123 @@
+import pluralize from 'pluralize-esm';
+import { DreamConst, } from '../../dream/types.js';
+import { checkForeignKey } from '../../errors/associations/InvalidComputedForeignKey.js';
+import NonLoadedAssociation from '../../errors/associations/NonLoadedAssociation.js';
+import CannotDefineAssociationWithBothDependentAndPassthrough from '../../errors/CannotDefineAssociationWithBothDependentAndPassthrough.js';
+import CannotDefineAssociationWithBothDependentAndRequiredOnClause from '../../errors/CannotDefineAssociationWithBothDependentAndRequiredOnClause.js';
+import camelize from '../../helpers/camelize.js';
+import freezeBaseClassArrayMap from '../helpers/freezeBaseClassArrayMap.js';
+import associationToGetterSetterProp from './associationToGetterSetterProp.js';
+export 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 freezeBaseClassArrayMap(associationsMap);
+    return associationsMap;
+}
+export function finalForeignKey(foreignKey, dreamClass, partialAssociation) {
+    let computedForeignKey = foreignKey;
+    if (!computedForeignKey) {
+        const table = partialAssociation.type === 'BelongsTo'
+            ? modelCBtoSingleDreamClass(dreamClass, partialAssociation).table
+            : dreamClass.table;
+        computedForeignKey = camelize(pluralize.singular(table)) + 'Id';
+    }
+    if (partialAssociation.type === 'BelongsTo' || !partialAssociation.through)
+        checkForeignKey(foreignKey, computedForeignKey, dreamClass, partialAssociation);
+    return computedForeignKey;
+}
+export function foreignKeyTypeField(foreignKey, dream, partialAssociation) {
+    return finalForeignKey(foreignKey, dream, partialAssociation).replace(/Id$/, 'Type');
+}
+export 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();
+}
+export 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[associationToGetterSetterProp(partialAssociation)];
+            if (value === undefined)
+                throw new NonLoadedAssociation({ 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[associationToGetterSetterProp(partialAssociation)] = associatedModel;
+            if (isBelongsTo) {
+                ;
+                this[finalForeignKey(foreignKeyBase, dreamClass, partialAssociation)] =
+                    partialAssociation.primaryKeyValue(associatedModel);
+                if (partialAssociation.polymorphic)
+                    this[foreignKeyTypeField(foreignKeyBase, dreamClass, partialAssociation)] =
+                        associatedModel?.constructor?.name;
+            }
+        },
+    });
+}
+export 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)];
+        },
+    };
+}
+export function validateHasStatementArgs({ dreamClass, dependent, methodName, on, }) {
+    const hasPassthroughOn = Object.values(on || {}).find(val => val === DreamConst.passthrough);
+    const hasRequiredOn = Object.values(on || {}).find(val => val === DreamConst.required);
+    if (dependent && hasPassthroughOn)
+        throw new CannotDefineAssociationWithBothDependentAndPassthrough(dreamClass, methodName);
+    if (dependent && hasRequiredOn)
+        throw new CannotDefineAssociationWithBothDependentAndRequiredOnClause(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/esm/src/decorators/helpers/freezeBaseClassArrayMap.js

@@ -0,0 +1,7 @@
+export default function freezeBaseClassArrayMap(map) {
+    return Object.freeze(Object.keys(map).reduce((frozenMap, key) => {
+        ;
+        frozenMap[key] = Object.freeze(map[key]);
+        return frozenMap;
+    }, {}));
+}

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

@@ -0,0 +1,22 @@
+import { blankHooksFactory } from './shared.js';
+export default function AfterCreate(opts = {}) {
+    return function (_, context) {
+        context.addInitializer(function () {
+            afterCreateImplementation(this, context.name, opts);
+        });
+    };
+}
+export function afterCreateImplementation(target, key, opts = {}) {
+    const dreamClass = target.constructor;
+    if (!dreamClass['globallyInitializingDecorators'])
+        return;
+    if (!Object.getOwnPropertyDescriptor(dreamClass, 'hooks'))
+        dreamClass['hooks'] = blankHooksFactory(dreamClass);
+    const hookStatement = {
+        className: dreamClass.name,
+        method: key,
+        type: 'afterCreate',
+        ifChanged: opts.ifChanged,
+    };
+    dreamClass['addHook']('afterCreate', hookStatement);
+}

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

@@ -0,0 +1,39 @@
+import { blankHooksFactory } from './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.
+ */
+export default function AfterCreateCommit(opts = {}) {
+    return function (_, context) {
+        context.addInitializer(function () {
+            afterCreateCommitImplementation(this, context.name, opts);
+        });
+    };
+}
+export function afterCreateCommitImplementation(target, key, opts = {}) {
+    const dreamClass = target.constructor;
+    if (!dreamClass['globallyInitializingDecorators'])
+        return;
+    if (!Object.getOwnPropertyDescriptor(dreamClass, 'hooks'))
+        dreamClass['hooks'] = blankHooksFactory(dreamClass);
+    const hookStatement = {
+        className: dreamClass.name,
+        method: key,
+        type: 'afterCreateCommit',
+        ifChanged: opts.ifChanged,
+    };
+    dreamClass['addHook']('afterCreateCommit', hookStatement);
+}

package/dist/esm/src/decorators/hooks/AfterDestroy.js

@@ -0,0 +1,21 @@
+import { blankHooksFactory } from './shared.js';
+export default function AfterDestroy() {
+    return function (_, context) {
+        context.addInitializer(function () {
+            afterDestroyImplementation(this, context.name);
+        });
+    };
+}
+export function afterDestroyImplementation(target, key) {
+    const dreamClass = target.constructor;
+    if (!dreamClass['globallyInitializingDecorators'])
+        return;
+    if (!Object.getOwnPropertyDescriptor(dreamClass, 'hooks'))
+        dreamClass['hooks'] = blankHooksFactory(dreamClass);
+    const hookStatement = {
+        className: dreamClass.name,
+        method: key,
+        type: 'afterDestroy',
+    };
+    dreamClass['addHook']('afterDestroy', hookStatement);
+}

package/dist/esm/src/decorators/hooks/AfterDestroyCommit.js

@@ -0,0 +1,36 @@
+import { blankHooksFactory } from './shared.js';
+/**
+ * Calls the decorated method whenever a dream has finished
+ * being destroyed. If the destroy takes place within a transaction,
+ * this method will not be called until the transaction is
+ * committed. However, if the destroy is not taking place in
+ * a transaction, the method will be run after the save
+ * is complete.
+ *
+ * class User extends ApplicationModel {
+ *   @Deco.AfterDestroyCommit()
+ *   public doSomething() {
+ *     ...
+ *   }
+ * }
+ */
+export default function AfterDestroyCommit() {
+    return function (_, context) {
+        context.addInitializer(function () {
+            afterDestroyCommitImplementation(this, context.name);
+        });
+    };
+}
+export function afterDestroyCommitImplementation(target, key) {
+    const dreamClass = target.constructor;
+    if (!dreamClass['globallyInitializingDecorators'])
+        return;
+    if (!Object.getOwnPropertyDescriptor(dreamClass, 'hooks'))
+        dreamClass['hooks'] = blankHooksFactory(dreamClass);
+    const hookStatement = {
+        className: dreamClass.name,
+        method: key,
+        type: 'afterDestroyCommit',
+    };
+    dreamClass['addHook']('afterDestroyCommit', hookStatement);
+}