@pipedream/kintone 0.0.2 → 0.1.0

package/README.md

@@ -0,0 +1,11 @@
+# Overview
+
+The Kintone API provides programmatic access to your Kintone database, allowing you to manage data such as records, spaces, and apps. With Pipedream, you can harness this API to automate workflows, sync data across different platforms, and trigger actions based on events in Kintone. Whether it's updating records in response to external triggers or pushing data from Kintone to other services, the integrations you can build are versatile and powerful.
+
+# Example Use Cases
+
+- **Sync Kintone Records with Google Sheets**: Automate the synchronization of data between Kintone and Google Sheets. Whenever a new record is added or updated in Kintone, the workflow triggers and updates the corresponding row in a Google Sheet. This is ideal for sharing data with team members who prefer viewing information in spreadsheet format.
+
+- **Automated Backup of Kintone Data to Dropbox**: Set up a workflow that periodically backs up your Kintone records to Dropbox. This can be a scheduled event that retrieves records from Kintone and saves them as a CSV or JSON file in a designated Dropbox folder, ensuring you have regular backups without manual intervention.
+
+- **Slack Notifications for New Kintone Records**: Create a real-time notification system that alerts a Slack channel whenever a new record is created in Kintone. This keeps your team informed instantly about new entries or requests, fostering quick responses and collaboration.

package/actions/add-comment/add-comment.mjs

@@ -0,0 +1,62 @@
+import { parseObject } from "../../common/utils.mjs";
+import kintone from "../../kintone.app.mjs";
+
+export default {
+  key: "kintone-add-comment",
+  name: "Add Comment",
+  description: "Adds a comment to a record in a Kintone App. [See the documentation](https://kintone.dev/en/docs/kintone/rest-api/records/add-comment/)",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: false,
+  },
+  props: {
+    kintone,
+    appId: {
+      propDefinition: [
+        kintone,
+        "appId",
+      ],
+    },
+    recordId: {
+      propDefinition: [
+        kintone,
+        "recordId",
+        ({ appId }) => ({
+          appId,
+        }),
+      ],
+    },
+    commentText: {
+      type: "string",
+      label: "Comment Text",
+      description: "The comment text (max 65,535 characters)",
+    },
+    mentions: {
+      type: "object",
+      label: "Mentions",
+      description: "Optional array of mentions. Example: `[{\"code\": \"user_code\", \"type\": \"USER\"}]` (USER, GROUP, or ORGANIZATION)",
+      optional: true,
+    },
+  },
+  async run({ $ }) {
+    const response = await this.kintone.addComment({
+      $,
+      data: {
+        app: this.appId,
+        record: this.recordId,
+        comment: {
+          text: this.commentText,
+          ...(this.mentions && {
+            mentions: parseObject(this.mentions),
+          }),
+        },
+      },
+    });
+
+    $.export("$summary", `Successfully added comment with ID: ${response.id}`);
+    return response;
+  },
+};

package/actions/create-record/create-record.mjs

@@ -0,0 +1,47 @@
+import { ConfigurationError } from "@pipedream/platform";
+import { parseObject } from "../../common/utils.mjs";
+import kintone from "../../kintone.app.mjs";
+
+export default {
+  key: "kintone-create-record",
+  name: "Create Record",
+  description: "Adds a new record to a Kintone App. [See the documentation](https://kintone.dev/en/docs/kintone/rest-api/records/add-record/)",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: false,
+  },
+  props: {
+    kintone,
+    appId: {
+      propDefinition: [
+        kintone,
+        "appId",
+      ],
+    },
+    record: {
+      propDefinition: [
+        kintone,
+        "record",
+      ],
+    },
+  },
+  async run({ $ }) {
+    try {
+      const response = await this.kintone.addRecord({
+        $,
+        data: {
+          app: this.appId,
+          record: parseObject(this.record),
+        },
+      });
+
+      $.export("$summary", `Successfully created record (ID: ${response.id})`);
+      return response;
+    } catch (error) {
+      throw new ConfigurationError(error.message);
+    }
+  },
+};

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

@@ -0,0 +1,96 @@
+import { ConfigurationError } from "@pipedream/platform";
+import { parseObject } from "../../common/utils.mjs";
+import kintone from "../../kintone.app.mjs";
+
+export default {
+  key: "kintone-update-record",
+  name: "Update Record",
+  description: "Updates an existing record in a Kintone App. [See the documentation](https://kintone.dev/en/docs/kintone/rest-api/records/update-record/)",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: false,
+  },
+  props: {
+    kintone,
+    appId: {
+      propDefinition: [
+        kintone,
+        "appId",
+      ],
+    },
+    recordId: {
+      propDefinition: [
+        kintone,
+        "recordId",
+        ({ appId }) => ({
+          appId,
+        }),
+      ],
+      description: "The Record ID of the record to update. Use this OR `Update Key`, not both",
+      optional: true,
+    },
+    updateKeyField: {
+      type: "string",
+      label: "Unique Key Field Code",
+      description: "The field code of the unique key (when using `Update Key` instead of Record ID). Must have 'Prohibit duplicate values' enabled",
+      optional: true,
+    },
+    updateKeyValue: {
+      type: "string",
+      label: "Unique Key Value",
+      description: "The value of the unique key to identify the record",
+      optional: true,
+    },
+    revision: {
+      type: "integer",
+      label: "Revision",
+      description: "The expected revision number. If the value does not match, an error will occur and the record will not be updated. If the value is not specified, the revision number will not be checked",
+      optional: true,
+    },
+    record: {
+      propDefinition: [
+        kintone,
+        "record",
+      ],
+      description: `Field codes and values are specified in this object.
+        \nFields not specified here will retain their current values.
+        \nFor more information on field types, refer to the following article: [Field Types](https://kintone.dev/en/docs/kintone/overview/field-types/).
+        \nExample: {"Text": {"value": "Sample"}, "Number": {"value": 1}}`,
+    },
+  },
+  async run({ $ }) {
+    if (!this.recordId && (!this.updateKeyField && !this.updateKeyValue)) {
+      throw new ConfigurationError("Either `Record ID` or both `Update Key Field` and `Update Key Value` must be provided");
+    }
+    if (this.recordId && this.updateKeyField) {
+      throw new ConfigurationError("Cannot specify both `Record ID` and `Update Key`");
+    }
+
+    let updateKey;
+    if (this.updateKeyField && this.updateKeyValue) {
+      updateKey = {
+        field: this.updateKeyField,
+        value: this.updateKeyValue,
+      };
+    }
+
+    const response = await this.kintone.updateRecord({
+      $,
+      data: {
+        app: this.appId,
+        id: this.recordId,
+        updateKey,
+        revision: this.revision === undefined
+          ? -1
+          : this.revision,
+        record: parseObject(this.record),
+      },
+    });
+
+    $.export("$summary", `Successfully updated record (revision: ${response.revision})`);
+    return response;
+  },
+};

package/common/constants.mjs

@@ -0,0 +1 @@
+export const LIMIT = 100;

package/common/utils.mjs

@@ -0,0 +1,25 @@
+export const parseObject = (obj) => {
+  if (!obj) return null;
+
+  if (typeof obj === "string") {
+    try {
+      return JSON.parse(obj);
+    } catch (e) {
+      return obj;
+    }
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => parseObject(item));
+  }
+  if (typeof obj === "object") {
+    const newObj = {};
+    for (const [
+      key,
+      value,
+    ] of Object.entries(obj)) {
+      newObj[key] = parseObject(value);
+    }
+    return newObj;
+  }
+  return obj;
+};

package/kintone.app.mjs

@@ -0,0 +1,135 @@
+import { axios } from "@pipedream/platform";
+import { LIMIT } from "./common/constants.mjs";
+
+export default {
+  type: "app",
+  app: "kintone",
+  propDefinitions: {
+    appId: {
+      type: "integer",
+      label: "App ID",
+      description: "The Kintone App ID",
+      async options({ page }) {
+        const { apps } = await this.getApps({
+          params: {
+            limit: LIMIT,
+            offset: page * LIMIT,
+          },
+        });
+        return apps.map((app) => ({
+          label: app.name,
+          value: parseInt(app.appId),
+        }));
+      },
+    },
+    recordId: {
+      type: "string",
+      label: "Record ID",
+      description: "The ID of the record",
+      async options({
+        appId, page,
+      }) {
+        const { records } = await this.getRecords({
+          params: {
+            app: appId,
+            query: `order by $id desc limit ${LIMIT} offset ${page * LIMIT}`,
+          },
+        });
+
+        return records.map((record) => record.$id.value);
+      },
+    },
+    record: {
+      type: "object",
+      label: "Record",
+      description: `Field codes and values are specified in this object.
+        \nThe values that can be specified vary depending on the type of field.
+        \nIf ignored, the record will be added with default field values.
+        \nIf field codes that don't exist are specified, these will be ignored.
+        \nFor more information on field types, refer to the following article: [Field Types](https://kintone.dev/en/docs/kintone/overview/field-types/).
+        \nExample: {"Text": {"value": "Sample"}, "Number": {"value": 1}}`,
+    },
+  },
+  methods: {
+    _getBaseUrl() {
+      return `https://${this.$auth.subdomain}.kintone.com/k/v1`;
+    },
+    _getHeaders() {
+      return {
+        "Authorization": `Bearer ${this.$auth.oauth_access_token}`,
+      };
+    },
+    _makeRequest({
+      $ = this, path, ...opts
+    }) {
+      return axios($, {
+        url: `${this._getBaseUrl()}${path}`,
+        headers: this._getHeaders(),
+        ...opts,
+      });
+    },
+    getApps(opts = {}) {
+      return this._makeRequest({
+        path: "/apps.json",
+        ...opts,
+      });
+    },
+    addRecord(opts = {}) {
+      return this._makeRequest({
+        path: "/record.json",
+        method: "POST",
+        ...opts,
+      });
+    },
+    updateRecord(opts = {}) {
+      return this._makeRequest({
+        path: "/record.json",
+        method: "PUT",
+        ...opts,
+      });
+    },
+    addComment(opts = {}) {
+      return this._makeRequest({
+        path: "/record/comment.json",
+        method: "POST",
+        ...opts,
+      });
+    },
+    getRecords(opts = {}) {
+      return this._makeRequest({
+        path: "/records.json",
+        ...opts,
+      });
+    },
+    async *paginate({
+      fn, params = {}, query = "", maxResults = null, ...opts
+    }) {
+      let hasMore = false;
+      let count = 0;
+      let page = 0;
+      let offset = 0;
+
+      do {
+        offset = page * LIMIT;
+        if (offset >= 10100) return;
+        params.query = `${query} limit ${LIMIT} offset ${offset}`;
+        page++;
+
+        const { records } = await fn({
+          params,
+          ...opts,
+        });
+        for (const d of records) {
+          yield d;
+
+          if (maxResults && ++count === maxResults) {
+            return count;
+          }
+        }
+
+        hasMore = records.length === LIMIT;
+
+      } while (hasMore);
+    },
+  },
+};

package/package.json

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

package/sources/new-record/new-record.mjs

@@ -0,0 +1,76 @@
+import { DEFAULT_POLLING_SOURCE_TIMER_INTERVAL } from "@pipedream/platform";
+import kintone from "../../kintone.app.mjs";
+import sampleEmit from "./test-event.mjs";
+
+export default {
+  key: "kintone-new-record",
+  name: "New Record",
+  description: "Emit new event when a new record is added to a Kintone App. [See the documentation](https://kintone.dev/en/docs/kintone/rest-api/records/get-records/)",
+  version: "0.0.1",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    kintone,
+    db: "$.service.db",
+    timer: {
+      type: "$.interface.timer",
+      default: {
+        intervalSeconds: DEFAULT_POLLING_SOURCE_TIMER_INTERVAL,
+      },
+    },
+    appId: {
+      propDefinition: [
+        kintone,
+        "appId",
+      ],
+    },
+  },
+  methods: {
+    _getLastDate() {
+      return this.db.get("lastDate") || "1970-01-01T00:00:00Z";
+    },
+    _setLastDate(lastDate) {
+      this.db.set("lastDate", lastDate);
+    },
+    async emitEvent(maxResults = false) {
+      const lastDate = this._getLastDate();
+
+      const query = `Created_datetime > "${lastDate}" order by Created_datetime desc`;
+
+      const response = this.kintone.paginate({
+        fn: this.kintone.getRecords,
+        maxResults,
+        query,
+        params: {
+          app: this.appId,
+        },
+      });
+
+      let responseArray = [];
+      for await (const item of response) {
+        responseArray.push(item);
+      }
+
+      if (responseArray.length) {
+        this._setLastDate(responseArray[0].Created_datetime.value);
+      }
+
+      for (const item of responseArray.reverse()) {
+        this.$emit(item, {
+          id: item.$id.value,
+          summary: `New record with ID: ${item.$id.value}`,
+          ts: Date.parse(item.Created_datetime.value),
+        });
+      }
+    },
+  },
+  hooks: {
+    async deploy() {
+      await this.emitEvent(25);
+    },
+  },
+  async run() {
+    await this.emitEvent();
+  },
+  sampleEmit,
+};

package/sources/new-record/test-event.mjs

@@ -0,0 +1,64 @@
+export default {
+  "Last_user": {
+    "type":"MODIFIER",
+    "value": {
+      "code":"test@example.com",
+      "name":"test@example.com"
+    }
+  },
+  "Rich_text": {
+    "type":"RICH_TEXT",
+    "value":""
+  },
+  "Attachment": {
+    "type":"FILE",
+    "value":[]
+  },
+  "$revision": {
+    "type":"__REVISION__",
+    "value":"4"
+  },
+  "Single_line_text": {
+    "type":"SINGLE_LINE_TEXT",
+    "value":"value example"
+  },
+  "Date": {
+    "type":"DATE",
+    "value":"2026-02-19"
+  },
+  "Updated_datetime": {
+    "type":"UPDATED_TIME",
+    "value":"2026-02-19T20:21:00Z"
+  },
+  "Created_datetime": {
+    "type":"CREATED_TIME",
+    "value":"2026-02-19T19:53:00Z"
+  },
+  "Date_and_time": {
+    "type":"DATETIME",
+    "value":""
+  },
+  "Record_number": {
+    "type":"RECORD_NUMBER",
+    "value":"2"
+  },
+  "Author": {
+    "type":"CREATOR",
+    "value": {
+      "code":"test@example.com",
+      "name":"test@example.com"
+    }
+  },
+  "Drop_down": {
+    "type":"DROP_DOWN",
+    "value":"Not started"
+  },
+  "User_selection": {
+    "type":"USER_SELECT",
+    "value":[]
+  },
+  "$id": {
+    "type":"__ID__",
+    "value":"2"
+  }
+};