feat: refactor validation of api keys

AleksandrSl · AleksandrSl · commit 12cd90fe5ea1 · 2025-12-05T16:34:11.000+01:00
diff --git a/cmp/compiler/src/translators/lcp/lcp-translator.ts b/cmp/compiler/src/translators/lcp/lcp-translator.ts
@@ -4,8 +4,12 @@ import type { DictionarySchema, TranslatableEntry, Translator } from "../api";
 import { getSystemPrompt } from "./prompt";
 import { obj2xml, xml2obj } from "./xml2obj";
 import { shots } from "./shots";
-import { getLingoDotDevKey } from "./api-keys";
-import { createAiModel, getLocaleModel } from "./model-factory";
+import {
+  createAiModel,
+  getLocaleModel,
+  validateAndGetApiKeys,
+  type ValidatedApiKeys,
+} from "./model-factory";
 import { Logger } from "../../utils/logger";
 import { DEFAULT_TIMEOUTS, withTimeout } from "../../utils/timeout";
 
@@ -22,10 +26,16 @@ export interface LCPTranslatorConfig {
  * LCP-based translator using AI models
  */
 export class LCPTranslator implements Translator<LCPTranslatorConfig> {
+  private readonly validatedKeys: ValidatedApiKeys;
+
   constructor(
     readonly config: LCPTranslatorConfig,
     private logger: Logger,
-  ) {}
+  ) {
+    this.logger.info("Validating API keys for translation...");
+    this.validatedKeys = validateAndGetApiKeys(config.models);
+    this.logger.info("✅ API keys validated successfully");
+  }
 
   /**
    * Translate multiple entries
@@ -127,10 +137,10 @@ export class LCPTranslator implements Translator<LCPTranslatorConfig> {
   ): Promise<DictionarySchema> {
     this.logger.debug(`[TRACE-LCP] translateWithLingoDotDev() called`);
 
-    const apiKey = getLingoDotDevKey();
+    const apiKey = this.validatedKeys["lingo.dev"];
     if (!apiKey) {
       throw new Error(
-        "⚠️  Lingo.dev API key not found. Please set LINGODOTDEV_API_KEY environment variable.",
+        "Internal error: Lingo.dev API key not found after validation. Please restart the service.",
       );
     }
 
@@ -197,7 +207,7 @@ export class LCPTranslator implements Translator<LCPTranslatorConfig> {
       `Using LLM ("${localeModel.provider}":"${localeModel.name}") to translate from "${this.config.sourceLocale}" to "${targetLocale}"`,
     );
 
-    const aiModel = createAiModel(localeModel);
+    const aiModel = createAiModel(localeModel, this.validatedKeys);
 
     try {
       const response = await withTimeout(
diff --git a/cmp/compiler/src/translators/lcp/model-factory.ts b/cmp/compiler/src/translators/lcp/model-factory.ts
@@ -8,18 +8,89 @@ import { createOpenRouter } from "@openrouter/ai-sdk-provider";
 import { createOllama } from "ollama-ai-provider";
 import { createMistral } from "@ai-sdk/mistral";
 import type { LanguageModel } from "ai";
-import {
-  getGoogleKey,
-  getGroqKey,
-  getMistralKey,
-  getOpenRouterKey,
-} from "./api-keys";
-
-type LocaleModel = {
+import { getKeyFromEnv } from "./api-keys";
+
+export type LocaleModel = {
   provider: string;
   name: string;
 };
 
+/**
+ * Pre-validated API keys for all providers
+ * Keys are fetched and validated once at initialization
+ */
+export type ValidatedApiKeys = Record<string, string>;
+
+/**
+ * Provider configuration including env var names and requirements
+ */
+type ProviderConfig = {
+  name: string; // Display name (e.g., "Groq", "Google")
+  apiKeyEnvVar?: string; // Environment variable name (e.g., "GROQ_API_KEY")
+  apiKeyConfigKey?: string; // Config key if applicable (e.g., "llm.groqApiKey")
+  getKeyLink: string; // Link to get API key
+  docsLink: string; // Link to API docs for troubleshooting
+};
+
+export const providerDetails: Record<string, ProviderConfig> = {
+  groq: {
+    name: "Groq",
+    apiKeyEnvVar: "GROQ_API_KEY",
+    apiKeyConfigKey: "llm.groqApiKey",
+    getKeyLink: "https://groq.com",
+    docsLink: "https://console.groq.com/docs/errors",
+  },
+  google: {
+    name: "Google",
+    apiKeyEnvVar: "GOOGLE_API_KEY",
+    apiKeyConfigKey: "llm.googleApiKey",
+    getKeyLink: "https://ai.google.dev/",
+    docsLink: "https://ai.google.dev/gemini-api/docs/troubleshooting",
+  },
+  openai: {
+    name: "OpenAI",
+    apiKeyEnvVar: "OPENAI_API_KEY",
+    apiKeyConfigKey: "llm.openaiApiKey",
+    getKeyLink: "https://platform.openai.com/account/api-keys",
+    docsLink: "https://platform.openai.com/docs",
+  },
+  anthropic: {
+    name: "Anthropic",
+    apiKeyEnvVar: "ANTHROPIC_API_KEY",
+    apiKeyConfigKey: "llm.anthropicApiKey",
+    getKeyLink: "https://console.anthropic.com/get-api-key",
+    docsLink: "https://console.anthropic.com/docs",
+  },
+  openrouter: {
+    name: "OpenRouter",
+    apiKeyEnvVar: "OPENROUTER_API_KEY",
+    apiKeyConfigKey: "llm.openrouterApiKey",
+    getKeyLink: "https://openrouter.ai",
+    docsLink: "https://openrouter.ai/docs",
+  },
+  ollama: {
+    name: "Ollama",
+    apiKeyEnvVar: undefined, // Ollama doesn't require an API key
+    apiKeyConfigKey: undefined, // Ollama doesn't require an API key
+    getKeyLink: "https://ollama.com/download",
+    docsLink: "https://github.com/ollama/ollama/tree/main/docs",
+  },
+  mistral: {
+    name: "Mistral",
+    apiKeyEnvVar: "MISTRAL_API_KEY",
+    apiKeyConfigKey: "llm.mistralApiKey",
+    getKeyLink: "https://console.mistral.ai",
+    docsLink: "https://docs.mistral.ai",
+  },
+  "lingo.dev": {
+    name: "Lingo.dev",
+    apiKeyEnvVar: "LINGODOTDEV_API_KEY",
+    apiKeyConfigKey: "auth.apiKey",
+    getKeyLink: "https://lingo.dev",
+    docsLink: "https://lingo.dev/docs",
+  },
+};
+
 /**
  * Get provider and model for a specific locale pair
  */
@@ -68,61 +139,128 @@ export function parseModelString(modelString: string): LocaleModel | undefined {
 }
 
 /**
- * Create AI model instance from provider and model ID
+ * Validate and fetch all necessary API keys for the given configuration
+ * This should be called once at initialization time
  *
- * @param model Provider name (groq, google, openrouter, ollama, mistral) and model identifier as an object
- * @returns LanguageModel instance
- * @throws Error if provider is not supported or API key is missing
+ * @param config Model configuration ("lingo.dev" or locale-pair mapping)
+ * @returns Validated API keys (provider ID -> API key)
+ * @throws Error if required keys are missing
  */
-export function createAiModel(model: LocaleModel): LanguageModel {
-  switch (model.provider) {
-    case "groq": {
-      const apiKey = getGroqKey();
-      if (!apiKey) {
-        throw new Error(
-          "⚠️  GROQ API key not found. Please set GROQ_API_KEY environment variable.",
-        );
+export function validateAndGetApiKeys(
+  config: "lingo.dev" | Record<string, string>,
+): ValidatedApiKeys {
+  const keys: ValidatedApiKeys = {};
+  const missingKeys: Array<{ provider: string; envVar: string }> = [];
+
+  // Determine which providers are configured
+  let providersToValidate: string[];
+
+  if (config === "lingo.dev") {
+    // Only need lingo.dev provider
+    providersToValidate = ["lingo.dev"];
+  } else {
+    // Extract unique providers from model strings
+    const providerSet = new Set<string>();
+    Object.values(config).forEach((modelString) => {
+      const model = parseModelString(modelString);
+      if (model) {
+        providerSet.add(model.provider);
       }
-      return createGroq({ apiKey })(model.name);
+    });
+    providersToValidate = Array.from(providerSet);
+  }
+
+  // Validate and fetch keys for each provider
+  for (const provider of providersToValidate) {
+    const providerConfig = providerDetails[provider];
+
+    if (!providerConfig) {
+      throw new Error(
+        `⚠️  Unknown provider "${provider}". Supported providers: ${Object.keys(providerDetails).join(", ")}`,
+      );
     }
 
-    case "google": {
-      const apiKey = getGoogleKey();
-      if (!apiKey) {
-        throw new Error(
-          "⚠️  Google API key not found. Please set GOOGLE_GENERATIVE_AI_API_KEY environment variable.",
-        );
-      }
-      return createGoogleGenerativeAI({ apiKey })(model.name);
+    // Skip providers that don't require keys (like Ollama)
+    if (!providerConfig.apiKeyEnvVar) {
+      continue;
     }
 
-    case "openrouter": {
-      const apiKey = getOpenRouterKey();
-      if (!apiKey) {
-        throw new Error(
-          "⚠️  OpenRouter API key not found. Please set OPENROUTER_API_KEY environment variable.",
-        );
-      }
-      return createOpenRouter({ apiKey })(model.name);
+    const key = getKeyFromEnv(providerConfig.apiKeyEnvVar);
+    if (key) {
+      keys[provider] = key;
+    } else {
+      missingKeys.push({
+        provider: providerConfig.name,
+        envVar: providerConfig.apiKeyEnvVar,
+      });
     }
+  }
 
-    case "ollama": {
+  // If any keys are missing, throw with detailed error
+  if (missingKeys.length > 0) {
+    const errorLines = missingKeys.map(
+      ({ provider, envVar }) => `  - ${provider}: ${envVar}`,
+    );
+    throw new Error(
+      `⚠️  Missing API keys for configured providers:\n${errorLines.join("\n")}\n\nPlease set the required environment variables.`,
+    );
+  }
+
+  return keys;
+}
+
+/**
+ * Create AI model instance from provider and model ID
+ *
+ * @param model Provider name (groq, google, openrouter, ollama, mistral) and model identifier
+ * @param validatedKeys Pre-validated API keys from validateAndFetchApiKeys()
+ * @returns LanguageModel instance
+ * @throws Error if provider is not supported or API key is missing
+ */
+export function createAiModel(
+  model: LocaleModel,
+  validatedKeys: ValidatedApiKeys,
+): LanguageModel {
+  const providerConfig = providerDetails[model.provider];
+
+  if (!providerConfig) {
+    throw new Error(
+      `⚠️  Provider "${model.provider}" is not supported. Supported providers: ${Object.keys(providerDetails).join(", ")}`,
+    );
+  }
+
+  // Get API key if required
+  const apiKey = providerConfig.apiKeyEnvVar
+    ? validatedKeys[model.provider]
+    : undefined;
+
+  // Verify key is present for providers that require it
+  if (providerConfig.apiKeyEnvVar && !apiKey) {
+    throw new Error(
+      `⚠️  ${providerConfig.name} API key not found. Please set ${providerConfig.apiKeyEnvVar} environment variable.\n\n` +
+        `This should not happen if validateAndFetchApiKeys() was called. Please restart the service.`,
+    );
+  }
+
+  // Create the appropriate model instance
+  switch (model.provider) {
+    case "groq":
+      return createGroq({ apiKey: apiKey! })(model.name);
+
+    case "google":
+      return createGoogleGenerativeAI({ apiKey: apiKey! })(model.name);
+
+    case "openrouter":
+      return createOpenRouter({ apiKey: apiKey! })(model.name);
+
+    case "ollama":
       return createOllama()(model.name);
-    }
 
-    case "mistral": {
-      const apiKey = getMistralKey();
-      if (!apiKey) {
-        throw new Error(
-          "⚠️  Mistral API key not found. Please set MISTRAL_API_KEY environment variable.",
-        );
-      }
-      return createMistral({ apiKey })(model.name);
-    }
+    case "mistral":
+      return createMistral({ apiKey: apiKey! })(model.name);
 
     default:
-      throw new Error(
-        `⚠️  Provider "${model.provider}" is not supported. Supported providers: groq, google, openrouter, ollama, mistral`,
-      );
+      // This should be unreachable due to check above
+      throw new Error(`⚠️  Provider "${model.provider}" is not implemented`);
   }
 }
diff --git a/cmp/compiler/src/translators/translation-service.ts b/cmp/compiler/src/translators/translation-service.ts
@@ -78,7 +78,6 @@ export interface TranslationError {
  */
 export class TranslationService {
   private useCache = true;
-  private pluralizationProcessed = false;
 
   constructor(
     private translator: Translator<any>,
@@ -104,13 +103,8 @@ export class TranslationService {
   ): Promise<TranslationResult> {
     const startTime = performance.now();
 
-    // TODO (AleksandrSl 04/12/2025): Think about how to avoid extra processing.
-    // Process pluralization ONCE for source locale metadata
-    // This transforms source text from "You have {count} items" to ICU format
-    if (
-      !this.pluralizationProcessed &&
-      this.config.pluralization?.enabled !== false
-    ) {
+    // TODO (AleksandrSl 05/12/2025): Most likely you don't need pluralization for the pseudo translation. We could move it as a part of the lcp translator
+    if (this.config.pluralization?.enabled !== false && !this.config.isPseudo) {
       this.logger.info(
         "Processing pluralization for source locale metadata...",
       );
@@ -125,7 +119,6 @@ export class TranslationService {
       this.logger.info(
         `Pluralization stats: ${pluralStats.pluralized} pluralized, ${pluralStats.rejected} rejected, ${pluralStats.failed} failed`,
       );
-      this.pluralizationProcessed = true;
     }
 
     // Skip translation if target is source locale
diff --git a/cmp/compiler/src/translators/translator-factory.ts b/cmp/compiler/src/translators/translator-factory.ts
