@pipedream/trello 0.3.2 → 0.3.5

package/sources/card-due-date-reminder/card-due-date-reminder.mjs

@@ -0,0 +1,80 @@
+import common from "../common-polling.mjs";
+
+export default {
+  ...common,
+  key: "trello-card-due-date-reminder",
+  name: "Card Due Date Reminder",
+  description: "Emit new event at a specified time before a card is due.",
+  version: "0.0.5",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    ...common.props,
+    board: {
+      propDefinition: [
+        common.props.trello,
+        "board",
+      ],
+    },
+    timeBefore: {
+      type: "integer",
+      label: "Time Before",
+      description: "How far before the due time the event should trigger.",
+      default: 5,
+    },
+    timeBeforeUnit: {
+      type: "integer",
+      label: "Time Before (Unit)",
+      description: "Unit of time for Time Before.",
+      options: [
+        {
+          label: "Minutes",
+          value: 60000,
+        },
+        {
+          label: "Hours",
+          value: 3600000,
+        },
+        {
+          label: "Days",
+          value: 86400000,
+        },
+        {
+          label: "Weeks",
+          value: 604800000,
+        },
+      ],
+      default: 60000,
+    },
+  },
+  methods: {
+    ...common.methods,
+    generateMeta({
+      id, name: summary,
+    }, now) {
+      return {
+        id,
+        summary,
+        ts: now,
+      };
+    },
+    emitEvent(card, now) {
+      const meta = this.generateMeta(card, now);
+      this.$emit(card, meta);
+    },
+  },
+  async run(event) {
+    const boardId = this.board;
+    const now = event.timestamp * 1000;
+
+    const cards = await this.trello.getCards(boardId);
+    for (const card of cards) {
+      if (!card.due) continue;
+      const due = Date.parse(card.due);
+      const notifyAt = due - this.timeBefore * this.timeBeforeUnit;
+      if (notifyAt <= now) {
+        this.emitEvent(card, now);
+      }
+    }
+  },
+};

package/sources/card-moved/card-moved.mjs

@@ -0,0 +1,84 @@
+import common from "../common-webhook.mjs";
+
+export default {
+  ...common,
+  key: "trello-card-moved",
+  name: "Card Moved (Instant)",
+  description: "Emit new event each time a card is moved to a list.",
+  version: "0.0.8",
+  type: "source",
+  props: {
+    ...common.props,
+    board: {
+      propDefinition: [
+        common.props.trello,
+        "board",
+      ],
+    },
+    lists: {
+      propDefinition: [
+        common.props.trello,
+        "lists",
+        (c) => ({
+          board: c.board,
+        }),
+      ],
+    },
+  },
+  methods: {
+    ...common.methods,
+    async getSampleEvents() {
+      const cards = this.lists && this.lists.length > 0
+        ? await this.trello.getCardsInList(this.lists[0])
+        : await this.trello.getCards(this.board);
+      return {
+        sampleEvents: cards,
+        sortFilter: "dateLastActivity",
+      };
+    },
+    _getListAfter() {
+      return this.db.get("listAfter");
+    },
+    _setListAfter(listAfter) {
+      this.db.set("listAfter", listAfter);
+    },
+    isCorrectEventType(event) {
+      const eventTranslationKey = event.body?.action?.display?.translationKey;
+      return eventTranslationKey === "action_move_card_from_list_to_list";
+    },
+    async getResult(event) {
+      const cardId = event.body?.action?.data?.card?.id;
+      const listAfter = event.body?.action?.data?.listAfter?.name;
+      /** Record listAfter to use in generateMeta() */
+      this._setListAfter(listAfter);
+      return this.trello.getCard(cardId);
+    },
+    isRelevant({
+      result: card, event,
+    }) {
+      const listIdAfter = event.body?.action?.data?.listAfter?.id;
+      const listIdBefore = event.body?.action?.data?.listBefore?.id;
+
+      return (
+        (!this.board || this.board === card.idBoard) &&
+        (!this.lists ||
+          this.lists.length === 0 ||
+          this.lists.includes(listIdAfter) ||
+          this.lists.includes(listIdBefore))
+      );
+    },
+    generateMeta({
+      id, name,
+    }) {
+      const listAfter = this._getListAfter();
+      const summary = listAfter
+        ? `${name} - moved to ${listAfter}`
+        : name;
+      return {
+        id,
+        summary,
+        ts: Date.now(),
+      };
+    },
+  },
+};

package/sources/card-updates/card-updates.mjs

@@ -0,0 +1,60 @@
+import common from "../common-webhook.mjs";
+
+export default {
+  ...common,
+  key: "trello-card-updates",
+  name: "Card Updates (Instant)",
+  description: "Emit new event for each update to a Trello card.",
+  version: "0.0.8",
+  type: "source",
+  props: {
+    ...common.props,
+    board: {
+      propDefinition: [
+        common.props.trello,
+        "board",
+      ],
+    },
+    cards: {
+      propDefinition: [
+        common.props.trello,
+        "cards",
+        (c) => ({
+          board: c.board,
+        }),
+      ],
+    },
+  },
+  methods: {
+    ...common.methods,
+    async getSampleEvents() {
+      let cards = [];
+      if (this.cards && this.cards.length > 0) {
+        for (const cardId of this.cards) {
+          const card = await this.trello.getCard(cardId);
+          cards.push(card);
+        }
+      } else {
+        cards = await this.trello.getCards(this.board);
+      }
+      return {
+        sampleEvents: cards,
+        sortField: "dateLastActivity",
+      };
+    },
+    isCorrectEventType(event) {
+      const eventType = event.body?.action?.type;
+      return eventType === "updateCard";
+    },
+    async getResult(event) {
+      const cardId = event.body?.action?.data?.card?.id;
+      return this.trello.getCard(cardId);
+    },
+    isRelevant({ result: card }) {
+      return (
+        (!this.board || this.board === card.idBoard) &&
+        (!this.cards || this.cards.length === 0 || this.cards.includes(card.id))
+      );
+    },
+  },
+};

package/sources/common-polling.mjs

@@ -0,0 +1,16 @@
+import common from "./common.js";
+
+export default {
+  ...common,
+  props: {
+    ...common.props,
+    timer: {
+      label: "Polling interval",
+      description: "Pipedream will poll the Trello API on this schedule",
+      type: "$.interface.timer",
+      default: {
+        intervalSeconds: 60 * 15,
+      },
+    },
+  },
+};

package/sources/common-webhook.mjs

@@ -0,0 +1,90 @@
+import common from "./common.js";
+
+export default {
+  ...common,
+  props: {
+    ...common.props,
+    http: "$.interface.http",
+  },
+  hooks: {
+    async deploy() {
+      const {
+        sampleEvents, sortField,
+      } = await this.getSampleEvents();
+      sampleEvents.sort((a, b) => (Date.parse(a[sortField]) > Date.parse(b[sortField]))
+        ? 1
+        : -1);
+      for (const event of sampleEvents.slice(-25)) {
+        this.emitEvent(event);
+      }
+    },
+    async activate() {
+      const modelId = await this.getModelId();
+      const { id } = await this.trello.createHook({
+        id: modelId,
+        endpoint: this.http.endpoint,
+      });
+      this.db.set("hookId", id);
+    },
+    async deactivate() {
+      const hookId = this.db.get("hookId");
+      await this.trello.deleteHook({
+        hookId,
+      });
+    },
+  },
+  methods: {
+    ...common.methods,
+    /**
+     * Returns the ID of the current board selected. If no board is selected, returns
+     * the id of the authenticated user.
+     */
+    async getModelId() {
+      if (this.board) return this.board;
+      const member = await this.trello.getMember("me");
+      return member.id;
+    },
+    /**
+     * Verifies that the event received was sent from Trello.
+     * @param {object} event - The event returned from a webhook
+     */
+    verifyEvent(event) {
+      return (
+        this.trello.verifyTrelloWebhookRequest(event, this.http.endpoint) &&
+        event.body !== undefined
+      );
+    },
+    /**
+     * Default isCorrectEventType. Used in components to verify that the event received is
+     * of the type that the component is watching for.
+     */
+    isCorrectEventType() {
+      return true;
+    },
+    /**
+     * Default isRelevant. Used in components to verify that the event received matches the
+     * board, list and/or card specified in the component's props.
+     */
+    isRelevant() {
+      return true;
+    },
+    getSampleEvents() {
+      throw new Error("getSampleEvents not implemented");
+    },
+  },
+  async run(event) {
+    if (!this.verifyEvent(event)) {
+      console.log("The event failed the verification. Skipping...");
+      return;
+    }
+    if (!this.isCorrectEventType(event)) return;
+
+    const result = await this.getResult(event);
+    if (!(await this.isRelevant({
+      result,
+      event,
+    }))) return;
+
+    this.emitEvent(result);
+  },
+};

package/sources/common.js

@@ -0,0 +1,34 @@
+const trello = require("../trello.app.js");
+
+module.exports = {
+  props: {
+    trello,
+    db: "$.service.db",
+  },
+  methods: {
+    /**
+     * Default generateMeta. Components should overwrite this function if they require
+     * different meta to be emitted.
+     * @param {string} id - The id of the item being emitted.
+     * @param {string} name - The name of the item of the book.
+     */
+    generateMeta({
+      id, name: summary,
+    }) {
+      return {
+        id,
+        summary,
+        ts: Date.now(),
+      };
+    },
+    /**
+     * Default emitEvent. Components should overwrite this function if something more
+     * needs to be emitted in the event.
+     * @param {object} result - The result object to be emitted
+     */
+    emitEvent(result) {
+      const meta = this.generateMeta(result);
+      this.$emit(result, meta);
+    },
+  },
+};

package/sources/custom-webhook-events/custom-webhook-events.mjs

@@ -0,0 +1,110 @@
+import common from "../common-webhook.mjs";
+
+export default {
+  ...common,
+  key: "trello-custom-webhook-events",
+  name: "Custom Webhook Events (Instant)",
+  description: "Emit new events for activity matching a board, event types, lists and/or cards.",
+  version: "0.0.7",
+  type: "source",
+  props: {
+    ...common.props,
+    board: {
+      propDefinition: [
+        common.props.trello,
+        "board",
+      ],
+    },
+    eventTypes: {
+      propDefinition: [
+        common.props.trello,
+        "eventTypes",
+      ],
+    },
+    lists: {
+      propDefinition: [
+        common.props.trello,
+        "lists",
+        (c) => ({
+          board: c.board,
+        }),
+      ],
+    },
+    cards: {
+      propDefinition: [
+        common.props.trello,
+        "cards",
+        (c) => ({
+          board: c.board,
+        }),
+      ],
+    },
+  },
+  hooks: {
+    ...common.hooks,
+    async deploy() {
+      const {
+        sampleEvents, sortField,
+      } = await this.getSampleEvents();
+      sampleEvents.sort((a, b) => (Date.parse(a[sortField]) > Date.parse(b[sortField]))
+        ? 1
+        : -1);
+      for (const action of sampleEvents.slice(-25)) {
+        this.emitEvent({
+          action,
+        });
+      }
+    },
+  },
+  methods: {
+    ...common.methods,
+    async getSampleEvents() {
+      const eventTypes = this.eventTypes && this.eventTypes.length > 0
+        ? this.eventTypes.join(",")
+        : null;
+      const actions = await this.trello.getBoardActivity(this.board, eventTypes);
+      return {
+        sampleEvents: actions,
+        sortField: "date",
+      };
+    },
+    isCorrectEventType(event) {
+      const eventType = event.body?.action?.type;
+      return (
+        (eventType) &&
+        (!this.eventTypes ||
+        this.eventTypes.length === 0 ||
+        this.eventTypes.includes(eventType))
+      );
+    },
+    async getResult(event) {
+      return event.body;
+    },
+    async isRelevant({ result: body }) {
+      let listId = body.action?.data?.list?.id;
+      const cardId = body.action?.data?.card?.id;
+      // If listId not returned, see if we can get it from the cardId
+      if (cardId && !listId)
+        listId = (await this.trello.getCardList(cardId)).id;
+      return (
+        (!this.lists ||
+          this.lists.length === 0 ||
+          !listId ||
+          this.lists.includes(listId)) &&
+        (!this.cards || this.cards.length === 0 || !cardId || this.cards.includes(cardId))
+      );
+    },
+    generateMeta({ action }) {
+      const {
+        id,
+        type: summary,
+        date,
+      } = action;
+      return {
+        id,
+        summary,
+        ts: Date.parse(date),
+      };
+    },
+  },
+};

package/sources/new-activity/new-activity.mjs

@@ -0,0 +1,64 @@
+import common from "../common-webhook.mjs";
+
+export default {
+  ...common,
+  key: "trello-new-activity",
+  name: "New Activity (Instant)",
+  description: "Emit new event for new activity on a board.",
+  version: "0.0.5",
+  type: "source",
+  props: {
+    ...common.props,
+    board: {
+      propDefinition: [
+        common.props.trello,
+        "board",
+      ],
+    },
+  },
+  hooks: {
+    ...common.hooks,
+    async deploy() {
+      const {
+        sampleEvents, sortField,
+      } = await this.getSampleEvents();
+      sampleEvents.sort((a, b) => (Date.parse(a[sortField]) > Date.parse(b[sortField]))
+        ? 1
+        : -1);
+      for (const action of sampleEvents.slice(-25)) {
+        this.emitEvent({
+          action,
+        });
+      }
+    },
+  },
+  methods: {
+    ...common.methods,
+    async getSampleEvents() {
+      const actions = await this.trello.getBoardActivity(this.board);
+      return {
+        sampleEvents: actions,
+        sortField: "date",
+      };
+    },
+    async getResult(event) {
+      return event.body;
+    },
+    isRelevant({ event }) {
+      const boardId = event.body?.action?.data?.board?.id;
+      return !this.board || this.board === boardId;
+    },
+    generateMeta({ action }) {
+      const {
+        id,
+        type: summary,
+        date,
+      } = action;
+      return {
+        id,
+        summary,
+        ts: Date.parse(date),
+      };
+    },
+  },
+};

package/sources/new-attachment/new-attachment.mjs

@@ -0,0 +1,60 @@
+import common from "../common-webhook.mjs";
+
+export default {
+  ...common,
+  key: "trello-new-attachment",
+  name: "New Attachment (Instant)",
+  description: "Emit new event for new attachment on a board.",
+  version: "0.0.5",
+  type: "source",
+  props: {
+    ...common.props,
+    board: {
+      propDefinition: [
+        common.props.trello,
+        "board",
+      ],
+    },
+  },
+  hooks: {
+    ...common.hooks,
+    async deploy() {
+      const {
+        sampleEvents, sortField,
+      } = await this.getSampleEvents();
+      sampleEvents.sort((a, b) => (Date.parse(a[sortField]) > Date.parse(b[sortField]))
+        ? 1
+        : -1);
+      for (const action of sampleEvents.slice(-25)) {
+        this.$emit(action, {
+          id: action.id,
+          summary: action?.data?.attachment?.name,
+          ts: Date.parse(action.date),
+        });
+      }
+    },
+  },
+  methods: {
+    ...common.methods,
+    async getSampleEvents() {
+      const actions = await this.trello.getBoardActivity(this.board, "addAttachmentToCard");
+      return {
+        sampleEvents: actions,
+        sortField: "date",
+      };
+    },
+    isCorrectEventType(event) {
+      const eventType = event.body?.action?.type;
+      return eventType === "addAttachmentToCard";
+    },
+    async getResult(event) {
+      const cardId = event.body?.action?.data?.card?.id;
+      const attachmentId = event.body?.action?.data?.attachment?.id;
+      return this.trello.getAttachment(cardId, attachmentId);
+    },
+    isRelevant({ event }) {
+      const boardId = event.body?.action?.data?.board?.id;
+      return !this.board || this.board === boardId;
+    },
+  },
+};

package/sources/new-board/new-board.mjs

@@ -0,0 +1,29 @@
+import common from "../common-webhook.mjs";
+
+export default {
+  ...common,
+  key: "trello-new-board",
+  name: "New Board (Instant)",
+  description: "Emit new event for each new board added.",
+  version: "0.0.9",
+  type: "source",
+  dedupe: "unique",
+  methods: {
+    ...common.methods,
+    async getSampleEvents() {
+      const boards = await this.trello.getBoards();
+      return {
+        sampleEvents: boards,
+        sortField: "dateLastView",
+      };
+    },
+    isCorrectEventType(event) {
+      const eventType = event.body?.action?.type;
+      return eventType === "createBoard";
+    },
+    async getResult(event) {
+      const boardId = event.body?.action?.data?.board?.id;
+      return this.trello.getBoard(boardId);
+    },
+  },
+};

package/sources/new-card/new-card.mjs

@@ -0,0 +1,58 @@
+import common from "../common-webhook.mjs";
+
+export default {
+  ...common,
+  key: "trello-new-card",
+  name: "New Card (Instant)",
+  description: "Emit new event for each new Trello card on a board.",
+  version: "0.0.8",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    ...common.props,
+    board: {
+      propDefinition: [
+        common.props.trello,
+        "board",
+      ],
+    },
+    lists: {
+      propDefinition: [
+        common.props.trello,
+        "lists",
+        (c) => ({
+          board: c.board,
+        }),
+      ],
+    },
+  },
+  methods: {
+    ...common.methods,
+    async getSampleEvents() {
+      const cards = this.lists && this.lists.length > 0
+        ? await this.trello.getCardsInList(this.lists[0])
+        : await this.trello.getCards(this.board);
+      return {
+        sampleEvents: cards,
+        sortField: "dateLastActivity",
+      };
+    },
+    isCorrectEventType(event) {
+      const eventType = event.body?.action?.type;
+      return eventType === "createCard";
+    },
+    async getResult(event) {
+      const cardId = event.body?.action?.data?.card?.id;
+      return this.trello.getCard(cardId);
+    },
+    isRelevant({ result: card }) {
+      if (this.board && this.board !== card.idBoard) return false;
+      return (
+        (!this.board || this.board === card.idBoard) &&
+        (!this.lists ||
+          this.lists.length === 0 ||
+          this.lists.includes(card.idList))
+      );
+    },
+  },
+};