@rvoh/dream 2.0.0-alpha.1 → 2.0.0-alpha.11

package/dist/cjs/src/Dream.js

@@ -1403,56 +1403,6 @@ export default class Dream {
     static preloadFor(serializerKey, modifierFn) {
         return this.query().preloadFor(serializerKey, modifierFn);
     }
-    /**
-     * Recursively preloads all Dream associations referenced by `rendersOne` and `rendersMany`
-     * in a DreamSerializer using left join preloading. This traverses the entire content tree
-     * of serializers to automatically load all necessary associations in a single query,
-     * eliminating N+1 query problems and removing the need to manually remember which
-     * associations to preload for serialization.
-     *
-     * This method decouples data loading code from data rendering code by having the serializer
-     * (rendering code) inform the query (loading code) about which associations are needed.
-     * As serializers evolve over time - adding new `rendersOne` and `rendersMany` calls or
-     * modifying existing ones - the loading code automatically adapts without requiring
-     * corresponding modifications to left join preload statements.
-     *
-     * This method analyzes the serializer (specified by `serializerKey` or 'default') and
-     * automatically left join preloads all associations that will be needed during serialization.
-     *
-     * Note: Left join preloading loads all data in a single SQL query but has trade-offs compared
-     * to regular preloading. See {@link Dream.leftJoinPreload} for details about limitations.
-     *
-     * ```ts
-     * // Instead of manually specifying all associations:
-     * await User.leftJoinPreload('posts', 'comments', 'replies').all()
-     *
-     * // Automatically left join preload everything needed for serialization:
-     * await User.leftJoinPreloadFor('summary').all()
-     *
-     * // Add where conditions to specific associations during left join preloading:
-     * await User.leftJoinPreloadFor('detailed', (associationName, dreamClass) => {
-     *   if (dreamClass.typeof(Post) && associationName === 'comments') {
-     *     return { and: { published: true } }
-     *   }
-     * }).all()
-     *
-     * // Skip left join preloading specific associations to handle them manually:
-     * await User.leftJoinPreloadFor('summary', (associationName, dreamClass) => {
-     *   if (dreamClass.typeof(User) && associationName === 'posts') {
-     *     return 'omit' // Handle posts preloading separately with custom logic
-     *   }
-     * })
-     * .preload('posts', { and: { featured: true } }) // Custom preloading instead
-     * .all()
-     * ```
-     *
-     * @param serializerKey - The serializer key to use for determining which associations to preload.
-     * @param modifierFn - Optional callback function to modify or omit specific associations during preloading. Called for each association with the Dream class and association name. Return an object with `and`, `andAny`, or `andNot` properties to add where conditions, return 'omit' to skip preloading that association (useful when you want to handle it manually), or return undefined to use default preloading
-     * @returns A Query with all serialization associations left join preloaded
-     */
-    static leftJoinPreloadFor(serializerKey, modifierFn) {
-        return this.query().leftJoinPreloadFor(serializerKey, modifierFn);
-    }
     /**
      * Returns a new Query instance with the provided
      * inner join statement attached
@@ -2667,7 +2617,7 @@ export default class Dream {
      *
      * ```ts
      *  const user = User.new({ email: 'how@yadoin' })
-     *  user.attributes()
+     *  user.getAttributes()
      *  // {
      *  //   email: 'how@yadoin',
      *  //   ...
@@ -2998,9 +2948,10 @@ export default class Dream {
      * @returns A boolean
      */
     equals(other) {
-        if (!(other instanceof Dream))
-            return false;
-        return this.comparisonKey === other.comparisonKey;
+        return (!!(other instanceof Dream) &&
+            this.isPersisted &&
+            other.isPersisted &&
+            this.comparisonKey === other.comparisonKey);
     }
     get comparisonKey() {
         return `${this.constructor.globalName}:${this.primaryKeyValue()}`;
@@ -3374,57 +3325,6 @@ export default class Dream {
     leftJoinLoad(...args) {
         return new LeftJoinLoadBuilder(this).leftJoinLoad(...args);
     }
-    /**
-     * Recursively loads all Dream associations referenced by `rendersOne` and `rendersMany`
-     * in a DreamSerializer. This traverses the entire content tree of serializers to automatically
-     * load all necessary associations, eliminating N+1 query problems and removing the need to
-     * manually remember which associations to preload for serialization.
-     *
-     * This method decouples data loading code from data rendering code by having the serializer
-     * (rendering code) inform the query (loading code) about which associations are needed.
-     * As serializers evolve over time - adding new `rendersOne` and `rendersMany` calls or
-     * modifying existing ones - the loading code automatically adapts without requiring
-     * corresponding modifications to preload statements.
-     *
-     * This method analyzes the serializer (specified by `serializerKey` or 'default') and
-     * automatically preloads all associations that will be needed during serialization.
-     *
-     * Note: Left join loading loads all data in a single SQL query but has trade-offs compared
-     * to regular preloading. See {@link Dream.leftJoinPreload} for details about limitations.
-     *
-     * ```ts
-     * // Instead of manually specifying all associations:
-     * await User.preload('posts', 'comments', 'replies').all()
-     *
-     * // Automatically preload everything needed for serialization:
-     * await user.leftJoinLoadFor('summary').execute()
-     *
-     * // Add where conditions to specific associations during preloading:
-     * await user.leftJoinLoadFor('detailed', (associationName, dreamClass) => {
-     *   if (dreamClass.typeof(Post) && associationName === 'comments') {
-     *     return { and: { published: true } }
-     *   }
-     * })
-     *    .execute()
-     *
-     * // Skip preloading specific associations to handle them manually:
-     * await user
-     *   .loadFor('summary', (associationName, dreamClass) => {
-     *     if (dreamClass.typeof(User) && associationName === 'posts') {
-     *       return 'omit' // Handle posts preloading separately with custom logic
-     *     }
-     *   })
-     *     .load('posts', { and: { featured: true } }) // Custom preloading
-     *     .execute()
-     * ```
-     *
-     * @param serializerKey - The serializer key to use for determining which associations to preload.
-     * @param modifierFn - Optional callback function to modify or omit specific associations during preloading. Called for each association with the Dream class and association name. Return an object with `and`, `andAny`, or `andNot` properties to add where conditions, return 'omit' to skip preloading that association (useful when you want to handle it manually), or return undefined to use default preloading
-     * @returns A Query with all serialization associations preloaded
-     */
-    leftJoinLoadFor(serializerKey, modifierFn) {
-        return new LeftJoinLoadBuilder(this)['leftJoinLoadFor'](serializerKey, modifierFn);
-    }
     /**
      * Returns true if the association specified has
      * been loaded on this instance

package/dist/cjs/src/cli/index.js

@@ -1,7 +1,9 @@
 import { InvalidArgumentError } from 'commander';
 import DreamBin from '../bin/index.js';
 import DreamApp from '../dream-app/index.js';
+import generateDream from '../helpers/cli/generateDream.js';
 import EnvInternal from '../helpers/EnvInternal.js';
+import loadRepl from '../helpers/loadRepl.js';
 import sspawn from '../helpers/sspawn.js';
 import DreamCliLogger from './logger/DreamCliLogger.js';
 const INDENT = '                  ';
@@ -61,6 +63,12 @@ ${INDENT}
 ${INDENT}        include the fully qualified model name, e.g., if the Coach model is in src/app/models/Health/Coach:
 ${INDENT}          Health/Coach:belongs_to`;
 export default class DreamCLI {
+    /**
+     * Starts the Dream console
+     */
+    static async loadRepl(context) {
+        return await loadRepl(context);
+    }
     /**
      * use this method for initializing a standalone dream application. If using Psychic and Dream together,
      * a different pattern is used, which leverages the `generateDreamCli` method instead.
@@ -81,6 +89,12 @@ export default class DreamCLI {
             onSync: () => { },
         });
     }
+    /**
+     * @internal
+     */
+    static async generateDream(opts) {
+        await generateDream(opts);
+    }
     /**
      * called under the hood when provisioning both psychic and dream applications.
      */
@@ -89,7 +103,7 @@ export default class DreamCLI {
             .command('generate:migration')
             .alias('g:migration')
             .description('create a new migration')
-            .argument('<migrationName>', 'end with -to-table-name to prepopulate with an alterTable command')
+            .argument('<migrationName>', 'end with -to-table-name or -from-table-name to prepopulate with an alterTable command')
             .option('--connection-name <connectionName>', 'the connection name you wish to use for your migration')
             .argument('[columnsWithTypes...]', columnsWithTypesDescriptionForMigration)
             .action(async (migrationName, columnsWithTypes, options) => {

package/dist/cjs/src/db/migration-helpers/DreamMigrationHelpers.js

@@ -17,7 +17,10 @@ export default class DreamMigrationHelpers {
      */
     static async renameTable(db, from, to) {
         await db.schema.alterTable(from).renameTo(to).execute();
-        await sql `ALTER SEQUENCE ${from}_id_seq RENAME TO ${to}_id_seq`.execute(db);
+        const fromSequenceName = `${from}_id_seq`;
+        const toSequenceName = `${to}_id_seq`;
+        const sqlStatement = `ALTER SEQUENCE ${fromSequenceName} RENAME TO ${toSequenceName}`;
+        await sql.raw(sqlStatement).execute(db);
     }
     /**
      * Unique indexes cannot be populated by the same value even within a transaction,
@@ -148,7 +151,8 @@ export default class DreamMigrationHelpers {
      */
     static newTransaction() { }
     /**
-     * Drop a value from an enum and replace it (or optionally remove it from array columns)
+     * Drop a value from an enum and replace it with a different enum already
+     * present in the enum type (or optionally remove it from array columns).
      *
      * @param db - The Kysely database object passed into the migration up/down function
      * @param __namedParameters - The options for dropping the enum value

package/dist/cjs/src/dream/DreamClassTransactionBuilder.js

@@ -362,54 +362,6 @@ export default class DreamClassTransactionBuilder {
     leftJoinPreload(...args) {
         return this.queryInstance().leftJoinPreload(...args);
     }
-    /**
-     * Recursively left-join-preloads all Dream associations referenced by `rendersOne` and `rendersMany`
-     * in a DreamSerializer. This traverses the entire content tree of serializers to automatically
-     * load all necessary associations, eliminating N+1 query problems and removing the need to
-     * manually remember which associations to preload for serialization.
-     *
-     * This method decouples data loading code from data rendering code by having the serializer
-     * (rendering code) inform the query (loading code) about which associations are needed.
-     * As serializers evolve over time - adding new `rendersOne` and `rendersMany` calls or
-     * modifying existing ones - the loading code automatically adapts without requiring
-     * corresponding modifications to preload statements.
-     *
-     * This method analyzes the serializer (specified by `serializerKey` or 'default') and
-     * automatically preloads all associations that will be needed during serialization.
-     *
-     * ```ts
-     * await ApplicationModel.transaction(async txn => {
-     *   // Instead of manually specifying all associations:
-     *   await User.txn(txn).preload('posts', 'comments', 'replies').all()
-     *
-     *   // Automatically preload everything needed for serialization:
-     *   await User.txn(txn).preloadFor('summary').all()
-     *
-     *   // Add where conditions to specific associations during preloading:
-     *   await User.txn(txn).leftJoinPreloadFor('detailed', (associationName, dreamClass) => {
-     *     if (dreamClass.typeof(Post) && associationName === 'comments') {
-     *       return { and: { published: true } }
-     *     }
-     *   }).all()
-     *
-     *   // Skip preloading specific associations to handle them manually:
-     *   await User.txn(txn).leftJoinPreloadFor('summary', (associationName, dreamClass) => {
-     *     if (dreamClass.typeof(User) && associationName === 'posts') {
-     *       return 'omit' // Handle posts preloading separately with custom logic
-     *     }
-     *   })
-     *   .preload('posts', { and: { featured: true } }) // Custom preloading
-     *   .all()
-     * })
-     * ```
-     *
-     * @param serializerKey - The serializer key to use for determining which associations to preload.
-     * @param modifierFn - Optional callback function to modify or omit specific associations during preloading. Called for each association with the Dream class and association name. Return an object with `and`, `andAny`, or `andNot` properties to add where conditions, return 'omit' to skip preloading that association (useful when you want to handle it manually), or return undefined to use default preloading
-     * @returns A Query with all serialization associations preloaded
-     */
-    leftJoinPreloadFor(serializerKey, modifierFn) {
-        return this.queryInstance().leftJoinPreloadFor(serializerKey, modifierFn);
-    }
     /**
      * Applies preload statement to a Query scoped to this model.
      * Upon instantiating records of this model type,

package/dist/cjs/src/dream/DreamInstanceTransactionBuilder.js

@@ -143,56 +143,6 @@ export default class DreamInstanceTransactionBuilder {
     leftJoinLoad(...args) {
         return new LeftJoinLoadBuilder(this.dreamInstance, this.dreamTransaction).leftJoinLoad(...args);
     }
-    /**
-     * Recursively loads all Dream associations referenced by `rendersOne` and `rendersMany`
-     * in a DreamSerializer. This traverses the entire content tree of serializers to automatically
-     * load all necessary associations, eliminating N+1 query problems and removing the need to
-     * manually remember which associations to preload for serialization.
-     *
-     * This method decouples data loading code from data rendering code by having the serializer
-     * (rendering code) inform the query (loading code) about which associations are needed.
-     * As serializers evolve over time - adding new `rendersOne` and `rendersMany` calls or
-     * modifying existing ones - the loading code automatically adapts without requiring
-     * corresponding modifications to preload statements.
-     *
-     * This method analyzes the serializer (specified by `serializerKey` or 'default') and
-     * automatically preloads all associations that will be needed during serialization.
-     *
-     * ```ts
-     * await ApplicationModel.transaction(async txn => {
-     *   // Instead of manually specifying all associations:
-     *   await User.txn(txn).preload('posts', 'comments', 'replies').all()
-     *
-     *   // Automatically preload everything needed for serialization:
-     *   await user.txn(txn).leftJoinLoadFor('summary').execute()
-     *
-     *   // Add where conditions to specific associations during preloading:
-     *   await user.txn(txn).leftJoinLoadFor('detailed', (associationName, dreamClass) => {
-     *     if (dreamClass.typeof(Post) && associationName === 'comments') {
-     *       return { and: { published: true } }
-     *     }
-     *   }).execute()
-     *
-     *   // Skip preloading specific associations to handle them manually:
-     *   await user
-     *     .txn(txn)
-     *     .leftJoinLoadFor('summary', (associationName, dreamClass) => {
-     *       if (dreamClass.typeof(User) && associationName === 'posts') {
-     *         return 'omit' // Handle posts preloading separately with custom logic
-     *       }
-     *     })
-     *     .load('posts', { and: { featured: true } }) // Custom preloading
-     *     .execute()
-     * })
-     * ```
-     *
-     * @param serializerKey - The serializer key to use for determining which associations to preload.
-     * @param modifierFn - Optional callback function to modify or omit specific associations during preloading. Called for each association with the Dream class and association name. Return an object with `and`, `andAny`, or `andNot` properties to add where conditions, return 'omit' to skip preloading that association (useful when you want to handle it manually), or return undefined to use default preloading
-     * @returns A Query with all serialization associations preloaded
-     */
-    leftJoinLoadFor(serializerKey, modifierFn) {
-        return new LeftJoinLoadBuilder(this.dreamInstance, this.dreamTransaction)['leftJoinLoadFor'](serializerKey, modifierFn);
-    }
     /**
      * Returns a new Query instance with the provided
      * inner join statement attached

package/dist/cjs/src/dream/LeftJoinLoadBuilder.js

@@ -38,55 +38,6 @@ export default class LeftJoinLoadBuilder {
         this.query = this.query.leftJoinPreload(...args);
         return this;
     }
-    /**
-     * Recursively loads all Dream associations referenced by `rendersOne` and `rendersMany`
-     * in a DreamSerializer. This traverses the entire content tree of serializers to automatically
-     * load all necessary associations, eliminating N+1 query problems and removing the need to
-     * manually remember which associations to preload for serialization.
-     *
-     * This method decouples data loading code from data rendering code by having the serializer
-     * (rendering code) inform the query (loading code) about which associations are needed.
-     * As serializers evolve over time - adding new `rendersOne` and `rendersMany` calls or
-     * modifying existing ones - the loading code automatically adapts without requiring
-     * corresponding modifications to preload statements.
-     *
-     * This method analyzes the serializer (specified by `serializerKey` or 'default') and
-     * automatically preloads all associations that will be needed during serialization.
-     *
-     * ```ts
-     * // Instead of manually specifying all associations:
-     * await User.preload('posts', 'comments', 'replies').all()
-     *
-     * // Automatically preload everything needed for serialization:
-     * await user.leftJoinLoadFor('summary').execute()
-     *
-     * // Add where conditions to specific associations during preloading:
-     * await user.leftJoinLoadFor('detailed', (associationName, dreamClass) => {
-     *   if (dreamClass.typeof(Post) && associationName === 'comments') {
-     *     return { and: { published: true } }
-     *   }
-     * })
-     *    .execute()
-     *
-     * // Skip preloading specific associations to handle them manually:
-     * await user
-     *   .leftJoinLoadFor('summary', (associationName, dreamClass) => {
-     *     if (dreamClass.typeof(User) && associationName === 'posts') {
-     *       return 'omit' // Handle posts preloading separately with custom logic
-     *     }
-     *   })
-     *     .load('posts', { and: { featured: true } }) // Custom preloading
-     *     .execute()
-     * ```
-     *
-     * @param serializerKey - The serializer key to use for determining which associations to preload.
-     * @param modifierFn - Optional callback function to modify or omit specific associations during preloading. Called for each association with the Dream class and association name. Return an object with `and`, `andAny`, or `andNot` properties to add where conditions, return 'omit' to skip preloading that association (useful when you want to handle it manually), or return undefined to use default preloading
-     * @returns A Query with all serialization associations preloaded
-     */
-    leftJoinLoadFor(serializerKey, modifierFn) {
-        this.query = this.query.leftJoinPreloadFor(serializerKey, modifierFn);
-        return this;
-    }
     /**
      * executes a load builder query, binding
      * all associations to their respective model

package/dist/cjs/src/dream/Query.js

@@ -530,63 +530,6 @@ export default class Query {
         });
         return query;
     }
-    /**
-     * Recursively preloads all Dream associations referenced by `rendersOne` and `rendersMany`
-     * in a DreamSerializer using left join preloading. This traverses the entire content tree
-     * of serializers to automatically load all necessary associations in a single query,
-     * eliminating N+1 query problems and removing the need to manually remember which
-     * associations to preload for serialization.
-     *
-     * This method decouples data loading code from data rendering code by having the serializer
-     * (rendering code) inform the query (loading code) about which associations are needed.
-     * As serializers evolve over time - adding new `rendersOne` and `rendersMany` calls or
-     * modifying existing ones - the loading code automatically adapts without requiring
-     * corresponding modifications to left join preload statements.
-     *
-     * This method analyzes the serializer (specified by `serializerKey` or 'default') and
-     * automatically left join preloads all associations that will be needed during serialization.
-     *
-     * Note: Left join preloading loads all data in a single SQL query but has trade-offs compared
-     * to regular preloading. See {@link Dream.leftJoinPreload} for details about limitations.
-     *
-     * ```ts
-     * // Instead of manually specifying all associations:
-     * await User.leftJoinPreload('posts', 'comments', 'replies').all()
-     *
-     * // Automatically left join preload everything needed for serialization:
-     * await User.leftJoinPreloadFor('summary').all()
-     *
-     * // Add where conditions to specific associations during left join preloading:
-     * await User.leftJoinPreloadFor('detailed', (associationName, dreamClass) => {
-     *   if (dreamClass.typeof(Post) && associationName === 'comments') {
-     *     return { and: { published: true } }
-     *   }
-     * })
-     *   .all()
-     *
-     * // Skip left join preloading specific associations to handle them manually:
-     * await User.leftJoinPreloadFor('summary', (associationName, dreamClass) => {
-     *   if (dreamClass.typeof(User) && associationName === 'posts') {
-     *     return 'omit' // Handle posts preloading separately with custom logic
-     *   }
-     * })
-     *   .preload('posts', { and: { featured: true } }) // Custom preloading instead
-     *   .all()
-     * ```
-     *
-     * @param serializerKey - The serializer key to use for determining which associations to preload.
-     * @param modifierFn - Optional callback function to modify or omit specific associations during preloading. Called for each association with the Dream class and association name. Return an object with `and`, `andAny`, or `andNot` properties to add where conditions, return 'omit' to skip preloading that association (useful when you want to handle it manually), or return undefined to use default preloading
-     * @returns A Query with all serialization associations left join preloaded
-     */
-    leftJoinPreloadFor(serializerKey, modifierFn) {
-        const preloadArgs = extractNestedPaths(this.dreamClass['serializationMap'](serializerKey));
-        let query = this;
-        const counter = { count: 0 };
-        preloadArgs.forEach(dreamClassAndAssociationNameTupleArray => {
-            query = query.leftJoinPreload(...convertDreamClassAndAssociationNameTupleArrayToPreloadArgs(dreamClassAndAssociationNameTupleArray, modifierFn, counter));
-        });
-        return query;
-    }
     /**
      * Returns a new Query instance, with the provided
      * joins statement attached

package/dist/cjs/src/dream/QueryDriver/Kysely.js

@@ -392,6 +392,8 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             return null;
     }
     /**
+     * @internal
+     *
      * Retrieves an array containing all records matching the Query.
      * Be careful using this, since it will attempt to pull every
      * record into memory at once. When querying might return a large

package/dist/cjs/src/dream-app/helpers/globalSerializerKeyFromPath.js

@@ -9,6 +9,6 @@ export default function globalSerializerKeyFromPath(filepath, dirPath, exportKey
     }
     else {
         const namePrefixFromPath = defaultExport.replace(/[^/]+\/?$/, '');
-        return namePrefixFromPath + exportKey.replace(new RegExp(`^${namePrefixFromPath.replace(/\/$/, '')}`), '');
+        return namePrefixFromPath + exportKey.replace(new RegExp(`^${namePrefixFromPath.replace(/\//g, '')}`), '');
     }
 }

package/dist/cjs/src/dream-app/index.js

@@ -8,9 +8,18 @@ import DreamAppInitMissingMissingProjectRoot from '../errors/dream-app/DreamAppI
 import CalendarDate from '../helpers/CalendarDate.js';
 import { DateTime, Settings } from '../helpers/DateTime.js';
 import EnvInternal from '../helpers/EnvInternal.js';
+import globalClassNameFromFullyQualifiedModelName from '../helpers/globalClassNameFromFullyQualifiedModelName.js';
+import absoluteDreamPath from '../helpers/path/absoluteDreamPath.js';
+import dreamPath from '../helpers/path/dreamPath.js';
+import standardizeFullyQualifiedModelName from '../helpers/standardizeFullyQualifiedModelName.js';
+import expandStiClasses from '../helpers/sti/expandStiClasses.js';
+import inferSerializerFromDreamOrViewModel, { inferSerializersFromDreamClassOrViewModelClass, } from '../serializer/helpers/inferSerializerFromDreamOrViewModel.js';
+import isDreamSerializer from '../serializer/helpers/isDreamSerializer.js';
+import serializerNameFromFullyQualifiedModelName from '../serializer/helpers/serializerNameFromFullyQualifiedModelName.js';
 import { cacheDreamApp, getCachedDreamAppOrFail } from './cache.js';
 import importModels, { getModelsOrFail } from './helpers/importers/importModels.js';
 import importSerializers, { getSerializersOrFail, setCachedSerializers, } from './helpers/importers/importSerializers.js';
+import lookupClassByGlobalName from './helpers/lookupClassByGlobalName.js';
 // this needs to be done top-level to ensure proper configuration
 Settings.defaultZone = 'UTC';
 export default class DreamApp {
@@ -44,6 +53,47 @@ export default class DreamApp {
         });
         return dreamApp;
     }
+    /**
+     * Since javascript is inherently vulnerable to circular dependencies,
+     * this function provides a workaround by enabling you to dynamically
+     * bring in classes that, if imported directly, would result in circular
+     * dependency issues.
+     *
+     * NOTE: You should only use this as a last resort, since it can create quite
+     * a headache for you when leaning into your editor to apply renames, etc...
+     *
+     * @param name - the global name you are trying to look up, i.e. 'User', or 'UserSerializer'.
+     *
+     * @example
+     * ```ts
+     * // this pattern is safe from circular imports, since _UserSerializer
+     * // is only being used to type something else, which will not result
+     * // in the circular dependency issue.
+     *
+     * import _UserSerializer from '../serializers/UserSerializer.js'
+     * const UserSerializer = PsychicApp.lookupClassByGlobalName('UserSerializer') as _UserSerializer
+     * ```
+     */
+    static lookupClassByGlobalName(name) {
+        return lookupClassByGlobalName(name);
+    }
+    /**
+     * @internal
+     *
+     */
+    static get system() {
+        return {
+            globalClassNameFromFullyQualifiedModelName,
+            absoluteDreamPath,
+            dreamPath,
+            standardizeFullyQualifiedModelName,
+            expandStiClasses,
+            inferSerializerFromDreamOrViewModel,
+            inferSerializersFromDreamClassOrViewModelClass,
+            isDreamSerializer,
+            serializerNameFromFullyQualifiedModelName,
+        };
+    }
     /**
      * @internal
      *

package/dist/cjs/src/helpers/cli/generateDreamContent.js

@@ -11,9 +11,10 @@ export default function generateDreamContent({ fullyQualifiedModelName, columnsW
     fullyQualifiedModelName = standardizeFullyQualifiedModelName(fullyQualifiedModelName);
     const modelClassName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedModelName);
     let parentModelClassName;
-    const dreamImports = ['Decorators', 'DreamColumn'];
+    const dreamTypeImports = ['DreamColumn'];
+    const dreamImports = ['Decorators'];
     if (serializer)
-        dreamImports.push('DreamSerializers');
+        dreamTypeImports.push('DreamSerializers');
     const isSTI = !!fullyQualifiedParentName;
     if (isSTI) {
         fullyQualifiedParentName = standardizeFullyQualifiedModelName(fullyQualifiedParentName);
@@ -49,9 +50,8 @@ public ${associationForeignKey}: DreamColumn<${modelClassName}, '${associationNa
             case 'has_many':
                 return '';
             case 'encrypted':
-                dreamImports.push('Encrypted');
                 return `
-@Encrypted()
+@deco.Encrypted()
 public ${camelize(attributeName)}: ${getAttributeType(attribute, modelClassName)}\
 `;
             default:
@@ -77,7 +77,7 @@ public ${camelize(attributeName)}: ${getAttributeType(attribute, modelClassName)
         timestamps = timestamps.replace(/\n$/, '');
     const tableName = snakeify(pluralize(fullyQualifiedModelName.replace(/\//g, '_')));
     return `\
-import { ${uniq(dreamImports).join(', ')} } from '@rvoh/dream'${uniq(modelImportStatements).join('')}
+${dreamImports.length ? `import { ${uniq(dreamImports).join(', ')} } from '@rvoh/dream'\n` : ''}import { ${uniq(dreamTypeImports).join(', ')} } from '@rvoh/dream/types'${uniq(modelImportStatements).join('')}
 
 const deco = new Decorators<typeof ${modelClassName}>()
 

package/dist/cjs/src/helpers/cli/generateFactoryContent.js

@@ -6,7 +6,8 @@ import uniq from '../uniq.js';
 import { optionalFromDescriptors } from './generateMigrationContent.js';
 export default function generateFactoryContent({ fullyQualifiedModelName, columnsWithTypes, }) {
     fullyQualifiedModelName = standardizeFullyQualifiedModelName(fullyQualifiedModelName);
-    const dreamImports = ['UpdateableProperties'];
+    const dreamTypeImports = ['UpdateableProperties'];
+    const dreamImports = [];
     const additionalImports = [];
     const belongsToNames = [];
     const belongsToTypedNames = [];
@@ -23,6 +24,8 @@ export default function generateFactoryContent({ fullyQualifiedModelName, column
         if (optional)
             continue;
         const attributeVariable = camelize(attributeName.replace(/\//g, ''));
+        if (/^type$/.test(attributeName))
+            continue;
         if (/(_type|_id)$/.test(attributeName))
             continue;
         if (!attributeType)
@@ -101,7 +104,7 @@ export default function generateFactoryContent({ fullyQualifiedModelName, column
     const relativePath = absoluteDreamPath('models', fullyQualifiedModelName);
     const modelClassName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedModelName);
     return `\
-import { ${uniq(dreamImports).join(', ')} } from '@rvoh/dream'
+${dreamImports.length ? `import { ${uniq(dreamImports).join(', ')} } from '@rvoh/dream'\n` : ''}import { ${uniq(dreamTypeImports).join(', ')} } from '@rvoh/dream/types'
 import ${modelClassName} from '${relativePath}'${additionalImports.length ? '\n' + uniq(additionalImports).join('\n') : ''}
 ${counterVariableIncremented ? '\nlet counter = 0\n' : ''}
 export default async function create${modelClassName}(attrs: UpdateableProperties<${modelClassName}> = {}) {

package/dist/cjs/src/helpers/cli/generateMigrationContent.js

@@ -11,7 +11,12 @@ export default function generateMigrationContent({ connectionName = 'default', t
     const checkConstraints = [];
     const { columnDefs, columnDrops, indexDefs, indexDrops } = columnsWithTypes.reduce((acc, attributeDeclaration) => {
         const { columnDefs, columnDrops, indexDefs, indexDrops } = acc;
-        const [nonStandardAttributeName, attributeType, ...descriptors] = attributeDeclaration.split(':');
+        const [nonStandardAttributeName, _attributeType, ...descriptors] = attributeDeclaration.split(':');
+        /**
+         * Automatically set email columns to citext since different casings of
+         * email address are the same email address
+         */
+        const attributeType = nonStandardAttributeName === 'email' ? 'citext' : _attributeType;
         const userWantsThisOptional = optionalFromDescriptors(descriptors);
         // when creating a migration for an STI child, we don't want to include notNull;
         // instead, we'll add a check constraint that uses the STI child class name
@@ -116,9 +121,9 @@ export async function down(db: Kysely<any>): Promise<void> {
         ? `  await DreamMigrationHelpers.createExtension(db, 'citext')\n\n`
         : '';
     const kyselyImports = ['Kysely', 'sql'];
-    const dreamImports = [];
+    const dreamDbImports = [];
     if (requireCitextExtension)
-        dreamImports.push('DreamMigrationHelpers');
+        dreamDbImports.push('DreamMigrationHelpers');
     const newlineIndent = '\n  ';
     const newlineDoubleIndent = '\n    ';
     const doubleNewlineIndent = '\n\n  ';
@@ -127,7 +132,7 @@ export async function down(db: Kysely<any>): Promise<void> {
         ? newlineDoubleIndent + columnDrops.join(newlineDoubleIndent) + newlineDoubleIndent
         : '';
     return `\
-${dreamImports.length ? `import { ${dreamImports.join(', ')} } from '@rvoh/dream'\n` : ''}import { ${kyselyImports.join(', ')} } from 'kysely'
+${dreamDbImports.length ? `import { ${dreamDbImports.join(', ')} } from '@rvoh/dream/db'\n` : ''}import { ${kyselyImports.join(', ')} } from 'kysely'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export async function up(db: Kysely<any>): Promise<void> {
@@ -231,6 +236,8 @@ function generateColumnStr(attributeName, attributeType, descriptors, { omitInli
         returnStr += ', col => col';
     if (notNull)
         returnStr += '.notNull()';
+    if (attributeName === 'email' || /token$/.test(attributeName))
+        returnStr += '.unique()';
     if (providedDefault)
         returnStr += `.defaultTo('${providedDefault}')`;
     else if (isArray)