beddel 0.2.3 → 1.0.0

package/src/compliance/lgpdEngine.ts

@@ -1,268 +0,0 @@
-/**
- * LGPD Compliance Engine v2025
- * Lei Geral de Proteção de Dados Brasileira
- * Enhanced with SHA-256 audit trail integration
- */
-
-import { AuditTrail } from "../audit/auditTrail";
-
-export interface LGPDConfig {
-  tenantId: string;
-  dataConsent: boolean;
-  dataAnonymization: boolean;
-  dataRetentionDays: number;
-  brazilianDataResidency: boolean;
-  rightToDelete: boolean;
-  dataOwnerRights: boolean;
-  automaticDeletion: boolean;
-}
-
-export interface LGPDComplianceResult {
-  compliant: boolean;
-  violations: string[];
-  recommendations: string[];
-  anpdRequirements: string[];
-}
-
-export class LGPDCompliance {
-  private auditTrail: AuditTrail;
-
-  constructor(auditTrail?: AuditTrail) {
-    this.auditTrail = auditTrail || new AuditTrail();
-  }
-
-  /**
-   * Verify LGPD compliance for tenant
-   */
-  public async verifyCompliance(config: LGPDConfig): Promise<boolean> {
-    const result = await this.checkCompliance(config);
-    return result.compliant;
-  }
-
-  /**
-   * Check full LGPD compliance with audit trail
-   */
-  private async checkCompliance(
-    config: LGPDConfig
-  ): Promise<LGPDComplianceResult> {
-    const violations: string[] = [];
-    const recommendations: string[] = [];
-    const anpdRequirements: string[] = [];
-    const operationId = `lgpd-check-${config.tenantId}-${Date.now()}`;
-
-    try {
-      // Check data consent
-      if (!config.dataConsent) {
-        violations.push(
-          "Explicit consent requires implementation (Art. 7, LGPD)"
-        );
-      } else {
-        recommendations.push(
-          "Implement consent management dashboard (ANPD Guidance)"
-        );
-      }
-
-      // Check data anonymization
-      if (!config.dataAnonymization) {
-        violations.push("Data anonymization required (ANPD Guidance)");
-      } else {
-        recommendations.push("Use strong anonymization algorithms (ISO 29100)");
-      }
-
-      // Check Brazilian data residency
-      if (!config.brazilianDataResidency) {
-        violations.push("Data residency requirement not met (Art. 48, LGPD)");
-        anpdRequirements.push("Implement data localization in Brazil");
-      } else {
-        recommendations.push(
-          "Document data residency compliance (ANPD Recommendation)"
-        );
-      }
-
-      // Check right to delete
-      if (!config.rightToDelete) {
-        violations.push("Right to delete not implemented (Art. 18, LGPD)");
-        anpdRequirements.push("Implement <24h data deletion system");
-      } else {
-        recommendations.push(
-          "Test deletion automation regularly (Best Practice)"
-        );
-      }
-
-      // Check data owner rights
-      if (!config.dataOwnerRights) {
-        violations.push("Data owner rights not respected (Art. 18, LGPD)");
-        anpdRequirements.push("Implement data subject request management");
-      }
-
-      // Check automatic deletion
-      if (!config.automaticDeletion) {
-        violations.push("Automatic deletion not configured (ANPD Guidance)");
-      } else {
-        recommendations.push(
-          "Monitor deletion schedules (ANPD Recommendation)"
-        );
-      }
-
-      // Check data retention
-      if (config.dataRetentionDays > 1825) {
-        // 5 anos máximo
-        violations.push(
-          "Data retention exceeds LGPD limits (ANPD Orientation)"
-        );
-        anpdRequirements.push("Reduce retention to 5 years maximum");
-      } else if (config.dataRetentionDays < 90) {
-        violations.push("Data retention too short for business needs");
-        recommendations.push("Consider retention period (Art. 16, LGPD)");
-      } else {
-        recommendations.push(
-          "Review retention policies annually (ANPD Practice)"
-        );
-      }
-
-      // Log compliance check to audit trail
-      await this.auditTrail.logOperation({
-        operationId,
-        tenantId: config.tenantId,
-        operation: "lgpd_compliance_check",
-        data: {
-          compliant: violations.length === 0,
-          violationsCount: violations.length,
-          anpdRequirementsCount: anpdRequirements.length,
-          retentionDays: config.dataRetentionDays,
-        },
-        timestamp: new Date(),
-      });
-
-      const compliant = violations.length === 0;
-
-      return {
-        compliant,
-        violations,
-        recommendations,
-        anpdRequirements,
-      };
-    } catch (error) {
-      await this.auditTrail.logOperation({
-        operationId,
-        tenantId: config.tenantId,
-        operation: "lgpd_compliance_error",
-        data: {
-          error: error instanceof Error ? error.message : String(error),
-        },
-        timestamp: new Date(),
-        success: false,
-      });
-      throw error;
-    }
-  }
-
-  /**
-   * Anonymize personal data LGPD standards
-   */
-  public anonymizeDataLGPD(data: any): any {
-    if (typeof data !== "object" || data === null) {
-      return data;
-    }
-
-    const anonymized = { ...data };
-
-    // Anonymize Brazilian personal data fields
-    const personalFields = [
-      "nome",
-      "email",
-      "telefone",
-      "cpf",
-      "rg",
-      "cnh",
-      "endereco",
-      "data_nascimento",
-      "nacionalidade",
-      "foto",
-      "assinatura",
-      "biometria",
-    ];
-
-    for (const field of personalFields) {
-      if (anonymized[field]) {
-        anonymized[field] = this.hashSensitiveDataLGPD(anonymized[field]);
-      }
-    }
-
-    return anonymized;
-  }
-
-  /**
-   * Hash sensitive data LGPD compliant
-   */
-  private hashSensitiveDataLGPD(data: any): string {
-    if (typeof data === "string") {
-      // Use SHA-256 hash for LGPD compliance
-      const crypto = require("crypto");
-      return crypto.createHash("sha256").update(data).digest("hex");
-    }
-    return "LGPD_HASH_BR_" + this.hashSensitiveDataLGPD(JSON.stringify(data));
-  }
-
-  /**
-   * Generate LGPD compliance report
-   */
-  public generateLGPDReport(tenantId: string): any {
-    return {
-      tenantId,
-      reportDate: new Date().toISOString(),
-      lawCompliance: "LGPD Lei 13.709/2018",
-      dataProtectionOfficer: "DPO_" + tenantId + "@compliance.com",
-      measures: {
-        dataLocalization: true,
-        consentManagement: true,
-        dataAnonymization: true,
-        encryption: "AES-256",
-        accessControl: "RBAC Multi-Factor",
-        auditTrail: "ISO 27001 aligned",
-        incidentResponse: "<72h per ANPD",
-        dataDeletion: "<24h automated",
-      },
-      certifications: {
-        iso27001: true,
-        iso27701: true,
-        nist: true,
-        lgpdScore: "9.5/10",
-      },
-      anpdCompliant: true,
-      version: "2025.1",
-    };
-  }
-
-  /**
-   * Calculate LGPD compliance score
-   */
-  public calculateScore(config: LGPDConfig): number {
-    let score = 5.0;
-
-    // Data consent
-    if (config.dataConsent) score += 0.8;
-
-    // Data anonymization
-    if (config.dataAnonymization) score += 1.0;
-
-    // Brazilian data residency
-    if (config.brazilianDataResidency) score += 1.2;
-
-    // Right to delete
-    if (config.rightToDelete) score += 0.8;
-
-    // Data owner rights
-    if (config.dataOwnerRights) score += 0.5;
-
-    // Automatic deletion
-    if (config.automaticDeletion) score += 0.7;
-
-    // Retention period
-    if (config.dataRetentionDays <= 1825 && config.dataRetentionDays >= 90) {
-      score += 0.5;
-    }
-
-    return Math.min(score, 10.0);
-  }
-}

package/src/config.ts

@@ -1,179 +0,0 @@
-/**
- * Beddel Runtime Configuration - Isolated VM v5
- * Ultra-secure runtime environment with zero-trust architecture
- */
-export type AllowedYamlPrimitive =
-  | "null"
-  | "boolean"
-  | "integer"
-  | "float"
-  | "string";
-
-export interface YAMLParserConfig {
-  schema?: "FAILSAFE_SCHEMA";
-  allowedTypes?: AllowedYamlPrimitive[];
-  performanceTarget?: number;
-  maxDepth?: number;
-  maxKeys?: number;
-  maxStringLength?: number;
-  maxValueSize?: number;
-  lazyLoading?: boolean;
-  enableCaching?: boolean;
-  validateUTF8?: boolean;
-  strictMode?: boolean;
-  filename?: string;
-}
-
-export interface RuntimeConfig {
-  // Memory limits for isolated execution
-  memoryLimit: number; // Memory limit in MB per execution
-  timeout: number; // Execution timeout in milliseconds
-  securityScore: number; // Minimum security score (9.5/10)
-  executionTimeTarget: number; // Target execution time in milliseconds
-
-  // Pool configuration
-  maxPoolSize: number; // Maximum number of isolates in pool
-  minPoolSize: number; // Minimum number of isolates in pool
-  poolIdleTimeout: number; // Pool cleanup timeout in ms
-
-  // Security profiles
-  defaultSecurityProfile: string; // Default security profile name
-  allowRestrictedAccess: boolean; // Allow restricted access to external resources
-
-  // Audit logging
-  auditEnabled: boolean; // Enable audit logging
-  auditLevel: "none" | "basic" | "full"; // Audit detail level
-  auditHashAlgorithm: "sha256" | "sha512"; // Hash algorithm for audit trail
-
-  // Performance monitoring
-  metricsEnabled: boolean; // Enable performance metrics
-  metricsInterval: number; // Metrics collection interval in ms
-  maxExecutionHistory: number; // Maximum number of executions to track
-
-  // Multi-tenant configuration
-  tenantIsolation: boolean; // Enable tenant isolation
-  maxConcurrentExecutions: number; // Maximum concurrent executions
-
-  // Firebase multi-tenant configuration (2025)
-  multiTenant: boolean; // Firebase multi-tenant mode
-  dataRetention: string; // LGPD/GDPR data retention policy
-  auditHash: string; // Hash algorithm for audit trail
-}
-
-export const runtimeConfig: RuntimeConfig = {
-  // Core runtime settings
-  memoryLimit: 2, // 2MB por execução
-  timeout: 5000, // 5 segundos máximo
-  securityScore: 9.5, // Target mínimo 9.5/10
-  executionTimeTarget: 50, // 50ms target
-
-  // Pool management
-  maxPoolSize: 100, // Máximo de 100 isolates
-  minPoolSize: 5, // Mínimo de 5 isolates
-  poolIdleTimeout: 300000, // 5 minutos idle timeout
-
-  // Security configuration
-  defaultSecurityProfile: "ultra-secure",
-  allowRestrictedAccess: false, // Sem acesso externo por padrão
-
-  // Audit configuration
-  auditEnabled: true,
-  auditLevel: "full",
-  auditHashAlgorithm: "sha256",
-
-  // Performance monitoring
-  metricsEnabled: true,
-  metricsInterval: 1000, // Coleta a cada segundo
-  maxExecutionHistory: 10000, // Histórico de 10k execuções
-
-  // Multi-tenant settings
-  tenantIsolation: true,
-  maxConcurrentExecutions: 1000, // Suporte a 1000 execuções simultâneas
-
-  // Firebase multi-tenant configuration (2025)
-  multiTenant: true, // Isolamento total de tenants
-  dataRetention: "LGPD", // LGPD compliance automatic
-  auditHash: "SHA-256", // Hash criptográfico de operações
-};
-
-/**
- * Security profiles for different execution contexts
- */
-export interface SecurityProfile {
-  name: string;
-  memoryLimit: number;
-  timeout: number;
-  allowExternalAccess: boolean;
-  allowedModules: string[];
-  restrictedFunctions: string[];
-  securityLevel: "low" | "medium" | "high" | "ultra";
-}
-
-export const securityProfiles: Record<string, SecurityProfile> = {
-  "ultra-secure": {
-    name: "ultra-secure",
-    memoryLimit: 2, // 2MB
-    timeout: 5000, // 5s
-    allowExternalAccess: false,
-    allowedModules: [],
-    restrictedFunctions: ["require", "eval", "Function", "process"],
-    securityLevel: "ultra",
-  },
-  "high-security": {
-    name: "high-security",
-    memoryLimit: 4, // 4MB
-    timeout: 10000, // 10s
-    allowExternalAccess: false,
-    allowedModules: ["lodash", "moment"],
-    restrictedFunctions: ["eval", "Function"],
-    securityLevel: "high",
-  },
-  "tenant-isolated": {
-    name: "tenant-isolated",
-    memoryLimit: 8, // 8MB
-    timeout: 15000, // 15s
-    allowExternalAccess: true,
-    allowedModules: ["lodash", "moment", "uuid"],
-    restrictedFunctions: ["eval"],
-    securityLevel: "medium",
-  },
-};
-
-/**
- * Performance targets for monitoring
- */
-export interface PerformanceTarget {
-  metric: string;
-  target: number;
-  unit: string;
-  threshold: number; // Alert threshold
-}
-
-export const performanceTargets: PerformanceTarget[] = [
-  { metric: "executionTime", target: 50, unit: "ms", threshold: 75 },
-  { metric: "memoryUsage", target: 2, unit: "MB", threshold: 3 },
-  { metric: "successRate", target: 99.9, unit: "%", threshold: 99.5 },
-  { metric: "isolateCreationTime", target: 100, unit: "ms", threshold: 200 },
-  { metric: "poolUtilization", target: 70, unit: "%", threshold: 90 },
-];
-
-/**
- * Audit trail configuration
- */
-export interface AuditConfig {
-  enabled: boolean;
-  hashAlgorithm: string;
-  includeContext: boolean;
-  includeResult: boolean;
-  maxTrailSize: number;
-  retentionPeriod: number; // in days
-}
-
-export const auditConfig: AuditConfig = {
-  enabled: true,
-  hashAlgorithm: "sha256",
-  includeContext: true,
-  includeResult: true,
-  maxTrailSize: 1024 * 1024 * 100, // 100MB
-  retentionPeriod: 90, // 90 dias
-};

package/src/errors.ts

@@ -1,35 +0,0 @@
-/**
- * Tipos de erro específicos para o parser YAML seguro
- */
-
-export class YAMLBaseError extends Error {
-  constructor(message: string, public code?: string) {
-    super(message);
-    this.name = 'YAMLBaseError';
-    Object.setPrototypeOf(this, YAMLBaseError.prototype);
-  }
-}
-
-export class YAMLParseError extends YAMLBaseError {
-  constructor(message: string, code?: string) {
-    super(message, code);
-    this.name = 'YAMLParseError';
-    Object.setPrototypeOf(this, YAMLParseError.prototype);
-  }
-}
-
-export class YAMLSecurityError extends YAMLBaseError {
-  constructor(message: string, code?: string) {
-    super(message, code);
-    this.name = 'YAMLSecurityError';
-    Object.setPrototypeOf(this, YAMLSecurityError.prototype);
-  }
-}
-
-export class YAMLPerformanceError extends YAMLBaseError {
-  constructor(message: string, code?: string) {
-    super(message, code);
-    this.name = 'YAMLPerformanceError';
-    Object.setPrototypeOf(this, YAMLPerformanceError.prototype);
-  }
-}