@rvoh/dream 0.29.1

package/dist/cjs/src/decorators/sortable/helpers/setPosition.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = setPosition;
+exports.applySortableScopesToQuery = applySortableScopesToQuery;
+const index_js_1 = require("../../../db/index.js");
+const range_js_1 = require("../../../helpers/range.js");
+const getColumnForSortableScope_js_1 = require("./getColumnForSortableScope.js");
+const scopeArray_js_1 = require("./scopeArray.js");
+const sortableQueryExcludingDream_js_1 = require("./sortableQueryExcludingDream.js");
+async function setPosition({ position, previousPosition, dream, positionField, scope, query, txn, }) {
+    if (position) {
+        await setPositionFromValue({
+            position,
+            dream,
+            positionField,
+            scope,
+            previousPosition,
+            query,
+            txn,
+        });
+    }
+    else {
+        await setNewPosition({
+            dream,
+            positionField,
+            scope,
+            previousPosition,
+            query,
+            txn,
+        });
+    }
+}
+async function setPositionFromValue({ position, previousPosition, dream, positionField, query, scope, txn, }) {
+    const newPosition = position;
+    if (txn) {
+        await applyUpdates({
+            position,
+            previousPosition,
+            dream,
+            positionField,
+            query,
+            scope,
+            txn,
+            newPosition,
+        });
+    }
+    else {
+        await dream.constructor.transaction(async (txn) => {
+            await applyUpdates({
+                position,
+                previousPosition,
+                dream,
+                positionField,
+                query,
+                scope,
+                txn,
+                newPosition,
+            });
+        });
+    }
+    if (txn) {
+        await dream.txn(txn).reload();
+    }
+    else {
+        await dream.reload();
+    }
+}
+async function applyUpdates({ position, previousPosition, dream, positionField, query, scope, txn, newPosition, }) {
+    await updateConflictingRecords({
+        position,
+        previousPosition,
+        dream,
+        positionField,
+        query,
+        scope,
+        txn,
+    });
+    await updatePositionForRecord(txn, dream, positionField, newPosition);
+}
+async function setNewPosition({ dream, positionField, query, scope, previousPosition, txn, }) {
+    const newPosition = (await (0, sortableQueryExcludingDream_js_1.default)(dream, query, scope).max(positionField)) + 1;
+    const dbOrTxn = txn ? txn.kyselyTransaction : (0, index_js_1.default)('primary');
+    await dbOrTxn
+        .updateTable(dream.table)
+        .where(dream.primaryKey, '=', dream.primaryKeyValue)
+        .set({
+        [positionField]: newPosition,
+    })
+        .execute();
+    if (txn) {
+        await dream.txn(txn).reload();
+    }
+    else {
+        await dream.reload();
+    }
+    if (txn) {
+        await updateConflictingRecords({
+            previousPosition,
+            dream,
+            positionField,
+            query,
+            scope,
+            txn,
+        });
+    }
+    else {
+        await dream.constructor.transaction(async (txn) => {
+            await updateConflictingRecords({
+                previousPosition,
+                dream,
+                positionField,
+                query,
+                scope,
+                txn,
+            });
+        });
+    }
+}
+async function updateConflictingRecords({ position, previousPosition, dream, positionField, query, scope, txn, }) {
+    const newPosition = position;
+    if (newPosition === undefined && previousPosition === undefined)
+        return;
+    const increasing = newPosition === undefined || (previousPosition !== undefined && previousPosition < newPosition);
+    let kyselyQuery = query
+        .txn(txn)
+        .whereNot({ [dream.primaryKey]: dream.primaryKeyValue })
+        .where({
+        [positionField]: increasing
+            ? (0, range_js_1.default)(previousPosition, newPosition)
+            : (0, range_js_1.default)(newPosition, previousPosition),
+    })
+        .toKysely('update')
+        .set((eb) => ({
+        [positionField]: eb(positionField, increasing ? '-' : '+', 1),
+    }));
+    kyselyQuery = applySortableScopesToQuery(dream, kyselyQuery, column => dream.savedChangeToAttribute(column)
+        ? (dream.changes()[column]?.was ?? dream[column])
+        : dream[column], scope);
+    await kyselyQuery.execute();
+}
+function applySortableScopesToQuery(dream, kyselyQuery, whereValueCB, scope) {
+    for (const singleScope of (0, scopeArray_js_1.default)(scope)) {
+        const column = (0, getColumnForSortableScope_js_1.default)(dream, singleScope);
+        if (column) {
+            kyselyQuery = kyselyQuery.where(column, '=', whereValueCB(column));
+        }
+    }
+    return kyselyQuery;
+}
+async function updatePositionForRecord(txn, dream, positionField, position) {
+    await txn.kyselyTransaction
+        .updateTable(dream.table)
+        .where(dream.primaryKey, '=', dream.primaryKeyValue)
+        .set({
+        [positionField]: position,
+    })
+        .execute();
+}

package/dist/cjs/src/decorators/sortable/helpers/sortableCacheKeyName.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = sortableCacheKeyName;
+const pascalize_js_1 = require("../../../helpers/pascalize.js");
+function sortableCacheKeyName(positionField) {
+    return `_cachedPositionFor${(0, pascalize_js_1.default)(positionField)}`;
+}

package/dist/cjs/src/decorators/sortable/helpers/sortableCacheValuesName.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = sortableCacheValuesName;
+const pascalize_js_1 = require("../../../helpers/pascalize.js");
+function sortableCacheValuesName(positionField) {
+    return `_cachedPositionValuesFor${(0, pascalize_js_1.default)(positionField)}`;
+}

package/dist/cjs/src/decorators/sortable/helpers/sortableQueryExcludingDream.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = sortableQueryExcludingDream;
+const applySortableScopeToQuery_js_1 = require("./applySortableScopeToQuery.js");
+function sortableQueryExcludingDream(dream, query, scope) {
+    query = query.whereNot({
+        [dream.primaryKey]: dream.primaryKeyValue,
+    });
+    return (0, applySortableScopeToQuery_js_1.default)(query, dream, scope);
+}

package/dist/cjs/src/decorators/sortable/hooks/afterSortableCreate.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = afterSortableCreate;
+const clearCachedSortableValues_js_1 = require("../helpers/clearCachedSortableValues.js");
+const setPosition_js_1 = require("../helpers/setPosition.js");
+const sortableCacheKeyName_js_1 = require("../helpers/sortableCacheKeyName.js");
+async function afterSortableCreate({ positionField, dream, query, txn, scope, }) {
+    const cacheKey = (0, sortableCacheKeyName_js_1.default)(positionField);
+    await (0, setPosition_js_1.default)({
+        position: dream[cacheKey],
+        dream,
+        positionField,
+        txn,
+        scope,
+        query,
+    });
+    (0, clearCachedSortableValues_js_1.default)(dream, positionField);
+}

package/dist/cjs/src/decorators/sortable/hooks/afterSortableDestroy.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = afterSortableDestroy;
+const clearCachedSortableValues_js_1 = require("../helpers/clearCachedSortableValues.js");
+const decrementScopedRecordsGreaterThanPosition_js_1 = require("../helpers/decrementScopedRecordsGreaterThanPosition.js");
+async function afterSortableDestroy({ positionField, dream, query, scope, }) {
+    await (0, decrementScopedRecordsGreaterThanPosition_js_1.default)(dream[positionField], {
+        dream,
+        positionField,
+        scope,
+        query,
+    });
+    (0, clearCachedSortableValues_js_1.default)(dream, positionField);
+}

package/dist/cjs/src/decorators/sortable/hooks/afterSortableUpdate.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = afterUpdateSortable;
+const clearCachedSortableValues_js_1 = require("../helpers/clearCachedSortableValues.js");
+const setPosition_js_1 = require("../helpers/setPosition.js");
+const sortableCacheKeyName_js_1 = require("../helpers/sortableCacheKeyName.js");
+const sortableCacheValuesName_js_1 = require("../helpers/sortableCacheValuesName.js");
+async function afterUpdateSortable({ positionField, dream, query, txn, scope, }) {
+    const cacheKey = (0, sortableCacheKeyName_js_1.default)(positionField);
+    const cachedValuesName = (0, sortableCacheValuesName_js_1.default)(positionField);
+    if (!dream[cacheKey])
+        return;
+    if (dream[cachedValuesName]) {
+        await (0, setPosition_js_1.default)({
+            ...dream[cachedValuesName],
+            txn,
+        });
+    }
+    else {
+        await (0, setPosition_js_1.default)({
+            position: dream[cacheKey],
+            dream: dream,
+            positionField,
+            scope,
+            previousPosition: dream.changes()[positionField]?.was,
+            query,
+            txn,
+        });
+    }
+    (0, clearCachedSortableValues_js_1.default)(dream, positionField);
+}

package/dist/cjs/src/decorators/sortable/hooks/beforeSortableSave.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = beforeSortableSave;
+const positionIsInvalid_js_1 = require("../helpers/positionIsInvalid.js");
+const scopeArray_js_1 = require("../helpers/scopeArray.js");
+const sortableCacheKeyName_js_1 = require("../helpers/sortableCacheKeyName.js");
+const sortableCacheValuesName_js_1 = require("../helpers/sortableCacheValuesName.js");
+async function beforeSortableSave({ positionField, dream, query, scope, }) {
+    const cacheKey = (0, sortableCacheKeyName_js_1.default)(positionField);
+    const cachedValuesName = (0, sortableCacheValuesName_js_1.default)(positionField);
+    const dreamAsAny = dream;
+    const changingScope = (0, scopeArray_js_1.default)(scope).filter(scopeField => dream['getAssociationMetadata'](scopeField)
+        ? dream.willSaveChangeToAttribute(dream['getAssociationMetadata'](scopeField).foreignKey())
+        : dream.willSaveChangeToAttribute(scopeField)).length;
+    if (!dream.willSaveChangeToAttribute(positionField) && !changingScope)
+        return;
+    const onlyChangingScope = !dream.willSaveChangeToAttribute(positionField) && changingScope;
+    const position = dreamAsAny[positionField];
+    if (onlyChangingScope) {
+        dreamAsAny[cacheKey] = position;
+    }
+    else if (await (0, positionIsInvalid_js_1.default)({ query, dream: dream, scope, position })) {
+        if (changingScope) {
+            dreamAsAny[cacheKey] = dream.changes()[positionField]?.was;
+        }
+        else {
+            if (dream.isPersisted) {
+                dreamAsAny[positionField] = undefined;
+                return;
+            }
+            else {
+                dreamAsAny[cacheKey] = dream.changes()[positionField]?.was;
+            }
+        }
+    }
+    else {
+        dreamAsAny[cacheKey] = position;
+    }
+    // store values to be used in after create/update hook
+    const values = {
+        position: changingScope ? undefined : dreamAsAny[cacheKey],
+        dream,
+        positionField,
+        scope,
+        previousPosition: dream.willSaveChangeToAttribute(positionField)
+            ? dream.changes()[positionField]?.was
+            : changingScope
+                ? position
+                : undefined,
+        query,
+    };
+    dreamAsAny[cachedValuesName] = values;
+    if (dream.isNewRecord || changingScope) {
+        // if the dream is not saved, or is being moved between scopes, set position to 0
+        // to prevent collisions with existing position values.
+        // it will be updated in an AfterCreateCommit hook to the correct value after saving.
+        dreamAsAny[positionField] = 0;
+    }
+    else {
+        // if the dream is saved, set the position field to undefined, which will cause
+        // the update cycle to ignore the position field. We will proceed to update it in an
+        // AfterUpdateCommit hook
+        dreamAsAny[positionField] = undefined;
+    }
+}

package/dist/cjs/src/decorators/validations/Validate.js

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

package/dist/cjs/src/decorators/validations/Validates.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationInstantiationError = void 0;
+exports.default = Validates;
+exports.validatesImplementation = validatesImplementation;
+function Validates(type, args) {
+    return function (_, context) {
+        const key = context.name;
+        context.addInitializer(function () {
+            validatesImplementation(this, key, type, args);
+        });
+    };
+}
+function validatesImplementation(target, key, type, args) {
+    const t = target.constructor;
+    if (!t['globallyInitializingDecorators'])
+        return;
+    if (!Object.getOwnPropertyDescriptor(t, 'validations')) {
+        // This pattern allows `validations` on a base STI class and on
+        // child STI classes. The new `validations` property will be created
+        // on the child STI class, but it will include all the `validations`
+        // already declared on the base STI class.
+        t['validations'] = [...t['validations']];
+    }
+    ;
+    t['validations'].push({
+        type,
+        column: key,
+        options: extractValidationOptionsFromArgs(type, args),
+    });
+}
+function extractValidationOptionsFromArgs(type, args) {
+    switch (type) {
+        case 'presence':
+            return { presence: {} };
+        case 'numericality':
+            return {
+                numericality: {
+                    max: args?.max,
+                    min: args?.min,
+                },
+            };
+        case 'contains':
+            if (!['String', 'RegExp'].includes(args.constructor.name))
+                throw new ValidationInstantiationError(`When validating using "contains", the second argument must be a string or regular expression`);
+            return { contains: { value: args } };
+        case 'length':
+            if (typeof args === 'number') {
+                return { length: { min: args } };
+            }
+            else if (args?.min) {
+                return { length: { min: args.min, max: args?.max } };
+            }
+            else {
+                throw new ValidationInstantiationError(`
+          When validating using "length", the second argument must be a number representing
+          the min length, or else an object expressing both min and max length, like so:
+
+          @Validates('length', { min: 4, max: 32 })
+        `);
+            }
+        case 'requiredBelongsTo':
+            return {};
+        default:
+            throw new Error(`Unhandled validation type when caching options: ${type}`);
+    }
+}
+class ValidationInstantiationError extends Error {
+}
+exports.ValidationInstantiationError = ValidationInstantiationError;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });