@gugananuvem/aws-local-simulator 1.0.35 → 1.0.39

package/src/services/cloudfront/index.js

@@ -0,0 +1,220 @@
+/**
+ * CloudFront Service Index
+ * Main entry point for CloudFront simulator
+ */
+
+const CloudFrontServer = require('./server');
+const CloudFrontSimulator = require('./simulator');
+const CloudFrontStore = require('./store');
+const SignedUrlGenerator = require('./signed-url-generator');
+const OriginValidator = require('./origin-validator');
+const GeoRestrictions = require('./geo-restrictions');
+const OriginRouter = require('./origin-router');
+const CacheEngine = require('./cache-engine');
+
+const {
+  Distribution,
+  Origin,
+  Behavior,
+  Invalidation,
+  validate
+} = require('./models');
+
+/**
+ * CloudFront Service Class
+ */
+class CloudFrontService {
+  constructor(config) {
+    this.config = config;
+    this.name = 'cloudfront';
+    this.port = config?.ports?.cloudfront || config?.services?.cloudfront?.port || 4017;
+    this.server = null;
+    this.simulator = null;
+    this.store = null;
+    this.isRunning = false;
+  }
+
+  async initialize() {
+    const logger = require('../../utils/logger');
+    logger?.debug?.(`Initializing CloudFront Service on port ${this.port}...`);
+    
+    this.simulator = new CloudFrontSimulator(this.config);
+    this.store = new CloudFrontStore(this.config?.storagePath || './data/cloudfront');
+    this.server = new CloudFrontServer(this.config);
+    
+    // Inject simulator into server
+    this.server.simulator = this.simulator;
+    
+    logger?.debug?.('CloudFront Service initialized');
+  }
+
+  injectDependencies(server) {
+    // CloudFront may depend on other services like S3, Lambda, etc.
+    // Injections would happen here
+    const s3Service = server.getService('s3');
+    const apigatewayService = server.getService('apigateway');
+    const ec2Service = server.getService('ec2');
+    const lambdaService = server.getService('lambda');
+
+    if (this.simulator) {
+      if (s3Service) this.simulator.registerService('s3', s3Service);
+      if (apigatewayService) this.simulator.registerService('apigateway', apigatewayService);
+      if (ec2Service) this.simulator.registerService('ec2', ec2Service);
+      if (lambdaService) this.simulator.registerService('lambda', lambdaService);
+    }
+  }
+
+  async start() {
+    if (this.isRunning) return;
+    
+    return new Promise((resolve, reject) => {
+      try {
+        const httpServer = this.server.listen(this.port);
+        
+        // Handle listen errors
+        httpServer.on('error', (error) => {
+          if (error.code === 'EADDRINUSE') {
+            reject(new Error(`Port ${this.port} is already in use`));
+          } else {
+            reject(error);
+          }
+        });
+        
+        // Server is listening
+        this.isRunning = true;
+        resolve();
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  async stop() {
+    if (!this.isRunning) return;
+    
+    return new Promise((resolve) => {
+      if (this.server?.server) {
+        this.server.server.close(() => {
+          this.isRunning = false;
+          resolve();
+        });
+      } else {
+        this.isRunning = false;
+        resolve();
+      }
+    });
+  }
+
+  async reset() {
+    if (this.simulator) {
+      this.simulator.reset?.();
+    }
+    if (this.store) {
+      this.store.clear?.();
+    }
+  }
+
+  getStatus() {
+    const stats = this.simulator?.getStats?.() || { 
+      distributionsCount: 0, 
+      cacheHits: 0, 
+      cacheMisses: 0 
+    };
+    
+    return {
+      name: 'cloudfront',
+      running: this.isRunning,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`,
+      ...stats
+    };
+  }
+
+  getSimulator() {
+    return this.simulator;
+  }
+
+  getServer() {
+    return this.server;
+  }
+
+  getStore() {
+    return this.store;
+  }
+}
+
+/**
+ * Create a CloudFront service instance (backward compatibility)
+ * @param {object} options - Configuration options
+ * @returns {object} CloudFront service object
+ */
+function createCloudFrontService(options = {}) {
+  const simulator = new CloudFrontSimulator(options);
+  const store = new CloudFrontStore(options.storePath);
+  const server = new CloudFrontServer(options);
+
+  return {
+    // Simulator methods
+    simulator,
+    createDistribution: (config) => simulator.createDistribution(config),
+    getDistribution: (id) => simulator.getDistribution(id),
+    listDistributions: () => simulator.listDistributions(),
+    deleteDistribution: (id) => simulator.deleteDistribution(id),
+    processRequest: (request) => simulator.processRequest(request),
+    invalidateDistribution: (id, paths) => simulator.invalidateDistribution(id, paths),
+    generateSignedUrl: (id, path, key, keyPair, expiration) =>
+      simulator.generateSignedUrl(id, path, key, keyPair, expiration),
+    getCacheStats: () => simulator.getCacheStats(),
+    getDistributionStats: (id) => simulator.getDistributionStats(id),
+    getRequestStats: () => simulator.getRequestStats(),
+
+    // Store methods
+    store,
+    saveDistribution: (distribution) => store.saveDistribution(distribution),
+    loadDistribution: (id) => store.getDistribution(id),
+    loadDistributions: () => store.getAllDistributions(),
+    saveInvalidation: (invalidation) => store.saveInvalidation(invalidation),
+    loadInvalidation: (id) => store.getInvalidation(id),
+    clearStore: () => store.clear(),
+    exportData: () => store.export(),
+    importData: (data) => store.import(data),
+    createBackup: (path) => store.createBackup(path),
+
+    // Server methods
+    server,
+    listen: (port) => server.listen(port),
+    getApp: () => server.getApp(),
+
+    // Helper classes
+    SignedUrlGenerator,
+    OriginValidator,
+    GeoRestrictions,
+    CacheEngine,
+
+    // Models
+    Distribution,
+    Origin,
+    Behavior,
+    Invalidation,
+    validate
+  };
+}
+
+module.exports = CloudFrontService;
+
+// Also export for backward compatibility
+module.exports.CloudFrontService = CloudFrontService;
+module.exports.createCloudFrontService = createCloudFrontService;
+module.exports.CloudFrontServer = CloudFrontServer;
+module.exports.CloudFrontSimulator = CloudFrontSimulator;
+module.exports.CloudFrontStore = CloudFrontStore;
+module.exports.SignedUrlGenerator = SignedUrlGenerator;
+module.exports.OriginValidator = OriginValidator;
+module.exports.OriginRouter = OriginRouter;
+module.exports.GeoRestrictions = GeoRestrictions;
+module.exports.CacheEngine = CacheEngine;
+module.exports.Distribution = Distribution;
+module.exports.Origin = Origin;
+module.exports.Behavior = Behavior;
+module.exports.Invalidation = Invalidation;
+module.exports.validate = validate;

package/src/services/cloudfront/models/behavior.js

@@ -0,0 +1,158 @@
+/**
+ * CloudFront Behavior Model
+ * Define como CloudFront comporta-se para diferentes paths
+ */
+
+class Behavior {
+  constructor(params = {}) {
+    this.PathPattern = params.PathPattern || '*';  // null for default
+    this.TargetOriginId = params.TargetOriginId;
+    this.ViewerProtocolPolicy = params.ViewerProtocolPolicy || 'allow-all';
+    this.AllowedMethods = params.AllowedMethods || {
+      Quantity: 2,
+      Items: ['GET', 'HEAD']
+    };
+    this.CachedMethods = params.CachedMethods || {
+      Quantity: 2,
+      Items: ['GET', 'HEAD']
+    };
+    
+    // Caching
+    this.CachePolicyId = params.CachePolicyId || '658327ea-f89d-4fab-a63d-7e88639e58f6';
+    this.OriginRequestPolicyId = params.OriginRequestPolicyId || null;
+    this.ResponseHeadersPolicyId = params.ResponseHeadersPolicyId || null;
+    
+    // TTL (deprecated, for backwards compatibility)
+    this.MinTTL = params.MinTTL || 0;
+    this.DefaultTTL = params.DefaultTTL || 86400;
+    this.MaxTTL = params.MaxTTL || 31536000;
+    
+    // Compression
+    this.Compress = params.Compress !== false;
+    
+    // Forwarded values
+    this.ForwardedValues = params.ForwardedValues || {
+      QueryString: true,
+      Cookies: { Forward: 'all' },
+      Headers: { Quantity: 0, Items: [] }
+    };
+    
+    // Trusted signers (for signed URLs/cookies)
+    this.TrustedSigners = params.TrustedSigners || {
+      Enabled: false,
+      Quantity: 0,
+      Items: []
+    };
+    
+    // Field-level encryption
+    this.FieldLevelEncryptionId = params.FieldLevelEncryptionId || null;
+    
+    // Lambda@Edge
+    this.LambdaFunctionAssociations = params.LambdaFunctionAssociations || {
+      Quantity: 0,
+      Items: []
+    };
+    
+    // Realtime logs
+    this.RealtimeLogConfigArn = params.RealtimeLogConfigArn || null;
+  }
+
+  /**
+   * Validar behavior
+   */
+  validate() {
+    const errors = [];
+
+    if (!this.TargetOriginId) {
+      errors.push('TargetOriginId is required');
+    }
+
+    if (!['allow-all', 'https-only', 'redirect-to-https'].includes(this.ViewerProtocolPolicy)) {
+      errors.push('Invalid ViewerProtocolPolicy');
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Obter política de cache baseada no CachePolicyId
+   */
+  getCachePolicy() {
+    const managedPolicies = {
+      '658327ea-f89d-4fab-a63d-7e88639e58f6': {
+        name: 'CachingOptimized',
+        ttl: { min: 0, default: 86400, max: 31536000 }
+      },
+      '4135ea3d-c35d-4c5f-bc95-6f532eef9d81': {
+        name: 'CachingDisabled',
+        ttl: { min: 0, default: 0, max: 0 }
+      },
+      '08627262-05a9-4f76-9ded-b50ec2b5fbf0': {
+        name: 'Elemental',
+        ttl: { min: 0, default: 0, max: 0 }
+      }
+    };
+
+    return managedPolicies[this.CachePolicyId] || {
+      name: 'Custom',
+      ttl: { min: this.MinTTL, default: this.DefaultTTL, max: this.MaxTTL }
+    };
+  }
+
+  /**
+   * Verificar se request é cacheável
+   */
+  isCacheable(method = 'GET', statusCode = 200) {
+    // GET e HEAD são cacheáveis por padrão
+    if (!['GET', 'HEAD'].includes(method)) {
+      return false;
+    }
+
+    // Apenas respostas 200 são cacheadas (simplificado)
+    if (statusCode !== 200) {
+      return false;
+    }
+
+    const cachePolicy = this.getCachePolicy();
+    if (cachePolicy.name === 'CachingDisabled') {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Obter TTL baseado na política
+   */
+  getTTL() {
+    const policy = this.getCachePolicy();
+    return policy.ttl.default;
+  }
+
+  /**
+   * Retornar behavior em formato AWS
+   */
+  toAWSFormat() {
+    return {
+      PathPattern: this.PathPattern,
+      TargetOriginId: this.TargetOriginId,
+      ViewerProtocolPolicy: this.ViewerProtocolPolicy,
+      AllowedMethods: this.AllowedMethods,
+      CachedMethods: this.CachedMethods,
+      Compress: this.Compress,
+      CachePolicyId: this.CachePolicyId,
+      OriginRequestPolicyId: this.OriginRequestPolicyId,
+      ResponseHeadersPolicyId: this.ResponseHeadersPolicyId,
+      MinTTL: this.MinTTL,
+      DefaultTTL: this.DefaultTTL,
+      MaxTTL: this.MaxTTL,
+      ForwardedValues: this.ForwardedValues,
+      TrustedSigners: this.TrustedSigners
+    };
+  }
+}
+
+module.exports = Behavior;

package/src/services/cloudfront/models/distribution.js

@@ -0,0 +1,284 @@
+/**
+ * CloudFront Distribution Model
+ * Representa uma distribuição CloudFront completa
+ */
+
+const crypto = require('crypto');
+
+class Distribution {
+  constructor(params = {}) {
+    this.Id = params.Id || this.generateId();
+    this.ARN = `arn:aws:cloudfront::123456789012:distribution/${this.Id}`;
+    this.DomainName = params.DomainName || `${this.Id}.cloudfront.net`;
+    this.CallerReference = params.CallerReference || crypto.randomUUID();
+    this.Comment = params.Comment || '';
+    this.DefaultRootObject = params.DefaultRootObject || 'index.html';
+    this.Enabled = params.Enabled !== false;
+    this.Status = 'Deployed';
+    this.CreatedTime = new Date();
+    this.LastModifiedTime = new Date();
+    this.LastModifiedBy = params.LastModifiedBy || 'simulator';
+    this.ETag = this.generateETag();
+    
+    // Origins
+    this.Origins = params.Origins || {
+      Quantity: 0,
+      Items: []
+    };
+
+    // Default Cache Behavior
+    this.DefaultCacheBehavior = params.DefaultCacheBehavior || {
+      TargetOriginId: this.Origins.Items?.[0]?.Id || 'default-origin',
+      ViewerProtocolPolicy: 'allow-all',
+      TrustedSigners: { Enabled: false, Quantity: 0 },
+      ForwardedValues: {
+        QueryString: false,
+        Cookies: { Forward: 'none' },
+        Headers: { Quantity: 0 }
+      },
+      MinTTL: 0,
+      DefaultTTL: 86400,
+      MaxTTL: 31536000,
+      Compress: false,
+      CachePolicyId: '658327ea-f89d-4fab-a63d-7e88639e58f6'
+    };
+
+    // Cache Behaviors (path patterns)
+    this.CacheBehaviors = params.CacheBehaviors || {
+      Quantity: 0,
+      Items: []
+    };
+
+    // Geo Restrictions
+    this.GeoRestriction = params.GeoRestriction || {
+      RestrictionType: 'none',
+      Quantity: 0,
+      Items: []
+    };
+
+    // WebACL
+    this.WebACLId = params.WebACLId || '';
+
+    // HTTP Version
+    this.HttpVersion = params.HttpVersion || 'http2';
+
+    // IPv6 Enabled
+    this.IsIPV6Enabled = params.IsIPV6Enabled !== false;
+
+    // Invalidations in progress
+    this.InvalidationsInProgress = 0;
+
+    // Cache statistics
+    this.CacheStats = {
+      Hits: 0,
+      Misses: 0,
+      BytesSent: 0,
+      BytesUploaded: 0
+    };
+
+    // Origin Shield
+    this.OriginShield = params.OriginShield || {
+      Enabled: false,
+      OriginShieldRegion: null
+    };
+
+    // Custom domain (CNAME)
+    this.Aliases = params.Aliases || {
+      Quantity: 0,
+      Items: []
+    };
+
+    // SSL/TLS
+    this.ViewerCertificate = params.ViewerCertificate || {
+      CloudFrontDefaultCertificate: true,
+      ACMCertificateArn: null,
+      SSLSupportMethod: null,
+      MinimumProtocolVersion: 'TLSv1'
+    };
+
+    // Logging
+    this.Logging = params.Logging || {
+      Enabled: false,
+      IncludeCookies: false,
+      Bucket: null,
+      Prefix: ''
+    };
+
+    // Price Class
+    this.PriceClass = params.PriceClass || 'PriceClass_All';
+  }
+
+  /**
+   * Getter para origins (compatibilidade com simulador)
+   * Converte Origins com Items para array com propriedades em minúsculas
+   */
+  get origins() {
+    if (!this.Origins?.Items) return [];
+    return this.Origins.Items.map(item => ({
+      id: item.Id || item.id,
+      domainName: item.DomainName || item.domainName,
+      originPath: item.OriginPath || item.originPath || '',
+      customOriginConfig: item.CustomOriginConfig || item.customOriginConfig,
+      s3OriginConfig: item.S3OriginConfig || item.s3OriginConfig,
+      ...item // Manter todas as outras propriedades
+    }));
+  }
+
+  /**
+   * Getter para cache behaviors
+   */
+  get cacheBehaviors() {
+    if (!this.CacheBehaviors?.Items) return [];
+    return this.CacheBehaviors.Items.map(item => ({
+      pathPattern: item.PathPattern || item.pathPattern,
+      targetOriginId: item.TargetOriginId || item.targetOriginId,
+      viewerProtocolPolicy: item.ViewerProtocolPolicy || item.viewerProtocolPolicy,
+      ...item
+    }));
+  }
+
+  generateId() {
+    return crypto.randomBytes(7).toString('hex').toUpperCase();
+  }
+
+  generateETag() {
+    const data = JSON.stringify({
+      Origins: this.Origins,
+      DefaultCacheBehavior: this.DefaultCacheBehavior,
+      CacheBehaviors: this.CacheBehaviors,
+      Enabled: this.Enabled,
+      LastModifiedTime: this.LastModifiedTime
+    });
+    return crypto.createHash('md5').update(data).digest('hex');
+  }
+
+  /**
+   * Encontrar behavior que corresponde ao path
+   */
+  matchBehavior(path) {
+    // Procurar em Cache Behaviors por path pattern (mais específico primeiro)
+    if (this.CacheBehaviors?.Items) {
+      const sorted = [...this.CacheBehaviors.Items].sort((a, b) => {
+        // Path patterns mais específicos primeiro
+        const aSpecificity = this.calculatePathSpecificity(a.PathPattern);
+        const bSpecificity = this.calculatePathSpecificity(b.PathPattern);
+        return bSpecificity - aSpecificity;
+      });
+
+      for (const behavior of sorted) {
+        if (this.pathMatches(path, behavior.PathPattern)) {
+          return behavior;
+        }
+      }
+    }
+
+    // Retornar default behavior
+    return this.DefaultCacheBehavior;
+  }
+
+  /**
+   * Verificar se path corresponde ao pattern
+   * Suporta wildcards: *.jpg, /api/*, etc
+   */
+  pathMatches(path, pattern) {
+    if (!pattern || pattern === '*') {
+      return true;
+    }
+
+    // Converter glob pattern para regex
+    const regex = new RegExp(
+      '^' + pattern
+        .replace(/\./g, '\\.')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.') +
+      '$'
+    );
+
+    return regex.test(path);
+  }
+
+  /**
+   * Calcular especificidade do path pattern
+   * Mais específico = maior número
+   */
+  calculatePathSpecificity(pattern) {
+    if (!pattern) return 0;
+    if (pattern === '*') return 1;
+    
+    // Contar caracteres não-wildcard
+    const nonWildcard = pattern.replace(/[*?]/g, '').length;
+    return nonWildcard;
+  }
+
+  /**
+   * Atualizar ETag após modificação
+   */
+  updateETag() {
+    this.ETag = this.generateETag();
+    this.LastModifiedTime = new Date();
+  }
+
+  /**
+   * Retornar distribuição em formato AWS
+   */
+  toAWSFormat() {
+    return {
+      Id: this.Id,
+      ARN: this.ARN,
+      Status: this.Status,
+      LastModifiedTime: this.LastModifiedTime,
+      DomainName: this.DomainName,
+      Aliases: this.Aliases,
+      DefaultRootObject: this.DefaultRootObject,
+      Origins: this.Origins,
+      DefaultCacheBehavior: this.DefaultCacheBehavior,
+      CacheBehaviors: this.CacheBehaviors,
+      CustomErrorResponses: {
+        Quantity: 0,
+        Items: []
+      },
+      Logging: this.Logging,
+      Enabled: this.Enabled,
+      Comment: this.Comment,
+      Restrictions: {
+        GeoRestriction: this.GeoRestriction
+      },
+      WebACLId: this.WebACLId,
+      HttpVersion: this.HttpVersion,
+      IsIPV6Enabled: this.IsIPV6Enabled,
+      PriceClass: this.PriceClass
+    };
+  }
+
+  /**
+   * Retornar config da distribuição
+   */
+  getConfig() {
+    return {
+      CallerReference: this.CallerReference,
+      ...this.toAWSFormat()
+    };
+  }
+
+  /**
+   * Validar distribuição
+   */
+  validate() {
+    const errors = [];
+
+    if (!this.Origins?.Items || this.Origins.Items.length === 0) {
+      errors.push('Distribution must have at least one origin');
+    }
+
+    if (!this.DefaultCacheBehavior?.TargetOriginId) {
+      errors.push('DefaultCacheBehavior must have a TargetOriginId');
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+}
+
+module.exports = Distribution;