@trigger.dev/core 3.0.0-beta.35 → 3.0.0-beta.37

package/dist/v3/zodfetch.mjs

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 import { fromZodError } from 'zod-validation-error';
 import { FormDataEncoder } from 'form-data-encoder';
 import { Readable } from 'node:stream';
@@ -9,11 +10,24 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
 
-// src/v3/apiErrors.ts
-var _APIError = class _APIError extends Error {
+// src/v3/apiClient/errors.ts
+var _ApiError = class _ApiError extends Error {
   constructor(status, error, message, headers) {
-    super(`${_APIError.makeMessage(status, error, message)}`);
+    super(`${_ApiError.makeMessage(status, error, message)}`);
     this.status = status;
     this.headers = headers;
     const data = error;
@@ -37,7 +51,7 @@ var _APIError = class _APIError extends Error {
   }
   static generate(status, errorResponse, message, headers) {
     if (!status) {
-      return new APIConnectionError({
+      return new ApiConnectionError({
         cause: castToError(errorResponse)
       });
     }
@@ -66,12 +80,12 @@ var _APIError = class _APIError extends Error {
     if (status >= 500) {
       return new InternalServerError(status, error, message, headers);
     }
-    return new _APIError(status, error, message, headers);
+    return new _ApiError(status, error, message, headers);
   }
 };
-__name(_APIError, "APIError");
-var APIError = _APIError;
-var _APIConnectionError = class _APIConnectionError extends APIError {
+__name(_ApiError, "ApiError");
+var ApiError = _ApiError;
+var _ApiConnectionError = class _ApiConnectionError extends ApiError {
   constructor({ message, cause }) {
     super(void 0, void 0, message || "Connection error.", void 0);
     __publicField(this, "status");
@@ -79,9 +93,9 @@ var _APIConnectionError = class _APIConnectionError extends APIError {
       this.cause = cause;
   }
 };
-__name(_APIConnectionError, "APIConnectionError");
-var APIConnectionError = _APIConnectionError;
-var _BadRequestError = class _BadRequestError extends APIError {
+__name(_ApiConnectionError, "ApiConnectionError");
+var ApiConnectionError = _ApiConnectionError;
+var _BadRequestError = class _BadRequestError extends ApiError {
   constructor() {
     super(...arguments);
     __publicField(this, "status", 400);
@@ -89,7 +103,7 @@ var _BadRequestError = class _BadRequestError extends APIError {
 };
 __name(_BadRequestError, "BadRequestError");
 var BadRequestError = _BadRequestError;
-var _AuthenticationError = class _AuthenticationError extends APIError {
+var _AuthenticationError = class _AuthenticationError extends ApiError {
   constructor() {
     super(...arguments);
     __publicField(this, "status", 401);
@@ -97,7 +111,7 @@ var _AuthenticationError = class _AuthenticationError extends APIError {
 };
 __name(_AuthenticationError, "AuthenticationError");
 var AuthenticationError = _AuthenticationError;
-var _PermissionDeniedError = class _PermissionDeniedError extends APIError {
+var _PermissionDeniedError = class _PermissionDeniedError extends ApiError {
   constructor() {
     super(...arguments);
     __publicField(this, "status", 403);
@@ -105,7 +119,7 @@ var _PermissionDeniedError = class _PermissionDeniedError extends APIError {
 };
 __name(_PermissionDeniedError, "PermissionDeniedError");
 var PermissionDeniedError = _PermissionDeniedError;
-var _NotFoundError = class _NotFoundError extends APIError {
+var _NotFoundError = class _NotFoundError extends ApiError {
   constructor() {
     super(...arguments);
     __publicField(this, "status", 404);
@@ -113,7 +127,7 @@ var _NotFoundError = class _NotFoundError extends APIError {
 };
 __name(_NotFoundError, "NotFoundError");
 var NotFoundError = _NotFoundError;
-var _ConflictError = class _ConflictError extends APIError {
+var _ConflictError = class _ConflictError extends ApiError {
   constructor() {
     super(...arguments);
     __publicField(this, "status", 409);
@@ -121,7 +135,7 @@ var _ConflictError = class _ConflictError extends APIError {
 };
 __name(_ConflictError, "ConflictError");
 var ConflictError = _ConflictError;
-var _UnprocessableEntityError = class _UnprocessableEntityError extends APIError {
+var _UnprocessableEntityError = class _UnprocessableEntityError extends ApiError {
   constructor() {
     super(...arguments);
     __publicField(this, "status", 422);
@@ -129,7 +143,7 @@ var _UnprocessableEntityError = class _UnprocessableEntityError extends APIError
 };
 __name(_UnprocessableEntityError, "UnprocessableEntityError");
 var UnprocessableEntityError = _UnprocessableEntityError;
-var _RateLimitError = class _RateLimitError extends APIError {
+var _RateLimitError = class _RateLimitError extends ApiError {
   constructor() {
     super(...arguments);
     __publicField(this, "status", 429);
@@ -137,7 +151,7 @@ var _RateLimitError = class _RateLimitError extends APIError {
 };
 __name(_RateLimitError, "RateLimitError");
 var RateLimitError = _RateLimitError;
-var _InternalServerError = class _InternalServerError extends APIError {
+var _InternalServerError = class _InternalServerError extends ApiError {
 };
 __name(_InternalServerError, "InternalServerError");
 var InternalServerError = _InternalServerError;
@@ -170,6 +184,108 @@ function calculateNextRetryDelay(options, attempt) {
   return Math.round(timeout);
 }
 __name(calculateNextRetryDelay, "calculateNextRetryDelay");
+
+// src/v3/apiClient/pagination.ts
+var _CursorPage = class _CursorPage {
+  constructor(data, pagination, pageFetcher) {
+    this.pageFetcher = pageFetcher;
+    this.data = data;
+    this.pagination = pagination;
+  }
+  getPaginatedItems() {
+    return this.data ?? [];
+  }
+  hasNextPage() {
+    return !!this.pagination.next;
+  }
+  hasPreviousPage() {
+    return !!this.pagination.previous;
+  }
+  getNextPage() {
+    if (!this.pagination.next) {
+      throw new Error("No next page available");
+    }
+    return this.pageFetcher({
+      after: this.pagination.next
+    });
+  }
+  getPreviousPage() {
+    if (!this.pagination.previous) {
+      throw new Error("No previous page available");
+    }
+    return this.pageFetcher({
+      before: this.pagination.previous
+    });
+  }
+  async *iterPages() {
+    let page = this;
+    yield page;
+    while (page.hasNextPage()) {
+      page = await page.getNextPage();
+      yield page;
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const page of this.iterPages()) {
+      for (const item of page.getPaginatedItems()) {
+        yield item;
+      }
+    }
+  }
+};
+__name(_CursorPage, "CursorPage");
+var CursorPage = _CursorPage;
+var _OffsetLimitPage = class _OffsetLimitPage {
+  constructor(data, pagination, pageFetcher) {
+    this.pageFetcher = pageFetcher;
+    this.data = data;
+    this.pagination = pagination;
+  }
+  getPaginatedItems() {
+    return this.data ?? [];
+  }
+  hasNextPage() {
+    return this.pagination.currentPage < this.pagination.totalPages;
+  }
+  hasPreviousPage() {
+    return this.pagination.currentPage > 1;
+  }
+  getNextPage() {
+    if (!this.hasNextPage()) {
+      throw new Error("No next page available");
+    }
+    return this.pageFetcher({
+      page: this.pagination.currentPage + 1
+    });
+  }
+  getPreviousPage() {
+    if (!this.hasPreviousPage()) {
+      throw new Error("No previous page available");
+    }
+    return this.pageFetcher({
+      page: this.pagination.currentPage - 1
+    });
+  }
+  async *iterPages() {
+    let page = this;
+    yield page;
+    while (page.hasNextPage()) {
+      page = await page.getNextPage();
+      yield page;
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const page of this.iterPages()) {
+      for (const item of page.getPaginatedItems()) {
+        yield item;
+      }
+    }
+  }
+};
+__name(_OffsetLimitPage, "OffsetLimitPage");
+var OffsetLimitPage = _OffsetLimitPage;
+
+// src/v3/apiClient/core.ts
 var defaultRetryOptions2 = {
   maxAttempts: 3,
   factor: 2,
@@ -177,21 +293,62 @@ var defaultRetryOptions2 = {
   maxTimeoutInMs: 6e4,
   randomize: false
 };
-async function zodfetch(schema, url, requestInit, options) {
-  return await _doZodFetch(schema, url, requestInit, options);
+function zodfetch(schema, url, requestInit, options) {
+  return new ApiPromise(_doZodFetch(schema, url, requestInit, options));
 }
 __name(zodfetch, "zodfetch");
-var _MultipartBody = class _MultipartBody {
-  constructor(body) {
-    this.body = body;
+function zodfetchCursorPage(schema, url, params, requestInit, options) {
+  const query = new URLSearchParams(params.query);
+  if (params.limit) {
+    query.set("page[size]", String(params.limit));
   }
-  get [Symbol.toStringTag]() {
-    return "MultipartBody";
+  if (params.after) {
+    query.set("page[after]", params.after);
   }
-};
-__name(_MultipartBody, "MultipartBody");
-var MultipartBody = _MultipartBody;
-async function zodupload(schema, url, body, requestInit, options) {
+  if (params.before) {
+    query.set("page[before]", params.before);
+  }
+  const cursorPageSchema = z.object({
+    data: z.array(schema),
+    pagination: z.object({
+      next: z.string().optional(),
+      previous: z.string().optional()
+    })
+  });
+  const $url = new URL(url);
+  $url.search = query.toString();
+  const fetchResult = _doZodFetch(cursorPageSchema, $url.href, requestInit, options);
+  return new CursorPagePromise(fetchResult, schema, url, params, requestInit, options);
+}
+__name(zodfetchCursorPage, "zodfetchCursorPage");
+function zodfetchOffsetLimitPage(schema, url, params, requestInit, options) {
+  const query = new URLSearchParams(params.query);
+  if (params.limit) {
+    query.set("perPage", String(params.limit));
+  }
+  if (params.page) {
+    query.set("page", String(params.page));
+  }
+  const offsetLimitPageSchema = z.object({
+    data: z.array(schema),
+    pagination: z.object({
+      currentPage: z.coerce.number(),
+      totalPages: z.coerce.number(),
+      count: z.coerce.number()
+    })
+  });
+  const $url = new URL(url);
+  $url.search = query.toString();
+  const fetchResult = _doZodFetch(offsetLimitPageSchema, $url.href, requestInit, options);
+  return new OffsetLimitPagePromise(fetchResult, schema, url, params, requestInit, options);
+}
+__name(zodfetchOffsetLimitPage, "zodfetchOffsetLimitPage");
+function zodupload(schema, url, body, requestInit, options) {
+  const finalRequestInit = createMultipartFormRequestInit(body, requestInit);
+  return new ApiPromise(_doZodFetch(schema, url, finalRequestInit, options));
+}
+__name(zodupload, "zodupload");
+async function createMultipartFormRequestInit(body, requestInit) {
   const form = await createForm(body);
   const encoder = new FormDataEncoder(form);
   const finalHeaders = {};
@@ -209,9 +366,9 @@ async function zodupload(schema, url, body, requestInit, options) {
     // @ts-expect-error
     duplex: "half"
   };
-  return await _doZodFetch(schema, url, finalRequestInit, options);
+  return finalRequestInit;
 }
-__name(zodupload, "zodupload");
+__name(createMultipartFormRequestInit, "createMultipartFormRequestInit");
 var createForm = /* @__PURE__ */ __name(async (body) => {
   const form = new FormData();
   await Promise.all(Object.entries(body || {}).map(([key, value]) => addFormValue(form, key, value)));
@@ -219,7 +376,8 @@ var createForm = /* @__PURE__ */ __name(async (body) => {
 }, "createForm");
 async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
   try {
-    const response = await fetch(url, requestInitWithCache(requestInit));
+    const $requestInit = await requestInit;
+    const response = await fetch(url, requestInitWithCache($requestInit));
     const responseHeaders = createResponseHeaders(response.headers);
     if (!response.ok) {
       const retryResult = shouldRetry(response, attempt, options?.retry);
@@ -230,17 +388,20 @@ async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
         const errText = await response.text().catch((e) => castToError2(e).message);
         const errJSON = safeJsonParse(errText);
         const errMessage = errJSON ? void 0 : errText;
-        throw APIError.generate(response.status, errJSON, errMessage, responseHeaders);
+        throw ApiError.generate(response.status, errJSON, errMessage, responseHeaders);
       }
     }
     const jsonBody = await response.json();
     const parsedResult = schema.safeParse(jsonBody);
     if (parsedResult.success) {
-      return parsedResult.data;
+      return {
+        data: parsedResult.data,
+        response
+      };
     }
     throw fromZodError(parsedResult.error);
   } catch (error) {
-    if (error instanceof APIError) {
+    if (error instanceof ApiError) {
       throw error;
     }
     if (options?.retry) {
@@ -254,7 +415,7 @@ async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
         return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
       }
     }
-    throw new APIConnectionError({
+    throw new ApiConnectionError({
       cause: castToError2(error)
     });
   }
@@ -427,7 +588,129 @@ var isUploadable = /* @__PURE__ */ __name((value) => {
   return isFileLike(value) || isResponseLike(value) || isFsReadStream(value);
 }, "isUploadable");
 var isRecordLike = /* @__PURE__ */ __name((value) => value != null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0 && Object.keys(value).every((key) => typeof key === "string" && typeof value[key] === "string"), "isRecordLike");
+var _ApiPromise = class _ApiPromise extends Promise {
+  constructor(responsePromise) {
+    super((resolve) => {
+      resolve(null);
+    });
+    this.responsePromise = responsePromise;
+  }
+  /**
+  * Gets the raw `Response` instance instead of parsing the response
+  * data.
+  *
+  * If you want to parse the response body but still get the `Response`
+  * instance, you can use {@link withResponse()}.
+  */
+  asResponse() {
+    return this.responsePromise.then((p) => p.response);
+  }
+  /**
+  * Gets the parsed response data and the raw `Response` instance.
+  *
+  * If you just want to get the raw `Response` instance without parsing it,
+  * you can use {@link asResponse()}.
+  */
+  async withResponse() {
+    const [data, response] = await Promise.all([
+      this.parse(),
+      this.asResponse()
+    ]);
+    return {
+      data,
+      response
+    };
+  }
+  parse() {
+    return this.responsePromise.then((result) => result.data);
+  }
+  then(onfulfilled, onrejected) {
+    return this.parse().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.parse().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.parse().finally(onfinally);
+  }
+};
+__name(_ApiPromise, "ApiPromise");
+var ApiPromise = _ApiPromise;
+var _fetchPage, fetchPage_fn;
+var _CursorPagePromise = class _CursorPagePromise extends ApiPromise {
+  constructor(result, schema, url, params, requestInit, options) {
+    super(result.then((result2) => ({
+      data: new CursorPage(result2.data.data, result2.data.pagination, __privateMethod(this, _fetchPage, fetchPage_fn).bind(this)),
+      response: result2.response
+    })));
+    __privateAdd(this, _fetchPage);
+    this.schema = schema;
+    this.url = url;
+    this.params = params;
+    this.requestInit = requestInit;
+    this.options = options;
+  }
+  /**
+  * Allow auto-paginating iteration on an unawaited list call, eg:
+  *
+  *    for await (const item of client.items.list()) {
+  *      console.log(item)
+  *    }
+  */
+  async *[Symbol.asyncIterator]() {
+    const page = await this;
+    for await (const item of page) {
+      yield item;
+    }
+  }
+};
+_fetchPage = new WeakSet();
+fetchPage_fn = /* @__PURE__ */ __name(function(params) {
+  return zodfetchCursorPage(this.schema, this.url, {
+    ...this.params,
+    ...params
+  }, this.requestInit, this.options);
+}, "#fetchPage");
+__name(_CursorPagePromise, "CursorPagePromise");
+var CursorPagePromise = _CursorPagePromise;
+var _fetchPage2, fetchPage_fn2;
+var _OffsetLimitPagePromise = class _OffsetLimitPagePromise extends ApiPromise {
+  constructor(result, schema, url, params, requestInit, options) {
+    super(result.then((result2) => ({
+      data: new OffsetLimitPage(result2.data.data, result2.data.pagination, __privateMethod(this, _fetchPage2, fetchPage_fn2).bind(this)),
+      response: result2.response
+    })));
+    __privateAdd(this, _fetchPage2);
+    this.schema = schema;
+    this.url = url;
+    this.params = params;
+    this.requestInit = requestInit;
+    this.options = options;
+  }
+  /**
+  * Allow auto-paginating iteration on an unawaited list call, eg:
+  *
+  *    for await (const item of client.items.list()) {
+  *      console.log(item)
+  *    }
+  */
+  async *[Symbol.asyncIterator]() {
+    const page = await this;
+    for await (const item of page) {
+      yield item;
+    }
+  }
+};
+_fetchPage2 = new WeakSet();
+fetchPage_fn2 = /* @__PURE__ */ __name(function(params1) {
+  return zodfetchOffsetLimitPage(this.schema, this.url, {
+    ...this.params,
+    ...params1
+  }, this.requestInit, this.options);
+}, "#fetchPage");
+__name(_OffsetLimitPagePromise, "OffsetLimitPagePromise");
+var OffsetLimitPagePromise = _OffsetLimitPagePromise;
 
-export { MultipartBody, createForm, defaultRetryOptions2 as defaultRetryOptions, isBlobLike, isFileLike, isFsReadStream, isRecordLike, isResponseLike, isUploadable, toFile, zodfetch, zodupload };
+export { ApiConnectionError, ApiError, ApiPromise, AuthenticationError, BadRequestError, ConflictError, CursorPage, CursorPagePromise, InternalServerError, NotFoundError, OffsetLimitPage, OffsetLimitPagePromise, PermissionDeniedError, RateLimitError, UnprocessableEntityError, defaultRetryOptions2 as defaultRetryOptions, isBlobLike, isFileLike, isFsReadStream, isRecordLike, isResponseLike, isUploadable, toFile, zodfetch, zodfetchCursorPage, zodfetchOffsetLimitPage, zodupload };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=zodfetch.mjs.map