@pipedream/linear_app 0.3.3

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2020 Pipedream, 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/actions/create-issue/create-issue.mjs

@@ -0,0 +1,60 @@
+import linearApp from "../../linear_app.app.mjs";
+
+export default {
+  type: "action",
+  key: "linear_app-create-issue",
+  name: "Create Issue",
+  description: "Create an issue (API Key). See the docs [here](https://developers.linear.app/docs/graphql/working-with-the-graphql-api#creating-and-editing-issues)",
+  version: "0.3.3",
+  props: {
+    linearApp,
+    teamId: {
+      propDefinition: [
+        linearApp,
+        "teamId",
+      ],
+    },
+    title: {
+      propDefinition: [
+        linearApp,
+        "issueTitle",
+      ],
+    },
+    description: {
+      propDefinition: [
+        linearApp,
+        "issueDescription",
+      ],
+    },
+    assigneeId: {
+      propDefinition: [
+        linearApp,
+        "assigneeId",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const {
+      title,
+      description,
+      teamId,
+      assigneeId,
+    } = this;
+
+    const response =
+      await this.linearApp.createIssue({
+        teamId,
+        title,
+        description,
+        assigneeId,
+      });
+
+    if (response.success) {
+      $.export("summary", `Created issue ${response._issue.id}`);
+    } else {
+      $.export("summary", "Failed to create issue");
+    }
+
+    return response;
+  },
+};

package/actions/get-teams/get-teams.mjs

@@ -0,0 +1,19 @@
+import linearApp from "../../linear_app.app.mjs";
+
+export default {
+  key: "linear_app-get-teams",
+  name: "Get Teams",
+  description: "Get all the teams (API Key). See the docs [here](https://developers.linear.app/docs/graphql/working-with-the-graphql-api)",
+  version: "0.1.3",
+  type: "action",
+  props: {
+    linearApp,
+  },
+  async run({ $ }) {
+    const { nodes: teams } = await this.linearApp.listTeams();
+
+    $.export("summary", `Found ${teams.length} teams(s)`);
+
+    return teams;
+  },
+};

package/actions/search-issues/search-issues.mjs

@@ -0,0 +1,116 @@
+import linearApp from "../../linear_app.app.mjs";
+
+export default {
+  key: "linear_app-search-issues",
+  name: "Search Issues",
+  description: "Search issues (API Key). See the docs [here](https://developers.linear.app/docs/graphql/working-with-the-graphql-api)",
+  type: "action",
+  version: "0.1.0",
+  props: {
+    linearApp,
+    query: {
+      propDefinition: [
+        linearApp,
+        "query",
+      ],
+    },
+    teamId: {
+      propDefinition: [
+        linearApp,
+        "teamId",
+      ],
+      optional: true,
+    },
+    projectId: {
+      propDefinition: [
+        linearApp,
+        "projectId",
+      ],
+    },
+    assigneeId: {
+      propDefinition: [
+        linearApp,
+        "assigneeId",
+      ],
+    },
+    issueLabels: {
+      propDefinition: [
+        linearApp,
+        "issueLabels",
+      ],
+    },
+    orderBy: {
+      propDefinition: [
+        linearApp,
+        "orderBy",
+      ],
+    },
+    includeArchived: {
+      propDefinition: [
+        linearApp,
+        "includeArchived",
+      ],
+    },
+  },
+  methods: {
+    buildFilter() {
+      return {
+        team: {
+          id: {
+            eq: this.teamId,
+          },
+        },
+        project: {
+          id: {
+            eq: this.projectId,
+          },
+        },
+        assignee: {
+          id: {
+            eq: this.assigneeId,
+          },
+        },
+        labels: {
+          name: {
+            in: this.issueLabels,
+          },
+        },
+      };
+    },
+  },
+  async run({ $ }) {
+    const {
+      query,
+      orderBy,
+      includeArchived,
+    } = this;
+
+    let issues = [];
+    let hasNextPage;
+    let after;
+    const filter = this.buildFilter();
+
+    do {
+      const {
+        nodes,
+        pageInfo,
+      } = await this.linearApp.searchIssues({
+        query,
+        variables: {
+          filter,
+          orderBy,
+          after,
+          includeArchived,
+        },
+      });
+
+      issues = issues.concat(nodes);
+      after = pageInfo.endCursor;
+      hasNextPage = pageInfo.hasNextPage;
+    } while (hasNextPage);
+
+    $.export("summary", `Found ${issues.length} issues`);
+
+    return issues;
+  },
+};

package/actions/update-issue/update-issue.mjs

@@ -0,0 +1,73 @@
+import linearApp from "../../linear_app.app.mjs";
+
+export default {
+  key: "linear_app-update-issue",
+  name: "Update Issue",
+  description: "Update an issue (API Key). See the docs [here](https://developers.linear.app/docs/graphql/working-with-the-graphql-api#creating-and-editing-issues)",
+  type: "action",
+  version: "0.0.2",
+  props: {
+    linearApp,
+    issueId: {
+      propDefinition: [
+        linearApp,
+        "issueId",
+      ],
+    },
+    title: {
+      optional: true,
+      propDefinition: [
+        linearApp,
+        "issueTitle",
+      ],
+    },
+    description: {
+      optional: true,
+      propDefinition: [
+        linearApp,
+        "issueDescription",
+      ],
+    },
+    teamId: {
+      optional: true,
+      propDefinition: [
+        linearApp,
+        "teamId",
+      ],
+    },
+    assigneeId: {
+      propDefinition: [
+        linearApp,
+        "assigneeId",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const {
+      issueId,
+      title,
+      description,
+      teamId,
+      assigneeId,
+    } = this;
+
+    const response =
+      await this.linearApp.updateIssue({
+        issueId,
+        input: {
+          teamId,
+          title,
+          description,
+          assigneeId,
+        },
+      });
+
+    if (response.success) {
+      $.export("summary", `Updated issue ${response._issue.id}`);
+    } else {
+      $.export("summary", "Failed to update issue");
+    }
+
+    return response;
+  },
+};

package/common/constants.mjs

@@ -0,0 +1,55 @@
+const WEBHOOK_ID = "webhookId";
+const LINEAR_DELIVERY_HEADER = "linear-delivery";
+const DEFAULT_LIMIT = 50;
+
+const ACTION = {
+  CREATE: "create",
+  UPDATE: "update",
+};
+
+const RESOURCE_TYPE = {
+  COMMENT: "Comment",
+  ISSUE: "Issue",
+  ISSUE_LABEL: "IssueLabel",
+  PROJECT: "Project",
+  CYCLE: "Cycle",
+  REACTION: "Reaction",
+};
+
+const RESOURCE_TYPES = Object.values(RESOURCE_TYPE);
+
+// https://developers.linear.app/docs/graphql/webhooks#how-does-a-webhook-work
+// To make sure a Webhook POST is truly created by Linear, check the request
+// that originates from one of the following IPs:
+const CLIENT_IPS = [
+  "35.231.147.226",
+  "35.243.134.228",
+];
+
+const FIELD = {
+  CREATED_AT: "createdAt",
+  UPDATED_AT: "updatedAt",
+};
+
+const ORDER_BY_OPTIONS = [
+  {
+    label: "Created at",
+    value: FIELD.CREATED_AT,
+  },
+  {
+    label: "Updated at",
+    value: FIELD.UPDATED_AT,
+  },
+];
+
+export default {
+  WEBHOOK_ID,
+  LINEAR_DELIVERY_HEADER,
+  DEFAULT_LIMIT,
+  ACTION,
+  RESOURCE_TYPE,
+  RESOURCE_TYPES,
+  CLIENT_IPS,
+  ORDER_BY_OPTIONS,
+  FIELD,
+};

package/linear_app.app.mjs

@@ -0,0 +1,201 @@
+import { LinearClient } from "@linear/sdk";
+import constants from "./common/constants.mjs";
+
+export default {
+  type: "app",
+  app: "linear_app",
+  propDefinitions: {
+    issueId: {
+      type: "string",
+      label: "Issue ID",
+      description: "The issue ID to update",
+      async options({ prevContext }) {
+        return this.listResourcesOptions({
+          prevContext,
+          resourcesFn: this.listIssues,
+          resouceMapper: ({
+            id, title,
+          }) => ({
+            label: title,
+            value: id,
+          }),
+        });
+      },
+    },
+    teamId: {
+      type: "string",
+      label: "Team ID",
+      description: "The identifier or key of the team associated with the issue.",
+      async options({ prevContext }) {
+        return this.listResourcesOptions({
+          prevContext,
+          resourcesFn: this.listTeams,
+          resouceMapper: ({
+            id, name,
+          }) => ({
+            label: name,
+            value: id,
+          }),
+        });
+      },
+    },
+    projectId: {
+      type: "string",
+      label: "Project ID",
+      description: "The identifier or key of the project associated with the issue.",
+      optional: true,
+      async options({ prevContext }) {
+        return this.listResourcesOptions({
+          prevContext,
+          resourcesFn: this.listProjects,
+          resouceMapper: ({
+            id, name,
+          }) => ({
+            label: name,
+            value: id,
+          }),
+        });
+      },
+    },
+    issueTitle: {
+      type: "string",
+      label: "Title",
+      description: "The title of the issue.",
+    },
+    assigneeId: {
+      type: "string",
+      label: "Assignee ID",
+      description: "The identifier of the user to assign the issue to.",
+      optional: true,
+      async options({ prevContext }) {
+        return this.listResourcesOptions({
+          prevContext,
+          resourcesFn: this.listUsers,
+          resouceMapper: ({
+            id, name,
+          }) => ({
+            label: name,
+            value: id,
+          }),
+        });
+      },
+    },
+    boardOrder: {
+      type: "string",
+      label: "Board order",
+      description: "The position of the issue in its column on the board view.",
+      optional: true,
+    },
+    issueDescription: {
+      type: "string",
+      label: "Description",
+      description: "The issue description in markdown format.",
+      optional: true,
+    },
+    issueLabels: {
+      type: "string[]",
+      label: "Issue Labels",
+      description: "The labels in the issue.",
+      optional: true,
+      async options({ prevContext }) {
+        return this.listResourcesOptions({
+          prevContext,
+          resourcesFn: this.listIssueLabels,
+          resouceMapper: ({ name }) => name,
+        });
+      },
+    },
+    query: {
+      type: "string",
+      label: "Query",
+      description: "Search string to look for.",
+    },
+    orderBy: {
+      type: "string",
+      label: "Order by",
+      description: "By which field should the pagination order by. Available options are `createdAt` (default) and `updatedAt`.",
+      optional: true,
+      options: constants.ORDER_BY_OPTIONS,
+    },
+    includeArchived: {
+      type: "boolean",
+      label: "Include archived",
+      description: "Should archived resources be included (default: `false`).",
+      optional: true,
+    },
+  },
+  methods: {
+    getClientOptions(options = {}) {
+      return {
+        apiKey: this.$auth.api_key,
+        ...options,
+      };
+    },
+    client(options = {}) {
+      return new LinearClient(this.getClientOptions(options));
+    },
+    async createWebhook(input) {
+      return this.client().webhookCreate(input);
+    },
+    async deleteWebhook(id) {
+      return this.client().webhookDelete(id);
+    },
+    async createIssue(input) {
+      return this.client().issueCreate(input);
+    },
+    async updateIssue({
+      issueId, input,
+    }) {
+      return this.client().issueUpdate(issueId, input);
+    },
+    async searchIssues({
+      query, variables,
+    }) {
+      return this.client().issueSearch(query, variables);
+    },
+    async listTeams(variables = {}) {
+      return this.client().teams(variables);
+    },
+    async listProjects(variables = {}) {
+      return this.client().projects(variables);
+    },
+    async listUsers(variables = {}) {
+      return this.client().users(variables);
+    },
+    async listIssues(variables = {}) {
+      return this.client().issues(variables);
+    },
+    async listIssueLabels(variables = {}) {
+      return this.client().issueLabels(variables);
+    },
+    async listResourcesOptions({
+      prevContext, resourcesFn, resouceMapper,
+    }) {
+      const {
+        after,
+        hasNextPage,
+      } = prevContext;
+
+      if (hasNextPage === false) {
+        return [];
+      }
+
+      const {
+        nodes,
+        pageInfo,
+      } =
+        await resourcesFn({
+          after,
+          first: constants.DEFAULT_LIMIT,
+        });
+
+      return {
+        options: nodes.map(resouceMapper),
+        context: {
+          after: pageInfo.endCursor,
+          hasNextPage: pageInfo.hasNextPage,
+        },
+      };
+    },
+  },
+};

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@pipedream/linear_app",
+  "version": "0.3.3",
+  "description": "Pipedream Linear_app Components",
+  "main": "linear_app.app.mjs",
+  "keywords": [
+    "pipedream",
+    "linear_app"
+  ],
+  "homepage": "https://pipedream.com/apps/linear_app",
+  "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
+  "license": "MIT",
+  "dependencies": {
+    "@linear/sdk": "^1.22.0"
+  },
+  "gitHead": "e12480b94cc03bed4808ebc6b13e7fdb3a1ba535",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/sources/common/webhook.mjs

@@ -0,0 +1,103 @@
+import linearApp from "../../linear_app.app.mjs";
+import constants from "../../common/constants.mjs";
+
+export default {
+  props: {
+    linearApp,
+    teamId: {
+      propDefinition: [
+        linearApp,
+        "teamId",
+      ],
+      optional: true,
+    },
+    projectId: {
+      propDefinition: [
+        linearApp,
+        "projectId",
+      ],
+    },
+    http: "$.interface.http",
+    db: "$.service.db",
+  },
+  methods: {
+    setWebhookId(id) {
+      this.db.set(constants.WEBHOOK_ID, id);
+    },
+    getWebhookId() {
+      return this.db.get(constants.WEBHOOK_ID);
+    },
+    isRelevant(body) {
+      if (!this.getActions().includes(body?.action)) {
+        return false;
+      }
+      if (this.projectId) {
+        return body.data.projectId === this.projectId;
+      }
+      return true;
+    },
+    isWebhookValid(clientIp) {
+      return constants.CLIENT_IPS.includes(clientIp);
+    },
+    getResourceTypes() {
+      throw new Error("getResourceTypes is not implemented");
+    },
+    getWebhookLabel() {
+      throw new Error("getWebhookLabel is not implemented");
+    },
+    getActions() {
+      throw new Error("getActions is not implemented");
+    },
+    getMetadata() {
+      throw new Error("getMetadata is not implemented");
+    },
+  },
+  hooks: {
+    async activate() {
+      const params = {
+        resourceTypes: this.getResourceTypes(),
+        url: this.http.endpoint,
+        label: this.getWebhookLabel(),
+      };
+
+      if (this.teamId) {
+        params.teamId = this.teamId;
+      } else {
+        params.allPublicTeams = true;
+      }
+
+      const { _webhook: webhook } = await this.linearApp.createWebhook(params);
+      this.setWebhookId(webhook.id);
+    },
+    async deactivate() {
+      const webhookId = this.getWebhookId();
+      if (webhookId) {
+        await this.linearApp.deleteWebhook(webhookId);
+      }
+    },
+  },
+  async run(event) {
+    const {
+      client_ip: clientIp,
+      body,
+      headers,
+    } = event;
+
+    const { [constants.LINEAR_DELIVERY_HEADER]: delivery } = headers;
+
+    const resource = {
+      ...body,
+      delivery,
+    };
+
+    if (!this.isWebhookValid(clientIp)) {
+      console.log("Webhook is not valid");
+      return;
+    }
+
+    if (this.isRelevant(body)) {
+      const meta = this.getMetadata(resource);
+      this.$emit(body, meta);
+    }
+  },
+};

package/sources/issue-created-instant/issue-created-instant.mjs

@@ -0,0 +1,40 @@
+import common from "../common/webhook.mjs";
+import constants from "../../common/constants.mjs";
+
+export default {
+  ...common,
+  key: "linear_app-issue-created-instant",
+  name: "New Created Issue (Instant)",
+  description: "Emit new event when a new issue is created. See the docs [here](https://developers.linear.app/docs/graphql/webhooks)",
+  type: "source",
+  version: "0.1.0",
+  dedupe: "unique",
+  methods: {
+    ...common.methods,
+    getResourceTypes() {
+      return [
+        constants.RESOURCE_TYPE.ISSUE,
+      ];
+    },
+    getWebhookLabel() {
+      return "Issue created";
+    },
+    getActions() {
+      return [
+        constants.ACTION.CREATE,
+      ];
+    },
+    getMetadata(resource) {
+      const {
+        delivery,
+        data,
+        createdAt,
+      } = resource;
+      return {
+        id: delivery,
+        summary: `Issue created: ${data.title}`,
+        ts: Date.parse(createdAt),
+      };
+    },
+  },
+};

package/sources/issue-updated-instant/issue-updated-instant.mjs

@@ -0,0 +1,40 @@
+import common from "../common/webhook.mjs";
+import constants from "../../common/constants.mjs";
+
+export default {
+  ...common,
+  key: "linear_app-issue-updated-instant",
+  name: "New Updated Issue (Instant)",
+  description: "Emit new event when an issue is updated. See the docs [here](https://developers.linear.app/docs/graphql/webhooks)",
+  type: "source",
+  version: "0.1.0",
+  dedupe: "unique",
+  methods: {
+    ...common.methods,
+    getResourceTypes() {
+      return [
+        constants.RESOURCE_TYPE.ISSUE,
+      ];
+    },
+    getWebhookLabel() {
+      return "Issue updated";
+    },
+    getActions() {
+      return [
+        constants.ACTION.UPDATE,
+      ];
+    },
+    getMetadata(resource) {
+      const {
+        delivery,
+        data,
+        updatedAt,
+      } = resource;
+      return {
+        id: delivery,
+        summary: `Issue Updated: ${data.title}`,
+        ts: Date.parse(updatedAt),
+      };
+    },
+  },
+};