localingos 0.1.33 → 0.1.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "localingos",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "description": "CLI tool to sync translations with Localingos",
   "main": "src/index.js",
   "type": "module",

package/src/api.js

@@ -6,11 +6,30 @@ export class LocalingosApi {
         this.apiKey = apiKey;
     }
 
-    async sync(familyId, translatables) {
-        return this._post('/sync', {
-            familyId,
-            translatables
-        });
+    async sync(familyId, translatables, { batchSize = 100, onProgress } = {}) {
+        // Push in batches to avoid API timeout
+        const batches = [];
+        for (let i = 0; i < translatables.length; i += batchSize) {
+            batches.push(translatables.slice(i, i + batchSize));
+        }
+
+        for (let i = 0; i < batches.length; i++) {
+            await this._post('/translatable', {
+                familyId,
+                translatableList: batches[i]
+            });
+            if (onProgress) onProgress(Math.min((i + 1) * batchSize, translatables.length), translatables.length);
+        }
+
+        // Pull translations separately
+        const translations = await this._get(`/translation/${familyId}`);
+        const pushedIds = new Set(translatables.map(t => t.id));
+        const available = Array.isArray(translations) ? translations : [];
+        const pending = translatables
+            .filter(t => !available.some(tr => tr.foreignId === t.id || tr.translatableId === t.id))
+            .map(t => t.id);
+
+        return { translations: available, pending };
     }
 
     async getTranslatables(familyId) {
@@ -28,6 +47,36 @@ export class LocalingosApi {
         });
     }
 
+    async deleteTranslatables(familyId, foreignIds) {
+        return this._request('DELETE', `/translatable/${familyId}`, { foreignIds });
+    }
+
+    async _request(method, path, body) {
+        const url = `${this.apiUrl}${path}`;
+        let response;
+        try {
+            const opts = {
+                method,
+                headers: {
+                    'X-API-Key': this.apiKey,
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json'
+                },
+            };
+            if (body) opts.body = JSON.stringify(body);
+            response = await fetch(url, opts);
+        } catch (networkError) {
+            this._throwConnectionError(method, url, networkError);
+        }
+        if (!response.ok) {
+            const responseBody = await response.text().catch(() => '');
+            throw new Error(`API ${method} ${path} failed (${response.status}): ${responseBody}`);
+        }
+        const text = await response.text();
+        if (!text) return {};
+        return JSON.parse(text);
+    }
+
     async _get(path) {
         const url = `${this.apiUrl}${path}`;
         let response;

package/src/commands/sync.js

@@ -75,7 +75,12 @@ export async function syncCommand(options) {
 
     let result;
     try {
-        result = await api.sync(config.familyId, translatables);
+        result = await api.sync(config.familyId, translatables, {
+            onProgress: (done, total) => {
+                process.stdout.write(`\r   Pushed ${done}/${total} strings...`);
+            }
+        });
+        process.stdout.write('\n');
     } catch (e) {
         console.error(chalk.red(`\nSync failed: ${e.message}`));
         process.exit(1);
@@ -88,6 +93,33 @@ export async function syncCommand(options) {
         console.log(chalk.yellow(`   ⏳ ${pending.length} keys pending translation: ${pending.slice(0, 5).join(', ')}${pending.length > 5 ? '...' : ''}`));
     }
 
+    // 2b. Prune stale translatables from the remote family
+    if (options.prune) {
+        console.log(chalk.blue('\n🔍 Checking for stale translatables in the remote family...'));
+        try {
+            const remoteTranslatables = await api.getTranslatables(config.familyId);
+            const localIds = new Set(translatables.map(t => t.id));
+            const staleIds = remoteTranslatables
+                .filter(t => !localIds.has(t.foreignId || t.id))
+                .map(t => t.foreignId || t.id);
+
+            if (staleIds.length > 0) {
+                console.log(chalk.yellow(`   Found ${staleIds.length} stale translatable(s) not in source file:`));
+                for (const id of staleIds.slice(0, 10)) {
+                    console.log(chalk.gray(`     - ${id}`));
+                }
+                if (staleIds.length > 10) console.log(chalk.gray(`     ... and ${staleIds.length - 10} more`));
+
+                const deleteResult = await api.deleteTranslatables(config.familyId, staleIds);
+                console.log(chalk.green(`   🗑️  Deleted ${deleteResult.deleted} stale translatable(s) from remote`));
+            } else {
+                console.log(chalk.green('   ✅ No stale translatables found'));
+            }
+        } catch (e) {
+            console.error(chalk.yellow(`   ⚠️  Could not prune remote translatables: ${e.message}`));
+        }
+    }
+
     // 3. Write translation files (skip source locale to avoid overwriting the source file)
     const targetTranslations = translations.filter(t => t.locale !== config.sourceLocale);