@junando/worker 0.9.0 → 0.10.1

package/dist/handler.cjs

@@ -59921,6 +59921,50 @@ function createLLMProvider(provider, apiKey, model, options) {
   return factory(apiKey, model, options);
 }
 
+// ../core/src/shared/factory-registry.ts
+var FactoryRegistry = class {
+  _factories = /* @__PURE__ */ new Map();
+  _default = () => {
+    throw new Error(`No factory registered and no default available`);
+  };
+  /**
+   * Register a factory for a given key.
+   * Overwrites any existing registration for that key.
+   */
+  register(key, factory) {
+    this._factories.set(key, factory);
+  }
+  /**
+   * Set the default factory to use when no key matches.
+   */
+  registerDefault(factory) {
+    this._default = factory;
+  }
+  /**
+   * Resolve the factory for a given key.
+   * Returns the default if no specific factory is registered for that key.
+   */
+  resolve(key) {
+    const factory = this._factories.get(key);
+    if (factory) {
+      return factory();
+    }
+    return this._default();
+  }
+  /**
+   * Check if a factory is registered for a given key.
+   */
+  has(key) {
+    return this._factories.has(key);
+  }
+  /**
+   * Return all registered keys.
+   */
+  keys() {
+    return Array.from(this._factories.keys());
+  }
+};
+
 // ../core/src/infrastructure/notifier/slack.adapter.ts
 createLogger();
 function sanitizeEndpointPath(endpointPath) {
@@ -60230,14 +60274,26 @@ var TeamsNotifier = class {
 };
 
 // ../core/src/infrastructure/notifier/factory.ts
+function buildNotifierRegistry(config) {
+  const registry2 = new FactoryRegistry();
+  registry2.register("teams", () => {
+    if (!config.teamsWebhookUrl) {
+      throw new Error("NOTIFIER_TYPE=teams requires TEAMS_WEBHOOK_URL to be set");
+    }
+    return new TeamsNotifier(config.teamsWebhookUrl);
+  });
+  registry2.register("slack", () => {
+    if (!config.slackBotToken || !config.slackChannel) {
+      throw new Error("NOTIFIER_TYPE=slack requires SLACK_BOT_TOKEN and SLACK_CHANNEL to be set");
+    }
+    return new SlackNotifier(config.slackBotToken, config.slackChannel);
+  });
+  registry2.registerDefault(() => new SlackNotifier("dummy-token", "#alerts"));
+  return registry2;
+}
 function createNotifier(config) {
-  switch (config.notifierType) {
-    case "teams":
-      return new TeamsNotifier(config.teamsWebhookUrl);
-    case "slack":
-    default:
-      return new SlackNotifier(config.slackBotToken, config.slackChannel);
-  }
+  const registry2 = buildNotifierRegistry(config);
+  return registry2.resolve(config.notifierType);
 }
 
 // ../../node_modules/.pnpm/@aws-sdk+client-sqs@3.1045.0/node_modules/@aws-sdk/client-sqs/dist-es/SQSClient.js
@@ -65488,6 +65544,144 @@ async function loadConfig3() {
 
 // src/handler.ts
 var import_ioredis = __toESM(require_built3());
+
+// src/adapters/csv-input.adapter.ts
+var DEFAULT_CSV_COLUMN_MAPPING = {
+  serviceCol: 0,
+  messageCol: 1,
+  severityCol: 2,
+  timestampCol: 3
+};
+var SEVERITY_TO_ALERT_TYPE = {
+  error: "http_500" /* Error */,
+  critical: "http_500" /* Error */,
+  high: "http_500" /* Error */,
+  warning: "latency_spike" /* Warning */,
+  warn: "latency_spike" /* Warning */,
+  latency: "latency_spike" /* Warning */,
+  success: "recovery" /* Success */,
+  recovery: "recovery" /* Success */,
+  resolved: "recovery" /* Success */,
+  info: "recovery" /* Success */
+};
+external_exports.object({
+  correlationId: external_exports.string().uuid(),
+  alerts: external_exports.array(NormalizedAlertSchema)
+});
+function isCsvBody(body) {
+  const trimmed = body.trim();
+  if (!trimmed) return false;
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) return false;
+  return trimmed.includes(",") && (trimmed.includes("\n") || trimmed.split(",").length >= 3);
+}
+function parseCsvBody(body, mapping = DEFAULT_CSV_COLUMN_MAPPING) {
+  const lines = body.trim().split("\n");
+  if (lines.length < 2) return null;
+  const headerLine = lines[0];
+  const headers = parseRow(headerLine);
+  const alerts = [];
+  for (let i8 = 1; i8 < lines.length; i8++) {
+    const row = lines[i8];
+    const values = parseRow(row);
+    if (values.length === 0) continue;
+    try {
+      const service = getColumnValue(headers, values, mapping.serviceCol);
+      const message = getColumnValue(headers, values, mapping.messageCol);
+      const severity = getColumnValue(headers, values, mapping.severityCol);
+      const timestamp = getColumnValue(headers, values, mapping.timestampCol);
+      const fingerprint = mapping.fingerprintCol != null ? getColumnValue(headers, values, mapping.fingerprintCol) || generateFingerprint(service, message) : generateFingerprint(service, message);
+      const endpoint = mapping.endpointCol != null ? getColumnValue(headers, values, mapping.endpointCol) || "/" : "/";
+      if (!service || !message || !severity || !timestamp) continue;
+      const alertType = mapSeverityToAlertType(severity);
+      if (!alertType) continue;
+      const alert = {
+        fingerprint,
+        alertName: message.slice(0, 200),
+        // truncate long names
+        status: "firing",
+        serviceName: service.trim(),
+        alertType,
+        endpointPath: endpoint.trim() || "/",
+        startsAt: normalizeTimestamp(timestamp),
+        labels: parseExtraLabels(mapping.extraLabels),
+        annotations: { source: "csv-adapter" }
+      };
+      const result = NormalizedAlertSchema.safeParse(alert);
+      if (result.success) {
+        alerts.push(result.data);
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (alerts.length === 0) return null;
+  return {
+    correlationId: crypto.randomUUID(),
+    alerts
+  };
+}
+function parseRow(line) {
+  const result = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i8 = 0; i8 < line.length; i8++) {
+    const char = line[i8];
+    if (char === '"') {
+      inQuotes = !inQuotes;
+    } else if (char === "," && !inQuotes) {
+      result.push(current.trim());
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  result.push(current.trim());
+  return result;
+}
+function getColumnValue(headers, values, col) {
+  if (typeof col === "number") {
+    return values[col] ?? "";
+  }
+  const idx = headers.indexOf(col);
+  return idx >= 0 ? values[idx] ?? "" : "";
+}
+function mapSeverityToAlertType(severity) {
+  const lower = severity.toLowerCase().trim();
+  return SEVERITY_TO_ALERT_TYPE[lower] ?? null;
+}
+function normalizeTimestamp(value) {
+  const trimmed = value.trim();
+  if (/\d{4}-\d{2}-\d{2}T/.test(trimmed)) return trimmed;
+  if (/^\d{10}$/.test(trimmed)) {
+    return new Date(Number(trimmed) * 1e3).toISOString();
+  }
+  if (/^\d{13}$/.test(trimmed)) {
+    return new Date(Number(trimmed)).toISOString();
+  }
+  const parsed = Date.parse(trimmed);
+  if (!isNaN(parsed)) return new Date(parsed).toISOString();
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function parseExtraLabels(extra) {
+  if (!extra) return {};
+  const labels = {};
+  for (const pair of extra.split(",")) {
+    const [k8, v2] = pair.split("=").map((s2) => s2.trim());
+    if (k8) labels[k8] = v2 ?? "";
+  }
+  return labels;
+}
+function generateFingerprint(service, message) {
+  const raw = `${service}:${message}`;
+  let hash = 0;
+  for (let i8 = 0; i8 < raw.length; i8++) {
+    const char = raw.charCodeAt(i8);
+    hash = char * 31 + hash >>> 0;
+  }
+  return `csv-${hash.toString(16).padStart(8, "0")}`;
+}
+
+// src/handler.ts
 var SQSMessageSchema = external_exports.object({
   correlationId: external_exports.string().uuid(),
   alerts: external_exports.array(NormalizedAlertSchema)
@@ -65529,6 +65723,12 @@ var handler = async (event) => {
     await flushLoki();
   }
 };
+function parseIntEnv(key) {
+  const val = process.env[key];
+  if (!val) return void 0;
+  const parsed = Number(val);
+  return isNaN(parsed) ? void 0 : parsed;
+}
 async function _handler(event) {
   let useCaseInstance;
   try {
@@ -65540,13 +65740,35 @@ async function _handler(event) {
   for (const record of event.Records) {
     let parsed;
     try {
-      const raw = JSON.parse(record.body);
-      const result = SQSMessageSchema.safeParse(raw);
-      if (!result.success) {
-        logger7.error({ err: result.error.issues }, "Invalid SQS message body");
-        continue;
+      if (isCsvBody(record.body)) {
+        const fpCol = parseIntEnv("CSV_FINGERPRINT_COL");
+        const epCol = parseIntEnv("CSV_ENDPOINT_COL");
+        const extraLabels = process.env["CSV_EXTRA_LABELS"];
+        const mapping = {
+          serviceCol: Number(process.env["CSV_SERVICE_COL"] ?? 0),
+          messageCol: Number(process.env["CSV_MESSAGE_COL"] ?? 1),
+          severityCol: Number(process.env["CSV_SEVERITY_COL"] ?? 2),
+          timestampCol: Number(process.env["CSV_TIMESTAMP_COL"] ?? 3),
+          ...fpCol !== void 0 && { fingerprintCol: fpCol },
+          ...epCol !== void 0 && { endpointCol: epCol },
+          ...extraLabels !== void 0 && { extraLabels }
+        };
+        const csvResult = parseCsvBody(record.body, mapping);
+        if (!csvResult) {
+          logger7.error({ record: record.messageId }, "CSV parse returned no valid alerts");
+          continue;
+        }
+        parsed = csvResult;
+        logger7.info({ alertCount: parsed.alerts.length }, "Parsed CSV SQS message");
+      } else {
+        const raw = JSON.parse(record.body);
+        const result = SQSMessageSchema.safeParse(raw);
+        if (!result.success) {
+          logger7.error({ err: result.error.issues }, "Invalid SQS message body");
+          continue;
+        }
+        parsed = result.data;
       }
-      parsed = result.data;
     } catch (err) {
       logger7.error({ err }, "Failed to parse SQS message body");
       continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junando/worker",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "description": "AWS Lambda SQS worker — processes alert events and dispatches notifications for Junando",
   "license": "Apache-2.0",
   "type": "module",
@@ -22,7 +22,7 @@
     "@aws-sdk/client-ssm": "^3.600.0",
     "ioredis": "^5.4.1",
     "zod": "^3.23.0",
-    "@junando/core": "0.9.0"
+    "@junando/core": "0.10.1"
   },
   "devDependencies": {
     "@types/aws-lambda": "^8.10.145",