@rvoh/dream 0.29.1

package/dist/esm/src/dream/internal/applyScopeBypassingSettingsToQuery.js

@@ -0,0 +1,8 @@
+export default function applyScopeBypassingSettingsToQuery(query, { bypassAllDefaultScopes, defaultScopesToBypass, }) {
+    if (bypassAllDefaultScopes)
+        query = query.removeAllDefaultScopes();
+    defaultScopesToBypass.forEach(defaultScopeToBypass => {
+        query = query.removeDefaultScope(defaultScopeToBypass);
+    });
+    return query;
+}

package/dist/esm/src/dream/internal/associations/associationQuery.js

@@ -0,0 +1,20 @@
+import applyScopeBypassingSettingsToQuery from '../applyScopeBypassingSettingsToQuery.js';
+export default function associationQuery(dream, txn = null, associationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, }) {
+    const association = dream['associationMetadataMap']()[associationName];
+    const associationClass = association.modelCB();
+    const dreamClass = dream.constructor;
+    const dreamClassOrTransaction = (txn ? dreamClass.txn(txn) : dreamClass);
+    let baseSelectQuery = dreamClassOrTransaction.where({
+        [dream.primaryKey]: dream.primaryKeyValue,
+    });
+    if (joinOnStatements && (joinOnStatements.on || joinOnStatements.notOn || joinOnStatements.onAny))
+        baseSelectQuery = baseSelectQuery.innerJoin(association.as, joinOnStatements);
+    else
+        baseSelectQuery = baseSelectQuery.innerJoin(association.as);
+    let query = txn ? associationClass.txn(txn).queryInstance() : associationClass.query();
+    query = applyScopeBypassingSettingsToQuery(query, {
+        bypassAllDefaultScopes,
+        defaultScopesToBypass,
+    });
+    return query['setBaseSQLAlias'](association.as)['setAssociationQueryBase'](baseSelectQuery);
+}

package/dist/esm/src/dream/internal/associations/associationUpdateQuery.js

@@ -0,0 +1,33 @@
+import namespaceColumn from '../../../helpers/namespaceColumn.js';
+import applyScopeBypassingSettingsToQuery from '../applyScopeBypassingSettingsToQuery.js';
+export default function associationUpdateQuery(dream, txn = null, associationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, }) {
+    const association = dream['associationMetadataMap']()[associationName];
+    const associationClass = association.modelCB();
+    if (Array.isArray(associationClass)) {
+        throw new Error('Cannot update a polymorphic association using associationUpdateQuery');
+    }
+    const dreamClass = dream.constructor;
+    let nestedScope = txn
+        ? dreamClass.txn(txn)
+        : dreamClass.query();
+    nestedScope = applyScopeBypassingSettingsToQuery(nestedScope, {
+        bypassAllDefaultScopes,
+        defaultScopesToBypass,
+    });
+    if (joinOnStatements && (joinOnStatements.on || joinOnStatements.notOn || joinOnStatements.onAny))
+        nestedScope = nestedScope.innerJoin(association.as, joinOnStatements);
+    else
+        nestedScope = nestedScope.innerJoin(association.as);
+    const nestedSelect = nestedScope
+        .where({ [dream.primaryKey]: dream.primaryKeyValue })
+        .nestedSelect(namespaceColumn(associationClass.primaryKey, association.as));
+    const whereClause = {
+        [associationClass.primaryKey]: nestedSelect,
+    };
+    let query = txn ? associationClass.txn(txn).where(whereClause) : associationClass.where(whereClause);
+    query = applyScopeBypassingSettingsToQuery(query, {
+        bypassAllDefaultScopes,
+        defaultScopesToBypass,
+    });
+    return query;
+}

package/dist/esm/src/dream/internal/associations/createAssociation.js

@@ -0,0 +1,52 @@
+import CannotCreateAssociationWithThroughContext from '../../../errors/associations/CannotCreateAssociationWithThroughContext.js';
+export default async function createAssociation(dream, txn = null, associationName, opts = {}) {
+    const association = dream['associationMetadataMap']()[associationName];
+    if (Array.isArray(association.modelCB())) {
+        throw new Error(`
+        Cannot create polymorphic associations using createAssociation
+      `);
+    }
+    const associationClass = association.modelCB();
+    let hasresult;
+    let belongstoresult;
+    let belongstoFn;
+    const hasAssociation = association;
+    let modifiedOpts;
+    switch (association.type) {
+        case 'HasMany':
+        case 'HasOne':
+            if (hasAssociation.through)
+                throw new CannotCreateAssociationWithThroughContext({
+                    dreamClass: dream.constructor,
+                    association,
+                });
+            modifiedOpts = {
+                [association.foreignKey()]: association.primaryKeyValue(dream),
+                ...opts,
+            };
+            if (hasAssociation.polymorphic) {
+                modifiedOpts[hasAssociation.foreignKeyTypeField()] = dream['stiBaseClassOrOwnClass'].name;
+            }
+            if (txn) {
+                hasresult = await associationClass.txn(txn).create(modifiedOpts);
+            }
+            else {
+                hasresult = await associationClass.create(modifiedOpts);
+            }
+            return hasresult;
+        case 'BelongsTo':
+            belongstoFn = async (txn) => {
+                belongstoresult = await associationClass.txn(txn).create({
+                    ...opts,
+                });
+                await dream.txn(txn).update({
+                    [association.foreignKey()]: association.primaryKeyValue(belongstoresult),
+                });
+            };
+            if (txn)
+                await belongstoFn(txn);
+            else
+                await dream.constructor.transaction(belongstoFn);
+            return belongstoresult;
+    }
+}

package/dist/esm/src/dream/internal/associations/destroyAssociation.js

@@ -0,0 +1,14 @@
+import associationUpdateQuery from './associationUpdateQuery.js';
+export default async function destroyAssociation(dream, txn = null, associationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, cascade, reallyDestroy, skipHooks, }) {
+    const query = associationUpdateQuery(dream, txn, associationName, {
+        joinOnStatements,
+        bypassAllDefaultScopes,
+        defaultScopesToBypass,
+    });
+    if (reallyDestroy) {
+        return await query.reallyDestroy({ skipHooks, cascade });
+    }
+    else {
+        return await query.destroy({ skipHooks, cascade });
+    }
+}

package/dist/esm/src/dream/internal/associations/undestroyAssociation.js

@@ -0,0 +1,9 @@
+import associationUpdateQuery from './associationUpdateQuery.js';
+export default async function undestroyAssociation(dream, txn = null, associationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, cascade, skipHooks, }) {
+    const query = associationUpdateQuery(dream, txn, associationName, {
+        joinOnStatements,
+        bypassAllDefaultScopes,
+        defaultScopesToBypass,
+    });
+    return await query.undestroy({ skipHooks, cascade });
+}

package/dist/esm/src/dream/internal/checkSingleValidation.js

@@ -0,0 +1,49 @@
+import NonLoadedAssociation from '../../errors/associations/NonLoadedAssociation.js';
+export default function checkSingleValidation(dream, validation) {
+    let value;
+    try {
+        value = dream[validation.column];
+    }
+    catch (error) {
+        if (error.constructor !== NonLoadedAssociation)
+            throw error;
+    }
+    let parsedFloat;
+    switch (validation.type) {
+        case 'presence':
+            return !isBlank(value);
+        case 'numericality':
+            if (isBlank(value))
+                return true;
+            if (isNaN(value))
+                return false;
+            parsedFloat = parseFloat(value);
+            if (validation.options?.numericality?.max?.constructor === Number &&
+                parsedFloat > validation.options?.numericality?.max)
+                return false;
+            if (validation.options?.numericality?.min?.constructor === Number &&
+                parsedFloat < validation.options?.numericality?.min)
+                return false;
+            return true;
+        case 'contains':
+            switch (validation.options.contains.value.constructor) {
+                case String:
+                    return new RegExp(validation.options.contains.value).test(value);
+                case RegExp:
+                    return validation.options.contains.value.test(value);
+            }
+            break;
+        case 'length':
+            return (value?.length &&
+                value.length >= validation.options.length.min &&
+                validation.options.length.max &&
+                value.length <= validation.options.length.max);
+        case 'requiredBelongsTo':
+            return !!(value || dream[dream['associationMetadataMap']()[validation.column].foreignKey()]);
+        default:
+            throw new Error(`Unhandled validation type found while running validations: ${validation.type}`);
+    }
+}
+function isBlank(value) {
+    return [undefined, null, ''].includes(value);
+}

package/dist/esm/src/dream/internal/destroyAssociatedRecords.js

@@ -0,0 +1,18 @@
+/**
+ * @internal
+ *
+ * Destroys all HasOne/HasMany associations on this
+ * dream that are marked as `dependent: 'destroy'`
+ */
+export default async function destroyAssociatedRecords(dream, txn, options) {
+    const dreamClass = dream.constructor;
+    const { reallyDestroy } = options;
+    for (const associationName of dreamClass['dependentDestroyAssociationNames']()) {
+        if (reallyDestroy) {
+            await dream.txn(txn).reallyDestroyAssociation(associationName, options);
+        }
+        else {
+            await dream.txn(txn).destroyAssociation(associationName, options);
+        }
+    }
+}

package/dist/esm/src/dream/internal/destroyDream.js

@@ -0,0 +1,69 @@
+import destroyAssociatedRecords from './destroyAssociatedRecords.js';
+import runHooksFor from './runHooksFor.js';
+import safelyRunCommitHooks from './safelyRunCommitHooks.js';
+import softDeleteDream from './softDeleteDream.js';
+/**
+ * @internal
+ *
+ * Destroys the Dream and any `dependent: 'destroy'` associations
+ * within a transaction. If a transaction is passed, it will be used.
+ * Otherwise, a new transaction will be created automatically.
+ * If any of the nested associations fails to destroy, then this
+ * record will also fail to destroy. If skipHooks is true, model hooks
+ * will be bypassed.
+ */
+export default async function destroyDream(dream, txn = null, options) {
+    if (txn) {
+        return await destroyDreamWithTransaction(dream, txn, options);
+    }
+    else {
+        const dreamClass = dream.constructor;
+        return await dreamClass.transaction(async (txn) => await destroyDreamWithTransaction(dream, txn, options));
+    }
+}
+/**
+ * @internal
+ *
+ * Given a transaction, applies the destroy query,
+ * including cascading to child associations and
+ * model hooks.
+ */
+async function destroyDreamWithTransaction(dream, txn, options) {
+    const { cascade, reallyDestroy, skipHooks } = options;
+    if (cascade) {
+        await destroyAssociatedRecords(dream, txn, options);
+    }
+    if (!skipHooks) {
+        await runHooksFor('beforeDestroy', dream, true, null, txn);
+    }
+    await maybeDestroyDream(dream, txn, reallyDestroy);
+    if (!skipHooks) {
+        await runHooksFor('afterDestroy', dream, true, null, txn || undefined);
+        await safelyRunCommitHooks(dream, 'afterDestroyCommit', true, null, txn);
+    }
+    if (shouldSoftDelete(dream, reallyDestroy)) {
+        await dream.txn(txn).reload();
+    }
+    return dream;
+}
+function shouldSoftDelete(dream, reallyDestroy) {
+    const dreamClass = dream.constructor;
+    return dreamClass['softDelete'] && !reallyDestroy;
+}
+/**
+ * @internal
+ *
+ * Destroys the dream iff it was not blocked from
+ * deleting by one of the beforeDestroy model hooks
+ */
+async function maybeDestroyDream(dream, txn, reallyDestroy) {
+    if (shouldSoftDelete(dream, reallyDestroy)) {
+        await softDeleteDream(dream, txn);
+    }
+    else if (!dream['_preventDeletion']) {
+        await txn.kyselyTransaction
+            .deleteFrom(dream.table)
+            .where(dream.primaryKey, '=', dream.primaryKeyValue)
+            .execute();
+    }
+}

package/dist/esm/src/dream/internal/destroyOptions.js

@@ -0,0 +1,27 @@
+import { addSoftDeleteScopeToUserScopes, DEFAULT_BYPASS_ALL_DEFAULT_SCOPES, DEFAULT_CASCADE, DEFAULT_DEFAULT_SCOPES_TO_BYPASS, DEFAULT_SKIP_HOOKS, } from './scopeHelpers.js';
+function baseDestroyOptions({ bypassAllDefaultScopes, defaultScopesToBypass, cascade, skipHooks, } = {}) {
+    return {
+        bypassAllDefaultScopes: bypassAllDefaultScopes ?? DEFAULT_BYPASS_ALL_DEFAULT_SCOPES,
+        defaultScopesToBypass: defaultScopesToBypass ?? DEFAULT_DEFAULT_SCOPES_TO_BYPASS,
+        cascade: cascade ?? DEFAULT_CASCADE,
+        skipHooks: skipHooks ?? DEFAULT_SKIP_HOOKS,
+    };
+}
+export function destroyOptions(options) {
+    return {
+        ...baseDestroyOptions(options),
+        reallyDestroy: false,
+    };
+}
+export function undestroyOptions(options) {
+    return {
+        ...baseDestroyOptions(options),
+        defaultScopesToBypass: addSoftDeleteScopeToUserScopes(options?.defaultScopesToBypass),
+    };
+}
+export function reallyDestroyOptions(options) {
+    return {
+        ...undestroyOptions(options),
+        reallyDestroy: true,
+    };
+}

package/dist/esm/src/dream/internal/ensureSTITypeFieldIsSet.js

@@ -0,0 +1,7 @@
+export default function ensureSTITypeFieldIsSet(dream) {
+    const Base = dream.constructor;
+    if (Base['sti'].value && !dream.type) {
+        ;
+        dream.type = Base['sti'].value;
+    }
+}

package/dist/esm/src/dream/internal/executeDatabaseQuery.js

@@ -0,0 +1,21 @@
+import DreamApplication from '../../dream-application/index.js';
+import EnvInternal from '../../helpers/EnvInternal.js';
+export default async function executeDatabaseQuery(kyselyQuery, command) {
+    try {
+        return await kyselyQuery[command]();
+    }
+    catch (error) {
+        if (EnvInternal.isDebug) {
+            const sqlString = kyselyQuery.compile().sql;
+            const paramsString = kyselyQuery.compile().parameters.join(', ');
+            DreamApplication.logWithLevel('error', `Error executing the following SQL:
+${error.message}
+
+${sqlString}
+[ ${paramsString} ]
+NOTE: to turn this message off, remove the DEBUG=1 env variable`);
+        }
+        // throw the original error to maintain stack trace
+        throw error;
+    }
+}

package/dist/esm/src/dream/internal/extractAssociationMetadataFromAssociationName.js

@@ -0,0 +1,5 @@
+export default function extractAssociationMetadataFromAssociationName(associationName) {
+    const name = / as /.test(associationName) ? associationName.split(/ as /)[0] : associationName;
+    const alias = / as /.test(associationName) ? associationName.split(/ as /)[1] : associationName;
+    return { name, alias };
+}

package/dist/esm/src/dream/internal/orderByDirection.js

@@ -0,0 +1,12 @@
+import { sql } from 'kysely';
+export default function orderByDirection(dir) {
+    switch (dir) {
+        case 'asc':
+        case null:
+            return sql `asc nulls first`;
+        case 'desc':
+            return sql `desc nulls last`;
+        default:
+            throw new Error(`Unrecognized orderBy direction: ${dir}`);
+    }
+}

package/dist/esm/src/dream/internal/reload.js

@@ -0,0 +1,18 @@
+import CannotReloadUnsavedDream from '../../errors/CannotReloadUnsavedDream.js';
+import Query from '../Query.js';
+export default async function reload(dream, txn = null) {
+    if (dream.isNewRecord)
+        throw new CannotReloadUnsavedDream(dream);
+    let query = new Query(dream);
+    if (txn)
+        query = query.txn(txn);
+    // must always reload from the primary database to avoid the race condition in which changes
+    // we have persisted are not yet propagated
+    else
+        query = query.connection('primary');
+    query = query.removeAllDefaultScopes().where({ [dream.primaryKey]: dream.primaryKeyValue });
+    const reloadedRecord = (await query.first());
+    dream.setAttributes(reloadedRecord.getAttributes());
+    dream['freezeAttributes']();
+    return dream;
+}

package/dist/esm/src/dream/internal/runHooksFor.js

@@ -0,0 +1,95 @@
+export default async function runHooksFor(key, dream, alreadyPersisted, beforeSaveChanges, txn) {
+    const Base = dream.constructor;
+    for (const statement of Base['hooks'][key]) {
+        if (statement.ifChanging?.length) {
+            switch (key) {
+                case 'beforeCreate':
+                    await runConditionalBeforeHooksForCreate(dream, statement, txn);
+                    break;
+                case 'beforeSave':
+                    if (alreadyPersisted)
+                        await runConditionalBeforeHooksForUpdate(dream, statement, txn);
+                    else
+                        await runConditionalBeforeHooksForCreate(dream, statement, txn);
+                    break;
+                case 'beforeUpdate':
+                    await runConditionalBeforeHooksForUpdate(dream, statement, txn);
+                    break;
+                default:
+                    throw new Error(`Unexpected statement key detected with ifChanging clause: ${key}`);
+            }
+        }
+        else if (statement.ifChanged?.length) {
+            switch (key) {
+                case 'afterCreate':
+                case 'afterCreateCommit':
+                    await runConditionalAfterHooksForCreate(dream, statement, beforeSaveChanges, txn);
+                    break;
+                case 'afterSave':
+                case 'afterSaveCommit':
+                    if (alreadyPersisted)
+                        await runConditionalAfterHooksForUpdate(dream, statement, txn);
+                    else
+                        await runConditionalAfterHooksForCreate(dream, statement, beforeSaveChanges, txn);
+                    break;
+                case 'afterUpdate':
+                case 'afterUpdateCommit':
+                    await runConditionalAfterHooksForUpdate(dream, statement, txn);
+                    break;
+                default:
+                    throw new Error(`Unexpected statement key detected with ifChanged clause: ${key}`);
+            }
+        }
+        else {
+            await runHook(statement, dream, txn);
+        }
+    }
+}
+export async function runHook(statement, dream, txn) {
+    if (typeof dream[statement.method] !== 'function') {
+        throw new Error(`
+Attempting to run ${statement.method} as part of the ${statement.type}
+Dream model hook sequence, but we encountered a method that does not exist.
+
+Please make sure "${statement.method}" is defined on ${dream.constructor.name}
+`);
+    }
+    await dream[statement.method](txn);
+}
+async function runConditionalBeforeHooksForCreate(dream, statement, txn) {
+    let shouldRun = false;
+    for (const attribute of statement.ifChanging) {
+        if (dream[attribute] !== undefined)
+            shouldRun = true;
+    }
+    if (shouldRun)
+        await runHook(statement, dream, txn);
+}
+async function runConditionalAfterHooksForCreate(dream, statement, beforeSaveChanges, txn) {
+    let shouldRun = false;
+    for (const attribute of statement.ifChanged) {
+        if (beforeSaveChanges?.[attribute] &&
+            beforeSaveChanges[attribute].was !== beforeSaveChanges[attribute].now)
+            shouldRun = true;
+    }
+    if (shouldRun)
+        await runHook(statement, dream, txn);
+}
+async function runConditionalBeforeHooksForUpdate(dream, statement, txn) {
+    let shouldRun = false;
+    for (const attribute of statement.ifChanging) {
+        if (dream.willSaveChangeToAttribute(attribute))
+            shouldRun = true;
+    }
+    if (shouldRun)
+        await runHook(statement, dream, txn);
+}
+async function runConditionalAfterHooksForUpdate(dream, statement, txn) {
+    let shouldRun = false;
+    for (const attribute of statement.ifChanged) {
+        if (dream.savedChangeToAttribute(attribute))
+            shouldRun = true;
+    }
+    if (shouldRun)
+        await runHook(statement, dream, txn);
+}

package/dist/esm/src/dream/internal/runValidations.js

@@ -0,0 +1,13 @@
+import checkSingleValidation from './checkSingleValidation.js';
+export default function runValidations(dream) {
+    const Base = dream.constructor;
+    Base['validations'].forEach(validation => runValidation(dream, validation));
+    for (const methodName of Base['customValidations']) {
+        ;
+        dream[methodName]();
+    }
+}
+function runValidation(dream, validation) {
+    if (!checkSingleValidation(dream, validation))
+        dream.addError(validation.column, validation.type);
+}

package/dist/esm/src/dream/internal/safelyRunCommitHooks.js

@@ -0,0 +1,12 @@
+import runHooksFor from './runHooksFor.js';
+export default async function safelyRunCommitHooks(dream, hookType, alreadyPersisted, beforeSaveChanges, txn = null) {
+    const Base = dream.constructor;
+    if (txn) {
+        Base['hooks'][hookType].forEach(hook => {
+            txn.addCommitHook(hook, dream);
+        });
+    }
+    else {
+        await runHooksFor(hookType, dream, alreadyPersisted, beforeSaveChanges);
+    }
+}

package/dist/esm/src/dream/internal/saveDream.js

@@ -0,0 +1,64 @@
+import { DateTime } from 'luxon';
+import _db from '../../db/index.js';
+import ValidationError from '../../errors/ValidationError.js';
+import namespaceColumn from '../../helpers/namespaceColumn.js';
+import sqlAttributes from '../../helpers/sqlAttributes.js';
+import executeDatabaseQuery from './executeDatabaseQuery.js';
+import runHooksFor from './runHooksFor.js';
+import safelyRunCommitHooks from './safelyRunCommitHooks.js';
+export default async function saveDream(dream, txn = null, { skipHooks = false } = {}) {
+    const db = txn?.kyselyTransaction || _db('primary');
+    const alreadyPersisted = dream.isPersisted;
+    if (!skipHooks) {
+        if (alreadyPersisted)
+            await runHooksFor('beforeUpdate', dream, alreadyPersisted, null, txn);
+        else
+            await runHooksFor('beforeCreate', dream, alreadyPersisted, null, txn);
+        await runHooksFor('beforeSave', dream, alreadyPersisted, null, txn);
+    }
+    const beforeSaveChanges = dream.changes();
+    // need to check validations after running before hooks, or else
+    // model hooks that might make a model valid cannot run
+    if (dream.isInvalid)
+        throw new ValidationError(dream.constructor.name, dream.errors);
+    if (alreadyPersisted && !dream.isDirty)
+        return dream;
+    let query;
+    const now = DateTime.now();
+    if (!alreadyPersisted && !dream.createdAt && dream.columns().has('createdAt'))
+        dream.createdAt = now;
+    if (!dream.dirtyAttributes().updatedAt && dream.columns().has('updatedAt'))
+        dream.updatedAt = now;
+    const sqlifiedAttributes = sqlAttributes(dream);
+    if (alreadyPersisted) {
+        query = db
+            .updateTable(dream.table)
+            .set(sqlifiedAttributes)
+            .where(namespaceColumn(dream.primaryKey, dream.table), '=', dream.primaryKeyValue);
+    }
+    else {
+        query = db.insertInto(dream.table).values(sqlifiedAttributes);
+    }
+    // BeforeSave/Update actions may clear all the data that we intended to save, leaving us with
+    // an invalid update command. The Sortable decorator is an example of this.
+    if (!alreadyPersisted || Object.keys(sqlifiedAttributes).length) {
+        const data = await executeDatabaseQuery(query.returning([...dream.columns()]), 'executeTakeFirstOrThrow');
+        dream['isPersisted'] = true;
+        dream.setAttributes(data);
+    }
+    // set frozen attributes to what has already been saved
+    dream['freezeAttributes']();
+    dream['attributesFromBeforeLastSave'] = dream['originalAttributes'];
+    dream['originalAttributes'] = dream.getAttributes();
+    if (!skipHooks) {
+        await runHooksFor('afterSave', dream, alreadyPersisted, beforeSaveChanges, txn);
+        if (alreadyPersisted)
+            await runHooksFor('afterUpdate', dream, alreadyPersisted, beforeSaveChanges, txn);
+        else
+            await runHooksFor('afterCreate', dream, alreadyPersisted, beforeSaveChanges, txn);
+        const commitHookType = alreadyPersisted ? 'afterUpdateCommit' : 'afterCreateCommit';
+        await safelyRunCommitHooks(dream, commitHookType, alreadyPersisted, beforeSaveChanges, txn);
+        await safelyRunCommitHooks(dream, 'afterSaveCommit', alreadyPersisted, beforeSaveChanges, txn);
+    }
+    return dream;
+}

package/dist/esm/src/dream/internal/scopeHelpers.js

@@ -0,0 +1,9 @@
+import { SOFT_DELETE_SCOPE_NAME } from '../../decorators/SoftDelete.js';
+import uniq from '../../helpers/uniq.js';
+export const DEFAULT_BYPASS_ALL_DEFAULT_SCOPES = false;
+export const DEFAULT_CASCADE = true;
+export const DEFAULT_DEFAULT_SCOPES_TO_BYPASS = [];
+export const DEFAULT_SKIP_HOOKS = false;
+export function addSoftDeleteScopeToUserScopes(userScopes = []) {
+    return uniq([...userScopes, SOFT_DELETE_SCOPE_NAME]);
+}

package/dist/esm/src/dream/internal/shouldBypassDefaultScope.js

@@ -0,0 +1,9 @@
+export default function shouldBypassDefaultScope(scopeName, { bypassAllDefaultScopes = false, defaultScopesToBypass, }) {
+    if (bypassAllDefaultScopes)
+        return true;
+    if (!defaultScopesToBypass.length)
+        return false;
+    if (defaultScopesToBypass.includes(scopeName))
+        return true;
+    return false;
+}