@vocab/phrase 0.0.0-phrase-pull-dev-language-202281412540

package/src/pull-translations.test.ts

@@ -0,0 +1,250 @@
+import path from 'path';
+import { pull } from './pull-translations';
+import { pullAllTranslations } from './phrase-api';
+import { writeFile } from './file';
+import { GeneratedLanguageTarget, LanguageTarget } from '@vocab/types';
+
+jest.mock('./file', () => ({
+  writeFile: jest.fn(() => Promise.resolve),
+  mkdir: jest.fn(() => Promise.resolve),
+}));
+
+jest.mock('./phrase-api', () => ({
+  ensureBranch: jest.fn(() => Promise.resolve()),
+  pullAllTranslations: jest.fn(() => Promise.resolve({ en: {}, fr: {} })),
+}));
+
+const devLanguage = 'en';
+
+function runPhrase(options: {
+  languages: LanguageTarget[];
+  generatedLanguages: GeneratedLanguageTarget[];
+}) {
+  return pull(
+    { branch: 'tester' },
+    {
+      ...options,
+      devLanguage,
+      projectRoot: path.resolve(__dirname, '..', '..', '..', 'fixtures/phrase'),
+    },
+  );
+}
+
+describe('pull translations', () => {
+  describe('when pulling translations for languages that already have translations', () => {
+    beforeEach(() => {
+      (pullAllTranslations as jest.Mock).mockClear();
+      (writeFile as jest.Mock).mockClear();
+      (pullAllTranslations as jest.Mock).mockImplementation(() =>
+        Promise.resolve({
+          en: {
+            'hello.mytranslations': {
+              message: 'Hi there',
+            },
+          },
+          fr: {
+            'hello.mytranslations': {
+              message: 'merci',
+            },
+          },
+        }),
+      );
+    });
+
+    const options = {
+      languages: [{ name: 'en' }, { name: 'fr' }],
+      generatedLanguages: [
+        {
+          name: 'generatedLanguage',
+          extends: 'en',
+          generator: {
+            transformMessage: (message: string) => `[${message}]`,
+          },
+        },
+      ],
+    };
+
+    it('should resolve', async () => {
+      await expect(runPhrase(options)).resolves.toBeUndefined();
+
+      expect(writeFile as jest.Mock).toHaveBeenCalledTimes(2);
+    });
+
+    it('should update keys', async () => {
+      await expect(runPhrase(options)).resolves.toBeUndefined();
+
+      expect(
+        (writeFile as jest.Mock).mock.calls.map(
+          ([_filePath, contents]: [string, string]) => JSON.parse(contents),
+        ),
+      ).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "hello": Object {
+            "message": "Hi there",
+          },
+          "world": Object {
+            "message": "world",
+          },
+        },
+        Object {
+          "hello": Object {
+            "message": "merci",
+          },
+          "world": Object {
+            "message": "monde",
+          },
+        },
+      ]
+    `);
+    });
+  });
+
+  describe('when pulling translations and some languages do not have any translations', () => {
+    beforeEach(() => {
+      (pullAllTranslations as jest.Mock).mockClear();
+      (writeFile as jest.Mock).mockClear();
+      (pullAllTranslations as jest.Mock).mockImplementation(() =>
+        Promise.resolve({
+          en: {
+            'hello.mytranslations': {
+              message: 'Hi there',
+            },
+          },
+          fr: {
+            'hello.mytranslations': {
+              message: 'merci',
+            },
+          },
+        }),
+      );
+    });
+
+    const options = {
+      languages: [{ name: 'en' }, { name: 'fr' }, { name: 'ja' }],
+      generatedLanguages: [
+        {
+          name: 'generatedLanguage',
+          extends: 'en',
+          generator: {
+            transformMessage: (message: string) => `[${message}]`,
+          },
+        },
+      ],
+    };
+
+    it('should resolve', async () => {
+      await expect(runPhrase(options)).resolves.toBeUndefined();
+
+      expect(writeFile as jest.Mock).toHaveBeenCalledTimes(2);
+    });
+
+    it('should update keys', async () => {
+      await expect(runPhrase(options)).resolves.toBeUndefined();
+
+      expect(
+        (writeFile as jest.Mock).mock.calls.map(
+          ([_filePath, contents]: [string, string]) => JSON.parse(contents),
+        ),
+      ).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "hello": Object {
+            "message": "Hi there",
+          },
+          "world": Object {
+            "message": "world",
+          },
+        },
+        Object {
+          "hello": Object {
+            "message": "merci",
+          },
+          "world": Object {
+            "message": "monde",
+          },
+        },
+      ]
+    `);
+    });
+  });
+
+  describe('when pulling translations and the project has not configured translations for the dev language', () => {
+    beforeEach(() => {
+      (pullAllTranslations as jest.Mock).mockClear();
+      (writeFile as jest.Mock).mockClear();
+      (pullAllTranslations as jest.Mock).mockImplementation(() =>
+        Promise.resolve({
+          fr: {
+            'hello.mytranslations': {
+              message: 'merci',
+            },
+          },
+        }),
+      );
+    });
+
+    const options = {
+      languages: [{ name: 'en' }, { name: 'fr' }],
+      generatedLanguages: [
+        {
+          name: 'generatedLanguage',
+          extends: 'en',
+          generator: {
+            transformMessage: (message: string) => `[${message}]`,
+          },
+        },
+      ],
+    };
+
+    it('should throw an error', async () => {
+      await expect(runPhrase(options)).rejects.toThrowError(
+        new Error(
+          'Phrase did not return any translations for dev language "en".\nEnsure you have configured your Phrase project for your dev language, and have pushed your translations.',
+        ),
+      );
+
+      expect(writeFile as jest.Mock).toHaveBeenCalledTimes(0);
+    });
+  });
+
+  describe('when pulling translations and there are no translations for the dev language', () => {
+    beforeEach(() => {
+      (pullAllTranslations as jest.Mock).mockClear();
+      (writeFile as jest.Mock).mockClear();
+      (pullAllTranslations as jest.Mock).mockImplementation(() =>
+        Promise.resolve({
+          en: {},
+          fr: {
+            'hello.mytranslations': {
+              message: 'merci',
+            },
+          },
+        }),
+      );
+    });
+
+    const options = {
+      languages: [{ name: 'en' }, { name: 'fr' }],
+      generatedLanguages: [
+        {
+          name: 'generatedLanguage',
+          extends: 'en',
+          generator: {
+            transformMessage: (message: string) => `[${message}]`,
+          },
+        },
+      ],
+    };
+
+    it('should throw an error', async () => {
+      await expect(runPhrase(options)).rejects.toThrowError(
+        new Error(
+          'Phrase did not return any translations for dev language "en".\nEnsure you have configured your Phrase project for your dev language, and have pushed your translations.',
+        ),
+      );
+
+      expect(writeFile as jest.Mock).toHaveBeenCalledTimes(0);
+    });
+  });
+});

package/src/pull-translations.ts

@@ -0,0 +1,119 @@
+import { writeFile, mkdir } from './file';
+import path from 'path';
+
+import {
+  loadAllTranslations,
+  getAltLanguageFilePath,
+  getAltLanguages,
+  getUniqueKey,
+} from '@vocab/core';
+import type { UserConfig } from '@vocab/types';
+
+import { pullAllTranslations, ensureBranch } from './phrase-api';
+import { trace } from './logger';
+
+interface PullOptions {
+  branch?: string;
+}
+
+export async function pull(
+  { branch = 'local-development' }: PullOptions,
+  config: UserConfig,
+) {
+  trace(`Pulling translations from branch ${branch}`);
+  await ensureBranch(branch);
+  const alternativeLanguages = getAltLanguages(config);
+  const allPhraseTranslations = await pullAllTranslations(branch);
+  trace(
+    `Pulling translations from Phrase for languages ${
+      config.devLanguage
+    } and ${alternativeLanguages.join(', ')}`,
+  );
+
+  const phraseLanguages = Object.keys(allPhraseTranslations);
+  const phraseLanguagesWithTranslations = phraseLanguages.filter((language) => {
+    const phraseTranslationsForLanguage = allPhraseTranslations[language];
+    return Object.keys(phraseTranslationsForLanguage).length > 0;
+  });
+
+  trace(
+    `Found Phrase translations for languages ${phraseLanguagesWithTranslations.join(
+      ', ',
+    )}`,
+  );
+  if (!phraseLanguagesWithTranslations.includes(config.devLanguage)) {
+    throw new Error(
+      `Phrase did not return any translations for dev language "${config.devLanguage}".\nEnsure you have configured your Phrase project for your dev language, and have pushed your translations.`,
+    );
+  }
+
+  const allVocabTranslations = await loadAllTranslations(
+    { fallbacks: 'none', includeNodeModules: false },
+    config,
+  );
+
+  for (const loadedTranslation of allVocabTranslations) {
+    const devTranslations = loadedTranslation.languages[config.devLanguage];
+
+    if (!devTranslations) {
+      throw new Error('No dev language translations loaded');
+    }
+
+    const defaultValues = { ...devTranslations };
+    const localKeys = Object.keys(defaultValues);
+
+    for (const key of localKeys) {
+      defaultValues[key] = {
+        ...defaultValues[key],
+        ...allPhraseTranslations[config.devLanguage][
+          getUniqueKey(key, loadedTranslation.namespace)
+        ],
+      };
+    }
+    await writeFile(
+      loadedTranslation.filePath,
+      `${JSON.stringify(defaultValues, null, 2)}\n`,
+    );
+
+    for (const alternativeLanguage of alternativeLanguages) {
+      if (alternativeLanguage in allPhraseTranslations) {
+        const altTranslations = {
+          ...loadedTranslation.languages[alternativeLanguage],
+        };
+        const phraseAltTranslations =
+          allPhraseTranslations[alternativeLanguage];
+
+        for (const key of localKeys) {
+          const phraseKey = getUniqueKey(key, loadedTranslation.namespace);
+          const phraseTranslationMessage =
+            phraseAltTranslations[phraseKey]?.message;
+
+          if (!phraseTranslationMessage) {
+            trace(
+              `Missing translation. No translation for key ${key} in phrase as ${phraseKey} in language ${alternativeLanguage}.`,
+            );
+            continue;
+          }
+
+          altTranslations[key] = {
+            ...altTranslations[key],
+            message: phraseTranslationMessage,
+          };
+        }
+
+        const altTranslationFilePath = getAltLanguageFilePath(
+          loadedTranslation.filePath,
+          alternativeLanguage,
+        );
+
+        await mkdir(path.dirname(altTranslationFilePath), {
+          recursive: true,
+        });
+        await writeFile(
+          altTranslationFilePath,
+          `${JSON.stringify(altTranslations, null, 2)}\n`,
+        );
+      }
+    }
+  }
+}

package/src/push-translations.test.ts

@@ -0,0 +1,77 @@
+import path from 'path';
+import { push } from './push-translations';
+import { pushTranslationsByLocale } from './phrase-api';
+import { writeFile } from './file';
+
+jest.mock('./file', () => ({
+  writeFile: jest.fn(() => Promise.resolve),
+  mkdir: jest.fn(() => Promise.resolve),
+}));
+
+jest.mock('./phrase-api', () => ({
+  ensureBranch: jest.fn(() => Promise.resolve()),
+  pushTranslationsByLocale: jest.fn(() => Promise.resolve({ en: {}, fr: {} })),
+}));
+
+function runPhrase() {
+  return push(
+    { branch: 'tester' },
+    {
+      devLanguage: 'en',
+      languages: [{ name: 'en' }, { name: 'fr' }],
+      generatedLanguages: [
+        {
+          name: 'generatedLanguage',
+          extends: 'en',
+          generator: {
+            transformMessage: (message: string) => `[${message}]`,
+          },
+        },
+      ],
+      projectRoot: path.resolve(__dirname, '..', '..', '..', 'fixtures/phrase'),
+    },
+  );
+}
+
+describe('push', () => {
+  beforeEach(() => {
+    (pushTranslationsByLocale as jest.Mock).mockClear();
+    (writeFile as jest.Mock).mockClear();
+  });
+
+  it('should resolve', async () => {
+    await expect(runPhrase()).resolves.toBeUndefined();
+
+    expect(pushTranslationsByLocale as jest.Mock).toHaveBeenCalledTimes(2);
+  });
+
+  it('should update keys', async () => {
+    await expect(runPhrase()).resolves.toBeUndefined();
+
+    expect(pushTranslationsByLocale as jest.Mock).toHaveBeenCalledWith(
+      {
+        'hello.mytranslations': {
+          message: 'Hello',
+        },
+        'world.mytranslations': {
+          message: 'world',
+        },
+      },
+      'en',
+      'tester',
+    );
+
+    expect(pushTranslationsByLocale as jest.Mock).toHaveBeenCalledWith(
+      {
+        'hello.mytranslations': {
+          message: 'Bonjour',
+        },
+        'world.mytranslations': {
+          message: 'monde',
+        },
+      },
+      'fr',
+      'tester',
+    );
+  });
+});

package/src/push-translations.ts

@@ -0,0 +1,55 @@
+import { TranslationsByLanguage } from './../../types/src/index';
+
+import { ensureBranch, pushTranslationsByLocale } from './phrase-api';
+import { trace } from './logger';
+import { loadAllTranslations, getUniqueKey } from '@vocab/core';
+import { UserConfig } from '@vocab/types';
+
+interface PushOptions {
+  branch: string;
+}
+
+/**
+ * Uploading to the Phrase API for each language. Adding a unique namespace to each key using file path they key came from
+ */
+export async function push({ branch }: PushOptions, config: UserConfig) {
+  const allLanguageTranslations = await loadAllTranslations(
+    { fallbacks: 'none', includeNodeModules: false },
+    config,
+  );
+  trace(`Pushing translations to branch ${branch}`);
+  const allLanguages = config.languages.map((v) => v.name);
+  await ensureBranch(branch);
+
+  trace(
+    `Pushing translations to phrase for languages ${allLanguages.join(', ')}`,
+  );
+
+  const phraseTranslations: TranslationsByLanguage = {};
+
+  for (const loadedTranslation of allLanguageTranslations) {
+    for (const language of allLanguages) {
+      const localTranslations = loadedTranslation.languages[language];
+      if (!localTranslations) {
+        continue;
+      }
+      if (!phraseTranslations[language]) {
+        phraseTranslations[language] = {};
+      }
+      for (const localKey of Object.keys(localTranslations)) {
+        const phraseKey = getUniqueKey(localKey, loadedTranslation.namespace);
+        phraseTranslations[language][phraseKey] = localTranslations[localKey];
+      }
+    }
+  }
+
+  for (const language of allLanguages) {
+    if (phraseTranslations[language]) {
+      await pushTranslationsByLocale(
+        phraseTranslations[language],
+        language,
+        branch,
+      );
+    }
+  }
+}