tinylink/middleware/src/runtime/pipeline.js

const queue = require('./queue');
const logger = require('../utils/logger');
const { normalize } = require('../domain/normalizer');
const { dedupeKey } = require('../utils/hash');
const instrumentConfig = require('../domain/instrumentConfig');
const { resolveParser } = require('../domain/parsers');
const translator = require('../domain/translator');

function translatePayload(entry, parsedPayload, connector) {
  const engineName = entry?.translator?.engine || entry?.translator?.name;
  return translator.translate(entry, parsedPayload, connector, engineName);
}

async function processMessage(connector, rawPayload, context = {}) {
  const rawRecord = await queue.insertRaw(connector, rawPayload);
  const rawId = rawRecord?.lastID;
  try {
    const matcher = instrumentConfig.resolveForMessage(connector, context);
    if (matcher.status === 'no_match') {
      logger.warn({ connector, context }, 'no matching instrument config, dropping payload');
      await queue.markRawParsed(rawId, 'dropped', 'no matching instrument config');
      return { dropped: true };
    }
    if (matcher.status === 'ambiguous') {
      logger.warn({ connector, context, matches: matcher.matches }, 'ambiguous instrument match, dropping payload');
      await queue.markRawParsed(rawId, 'dropped', 'ambiguous instrument match');
      return { dropped: true };
    }

    const instrumentEntry = matcher.entry;
    const parser = resolveParser(connector, instrumentEntry);
    const parsed = await parser.parse(rawPayload);
    const translated = parser.translate
      ? parser.translate(instrumentEntry, parsed, connector)
      : translatePayload(instrumentEntry, parsed, connector);
    const canonical = normalize(translated);
    const dedupe = dedupeKey(canonical);
    const inserted = await queue.insertOutbox(canonical, dedupe);
    await queue.markRawParsed(rawId, 'processed');
    if (inserted && inserted.duplicate) {
      logger.info({ dedupe, connector }, 'duplicate payload detected');
    }
    return { canonical, inserted, dedupe };
  } catch (error) {
    logger.error({ err: error.message, connector }, 'message processing failed');
    if (rawId) {
      await queue.markRawParsed(rawId, 'failed', error.message);
    }
    throw error;
  }
}

module.exports = { processMessage };