twenty-app-intake 0.2.1 → 0.4.0

package/src/logic-functions/retry.ts

@@ -0,0 +1,101 @@
+import { defineLogicFunction, type RoutePayload } from 'twenty-sdk/define';
+import { IDS } from '../constants/universal-identifiers';
+import { loadLog, slugForSource } from '../lib/replay';
+import { runIngestion, successBody } from '../lib/ingest';
+
+/**
+ * Re-run a failed ingestion.
+ *
+ * Deliberately narrower than replay: this refuses a log that already succeeded,
+ * so an operator clicking Retry on a working record cannot create a second one.
+ * Use `/replay` for a log that succeeded but needs re-mapping.
+ */
+const handler = async (params: RoutePayload) => {
+  const startedAt = Date.now();
+
+  const logId = params.pathParameters?.['logId'];
+  if (!logId) return { statusCode: 400, body: { error: 'Missing logId in URL' } };
+
+  const log = await loadLog(logId);
+  if (!log) return { statusCode: 404, body: { error: `IntakeLog ${logId} not found` } };
+
+  if (log.status === 'SUCCESS') {
+    return {
+      statusCode: 400,
+      body: {
+        error: 'This ingestion already succeeded — no retry needed. Use POST /s/intake/logs/:logId/replay to re-run it through the current rules.',
+        status: log.status,
+      },
+    };
+  }
+
+  if (log.status === 'QUARANTINED') {
+    return {
+      statusCode: 400,
+      body: {
+        error: 'This payload is quarantined. Use POST /s/intake/quarantine/:logId/release to let it through.',
+        status: log.status,
+      },
+    };
+  }
+
+  if (!log.rawPayload) {
+    return {
+      statusCode: 400,
+      body: {
+        error: 'No raw payload stored on this log — retry needs one. Check INTAKE_RAW_PAYLOAD_RETENTION and INTAKE_RAW_PAYLOAD_MAX_BYTES.',
+        code: 'NO_STORED_PAYLOAD',
+      },
+    };
+  }
+
+  let rawPayload: Record<string, unknown>;
+  try {
+    rawPayload = JSON.parse(log.rawPayload) as Record<string, unknown>;
+  } catch {
+    return { statusCode: 400, body: { error: 'rawPayload is not valid JSON' } };
+  }
+
+  const sourceSlug = await slugForSource(log.intakeSourceId);
+  if (!sourceSlug) {
+    return { statusCode: 400, body: { error: 'The source for this log no longer exists' } };
+  }
+
+  const outcome = await runIngestion({
+    sourceSlug,
+    rawPayload,
+    // The signature was verified when the payload first arrived and there is no
+    // body to re-verify against; the caller here is already authenticated.
+    skipDedup: true,
+    replayOfLogId: log.id,
+  });
+
+  if (!outcome.ok) {
+    return {
+      statusCode: 500,
+      body: {
+        error: `Retry failed: ${outcome.error.message}`,
+        code: outcome.error.code,
+        originalLogId: logId,
+      },
+    };
+  }
+
+  return {
+    statusCode: 200,
+    body: { originalLogId: logId, ...successBody(outcome.ctx, startedAt) },
+  };
+};
+
+export default defineLogicFunction({
+  universalIdentifier: IDS.RETRY_LOGIC_FUNCTION,
+  name: 'intake-retry',
+  description: 'Retry a failed ingestion using the stored raw payload from an IntakeLog record.',
+  timeoutSeconds: 30,
+  handler,
+  httpRouteTriggerSettings: {
+    path: '/intake/logs/:logId/retry',
+    httpMethod: 'POST',
+    isAuthRequired: true,
+  },
+});