WIp

Author: AleksandrSl

cmp/compiler/src/plugin/build-translator.ts

@@ -11,12 +11,12 @@ import fs from "fs/promises";
 import path from "path";
 import type { LingoConfig, MetadataSchema } from "../types";
 import { logger } from "../utils/logger";
-import { getCachePath } from "../utils/path-helpers";
 import {
   startTranslationServer,
   type TranslationServer,
 } from "../translation-server";
 import { loadMetadata } from "../metadata/manager";
+import { LocalTranslationCache, type TranslationCache } from "../translators";
 
 export interface BuildTranslationOptions {
   config: LingoConfig;
@@ -82,14 +82,19 @@ export async function processBuildTranslations(
   const totalEntries = Object.keys(metadata.entries).length;
   logger.info(`📊 Found ${totalEntries} translatable entries`);
 
+  const cache = new LocalTranslationCache(
+    { cacheDir: config.lingoDir },
+    logger,
+  );
+
   // Handle cache-only mode
   if (buildMode === "cache-only") {
     logger.info("🔍 Validating translation cache...");
-    await validateCache(config, metadata);
+    await validateCache(config, metadata, cache);
     logger.info("✅ Cache validation passed");
 
     if (publicOutputPath) {
-      await copyStaticFiles(config, publicOutputPath, metadata);
+      await copyStaticFiles(config, publicOutputPath, metadata, cache);
     }
 
     return {
@@ -161,7 +166,7 @@ export async function processBuildTranslations(
 
     // Copy cache to public directory if requested
     if (publicOutputPath) {
-      await copyStaticFiles(config, publicOutputPath, metadata);
+      await copyStaticFiles(config, publicOutputPath, metadata, cache);
     }
 
     logger.info("✅ Translation generation completed successfully");
@@ -188,6 +193,7 @@ export async function processBuildTranslations(
 async function validateCache(
   config: LingoConfig,
   metadata: MetadataSchema,
+  cache: TranslationCache,
 ): Promise<void> {
   const allHashes = Object.keys(metadata.entries);
   const missingLocales: string[] = [];
@@ -204,13 +210,16 @@ async function validateCache(
     : config.targetLocales;
 
   for (const locale of allLocales) {
-    const cacheFilePath = getCachePath(config, locale);
-
     try {
-      const cacheContent = await fs.readFile(cacheFilePath, "utf-8");
-      const cache = JSON.parse(cacheContent).entries as Record<string, string>;
+      const entries = await cache.get(locale);
 
-      const missingHashes = allHashes.filter((hash) => !cache[hash]);
+      if (Object.keys(entries).length === 0) {
+        missingLocales.push(locale);
+        logger.debug(`Cache file not found or empty for ${locale}`);
+        continue;
+      }
+
+      const missingHashes = allHashes.filter((hash) => !entries[hash]);
 
       if (missingHashes.length > 0) {
         incompleteLocales.push({
@@ -228,7 +237,7 @@ async function validateCache(
       }
     } catch (error) {
       missingLocales.push(locale);
-      logger.debug(`Cache file not found for ${locale}: ${cacheFilePath}`);
+      logger.debug(`Failed to read cache for ${locale}:`, error);
     }
   }
 
@@ -270,6 +279,7 @@ async function copyStaticFiles(
   config: LingoConfig,
   publicOutputPath: string,
   metadata: MetadataSchema,
+  cache: TranslationCache,
 ): Promise<void> {
   logger.info(`📦 Generating static translation files in ${publicOutputPath}`);
 
@@ -285,20 +295,24 @@ async function copyStaticFiles(
     : config.targetLocales;
 
   for (const locale of allLocales) {
-    const cacheFilePath = getCachePath(config, locale);
     const publicFilePath = path.join(publicOutputPath, `${locale}.json`);
 
     try {
-      const cacheContent = await fs.readFile(cacheFilePath, "utf-8");
-      const cache = JSON.parse(cacheContent);
+      // Use getDictionary if available (for LocalTranslationCache), otherwise use get
+      const dictionary = cache.getDictionary
+        ? await cache.getDictionary(locale)
+        : null;
+
+      if (!dictionary) {
+        logger.error(`❌ Failed to read cache for ${locale}`);
+        process.exit(1);
+      }
 
       const filteredEntries: Record<string, string> = {};
       let includedCount = 0;
       let skippedCount = 0;
 
-      for (const [hash, translation] of Object.entries(
-        cache.entries as Record<string, string>,
-      )) {
+      for (const [hash, translation] of Object.entries(dictionary.entries)) {
         if (usedHashes.has(hash)) {
           filteredEntries[hash] = translation;
           includedCount++;
@@ -311,7 +325,7 @@ async function copyStaticFiles(
       const outputData = {
         locale,
         entries: filteredEntries,
-        version: cache.version,
+        version: dictionary.version,
       };
 
       await fs.writeFile(

cmp/compiler/src/translation-server/translation-server.ts

@@ -95,10 +95,7 @@ export class TranslationServer {
     const isPseudo = translator.constructor.name === "PseudoTranslator";
 
     const cache = new LocalTranslationCache(
-      {
-        cacheDir: this.config.lingoDir,
-        sourceRoot: this.config.sourceRoot,
-      },
+      { cacheDir: this.config.lingoDir },
       this.logger,
     );
 

cmp/compiler/src/translators/cache.ts

@@ -42,19 +42,29 @@ export interface TranslationCache {
    * Clear all cached translations
    */
   clearAll(): Promise<void>;
+
+  /**
+   * Get full dictionary schema for a locale (includes version, metadata)
+   * Used for build-time operations that need the complete schema
+   * Returns null if cache doesn't exist
+   */
+  getDictionary?(
+    locale: string,
+  ): Promise<import("./api").DictionarySchema | null>;
+
+  /**
+   * Write full dictionary schema for a locale
+   * Used for build-time operations that need to preserve schema metadata
+   */
+  setDictionary?(
+    locale: string,
+    dictionary: import("./api").DictionarySchema,
+  ): Promise<void>;
 }
 
 /**
  * Configuration for local disk cache
  */
 export interface LocalCacheConfig {
-  /**
-   * Directory to store cache files (e.g., ".lingo")
-   */
   cacheDir: string;
-
-  /**
-   * Optional source root path
-   */
-  sourceRoot?: string;
 }

cmp/compiler/src/translators/local-cache.ts

@@ -23,24 +23,15 @@ export class LocalTranslationCache implements TranslationCache {
     this.config = config;
   }
 
-  /**
-   * Get cache file path for a locale
-   */
   private getCachePath(locale: string): string {
-    const baseDir = this.config.sourceRoot
-      ? path.join(process.cwd(), this.config.sourceRoot, this.config.cacheDir)
-      : path.join(process.cwd(), this.config.cacheDir);
-
-    return path.join(baseDir, "cache", `${locale}.json`);
+    return path.join(this.config.cacheDir, `${locale}.json`);
   }
 
   /**
    * Read dictionary file from disk
    * Times out after 10 seconds to prevent indefinite hangs
    */
-  private async readDictionary(
-    locale: string,
-  ): Promise<DictionarySchema | null> {
+  async getDictionary(locale: string): Promise<DictionarySchema | null> {
     try {
       const cachePath = this.getCachePath(locale);
       const content = await withTimeout(
@@ -58,7 +49,7 @@ export class LocalTranslationCache implements TranslationCache {
    * Write dictionary file to disk
    * Times out after 10 seconds to prevent indefinite hangs
    */
-  private async writeDictionary(
+  async setDictionary(
     locale: string,
     dictionary: DictionarySchema,
   ): Promise<void> {
@@ -89,7 +80,7 @@ export class LocalTranslationCache implements TranslationCache {
    * Get cached translations for a locale
    */
   async get(locale: string): Promise<Record<string, string>> {
-    const dictionary = await this.readDictionary(locale);
+    const dictionary = await this.getDictionary(locale);
     if (!dictionary) {
       return {};
     }
@@ -126,7 +117,7 @@ export class LocalTranslationCache implements TranslationCache {
       entries: translations,
     };
 
-    await this.writeDictionary(locale, dictionary);
+    await this.setDictionary(locale, dictionary);
   }
 
   /**
@@ -159,17 +150,12 @@ export class LocalTranslationCache implements TranslationCache {
    */
   async clearAll(): Promise<void> {
     try {
-      const baseDir = this.config.sourceRoot
-        ? path.join(process.cwd(), this.config.sourceRoot, this.config.cacheDir)
-        : path.join(process.cwd(), this.config.cacheDir);
-
-      const cacheDir = path.join(baseDir, "cache");
-      const files = await fs.readdir(cacheDir);
+      const files = await fs.readdir(this.config.cacheDir);
 
       await Promise.all(
         files
           .filter((file) => file.endsWith(".json"))
-          .map((file) => fs.unlink(path.join(cacheDir, file))),
+          .map((file) => fs.unlink(path.join(this.config.cacheDir, file))),
       );
     } catch {
       // Ignore errors if directory doesn't exist

cmp/compiler/src/types.ts

@@ -65,6 +65,8 @@ export interface PluralizationConfig {
   model?: string;
 }
 
+export type LingoEnvironment = "development" | "production";
+
 /**
  * Lingo config with all the defaults applied
  */
@@ -85,7 +87,7 @@ export type LingoConfig = {
    *
    * @default "production"
    */
-  environment: "development" | "production";
+  environment: LingoEnvironment;
 
   /**
    * The locale to translate from.