Added jsdocs, removed schema version because of errors

Author: matt-aitken

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

@@ -652,9 +652,53 @@ export const wait = {
       }
     );
   },
+  /**
+   * This allows you to start some work on another API (or one of your own services) 
+   * and continue the run when a callback URL we give you is hit with the result.
+   * 
+   * You should send the callback URL to the other service, and then that service will 
+   * make a request to the callback URL with the result.
+   * 
+   * @example
+   * 
+   * ```ts
+   * //wait for the prediction to complete
+    const prediction = await wait.forHttpCallback<Prediction>(
+      async (url) => {
+        //pass the provided URL to Replicate's webhook
+        await replicate.predictions.create({
+          version:
+            "19deaef633fd44776c82edf39fd60e95a7250b8ececf11a725229dc75a81f9ca",
+          input: payload,
+          // pass the provided URL to Replicate's webhook, so they can "callback"
+          webhook: url,
+          webhook_events_filter: ["completed"],
+        });
+      },
+      {
+        timeout: "2m",
+      }
+    );
+
+    //the value of prediction is the body of the webook that Replicate sent
+    const result = prediction.output;
+   * ```
+   * 
+   * @param callback 
+   * @param options 
+   * @param requestOptions 
+   * @returns 
+   */
   async forHttpCallback<TResult>(
     callback: (url: string) => Promise<void>,
     options?: CreateWaitpointTokenRequestBody & {
+      /**
+       * If set to true, this will cause the waitpoint to release the current run from the queue's concurrency.
+       *
+       * This is useful if you want to allow other runs to execute while waiting
+       *
+       * @default false
+       */
       releaseConcurrency?: boolean;
     },
     requestOptions?: ApiRequestOptions
@@ -762,123 +806,6 @@ export const wait = {
     // 10. Receive the result here and import the packet, then get the result in the right format
     // 11. Make unwrap work
   },
-  async forHttpCallbackWithSchema<TSchema extends HttpCallbackSchema>(
-    schema: TSchema,
-    callback: (url: string) => Promise<void>,
-    options?: CreateWaitpointTokenRequestBody & {
-      releaseConcurrency?: boolean;
-    },
-    requestOptions?: ApiRequestOptions
-  ): Promise<HttpCallbackResult<HttpCallbackResultTypeFromSchema<TSchema>>> {
-    const ctx = taskContext.ctx;
-
-    if (!ctx) {
-      throw new Error("wait.forHttpCallback can only be used from inside a task.run()");
-    }
-
-    const apiClient = apiClientManager.clientOrThrow();
-
-    const waitpoint = await apiClient.createWaitpointHttpCallback(options ?? {}, requestOptions);
-
-    return tracer.startActiveSpan(
-      `wait.forHttpCallback()`,
-      async (span) => {
-        const [error] = await tryCatch(callback(waitpoint.url));
-
-        if (error) {
-          throw new Error(`You threw an error in your callback: ${error.message}`, {
-            cause: error,
-          });
-        }
-
-        const response = await apiClient.waitForWaitpointToken({
-          runFriendlyId: ctx.run.id,
-          waitpointFriendlyId: waitpoint.id,
-          releaseConcurrency: options?.releaseConcurrency,
-        });
-
-        if (!response.success) {
-          throw new Error(`Failed to wait for wait for HTTP callback ${waitpoint.id}`);
-        }
-
-        const result = await runtime.waitUntil(waitpoint.id);
-
-        const data = result.output
-          ? await conditionallyImportAndParsePacket(
-              { data: result.output, dataType: result.outputType ?? "application/json" },
-              apiClient
-            )
-          : undefined;
-
-        if (result.ok) {
-          try {
-            const parser = schema ? getSchemaParseFn<inferSchemaIn<TSchema>>(schema) : undefined;
-
-            if (!parser) {
-              throw new Error("No parser found for schema");
-            }
-
-            const parsedOutput = await parser(data);
-
-            return {
-              ok: result.ok,
-              output: parsedOutput,
-            };
-          } catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            span.recordException(err);
-            span.setStatus({
-              code: SpanStatusCode.ERROR,
-            });
-
-            return {
-              ok: false,
-              error: err,
-            };
-          }
-        } else {
-          const error = new WaitpointTimeoutError(data.message);
-
-          span.recordException(error);
-          span.setStatus({
-            code: SpanStatusCode.ERROR,
-          });
-
-          return {
-            ok: result.ok,
-            error,
-          };
-        }
-      },
-      {
-        attributes: {
-          [SemanticInternalAttributes.STYLE_ICON]: "wait",
-          [SemanticInternalAttributes.ENTITY_TYPE]: "waitpoint",
-          [SemanticInternalAttributes.ENTITY_ID]: waitpoint.id,
-          ...accessoryAttributes({
-            items: [
-              {
-                text: waitpoint.id,
-                variant: "normal",
-              },
-            ],
-            style: "codepath",
-          }),
-          id: waitpoint.id,
-          isCached: waitpoint.isCached,
-          idempotencyKey: options?.idempotencyKey,
-          idempotencyKeyTTL: options?.idempotencyKeyTTL,
-          timeout: options?.timeout
-            ? typeof options.timeout === "string"
-              ? options.timeout
-              : options.timeout.toISOString()
-            : undefined,
-          tags: options?.tags,
-          url: waitpoint.url,
-        },
-      }
-    );
-  },
 };
 
 function nameForWaitOptions(options: WaitForOptions): string {

references/hello-world/src/trigger/waits.ts

@@ -158,18 +158,5 @@ export const waitHttpCallback = task({
     } else {
       logger.log("Wait for HTTP callback completed", result);
     }
-
-    const result2 = await wait.forHttpCallbackWithSchema(
-      z.object({ bar: z.string() }),
-      async (url) => {
-        logger.log(`Wait for HTTP callback ${url}`);
-      }
-    );
-
-    if (!result2.ok) {
-      logger.log("Wait for HTTP callback failed", { error: result2.error });
-    } else {
-      logger.log("Wait for HTTP callback completed", result2);
-    }
   },
 });