@pipedream/postman 0.0.1 → 0.1.0

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

@@ -0,0 +1,86 @@
+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.1",
+  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/run-monitor/run-monitor.mjs

@@ -0,0 +1,27 @@
+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.1",
+  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,104 @@
+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.1",
+  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.1.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.5.1"
   }
 }

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
+      }
+}
+}