@pipedream/servicenow 0.7.0 → 0.8.0

package/actions/update-table-record/update-table-record.mjs

@@ -1,11 +1,11 @@
-// legacy_hash_id: a_4riE2J
-import { axios } from "@pipedream/platform";
+import servicenow from "../../servicenow.app.mjs";
+import { parseObject } from "../../common/utils.mjs";
 
 export default {
   key: "servicenow-update-table-record",
   name: "Update Table Record",
-  description: "Updates the specified record with the name-value pairs included in the request body.",
-  version: "0.1.2",
+  description: "Updates the specified record with the name-value pairs included in the request body. [See the documentation](https://www.servicenow.com/docs/bundle/zurich-api-reference/page/integrate/inbound-rest/concept/c_TableAPI.html#title_table-PATCH)",
+  version: "1.0.0",
   annotations: {
     destructiveHint: true,
     openWorldHint: true,
@@ -13,123 +13,82 @@ export default {
   },
   type: "action",
   props: {
-    servicenow: {
-      type: "app",
-      app: "servicenow",
-    },
-    table_name: {
-      type: "string",
-      description: "The name of the table containing the record to update.",
-    },
-    sys_id: {
-      type: "string",
-      description: "Unique identifier of the record to update.",
-    },
-    update_fields: {
-      type: "object",
-      description: "An object with name-value pairs with the fields to update in the specified record.\n**Note:** All fields within a record may not be available for update. For example, fields that have a prefix of \"sys_\" are typically system parameters that are automatically generated and cannot be updated.",
-    },
-    api_version: {
-      type: "string",
-      description: "API version number. Version numbers identify the endpoint version that a URI accesses. By specifying a version number in your URIs, you can ensure that future updates to the REST API do not negatively impact your integration. Use `lastest` to use the latest REST endpoint for your instance version.",
-      optional: true,
-      options: [
-        "lastest",
-        "v1",
-        "v2",
+    servicenow,
+    table: {
+      propDefinition: [
+        servicenow,
+        "table",
       ],
     },
-    request_format: {
-      type: "string",
-      description: "Format of REST request body",
-      optional: true,
-      options: [
-        "application/json",
-        "application/xml",
-        "text/xml",
+    recordId: {
+      propDefinition: [
+        servicenow,
+        "recordId",
       ],
     },
-    response_format: {
-      type: "string",
-      description: "Format of REST response body.",
-      optional: true,
-      options: [
-        "application/json",
-        "application/xml",
-        "text/xml",
-      ],
+    updateFields: {
+      label: "Update Fields",
+      type: "object",
+      description: "The fields to update in the record, as key-value pairs (e.g. `{ \"name\": \"Jane Doe\", \"status\": \"active\" }`). **Note:** System fields (prefixed with `sys_`) are typically auto-generated and cannot be updated.",
     },
-    x_no_response_body: {
+    replaceRecord: {
       type: "boolean",
-      description: "By default, responses include body content detailing the modified record. Set this request header to true to suppress the response body.",
+      label: "Replace Record",
+      description: "If true, replaces the entire record with the provided fields (uses PUT instead of PATCH). Any fields not provided will be cleared.",
       optional: true,
     },
-    sysparm_display_value: {
-      type: "string",
-      description: "Return field display values (true), actual values (false), or both (all) (default: false).",
-      optional: true,
-      options: [
-        "true",
-        "false",
-        "all",
+    responseDataFormat: {
+      propDefinition: [
+        servicenow,
+        "responseDataFormat",
       ],
     },
-    sysparm_fields: {
-      type: "string",
-      description: "A comma-separated list of fields to return in the response.",
-      optional: true,
+    responseFields: {
+      propDefinition: [
+        servicenow,
+        "responseFields",
+      ],
     },
-    sysparm_input_display_value: {
-      type: "boolean",
-      description: "Flag that indicates whether to set field values using the display value or the actual value.\n* `true`: Treats input values as display values and they are manipulated so they can be stored properly in the database.\n* `false`: Treats input values as actual values and stored them in the database without manipulation.",
-      optional: true,
+    inputDisplayValue: {
+      propDefinition: [
+        servicenow,
+        "inputDisplayValue",
+      ],
     },
-    sysparm_view: {
-      type: "string",
-      description: "Render the response according to the specified UI view (overridden by sysparm_fields).",
-      optional: true,
-      options: [
-        "desktop",
-        "mobile",
-        "both",
+    responseView: {
+      propDefinition: [
+        servicenow,
+        "responseView",
       ],
     },
-    sysparm_query_no_domain: {
-      type: "boolean",
-      description: "True to access data across domains if authorized (default: false).",
-      optional: true,
+    queryNoDomain: {
+      propDefinition: [
+        servicenow,
+        "queryNoDomain",
+      ],
     },
   },
   async run({ $ }) {
-  /* See the API docs: https://docs.servicenow.com/bundle/paris-application-development/page/integrate/inbound-rest/concept/c_TableAPI.html#c_TableAPI
-    Section Table - PATCH /now/table/{tableName}/{sys_id}                      */
-
-    if (!this.table_name || !this.sys_id || !this.update_fields) {
-      throw new Error("Must provide table_name, sys_id, and update_fields parameters.");
-    }
-
-    var apiVersion = "";
-    if (this.api_version == "v1" || this.api_version == "v2") {
-      apiVersion = this.api_version + "/";
-    }
-
-    return await axios($, {
-      method: "patch",
-      url: `https://${this.servicenow.$auth.instance_name}.service-now.com/api/now/${apiVersion}table/${this.table_name}/${this.sys_id}`,
-      headers: {
-        "Authorization": `Bearer ${this.servicenow.$auth.oauth_access_token}`,
-        "Accept": this.request_format || "application/json",
-        "Content-Type": this.response_format || "application/json",
-        "X-no-response-body": this.x_no_response_body,
-      },
+    const response = await this.servicenow.updateTableRecord({
+      $,
+      table: this.table,
+      recordId: this.recordId,
+      replace: this.replaceRecord,
+      data: parseObject(this.updateFields),
       params: {
-        sysparm_display_value: this.sysparm_display_value,
-        sysparm_fields: this.sysparm_fields,
-        sysparm_input_display_value: this.sysparm_input_display_value,
-        sysparm_view: this.sysparm_view,
-        sysparm_query_no_domain: this.sysparm_query_no_domain,
+        sysparm_display_value: this.responseDataFormat,
+        sysparm_fields: this.responseFields?.join?.() || this.responseFields,
+        sysparm_input_display_value: this.inputDisplayValue,
+        sysparm_view: this.responseView,
+        sysparm_query_no_domain: this.queryNoDomain,
       },
-      data: this.update_fields,
     });
+
+    const action = this.replaceRecord
+      ? "replaced"
+      : "updated";
+    $.export("$summary", `Successfully ${action} record ${this.recordId} in table "${this.table}"`);
+
+    return response;
   },
 };

package/common/utils.mjs

@@ -0,0 +1,15 @@
+import { ConfigurationError } from "@pipedream/platform";
+
+export function parseObject(value) {
+  if (!value) return undefined;
+
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch (e) {
+      throw new ConfigurationError(`Invalid JSON: ${value}`);
+    }
+  }
+
+  return value;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pipedream/servicenow",
-  "version": "0.7.0",
-  "description": "Pipedream servicenow Components",
+  "version": "0.8.0",
+  "description": "Pipedream ServiceNow Components",
   "main": "servicenow.app.mjs",
   "keywords": [
     "pipedream",
@@ -13,6 +13,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@pipedream/platform": "^3.1.0"
+    "@pipedream/platform": "^3.1.1"
   }
 }

package/servicenow.app.mjs

@@ -1,160 +1,168 @@
 import { axios } from "@pipedream/platform";
-import constants from "./common/constants.mjs";
-
-const {
-  DEFAULT_SEVERITY_OPTIONS,
-  INCIDENT_SEVERITY_OPTIONS,
-} = constants;
 
 export default {
   type: "app",
   app: "servicenow",
   propDefinitions: {
-    name: {
+    table: {
       type: "string",
-      label: "Name",
-      description: "A short description of the ticket issue.",
-      optional: true,
-    },
-    description: {
-      type: "string",
-      label: "Description",
-      description: "A detailed description of the issue.",
-    },
-    caseSeverity: {
-      type: "string",
-      label: "Severity",
-      description: "The priority/severity of the case.",
-      options: DEFAULT_SEVERITY_OPTIONS,
-    },
-    incidentSeverity: {
-      type: "string",
-      label: "Severity",
-      description: "The priority/severity of the incident.",
-      options: INCIDENT_SEVERITY_OPTIONS,
-    },
-    status: {
-      type: "string",
-      label: "Status",
-      description: "The current status of the ticket.",
-      optional: true,
-      default: "New",
-    },
-    channelName: {
-      type: "string",
-      label: "Channel Name",
-      description: "The channel (`contact_type`) that the ticket was created through.",
-      optional: true,
-    },
-    contactMethod: {
+      label: "Table",
+      description: "Search for a table or provide a table name (not label)",
+      useQuery: true,
+      async options({ query }) {
+        if (!(query?.length > 1)) {
+          console.log("Please input a search term");
+          return [];
+        }
+        const data = await this.getTableRecords({
+          table: "sys_db_object",
+          params: {
+            sysparm_query: `nameLIKE${query}^ORlabelLIKE${query}`,
+            sysparm_fields: "name,label",
+          },
+        });
+        return data.map(({
+          label, name,
+        }) => ({
+          label,
+          value: name,
+        }));
+      },
+    },
+    recordId: {
       type: "string",
-      label: "Contact Method",
-      description: "Name of the contact method (`contact_type`) that the ticket was created through.",
-      optional: true,
+      label: "Record ID",
+      description: "The ID (`sys_id` field) of the record",
     },
-    accountId: {
+    responseDataFormat: {
+      label: "Response Data Format",
       type: "string",
-      label: "Account ID",
-      description: "`Sys_id` of the account related to the case.",
+      description: "The format to return response fields in",
       optional: true,
-    },
-    contactId: {
-      type: "string",
-      label: "Contact ID",
-      description: "`Sys_id` of the contact related to the case.",
+      options: [
+        {
+          value: "true",
+          label: "Returns the display values for all fields",
+        },
+        {
+          value: "false",
+          label: "Returns the actual values from the database",
+        },
+        {
+          value: "all",
+          label: "Returns both actual and display values",
+        },
+      ],
+    },
+    excludeReferenceLinks: {
+      type: "boolean",
+      label: "Exclude Reference Links",
+      description: "If true, the response excludes Table API links for reference fields",
       optional: true,
     },
-    companyId: {
-      type: "string",
-      label: "Company ID",
-      description: "`Sys_id` of the company related to the incident.",
+    responseFields: {
+      type: "string[]",
+      label: "Response Fields",
+      description: "The fields to return in the response. By default, all fields are returned",
       optional: true,
     },
-    userId: {
-      type: "string",
-      label: "User ID",
-      description: "`Sys_id` of the user related to the incident.",
+    inputDisplayValue: {
+      label: "Input Display Value",
+      type: "boolean",
+      description: "If true, the input values are treated as display values (and are manipulated so they can be stored properly in the database)",
       optional: true,
     },
-    workNote: {
+    responseView: {
+      label: "Response View",
       type: "string",
-      label: "Work Note",
-      description: "Internal work note for the ticket.",
+      description: "Render the response according to the specified UI view (overridden by `Response Fields`)",
       optional: true,
-    },
-    comment: {
-      type: "string",
-      label: "Comment",
-      description: "Additional comment for the ticket.",
+      options: [
+        "desktop",
+        "mobile",
+        "both",
+      ],
+    },
+    queryNoDomain: {
+      type: "boolean",
+      label: "Query Across Domains",
+      description: "If true, allows access to data across domains (if authorized)",
       optional: true,
     },
   },
   methods: {
-    baseUrl() {
-      const { instance_name: instanceName } = this.$auth;
-      return `https://${instanceName}.service-now.com`;
+    async _makeRequest({
+      $ = this,
+      headers,
+      ...args
+    }) {
+      const response = await axios($, {
+        baseURL: `https://${this.$auth.instance_name}.service-now.com/api/now`,
+        headers: {
+          ...headers,
+          "Authorization": `Bearer ${this.$auth.oauth_access_token}`,
+        },
+        ...args,
+      });
+      return response.result;
     },
-    authHeaders() {
-      const { oauth_access_token: oauthAccessToken } = this.$auth;
-      return {
-        "Authorization": `Bearer ${oauthAccessToken}`,
-        "Accept": "application/json",
-        "Content-Type": "application/json",
-      };
+    async createTableRecord({
+      table, ...args
+    }) {
+      return this._makeRequest({
+        method: "post",
+        url: `/table/${table}`,
+        headers: {
+          "Content-Type": "application/json",
+        },
+        ...args,
+      });
     },
-    buildChannel(name) {
-      if (!name) {
-        return;
-      }
-      return {
-        name,
-      };
+    async updateTableRecord({
+      table, recordId, replace, ...args
+    }) {
+      return this._makeRequest({
+        method: replace
+          ? "put"
+          : "patch",
+        url: `/table/${table}/${recordId}`,
+        headers: {
+          "Content-Type": "application/json",
+        },
+        ...args,
+      });
     },
-    buildNotes({
-      workNote,
-      comment,
-    } = {}) {
-      const notes = [];
-      if (workNote) {
-        notes.push({
-          "text": workNote,
-          "@type": "work_notes",
-        });
-      }
-      if (comment) {
-        notes.push({
-          "text": comment,
-          "@type": "comments",
-        });
-      }
-      return notes.length
-        ? notes
-        : undefined;
+    async deleteTableRecord({
+      table, recordId, ...args
+    }) {
+      return this._makeRequest({
+        method: "delete",
+        url: `/table/${table}/${recordId}`,
+        ...args,
+      });
     },
-    buildRelatedParties(partyTypeToId = {}) {
-      const entries = Object.entries(partyTypeToId)
-        .filter(([
-          , id,
-        ]) => id);
-      if (!entries.length) {
-        return;
-      }
-      return entries.map(([
-        type,
-        id,
-      ]) => ({
-        id,
-        "@referredType": type,
-      }));
+    async getTableRecordById({
+      table, recordId, ...args
+    }) {
+      return this._makeRequest({
+        url: `/table/${table}/${recordId}`,
+        ...args,
+      });
     },
-    async createTroubleTicket({
-      $ = this, data,
-    } = {}) {
-      return axios($, {
-        method: "post",
-        url: `${this.baseUrl()}/api/sn_ind_tsm_sdwan/ticket/troubleTicket`,
-        headers: this.authHeaders(),
-        data,
+    async getTableRecords({
+      table, ...args
+    }) {
+      return this._makeRequest({
+        url: `/table/${table}`,
+        ...args,
+      });
+    },
+    async getRecordCountsByField({
+      table, ...args
+    }) {
+      return this._makeRequest({
+        url: `/stats/${table}`,
+        ...args,
       });
     },
   },

package/actions/create-case/create-case.mjs

@@ -1,114 +0,0 @@
-import servicenow from "../../servicenow.app.mjs";
-
-export default {
-  key: "servicenow-create-case",
-  name: "Create Case",
-  description: "Creates a new case record in ServiceNow. [See the docs here](https://www.servicenow.com/docs/bundle/zurich-api-reference/page/integrate/inbound-rest/concept/trouble-ticket-open-api.html#title_trouble-ticket-POST-ticket-tt).",
-  version: "0.0.1",
-  type: "action",
-  annotations: {
-    destructiveHint: false,
-    openWorldHint: true,
-    readOnlyHint: false,
-  },
-  props: {
-    servicenow,
-    name: {
-      propDefinition: [
-        servicenow,
-        "name",
-      ],
-    },
-    description: {
-      propDefinition: [
-        servicenow,
-        "description",
-      ],
-    },
-    severity: {
-      propDefinition: [
-        servicenow,
-        "caseSeverity",
-      ],
-    },
-    status: {
-      propDefinition: [
-        servicenow,
-        "status",
-      ],
-    },
-    channelName: {
-      propDefinition: [
-        servicenow,
-        "channelName",
-      ],
-    },
-    accountId: {
-      propDefinition: [
-        servicenow,
-        "accountId",
-      ],
-    },
-    contactId: {
-      propDefinition: [
-        servicenow,
-        "contactId",
-      ],
-    },
-    workNote: {
-      propDefinition: [
-        servicenow,
-        "workNote",
-      ],
-    },
-    comment: {
-      propDefinition: [
-        servicenow,
-        "comment",
-      ],
-    },
-  },
-  async run({ $ }) {
-    const {
-      name,
-      description,
-      severity,
-      status,
-      channelName,
-      accountId,
-      contactId,
-      workNote,
-      comment,
-    } = this;
-
-    const channel = this.servicenow.buildChannel(channelName);
-
-    const notes = this.servicenow.buildNotes({
-      workNote,
-      comment,
-    });
-
-    const relatedParties = this.servicenow.buildRelatedParties({
-      customer: accountId,
-      customer_contact: contactId,
-    });
-
-    const response = await this.servicenow.createTroubleTicket({
-      $,
-      data: {
-        ticketType: "Case",
-        name,
-        description,
-        severity,
-        status,
-        channel,
-        notes,
-        relatedParties,
-      },
-    });
-
-    $.export("$summary", "Successfully created a case.");
-
-    return response;
-  },
-};