@pipedream/qstash 0.0.1 → 0.0.2

package/actions/create-endpoint/create-endpoint.mjs

@@ -0,0 +1,45 @@
+import qstash from "../../qstash.app.mjs";
+
+export default {
+  name: "Create Endpoint",
+  version: "0.0.1",
+  key: "qstash-create-endpoint",
+  description: "Create a new HTTP endpoint on a QStash topic.",
+  props: {
+    qstash,
+    topicId: {
+      type: "string",
+      label: "QStash Topic",
+      description: "The QStash topic to subscribe to.",
+      async options() {
+        const topics = await this.qstash.listTopics({
+          $: this,
+        });
+
+        return topics.map((topic) => ({
+          label: topic.name,
+          value: topic.topicId,
+        }));
+      },
+    },
+    endpointUrl: {
+      propDefinition: [
+        qstash,
+        "endpointUrl",
+      ],
+    },
+  },
+  type: "action",
+  methods: {},
+  async run({ $ }) {
+    const {
+      topicId, topicName, endpointUrl,
+    } = this;
+    return this.qstash.createEndpoint({
+      $,
+      topicId,
+      topicName,
+      endpointUrl,
+    });
+  },
+};

package/actions/create-topic/create-topic.mjs

@@ -0,0 +1,24 @@
+import qstash from "../../qstash.app.mjs";
+
+export default {
+  name: "Create Topic",
+  version: "0.0.1",
+  key: "qstash-create-topic",
+  description: "Create a new QStash topic that emits to multiple endpoints.",
+  props: {
+    qstash,
+    topicName: {
+      propDefinition: [
+        qstash,
+        "topicName",
+      ],
+    },
+  },
+  type: "action",
+  async run({ $ }) {
+    return this.qstash.createTopic({
+      $,
+      topicName: this.topicName,
+    });
+  },
+};

package/actions/list-endpoints/list-endpoints.mjs

@@ -0,0 +1,17 @@
+import qstash from "../../qstash.app.mjs";
+
+export default {
+  name: "List Endpoints",
+  version: "0.0.1",
+  key: "qstash-list-endpoints",
+  description: "Lists all your existing QStash endpoints.",
+  props: {
+    qstash,
+  },
+  type: "action",
+  async run({ $ }) {
+    return this.qstash.listEndpoints({
+      $,
+    });
+  },
+};

package/actions/list-topics/list-topics.mjs

@@ -0,0 +1,17 @@
+import qstash from "../../qstash.app.mjs";
+
+export default {
+  name: "List Topics",
+  version: "0.0.1",
+  key: "qstash-list-topics",
+  description: "List all your existing QStash topics.",
+  props: {
+    qstash,
+  },
+  type: "action",
+  async run({ $ }) {
+    return await this.qstash.listTopics({
+      $,
+    });
+  },
+};

package/actions/publish-endpoint-message/publish-endpoint-message.mjs

@@ -0,0 +1,70 @@
+import qstash from "../../qstash.app.mjs";
+
+export default {
+  name: "Publish Endpoint Message",
+  version: "0.0.1",
+  key: "qstash-publish-endpoint-message",
+  description: "Publish a message a callback endpoint",
+  type: "action",
+  props: {
+    qstash,
+    endpoint: {
+      propDefinition: [
+        qstash,
+        "endpoint",
+      ],
+    },
+    body: {
+      propDefinition: [
+        qstash,
+        "body",
+      ],
+    },
+    retries: {
+      propDefinition: [
+        qstash,
+        "retries",
+      ],
+    },
+    deduplicationId: {
+      propDefinition: [
+        qstash,
+        "deduplicationId",
+      ],
+    },
+    contentBasedDeduplicationEnabled: {
+      propDefinition: [
+        qstash,
+        "contentBasedDeduplicationEnabled",
+      ],
+    },
+    delay: {
+      propDefinition: [
+        qstash,
+        "delay",
+      ],
+    },
+    cron: {
+      propDefinition: [
+        qstash,
+        "cron",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const {
+      body, endpoint, deduplicationId, retries, cron, delay, contentBasedDeduplicationEnabled,
+    } = this;
+
+    return this.qstash.publishEndpointMessage({
+      $,
+      body,
+      endpoint,
+      deduplicationId,
+      contentBasedDeduplicationEnabled,
+      retries,
+      cron,
+      delay,
+    });
+  },
+};

package/actions/publish-topic-message/publish-topic-message.mjs

@@ -0,0 +1,76 @@
+import qstash from "../../qstash.app.mjs";
+
+export default {
+  name: "Publish Topic Message",
+  version: "0.0.1",
+  key: "qstash-publish-topic-message",
+  description: "Publish a message to a topic",
+  type: "action",
+  props: {
+    qstash,
+    topic: {
+      type: "string",
+      label: "QStash Topic",
+      description: "The QStash topic to publish a message to.",
+      async options() {
+        const topics = await this.qstash.listTopics({
+          $: this,
+        });
+
+        return topics.map((topic) => topic.name);
+      },
+    },
+    body: {
+      propDefinition: [
+        qstash,
+        "body",
+      ],
+    },
+    retries: {
+      propDefinition: [
+        qstash,
+        "retries",
+      ],
+    },
+    deduplicationId: {
+      propDefinition: [
+        qstash,
+        "deduplicationId",
+      ],
+    },
+    contentBasedDeduplicationEnabled: {
+      propDefinition: [
+        qstash,
+        "contentBasedDeduplicationEnabled",
+      ],
+    },
+    delay: {
+      propDefinition: [
+        qstash,
+        "delay",
+      ],
+    },
+    cron: {
+      propDefinition: [
+        qstash,
+        "cron",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const {
+      body, topic, delay, retries, deduplicationId, cron, contentBasedDeduplicationEnabled,
+    } = this;
+
+    return this.qstash.publishTopicMessage({
+      $,
+      body,
+      topic,
+      delay,
+      retries,
+      contentBasedDeduplicationEnabled,
+      deduplicationId,
+      cron,
+    });
+  },
+};

package/actions/verify-webhook/verify-webhook.mjs

@@ -0,0 +1,38 @@
+import qstash from "../../qstash.app.mjs";
+import { methods } from "../../common.mjs";
+
+export default {
+  name: "Verify Webhook",
+  version: "0.0.1",
+  key: "qstash-verify-webhook",
+  description: "Verify an incoming QStash webhook to an endpoint. Only to be used with the **Publish Endpoint** action.",
+  props: {
+    qstash,
+    event: {
+      type: "object",
+      label: "HTTP Request",
+      description: "The incoming QStash HTTP request to be verified. Use `{{ steps.trigger.event }}` as a custom expression and make sure the HTTP triggers **Event Body** option is set to **Raw Body**.",
+    },
+  },
+  type: "action",
+  methods: {
+    ...methods,
+  },
+  async run({ $ }) {
+    const signature = this.event.headers[this.event.headers.indexOf("upstash-signature") + 1];
+    const keys = await this.qstash.getKeys({
+      $,
+    });
+
+    const currentSigningKey = keys.current;
+    const nextSigningKey = keys.next;
+    const url = this.event.url.slice(0, -1);
+
+    try {
+      return await this.verify(signature, currentSigningKey, this.event.body, url);
+    } catch (e) {
+      console.log(e);
+      return await this.verify(signature, nextSigningKey, this.event.body, url);
+    }
+  },
+};

package/common.mjs

@@ -0,0 +1,61 @@
+import {
+  createHash, createHmac,
+} from "crypto";
+
+export const methods = {
+  async verify(
+    jwt,
+    signingKey,
+    body,
+    url,
+  ) {
+    const split = jwt.split(".");
+    if (split.length != 3) {
+      throw new Error("Invalid JWT");
+    }
+    const [
+      header,
+      payload,
+      signature,
+    ] = split;
+
+    if (
+      signature !=
+          createHmac("sha256", signingKey)
+            .update(`${header}.${payload}`)
+            .digest("base64url")
+    ) {
+      throw new Error("Invalid JWT signature");
+    }
+
+    // Now the jwt is verified and we can start looking at the claims in the payload
+    const p = JSON.parse(Buffer.from(payload, "base64url").toString());
+
+    if (p.iss !== "Upstash") {
+      throw new Error(`invalid issuer: ${p.iss}, expected "Upstash"`);
+    }
+    if (p.sub !== url) {
+      throw new Error(`invalid subject: ${p.sub}, expected "${url}"`);
+    }
+
+    const now = Math.floor(Date.now() / 1000);
+    if (now > p.exp) {
+      throw new Error("token has expired");
+    }
+    if (now < p.nbf) {
+      throw new Error("token is not yet valid");
+    }
+
+    if (body != null) {
+      if (
+        p.body.replace(/=+$/, "") !=
+            createHash("sha256").update(body)
+              .digest("base64url")
+      ) {
+        throw new Error("body hash does not match");
+      }
+    }
+
+    return true;
+  },
+};

package/package.json

@@ -1,15 +1,12 @@
 {
   "name": "@pipedream/qstash",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Pipedream qstash Components",
-  "main": "dist/app/qstash.app.mjs",
+  "main": "qstash.app.mjs",
   "keywords": [
     "pipedream",
     "qstash"
   ],
-  "files": [
-    "dist"
-  ],
   "homepage": "https://pipedream.com/apps/qstash",
   "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
   "license": "MIT",

package/qstash.app.mjs

@@ -0,0 +1,174 @@
+import { axios } from "@pipedream/platform";
+
+export default {
+  type: "app",
+  app: "qstash",
+  propDefinitions: {
+    topic: {
+      type: "string",
+      label: "Topic",
+      description: "Topics allow you to publish a single message to more than one API endpoints.",
+    },
+    topicId: {
+      type: "string",
+      label: "Topic",
+      description: "The ID of th QStash topic.",
+    },
+    endpoint: {
+      type: "string",
+      label: "Callback Endpoint",
+      description: "The endpoint that will be receiving these events",
+    },
+    body: {
+      type: "object",
+      label: "Body",
+      description: "The body is forwarded to your endpoints in the HTTP request",
+    },
+    retries: {
+      type: "integer",
+      label: "Retries",
+      description: "How often should this messasge be retried in case the destination API is not available.",
+      default: 3,
+      optional: true,
+    },
+    deduplicationId: {
+      type: "string",
+      label: "Deduplication ID",
+      description: "Provide an ID that will be used to detect duplicate messages. If a duplicate message is detected, the request will be accepted but not enqueued. [Learn more.](https://docs.upstash.com/qstash/howto/publishing#optional-parameters-and-configuration)",
+      optional: true,
+    },
+    contentBasedDeduplicationEnabled: {
+      type: "boolean",
+      label: "Content Based Deduplication Enabled",
+      description: "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.",
+      optional: true,
+    },
+    delay: {
+      type: "string",
+      label: "Delay",
+      description: "Format for this header is a number followed by duration abbreviation, like `10s`. Available durations are `s` (seconds), `m` (minutes), `h` (hours), `d` (days).",
+      optional: true,
+    },
+    cron: {
+      type: "string",
+      label: "Cron",
+      description: "You can use a tool like [Crontab.guru](https://crontab.guru) to generate cron expressions.",
+      optional: true,
+    },
+    topicName: {
+      type: "string",
+      label: "Topic Name",
+      description: "The name of the topic.",
+    },
+    endpointUrl: {
+      type: "string",
+      label: "Endpoint URL",
+      description: "User controlled service url where we will send webhooks to.",
+    },
+  },
+  methods: {
+    baseUrl() {
+      return "https://qstash.upstash.io/v1";
+    },
+    getHeaders({
+      deduplicationId, delay, cron, retries, contentBasedDeduplicationEnabled,
+    }) {
+      let headers = {
+        "Authorization": `Bearer ${this.$auth.qstash_token}`,
+        "Content-Type": "application/json",
+      };
+      if (contentBasedDeduplicationEnabled) {
+        headers["Upstash-Content-Based-Deduplication"] = contentBasedDeduplicationEnabled;
+      }
+      if (deduplicationId) {
+        headers["Upstash-Deduplication-Id"] = deduplicationId;
+      }
+      if (delay) {
+        headers["Upstash-Delay"] = delay;
+      }
+      if (cron) {
+        headers["Upstash-Cron"] = cron;
+      }
+      if (retries) {
+        headers["Upstash-Retries"] = retries;
+      }
+      return headers;
+    },
+    async publishEndpointMessage({
+      $, body, endpoint, ...headers
+    }) {
+      return axios($, {
+        url: `${this.baseUrl()}/publish/${endpoint}`,
+        method: "POST",
+        data: body,
+        headers: this.getHeaders(headers),
+      });
+    },
+    async publishTopicMessage({
+      $, body, topic, ...headers
+    }) {
+      return axios($, {
+        url: `${this.baseUrl()}/publish/${topic}`,
+        method: "POST",
+        data: body,
+        headers: this.getHeaders(headers),
+      });
+    },
+    async listEndpoints({ $ }) {
+      return axios($ || this, {
+        url: `${this.baseUrl()}/endpoints`,
+        method: "GET",
+        headers: this.getHeaders({}),
+      });
+    },
+    async listTopics({ $ = this }) {
+      return axios($, {
+        url: `${this.baseUrl()}/topics`,
+        method: "GET",
+        headers: this.getHeaders({}),
+      });
+    },
+    async createTopic({
+      $, topicName,
+    }) {
+      return axios($, {
+        url: `${this.baseUrl()}/topics`,
+        method: "POST",
+        data: {
+          name: topicName,
+        },
+        headers: this.getHeaders({}),
+      });
+    },
+    async createEndpoint({
+      $, topicName, topicId, endpointUrl,
+    }) {
+      return axios($, {
+        url: `${this.baseUrl()}/endpoints`,
+        method: "POST",
+        data: {
+          topicName,
+          topicId,
+          url: endpointUrl,
+        },
+        headers: this.getHeaders({}),
+      });
+    },
+    async deleteEndpoint({
+      $ = this, endpointId,
+    }) {
+      return axios($, {
+        url: `${this.baseUrl()}/endpoints/${endpointId}`,
+        method: "DELETE",
+        headers: this.getHeaders({}),
+      });
+    },
+    async getKeys({ $ = this }) {
+      return axios($, {
+        url: `${this.baseUrl()}/keys`,
+        method: "GET",
+        headers: this.getHeaders({}),
+      });
+    },
+  },
+};

package/sources/new-topic-webhook/new-topic-webhook.mjs

@@ -0,0 +1,101 @@
+import qstash from "../../qstash.app.mjs";
+import { methods } from "../../common.mjs";
+
+export default {
+  name: "New Topic Webhook",
+  version: "0.0.1",
+  key: "qstash-new-topic-webhook",
+  description: "Emit new events on each new QStash topic message",
+  props: {
+    qstash,
+    topicId: {
+      type: "string",
+      label: "QStash Topic",
+      description: "The QStash topic to subscribe to.",
+      async options() {
+        const topics = await this.qstash.listTopics({
+          $: this,
+        });
+
+        return topics.map((topic) => ({
+          label: topic.name,
+          value: topic.topicId,
+        }));
+      },
+    },
+    http: {
+      type: "$.interface.http",
+      customResponse: true, // optional: defaults to false
+    },
+    db: "$.service.db",
+  },
+  type: "source",
+  methods: {
+    ...methods,
+  },
+  hooks: {
+    async deploy() {
+      console.log("deployment hook started");
+      console.log("selected topic ID", this.topicId);
+      console.log(`PD generated endpoint URL ${this.http.endpoint}`);
+      const endpoint = await this.qstash.createEndpoint({
+        $: this,
+        topicId: this.topicId,
+        endpointUrl: this.http.endpoint,
+      });
+      console.log("Created endpoint", endpoint);
+      this.db.set("endpointId", endpoint.endpointId);
+    },
+    async deactivate() {
+      console.log("deactivate hook started");
+      const endpointId = this.db.get("endpointId");
+      await this.qstash.deleteEndpoint({
+        $: this,
+        endpointId,
+      });
+      console.log(`Deleted QStash endpoint ${endpointId}`);
+    },
+    async activate() {
+      console.log("activate hook started");
+
+      const keys = await this.qstash.getKeys({
+        $: this,
+      });
+
+      const currentSigningKey = keys.current;
+      const nextSigningKey = keys.next;
+
+      this.db.set("currentSigningKey", currentSigningKey);
+      this.db.set("nextSigningKey", nextSigningKey);
+      console.log("Set QStash signing keys");
+    },
+  },
+  async run(event) {
+    const signature = event.headers["upstash-signature"];
+    const currentSigningKey = this.db.get("currentSigningKey");
+    const nextSigningKey = this.db.get("nextSigningKey");
+    const url = event.url.slice(0, -1);
+
+    try {
+      await this.verify(signature, currentSigningKey, event.rawBody, url);
+    } catch (e) {
+      console.log(e);
+      await this.verify(signature, nextSigningKey, event.rawBody, url);
+    }
+
+    await this.$emit(
+      {
+        event,
+      },
+      {
+        id: event.headers["upstash-signature"],
+        summary: "New webhook received from QStash",
+        ts: Date.now(),
+      },
+    );
+
+    await this.http.respond({
+      status: 200,
+    });
+  },
+};