msa-parsers 1.0.3

package/src/gff/gffToInterPro.test.ts

@@ -0,0 +1,202 @@
+import { describe, expect, test } from 'vitest'
+
+import { gffToInterProResponse, gffToInterProResults } from './gffToInterPro'
+
+import type { GFFRecord } from '../types'
+
+describe('gffToInterProResults', () => {
+  test('converts empty array', () => {
+    expect(gffToInterProResults([])).toEqual({})
+  })
+
+  test('converts single GFF record', () => {
+    const records: GFFRecord[] = [
+      {
+        seq_id: 'seq1',
+        source: 'Pfam',
+        type: 'protein_match',
+        start: 10,
+        end: 50,
+        score: 0,
+        strand: '.',
+        phase: '.',
+        Name: 'PF00001',
+        signature_desc: '7tm_1',
+        description: 'GPCR family',
+      },
+    ]
+    const result = gffToInterProResults(records)
+
+    expect(result).toHaveProperty('seq1')
+    expect(result.seq1?.matches).toHaveLength(1)
+    expect(result.seq1?.matches[0]?.signature.entry).toEqual({
+      accession: 'PF00001',
+      name: '7tm_1',
+      description: 'GPCR family',
+    })
+    expect(result.seq1?.matches[0]?.locations).toEqual([{ start: 10, end: 50 }])
+    expect(result.seq1?.xref).toEqual([{ id: 'seq1' }])
+  })
+
+  test('groups multiple records for same sequence', () => {
+    const records: GFFRecord[] = [
+      {
+        seq_id: 'seq1',
+        source: 'Pfam',
+        type: 'protein_match',
+        start: 10,
+        end: 50,
+        score: 0,
+        strand: '.',
+        phase: '.',
+        Name: 'PF00001',
+      },
+      {
+        seq_id: 'seq1',
+        source: 'SMART',
+        type: 'protein_match',
+        start: 60,
+        end: 100,
+        score: 0,
+        strand: '.',
+        phase: '.',
+        Name: 'SM00001',
+      },
+    ]
+    const result = gffToInterProResults(records)
+
+    expect(Object.keys(result)).toHaveLength(1)
+    expect(result.seq1?.matches).toHaveLength(2)
+  })
+
+  test('handles multiple sequences', () => {
+    const records: GFFRecord[] = [
+      {
+        seq_id: 'seq1',
+        source: 'Pfam',
+        type: 'protein_match',
+        start: 10,
+        end: 50,
+        score: 0,
+        strand: '.',
+        phase: '.',
+        Name: 'PF00001',
+      },
+      {
+        seq_id: 'seq2',
+        source: 'Pfam',
+        type: 'protein_match',
+        start: 5,
+        end: 40,
+        score: 0,
+        strand: '.',
+        phase: '.',
+        Name: 'PF00002',
+      },
+    ]
+    const result = gffToInterProResults(records)
+
+    expect(Object.keys(result)).toHaveLength(2)
+    expect(result).toHaveProperty('seq1')
+    expect(result).toHaveProperty('seq2')
+  })
+
+  test('combines locations for same accession', () => {
+    const records: GFFRecord[] = [
+      {
+        seq_id: 'seq1',
+        source: 'Pfam',
+        type: 'protein_match',
+        start: 10,
+        end: 50,
+        score: 0,
+        strand: '.',
+        phase: '.',
+        Name: 'PF00001',
+      },
+      {
+        seq_id: 'seq1',
+        source: 'Pfam',
+        type: 'protein_match',
+        start: 100,
+        end: 150,
+        score: 0,
+        strand: '.',
+        phase: '.',
+        Name: 'PF00001',
+      },
+    ]
+    const result = gffToInterProResults(records)
+
+    expect(result.seq1?.matches).toHaveLength(1)
+    expect(result.seq1?.matches[0]?.locations).toHaveLength(2)
+    expect(result.seq1?.matches[0]?.locations).toEqual([
+      { start: 10, end: 50 },
+      { start: 100, end: 150 },
+    ])
+  })
+
+  test('uses ID as fallback for Name', () => {
+    const records: GFFRecord[] = [
+      {
+        seq_id: 'seq1',
+        source: 'Source',
+        type: 'protein_match',
+        start: 10,
+        end: 50,
+        score: 0,
+        strand: '.',
+        phase: '.',
+        ID: 'domain_123',
+      },
+    ]
+    const result = gffToInterProResults(records)
+
+    expect(result.seq1?.matches[0]?.signature.entry?.accession).toBe(
+      'domain_123',
+    )
+  })
+
+  test('generates fallback accession from source and positions', () => {
+    const records: GFFRecord[] = [
+      {
+        seq_id: 'seq1',
+        source: 'CustomSource',
+        type: 'protein_match',
+        start: 10,
+        end: 50,
+        score: 0,
+        strand: '.',
+        phase: '.',
+      },
+    ]
+    const result = gffToInterProResults(records)
+
+    expect(result.seq1?.matches[0]?.signature.entry?.accession).toBe(
+      'CustomSource_10_50',
+    )
+  })
+})
+
+describe('gffToInterProResponse', () => {
+  test('wraps results in response format', () => {
+    const records: GFFRecord[] = [
+      {
+        seq_id: 'seq1',
+        source: 'Pfam',
+        type: 'protein_match',
+        start: 10,
+        end: 50,
+        score: 0,
+        strand: '.',
+        phase: '.',
+        Name: 'PF00001',
+      },
+    ]
+    const response = gffToInterProResponse(records)
+
+    expect(response).toHaveProperty('results')
+    expect(response.results).toHaveLength(1)
+    expect(response.results[0]?.xref[0]?.id).toBe('seq1')
+  })
+})

package/src/gff/gffToInterPro.ts

@@ -0,0 +1,113 @@
+import type {
+  GFFRecord,
+  InterProScanResponse,
+  InterProScanResults,
+} from '../types'
+
+/**
+ * Convert GFF records to InterProScan format
+ *
+ * InterProScan GFF3 output format:
+ * - seq_id: sequence identifier
+ * - source: database/signature (e.g., "Pfam", "SMART")
+ * - type: usually "protein_match"
+ * - start/end: domain positions (1-based)
+ * - Attributes: Name (accession), signature_desc (name), Dbxref, etc.
+ */
+export function gffToInterProResults(
+  gffRecords: GFFRecord[],
+): Record<string, InterProScanResults> {
+  const bySequence = new Map<string, GFFRecord[]>()
+
+  for (const record of gffRecords) {
+    const existing = bySequence.get(record.seq_id)
+    if (existing) {
+      existing.push(record)
+    } else {
+      bySequence.set(record.seq_id, [record])
+    }
+  }
+
+  const results: Record<string, InterProScanResults> = {}
+
+  for (const [seqId, records] of bySequence) {
+    const matchesByAccession = new Map<
+      string,
+      { start: number; end: number }[]
+    >()
+    const matchInfo = new Map<
+      string,
+      { name: string; description: string; accession: string }
+    >()
+
+    for (const record of records) {
+      const accession =
+        (record.Name as string) ||
+        (record.ID as string) ||
+        `${record.source}_${record.start}_${record.end}`
+      const name =
+        (record.signature_desc as string) ||
+        (record.Name as string) ||
+        accession
+      const description =
+        (record.Ontology_term as string) ||
+        (record.description as string) ||
+        (record.Note as string) ||
+        name
+
+      if (!matchInfo.has(accession)) {
+        matchInfo.set(accession, { name, description, accession })
+      }
+
+      const locations = matchesByAccession.get(accession)
+      if (locations) {
+        locations.push({ start: record.start, end: record.end })
+      } else {
+        matchesByAccession.set(accession, [
+          { start: record.start, end: record.end },
+        ])
+      }
+    }
+
+    const matches = []
+    for (const [accession, locations] of matchesByAccession) {
+      const info = matchInfo.get(accession)!
+      matches.push({
+        signature: {
+          entry: info,
+        },
+        locations,
+      })
+    }
+
+    results[seqId] = {
+      matches,
+      xref: [{ id: seqId }],
+    }
+  }
+
+  return results
+}
+
+/**
+ * Convert GFF string directly to InterProScan format
+ */
+export function parseGFFToInterPro(
+  gffStr: string,
+  parseGFFfn: (str: string) => GFFRecord[],
+): Record<string, InterProScanResults> {
+  const records = parseGFFfn(gffStr)
+  return gffToInterProResults(records)
+}
+
+/**
+ * Create a full InterProScanResponse from GFF records
+ */
+export function gffToInterProResponse(
+  gffRecords: GFFRecord[],
+): InterProScanResponse {
+  const resultsMap = gffToInterProResults(gffRecords)
+  return {
+    results: Object.values(resultsMap),
+  }
+}

package/src/gff/index.ts

@@ -0,0 +1,3 @@
+export { parseGFF } from './parseGFF'
+export { gffToInterProResponse, gffToInterProResults } from './gffToInterPro'
+export { interProResponseToGFF, interProToGFF } from './interProToGFF'

package/src/gff/interProToGFF.test.ts

@@ -0,0 +1,206 @@
+import { describe, expect, test } from 'vitest'
+
+import { interProResponseToGFF, interProToGFF } from './interProToGFF'
+
+import type { InterProScanResults } from '../types'
+
+describe('interProToGFF', () => {
+  test('converts empty results', () => {
+    const gff = interProToGFF({})
+    expect(gff).toBe('##gff-version 3')
+  })
+
+  test('converts single result', () => {
+    const results: Record<string, InterProScanResults> = {
+      seq1: {
+        matches: [
+          {
+            signature: {
+              entry: {
+                accession: 'PF00001',
+                name: '7tm_1',
+                description: 'GPCR family',
+              },
+            },
+            locations: [{ start: 10, end: 50 }],
+          },
+        ],
+        xref: [{ id: 'seq1' }],
+      },
+    }
+    const gff = interProToGFF(results)
+    const lines = gff.split('\n')
+
+    expect(lines[0]).toBe('##gff-version 3')
+    expect(lines[1]).toContain('seq1')
+    expect(lines[1]).toContain('InterProScan')
+    expect(lines[1]).toContain('protein_match')
+    expect(lines[1]).toContain('10')
+    expect(lines[1]).toContain('50')
+    expect(lines[1]).toContain('Name=PF00001')
+    expect(lines[1]).toContain('signature_desc=7tm_1')
+    expect(lines[1]).toContain('description=GPCR%20family')
+  })
+
+  test('handles multiple locations', () => {
+    const results: Record<string, InterProScanResults> = {
+      seq1: {
+        matches: [
+          {
+            signature: {
+              entry: {
+                accession: 'PF00001',
+                name: 'domain',
+                description: 'test',
+              },
+            },
+            locations: [
+              { start: 10, end: 50 },
+              { start: 100, end: 150 },
+            ],
+          },
+        ],
+        xref: [{ id: 'seq1' }],
+      },
+    }
+    const gff = interProToGFF(results)
+    const lines = gff.split('\n')
+
+    expect(lines).toHaveLength(3)
+    expect(lines[1]).toContain('10\t50')
+    expect(lines[2]).toContain('100\t150')
+  })
+
+  test('handles multiple sequences', () => {
+    const results: Record<string, InterProScanResults> = {
+      seq1: {
+        matches: [
+          {
+            signature: {
+              entry: {
+                accession: 'PF00001',
+                name: 'domain1',
+                description: 'test1',
+              },
+            },
+            locations: [{ start: 10, end: 50 }],
+          },
+        ],
+        xref: [{ id: 'seq1' }],
+      },
+      seq2: {
+        matches: [
+          {
+            signature: {
+              entry: {
+                accession: 'PF00002',
+                name: 'domain2',
+                description: 'test2',
+              },
+            },
+            locations: [{ start: 5, end: 40 }],
+          },
+        ],
+        xref: [{ id: 'seq2' }],
+      },
+    }
+    const gff = interProToGFF(results)
+    const lines = gff.split('\n')
+
+    expect(lines).toHaveLength(3)
+    expect(lines.some(l => l.includes('seq1'))).toBe(true)
+    expect(lines.some(l => l.includes('seq2'))).toBe(true)
+  })
+
+  test('skips matches without entry', () => {
+    const results: Record<string, InterProScanResults> = {
+      seq1: {
+        matches: [
+          {
+            signature: {},
+            locations: [{ start: 10, end: 50 }],
+          },
+        ],
+        xref: [{ id: 'seq1' }],
+      },
+    }
+    const gff = interProToGFF(results)
+    const lines = gff.split('\n')
+
+    expect(lines).toHaveLength(1)
+    expect(lines[0]).toBe('##gff-version 3')
+  })
+
+  test('URL-encodes special characters in attributes', () => {
+    const results: Record<string, InterProScanResults> = {
+      seq1: {
+        matches: [
+          {
+            signature: {
+              entry: {
+                accession: 'PF00001',
+                name: 'test;name=value',
+                description: 'description with spaces',
+              },
+            },
+            locations: [{ start: 10, end: 50 }],
+          },
+        ],
+        xref: [{ id: 'seq1' }],
+      },
+    }
+    const gff = interProToGFF(results)
+
+    expect(gff).toContain('signature_desc=test%3Bname%3Dvalue')
+    expect(gff).toContain('description=description%20with%20spaces')
+  })
+})
+
+describe('interProResponseToGFF', () => {
+  test('converts array of results', () => {
+    const results: InterProScanResults[] = [
+      {
+        matches: [
+          {
+            signature: {
+              entry: {
+                accession: 'PF00001',
+                name: 'domain',
+                description: 'test',
+              },
+            },
+            locations: [{ start: 10, end: 50 }],
+          },
+        ],
+        xref: [{ id: 'seq1' }],
+      },
+    ]
+    const gff = interProResponseToGFF(results)
+
+    expect(gff).toContain('##gff-version 3')
+    expect(gff).toContain('seq1')
+  })
+
+  test('handles results without xref', () => {
+    const results: InterProScanResults[] = [
+      {
+        matches: [
+          {
+            signature: {
+              entry: {
+                accession: 'PF00001',
+                name: 'domain',
+                description: 'test',
+              },
+            },
+            locations: [{ start: 10, end: 50 }],
+          },
+        ],
+        xref: [],
+      },
+    ]
+    const gff = interProResponseToGFF(results)
+
+    expect(gff).toBe('##gff-version 3')
+  })
+})

package/src/gff/interProToGFF.ts

@@ -0,0 +1,59 @@
+import type { InterProScanResults } from '../types'
+
+/**
+ * Convert InterProScan results to GFF3 format
+ */
+export function interProToGFF(
+  results: Record<string, InterProScanResults>,
+): string {
+  const lines: string[] = ['##gff-version 3']
+
+  for (const [seqId, data] of Object.entries(results)) {
+    for (const match of data.matches) {
+      const entry = match.signature.entry
+      if (!entry) {
+        continue
+      }
+
+      for (const location of match.locations) {
+        const attributes = [
+          `Name=${encodeURIComponent(entry.accession)}`,
+          `signature_desc=${encodeURIComponent(entry.name)}`,
+          `description=${encodeURIComponent(entry.description)}`,
+        ].join(';')
+
+        const line = [
+          seqId,
+          'InterProScan',
+          'protein_match',
+          location.start,
+          location.end,
+          '.',
+          '.',
+          '.',
+          attributes,
+        ].join('\t')
+
+        lines.push(line)
+      }
+    }
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * Convert InterProScan JSON response to GFF3 format
+ */
+export function interProResponseToGFF(results: InterProScanResults[]): string {
+  const resultsMap: Record<string, InterProScanResults> = {}
+
+  for (const result of results) {
+    const seqId = result.xref[0]?.id
+    if (seqId) {
+      resultsMap[seqId] = result
+    }
+  }
+
+  return interProToGFF(resultsMap)
+}

package/src/gff/parseGFF.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, test } from 'vitest'
+
+import { parseGFF } from './parseGFF'
+
+describe('parseGFF', () => {
+  test('parses empty string', () => {
+    expect(parseGFF('')).toEqual([])
+    expect(parseGFF(undefined)).toEqual([])
+  })
+
+  test('parses basic GFF3 line', () => {
+    const gff =
+      'seq1\tInterProScan\tprotein_match\t10\t50\t.\t+\t.\tName=PF00001'
+    const result = parseGFF(gff)
+    expect(result).toHaveLength(1)
+    expect(result[0]).toEqual({
+      seq_id: 'seq1',
+      source: 'InterProScan',
+      type: 'protein_match',
+      start: 10,
+      end: 50,
+      score: 0,
+      strand: '+',
+      phase: '.',
+      Name: 'PF00001',
+    })
+  })
+
+  test('parses multiple attributes', () => {
+    const gff =
+      'seq1\tPfam\tprotein_match\t10\t50\t1.5\t.\t.\tName=PF00001;signature_desc=7tm_1;description=GPCR'
+    const result = parseGFF(gff)
+    expect(result[0]).toMatchObject({
+      Name: 'PF00001',
+      signature_desc: '7tm_1',
+      description: 'GPCR',
+    })
+  })
+
+  test('handles URL-encoded attribute values', () => {
+    const gff = 'seq1\tSource\ttype\t1\t10\t.\t.\t.\tNote=Hello%20World%3B%3D'
+    const result = parseGFF(gff)
+    expect(result[0]?.Note).toBe('Hello World;=')
+  })
+
+  test('skips comment lines', () => {
+    const gff = `##gff-version 3
+# This is a comment
+seq1\tSource\ttype\t1\t10\t.\t.\t.\tName=test`
+    const result = parseGFF(gff)
+    expect(result).toHaveLength(1)
+    expect(result[0]?.seq_id).toBe('seq1')
+  })
+
+  test('skips empty lines', () => {
+    const gff = `seq1\tSource\ttype\t1\t10\t.\t.\t.\tName=test1
+
+seq2\tSource\ttype\t20\t30\t.\t.\t.\tName=test2`
+    const result = parseGFF(gff)
+    expect(result).toHaveLength(2)
+  })
+
+  test('handles missing attributes column', () => {
+    const gff = 'seq1\tSource\ttype\t1\t10\t.\t.\t.'
+    const result = parseGFF(gff)
+    expect(result).toHaveLength(1)
+    expect(result[0]?.seq_id).toBe('seq1')
+  })
+
+  test('handles partial GFF lines gracefully', () => {
+    const gff = 'seq1\tSource\ttype'
+    const result = parseGFF(gff)
+    expect(result).toHaveLength(1)
+    expect(result[0]).toMatchObject({
+      seq_id: 'seq1',
+      source: 'Source',
+      type: 'type',
+      start: 0,
+      end: 0,
+    })
+  })
+
+  test('parses numeric score', () => {
+    const gff = 'seq1\tSource\ttype\t1\t10\t45.6\t.\t.\tName=test'
+    const result = parseGFF(gff)
+    expect(result[0]?.score).toBe(45.6)
+  })
+
+  test('handles comma-separated values in attributes', () => {
+    const gff =
+      'seq1\tSource\ttype\t1\t10\t.\t.\t.\tOntology_term=GO:0001,GO:0002'
+    const result = parseGFF(gff)
+    expect(result[0]?.Ontology_term).toBe('GO:0001 GO:0002')
+  })
+
+  test('parses multiple lines', () => {
+    const gff = `seq1\tPfam\tprotein_match\t10\t50\t.\t.\t.\tName=PF00001
+seq1\tSMART\tprotein_match\t60\t100\t.\t.\t.\tName=SM00001
+seq2\tPfam\tprotein_match\t5\t40\t.\t.\t.\tName=PF00002`
+    const result = parseGFF(gff)
+    expect(result).toHaveLength(3)
+    expect(result[0]?.seq_id).toBe('seq1')
+    expect(result[1]?.seq_id).toBe('seq1')
+    expect(result[2]?.seq_id).toBe('seq2')
+  })
+})