Class DocxParser

apps/sim/lib/file-parsers/docx-parser.ts:20–110

}

export class DocxParser implements FileParser {
  async parseFile(filePath: string): Promise<FileParseResult> {
    try {
      if (!filePath) {
        throw new Error('No file path provided')
      }

      const buffer = await readFile(filePath)
      return this.parseBuffer(buffer)
    } catch (error) {
      logger.error('DOCX file error:', error)
      throw new Error(`Failed to parse DOCX file: ${(error as Error).message}`)
    }
  }

  async parseBuffer(buffer: Buffer): Promise<FileParseResult> {
    try {
      if (!buffer || buffer.length === 0) {
        throw new Error('Empty buffer provided')
      }

      assertOoxmlArchiveWithinLimits(buffer)

      try {
        const result = await mammoth.extractRawText({ buffer })

        if (result.value && result.value.trim().length > 0) {
          let htmlResult: MammothResult = { value: '', messages: [] }
          try {
            htmlResult = await mammoth.convertToHtml({ buffer })
          } catch {
            // HTML conversion is optional
          }

          return {
            content: sanitizeTextForUTF8(result.value),
            metadata: {
              extractionMethod: 'mammoth',
              messages: [...result.messages, ...htmlResult.messages],
              html: htmlResult.value,
            },
          }
        }
      } catch (mammothError) {
        logger.warn('mammoth failed, trying officeparser:', mammothError)
      }

      try {
        const officeParser = await import('officeparser')
        const result = await officeParser.parseOfficeAsync(buffer)

        if (result) {
          const resultString = typeof result === 'string' ? result : String(result)
          const content = sanitizeTextForUTF8(resultString.trim())

          if (content.length > 0) {
            return {
              content,