@vocab/phrase 1.0.0 → 1.1.0

package/src/push-translations.test.ts

@@ -1,6 +1,6 @@
 import path from 'path';
 import { push } from './push-translations';
-import { pushTranslationsByLocale } from './phrase-api';
+import { pushTranslationsByLocale, deleteUnusedKeys } from './phrase-api';
 import { writeFile } from './file';
 
 jest.mock('./file', () => ({
@@ -11,55 +11,158 @@ jest.mock('./file', () => ({
 jest.mock('./phrase-api', () => ({
   ensureBranch: jest.fn(() => Promise.resolve()),
   pushTranslationsByLocale: jest.fn(() => Promise.resolve({ en: {}, fr: {} })),
+  deleteUnusedKeys: jest.fn(() => Promise.resolve()),
 }));
 
-function runPhrase() {
+const uploadId = '1234';
+
+function runPhrase(config: { deleteUnusedKeys: boolean }) {
   return push(
-    { branch: 'tester' },
+    { 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', () => {
-  beforeEach(() => {
-    (pushTranslationsByLocale as jest.Mock).mockClear();
-    (writeFile as jest.Mock).mockClear();
-  });
-  it('should resolve', async () => {
-    await expect(runPhrase()).resolves.toBeUndefined();
+  describe('when deleteUnusedKeys is false', () => {
+    const config = { deleteUnusedKeys: false };
 
-    expect(pushTranslationsByLocale as jest.Mock).toHaveBeenCalledTimes(2);
-  });
-  it('should update keys', async () => {
-    await expect(runPhrase()).resolves.toBeUndefined();
+    beforeEach(() => {
+      jest.mocked(pushTranslationsByLocale).mockClear();
+      jest.mocked(writeFile).mockClear();
+      jest.mocked(deleteUnusedKeys).mockClear();
 
-    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',
+      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',
+          },
         },
-        'world.mytranslations': {
-          message: 'monde',
+        'en',
+        'tester',
+      );
+
+      expect(jest.mocked(pushTranslationsByLocale)).toHaveBeenCalledWith(
+        {
+          'hello.mytranslations': {
+            message: 'Bonjour',
+          },
+          'world.mytranslations': {
+            message: 'monde',
+          },
         },
-      },
-      'fr',
-      'tester',
-    );
+        '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();
+      });
+    });
   });
 });

package/src/push-translations.ts

@@ -1,18 +1,26 @@
 import { TranslationsByLanguage } from './../../types/src/index';
 
-import { ensureBranch, pushTranslationsByLocale } from './phrase-api';
+import {
+  ensureBranch,
+  pushTranslationsByLocale,
+  deleteUnusedKeys as phraseDeleteUnusedKeys,
+} from './phrase-api';
 import { trace } from './logger';
 import { loadAllTranslations, getUniqueKey } from '@vocab/core';
 import { UserConfig } from '@vocab/types';
 
 interface PushOptions {
   branch: string;
+  deleteUnusedKeys?: boolean;
 }
 
 /**
  * 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) {
+export async function push(
+  { branch, deleteUnusedKeys }: PushOptions,
+  config: UserConfig,
+) {
   const allLanguageTranslations = await loadAllTranslations(
     { fallbacks: 'none', includeNodeModules: false },
     config,
@@ -45,11 +53,15 @@ export async function push({ branch }: PushOptions, config: UserConfig) {
 
   for (const language of allLanguages) {
     if (phraseTranslations[language]) {
-      await pushTranslationsByLocale(
+      const { uploadId } = await pushTranslationsByLocale(
         phraseTranslations[language],
         language,
         branch,
       );
+
+      if (deleteUnusedKeys) {
+        await phraseDeleteUnusedKeys(uploadId, language, branch);
+      }
     }
   }
 }