twenty-app-intake 0.3.0 → 0.4.0

package/src/logic-functions/retry.ts

@@ -1,112 +1,89 @@
 import { defineLogicFunction, type RoutePayload } from 'twenty-sdk/define';
-import { CoreApiClient } from 'twenty-client-sdk/core';
-import { MetadataApiClient } from 'twenty-client-sdk/metadata';
 import { IDS } from '../constants/universal-identifiers';
-import { createPipeline } from '../lib/pipeline-factory';
-import type { PipelineContext } from '../lib/pipeline';
-import { coreApi } from '../lib/rest-client';
+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 logId = params.pathParameters?.['logId'];
-  if (!logId) {
-    return { statusCode: 400, body: { error: 'Missing logId in URL' } };
-  }
+  const startedAt = Date.now();
 
-  // Fetch the existing log
-  const logResult = await coreApi.get<{
-    data: {
-      intakeLog: {
-        id: string;
-        status: string;
-        rawPayload: string | null;
-        intakeSourceId: string | null;
-        error: string | null;
-      };
-    };
-  }>(`/intakeLogs/${logId}`).catch(() => null);
+  const logId = params.pathParameters?.['logId'];
+  if (!logId) return { statusCode: 400, body: { error: 'Missing logId in URL' } };
 
-  const log = logResult?.data?.intakeLog;
+  const log = await loadLog(logId);
+  if (!log) return { statusCode: 404, body: { error: `IntakeLog ${logId} not found` } };
 
-  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 === 'SUCCESS') {
+  if (log.status === 'QUARANTINED') {
     return {
       statusCode: 400,
-      body: { error: 'This ingestion already succeeded — no retry needed', status: log.status },
+      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 requires rawPayload field (logs created in v0.2.0+)' },
+      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);
+    rawPayload = JSON.parse(log.rawPayload) as Record<string, unknown>;
   } catch {
     return { statusCode: 400, body: { error: 'rawPayload is not valid JSON' } };
   }
 
-  // We need a sourceSlug to run the pipeline — get it from the source record
-  let sourceSlug = 'unknown';
-  if (log.intakeSourceId) {
-    const srcResult = await coreApi.get<{ data: { intakeSource: { slug: string } } }>(
-      `/intakeSources/${log.intakeSourceId}`,
-    ).catch(() => null);
-    sourceSlug = srcResult?.data?.intakeSource?.slug ?? 'unknown';
+  const sourceSlug = await slugForSource(log.intakeSourceId);
+  if (!sourceSlug) {
+    return { statusCode: 400, body: { error: 'The source for this log no longer exists' } };
   }
 
-  const startedAt = Date.now();
-  const coreClient = new CoreApiClient();
-  const metadataClient = new MetadataApiClient();
-  const pipeline = createPipeline(coreClient, metadataClient);
-
-  const ctx: PipelineContext = {
+  const outcome = await runIngestion({
     sourceSlug,
-    rawBody: undefined, // HMAC skipped on retry — source already verified originally
     rawPayload,
-    headers: {},
-    startedAt,
-    skipDedup: true, // Critical — bypass idempotency so the payload re-runs
-    fieldsCreated: 0,
-    fieldsMatched: 0,
-    warnings: [],
-    events: [],
-  };
+    // 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,
+  });
 
-  const result = await pipeline.run(ctx);
-
-  if (!result.ok) {
+  if (!outcome.ok) {
     return {
       statusCode: 500,
       body: {
-        error: `Retry failed: ${result.error.message}`,
-        code: result.error.code,
+        error: `Retry failed: ${outcome.error.message}`,
+        code: outcome.error.code,
         originalLogId: logId,
       },
     };
   }
 
-  const { value: finalCtx } = result;
-
   return {
     statusCode: 200,
-    body: {
-      success: true,
-      originalLogId: logId,
-      recordId: finalCtx.personId ?? finalCtx.companyId,
-      recordType: finalCtx.recordType,
-      personId: finalCtx.personId,
-      companyId: finalCtx.companyId,
-      fieldsCreated: finalCtx.fieldsCreated,
-      processingMs: Date.now() - startedAt,
-      warnings: finalCtx.warnings,
-    },
+    body: { originalLogId: logId, ...successBody(outcome.ctx, startedAt) },
   };
 };