feat: failOnMissing & failOnCompileError for loaders + compiler (#2198)

Co-authored-by: Kevin Hahn <kevin_hahn@sil.org>

Author: timofei-iatsenko

packages/cli/src/api/__snapshots__/catalog.test.ts.snap

@@ -2,8 +2,20 @@
 
 exports[`Catalog POT Flow Should get translations from template if locale file not presented 1`] = `
 {
-  2ZeN02: Test String,
-  mY42CM: Hello World,
+  messages: {
+    2ZeN02: Test String,
+    mY42CM: Hello World,
+  },
+  missing: [
+    {
+      id: mY42CM,
+      source: Hello World,
+    },
+    {
+      id: 2ZeN02,
+      source: Test String,
+    },
+  ],
 }
 `;
 

packages/cli/src/api/catalog.test.ts

@@ -638,11 +638,11 @@ describe("writeCompiled", () => {
   ])(
     "Should save namespace $namespace in $extension extension",
     async ({ namespace, extension }) => {
-      const compiledCatalog = createCompiledCatalog("en", {}, { namespace })
+      const { source } = createCompiledCatalog("en", {}, { namespace })
       // Test that the file extension of the compiled catalog is `.mjs`
-      expect(
-        await catalog.writeCompiled("en", compiledCatalog, namespace)
-      ).toMatch(extension)
+      expect(await catalog.writeCompiled("en", source, namespace)).toMatch(
+        extension
+      )
     }
   )
 })

packages/cli/src/api/catalog.ts

@@ -12,6 +12,7 @@ import { CompiledCatalogNamespace } from "./compile"
 import {
   getTranslationsForCatalog,
   GetTranslationsOptions,
+  TranslationMissingEvent,
 } from "./catalog/getTranslationsForCatalog"
 import { mergeCatalog } from "./catalog/mergeCatalog"
 import { extractFromFiles } from "./catalog/extractFromFiles"
@@ -177,8 +178,23 @@ export class Catalog {
     )
   }
 
-  async getTranslations(locale: string, options: GetTranslationsOptions) {
-    return await getTranslationsForCatalog(this, locale, options)
+  async getTranslations(
+    locale: string,
+    options: Omit<GetTranslationsOptions, "onMissing">
+  ) {
+    const missing: TranslationMissingEvent[] = []
+
+    const messages = await getTranslationsForCatalog(this, locale, {
+      ...options,
+      onMissing: (event) => {
+        missing.push(event)
+      },
+    })
+
+    return {
+      missing,
+      messages,
+    }
   }
 
   async write(

packages/cli/src/api/compile.test.ts

@@ -190,7 +190,7 @@ describe("createCompiledCatalog", () => {
         {
           namespace,
         }
-      )
+      ).source
 
     it("should compile with json", () => {
       expect(getCompiledCatalog("json")).toMatchSnapshot()
@@ -229,7 +229,7 @@ describe("createCompiledCatalog", () => {
         {
           strict,
         }
-      )
+      ).source
 
     it("should return message key as a fallback translation", () => {
       expect(getCompiledCatalog(false)).toMatchSnapshot()
@@ -250,7 +250,7 @@ describe("createCompiledCatalog", () => {
         {
           pseudoLocale,
         }
-      )
+      ).source
 
     it("should return catalog with pseudolocalized messages", () => {
       expect(getCompiledCatalog("ps")).toMatchSnapshot()
@@ -269,7 +269,7 @@ describe("createCompiledCatalog", () => {
           Hello: "Alohà",
         },
         opts
-      )
+      ).source
 
     it("by default should return catalog without ASCII chars", () => {
       expect(getCompiledCatalog()).toMatchSnapshot()
@@ -287,4 +287,30 @@ describe("createCompiledCatalog", () => {
       ).toMatchSnapshot()
     })
   })
+
+  it("should return list of compile errors", () => {
+    const res = createCompiledCatalog(
+      "ru",
+      {
+        Hello: "{plural,  }",
+        Second: "{bla, }",
+      },
+      {}
+    )
+
+    expect(res.errors).toHaveLength(2)
+    expect(res.errors[0]).toMatchObject({
+      id: "Hello",
+      source: "{plural,  }",
+    })
+
+    expect(res.errors[0].error.message).toContain("invalid syntax at line")
+
+    expect(res.errors[1]).toMatchObject({
+      id: "Second",
+      source: "{bla, }",
+    })
+
+    expect(res.errors[1].error.message).toContain("invalid syntax at line")
+  })
 })

packages/cli/src/api/compile.ts

@@ -1,8 +1,8 @@
 import * as t from "@babel/types"
 import generate, { GeneratorOptions } from "@babel/generator"
 import {
-  compileMessage,
   CompiledMessage,
+  compileMessageOrThrow,
 } from "@lingui/message-utils/compileMessage"
 import pseudoLocalize from "./pseudoLocalize"
 
@@ -19,11 +19,26 @@ export type CreateCompileCatalogOptions = {
   compilerBabelOptions?: GeneratorOptions
 }
 
+export type MessageCompilationError = {
+  /**
+   * ID of the message in the Catalog
+   */
+  id: string
+  /**
+   * Message itself
+   */
+  source: string
+  /**
+   * Error associated with this message
+   */
+  error: Error
+}
+
 export function createCompiledCatalog(
   locale: string,
   messages: CompiledCatalogType,
   options: CreateCompileCatalogOptions
-): string {
+): { source: string; errors: MessageCompilationError[] } {
   const {
     strict = false,
     namespace = "cjs",
@@ -32,18 +47,29 @@ export function createCompiledCatalog(
   } = options
   const shouldPseudolocalize = locale === pseudoLocale
 
+  const errors: MessageCompilationError[] = []
+
   const compiledMessages = Object.keys(messages).reduce<{
     [msgId: string]: CompiledMessage
   }>((obj, key: string) => {
     // Don't use `key` as a fallback translation in strict mode.
     const translation = (messages[key] || (!strict ? key : "")) as string
 
-    obj[key] = compile(translation, shouldPseudolocalize)
+    try {
+      obj[key] = compile(translation, shouldPseudolocalize)
+    } catch (e) {
+      errors.push({
+        id: key,
+        source: translation,
+        error: e as Error,
+      })
+    }
+
     return obj
   }, {})
 
   if (namespace === "json") {
-    return JSON.stringify({ messages: compiledMessages })
+    return { source: JSON.stringify({ messages: compiledMessages }), errors }
   }
 
   const ast = buildExportStatement(
@@ -63,7 +89,7 @@ export function createCompiledCatalog(
     ...compilerBabelOptions,
   }).code
 
-  return "/*eslint-disable*/" + code
+  return { source: "/*eslint-disable*/" + code, errors }
 }
 
 function buildExportStatement(
@@ -138,7 +164,7 @@ export function compile(
   message: string,
   shouldPseudolocalize: boolean = false
 ) {
-  return compileMessage(message, (value) =>
+  return compileMessageOrThrow(message, (value) =>
     shouldPseudolocalize ? pseudoLocalize(value) : value
   )
 }

packages/cli/src/api/index.ts

@@ -8,4 +8,8 @@ export {
   extractFromFileWithBabel,
 } from "./extractors/babel"
 export { getCatalogDependentFiles } from "./catalog/getCatalogDependentFiles"
+export {
+  createMissingErrorMessage,
+  createCompilationErrorMessage,
+} from "./messages"
 export * from "./types"

packages/cli/src/api/messages.test.ts

@@ -0,0 +1,66 @@
+import {
+  createCompilationErrorMessage,
+  createMissingErrorMessage,
+} from "./messages"
+
+describe("createMissingErrorMessage", () => {
+  it("should print correct missing message", async () => {
+    const message = createMissingErrorMessage(
+      "en",
+      [
+        {
+          id: "1",
+          source: "Hello",
+        },
+        {
+          id: "World",
+          source: "World",
+        },
+      ],
+      "bla bla"
+    )
+
+    expect(message).toMatchInlineSnapshot(`
+      Failed to compile catalog for locale en!
+
+      Missing 2 translation(s):
+
+      1: Hello
+      World: World
+
+    `)
+  })
+})
+
+describe("createCompilationErrorMessage", () => {
+  const errors = [
+    {
+      error: new Error("Syntax error"),
+      source: "Hello",
+      id: "1",
+    },
+    {
+      error: new Error("Syntax error"),
+      source: "World",
+      id: "World",
+    },
+  ]
+
+  it("should print correct compile error message", () => {
+    const message = createCompilationErrorMessage("en", errors)
+
+    expect(message).toMatchInlineSnapshot(`
+      Failed to compile catalog for locale en!
+
+      Compilation error for 2 translation(s):
+
+      1: Hello
+      Reason: Syntax error
+
+      World: World
+      Reason: Syntax error
+
+
+    `)
+  })
+})

packages/cli/src/api/messages.ts

@@ -0,0 +1,44 @@
+import { TranslationMissingEvent } from "./catalog/getTranslationsForCatalog"
+import chalk from "chalk"
+import { MessageCompilationError } from "./compile"
+
+export function createMissingErrorMessage(
+  locale: string,
+  missingMessages: TranslationMissingEvent[],
+  configurationMsg: string
+) {
+  let message = `Failed to compile catalog for locale ${chalk.bold(locale)}!
+
+Missing ${missingMessages.length} translation(s):
+\n`
+
+  missingMessages.forEach((missing) => {
+    const source =
+      missing.source || missing.source === missing.id
+        ? `: ${missing.source}`
+        : ""
+
+    message += `${missing.id}${source}\n`
+  })
+
+  return message
+}
+
+export function createCompilationErrorMessage(
+  locale: string,
+  errors: MessageCompilationError[]
+) {
+  let message = `Failed to compile catalog for locale ${chalk.bold(locale)}!
+
+Compilation error for ${errors.length} translation(s):
+\n`
+
+  errors.forEach((error) => {
+    const source =
+      error.source || error.source === error.id ? `: ${error.source}` : ""
+
+    message += `${error.id}${source}\nReason: ${error.error.message}\n\n`
+  })
+
+  return message
+}