@nlabs/reaktor 0.10.5 → 0.10.6

package/lib/utils/translationQueue.example.js

@@ -0,0 +1,340 @@
+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ *
+ * Example usage of the translation queue system with Google Translate integration
+ *
+ * This demonstrates how to use the new translation queue that automatically
+ * translates content using Google Translate API when needed.
+ */ import { flush, i18n } from './translationQueue.js';
+// Example 1: Basic translations - will use database or translate as needed
+export async function getWelcomeMessages(context, locale = 'en') {
+    const translations = [
+        {
+            key: 'welcome.title',
+            fallback: 'Welcome to TorchOne!'
+        },
+        {
+            key: 'welcome.subtitle',
+            fallback: 'Your personal AI assistant'
+        },
+        {
+            key: 'welcome.description',
+            fallback: 'Get started by exploring our features'
+        }
+    ];
+    // This will:
+    // 1. Check database for existing translations
+    // 2. If not found and locale is default (en), save fallback to DB
+    // 3. If not found and locale is different, translate from default locale
+    // 4. Save translated content to DB for future use
+    const result = await i18n(context, translations, locale);
+    return result;
+// Returns: {
+//   'welcome.title': 'Welcome to TorchOne!' (or translated version),
+//   'welcome.subtitle': 'Your personal AI assistant' (or translated version),
+//   'welcome.description': 'Get started by exploring our features' (or translated version)
+// }
+}
+// Example 2: Translations with interpolation
+export async function getPersonalizedMessages(context, username, locale = 'en') {
+    const translations = [
+        {
+            key: 'user.welcome',
+            fallback: 'Welcome back, {{username}}!',
+            params: {
+                username
+            }
+        },
+        {
+            key: 'user.notifications',
+            fallback: 'You have {{count}} new notifications',
+            params: {
+                count: 5
+            }
+        },
+        {
+            key: 'user.lastLogin',
+            fallback: 'Last login: {{date}}',
+            params: {
+                date: new Date().toLocaleDateString()
+            }
+        }
+    ];
+    const result = await i18n(context, translations, locale);
+    return result;
+// Returns: {
+//   'user.welcome': 'Welcome back, Alice!' (or translated with interpolation),
+//   'user.notifications': 'You have 5 new notifications' (or translated with interpolation),
+//   'user.lastLogin': 'Last login: 1/15/2025' (or translated with interpolation)
+// }
+}
+// Example 3: Multi-language support
+export async function getMultiLanguageContent(context) {
+    // Get content in multiple languages
+    const languages = [
+        'en',
+        'es',
+        'fr'
+    ];
+    const results = {};
+    for (const locale of languages){
+        const translations = [
+            {
+                key: 'app.name',
+                fallback: 'TorchOne'
+            },
+            {
+                key: 'app.tagline',
+                fallback: 'Your AI Assistant'
+            }
+        ];
+        results[locale] = await i18n(context, translations, locale);
+    }
+    return results;
+// Returns: {
+//   en: { 'app.name': 'TorchOne', 'app.tagline': 'Your AI Assistant' },
+//   es: { 'app.name': 'TorchOne', 'app.tagline': 'Tu Asistente de IA' },
+//   fr: { 'app.name': 'TorchOne', 'app.tagline': 'Votre Assistant IA' }
+// }
+}
+// Example 4: Error handling and fallbacks
+export async function getRobustTranslations(context, locale = 'en') {
+    const translations = [
+        {
+            key: 'error.notFound',
+            fallback: 'Content not found'
+        },
+        {
+            key: 'error.serverError',
+            fallback: 'Server error occurred'
+        },
+        {
+            key: 'success.saved',
+            fallback: 'Content saved successfully'
+        }
+    ];
+    try {
+        const result = await i18n(context, translations, locale);
+        return result;
+    } catch (error) {
+        console.error('Translation error:', error);
+        // Return fallbacks if translation fails
+        return translations.reduce((acc, t)=>{
+            acc[t.key] = t.fallback || '';
+            return acc;
+        }, {});
+    }
+}
+// Example 5: Batch processing with flush
+export async function processLargeTranslationBatch(context, locale = 'en') {
+    // Create a large batch of translations
+    const translations = [];
+    for(let i = 1; i <= 100; i++){
+        translations.push({
+            key: `item.${i}.title`,
+            fallback: `Item ${i} Title`,
+            params: {
+                number: i
+            }
+        });
+    }
+    // Process the batch
+    const result = await i18n(context, translations, locale);
+    // Ensure all pending translations are processed
+    await flush();
+    return result;
+}
+// Example 6: Error handling with fallbacks
+export async function getErrorMessages(context, errorCode, locale = 'en') {
+    const translations = [
+        {
+            key: `error.${errorCode}`,
+            fallback: `An error occurred: ${errorCode}`,
+            params: {
+                errorCode
+            }
+        },
+        {
+            key: 'error.contactSupport',
+            fallback: 'Please contact support if this problem persists.',
+            params: {}
+        }
+    ];
+    const result = await i18n(context, translations, locale);
+    // If database is unavailable, will return fallbacks:
+    // {
+    //   'error.INVALID_EMAIL': 'An error occurred: INVALID_EMAIL',
+    //   'error.contactSupport': 'Please contact support if this problem persists.'
+    // }
+    return result;
+}
+// Example 7: Complex email template with multiple interpolations
+export async function generateEmailTemplate(context, userData, locale = 'en') {
+    const translations = [
+        {
+            key: 'email.orderConfirmation.subject',
+            fallback: 'Order {{orderId}} Confirmed',
+            params: {
+                orderId: userData.orderId
+            }
+        },
+        {
+            key: 'email.orderConfirmation.greeting',
+            fallback: 'Hello {{name}},',
+            params: {
+                name: userData.name
+            }
+        },
+        {
+            key: 'email.orderConfirmation.body',
+            fallback: 'Your order {{orderId}} has been confirmed. Total: ${{total}} for {{items}} items.',
+            params: {
+                orderId: userData.orderId,
+                total: userData.total,
+                items: userData.items
+            }
+        },
+        {
+            key: 'email.orderConfirmation.footer',
+            fallback: 'Thank you for your purchase!'
+        }
+    ];
+    const result = await i18n(context, translations, locale);
+    return {
+        subject: result['email.orderConfirmation.subject'],
+        greeting: result['email.orderConfirmation.greeting'],
+        body: result['email.orderConfirmation.body'],
+        footer: result['email.orderConfirmation.footer']
+    };
+}
+// Example 8: Notification messages for different scenarios
+export async function getNotificationMessages(context, locale = 'en') {
+    const translations = [
+        {
+            key: 'notification.welcome',
+            fallback: 'Welcome to TorchOne!'
+        },
+        {
+            key: 'notification.verification',
+            fallback: 'Please verify your account.'
+        },
+        {
+            key: 'notification.passwordReset',
+            fallback: 'Your password has been reset.'
+        },
+        {
+            key: 'notification.profileUpdate',
+            fallback: 'Your profile has been updated.'
+        },
+        {
+            key: 'notification.newMessage',
+            fallback: 'You have a new message from {{sender}}.',
+            params: {
+                sender: 'John Doe'
+            }
+        }
+    ];
+    const result = await i18n(context, translations, locale);
+    return result;
+}
+// Example 9: Performance comparison
+export async function performanceComparison(context) {
+    const keys = [
+        'welcome',
+        'verification',
+        'passwordReset',
+        'profileUpdate',
+        'email.subject',
+        'email.body',
+        'sms.welcome',
+        'sms.verification'
+    ];
+    const translations = keys.map((key)=>({
+            key,
+            fallback: `Fallback for ${key}`
+        }));
+    console.time('Batch translation');
+    const batchResults = await i18n(context, translations, 'en');
+    console.timeEnd('Batch translation');
+    return batchResults;
+}
+// Example 10: Dynamic content based on user preferences
+export async function getUserGreeting(context, userLocale, username) {
+    const locale = userLocale || 'en';
+    const translations = [
+        {
+            key: 'greeting.morning',
+            fallback: 'Good morning!',
+            params: username ? {
+                username
+            } : {}
+        },
+        {
+            key: 'greeting.afternoon',
+            fallback: 'Good afternoon!',
+            params: username ? {
+                username
+            } : {}
+        },
+        {
+            key: 'greeting.evening',
+            fallback: 'Good evening!',
+            params: username ? {
+                username
+            } : {}
+        }
+    ];
+    const result = await i18n(context, translations, locale);
+    // Return appropriate greeting based on time of day
+    const hour = new Date().getHours();
+    if (hour < 12) {
+        return result['greeting.morning'];
+    }
+    if (hour < 18) {
+        return result['greeting.afternoon'];
+    }
+    return result['greeting.evening'];
+}
+// Example 11: Force flush pending translations
+export async function ensureAllTranslationsProcessed() {
+    // Force process any pending translation batches
+    await flush();
+    console.log('All translation batches processed');
+} // Usage examples:
+ // const context = { databaseName: 'torchone-dev', session: { userId: 'user123' } };
+ //
+ // // Basic usage
+ // const welcomeMessages = await getWelcomeMessages(context, 'en');
+ //
+ // // With interpolation
+ // const personalizedMessages = await getPersonalizedMessages(context, 'John', 'es');
+ //
+ // // Multi-language content
+ // const multiLanguageContent = await getMultiLanguageContent(context);
+ //
+ // // Error handling
+ // const errorMessages = await getRobustTranslations(context, 'de');
+ //
+ // // Complex template
+ // const emailTemplate = await generateEmailTemplate(context, {
+ //   name: 'Maria',
+ //   email: 'maria@example.com',
+ //   orderId: 'ORD-123',
+ //   total: 99.99,
+ //   items: 3
+ // }, 'pt');
+ //
+ // // Notifications
+ // const notifications = await getNotificationMessages(context, 'fr');
+ //
+ // // Performance test
+ // const perf = await performanceComparison(context);
+ //
+ // // Dynamic greeting
+ // const greeting = await getUserGreeting(context, 'en', 'John');
+ //
+ // // Force flush
+ // await ensureAllTranslationsProcessed();
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/utils/translationQueue.example.ts"],"sourcesContent":["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n *\n * Example usage of the translation queue system with Google Translate integration\n *\n * This demonstrates how to use the new translation queue that automatically\n * translates content using Google Translate API when needed.\n */\n\nimport {flush, i18n, type TranslationObject} from './translationQueue.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {Locale} from '../types/content.types.js';\n\n// Example 1: Basic translations - will use database or translate as needed\nexport async function getWelcomeMessages(context: ApiContext, locale: Locale = 'en') {\n  const translations: TranslationObject[] = [\n    {\n      key: 'welcome.title',\n      fallback: 'Welcome to TorchOne!'\n    },\n    {\n      key: 'welcome.subtitle',\n      fallback: 'Your personal AI assistant'\n    },\n    {\n      key: 'welcome.description',\n      fallback: 'Get started by exploring our features'\n    }\n  ];\n\n  // This will:\n  // 1. Check database for existing translations\n  // 2. If not found and locale is default (en), save fallback to DB\n  // 3. If not found and locale is different, translate from default locale\n  // 4. Save translated content to DB for future use\n  const result = await i18n (context, translations, locale);\n\n  return result;\n  // Returns: {\n  //   'welcome.title': 'Welcome to TorchOne!' (or translated version),\n  //   'welcome.subtitle': 'Your personal AI assistant' (or translated version),\n  //   'welcome.description': 'Get started by exploring our features' (or translated version)\n  // }\n}\n\n// Example 2: Translations with interpolation\nexport async function getPersonalizedMessages(context: ApiContext, username: string, locale: Locale = 'en') {\n  const translations: TranslationObject[] = [\n    {\n      key: 'user.welcome',\n      fallback: 'Welcome back, {{username}}!',\n      params: {username}\n    },\n    {\n      key: 'user.notifications',\n      fallback: 'You have {{count}} new notifications',\n      params: {count: 5}\n    },\n    {\n      key: 'user.lastLogin',\n      fallback: 'Last login: {{date}}',\n      params: {date: new Date().toLocaleDateString()}\n    }\n  ];\n\n  const result = await i18n(context, translations, locale);\n\n  return result;\n  // Returns: {\n  //   'user.welcome': 'Welcome back, Alice!' (or translated with interpolation),\n  //   'user.notifications': 'You have 5 new notifications' (or translated with interpolation),\n  //   'user.lastLogin': 'Last login: 1/15/2025' (or translated with interpolation)\n  // }\n}\n\n// Example 3: Multi-language support\nexport async function getMultiLanguageContent(context: ApiContext) {\n  // Get content in multiple languages\n  const languages: Locale[] = ['en', 'es', 'fr'];\n  const results: Record<Locale, Record<string, string>> = {} as any;\n\n  for(const locale of languages) {\n    const translations: TranslationObject[] = [\n      {\n        key: 'app.name',\n        fallback: 'TorchOne'\n      },\n      {\n        key: 'app.tagline',\n        fallback: 'Your AI Assistant'\n      }\n    ];\n\n    results[locale] = await i18n(context, translations, locale);\n  }\n\n  return results;\n  // Returns: {\n  //   en: { 'app.name': 'TorchOne', 'app.tagline': 'Your AI Assistant' },\n  //   es: { 'app.name': 'TorchOne', 'app.tagline': 'Tu Asistente de IA' },\n  //   fr: { 'app.name': 'TorchOne', 'app.tagline': 'Votre Assistant IA' }\n  // }\n}\n\n// Example 4: Error handling and fallbacks\nexport async function getRobustTranslations(context: ApiContext, locale: Locale = 'en') {\n  const translations: TranslationObject[] = [\n    {\n      key: 'error.notFound',\n      fallback: 'Content not found'\n    },\n    {\n      key: 'error.serverError',\n      fallback: 'Server error occurred'\n    },\n    {\n      key: 'success.saved',\n      fallback: 'Content saved successfully'\n    }\n  ];\n\n  try {\n    const result = await i18n(context, translations, locale);\n    return result;\n  } catch(error) {\n    console.error('Translation error:', error);\n    // Return fallbacks if translation fails\n    return translations.reduce((acc, t) => {\n      acc[t.key] = t.fallback || '';\n      return acc;\n    }, {} as Record<string, string>);\n  }\n}\n\n// Example 5: Batch processing with flush\nexport async function processLargeTranslationBatch(context: ApiContext, locale: Locale = 'en') {\n  // Create a large batch of translations\n  const translations: TranslationObject[] = [];\n\n  for(let i = 1; i <= 100; i++) {\n    translations.push({\n      key: `item.${i}.title`,\n      fallback: `Item ${i} Title`,\n      params: {number: i}\n    });\n  }\n\n  // Process the batch\n  const result = await i18n(context, translations, locale);\n\n  // Ensure all pending translations are processed\n  await flush();\n\n  return result;\n}\n\n// Example 6: Error handling with fallbacks\nexport async function getErrorMessages(context: ApiContext, errorCode: string, locale: Locale = 'en') {\n  const translations: TranslationObject[] = [\n    {\n      key: `error.${errorCode}`,\n      fallback: `An error occurred: ${errorCode}`,\n      params: {errorCode}\n    },\n    {\n      key: 'error.contactSupport',\n      fallback: 'Please contact support if this problem persists.',\n      params: {}\n    }\n  ];\n\n  const result = await i18n(context, translations, locale);\n\n  // If database is unavailable, will return fallbacks:\n  // {\n  //   'error.INVALID_EMAIL': 'An error occurred: INVALID_EMAIL',\n  //   'error.contactSupport': 'Please contact support if this problem persists.'\n  // }\n\n  return result;\n}\n\n// Example 7: Complex email template with multiple interpolations\nexport async function generateEmailTemplate(\n  context: ApiContext,\n  userData: {\n    name: string;\n    email: string;\n    orderId: string;\n    total: number;\n    items: number;\n  },\n  locale: Locale = 'en'\n) {\n  const translations: TranslationObject[] = [\n    {\n      key: 'email.orderConfirmation.subject',\n      fallback: 'Order {{orderId}} Confirmed',\n      params: {orderId: userData.orderId}\n    },\n    {\n      key: 'email.orderConfirmation.greeting',\n      fallback: 'Hello {{name}},',\n      params: {name: userData.name}\n    },\n    {\n      key: 'email.orderConfirmation.body',\n      fallback: 'Your order {{orderId}} has been confirmed. Total: ${{total}} for {{items}} items.',\n      params: {\n        orderId: userData.orderId,\n        total: userData.total,\n        items: userData.items\n      }\n    },\n    {\n      key: 'email.orderConfirmation.footer',\n      fallback: 'Thank you for your purchase!'\n    }\n  ];\n\n  const result = await i18n(context, translations, locale);\n\n  return {\n    subject: result['email.orderConfirmation.subject'],\n    greeting: result['email.orderConfirmation.greeting'],\n    body: result['email.orderConfirmation.body'],\n    footer: result['email.orderConfirmation.footer']\n  };\n}\n\n// Example 8: Notification messages for different scenarios\nexport async function getNotificationMessages(context: ApiContext, locale: Locale = 'en') {\n  const translations: TranslationObject[] = [\n    {\n      key: 'notification.welcome',\n      fallback: 'Welcome to TorchOne!'\n    },\n    {\n      key: 'notification.verification',\n      fallback: 'Please verify your account.'\n    },\n    {\n      key: 'notification.passwordReset',\n      fallback: 'Your password has been reset.'\n    },\n    {\n      key: 'notification.profileUpdate',\n      fallback: 'Your profile has been updated.'\n    },\n    {\n      key: 'notification.newMessage',\n      fallback: 'You have a new message from {{sender}}.',\n      params: {sender: 'John Doe'}\n    }\n  ];\n\n  const result = await i18n(context, translations, locale);\n\n  return result;\n}\n\n// Example 9: Performance comparison\nexport async function performanceComparison(context: ApiContext) {\n  const keys = [\n    'welcome', 'verification', 'passwordReset', 'profileUpdate',\n    'email.subject', 'email.body', 'sms.welcome', 'sms.verification'\n  ];\n\n  const translations: TranslationObject[] = keys.map((key) => ({\n    key,\n    fallback: `Fallback for ${key}`\n  }));\n\n  console.time('Batch translation');\n  const batchResults = await i18n(context, translations, 'en');\n  console.timeEnd('Batch translation');\n\n  return batchResults;\n}\n\n// Example 10: Dynamic content based on user preferences\nexport async function getUserGreeting(\n  context: ApiContext,\n  userLocale?: string,\n  username?: string\n) {\n  const locale: Locale = (userLocale as Locale) || 'en';\n\n  const translations: TranslationObject[] = [\n    {\n      key: 'greeting.morning',\n      fallback: 'Good morning!',\n      params: username ? {username} : {}\n    },\n    {\n      key: 'greeting.afternoon',\n      fallback: 'Good afternoon!',\n      params: username ? {username} : {}\n    },\n    {\n      key: 'greeting.evening',\n      fallback: 'Good evening!',\n      params: username ? {username} : {}\n    }\n  ];\n\n  const result = await i18n(context, translations, locale);\n\n  // Return appropriate greeting based on time of day\n  const hour = new Date().getHours();\n  if(hour < 12) {\n    return result['greeting.morning'];\n  }\n  if(hour < 18) {\n    return result['greeting.afternoon'];\n  }\n  return result['greeting.evening'];\n}\n\n// Example 11: Force flush pending translations\nexport async function ensureAllTranslationsProcessed() {\n  // Force process any pending translation batches\n  await flush();\n  console.log('All translation batches processed');\n}\n\n// Usage examples:\n// const context = { databaseName: 'torchone-dev', session: { userId: 'user123' } };\n//\n// // Basic usage\n// const welcomeMessages = await getWelcomeMessages(context, 'en');\n//\n// // With interpolation\n// const personalizedMessages = await getPersonalizedMessages(context, 'John', 'es');\n//\n// // Multi-language content\n// const multiLanguageContent = await getMultiLanguageContent(context);\n//\n// // Error handling\n// const errorMessages = await getRobustTranslations(context, 'de');\n//\n// // Complex template\n// const emailTemplate = await generateEmailTemplate(context, {\n//   name: 'Maria',\n//   email: 'maria@example.com',\n//   orderId: 'ORD-123',\n//   total: 99.99,\n//   items: 3\n// }, 'pt');\n//\n// // Notifications\n// const notifications = await getNotificationMessages(context, 'fr');\n//\n// // Performance test\n// const perf = await performanceComparison(context);\n//\n// // Dynamic greeting\n// const greeting = await getUserGreeting(context, 'en', 'John');\n//\n// // Force flush\n// await ensureAllTranslationsProcessed();"],"names":["flush","i18n","getWelcomeMessages","context","locale","translations","key","fallback","result","getPersonalizedMessages","username","params","count","date","Date","toLocaleDateString","getMultiLanguageContent","languages","results","getRobustTranslations","error","console","reduce","acc","t","processLargeTranslationBatch","i","push","number","getErrorMessages","errorCode","generateEmailTemplate","userData","orderId","name","total","items","subject","greeting","body","footer","getNotificationMessages","sender","performanceComparison","keys","map","time","batchResults","timeEnd","getUserGreeting","userLocale","hour","getHours","ensureAllTranslationsProcessed","log"],"mappings":"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"}

package/lib/utils/translationQueue.js

@@ -0,0 +1,113 @@
+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { getContentWithFallback } from '../actions/content.js';
+class TranslationQueue {
+    batches = new Map();
+    batchTimeout = 50;
+    maxBatchSize = 20;
+    async translate(context, translations, locale = 'en') {
+        if (translations.length === 0) {
+            return {};
+        }
+        const promises = translations.map(({ key, fallback = '', params = {} })=>this.getTranslation(context, key, fallback, params, locale));
+        const results = await Promise.all(promises);
+        const resultMap = {};
+        translations.forEach(({ key }, index)=>{
+            resultMap[key] = results[index];
+        });
+        return resultMap;
+    }
+    async getTranslation(context, key, fallback, params = {}, locale = 'en') {
+        return new Promise((resolve, reject)=>{
+            const batchKey = this.getBatchKey(context, locale);
+            const request = {
+                key,
+                fallback,
+                params,
+                locale,
+                resolve,
+                reject
+            };
+            if (!this.batches.has(batchKey)) {
+                const timeout = setTimeout(()=>{
+                    this.processBatch(batchKey);
+                }, this.batchTimeout);
+                this.batches.set(batchKey, {
+                    context,
+                    requests: [
+                        request
+                    ],
+                    timeout
+                });
+            } else {
+                const batch = this.batches.get(batchKey);
+                batch.requests.push(request);
+                if (batch.requests.length >= this.maxBatchSize) {
+                    clearTimeout(batch.timeout);
+                    this.processBatch(batchKey);
+                }
+            }
+        });
+    }
+    async flush() {
+        const batchKeys = Array.from(this.batches.keys());
+        await Promise.all(batchKeys.map((key)=>this.processBatch(key)));
+    }
+    clear() {
+        this.batches.forEach((batch)=>{
+            clearTimeout(batch.timeout);
+            batch.requests.forEach((request)=>{
+                request.reject(new Error('Translation queue cleared'));
+            });
+        });
+        this.batches.clear();
+    }
+    getBatchKey(context, locale) {
+        return `${context.databaseName}:${locale}`;
+    }
+    async processBatch(batchKey) {
+        const batch = this.batches.get(batchKey);
+        if (!batch) {
+            return;
+        }
+        this.batches.delete(batchKey);
+        clearTimeout(batch.timeout);
+        const promises = batch.requests.map(async (request)=>{
+            try {
+                const content = await getContentWithFallback(batch.context, request.key, request.fallback, request.locale);
+                const interpolatedContent = this.interpolate(content, request.params);
+                return {
+                    request,
+                    result: interpolatedContent
+                };
+            } catch (error) {
+                const interpolatedFallback = this.interpolate(request.fallback, request.params);
+                return {
+                    request,
+                    result: interpolatedFallback
+                };
+            }
+        });
+        const results = await Promise.allSettled(promises);
+        results.forEach((result)=>{
+            if (result.status === 'fulfilled') {
+                result.value.request.resolve(result.value.result);
+            } else {
+                const { request } = result.reason;
+                const interpolatedFallback = this.interpolate(request.fallback, request.params);
+                request.resolve(interpolatedFallback);
+            }
+        });
+    }
+    interpolate(content, params = {}) {
+        return content.replace(/\{\{(\w+)\}\}/g, (match, key)=>params[key] !== undefined ? String(params[key]) : match);
+    }
+}
+const translationQueue = new TranslationQueue();
+export const i18n = (context, translations, locale)=>translationQueue.translate(context, translations, locale);
+export const flush = ()=>translationQueue.flush();
+export const clear = ()=>translationQueue.clear();
+export { translationQueue };
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/utils/translationQueue.ts"],"sourcesContent":["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\n\nimport {getContentWithFallback} from '../actions/content.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {Locale} from '../types/content.types.js';\n\ninterface TranslationRequest {\n  key: string;\n  fallback: string;\n  params?: Record<string, any>;\n  locale: Locale;\n  resolve: (value: string) => void;\n  reject: (error: Error) => void;\n}\n\ninterface TranslationBatch {\n  context: ApiContext;\n  requests: TranslationRequest[];\n  timeout: NodeJS.Timeout;\n}\n\ninterface TranslationObject {\n  key: string;\n  fallback?: string;\n  params?: Record<string, any>;\n}\n\nclass TranslationQueue {\n  private batches: Map<string, TranslationBatch> = new Map();\n  private batchTimeout = 50;\n  private maxBatchSize = 20;\n\n  async translate(\n    context: ApiContext,\n    translations: TranslationObject[],\n    locale: Locale = 'en'\n  ): Promise<Record<string, string>> {\n    if(translations.length === 0) {\n      return {};\n    }\n\n    const promises = translations.map(({key, fallback = '', params = {}}) =>\n      this.getTranslation(context, key, fallback, params, locale)\n    );\n\n    const results = await Promise.all(promises);\n\n    const resultMap: Record<string, string> = {};\n    translations.forEach(({key}, index) => {\n      resultMap[key] = results[index];\n    });\n\n    return resultMap;\n  }\n\n  private async getTranslation(\n    context: ApiContext,\n    key: string,\n    fallback: string,\n    params: Record<string, any> = {},\n    locale: Locale = 'en'\n  ): Promise<string> {\n    return new Promise((resolve, reject) => {\n      const batchKey = this.getBatchKey(context, locale);\n      const request: TranslationRequest = {key, fallback, params, locale, resolve, reject};\n\n      if(!this.batches.has(batchKey)) {\n        const timeout = setTimeout(() => {\n          this.processBatch(batchKey);\n        }, this.batchTimeout);\n\n        this.batches.set(batchKey, {\n          context,\n          requests: [request],\n          timeout\n        });\n      } else {\n        const batch = this.batches.get(batchKey)!;\n        batch.requests.push(request);\n\n        if(batch.requests.length >= this.maxBatchSize) {\n          clearTimeout(batch.timeout);\n          this.processBatch(batchKey);\n        }\n      }\n    });\n  }\n\n  async flush(): Promise<void> {\n    const batchKeys = Array.from(this.batches.keys());\n    await Promise.all(batchKeys.map((key) => this.processBatch(key)));\n  }\n\n  clear(): void {\n    this.batches.forEach((batch) => {\n      clearTimeout(batch.timeout);\n      batch.requests.forEach((request) => {\n        request.reject(new Error('Translation queue cleared'));\n      });\n    });\n    this.batches.clear();\n  }\n\n  private getBatchKey(context: ApiContext, locale: Locale): string {\n    return `${context.databaseName}:${locale}`;\n  }\n\n  private async processBatch(batchKey: string): Promise<void> {\n    const batch = this.batches.get(batchKey);\n    if(!batch) {\n      return;\n    }\n\n    this.batches.delete(batchKey);\n    clearTimeout(batch.timeout);\n\n    const promises = batch.requests.map(async (request) => {\n      try {\n        const content = await getContentWithFallback(\n          batch.context,\n          request.key,\n          request.fallback,\n          request.locale\n        );\n\n        const interpolatedContent = this.interpolate(content, request.params);\n        return {request, result: interpolatedContent};\n      } catch(error) {\n        const interpolatedFallback = this.interpolate(request.fallback, request.params);\n        return {request, result: interpolatedFallback};\n      }\n    });\n\n    const results = await Promise.allSettled(promises);\n\n    results.forEach((result) => {\n      if(result.status === 'fulfilled') {\n        result.value.request.resolve(result.value.result);\n      } else {\n        const {request} = result.reason;\n        const interpolatedFallback = this.interpolate(request.fallback, request.params);\n        request.resolve(interpolatedFallback);\n      }\n    });\n  }\n\n  private interpolate(content: string, params: Record<string, any> = {}): string {\n    return content.replace(/\\{\\{(\\w+)\\}\\}/g, (match, key) => (params[key] !== undefined ? String(params[key]) : match));\n  }\n}\n\nconst translationQueue = new TranslationQueue();\n\nexport const i18n = (\n  context: ApiContext,\n  translations: TranslationObject[],\n  locale?: Locale\n): Promise<Record<string, string>> => translationQueue.translate(context, translations, locale);\n\nexport const flush = (): Promise<void> => translationQueue.flush();\nexport const clear = (): void => translationQueue.clear();\n\nexport type {TranslationObject};\n\n  export {translationQueue};\n"],"names":["getContentWithFallback","TranslationQueue","batches","Map","batchTimeout","maxBatchSize","translate","context","translations","locale","length","promises","map","key","fallback","params","getTranslation","results","Promise","all","resultMap","forEach","index","resolve","reject","batchKey","getBatchKey","request","has","timeout","setTimeout","processBatch","set","requests","batch","get","push","clearTimeout","flush","batchKeys","Array","from","keys","clear","Error","databaseName","delete","content","interpolatedContent","interpolate","result","error","interpolatedFallback","allSettled","status","value","reason","replace","match","undefined","String","translationQueue","i18n"],"mappings":"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"}

package/package.json

@@ -1,11 +1,18 @@
 {
   "name": "@nlabs/reaktor",
-  "version": "0.10.5",
+  "version": "0.10.6",
   "description": "Reaktor",
   "type": "module",
   "main": "./lib/index.js",
   "module": "./lib/index.js",
   "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "default": "./lib/index.js"
+    }
+  },
   "keywords": [
     "reaktor",
     "nitrogenlabs",
@@ -43,53 +50,65 @@
     "watch": "lex compile --remove --watch"
   },
   "dependencies": {
-    "@aws-sdk/client-apigatewaymanagementapi": "^3.901.0",
-    "@aws-sdk/client-dynamodb": "^3.902.0",
-    "@aws-sdk/client-s3": "^3.901.0",
-    "@aws-sdk/client-ses": "^3.901.0",
-    "@aws-sdk/client-sns": "^3.901.0",
-    "@aws-sdk/s3-request-presigner": "^3.901.0",
-    "@nlabs/arkhamjs": "^3.31.7",
+    "@aws-sdk/client-apigatewaymanagementapi": "^3.958.0",
+    "@aws-sdk/client-dynamodb": "^3.958.0",
+    "@aws-sdk/client-s3": "^3.958.0",
+    "@aws-sdk/client-ses": "^3.958.0",
+    "@aws-sdk/client-sns": "^3.958.0",
+    "@aws-sdk/s3-request-presigner": "^3.958.0",
+    "@nlabs/arkhamjs": "^3.31.9",
     "@nlabs/rip-hunter": "^3.0.2",
-    "@nlabs/utils": "^2.8.4",
-    "@types/aws-lambda": "^8.10.155",
-    "apn": "^2.0.0",
+    "@nlabs/utils": "^2.8.6",
+    "@types/aws-lambda": "^8.10.159",
+    "apn": "^2.2.0",
     "arangojs": "^10.1.2",
-    "aws-sdk": "^2.1692.0",
+    "aws-sdk": "^2.1693.0",
     "child_process": "^1.0.2",
-    "core-js": "^3.45.1",
-    "file-type": "^21.0.0",
+    "core-js": "^3.47.0",
+    "file-type": "^21.2.0",
     "gm": "^1.25.1",
     "google-libphonenumber": "^3.2.43",
-    "googleapis": "161.0.0",
-    "graphql": "^16.11.0",
+    "googleapis": "169.0.0",
+    "graphql": "^16.12.0",
     "graphql-compose": "^9.1.0",
     "graphql-fields": "^2.0.3",
-    "i18next": "^25.5.3",
-    "jsonwebtoken": "^9.0.2",
+    "i18next": "^25.7.3",
+    "jsonwebtoken": "^9.0.3",
     "luxon": "^3.7.2",
-    "mime-types": "^3.0.1",
+    "mime-types": "^3.0.2",
     "net": "^1.0.2",
     "numeral": "^2.0.6",
     "sanitize-html": "^2.17.0",
     "spawn-sync": "^2.0.0",
-    "stripe": "^19.1.0",
+    "stripe": "^20.1.0",
     "tls": "0.0.1",
     "to": "^0.2.9",
     "typed-promisify": "^0.4.0",
     "universal-analytics": "^0.5.3",
-    "zod": "^4.1.11"
+    "zod": "^4.2.1"
   },
   "devDependencies": {
     "@jest/globals": "^30.2.0",
-    "@nlabs/lex": "^1.50.1",
+    "@nlabs/lex": "^1.52.17",
     "@types/history": "^5.0.0",
     "@types/jest": "^30.0.0",
     "@types/luxon": "^3.7.1",
-    "@types/node": "^24.6.2",
+    "@types/node": "^25.0.3",
     "@types/stripe": "^8.0.417",
     "@types/twilio": "^3.19.3",
-    "graphql-tools": "^9.0.20",
+    "graphql-tools": "^9.0.25",
     "typescript": "^5.9.3"
+  },
+  "overrides": {
+    "cross-spawn": ">=6.0.6",
+    "got": ">=11.8.5",
+    "http-cache-semantics": ">=4.1.1",
+    "http-proxy-middleware": ">=2.0.7",
+    "jsonwebtoken": "^9.0.3",
+    "minimist": ">=0.2.1",
+    "node-forge": ">=1.0.0",
+    "postcss": ">=7.0.36",
+    "semver-regex": ">=3.1.3",
+    "tmp": ">0.2.3"
   }
 }