@vocab/phrase 1.0.1 → 1.2.0

package/src/file.ts

@@ -1,4 +0,0 @@
-import { promises as fs } from 'fs';
-
-export const mkdir = fs.mkdir;
-export const writeFile = fs.writeFile;

package/src/index.ts

@@ -1,2 +0,0 @@
-export { pull } from './pull-translations';
-export { push } from './push-translations';

package/src/logger.ts

@@ -1,9 +0,0 @@
-import chalk from 'chalk';
-import debug from 'debug';
-
-export const trace = debug(`vocab:phrase`);
-
-export const log = (...params: unknown[]) => {
-  // eslint-disable-next-line no-console
-  console.log(chalk.yellow('Vocab'), ...params);
-};

package/src/phrase-api.ts

@@ -1,147 +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})`,
-    );
-    console.log('\nLink:', response.headers.get('Link'), '\n');
-    // Print All Headers:
-    // console.log(Array.from(r.headers.entries()));
-
-    try {
-      const result = await response.json();
-
-      console.log(`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('Cant parse next page URL');
-        }
-
-        console.log('Results recieved 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(
-  relativePath: string,
-  options: Parameters<typeof fetch>[1] = {},
-) {
-  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: Array<{
-    key: { name: string };
-    locale: { code: string };
-    content: string;
-  }> = await callPhrase(`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');
-
-  trace('Starting to upload:', locale);
-
-  await callPhrase(`uploads`, {
-    method: 'POST',
-    body: formData,
-  });
-  log('Successfully Uploaded:', locale, '\n');
-}
-
-export async function ensureBranch(branch: string) {
-  await callPhrase(`branches`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({ name: branch }),
-  });
-  trace('Created branch:', branch);
-}

package/src/pull-translations.test.ts

@@ -1,148 +0,0 @@
-import path from 'path';
-import { pull } from './pull-translations';
-import { pullAllTranslations } from './phrase-api';
-import { writeFile } from './file';
-import { 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: {} })),
-}));
-
-function runPhrase(options: { languages: LanguageTarget[] }) {
-  return pull(
-    { branch: 'tester' },
-    {
-      ...options,
-      devLanguage: 'en',
-      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' }],
-    };
-
-    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' }],
-    };
-
-    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",
-          },
-        },
-      ]
-    `);
-    });
-  });
-});

package/src/pull-translations.ts

@@ -1,102 +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;
-}
-
-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 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,65 +0,0 @@
-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' }],
-      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

@@ -1,55 +0,0 @@
-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,
-      );
-    }
-  }
-}