fix: use fastify native parser for xml

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

Author: ferhatelmas

package-lock.json

@@ -70,7 +70,6 @@
     "dotenv": "^16.0.0",
     "fastify": "^5.7.4",
     "fastify-plugin": "^5.1.0",
-    "fastify-xml-body-parser": "^2.2.0",
     "fs-extra": "^10.0.1",
     "fs-xattr": "0.3.1",
     "ioredis": "^5.2.4",

package.json

@@ -1,25 +1,86 @@
 import accepts from '@fastify/accepts'
 import { FastifyInstance } from 'fastify'
 import fastifyPlugin from 'fastify-plugin'
-// no types exists for this package
-// @ts-ignore
-import xmlBodyParser from 'fastify-xml-body-parser'
 import xml from 'xml2js'
 
+type XmlParserOptions = { disableContentParser?: boolean; parseAsArray?: string[] }
+type RequestError = Error & { statusCode?: number }
+
+function forcePathAsArray(node: unknown, pathSegments: string[]): void {
+  if (pathSegments.length === 0 || node === null || node === undefined) {
+    return
+  }
+
+  if (Array.isArray(node)) {
+    node.forEach((item) => forcePathAsArray(item, pathSegments))
+    return
+  }
+
+  if (typeof node !== 'object') {
+    return
+  }
+
+  const [current, ...rest] = pathSegments
+  const currentRecord = node as Record<string, unknown>
+
+  if (!(current in currentRecord)) {
+    return
+  }
+
+  if (rest.length === 0) {
+    const value = currentRecord[current]
+    if (value !== undefined && !Array.isArray(value)) {
+      currentRecord[current] = [value]
+    }
+    return
+  }
+
+  forcePathAsArray(currentRecord[current], rest)
+}
+
 export const xmlParser = fastifyPlugin(
-  async function (
-    fastify: FastifyInstance,
-    opts: { disableContentParser?: boolean; parseAsArray?: string[] }
-  ) {
+  async function (fastify: FastifyInstance, opts: XmlParserOptions) {
     fastify.register(accepts)
 
     if (!opts.disableContentParser) {
-      fastify.register(xmlBodyParser, {
-        contentType: ['text/xml', 'application/xml'],
-        isArray: (_: string, jpath: string) => {
-          return opts.parseAsArray?.includes(jpath)
-        },
-      })
+      fastify.addContentTypeParser(
+        ['text/xml', 'application/xml'],
+        { parseAs: 'string' },
+        (_request, body, done) => {
+          if (!body) {
+            done(null, null)
+            return
+          }
+
+          xml.parseString(
+            body,
+            {
+              explicitArray: false,
+              trim: true,
+              valueProcessors: [xml.processors.parseNumbers, xml.processors.parseBooleans],
+            },
+            (err: Error | null, parsed: unknown) => {
+              if (err) {
+                const parseError: RequestError = new Error(`Invalid XML payload: ${err.message}`)
+                parseError.statusCode = 400
+                done(parseError)
+                return
+              }
+
+              if (parsed && opts.parseAsArray?.length) {
+                opts.parseAsArray.forEach((path) => {
+                  if (!path) {
+                    return
+                  }
+                  forcePathAsArray(parsed, path.split('.'))
+                })
+              }
+
+              done(null, parsed)
+            }
+          )
+        }
+      )
     }
 
     fastify.addHook('preSerialization', async (req, res, payload) => {

src/http/plugins/xml.ts

@@ -1,7 +1,6 @@
 import { ERRORS } from '@internal/errors'
 import { Obj } from '@storage/schemas'
 import { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify'
-import { IncomingMessage, Server, ServerResponse } from 'http'
 import { FromSchema } from 'json-schema-to-ts'
 import { getConfig } from '../../../config'
 import { AuthenticatedRangeRequest } from '../../types'
@@ -30,16 +29,9 @@ interface getObjectRequestInterface extends AuthenticatedRangeRequest {
   Querystring: FromSchema<typeof getObjectQuerySchema>
 }
 
-async function requestHandler(
-  request: FastifyRequest<getObjectRequestInterface, Server, IncomingMessage>,
-  response: FastifyReply<
-    getObjectRequestInterface,
-    Server,
-    IncomingMessage,
-    ServerResponse,
-    unknown
-  >
-) {
+type GetObjectRequest = FastifyRequest<getObjectRequestInterface>
+
+async function requestHandler(request: GetObjectRequest, response: FastifyReply) {
   const { bucketName } = request.params
   const { download } = request.query
   const objectName = request.params['*']

src/http/routes/object/getObject.ts

@@ -1,7 +1,6 @@
 import { ERRORS } from '@internal/errors'
 import { Obj } from '@storage/schemas'
 import { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify'
-import { IncomingMessage, Server, ServerResponse } from 'http'
 import { FromSchema } from 'json-schema-to-ts'
 import { getConfig } from '../../../config'
 import { AuthenticatedRangeRequest } from '../../types'
@@ -22,15 +21,11 @@ interface getObjectRequestInterface extends AuthenticatedRangeRequest {
   Params: FromSchema<typeof getObjectParamsSchema>
 }
 
+type GetObjectInfoRequest = FastifyRequest<getObjectRequestInterface>
+
 async function requestHandler(
-  request: FastifyRequest<getObjectRequestInterface, Server, IncomingMessage>,
-  response: FastifyReply<
-    getObjectRequestInterface,
-    Server,
-    IncomingMessage,
-    ServerResponse,
-    unknown
-  >,
+  request: GetObjectInfoRequest,
+  response: FastifyReply,
   publicRoute = false,
   method: 'head' | 'info' = 'head'
 ) {