- 9. International Data Transfers
+ 9. Data Location and International Operations
-
- The Tractatus Framework operates from New Zealand. If you access our services from other countries, your data may be transferred to and processed in New Zealand. By using our services, you consent to this transfer.
+
+ The Tractatus Framework is administered from Aotearoa New Zealand, but our infrastructure is hosted with OVHCloud in the European Union (France). Your data is stored and processed within the EU, benefiting from robust EU data protection standards.
-
- GDPR Compliance: For EU users, we comply with GDPR requirements including lawful basis for processing, data minimization, and your rights under Articles 15-22.
+
Hosting and Data Residency:
+
+ - Primary Hosting: OVHCloud (France, EU) - all user data stored in EU jurisdiction
+ - Database: MongoDB Atlas (EU-West region, Frankfurt, Germany)
+ - Payment Processing: Stripe (uses Standard Contractual Clauses for EU-US data transfers)
+ - No Data Transfer to NZ: Your personal data is not transferred to or processed in New Zealand
+
+
+ GDPR Compliance:
+
+ As our infrastructure is hosted in the EU, we benefit from the protections of the General Data Protection Regulation (GDPR). EU users' data never leaves EU jurisdiction during normal operations. We comply with GDPR requirements including:
+
+
+ - Lawful basis for processing (Article 6)
+ - Data minimization and purpose limitation (Article 5)
+ - Your rights under Articles 15-22 (access, rectification, erasure, portability, objection)
+ - Privacy by Design and Default (Article 25)
+ - Data security measures (Article 32)
+
+
+
+ For non-EU users: Your data is processed in the EU and benefits from GDPR protections, regardless of your location. We extend GDPR rights to all users globally.
diff --git a/scripts/translate-privacy-deepl.js b/scripts/translate-privacy-deepl.js
new file mode 100755
index 00000000..5dca4385
--- /dev/null
+++ b/scripts/translate-privacy-deepl.js
@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+
+/**
+ * Translate privacy.json from EN to DE and FR using DeepL API
+ *
+ * Usage: node scripts/translate-privacy-deepl.js [--force]
+ *
+ * Options:
+ * --force Overwrite existing translations
+ *
+ * Requires: DEEPL_API_KEY environment variable
+ */
+
+require('dotenv').config();
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+
+const DEEPL_API_KEY = process.env.DEEPL_API_KEY;
+const API_URL = 'api.deepl.com'; // Pro API endpoint
+
+const FORCE = process.argv.includes('--force');
+
+if (!DEEPL_API_KEY) {
+ console.error('❌ ERROR: DEEPL_API_KEY environment variable not set');
+ console.error(' Set it with: export DEEPL_API_KEY="your-key-here"');
+ process.exit(1);
+}
+
+const EN_FILE = path.join(__dirname, '../public/locales/en/privacy.json');
+const DE_FILE = path.join(__dirname, '../public/locales/de/privacy.json');
+const FR_FILE = path.join(__dirname, '../public/locales/fr/privacy.json');
+
+// Load JSON files
+const enData = JSON.parse(fs.readFileSync(EN_FILE, 'utf8'));
+const deData = JSON.parse(fs.readFileSync(DE_FILE, 'utf8'));
+const frData = JSON.parse(fs.readFileSync(FR_FILE, 'utf8'));
+
+// DeepL API request function
+function translateText(text, targetLang) {
+ return new Promise((resolve, reject) => {
+ const postData = new URLSearchParams({
+ auth_key: DEEPL_API_KEY,
+ text: text,
+ target_lang: targetLang,
+ source_lang: 'EN',
+ formality: 'default',
+ preserve_formatting: '1',
+ tag_handling: 'html' // Preserve HTML tags
+ }).toString();
+
+ const options = {
+ hostname: API_URL,
+ port: 443,
+ path: '/v2/translate',
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/x-www-form-urlencoded',
+ 'Content-Length': Buffer.byteLength(postData)
+ }
+ };
+
+ const req = https.request(options, (res) => {
+ let data = '';
+ res.on('data', (chunk) => { data += chunk; });
+ res.on('end', () => {
+ if (res.statusCode === 200) {
+ try {
+ const response = JSON.parse(data);
+ resolve(response.translations[0].text);
+ } catch (err) {
+ reject(new Error(`Failed to parse response: ${err.message}`));
+ }
+ } else {
+ reject(new Error(`DeepL API error: ${res.statusCode} - ${data}`));
+ }
+ });
+ });
+
+ req.on('error', reject);
+ req.write(postData);
+ req.end();
+ });
+}
+
+// Helper to get nested value
+function getNestedValue(obj, path) {
+ return path.split('.').reduce((current, key) => current?.[key], obj);
+}
+
+// Helper to set nested value
+function setNestedValue(obj, path, value) {
+ const keys = path.split('.');
+ const lastKey = keys.pop();
+ const target = keys.reduce((current, key) => {
+ if (!current[key]) current[key] = {};
+ return current[key];
+ }, obj);
+ target[lastKey] = value;
+}
+
+// Recursively find all string values and their paths
+function findAllStrings(obj, prefix = '') {
+ const strings = [];
+
+ for (const [key, value] of Object.entries(obj)) {
+ const currentPath = prefix ? `${prefix}.${key}` : key;
+
+ if (typeof value === 'string') {
+ strings.push(currentPath);
+ } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+ strings.push(...findAllStrings(value, currentPath));
+ } else if (Array.isArray(value)) {
+ // Handle arrays of strings
+ value.forEach((item, index) => {
+ if (typeof item === 'string') {
+ strings.push(`${currentPath}.${index}`);
+ }
+ });
+ }
+ }
+
+ return strings;
+}
+
+// Main translation function
+async function translateFile(targetLang, targetData, targetFile) {
+ console.log(`\n🌐 Translating to ${targetLang}...`);
+
+ const allPaths = findAllStrings(enData);
+ let translatedCount = 0;
+ let skippedCount = 0;
+ let errorCount = 0;
+
+ for (const keyPath of allPaths) {
+ const enValue = getNestedValue(enData, keyPath);
+ const existingValue = getNestedValue(targetData, keyPath);
+
+ // Skip if already translated (not empty) unless --force flag
+ if (!FORCE && existingValue && existingValue.trim().length > 0 && existingValue !== enValue) {
+ skippedCount++;
+ process.stdout.write('.');
+ continue;
+ }
+
+ try {
+ // Translate
+ const translated = await translateText(enValue, targetLang);
+ setNestedValue(targetData, keyPath, translated);
+ translatedCount++;
+ process.stdout.write('✓');
+
+ // Rate limiting: wait 500ms between requests to avoid 429 errors
+ await new Promise(resolve => setTimeout(resolve, 500));
+
+ } catch (error) {
+ console.error(`\n❌ Error translating ${keyPath}:`, error.message);
+ errorCount++;
+ process.stdout.write('✗');
+ }
+ }
+
+ console.log(`\n\n📊 Translation Summary for ${targetLang}:`);
+ console.log(` ✓ Translated: ${translatedCount}`);
+ console.log(` . Skipped (already exists): ${skippedCount}`);
+ console.log(` ✗ Errors: ${errorCount}`);
+
+ // Save updated file
+ fs.writeFileSync(targetFile, JSON.stringify(targetData, null, 2) + '\n', 'utf8');
+ console.log(` 💾 Saved: ${targetFile}`);
+}
+
+// Run translations
+async function main() {
+ console.log('═══════════════════════════════════════════════════════════');
+ console.log(' DeepL Translation: privacy.json (EN → DE, FR)');
+ console.log('═══════════════════════════════════════════════════════════\n');
+
+ if (FORCE) {
+ console.log('⚠️ --force flag enabled: Will overwrite existing translations\n');
+ }
+
+ const totalStrings = findAllStrings(enData).length;
+ console.log(`📝 Total translation keys in EN file: ${totalStrings}`);
+
+ try {
+ // Translate to German
+ await translateFile('DE', deData, DE_FILE);
+
+ // Translate to French
+ await translateFile('FR', frData, FR_FILE);
+
+ console.log('\n✅ Translation complete!');
+ console.log('\n💡 Next steps:');
+ console.log(' 1. Review translations in de/privacy.json and fr/privacy.json');
+ console.log(' 2. Test on local server: npm start');
+ console.log(' 3. Visit http://localhost:9000/privacy.html and switch languages');
+
+ } catch (error) {
+ console.error('\n❌ Fatal error:', error);
+ process.exit(1);
+ }
+}
+
+main();