fix: no any rule

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>
   }
 }
 
@@ -58,11 +64,12 @@ export const logRequest = (options: RequestLoggerOptions) =>
        */
       fastify.addHook('preHandler', async (req) => {
         const resourceFromParams = Object.values(req.params || {}).join('/')
+        const rawReq = getRawRequest(req)
         const resources = getFirstDefined<string[]>(
           req.resources,
           req.routeOptions.config.resources?.(req),
-          (req.raw as any).resources,
-          resourceFromParams ? [resourceFromParams] : ([] as string[])
+          rawReq.resources,
+          resourceFromParams ? [resourceFromParams] : []
         )
 
         if (resources && resources.length > 0) {
@@ -123,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> = {}
@@ -171,7 +178,11 @@ function doRequestLog(req: FastifyRequest, options: LogRequestOptions) {
   })
 }
 
-function getFirstDefined<T>(...values: any[]): T | undefined {
+function getRawRequest(req: FastifyRequest): RawRequestMetadata {
+  return req.raw as RawRequestMetadata
+}
+
+function getFirstDefined<T>(...values: (T | undefined)[]): T | undefined {
   for (const value of values) {
     if (value !== undefined) {
       return value

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

@@ -12,6 +12,15 @@ import apiKey from '../../plugins/apikey'
 
 const { pgQueueEnable } = getConfig()
 
+type ResetFleetBody = {
+  untilMigration?: unknown
+  markCompletedTillMigration?: unknown
+}
+
+type FailedQuery = {
+  cursor?: string
+}
+
 export default async function routes(fastify: FastifyInstance) {
   fastify.register(apiKey)
 
@@ -30,7 +39,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' })
@@ -95,7 +104,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,
       },
     })
   }
@@ -78,7 +84,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)
 

src/http/routes/s3/router.ts

@@ -114,7 +114,7 @@ type Route<S extends Schema, Context> = {
   compiledSchema: () => ValidateFunction<JTDDataType<S>>
 }
 
-interface RouteOptions<S extends JSONSchema> {
+interface RouteOptions<S extends Schema> {
   disableContentTypeParser?: boolean
   acceptMultiformData?: boolean
   operation: string
@@ -134,11 +134,11 @@ export class Router<Context = unknown, S extends Schema = Schema> {
     allErrors: false,
   })
 
-  registerRoute<R extends S = S>(
+  registerRoute(
     method: HTTPMethod,
     url: string,
-    options: RouteOptions<R>,
-    handler: Handler<R, Context>
+    options: RouteOptions<Schema>,
+    handler: Handler<Schema, Context>
   ) {
     const { query, headers } = this.parseRequestInfo(url)
     const normalizedUrl = url.split('?')[0].split('|')[0]
@@ -194,14 +194,15 @@ export class Router<Context = unknown, S extends Schema = Schema> {
       )
     }
 
-    const newRoute: Route<R, Context> = {
+    const newRoute: Route<Schema, Context> = {
       method: method as HTTPMethod,
       path: normalizedUrl,
       querystringMatches: query,
       headersMatches: headers,
       schema,
-      compiledSchema: () => this.ajv.getSchema(method + url) as ValidateFunction<JTDDataType<R>>,
-      handler: handler as Handler<R, Context>,
+      compiledSchema: () =>
+        this.ajv.getSchema(method + url) as ValidateFunction<JTDDataType<Schema>>,
+      handler,
       disableContentTypeParser,
       acceptMultiformData,
       operation,
@@ -217,24 +218,58 @@ export class Router<Context = unknown, S extends Schema = Schema> {
     this._routes.set(normalizedUrl, existingPath)
   }
 
-  get<R extends S>(url: string, options: RouteOptions<R>, handler: Handler<R, Context>) {
-    this.registerRoute('get', url, options, handler as any)
+  private registerRouteUnsafe(
+    method: HTTPMethod,
+    url: string,
+    options: RouteOptions<Schema>,
+    handler: Handler<Schema, Context>
+  ) {
+    this.registerRoute(method, url, options, handler)
+  }
+
+  get<R extends Schema>(url: string, options: RouteOptions<R>, handler: Handler<R, Context>) {
+    this.registerRouteUnsafe(
+      'get',
+      url,
+      options as unknown as RouteOptions<Schema>,
+      handler as unknown as Handler<Schema, Context>
+    )
   }
 
-  post<R extends S = S>(url: string, options: RouteOptions<R>, handler: Handler<R, Context>) {
-    this.registerRoute('post', url, options, handler as any)
+  post<R extends Schema>(url: string, options: RouteOptions<R>, handler: Handler<R, Context>) {
+    this.registerRouteUnsafe(
+      'post',
+      url,
+      options as unknown as RouteOptions<Schema>,
+      handler as unknown as Handler<Schema, Context>
+    )
   }
 
-  put<R extends S = S>(url: string, options: RouteOptions<R>, handler: Handler<R, Context>) {
-    this.registerRoute('put', url, options, handler as any)
+  put<R extends Schema>(url: string, options: RouteOptions<R>, handler: Handler<R, Context>) {
+    this.registerRouteUnsafe(
+      'put',
+      url,
+      options as unknown as RouteOptions<Schema>,
+      handler as unknown as Handler<Schema, Context>
+    )
   }
 
-  delete<R extends S = S>(url: string, options: RouteOptions<R>, handler: Handler<R, Context>) {
-    this.registerRoute('delete', url, options, handler as any)
+  delete<R extends Schema>(url: string, options: RouteOptions<R>, handler: Handler<R, Context>) {
+    this.registerRouteUnsafe(
+      'delete',
+      url,
+      options as unknown as RouteOptions<Schema>,
+      handler as unknown as Handler<Schema, Context>
+    )
   }
 
-  head<R extends S = S>(url: string, options: RouteOptions<R>, handler: Handler<R, Context>) {
-    this.registerRoute('head', url, options, handler as any)
+  head<R extends Schema>(url: string, options: RouteOptions<R>, handler: Handler<R, Context>) {
+    this.registerRouteUnsafe(
+      'head',
+      url,
+      options as unknown as RouteOptions<Schema>,
+      handler as unknown as Handler<Schema, Context>
+    )
   }
 
   parseQueryMatch(query: string) {

src/http/routes/tus/lifecycle.ts

@@ -31,6 +31,7 @@ function getNodeRequest(rawReq: Request): MultiPartRequest {
   return req
 }
 export type MultiPartRequest = http.IncomingMessage & {
+  executionError?: Error
   log: BaseLogger
   upload: {
     storage: Storage
@@ -282,8 +283,9 @@ export async function onUploadFinish(rawReq: Request, upload: Upload) {
     }
   } catch (e) {
     if (isRenderableError(e)) {
-      ;(e as any).status_code = parseInt(e.render().statusCode, 10)
-      ;(e as any).body = e.render().message
+      const renderableError = e as unknown as Error & Partial<TusError>
+      renderableError.status_code = parseInt(e.render().statusCode, 10)
+      renderableError.body = e.render().message
     }
     throw e
   }
@@ -298,9 +300,9 @@ export function onResponseError(rawReq: Request, e: TusError | Error) {
   const req = getNodeRequest(rawReq)
 
   if (e instanceof Error) {
-    ;(req as any).executionError = e
+    req.executionError = e
   } else {
-    ;(req as any).executionError = ERRORS.TusError(e.body, e.status_code).withMetadata(e)
+    req.executionError = ERRORS.TusError(e.body, e.status_code).withMetadata(e)
   }
 
   if (isRenderableError(e)) {

src/http/routes/vector/query-vectors.ts

@@ -112,7 +112,7 @@ export default async function routes(fastify: FastifyInstance) {
     coerceTypes: false,
   })
 
-  const perRouteValidator: FastifySchemaCompiler<any> = ({ schema }) => {
+  const perRouteValidator: FastifySchemaCompiler<unknown> = ({ schema }) => {
     const validate = ajvNoRemoval.compile(schema as object)
     return (data) => {
       const ok = validate(data)