strapi-llm-translator 0.9.0

package/dist/server/index.js

@@ -0,0 +1,392 @@
+"use strict";
+const openai$1 = require("openai");
+const bootstrap = ({ strapi: strapi2 }) => {
+};
+const destroy = ({ strapi: strapi2 }) => {
+};
+const register = ({ strapi: strapi2 }) => {
+};
+const config = {
+  default: {
+    llmApiKey: process.env.LLM_TRANSLATOR_LLM_API_KEY,
+    llmEndpoint: process.env.STRAPI_ADMIN_LLM_TRANSLATOR_LLM_BASE_URL || "https://api.openai.com/v1/chat/completions",
+    llmModel: process.env.STRAPI_ADMIN_LLM_TRANSLATOR_LLM_MODEL || "gpt-4o"
+  },
+  validator() {
+    const {
+      LLM_TRANSLATOR_LLM_API_KEY,
+      STRAPI_ADMIN_LLM_TRANSLATOR_LLM_BASE_URL,
+      STRAPI_ADMIN_LLM_TRANSLATOR_LLM_MODEL
+    } = process.env;
+    if (!LLM_TRANSLATOR_LLM_API_KEY) {
+      throw new Error("LLM_TRANSLATOR_LLM_API_KEY is required");
+    }
+    if (!STRAPI_ADMIN_LLM_TRANSLATOR_LLM_BASE_URL) {
+      console.info(
+        "STRAPI_ADMIN_LLM_TRANSLATOR_LLM_BASE_URL is not set, using default: https://api.openai.com/v1/chat/completions"
+      );
+    } else {
+      console.info(
+        `STRAPI_ADMIN_LLM_TRANSLATOR_LLM_BASE_URL is set to: ${STRAPI_ADMIN_LLM_TRANSLATOR_LLM_BASE_URL}`
+      );
+    }
+    if (!STRAPI_ADMIN_LLM_TRANSLATOR_LLM_MODEL) {
+      console.info("STRAPI_ADMIN_LLM_TRANSLATOR_LLM_MODEL is not set, using default: gpt-4o");
+    } else {
+      console.info(
+        `STRAPI_ADMIN_LLM_TRANSLATOR_LLM_MODEL is set to: ${STRAPI_ADMIN_LLM_TRANSLATOR_LLM_MODEL}`
+      );
+    }
+  }
+};
+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-llm-translator").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-llm-translator"
+      // 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-llm-translator"
+      // replace with your plugin name
+    });
+    await pluginStore.set({
+      key: "configuration",
+      value: { ...body }
+    });
+    ctx.body = await pluginStore.get({ key: "configuration" });
+  }
+});
+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: []
+    }
+  }
+];
+const routes = {
+  admin: {
+    type: "admin",
+    routes: adminRoutes
+  }
+};
+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 openai = new openai$1.OpenAI({
+  baseURL: process.env.STRAPI_ADMIN_LLM_TRANSLATOR_LLM_BASE_URL,
+  apiKey: process.env.LLM_TRANSLATOR_LLM_API_KEY
+});
+const model = process.env.STRAPI_ADMIN_LLM_TRANSLATOR_LLM_MODEL;
+const isTranslatableField = (contentType, key, value) => {
+  if (typeof value !== "string") {
+    return false;
+  }
+  const fieldSchema = contentType?.attributes?.[key];
+  if (!fieldSchema) {
+    return false;
+  }
+  const isStringOrText = ["string", "text"].includes(fieldSchema.type);
+  const isNotUID = fieldSchema.type !== "uid";
+  const isLocalizable = fieldSchema.pluginOptions?.i18n?.localized !== false;
+  return isStringOrText && isNotUID && isLocalizable;
+};
+const extractTranslatableFields = (contentType, fields, components = {}) => {
+  const translatableFields = [];
+  Object.entries(fields).forEach(([key, value]) => {
+    if (isTranslatableField(contentType, key, value)) {
+      translatableFields.push({
+        path: [key],
+        value,
+        originalPath: [key]
+      });
+    }
+  });
+  if (fields.blocks && Array.isArray(fields.blocks)) {
+    fields.blocks.forEach((block, blockIndex) => {
+      if (block.__component && components[block.__component]) {
+        const componentSchema = components[block.__component];
+        Object.entries(componentSchema.attributes).forEach(([fieldName, schema]) => {
+          if (block[fieldName] && typeof block[fieldName] === "string" && ["string", "text", "richtext"].includes(schema.type)) {
+            translatableFields.push({
+              path: ["blocks", String(blockIndex), fieldName],
+              value: block[fieldName],
+              originalPath: ["blocks", String(blockIndex), fieldName]
+            });
+          }
+        });
+      }
+    });
+  }
+  return translatableFields;
+};
+const prepareTranslationPayload = (fields) => {
+  const payload = {};
+  fields.forEach((field) => {
+    let current = payload;
+    field.path.forEach((part, index2) => {
+      if (index2 === 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, index2) => {
+        if (index2 === 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, model, userConfig);
+      const translatedData = 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. Do not add any explanations or comments
+8. 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-llm-translator"
+  });
+  const config2 = await pluginStore.get({ key: "configuration" });
+  return config2;
+};
+const buildSystemPrompt = async (config2) => {
+  return `${config2.systemPrompt || DEFAULT_SYSTEM_PROMPT} ${SYSTEM_PROMPT_APPENDIX}`;
+};
+const callLLMProvider = async (prompt, systemPrompt, model2, config2) => {
+  const response = await openai.chat.completions.create({
+    model: model2,
+    messages: [
+      {
+        role: "system",
+        content: systemPrompt
+      },
+      {
+        role: "user",
+        content: prompt
+      }
+    ],
+    temperature: config2.temperature
+  });
+  return response;
+};
+const parseLLMResponse = (response) => {
+  try {
+    const content = response.choices[0]?.message?.content;
+    if (!content) throw new Error("No content in response");
+    const cleanContent = content.replace(/^```json\s*\n/, "").replace(/^```\s*\n/, "").replace(/\n\s*```$/, "").replace(/\u200B/g, "").replace(/[\u2018\u2019]/g, "'").replace(/[\u201C\u201D]/g, '"').trim();
+    try {
+      const parsed = JSON.parse(cleanContent);
+      if (typeof parsed === "object" && parsed !== null) {
+        return parsed;
+      }
+      throw new Error("Invalid response format - not an object");
+    } catch (parseError) {
+      const openBraces = (cleanContent.match(/{/g) || []).length;
+      const closeBraces = (cleanContent.match(/}/g) || []).length;
+      if (openBraces > closeBraces) {
+        const missingBraces = openBraces - closeBraces;
+        const fixedContent = cleanContent + "}".repeat(missingBraces);
+        try {
+          const parsed = JSON.parse(fixedContent);
+          if (typeof parsed === "object" && parsed !== null) {
+            return parsed;
+          }
+        } catch (secondError) {
+          console.error("Second parse attempt failed:", secondError);
+        }
+      }
+      throw new Error(`JSON parsing failed: ${parseError.message}`);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Translation failed: ${errorMessage}`);
+  }
+};
+const services = {
+  "llm-service": llmService
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+module.exports = index;