Devrel 1074 import taxonomies

src/commands/export.ts

@@ -16,7 +16,7 @@ import { languageVariantsExportEntity } from "./importExportEntities/entities/la
 import { previewUrlsExportEntity } from "./importExportEntities/entities/previewUrls.js";
 import { rolesExportEntity } from "./importExportEntities/entities/roles.js";
 import { spacesExportEntity } from "./importExportEntities/entities/spaces.js";
-import { taxonomiesExportEntity } from "./importExportEntities/entities/taxonomies.js";
+import { taxonomiesEntity } from "./importExportEntities/entities/taxonomies.js";
 import { workflowsExportEntity } from "./importExportEntities/entities/workflows.js";
 import { EntityDefinition } from "./importExportEntities/entityDefinition.js";
 
@@ -50,7 +50,7 @@ export const register: RegisterCommand = yargs => yargs.command({
 const entityDefinitions: ReadonlyArray<EntityDefinition<any>> = [
   collectionsEntity,
   spacesExportEntity,
-  taxonomiesExportEntity,
+  taxonomiesEntity,
   languagesEntity,
   previewUrlsExportEntity,
   rolesExportEntity,

src/commands/import.ts

@@ -6,6 +6,7 @@ import { RegisterCommand } from "../types/yargs.js";
 import { serially } from "../utils/requests.js";
 import { collectionsEntity } from "./importExportEntities/entities/collections.js";
 import { languagesEntity } from "./importExportEntities/entities/languages.js";
+import { taxonomiesEntity } from "./importExportEntities/entities/taxonomies.js";
 import { EntityDefinition, ImportContext } from "./importExportEntities/entityDefinition.js";
 
 export const register: RegisterCommand = yargs => yargs.command({
@@ -34,7 +35,8 @@ export const register: RegisterCommand = yargs => yargs.command({
 // Keep in mind that there are dependencies between entities so the order is important.
 const entityDefinitions: ReadonlyArray<EntityDefinition<any>> = [
   collectionsEntity,
-  languagesEntity
+  languagesEntity,
+  taxonomiesEntity,
 ];
 
 type ImportEntitiesParams = Readonly<{
@@ -55,7 +57,9 @@ const importEntities = async (params: ImportEntitiesParams) => {
 
   let context: ImportContext = {
     collectionIdsByOldIds: new Map(),
-    languageIdsByOldIds: new Map()
+    languageIdsByOldIds: new Map(),
+    taxonomyGroupIdsByOldIds: new Map(),
+    taxonomyTermIdsByOldIds: new Map(),
   };
 
   await serially(entityDefinitions.map(def => async () => {
@@ -69,12 +73,12 @@ const importEntities = async (params: ImportEntitiesParams) => {
         ?? context;
 
       console.log(`${def.name} imported`);
-
-      console.log(`All entities were successfully imported into environment ${params.environmentId}.`);
     }
     catch (err) {
       console.error(`Failed to import entity ${def.name} due to error ${JSON.stringify(err)}. Stopping import...`);
       process.exit(1);
     }
   }));
+
+  console.log(`All entities were successfully imported into environment ${params.environmentId}.`);
 };

src/commands/importExportEntities/entities/taxonomies.ts

@@ -1,11 +1,39 @@
 import { TaxonomyContracts } from "@kontent-ai/management-sdk";
 
+import { zip } from "../../../utils/array.js";
+import { serially } from "../../../utils/requests.js";
 import { EntityDefinition } from "../entityDefinition.js";
 
-export const taxonomiesExportEntity: EntityDefinition<ReadonlyArray<TaxonomyContracts.ITaxonomyContract>> = {
+export const taxonomiesEntity: EntityDefinition<ReadonlyArray<TaxonomyContracts.ITaxonomyContract>> = {
   name: "taxonomies",
   fetchEntities: client => client.listTaxonomies().toAllPromise().then(res => res.data.items.map(t => t._raw)),
   serializeEntities: taxonomies => JSON.stringify(taxonomies),
-  importEntities: () => { throw new Error("Not supported yet.")},
-  deserializeEntities: () => { throw new Error("Not supported yet.")},
+  importEntities: async (client, fileTaxonomies, context) => {
+    const projectTaxonomies = await serially<ReadonlyArray<() => Promise<TaxonomyContracts.ITaxonomyContract>>>(
+      fileTaxonomies.map(taxonomy => () =>
+        client
+          .addTaxonomy()
+          .withData(addExternalIds(taxonomy))
+          .toPromise()
+          .then(res => res.data._raw))
+    );
+
+    return {
+      ...context,
+      taxonomyGroupIdsByOldIds: new Map(zip(fileTaxonomies.map(t => t.id), projectTaxonomies.map(t => t.id))),
+      taxonomyTermIdsByOldIds: new Map(zip(fileTaxonomies.flatMap(t => t.terms), projectTaxonomies.flatMap(t => t.terms)).flatMap(extractTermIdsEntries)),
+    };
+  },
+  deserializeEntities: JSON.parse,
 };
+
+const addExternalIds = (taxonomy: TaxonomyContracts.ITaxonomyContract): TaxonomyContracts.ITaxonomyContract => ({
+  ...taxonomy,
+  external_id: taxonomy.external_id ?? taxonomy.codename,
+  terms: taxonomy.terms.map(addExternalIds),
+});
+
+const extractTermIdsEntries = ([fileTaxonomy, projectTaxonomy]: readonly [TaxonomyContracts.ITaxonomyContract, TaxonomyContracts.ITaxonomyContract]): ReadonlyArray<readonly [string, string]> => [
+  [fileTaxonomy.id, projectTaxonomy.id] as const,
+  ...zip(fileTaxonomy.terms, projectTaxonomy.terms).flatMap(extractTermIdsEntries),
+];

src/commands/importExportEntities/entityDefinition.ts

@@ -13,4 +13,8 @@ export type EntityDefinition<T> = Readonly<{
 export type ImportContext = Readonly<{
   collectionIdsByOldIds: ReadonlyMap<string, string>;
   languageIdsByOldIds: ReadonlyMap<string, string>;
+  taxonomyGroupIdsByOldIds: IdsMap;
+  taxonomyTermIdsByOldIds: IdsMap;
 }>;
+
+type IdsMap = ReadonlyMap<string, string>;

src/utils/array.ts

@@ -0,0 +1,29 @@
+export const zip = <T1 extends ReadonlyArray<any>, T2 extends ReadonlyArray<any>>(arr1: T1, arr2: T2): Zip<T1, T2> =>
+  arr1
+    .slice(0, Math.min(arr1.length, arr2.length))
+    .map((el1, i) => [el1, arr2[i]] as const) as unknown as Zip<T1, T2>;
+
+type Zip<T1 extends ReadonlyArray<any>, T2 extends ReadonlyArray<any>> =
+  true extends IsEmptyTuple<T1> | IsEmptyTuple<T2>
+    ? readonly []
+    : [IsNonEmptyTuple<T1>, IsNonEmptyTuple<T2>] extends [true, true]
+      ? ZipTuples<T1, T2>
+      : ZipArrays<T1, T2>;
+
+type IsEmptyTuple<T extends ReadonlyArray<any>> = T extends readonly [] ? true : false;
+
+type IsNonEmptyTuple<T extends ReadonlyArray<any>> = T extends readonly [any, ...ReadonlyArray<any>] ? true : false;
+
+/**
+ * Handles zip of two types where at least one is an array of unknown length.
+*/
+type ZipArrays<T1 extends ReadonlyArray<any>, T2 extends ReadonlyArray<any>> = ReadonlyArray<readonly [T1[number], T2[number]]>;
+
+/**
+ * Handles zip of two tuples (arrays of known length and exact types for different positions).
+ * This type expects two tuples and doesn't work well with arrays of unknown length.
+*/
+type ZipTuples<T1 extends ReadonlyArray<any>, T2 extends ReadonlyArray<any>, Accum extends ReadonlyArray<readonly [any, any]> = readonly []> =
+  [T1, T2] extends [readonly [infer First1, ...infer Rest1 extends ReadonlyArray<any>], readonly [infer First2, ...infer Rest2 extends ReadonlyArray<any>]]
+    ? ZipTuples<Rest1, Rest2, readonly [...Accum, readonly [First1, First2]]>
+    : Accum;