feat(cli): add missing check modes

Author: yslpn

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

@@ -1,12 +1,8 @@
 import { getTranslationsForCatalog } from "./getTranslationsForCatalog.js"
-import { Catalog } from "../catalog.js"
 import type { AllCatalogsType, CatalogType } from "../types.js"
 
-function getCatalogStub(
-  catalogs: AllCatalogsType,
-  template: CatalogType = {},
-): Catalog {
-  const catalogStub: Partial<Catalog> = {
+function getCatalogStub(catalogs: AllCatalogsType, template: CatalogType = {}) {
+  return {
     async readAll(): Promise<AllCatalogsType> {
       return catalogs
     },
@@ -15,8 +11,6 @@ function getCatalogStub(
       return template
     },
   }
-
-  return catalogStub as Catalog
 }
 
 function lang(
@@ -44,6 +38,18 @@ function message(id: string, source: string, noTranslation = false) {
   })
 }
 
+function obsoleteMessage(id: string, source: string, noTranslation = false) {
+  return (locale: string): CatalogType => ({
+    [id]: {
+      message: source,
+      translation: noTranslation
+        ? undefined
+        : `${locale}: translation: ${source}`,
+      obsolete: true,
+    },
+  })
+}
+
 describe("getTranslationsForCatalog", () => {
   it("Should return translated catalog if all translation exists", async () => {
     // prettier-ignore
@@ -418,4 +424,93 @@ describe("getTranslationsForCatalog", () => {
       }
     `)
   })
+
+  it("Should ignore obsolete messages that are not active anywhere", async () => {
+    // prettier-ignore
+    const catalogStub = getCatalogStub({
+      ...lang("pl", [
+        message("hashid1", "Lorem"),
+        obsoleteMessage("hashid2", "Ipsum", true)
+      ])
+    })
+
+    const actual = await getTranslationsForCatalog(catalogStub, "pl", {
+      sourceLocale: "en",
+      fallbackLocales: {},
+    })
+
+    expect(actual).toMatchInlineSnapshot(`
+      {
+        messages: {
+          hashid1: pl: translation: Lorem,
+        },
+        missing: [],
+      }
+    `)
+  })
+
+  it("Should not use obsolete target translations for active messages", async () => {
+    // prettier-ignore
+    const catalogStub = getCatalogStub({
+      ...lang("pl", [
+        obsoleteMessage("hashid1", "Lorem")
+      ])
+    }, lang("tpl", [
+      message("hashid1", "Lorem", true)
+    ]).tpl)
+
+    const actual = await getTranslationsForCatalog(catalogStub, "pl", {
+      sourceLocale: "en",
+      fallbackLocales: {},
+    })
+
+    expect(actual).toMatchInlineSnapshot(`
+      {
+        messages: {
+          hashid1: Lorem,
+        },
+        missing: [
+          {
+            id: hashid1,
+            source: Lorem,
+          },
+        ],
+      }
+    `)
+  })
+
+  it("Should not use obsolete fallback translations", async () => {
+    // prettier-ignore
+    const catalogStub = getCatalogStub({
+      ...lang("pl", [
+        obsoleteMessage("hashid1", "Lorem")
+      ]),
+      ...lang("ru", [
+        message("hashid1", "Lorem", true)
+      ])
+    }, lang("tpl", [
+      message("hashid1", "Lorem", true)
+    ]).tpl)
+
+    const actual = await getTranslationsForCatalog(catalogStub, "ru", {
+      sourceLocale: "en",
+      fallbackLocales: {
+        default: "pl",
+      },
+    })
+
+    expect(actual).toMatchInlineSnapshot(`
+      {
+        messages: {
+          hashid1: Lorem,
+        },
+        missing: [
+          {
+            id: hashid1,
+            source: Lorem,
+          },
+        ],
+      }
+    `)
+  })
 })

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

@@ -1,4 +1,3 @@
-import { Catalog } from "../catalog.js"
 import { FallbackLocales } from "@lingui/conf"
 import type { AllCatalogsType, CatalogType, MessageType } from "../types.js"
 import { getFallbackListForLocale } from "./getFallbackListForLocale.js"
@@ -10,14 +9,23 @@ export type TranslationMissingEvent = {
 
 export type MissingBehavior = "resolved" | "catalog"
 
+export function isMissingBehavior(value: string): value is MissingBehavior {
+  return value === "resolved" || value === "catalog"
+}
+
 export type GetTranslationsOptions = {
   sourceLocale: string
   fallbackLocales: FallbackLocales
   missingBehavior?: MissingBehavior
 }
 
+type CatalogTranslationsReader = {
+  readAll(locales: string[]): Promise<AllCatalogsType>
+  readTemplate(): Promise<CatalogType | undefined>
+}
+
 export async function getTranslationsForCatalog(
-  catalog: Catalog,
+  catalog: CatalogTranslationsReader,
   locale: string,
   options: GetTranslationsOptions,
 ) {
@@ -27,22 +35,24 @@ export async function getTranslationsForCatalog(
     ...getFallbackListForLocale(options.fallbackLocales, locale),
   ])
 
-  const [catalogs, template] = await Promise.all([
+  const [rawCatalogs, rawTemplate] = await Promise.all([
     catalog.readAll(Array.from(locales)),
     catalog.readTemplate(),
   ])
 
+  const catalogs = withoutObsolete(rawCatalogs)
+  const template = withoutObsoleteCatalog(rawTemplate)
   const sourceLocaleCatalog = catalogs[options.sourceLocale] || {}
 
   const input = { ...template, ...sourceLocaleCatalog, ...catalogs[locale] }
 
   const missing: TranslationMissingEvent[] = []
 
-  const messages = Object.keys(input).reduce<{ [id: string]: string }>(
-    (acc, key) => {
+  const messages = Object.entries(input).reduce<{ [id: string]: string }>(
+    (acc, [key, msg]) => {
       acc[key] = getTranslation(
         catalogs,
-        input[key]!,
+        msg,
         locale,
         key,
         (event) => {
@@ -61,12 +71,41 @@ export async function getTranslationsForCatalog(
   }
 }
 
+function isActiveMessage(
+  message: MessageType | undefined,
+): message is MessageType {
+  return Boolean(message && !message.obsolete)
+}
+
+function withoutObsolete(catalogs: AllCatalogsType): AllCatalogsType {
+  return Object.fromEntries(
+    Object.entries(catalogs).map(([locale, catalog]) => [
+      locale,
+      withoutObsoleteCatalog(catalog),
+    ]),
+  )
+}
+
+function withoutObsoleteCatalog(catalog: CatalogType | undefined): CatalogType {
+  const activeCatalog: CatalogType = {}
+
+  Object.entries(catalog ?? {}).forEach(([id, message]) => {
+    if (isActiveMessage(message)) {
+      activeCatalog[id] = message
+    }
+  })
+
+  return activeCatalog
+}
+
 function sourceLocaleFallback(catalog: CatalogType | undefined, key: string) {
-  if (!catalog?.[key]) {
+  const message = catalog?.[key]
+
+  if (!isActiveMessage(message)) {
     return undefined
   }
 
-  return catalog[key].translation || catalog[key].message
+  return message.translation || message.message
 }
 
 function getTranslation(
@@ -81,7 +120,13 @@ function getTranslation(
 
   const getCatalogTranslation = (_locale: string) => {
     const localeCatalog = catalogs[_locale]
-    return localeCatalog?.[key]?.translation
+    const message = localeCatalog?.[key]
+
+    if (!isActiveMessage(message)) {
+      return undefined
+    }
+
+    return message.translation
   }
 
   const getMultipleFallbacks = (_locale: string) => {

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

@@ -6,7 +6,7 @@ import {
   getTranslationsForCatalog,
   TranslationMissingEvent,
 } from "./getTranslationsForCatalog.js"
-import type { CatalogType } from "../types.js"
+import type { MissingBehavior } from "./getTranslationsForCatalog.js"
 
 export type MissingTranslationFinding = CheckFindingBase & {
   code: "missing_translation"
@@ -22,50 +22,24 @@ function createMissingTranslationMessage(messageId: string, source?: string) {
 export async function getCatalogTranslationsWithMissing(
   catalog: Catalog,
   locale: string,
+  missingBehavior: MissingBehavior = "resolved",
 ) {
   const { messages, missing } = await getTranslationsForCatalog(
     catalog,
     locale,
     {
       fallbackLocales: catalog.config.fallbackLocales,
       sourceLocale: catalog.config.sourceLocale,
-      missingBehavior: "catalog",
+      missingBehavior,
     },
   )
 
-  const [selectedCatalog, sourceLocaleCatalog, templateCatalog] =
-    await Promise.all([
-      catalog.read(locale),
-      catalog.read(catalog.config.sourceLocale),
-      catalog.readTemplate(),
-    ])
-
-  const activeMessageIds = getActiveMessageIds(
-    selectedCatalog,
-    sourceLocaleCatalog,
-    templateCatalog,
-  )
-
   return {
     messages,
-    missing: missing.filter((entry) => activeMessageIds.has(entry.id)),
+    missing,
   }
 }
 
-function getActiveMessageIds(...catalogs: Array<CatalogType | undefined>) {
-  const activeMessageIds = new Set<string>()
-
-  catalogs.forEach((catalog) => {
-    Object.entries(catalog ?? {}).forEach(([id, message]) => {
-      if (!message.obsolete) {
-        activeMessageIds.add(id)
-      }
-    })
-  })
-
-  return activeMessageIds
-}
-
 export function createMissingTranslationFinding(
   catalog: Catalog,
   locale: string,

packages/cli/src/api/check/index.ts

@@ -8,22 +8,36 @@ import {
   checkSpecificOptions,
 } from "./types.js"
 
-const registeredChecks = [
-  syncCheck,
-  missingCheck,
-] as const satisfies readonly CheckDefinition[]
+export const checkDefinitionsByName = {
+  sync: syncCheck,
+  missing: missingCheck,
+} satisfies Record<CheckName, CheckDefinition>
 
-export const checkDefinitionsByName: Record<CheckName, CheckDefinition> =
-  Object.fromEntries(
-    registeredChecks.map((check) => [check.name, check]),
-  ) as Record<CheckName, CheckDefinition>
+const registeredChecks: readonly CheckDefinition[] = [
+  checkDefinitionsByName.sync,
+  checkDefinitionsByName.missing,
+]
 
 export function getRegisteredChecks(): readonly CheckDefinition[] {
   return registeredChecks
 }
 
 function getSupportedOptions(check: CheckDefinition) {
-  return check.cli.options.map((option) => option.name)
+  return check.cli.options.map((option) => option.runOption)
+}
+
+function getCliOptionName(option: CheckSpecificOption) {
+  for (const check of registeredChecks) {
+    const cliOption = check.cli.options.find(
+      (currentOption) => currentOption.runOption === option,
+    )
+
+    if (cliOption) {
+      return cliOption.name
+    }
+  }
+
+  return option
 }
 
 function findSupportedCheck(option: CheckSpecificOption): CheckName {
@@ -48,17 +62,22 @@ export function validateSupportedOptions(
     }
 
     const supportedCheck = findSupportedCheck(option)
+    const cliOptionName = getCliOptionName(option)
 
     throw new Error(
-      `Option \`--${option}\` can only be used with the \`${supportedCheck}\` check.`,
+      `Option \`--${cliOptionName}\` can only be used with the \`${supportedCheck}\` check.`,
     )
   })
 }
 
+function isCheckName(inputCheck: string): inputCheck is CheckName {
+  return inputCheck === "sync" || inputCheck === "missing"
+}
+
 export function getCheck(inputCheck: string): CheckDefinition {
-  if (!(inputCheck in checkDefinitionsByName)) {
+  if (!isCheckName(inputCheck)) {
     throw new Error(`Unknown check ${inputCheck}.`)
   }
 
-  return checkDefinitionsByName[inputCheck as CheckName]
+  return checkDefinitionsByName[inputCheck]
 }