Provide options for taxonomy elements (terms)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "zapier-cli",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "scripts": {
     "test": "jest",
     "build": "tsc",

src/fields/elements/getItemElementFields.ts

@@ -1,59 +1,92 @@
 import { ZObject } from 'zapier-platform-core';
 import { KontentBundle } from '../../types/kontentBundle';
 import { getContentTypeElements } from './getContentTypeElements';
-import { ContentTypeElements } from '@kontent-ai/management-sdk';
+import { ContentTypeElements, TaxonomyModels } from '@kontent-ai/management-sdk';
 import { Field } from '../field';
+import { getTaxonomyGroup } from '../../utils/taxonomies/getTaxonomyGroup';
 
-export const getItemElementFields = async (z: ZObject, bundle: KontentBundle<{}>, contentTypeId: string) =>
+export const getItemElementFields = (z: ZObject, bundle: KontentBundle<{}>, contentTypeId: string) =>
   getContentTypeElements(z, bundle, contentTypeId)
-    .then(elements => elements.map(getSimpleElementField));
+    .then(async elements => [elements, await getTermsForTaxonomyElements(z, bundle)(elements)] as const)
+    .then(([elements, termsByElementId]) => elements.map(getSimpleElementField(termsByElementId)));
+
+const getTermsForTaxonomyElements = (z: ZObject, bundle: KontentBundle<{}>) =>
+  (elements: readonly ContentTypeElements.ContentTypeElementModel[]) =>
+    Promise.all(elements
+      .filter(el => el.type === "taxonomy")
+      .map(async el => [el.id, await getTaxonomyGroup(z, bundle)((el as ContentTypeElements.ITaxonomyElement).taxonomy_group.id || '')] as const))
+      .then(entries => entries.map(([elId, group]) => [elId, group.terms.flatMap(createTermData)] as const))
+      .then(entries => new Map(entries));
+
+type TermData = Readonly<{
+  id: string;
+  name: string;
+  codename: string;
+}>;
+
+const createTermData = (term: TaxonomyModels.Taxonomy): ReadonlyArray<TermData> => [
+  {
+    id: term.id,
+    name: term.name,
+    codename: term.codename,
+  },
+  ...term.terms.flatMap(createTermData),
+];
 
 export type ElementFields = Readonly<{
   [key: `elements__${string}`]: string | string[] | number | undefined;
 }>;
 
-function getSimpleElementField(element: ContentTypeElements.ContentTypeElementModel) {
-  switch (element.type) {
-    case 'text':
-    case 'rich_text':
-    case 'custom':
-      return getField(element, { type: 'text' });
-
-    case 'number':
-      return getField(element, { type: 'float' });
-
-    case 'date_time':
-      return getField(element, { type: 'datetime' });
-
-    case 'modular_content':
-      const opts = {
-        search: 'find_item.id',
-        list: true,
-        dynamic: 'get_linked_items.id.name',
-        type: 'string',
-        altersDynamicFields: false,
-      } as const;
-
-      return getField(element, opts);
-
-    case 'multiple_choice': {
-      const choices = element.options.map(o => ({ label: o.name, value: o.codename || '', sample: '' }));
-
-      return getField(element, { type: 'unicode', list: element.mode === 'multiple', choices });
+const getSimpleElementField = (termsByElementId: ReadonlyMap<string, readonly TermData[]>) =>
+  (element: ContentTypeElements.ContentTypeElementModel) => {
+    switch (element.type) {
+      case 'text':
+      case 'rich_text':
+      case 'custom':
+        return getField(element, { type: 'text' });
+
+      case 'number':
+        return getField(element, { type: 'float' });
+
+      case 'date_time':
+        return getField(element, { type: 'datetime' });
+
+      case 'modular_content':
+        const opts = {
+          search: 'find_item.id',
+          list: true,
+          dynamic: 'get_linked_items.id.name',
+          type: 'string',
+          altersDynamicFields: false,
+        } as const;
+
+        return getField(element, opts);
+
+      case 'multiple_choice': {
+        const choices = element.options.map(o => ({ label: o.name, value: o.codename || '', sample: '' }));
+
+        return getField(element, { type: 'unicode', list: element.mode === 'multiple', choices });
+      }
+      case 'asset':
+        return getField(element, { type: 'unicode', list: true });
+
+      case 'taxonomy': {
+        const terms = termsByElementId.get(element.id) ?? [];
+        const idChoices = terms.map(t => ({ value: t.id, label: t.name, sample: t.id }));
+        const codenameChoices = terms.map(t => ({ value: t.codename, label: `${t.name} (codename)`, sample: t.codename }));
+
+        return getField(element, { type: 'unicode', choices: [...idChoices, ...codenameChoices], list: true });
+      }
+
+      case 'url_slug':
+        return getField(element, { type: 'unicode' });
+
+      case 'guidelines':
+        return getField(element, { type: 'copy' });
+      default:
+        return undefined;
     }
-    case 'asset':
-    case 'taxonomy':
-      return getField(element, { type: 'unicode', list: true });
-
-    case 'url_slug':
-      return getField(element, { type: 'unicode' });
-
-    case 'guidelines':
-      return getField(element, { type: 'copy' });
-    default:
-      return undefined;
   }
-}
 
 function getField(element: ElementWithoutSnippets, extra?: Partial<Field>) {
   const base = {

src/searches/findLanguage.ts

@@ -80,6 +80,7 @@ export const findLanguage = {
   key: 'find_language',
   operation: {
     perform: execute,
+    outputFields,
     inputFields: [
       ...languageSearchFields,
     ],

src/utils/range.ts

@@ -1,3 +1,3 @@
 export const range = (countOrStart: number, end?: number, step: number = 1) =>
-  [...new Array((end !== undefined ? Math.floor((end - countOrStart) / step) : countOrStart))]
+  [...new Array(end !== undefined ? Math.floor((end - countOrStart) / step) : countOrStart)]
     .map((_, i) => i * step);

src/utils/taxonomies/getTaxonomyGroup.ts

@@ -0,0 +1,10 @@
+import { ZObject } from "zapier-platform-core";
+import { KontentBundle } from "../../types/kontentBundle";
+import { createManagementClient } from "../kontentServices/managementClient";
+
+export const getTaxonomyGroup = (z: ZObject, bundle: KontentBundle<{}>) => (groupId: string) =>
+  createManagementClient(z, bundle)
+    .getTaxonomy()
+    .byTaxonomyId(groupId)
+    .toPromise()
+    .then(res => res.data);