@upstash/qstash 2.5.0 → 2.5.1

package/index.mjs

@@ -0,0 +1,583 @@
+import {
+  Receiver,
+  SignatureError
+} from "./chunk-CP4IU45K.mjs";
+
+// src/client/dlq.ts
+var DLQ = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List messages in the dlq
+   */
+  async listMessages(options) {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "dlq"],
+      query: { cursor: options?.cursor }
+    });
+  }
+  /**
+   * Remove a message from the dlq using it's `dlqId`
+   */
+  async delete(dlqMessageId) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "dlq", dlqMessageId],
+      parseResponseAsJson: false
+      // there is no response
+    });
+  }
+  /**
+   * Remove multiple messages from the dlq using their `dlqId`s
+   */
+  async deleteMany(request) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "dlq"],
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ dlqIds: request.dlqIds })
+    });
+  }
+};
+
+// src/client/error.ts
+var QstashError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "QstashError";
+  }
+};
+var QstashRatelimitError = class extends QstashError {
+  constructor(args) {
+    super(`You have been ratelimited. ${JSON.stringify(args)} `);
+  }
+};
+
+// src/client/http.ts
+var HttpClient = class {
+  baseUrl;
+  authorization;
+  options;
+  retry;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.authorization = config.authorization;
+    this.retry = // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    typeof config.retry === "boolean" && !config.retry ? {
+      attempts: 1,
+      backoff: () => 0
+    } : {
+      attempts: config.retry?.retries ? config.retry.retries + 1 : 5,
+      backoff: config.retry?.backoff ?? ((retryCount) => Math.exp(retryCount) * 50)
+    };
+  }
+  async request(request) {
+    const headers = new Headers(request.headers);
+    headers.set("Authorization", this.authorization);
+    const requestOptions = {
+      method: request.method,
+      headers,
+      body: request.body,
+      keepalive: request.keepalive
+    };
+    const url = new URL([this.baseUrl, ...request.path].join("/"));
+    if (request.query) {
+      for (const [key, value] of Object.entries(request.query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, value.toString());
+        }
+      }
+    }
+    let response = void 0;
+    let error = void 0;
+    for (let index = 0; index < this.retry.attempts; index++) {
+      try {
+        response = await fetch(url.toString(), requestOptions);
+        break;
+      } catch (error_) {
+        error = error_;
+        await new Promise((r) => setTimeout(r, this.retry.backoff(index)));
+      }
+    }
+    if (!response) {
+      throw error ?? new Error("Exhausted all retries");
+    }
+    if (response.status === 429) {
+      throw new QstashRatelimitError({
+        limit: response.headers.get("Burst-RateLimit-Limit"),
+        remaining: response.headers.get("Burst-RateLimit-Remaining"),
+        reset: response.headers.get("Burst-RateLimit-Reset")
+      });
+    }
+    if (response.status < 200 || response.status >= 300) {
+      const body = await response.text();
+      throw new QstashError(body.length > 0 ? body : `Error: status=${response.status}`);
+    }
+    if (request.parseResponseAsJson === false) {
+      return void 0;
+    }
+    return await response.json();
+  }
+};
+
+// src/client/messages.ts
+var Messages = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get a message
+   */
+  async get(messageId) {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "messages", messageId]
+    });
+  }
+  /**
+   * Cancel a message
+   */
+  async delete(messageId) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "messages", messageId],
+      parseResponseAsJson: false
+    });
+  }
+};
+
+// src/client/utils.ts
+import { Headers as Headers2 } from "undici";
+var isIgnoredHeader = (header) => {
+  const lowerCaseHeader = header.toLowerCase();
+  return lowerCaseHeader.startsWith("content-type") || lowerCaseHeader.startsWith("upstash-");
+};
+function prefixHeaders(headers) {
+  const keysToBePrefixed = [...headers.keys()].filter((key) => !isIgnoredHeader(key));
+  for (const key of keysToBePrefixed) {
+    const value = headers.get(key);
+    if (value !== null) {
+      headers.set(`Upstash-Forward-${key}`, value);
+    }
+    headers.delete(key);
+  }
+  return headers;
+}
+function processHeaders(request) {
+  const headers = prefixHeaders(new Headers2(request.headers));
+  headers.set("Upstash-Method", request.method ?? "POST");
+  if (request.delay !== void 0) {
+    headers.set("Upstash-Delay", `${request.delay.toFixed(0)}s`);
+  }
+  if (request.notBefore !== void 0) {
+    headers.set("Upstash-Not-Before", request.notBefore.toFixed(0));
+  }
+  if (request.deduplicationId !== void 0) {
+    headers.set("Upstash-Deduplication-Id", request.deduplicationId);
+  }
+  if (request.contentBasedDeduplication !== void 0) {
+    headers.set("Upstash-Content-Based-Deduplication", "true");
+  }
+  if (request.retries !== void 0) {
+    headers.set("Upstash-Retries", request.retries.toFixed(0));
+  }
+  if (request.callback !== void 0) {
+    headers.set("Upstash-Callback", request.callback);
+  }
+  if (request.failureCallback !== void 0) {
+    headers.set("Upstash-Failure-Callback", request.failureCallback);
+  }
+  return headers;
+}
+
+// src/client/queue.ts
+import { Headers as Headers3 } from "undici";
+var Queue = class {
+  http;
+  queueName;
+  constructor(http, queueName) {
+    this.http = http;
+    this.queueName = queueName;
+  }
+  /**
+   * Create or update the queue
+   */
+  async upsert(request) {
+    if (!this.queueName) {
+      throw new Error("Please provide a queue name to the Queue constructor");
+    }
+    const body = {
+      queueName: this.queueName,
+      parallelism: request.parallelism
+    };
+    await this.http.request({
+      method: "POST",
+      path: ["v2", "queues"],
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Get the queue details
+   */
+  async get() {
+    if (!this.queueName) {
+      throw new Error("Please provide a queue name to the Queue constructor");
+    }
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "queues", this.queueName]
+    });
+  }
+  /**
+   * List queues
+   */
+  async list() {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "queues"]
+    });
+  }
+  /**
+   * Delete the queue
+   */
+  async delete() {
+    if (!this.queueName) {
+      throw new Error("Please provide a queue name to the Queue constructor");
+    }
+    await this.http.request({
+      method: "DELETE",
+      path: ["v2", "queues", this.queueName],
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Enqueue a message to a queue.
+   */
+  async enqueue(request) {
+    if (!this.queueName) {
+      throw new Error("Please provide a queue name to the Queue constructor");
+    }
+    const headers = processHeaders(request);
+    const destination = request.url ?? request.topic;
+    const response = await this.http.request({
+      path: ["v2", "enqueue", this.queueName, destination],
+      body: request.body,
+      headers,
+      method: "POST"
+    });
+    return response;
+  }
+  /**
+   * Enqueue a message to a queue, serializing the body to JSON.
+   */
+  async enqueueJSON(request) {
+    const headers = prefixHeaders(new Headers3(request.headers));
+    headers.set("Content-Type", "application/json");
+    const response = await this.enqueue({
+      ...request,
+      body: JSON.stringify(request.body),
+      headers
+    });
+    return response;
+  }
+};
+
+// src/client/schedules.ts
+import { Headers as Headers4 } from "undici";
+var Schedules = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a schedule
+   */
+  async create(request) {
+    const headers = prefixHeaders(new Headers4(request.headers));
+    if (!headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    headers.set("Upstash-Cron", request.cron);
+    if (request.method !== void 0) {
+      headers.set("Upstash-Method", request.method);
+    }
+    if (request.delay !== void 0) {
+      headers.set("Upstash-Delay", `${request.delay.toFixed(0)}s`);
+    }
+    if (request.retries !== void 0) {
+      headers.set("Upstash-Retries", request.retries.toFixed(0));
+    }
+    if (request.callback !== void 0) {
+      headers.set("Upstash-Callback", request.callback);
+    }
+    if (request.failureCallback !== void 0) {
+      headers.set("Upstash-Failure-Callback", request.failureCallback);
+    }
+    return await this.http.request({
+      method: "POST",
+      headers,
+      path: ["v2", "schedules", request.destination],
+      body: request.body
+    });
+  }
+  /**
+   * Get a schedule
+   */
+  async get(scheduleId) {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "schedules", scheduleId]
+    });
+  }
+  /**
+   * List your schedules
+   */
+  async list() {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "schedules"]
+    });
+  }
+  /**
+   * Delete a schedule
+   */
+  async delete(scheduleId) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "schedules", scheduleId],
+      parseResponseAsJson: false
+    });
+  }
+};
+
+// src/client/topics.ts
+var Topics = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new topic with the given name and endpoints
+   */
+  async addEndpoints(request) {
+    await this.http.request({
+      method: "POST",
+      path: ["v2", "topics", request.name, "endpoints"],
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ endpoints: request.endpoints }),
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Remove endpoints from a topic.
+   */
+  async removeEndpoints(request) {
+    await this.http.request({
+      method: "DELETE",
+      path: ["v2", "topics", request.name, "endpoints"],
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ endpoints: request.endpoints }),
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Get a list of all topics.
+   */
+  async list() {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "topics"]
+    });
+  }
+  /**
+   * Get a single topic
+   */
+  async get(name) {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "topics", name]
+    });
+  }
+  /**
+   * Delete a topic
+   */
+  async delete(name) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "topics", name],
+      parseResponseAsJson: false
+    });
+  }
+};
+
+// src/client/client.ts
+import { Headers as Headers5 } from "undici";
+var Client = class {
+  http;
+  constructor(config) {
+    this.http = new HttpClient({
+      retry: config.retry,
+      baseUrl: config.baseUrl ? config.baseUrl.replace(/\/$/, "") : "https://qstash.upstash.io",
+      authorization: `Bearer ${config.token}`
+    });
+  }
+  /**
+   * Access the topic API.
+   *
+   * Create, read, update or delete topics.
+   */
+  get topics() {
+    return new Topics(this.http);
+  }
+  /**
+   * Access the dlq API.
+   *
+   * List or remove messages from the DLQ.
+   */
+  get dlq() {
+    return new DLQ(this.http);
+  }
+  /**
+   * Access the message API.
+   *
+   * Read or cancel messages.
+   */
+  get messages() {
+    return new Messages(this.http);
+  }
+  /**
+   * Access the schedule API.
+   *
+   * Create, read or delete schedules.
+   */
+  get schedules() {
+    return new Schedules(this.http);
+  }
+  /**
+   * Access the queue API.
+   *
+   * Create, read, update or delete queues.
+   */
+  queue(request) {
+    return new Queue(this.http, request?.queueName);
+  }
+  async publish(request) {
+    const headers = processHeaders(request);
+    const response = await this.http.request({
+      path: ["v2", "publish", request.url ?? request.topic],
+      body: request.body,
+      headers,
+      method: "POST"
+    });
+    return response;
+  }
+  /**
+   * publishJSON is a utility wrapper around `publish` that automatically serializes the body
+   * and sets the `Content-Type` header to `application/json`.
+   */
+  async publishJSON(request) {
+    const headers = prefixHeaders(new Headers5(request.headers));
+    headers.set("Content-Type", "application/json");
+    const response = await this.publish({
+      ...request,
+      headers,
+      body: JSON.stringify(request.body)
+    });
+    return response;
+  }
+  /**
+   * Batch publish messages to QStash.
+   */
+  async batch(request) {
+    const messages = [];
+    for (const message of request) {
+      const headers = processHeaders(message);
+      const headerEntries = Object.fromEntries(headers.entries());
+      messages.push({
+        destination: message.url ?? message.topic,
+        headers: headerEntries,
+        body: message.body
+      });
+    }
+    const response = await this.http.request({
+      path: ["v2", "batch"],
+      body: JSON.stringify(messages),
+      headers: {
+        "Content-Type": "application/json"
+      },
+      method: "POST"
+    });
+    return response;
+  }
+  /**
+   * Batch publish messages to QStash, serializing each body to JSON.
+   */
+  async batchJSON(request) {
+    for (const message of request) {
+      if ("body" in message) {
+        message.body = JSON.stringify(message.body);
+      }
+      message.headers = new Headers5(message.headers);
+      message.headers.set("Content-Type", "application/json");
+    }
+    const response = await this.batch(request);
+    return response;
+  }
+  /**
+   * Retrieve your logs.
+   *
+   * The logs endpoint is paginated and returns only 100 logs at a time.
+   * If you want to receive more logs, you can use the cursor to paginate.
+   *
+   * The cursor is a unix timestamp with millisecond precision
+   *
+   * @example
+   * ```ts
+   * let cursor = Date.now()
+   * const logs: Log[] = []
+   * while (cursor > 0) {
+   *   const res = await qstash.logs({ cursor })
+   *   logs.push(...res.logs)
+   *   cursor = res.cursor ?? 0
+   * }
+   * ```
+   */
+  async events(request) {
+    const query = {};
+    if (request?.cursor && request.cursor > 0) {
+      query.cursor = request.cursor.toString();
+    }
+    for (const [key, value] of Object.entries(request?.filter ?? {})) {
+      if (typeof value === "number" && value < 0) {
+        continue;
+      }
+      if (typeof value !== "undefined") {
+        query[key] = value.toString();
+      }
+    }
+    const response = await this.http.request({
+      path: ["v2", "events"],
+      method: "GET",
+      query
+    });
+    return response;
+  }
+};
+export {
+  Client,
+  Messages,
+  QstashError,
+  QstashRatelimitError,
+  Receiver,
+  Schedules,
+  SignatureError,
+  Topics
+};

package/{dist/nextjs.d.mts → nextjs.d.mts}

@@ -18,8 +18,8 @@ type VerifySignatureConfig = {
     clockTolerance?: number;
 };
 declare function verifySignature(handler: NextApiHandler, config?: VerifySignatureConfig): NextApiHandler;
-declare function verifySignatureEdge(handler: (req: NextRequest, nfe?: NextFetchEvent) => NextResponse | Promise<NextResponse>, config?: VerifySignatureConfig): (req: NextRequest, nfe: NextFetchEvent) => Promise<NextResponse<unknown>>;
-type VerifySignatureAppRouterResponse = NextResponse | Promise<NextResponse>;
-declare function verifySignatureAppRouter(handler: ((req: Request) => VerifySignatureAppRouterResponse) | ((req: NextRequest) => VerifySignatureAppRouterResponse), config?: VerifySignatureConfig): (req: NextRequest | Request) => Promise<NextResponse<unknown>>;
+declare function verifySignatureEdge(handler: (request: NextRequest, nfe?: NextFetchEvent) => NextResponse | Promise<NextResponse>, config?: VerifySignatureConfig): (request: NextRequest, nfe: NextFetchEvent) => Promise<NextResponse<unknown>>;
+type VerifySignatureAppRouterResponse = NextResponse | Promise<NextResponse> | Response | Promise<Response>;
+declare function verifySignatureAppRouter(handler: ((request: Request) => VerifySignatureAppRouterResponse) | ((request: NextRequest) => VerifySignatureAppRouterResponse), config?: VerifySignatureConfig): (request: NextRequest | Request) => Promise<Response>;
 
-export { VerifySignatureConfig, verifySignature, verifySignatureAppRouter, verifySignatureEdge };
+export { type VerifySignatureConfig, verifySignature, verifySignatureAppRouter, verifySignatureEdge };

package/{dist/nextjs.d.ts → nextjs.d.ts}

@@ -18,8 +18,8 @@ type VerifySignatureConfig = {
     clockTolerance?: number;
 };
 declare function verifySignature(handler: NextApiHandler, config?: VerifySignatureConfig): NextApiHandler;
-declare function verifySignatureEdge(handler: (req: NextRequest, nfe?: NextFetchEvent) => NextResponse | Promise<NextResponse>, config?: VerifySignatureConfig): (req: NextRequest, nfe: NextFetchEvent) => Promise<NextResponse<unknown>>;
-type VerifySignatureAppRouterResponse = NextResponse | Promise<NextResponse>;
-declare function verifySignatureAppRouter(handler: ((req: Request) => VerifySignatureAppRouterResponse) | ((req: NextRequest) => VerifySignatureAppRouterResponse), config?: VerifySignatureConfig): (req: NextRequest | Request) => Promise<NextResponse<unknown>>;
+declare function verifySignatureEdge(handler: (request: NextRequest, nfe?: NextFetchEvent) => NextResponse | Promise<NextResponse>, config?: VerifySignatureConfig): (request: NextRequest, nfe: NextFetchEvent) => Promise<NextResponse<unknown>>;
+type VerifySignatureAppRouterResponse = NextResponse | Promise<NextResponse> | Response | Promise<Response>;
+declare function verifySignatureAppRouter(handler: ((request: Request) => VerifySignatureAppRouterResponse) | ((request: NextRequest) => VerifySignatureAppRouterResponse), config?: VerifySignatureConfig): (request: NextRequest | Request) => Promise<Response>;
 
-export { VerifySignatureConfig, verifySignature, verifySignatureAppRouter, verifySignatureEdge };
+export { type VerifySignatureConfig, verifySignature, verifySignatureAppRouter, verifySignatureEdge };