@pipedream/postman 0.0.1 → 0.2.0

package/README.md

@@ -0,0 +1,11 @@
+# Overview
+
+The Postman API enables you to automate tasks within your Postman collections, such as running collections, fetching and updating environments, and integrating your API development workflow into your CI/CD pipeline. Using Pipedream, you can harness this functionality to create custom workflows that trigger on various events, process data, and connect with other apps, extending the capabilities of your API testing and development processes.
+
+# Example Use Cases
+
+- **Scheduled Collection Runs**: Use Pipedream to schedule and run Postman collections at regular intervals. You can analyze the results, send alerts if a test fails, or even trigger other workflows based on those results.
+
+- **Dynamic Environment Updates**: Automatically update Postman environment variables when changes occur in your apps. For instance, sync new user data from a CRM platform to Postman's environment, ensuring your API tests always use the latest data.
+
+- **CI/CD Integration**: Connect your Postman tests with your CI/CD pipeline. After every code commit, use Pipedream to trigger a workflow that runs a specific Postman collection and reports the status back to your CI/CD tool, such as GitHub Actions, ensuring that only tested code gets deployed.

package/actions/create-environment/create-environment.mjs

@@ -0,0 +1,91 @@
+import postman from "../../postman.app.mjs";
+
+export default {
+  key: "postman-create-environment",
+  name: "Create Environment",
+  description: "Creates a new environment in Postman. [See the documentation](https://learning.postman.com/docs/developer/postman-api/intro-api/)",
+  version: "0.0.2",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: false,
+  },
+  type: "action",
+  props: {
+    postman,
+    workspaceId: {
+      propDefinition: [
+        postman,
+        "workspaceId",
+      ],
+      optional: true,
+    },
+    environmentName: {
+      type: "string",
+      label: "New Environment Name",
+      description: "The name for the new environment",
+    },
+    variablesCount: {
+      type: "integer",
+      label: "Variables Quantity",
+      description: "The quantity of variables you want to create into the environment.",
+      reloadProps: true,
+      optional: true,
+    },
+  },
+  async additionalProps() {
+    const props = {};
+    if (this.variablesCount) {
+      for (var i = 1; i <= this.variablesCount; i++) {
+        props[`variableKey_${i}`] = {
+          type: "string",
+          label: `Variable Name ${i}`,
+          description: `The name for the variable ${i}`,
+        };
+        props[`variableValue_${i}`] = {
+          type: "string",
+          label: `Variable Value ${i}`,
+          description: `The value for the variable ${i}`,
+        };
+        props[`variableEnabled_${i}`] = {
+          type: "boolean",
+          label: `Variable Enabled ${i}`,
+          description: `Whether the variable ${i} is enabled or not.`,
+        };
+        props[`variableType_${i}`] = {
+          type: "string",
+          label: `Variable Type ${i}`,
+          description: `The type of the variable ${i}`,
+          options: [
+            "secret",
+            "default",
+          ],
+        };
+      }
+    }
+    return props;
+  },
+  async run({ $ }) {
+    const variables = [];
+    for (var i = 1; i <= this.variablesCount; i++) {
+      variables.push({
+        key: this[`variableKey_${i}`],
+        value: this[`variableValue_${i}`],
+        enabled: this[`variableEnabled_${i}`],
+        type: this[`variableType_${i}`],
+      });
+    }
+
+    const response = await this.postman.createEnvironment({
+      $,
+      data: {
+        environment: {
+          name: this.environmentName,
+          values: variables,
+        },
+      },
+    });
+    $.export("$summary", `Successfully created a new environment with ID: ${response.environment?.id}`);
+    return response;
+  },
+};

package/actions/list-workspace-id-options/list-workspace-id-options.mjs

@@ -0,0 +1,24 @@
+import postman from "../../postman.app.mjs";
+
+export default {
+  key: "postman-list-workspace-id-options",
+  name: "List Workspace ID Options",
+  description: "Retrieves available options for the Workspace ID field.",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  props: {
+    postman,
+  },
+  async run({ $ }) {
+    const options = await postman.propDefinitions.workspaceId.options.call(this.postman);
+    $.export("$summary", `Successfully retrieved ${options.length} option${options.length === 1
+      ? ""
+      : "s"}`);
+    return options;
+  },
+};

package/actions/run-monitor/run-monitor.mjs

@@ -0,0 +1,32 @@
+import postman from "../../postman.app.mjs";
+
+export default {
+  key: "postman-run-monitor",
+  name: "Run Monitor",
+  description: "Run a specific monitor in Postman. [See the documentation](https://learning.postman.com/docs/developer/postman-api/intro-api/)",
+  version: "0.0.2",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: false,
+  },
+  type: "action",
+  props: {
+    postman,
+    monitorId: {
+      propDefinition: [
+        postman,
+        "monitorId",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.postman.runMonitor({
+      $,
+      monitorId: this.monitorId,
+    });
+
+    $.export("$summary", `Successfully executed monitor with ID: ${this.monitorId}`);
+    return response;
+  },
+};

package/actions/update-variable/update-variable.mjs

@@ -0,0 +1,109 @@
+import postman from "../../postman.app.mjs";
+
+export default {
+  key: "postman-update-variable",
+  name: "Update Environment Variable",
+  description: "Updates a specific environment variable in Postman. [See the documentation](https://learning.postman.com/docs/developer/postman-api/intro-api/)",
+  version: "0.0.2",
+  annotations: {
+    destructiveHint: true,
+    openWorldHint: true,
+    readOnlyHint: false,
+  },
+  type: "action",
+  props: {
+    postman,
+    workspaceId: {
+      propDefinition: [
+        postman,
+        "workspaceId",
+      ],
+      optional: true,
+    },
+    environmentId: {
+      propDefinition: [
+        postman,
+        "environmentId",
+        ({ workspaceId }) => ({
+          workspaceId,
+        }),
+      ],
+    },
+    variable: {
+      propDefinition: [
+        postman,
+        "variable",
+        ({ environmentId }) => ({
+          environmentId,
+        }),
+      ],
+      reloadProps: true,
+    },
+  },
+  async additionalProps() {
+    const props = {};
+    if (this.variable) {
+      const { environment: { values: variables } } = await this.postman.getEnvironment({
+        environmentId: this.environmentId,
+      });
+      const indexVar = variables.findIndex((variable) => variable.key === this.variable);
+      const variable = variables[indexVar];
+
+      props.variableValue = {
+        type: "string",
+        label: "Variable Value",
+        description: "The value for the variable",
+      };
+      props.variableEnabled = {
+        type: "boolean",
+        label: "Variable Enabled",
+        description: "Whether the variable is enabled or not.",
+        default: variable.enabled,
+      };
+    }
+    return props;
+  },
+  async run({ $ }) {
+    const {
+      postman,
+      environmentId,
+    } = this;
+
+    const { environment } = await postman.getEnvironment({
+      $,
+      environmentId,
+    });
+
+    const indexVar = environment.values.findIndex((variable) => variable.key === this.variable);
+    environment.values[indexVar] = {
+      ...environment.values[indexVar],
+      value: this.variableValue,
+      enabled: this.variableEnabled,
+    };
+
+    // This step is to delete all variables and create them again.
+    // Without this step, the postman will only update the variables` initial value.
+    await postman.updateEnvironment({
+      $,
+      environmentId,
+      data: {
+        environment: {
+          values: [],
+        },
+      },
+    });
+
+    const response = await postman.updateEnvironment({
+      $,
+      environmentId,
+      data: {
+        environment: {
+          values: environment.values,
+        },
+      },
+    });
+
+    $.export("$summary", `Successfully updated the variable "${this.variable}" in environment ID ${this.environmentId}`);
+    return response;
+  },
+};

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@pipedream/postman",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "description": "Pipedream Postman Components",
-  "main": "dist/app/postman.app.mjs",
+  "main": "postman.app.mjs",
   "keywords": [
     "pipedream",
     "postman"
   ],
-  "files": [
-    "dist"
-  ],
   "homepage": "https://pipedream.com/apps/postman",
   "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@pipedream/platform": "^1.6.8"
   }
 }

package/postman.app.mjs

@@ -0,0 +1,139 @@
+import { axios } from "@pipedream/platform";
+
+export default {
+  type: "app",
+  app: "postman",
+  propDefinitions: {
+    environmentId: {
+      type: "string",
+      label: "Environment ID",
+      description: "The ID of the environment to be used.",
+      async options({ workspaceId }) {
+        const { environments } = await this.listEnvironments({
+          params: {
+            workspace: workspaceId,
+          },
+        });
+        return environments.map(({
+          id: value, name: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    monitorId: {
+      type: "string",
+      label: "Monitor ID",
+      description: "The ID of the monitor to run.",
+      async options() {
+        const { monitors } = await this.listMonitors();
+        return monitors.map(({
+          id: value, name: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    variable: {
+      type: "string",
+      label: "Variable",
+      description: "The varriable to be updated.",
+      async options({ environmentId }) {
+        const { environment: { values: variables } } = await this.getEnvironment({
+          environmentId,
+        });
+
+        return variables.map(({ key }) => key);
+      },
+    },
+    workspaceId: {
+      type: "string",
+      label: "Workspace ID",
+      description: "The ID of the workspace to be used.",
+      async options() {
+        const { workspaces } = await this.listWorkspaces();
+        return workspaces.map(({
+          id: value, name: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+  },
+  methods: {
+    _baseUrl() {
+      return "https://api.getpostman.com";
+    },
+    _headers() {
+      return {
+        "X-Api-Key": `${this.$auth.api_key}`,
+        "Accept": "application/vnd.api.v10+json",
+      };
+    },
+    _makeRequest({
+      $ = this, path, ...opts
+    }) {
+      return axios($, {
+        url: this._baseUrl() + path,
+        headers: this._headers(),
+        ...opts,
+      });
+    },
+    getEnvironment({
+      environmentId, ...opts
+    }) {
+      return this._makeRequest({
+        path: `/environments/${environmentId}`,
+        ...opts,
+      });
+    },
+    getMonitor({ monitorId }) {
+      return this._makeRequest({
+        path: `/monitors/${monitorId}`,
+      });
+    },
+    listEnvironments() {
+      return this._makeRequest({
+        path: "/environments",
+      });
+    },
+    listMonitors() {
+      return this._makeRequest({
+        path: "/monitors",
+      });
+    },
+    listWorkspaces() {
+      return this._makeRequest({
+        path: "/workspaces",
+      });
+    },
+    createEnvironment(opts = {}) {
+      return this._makeRequest({
+        method: "POST",
+        path: "/environments",
+        ...opts,
+      });
+    },
+    updateEnvironment({
+      environmentId, ...opts
+    }) {
+      return this._makeRequest({
+        method: "PUT",
+        path: `/environments/${environmentId}`,
+        ...opts,
+      });
+    },
+    runMonitor({
+      monitorId, ...opts
+    }) {
+      return this._makeRequest({
+        method: "POST",
+        path: `/monitors/${monitorId}/run`,
+        ...opts,
+      });
+    },
+  },
+};

package/sources/monitor-run-completed/monitor-run-completed.mjs

@@ -0,0 +1,58 @@
+import postman from "../../postman.app.mjs";
+import sampleEmit from "./test-event.mjs";
+
+export default {
+  key: "postman-monitor-run-completed",
+  name: "New Monitor Run Completed",
+  description: "Emit new event when a monitor run is completed. [See the documentation](https://learning.postman.com/docs/monitoring-your-api/intro-monitors/)",
+  version: "0.0.1",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    postman,
+    db: "$.service.db",
+    timer: {
+      type: "$.interface.timer",
+      default: {
+        intervalSeconds: 60,
+      },
+    },
+    monitorId: {
+      propDefinition: [
+        postman,
+        "monitorId",
+      ],
+    },
+  },
+  methods: {
+    _getLastDate() {
+      return this.db.get("lastDate") || new Date("1970-01-01");
+    },
+    _setLastDate(lastDate) {
+      this.db.set("lastDate", lastDate);
+    },
+    async startEvent() {
+      const lastDate = this._getLastDate();
+
+      const { monitor } = await this.postman.getMonitor({
+        monitorId: this.monitorId,
+      });
+
+      if (monitor.lastRun?.status === "success" && new Date(monitor.lastRun.startedAt) > new Date(lastDate)) {
+        this._setLastDate(monitor.lastRun.startedAt);
+        this.emitEvent(monitor);
+      }
+    },
+    emitEvent(monitor) {
+      this.$emit(monitor, {
+        id: monitor.id + monitor.lastRun.startedAt,
+        summary: `Monitor Run Completed: ${monitor.name}`,
+        ts: Date.parse(monitor.lastRun.finishedAt),
+      });
+    },
+  },
+  async run() {
+    await this.startEvent();
+  },
+  sampleEmit,
+};

package/sources/monitor-run-completed/test-event.mjs

@@ -0,0 +1,46 @@
+export default {
+  "id": "1e6b6cc1-c760-48e0-968f-4bfaeeae9af1",
+  "name": "Test Monitor",
+  "uid": "12345678-1e6b6cc1-c760-48e0-968f-4bfaeeae9af1",
+  "owner": 12345678,
+  "collectionUid": "12345678-12ece9e1-2abf-4edc-8e34-de66e74114d2",
+  "environmentUid": "12345678-5daabc50-8451-43f6-922d-96b403b4f28e",
+  "options": {
+      "strictSSL": true,
+      "followRedirects": true,
+      "requestTimeout": 3000,
+      "requestDelay": 0
+  },
+  "notifications": {
+      "onError": [
+          {
+              "email": "user@example.com"
+          }
+      ],
+      "onFailure": [
+          {
+              "email": "user@example.com"
+          }
+      ]
+  },
+  "distribution": [],
+  "schedule": {
+      "cron": "0 0 * * * *",
+      "timezone": "America/Chicago",
+      "nextRun": "2022-06-18T05:00:00.000Z"
+  },
+  "lastRun": {
+      "status": "failed",
+      "startedAt": "2022-06-17T18:39:52.852Z",
+      "finishedAt": "2022-06-17T18:39:53.707Z"
+  },
+  "stats": {
+      "assertions": {
+          "total": 8,
+          "failed": 1
+      },
+      "requests": {
+          "total": 4
+      }
+}
+}