fix: no any rule

Signed-off-by: ferhat elmas <elmas.ferhat@gmail.com>

Author: ferhatelmas

biome.jsonc

@@ -42,7 +42,7 @@
         "noAssignInExpressions": "error",
         "noAsyncPromiseExecutor": "error",
         "noDoubleEquals": "error",
-        "noExplicitAny": "warn",
+        "noExplicitAny": "error",
         "noFocusedTests": "error",
         "noImplicitAnyLet": "error",
         "noShadowRestrictedNames": "error",

src/http/error-handler.ts

@@ -14,7 +14,7 @@ export const setErrorHandler = (
   app: FastifyInstance,
   options?: {
     respectStatusCode?: boolean
-    formatter?: (error: StorageError) => Record<string, any>
+    formatter?: (error: StorageError) => unknown
   }
 ) => {
   app.setErrorHandler<Error>(function (error, request, reply) {

src/http/plugins/log-request.ts

@@ -1,4 +1,5 @@
 import { logger, logSchema, redactQueryParamFromRequest } from '@internal/monitoring'
+import { RouteGenericInterface } from 'fastify'
 import { FastifyReply } from 'fastify/types/reply'
 import { FastifyRequest } from 'fastify/types/request'
 import fastifyPlugin from 'fastify-plugin'
@@ -7,6 +8,11 @@ interface RequestLoggerOptions {
   excludeUrls?: string[]
 }
 
+type RawRequestMetadata = FastifyRequest['raw'] & {
+  executionError?: Error
+  resources?: string[]
+}
+
 declare module 'fastify' {
   interface FastifyRequest {
     executionError?: Error
@@ -18,8 +24,8 @@ declare module 'fastify' {
 
   interface FastifyContextConfig {
     operation?: { type: string }
-    resources?: (req: FastifyRequest<any>) => string[]
-    logMetadata?: (req: FastifyRequest<any>) => Record<string, unknown>
+    resources?(req: FastifyRequest<RouteGenericInterface>): string[]
+    logMetadata?(req: FastifyRequest<RouteGenericInterface>): Record<string, unknown>
   }
 }
 
@@ -57,39 +63,13 @@ export const logRequest = (options: RequestLoggerOptions) =>
        * Adds req.resources and req.operation to the request object
        */
       fastify.addHook('preHandler', async (req) => {
-        let resources = req.resources
-
-        if (resources === undefined) {
-          resources = req.routeOptions.config.resources?.(req)
-        }
-
-        if (resources === undefined) {
-          resources = (req.raw as any).resources
-        }
-
-        if (resources === undefined) {
-          const params = req.params as Record<string, unknown> | undefined
-          let resourceFromParams = ''
-
-          if (params) {
-            let first = true
-            for (const key in params) {
-              if (!Object.prototype.hasOwnProperty.call(params, key)) {
-                continue
-              }
-
-              if (!first) {
-                resourceFromParams += '/'
-              }
-
-              const value = params[key]
-              resourceFromParams += value == null ? '' : String(value)
-              first = false
-            }
-          }
-
-          resources = resourceFromParams ? [resourceFromParams] : []
-        }
+        const resourceFromParams = getResourceFromParams(req.params)
+        const resources = getFirstDefined<string[]>(
+          req.resources,
+          req.routeOptions.config.resources?.(req),
+          getRawRequest(req).resources,
+          resourceFromParams ? [resourceFromParams] : []
+        )
 
         if (resources && resources.length > 0) {
           for (let index = 0; index < resources.length; index++) {
@@ -150,7 +130,7 @@ function doRequestLog(req: FastifyRequest, options: LogRequestOptions) {
   const rId = req.id
   const cIP = req.ip
   const statusCode = options.statusCode
-  const error = (req.raw as any).executionError || req.executionError
+  const error = getRawRequest(req).executionError || req.executionError
   const tenantId = req.tenantId
 
   let reqMetadata: Record<string, unknown> = {}
@@ -197,3 +177,41 @@ function doRequestLog(req: FastifyRequest, options: LogRequestOptions) {
     serverTimes: req.serverTimings,
   })
 }
+
+function getRawRequest(req: FastifyRequest): RawRequestMetadata {
+  return req.raw as RawRequestMetadata
+}
+
+function getResourceFromParams(params: unknown): string {
+  if (!params || typeof params !== 'object') {
+    return ''
+  }
+
+  let resource = ''
+  let first = true
+
+  for (const key in params) {
+    if (!Object.prototype.hasOwnProperty.call(params, key)) {
+      continue
+    }
+
+    if (!first) {
+      resource += '/'
+    }
+
+    const value = (params as Record<string, unknown>)[key]
+    resource += value == null ? '' : String(value)
+    first = false
+  }
+
+  return resource
+}
+
+function getFirstDefined<T>(...values: (T | undefined)[]): T | undefined {
+  for (const value of values) {
+    if (value !== undefined) {
+      return value
+    }
+  }
+  return undefined
+}

src/http/routes-helper.ts

@@ -1,4 +1,5 @@
 type BucketResponseType = { message: string; statusCode?: string; error?: string }
+type SchemaObject = Record<string, unknown>
 
 /**
  * Create generic response for all buckets
@@ -23,7 +24,10 @@ function createResponse(message: string, status?: string, error?: string): Bucke
   return response
 }
 
-function createDefaultSchema(successResponseSchema: any, properties: any): any {
+function createDefaultSchema(
+  successResponseSchema: SchemaObject,
+  properties: SchemaObject
+): SchemaObject {
   return {
     headers: { $ref: 'authSchema#' },
     response: {

src/http/routes/admin/migrations.ts

@@ -13,6 +13,15 @@ import apiKey from '../../plugins/apikey'
 const { pgQueueEnable } = getConfig()
 const migrationQueueName = RunMigrationsOnTenants.getQueueName()
 
+type ResetFleetBody = {
+  untilMigration?: unknown
+  markCompletedTillMigration?: unknown
+}
+
+type FailedQuery = {
+  cursor?: string
+}
+
 export default async function routes(fastify: FastifyInstance) {
   fastify.register(apiKey)
 
@@ -31,7 +40,7 @@ export default async function routes(fastify: FastifyInstance) {
       return reply.status(400).send({ message: 'Queue is not enabled' })
     }
 
-    const { untilMigration, markCompletedTillMigration } = req.body as Record<string, unknown>
+    const { untilMigration, markCompletedTillMigration } = req.body as ResetFleetBody
 
     if (!isDBMigrationName(untilMigration)) {
       return reply.status(400).send({ message: 'Invalid migration' })
@@ -96,7 +105,8 @@ export default async function routes(fastify: FastifyInstance) {
     if (!pgQueueEnable) {
       return reply.code(400).send({ message: 'Queue is not enabled' })
     }
-    const offset = (req.query as any).cursor ? Number((req.query as any).cursor) : 0
+    const { cursor } = req.query as FailedQuery
+    const offset = cursor ? Number(cursor) : 0
 
     const failed = await multitenantKnex
       .table('tenants')

src/http/routes/iceberg/table.ts

@@ -518,12 +518,10 @@ export default async function routes(fastify: FastifyInstance) {
       try {
         if (typeof payload === 'string') return done(null, JSONBigint.parse(payload))
         if (Buffer.isBuffer(payload)) return done(null, JSONBigint.parse(payload.toString('utf8')))
-        if (payload && typeof (payload as any).on === 'function') {
+        if (isReadablePayload(payload)) {
           const chunks: Buffer[] = []
-          ;(payload as NodeJS.ReadableStream).on('data', (c) =>
-            chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(String(c)))
-          )
-          ;(payload as NodeJS.ReadableStream).on('end', () => {
+          payload.on('data', (c) => chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(String(c))))
+          payload.on('end', () => {
             try {
               done(null, JSONBigint.parse(Buffer.concat(chunks).toString('utf8')))
             } catch (err) {
@@ -574,3 +572,9 @@ export default async function routes(fastify: FastifyInstance) {
     )
   })
 }
+
+function isReadablePayload(payload: unknown): payload is NodeJS.ReadableStream {
+  return (
+    !!payload && typeof payload === 'object' && 'on' in payload && typeof payload.on === 'function'
+  )
+}

src/http/routes/render/rate-limiter.ts

@@ -13,7 +13,7 @@ const {
   rateLimiterRenderPathMaxReqSec,
 } = getConfig()
 
-export const rateLimiter = fp((fastify: FastifyInstance, ops: any, done: () => void) => {
+export const rateLimiter = fp((fastify: FastifyInstance, _ops: unknown, done: () => void) => {
   fastify.register(fastifyRateLimit, {
     global: true,
     max: rateLimiterRenderPathMaxReqSec * 4,

src/http/routes/s3/error-handler.ts

@@ -5,12 +5,18 @@ import { FastifyReply } from 'fastify/types/reply'
 import { FastifyRequest } from 'fastify/types/request'
 import { DatabaseError } from 'pg'
 
+type ValidationIssue = {
+  instancePath?: string
+  message?: string
+}
+
 export const s3ErrorHandler = (
   error: FastifyError | Error,
   request: FastifyRequest,
   reply: FastifyReply
 ) => {
   request.executionError = error
+  const validation = getValidationIssues(error)
 
   const resource = request.url
     .split('?')[0]
@@ -19,12 +25,12 @@ export const s3ErrorHandler = (
     .filter((e) => e)
     .join('/')
 
-  if ('validation' in error) {
+  if (validation) {
     return reply.status(400).send({
       Error: {
         Resource: resource,
         Code: ErrorCode.InvalidRequest,
-        Message: formatValidationError(error.validation).message,
+        Message: formatValidationError(validation).message,
       },
     })
   }
@@ -91,7 +97,20 @@ export const s3ErrorHandler = (
   })
 }
 
-function formatValidationError(errors: any) {
+function isValidationIssueArray(value: unknown): value is ValidationIssue[] {
+  return Array.isArray(value)
+}
+
+function getValidationIssues(error: FastifyError | Error): ValidationIssue[] | undefined {
+  if (!('validation' in error)) {
+    return undefined
+  }
+
+  const value = error.validation
+  return isValidationIssueArray(value) ? value : undefined
+}
+
+function formatValidationError(errors: readonly ValidationIssue[]) {
   let text = ''
   const separator = ', '
 

src/http/routes/s3/index.ts

@@ -66,12 +66,12 @@ export default async function routes(fastify: FastifyInstance) {
                   req.opentelemetry()?.span?.setAttribute('http.operation', req.operation.type)
                 }
 
-                const data: RequestInput<any> = {
+                const data = {
                   Params: req.params,
                   Body: req.body,
                   Headers: req.headers,
                   Querystring: req.query,
-                }
+                } as unknown as RequestInput<typeof route.schema>
                 const compiler = route.compiledSchema()
                 const isValid = compiler(data)