fix: auto approve script

Author: ReenigneArcher

src/sync-crowdin-en-us.js

@@ -5,8 +5,8 @@
  *
  * The script is fully idempotent – each run will:
  *   • Fetch all source strings for each configured project.
- *   • Fetch all existing en_US approvals and translations for the project
- *     upfront (two API calls) and skip strings that are already fully approved,
+ *   • Fetch all already-approved en_US translations for the project upfront
+ *     (one API call) and skip strings that are already fully approved,
  *     significantly reducing per-string API usage.
  *   • For strings that need attention: check whether the en_US translation
  *     already exists and matches the source text (including plurals).
@@ -101,28 +101,17 @@ async function fetchApprovals(projectId, stringId) {
 }
 
 /**
- * Fetches all existing en_US approvals for an entire project in one call.
+ * Fetches all already-approved en_US translations for an entire project in
+ * one call, using the approvedOnly filter so no separate approvals request
+ * is needed.
  *
  * @param {string|number} projectId
- * @returns {Promise<object[]>}  Unwrapped Approval data objects.
- */
-async function fetchProjectApprovals(projectId) {
-  const response = await crowdin.stringTranslationsApi
-    .withFetchAll()
-    .listTranslationApprovals(projectId, { languageId: EN_US });
-  return (response.data ?? []).map((item) => item.data);
-}
-
-/**
- * Fetches all existing en_US translations for an entire project in one call.
- *
- * @param {string|number} projectId
- * @returns {Promise<object[]>}  Unwrapped translation data objects.
+ * @returns {Promise<object[]>}  Unwrapped translation data objects (approved only).
  */
-async function fetchProjectTranslations(projectId) {
+async function fetchApprovedProjectTranslations(projectId) {
   const response = await crowdin.stringTranslationsApi
     .withFetchAll()
-    .listLanguageTranslations(projectId, EN_US);
+    .listLanguageTranslations(projectId, EN_US, { approvedOnly: 1 });
   return (response.data ?? []).map((item) => item.data);
 }
 
@@ -233,21 +222,15 @@ async function ensureTranslation(projectId, stringId, expectedText, pluralCatego
  * Determines whether all plural forms (or the single plain form) of a source
  * string already have an approved en_US translation.
  *
- * @param {object}         sourceString
- * @param {Set<number>}    approvedTranslationIds
- * @param {Map<number, Array<{translationId: number, pluralCategoryName: string|null}>>} stringTranslationMap
- *   Maps stringId → array of {translationId, pluralCategoryName} entries for
- *   that string's en_US translations.
+ * @param {object} sourceString
+ * @param {Map<number, Set<string|null>>} approvedCategoriesByStringId
+ *   Maps stringId → Set of pluralCategoryName values (or null for plain strings)
+ *   that already have an approved en_US translation.
  * @returns {boolean}
  */
-function isFullyApproved(sourceString, approvedTranslationIds, stringTranslationMap) {
+function isFullyApproved(sourceString, approvedCategoriesByStringId) {
   const expectedEntries = normalisedTextEntries(sourceString.text);
-  const translations = stringTranslationMap.get(sourceString.id) ?? [];
-  const approvedCategories = new Set(
-    translations
-      .filter((t) => approvedTranslationIds.has(t.translationId))
-      .map((t) => t.pluralCategoryName),
-  );
+  const approvedCategories = approvedCategoriesByStringId.get(sourceString.id) ?? new Set();
   return expectedEntries.every(({ pluralCategoryName }) =>
     approvedCategories.has(pluralCategoryName),
   );
@@ -307,33 +290,24 @@ async function syncStringTranslation(projectId, sourceString) {
 async function syncProject(projectId) {
   console.log(`\n── Project ${projectId} ──`);
 
-  // Fetch source strings and all en_US approvals/translations in parallel.
-  const [strings, projectApprovals, projectTranslations] = await Promise.all([
+  // Fetch source strings and all approved en_US translations in parallel.
+  const [strings, approvedTranslations] = await Promise.all([
     fetchSourceStrings(projectId),
-    fetchProjectApprovals(projectId),
-    fetchProjectTranslations(projectId),
+    fetchApprovedProjectTranslations(projectId),
   ]);
   console.log(`  ${strings.length} source string(s) found.`);
 
-  // Build a set of approved translation IDs.
-  const approvedTranslationIds = new Set(projectApprovals.map((a) => a.translationId));
-
-  // Build a map: stringId → [{translationId, pluralCategoryName}] for all
-  // en_US translations in the project, so isFullyApproved can check coverage
-  // per-string without cross-string contamination.
-  const stringTranslationMap = new Map();
-  for (const t of projectTranslations) {
+  // Build a map: stringId → Set<pluralCategoryName|null> of approved categories.
+  const approvedCategoriesByStringId = new Map();
+  for (const t of approvedTranslations) {
     const sid = t.stringId;
-    if (!stringTranslationMap.has(sid)) stringTranslationMap.set(sid, []);
-    stringTranslationMap.get(sid).push({
-      translationId: t.translationId,
-      pluralCategoryName: t.pluralCategoryName ?? null,
-    });
+    if (!approvedCategoriesByStringId.has(sid)) approvedCategoriesByStringId.set(sid, new Set());
+    approvedCategoriesByStringId.get(sid).add(t.pluralCategoryName ?? null);
   }
 
   let skipped = 0;
   for (const string of strings) {
-    if (isFullyApproved(string, approvedTranslationIds, stringTranslationMap)) {
+    if (isFullyApproved(string, approvedCategoriesByStringId)) {
       skipped++;
       continue;
     }
@@ -370,8 +344,7 @@ if (_isMain) {
 export {
   EN_US,
   fetchSourceStrings,
-  fetchProjectApprovals,
-  fetchProjectTranslations,
+  fetchApprovedProjectTranslations,
   fetchTranslations,
   fetchApprovals,
   addTranslation,

tests/sync-crowdin-en-us.test.js

@@ -42,8 +42,7 @@ import { Client as CrowdinClient } from '@crowdin/crowdin-api-client';
 import {
   EN_US,
   fetchSourceStrings,
-  fetchProjectApprovals,
-  fetchProjectTranslations,
+  fetchApprovedProjectTranslations,
   fetchTranslations,
   fetchApprovals,
   addTranslation,
@@ -535,39 +534,9 @@ describe('syncStringTranslation', () => {
   });
 });
 
-// fetchProjectApprovals
+// fetchApprovedProjectTranslations
 
-describe('fetchProjectApprovals', () => {
-  beforeEach(() => jest.clearAllMocks());
-
-  it('returns unwrapped approval data objects', async () => {
-    const raw = [
-      { data: makeApproval({ id: 30, translationId: 20 }) },
-      { data: makeApproval({ id: 31, translationId: 21 }) },
-    ];
-    mockListTranslationApprovals.mockResolvedValue({ data: raw });
-
-    const result = await fetchProjectApprovals('42');
-    expect(result).toHaveLength(2);
-    expect(result[0].id).toBe(30);
-    expect(result[1].id).toBe(31);
-  });
-
-  it('returns an empty array when response.data is null/undefined', async () => {
-    mockListTranslationApprovals.mockResolvedValue({});
-    expect(await fetchProjectApprovals('42')).toEqual([]);
-  });
-
-  it('calls listTranslationApprovals with projectId and EN_US only (no stringId)', async () => {
-    mockListTranslationApprovals.mockResolvedValue({ data: [] });
-    await fetchProjectApprovals('42');
-    expect(mockListTranslationApprovals).toHaveBeenCalledWith('42', { languageId: EN_US });
-  });
-});
-
-// fetchProjectTranslations
-
-describe('fetchProjectTranslations', () => {
+describe('fetchApprovedProjectTranslations', () => {
   beforeEach(() => jest.clearAllMocks());
 
   it('returns unwrapped translation data objects', async () => {
@@ -577,22 +546,22 @@ describe('fetchProjectTranslations', () => {
     ];
     mockListLanguageTranslations.mockResolvedValue({ data: raw });
 
-    const result = await fetchProjectTranslations('42');
+    const result = await fetchApprovedProjectTranslations('42');
     expect(result).toHaveLength(2);
     expect(result[0].translationId).toBe(10);
     expect(result[1].translationId).toBe(11);
   });
 
   it('returns an empty array when response.data is null/undefined', async () => {
     mockListLanguageTranslations.mockResolvedValue({});
-    expect(await fetchProjectTranslations('42')).toEqual([]);
+    expect(await fetchApprovedProjectTranslations('42')).toEqual([]);
   });
 
-  it('calls listLanguageTranslations with projectId and EN_US', async () => {
+  it('calls listLanguageTranslations with projectId, EN_US, and approvedOnly:1', async () => {
     mockListLanguageTranslations.mockResolvedValue({ data: [] });
-    await fetchProjectTranslations('42');
+    await fetchApprovedProjectTranslations('42');
     expect(mockTranslationsWithFetchAll).toHaveBeenCalled();
-    expect(mockListLanguageTranslations).toHaveBeenCalledWith('42', EN_US);
+    expect(mockListLanguageTranslations).toHaveBeenCalledWith('42', EN_US, { approvedOnly: 1 });
   });
 });
 
@@ -601,61 +570,45 @@ describe('fetchProjectTranslations', () => {
 describe('isFullyApproved', () => {
   it('returns true for a plain string with an approved translation', () => {
     const string = makeSourceString({ id: 1, text: 'Hello' });
-    const approvedIds = new Set([100]);
-    const stringTranslationMap = new Map([[1, [{ translationId: 100, pluralCategoryName: null }]]]);
-    expect(isFullyApproved(string, approvedIds, stringTranslationMap)).toBe(true);
+    const map = new Map([[1, new Set([null])]]);
+    expect(isFullyApproved(string, map)).toBe(true);
   });
 
   it('returns false for a plain string with no entry in the map', () => {
     const string = makeSourceString({ id: 1, text: 'Hello' });
-    const approvedIds = new Set();
-    const stringTranslationMap = new Map();
-    expect(isFullyApproved(string, approvedIds, stringTranslationMap)).toBe(false);
+    expect(isFullyApproved(string, new Map())).toBe(false);
   });
 
-  it('returns false for a plain string whose translation is not approved', () => {
+  it('returns false for a plain string whose category is not in the approved set', () => {
     const string = makeSourceString({ id: 1, text: 'Hello' });
-    const approvedIds = new Set([999]); // different ID
-    const stringTranslationMap = new Map([[1, [{ translationId: 100, pluralCategoryName: null }]]]);
-    expect(isFullyApproved(string, approvedIds, stringTranslationMap)).toBe(false);
+    // Map has the string but an empty set – no category approved
+    const map = new Map([[1, new Set()]]);
+    expect(isFullyApproved(string, map)).toBe(false);
   });
 
   it('returns true for a plural string when all forms are approved', () => {
     const string = makeSourceString({ id: 2, text: { one: 'One', other: 'Other' } });
-    const approvedIds = new Set([10, 11]);
-    const stringTranslationMap = new Map([[2, [
-      { translationId: 10, pluralCategoryName: 'one' },
-      { translationId: 11, pluralCategoryName: 'other' },
-    ]]]);
-    expect(isFullyApproved(string, approvedIds, stringTranslationMap)).toBe(true);
+    const map = new Map([[2, new Set(['one', 'other'])]]);
+    expect(isFullyApproved(string, map)).toBe(true);
   });
 
   it('returns false for a plural string when only some forms are approved', () => {
     const string = makeSourceString({ id: 2, text: { one: 'One', other: 'Other' } });
-    const approvedIds = new Set([10]); // only 'one' approved
-    const stringTranslationMap = new Map([[2, [
-      { translationId: 10, pluralCategoryName: 'one' },
-      { translationId: 11, pluralCategoryName: 'other' },
-    ]]]);
-    expect(isFullyApproved(string, approvedIds, stringTranslationMap)).toBe(false);
+    const map = new Map([[2, new Set(['one'])]]);
+    expect(isFullyApproved(string, map)).toBe(false);
   });
 
   it('returns false for a plural string when no forms are approved', () => {
     const string = makeSourceString({ id: 2, text: { one: 'One', other: 'Other' } });
-    const approvedIds = new Set();
-    const stringTranslationMap = new Map([[2, [
-      { translationId: 10, pluralCategoryName: 'one' },
-      { translationId: 11, pluralCategoryName: 'other' },
-    ]]]);
-    expect(isFullyApproved(string, approvedIds, stringTranslationMap)).toBe(false);
+    const map = new Map([[2, new Set()]]);
+    expect(isFullyApproved(string, map)).toBe(false);
   });
 
-  it('does not consider translations belonging to other strings', () => {
+  it('does not consider approvals belonging to other strings', () => {
     const string = makeSourceString({ id: 1, text: 'Hello' });
-    const approvedIds = new Set([200]);
-    // Only string 2 has translation 200; string 1 has no entry
-    const stringTranslationMap = new Map([[2, [{ translationId: 200, pluralCategoryName: null }]]]);
-    expect(isFullyApproved(string, approvedIds, stringTranslationMap)).toBe(false);
+    // Only string 2 has an approved null category; string 1 has no entry
+    const map = new Map([[2, new Set([null])]]);
+    expect(isFullyApproved(string, map)).toBe(false);
   });
 });
 
@@ -672,9 +625,9 @@ describe('syncProject', () => {
   it('logs the project and string count', async () => {
     const strings = [makeSourceString({ id: 1 }), makeSourceString({ id: 2 })];
     mockListProjectStrings.mockResolvedValue({ data: strings.map((s) => ({ data: s })) });
-    mockListTranslationApprovals.mockResolvedValue({ data: [] });
     mockListLanguageTranslations.mockResolvedValue({ data: [] });
     mockListStringTranslations.mockResolvedValue({ data: [] });
+    mockListTranslationApprovals.mockResolvedValue({ data: [] });
     mockAddTranslation.mockResolvedValue({ data: { id: 50 } });
     mockAddApproval.mockResolvedValue({ data: { id: 200 } });
 
@@ -687,50 +640,45 @@ describe('syncProject', () => {
   it('processes strings that are not fully approved', async () => {
     const strings = [makeSourceString({ id: 10 }), makeSourceString({ id: 11 })];
     mockListProjectStrings.mockResolvedValue({ data: strings.map((s) => ({ data: s })) });
-    // No project-level approvals → both strings need processing
-    mockListTranslationApprovals.mockResolvedValue({ data: [] });
+    // No approved translations upfront → both strings need processing
     mockListLanguageTranslations.mockResolvedValue({ data: [] });
     mockListStringTranslations.mockResolvedValue({ data: [] });
+    mockListTranslationApprovals.mockResolvedValue({ data: [] });
     mockAddTranslation.mockResolvedValue({ data: { id: 50 } });
     mockAddApproval.mockResolvedValue({ data: { id: 200 } });
 
     await syncProject('42');
 
-    // One pair of fetchTranslations+fetchApprovals per string that needs processing
+    // One fetchTranslations call per string that needs processing
     expect(mockListStringTranslations).toHaveBeenCalledTimes(2);
   });
 
   it('skips strings that are already fully approved', async () => {
     const string = makeSourceString({ id: 5, text: 'Hello' });
     mockListProjectStrings.mockResolvedValue({ data: [{ data: string }] });
-    mockListTranslationApprovals.mockResolvedValue({
-      data: [{ data: makeApproval({ translationId: 77 }) }],
-    });
+    // approvedOnly response includes stringId=5, category=null → fully covered
     mockListLanguageTranslations.mockResolvedValue({
       data: [{ data: { translationId: 77, stringId: 5, pluralCategoryName: null } }],
     });
 
     await syncProject('42');
 
-    // No per-string API calls should have been made
     expect(mockListStringTranslations).not.toHaveBeenCalled();
     expect(console.log).toHaveBeenCalledWith(expect.stringContaining('1 string(s) skipped'));
   });
 
-  it('processes only the strings that are not fully approved, skipping the rest', async () => {
+  it('processes only unapproved strings, skipping the rest', async () => {
     const approvedString = makeSourceString({ id: 5, text: 'Hello' });
     const unapprovedString = makeSourceString({ id: 6, text: 'World' });
     mockListProjectStrings.mockResolvedValue({
       data: [{ data: approvedString }, { data: unapprovedString }],
     });
-    mockListTranslationApprovals.mockResolvedValue({
-      data: [{ data: makeApproval({ translationId: 77 }) }],
-    });
+    // Only string 5 is approved
     mockListLanguageTranslations.mockResolvedValue({
       data: [{ data: { translationId: 77, stringId: 5, pluralCategoryName: null } }],
     });
-    // Per-string calls for unapproved string
     mockListStringTranslations.mockResolvedValue({ data: [] });
+    mockListTranslationApprovals.mockResolvedValue({ data: [] });
     mockAddTranslation.mockResolvedValue({ data: { id: 50 } });
     mockAddApproval.mockResolvedValue({ data: { id: 200 } });
 
@@ -744,12 +692,6 @@ describe('syncProject', () => {
   it('skips a plural string only when all its forms are approved', async () => {
     const string = makeSourceString({ id: 8, text: { one: 'One', other: 'Other' } });
     mockListProjectStrings.mockResolvedValue({ data: [{ data: string }] });
-    mockListTranslationApprovals.mockResolvedValue({
-      data: [
-        { data: makeApproval({ translationId: 80 }) },
-        { data: makeApproval({ translationId: 81 }) },
-      ],
-    });
     // Two entries share the same stringId=8 — exercises the map-accumulation branch
     mockListLanguageTranslations.mockResolvedValue({
       data: [
@@ -765,8 +707,22 @@ describe('syncProject', () => {
   });
 
   it('does not log skipped message when no strings are skipped', async () => {
-    mockListProjectStrings.mockResolvedValue({ data: [] });
+    const string = makeSourceString({ id: 7, text: 'Test' });
+    mockListProjectStrings.mockResolvedValue({ data: [{ data: string }] });
+    mockListLanguageTranslations.mockResolvedValue({ data: [] });
+    mockListStringTranslations.mockResolvedValue({ data: [] });
     mockListTranslationApprovals.mockResolvedValue({ data: [] });
+    mockAddTranslation.mockResolvedValue({ data: { id: 50 } });
+    mockAddApproval.mockResolvedValue({ data: { id: 200 } });
+
+    await syncProject('42');
+
+    const logs = console.log.mock.calls.map((c) => c[0]);
+    expect(logs.some((m) => m.includes('skipped'))).toBe(false);
+  });
+
+  it('handles a project with no source strings', async () => {
+    mockListProjectStrings.mockResolvedValue({ data: [] });
     mockListLanguageTranslations.mockResolvedValue({ data: [] });
 
     await syncProject('99');
@@ -802,7 +758,6 @@ describe('main', () => {
     });
 
     mockListProjectStrings.mockResolvedValue({ data: [] });
-    mockListTranslationApprovals.mockResolvedValue({ data: [] });
     mockListLanguageTranslations.mockResolvedValue({ data: [] });
 
     await freshMain();