@trigger.dev/core 3.0.0-beta.46 → 3.0.0-beta.47

package/dist/v3/zodfetch.d.mts

@@ -1,5 +1,8 @@
 import { z } from 'zod';
-import { R as RetryOptions } from '../schemas-CeAee_C2.mjs';
+import { R as RetryOptions } from '../schemas-Zy7mGFgD.mjs';
+import { Attributes, Span } from '@opentelemetry/api';
+import { T as TriggerTracer } from '../tracer-N0p2Fuuv.mjs';
+import '@opentelemetry/api-logs';
 
 interface CursorPageParams {
     limit?: number;
@@ -81,7 +84,14 @@ declare const defaultRetryOptions: {
 };
 type ZodFetchOptions = {
     retry?: RetryOptions;
+    tracer?: TriggerTracer;
+    name?: string;
+    attributes?: Attributes;
+    icon?: string;
+    onResponseBody?: (body: unknown, span: Span) => void;
 };
+type ApiRequestOptions = Pick<ZodFetchOptions, "retry">;
+declare const isRequestOptions: (obj: unknown) => obj is ApiRequestOptions;
 interface FetchCursorPageParams extends CursorPageParams {
     query?: URLSearchParams;
 }
@@ -159,6 +169,8 @@ declare class OffsetLimitPagePromise<TItemSchema extends z.ZodTypeAny> extends A
      */
     [Symbol.asyncIterator](): AsyncGenerator<Awaited<z.output<TItemSchema>>, void, unknown>;
 }
+declare function isEmptyObj(obj: Object | null | undefined): boolean;
+declare function hasOwn(obj: Object, key: string): boolean;
 
 type APIHeaders = Record<string, string | null | undefined>;
 declare class ApiError extends Error {
@@ -199,8 +211,9 @@ declare class UnprocessableEntityError extends ApiError {
 }
 declare class RateLimitError extends ApiError {
     readonly status: 429;
+    get millisecondsUntilReset(): number | undefined;
 }
 declare class InternalServerError extends ApiError {
 }
 
-export { type APIHeaders, ApiConnectionError, ApiError, ApiPromise, AuthenticationError, BadRequestError, ConflictError, CursorPage, type CursorPageParams, CursorPagePromise, type CursorPageResponse, InternalServerError, NotFoundError, OffsetLimitPage, type OffsetLimitPageParams, OffsetLimitPagePromise, type OffsetLimitPageResponse, type Page, type PageResponse, PermissionDeniedError, RateLimitError, UnprocessableEntityError, type ZodFetchOptions, defaultRetryOptions, zodfetch, zodfetchCursorPage, zodfetchOffsetLimitPage };
+export { type APIHeaders, ApiConnectionError, ApiError, ApiPromise, type ApiRequestOptions, AuthenticationError, BadRequestError, ConflictError, CursorPage, type CursorPageParams, CursorPagePromise, type CursorPageResponse, InternalServerError, NotFoundError, OffsetLimitPage, type OffsetLimitPageParams, OffsetLimitPagePromise, type OffsetLimitPageResponse, type Page, type PageResponse, PermissionDeniedError, RateLimitError, UnprocessableEntityError, type ZodFetchOptions, defaultRetryOptions, hasOwn, isEmptyObj, isRequestOptions, zodfetch, zodfetchCursorPage, zodfetchOffsetLimitPage };

package/dist/v3/zodfetch.d.ts

@@ -1,5 +1,8 @@
 import { z } from 'zod';
-import { R as RetryOptions } from '../schemas-CeAee_C2.js';
+import { R as RetryOptions } from '../schemas-Zy7mGFgD.js';
+import { Attributes, Span } from '@opentelemetry/api';
+import { T as TriggerTracer } from '../tracer-N0p2Fuuv.js';
+import '@opentelemetry/api-logs';
 
 interface CursorPageParams {
     limit?: number;
@@ -81,7 +84,14 @@ declare const defaultRetryOptions: {
 };
 type ZodFetchOptions = {
     retry?: RetryOptions;
+    tracer?: TriggerTracer;
+    name?: string;
+    attributes?: Attributes;
+    icon?: string;
+    onResponseBody?: (body: unknown, span: Span) => void;
 };
+type ApiRequestOptions = Pick<ZodFetchOptions, "retry">;
+declare const isRequestOptions: (obj: unknown) => obj is ApiRequestOptions;
 interface FetchCursorPageParams extends CursorPageParams {
     query?: URLSearchParams;
 }
@@ -159,6 +169,8 @@ declare class OffsetLimitPagePromise<TItemSchema extends z.ZodTypeAny> extends A
      */
     [Symbol.asyncIterator](): AsyncGenerator<Awaited<z.output<TItemSchema>>, void, unknown>;
 }
+declare function isEmptyObj(obj: Object | null | undefined): boolean;
+declare function hasOwn(obj: Object, key: string): boolean;
 
 type APIHeaders = Record<string, string | null | undefined>;
 declare class ApiError extends Error {
@@ -199,8 +211,9 @@ declare class UnprocessableEntityError extends ApiError {
 }
 declare class RateLimitError extends ApiError {
     readonly status: 429;
+    get millisecondsUntilReset(): number | undefined;
 }
 declare class InternalServerError extends ApiError {
 }
 
-export { type APIHeaders, ApiConnectionError, ApiError, ApiPromise, AuthenticationError, BadRequestError, ConflictError, CursorPage, type CursorPageParams, CursorPagePromise, type CursorPageResponse, InternalServerError, NotFoundError, OffsetLimitPage, type OffsetLimitPageParams, OffsetLimitPagePromise, type OffsetLimitPageResponse, type Page, type PageResponse, PermissionDeniedError, RateLimitError, UnprocessableEntityError, type ZodFetchOptions, defaultRetryOptions, zodfetch, zodfetchCursorPage, zodfetchOffsetLimitPage };
+export { type APIHeaders, ApiConnectionError, ApiError, ApiPromise, type ApiRequestOptions, AuthenticationError, BadRequestError, ConflictError, CursorPage, type CursorPageParams, CursorPagePromise, type CursorPageResponse, InternalServerError, NotFoundError, OffsetLimitPage, type OffsetLimitPageParams, OffsetLimitPagePromise, type OffsetLimitPageResponse, type Page, type PageResponse, PermissionDeniedError, RateLimitError, UnprocessableEntityError, type ZodFetchOptions, defaultRetryOptions, hasOwn, isEmptyObj, isRequestOptions, zodfetch, zodfetchCursorPage, zodfetchOffsetLimitPage };

package/dist/v3/zodfetch.js

@@ -24,10 +24,34 @@ var __privateMethod = (obj, member, method) => {
   return method;
 };
 
+// src/v3/utils/retries.ts
+var defaultRetryOptions = {
+  maxAttempts: 3,
+  factor: 2,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 6e4,
+  randomize: true
+};
+function calculateNextRetryDelay(options, attempt) {
+  const opts = {
+    ...defaultRetryOptions,
+    ...options
+  };
+  if (attempt >= opts.maxAttempts) {
+    return;
+  }
+  const { factor, minTimeoutInMs, maxTimeoutInMs, randomize } = opts;
+  const random = randomize ? Math.random() + 1 : 1;
+  const timeout = Math.min(maxTimeoutInMs, random * minTimeoutInMs * Math.pow(factor, attempt - 1));
+  return Math.round(timeout);
+}
+__name(calculateNextRetryDelay, "calculateNextRetryDelay");
+
 // src/v3/apiClient/errors.ts
 var _ApiError = class _ApiError extends Error {
   constructor(status, error, message, headers) {
     super(`${_ApiError.makeMessage(status, error, message)}`);
+    this.name = "TriggerApiError";
     this.status = status;
     this.headers = headers;
     const data = error;
@@ -148,6 +172,16 @@ var _RateLimitError = class _RateLimitError extends ApiError {
     super(...arguments);
     __publicField(this, "status", 429);
   }
+  get millisecondsUntilReset() {
+    const resetAtUnixEpochMs = (this.headers ?? {})["x-ratelimit-reset"];
+    if (typeof resetAtUnixEpochMs === "string") {
+      const resetAtUnixEpoch = parseInt(resetAtUnixEpochMs, 10);
+      if (isNaN(resetAtUnixEpoch)) {
+        return;
+      }
+      return Math.max(resetAtUnixEpoch - Date.now() + Math.floor(Math.random() * 2e3), 0);
+    }
+  }
 };
 __name(_RateLimitError, "RateLimitError");
 var RateLimitError = _RateLimitError;
@@ -162,28 +196,122 @@ function castToError(err) {
 }
 __name(castToError, "castToError");
 
-// src/v3/utils/retries.ts
-var defaultRetryOptions = {
-  maxAttempts: 3,
-  factor: 2,
-  minTimeoutInMs: 1e3,
-  maxTimeoutInMs: 6e4,
-  randomize: true
+// src/v3/semanticInternalAttributes.ts
+var SemanticInternalAttributes = {
+  ENVIRONMENT_ID: "ctx.environment.id",
+  ENVIRONMENT_TYPE: "ctx.environment.type",
+  ORGANIZATION_ID: "ctx.organization.id",
+  ORGANIZATION_SLUG: "ctx.organization.slug",
+  ORGANIZATION_NAME: "ctx.organization.name",
+  PROJECT_ID: "ctx.project.id",
+  PROJECT_REF: "ctx.project.ref",
+  PROJECT_NAME: "ctx.project.title",
+  PROJECT_DIR: "project.dir",
+  ATTEMPT_ID: "ctx.attempt.id",
+  ATTEMPT_NUMBER: "ctx.attempt.number",
+  RUN_ID: "ctx.run.id",
+  RUN_IS_TEST: "ctx.run.isTest",
+  BATCH_ID: "ctx.batch.id",
+  TASK_SLUG: "ctx.task.id",
+  TASK_PATH: "ctx.task.filePath",
+  TASK_EXPORT_NAME: "ctx.task.exportName",
+  QUEUE_NAME: "ctx.queue.name",
+  QUEUE_ID: "ctx.queue.id",
+  MACHINE_PRESET_NAME: "ctx.machine.name",
+  MACHINE_PRESET_CPU: "ctx.machine.cpu",
+  MACHINE_PRESET_MEMORY: "ctx.machine.memory",
+  MACHINE_PRESET_CENTS_PER_MS: "ctx.machine.centsPerMs",
+  SPAN_PARTIAL: "$span.partial",
+  SPAN_ID: "$span.span_id",
+  OUTPUT: "$output",
+  OUTPUT_TYPE: "$mime_type_output",
+  STYLE: "$style",
+  STYLE_ICON: "$style.icon",
+  STYLE_VARIANT: "$style.variant",
+  STYLE_ACCESSORY: "$style.accessory",
+  METADATA: "$metadata",
+  TRIGGER: "$trigger",
+  PAYLOAD: "$payload",
+  PAYLOAD_TYPE: "$mime_type_payload",
+  SHOW: "$show",
+  SHOW_ACTIONS: "$show.actions",
+  WORKER_ID: "worker.id",
+  WORKER_VERSION: "worker.version",
+  CLI_VERSION: "cli.version",
+  SDK_VERSION: "sdk.version",
+  SDK_LANGUAGE: "sdk.language",
+  RETRY_AT: "retry.at",
+  RETRY_DELAY: "retry.delay",
+  RETRY_COUNT: "retry.count",
+  LINK_TITLE: "$link.title",
+  IDEMPOTENCY_KEY: "ctx.run.idempotencyKey",
+  USAGE_DURATION_MS: "$usage.durationMs",
+  USAGE_COST_IN_CENTS: "$usage.costInCents",
+  RATE_LIMIT_LIMIT: "response.rateLimit.limit",
+  RATE_LIMIT_REMAINING: "response.rateLimit.remaining",
+  RATE_LIMIT_RESET: "response.rateLimit.reset"
 };
-function calculateNextRetryDelay(options, attempt) {
-  const opts = {
-    ...defaultRetryOptions,
-    ...options
-  };
-  if (attempt >= opts.maxAttempts) {
-    return;
+
+// src/v3/utils/flattenAttributes.ts
+var NULL_SENTINEL = "$@null((";
+function flattenAttributes(obj, prefix) {
+  const result = {};
+  if (obj === void 0) {
+    return result;
+  }
+  if (obj === null) {
+    result[prefix || ""] = NULL_SENTINEL;
+    return result;
+  }
+  if (typeof obj === "string") {
+    result[prefix || ""] = obj;
+    return result;
+  }
+  if (typeof obj === "number") {
+    result[prefix || ""] = obj;
+    return result;
+  }
+  if (typeof obj === "boolean") {
+    result[prefix || ""] = obj;
+    return result;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    const newPrefix = `${prefix ? `${prefix}.` : ""}${Array.isArray(obj) ? `[${key}]` : key}`;
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        if (typeof value[i] === "object" && value[i] !== null) {
+          Object.assign(result, flattenAttributes(value[i], `${newPrefix}.[${i}]`));
+        } else {
+          if (value[i] === null) {
+            result[`${newPrefix}.[${i}]`] = NULL_SENTINEL;
+          } else {
+            result[`${newPrefix}.[${i}]`] = value[i];
+          }
+        }
+      }
+    } else if (isRecord(value)) {
+      Object.assign(result, flattenAttributes(value, newPrefix));
+    } else {
+      if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
+        result[newPrefix] = value;
+      } else if (value === null) {
+        result[newPrefix] = NULL_SENTINEL;
+      }
+    }
   }
-  const { factor, minTimeoutInMs, maxTimeoutInMs, randomize } = opts;
-  const random = randomize ? Math.random() + 1 : 1;
-  const timeout = Math.min(maxTimeoutInMs, random * minTimeoutInMs * Math.pow(factor, attempt - 1));
-  return Math.round(timeout);
+  return result;
 }
-__name(calculateNextRetryDelay, "calculateNextRetryDelay");
+__name(flattenAttributes, "flattenAttributes");
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+
+// src/v3/utils/styleAttributes.ts
+function accessoryAttributes(accessory) {
+  return flattenAttributes(accessory, SemanticInternalAttributes.STYLE_ACCESSORY);
+}
+__name(accessoryAttributes, "accessoryAttributes");
 
 // src/v3/apiClient/pagination.ts
 var _CursorPage = class _CursorPage {
@@ -293,6 +421,12 @@ var defaultRetryOptions2 = {
   maxTimeoutInMs: 6e4,
   randomize: false
 };
+var requestOptionsKeys = {
+  retry: true
+};
+var isRequestOptions = /* @__PURE__ */ __name((obj) => {
+  return typeof obj === "object" && obj !== null && !isEmptyObj(obj) && Object.keys(obj).every((k) => hasOwn(requestOptionsKeys, k));
+}, "isRequestOptions");
 function zodfetch(schema, url, requestInit, options) {
   return new ApiPromise(_doZodFetch(schema, url, requestInit, options));
 }
@@ -343,16 +477,47 @@ function zodfetchOffsetLimitPage(schema, url, params, requestInit, options) {
   return new OffsetLimitPagePromise(fetchResult, schema, url, params, requestInit, options);
 }
 __name(zodfetchOffsetLimitPage, "zodfetchOffsetLimitPage");
-async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
+async function traceZodFetch(params, callback) {
+  if (!params.options?.tracer) {
+    return callback();
+  }
+  const url = new URL(params.url);
+  const method = params.requestInit?.method ?? "GET";
+  const name = params.options.name ?? `${method} ${url.pathname}`;
+  return await params.options.tracer.startActiveSpan(name, async (span) => {
+    return await callback(span);
+  }, {
+    attributes: {
+      [SemanticInternalAttributes.STYLE_ICON]: params.options?.icon ?? "api",
+      ...params.options.attributes
+    }
+  });
+}
+__name(traceZodFetch, "traceZodFetch");
+async function _doZodFetch(schema, url, requestInit, options) {
+  const $requestInit = await requestInit;
+  return traceZodFetch({
+    url,
+    requestInit: $requestInit,
+    options
+  }, async (span) => {
+    const result = await _doZodFetchWithRetries(schema, url, $requestInit, options);
+    if (options?.onResponseBody && span) {
+      options.onResponseBody(result.data, span);
+    }
+    return result;
+  });
+}
+__name(_doZodFetch, "_doZodFetch");
+async function _doZodFetchWithRetries(schema, url, requestInit, options, attempt = 1) {
   try {
-    const $requestInit = await requestInit;
-    const response = await fetch(url, requestInitWithCache($requestInit));
+    const response = await fetch(url, requestInitWithCache(requestInit));
     const responseHeaders = createResponseHeaders(response.headers);
     if (!response.ok) {
       const retryResult = shouldRetry(response, attempt, options?.retry);
       if (retryResult.retry) {
-        await new Promise((resolve) => setTimeout(resolve, retryResult.delay));
-        return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
+        await waitForRetry(url, attempt + 1, retryResult.delay, options, requestInit, response);
+        return await _doZodFetchWithRetries(schema, url, requestInit, options, attempt + 1);
       } else {
         const errText = await response.text().catch((e) => castToError2(e).message);
         const errJSON = safeJsonParse(errText);
@@ -380,8 +545,8 @@ async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
       };
       const delay = calculateNextRetryDelay(retry, attempt);
       if (delay) {
-        await new Promise((resolve) => setTimeout(resolve, delay));
-        return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
+        await waitForRetry(url, attempt + 1, delay, options, requestInit);
+        return await _doZodFetchWithRetries(schema, url, requestInit, options, attempt + 1);
       }
     }
     throw new ApiConnectionError({
@@ -389,7 +554,7 @@ async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
     });
   }
 }
-__name(_doZodFetch, "_doZodFetch");
+__name(_doZodFetchWithRetries, "_doZodFetchWithRetries");
 function castToError2(err) {
   if (err instanceof Error)
     return err;
@@ -426,8 +591,25 @@ function shouldRetry(response, attempt, retryOptions) {
     return shouldRetryForOptions();
   if (response.status === 409)
     return shouldRetryForOptions();
-  if (response.status === 429)
+  if (response.status === 429) {
+    if (attempt >= (typeof retryOptions?.maxAttempts === "number" ? retryOptions?.maxAttempts : 3)) {
+      return {
+        retry: false
+      };
+    }
+    const resetAtUnixEpochMs = response.headers.get("x-ratelimit-reset");
+    if (resetAtUnixEpochMs) {
+      const resetAtUnixEpoch = parseInt(resetAtUnixEpochMs, 10);
+      const delay = resetAtUnixEpoch - Date.now() + Math.floor(Math.random() * 1e3);
+      if (delay > 0) {
+        return {
+          retry: true,
+          delay
+        };
+      }
+    }
     return shouldRetryForOptions();
+  }
   if (response.status >= 500)
     return shouldRetryForOptions();
   return {
@@ -590,6 +772,41 @@ fetchPage_fn2 = /* @__PURE__ */ __name(function(params1) {
 }, "#fetchPage");
 __name(_OffsetLimitPagePromise, "OffsetLimitPagePromise");
 var OffsetLimitPagePromise = _OffsetLimitPagePromise;
+async function waitForRetry(url, attempt, delay, options, requestInit, response) {
+  if (options?.tracer) {
+    const method = requestInit?.method ?? "GET";
+    return options.tracer.startActiveSpan(response ? `wait after ${response.status}` : `wait after error`, async (span) => {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "wait",
+        ...accessoryAttributes({
+          items: [
+            {
+              text: `retrying ${options?.name ?? method.toUpperCase()} in ${delay}ms`,
+              variant: "normal"
+            }
+          ],
+          style: "codepath"
+        })
+      }
+    });
+  }
+  await new Promise((resolve) => setTimeout(resolve, delay));
+}
+__name(waitForRetry, "waitForRetry");
+function isEmptyObj(obj) {
+  if (!obj)
+    return true;
+  for (const _k in obj)
+    return false;
+  return true;
+}
+__name(isEmptyObj, "isEmptyObj");
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+__name(hasOwn, "hasOwn");
 
 exports.ApiConnectionError = ApiConnectionError;
 exports.ApiError = ApiError;
@@ -607,6 +824,9 @@ exports.PermissionDeniedError = PermissionDeniedError;
 exports.RateLimitError = RateLimitError;
 exports.UnprocessableEntityError = UnprocessableEntityError;
 exports.defaultRetryOptions = defaultRetryOptions2;
+exports.hasOwn = hasOwn;
+exports.isEmptyObj = isEmptyObj;
+exports.isRequestOptions = isRequestOptions;
 exports.zodfetch = zodfetch;
 exports.zodfetchCursorPage = zodfetchCursorPage;
 exports.zodfetchOffsetLimitPage = zodfetchOffsetLimitPage;