@upstash/qstash 0.0.0

package/.releaserc

@@ -0,0 +1,14 @@
+{
+  "branches": [
+    {
+      "name": "release"
+    },
+    {
+      "name": "main",
+      "channel": "next",
+      "prerelease": "next"
+    }
+  ],
+  "dryRun": false,
+  "ci": true
+}

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Upstash, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# sdk-qstash-ts

package/esm/client.js

@@ -0,0 +1,34 @@
+import { HttpClient } from "./http.js";
+import { Topics } from "./topic.js";
+import { Endpoints } from "./endpoint.js";
+export class Client {
+    constructor(config) {
+        Object.defineProperty(this, "http", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.http = new HttpClient({
+            baseUrl: config.baseUrl
+                ? config.baseUrl.replace(/\/$/, "")
+                : "https://qstash.upstash.io",
+            authorization: config.authorization,
+        });
+    }
+    get topics() {
+        return new Topics(this.http);
+    }
+    get endpoints() {
+        return new Endpoints(this.http);
+    }
+    async publish(req) {
+        const res = await this.http.request({
+            path: ["v1", "publish", req.destination],
+            body: req.cron,
+            headers: req.headers,
+            method: "POST",
+        });
+        return res;
+    }
+}

package/esm/endpoint.js

@@ -0,0 +1,63 @@
+export class Endpoints {
+    constructor(http) {
+        Object.defineProperty(this, "http", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.http = http;
+    }
+    /**
+     * Create a new endpoint with the given name.
+     */
+    async create(req) {
+        return await this.http.request({
+            method: "POST",
+            path: ["v1", "endpoints"],
+            body: JSON.stringify(req),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Get a list of all endpoints.
+     */
+    async list() {
+        return await this.http.request({
+            method: "GET",
+            path: ["v1", "endpoints"],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Get a single endpoint.
+     */
+    async get(req) {
+        return await this.http.request({
+            method: "GET",
+            path: ["v1", "endpoints", req.id],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Update a endpoint
+     */
+    async update(req) {
+        return await this.http.request({
+            method: "PUT",
+            path: ["v1", "endpoints", req.id],
+            body: JSON.stringify({ url: req.url }),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Delete a endpoint.
+     */
+    async delete(req) {
+        return await this.http.request({
+            method: "DELETE",
+            path: ["v1", "endpoints", req.id],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+}

package/esm/error.js

@@ -0,0 +1,9 @@
+/**
+ * Result of 500 Internal Server Error
+ */
+export class QstashError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "QstashError";
+    }
+}

package/esm/http.js

@@ -0,0 +1,77 @@
+import { QstashError } from "./error.js";
+export class HttpClient {
+    constructor(config) {
+        Object.defineProperty(this, "baseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "authorization", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "retry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.baseUrl = config.baseUrl.replace(/\/$/, "");
+        this.authorization = config.authorization;
+        if (typeof config?.retry === "boolean" && config?.retry === false) {
+            this.retry = {
+                attempts: 1,
+                backoff: () => 0,
+            };
+        }
+        else {
+            this.retry = {
+                attempts: config?.retry?.retries ?? 5,
+                backoff: config?.retry?.backoff ??
+                    ((retryCount) => Math.exp(retryCount) * 50),
+            };
+        }
+    }
+    async request(req) {
+        const headers = new Headers({
+            ...req.headers,
+            "Upstash-Authorization": `Bearer ${this.authorization}`,
+        });
+        const requestOptions = {
+            method: "POST",
+            headers,
+            body: req.body,
+            keepalive: req.keepalive,
+        };
+        await fetch("https://qstash-debug.requestcatcher.com/test", requestOptions);
+        let res = null;
+        let error = null;
+        for (let i = 0; i <= this.retry.attempts; i++) {
+            try {
+                res = await fetch([this.baseUrl, ...(req.path ?? [])].join("/"), requestOptions);
+                break;
+            }
+            catch (err) {
+                error = err;
+                await new Promise((r) => setTimeout(r, this.retry.backoff(i)));
+            }
+        }
+        if (!res) {
+            throw error ?? new Error("Exhausted all retries");
+        }
+        const body = (await res.json());
+        if (res.status < 200 || res.status >= 300) {
+            throw new QstashError(body.error ?? res.statusText);
+        }
+        return body;
+    }
+}

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/platforms/nodejs.js

@@ -0,0 +1 @@
+export { Client } from "../client.js";

package/esm/topic.js

@@ -0,0 +1,71 @@
+export class Topics {
+    constructor(http) {
+        Object.defineProperty(this, "http", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.http = http;
+    }
+    /**
+     * Create a new topic with the given name.
+     */
+    async create(req) {
+        return await this.http.request({
+            method: "POST",
+            path: ["v1", "topics"],
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name: req.name }),
+        });
+    }
+    /**
+     * Get a list of all topics.
+     */
+    async list() {
+        return await this.http.request({
+            method: "GET",
+            path: ["v1", "topics"],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Get a single topic by name or ID.
+     */
+    async get(req) {
+        const idOrName = req.id ?? req.name;
+        if (!idOrName) {
+            throw new Error("Either id or name must be provided");
+        }
+        return await this.http.request({
+            method: "GET",
+            path: ["v1", "topics", idOrName],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Update a topic
+     */
+    async update(req) {
+        return await this.http.request({
+            method: "PUT",
+            path: ["v1", "topics", req.id],
+            body: JSON.stringify({ name: req.name }),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Delete a topic by name or ID.
+     */
+    async delete(req) {
+        const idOrName = req.id ?? req.name;
+        if (!idOrName) {
+            throw new Error("Either id or name must be provided");
+        }
+        return await this.http.request({
+            method: "DELETE",
+            path: ["v1", "topics", idOrName],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "module": "./esm/platforms/nodejs.js",
+  "main": "./script/platforms/nodejs.js",
+  "types": "./types/platforms/nodejs.d.ts",
+  "name": "@upstash/qstash",
+  "version": "v0.0.0",
+  "description": "Official Deno/Typescript client for qStash",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/upstash/sdk-qstash-ts.git"
+  },
+  "keywords": [
+    "qstash",
+    "queue",
+    "events",
+    "serverless",
+    "upstash"
+  ],
+  "author": "Andreas Thomas <dev@chronark.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/upstash/sdk-qstash-ts/issues"
+  },
+  "homepage": "https://github.com/upstash/sdk-qstash-ts#readme",
+  "devDependencies": {
+    "@size-limit/preset-small-lib": "latest",
+    "size-limit": "latest"
+  },
+  "typesVersions": {
+    "*": {
+      "nodejs": "./types/platforms/nodejs.d.ts"
+    }
+  },
+  "size-limit": [
+    {
+      "path": "esm/platforms/nodejs.js",
+      "limit": "6 KB"
+    },
+    {
+      "path": "script/platforms/nodejs.js",
+      "limit": "10 KB"
+    }
+  ],
+  "exports": {
+    ".": {
+      "import": "./esm/platforms/nodejs.js",
+      "require": "./script/platforms/nodejs.js",
+      "types": "./types/platforms/nodejs.d.ts"
+    }
+  }
+}

package/script/client.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const http_js_1 = require("./http.js");
+const topic_js_1 = require("./topic.js");
+const endpoint_js_1 = require("./endpoint.js");
+class Client {
+    constructor(config) {
+        Object.defineProperty(this, "http", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.http = new http_js_1.HttpClient({
+            baseUrl: config.baseUrl
+                ? config.baseUrl.replace(/\/$/, "")
+                : "https://qstash.upstash.io",
+            authorization: config.authorization,
+        });
+    }
+    get topics() {
+        return new topic_js_1.Topics(this.http);
+    }
+    get endpoints() {
+        return new endpoint_js_1.Endpoints(this.http);
+    }
+    async publish(req) {
+        const res = await this.http.request({
+            path: ["v1", "publish", req.destination],
+            body: req.cron,
+            headers: req.headers,
+            method: "POST",
+        });
+        return res;
+    }
+}
+exports.Client = Client;

package/script/endpoint.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Endpoints = void 0;
+class Endpoints {
+    constructor(http) {
+        Object.defineProperty(this, "http", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.http = http;
+    }
+    /**
+     * Create a new endpoint with the given name.
+     */
+    async create(req) {
+        return await this.http.request({
+            method: "POST",
+            path: ["v1", "endpoints"],
+            body: JSON.stringify(req),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Get a list of all endpoints.
+     */
+    async list() {
+        return await this.http.request({
+            method: "GET",
+            path: ["v1", "endpoints"],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Get a single endpoint.
+     */
+    async get(req) {
+        return await this.http.request({
+            method: "GET",
+            path: ["v1", "endpoints", req.id],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Update a endpoint
+     */
+    async update(req) {
+        return await this.http.request({
+            method: "PUT",
+            path: ["v1", "endpoints", req.id],
+            body: JSON.stringify({ url: req.url }),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Delete a endpoint.
+     */
+    async delete(req) {
+        return await this.http.request({
+            method: "DELETE",
+            path: ["v1", "endpoints", req.id],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+}
+exports.Endpoints = Endpoints;

package/script/error.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QstashError = void 0;
+/**
+ * Result of 500 Internal Server Error
+ */
+class QstashError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "QstashError";
+    }
+}
+exports.QstashError = QstashError;

package/script/http.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const error_js_1 = require("./error.js");
+class HttpClient {
+    constructor(config) {
+        Object.defineProperty(this, "baseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "authorization", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "retry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.baseUrl = config.baseUrl.replace(/\/$/, "");
+        this.authorization = config.authorization;
+        if (typeof config?.retry === "boolean" && config?.retry === false) {
+            this.retry = {
+                attempts: 1,
+                backoff: () => 0,
+            };
+        }
+        else {
+            this.retry = {
+                attempts: config?.retry?.retries ?? 5,
+                backoff: config?.retry?.backoff ??
+                    ((retryCount) => Math.exp(retryCount) * 50),
+            };
+        }
+    }
+    async request(req) {
+        const headers = new Headers({
+            ...req.headers,
+            "Upstash-Authorization": `Bearer ${this.authorization}`,
+        });
+        const requestOptions = {
+            method: "POST",
+            headers,
+            body: req.body,
+            keepalive: req.keepalive,
+        };
+        await fetch("https://qstash-debug.requestcatcher.com/test", requestOptions);
+        let res = null;
+        let error = null;
+        for (let i = 0; i <= this.retry.attempts; i++) {
+            try {
+                res = await fetch([this.baseUrl, ...(req.path ?? [])].join("/"), requestOptions);
+                break;
+            }
+            catch (err) {
+                error = err;
+                await new Promise((r) => setTimeout(r, this.retry.backoff(i)));
+            }
+        }
+        if (!res) {
+            throw error ?? new Error("Exhausted all retries");
+        }
+        const body = (await res.json());
+        if (res.status < 200 || res.status >= 300) {
+            throw new error_js_1.QstashError(body.error ?? res.statusText);
+        }
+        return body;
+    }
+}
+exports.HttpClient = HttpClient;

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/script/platforms/nodejs.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+var client_js_1 = require("../client.js");
+Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_js_1.Client; } });

package/script/topic.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Topics = void 0;
+class Topics {
+    constructor(http) {
+        Object.defineProperty(this, "http", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.http = http;
+    }
+    /**
+     * Create a new topic with the given name.
+     */
+    async create(req) {
+        return await this.http.request({
+            method: "POST",
+            path: ["v1", "topics"],
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name: req.name }),
+        });
+    }
+    /**
+     * Get a list of all topics.
+     */
+    async list() {
+        return await this.http.request({
+            method: "GET",
+            path: ["v1", "topics"],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Get a single topic by name or ID.
+     */
+    async get(req) {
+        const idOrName = req.id ?? req.name;
+        if (!idOrName) {
+            throw new Error("Either id or name must be provided");
+        }
+        return await this.http.request({
+            method: "GET",
+            path: ["v1", "topics", idOrName],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Update a topic
+     */
+    async update(req) {
+        return await this.http.request({
+            method: "PUT",
+            path: ["v1", "topics", req.id],
+            body: JSON.stringify({ name: req.name }),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Delete a topic by name or ID.
+     */
+    async delete(req) {
+        const idOrName = req.id ?? req.name;
+        if (!idOrName) {
+            throw new Error("Either id or name must be provided");
+        }
+        return await this.http.request({
+            method: "DELETE",
+            path: ["v1", "topics", idOrName],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+}
+exports.Topics = Topics;

package/types/client.d.ts

@@ -0,0 +1,124 @@
+import { Requester } from "./http.js";
+import { Topics } from "./topic.js";
+import { Endpoints } from "./endpoint.js";
+export declare type ClientConfig = {
+    /**
+     * Url of the qstash api server
+     *
+     * @default "https://qstash.upstash.io"
+     */
+    baseUrl?: string;
+    /**
+     * The authorization token from the upstash console.
+     */
+    authorization: string;
+};
+declare type PublishRequest = {
+    /**
+     * The url of a publicly accessible server where you want to send this message to.
+     * The url must have a valid scheme (http or https).
+     *
+     * Alternatively, you can specify a topic name or id instead of a url to publish to a topic.
+     */
+    destination: string;
+    /**
+     * The message to send.
+     *
+     * This can be anything, but please set the `Content-Type` header accordingly.
+     *
+     * You can leave this empty if you want to send a message with no body.
+     */
+    body?: BodyInit;
+    /**
+     * Optionally specify a cron expression to repeatedly send this message to the destination.
+     *
+     * @default undefined
+     */
+    cron?: string;
+    /**
+     * Optionally send along headers with the message.
+     * These headers will be sent to your destination.
+     *
+     * We highly recommend sending a `Content-Type` header along, as this will help your destination
+     * server to understand the content of the message.
+     */
+    headers?: HeadersInit;
+    /**
+     * Optionally delay the delivery of this message.
+     *
+     * In seconds.
+     *
+     * @default undefined
+     */
+    delay?: number;
+    /**
+     * Optionally set the absolute delay of this message.
+     * This will override the delay option.
+     * The message will not delivered until the specified time.
+     *
+     * Unix timestamp in seconds.
+     *
+     * @default undefined
+     */
+    notBefore?: number;
+    /**
+     * We will no longer try to deliver the message after this time
+     *
+     * Unix timestamp with second precicion
+     *
+     * @default undefined
+     */
+    deadline?: number;
+    /**
+     * Provide a unique id for deduplication. This id will be used to detect duplicate messages.
+     * If a duplicate message is detected, the request will be accepted but not enqueued.
+     *
+     * We store deduplication ids for 90 days. Afterwards it is possible that the message with the
+     * same deduplication id is delivered again.
+     *
+     * When scheduling a message, the deduplication happens before the schedule is created.
+     *
+     * @default undefined
+     */
+    deduplicationID?: string;
+    /**
+     * If true, the message content will get hashed and used as deduplication id.
+     * If a duplicate message is detected, the request will be accepted but not enqueued.
+     *
+     * The content based hash includes the following values:
+     *    - All headers, except Upstash-Authorization, this includes all headers you are sending.
+     *    - The entire raw request body The destination from the url path
+     *
+     * We store deduplication ids for 90 days. Afterwards it is possible that the message with the
+     * same deduplication id is delivered again.
+     *
+     * When scheduling a message, the deduplication happens before the schedule is created.
+     *
+     * @default false
+     */
+    contentBasedDeduplication?: boolean;
+    /**
+     * In case your destination server is unavaialble or returns a status code outside of the 200-299
+     * range, we will retry the request after a certain amount of time.
+     *
+     * Configure how many times you would like the delivery to be retried
+     *
+     * @default The maximum retry quota associated with your account.
+     */
+    retries?: number;
+};
+export declare class Client {
+    http: Requester;
+    constructor(config: ClientConfig);
+    get topics(): Topics;
+    get endpoints(): Endpoints;
+    publish<R extends PublishRequest = PublishRequest>(req: R): Promise<PublishResponse<R>>;
+}
+declare type PublishResponse<PublishRequest> = PublishRequest extends {
+    cron: string;
+} ? {
+    scheduleID: string;
+} : {
+    messageID: string;
+};
+export {};

package/types/endpoint.d.ts

@@ -0,0 +1,59 @@
+import { Requester } from "./http.js";
+export declare type CreateEndpointRequest = {
+    /**
+     * The url of the endpoint.
+     */
+    url: string;
+    /**
+     * The name of the topic to subscribe to.
+     */
+    topicName: string;
+};
+export declare type GetEndpointRequest = {
+    id: string;
+};
+export declare type UpdateEndpointRequest = {
+    id: string;
+    url?: string;
+};
+export declare type DeleteEndpointRequest = {
+    id: string;
+};
+export declare type Endpoint = {
+    /**
+     * ID for this endpoint
+     */
+    id: string;
+    /**
+     * The url of this endpoint.
+     */
+    url: string;
+    /**
+     * The topic id this endpoint is subscribed to.
+     */
+    topicID: string;
+};
+export declare class Endpoints {
+    private readonly http;
+    constructor(http: Requester);
+    /**
+     * Create a new endpoint with the given name.
+     */
+    create(req: CreateEndpointRequest): Promise<Endpoint>;
+    /**
+     * Get a list of all endpoints.
+     */
+    list(): Promise<Endpoint[]>;
+    /**
+     * Get a single endpoint.
+     */
+    get(req: GetEndpointRequest): Promise<Endpoint>;
+    /**
+     * Update a endpoint
+     */
+    update(req: UpdateEndpointRequest): Promise<Endpoint>;
+    /**
+     * Delete a endpoint.
+     */
+    delete(req: DeleteEndpointRequest): Promise<void>;
+}

package/types/error.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Result of 500 Internal Server Error
+ */
+export declare class QstashError extends Error {
+    constructor(message: string);
+}

package/types/http.d.ts

@@ -0,0 +1,64 @@
+export declare type UpstashRequest = {
+    /**
+     * The path to the resource.
+     */
+    path: string[];
+    /**
+     * A BodyInit object or null to set request's body.
+     */
+    body?: BodyInit | null;
+    /**
+     * A Headers object, an object literal, or an array of two-item arrays to set
+     * request's headers.
+     */
+    headers?: HeadersInit;
+    /**
+     * A boolean to set request's keepalive.
+     */
+    keepalive?: boolean;
+    /**
+     * A string to set request's method.
+     */
+    method?: "GET" | "POST" | "PUT" | "DELETE";
+};
+export declare type UpstashResponse<TResult> = TResult & {
+    error?: string;
+};
+export interface Requester {
+    request: <TResult = unknown>(req: UpstashRequest) => Promise<UpstashResponse<TResult>>;
+}
+export declare type RetryConfig = false | {
+    /**
+     * The number of retries to attempt before giving up.
+     *
+     * @default 5
+     */
+    retries?: number;
+    /**
+     * A backoff function receives the current retry cound and returns a number in milliseconds to wait before retrying.
+     *
+     * @default
+     * ```ts
+     * Math.exp(retryCount) * 50
+     * ```
+     */
+    backoff?: (retryCount: number) => number;
+};
+export declare type HttpClientConfig = {
+    baseUrl: string;
+    authorization: string;
+    retry?: RetryConfig;
+};
+export declare class HttpClient implements Requester {
+    readonly baseUrl: string;
+    readonly authorization: string;
+    readonly options?: {
+        backend?: string;
+    };
+    readonly retry: {
+        attempts: number;
+        backoff: (retryCount: number) => number;
+    };
+    constructor(config: HttpClientConfig);
+    request<TResult>(req: UpstashRequest): Promise<UpstashResponse<TResult>>;
+}

package/types/platforms/nodejs.d.ts

@@ -0,0 +1 @@
+export { Client } from "../client.js";

package/types/topic.d.ts

@@ -0,0 +1,64 @@
+import { Requester } from "./http.js";
+export declare type CreateTopicRequest = {
+    /**
+     * The name of the topic.
+     * Must be unique and only contain alphanumeric, hyphen, underscore and periods.
+     */
+    name: string;
+};
+export declare type GetTopicRequest = {
+    name: string;
+    id?: never;
+} | {
+    id: string;
+    name?: never;
+};
+export declare type UpdateTopicRequest = {
+    id: string;
+    name?: string;
+};
+export declare type DeleteTopicRequest = {
+    name: string;
+    id?: never;
+} | {
+    id: string;
+    name?: never;
+};
+export declare type Topic = {
+    /**
+     * ID for this topic
+     */
+    id: string;
+    /**
+     * The name of this topic.
+     */
+    name: string;
+    /**
+     * A list of all subscribed endpoints
+     */
+    endpointIDs: string[];
+};
+export declare class Topics {
+    private readonly http;
+    constructor(http: Requester);
+    /**
+     * Create a new topic with the given name.
+     */
+    create(req: CreateTopicRequest): Promise<Topic>;
+    /**
+     * Get a list of all topics.
+     */
+    list(): Promise<Topic[]>;
+    /**
+     * Get a single topic by name or ID.
+     */
+    get(req: GetTopicRequest): Promise<Topic>;
+    /**
+     * Update a topic
+     */
+    update(req: UpdateTopicRequest): Promise<Topic>;
+    /**
+     * Delete a topic by name or ID.
+     */
+    delete(req: DeleteTopicRequest): Promise<void>;
+}