From 16a365fd6f63b870d1cebc4e9de6d4f36f4d6089 Mon Sep 17 00:00:00 2001
From: nicktrn <55853254+nicktrn@users.noreply.github.com>
Date: Tue, 28 May 2024 15:00:15 +0100
Subject: [PATCH] add lazy attempts catalog entries

---
 .../v3-catalog/src/trigger/lazyAttempts.ts    | 394 ++++++++++++++++++
 references/v3-catalog/trigger.config.ts       |   2 +-
 2 files changed, 395 insertions(+), 1 deletion(-)
 create mode 100644 references/v3-catalog/src/trigger/lazyAttempts.ts

diff --git a/references/v3-catalog/src/trigger/lazyAttempts.ts b/references/v3-catalog/src/trigger/lazyAttempts.ts
new file mode 100644
index 000000000..c84207b60
--- /dev/null
+++ b/references/v3-catalog/src/trigger/lazyAttempts.ts
@@ -0,0 +1,394 @@
+import { logger, task, wait } from "@trigger.dev/sdk/v3";
+
+export const lazyImmediate = task({
+  id: "lazy-immediate",
+  run: async (payload: { forceError?: boolean }) => {
+    logger.info("Log something", { payload });
+    logger.info("Log something else", { payload });
+
+    if (payload.forceError) {
+      throw new Error("Forced error");
+    }
+
+    return {
+      message: "This is a message",
+      payload,
+    };
+  },
+});
+
+export const lazyWait = task({
+  id: "lazy-wait",
+  run: async (payload: { forceError?: boolean; delayInSeconds?: number }) => {
+    logger.info("Log something", { payload });
+
+    await wait.for({ seconds: payload.delayInSeconds ?? 1 });
+
+    logger.info("Log something else", { payload });
+
+    if (payload.forceError) {
+      throw new Error("Forced error");
+    }
+
+    return {
+      message: "This is a message",
+      payload,
+    };
+  },
+});
+
+export const lazySingleDependency = task({
+  id: "lazy-single-dependency",
+  run: async (payload: {
+    forceError?: boolean;
+    forceChildError?: boolean;
+    delayInSeconds?: number;
+  }) => {
+    logger.info("Log something", { payload });
+
+    const result = await lazyWait.triggerAndWait({
+      delayInSeconds: payload.delayInSeconds,
+      forceError: payload.forceChildError,
+    });
+    logger.info("Single result", { result });
+
+    logger.info("Log something else", { payload });
+
+    if (payload.forceError) {
+      throw new Error("Forced error");
+    }
+
+    return {
+      message: "This is a message",
+      payload,
+    };
+  },
+});
+
+export const lazyBatchDependency = task({
+  id: "lazy-batch-dependency",
+  run: async (payload: {
+    forceError?: boolean;
+    forceChildError?: boolean;
+    delayInSeconds?: number;
+  }) => {
+    logger.info("Log something", { payload });
+
+    const results = await lazyWait.batchTriggerAndWait([
+      { payload: { delayInSeconds: payload.delayInSeconds, forceError: payload.forceChildError } },
+      { payload: { delayInSeconds: payload.delayInSeconds, forceError: payload.forceChildError } },
+    ]);
+    logger.info("Batch results", { results });
+
+    logger.info("Log something else", { payload });
+
+    if (payload.forceError) {
+      throw new Error("Forced error");
+    }
+
+    return {
+      message: "This is a message",
+      payload,
+    };
+  },
+});
+
+export const lazyConsecutiveWaits = task({
+  id: "lazy-consecutive-waits",
+  run: async (payload: {
+    forceError?: boolean;
+    forceChildError?: boolean;
+    delayInSeconds?: number;
+  }) => {
+    logger.info("Log something", { payload });
+
+    await wait.for({ seconds: payload.delayInSeconds ?? 1 });
+
+    logger.info("Log something else", { payload });
+
+    await wait.for({ seconds: payload.delayInSeconds ?? 1 });
+
+    logger.info("Log something else again", { payload });
+
+    if (payload.forceError) {
+      throw new Error("Forced error");
+    }
+
+    return {
+      message: "This is a message",
+      payload,
+    };
+  },
+});
+
+export const lazyConsecutiveDependencies = task({
+  id: "lazy-consecutive-dependencies",
+  run: async (payload: {
+    forceError?: boolean;
+    forceChildError?: boolean;
+    delayInSeconds?: number;
+  }) => {
+    logger.info("Log something", { payload });
+
+    const result = await lazyWait.triggerAndWait({
+      delayInSeconds: payload.delayInSeconds,
+      forceError: payload.forceChildError,
+    });
+    logger.info("Single result #1", { result });
+
+    logger.info("Log something else", { payload });
+
+    const result2 = await lazyWait.triggerAndWait({
+      delayInSeconds: payload.delayInSeconds,
+      forceError: payload.forceChildError,
+    });
+    logger.info("Single result #2", { result2 });
+
+    logger.info("Log something else again", { payload });
+
+    if (payload.forceError) {
+      throw new Error("Forced error");
+    }
+
+    return {
+      message: "This is a message",
+      payload,
+    };
+  },
+});
+
+export const lazyConsecutiveBatchDependencies = task({
+  id: "lazy-consecutive-batch-dependencies",
+  run: async (payload: {
+    forceError?: boolean;
+    forceChildError?: boolean;
+    delayInSeconds?: number;
+  }) => {
+    logger.info("Log something", { payload });
+
+    const results = await lazyWait.batchTriggerAndWait([
+      { payload: { delayInSeconds: payload.delayInSeconds, forceError: payload.forceChildError } },
+      { payload: { delayInSeconds: payload.delayInSeconds, forceError: payload.forceChildError } },
+    ]);
+    logger.info("Batch results #1", { results });
+
+    logger.info("Log something else", { payload });
+
+    const results2 = await lazyWait.batchTriggerAndWait([
+      { payload: { delayInSeconds: payload.delayInSeconds, forceError: payload.forceChildError } },
+      { payload: { delayInSeconds: payload.delayInSeconds, forceError: payload.forceChildError } },
+    ]);
+    logger.info("Batch results #2", { results2 });
+
+    logger.info("Log something else again", { payload });
+
+    if (payload.forceError) {
+      throw new Error("Forced error");
+    }
+
+    return {
+      message: "This is a message",
+      payload,
+    };
+  },
+});
+
+export const lazyWaitThenSingleDependency = task({
+  id: "lazy-wait-then-single-dependency",
+  run: async (payload: {
+    forceError?: boolean;
+    forceChildError?: boolean;
+    delayInSeconds?: number;
+  }) => {
+    logger.info("Log something", { payload });
+
+    await wait.for({ seconds: payload.delayInSeconds ?? 1 });
+
+    logger.info("Log something else", { payload });
+
+    const result = await lazyWait.triggerAndWait({
+      delayInSeconds: payload.delayInSeconds,
+      forceError: payload.forceChildError,
+    });
+    logger.info("Single result", { result });
+
+    logger.info("Log something else again", { payload });
+
+    if (payload.forceError) {
+      throw new Error("Forced error");
+    }
+
+    return {
+      message: "This is a message",
+      payload,
+    };
+  },
+});
+
+export const lazyWaitThenBatchDependency = task({
+  id: "lazy-wait-then-batch-dependency",
+  run: async (payload: {
+    forceError?: boolean;
+    forceChildError?: boolean;
+    delayInSeconds?: number;
+  }) => {
+    logger.info("Log something", { payload });
+
+    await wait.for({ seconds: payload.delayInSeconds ?? 1 });
+
+    logger.info("Log something else", { payload });
+
+    const results = await lazyWait.batchTriggerAndWait([
+      { payload: { delayInSeconds: payload.delayInSeconds, forceError: payload.forceChildError } },
+      { payload: { delayInSeconds: payload.delayInSeconds, forceError: payload.forceChildError } },
+    ]);
+    logger.info("Batch results", { results });
+
+    logger.info("Log something else again", { payload });
+
+    if (payload.forceError) {
+      throw new Error("Forced error");
+    }
+
+    return {
+      message: "This is a message",
+      payload,
+    };
+  },
+});
+
+export const lazySingleDependencyThenWait = task({
+  id: "lazy-single-dependency-then-wait",
+  run: async (payload: {
+    forceError?: boolean;
+    forceChildError?: boolean;
+    delayInSeconds?: number;
+  }) => {
+    logger.info("Log something", { payload });
+
+    const result = await lazyWait.triggerAndWait({
+      delayInSeconds: payload.delayInSeconds,
+      forceError: payload.forceChildError,
+    });
+    logger.info("Single result", { result });
+
+    logger.info("Log something else", { payload });
+
+    await wait.for({ seconds: payload.delayInSeconds ?? 1 });
+
+    logger.info("Log something else again", { payload });
+
+    if (payload.forceError) {
+      throw new Error("Forced error");
+    }
+
+    return {
+      message: "This is a message",
+      payload,
+    };
+  },
+});
+
+export const lazySingleDependencyThenBatch = task({
+  id: "lazy-single-dependency-then-batch",
+  run: async (payload: {
+    forceError?: boolean;
+    forceChildError?: boolean;
+    delayInSeconds?: number;
+  }) => {
+    logger.info("Log something", { payload });
+
+    const result = await lazyWait.triggerAndWait({
+      delayInSeconds: payload.delayInSeconds,
+      forceError: payload.forceChildError,
+    });
+    logger.info("Single result", { result });
+
+    logger.info("Log something else", { payload });
+
+    const results = await lazyWait.batchTriggerAndWait([
+      { payload: { delayInSeconds: payload.delayInSeconds, forceError: payload.forceChildError } },
+      { payload: { delayInSeconds: payload.delayInSeconds, forceError: payload.forceChildError } },
+    ]);
+    logger.info("Batch results", { results });
+
+    logger.info("Log something else again", { payload });
+
+    if (payload.forceError) {
+      throw new Error("Forced error");
+    }
+
+    return {
+      message: "This is a message",
+      payload,
+    };
+  },
+});
+
+export const lazyBatchDependencyThenWait = task({
+  id: "lazy-batch-dependency-then-wait",
+  run: async (payload: {
+    forceError?: boolean;
+    forceChildError?: boolean;
+    delayInSeconds?: number;
+  }) => {
+    logger.info("Log something", { payload });
+
+    const results = await lazyWait.batchTriggerAndWait([
+      { payload: { delayInSeconds: payload.delayInSeconds, forceError: payload.forceChildError } },
+      { payload: { delayInSeconds: payload.delayInSeconds, forceError: payload.forceChildError } },
+    ]);
+    logger.info("Batch results", { results });
+
+    logger.info("Log something else", { payload });
+
+    await wait.for({ seconds: payload.delayInSeconds ?? 1 });
+
+    logger.info("Log something else again", { payload });
+
+    if (payload.forceError) {
+      throw new Error("Forced error");
+    }
+
+    return {
+      message: "This is a message",
+      payload,
+    };
+  },
+});
+
+export const lazyBatchDependencyThenSingle = task({
+  id: "lazy-batch-dependency-then-single",
+  run: async (payload: {
+    forceError?: boolean;
+    forceChildError?: boolean;
+    delayInSeconds?: number;
+  }) => {
+    logger.info("Log something", { payload });
+
+    const results = await lazyWait.batchTriggerAndWait([
+      { payload: { delayInSeconds: payload.delayInSeconds, forceError: payload.forceChildError } },
+      { payload: { delayInSeconds: payload.delayInSeconds, forceError: payload.forceChildError } },
+    ]);
+    logger.info("Batch results", { results });
+
+    logger.info("Log something else", { payload });
+
+    const result = await lazyWait.triggerAndWait({
+      delayInSeconds: payload.delayInSeconds,
+      forceError: payload.forceChildError,
+    });
+    logger.info("Single result", { result });
+
+    logger.info("Log something else again", { payload });
+
+    if (payload.forceError) {
+      throw new Error("Forced error");
+    }
+
+    return {
+      message: "This is a message",
+      payload,
+    };
+  },
+});
diff --git a/references/v3-catalog/trigger.config.ts b/references/v3-catalog/trigger.config.ts
index 649a349a6..c1f504f2e 100644
--- a/references/v3-catalog/trigger.config.ts
+++ b/references/v3-catalog/trigger.config.ts
@@ -37,7 +37,7 @@ export const config: TriggerConfig = {
   retries: {
     enabledInDev: true,
     default: {
-      maxAttempts: 3,
+      maxAttempts: 4,
       minTimeoutInMs: 1000,
       maxTimeoutInMs: 10000,
       factor: 2,