Moved resumeTokens to just be wait functions 🥳

matt-aitken · matt-aitken · commit acd351d76395 · 2025-02-21T11:34:31.000Z
diff --git a/apps/webapp/app/assets/icons/WaitTokenIcon.tsx b/apps/webapp/app/assets/icons/WaitTokenIcon.tsx
@@ -0,0 +1,41 @@
+export function WaitTokenIcon({ className }: { className?: string }) {
+  return (
+    <svg className={className} viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+      <g clip-path="url(#clip0_16172_85184)">
+        <path
+          d="M13.3335 8L6.66683 8"
+          stroke="currentColor"
+          stroke-width="1.33333"
+          stroke-linecap="round"
+          stroke-linejoin="round"
+        />
+        <path
+          d="M13.3335 8L10.6668 10.6667"
+          stroke="currentColor"
+          stroke-width="1.33333"
+          stroke-linecap="round"
+          stroke-linejoin="round"
+        />
+        <path
+          d="M13.3335 7.99992L10.6668 5.33325"
+          stroke="currentColor"
+          stroke-width="1.33333"
+          stroke-linecap="round"
+          stroke-linejoin="round"
+        />
+        <path
+          d="M3.6665 2.66675L3.6665 13.3334"
+          stroke="currentColor"
+          stroke-width="1.33333"
+          stroke-linecap="round"
+          stroke-linejoin="round"
+        />
+      </g>
+      <defs>
+        <clipPath id="clip0_16172_85184">
+          <rect width="16" height="16" fill="currentColor" />
+        </clipPath>
+      </defs>
+    </svg>
+  );
+}
diff --git a/apps/webapp/app/components/runs/v3/RunIcon.tsx b/apps/webapp/app/components/runs/v3/RunIcon.tsx
@@ -10,6 +10,7 @@ import { TaskIcon } from "~/assets/icons/TaskIcon";
 import { TaskCachedIcon } from "~/assets/icons/TaskCachedIcon";
 import { NamedIcon } from "~/components/primitives/NamedIcon";
 import { cn } from "~/utils/cn";
+import { WaitTokenIcon } from "~/assets/icons/WaitTokenIcon";
 
 type TaskIconProps = {
   name: string | undefined;
@@ -54,6 +55,8 @@ export function RunIcon({ name, className, spanName }: TaskIconProps) {
       return <Squares2X2Icon className={cn(className, "text-text-dimmed")} />;
     case "tag":
       return <TagIcon className={cn(className, "text-text-dimmed")} />;
+    case "wait-token":
+      return <WaitTokenIcon className={cn(className, "text-text-dimmed")} />;
     //log levels
     case "debug":
     case "log":
diff --git a/apps/webapp/app/routes/api.v1.waitpoints.tokens.$waitpointFriendlyId.complete.ts b/apps/webapp/app/routes/api.v1.waitpoints.tokens.$waitpointFriendlyId.complete.ts
@@ -0,0 +1,70 @@
+import { json } from "@remix-run/server-runtime";
+import {
+  CompleteWaitpointTokenRequestBody,
+  CompleteWaitpointTokenResponseBody,
+  conditionallyExportPacket,
+  CreateWaitpointTokenResponseBody,
+  stringifyIO,
+} from "@trigger.dev/core/v3";
+import { WaitpointId } from "@trigger.dev/core/v3/apps";
+import { z } from "zod";
+import { $replica } from "~/db.server";
+import { logger } from "~/services/logger.server";
+import { createActionApiRoute } from "~/services/routeBuilders/apiBuilder.server";
+import { parseDelay } from "~/utils/delays";
+import { resolveIdempotencyKeyTTL } from "~/utils/idempotencyKeys.server";
+import { engine } from "~/v3/runEngine.server";
+
+const { action } = createActionApiRoute(
+  {
+    params: z.object({
+      waitpointFriendlyId: z.string(),
+    }),
+    body: CompleteWaitpointTokenRequestBody,
+    maxContentLength: 1024 * 10, // 10KB
+    method: "POST",
+  },
+  async ({ authentication, body, params }) => {
+    // Resume tokens are actually just waitpoints
+    const waitpointId = WaitpointId.toId(params.waitpointFriendlyId);
+
+    try {
+      const stringifiedData = await stringifyIO(body.data);
+      const finalData = await conditionallyExportPacket(
+        stringifiedData,
+        `${waitpointId}/waitpoint/token`
+      );
+
+      //check permissions
+      const waitpoint = await $replica.waitpoint.findFirst({
+        where: {
+          id: waitpointId,
+          environmentId: authentication.environment.id,
+        },
+      });
+
+      if (!waitpoint) {
+        throw json({ error: "Waitpoint not found" }, { status: 404 });
+      }
+
+      const result = await engine.completeWaitpoint({
+        id: waitpointId,
+        output: finalData.data
+          ? { type: finalData.dataType, value: finalData.data, isError: false }
+          : undefined,
+      });
+
+      return json<CompleteWaitpointTokenResponseBody>(
+        {
+          success: true,
+        },
+        { status: 200 }
+      );
+    } catch (error) {
+      logger.error("Failed to complete waitpoint token", { error });
+      throw json({ error: "Failed to complete waitpoint token" }, { status: 500 });
+    }
+  }
+);
+
+export { action };
diff --git a/apps/webapp/app/routes/api.v1.waitpoints.tokens.ts b/apps/webapp/app/routes/api.v1.waitpoints.tokens.ts
@@ -1,14 +1,17 @@
 import { json } from "@remix-run/server-runtime";
-import { CreateWaitpointRequestBody, CreateWaitpointResponseBody } from "@trigger.dev/core/v3";
-import { ResumeTokenId, WaitpointId } from "@trigger.dev/core/v3/apps";
+import {
+  CreateWaitpointTokenRequestBody,
+  CreateWaitpointTokenResponseBody,
+} from "@trigger.dev/core/v3";
+import { WaitpointId } from "@trigger.dev/core/v3/apps";
 import { createActionApiRoute } from "~/services/routeBuilders/apiBuilder.server";
 import { parseDelay } from "~/utils/delays";
 import { resolveIdempotencyKeyTTL } from "~/utils/idempotencyKeys.server";
 import { engine } from "~/v3/runEngine.server";
 
 const { action } = createActionApiRoute(
   {
-    body: CreateWaitpointRequestBody,
+    body: CreateWaitpointTokenRequestBody,
     maxContentLength: 1024 * 10, // 10KB
     method: "POST",
   },
@@ -27,12 +30,9 @@ const { action } = createActionApiRoute(
       timeout,
     });
 
-    //result is a waitpoint but we want to make it look like a resume token
-    const resumeTokenFriendlyId = ResumeTokenId.toFriendlyId(result.waitpoint.id);
-
-    return json<CreateWaitpointResponseBody>(
+    return json<CreateWaitpointTokenResponseBody>(
       {
-        id: resumeTokenFriendlyId,
+        id: WaitpointId.toFriendlyId(result.waitpoint.id),
         isCached: result.isCached,
       },
       { status: 200 }
diff --git a/packages/core/src/v3/apiClient/index.ts b/packages/core/src/v3/apiClient/index.ts
@@ -7,11 +7,13 @@ import {
   BatchTriggerTaskV3RequestBody,
   BatchTriggerTaskV3Response,
   CanceledRunResponse,
+  CompleteWaitpointTokenRequestBody,
+  CompleteWaitpointTokenResponseBody,
   CreateEnvironmentVariableRequestBody,
   CreateScheduleOptions,
   CreateUploadPayloadUrlResponseBody,
-  CreateWaitpointRequestBody,
-  CreateWaitpointResponseBody,
+  CreateWaitpointTokenRequestBody,
+  CreateWaitpointTokenResponseBody,
   DeletedScheduleObject,
   EnvironmentVariableResponseBody,
   EnvironmentVariableValue,
@@ -637,10 +639,27 @@ export class ApiClient {
     );
   }
 
-  createResumeToken(options: CreateWaitpointRequestBody, requestOptions?: ZodFetchOptions) {
+  createWaitpointToken(options: CreateWaitpointTokenRequestBody, requestOptions?: ZodFetchOptions) {
     return zodfetch(
-      CreateWaitpointResponseBody,
-      `${this.baseUrl}/api/v1/waitpoints`,
+      CreateWaitpointTokenResponseBody,
+      `${this.baseUrl}/api/v1/waitpoints/tokens`,
+      {
+        method: "POST",
+        headers: this.#getHeaders(false),
+        body: JSON.stringify(options),
+      },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
+  completeResumeToken(
+    friendlyId: string,
+    options: CompleteWaitpointTokenRequestBody,
+    requestOptions?: ZodFetchOptions
+  ) {
+    return zodfetch(
+      CompleteWaitpointTokenResponseBody,
+      `${this.baseUrl}/api/v1/waitpoints/tokens/${friendlyId}/complete`,
       {
         method: "POST",
         headers: this.#getHeaders(false),
diff --git a/packages/core/src/v3/apps/friendlyId.ts b/packages/core/src/v3/apps/friendlyId.ts
@@ -90,4 +90,3 @@ export const RunId = new IdUtil("run");
 export const SnapshotId = new IdUtil("snapshot");
 export const WaitpointId = new IdUtil("waitpoint");
 export const BatchId = new IdUtil("batch");
-export const ResumeTokenId = new IdUtil("resumetoken");
diff --git a/packages/core/src/v3/schemas/api.ts b/packages/core/src/v3/schemas/api.ts
@@ -890,7 +890,7 @@ export type SubscribeRealtimeStreamChunkRawShape = z.infer<
 export const TimePeriod = z.string().or(z.coerce.date());
 export type TimePeriod = z.infer<typeof TimePeriod>;
 
-export const CreateWaitpointRequestBody = z.object({
+export const CreateWaitpointTokenRequestBody = z.object({
   /**
    * An optional idempotency key for the waitpoint.
    * If you use the same key twice (and the key hasn't expired), you will get the original waitpoint back.
@@ -910,13 +910,23 @@ export const CreateWaitpointRequestBody = z.object({
    */
   timeout: TimePeriod.optional(),
 });
-export type CreateWaitpointRequestBody = z.infer<typeof CreateWaitpointRequestBody>;
+export type CreateWaitpointTokenRequestBody = z.infer<typeof CreateWaitpointTokenRequestBody>;
 
-export const CreateWaitpointResponseBody = z.object({
+export const CreateWaitpointTokenResponseBody = z.object({
   id: z.string(),
   isCached: z.boolean(),
 });
-export type CreateWaitpointResponseBody = z.infer<typeof CreateWaitpointResponseBody>;
+export type CreateWaitpointTokenResponseBody = z.infer<typeof CreateWaitpointTokenResponseBody>;
+
+export const CompleteWaitpointTokenRequestBody = z.object({
+  data: z.any().nullish(),
+});
+export type CompleteWaitpointTokenRequestBody = z.infer<typeof CompleteWaitpointTokenRequestBody>;
+
+export const CompleteWaitpointTokenResponseBody = z.object({
+  success: z.literal(true),
+});
+export type CompleteWaitpointTokenResponseBody = z.infer<typeof CompleteWaitpointTokenResponseBody>;
 
 export const WAITPOINT_TIMEOUT_ERROR_CODE = "TRIGGER_WAITPOINT_TIMEOUT";
 
diff --git a/packages/trigger-sdk/src/v3/index.ts b/packages/trigger-sdk/src/v3/index.ts
@@ -12,7 +12,6 @@ export * from "./tags.js";
 export * from "./metadata.js";
 export * from "./timeout.js";
 export * from "./waitUntil.js";
-export * from "./resumeTokens.js";
 export type { Context };
 
 import type { Context } from "./shared.js";
diff --git a/packages/trigger-sdk/src/v3/resumeTokens.ts b/packages/trigger-sdk/src/v3/resumeTokens.ts
diff --git a/packages/trigger-sdk/src/v3/wait.ts b/packages/trigger-sdk/src/v3/wait.ts
@@ -1,6 +1,75 @@
-import { SemanticInternalAttributes, accessoryAttributes, runtime } from "@trigger.dev/core/v3";
+import {
+  SemanticInternalAttributes,
+  accessoryAttributes,
+  runtime,
+  apiClientManager,
+  ApiPromise,
+  ApiRequestOptions,
+  conditionallyExportPacket,
+  CreateWaitpointTokenRequestBody,
+  CreateWaitpointTokenResponseBody,
+  mergeRequestOptions,
+  stringifyIO,
+  CompleteWaitpointTokenResponseBody,
+} from "@trigger.dev/core/v3";
 import { tracer } from "./tracer.js";
 
+function createToken(
+  options?: CreateWaitpointTokenRequestBody,
+  requestOptions?: ApiRequestOptions
+): ApiPromise<CreateWaitpointTokenResponseBody> {
+  const apiClient = apiClientManager.clientOrThrow();
+
+  const $requestOptions = mergeRequestOptions(
+    {
+      tracer,
+      name: "wait.createToken()",
+      icon: "wait-token",
+      attributes: {
+        idempotencyKey: options?.idempotencyKey,
+        idempotencyKeyTTL: options?.idempotencyKeyTTL,
+        timeout: options?.timeout
+          ? typeof options.timeout === "string"
+            ? options.timeout
+            : options.timeout.toISOString()
+          : undefined,
+      },
+      onResponseBody: (body: CreateWaitpointTokenResponseBody, span) => {
+        span.setAttribute("id", body.id);
+        span.setAttribute("isCached", body.isCached);
+      },
+    },
+    requestOptions
+  );
+
+  return apiClient.createWaitpointToken(options ?? {}, $requestOptions);
+}
+
+async function completeToken<T>(
+  token: { id: string },
+  data: T,
+  requestOptions?: ApiRequestOptions
+) {
+  const apiClient = apiClientManager.clientOrThrow();
+
+  const $requestOptions = mergeRequestOptions(
+    {
+      tracer,
+      name: "wait.completeToken()",
+      icon: "wait-token",
+      attributes: {
+        id: token.id,
+      },
+      onResponseBody: (body: CompleteWaitpointTokenResponseBody, span) => {
+        span.setAttribute("success", body.success);
+      },
+    },
+    requestOptions
+  );
+
+  return apiClient.completeResumeToken(token.id, { data }, $requestOptions);
+}
+
 export type WaitOptions =
   | {
       seconds: number;
@@ -80,6 +149,8 @@ export const wait = {
       }
     );
   },
+  createToken,
+  completeToken,
 };
 
 function nameForWaitOptions(options: WaitOptions): string {
diff --git a/references/hello-world/src/trigger/resume-tokens.ts b/references/hello-world/src/trigger/resume-tokens.ts
diff --git a/references/hello-world/src/trigger/wait-tokens.ts b/references/hello-world/src/trigger/wait-tokens.ts
