@goenhance/strapi-plugins-translate 0.11.0

package/dist/server/index.js

@@ -0,0 +1,754 @@
+"use strict";
+const openai = require("openai");
+const bootstrap = ({ strapi: strapi2 }) => {
+};
+const destroy = ({ strapi: strapi2 }) => {
+};
+const register = ({ strapi: strapi2 }) => {
+};
+const DEFAULT_SYSTEM_PROMPT = "You are a professional translator. Your task is to translate the provided content accurately while preserving the original meaning and tone.";
+const SYSTEM_PROMPT_APPENDIX = `The user asks you to translate the text to a specific language, the language is provided via short code like "en", "fr", "de", etc.`;
+const DEFAULT_LLM_TEMPERATURE = 0.3;
+const DEFAULT_LLM_MODEL = "gpt-4o";
+const DEFAULT_LLM_BASE_URL = "https://api.openai.com/v1";
+const SYSTEM_PROMPT_FIX = `You are a JSON correction assistant. Only return valid, corrected JSON.`;
+const USER_PROMPT_FIX_PREFIX = "Fix this invalid JSON and return ONLY the corrected JSON. No explanations allowed. The JSON is:";
+const config = {
+  default: ({ env }) => ({
+    llmApiKey: env("LLM_TRANSLATOR_LLM_API_KEY"),
+    llmEndpoint: env("STRAPI_ADMIN_LLM_TRANSLATOR_LLM_BASE_URL"),
+    llmModel: env("STRAPI_ADMIN_LLM_TRANSLATOR_LLM_MODEL")
+  }),
+  validator(config2) {
+    const PLUGIN_NAME = "Strapi LLM Translator";
+    console.info(`
+==== ${PLUGIN_NAME} Configuration Validation ====`);
+    if (!config2?.llmApiKey) {
+      console.warn("⚠️  LLM API Key: Missing");
+      console.info("   → Translation features requiring API keys will be disabled");
+    } else {
+      console.info("✅ LLM API Key: Configured");
+    }
+    const endpoint = config2?.llmEndpoint || DEFAULT_LLM_BASE_URL;
+    if (!config2?.llmEndpoint) {
+      console.warn(`⚠️  API Endpoint: Using default (${DEFAULT_LLM_BASE_URL})`);
+    } else {
+      console.info(`✅ API Endpoint: Configured (${endpoint})`);
+    }
+    const model = config2?.llmModel || DEFAULT_LLM_MODEL;
+    if (!config2?.llmModel) {
+      console.warn(`⚠️  LLM Model: Using default (${DEFAULT_LLM_MODEL})`);
+    } else {
+      console.info(`✅ LLM Model: Configured (${model})`);
+    }
+    console.info("========================================================\n");
+  }
+};
+const contentTypes = {};
+const controllers$1 = ({ strapi: strapi2 }) => ({
+  // Genertate translations
+  async generate(ctx) {
+    try {
+      const { fields, components, targetLanguage, contentType } = ctx.request.body;
+      const result = await strapi2.plugin("strapi-plugins-translate").service("llm-service").generateWithLLM(contentType, fields, components, {
+        targetLanguage
+      });
+      ctx.status = result.meta.status;
+      ctx.body = result;
+    } catch (error) {
+      console.error("Error in generate controller:", error);
+      ctx.status = 500;
+      ctx.body = {
+        meta: {
+          ok: false,
+          status: 500,
+          message: "Internal server error"
+        }
+      };
+    }
+  },
+  // Get the configuration
+  async getConfig(ctx) {
+    const pluginStore = strapi2.store({
+      environment: strapi2.config.environment,
+      type: "plugin",
+      name: "strapi-plugins-translate"
+      // replace with your plugin name
+    });
+    const config2 = await pluginStore.get({ key: "configuration" });
+    ctx.body = config2 || {};
+  },
+  // Save the configuration
+  async setConfig(ctx) {
+    const { body } = ctx.request;
+    const pluginStore = strapi2.store({
+      environment: strapi2.config.environment,
+      type: "plugin",
+      name: "strapi-plugins-translate"
+      // replace with your plugin name
+    });
+    await pluginStore.set({
+      key: "configuration",
+      value: { ...body }
+    });
+    ctx.body = await pluginStore.get({ key: "configuration" });
+  },
+  // Get all content types that support i18n
+  async getContentTypes(ctx) {
+    try {
+      const contentTypes2 = strapi2.contentTypes;
+      const i18nContentTypes = [];
+      Object.entries(contentTypes2).forEach(([uid, contentType]) => {
+        const isI18nEnabled = contentType.pluginOptions?.i18n?.localized === true;
+        const isApiContentType = uid.startsWith("api::");
+        if (isI18nEnabled && isApiContentType) {
+          i18nContentTypes.push({
+            uid,
+            displayName: contentType.info?.displayName || uid,
+            apiID: contentType.info?.singularName || uid.split(".").pop() || uid,
+            kind: contentType.kind || "collectionType"
+          });
+        }
+      });
+      ctx.body = {
+        data: i18nContentTypes,
+        meta: { ok: true }
+      };
+    } catch (error) {
+      console.error("Error getting content types:", error);
+      ctx.status = 500;
+      ctx.body = {
+        data: [],
+        meta: { ok: false, message: "Failed to get content types" }
+      };
+    }
+  },
+  // Get all available locales
+  async getLocales(ctx) {
+    try {
+      const locales = await strapi2.plugin("i18n").service("locales").find();
+      ctx.body = {
+        data: locales,
+        meta: { ok: true }
+      };
+    } catch (error) {
+      console.error("Error getting locales:", error);
+      ctx.status = 500;
+      ctx.body = {
+        data: [],
+        meta: { ok: false, message: "Failed to get locales" }
+      };
+    }
+  },
+  // Get entries for a specific content type and locale
+  async getEntries(ctx) {
+    try {
+      const { contentType } = ctx.params;
+      const { locale, page = "1", pageSize = "25" } = ctx.query;
+      const decodedContentType = decodeURIComponent(contentType);
+      const contentTypeSchema = strapi2.contentTypes[decodedContentType];
+      if (!contentTypeSchema) {
+        ctx.status = 404;
+        ctx.body = {
+          data: [],
+          meta: { ok: false, message: "Content type not found" }
+        };
+        return;
+      }
+      const mainField = contentTypeSchema.info?.mainField || Object.keys(contentTypeSchema.attributes).find(
+        (key) => contentTypeSchema.attributes[key].type === "string" && ["title", "name", "label"].includes(key.toLowerCase())
+      ) || "id";
+      const idField = Object.keys(contentTypeSchema.attributes).find(
+        (key) => (key.endsWith("_id") || key.endsWith("Id") || contentTypeSchema.attributes[key].type === "uid" && key !== "slug") && key != "category_id"
+      );
+      const query = {
+        page: parseInt(page, 10),
+        pageSize: parseInt(pageSize, 10),
+        populate: "*"
+      };
+      if (locale) {
+        query.locale = locale;
+      }
+      const entries = await strapi2.documents(decodedContentType).findMany(query);
+      const count = await strapi2.documents(decodedContentType).count(
+        locale ? { locale } : {}
+      );
+      const getDisplayValue = (value) => {
+        if (value === null || value === void 0) {
+          return "";
+        }
+        if (typeof value === "string" || typeof value === "number") {
+          return String(value);
+        }
+        if (typeof value === "object") {
+          return value.title || value.name || value.label || value.id || JSON.stringify(value);
+        }
+        return String(value);
+      };
+      const entriesWithLocaleInfo = await Promise.all(
+        entries.map(async (entry) => {
+          const localizations = entry.localizations || [];
+          const existingLocales = [entry.locale, ...localizations.map((l) => l.locale)];
+          const titleValue = entry[mainField];
+          const displayTitle = getDisplayValue(titleValue) || getDisplayValue(entry.id);
+          const customIdValue = idField ? entry[idField] : null;
+          const displayCustomId = customIdValue ? getDisplayValue(customIdValue) : null;
+          return {
+            id: entry.id,
+            documentId: entry.documentId,
+            customId: displayCustomId,
+            title: displayTitle,
+            locale: entry.locale,
+            publishedAt: entry.publishedAt,
+            existingLocales,
+            createdAt: entry.createdAt,
+            updatedAt: entry.updatedAt
+          };
+        })
+      );
+      ctx.body = {
+        data: entriesWithLocaleInfo,
+        meta: {
+          ok: true,
+          pagination: {
+            page: parseInt(page, 10),
+            pageSize: parseInt(pageSize, 10),
+            total: count,
+            pageCount: Math.ceil(count / parseInt(pageSize, 10))
+          },
+          mainField,
+          idField
+        }
+      };
+    } catch (error) {
+      console.error("Error getting entries:", error);
+      ctx.status = 500;
+      ctx.body = {
+        data: [],
+        meta: { ok: false, message: "Failed to get entries" }
+      };
+    }
+  },
+  // Batch translate entries
+  async batchTranslate(ctx) {
+    try {
+      const { contentType, entries, sourceLocale, targetLocales, publish = false } = ctx.request.body;
+      const results = [];
+      const contentTypeSchema = strapi2.contentTypes[contentType];
+      if (!contentTypeSchema) {
+        ctx.status = 404;
+        ctx.body = {
+          data: results,
+          meta: { ok: false, message: "Content type not found" }
+        };
+        return;
+      }
+      const components = {};
+      Object.entries(contentTypeSchema.attributes || {}).forEach(
+        ([, attr]) => {
+          if (attr.type === "component" && attr.component) {
+            components[attr.component] = strapi2.components[attr.component];
+          } else if (attr.type === "dynamiczone" && attr.components) {
+            attr.components.forEach((comp) => {
+              components[comp] = strapi2.components[comp];
+            });
+          }
+        }
+      );
+      for (const entryId of entries) {
+        const sourceEntry = await strapi2.documents(contentType).findOne({
+          documentId: entryId,
+          locale: sourceLocale,
+          populate: "*"
+        });
+        if (!sourceEntry) {
+          results.push({
+            documentId: entryId,
+            locale: sourceLocale,
+            success: false,
+            message: "Source entry not found"
+          });
+          continue;
+        }
+        for (const targetLocale of targetLocales) {
+          try {
+            const existingTranslation = await strapi2.documents(contentType).findOne({
+              documentId: entryId,
+              locale: targetLocale
+            });
+            if (existingTranslation) {
+              results.push({
+                documentId: entryId,
+                locale: targetLocale,
+                success: false,
+                message: "Translation already exists"
+              });
+              continue;
+            }
+            const translationResult = await strapi2.plugin("strapi-plugins-translate").service("llm-service").generateWithLLM(contentTypeSchema, sourceEntry, components, {
+              targetLanguage: targetLocale
+            });
+            if (!translationResult.meta.ok) {
+              results.push({
+                documentId: entryId,
+                locale: targetLocale,
+                success: false,
+                message: translationResult.meta.message || "Translation failed"
+              });
+              continue;
+            }
+            const translatedData = { ...translationResult.data };
+            delete translatedData.id;
+            delete translatedData.documentId;
+            delete translatedData.createdAt;
+            delete translatedData.updatedAt;
+            delete translatedData.publishedAt;
+            delete translatedData.locale;
+            delete translatedData.localizations;
+            delete translatedData.createdBy;
+            delete translatedData.updatedBy;
+            await strapi2.documents(contentType).update({
+              documentId: entryId,
+              locale: targetLocale,
+              data: translatedData,
+              status: publish ? "published" : "draft"
+            });
+            results.push({
+              documentId: entryId,
+              locale: targetLocale,
+              success: true
+            });
+          } catch (error) {
+            console.error(`Error translating entry ${entryId} to ${targetLocale}:`, error);
+            results.push({
+              documentId: entryId,
+              locale: targetLocale,
+              success: false,
+              message: error instanceof Error ? error.message : "Unknown error"
+            });
+          }
+        }
+      }
+      const successCount = results.filter((r) => r.success).length;
+      const failureCount = results.filter((r) => !r.success).length;
+      ctx.body = {
+        data: results,
+        meta: {
+          ok: true,
+          successCount,
+          failureCount,
+          message: `Translated ${successCount} entries, ${failureCount} failed`
+        }
+      };
+    } catch (error) {
+      console.error("Error in batch translate:", error);
+      ctx.status = 500;
+      ctx.body = {
+        data: [],
+        meta: {
+          ok: false,
+          message: error instanceof Error ? error.message : "Batch translation failed"
+        }
+      };
+    }
+  }
+});
+const controllers = {
+  admin: controllers$1
+};
+const middlewares = {};
+const policies = {};
+const adminRoutes = [
+  {
+    method: "POST",
+    path: "/generate",
+    handler: "admin.generate",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "GET",
+    path: "/config",
+    handler: "admin.getConfig",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "POST",
+    path: "/config",
+    handler: "admin.setConfig",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "GET",
+    path: "/content-types",
+    handler: "admin.getContentTypes",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "GET",
+    path: "/locales",
+    handler: "admin.getLocales",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "GET",
+    path: "/entries/:contentType",
+    handler: "admin.getEntries",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "POST",
+    path: "/batch-translate",
+    handler: "admin.batchTranslate",
+    config: {
+      policies: []
+    }
+  }
+];
+const routes = {
+  admin: {
+    type: "admin",
+    routes: adminRoutes
+  }
+};
+const cleanJSONString = (content) => {
+  return content.replace(/^```json\s*\n/, "").replace(/^```\s*\n/, "").replace(/\n\s*```$/, "").replace(/\u200B/g, "").replace(/[\u2018\u2019]/g, "'").replace(/[\u201C\u201D]/g, '"').trim();
+};
+const balanceJSONBraces = (content) => {
+  let openBraces = 0;
+  let closeBraces = 0;
+  let inString = false;
+  for (let i = 0; i < content.length; i += 1) {
+    const char = content[i];
+    if (char === '"' && content[i - 1] !== "\\") {
+      inString = !inString;
+    }
+    if (!inString) {
+      if (char === "{") openBraces += 1;
+      if (char === "}") closeBraces += 1;
+    }
+  }
+  if (openBraces > closeBraces) {
+    return content + "}".repeat(openBraces - closeBraces);
+  }
+  return content;
+};
+const extractJSONObject = (content) => {
+  const firstBrace = content.indexOf("{");
+  const lastBrace = content.lastIndexOf("}");
+  if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
+    return content.slice(firstBrace, lastBrace + 1);
+  }
+  return content;
+};
+const safeJSONParse = (content) => {
+  const parsed = JSON.parse(content);
+  if (typeof parsed === "object" && parsed !== null) {
+    return parsed;
+  }
+  throw new Error("Invalid response format - not an object");
+};
+const llmClient = new openai.OpenAI({
+  baseURL: process.env.STRAPI_ADMIN_LLM_TRANSLATOR_LLM_BASE_URL ?? DEFAULT_LLM_BASE_URL,
+  apiKey: process.env.LLM_TRANSLATOR_LLM_API_KEY ?? "not_set"
+});
+const LLM_MODEL = process.env.STRAPI_ADMIN_LLM_TRANSLATOR_LLM_MODEL ?? DEFAULT_LLM_MODEL;
+const extractTranslatableFields = (contentType, fields, components = {}) => {
+  const translatableFields = [];
+  const isTranslatableFieldSchema = (schema, value) => {
+    if (!schema) {
+      return false;
+    }
+    const { type } = schema;
+    const isStringType = ["string", "text"].includes(type) && typeof value === "string";
+    const isRichTextType = ["richtext", "richText", "blocks"].includes(type) && (typeof value === "string" || typeof value === "object");
+    const isJSONType = type === "json" && typeof value === "object";
+    const isNotUID = type !== "uid";
+    const isLocalizable = schema.pluginOptions?.i18n?.localized !== false;
+    return (isStringType || isRichTextType || isJSONType) && isNotUID && isLocalizable;
+  };
+  const traverse = (schema, data, path = [], originalPath = []) => {
+    Object.entries(schema.attributes || {}).forEach(([fieldName, fieldSchemaRaw]) => {
+      const fieldSchema = fieldSchemaRaw;
+      const value = data?.[fieldName];
+      if (value === void 0 || value === null) {
+        return;
+      }
+      if (isTranslatableFieldSchema(fieldSchema, value)) {
+        translatableFields.push({
+          path: [...path, fieldName],
+          value,
+          originalPath: [...originalPath, fieldName]
+        });
+        return;
+      }
+      if (fieldSchema.type === "component") {
+        const componentSchema = components[fieldSchema.component];
+        if (!componentSchema) return;
+        if (fieldSchema.repeatable && Array.isArray(value)) {
+          value.forEach(
+            (item, index) => traverse(
+              componentSchema,
+              item,
+              [...path, fieldName, String(index)],
+              [...originalPath, fieldName, String(index)]
+            )
+          );
+        } else if (typeof value === "object") {
+          traverse(componentSchema, value, [...path, fieldName], [...originalPath, fieldName]);
+        }
+      } else if (fieldSchema.type === "dynamiczone" && Array.isArray(value)) {
+        value.forEach((item, index) => {
+          const compSchema = components[item.__component];
+          if (compSchema) {
+            traverse(
+              compSchema,
+              item,
+              [...path, fieldName, String(index)],
+              [...originalPath, fieldName, String(index)]
+            );
+          }
+        });
+      }
+    });
+  };
+  traverse(contentType, fields, [], []);
+  return translatableFields;
+};
+const prepareTranslationPayload = (fields) => {
+  const payload = {};
+  fields.forEach((field) => {
+    let current = payload;
+    field.path.forEach((part, index) => {
+      if (index === field.path.length - 1) {
+        current[part] = field.value;
+      } else {
+        current[part] = current[part] || {};
+        current = current[part];
+      }
+    });
+  });
+  return payload;
+};
+const mergeTranslatedContent = (originalData, translatedData, translatableFields) => {
+  const result = JSON.parse(JSON.stringify(originalData));
+  translatableFields.forEach((field) => {
+    let translatedValue = translatedData;
+    for (const part of field.path) {
+      translatedValue = translatedValue?.[part];
+      if (translatedValue === void 0) break;
+    }
+    if (translatedValue !== void 0) {
+      let current = result;
+      field.originalPath.forEach((part, index) => {
+        if (index === field.originalPath.length - 1) {
+          current[part] = translatedValue;
+        } else {
+          current = current[part];
+        }
+      });
+    }
+  });
+  return result;
+};
+const generateSlug = async (data, field, contentTypeUID) => {
+  const uidService = strapi.service("plugin::content-manager.uid");
+  const slug = await uidService.generateUIDField({
+    contentTypeUID,
+    field,
+    data
+  });
+  return slug;
+};
+const findUIDFields = (contentType) => {
+  const uidFields = [];
+  Object.entries(contentType.attributes || {}).forEach(([fieldName, schema]) => {
+    if (schema.type === "uid" && schema.targetField) {
+      uidFields.push({
+        fieldName,
+        targetField: schema.targetField
+      });
+    }
+  });
+  return uidFields;
+};
+const generateUIDsForTranslatedFields = async (uidFields, translatedData, contentTypeUID, mergedContent) => {
+  const translatedUIDs = {};
+  for (const { fieldName, targetField } of uidFields) {
+    if (translatedData[targetField] !== void 0) {
+      try {
+        const newUID = await generateSlug(
+          {
+            ...mergedContent,
+            [targetField]: translatedData[targetField]
+          },
+          fieldName,
+          contentTypeUID
+        );
+        translatedUIDs[fieldName] = newUID;
+      } catch (error) {
+        console.error(`Failed to generate UID for field ${fieldName}:`, error);
+      }
+    }
+  }
+  return translatedUIDs;
+};
+const llmService = ({ strapi: strapi2 }) => ({
+  async generateWithLLM(contentType, fields, components, config2) {
+    try {
+      const userConfig = await getUserConfig();
+      const translatableFields = extractTranslatableFields(contentType, fields, components);
+      const translationPayload = prepareTranslationPayload(translatableFields);
+      const prompt = buildPrompt(translationPayload, config2.targetLanguage);
+      const systemPrompt = await buildSystemPrompt(userConfig);
+      const response = await callLLMProvider(prompt, systemPrompt, userConfig);
+      const translatedData = await parseLLMResponse(response);
+      const mergedContent = mergeTranslatedContent(fields, translatedData, translatableFields);
+      const uidFields = findUIDFields(contentType);
+      const translatedUIDs = await generateUIDsForTranslatedFields(
+        uidFields,
+        translatedData,
+        contentType.uid,
+        mergedContent
+      );
+      return {
+        data: {
+          ...mergedContent,
+          ...translatedUIDs
+        },
+        meta: {
+          ok: true,
+          status: 200,
+          message: "Translation completed successfully"
+        }
+      };
+    } catch (error) {
+      strapi2.log.error("LLM translation error:", error);
+      return {
+        data: fields,
+        // Return original fields in case of error
+        meta: {
+          ok: false,
+          status: 500,
+          message: error instanceof Error ? error.message : "Translation failed"
+        }
+      };
+    }
+  }
+});
+const buildPrompt = (fields, targetLanguage) => {
+  return `You are translating content from a CMS. Please translate the following JSON data to ${targetLanguage}.
+
+IMPORTANT RULES:
+1. Preserve all JSON structure and keys exactly as provided
+2. Only translate string values
+3. Maintain any markdown formatting within the text
+4. Keep HTML tags intact if present
+5. Preserve any special characters or placeholders
+6. Return ONLY the translated JSON object
+7. Ensure the JSON is valid and well-formed. Keep arrays and nested objects intact
+8. Do not add any explanations or comments
+9. Ensure professional and culturally appropriate translations
+
+SOURCE JSON:
+${JSON.stringify(fields, null, 2)}`;
+};
+const getUserConfig = async () => {
+  const pluginStore = strapi.store({
+    environment: strapi.config.environment,
+    type: "plugin",
+    name: "strapi-plugins-translate"
+  });
+  const config2 = await pluginStore.get({ key: "configuration" });
+  return config2;
+};
+const buildSystemPrompt = async (userConfig) => {
+  return `${userConfig?.systemPrompt || DEFAULT_SYSTEM_PROMPT} ${SYSTEM_PROMPT_APPENDIX}`;
+};
+const createLLMRequest = (messages, temperature = 0.1) => {
+  return llmClient.chat.completions.create({
+    model: LLM_MODEL,
+    messages,
+    temperature,
+    response_format: { type: "json_object" }
+  });
+};
+const callLLMProvider = async (prompt, systemPrompt, userConfig) => {
+  return createLLMRequest(
+    [
+      {
+        role: "system",
+        content: systemPrompt
+      },
+      {
+        role: "user",
+        content: prompt
+      }
+    ],
+    userConfig?.temperature ?? DEFAULT_LLM_TEMPERATURE
+  );
+};
+const requestJSONCorrection = async (invalidJson) => {
+  const response = await createLLMRequest([
+    {
+      role: "system",
+      content: SYSTEM_PROMPT_FIX
+    },
+    {
+      role: "user",
+      content: `${USER_PROMPT_FIX_PREFIX} ${invalidJson}`
+    }
+  ]);
+  const correctedContent = response.choices[0]?.message?.content;
+  if (!correctedContent) throw new Error("No content in correction response");
+  return safeJSONParse(correctedContent.trim());
+};
+const parseLLMResponse = async (response) => {
+  try {
+    const content = response.choices[0]?.message?.content;
+    if (!content) throw new Error("No content in response");
+    const cleanContent = cleanJSONString(content);
+    const jsonContent = extractJSONObject(cleanContent);
+    try {
+      return safeJSONParse(jsonContent);
+    } catch (parseError) {
+      const balancedContent = balanceJSONBraces(jsonContent);
+      try {
+        return safeJSONParse(balancedContent);
+      } catch (secondError) {
+        console.error("Second parse attempt failed:", secondError);
+        return await requestJSONCorrection(cleanContent);
+      }
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Translation failed: ${errorMessage}`);
+  }
+};
+const services = {
+  "llm-service": llmService
+};
+const plugin = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+module.exports = plugin;