@translationstudio/translationstudio-strapi-extension 1.1.3 → 2.0.1

package/dist/server/index.mjs

@@ -1,3 +1,4 @@
+import * as crypto from "crypto";
 const bootstrap = ({ strapi: strapi2 }) => {
 };
 const destroy = ({ strapi: strapi2 }) => {
@@ -75,10 +76,15 @@ const controller = ({ strapi: strapi2 }) => ({
       ctx.status = 400;
       return;
     }
-    const payload = JSON.parse(ctx.request.body);
-    const result = await strapi2.plugin(APP_NAME$1).service("service").exportData(payload);
-    ctx.status = 200;
-    ctx.body = [{ fields: result }];
+    try {
+      const payload = typeof ctx.request.body === "string" ? JSON.parse(ctx.request.body) : ctx.request.body;
+      const result = await strapi2.plugin(APP_NAME$1).service("service").exportData(payload);
+      ctx.status = 200;
+      ctx.body = [{ fields: result }];
+    } catch (ex) {
+      ctx.status = 500;
+      ctx.body = { error: ex.message ?? "Generic error" };
+    }
   },
   async setDevelopmentUrl(ctx) {
     const url = ctx.request.body.url;
@@ -106,23 +112,36 @@ const controller = ({ strapi: strapi2 }) => ({
       ctx.status = 400;
       return;
     }
-    const payload = JSON.parse(ctx.request.body);
-    const result = await strapi2.plugin(APP_NAME$1).service("service").importData(payload);
-    ctx.body = result;
+    try {
+      const payload = typeof ctx.request.body === "object" ? ctx.request.body : JSON.parse(ctx.request.body);
+      strapi2.log.info("Importing");
+      const result = await strapi2.plugin(APP_NAME$1).service("service").importData(payload);
+      ctx.body = { success: result };
+      ctx.status = 200;
+      return;
+    } catch (err) {
+      strapi2.log.error(err.message ?? err);
+    }
+    ctx.body = { message: "Could not perform import" };
+    ctx.status = 500;
   },
   async ping(ctx) {
-    const result = await strapi2.plugin(APP_NAME$1).service("service").ping();
+    await strapi2.plugin(APP_NAME$1).service("service").ping();
     ctx.status = 204;
-    ctx.body = result;
   },
   async getLanguages(ctx) {
     if (!await this.validateToken(ctx)) {
       ctx.status = 400;
       return;
     }
-    const result = await strapi2.plugin(APP_NAME$1).service("service").getLanguages();
-    ctx.status = 200;
-    ctx.body = result;
+    try {
+      const result = await strapi2.plugin(APP_NAME$1).service("service").getLanguages();
+      ctx.status = 200;
+      ctx.body = result;
+    } catch (err) {
+      ctx.status = 400;
+      ctx.body = {};
+    }
   },
   async getEmail(ctx) {
     const result = await strapi2.plugin(APP_NAME$1).service("service").getEmail(ctx);
@@ -256,6 +275,7 @@ const routes = [
       policies: []
     }
   },
+  /* get entry title */
   {
     method: "POST",
     path: "/entrydata",
@@ -265,13 +285,33 @@ const routes = [
     }
   }
 ];
-const getContentType = async (contentTypeID) => {
-  const contentType = await strapi.contentType(contentTypeID);
+function getComponentSchemata(schema) {
+  const res = {};
+  for (let fieldName in schema.attributes) {
+    const field = schema.attributes[fieldName];
+    if (!field.components || !Array.isArray(field.components) || field.components.length === 0)
+      continue;
+    for (let type of field.components) {
+      const schema2 = strapi.components[type];
+      if (schema2 && schema2.attributes)
+        res[type] = schema2;
+    }
+  }
+  return res;
+}
+function getContentType(contentTypeID) {
+  const contentType = strapi.contentType(contentTypeID);
   if (!contentType?.attributes) {
-    throw new Error(`Content type or schema not found: ${contentTypeID}`);
+    strapi.log.error(`Content type or schema not found: ${contentTypeID}`);
+    return null;
   }
-  return contentType;
-};
+  const res = {
+    entry: contentType,
+    components: getComponentSchemata(contentType)
+  };
+  strapi.log.info("SChema loaded for " + contentTypeID + ". Component schemata loaded: " + Object.keys(res.components).length);
+  return res;
+}
 const parsePayload = (payload) => {
   const [contentTypeID, entryID] = payload.element.includes("#") ? payload.element.split("#") : [payload.element, void 0];
   const locale = payload.source.includes("-") ? payload.source.split("-")[0] : payload.source;
@@ -281,7 +321,7 @@ const getComponentSchema = async (componentName) => {
   try {
     return await strapi.components[componentName];
   } catch (error) {
-    console.error(`Failed to get component schema for ${componentName}:`, error);
+    strapi.log.error(`Failed to get component schema for ${componentName}:`, error);
     return null;
   }
 };
@@ -304,27 +344,32 @@ const buildPopulateConfig = async (schema) => {
   }
   return populate;
 };
-const getEntry = async (contentTypeID, entryID, locale) => {
+const getEntry = async (contentTypeID, entryID, locale, logError = true) => {
   try {
     const contentType = await strapi.contentTypes[contentTypeID];
     const populateConfig = await buildPopulateConfig(contentType);
     const query = {
       locale,
+      documentId: entryID,
       populate: populateConfig
     };
-    if (entryID) {
-      Object.assign(query, { documentId: entryID });
-    }
     const entry = await strapi.documents(contentTypeID).findFirst(query);
-    return entry;
+    if (entry) {
+      strapi.log.info("Obtained " + contentTypeID + "::" + entryID + " in " + locale);
+      return entry;
+    }
   } catch (error) {
-    console.error("Entry fetch error:", error);
-    return null;
+    strapi.log.error(error.message ?? error);
   }
+  strapi.log.warn("Could not find entry " + entryID + " in locale " + locale);
+  return null;
+};
+const transformResponse = function(data) {
+  data.fields = data.fields.map(
+    (item) => item.realType === "blocks" && Array.isArray(item.translatableValue[0]) ? { ...item, translatableValue: item.translatableValue[0] } : item
+  );
+  return data;
 };
-const transformResponse = (data) => data.map(
-  (item) => item.realType === "blocks" && Array.isArray(item.translatableValue[0]) ? { ...item, translatableValue: item.translatableValue[0] } : item
-);
 function jsonToHtml(json) {
   if (!json || !Array.isArray(json)) {
     return "";
@@ -373,43 +418,37 @@ function formatText(child) {
   }
   return text;
 }
-const processComponent = async (fieldName, componentName, value, schemaName, componentId) => {
+const Logger$4 = {
+  log: typeof strapi !== "undefined" ? strapi.log : console,
+  info: (val) => Logger$4.log.info(val),
+  warn: (val) => Logger$4.log.warn(val),
+  error: (val) => Logger$4.log.error(val),
+  debug: (val) => Logger$4.log.debug(val)
+};
+async function processComponent(fieldName, value, componentSchema, schemata) {
   const contentFields = [];
-  const componentSchema = await strapi.components[componentName];
-  if (!componentSchema) {
-    throw new Error(`Component schema not found for ${componentName}`);
-  }
+  Logger$4.info("Processing dynamic field " + fieldName);
+  if (!componentSchema || !componentSchema.attributes)
+    return [];
   const schemaAttributes = componentSchema.attributes || {};
   const dataToProcess = value || {};
-  if (Array.isArray(dataToProcess)) {
-    for (const item of dataToProcess) {
-      const processedFields = await processComponentFields$1(
-        item,
-        schemaAttributes,
-        fieldName,
-        componentName,
-        schemaName,
-        item.id
-      );
-      contentFields.push(...processedFields);
-    }
-  } else {
-    const processedFields = await processComponentFields$1(
-      dataToProcess,
+  const candidates = Array.isArray(dataToProcess) ? dataToProcess : [dataToProcess];
+  for (const item of candidates) {
+    const processedFields = await processComponentFields(
+      item,
       schemaAttributes,
       fieldName,
-      componentName,
-      schemaName,
-      componentId
+      schemata
     );
-    contentFields.push(...processedFields);
+    if (processedFields.length > 0)
+      contentFields.push(...processedFields);
   }
   return contentFields;
-};
+}
 const shouldSkipField$1 = (key, fieldSchema) => {
   return key === "id" || fieldSchema.private;
 };
-const isTranslatableField$1 = (type) => {
+const isTranslatableField = (type) => {
   return ["string", "text", "blocks", "richtext"].includes(type);
 };
 const getTranslatedValue = (type, value) => {
@@ -418,64 +457,61 @@ const getTranslatedValue = (type, value) => {
   }
   return value.toString();
 };
-const buildTranslatable = (key, fieldSchema, value, parentPath, componentId, schemaName) => {
+const buildTranslatable = (key, fieldSchema, value, uuid = "") => {
   return {
     field: key,
     type: ["richtext", "blocks"].includes(fieldSchema.type) ? "html" : "text",
     translatableValue: [value],
     realType: fieldSchema.type,
-    componentInfo: {
-      namePath: parentPath,
-      id: componentId,
-      schemaName
-    }
+    uuid
   };
 };
-const processComponentFields$1 = async (componentData, schema, parentField, componentName, schemaName, componentId) => {
+const processComponentFields = async (componentData, schema, parentField, schemata) => {
   const contentFields = [];
-  const parentPath = parentField.split(".");
+  const uuid = crypto.randomUUID();
   for (const [key, fieldSchema] of Object.entries(schema)) {
     if (shouldSkipField$1(key, fieldSchema)) continue;
     const value = componentData?.[key];
-    const fieldPath = `${parentField}.${key}`;
+    if (!value)
+      continue;
     if (fieldSchema.type === "component") {
-      if (!fieldSchema.component) continue;
+      if (!value.__component)
+        continue;
+      const targetSchema = schemata[value.__component];
+      if (!targetSchema)
+        continue;
       const nestedFields = await processComponent(
-        fieldPath,
-        fieldSchema.component,
-        value || {},
-        fieldSchema.component,
-        value?.id
+        `${parentField}.${key}`,
+        value,
+        targetSchema,
+        schemata
       );
-      contentFields.push(...nestedFields);
+      if (nestedFields.length > 0)
+        contentFields.push(...nestedFields);
       continue;
     }
-    if (!isTranslatableField$1(fieldSchema.type)) continue;
+    if (!isTranslatableField(fieldSchema.type)) continue;
     if (value === null || value === void 0 || value === "") continue;
     const translatedValue = getTranslatedValue(fieldSchema.type, value);
     const translatable = buildTranslatable(
       key,
       fieldSchema,
       translatedValue,
-      parentPath,
-      componentId,
-      schemaName
+      uuid
     );
+    componentData.__tsuid = uuid;
     contentFields.push(translatable);
   }
   return contentFields;
 };
-const isFieldLocalizable = (fieldSchema, parentSchema) => {
-  if (fieldSchema.pluginOptions?.i18n?.localized !== void 0) {
-    return fieldSchema.pluginOptions.i18n.localized;
-  }
-  if (parentSchema.pluginOptions?.i18n?.localized === true) {
-    const localizableTypes = ["string", "text", "blocks", "richtext"];
-    return localizableTypes.includes(fieldSchema.type);
-  }
-  return false;
+const Logger$3 = {
+  log: typeof strapi !== "undefined" ? strapi.log : console,
+  info: (val) => Logger$3.log.info(val),
+  warn: (val) => Logger$3.log.warn(val),
+  error: (val) => Logger$3.log.error(val),
+  debug: (val) => Logger$3.log.debug(val)
 };
-const DEFAULT_FIELDS = /* @__PURE__ */ new Set([
+const DEFAULT_FIELDS$1 = /* @__PURE__ */ new Set([
   "id",
   "documentId",
   "createdAt",
@@ -487,45 +523,41 @@ const DEFAULT_FIELDS = /* @__PURE__ */ new Set([
   "createdBy"
 ]);
 const isEmpty = (value) => value === null || value === void 0 || value === "";
-const isTranslatableField = (fieldSchema) => ["string", "text", "blocks", "richtext"].includes(fieldSchema.type) && fieldSchema.pluginOptions?.i18n?.localized !== false;
-const processDynamicZone = async (key, value, schema) => {
+const isSimpleTranslatableField = (fieldSchema) => ["string", "text", "blocks", "richtext"].includes(fieldSchema.type) && fieldSchema.pluginOptions?.i18n?.localized === true;
+const processDynamicZone = async (key, value, schemata) => {
   const results = [];
   for (const component of value) {
     const componentName = component?.__component;
     if (!componentName) continue;
+    const schema = schemata[componentName];
+    if (!schema) continue;
     const fields = await processComponent(
       key,
-      componentName,
       component,
-      componentName,
-      component.id
+      schema,
+      schemata
     );
-    results.push(...fields);
+    if (fields.length > 0)
+      results.push(...fields);
   }
   return results;
 };
-const processComponentField = async (key, value, fieldSchema) => {
+const processComponentField = async (key, value, fieldSchema, schemata) => {
   const results = [];
-  if (fieldSchema.repeatable && Array.isArray(value)) {
-    for (const component of value) {
-      const fields = await processComponent(
-        key,
-        fieldSchema.component,
-        component,
-        fieldSchema.component,
-        component.id
-      );
-      results.push(...fields);
-    }
-  } else {
+  const candidates = Array.isArray(value) ? value : [value];
+  for (const component of candidates) {
+    const componentName = component?.__component;
+    if (!componentName) continue;
+    const schema = schemata[componentName];
+    if (!schema) continue;
     const fields = await processComponent(
       key,
-      fieldSchema.component,
-      value,
-      fieldSchema.component,
-      value.id
+      component,
+      schema,
+      schemata
     );
-    results.push(...fields);
+    if (fields.length > 0)
+      results.push(...fields);
   }
   return results;
 };
@@ -538,38 +570,148 @@ const processRegularField = (key, value, fieldSchema) => {
     realType: fieldSchema.type
   };
 };
-const processEntryFields = async (entry, schema, locale) => {
+function IsLocalisableSchema(schema) {
+  return schema.pluginOptions?.i18n?.localized === true;
+}
+function IsLocalisedField(field) {
+  return field.pluginOptions?.i18n?.localized === true;
+}
+const processEntryFields = async (entry, schemaData, _locale) => {
   const contentFields = [];
+  const staticContent = {};
+  const schema = schemaData.entry.attributes;
   for (const [key, value] of Object.entries(entry)) {
-    if (shouldSkipField(key, value)) continue;
-    const fieldSchema = schema[key];
-    if (!fieldSchema) continue;
-    if (isDynamicZone(fieldSchema, value, schema)) {
-      const zoneFields = await processDynamicZone(key, value);
-      contentFields.push(...zoneFields);
+    if (shouldSkipField(key, value))
       continue;
-    }
-    if (isComponent(fieldSchema, value, schema)) {
-      const componentFields = await processComponentField(key, value, fieldSchema);
-      contentFields.push(...componentFields);
+    const fieldSchema = schema[key];
+    if (!fieldSchema || !IsLocalisedField(fieldSchema)) {
+      Logger$3.debug("SKipping non-local field " + key);
       continue;
     }
-    if (isTranslatableField(fieldSchema)) {
+    if (isSimpleTranslatableField(fieldSchema)) {
+      Logger$3.debug("Processing simple field " + key);
       const translatedField = processRegularField(key, value, fieldSchema);
       contentFields.push(translatedField);
+      continue;
+    }
+    const zoneInfo = isDynamicZone(fieldSchema, value);
+    if (zoneInfo.isZone) {
+      if (zoneInfo.hasContent) {
+        Logger$3.debug("Processing dynamic zone field " + key);
+        const zoneFields = await processDynamicZone(key, value, schemaData.components);
+        contentFields.push(...zoneFields);
+        staticContent[key] = value;
+      }
+      continue;
+    }
+    const componentInfo = isComponent(fieldSchema);
+    if (componentInfo.isZone) {
+      const componentFields = await processComponentField(key, value, fieldSchema, schemaData.components);
+      contentFields.push(...componentFields);
+      staticContent[key] = value;
     }
   }
-  return contentFields;
+  Logger$3.info("Process completed");
+  return {
+    fields: contentFields,
+    keep: staticContent
+  };
 };
 const shouldSkipField = (key, value) => {
-  return DEFAULT_FIELDS.has(key) || isEmpty(value);
+  return DEFAULT_FIELDS$1.has(key) || isEmpty(value);
+};
+const isDynamicZone = (fieldSchema, value) => {
+  return {
+    isZone: fieldSchema.type === "dynamiczone",
+    hasContent: Array.isArray(value) && value.length > 0
+  };
+};
+const isComponent = (fieldSchema) => {
+  return {
+    isZone: fieldSchema.type === "dynamiczone",
+    hasContent: true
+  };
+};
+const Logger$2 = {
+  log: typeof strapi !== "undefined" ? strapi.log : console,
+  info: (val) => Logger$2.log.info(val),
+  warn: (val) => Logger$2.log.warn(val),
+  error: (val) => Logger$2.log.error(val),
+  debug: (val) => Logger$2.log.debug(val)
 };
-const isDynamicZone = (fieldSchema, value, schema) => {
-  return fieldSchema.type === "dynamiczone" && isFieldLocalizable(fieldSchema, schema) && Array.isArray(value);
+const DEFAULT_FIELDS = [
+  "id",
+  "documentId",
+  "createdAt",
+  "updatedAt",
+  ,
+  "createdBy",
+  "updatedBy",
+  "publishedAt",
+  "locale",
+  "localizations"
+];
+const getContentFields = function(schema) {
+  const nullFields = [];
+  for (let field in schema) {
+    if (!DEFAULT_FIELDS.includes(field))
+      nullFields.push(field);
+  }
+  return nullFields;
 };
-const isComponent = (fieldSchema, value, schema) => {
-  return fieldSchema.type === "component" && isFieldLocalizable(fieldSchema, schema);
+const getInvalidOrNullFields = function(document, schema) {
+  if (!document)
+    return getContentFields(schema);
+  const nullFields = [];
+  let fieldsValid = 0;
+  for (let field in document) {
+    if (DEFAULT_FIELDS.includes(field))
+      continue;
+    if (document[field] === null)
+      nullFields.push(field);
+    else
+      fieldsValid++;
+  }
+  if (nullFields.length > 0 || fieldsValid > 0)
+    return nullFields;
+  return getContentFields(schema);
 };
+function appendMissingFields(data, sourceEntry, targetSchema, targetEntry) {
+  const nullFields = getInvalidOrNullFields(targetEntry, targetSchema.entry.attributes);
+  if (nullFields.length === 0)
+    return;
+  let count = 0;
+  Logger$2.info("Adding missing fields to new locale: " + nullFields.join(", "));
+  for (let field of nullFields) {
+    if (data[field]) {
+      Logger$2.info("Field already present: " + field);
+      continue;
+    }
+    if (!sourceEntry[field]) {
+      Logger$2.info("No valid source langauge field value for " + field + " - skipping it.");
+      continue;
+    }
+    if (!targetSchema.entry.attributes[field]) {
+      Logger$2.warn("Schema does not contain field " + field);
+      continue;
+    }
+    Logger$2.info("Adding missing field and value for " + field);
+    data[field] = sourceEntry[field];
+    count++;
+  }
+  if (count > 0)
+    Logger$2.info(count + " missing fields added.");
+}
+async function updateEntry(contentTypeID, entryID, targetLocale, data) {
+  strapi.log.info("Updating target entry " + contentTypeID + "::" + entryID + " in locale " + targetLocale);
+  const newEntry = await strapi.documents(contentTypeID).update({
+    documentId: entryID,
+    locale: targetLocale,
+    data
+  });
+  if (!newEntry)
+    throw new Error("Cannot update target entry " + contentTypeID + "::" + entryID + " in locale " + targetLocale);
+}
 function htmlToJson(html) {
   function parseHTML(html2) {
     const elements2 = [];
@@ -762,227 +904,171 @@ function htmlToJson(html) {
   }
   return blocks;
 }
-async function updateEntry(contentTypeID, entryID, sourceLocale, targetLocale, data, attributes) {
-  if (!entryID) {
-    const singleTypeData = await strapi.documents(contentTypeID).findFirst();
-    entryID = singleTypeData.documentId;
-  }
-  const originalEntry = await strapi.documents(contentTypeID).findFirst({
-    documentId: entryID,
-    locale: sourceLocale
-  });
-  const processedData = processDataRecursively(data);
-  for (const [key, value] of Object.entries(processedData)) {
-    if (attributes[key]?.type === "blocks" && typeof value === "string") {
-      console.warn(
-        `Field ${key} is a blocks field but received string value. Converting to blocks format.`
-      );
-      processedData[key] = htmlToJson(value);
+const Logger$1 = {
+  log: typeof strapi !== "undefined" ? strapi.log : console,
+  info: (val) => Logger$1.log.info(val),
+  warn: (val) => Logger$1.log.warn(val),
+  error: (val) => Logger$1.log.error(val),
+  debug: (val) => Logger$1.log.debug(val)
+};
+const removeComponentIds = function(elem) {
+  const list = Array.isArray(elem) ? elem : [elem];
+  for (let obj of list) {
+    if (obj.__component && obj.id)
+      delete obj.id;
+    for (let key in obj) {
+      const child = obj[key];
+      if (Array.isArray(child) && Array.length > 0)
+        removeComponentIds(child);
+      else if (typeof child === "object")
+        removeComponentIds(child);
     }
   }
-  const localizedData = {};
-  for (const field in processedData) {
-    if (attributes[field] && (!attributes[field].pluginOptions?.i18n || attributes[field].pluginOptions?.i18n?.localized !== false)) {
-      localizedData[field] = processedData[field];
+};
+function replaceDynamicZones(strapiEntry, replacableFields) {
+  const fields = [];
+  for (let key in strapiEntry) {
+    if (replacableFields[key]) {
+      removeComponentIds(replacableFields[key]);
+      strapiEntry[key] = replacableFields[key];
+      fields.push(key);
     }
   }
-  await strapi.documents(contentTypeID).update({
-    documentId: entryID,
-    locale: targetLocale,
-    data: localizedData
-  });
-  if (originalEntry.publishedAt !== null) {
-    await strapi.documents(contentTypeID).publish({
-      documentId: entryID,
-      locale: sourceLocale
-    });
-  }
+  if (fields.length > 0)
+    Logger$1.info(fields.length + " dynamic fields/components replaced for later merge: " + fields.join(", "));
+  return fields;
 }
-function processDataRecursively(data, schema) {
-  if (!data || typeof data !== "object") {
-    return data;
+const mergeValue = function(field, translatable, targetSchema, map) {
+  if (translatable.translatableValue.length === 0)
+    return false;
+  if (targetSchema.attributes[field] === void 0) {
+    Logger$1.info("Field " + field + " does not exist in schema. Skipping it");
+    Logger$1.info(targetSchema);
+    return false;
   }
-  if (Array.isArray(data)) {
-    if (data[0]?.fields) {
-      const processedFields = {};
-      for (const fieldData of data[0].fields) {
-        if (fieldData.realType === "blocks") {
-          if (fieldData.translatableValue?.[0]) {
-            processedFields[fieldData.field] = htmlToJson(fieldData.translatableValue[0]);
-          }
-        } else {
-          processedFields[fieldData.field] = fieldData.translatableValue?.[0] || null;
-        }
-      }
-      return processedFields;
-    }
-    return data.map((item) => processDataRecursively(item));
+  if (translatable.translatableValue[0] === "") {
+    Logger$1.info("Skipping empty translated content for field " + field);
+    return false;
   }
-  const result = {};
-  for (const key in data) {
-    result[key] = processDataRecursively(data[key]);
+  if (translatable.realType === "blocks") {
+    Logger$1.info("Merge block field " + field);
+    map[field] = htmlToJson(translatable.translatableValue[0] || "");
+    return true;
   }
-  return result;
-}
-function organizeFields(fields) {
-  const componentFieldsMap = /* @__PURE__ */ new Map();
-  const dynamicZoneFields = /* @__PURE__ */ new Map();
-  const regularFields = [];
-  fields.forEach((field) => {
-    if (!field.componentInfo) {
-      regularFields.push(field);
-      return;
-    }
-    const { namePath, id } = field.componentInfo;
-    const pathString = namePath.join(".");
-    if (namePath[0] === "dynamiczone") {
-      if (!dynamicZoneFields.has(id)) {
-        dynamicZoneFields.set(id, []);
-      }
-      dynamicZoneFields.get(id)?.push(field);
-    } else {
-      if (!componentFieldsMap.has(pathString)) {
-        componentFieldsMap.set(pathString, []);
-      }
-      componentFieldsMap.get(pathString)?.push(field);
-    }
-  });
-  return { regularFields, componentFieldsMap, dynamicZoneFields };
-}
-function processRegularFields(regularFields, acc) {
-  regularFields.forEach((field) => {
-    acc[field.field] = field.translatableValue[0];
-  });
-  return acc;
-}
-function processRepeatableComponents(fields, existingEntry, rootPath) {
-  const existingComponents = existingEntry?.[rootPath] || [];
-  const componentsById = /* @__PURE__ */ new Map();
-  fields.forEach((field) => {
-    if (!field.componentInfo) {
-      console.warn(`Component info missing for field: ${field.field}`);
-      return;
-    }
-    const componentId = field.componentInfo.id;
-    if (!componentsById.has(componentId)) {
-      const existingComponent = existingComponents.find((c) => c.id === componentId);
-      componentsById.set(componentId, existingComponent ? { ...existingComponent } : {});
-    }
-    const component = componentsById.get(componentId);
-    if (field.realType === "blocks") {
-      component[field.field] = htmlToJson(field.translatableValue[0] || "");
-    } else {
-      component[field.field] = field.translatableValue[0];
-    }
-  });
-  return Array.from(componentsById.values()).map((comp) => {
-    if (!existingComponents.find((ec) => ec.id === comp.id)) {
-      const { id, ...rest } = comp;
-      return rest;
-    }
-    return comp;
-  }).filter((comp) => Object.keys(comp).length > 0);
-}
-function processNestedComponents(fields, pathParts, existingEntry, acc) {
-  let current = acc;
-  let currentExisting = existingEntry;
-  pathParts.forEach((part, index2) => {
-    if (!current[part]) {
-      current[part] = {};
-      if (currentExisting?.[part]?.id) {
-        current[part].id = currentExisting[part].id;
-      }
-    }
-    if (index2 === pathParts.length - 1) {
-      fields.forEach((field) => {
-        if (field.realType === "blocks") {
-          current[part][field.field] = htmlToJson(field.translatableValue[0] || "");
-        } else {
-          current[part][field.field] = field.translatableValue[0];
-        }
-      });
-    } else {
-      current = current[part];
-      currentExisting = currentExisting?.[part];
-    }
-  });
-}
-function processComponentFields(componentFieldsMap, acc, existingEntry, targetSchema) {
-  componentFieldsMap.forEach((fields, namePath) => {
-    if (!fields.length) return;
-    const pathParts = namePath.split(".");
-    const rootPath = pathParts[0];
-    const schema = targetSchema.attributes?.[rootPath];
-    if (schema?.repeatable) {
-      acc[rootPath] = processRepeatableComponents(fields, existingEntry, rootPath);
-    } else {
-      processNestedComponents(fields, pathParts, existingEntry, acc);
+  if (translatable.type === "text") {
+    Logger$1.info("Merge text field " + field);
+    map[field] = translatable.translatableValue[0];
+    return true;
+  }
+  Logger$1.warn("Did not process " + field);
+  return false;
+};
+const mergeSimpleFields = function(translatables, existingEntry, targetSchema, map) {
+  let count = 0;
+  for (const candidate of translatables) {
+    const field = candidate.field;
+    if (!candidate.uuid && mergeValue(field, candidate, targetSchema.entry, map))
+      count++;
+  }
+  if (count > 0) {
+    Logger$1.info("Updated " + count + " simple text fields");
+    return true;
+  }
+  return false;
+};
+const buildMapOfUuids = function(existingEntry, schemaMap, map) {
+  if (typeof existingEntry !== "object")
+    return map;
+  const componentName = existingEntry["__component"] ?? "";
+  const schema = componentName && schemaMap.components[componentName] ? schemaMap.components[componentName] : null;
+  if (componentName && !schema)
+    Logger$1.warn("Cannot find component schema " + componentName);
+  for (const key of Object.keys(existingEntry)) {
+    if (key === "__component")
+      continue;
+    if (schema !== null && key === "__tsuid") {
+      map[existingEntry[key]] = {
+        entry: existingEntry,
+        schema
+      };
+      continue;
     }
-  });
-  return acc;
-}
-function transformFieldsToData(fields) {
-  return fields.reduce((acc, field) => {
-    if (!field.translatableValue) {
-      acc[field.field] = "";
-      return acc;
+    const child = existingEntry[key];
+    if (child) {
+      if (Array.isArray(child)) {
+        for (let e of child)
+          buildMapOfUuids(e, schemaMap, map);
+      } else
+        buildMapOfUuids(child, schemaMap, map);
     }
-    if (field.realType === "blocks") {
-      acc[field.field] = htmlToJson(field.translatableValue[0] || "");
-    } else if (field.realType === "richtext") {
-      acc[field.field] = field.translatableValue[0] || "";
-    } else {
-      acc[field.field] = Array.isArray(field.translatableValue) && field.translatableValue.length > 1 ? field.translatableValue.join(" ") : field.translatableValue[0] || "";
+  }
+  if (existingEntry["__tsuid"]) {
+    delete existingEntry["__tsuid"];
+    Logger$1.info("Removed cusom property __tsuid");
+  }
+  return map;
+};
+const mergeDynamicZones = function(translatables, schemaMap, existingEntry) {
+  if (translatables.length === 0) {
+    Logger$1.info("Skipping merging of dynamic zones, because none are present.");
+    return;
+  }
+  const map = {};
+  buildMapOfUuids(existingEntry, schemaMap, map);
+  const mapSize = Object.keys(map).length;
+  if (mapSize === 0) {
+    Logger$1.warn("Could not create a uuid map");
+    return false;
+  }
+  Logger$1.info("Built uuid map with " + mapSize + " entry(s)");
+  let count = 0;
+  for (const translatable of translatables) {
+    if (!translatable.uuid)
+      continue;
+    const uuid = translatable.uuid;
+    if (!map[uuid])
+      continue;
+    const entry = map[uuid];
+    const schema = entry.schema;
+    if (!schema) {
+      Logger$1.warn("Cannot find schema by uuid #" + uuid);
+      continue;
     }
-    return acc;
-  }, {});
-}
-function processDynamicZones(dynamicZoneFields, acc, existingEntry) {
-  if (dynamicZoneFields.size > 0) {
-    const existingDynamicZone = existingEntry?.dynamiczone || [];
-    acc.dynamiczone = Array.from(dynamicZoneFields.entries()).sort(([a], [b]) => a - b).map(([_, fields]) => {
-      if (!fields[0].componentInfo) {
-        console.warn(
-          `Component info missing for dynamic zone field: ${fields[0].field}`
-        );
-        return null;
-      }
-      const { schemaName } = fields[0].componentInfo;
-      const componentData = transformFieldsToData(fields);
-      const matchingComponent = existingDynamicZone.find(
-        (comp) => comp.__component === schemaName
-      );
-      return {
-        __component: schemaName,
-        ...componentData,
-        ...matchingComponent?.id ? { id: matchingComponent.id } : {}
-      };
-    }).filter(Boolean);
+    if (mergeValue(translatable.field, translatable, schema, entry.entry))
+      count++;
   }
-  return acc;
-}
-function prepareImportData(translatables, existingEntry, targetSchema) {
-  return translatables.reduce((acc, doc) => {
-    const { regularFields, componentFieldsMap, dynamicZoneFields } = organizeFields(translatables);
-    const withRegularFields = processRegularFields(regularFields, acc);
-    const withComponentFields = processComponentFields(
-      componentFieldsMap,
-      withRegularFields,
-      existingEntry,
-      targetSchema
-    );
-    const withDynamicZones = processDynamicZones(
-      dynamicZoneFields,
-      withComponentFields,
-      existingEntry
-    );
-    return withDynamicZones;
-  }, {});
+  if (count > 0) {
+    Logger$1.info("Updated " + count + " entries in dynamic zones/content blocks");
+    return true;
+  }
+  return false;
+};
+function prepareImportData(translatables, keepData, existingEntry, targetSchema) {
+  const result = {};
+  const simpleUpdated = mergeSimpleFields(translatables, existingEntry, targetSchema, result);
+  let otherUpdated = false;
+  const vsFields = replaceDynamicZones(existingEntry, keepData);
+  if (vsFields.length > 0) {
+    if (mergeDynamicZones(translatables, targetSchema, existingEntry)) {
+      vsFields.forEach((field) => result[field] = existingEntry[field]);
+      otherUpdated = true;
+    } else
+      Logger$1.warn("Could not merge dynamic fields");
+  }
+  if (simpleUpdated || otherUpdated)
+    return result;
+  else
+    return null;
 }
-require("jsonwebtoken");
-const crypto = require("crypto");
 const TRANSLATIONTUDIO_URL = "https://strapi.translationstudio.tech";
 const APP_NAME = "translationstudio";
+const Logger = {
+  log: typeof strapi !== "undefined" ? strapi.log : console,
+  info: (val) => Logger.log.info(val),
+  warn: (val) => Logger.log.warn(val),
+  error: (val) => Logger.log.error(val),
+  debug: (val) => Logger.log.debug(val)
+};
 const service = ({ strapi: strapi2 }) => {
   const pluginStore = strapi2.store({
     type: "plugin",
@@ -1000,7 +1086,7 @@ const service = ({ strapi: strapi2 }) => {
         if (typeof result === "string" && result !== "")
           return result;
       } catch (err) {
-        console.warn(err);
+        strapi2.log.warn(err);
       }
       return TRANSLATIONTUDIO_URL;
     },
@@ -1063,9 +1149,15 @@ const service = ({ strapi: strapi2 }) => {
     },
     async exportData(payload) {
       const { contentTypeID, entryID, locale } = parsePayload(payload);
-      const contentType = await getContentType(contentTypeID);
+      const contentType = getContentType(contentTypeID);
+      if (contentType === null || !IsLocalisableSchema(contentType.entry)) {
+        return {
+          fields: [],
+          keep: {}
+        };
+      }
       const entry = await getEntry(contentTypeID, entryID, locale);
-      const contentFields = await processEntryFields(entry, contentType.attributes);
+      const contentFields = await processEntryFields(entry, contentType);
       return transformResponse(contentFields);
     },
     async importData(payload) {
@@ -1073,23 +1165,32 @@ const service = ({ strapi: strapi2 }) => {
       const sourceLocale = payload.source;
       const targetLocale = payload.target;
       try {
-        const existingEntry = await getEntry(contentTypeID, entryID, targetLocale);
-        const targetSchema = await getContentType(contentTypeID);
-        const data = prepareImportData(payload.document[0].fields, existingEntry, targetSchema);
-        if (targetSchema.pluginOptions.i18n.localized === true) {
-          await updateEntry(
-            contentTypeID,
-            entryID,
-            sourceLocale,
-            targetLocale,
-            data,
-            targetSchema.attributes
-          );
-        }
-        return { success: true };
+        const sourceEntry = await getEntry(contentTypeID, entryID, sourceLocale);
+        if (sourceEntry == null)
+          throw new Error("Cannot find source entry " + contentTypeID + "::" + entryID + " in " + sourceLocale);
+        const targetSchema = getContentType(contentTypeID);
+        if (targetSchema === null || !IsLocalisableSchema(targetSchema.entry))
+          throw new Error("Cannot find schema");
+        const data = prepareImportData(
+          payload.document[0].fields,
+          payload.document[0].keep ?? {},
+          sourceEntry,
+          targetSchema
+        );
+        strapi2.log.info("Loading target language entry");
+        const targetLocaleEntry = await getEntry(contentTypeID, entryID, targetLocale);
+        appendMissingFields(data, sourceEntry, targetSchema, targetLocaleEntry);
+        await updateEntry(
+          contentTypeID,
+          entryID,
+          targetLocale,
+          data
+        );
+        return true;
       } catch (error) {
-        return { success: false };
+        strapi2.log.error(error);
       }
+      return false;
     },
     async requestTranslation(payload) {
       const { license } = await this.getLicense();