@gugananuvem/aws-local-simulator 1.0.34 → 1.0.39

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

@@ -0,0 +1,99 @@
+/**
+ * CloudFront Models Index
+ */
+
+const Distribution = require('./distribution');
+const Origin = require('./origin');
+const Behavior = require('./behavior');
+const Invalidation = require('./invalidation');
+
+/**
+ * Validate a distribution configuration
+ * @param {object} config - Configuration to validate
+ * @returns {object} Validation result
+ */
+function validate(config) {
+  const errors = [];
+  const warnings = [];
+
+  // Check required fields
+  if (!config.Origins || !Array.isArray(config.Origins) || config.Origins.length === 0) {
+    errors.push('Configuration must have at least one origin');
+  }
+
+  if (!config.DefaultCacheBehavior) {
+    errors.push('Configuration must have DefaultCacheBehavior');
+  }
+
+  if (!config.CallerReference) {
+    errors.push('Configuration must have CallerReference');
+  }
+
+  // Check behavior configuration
+  if (config.DefaultCacheBehavior) {
+    const behavior = config.DefaultCacheBehavior;
+    
+    if (!behavior.TargetOriginId) {
+      errors.push('DefaultCacheBehavior must have TargetOriginId');
+    }
+
+    if (!behavior.ViewerProtocolPolicy) {
+      errors.push('DefaultCacheBehavior must have ViewerProtocolPolicy');
+    }
+
+    const validPolicies = ['allow-all', 'https-only', 'redirect-to-https'];
+    if (behavior.ViewerProtocolPolicy && !validPolicies.includes(behavior.ViewerProtocolPolicy)) {
+      errors.push(
+        `Invalid ViewerProtocolPolicy: ${behavior.ViewerProtocolPolicy}`
+      );
+    }
+  }
+
+  // Check cache behaviors if present
+  if (config.CacheBehaviors && Array.isArray(config.CacheBehaviors)) {
+    for (let i = 0; i < config.CacheBehaviors.length; i++) {
+      const behavior = config.CacheBehaviors[i];
+      
+      if (!behavior.PathPattern) {
+        errors.push(`CacheBehavior ${i} must have PathPattern`);
+      }
+
+      if (!behavior.TargetOriginId) {
+        errors.push(`CacheBehavior ${i} must have TargetOriginId`);
+      }
+    }
+  }
+
+  // Check geo-restrictions if present
+  if (config.GeoRestriction) {
+    const validTypes = ['none', 'whitelist', 'blacklist'];
+    if (!validTypes.includes(config.GeoRestriction.RestrictionType)) {
+      errors.push(
+        `Invalid GeoRestriction type: ${config.GeoRestriction.RestrictionType}`
+      );
+    }
+  }
+
+  // Warnings for best practices
+  if (!config.Comment) {
+    warnings.push('It is recommended to provide a comment for the distribution');
+  }
+
+  if (config.Logging?.Enabled && !config.Logging?.Bucket) {
+    errors.push('Logging is enabled but no bucket is specified');
+  }
+
+  return {
+    isValid: errors.length === 0,
+    errors: errors,
+    warnings: warnings
+  };
+}
+
+module.exports = {
+  Distribution,
+  Origin,
+  Behavior,
+  Invalidation,
+  validate
+};

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

@@ -0,0 +1,109 @@
+/**
+ * CloudFront Invalidation Model
+ * Gerencia invalidação de cache
+ */
+
+const crypto = require('crypto');
+
+class Invalidation {
+  constructor(params = {}) {
+    this.Id = params.Id || this.generateId();
+    this.DistributionId = params.DistributionId;
+    this.CreateTime = new Date();
+    this.Status = params.Status || 'InProgress';
+    this.CallerReference = params.CallerReference || crypto.randomUUID();
+    
+    // Paths to invalidate
+    this.Paths = params.Paths || {
+      Quantity: 0,
+      Items: []
+    };
+
+    // Progress (0-100)
+    this.Progress = params.Progress !== undefined ? params.Progress : 0;
+
+    // Estimated completion time (após 5 minutos é normalmente completo)
+    this.EstimatedCompletionTime = new Date(Date.now() + 5 * 60 * 1000);
+  }
+
+  generateId() {
+    return crypto.randomBytes(16).toString('hex').toUpperCase();
+  }
+
+  /**
+   * Marcar como concluída
+   */
+  complete() {
+    this.Status = 'Completed';
+    this.Progress = 100;
+  }
+
+  /**
+   * Verificar se path deve ser invalidado
+   */
+  shouldInvalidate(path) {
+    if (!this.Paths?.Items) {
+      return false;
+    }
+
+    for (const invalidationPath of this.Paths.Items) {
+      if (this.pathMatches(path, invalidationPath)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Verificar se path corresponde ao padrão de invalidação
+   * Suporta wildcards: *.jpg, /api/*, etc
+   */
+  pathMatches(path, pattern) {
+    if (pattern === '*') {
+      return true;
+    }
+
+    // Converter glob pattern para regex
+    const regex = new RegExp(
+      '^' + pattern
+        .replace(/\./g, '\\.')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.') +
+      '$'
+    );
+
+    return regex.test(path);
+  }
+
+  /**
+   * Retornar invalidação em formato AWS
+   */
+  toAWSFormat() {
+    return {
+      Id: this.Id,
+      DistributionId: this.DistributionId,
+      CreateTime: this.CreateTime,
+      Status: this.Status,
+      Paths: this.Paths,
+      InvalidationBatch: {
+        Paths: this.Paths,
+        CallerReference: this.CallerReference
+      },
+      Progress: this.Progress
+    };
+  }
+
+  /**
+   * Obter invalidation em formato para resposta
+   */
+  getSummary() {
+    return {
+      Id: this.Id,
+      CreateTime: this.CreateTime,
+      Status: this.Status
+    };
+  }
+}
+
+module.exports = Invalidation;

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

@@ -0,0 +1,155 @@
+/**
+ * CloudFront Origin Model
+ * Suporta S3, HTTP, e Lambda@Edge origins
+ */
+
+class Origin {
+  constructor(params = {}) {
+    this.Id = params.Id || 'default-origin';
+    this.DomainName = params.DomainName || 'example.com';
+    this.OriginPath = params.OriginPath || '';
+    this.CustomHeaders = params.CustomHeaders || {
+      Quantity: 0,
+      Items: []
+    };
+
+    // Tipo de origem
+    this.OriginType = this.detectOriginType(params.DomainName);
+
+    // S3 Origin
+    if (this.OriginType === 's3') {
+      this.S3OriginConfig = params.S3OriginConfig || {
+        OriginAccessIdentity: ''
+      };
+    }
+
+    // HTTP/HTTPS Origin
+    if (this.OriginType === 'http' || this.OriginType === 'lambda') {
+      this.CustomOriginConfig = params.CustomOriginConfig || {
+        HTTPPort: 80,
+        HTTPSPort: 443,
+        OriginProtocolPolicy: 'https-only',
+        OriginSslProtocols: {
+          Quantity: 3,
+          Items: ['TLSv1', 'TLSv1.1', 'TLSv1.2']
+        },
+        OriginReadTimeout: 30,
+        OriginKeepaliveTimeout: 5
+      };
+    }
+
+    // Origin Shield
+    this.OriginShield = params.OriginShield || {
+      Enabled: false,
+      OriginShieldRegion: null
+    };
+
+    // Origin Groups (para failover)
+    this.OriginGroupId = params.OriginGroupId || null;
+
+    // Lambda@Edge
+    this.LambdaFunctionAssociations = params.LambdaFunctionAssociations || {
+      Quantity: 0,
+      Items: []
+    };
+
+    // Origin Access Control
+    this.OriginAccessControlId = params.OriginAccessControlId || null;
+
+    // Connection settings
+    this.ConnectionAttempts = params.ConnectionAttempts || 3;
+    this.ConnectionTimeout = params.ConnectionTimeout || 10;
+  }
+
+  /**
+   Detectar tipo de origem
+   */
+  detectOriginType(domainName) {
+    if (!domainName) return 'http';
+
+    if (domainName.includes('.s3') || domainName.includes('s3.amazonaws.com')) {
+      return 's3';
+    }
+
+    if (domainName.includes('.lambda.') || domainName.includes('lambda-url')) {
+      return 'lambda';
+    }
+
+    return 'http';
+  }
+
+  /**
+   * Validar origem
+   */
+  validate() {
+    const errors = [];
+
+    if (!this.Id) {
+      errors.push('Origin Id is required');
+    }
+
+    if (!this.DomainName) {
+      errors.push('Origin DomainName is required');
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Retornar origem em formato AWS
+   */
+  toAWSFormat() {
+    const origin = {
+      Id: this.Id,
+      DomainName: this.DomainName,
+      OriginPath: this.OriginPath,
+      CustomHeaders: this.CustomHeaders,
+      ConnectionAttempts: this.ConnectionAttempts,
+      ConnectionTimeout: this.ConnectionTimeout
+    };
+
+    if (this.OriginType === 's3') {
+      origin.S3OriginConfig = this.S3OriginConfig;
+    } else {
+      origin.CustomOriginConfig = this.CustomOriginConfig;
+    }
+
+    if (this.OriginShield?.Enabled) {
+      origin.OriginShield = this.OriginShield;
+    }
+
+    if (this.LambdaFunctionAssociations?.Quantity > 0) {
+      origin.LambdaFunctionAssociations = this.LambdaFunctionAssociations;
+    }
+
+    if (this.OriginAccessControlId) {
+      origin.OriginAccessControlId = this.OriginAccessControlId;
+    }
+
+    return origin;
+  }
+
+  /**
+   * Obter URL completa do origin
+   */
+  getOriginUrl(path = '/') {
+    const protocol = this.OriginType === 's3' || this.CustomOriginConfig?.OriginProtocolPolicy === 'https-only'
+      ? 'https'
+      : 'http';
+
+    const port = protocol === 'https'
+      ? (this.CustomOriginConfig?.HTTPSPort || 443)
+      : (this.CustomOriginConfig?.HTTPPort || 80);
+
+    const portString = (protocol === 'https' && port === 443) || (protocol === 'http' && port === 80)
+      ? ''
+      : `:${port}`;
+
+    return `${protocol}://${this.DomainName}${portString}${this.OriginPath}${path}`;
+  }
+}
+
+module.exports = Origin;