@rvoh/dream 0.29.1

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

@@ -0,0 +1,22 @@
+import { blankHooksFactory } from './shared.js';
+export default function AfterSave(opts = {}) {
+    return function (_, context) {
+        context.addInitializer(function () {
+            afterSaveImplementation(this, context.name, opts);
+        });
+    };
+}
+export function afterSaveImplementation(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: 'afterSave',
+        ifChanged: opts.ifChanged,
+    };
+    dreamClass['addHook']('afterSave', hookStatement);
+}

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

@@ -0,0 +1,39 @@
+import { blankHooksFactory } from './shared.js';
+/**
+ * Calls the decorated method whenever a dream has finished
+ * being saved. 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.AfterSaveCommit()
+ *   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 AfterSaveCommit(opts = {}) {
+    return function (_, context) {
+        context.addInitializer(function () {
+            afterSaveCommitImplementation(this, context.name, opts);
+        });
+    };
+}
+export function afterSaveCommitImplementation(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: 'afterSaveCommit',
+        ifChanged: opts.ifChanged,
+    };
+    dreamClass['addHook']('afterSaveCommit', hookStatement);
+}

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

@@ -0,0 +1,22 @@
+import { blankHooksFactory } from './shared.js';
+export default function AfterUpdate(opts = {}) {
+    return function (_, context) {
+        context.addInitializer(function () {
+            afterUpdateImplementation(this, context.name, opts);
+        });
+    };
+}
+export function afterUpdateImplementation(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: 'afterUpdate',
+        ifChanged: opts.ifChanged,
+    };
+    dreamClass['addHook']('afterUpdate', hookStatement);
+}

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

@@ -0,0 +1,39 @@
+import { blankHooksFactory } from './shared.js';
+/**
+ * Calls the decorated method whenever a dream has finished
+ * being updated. 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.AfterUpdateCommit()
+ *   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 AfterUpdateCommit(opts = {}) {
+    return function (_, context) {
+        context.addInitializer(function () {
+            afterUpdateCommitImplementation(this, context.name, opts);
+        });
+    };
+}
+export function afterUpdateCommitImplementation(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: 'afterUpdateCommit',
+        ifChanged: opts.ifChanged,
+    };
+    dreamClass['addHook']('afterUpdateCommit', hookStatement);
+}

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

@@ -0,0 +1,22 @@
+import { blankHooksFactory } from './shared.js';
+export default function BeforeCreate(opts = {}) {
+    return function (_, context) {
+        context.addInitializer(function () {
+            beforeCreateImplementation(this, context.name, opts);
+        });
+    };
+}
+export function beforeCreateImplementation(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: 'beforeCreate',
+        ifChanging: opts.ifChanging,
+    };
+    dreamClass['addHook']('beforeCreate', hookStatement);
+}

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

@@ -0,0 +1,21 @@
+import { blankHooksFactory } from './shared.js';
+export default function BeforeDestroy() {
+    return function (_, context) {
+        context.addInitializer(function () {
+            beforeDestroyImplementation(this, context.name);
+        });
+    };
+}
+export function beforeDestroyImplementation(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: 'beforeDestroy',
+    };
+    dreamClass['addHook']('beforeDestroy', hookStatement);
+}

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

@@ -0,0 +1,22 @@
+import { blankHooksFactory } from './shared.js';
+export default function BeforeSave(opts = {}) {
+    return function (_, context) {
+        context.addInitializer(function () {
+            beforeSaveImplementation(this, context.name, opts);
+        });
+    };
+}
+export function beforeSaveImplementation(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: 'beforeSave',
+        ifChanging: opts.ifChanging,
+    };
+    dreamClass['addHook']('beforeSave', hookStatement);
+}

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

@@ -0,0 +1,22 @@
+import { blankHooksFactory } from './shared.js';
+export default function BeforeUpdate(opts = {}) {
+    return function (_, context) {
+        context.addInitializer(function () {
+            beforeUpdateImplementation(this, context.name, opts);
+        });
+    };
+}
+export function beforeUpdateImplementation(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: 'beforeUpdate',
+        ifChanging: opts.ifChanging,
+    };
+    dreamClass['addHook']('beforeUpdate', hookStatement);
+}

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

@@ -0,0 +1,20 @@
+import freezeBaseClassArrayMap from '../helpers/freezeBaseClassArrayMap.js';
+export function blankHooksFactory(dreamClass, { freeze = false, } = {}) {
+    const hooksMap = {
+        beforeCreate: [...(dreamClass['hooks']?.beforeCreate || [])],
+        beforeUpdate: [...(dreamClass['hooks']?.beforeUpdate || [])],
+        beforeSave: [...(dreamClass['hooks']?.beforeSave || [])],
+        beforeDestroy: [...(dreamClass['hooks']?.beforeDestroy || [])],
+        afterCreate: [...(dreamClass['hooks']?.afterCreate || [])],
+        afterCreateCommit: [...(dreamClass['hooks']?.afterCreateCommit || [])],
+        afterUpdate: [...(dreamClass['hooks']?.afterUpdate || [])],
+        afterUpdateCommit: [...(dreamClass['hooks']?.afterUpdateCommit || [])],
+        afterSave: [...(dreamClass['hooks']?.afterSave || [])],
+        afterSaveCommit: [...(dreamClass['hooks']?.afterSaveCommit || [])],
+        afterDestroy: [...(dreamClass['hooks']?.afterDestroy || [])],
+        afterDestroyCommit: [...(dreamClass['hooks']?.afterDestroyCommit || [])],
+    };
+    if (freeze)
+        return freezeBaseClassArrayMap(hooksMap);
+    return hooksMap;
+}

package/dist/esm/src/decorators/sortable/Sortable.js

@@ -0,0 +1,157 @@
+import pascalize from '../../helpers/pascalize.js';
+import { afterCreateImplementation } from '../hooks/AfterCreate.js';
+import { afterCreateCommitImplementation } from '../hooks/AfterCreateCommit.js';
+import { afterDestroyImplementation } from '../hooks/AfterDestroy.js';
+import { afterDestroyCommitImplementation } from '../hooks/AfterDestroyCommit.js';
+import { afterUpdateImplementation } from '../hooks/AfterUpdate.js';
+import { afterUpdateCommitImplementation } from '../hooks/AfterUpdateCommit.js';
+import { beforeSaveImplementation } from '../hooks/BeforeSave.js';
+import scopeArray from './helpers/scopeArray.js';
+import afterSortableCreate from './hooks/afterSortableCreate.js';
+import afterSortableDestroy from './hooks/afterSortableDestroy.js';
+import afterUpdateSortable from './hooks/afterSortableUpdate.js';
+import beforeSortableSave from './hooks/beforeSortableSave.js';
+export default function Sortable(opts = {}) {
+    return function (_, context) {
+        const key = context.name;
+        context.addInitializer(function () {
+            const dream = this;
+            const dreamClass = dream.constructor;
+            if (!dreamClass['globallyInitializingDecorators'])
+                return;
+            if (dreamClass['sti']['active']) {
+                if (!(dreamClass instanceof dreamClass['stiBaseClassOrOwnClass'])) {
+                    // what we should really be doing is throwing CannotCallSortableOnSTIChild,
+                    // but we cannot, since there is no way to know during this initializer if
+                    // the Sortable decorator was applied to the STI child, or the STI parent.
+                    //
+                    // because of this bizarre issue, we are forced to early return when
+                    // we are processing Sortable on an STI child.
+                    // throw new CannotCallSortableOnSTIChild(dreamClass)
+                    return;
+                }
+            }
+            if (!Object.getOwnPropertyDescriptor(dreamClass, 'sortableFields')) {
+                // This pattern allows `sortableFields` on a base STI class and on
+                // child STI classes. The new `sortableFields` property will be created
+                // on the child STI class, but it will include all the `sortableFields`
+                // already declared on the base STI class.
+                dreamClass['sortableFields'] = [...dreamClass['sortableFields']];
+            }
+            ;
+            dreamClass['sortableFields'].push({
+                scope: scopeArray(opts.scope),
+                positionField: key,
+            });
+            const positionField = key;
+            const beforeSaveMethodName = `_cacheValueFor${pascalize(key)}`;
+            const afterCreateMethodName = `_setNewValueFor${pascalize(key)}AfterCreate`;
+            const afterCreateCommitMethodName = `_setNewValueFor${pascalize(key)}AfterCreateCommit`;
+            const afterUpdateMethodName = `_updateValueFor${pascalize(key)}AfterUpdate`;
+            const afterUpdateCommitMethodName = `_updateValueFor${pascalize(key)}AfteUpdateCommit`;
+            const afterDestroyMethodName = `_setValuesAfterDestructionFor${pascalize(key)}AfterDestroy`;
+            const afterDestroyCommitMethodName = `_setValuesAfterDestructionFor${pascalize(key)}AfterDestroyCommit`;
+            const dreamPrototype = Object.getPrototypeOf(dream);
+            // before saving, we remember the new value for position, but clear it from our
+            // supervised attributes to prevent position from saving
+            dreamPrototype[beforeSaveMethodName] = async function (txn) {
+                let query = dreamClass.query();
+                if (txn)
+                    query = query.txn(txn);
+                await beforeSortableSave({
+                    dream: this,
+                    positionField,
+                    query,
+                    scope: opts.scope,
+                });
+            };
+            // once saved, we can now safely update position in isolation
+            dreamPrototype[afterUpdateMethodName] = async function (txn) {
+                // if no transaction is provided, leverage update commit hook instead
+                if (!txn)
+                    return;
+                const query = dreamClass.query().txn(txn);
+                await afterUpdateSortable({
+                    dream: this,
+                    positionField,
+                    query,
+                    scope: opts.scope,
+                    txn,
+                });
+            };
+            dreamPrototype[afterUpdateCommitMethodName] = async function (txn) {
+                // if transaction is provided, leverage update hook instead
+                if (txn)
+                    return;
+                const query = dreamClass.query();
+                await afterUpdateSortable({
+                    dream: this,
+                    positionField,
+                    query,
+                    scope: opts.scope,
+                });
+            };
+            // after create, we always want to ensure the position is set, so if they provide one,
+            // we need to split existing records on position and update, but otherwise we simply set the new position
+            // to be the length of all existing records + 1
+            dreamPrototype[afterCreateMethodName] = async function (txn) {
+                // if no transaction is provided, leverage create commit hook instead
+                if (!txn)
+                    return;
+                const query = dreamClass.query().txn(txn);
+                await afterSortableCreate({
+                    dream: this,
+                    positionField,
+                    query,
+                    scope: opts.scope,
+                    txn,
+                });
+            };
+            dreamPrototype[afterCreateCommitMethodName] = async function (txn) {
+                // if transaction is provided, leverage create hook instead
+                if (txn)
+                    return;
+                const query = dreamClass.query();
+                await afterSortableCreate({
+                    dream: this,
+                    positionField,
+                    query,
+                    scope: opts.scope,
+                });
+            };
+            // after destroy, auto-adjust positions of all related records with a greater position
+            // than this one to maintain incrementing order,
+            dreamPrototype[afterDestroyMethodName] = async function (txn) {
+                // if no transaction is provided, leverage destroy commit hook instead
+                if (!txn)
+                    return;
+                const query = dreamClass.query().txn(txn);
+                await afterSortableDestroy({
+                    dream: this,
+                    positionField,
+                    query,
+                    scope: opts.scope,
+                });
+            };
+            dreamPrototype[afterDestroyCommitMethodName] = async function (txn) {
+                // if transaction is provided, leverage destroy hook instead
+                if (txn)
+                    return;
+                const query = dreamClass.query();
+                await afterSortableDestroy({
+                    dream: this,
+                    positionField,
+                    query,
+                    scope: opts.scope,
+                });
+            };
+            beforeSaveImplementation(dream, beforeSaveMethodName);
+            afterCreateImplementation(dream, afterCreateMethodName);
+            afterCreateCommitImplementation(dream, afterCreateCommitMethodName);
+            afterUpdateImplementation(dream, afterUpdateMethodName);
+            afterUpdateCommitImplementation(dream, afterUpdateCommitMethodName);
+            afterDestroyImplementation(dream, afterDestroyMethodName);
+            afterDestroyCommitImplementation(dream, afterDestroyCommitMethodName);
+        });
+    };
+}

package/dist/esm/src/decorators/sortable/helpers/applySortableScopeToQuery.js

@@ -0,0 +1,14 @@
+import getColumnForSortableScope from './getColumnForSortableScope.js';
+import scopeArray from './scopeArray.js';
+export default function applySortableScopeToQuery(query, dream, scope) {
+    if (!scope)
+        return query;
+    const scopes = scopeArray(scope);
+    for (const scope of scopes) {
+        const column = getColumnForSortableScope(dream, scope);
+        query = query.where({
+            [column]: dream[column],
+        });
+    }
+    return query;
+}

package/dist/esm/src/decorators/sortable/helpers/clearCachedSortableValues.js

@@ -0,0 +1,8 @@
+import sortableCacheKeyName from './sortableCacheKeyName.js';
+import sortableCacheValuesName from './sortableCacheValuesName.js';
+export default function clearCachedSortableValues(dream, positionField) {
+    const cacheKey = sortableCacheKeyName(positionField);
+    const cachedValuesName = sortableCacheValuesName(positionField);
+    dream[cacheKey] = undefined;
+    dream[cachedValuesName] = undefined;
+}

package/dist/esm/src/decorators/sortable/helpers/decrementScopedRecordsGreaterThanPosition.js

@@ -0,0 +1,23 @@
+import ops from '../../../ops/index.js';
+import getColumnForSortableScope from './getColumnForSortableScope.js';
+import scopeArray from './scopeArray.js';
+export default async function decrementPositionForScopedRecordsGreaterThanPosition(position, { dream, positionField, query, scope, }) {
+    let kyselyQuery = query
+        .whereNot({ [dream.primaryKey]: dream.primaryKeyValue })
+        .where({
+        [positionField]: ops.greaterThanOrEqualTo(position),
+    })
+        .toKysely('update')
+        .set((eb) => {
+        return {
+            [positionField]: eb(positionField, '-', 1),
+        };
+    });
+    for (const singleScope of scopeArray(scope)) {
+        const column = getColumnForSortableScope(dream, singleScope);
+        if (column) {
+            kyselyQuery = kyselyQuery.where(column, '=', dream[column]);
+        }
+    }
+    await kyselyQuery.execute();
+}

package/dist/esm/src/decorators/sortable/helpers/getColumnForSortableScope.js

@@ -0,0 +1,15 @@
+import NonBelongsToAssociationProvidedAsSortableDecoratorScope from '../../../errors/NonBelongsToAssociationProvidedAsSortableDecoratorScope.js';
+import SortableDecoratorRequiresColumnOrBelongsToAssociation from '../../../errors/SortableDecoratorRequiresColumnOrBelongsToAssociation.js';
+export default function getColumnForSortableScope(dream, scope) {
+    if (!scope)
+        return null;
+    const dreamClass = dream.constructor;
+    if (dreamClass.columns().has(scope))
+        return scope;
+    const associationMetadata = dream['associationMetadataMap']()[scope];
+    if (!associationMetadata)
+        throw new SortableDecoratorRequiresColumnOrBelongsToAssociation(scope, dreamClass);
+    if (associationMetadata.type !== 'BelongsTo')
+        throw new NonBelongsToAssociationProvidedAsSortableDecoratorScope(scope, dreamClass);
+    return associationMetadata.foreignKey();
+}

package/dist/esm/src/decorators/sortable/helpers/isSortedCorrectly.js

@@ -0,0 +1,4 @@
+export default function isSortedCorrectly(arr, positionField) {
+    const invalidPositionItem = arr.find((item, index) => item[positionField] !== index + 1);
+    return !invalidPositionItem;
+}

package/dist/esm/src/decorators/sortable/helpers/positionIsInvalid.js

@@ -0,0 +1,8 @@
+import applySortableScopeToQuery from './applySortableScopeToQuery.js';
+export default async function positionIsInvalid({ query, dream, position, scope, }) {
+    const totalRecordsQuery = applySortableScopeToQuery(query, dream, scope);
+    return (position === null ||
+        position === undefined ||
+        position < 1 ||
+        position > (await totalRecordsQuery.count()) + (dream.isPersisted ? 0 : 1));
+}

package/dist/esm/src/decorators/sortable/helpers/resortAllRecords.js

@@ -0,0 +1,35 @@
+import getColumnForSortableScope from './getColumnForSortableScope.js';
+import isSortedCorrectly from './isSortedCorrectly.js';
+import scopeArray from './scopeArray.js';
+export default async function resortAllRecords(dreamClass, positionField, scope) {
+    const dreams = await dreamClass.order({ [positionField]: 'asc' }).all();
+    const hash = {};
+    for (const dream of dreams) {
+        const foreignKeys = foreignKeysForScope(dream, scope);
+        hash[foreignKeys.join(':')] ||= [];
+        hash[foreignKeys.join(':')].push(dream);
+    }
+    for (const dreamArr of Object.values(hash)) {
+        const dreams = dreamArr;
+        if (isSortedCorrectly(dreams, positionField))
+            continue;
+        await dreamClass.transaction(async (txn) => {
+            let counter = 1;
+            for (const dream of dreams) {
+                await dreamClass
+                    .txn(txn)
+                    .where({ [dream.primaryKey]: dream.primaryKeyValue })
+                    .toKysely('update')
+                    .set({
+                    [positionField]: counter++,
+                })
+                    .execute();
+            }
+        });
+    }
+}
+function foreignKeysForScope(dream, scope) {
+    return scopeArray(scope)
+        .map(singleScope => getColumnForSortableScope(dream, singleScope))
+        .map(fk => dream[fk]);
+}

package/dist/esm/src/decorators/sortable/helpers/scopeArray.js

@@ -0,0 +1,7 @@
+export default function scopeArray(scope) {
+    if (!scope)
+        return [];
+    if (Array.isArray(scope))
+        return scope;
+    return [scope];
+}