lokalise-data-handling

name	lokalise-data-handling
description	Implement Lokalise translation data handling, PII management, and compliance patterns. Use when handling sensitive translation data, implementing data redaction, or ensuring compliance with privacy regulations for Lokalise integrations. Trigger with phrases like "lokalise data", "lokalise PII", "lokalise GDPR", "lokalise data retention", "lokalise privacy", "lokalise compliance".
allowed-tools	Read, Write, Edit
version	1.0.0
license	MIT
author	Jeremy Longshore <[e-mail]>

Lokalise Data Handling

Overview

Handle translation data correctly with privacy, compliance, and data governance best practices.

Prerequisites

• Understanding of GDPR/CCPA requirements
• Lokalise SDK installed
• Database for audit logging
• Data classification policies

Data Classification

Category	Examples	Handling
Translation Keys	welcome.message, error.network	Standard
UI Text	"Welcome!", "Submit"	Standard
Dynamic Content	Hello, {name}	Review for PII
User-Generated	Comments, descriptions	May contain PII
API Tokens	abc123...	Never log
Screenshots	Context images	May contain PII

Instructions

Step 1: Translation Content Scanning

// Scan translations for potential PII before upload
const PII_PATTERNS = [
  { type: "email", regex: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g },
  { type: "phone", regex: /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g },
  { type: "ssn", regex: /\b\d{3}-\d{2}-\d{4}\b/g },
  { type: "credit_card", regex: /\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b/g },
  { type: "ip_address", regex: /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g },
];

interface PIIFinding {
  type: string;
  match: string;
  key: string;
  language: string;
}

function scanTranslationsForPII(
  translations: Record<string, string>,
  language: string
): PIIFinding[] {
  const findings: PIIFinding[] = [];

  for (const [key, value] of Object.entries(translations)) {
     ( pattern  ) {
       matches = value.(pattern.);
       ( match  matches) {
        findings.({
          : pattern.,
          : match[],
          key,
          language,
        });
      }
    }
  }

   findings;
}


  (): <{
  : ;
  : [];
}> {
   content = .(fs.(filePath, ));
   locale = path.(filePath, );
   findings = (content, locale);

   (findings. > ) {
    .();
    findings.( {
      .();
    });
  }

   {
    : findings. === ,
    findings,
  };
}

Step 2: Safe Logging Practices

// Never log API tokens or sensitive translation content
function safeLokaliseLog(
  operation: string,
  data: Record<string, any>
): void {
  const sanitized = { ...data };

  // Remove sensitive fields
  delete sanitized.apiToken;
  delete sanitized.apiKey;
  delete sanitized.webhookSecret;

  // Truncate large translation content
  if (sanitized.translation && typeof sanitized.translation === "string") {
    sanitized.translation = sanitized.translation.length > 100
      ? `${sanitized.translation.slice(0, 100)}...`
      : sanitized.translation;
  }

  // Mask key IDs in production
  if (process.env.NODE_ENV === "production" && sanitized.keyId) {
    sanitized.keyId = "***";
  }

  console.log(`[Lokalise] ${operation}:`, sanitized);
}

// Usage
safeLokaliseLog("translation.update", {
  : ,
  : ,
  : ,
  : ,
});

Step 3: Data Retention Management

interface RetentionPolicy {
  dataType: string;
  retentionDays: number;
  reason: string;
}

const RETENTION_POLICIES: RetentionPolicy[] = [
  { dataType: "api_logs", retentionDays: 30, reason: "Debugging" },
  { dataType: "error_logs", retentionDays: 90, reason: "Root cause analysis" },
  { dataType: "audit_logs", retentionDays: 2555, reason: "Compliance (7 years)" },
  { dataType: "webhook_payloads", retentionDays: 7, reason: "Retry/debugging" },
  { dataType: "translation_cache", retentionDays: 1, reason: "Performance" },
];

async function enforceRetention(dataType: string): Promise<number> {
  const policy = RETENTION_POLICIES.find( => p. === dataType);
   (!policy) {
      ();
  }

   cutoff =  ();
  cutoff.(cutoff.() - policy.);

   deleted =  db..({
    dataType,
    : { : cutoff },
  });

  .();
   deleted.;
}

Step 4: Audit Logging

interface AuditEntry {
  timestamp: Date;
  userId: string;
  action: string;
  resource: string;
  projectId: string;
  details?: Record<string, any>;
  ipAddress?: string;
}

async function auditLokaliseAction(entry: Omit<AuditEntry, "timestamp">): Promise<void> {
  const audit: AuditEntry = {
    ...entry,
    timestamp: new Date(),
  };

  // Store in audit log (separate from regular logs)
  await db.auditLog.insert(audit);

  // Log for real-time monitoring
  console.log("[AUDIT]", JSON.stringify(audit));
}

// Usage
await auditLokaliseAction({
  userId: currentUser.id,
  action: "translation.update",
  resource: ,
  : ,
  : {
    : ,
    : ,
    : ,
  },
  : request.,
});

Step 5: Data Export for Compliance

// GDPR Data Subject Access Request (DSAR)
async function exportUserTranslationActivity(userId: string): Promise<{
  user: { id: string; email: string };
  activity: AuditEntry[];
  exportedAt: string;
}> {
  // Get all Lokalise-related activity for user
  const activity = await db.auditLog.find({
    userId,
    resource: { $regex: /^lokalise/ },
  });

  return {
    user: { id: userId, email: "[from user database]" },
    activity: activity.map(a => ({
      ...a,
      // Redact sensitive details
      details: { action: a.details?.action, timestamp: a.timestamp },
    })),
    exportedAt: new Date().toISOString(),
  };
}

// Right to deletion
async function deleteUserTranslationData(userId: ): <{
  : ;
  : ;
}> {
  
   deleted =  db..({ userId });

  
  
   db..(
    { userId },
    { : { : , :  } }
  );

  
   ({
    : ,
    : ,
    : ,
    : ,
    : { :  },
  });

   {
    : deleted.,
    : ,
  };
}

Output

• PII scanning for translations
• Safe logging practices
• Data retention enforcement
• Audit trail for compliance

Error Handling

Issue	Cause	Solution
PII in translations	User-submitted content	Scan before upload
Token in logs	Improper logging	Use safe log wrapper
Audit gaps	Missing logging	Add audit calls
Retention violation	No cleanup	Schedule retention jobs

Examples

Pre-commit PII Check

#!/bin/bash
# .husky/pre-commit

# Check for PII in translation files
node scripts/scan-translations-pii.js

if [ $? -ne 0 ]; then
  echo "PII detected in translations. Please review and remove."
  exit 1
fi

Compliance Checklist

## Translation Data Compliance Checklist

### Data Collection
- [ ] Only necessary data collected
- [ ] User consent for personalized content
- [ ] Purpose documented

### Storage
- [ ] Translations stored securely
- [ ] API tokens in secret manager
- [ ] Cache encrypted at rest

### Retention
- [ ] Retention policies defined
- [ ] Automatic cleanup scheduled
- [ ] Audit logs retained per regulations

### Access
- [ ] Role-based access to projects
- [ ] Access logged and auditable
- [ ] Regular access reviews

### User Rights
- [ ] Data export capability
- [ ] Deletion process documented
- [ ] Anonymization procedures

Quick PII Scan

const result = await validateBeforeUpload("./locales/en.json");
if (!result.valid) {
  console.error("Cannot upload: PII detected");
  result.findings.forEach(f => console.error(`  ${f.type}: ${f.key}`));
  process.exit(1);
}

Resources

• GDPR Developer Guide
• CCPA Compliance
• Lokalise Privacy

Next Steps

For enterprise access control, see lokalise-enterprise-rbac.