@rvoh/dream 2.11.2 → 2.11.4

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

@@ -419,7 +419,9 @@ export default class DreamInstanceTransactionBuilder {
             },
             bypassAllDefaultScopes: updateAssociationOptions?.bypassAllDefaultScopes ?? DEFAULT_BYPASS_ALL_DEFAULT_SCOPES,
             defaultScopesToBypass: updateAssociationOptions?.defaultScopesToBypass ?? DEFAULT_DEFAULT_SCOPES_TO_BYPASS,
-        }).update(attributes, { skipHooks: updateAssociationOptions?.skipHooks ?? DEFAULT_SKIP_HOOKS });
+        }).update(attributes, {
+            skipHooks: updateAssociationOptions?.skipHooks ?? DEFAULT_SKIP_HOOKS,
+        });
     }
     /**
      * Creates an association for an instance. Automatically

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

@@ -1693,18 +1693,6 @@ export default class Query {
     async delete() {
         return await this.dbDriverInstance().delete();
     }
-    /**
-     * Updates all records matching the Query
-     *
-     * ```ts
-     * await User.where({ email: ops.ilike('%burpcollaborator%') }).update({ email: null })
-     * // 12
-     * ```
-     * @param attributes - The attributes used to update the records
-     * @param options - Options for updating the instance
-     * @param options.skipHooks - If true, skips applying model hooks. Defaults to false
-     * @returns The number of records that were updated
-     */
     async update(attributes, { skipHooks } = {}) {
         if (this.baseSelectQuery)
             throw new NoUpdateOnAssociationQuery();

package/dist/cjs/src/errors/dream-app/MissingDbSslDirective.js

@@ -9,7 +9,7 @@ export default class MissingDbSslDirective extends Error {
     get message() {
         return `
 DreamApp refused to register a db credential without an explicit TLS
-directive. Every \`SingleDbCredential\` passed to \`app.set('db', ...)\`
+directive. Every \`DreamDbConfig\` passed to \`app.set('db', ...)\`
 must set one of:
 
   ssl: { rejectUnauthorized: true }              // verified TLS (system CA)

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

@@ -419,7 +419,9 @@ export default class DreamInstanceTransactionBuilder {
             },
             bypassAllDefaultScopes: updateAssociationOptions?.bypassAllDefaultScopes ?? DEFAULT_BYPASS_ALL_DEFAULT_SCOPES,
             defaultScopesToBypass: updateAssociationOptions?.defaultScopesToBypass ?? DEFAULT_DEFAULT_SCOPES_TO_BYPASS,
-        }).update(attributes, { skipHooks: updateAssociationOptions?.skipHooks ?? DEFAULT_SKIP_HOOKS });
+        }).update(attributes, {
+            skipHooks: updateAssociationOptions?.skipHooks ?? DEFAULT_SKIP_HOOKS,
+        });
     }
     /**
      * Creates an association for an instance. Automatically

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

@@ -1693,18 +1693,6 @@ export default class Query {
     async delete() {
         return await this.dbDriverInstance().delete();
     }
-    /**
-     * Updates all records matching the Query
-     *
-     * ```ts
-     * await User.where({ email: ops.ilike('%burpcollaborator%') }).update({ email: null })
-     * // 12
-     * ```
-     * @param attributes - The attributes used to update the records
-     * @param options - Options for updating the instance
-     * @param options.skipHooks - If true, skips applying model hooks. Defaults to false
-     * @returns The number of records that were updated
-     */
     async update(attributes, { skipHooks } = {}) {
         if (this.baseSelectQuery)
             throw new NoUpdateOnAssociationQuery();

package/dist/esm/src/errors/dream-app/MissingDbSslDirective.js

@@ -9,7 +9,7 @@ export default class MissingDbSslDirective extends Error {
     get message() {
         return `
 DreamApp refused to register a db credential without an explicit TLS
-directive. Every \`SingleDbCredential\` passed to \`app.set('db', ...)\`
+directive. Every \`DreamDbConfig\` passed to \`app.set('db', ...)\`
 must set one of:
 
   ssl: { rejectUnauthorized: true }              // verified TLS (system CA)

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

@@ -8,7 +8,7 @@ import LoadBuilder from './dream/LoadBuilder.js';
 import Query from './dream/Query.js';
 import { OnStatementForSpecificColumns, PassthroughOnClause, WhereStatement } from './types/associations/shared.js';
 import { AssociationTableNames, DbConnectionType } from './types/db.js';
-import { AllDefaultScopeNames, AssociationNameToDream, AttributeKeys, CreateOrFindByExtraOpts, DefaultOrNamedScopeName, DreamAssociationNames, DreamAssociationNamesWithoutRequiredOnClauses, DreamAssociationNamesWithPassthroughOnClauses, DreamAssociationNamesWithRequiredOnClauses, DreamAttributes, DreamBelongsToAssociationNames, DreamColumnNames, DreamHasManyAssociationNames, DreamHasOneAssociationNames, DreamModelAssociationNames, DreamParamSafeColumnNames, DreamPrimaryKeyType, DreamSerializerKey, GlobalModelNames, GlobalSerializerName, JoinAndStatements, OrderDir, PassthroughColumnNames, PassthroughOnClauseKeys, PluckEachArgs, PrimaryKeyForFind, RequiredOnClauseKeys, TableColumnNames, UpdateableAssociationProperties, UpdateableProperties, UpdateablePropertiesForClass, UpdateOrCreateByExtraOpts } from './types/dream.js';
+import { AllDefaultScopeNames, AssociationNameToDream, AttributeKeys, CreateOrFindByExtraOpts, DefaultOrNamedScopeName, DreamAssociationNames, DreamAssociationNamesWithoutRequiredOnClauses, DreamAssociationNamesWithPassthroughOnClauses, DreamAssociationNamesWithRequiredOnClauses, DreamAttributes, DreamBelongsToAssociationNames, DreamColumnNames, DreamHasManyAssociationNames, DreamHasOneAssociationNames, DreamModelAssociationNames, DreamParamSafeColumnNames, DreamPrimaryKeyType, DreamSerializerKey, FindablePropertiesForClass, GlobalModelNames, GlobalSerializerName, JoinAndStatements, OrderDir, PassthroughColumnNames, PassthroughOnClauseKeys, PluckEachArgs, PrimaryKeyForFind, RequiredOnClauseKeys, TableColumnNames, UpdateableAssociationProperties, UpdateableProperties, UpdateablePropertiesForClass, UpdateOrCreateByExtraOpts } from './types/dream.js';
 import { BaseModelColumnTypes, CursorPaginatedDreamQueryOptions, CursorPaginatedDreamQueryResult, DefaultQueryTypeOptions, FindEachOpts, LoadForModifierFn, PaginatedDreamQueryOptions, PaginatedDreamQueryResult, QueryWithJoinedAssociationsType, QueryWithJoinedAssociationsTypeAndNoPreload } from './types/query.js';
 import { DreamModelSerializerType, SimpleObjectSerializerType } from './types/serializer.js';
 import { ValidationType } from './types/validation.js';
@@ -812,7 +812,7 @@ export default class Dream {
      * @param extraOpts.skipHooks - if true, will skip applying model hooks. Defaults to false
      * @returns A dream instance
      */
-    static createOrFindBy<T extends typeof Dream>(this: T, attributes: UpdateablePropertiesForClass<T>, extraOpts?: CreateOrFindByExtraOpts<T>): Promise<InstanceType<T>>;
+    static createOrFindBy<T extends typeof Dream>(this: T, attributes: FindablePropertiesForClass<T>, extraOpts?: CreateOrFindByExtraOpts<T>): Promise<InstanceType<T>>;
     /**
      * Attempt to update the model with the given attributes.
      * If no record is found, then a new record is created.
@@ -828,7 +828,7 @@ export default class Dream {
      * @param extraOpts.skipHooks - if true, will skip applying model hooks. Defaults to false
      * @returns A dream instance
      */
-    static updateOrCreateBy<T extends typeof Dream>(this: T, attributes: UpdateablePropertiesForClass<T>, extraOpts?: UpdateOrCreateByExtraOpts<T>): Promise<InstanceType<T>>;
+    static updateOrCreateBy<T extends typeof Dream>(this: T, attributes: FindablePropertiesForClass<T>, extraOpts?: UpdateOrCreateByExtraOpts<T>): Promise<InstanceType<T>>;
     /**
      * Attempt to create the model with the given attributes.
      * If creation fails due to uniqueness constraint, then find and update
@@ -847,7 +847,7 @@ export default class Dream {
      * @param extraOpts.skipHooks - if true, will skip applying model hooks. Defaults to false
      * @returns A dream instance
      */
-    static createOrUpdateBy<T extends typeof Dream>(this: T, attributes: UpdateablePropertiesForClass<T>, extraOpts?: UpdateOrCreateByExtraOpts<T>): Promise<InstanceType<T>>;
+    static createOrUpdateBy<T extends typeof Dream>(this: T, attributes: FindablePropertiesForClass<T>, extraOpts?: UpdateOrCreateByExtraOpts<T>): Promise<InstanceType<T>>;
     /**
      * Returns a new query instance with the distinct query applied.
      * If no columnName is provided, then distinct will apply to the
@@ -998,7 +998,7 @@ export default class Dream {
      * @param extraOpts.skipHooks - if true, will skip applying model hooks. Defaults to false
      * @returns A dream instance
      */
-    static findOrCreateBy<T extends typeof Dream>(this: T, attributes: UpdateablePropertiesForClass<T>, extraOpts?: CreateOrFindByExtraOpts<T>): Promise<InstanceType<T>>;
+    static findOrCreateBy<T extends typeof Dream>(this: T, attributes: FindablePropertiesForClass<T>, extraOpts?: CreateOrFindByExtraOpts<T>): Promise<InstanceType<T>>;
     /**
      * Returns true if a record exists for the given
      * model class

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

@@ -1,5 +1,5 @@
 import { Kysely } from 'kysely';
-import { SingleDbCredential } from '../dream-app/index.js';
+import { DreamDbConfig } from '../dream-app/index.js';
 import { DbConnectionType } from '../types/db.js';
 export default class DreamDbConnection {
     static getConnection<DB>(connectionName: string, connectionType: DbConnectionType, dialectProvider: DialectProviderCb): Kysely<DB>;
@@ -12,4 +12,4 @@ export declare function dreamDbConnections(): {
 };
 export declare function closeAllDbConnections(): Promise<void>;
 export declare function closeAllConnectionsForConnectionName(connectionName: string): Promise<PromiseSettledResult<void>[]>;
-export type DialectProviderCb = (connectionConf: SingleDbCredential) => any;
+export type DialectProviderCb = (connectionConf: DreamDbConfig) => any;

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

@@ -1,5 +1,5 @@
 import { Kysely } from 'kysely';
-import { SingleDbCredential } from '../dream-app/index.js';
+import { DreamDbConfig } from '../dream-app/index.js';
 import Dream from '../Dream.js';
 import { DbConnectionType } from '../types/db.js';
-export default function db<T extends Dream, DB extends T['DB'] = T['DB']>(connectionName?: string, connectionType?: DbConnectionType, dialectProvider?: (connectionConf: SingleDbCredential) => any): Kysely<DB>;
+export default function db<T extends Dream, DB extends T['DB'] = T['DB']>(connectionName?: string, connectionType?: DbConnectionType, dialectProvider?: (connectionConf: DreamDbConfig) => any): Kysely<DB>;

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

@@ -1,7 +1,7 @@
 import { SelectArg, SelectExpression } from 'kysely';
 import Dream from '../Dream.js';
 import { PassthroughOnClause, WhereStatement } from '../types/associations/shared.js';
-import { CreateOrFindByExtraOpts, DefaultScopeName, DreamColumnNames, DreamSerializerKey, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, TableColumnNames, UpdateableProperties, UpdateablePropertiesForClass, UpdateOrCreateByExtraOpts } from '../types/dream.js';
+import { CreateOrFindByExtraOpts, DefaultScopeName, DreamColumnNames, DreamSerializerKey, FindablePropertiesForClass, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, TableColumnNames, UpdateableProperties, UpdateOrCreateByExtraOpts } from '../types/dream.js';
 import { BaseModelColumnTypes, FindEachOpts, LoadForModifierFn, QueryWithJoinedAssociationsType, QueryWithJoinedAssociationsTypeAndNoPreload } from '../types/query.js';
 import { JoinedAssociation, JoinedAssociationsTypeFromAssociations, VariadicJoinsArgs, VariadicLeftJoinLoadArgs, VariadicLoadArgs } from '../types/variadic.js';
 import DreamTransaction from './DreamTransaction.js';
@@ -246,7 +246,7 @@ export default class DreamClassTransactionBuilder<DreamClass extends typeof Drea
      * @param extraOpts.skipHooks - if true, will skip applying model hooks. Defaults to false
      * @returns A dream instance
      */
-    findOrCreateBy<I extends DreamClassTransactionBuilder<DreamClass, DreamInstance>>(this: I, attributes: UpdateablePropertiesForClass<DreamClass>, extraOpts?: CreateOrFindByExtraOpts<DreamClass>): Promise<InstanceType<DreamClass>>;
+    findOrCreateBy<I extends DreamClassTransactionBuilder<DreamClass, DreamInstance>>(this: I, attributes: FindablePropertiesForClass<DreamClass>, extraOpts?: CreateOrFindByExtraOpts<DreamClass>): Promise<InstanceType<DreamClass>>;
     /**
      * Attempt to update the model with the given attributes.
      * If no record is found, then a new record is created.
@@ -263,7 +263,7 @@ export default class DreamClassTransactionBuilder<DreamClass extends typeof Drea
      * @param extraOpts.skipHooks - if true, will skip applying model hooks. Defaults to false
      * @returns A dream instance
      */
-    updateOrCreateBy<I extends DreamClassTransactionBuilder<DreamClass, DreamInstance>>(this: I, attributes: UpdateablePropertiesForClass<DreamClass>, extraOpts?: UpdateOrCreateByExtraOpts<DreamClass>): Promise<InstanceType<DreamClass>>;
+    updateOrCreateBy<I extends DreamClassTransactionBuilder<DreamClass, DreamInstance>>(this: I, attributes: FindablePropertiesForClass<DreamClass>, extraOpts?: UpdateOrCreateByExtraOpts<DreamClass>): Promise<InstanceType<DreamClass>>;
     /**
      * Finds all records for the corresponding model in batches,
      * and then calls the provided callback for each found record.

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

@@ -1,6 +1,6 @@
 import Dream from '../Dream.js';
 import { OnStatementForSpecificColumns } from '../types/associations/shared.js';
-import { AllDefaultScopeNames, AssociationNameToDream, DreamAssociationNames, DreamAssociationNamesWithoutRequiredOnClauses, DreamAssociationNamesWithPassthroughOnClauses, DreamAssociationNamesWithRequiredOnClauses, DreamAttributes, DreamBelongsToAssociationNames, DreamHasManyAssociationNames, DreamHasOneAssociationNames, DreamSerializerKey, JoinAndStatements, PassthroughOnClauseKeys, RequiredOnClauseKeys, UpdateableAssociationProperties, UpdateableProperties } from '../types/dream.js';
+import { AllDefaultScopeNames, AssociationNameToDream, DreamAssociationNames, DreamAssociationNamesWithoutRequiredOnClauses, DreamAssociationNamesWithPassthroughOnClauses, DreamAssociationNamesWithRequiredOnClauses, DreamBelongsToAssociationNames, DreamHasManyAssociationNames, DreamHasOneAssociationNames, DreamSerializerKey, JoinAndStatements, PassthroughOnClauseKeys, RequiredOnClauseKeys, UpdateableAssociationProperties, UpdateableProperties } from '../types/dream.js';
 import { DefaultQueryTypeOptions, LoadForModifierFn, QueryWithJoinedAssociationsType } from '../types/query.js';
 import { JoinedAssociation, JoinedAssociationsTypeFromAssociations, VariadicJoinsArgs, VariadicLeftJoinLoadArgs, VariadicLoadArgs } from '../types/variadic.js';
 import DreamTransaction from './DreamTransaction.js';
@@ -432,12 +432,12 @@ export default class DreamInstanceTransactionBuilder<DreamInstance extends Dream
     associationOrFail<I extends DreamInstanceTransactionBuilder<DreamInstance>, MaybeAssociationName extends DreamBelongsToAssociationNames<DreamInstance> | DreamHasOneAssociationNames<DreamInstance> | DreamHasManyAssociationNames<DreamInstance>, AssociationName extends MaybeAssociationName extends DreamAssociationNamesWithPassthroughOnClauses<DreamInstance> | DreamAssociationNamesWithRequiredOnClauses<DreamInstance> ? never : MaybeAssociationName, ReturnType extends AssociationName extends DreamHasManyAssociationNames<DreamInstance> ? AssociationNameToDream<DreamInstance, AssociationName>[] : AssociationNameToDream<DreamInstance, AssociationName>>(this: I, associationName: AssociationName): Promise<ReturnType>;
     associationQuery<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], TableName extends DreamInstance['table'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNamesWithRequiredOnClauses<DreamInstance>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, joinAndStatements: JoinAndStatements<AssociationDream, DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Query<AssociationDream, DefaultQueryTypeOptions<AssociationDream, AssociationName & string>>;
     associationQuery<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, joinAndStatements?: JoinAndStatements<AssociationDream, DB, Schema, AssociationTableName, null>): Query<AssociationDream, DefaultQueryTypeOptions<AssociationDream, AssociationName & string>>;
-    updateAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], TableName extends DreamInstance['table'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNamesWithRequiredOnClauses<DreamInstance>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, attributes: Partial<DreamAttributes<AssociationNameToDream<DreamInstance, AssociationName>>>, updateAssociationOptions: {
+    updateAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], TableName extends DreamInstance['table'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNamesWithRequiredOnClauses<DreamInstance>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table'], PossibleArrayAssociationType = DreamInstance[AssociationName & keyof DreamInstance], AssociationType = PossibleArrayAssociationType extends (infer ElementType)[] ? ElementType : PossibleArrayAssociationType, RestrictedAssociationType extends AssociationType extends Dream ? AssociationType : never = AssociationType extends Dream ? AssociationType : never>(this: I, associationName: AssociationName, attributes: UpdateableAssociationProperties<DreamInstance, RestrictedAssociationType>, updateAssociationOptions: {
         bypassAllDefaultScopes?: boolean;
         defaultScopesToBypass?: AllDefaultScopeNames<DreamInstance>[];
         skipHooks?: boolean;
     } & JoinAndStatements<AssociationDream, DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
-    updateAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, attributes: Partial<DreamAttributes<AssociationNameToDream<DreamInstance, AssociationName>>>, updateAssociationOptions?: {
+    updateAssociation<I extends DreamInstanceTransactionBuilder<DreamInstance>, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table'], PossibleArrayAssociationType = DreamInstance[AssociationName & keyof DreamInstance], AssociationType = PossibleArrayAssociationType extends (infer ElementType)[] ? ElementType : PossibleArrayAssociationType, RestrictedAssociationType extends AssociationType extends Dream ? AssociationType : never = AssociationType extends Dream ? AssociationType : never>(this: I, associationName: AssociationName, attributes: UpdateableAssociationProperties<DreamInstance, RestrictedAssociationType>, updateAssociationOptions?: {
         bypassAllDefaultScopes?: boolean;
         defaultScopesToBypass?: AllDefaultScopeNames<DreamInstance>[];
         skipHooks?: boolean;

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

@@ -2,7 +2,7 @@ import { DeleteQueryBuilder, SelectQueryBuilder, UpdateQueryBuilder } from 'kyse
 import Dream from '../Dream.js';
 import { ColumnNamesAccountingForJoinedAssociations, InternalWhereStatement, LimitStatement, OffsetStatement, OrderQueryStatement, PassthroughOnClause, WhereStatement, WhereStatementForJoinedAssociation } from '../types/associations/shared.js';
 import { DbConnectionType } from '../types/db.js';
-import { AllDefaultScopeNames, DefaultScopeName, DreamColumnNames, DreamConstructorType, DreamSerializerKey, DreamTableSchema, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, RelaxedJoinAndStatement, RelaxedJoinStatement, RelaxedPreloadOnStatement, RelaxedPreloadStatement, TableColumnNames, TableOrAssociationName } from '../types/dream.js';
+import { AllDefaultScopeNames, DefaultScopeName, DreamColumnNames, DreamConstructorType, DreamSerializerKey, DreamTableSchema, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, RelaxedJoinAndStatement, RelaxedJoinStatement, RelaxedPreloadOnStatement, RelaxedPreloadStatement, TableColumnNames, TableOrAssociationName, UpdateableProperties } from '../types/dream.js';
 import { CursorPaginatedDreamQueryOptions, CursorPaginatedDreamQueryResult, DefaultQueryTypeOptions, ExtendQueryType, LoadForModifierFn, NamespacedOrBaseModelColumnTypes, PaginatedDreamQueryOptions, PaginatedDreamQueryResult, QueryToKyselyDBType, QueryToKyselyTableNamesType } from '../types/query.js';
 import { JoinedAssociation, JoinedAssociationsTypeFromAssociations, QueryTypeOptions, VariadicJoinsArgs, VariadicLeftJoinLoadArgs, VariadicLoadArgs } from '../types/variadic.js';
 import DreamTransaction from './DreamTransaction.js';
@@ -1154,9 +1154,10 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      * @param options.skipHooks - If true, skips applying model hooks. Defaults to false
      * @returns The number of records that were updated
      */
-    update(attributes: DreamTableSchema<DreamInstance>, { skipHooks }?: {
+    update(attributes: DreamTableSchema<DreamInstance>, options?: {
         skipHooks?: boolean;
     }): Promise<number>;
+    update(attributes: UpdateableProperties<DreamInstance>): Promise<number>;
     private updateWithoutCallingModelHooks;
     private invertOrder;
 }

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

@@ -1,7 +1,7 @@
 import type { ConnectionOptions as TlsConnectionOptions } from 'node:tls';
 import { DeleteQueryBuilder, Kysely, Transaction as KyselyTransaction, OrderByItemBuilder, SelectQueryBuilder, UpdateQueryBuilder } from 'kysely';
 import { DialectProviderCb } from '../../db/DreamDbConnection.js';
-import { SingleDbCredential } from '../../dream-app/index.js';
+import { DreamDbConfig } from '../../dream-app/index.js';
 import Dream from '../../Dream.js';
 import { SchemaBuilderInformationSchemaRow } from '../../helpers/cli/ASTBuilder.js';
 import { AssociationStatement } from '../../types/associations/shared.js';
@@ -482,4 +482,4 @@ export default class KyselyQueryDriver<DreamInstance extends Dream> extends Quer
  * `app.set('db', ...)` time when both `ssl` and `useSsl` are unset, so this
  * resolver never sees the "neither directive" state.
  */
-export declare function resolvePostgresSsl(connectionConf: SingleDbCredential): TlsConnectionOptions | false;
+export declare function resolvePostgresSsl(connectionConf: DreamDbConfig): TlsConnectionOptions | false;

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

@@ -149,7 +149,7 @@ export default class DreamApp {
     get models(): Record<string, typeof Dream>;
     get serializers(): Record<string, DreamModelSerializerType | SimpleObjectSerializerType>;
     dbName(connectionName: string, connection: DbConnectionType): string;
-    dbConnectionConfig(connectionName: string, connection: DbConnectionType): SingleDbCredential;
+    dbConnectionConfig(connectionName: string, connection: DbConnectionType): DreamDbConfig;
     dbConnectionQueryDriverClass<T extends Dream = Dream>(connectionName: string): typeof QueryDriverBase<T>;
     dbConnectionKeys(): string[];
     hasReplicaConfig(connectionName: string): boolean;
@@ -180,8 +180,8 @@ export interface DreamDirectoryPaths {
     types?: string;
 }
 export interface DreamDbCredentialOptions {
-    primary: SingleDbCredential;
-    replica?: SingleDbCredential | undefined;
+    primary: DreamDbConfig;
+    replica?: DreamDbConfig | undefined;
     queryDriverClass?: typeof QueryDriverBase;
     /**
      * a string which informs the kysely-codegen tool,
@@ -205,7 +205,7 @@ export interface DreamDbCredentialOptions {
     tableExcludePattern?: string;
 }
 type UnicodeNormalizationForm = 'NFC' | 'NFD' | 'none';
-export interface SingleDbCredential {
+export interface DreamDbConfig {
     user: string;
     password: string;
     host: string;

package/dist/types/src/package-exports/types.d.ts

@@ -14,5 +14,5 @@ export { type DurationObject, type DurationUnit, type WeekdayName } from '../typ
 export { type DreamAssociationMetadata, type DreamAttributes, type DreamClassAssociationAndStatement, type DreamClassColumn, type DreamColumn, type DreamColumnNames, type DreamOrViewModelClassSerializerKey, type DreamOrViewModelSerializerKey, type DreamParamSafeAttributes, type DreamParamSafeColumnNames, type DreamSerializable, type DreamSerializableArray, type DreamSerializerKey, type DreamSerializers, type DreamVirtualColumns, type UpdateableAssociationProperties, type UpdateableProperties, type ViewModel, type ViewModelClass, } from '../types/dream.js';
 export { type DreamModelSerializerType, type InternalAnyTypedSerializerRendersMany, type InternalAnyTypedSerializerRendersOne, type SerializerCasing, type SimpleObjectSerializerType, } from '../types/serializer.js';
 export { type ValidationType } from '../types/validation.js';
-export { type DreamAppInitOptions, type DreamAppOpts, type DreamLogger, type DreamLogLevel, } from '../dream-app/index.js';
+export { type DreamAppInitOptions, type DreamAppOpts, type DreamLogger, type DreamLogLevel, type DreamDbConfig, } from '../dream-app/index.js';
 export { type WhereStatementForDream, type WhereStatementForDreamClass, } from '../types/associations/shared.js';

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

@@ -125,6 +125,15 @@ export type JoinAndStatements<I extends Dream, DB, Schema, TableName extends key
     andAny?: InternalWhereStatement<I, DB, Schema, TableName>[];
 } : never;
 export type UpdateablePropertiesForClass<DreamClass extends typeof Dream, TableName extends AssociationTableNames<InstanceType<DreamClass>['DB'], InstanceType<DreamClass>['schema']> & InstanceType<DreamClass>['table'] = InstanceType<DreamClass>['table'], VirtualColumns = DreamVirtualColumns<InstanceType<DreamClass>>> = Partial<Updateable<InstanceType<DreamClass>['DB'][TableName]> & (VirtualColumns extends readonly any[] ? Record<VirtualColumns[number], any> : object) & (AssociatedModelParam<InstanceType<DreamClass>> extends never ? object : AssociatedModelParam<InstanceType<DreamClass>>)>;
+/**
+ * Like {@link UpdateablePropertiesForClass} but without virtual columns
+ * (including `@Encrypted` properties). Used for the find-key argument of
+ * findOrCreateBy / createOrFindBy / updateOrCreateBy / createOrUpdateBy:
+ * that argument builds the lookup query, and virtual columns are not real
+ * columns while encrypted columns store non-deterministic ciphertext, so
+ * neither can be queried by.
+ */
+export type FindablePropertiesForClass<DreamClass extends typeof Dream, TableName extends AssociationTableNames<InstanceType<DreamClass>['DB'], InstanceType<DreamClass>['schema']> & InstanceType<DreamClass>['table'] = InstanceType<DreamClass>['table']> = Partial<Updateable<InstanceType<DreamClass>['DB'][TableName]> & (AssociatedModelParam<InstanceType<DreamClass>> extends never ? object : AssociatedModelParam<InstanceType<DreamClass>>)>;
 export type UpdateableAssociationProperties<DreamInstance extends Dream, AssociationClass extends Dream, Schema = DreamInstance['schema'], AssociationTableName extends AssociationTableNames<DreamInstance['DB'], DreamInstance['schema']> & keyof DreamInstance['DB'] = AssociationClass['table'], VirtualColumns = VirtualColumnsForTable<Schema, AssociationTableName>> = Partial<Updateable<DreamInstance['DB'][AssociationTableName]> & (VirtualColumns extends readonly any[] ? Record<VirtualColumns[number], any> : object) & (AssociatedModelParam<AssociationClass> extends never ? object : AssociatedModelParam<AssociationClass>)>;
 export type AttributeKeys<I extends Dream, TableName extends AssociationTableNames<I['DB'], I['schema']> & I['table'] = I['table'], VirtualColumns = DreamVirtualColumns<I>> = keyof (Updateable<I['DB'][TableName]> & (VirtualColumns extends readonly any[] ? Record<VirtualColumns[number], any> : object));
 export type UpdateableProperties<I extends Dream, TableName extends AssociationTableNames<I['DB'], I['schema']> & I['table'] = I['table'], VirtualColumns = DreamVirtualColumns<I>> = Partial<Updateable<I['DB'][TableName]> & (VirtualColumns extends readonly any[] ? Record<VirtualColumns[number], any> : object) & (AssociatedModelParam<I> extends never ? object : AssociatedModelParam<I>)>;

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

@@ -490,6 +490,28 @@ export type UpdateablePropertiesForClass<
       : AssociatedModelParam<InstanceType<DreamClass>>)
 >
 
+/**
+ * Like {@link UpdateablePropertiesForClass} but without virtual columns
+ * (including `@Encrypted` properties). Used for the find-key argument of
+ * findOrCreateBy / createOrFindBy / updateOrCreateBy / createOrUpdateBy:
+ * that argument builds the lookup query, and virtual columns are not real
+ * columns while encrypted columns store non-deterministic ciphertext, so
+ * neither can be queried by.
+ */
+export type FindablePropertiesForClass<
+  DreamClass extends typeof Dream,
+  TableName extends AssociationTableNames<
+    InstanceType<DreamClass>['DB'],
+    InstanceType<DreamClass>['schema']
+  > &
+    InstanceType<DreamClass>['table'] = InstanceType<DreamClass>['table'],
+> = Partial<
+  Updateable<InstanceType<DreamClass>['DB'][TableName]> &
+    (AssociatedModelParam<InstanceType<DreamClass>> extends never
+      ? object
+      : AssociatedModelParam<InstanceType<DreamClass>>)
+>
+
 export type UpdateableAssociationProperties<
   DreamInstance extends Dream,
   AssociationClass extends Dream,

package/docs/assets/navigation.js

@@ -1 +1 @@
-window.navigationData = "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"
+window.navigationData = "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"

package/docs/assets/search.js

@@ -1 +1 @@
-window.searchData = "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";
+window.searchData = "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";