new components

Author: michelle0927

components/imagior/actions/generate-image/generate-image.mjs

@@ -3,31 +3,77 @@ import imagior from "../../imagior.app.mjs";
 export default {
   key: "imagior-generate-image",
   name: "Generate Image",
-  description: "Generates a unique and robust image using a provided template.",
-  version: "0.0.{{ts}}",
+  description: "Generates a unique and robust image using a provided template. [See the documentation](https://docs.imagior.com/api-reference/image-generate)",
+  version: "0.0.1",
   type: "action",
   props: {
     imagior,
-    template_id: {
+    templateId: {
       propDefinition: [
         imagior,
-        "template_id",
+        "templateId",
       ],
-    },
-    image_parameters: {
-      propDefinition: [
-        imagior,
-        "image_parameters",
-      ],
-      optional: true,
+      reloadProps: true,
     },
   },
+  async additionalProps() {
+    const props = {};
+    if (!this.templateId) {
+      return props;
+    }
+    const { elements } = await this.imagior.listTemplateElements({
+      templateId: this.templateId,
+    });
+    for (const [
+      key,
+      value,
+    ] of Object.entries(elements)) {
+      props[`customize_${key}`] = {
+        type: "boolean",
+        label: `Customize ${key}`,
+        optional: true,
+        reloadProps: true,
+      };
+      if (this[`customize_${key}`]) {
+        for (const elementKey of Object.keys(value)) {
+          props[elementKey] = {
+            type: "string",
+            label: `${elementKey}`,
+            optional: true,
+          };
+        }
+      }
+    }
+    return props;
+  },
   async run({ $ }) {
+    const elements = {};
+    const { elements: allElements } = await this.imagior.listTemplateElements({
+      templateId: this.templateId,
+    });
+    for (const [
+      key,
+      value,
+    ] of Object.entries(allElements)) {
+      if (!this[`customize_${key}`]) {
+        continue;
+      }
+      elements[key] = {};
+      for (const elementKey of Object.keys(value)) {
+        if (this[elementKey]) {
+          elements[key][elementKey] = this[elementKey];
+        }
+      }
+    }
+
     const response = await this.imagior.generateImage({
-      template_id: this.template_id,
-      image_parameters: this.image_parameters,
+      $,
+      data: {
+        templateId: this.templateId,
+        elements,
+      },
     });
-    $.export("$summary", "Successfully generated image");
+    $.export("$summary", `${response.message}`);
     return response;
   },
 };

components/imagior/imagior.app.mjs

@@ -4,17 +4,19 @@ export default {
   type: "app",
   app: "imagior",
   propDefinitions: {
-    template_id: {
+    templateId: {
       type: "string",
       label: "Template ID",
-      description: "The unique ID of the design template you created",
-      required: true,
-    },
-    image_parameters: {
-      type: "object",
-      label: "Image Parameters",
-      description: "Optional parameters to customize the appearance of the image",
-      optional: true,
+      description: "The unique ID of the design template to use",
+      async options() {
+        const templates = await this.listTemplates();
+        return templates?.map(({
+          id: value, name: label,
+        }) => ({
+          value,
+          label,
+        })) || [];
+      },
     },
   },
   methods: {
@@ -23,35 +25,37 @@ export default {
     },
     async _makeRequest(opts = {}) {
       const {
-        $ = this, method = "GET", path, headers, ...otherOpts
+        $ = this,
+        path,
+        ...otherOpts
       } = opts;
       return axios($, {
         ...otherOpts,
-        method,
-        url: this._baseUrl() + path,
+        url: `${this._baseUrl()}${path}`,
         headers: {
-          ...headers,
-          Authorization: `Bearer ${this.$auth.oauth_access_token}`,
+          Authorization: `Bearer ${this.$auth.api_key}`,
         },
       });
     },
-    async createTemplate(opts = {}) {
+    listTemplates(opts = {}) {
       return this._makeRequest({
-        method: "POST",
-        path: "/templates",
+        path: "/template/all",
         ...opts,
       });
     },
-    async generateImage({
-      template_id, image_parameters,
+    listTemplateElements({
+      templateId, ...opts
     }) {
+      return this._makeRequest({
+        path: `/template/${templateId}/elements`,
+        ...opts,
+      });
+    },
+    generateImage(opts = {}) {
       return this._makeRequest({
         method: "POST",
         path: "/image/generate",
-        data: {
-          templateId: template_id,
-          elements: image_parameters,
-        },
+        ...opts,
       });
     },
   },

components/imagior/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/imagior",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Pipedream Imagior Components",
   "main": "imagior.app.mjs",
   "keywords": [
@@ -11,5 +11,8 @@
   "author": "Pipedream <[email protected]> (https://pipedream.com/)",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@pipedream/platform": "^3.0.3"
   }
-}
+}

components/imagior/sources/new-template/new-template.mjs

@@ -1,9 +1,10 @@
 import imagior from "../../imagior.app.mjs";
+import { DEFAULT_POLLING_SOURCE_TIMER_INTERVAL } from "@pipedream/platform";
 
 export default {
   key: "imagior-new-template",
   name: "New Template Created",
-  description: "Emits a new event when a new template is created.",
+  description: "Emit new event when a new template is created.",
   version: "0.0.1",
   type: "source",
   dedupe: "unique",
@@ -13,42 +14,46 @@ export default {
     timer: {
       type: "$.interface.timer",
       default: {
-        intervalSeconds: 60 * 15, // 15 minutes
+        intervalSeconds: DEFAULT_POLLING_SOURCE_TIMER_INTERVAL,
       },
     },
   },
   methods: {
-    _getPrevTemplateId() {
-      return this.db.get("prevTemplateId");
+    _getLastTs() {
+      return this.db.get("lastTs") || 0;
     },
-    _setPrevTemplateId(id) {
-      this.db.set("prevTemplateId", id);
+    _setLastTs(lastTs) {
+      this.db.set("lastTs", lastTs);
+    },
+    generateMeta(template) {
+      return {
+        id: template.id,
+        summary: `New Template: ${template.name}`,
+        ts: Date.parse(template.createdAt),
+      };
     },
   },
   async run() {
-    const { elements: templates } = await this.imagior._makeRequest({
-      path: "/templates/all",
+    const lastTs = this._getLastTs();
+
+    const templates = await this.imagior.listTemplates({
+      params: {
+        sort: "createdAt",
+        order: "desc",
+      },
     });
 
-    if (!templates.length) {
-      console.log("No templates found");
+    if (!templates?.length) {
       return;
     }
 
-    const sortedTemplates = templates.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
-    const latestTemplate = sortedTemplates[0];
-    const prevTemplateId = this._getPrevTemplateId();
+    const newTemplates = templates.filter(({ createdAt }) => Date.parse(createdAt) >= lastTs);
 
-    if (prevTemplateId && latestTemplate.id === prevTemplateId) {
-      console.log("No new templates found");
-      return;
-    }
+    this._setLastTs(Date.parse(newTemplates[0].createdAt));
 
-    this._setPrevTemplateId(latestTemplate.id);
-    this.$emit(latestTemplate, {
-      id: latestTemplate.id,
-      summary: `New template: ${latestTemplate.name}`,
-      ts: Date.parse(latestTemplate.createdAt),
+    newTemplates.forEach((template) => {
+      const meta = this.generateMeta(template);
+      this.$emit(template, meta);
     });
   },
 };