Creating resume tokens is working

Author: matt-aitken

apps/webapp/app/routes/api.v1.waitpoints.ts

@@ -0,0 +1,38 @@
+import { json } from "@remix-run/server-runtime";
+import { CreateWaitpointRequestBody, CreateWaitpointResponseBody } from "@trigger.dev/core/v3";
+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,
+    maxContentLength: 1024 * 10, // 10KB
+    method: "POST",
+  },
+  async ({ authentication, body }) => {
+    const idempotencyKeyExpiresAt = body.idempotencyKeyTTL
+      ? resolveIdempotencyKeyTTL(body.idempotencyKeyTTL)
+      : undefined;
+
+    const timeout = await parseDelay(body.timeout);
+
+    const waitpoint = await engine.createManualWaitpoint({
+      environmentId: authentication.environment.id,
+      projectId: authentication.environment.projectId,
+      idempotencyKey: body.idempotencyKey,
+      idempotencyKeyExpiresAt,
+      timeout,
+    });
+
+    return json<CreateWaitpointResponseBody>(
+      {
+        id: waitpoint.friendlyId,
+      },
+      { status: 200 }
+    );
+  }
+);
+
+export { action };

packages/core/src/v3/apiClient/index.ts

@@ -10,6 +10,8 @@ import {
   CreateEnvironmentVariableRequestBody,
   CreateScheduleOptions,
   CreateUploadPayloadUrlResponseBody,
+  CreateWaitpointRequestBody,
+  CreateWaitpointResponseBody,
   DeletedScheduleObject,
   EnvironmentVariableResponseBody,
   EnvironmentVariableValue,
@@ -635,6 +637,19 @@ export class ApiClient {
     );
   }
 
+  createResumeToken(options: CreateWaitpointRequestBody, requestOptions?: ZodFetchOptions) {
+    return zodfetch(
+      CreateWaitpointResponseBody,
+      `${this.baseUrl}/api/v1/waitpoints`,
+      {
+        method: "POST",
+        headers: this.#getHeaders(false),
+        body: JSON.stringify(options),
+      },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
   subscribeToRun<TRunTypes extends AnyRunTypes>(
     runId: string,
     options?: {

packages/core/src/v3/schemas/api.ts

@@ -887,20 +887,35 @@ export type SubscribeRealtimeStreamChunkRawShape = z.infer<
   typeof SubscribeRealtimeStreamChunkRawShape
 >;
 
+export const TimePeriod = z.string().or(z.coerce.date());
+export type TimePeriod = z.infer<typeof TimePeriod>;
+
 export const CreateWaitpointRequestBody = z.object({
-  /** An optional idempotency key for the waitpoint. If you provide one. */
+  /**
+   * 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.
+   *
+   * Note: This waitpoint may already be complete, in which case when you wait for it, it will immediately continue.
+   */
   idempotencyKey: z.string().optional(),
-  /** The TTL for the idempotency key. */
+  /**
+   * When set, this means the passed in idempotency key will expire after this time.
+   * This means after that time if you pass the same idempotency key again, you will get a new waitpoint.
+   */
   idempotencyKeyTTL: z.string().optional(),
-  /** If the waitpoint hasn't been completed by this timeout, it will fail with a timeout error. */
-  timeout: z.string().or(z.coerce.date()).optional(),
+  /** The resume token will timeout after this time.
+   * If you are waiting for the token in a run, the token will return a result where `ok` is false.
+   *
+   * You can pass a `Date` object, or a string in this format: "30s", "1m", "2h", "3d", "4w".
+   */
+  timeout: TimePeriod.optional(),
 });
 export type CreateWaitpointRequestBody = z.infer<typeof CreateWaitpointRequestBody>;
 
-export const CreateWaitpointResponse = z.object({
+export const CreateWaitpointResponseBody = z.object({
   id: z.string(),
 });
-export type CreateWaitpointResponse = z.infer<typeof CreateWaitpointResponse>;
+export type CreateWaitpointResponseBody = z.infer<typeof CreateWaitpointResponseBody>;
 
 export const WAITPOINT_TIMEOUT_ERROR_CODE = "TRIGGER_WAITPOINT_TIMEOUT";
 

packages/trigger-sdk/src/v3/index.ts

@@ -12,6 +12,7 @@ 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";

packages/trigger-sdk/src/v3/resumeTokens.ts

@@ -0,0 +1,31 @@
+import {
+  apiClientManager,
+  ApiPromise,
+  ApiRequestOptions,
+  CreateWaitpointRequestBody,
+  CreateWaitpointResponseBody,
+  mergeRequestOptions,
+} from "@trigger.dev/core/v3";
+import { tracer } from "./tracer.js";
+
+function createResumeToken(
+  options?: CreateWaitpointRequestBody,
+  requestOptions?: ApiRequestOptions
+): ApiPromise<CreateWaitpointResponseBody> {
+  const apiClient = apiClientManager.clientOrThrow();
+
+  const $requestOptions = mergeRequestOptions(
+    {
+      tracer,
+      name: "resumeTokens.create()",
+      icon: "wait",
+    },
+    requestOptions
+  );
+
+  return apiClient.createResumeToken(options ?? {}, $requestOptions);
+}
+
+export const resumeTokens = {
+  create: createResumeToken,
+};

references/hello-world/src/trigger/resume-tokens.ts

@@ -0,0 +1,11 @@
+import { logger, resumeTokens, task } from "@trigger.dev/sdk/v3";
+
+export const resumeToken = task({
+  id: "resume-token",
+  run: async (payload: any, { ctx }) => {
+    logger.log("Hello, world", { payload });
+
+    const token = await resumeTokens.create();
+    logger.log("Token", token);
+  },
+});