new components

Author: michelle0927

components/attio/actions/create-note/create-note.mjs

@@ -4,7 +4,7 @@ export default {
   key: "attio-create-note",
   name: "Create Note",
   description: "Creates a new note for a given record. The note will be linked to the specified record. [See the documentation](https://developers.attio.com/reference/post_v2-notes)",
-  version: "0.0.{{ts}}",
+  version: "0.0.1",
   type: "action",
   props: {
     attio,

components/attio/actions/create-update-record/create-update-record.mjs

@@ -1,10 +1,11 @@
 import attio from "../../attio.app.mjs";
+import utils from "../../common/utils.mjs";
 
 export default {
   key: "attio-create-update-record",
   name: "Create or Update Record",
   description: "Creates or updates a specific record such as a person or a deal. If the record already exists, it's updated. Otherwise, a new record is created. [See the documentation](https://developers.attio.com/reference/put_v2-objects-object-records)",
-  version: "0.0.{{ts}}",
+  version: "0.0.1",
   type: "action",
   props: {
     attio,
@@ -14,21 +15,70 @@ export default {
         "objectId",
       ],
     },
-    parentRecordId: {
+    attributeId: {
       propDefinition: [
         attio,
-        "recordId",
+        "attributeId",
         (c) => ({
           objectId: c.objectId,
         }),
       ],
+      reloadProps: true,
+    },
+  },
+  async additionalProps() {
+    const props = {};
+    if (!this.attributeId) {
+      return props;
+    }
+    const attributes = await this.getRelevantAttributes();
+    for (const attribute of attributes) {
+      props[attribute.id.attribute_id] = {
+        type: attribute.is_multiselect
+          ? "string[]"
+          : "string",
+        label: attribute.title,
+        optional: attribute.id.attribute_id !== this.attributeId && !attribute.is_required,
+      };
+    }
+    return props;
+  },
+  methods: {
+    async getRelevantAttributes() {
+      const stream = utils.paginate({
+        fn: this.attio.listAttributes,
+        args: {
+          objectId: this.objectId,
+        },
+      });
+      const attributes = await utils.streamIterator(stream);
+      return attributes.filter((a) => a.is_writable || a.id.attribute_id === this.attributeId);
     },
   },
   async run({ $ }) {
-    const response = await this.upsertRecord({
+    const {
+      attio,
+      getRelevantAttributes,
+      objectId,
+      attributeId,
+      ...values
+    } = this;
+
+    const attributes = await getRelevantAttributes();
+
+    const response = await attio.upsertRecord({
       $,
-      data: {},
+      objectId,
+      params: {
+        matching_attribute: attributeId,
+      },
+      data: {
+        data: {
+          values: utils.parseValues(attributes, values),
+        },
+      },
     });
+    $.export("$summary", "Successfully created or updated record");
     return response;
   },
 };

components/attio/actions/delete-list-entry/delete-list-entry.mjs

@@ -4,7 +4,7 @@ export default {
   key: "attio-delete-list-entry",
   name: "Delete List Entry",
   description: "Deletes an existing entry from a specific list. [See the documentation](https://developers.attio.com/reference/delete_v2-lists-list-entries-entry-id)",
-  version: "0.0.{{ts}}",
+  version: "0.0.1",
   type: "action",
   props: {
     attio,

components/attio/attio.app.mjs

@@ -67,6 +67,30 @@ export default {
         return data?.map(({ id }) => id.record_id) || [];
       },
     },
+    attributeId: {
+      type: "string",
+      label: "Attribute ID",
+      description: "The ID or slug of the attribute to use to check if a record already exists. The attribute must be unique.",
+      async options({
+        objectId, page,
+      }) {
+        const { data } = await this.listAttributes({
+          objectId,
+          params: {
+            limit: DEFAULT_LIMIT,
+            offset: page * DEFAULT_LIMIT,
+          },
+        });
+        return data
+          ?.filter((attribute) => attribute.is_unique)
+          ?.map(({
+            id, title: label,
+          }) => ({
+            value: id.attribute_id,
+            label,
+          })) || [];
+      },
+    },
   },
   methods: {
     _baseUrl() {
@@ -85,6 +109,22 @@ export default {
         ...opts,
       });
     },
+    createWebhook(opts = {}) {
+      return this._makeRequest({
+        method: "POST",
+        path: "/webhooks",
+        ...opts,
+      });
+    },
+    deleteWebhook({
+      hookId, ...opts
+    }) {
+      return this._makeRequest({
+        method: "DELETE",
+        path: `/webhooks/${hookId}`,
+        ...opts,
+      });
+    },
     listLists(opts = {}) {
       return this._makeRequest({
         path: "/lists",
@@ -115,6 +155,14 @@ export default {
         ...opts,
       });
     },
+    listAttributes({
+      objectId, ...opts
+    }) {
+      return this._makeRequest({
+        path: `/objects/${objectId}/attributes`,
+        ...opts,
+      });
+    },
     createNote(opts = {}) {
       return this._makeRequest({
         method: "POST",
@@ -123,11 +171,11 @@ export default {
       });
     },
     upsertRecord({
-      objectType, ...opts
+      objectId, ...opts
     }) {
       return this._makeRequest({
         method: "PUT",
-        path: `/objects/${objectType}/records`,
+        path: `/objects/${objectId}/records`,
         ...opts,
       });
     },

components/attio/common/utils.mjs

@@ -0,0 +1,62 @@
+async function streamIterator(stream) {
+  let resources = [];
+  for await (const resource of stream) {
+    resources.push(resource);
+  }
+  return resources;
+}
+
+async function *paginate({
+  fn,
+  args,
+  max,
+}) {
+  args = {
+    ...args,
+    params: {
+      ...args.params,
+      limit: 500,
+      offset: 0,
+    },
+  };
+  let total, count = 0;
+  do {
+    const { data } = await fn(args);
+    for (const item of data) {
+      yield item;
+      if (max && ++count >= max) {
+        return;
+      }
+    }
+    total = data?.length;
+    args.params.offset += args.params.limit;
+  } while (total === args.params.limit);
+}
+
+function parseValues(attributes, values) { console.log(attributes);
+  for (const [
+    key,
+    value,
+  ] of Object.entries(values)) {
+    const {
+      type, is_multiselect: isMultiselect,
+    } = attributes.find(({ id }) => id.attribute_id === key);
+    if (type === "checkbox") {
+      values[key] = isMultiselect
+        ? value.map((v) => !(v === "false" || v === "0"))
+        : !(value === "false" || value === "0");
+    }
+    if (type === "number" || type === "rating") {
+      values[key] = isMultiselect
+        ? value.map((v) => +v)
+        : +value;
+    }
+  }
+  return values;
+}
+
+export default {
+  streamIterator,
+  paginate,
+  parseValues,
+};

components/attio/sources/common/base.mjs

@@ -0,0 +1,62 @@
+import attio from "../../attio.app.mjs";
+
+export default {
+  props: {
+    attio,
+    db: "$.service.db",
+    http: "$.interface.http",
+  },
+  hooks: {
+    async activate() {
+      const { data: { id: { webhook_id: hookId } } } = await this.attio.createWebhook({
+        data: {
+          data: {
+            target_url: this.http.endpoint,
+            subscriptions: [
+              {
+                event_type: this.getEventType(),
+                filter: this.getFilter(),
+              },
+            ],
+          },
+        },
+      });
+      this._setHookId(hookId);
+    },
+    async deactivate() {
+      const hookId = this._getHookId();
+      if (hookId) {
+        await this.attio.deleteWebhook({
+          hookId,
+        });
+      }
+    },
+  },
+  methods: {
+    _getHookId() {
+      return this.db.get("hookId");
+    },
+    _setHookId(hookId) {
+      this.db.set("hookId", hookId);
+    },
+    getFilter() {
+      return null;
+    },
+    getEventType() {
+      throw new Error("getEventType is not implemented");
+    },
+    generateMeta() {
+      throw new Error("generateMeta is not implemented");
+    },
+  },
+  async run(event) {
+    const { body: { events } } = event;
+    if (!events?.length) {
+      return;
+    }
+    events.forEach((item) => {
+      const meta = this.generateMeta(item);
+      this.$emit(item, meta);
+    });
+  },
+};

components/attio/sources/new-list-entry-instant/new-list-entry-instant.mjs

@@ -0,0 +1,46 @@
+import common from "../common/base.mjs";
+import sampleEmit from "./test-event";
+
+export default {
+  ...common,
+  key: "attio-new-list-entry-instant",
+  name: "New List Entry (Instant)",
+  description: "Emit new event when a record, such as person, company, or deal, is added to a list",
+  version: "0.0.1",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    ...common.props,
+    listId: {
+      propDefinition: [
+        common.props.attio,
+        "listId",
+      ],
+    },
+  },
+  methods: {
+    ...common.methods,
+    getEventType() {
+      return "list-entry.created";
+    },
+    getFilter() {
+      return {
+        "$and": [
+          {
+            field: "id.list_id",
+            operator: "equals",
+            value: this.listId,
+          },
+        ],
+      };
+    },
+    generateMeta(entry) {
+      return {
+        id: entry.id.entry_id,
+        summary: `New Entry with ID: ${entry.id.entry_id}`,
+        ts: Date.now(),
+      };
+    },
+  },
+  sampleEmit,
+};

components/attio/sources/new-list-entry-instant/test-event.mjs

@@ -0,0 +1,14 @@
+export default {
+  "event_type": "list-entry.created",
+  "id": {
+    "workspace_id": "14beef7a-99f7-4534-a87e-70b564330a4c",
+    "list_id": "33ebdbe9-e529-47c9-b894-0ba25e9c15c0",
+    "entry_id": "2e6e29ea-c4e0-4f44-842d-78a891f8c156"
+  },
+  "parent_object_id": "97052eb9-e65e-443f-a297-f2d9a4a7f795",
+  "parent_record_id": "bf071e1f-6035-429d-b874-d83ea64ea13b",
+  "actor": {
+    "type": "workspace-member",
+    "id": "50cf242c-7fa3-4cad-87d0-75b1af71c57b"
+  }
+}