@rvoh/dream 0.31.5 → 0.32.1

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

@@ -2,14 +2,19 @@ import pluralize from 'pluralize-esm';
 import InvalidDecimalFieldPassedToGenerator from '../../errors/InvalidDecimalFieldPassedToGenerator.js';
 import foreignKeyTypeFromPrimaryKey from '../db/foreignKeyTypeFromPrimaryKey.js';
 import snakeify from '../snakeify.js';
+const STI_TYPE_COLUMN_NAME = 'type';
+const COLUMNS_TO_INDEX = [STI_TYPE_COLUMN_NAME];
+const NOT_NULL_COLUMNS = [STI_TYPE_COLUMN_NAME];
 export default function generateMigrationContent({ table, columnsWithTypes = [], primaryKeyType = 'bigserial', createOrAlter = 'create', } = {}) {
     const altering = createOrAlter === 'alter';
     let requireCitextExtension = false;
-    const { columnDefs, columnDrops } = columnsWithTypes.reduce((acc, attribute) => {
-        const { columnDefs, columnDrops } = acc;
+    const { columnDefs, columnDrops, indexDefs, indexDrops } = columnsWithTypes.reduce((acc, attribute) => {
+        const { columnDefs, columnDrops, indexDefs, indexDrops } = acc;
         const [nonStandardAttributeName, attributeType, ...descriptors] = attribute.split(':');
         let attributeName = snakeify(nonStandardAttributeName);
-        if (['has_one', 'has_many'].includes(attributeType))
+        if (attributeName === undefined)
+            return acc;
+        if (attributeType !== undefined && ['has_one', 'has_many'].includes(attributeType))
             return acc;
         if (attributeType === 'citext')
             requireCitextExtension = true;
@@ -35,12 +40,23 @@ export default function generateMigrationContent({ table, columnsWithTypes = [],
                 columnDefs.push(generateColumnStr(`encrypted_${attributeName}`, 'text', descriptors));
                 break;
             default:
-                columnDefs.push(generateColumnStr(attributeName, coercedAttributeType, descriptors));
+                if (coercedAttributeType !== undefined) {
+                    columnDefs.push(generateColumnStr(attributeName, coercedAttributeType, descriptors));
+                }
                 break;
         }
         columnDrops.push(`.dropColumn('${attributeName}')`);
+        if (COLUMNS_TO_INDEX.includes(attributeName)) {
+            const indexName = `${table}_${attributeName}`;
+            indexDefs.push(`await db.schema
+    .createIndex('${indexName}')
+    .on('${table}')
+    .column('${attributeName}')
+    .execute()`);
+            indexDrops.push(`await db.schema.dropIndex('${indexName}').execute()`);
+        }
         return acc;
-    }, { columnDefs: [], columnDrops: [] });
+    }, { columnDefs: [], columnDrops: [], indexDefs: [], indexDrops: [] });
     if (!table) {
         return `\
 import { Kysely, sql } from 'kysely'
@@ -61,28 +77,31 @@ export async function down(db: Kysely<any>): Promise<void> {
     const dreamImports = [];
     if (requireCitextExtension)
         dreamImports.push('DreamMigrationHelpers');
-    const newline = '\n    ';
-    const columnDefLines = columnDefs.length ? newline + columnDefs.join(newline) : '';
-    const columnDropLines = columnDrops.length ? newline + columnDrops.join(newline) + newline : '';
+    const newlineIndent = '\n  ';
+    const newlineDoubleIndent = '\n    ';
+    const columnDefLines = columnDefs.length ? newlineDoubleIndent + columnDefs.join(newlineDoubleIndent) : '';
+    const columnDropLines = columnDrops.length
+        ? newlineDoubleIndent + columnDrops.join(newlineDoubleIndent) + newlineDoubleIndent
+        : '';
     return `\
 ${dreamImports.length ? `import { ${dreamImports.join(', ')} } from '@rvoh/dream'\n` : ''}import { ${kyselyImports.join(', ')} } from 'kysely'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export async function up(db: Kysely<any>): Promise<void> {
 ${citextExtension}${generateEnumStatements(columnsWithTypes)}  await db.schema
-    .${altering ? 'alterTable' : 'createTable'}('${table}')${altering ? '' : newline + generateIdStr({ primaryKeyType })}${columnDefLines}${altering
+    .${altering ? 'alterTable' : 'createTable'}('${table}')${altering ? '' : newlineDoubleIndent + generateIdStr({ primaryKeyType })}${columnDefLines}${altering
         ? ''
-        : newline +
+        : newlineDoubleIndent +
             ".addColumn('created_at', 'timestamp', col => col.notNull())" +
-            newline +
+            newlineDoubleIndent +
             ".addColumn('updated_at', 'timestamp', col => col.notNull())"}
-    .execute()
+    .execute()${indexDefs.length ? `\n${newlineIndent}` : ''}${indexDefs.join(newlineDoubleIndent)}
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export async function down(db: Kysely<any>): Promise<void> {
-  ${altering
-        ? `await db.schema${newline}.alterTable('${table}')${columnDropLines}.execute()`
+  ${indexDrops.join(newlineIndent)}${indexDrops.length ? newlineIndent : ''}${altering
+        ? `await db.schema${newlineDoubleIndent}.alterTable('${table}')${columnDropLines}.execute()`
         : `await db.schema.dropTable('${table}').execute()`}${generateEnumDropStatements(columnsWithTypes)}
 }\
 `;
@@ -109,7 +128,10 @@ function generateEnumStatements(columnsWithTypes) {
     const enumStatements = columnsWithTypes.filter(attribute => /:enum:.*:/.test(attribute));
     const finalStatements = enumStatements.map(statement => {
         const enumName = statement.split(':')[2];
-        const columnsWithTypes = statement.split(':')[3].split(/,\s{0,}/);
+        const columnsWithTypesString = statement.split(':')[3];
+        if (columnsWithTypesString === undefined)
+            return '';
+        const columnsWithTypes = columnsWithTypesString.split(/,\s{0,}/);
         return `  await db.schema
     .createType('${enumName}_enum')
     .asEnum([
@@ -132,7 +154,11 @@ function generateBooleanStr(attributeName) {
 }
 function generateEnumStr(attribute) {
     const computedAttributeType = enumAttributeType(attribute);
-    return `.addColumn('${attribute.split(':')[0]}', ${computedAttributeType})`;
+    const attributeName = attribute.split(':')[0];
+    if (attributeName === undefined)
+        return '';
+    const notNull = NOT_NULL_COLUMNS.includes(attributeName);
+    return `.addColumn('${attributeName}', ${computedAttributeType}${notNull ? ', col => col.notNull()' : ''})`;
 }
 function generateDecimalStr(attribute) {
     const [, , ...descriptors] = attribute.split(':');
@@ -145,15 +171,21 @@ function generateColumnStr(attributeName, attributeType, descriptors) {
     let returnStr = `.addColumn('${attributeName}', ${attributeTypeString(attributeType)}`;
     const providedDefaultArg = descriptors.find(d => /^default\(/.test(d));
     const providedDefault = providedDefaultArg?.replace(/^default\(/, '')?.replace(/\)$/, '');
-    const hasExtraValues = descriptors.includes('primary') || providedDefault;
+    const notNull = NOT_NULL_COLUMNS.includes(attributeName);
+    const hasExtraValues = providedDefault || notNull;
     if (hasExtraValues)
         returnStr += ', col => col';
-    if (descriptors.includes('primary'))
-        returnStr += `.defaultTo('${providedDefault}')`;
+    if (notNull)
+        returnStr += '.notNull()';
     if (providedDefault)
         returnStr += `.defaultTo('${providedDefault}')`;
-    // TODO: handle index
-    return `${returnStr}${hasExtraValues ? '))' : ')'}`;
+    returnStr = `${returnStr})`;
+    if (attributeName === STI_TYPE_COLUMN_NAME)
+        returnStr = `// CONSIDER: when using type for STI, always use an enum
+    // Try using the enum syntax in your generator, e.g.:
+    // yarn psy g:model Balloon type:enum:balloon_type:latex,mylar
+    ${returnStr}`;
+    return returnStr;
 }
 function attributeTypeString(attributeType) {
     const attributeTypesRequiringSql = ['citext'];

package/dist/esm/src/helpers/cli/generateSerializerContent.js

@@ -1,6 +1,5 @@
 import camelize from '../camelize.js';
 import globalClassNameFromFullyQualifiedModelName from '../globalClassNameFromFullyQualifiedModelName.js';
-import pascalize from '../pascalize.js';
 import relativeDreamPath from '../path/relativeDreamPath.js';
 import serializerNameFromFullyQualifiedModelName from '../serializerNameFromFullyQualifiedModelName.js';
 import standardizeFullyQualifiedModelName from '../standardizeFullyQualifiedModelName.js';
@@ -71,6 +70,8 @@ export default class ${defaultSerialzerClassName}${dataTypeCapture} extends ${de
 ${columnsWithTypes
         .map(attr => {
         const [name, type] = attr.split(':');
+        if (name === undefined)
+            return '';
         const fullyQualifiedAssociatedModelName = standardizeFullyQualifiedModelName(name);
         const associatedModelName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedAssociatedModelName);
         const propertyName = camelize(associatedModelName);
@@ -81,7 +82,7 @@ ${columnsWithTypes
                 return '';
             default:
                 return `  @Attribute(${modelClassName}${attributeOptionsSpecifier(type, attr)})
-  public ${propertyName}: ${jsType(type, attr, propertyName, modelClassName)}`;
+  public ${propertyName}: ${`DreamColumn<${modelClassName}, '${propertyName}'>`}`;
         }
     })
         .join('\n\n  ')}
@@ -96,29 +97,6 @@ function attributeOptionsSpecifier(type, attr) {
             return '';
     }
 }
-function jsType(type, originalAttribute, propertyName, modelClass = null) {
-    if (modelClass)
-        return `DreamColumn<${modelClass}, '${propertyName}'>`;
-    switch (type) {
-        case 'date':
-            return 'CalendarDate';
-        case 'datetime':
-            return 'DateTime';
-        case 'decimal':
-        case 'integer':
-        case 'number':
-            return 'number';
-        case 'string':
-        case 'text':
-        case 'bigint':
-        case 'uuid':
-            return 'string';
-        case 'enum':
-            return pascalize(originalAttribute.split(':')[2]) + 'Enum';
-        default:
-            return 'any';
-    }
-}
 function importStatementForSerializer(originModelName, destinationModelName) {
     return `\nimport ${globalClassNameFromFullyQualifiedModelName(serializerNameFromFullyQualifiedModelName(destinationModelName))}, { ${globalClassNameFromFullyQualifiedModelName(serializerNameFromFullyQualifiedModelName(destinationModelName, 'summary'))} } from '${relativeDreamPath('serializers', 'serializers', originModelName, destinationModelName)}'`;
 }

package/dist/esm/src/helpers/objectPathsToArrays.js

@@ -6,7 +6,8 @@ export default function objectPathsToArrays(obj) {
 }
 function depthFirstSearch(obj, workingPath, completePaths) {
     return Object.keys(obj).forEach(key => {
-        if (Object.keys(obj[key]).length) {
+        const subObj = obj[key];
+        if (subObj && Object.keys(subObj).length) {
             depthFirstSearch(obj[key], [...workingPath, key], completePaths);
         }
         else {

package/dist/types/src/Dream.d.ts

@@ -1440,7 +1440,7 @@ export default class Dream {
      *
      * ```ts
      * class User extends ApplicationModel {
-     *   public get table() {
+     *   public override get table() {
      *     return 'users' as const
      *   }
      * }

package/dist/types/src/cli/logger/loggable/DreamCliLoggable.d.ts

@@ -4,9 +4,9 @@ export default class DreamCliLoggable {
     logPrefixColor: DreamCliForegroundColor | undefined;
     logPrefixBgColor: DreamCliBgColor | undefined;
     constructor({ logPrefix, logPrefixColor, logPrefixBgColor, }: {
-        logPrefix?: string;
-        logPrefixColor?: DreamCliForegroundColor;
-        logPrefixBgColor?: DreamCliBgColor;
+        logPrefix?: string | undefined;
+        logPrefixColor?: DreamCliForegroundColor | undefined;
+        logPrefixBgColor?: DreamCliBgColor | undefined;
     });
     render(): void;
     get colorizedLogPrefix(): string;

package/dist/types/src/cli/logger/loggable/DreamCliLoggableText.d.ts

@@ -5,11 +5,11 @@ export default class DreamCliLoggableText extends DreamCliLoggable {
     private color;
     private bgColor;
     constructor(text: string, { logPrefix, color, bgColor, logPrefixColor, logPrefixBgColor, }: {
-        logPrefix?: string;
-        color?: DreamCliForegroundColor;
-        bgColor?: DreamCliBgColor;
-        logPrefixColor?: DreamCliForegroundColor;
-        logPrefixBgColor?: DreamCliBgColor;
+        logPrefix?: string | undefined;
+        color?: DreamCliForegroundColor | undefined;
+        bgColor?: DreamCliBgColor | undefined;
+        logPrefixColor?: DreamCliForegroundColor | undefined;
+        logPrefixBgColor?: DreamCliBgColor | undefined;
     });
     render(): void;
 }

package/dist/types/src/cli/logger/loggable/colorize.d.ts

@@ -1,5 +1,5 @@
 import { DreamCliBgColor, DreamCliForegroundColor } from '../../../types/logger.js';
-export default function colorize(text: string, { color, bgColor }: {
-    color?: DreamCliForegroundColor;
-    bgColor?: DreamCliBgColor;
+export default function colorize(text: string, { color, bgColor, }: {
+    color?: DreamCliForegroundColor | undefined;
+    bgColor?: DreamCliBgColor | undefined;
 }): string;

package/dist/types/src/db/ConnectedToDB.d.ts

@@ -7,7 +7,7 @@ export default class ConnectedToDB<DreamInstance extends Dream> {
     dreamInstance: DreamInstance;
     protected readonly dreamClass: DreamConstructorType<DreamInstance>;
     protected dreamTransaction: DreamTransaction<Dream> | null;
-    protected connectionOverride?: DbConnectionType;
+    protected connectionOverride: DbConnectionType | undefined;
     /**
      * @internal
      *
@@ -21,6 +21,6 @@ export default class ConnectedToDB<DreamInstance extends Dream> {
 }
 export interface ConnectedToDBOpts {
     transaction?: DreamTransaction<Dream> | null | undefined;
-    connection?: DbConnectionType;
-    innerJoinDreamClasses?: readonly (typeof Dream)[];
+    connection?: DbConnectionType | undefined;
+    innerJoinDreamClasses?: readonly (typeof Dream)[] | undefined;
 }

package/dist/types/src/decorators/field/sortable/helpers/decrementScopedRecordsGreaterThanPosition.d.ts

@@ -4,5 +4,5 @@ export default function decrementPositionForScopedRecordsGreaterThanPosition(pos
     dream: Dream;
     positionField: string;
     query: Query<Dream>;
-    scope?: string | string[];
+    scope: string | string[] | undefined;
 }): Promise<void>;

package/dist/types/src/decorators/field/sortable/helpers/positionIsInvalid.d.ts

@@ -4,5 +4,5 @@ export default function positionIsInvalid({ query, dream, position, scope, }: {
     query: Query<Dream>;
     dream: Dream;
     position: number | null | undefined;
-    scope?: string | string[];
+    scope: string | string[] | undefined;
 }): Promise<boolean>;

package/dist/types/src/decorators/field/sortable/helpers/setPosition.d.ts

@@ -8,7 +8,7 @@ export default function setPosition({ position, previousPosition, dream, positio
     previousPosition?: number;
     positionField: string;
     query: Query<Dream>;
-    scope?: string | string[];
-    txn?: DreamTransaction<any>;
+    scope: string | string[] | undefined;
+    txn: DreamTransaction<any> | undefined;
 }): Promise<void>;
 export declare function applySortableScopesToQuery<QB extends UpdateQueryBuilder<any, string, string, any> | SelectQueryBuilder<any, any, any>>(dream: Dream, kyselyQuery: QB, whereValueCB: (column: string) => any, scope?: string | string[]): QB;

package/dist/types/src/decorators/field/sortable/hooks/afterSortableCreate.d.ts

@@ -5,6 +5,6 @@ export default function afterSortableCreate({ positionField, dream, query, txn,
     positionField: string;
     dream: Dream;
     query: Query<Dream>;
-    txn?: DreamTransaction<any>;
-    scope?: string | string[];
+    txn?: DreamTransaction<any> | undefined;
+    scope: string | string[] | undefined;
 }): Promise<void>;

package/dist/types/src/decorators/field/sortable/hooks/afterSortableDestroy.d.ts

@@ -4,5 +4,5 @@ export default function afterSortableDestroy({ positionField, dream, query, scop
     positionField: string;
     dream: Dream;
     query: Query<Dream>;
-    scope?: string | string[];
+    scope: string | string[] | undefined;
 }): Promise<void>;

package/dist/types/src/decorators/field/sortable/hooks/afterSortableUpdate.d.ts

@@ -5,6 +5,6 @@ export default function afterUpdateSortable({ positionField, dream, query, txn,
     positionField: string;
     dream: Dream;
     query: Query<Dream>;
-    txn?: DreamTransaction<any>;
-    scope?: string | string[];
+    txn?: DreamTransaction<any> | undefined;
+    scope: string | string[] | undefined;
 }): Promise<void>;

package/dist/types/src/decorators/field/sortable/hooks/beforeSortableSave.d.ts

@@ -4,5 +4,5 @@ export default function beforeSortableSave({ positionField, dream, query, scope,
     positionField: string;
     dream: Dream;
     query: Query<Dream>;
-    scope?: string | string[];
+    scope: string | string[] | undefined;
 }): Promise<void>;

package/dist/types/src/decorators/field-or-getter/Virtual.d.ts

@@ -2,5 +2,5 @@ import { SerializableTypes } from '../../serializer/decorators/attribute.js';
 export default function Virtual(type?: SerializableTypes): any;
 export interface VirtualAttributeStatement {
     property: string;
-    type?: SerializableTypes;
+    type: SerializableTypes | undefined;
 }

package/dist/types/src/dream/Query.d.ts

@@ -885,8 +885,8 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      * @returns The number of records that were removed
      */
     destroy({ skipHooks, cascade, }?: {
-        skipHooks?: boolean;
-        cascade?: boolean;
+        skipHooks?: boolean | undefined;
+        cascade?: boolean | undefined;
     }): Promise<number>;
     /**
      * Destroys all records matching the Query,
@@ -1073,29 +1073,29 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
     private invertOrder;
 }
 export interface QueryOpts<DreamInstance extends Dream, ColumnType extends DreamColumnNames<DreamInstance> = DreamColumnNames<DreamInstance>, Schema extends DreamInstance['schema'] = DreamInstance['schema'], DB extends DreamInstance['DB'] = DreamInstance['DB'], PassthroughColumns extends PassthroughColumnNames<DreamInstance> = PassthroughColumnNames<DreamInstance>> {
-    baseSqlAlias?: TableOrAssociationName<Schema>;
-    baseSelectQuery?: Query<any, any> | null;
-    passthroughOnStatement?: PassthroughOnClause<PassthroughColumns> | null;
-    where?: readonly WhereStatement<DB, Schema, any>[] | null;
-    whereNot?: readonly WhereStatement<DB, Schema, any>[] | null;
-    limit?: LimitStatement | null;
-    offset?: OffsetStatement | null;
-    or?: WhereStatement<DB, Schema, any>[][] | null;
-    order?: OrderQueryStatement<ColumnType>[] | null;
-    loadFromJoins?: boolean;
-    preloadStatements?: RelaxedPreloadStatement;
-    preloadOnStatements?: RelaxedPreloadOnStatement<DB, Schema>;
-    distinctColumn?: ColumnType | null;
-    innerJoinDreamClasses?: readonly (typeof Dream)[];
-    innerJoinStatements?: RelaxedJoinStatement;
-    innerJoinOnStatements?: RelaxedJoinOnStatement<DB, Schema>;
-    leftJoinStatements?: RelaxedJoinStatement;
-    leftJoinOnStatements?: RelaxedJoinOnStatement<DB, Schema>;
-    bypassAllDefaultScopes?: boolean;
-    bypassAllDefaultScopesExceptOnAssociations?: boolean;
-    defaultScopesToBypass?: AllDefaultScopeNames<DreamInstance>[];
-    defaultScopesToBypassExceptOnAssociations?: DefaultScopeName<DreamInstance>[];
+    baseSqlAlias?: TableOrAssociationName<Schema> | undefined;
+    baseSelectQuery?: Query<any, any> | null | undefined;
+    passthroughOnStatement?: PassthroughOnClause<PassthroughColumns> | null | undefined;
+    where?: readonly WhereStatement<DB, Schema, any>[] | null | undefined;
+    whereNot?: readonly WhereStatement<DB, Schema, any>[] | null | undefined;
+    limit?: LimitStatement | null | undefined;
+    offset?: OffsetStatement | null | undefined;
+    or?: WhereStatement<DB, Schema, any>[][] | null | undefined;
+    order?: OrderQueryStatement<ColumnType>[] | null | undefined;
+    loadFromJoins?: boolean | undefined;
+    preloadStatements?: RelaxedPreloadStatement | undefined;
+    preloadOnStatements?: RelaxedPreloadOnStatement<DB, Schema> | undefined;
+    distinctColumn?: ColumnType | null | undefined;
+    innerJoinDreamClasses?: readonly (typeof Dream)[] | undefined;
+    innerJoinStatements?: RelaxedJoinStatement | undefined;
+    innerJoinOnStatements?: RelaxedJoinOnStatement<DB, Schema> | undefined;
+    leftJoinStatements?: RelaxedJoinStatement | undefined;
+    leftJoinOnStatements?: RelaxedJoinOnStatement<DB, Schema> | undefined;
+    bypassAllDefaultScopes?: boolean | undefined;
+    bypassAllDefaultScopesExceptOnAssociations?: boolean | undefined;
+    defaultScopesToBypass?: AllDefaultScopeNames<DreamInstance>[] | undefined;
+    defaultScopesToBypassExceptOnAssociations?: DefaultScopeName<DreamInstance>[] | undefined;
     transaction?: DreamTransaction<Dream> | null | undefined;
-    connection?: DbConnectionType;
-    shouldReallyDestroy?: boolean;
+    connection?: DbConnectionType | undefined;
+    shouldReallyDestroy?: boolean | undefined;
 }

package/dist/types/src/dream/internal/destroyOptions.d.ts

@@ -8,21 +8,21 @@ export interface DestroyOptions<DreamInstance extends Dream> {
      * If true, bypasses all default scopes when destroying the instance.
      * Defaults to false.
      */
-    bypassAllDefaultScopes?: boolean;
+    bypassAllDefaultScopes?: boolean | undefined;
     /**
      * An array of default scope names to bypass when destroying the instance.
      * Defaults to an empty array.
      */
-    defaultScopesToBypass?: AllDefaultScopeNames<DreamInstance>[];
+    defaultScopesToBypass?: AllDefaultScopeNames<DreamInstance>[] | undefined;
     /**
      * If false, skips destroying associations marked `dependent: 'destroy'`. Defaults to true.
      */
-    cascade?: boolean;
+    cascade?: boolean | undefined;
     /**
      * If true, skips applying model hooks during the destroy operation.
      * Defaults to false.
      */
-    skipHooks?: boolean;
+    skipHooks?: boolean | undefined;
 }
 export declare function destroyOptions<DreamInstance extends Dream>(options: DestroyOptions<DreamInstance>): {
     reallyDestroy: boolean;

package/dist/types/src/dream/internal/similarity/SimilarityBuilder.d.ts

@@ -28,11 +28,11 @@ export default class SimilarityBuilder<DreamInstance extends Dream, DB extends D
     private rankSQLAlias;
 }
 export interface SimilarityBuilderOpts<DreamInstance extends Dream, DB extends DreamInstance['DB'] = DreamInstance['DB'], Schema extends DreamInstance['schema'] = DreamInstance['schema']> {
-    where?: WhereStatement<DB, Schema, any>[];
-    whereNot?: WhereStatement<DB, Schema, any>[];
-    joinOnStatements?: RelaxedJoinOnStatement<DB, Schema>;
+    where?: WhereStatement<DB, Schema, any>[] | undefined;
+    whereNot?: WhereStatement<DB, Schema, any>[] | undefined;
+    joinOnStatements?: RelaxedJoinOnStatement<DB, Schema> | undefined;
     transaction?: DreamTransaction<Dream> | null | undefined;
-    connection?: DbConnectionType;
+    connection?: DbConnectionType | undefined;
 }
 export declare const SIMILARITY_TYPES: readonly ["where", "on"];
 export type SimilarityStatementType = (typeof SIMILARITY_TYPES)[number];

package/dist/types/src/dream-application/index.d.ts

@@ -103,7 +103,7 @@ export interface DreamDirectoryPaths {
 }
 export interface DreamDbCredentialOptions {
     primary: SingleDbCredential;
-    replica?: SingleDbCredential;
+    replica?: SingleDbCredential | undefined;
 }
 export interface SingleDbCredential {
     user: string;

package/dist/types/src/errors/UnexpectedUndefined.d.ts

@@ -0,0 +1,4 @@
+export default class UnexpectedUndefined extends Error {
+    constructor();
+    get message(): string;
+}

package/dist/types/src/errors/associations/AssociationDeclaredWithoutAssociatedDreamClass.d.ts

@@ -0,0 +1,7 @@
+import Dream from '../../Dream.js';
+export default class AssociationDeclaredWithoutAssociatedDreamClass extends Error {
+    private dreamClass;
+    private associationName;
+    constructor(dreamClass: typeof Dream, associationName: string | number | symbol);
+    get message(): string;
+}

package/dist/types/src/errors/associations/MissingRequiredAssociationOnClause.d.ts

@@ -3,6 +3,6 @@ import { HasOneStatement } from '../../types/associations/hasOne.js';
 export default class MissingRequiredAssociationOnClause extends Error {
     private association;
     private column;
-    constructor(association: HasManyStatement<any, any, any, any> | HasOneStatement<any, any, any, any>, column: string);
+    constructor(association: HasManyStatement<any, any, any, any> | HasOneStatement<any, any, any, any>, column: string | undefined);
     get message(): string;
 }

package/dist/types/src/helpers/cli/generateDream.d.ts

@@ -4,5 +4,5 @@ export default function generateDream({ fullyQualifiedModelName, columnsWithType
     options: {
         serializer: boolean;
     };
-    fullyQualifiedParentName?: string;
+    fullyQualifiedParentName?: string | undefined;
 }): Promise<void>;

package/dist/types/src/helpers/cli/generateDreamContent.d.ts

@@ -1,6 +1,6 @@
 export default function generateDreamContent({ fullyQualifiedModelName, columnsWithTypes, fullyQualifiedParentName, serializer, }: {
     fullyQualifiedModelName: string;
     columnsWithTypes: string[];
-    fullyQualifiedParentName?: string;
+    fullyQualifiedParentName?: string | undefined;
     serializer: boolean;
 }): string;

package/dist/types/src/helpers/cli/generateMigration.d.ts

@@ -1,6 +1,6 @@
 export default function generateMigration({ migrationName, columnsWithTypes, fullyQualifiedModelName, fullyQualifiedParentName, }: {
     migrationName: string;
     columnsWithTypes: string[];
-    fullyQualifiedModelName?: string;
-    fullyQualifiedParentName?: string;
+    fullyQualifiedModelName?: string | undefined;
+    fullyQualifiedParentName?: string | undefined;
 }): Promise<void>;

package/dist/types/src/helpers/cli/generateMigrationContent.d.ts

@@ -1,7 +1,7 @@
 import { PrimaryKeyType } from '../../types/dream.js';
 export default function generateMigrationContent({ table, columnsWithTypes, primaryKeyType, createOrAlter, }?: {
-    table?: string;
-    columnsWithTypes?: string[];
-    primaryKeyType?: PrimaryKeyType;
-    createOrAlter?: 'create' | 'alter';
+    table?: string | undefined;
+    columnsWithTypes?: string[] | undefined;
+    primaryKeyType?: PrimaryKeyType | undefined;
+    createOrAlter?: 'create' | 'alter' | undefined;
 }): string;

package/dist/types/src/helpers/cli/generateSerializer.d.ts

@@ -1,5 +1,5 @@
 export default function generateSerializer({ fullyQualifiedModelName, columnsWithTypes, fullyQualifiedParentName, }: {
     fullyQualifiedModelName: string;
     columnsWithTypes: string[];
-    fullyQualifiedParentName?: string;
+    fullyQualifiedParentName?: string | undefined;
 }): Promise<void>;

package/dist/types/src/helpers/cli/generateSerializerContent.d.ts

@@ -1,5 +1,5 @@
 export default function generateSerializerContent({ fullyQualifiedModelName, columnsWithTypes, fullyQualifiedParentName, }: {
     fullyQualifiedModelName: string;
-    columnsWithTypes?: string[];
-    fullyQualifiedParentName?: string;
+    columnsWithTypes?: string[] | undefined;
+    fullyQualifiedParentName?: string | undefined;
 }): string;

package/dist/types/src/types/associations/shared.d.ts

@@ -33,12 +33,7 @@ import { HasOneStatement } from './hasOne.ts'
 
 export type MAX_JOINED_TABLES_DEPTH = 25
 
-export type AssociationMetadataMap = Record<
-  string,
-  | BelongsToStatement<any, any, any, any>
-  | HasManyStatement<any, any, any, any>
-  | HasOneStatement<any, any, any, any>
->
+export type AssociationMetadataMap = Record<string, AssociationStatement>
 
 export type AssociatedBelongsToModelType<
   I extends Dream,

package/dist/types/src/types/dream.d.ts

@@ -6,9 +6,6 @@ import CalendarDate from '../helpers/CalendarDate.ts'
 import { DateTime } from '../helpers/DateTime.ts'
 import OpsStatement from '../ops/ops-statement.ts'
 import DreamSerializer from '../serializer/index.ts'
-import { BelongsToStatement } from './associations/belongsTo.ts'
-import { HasManyStatement } from './associations/hasMany.ts'
-import { HasOneStatement } from './associations/hasOne.ts'
 import { AssociatedModelParam, OnStatementForAssociation, WhereStatement } from './associations/shared.ts'
 import { AssociationTableNames } from './db.js'
 import { FindEachOpts } from './query.ts'
@@ -386,20 +383,12 @@ export type PreloadArgumentTypeAssociatedTableNames<
 // end:preload
 
 export type AssociationNameToDreamClassMap = Record<string, typeof Dream>
-export type AssociationNameToAssociationMap = Record<
-  string,
-  | BelongsToStatement<any, any, any, any>
-  | HasOneStatement<any, any, any, any>
-  | HasManyStatement<any, any, any, any>
->
+export type AssociationNameToAssociationMap = Record<string, AssociationMetadata>
 export type AssociationNameToAssociationDataAndDreamClassMap = Record<
   string,
   {
     dreamClass: typeof Dream
-    association:
-      | BelongsToStatement<any, any, any, any>
-      | HasOneStatement<any, any, any, any>
-      | HasManyStatement<any, any, any, any>
+    association: AssociationMetadata
   }
 >
 

package/dist/types/src/types/lifecycle.d.ts

@@ -22,8 +22,8 @@ export interface HookStatement {
   type: HookType
   className: string
   method: string
-  ifChanging?: string[]
-  ifChanged?: string[]
+  ifChanging?: string[] | undefined
+  ifChanged?: string[] | undefined
 }
 
 export interface BeforeHookOpts<T extends Dream | null = null> {

package/dist/types/src/types/logger.d.ts

@@ -1,7 +1,7 @@
 export interface DreamCliLoggerLogOpts {
-  logPrefix?: string
-  logPrefixColor?: DreamCliForegroundColor
-  logPrefixBgColor?: DreamCliBgColor
+  logPrefix?: string | undefined
+  logPrefixColor?: DreamCliForegroundColor | undefined
+  logPrefixBgColor?: DreamCliBgColor | undefined
 }
 
 export type DreamCliColor = DreamCliForegroundColor | DreamCliBgColor