classify.ts · Source

classify.tsapps/worker/src/processors/automations/executors/classify.tsraw ← executors2,954 B← Back to the app
1/**
2 * apps/worker — automation executor error types + classification (TASK-0112 §4).
3 *
4 * Every error an executor throws is classified retryable-vs-fatal. The run
5 * pipeline (TASK-0113) consumes `retryable` only:
6 *   - FatalError      → the run is marked FAILED immediately (no retry):
7 *                       validation, permission, 4xx, ACTION_TIMEOUT, unknown
8 *                       action/property, stubs, quota, SSRF.
9 *   - RetryableError  → the whole run is re-enqueued (BullMQ attempts, max 8):
10 *                       network I/O (ECONNRESET/ETIMEDOUT/EPIPE), HTTP 429/5xx,
11 *                       Postgres transient (40P01 deadlock, 40001 serialization),
12 *                       email-queue-full.
13 *
14 * `classifyError` is the single mapping the pipeline uses; each executor
15 * declares its own classification by throwing the matching class (the HTTP
16 * executor classifies by status code, the DB executors by Prisma error code).
17 */
18 
19export class FatalError extends Error {
20  constructor(
21    public readonly code: string,
22    message: string
23  ) {
24    super(message);
25    this.name = "FatalError";
26  }
27}
28 
29export class RetryableError extends Error {
30  constructor(
31    public readonly code: string,
32    message: string
33  ) {
34    super(message);
35    this.name = "RetryableError";
36  }
37}
38 
39/** node errno codes that mean "the transport hiccuped — retry the call". */
40const RETRYABLE_ERRNO = new Set(["ECONNRESET", "ETIMEDOUT", "EPIPE", "ECONNREFUSED", "EAI_AGAIN"]);
41 
42/** Postgres SQLSTATE codes that are transient (safe to retry the statement). */
43const RETRYABLE_PG = new Set(["40P01", "40001", "57P01", "55P03", "57014"]);
44 
45/**
46 * Map any thrown error to { retryable, code }.
47 *  - FatalError / RetryableError: use their declared code,
48 *  - Prisma errors: retryable only on the transient SQLSTATE set,
49 *  - network errors with a retryable errno → retryable,
50 *  - otherwise fatal (fail closed — an unknown error must not silently retry).
51 */
52export function classifyError(err: unknown): { retryable: boolean; code: string } {
53  if (err instanceof FatalError) return { retryable: false, code: err.code };
54  if (err instanceof RetryableError) return { retryable: true, code: err.code };
55 
56  const e = err as { code?: string; errno?: string; cause?: { errno?: string }; meta?: { driverError?: { code?: string } } };
57  const pgCode =
58    e?.meta?.driverError?.code ??
59    (typeof e?.code === "string" && RETRYABLE_PG.has(e.code) ? e.code : undefined);
60  if (pgCode && RETRYABLE_PG.has(pgCode)) return { retryable: true, code: `DB_TRANSIENT_${pgCode}` };
61 
62  const errno = e?.errno ?? e?.cause?.errno;
63  if (errno && RETRYABLE_ERRNO.has(errno)) return { retryable: true, code: `NET_${errno}` };
64  if (typeof e?.code === "string" && RETRYABLE_ERRNO.has(e.code)) return { retryable: true, code: `NET_${e.code}` };
65 
66  return { retryable: false, code: (err as Error)?.name === "TimeoutError" ? "ACTION_TIMEOUT" : "UNEXPECTED" };
67}
68