Bump prettier from 2.8.8 to 3.2.5

apps/authz/src/app/app.service.ts

@@ -68,7 +68,10 @@ export const finalizeDecision = (response: OpaResult[]) => {
 
 @Injectable()
 export class AppService {
-  constructor(private opaService: OpaService, private entityRepository: EntityRepository) {}
+  constructor(
+    private opaService: OpaService,
+    private entityRepository: EntityRepository
+  ) {}
 
   async #verifySignature(requestSignature: Signature, verificationMessage: string): Promise<CredentialEntity> {
     const { pubKey, alg, sig } = requestSignature

apps/orchestration/src/data-feed/core/service/price-feed.service.ts

@@ -16,7 +16,10 @@ import { DataFeed } from '../type/data-feed.type'
 export class PriceFeedService implements DataFeed<Prices> {
   static SOURCE_ID = 'armory/price-feed'
 
-  constructor(private priceService: PriceService, private configService: ConfigService<Config, true>) {}
+  constructor(
+    private priceService: PriceService,
+    private configService: ConfigService<Config, true>
+  ) {}
 
   getId(): string {
     return PriceFeedService.SOURCE_ID

apps/orchestration/src/policy-engine/core/service/cluster.service.ts

@@ -106,13 +106,16 @@ export class ClusterService {
     nodes: Node[],
     responses: EvaluationResponse[]
   ): { node: Node; response: EvaluationResponse }[] {
-    return zip(nodes, responses).reduce((acc, [node, response]) => {
-      if (node && response) {
-        return [...acc, { node, response }]
-      }
+    return zip(nodes, responses).reduce(
+      (acc, [node, response]) => {
+        if (node && response) {
+          return [...acc, { node, response }]
+        }
 
-      return acc
-    }, [] as { node: Node; response: EvaluationResponse }[])
+        return acc
+      },
+      [] as { node: Node; response: EvaluationResponse }[]
+    )
   }
 
   private async recoverPubKey(response: EvaluationResponse) {

apps/orchestration/src/price/core/service/price.service.ts

@@ -16,7 +16,10 @@ type GetPricesOption = {
 export class PriceService {
   private logger = new Logger(PriceService.name)
 
-  constructor(private coinGeckoClient: CoinGeckoClient, private coinGeckoAssetRepository: CoinGeckoAssetRepository) {}
+  constructor(
+    private coinGeckoClient: CoinGeckoClient,
+    private coinGeckoAssetRepository: CoinGeckoAssetRepository
+  ) {}
 
   async getPrices(options: GetPricesOption): Promise<Prices> {
     this.logger.log('Get prices', options)
@@ -68,22 +71,25 @@ export class PriceService {
   }
 
   private getAssetsPriceInformation(simplePrice: SimplePrice) {
-    return Object.keys(simplePrice).reduce((acc, coinId) => {
-      const sourceAssetIds = this.coinGeckoAssetRepository.getAssetIds(coinId)
-
-      if (sourceAssetIds) {
-        return [
-          ...acc,
-          ...sourceAssetIds.map((sourceAssetId) => ({
-            sourceAssetId,
-            coinId,
-            values: this.getValues(simplePrice, coinId)
-          }))
-        ]
-      }
+    return Object.keys(simplePrice).reduce(
+      (acc, coinId) => {
+        const sourceAssetIds = this.coinGeckoAssetRepository.getAssetIds(coinId)
 
-      return acc
-    }, [] as { sourceAssetId: AssetId; coinId: string; values: unknown }[])
+        if (sourceAssetIds) {
+          return [
+            ...acc,
+            ...sourceAssetIds.map((sourceAssetId) => ({
+              sourceAssetId,
+              coinId,
+              values: this.getValues(simplePrice, coinId)
+            }))
+          ]
+        }
+
+        return acc
+      },
+      [] as { sourceAssetId: AssetId; coinId: string; values: unknown }[]
+    )
   }
 
   private getValues(simplePrice: SimplePrice, coinId: string) {

apps/orchestration/src/store/entity/core/service/organization.service.ts

@@ -5,7 +5,10 @@ import { UserService } from './user.service'
 
 @Injectable()
 export class OrganizationService {
-  constructor(private orgRepository: OrganizationRepository, private userService: UserService) {}
+  constructor(
+    private orgRepository: OrganizationRepository,
+    private userService: UserService
+  ) {}
 
   async create(input: { uid: string; rootCredential: CredentialEntity }): Promise<{
     organization: OrganizationEntity

apps/orchestration/src/store/entity/core/service/user.service.ts

@@ -5,7 +5,10 @@ import { UserRepository } from '../../persistence/repository/user.repository'
 
 @Injectable()
 export class UserService {
-  constructor(private userRepository: UserRepository, private userWalletRepository: UserWalletRepository) {}
+  constructor(
+    private userRepository: UserRepository,
+    private userWalletRepository: UserWalletRepository
+  ) {}
 
   create(orgId: string, user: UserEntity, credential?: CredentialEntity): Promise<UserEntity> {
     return this.userRepository.create(orgId, user, credential)

apps/orchestration/src/store/entity/core/service/wallet.service.ts

@@ -5,7 +5,10 @@ import { WalletRepository } from '../../persistence/repository/wallet.repository
 
 @Injectable()
 export class WalletService {
-  constructor(private walletRepository: WalletRepository, private walletGroupRepository: WalletGroupRepository) {}
+  constructor(
+    private walletRepository: WalletRepository,
+    private walletGroupRepository: WalletGroupRepository
+  ) {}
 
   async create(orgId: string, wallet: WalletEntity): Promise<WalletEntity> {
     return this.walletRepository.create(orgId, wallet)

package.json

@@ -57,7 +57,7 @@
     "lint-staged": "15.2.0",
     "nock": "^13.5.1",
     "nx": "17.1.3",
-    "prettier": "^2.6.2",
+    "prettier": "^3.2.5",
     "prettier-plugin-organize-imports": "^3.2.4",
     "prisma": "^5.8.1",
     "supertest": "^6.3.4",

packages/authz-shared/src/lib/util/enum.util.ts

@@ -29,17 +29,20 @@ export const convertEnums = <T extends Record<string, string>>(
   enumMap: EnumMap<T>,
   data: T
 ): EnumConverted<T, EnumMap<T>> => {
-  return Object.entries(data).reduce((acc, [key, value]) => {
-    if (key in enumMap) {
-      acc[key as keyof T] = toEnum(enumMap[key as keyof EnumMap<T>], value) as EnumConverted<T, EnumMap<T>>[keyof T]
-      if (acc[key] === undefined || acc[key] === null) {
-        throw new Error(`Invalid enum value for key ${key}: ${value}`)
+  return Object.entries(data).reduce(
+    (acc, [key, value]) => {
+      if (key in enumMap) {
+        acc[key as keyof T] = toEnum(enumMap[key as keyof EnumMap<T>], value) as EnumConverted<T, EnumMap<T>>[keyof T]
+        if (acc[key] === undefined || acc[key] === null) {
+          throw new Error(`Invalid enum value for key ${key}: ${value}`)
+        }
+      } else {
+        acc[key as keyof T] = value as EnumConverted<T, EnumMap<T>>[keyof T]
       }
-    } else {
-      acc[key as keyof T] = value as EnumConverted<T, EnumMap<T>>[keyof T]
-    }
-    return acc
-  }, {} as EnumConverted<T, EnumMap<T>>)
+      return acc
+    },
+    {} as EnumConverted<T, EnumMap<T>>
+  )
 }
 
 export const convertEnumsArray = <T extends Record<string, string>>(