@pipedream/kintone 0.0.3 → 0.1.0

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

@@ -1,11 +1,135 @@
+import { axios } from "@pipedream/platform";
+import { LIMIT } from "./common/constants.mjs";
+
 export default {
   type: "app",
   app: "kintone",
-  propDefinitions: {},
+  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: {
-    // this.$auth contains connected account data
-    authKeys() {
-      console.log(Object.keys(this.$auth));
+    _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,6 +1,6 @@
 {
   "name": "@pipedream/kintone",
-  "version": "0.0.3",
+  "version": "0.1.0",
   "description": "Pipedream Kintone Components",
   "main": "kintone.app.mjs",
   "keywords": [
@@ -11,5 +11,8 @@
   "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"
+  }
+};