@vocab/phrase 1.1.0 → 1.2.1

package/src/phrase-api.ts

@@ -1,181 +0,0 @@
-import FormData from 'form-data';
-import { TranslationsByKey } from './../../types/src/index';
-/* eslint-disable no-console */
-import type { TranslationsByLanguage } from '@vocab/types';
-import fetch from 'node-fetch';
-import { log, trace } from './logger';
-
-function _callPhrase(path: string, options: Parameters<typeof fetch>[1] = {}) {
-  const phraseApiToken = process.env.PHRASE_API_TOKEN;
-
-  if (!phraseApiToken) {
-    throw new Error('Missing PHRASE_API_TOKEN');
-  }
-
-  return fetch(path, {
-    ...options,
-    headers: {
-      Authorization: `token ${phraseApiToken}`,
-      // Provide identification via User Agent as requested in https://developers.phrase.com/api/#overview--identification-via-user-agent
-      'User-Agent': 'SEEK Demo Candidate App (jhope@seek.com.au)',
-      ...options.headers,
-    },
-  }).then(async (response) => {
-    console.log(`${path}: ${response.status} - ${response.statusText}`);
-    console.log(
-      `Rate Limit: ${response.headers.get(
-        'X-Rate-Limit-Remaining',
-      )} of ${response.headers.get(
-        'X-Rate-Limit-Limit',
-      )} remaining. (${response.headers.get(
-        'X-Rate-Limit-Reset',
-      )} seconds remaining})`,
-    );
-    trace('\nLink:', response.headers.get('Link'), '\n');
-    // Print All Headers:
-    // console.log(Array.from(r.headers.entries()));
-
-    try {
-      const result = await response.json();
-
-      trace(`Internal Result (Length: ${result.length})\n`);
-
-      if (
-        (!options.method || options.method === 'GET') &&
-        response.headers.get('Link')?.includes('rel=next')
-      ) {
-        const [, nextPageUrl] =
-          response.headers.get('Link')?.match(/<([^>]*)>; rel=next/) ?? [];
-
-        if (!nextPageUrl) {
-          throw new Error("Can't parse next page URL");
-        }
-
-        console.log('Results received with next page: ', nextPageUrl);
-
-        const nextPageResult = (await _callPhrase(nextPageUrl, options)) as any;
-
-        return [...result, ...nextPageResult];
-      }
-
-      return result;
-    } catch (e) {
-      console.error('Unable to parse response as JSON', e);
-      return response.text();
-    }
-  });
-}
-
-export async function callPhrase<T = any>(
-  relativePath: string,
-  options: Parameters<typeof fetch>[1] = {},
-): Promise<T> {
-  const projectId = process.env.PHRASE_PROJECT_ID;
-
-  if (!projectId) {
-    throw new Error('Missing PHRASE_PROJECT_ID');
-  }
-  return _callPhrase(
-    `https://api.phrase.com/v2/projects/${projectId}/${relativePath}`,
-    options,
-  )
-    .then((result) => {
-      if (Array.isArray(result)) {
-        console.log('Result length:', result.length);
-      }
-      return result;
-    })
-    .catch((error) => {
-      console.error(`Error calling phrase for ${relativePath}:`, error);
-      throw Error;
-    });
-}
-
-export async function pullAllTranslations(
-  branch: string,
-): Promise<TranslationsByLanguage> {
-  const phraseResult = await callPhrase<
-    Array<{
-      key: { name: string };
-      locale: { code: string };
-      content: string;
-    }>
-  >(`translations?branch=${branch}&per_page=100`);
-
-  const translations: TranslationsByLanguage = {};
-
-  for (const r of phraseResult) {
-    if (!translations[r.locale.code]) {
-      translations[r.locale.code] = {};
-    }
-    translations[r.locale.code][r.key.name] = { message: r.content };
-  }
-
-  return translations;
-}
-
-export async function pushTranslationsByLocale(
-  contents: TranslationsByKey,
-  locale: string,
-  branch: string,
-) {
-  const formData = new FormData();
-  const fileContents = Buffer.from(JSON.stringify(contents));
-  formData.append('file', fileContents, {
-    contentType: 'application/json',
-    filename: `${locale}.json`,
-  });
-
-  formData.append('file_format', 'json');
-  formData.append('locale_id', locale);
-  formData.append('branch', branch);
-  formData.append('update_translations', 'true');
-
-  log('Starting to upload:', locale, '\n');
-
-  const { id } = await callPhrase<{ id: string }>(`uploads`, {
-    method: 'POST',
-    body: formData,
-  });
-  log('Upload ID:', id, '\n');
-  log('Successfully Uploaded:', locale, '\n');
-
-  return { uploadId: id };
-}
-
-export async function deleteUnusedKeys(
-  uploadId: string,
-  locale: string,
-  branch: string,
-) {
-  const query = `unmentioned_in_upload:${uploadId}`;
-  const { records_affected } = await callPhrase<{ records_affected: number }>(
-    'keys',
-    {
-      method: 'DELETE',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({ branch, locale_id: locale, q: query }),
-    },
-  );
-
-  log(
-    'Successfully deleted',
-    records_affected,
-    'unused keys from branch',
-    branch,
-  );
-}
-
-export async function ensureBranch(branch: string) {
-  await callPhrase(`branches`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({ name: branch }),
-  });
-
-  log('Created branch:', branch);
-}

package/src/pull-translations.test.ts

@@ -1,214 +0,0 @@
-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(() => {
-      jest.mocked(pullAllTranslations).mockClear();
-      jest.mocked(writeFile).mockClear();
-      jest.mocked(pullAllTranslations).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(jest.mocked(writeFile)).toHaveBeenCalledTimes(2);
-    });
-
-    it('should update keys', async () => {
-      await expect(runPhrase(options)).resolves.toBeUndefined();
-
-      expect(
-        jest
-          .mocked(writeFile)
-          .mock.calls.map(([_filePath, contents]) =>
-            JSON.parse(contents as string),
-          ),
-      ).toMatchInlineSnapshot(`
-        [
-          {
-            "hello": {
-              "message": "Hi there",
-            },
-            "world": {
-              "message": "world",
-            },
-          },
-          {
-            "hello": {
-              "message": "merci",
-            },
-            "world": {
-              "message": "monde",
-            },
-          },
-        ]
-      `);
-    });
-  });
-
-  describe('when pulling translations and some languages do not have any translations', () => {
-    beforeEach(() => {
-      jest.mocked(pullAllTranslations).mockClear();
-      jest.mocked(writeFile).mockClear();
-      jest.mocked(pullAllTranslations).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(jest.mocked(writeFile)).toHaveBeenCalledTimes(2);
-    });
-
-    it('should update keys', async () => {
-      await expect(runPhrase(options)).resolves.toBeUndefined();
-
-      expect(
-        jest
-          .mocked(writeFile)
-          .mock.calls.map(([_filePath, contents]) =>
-            JSON.parse(contents as string),
-          ),
-      ).toMatchInlineSnapshot(`
-        [
-          {
-            "hello": {
-              "message": "Hi there",
-            },
-            "world": {
-              "message": "world",
-            },
-          },
-          {
-            "hello": {
-              "message": "merci",
-            },
-            "world": {
-              "message": "monde",
-            },
-          },
-        ]
-      `);
-    });
-  });
-
-  describe('when pulling translations and the project has not configured translations for the dev language', () => {
-    beforeEach(() => {
-      jest.mocked(pullAllTranslations).mockClear();
-      jest.mocked(writeFile).mockClear();
-      jest.mocked(pullAllTranslations).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.toThrow(
-        new Error(
-          `Phrase did not return any translations for the configured development language "en".\nPlease ensure this language is present in your Phrase project's configuration.`,
-        ),
-      );
-
-      expect(jest.mocked(writeFile)).toHaveBeenCalledTimes(0);
-    });
-  });
-});

package/src/pull-translations.ts

@@ -1,114 +0,0 @@
-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;
-  deleteUnusedKeys?: boolean;
-}
-
-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);
-  trace(
-    `Found Phrase translations for languages ${phraseLanguages.join(', ')}`,
-  );
-
-  if (!phraseLanguages.includes(config.devLanguage)) {
-    throw new Error(
-      `Phrase did not return any translations for the configured development language "${config.devLanguage}".\nPlease ensure this language is present in your Phrase project's configuration.`,
-    );
-  }
-
-  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

@@ -1,168 +0,0 @@
-import path from 'path';
-import { push } from './push-translations';
-import { pushTranslationsByLocale, deleteUnusedKeys } 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: {} })),
-  deleteUnusedKeys: jest.fn(() => Promise.resolve()),
-}));
-
-const uploadId = '1234';
-
-function runPhrase(config: { deleteUnusedKeys: boolean }) {
-  return push(
-    { branch: 'tester', deleteUnusedKeys: config.deleteUnusedKeys },
-    {
-      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', () => {
-  describe('when deleteUnusedKeys is false', () => {
-    const config = { deleteUnusedKeys: false };
-
-    beforeEach(() => {
-      jest.mocked(pushTranslationsByLocale).mockClear();
-      jest.mocked(writeFile).mockClear();
-      jest.mocked(deleteUnusedKeys).mockClear();
-
-      jest
-        .mocked(pushTranslationsByLocale)
-        .mockImplementation(() => Promise.resolve({ uploadId }));
-    });
-
-    it('should resolve', async () => {
-      await expect(runPhrase(config)).resolves.toBeUndefined();
-
-      expect(jest.mocked(pushTranslationsByLocale)).toHaveBeenCalledTimes(2);
-    });
-
-    it('should update keys', async () => {
-      await expect(runPhrase(config)).resolves.toBeUndefined();
-
-      expect(jest.mocked(pushTranslationsByLocale)).toHaveBeenCalledWith(
-        {
-          'hello.mytranslations': {
-            message: 'Hello',
-          },
-          'world.mytranslations': {
-            message: 'world',
-          },
-        },
-        'en',
-        'tester',
-      );
-
-      expect(jest.mocked(pushTranslationsByLocale)).toHaveBeenCalledWith(
-        {
-          'hello.mytranslations': {
-            message: 'Bonjour',
-          },
-          'world.mytranslations': {
-            message: 'monde',
-          },
-        },
-        'fr',
-        'tester',
-      );
-    });
-
-    it('should not delete unused keys', () => {
-      expect(deleteUnusedKeys).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('when deleteUnusedKeys is true', () => {
-    const config = { deleteUnusedKeys: true };
-
-    beforeEach(() => {
-      jest.mocked(pushTranslationsByLocale).mockClear();
-      jest.mocked(writeFile).mockClear();
-      jest.mocked(deleteUnusedKeys).mockClear();
-    });
-
-    describe('and the upload succeeds', () => {
-      beforeEach(() => {
-        jest
-          .mocked(pushTranslationsByLocale)
-          .mockImplementation(() => Promise.resolve({ uploadId }));
-      });
-
-      it('should resolve', async () => {
-        await expect(runPhrase(config)).resolves.toBeUndefined();
-
-        expect(jest.mocked(pushTranslationsByLocale)).toHaveBeenCalledTimes(2);
-      });
-
-      it('should update keys', async () => {
-        await expect(runPhrase(config)).resolves.toBeUndefined();
-
-        expect(jest.mocked(pushTranslationsByLocale)).toHaveBeenCalledWith(
-          {
-            'hello.mytranslations': {
-              message: 'Hello',
-            },
-            'world.mytranslations': {
-              message: 'world',
-            },
-          },
-          'en',
-          'tester',
-        );
-
-        expect(jest.mocked(pushTranslationsByLocale)).toHaveBeenCalledWith(
-          {
-            'hello.mytranslations': {
-              message: 'Bonjour',
-            },
-            'world.mytranslations': {
-              message: 'monde',
-            },
-          },
-          'fr',
-          'tester',
-        );
-      });
-
-      it('should delete unused keys', async () => {
-        await expect(runPhrase(config)).resolves.toBeUndefined();
-
-        expect(deleteUnusedKeys).toHaveBeenCalledWith(uploadId, 'en', 'tester');
-        expect(deleteUnusedKeys).toHaveBeenCalledWith(uploadId, 'fr', 'tester');
-      });
-    });
-
-    describe('and the upload fails', () => {
-      beforeEach(() => {
-        jest
-          .mocked(pushTranslationsByLocale)
-          .mockImplementation(() => Promise.reject('Upload failed'));
-      });
-
-      it('should not delete unused keys', async () => {
-        await expect(runPhrase(config)).rejects.toBe('Upload failed');
-
-        expect(deleteUnusedKeys).not.toHaveBeenCalled();
-      });
-    });
-  });
-});