@rvoh/dream 0.29.1

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = applyScopeBypassingSettingsToQuery;
+function applyScopeBypassingSettingsToQuery(query, { bypassAllDefaultScopes, defaultScopesToBypass, }) {
+    if (bypassAllDefaultScopes)
+        query = query.removeAllDefaultScopes();
+    defaultScopesToBypass.forEach(defaultScopeToBypass => {
+        query = query.removeDefaultScope(defaultScopeToBypass);
+    });
+    return query;
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = associationQuery;
+const applyScopeBypassingSettingsToQuery_js_1 = require("../applyScopeBypassingSettingsToQuery.js");
+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 = (0, applyScopeBypassingSettingsToQuery_js_1.default)(query, {
+        bypassAllDefaultScopes,
+        defaultScopesToBypass,
+    });
+    return query['setBaseSQLAlias'](association.as)['setAssociationQueryBase'](baseSelectQuery);
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = associationUpdateQuery;
+const namespaceColumn_js_1 = require("../../../helpers/namespaceColumn.js");
+const applyScopeBypassingSettingsToQuery_js_1 = require("../applyScopeBypassingSettingsToQuery.js");
+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 = (0, applyScopeBypassingSettingsToQuery_js_1.default)(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((0, namespaceColumn_js_1.default)(associationClass.primaryKey, association.as));
+    const whereClause = {
+        [associationClass.primaryKey]: nestedSelect,
+    };
+    let query = txn ? associationClass.txn(txn).where(whereClause) : associationClass.where(whereClause);
+    query = (0, applyScopeBypassingSettingsToQuery_js_1.default)(query, {
+        bypassAllDefaultScopes,
+        defaultScopesToBypass,
+    });
+    return query;
+}

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createAssociation;
+const CannotCreateAssociationWithThroughContext_js_1 = require("../../../errors/associations/CannotCreateAssociationWithThroughContext.js");
+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_js_1.default({
+                    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/cjs/src/dream/internal/associations/destroyAssociation.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = destroyAssociation;
+const associationUpdateQuery_js_1 = require("./associationUpdateQuery.js");
+async function destroyAssociation(dream, txn = null, associationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, cascade, reallyDestroy, skipHooks, }) {
+    const query = (0, associationUpdateQuery_js_1.default)(dream, txn, associationName, {
+        joinOnStatements,
+        bypassAllDefaultScopes,
+        defaultScopesToBypass,
+    });
+    if (reallyDestroy) {
+        return await query.reallyDestroy({ skipHooks, cascade });
+    }
+    else {
+        return await query.destroy({ skipHooks, cascade });
+    }
+}

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = undestroyAssociation;
+const associationUpdateQuery_js_1 = require("./associationUpdateQuery.js");
+async function undestroyAssociation(dream, txn = null, associationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, cascade, skipHooks, }) {
+    const query = (0, associationUpdateQuery_js_1.default)(dream, txn, associationName, {
+        joinOnStatements,
+        bypassAllDefaultScopes,
+        defaultScopesToBypass,
+    });
+    return await query.undestroy({ skipHooks, cascade });
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = checkSingleValidation;
+const NonLoadedAssociation_js_1 = require("../../errors/associations/NonLoadedAssociation.js");
+function checkSingleValidation(dream, validation) {
+    let value;
+    try {
+        value = dream[validation.column];
+    }
+    catch (error) {
+        if (error.constructor !== NonLoadedAssociation_js_1.default)
+            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/cjs/src/dream/internal/destroyAssociatedRecords.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = destroyAssociatedRecords;
+/**
+ * @internal
+ *
+ * Destroys all HasOne/HasMany associations on this
+ * dream that are marked as `dependent: 'destroy'`
+ */
+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/cjs/src/dream/internal/destroyDream.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = destroyDream;
+const destroyAssociatedRecords_js_1 = require("./destroyAssociatedRecords.js");
+const runHooksFor_js_1 = require("./runHooksFor.js");
+const safelyRunCommitHooks_js_1 = require("./safelyRunCommitHooks.js");
+const softDeleteDream_js_1 = require("./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.
+ */
+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 (0, destroyAssociatedRecords_js_1.default)(dream, txn, options);
+    }
+    if (!skipHooks) {
+        await (0, runHooksFor_js_1.default)('beforeDestroy', dream, true, null, txn);
+    }
+    await maybeDestroyDream(dream, txn, reallyDestroy);
+    if (!skipHooks) {
+        await (0, runHooksFor_js_1.default)('afterDestroy', dream, true, null, txn || undefined);
+        await (0, safelyRunCommitHooks_js_1.default)(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 (0, softDeleteDream_js_1.default)(dream, txn);
+    }
+    else if (!dream['_preventDeletion']) {
+        await txn.kyselyTransaction
+            .deleteFrom(dream.table)
+            .where(dream.primaryKey, '=', dream.primaryKeyValue)
+            .execute();
+    }
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destroyOptions = destroyOptions;
+exports.undestroyOptions = undestroyOptions;
+exports.reallyDestroyOptions = reallyDestroyOptions;
+const scopeHelpers_js_1 = require("./scopeHelpers.js");
+function baseDestroyOptions({ bypassAllDefaultScopes, defaultScopesToBypass, cascade, skipHooks, } = {}) {
+    return {
+        bypassAllDefaultScopes: bypassAllDefaultScopes ?? scopeHelpers_js_1.DEFAULT_BYPASS_ALL_DEFAULT_SCOPES,
+        defaultScopesToBypass: defaultScopesToBypass ?? scopeHelpers_js_1.DEFAULT_DEFAULT_SCOPES_TO_BYPASS,
+        cascade: cascade ?? scopeHelpers_js_1.DEFAULT_CASCADE,
+        skipHooks: skipHooks ?? scopeHelpers_js_1.DEFAULT_SKIP_HOOKS,
+    };
+}
+function destroyOptions(options) {
+    return {
+        ...baseDestroyOptions(options),
+        reallyDestroy: false,
+    };
+}
+function undestroyOptions(options) {
+    return {
+        ...baseDestroyOptions(options),
+        defaultScopesToBypass: (0, scopeHelpers_js_1.addSoftDeleteScopeToUserScopes)(options?.defaultScopesToBypass),
+    };
+}
+function reallyDestroyOptions(options) {
+    return {
+        ...undestroyOptions(options),
+        reallyDestroy: true,
+    };
+}

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ensureSTITypeFieldIsSet;
+function ensureSTITypeFieldIsSet(dream) {
+    const Base = dream.constructor;
+    if (Base['sti'].value && !dream.type) {
+        ;
+        dream.type = Base['sti'].value;
+    }
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = executeDatabaseQuery;
+const index_js_1 = require("../../dream-application/index.js");
+const EnvInternal_js_1 = require("../../helpers/EnvInternal.js");
+async function executeDatabaseQuery(kyselyQuery, command) {
+    try {
+        return await kyselyQuery[command]();
+    }
+    catch (error) {
+        if (EnvInternal_js_1.default.isDebug) {
+            const sqlString = kyselyQuery.compile().sql;
+            const paramsString = kyselyQuery.compile().parameters.join(', ');
+            index_js_1.default.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/cjs/src/dream/internal/extractAssociationMetadataFromAssociationName.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = extractAssociationMetadataFromAssociationName;
+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/cjs/src/dream/internal/orderByDirection.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = orderByDirection;
+const kysely_1 = require("kysely");
+function orderByDirection(dir) {
+    switch (dir) {
+        case 'asc':
+        case null:
+            return (0, kysely_1.sql) `asc nulls first`;
+        case 'desc':
+            return (0, kysely_1.sql) `desc nulls last`;
+        default:
+            throw new Error(`Unrecognized orderBy direction: ${dir}`);
+    }
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = reload;
+const CannotReloadUnsavedDream_js_1 = require("../../errors/CannotReloadUnsavedDream.js");
+const Query_js_1 = require("../Query.js");
+async function reload(dream, txn = null) {
+    if (dream.isNewRecord)
+        throw new CannotReloadUnsavedDream_js_1.default(dream);
+    let query = new Query_js_1.default(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/cjs/src/dream/internal/runHooksFor.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = runHooksFor;
+exports.runHook = runHook;
+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);
+        }
+    }
+}
+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/cjs/src/dream/internal/runValidations.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = runValidations;
+const checkSingleValidation_js_1 = require("./checkSingleValidation.js");
+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 (!(0, checkSingleValidation_js_1.default)(dream, validation))
+        dream.addError(validation.column, validation.type);
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = safelyRunCommitHooks;
+const runHooksFor_js_1 = require("./runHooksFor.js");
+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 (0, runHooksFor_js_1.default)(hookType, dream, alreadyPersisted, beforeSaveChanges);
+    }
+}

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = saveDream;
+const luxon_1 = require("luxon");
+const index_js_1 = require("../../db/index.js");
+const ValidationError_js_1 = require("../../errors/ValidationError.js");
+const namespaceColumn_js_1 = require("../../helpers/namespaceColumn.js");
+const sqlAttributes_js_1 = require("../../helpers/sqlAttributes.js");
+const executeDatabaseQuery_js_1 = require("./executeDatabaseQuery.js");
+const runHooksFor_js_1 = require("./runHooksFor.js");
+const safelyRunCommitHooks_js_1 = require("./safelyRunCommitHooks.js");
+async function saveDream(dream, txn = null, { skipHooks = false } = {}) {
+    const db = txn?.kyselyTransaction || (0, index_js_1.default)('primary');
+    const alreadyPersisted = dream.isPersisted;
+    if (!skipHooks) {
+        if (alreadyPersisted)
+            await (0, runHooksFor_js_1.default)('beforeUpdate', dream, alreadyPersisted, null, txn);
+        else
+            await (0, runHooksFor_js_1.default)('beforeCreate', dream, alreadyPersisted, null, txn);
+        await (0, runHooksFor_js_1.default)('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_js_1.default(dream.constructor.name, dream.errors);
+    if (alreadyPersisted && !dream.isDirty)
+        return dream;
+    let query;
+    const now = luxon_1.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 = (0, sqlAttributes_js_1.default)(dream);
+    if (alreadyPersisted) {
+        query = db
+            .updateTable(dream.table)
+            .set(sqlifiedAttributes)
+            .where((0, namespaceColumn_js_1.default)(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 (0, executeDatabaseQuery_js_1.default)(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 (0, runHooksFor_js_1.default)('afterSave', dream, alreadyPersisted, beforeSaveChanges, txn);
+        if (alreadyPersisted)
+            await (0, runHooksFor_js_1.default)('afterUpdate', dream, alreadyPersisted, beforeSaveChanges, txn);
+        else
+            await (0, runHooksFor_js_1.default)('afterCreate', dream, alreadyPersisted, beforeSaveChanges, txn);
+        const commitHookType = alreadyPersisted ? 'afterUpdateCommit' : 'afterCreateCommit';
+        await (0, safelyRunCommitHooks_js_1.default)(dream, commitHookType, alreadyPersisted, beforeSaveChanges, txn);
+        await (0, safelyRunCommitHooks_js_1.default)(dream, 'afterSaveCommit', alreadyPersisted, beforeSaveChanges, txn);
+    }
+    return dream;
+}

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SKIP_HOOKS = exports.DEFAULT_DEFAULT_SCOPES_TO_BYPASS = exports.DEFAULT_CASCADE = exports.DEFAULT_BYPASS_ALL_DEFAULT_SCOPES = void 0;
+exports.addSoftDeleteScopeToUserScopes = addSoftDeleteScopeToUserScopes;
+const SoftDelete_js_1 = require("../../decorators/SoftDelete.js");
+const uniq_js_1 = require("../../helpers/uniq.js");
+exports.DEFAULT_BYPASS_ALL_DEFAULT_SCOPES = false;
+exports.DEFAULT_CASCADE = true;
+exports.DEFAULT_DEFAULT_SCOPES_TO_BYPASS = [];
+exports.DEFAULT_SKIP_HOOKS = false;
+function addSoftDeleteScopeToUserScopes(userScopes = []) {
+    return (0, uniq_js_1.default)([...userScopes, SoftDelete_js_1.SOFT_DELETE_SCOPE_NAME]);
+}

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = shouldBypassDefaultScope;
+function shouldBypassDefaultScope(scopeName, { bypassAllDefaultScopes = false, defaultScopesToBypass, }) {
+    if (bypassAllDefaultScopes)
+        return true;
+    if (!defaultScopesToBypass.length)
+        return false;
+    if (defaultScopesToBypass.includes(scopeName))
+        return true;
+    return false;
+}