prettier

Author: wd-alejandroescobedogarcia

packages/core/src/associations/base.ts

@@ -319,7 +319,7 @@ export interface AssociationOptions<ForeignKey extends string = string> extends
    */
   foreignKey?: ForeignKey | ForeignKeyOptions<ForeignKey>;
 
-  foreignKeys?: ForeignKey[] | Array<{ source: string, target: string }>;
+  foreignKeys?: ForeignKey[] | Array<{ source: string; target: string }>;
 
   /**
    * Should ON UPDATE, ON DELETE, and REFERENCES constraints be enabled on the foreign key.

packages/core/src/associations/belongs-to.ts

@@ -1,5 +1,6 @@
-import isEqual from 'lodash/isEqual';
+import { MapView } from '@sequelize/utils';
 import isEmpty from 'lodash/isEmpty.js';
+import isEqual from 'lodash/isEqual';
 import isObject from 'lodash/isObject.js';
 import upperFirst from 'lodash/upperFirst';
 import assert from 'node:assert';
@@ -29,7 +30,6 @@ import { HasManyAssociation } from './has-many.js';
 import { HasOneAssociation } from './has-one.js';
 import type { NormalizeBaseAssociationOptions } from './helpers';
 import { defineAssociation, mixinMethods, normalizeBaseAssociationOptions } from './helpers';
-import { MapView } from '@sequelize/utils';
 
 /**
  * One-to-one association
@@ -64,7 +64,7 @@ export class BelongsToAssociation<
 
   foreignKey: SourceKey;
 
-  foreignKeys: Array<{ source: SourceKey, target: TargetKey }> = [];
+  foreignKeys: Array<{ source: SourceKey; target: TargetKey }> = [];
 
   /**
    * The column name of the foreign key
@@ -113,26 +113,29 @@ export class BelongsToAssociation<
     parent?: Association,
   ) {
     const isForeignKeyEmpty = isEmpty(options.foreignKey);
-    const isForeignKeysValid = Array.isArray(options.foreignKeys)
-      && options.foreignKeys.length > 0
-      && options.foreignKeys.every(fk => !isEmpty(fk));
+    const isForeignKeysValid =
+      Array.isArray(options.foreignKeys) &&
+      options.foreignKeys.length > 0 &&
+      options.foreignKeys.every(fk => !isEmpty(fk));
 
     let targetKeys;
     if (isForeignKeyEmpty && isForeignKeysValid) {
-      targetKeys = (options.foreignKeys as Array<{ source: SourceKey, target: TargetKey }>).map(fk => fk.target);
+      targetKeys = (options.foreignKeys as Array<{ source: SourceKey; target: TargetKey }>).map(
+        fk => fk.target,
+      );
     } else {
       targetKeys = options?.targetKey
-      ? [options.targetKey]
-      : target.modelDefinition.primaryKeysAttributeNames;
+        ? [options.targetKey]
+        : target.modelDefinition.primaryKeysAttributeNames;
     }
 
     const targetAttributes = target.modelDefinition.attributes;
 
     for (const key of targetKeys) {
       if (!targetAttributes.has(key)) {
         throw new Error(
-        `Unknown attribute "${key}" passed as targetKey, define this attribute on model "${target.name}" first`,
-      );
+          `Unknown attribute "${key}" passed as targetKey, define this attribute on model "${target.name}" first`,
+        );
       }
     }
 
@@ -148,15 +151,14 @@ export class BelongsToAssociation<
 
     const shouldHashPrimaryKey = this.shouldHashPrimaryKey(targetAttributes);
 
-    if ((!isEmpty(options.foreignKeys) && isEmpty(options.foreignKey)) && !shouldHashPrimaryKey) {
-
+    if (!isEmpty(options.foreignKeys) && isEmpty(options.foreignKey) && !shouldHashPrimaryKey) {
       // Composite key flow
       // TODO: fix this
       this.targetKey = null as any;
       this.foreignKey = null as any;
       this.identifierField = null as any;
 
-      this.foreignKeys = options.foreignKeys as Array<{ source: SourceKey, target: TargetKey }>;
+      this.foreignKeys = options.foreignKeys as Array<{ source: SourceKey; target: TargetKey }>;
 
       for (const targetKey of this.targetKeys) {
         const targetColumn = targetAttributes.get(targetKey)!;
@@ -170,7 +172,6 @@ export class BelongsToAssociation<
           [targetColumn.columnName]: newForeignKeyAttribute,
         });
       }
-
     } else {
       const [targetKey] = this.targetKeys;
       this.targetKey = targetKey;
@@ -179,9 +180,9 @@ export class BelongsToAssociation<
       // else, server throws SQL0573N error. Hence, setting it here explicitly
       // for non primary columns.
       if (
-      target.sequelize.dialect.name === 'db2' &&
-      targetAttributes.get(this.targetKey)!.primaryKey !== true
-    ) {
+        target.sequelize.dialect.name === 'db2' &&
+        targetAttributes.get(this.targetKey)!.primaryKey !== true
+      ) {
         // TODO: throw instead
         this.target.modelDefinition.rawAttributes[this.targetKey].unique = true;
       }
@@ -218,7 +219,7 @@ export class BelongsToAssociation<
       if (options.foreignKeyConstraints !== false) {
         const existingReference = existingForeignKey?.references
           ? ((normalizeReference(existingForeignKey.references) ??
-            existingForeignKey.references) as AttributeReferencesOptions)
+              existingForeignKey.references) as AttributeReferencesOptions)
           : undefined;
 
         const queryGenerator = this.source.sequelize.queryGenerator;
@@ -233,24 +234,27 @@ export class BelongsToAssociation<
         if (existingReferencedTable) {
           if (!isEqual(existingReferencedTable, newReferencedTable)) {
             throw new Error(
-            `Foreign key ${this.foreignKey} on ${this.source.name} already references ${queryGenerator.quoteTable(existingReferencedTable)}, but this association needs to make it reference ${queryGenerator.quoteTable(newReferencedTable)} instead.`,
-          );
+              `Foreign key ${this.foreignKey} on ${this.source.name} already references ${queryGenerator.quoteTable(existingReferencedTable)}, but this association needs to make it reference ${queryGenerator.quoteTable(newReferencedTable)} instead.`,
+            );
           }
         } else {
           newReference.table = newReferencedTable;
         }
 
-      if (existingReference?.key && existingReference.key !== this.targetKeyField(this.targetKey)) {
-        throw new Error(
-          `Foreign key ${this.foreignKey} on ${this.source.name} already references column ${existingReference.key}, but this association needs to make it reference ${this.targetKeyField} instead.`,
-        );
-      }
+        if (
+          existingReference?.key &&
+          existingReference.key !== this.targetKeyField(this.targetKey)
+        ) {
+          throw new Error(
+            `Foreign key ${this.foreignKey} on ${this.source.name} already references column ${existingReference.key}, but this association needs to make it reference ${this.targetKeyField} instead.`,
+          );
+        }
 
         newReference.key = this.targetKeyField(this.targetKey);
 
         newForeignKeyAttribute.references = newReference;
         newForeignKeyAttribute.onDelete ??=
-        newForeignKeyAttribute.allowNull !== false ? 'SET NULL' : 'CASCADE';
+          newForeignKeyAttribute.allowNull !== false ? 'SET NULL' : 'CASCADE';
         newForeignKeyAttribute.onUpdate ??= newForeignKeyAttribute.onUpdate ?? 'CASCADE';
       }
 
@@ -300,15 +304,21 @@ export class BelongsToAssociation<
     }
   }
 
-  private setupTargetKeys(options: NormalizedBelongsToOptions<SourceKey, TargetKey>, target: ModelStatic<T>) {
+  private setupTargetKeys(
+    options: NormalizedBelongsToOptions<SourceKey, TargetKey>,
+    target: ModelStatic<T>,
+  ) {
     const isForeignKeyEmpty = isEmpty(options.foreignKey);
-    const isForeignKeysValid = Array.isArray(options.foreignKeys)
-      && options.foreignKeys.length > 0
-      && options.foreignKeys.every(fk => !isEmpty(fk));
+    const isForeignKeysValid =
+      Array.isArray(options.foreignKeys) &&
+      options.foreignKeys.length > 0 &&
+      options.foreignKeys.every(fk => !isEmpty(fk));
 
     let targetKeys;
     if (isForeignKeyEmpty && isForeignKeysValid) {
-      targetKeys = (options.foreignKeys as Array<{ source: SourceKey, target: TargetKey }>).map(fk => fk.target);
+      targetKeys = (options.foreignKeys as Array<{ source: SourceKey; target: TargetKey }>).map(
+        fk => fk.target,
+      );
     } else {
       targetKeys = options?.targetKey
         ? [options.targetKey]
@@ -318,11 +328,15 @@ export class BelongsToAssociation<
     const targetAttributes = target.modelDefinition.attributes;
     for (const key of targetKeys) {
       if (!targetAttributes.has(key)) {
-        throw new Error(`Unknown attribute "${key}" passed as targetKey, define this attribute on model "${target.name}" first`);
+        throw new Error(
+          `Unknown attribute "${key}" passed as targetKey, define this attribute on model "${target.name}" first`,
+        );
       }
     }
 
-    this.targetKeys = Array.isArray(targetKeys) ? targetKeys : [...targetKeys].map(key => key as TargetKey);
+    this.targetKeys = Array.isArray(targetKeys)
+      ? targetKeys
+      : [...targetKeys].map(key => key as TargetKey);
   }
 
   /**
@@ -334,15 +348,20 @@ export class BelongsToAssociation<
    * @param targetAttributes
    * @protected
    */
-  protected shouldHashPrimaryKey(targetAttributes: MapView<string, NormalizedAttributeOptions<Model<any, any>>>): Boolean {
+  protected shouldHashPrimaryKey(
+    targetAttributes: MapView<string, NormalizedAttributeOptions<Model<any, any>>>,
+  ): Boolean {
     const primaryKeyAttributes = [];
     for (const attributes of targetAttributes.values()) {
       if (attributes.primaryKey) {
         primaryKeyAttributes.push(attributes);
       }
     }
 
-    return primaryKeyAttributes.length === 2 && primaryKeyAttributes.some(attr => attr.type === 'BINARY(16)');
+    return (
+      primaryKeyAttributes.length === 2 &&
+      primaryKeyAttributes.some(attr => attr.type === 'BINARY(16)')
+    );
   }
 
   static associate<
@@ -456,13 +475,13 @@ export class BelongsToAssociation<
     } else if (this.targetKeyIsPrimary(this.targetKey) && !options.where) {
       const foreignKeyValue = instances[0].get(this.foreignKey);
 
-        return Target.findByPk(foreignKeyValue as any, options);} else {
+      return Target.findByPk(foreignKeyValue as any, options);
+    } else {
       // TODO: combine once we can just have the foreignKey in the foreignKeys array all the time
       if (this.isCompositeKey) {
         for (const key of this.foreignKeys) {
           where[key.target] = instances[0].get(key.source);
         }
-
       } else {
         where[this.targetKey] = instances[0].get(this.foreignKey);
       }

packages/core/src/associations/has-one.ts

@@ -122,7 +122,8 @@ export class HasOneAssociation<
           as: options.inverse?.as,
           scope: options.inverse?.scope,
           foreignKey: options.foreignKey,
-          foreignKeys: options.foreignKeys,targetKey: options.sourceKey,
+          foreignKeys: options.foreignKeys,
+          targetKey: options.sourceKey,
           foreignKeyConstraints: options.foreignKeyConstraints,
           hooks: options.hooks,
         }),
@@ -248,7 +249,6 @@ If having two associations does not make sense (for instance a "spouse" associat
       for (const key of this.foreignKeys) {
         where[key.target] = instances[0].get(key.source);
       }
-
     } else {
       where[this.foreignKey] = instances[0].get(this.sourceKey);
     }

packages/core/src/associations/helpers.ts

@@ -1,12 +1,12 @@
-import assert from 'node:assert';
-import NodeUtils from 'node:util';
 import isArray from 'lodash/isArray';
 import isEmpty from 'lodash/isEmpty';
 import isEqual from 'lodash/isEqual';
 import isPlainObject from 'lodash/isPlainObject.js';
 import lowerFirst from 'lodash/lowerFirst';
 import omit from 'lodash/omit';
 import some from 'lodash/some';
+import assert from 'node:assert';
+import NodeUtils from 'node:util';
 import type { Class } from 'type-fest';
 import { AssociationError } from '../errors/index.js';
 import type { Model, ModelStatic } from '../model';
@@ -16,15 +16,20 @@ import { isModelStatic, isSameInitialModel } from '../utils/model-utils.js';
 import { removeUndefined } from '../utils/object.js';
 import { pluralize, singularize } from '../utils/string.js';
 import type { OmitConstructors } from '../utils/types.js';
-import type { Association, AssociationOptions, ForeignKeyOptions, NormalizedAssociationOptions } from './base';
+import type {
+  Association,
+  AssociationOptions,
+  ForeignKeyOptions,
+  NormalizedAssociationOptions,
+} from './base';
 import type { ThroughOptions } from './belongs-to-many.js';
 
 export function checkNamingCollision(source: ModelStatic<any>, associationName: string): void {
   if (Object.hasOwn(source.getAttributes(), associationName)) {
     throw new Error(
-      `Naming collision between attribute '${associationName}'`
-        + ` and association '${associationName}' on model ${source.name}`
-        + '. To remedy this, change the "as" options in your association definition',
+      `Naming collision between attribute '${associationName}'` +
+        ` and association '${associationName}' on model ${source.name}` +
+        '. To remedy this, change the "as" options in your association definition',
     );
   }
 }
@@ -127,7 +132,7 @@ ${NodeUtils.inspect(omit(options, 'inverse'), { sorted: true })}
 Options of the existing association:
 ${NodeUtils.inspect(omit(existingAssociation.options as any, 'inverse'), { sorted: true })}
 `
-}`.trim(),
+    }`.trim(),
   );
 }
 
@@ -172,7 +177,7 @@ export function assertAssociationModelIsDefined(model: ModelStatic<any>): void {
 }
 
 export type AssociationStatic<T extends Association> = {
-  new (...arguments_: any[]): T,
+  new (...arguments_: any[]): T;
 } & OmitConstructors<typeof Association>;
 
 export function defineAssociation<
@@ -247,10 +252,10 @@ export function defineAssociation<
 }
 
 export type NormalizeBaseAssociationOptions<T> = Omit<T, 'as' | 'hooks' | 'foreignKey'> & {
-  as: string,
-  name: { singular: string, plural: string },
-  hooks: boolean,
-  foreignKey: ForeignKeyOptions<any>,
+  as: string;
+  name: { singular: string; plural: string };
+  hooks: boolean;
+  foreignKey: ForeignKeyOptions<any>;
   // foreignKeys: Array<{ source: string, target: string }>,
 };
 
@@ -288,14 +293,12 @@ export function normalizeBaseAssociationOptions<T extends AssociationOptions<any
 
   // make sure both are not used at the same time
   if (some(options.foreignKey, isEmpty) && some(options.foreignKeys, isEmpty)) {
-    throw new Error(
-      'Only one of "foreignKey" and "foreignKeys" can be defined',
-    );
+    throw new Error('Only one of "foreignKey" and "foreignKeys" can be defined');
   }
 
   const isMultiAssociation = associationType.isMultiAssociation;
 
-  let name: { singular: string, plural: string };
+  let name: { singular: string; plural: string };
   let as: string;
   if (options?.as) {
     if (isPlainObject(options.as)) {
@@ -334,16 +337,18 @@ export function normalizeForeignKeyOptions<T extends string>(
   return typeof foreignKey === 'string'
     ? { name: foreignKey }
     : removeUndefined({
-      ...foreignKey,
-      name: foreignKey?.name ?? foreignKey?.columnName,
-      fieldName: undefined,
-    });
+        ...foreignKey,
+        name: foreignKey?.name ?? foreignKey?.columnName,
+        fieldName: undefined,
+      });
 }
 
 // Update the option normalization logic to turn `foreignKey` and `targetKey` into `foreignKeys`,
-export function normalizeCompositeForeignKeyOptions<T extends string>(options: AssociationOptions<T>): Array<{
-  source: string,
-  target: string,
+export function normalizeCompositeForeignKeyOptions<T extends string>(
+  options: AssociationOptions<T>,
+): Array<{
+  source: string;
+  target: string;
 }> {
   if (isArray(options.foreignKeys) && !some(options.foreignKeys, isEmpty)) {
     return options.foreignKeys.map(fk => {
@@ -361,7 +366,12 @@ export function normalizeCompositeForeignKeyOptions<T extends string>(options: A
   // belongsTo has a targetKey option, which is the name of the column in the target table that the foreign key should reference.
   // hasOne and hasMany have a sourceKey option, which is the name of the column in the source table that the foreign key should reference.
   // belongsToMany has both sourceKey and targetKey, which are the names of the columns in the source and target tables that the foreign key should reference, respectively.
-  return [{ source: sourceKey ?? normalizedForeignKey.name, target: targetKey ?? normalizedForeignKey.name }];
+  return [
+    {
+      source: sourceKey ?? normalizedForeignKey.name,
+      target: targetKey ?? normalizedForeignKey.name,
+    },
+  ];
 }
 
 export type MaybeForwardedModelStatic<M extends Model = Model> =