@upstash/qstash 0.0.9 → 0.0.12

package/script/deps/deno.land/std@0.147.0/_wasm_crypto/mod.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.digestAlgorithms = exports.instantiateWasm = exports.DigestContext = void 0;
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+var deno_std_wasm_crypto_generated_js_1 = require("./lib/deno_std_wasm_crypto.generated.js");
+Object.defineProperty(exports, "DigestContext", { enumerable: true, get: function () { return deno_std_wasm_crypto_generated_js_1.DigestContext; } });
+Object.defineProperty(exports, "instantiateWasm", { enumerable: true, get: function () { return deno_std_wasm_crypto_generated_js_1.instantiate; } });
+/**
+ * All cryptographic hash/digest algorithms supported by std/_wasm_crypto.
+ *
+ * For algorithms that are supported by WebCrypto, the name here must match the
+ * one used by WebCrypto. Otherwise we should prefer the formatting used in the
+ * official specification. All names are uppercase to facilitate case-insensitive
+ * comparisons required by the WebCrypto spec.
+ */
+exports.digestAlgorithms = [
+    "BLAKE2B-256",
+    "BLAKE2B-384",
+    "BLAKE2B",
+    "BLAKE2S",
+    "BLAKE3",
+    "KECCAK-224",
+    "KECCAK-256",
+    "KECCAK-384",
+    "KECCAK-512",
+    "SHA-384",
+    "SHA3-224",
+    "SHA3-256",
+    "SHA3-384",
+    "SHA3-512",
+    "SHAKE128",
+    "SHAKE256",
+    "TIGER",
+    // insecure (length-extendable):
+    "RIPEMD-160",
+    "SHA-224",
+    "SHA-256",
+    "SHA-512",
+    // insecure (collidable and length-extendable):
+    "MD4",
+    "MD5",
+    "SHA-1",
+];

package/script/deps/deno.land/std@0.147.0/crypto/_fnv/fnv32.js

@@ -0,0 +1,29 @@
+"use strict";
+// Ported from Go:
+// https://github.com/golang/go/tree/go1.13.10/src/hash/fnv/fnv.go
+// Copyright 2011 The Go Authors. All rights reserved. BSD license.
+// https://github.com/golang/go/blob/master/LICENSE
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnv32a = exports.fnv32 = void 0;
+const util_js_1 = require("./util.js");
+const prime32 = 16777619;
+const fnv32 = (data) => {
+    let hash = 2166136261;
+    data.forEach((c) => {
+        hash = (0, util_js_1.mul32)(hash, prime32);
+        hash ^= c;
+    });
+    return Uint32Array.from([(0, util_js_1.swap32)(hash)]).buffer;
+};
+exports.fnv32 = fnv32;
+const fnv32a = (data) => {
+    let hash = 2166136261;
+    data.forEach((c) => {
+        hash ^= c;
+        hash = (0, util_js_1.mul32)(hash, prime32);
+    });
+    return Uint32Array.from([(0, util_js_1.swap32)(hash)]).buffer;
+};
+exports.fnv32a = fnv32a;

package/script/deps/deno.land/std@0.147.0/crypto/_fnv/fnv64.js

@@ -0,0 +1,32 @@
+"use strict";
+// Ported from Go:
+// https://github.com/golang/go/tree/go1.13.10/src/hash/fnv/fnv.go
+// Copyright 2011 The Go Authors. All rights reserved. BSD license.
+// https://github.com/golang/go/blob/master/LICENSE
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnv64a = exports.fnv64 = void 0;
+const util_js_1 = require("./util.js");
+const prime64Lo = 435;
+const prime64Hi = 256;
+const fnv64 = (data) => {
+    let hashLo = 2216829733;
+    let hashHi = 3421674724;
+    data.forEach((c) => {
+        [hashHi, hashLo] = (0, util_js_1.mul64)([hashHi, hashLo], [prime64Hi, prime64Lo]);
+        hashLo ^= c;
+    });
+    return new Uint32Array([(0, util_js_1.swap32)(hashHi >>> 0), (0, util_js_1.swap32)(hashLo >>> 0)]).buffer;
+};
+exports.fnv64 = fnv64;
+const fnv64a = (data) => {
+    let hashLo = 2216829733;
+    let hashHi = 3421674724;
+    data.forEach((c) => {
+        hashLo ^= c;
+        [hashHi, hashLo] = (0, util_js_1.mul64)([hashHi, hashLo], [prime64Hi, prime64Lo]);
+    });
+    return new Uint32Array([(0, util_js_1.swap32)(hashHi >>> 0), (0, util_js_1.swap32)(hashLo >>> 0)]).buffer;
+};
+exports.fnv64a = fnv64a;

package/script/deps/deno.land/std@0.147.0/crypto/_fnv/index.js

@@ -0,0 +1,25 @@
+"use strict";
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnv = void 0;
+const fnv32_js_1 = require("./fnv32.js");
+const fnv64_js_1 = require("./fnv64.js");
+const fnv = (name, buf) => {
+    if (!buf) {
+        throw new TypeError("no data provided for hashing");
+    }
+    switch (name) {
+        case "FNV32":
+            return (0, fnv32_js_1.fnv32)(buf);
+        case "FNV64":
+            return (0, fnv64_js_1.fnv64)(buf);
+        case "FNV32A":
+            return (0, fnv32_js_1.fnv32a)(buf);
+        case "FNV64A":
+            return (0, fnv64_js_1.fnv64a)(buf);
+        default:
+            throw new TypeError(`unsupported fnv digest: ${name}`);
+    }
+};
+exports.fnv = fnv;

package/script/deps/deno.land/std@0.147.0/crypto/_fnv/util.js

@@ -0,0 +1,54 @@
+"use strict";
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mul64 = exports.mul32 = exports.swap32 = void 0;
+function swap32(val) {
+    return (((val & 0xff) << 24) |
+        ((val & 0xff00) << 8) |
+        ((val >> 8) & 0xff00) |
+        ((val >> 24) & 0xff));
+}
+exports.swap32 = swap32;
+function n16(n) {
+    return n & 0xffff;
+}
+function n32(n) {
+    return n >>> 0;
+}
+function add32WithCarry(a, b) {
+    const added = n32(a) + n32(b);
+    return [n32(added), added > 0xffffffff ? 1 : 0];
+}
+function mul32WithCarry(a, b) {
+    const al = n16(a);
+    const ah = n16(a >>> 16);
+    const bl = n16(b);
+    const bh = n16(b >>> 16);
+    const [t, tc] = add32WithCarry(al * bh, ah * bl);
+    const [n, nc] = add32WithCarry(al * bl, n32(t << 16));
+    const carry = nc + (tc << 16) + n16(t >>> 16) + ah * bh;
+    return [n, carry];
+}
+/**
+ * mul32 performs 32-bit multiplication, a * b
+ * @param a
+ * @param b
+ */
+function mul32(a, b) {
+    // https://stackoverflow.com/a/28151933
+    const al = n16(a);
+    const ah = a - al;
+    return n32(n32(ah * b) + al * b);
+}
+exports.mul32 = mul32;
+/**
+ * mul64 performs 64-bit multiplication with two 32-bit words
+ * @param [ah, al]
+ * @param [bh, bl]
+ */
+function mul64([ah, al], [bh, bl]) {
+    const [n, c] = mul32WithCarry(al, bl);
+    return [n32(mul32(al, bh) + mul32(ah, bl) + c), n];
+}
+exports.mul64 = mul64;

package/script/deps/deno.land/std@0.147.0/crypto/mod.js

@@ -0,0 +1,175 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crypto = void 0;
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+const dntShim = __importStar(require("../../../../_dnt.shims.js"));
+const mod_js_1 = require("../_wasm_crypto/mod.js");
+const index_js_1 = require("./_fnv/index.js");
+/**
+ * A copy of the global WebCrypto interface, with methods bound so they're
+ * safe to re-export.
+ * @module
+ */
+const webCrypto = ((crypto) => ({
+    getRandomValues: crypto.getRandomValues?.bind(crypto),
+    randomUUID: crypto.randomUUID?.bind(crypto),
+    subtle: {
+        decrypt: crypto.subtle?.decrypt?.bind(crypto.subtle),
+        deriveBits: crypto.subtle?.deriveBits?.bind(crypto.subtle),
+        deriveKey: crypto.subtle?.deriveKey?.bind(crypto.subtle),
+        digest: crypto.subtle?.digest?.bind(crypto.subtle),
+        encrypt: crypto.subtle?.encrypt?.bind(crypto.subtle),
+        exportKey: crypto.subtle?.exportKey?.bind(crypto.subtle),
+        generateKey: crypto.subtle?.generateKey?.bind(crypto.subtle),
+        importKey: crypto.subtle?.importKey?.bind(crypto.subtle),
+        sign: crypto.subtle?.sign?.bind(crypto.subtle),
+        unwrapKey: crypto.subtle?.unwrapKey?.bind(crypto.subtle),
+        verify: crypto.subtle?.verify?.bind(crypto.subtle),
+        wrapKey: crypto.subtle?.wrapKey?.bind(crypto.subtle),
+    },
+}))(dntShim.dntGlobalThis.crypto);
+const bufferSourceBytes = (data) => {
+    let bytes;
+    if (data instanceof Uint8Array) {
+        bytes = data;
+    }
+    else if (ArrayBuffer.isView(data)) {
+        bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    else if (data instanceof ArrayBuffer) {
+        bytes = new Uint8Array(data);
+    }
+    return bytes;
+};
+/**
+ * An wrapper for WebCrypto adding support for additional non-standard
+ * algorithms, but delegating to the runtime WebCrypto implementation whenever
+ * possible.
+ */
+const stdCrypto = ((x) => x)({
+    ...webCrypto,
+    subtle: {
+        ...webCrypto.subtle,
+        /**
+         * Returns a new `Promise` object that will digest `data` using the specified
+         * `AlgorithmIdentifier`.
+         */
+        async digest(algorithm, data) {
+            const { name, length } = normalizeAlgorithm(algorithm);
+            const bytes = bufferSourceBytes(data);
+            if (FNVAlgorithms.includes(name)) {
+                return (0, index_js_1.fnv)(name, bytes);
+            }
+            // We delegate to WebCrypto whenever possible,
+            if (
+            // if the algorithm is supported by the WebCrypto standard,
+            webCryptoDigestAlgorithms.includes(name) &&
+                // and the data is a single buffer,
+                bytes) {
+                return webCrypto.subtle.digest(algorithm, bytes);
+            }
+            else if (mod_js_1.digestAlgorithms.includes(name)) {
+                if (bytes) {
+                    // Otherwise, we use our bundled Wasm implementation via digestSync
+                    // if it supports the algorithm.
+                    return stdCrypto.subtle.digestSync(algorithm, bytes);
+                }
+                else if (data[Symbol.iterator]) {
+                    return stdCrypto.subtle.digestSync(algorithm, data);
+                }
+                else if (data[Symbol.asyncIterator]) {
+                    const wasmCrypto = (0, mod_js_1.instantiateWasm)();
+                    const context = new wasmCrypto.DigestContext(name);
+                    for await (const chunk of data) {
+                        const chunkBytes = bufferSourceBytes(chunk);
+                        if (!chunkBytes) {
+                            throw new TypeError("data contained chunk of the wrong type");
+                        }
+                        context.update(chunkBytes);
+                    }
+                    return context.digestAndDrop(length).buffer;
+                }
+                else {
+                    throw new TypeError("data must be a BufferSource or [Async]Iterable<BufferSource>");
+                }
+            }
+            else if (webCrypto.subtle?.digest) {
+                // (TypeScript type definitions prohibit this case.) If they're trying
+                // to call an algorithm we don't recognize, pass it along to WebCrypto
+                // in case it's a non-standard algorithm supported by the the runtime
+                // they're using.
+                return webCrypto.subtle.digest(algorithm, data);
+            }
+            else {
+                throw new TypeError(`unsupported digest algorithm: ${algorithm}`);
+            }
+        },
+        /**
+         * Returns a ArrayBuffer with the result of digesting `data` using the
+         * specified `AlgorithmIdentifier`.
+         */
+        digestSync(algorithm, data) {
+            algorithm = normalizeAlgorithm(algorithm);
+            const bytes = bufferSourceBytes(data);
+            if (FNVAlgorithms.includes(algorithm.name)) {
+                return (0, index_js_1.fnv)(algorithm.name, bytes);
+            }
+            const wasmCrypto = (0, mod_js_1.instantiateWasm)();
+            if (bytes) {
+                return wasmCrypto.digest(algorithm.name, bytes, algorithm.length)
+                    .buffer;
+            }
+            else if (data[Symbol.iterator]) {
+                const context = new wasmCrypto.DigestContext(algorithm.name);
+                for (const chunk of data) {
+                    const chunkBytes = bufferSourceBytes(chunk);
+                    if (!chunkBytes) {
+                        throw new TypeError("data contained chunk of the wrong type");
+                    }
+                    context.update(chunkBytes);
+                }
+                return context.digestAndDrop(algorithm.length).buffer;
+            }
+            else {
+                throw new TypeError("data must be a BufferSource or Iterable<BufferSource>");
+            }
+        },
+    },
+});
+exports.crypto = stdCrypto;
+const FNVAlgorithms = ["FNV32", "FNV32A", "FNV64", "FNV64A"];
+/** Digest algorithms supported by WebCrypto. */
+const webCryptoDigestAlgorithms = [
+    "SHA-384",
+    "SHA-256",
+    "SHA-512",
+    // insecure (length-extendable and collidable):
+    "SHA-1",
+];
+const normalizeAlgorithm = (algorithm) => ((typeof algorithm === "string") ? { name: algorithm.toUpperCase() } : {
+    ...algorithm,
+    name: algorithm.name.toUpperCase(),
+});

package/script/deps/deno.land/{std@0.144.0 → std@0.147.0}/encoding/base64url.js

@@ -25,7 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decode = exports.encode = exports.addPaddingToBase64url = void 0;
+exports.decode = exports.encode = void 0;
 const base64 = __importStar(require("./base64.js"));
 /*
  * Some variants allow or require omitting the padding '=' signs:
@@ -42,7 +42,6 @@ function addPaddingToBase64url(base64url) {
     }
     return base64url;
 }
-exports.addPaddingToBase64url = addPaddingToBase64url;
 function convertBase64urlToBase64(b64url) {
     if (!/^[-_A-Z0-9]*?={0,2}$/i.test(b64url)) {
         // Contains characters not part of base64url spec.

package/script/deps.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64Url = void 0;
+exports.base64Url = __importStar(require("./deps/deno.land/std@0.147.0/encoding/base64url.js"));

package/script/entrypoints/cloudflare.js

@@ -0,0 +1,42 @@
+"use strict";
+// dnt-shim-ignore
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Consumer = void 0;
+const c = __importStar(require("../pkg/consumer.js"));
+__exportStar(require("../pkg/client/client.js"), exports);
+class Consumer extends c.Consumer {
+    constructor(config) {
+        super({
+            ...config,
+            // dnt-shim-ignore
+            subtleCrypto: crypto.subtle
+        });
+    }
+}
+exports.Consumer = Consumer;

package/script/entrypoints/nextjs.js

@@ -1,15 +1,42 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifySignature = void 0;
+const dntShim = __importStar(require("../_dnt.shims.js"));
+// @ts-ignore Deno can't compile
 const micro_1 = require("micro");
-const consumer_js_1 = require("../consumer.js");
+const consumer_js_1 = require("../pkg/consumer.js");
 function verifySignature(handler, config) {
     const currentSigningKey = config?.currentSigningKey ??
+        // @ts-ignore Deno can't compile
         process.env.get["QSTASH_CURRENT_SIGNING_KEY"];
     if (!currentSigningKey) {
         throw new Error("currentSigningKey is required, either in the config or as env variable QSTASH_CURRENT_SIGNING_KEY");
     }
     const nextSigningKey = config?.nextSigningKey ??
+        // @ts-ignore Deno can't compile
         process.env.get["QSTASH_NEXT_SIGNING_KEY"];
     if (!nextSigningKey) {
         throw new Error("nextSigningKey is required, either in the config or as env variable QSTASH_NEXT_SIGNING_KEY");
@@ -17,6 +44,7 @@ function verifySignature(handler, config) {
     const consumer = new consumer_js_1.Consumer({
         currentSigningKey,
         nextSigningKey,
+        subtleCrypto: dntShim.crypto.subtle
     });
     return async (req, res) => {
         const signature = req.headers["upstash-signature"];
@@ -27,8 +55,8 @@ function verifySignature(handler, config) {
             throw new Error("`Upstash-Signature` header is not a string");
         }
         const body = (await (0, micro_1.buffer)(req)).toString();
-        const url = new URL(req.url, `https://${req.headers.host}`).href;
-        console.log({ reqUrl: req.url, url });
+        console.log(req.headers);
+        const url = config?.url ?? new URL(req.url, `https://${process.env.VERCEL_URL}`).href;
         const isValid = await consumer.verify({ signature, body, url });
         if (!isValid) {
             res.status(400);

package/script/pkg/client/client.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const http_js_1 = require("./http.js");
+const topics_js_1 = require("./topics.js");
+const messages_js_1 = require("./messages.js");
+const schedules_js_1 = require("./schedules.js");
+const endpoints_js_1 = require("./endpoints.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.token,
+        });
+    }
+    /**
+     * Access the topic API.
+     *
+     * Create, read, update or delete topics.
+     */
+    get topics() {
+        return new topics_js_1.Topics(this.http);
+    }
+    /**
+     * Access the endpoint API.
+     *
+     * Create, read, update or delete endpoints.
+     */
+    get endpoints() {
+        return new endpoints_js_1.Endpoints(this.http);
+    }
+    /**
+     * Access the message API.
+     *
+     * Read or cancel messages.
+     */
+    get messages() {
+        return new messages_js_1.Messages(this.http);
+    }
+    /**
+     * Access the schedule API.
+     *
+     * Read or delete schedules.
+     */
+    get schedules() {
+        return new schedules_js_1.Schedules(this.http);
+    }
+    async publish(req) {
+        const destination = req.url ?? req.topic;
+        if (!destination) {
+            throw new Error("Either url or topic must be set");
+        }
+        const headers = new Headers(req.headers);
+        if (req.delay) {
+            headers.set("Upstash-Delay", req.delay.toFixed());
+        }
+        if (req.notBefore) {
+            headers.set("Upstash-Not-Before", req.notBefore.toFixed());
+        }
+        if (req.deduplicationId) {
+            headers.set("Upstash-Deduplication-Id", req.deduplicationId);
+        }
+        if (req.contentBasedDeduplication) {
+            headers.set("Upstash-Content-Based-Deduplication", "true");
+        }
+        if (req.retries) {
+            headers.set("Upstash-Retries", req.retries.toFixed());
+        }
+        if (req.cron) {
+            headers.set("Upstash-Cron", req.cron);
+        }
+        const res = await this.http.request({
+            path: ["v1", "publish", destination],
+            body: req.body,
+            headers,
+            method: "POST",
+        });
+        return res;
+    }
+    /**
+     * publishJSON is a utility wrapper around `publish` that automatically serializes the body
+     * and sets the `Content-Type` header to `application/json`.
+     */
+    async publishJSON(req) {
+        const headers = new Headers(req.headers);
+        headers.set("Content-Type", "application/json");
+        const res = await this.publish({
+            ...req,
+            headers,
+            body: JSON.stringify(req.body),
+        });
+        return res;
+    }
+    /**
+     * 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 logs(req) {
+        const query = {};
+        if (req?.cursor && req.cursor > 0) {
+            query["cursor"] = req.cursor;
+        }
+        const res = await this.http.request({
+            path: ["v1", "logs"],
+            method: "GET",
+            query,
+        });
+        return res;
+    }
+}
+exports.Client = Client;