@gugananuvem/aws-local-simulator 1.0.35 → 1.0.39

package/src/services/index.js

@@ -21,6 +21,20 @@ const { SecretManagerService } = require('./secret-manager');
 const { ParameterStoreService } = require('./parameter-store');
 const { ConfigService } = require('./config');
 const { AthenaService } = require('./athena');
+const { AuroraService } = require('./aurora');
+const IAMService = require('./iam');
+const VPCService = require('./vpc');
+const EC2Service = require('./ec2');
+const ALBService = require('./alb');
+const ASGService = require('./asg');
+const OpenSearchService = require('./opensearch');
+const KinesisDataStreamsService = require('./kinesis-data-streams');
+const KinesisFirehoseService = require('./kinesis-firehose');
+const KinesisAnalyticsService = require('./kinesis-analytics');
+const OrganizationsService = require('./organizations');
+const CloudFrontService = require('./cloudfront');
+const Route53Service = require('./route53');
+const ACMService = require('./acm');
 
 module.exports = {
   DynamoDBService,
@@ -42,4 +56,18 @@ module.exports = {
   ParameterStoreService,
   ConfigService,
   AthenaService,
+  AuroraService,
+  IAMService,
+  VPCService,
+  EC2Service,
+  ALBService,
+  ASGService,
+  OpenSearchService,
+  KinesisDataStreamsService,
+  KinesisFirehoseService,
+  KinesisAnalyticsService,
+  OrganizationsService,
+  CloudFrontService,
+  Route53Service,
+  ACMService,
 };

package/src/services/kinesis-analytics/index.js

@@ -0,0 +1,105 @@
+/**
+ * Kinesis Data Analytics Service - Ponto de entrada
+ */
+
+const KinesisAnalyticsServer = require('./server');
+const KinesisAnalyticsSimulator = require('./simulator');
+
+class KinesisAnalyticsService {
+  constructor(config) {
+    this.config = config;
+    this.name = 'kinesis-analytics';
+    this.port = config.ports['kinesis-analytics'] || 4570;
+    this.server = null;
+    this.simulator = null;
+    this.isRunning = false;
+  }
+
+  async initialize() {
+    const logger = require('../../utils/logger');
+    logger.debug(`Inicializando Kinesis Analytics Service na porta ${this.port}...`);
+
+    this.simulator = new KinesisAnalyticsSimulator(this.config);
+    await this.simulator.initialize();
+
+    this.server = new KinesisAnalyticsServer(this.port, this.config);
+    this.server.simulator = this.simulator;
+
+    await this.server.initialize();
+
+    logger.debug('Kinesis Analytics Service inicializado');
+  }
+
+  injectDependencies(server) {
+    // Aqui você pode injetar dependências de outros serviços se necessário
+  }
+
+  async start() {
+    const logger = require('../../utils/logger');
+
+    if (this.isRunning) {
+      logger.warn('Kinesis Analytics Service já está em execução');
+      return;
+    }
+
+    try {
+      await this.server.start();
+      this.isRunning = true;
+      logger.info('Kinesis Analytics Service iniciado com sucesso');
+    } catch (error) {
+      logger.error(`Erro ao iniciar Kinesis Analytics Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async stop() {
+    const logger = require('../../utils/logger');
+
+    if (!this.isRunning) {
+      logger.warn('Kinesis Analytics Service não está em execução');
+      return;
+    }
+
+    try {
+      await this.server.stop();
+      this.isRunning = false;
+      logger.info('Kinesis Analytics Service parado com sucesso');
+    } catch (error) {
+      logger.error(`Erro ao parar Kinesis Analytics Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async reset() {
+    const logger = require('../../utils/logger');
+    try {
+      await this.simulator.reset();
+      logger.info('Kinesis Analytics Service resetado');
+    } catch (error) {
+      logger.error(`Erro ao resetar Kinesis Analytics Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  getSimulator() {
+    return this.simulator;
+  }
+
+  getStatus() {
+    const stats = this.simulator?.getStats() || { applicationsCount: 0, totalInputs: 0, totalOutputs: 0 };
+
+    return {
+      name: this.name,
+      running: this.isRunning,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`,
+      resources: {
+        applicationsCount: stats.applicationsCount,
+        totalInputs: stats.totalInputs,
+        totalOutputs: stats.totalOutputs
+      }
+    };
+  }
+}
+
+module.exports = KinesisAnalyticsService;

package/src/services/kinesis-analytics/models/application.js

@@ -0,0 +1,325 @@
+/**
+ * Kinesis Data Analytics - Application Model
+ * Representa uma aplicação de analytics
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+class Application {
+  constructor(applicationName, config = {}) {
+    this.applicationName = applicationName;
+    this.applicationArn = `arn:aws:kinesisanalytics:us-east-1:123456789012:application/${applicationName}`;
+    this.applicationStatus = 'READY';
+    this.applicationVersionId = 1;
+    this.creationTimestamp = new Date().toISOString();
+
+    // Runtime Environment (SQL ou JAVA_FLINK)
+    this.runtimeEnvironment = config.runtimeEnvironment || 'SQL_1_0';
+    this.serviceExecutionRole = config.serviceExecutionRole || 'arn:aws:iam::123456789012:role/kinesis-analytics-role';
+
+    // Application description
+    this.applicationDescription = config.applicationDescription || '';
+    this.lastUpdateTimestamp = new Date().toISOString();
+
+    // Inputs - input streams
+    this.inputs = new Map();
+    this.inputCount = 0;
+
+    // Outputs - saídas da query
+    this.outputs = new Map();
+    this.outputCount = 0;
+
+    // Reference Data Sources
+    this.referenceDataSources = new Map();
+
+    // SQL Code
+    this.sqlCode = '';
+
+    // Application Configuration
+    this.applicationConfiguration = {
+      sqlApplicationConfiguration: {
+        inputs: [],
+        outputs: [],
+        referenceDataSources: []
+      },
+      environmentProperties: {
+        propertyGroups: []
+      }
+    };
+
+    // Metrics
+    this.inputRecordsCount = 0;
+    this.processedRecordsCount = 0;
+    this.outputRecordsCount = 0;
+    this.processedBytes = 0;
+    this.errors = [];
+
+    // Tags
+    this.tags = config.tags || {};
+  }
+
+  /**
+   * Adiciona input (input stream)
+   */
+  addInput(inputName, config = {}) {
+    const input = new Input(inputName, config);
+    this.inputs.set(inputName, input);
+    this.inputCount++;
+    this.lastUpdateTimestamp = new Date().toISOString();
+    return input;
+  }
+
+  /**
+   * Obtém input
+   */
+  getInput(inputName) {
+    return this.inputs.get(inputName);
+  }
+
+  /**
+   * Remove input
+   */
+  removeInput(inputName) {
+    if (this.inputs.delete(inputName)) {
+      this.inputCount--;
+      this.lastUpdateTimestamp = new Date().toISOString();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Adiciona output
+   */
+  addOutput(outputName, config = {}) {
+    const output = new Output(outputName, config);
+    this.outputs.set(outputName, output);
+    this.outputCount++;
+    this.lastUpdateTimestamp = new Date().toISOString();
+    return output;
+  }
+
+  /**
+   * Obtém output
+   */
+  getOutput(outputName) {
+    return this.outputs.get(outputName);
+  }
+
+  /**
+   * Remove output
+   */
+  removeOutput(outputName) {
+    if (this.outputs.delete(outputName)) {
+      this.outputCount--;
+      this.lastUpdateTimestamp = new Date().toISOString();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Define SQL code
+   */
+  setSqlCode(sqlCode) {
+    this.sqlCode = sqlCode;
+    this.lastUpdateTimestamp = new Date().toISOString();
+  }
+
+  /**
+   * Obtém SQL code
+   */
+  getSqlCode() {
+    return this.sqlCode;
+  }
+
+  /**
+   * Registra um record de input
+   */
+  recordInputData(inputName, recordData) {
+    const input = this.inputs.get(inputName);
+    if (input) {
+      input.recordCount++;
+      input.recordsTimestamp.push(Date.now());
+      this.inputRecordsCount++;
+      this.lastUpdateTimestamp = new Date().toISOString();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Registra um record de output
+   */
+  recordOutputData(outputName, recordData) {
+    const output = this.outputs.get(outputName);
+    if (output) {
+      output.recordCount++;
+      output.recordsTimestamp.push(Date.now());
+      this.outputRecordsCount++;
+      this.lastUpdateTimestamp = new Date().toISOString();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Retorna descrição da aplicação
+   */
+  describe() {
+    return {
+      ApplicationDetail: {
+        ApplicationName: this.applicationName,
+        ApplicationArn: this.applicationArn,
+        ApplicationStatus: this.applicationStatus,
+        ApplicationVersionId: this.applicationVersionId,
+        CreationTimestamp: this.creationTimestamp,
+        LastUpdateTimestamp: this.lastUpdateTimestamp,
+        ApplicationDescription: this.applicationDescription,
+        RuntimeEnvironment: this.runtimeEnvironment,
+        ServiceExecutionRole: this.serviceExecutionRole,
+        ApplicationConfiguration: this.applicationConfiguration,
+        CloudWatchLoggingOptionDescriptions: []
+      }
+    };
+  }
+
+  toJSON() {
+    return {
+      applicationName: this.applicationName,
+      applicationArn: this.applicationArn,
+      applicationStatus: this.applicationStatus,
+      applicationVersionId: this.applicationVersionId,
+      creationTimestamp: this.creationTimestamp,
+      lastUpdateTimestamp: this.lastUpdateTimestamp,
+      inputCount: this.inputCount,
+      outputCount: this.outputCount,
+      inputRecordsCount: this.inputRecordsCount,
+      processedRecordsCount: this.processedRecordsCount,
+      outputRecordsCount: this.outputRecordsCount,
+      runtimeEnvironment: this.runtimeEnvironment
+    };
+  }
+}
+
+/**
+ * Input Model - Entrada de dados (stream)
+ */
+class Input {
+  constructor(inputName, config = {}) {
+    this.inputName = inputName;
+    this.inputId = uuidv4();
+    this.sourceStreamArn = config.sourceStreamArn || null;
+    this.inputStartingPositionConfiguration = config.inputStartingPositionConfiguration || {
+      inputStartingPosition: 'NOW'
+    };
+    this.recordCount = 0;
+    this.recordsTimestamp = [];
+    this.createdAt = new Date().toISOString();
+    this.schema = config.schema || {
+      RecordColumns: [],
+      RecordFormat: {
+        RecordFormatType: 'JSON'
+      }
+    };
+  }
+
+  toJSON() {
+    return {
+      inputName: this.inputName,
+      inputId: this.inputId,
+      sourceStreamArn: this.sourceStreamArn,
+      recordCount: this.recordCount,
+      createdAt: this.createdAt,
+      schema: this.schema
+    };
+  }
+}
+
+/**
+ * Output Model - Saída de dados (destino)
+ */
+class Output {
+  constructor(outputName, config = {}) {
+    this.outputName = outputName;
+    this.outputId = uuidv4();
+    this.destinationSchema = config.destinationSchema || {
+      RecordFormatType: 'JSON'
+    };
+    this.destination = config.destination || {
+      DestinationType: 'KINESIS_STREAMS',
+      KinesisStreamsOutput: {
+        ResourceArn: config.resourceArn || null,
+        RoleArn: config.roleArn || null
+      }
+    };
+    this.recordCount = 0;
+    this.recordsTimestamp = [];
+    this.createdAt = new Date().toISOString();
+  }
+
+  toJSON() {
+    return {
+      outputName: this.outputName,
+      outputId: this.outputId,
+      destination: this.destination,
+      recordCount: this.recordCount,
+      createdAt: this.createdAt
+    };
+  }
+}
+
+/**
+ * Query Model - Consulta SQL
+ */
+class Query {
+  constructor(queryName, config = {}) {
+    this.queryName = queryName;
+    this.queryId = uuidv4();
+    this.sqlQuery = config.sqlQuery || '';
+    this.status = 'READY';
+    this.createdAt = new Date().toISOString();
+    this.lastModifiedAt = new Date().toISOString();
+    this.executedCount = 0;
+    this.results = [];
+  }
+
+  /**
+   * Executa query e retorna resultados
+   */
+  execute(data) {
+    this.executedCount++;
+    this.lastModifiedAt = new Date().toISOString();
+
+    // Simulação básica de query execution
+    const result = {
+      queryId: this.queryId,
+      executedAt: new Date().toISOString(),
+      rowsProcessed: Array.isArray(data) ? data.length : 1,
+      status: 'SUCCEEDED',
+      data: data
+    };
+
+    this.results.push(result);
+    return result;
+  }
+
+  toJSON() {
+    return {
+      queryName: this.queryName,
+      queryId: this.queryId,
+      sqlQuery: this.sqlQuery,
+      status: this.status,
+      createdAt: this.createdAt,
+      lastModifiedAt: this.lastModifiedAt,
+      executedCount: this.executedCount
+    };
+  }
+}
+
+module.exports = {
+  Application,
+  Input,
+  Output,
+  Query
+};

package/src/services/kinesis-analytics/models/index.js

@@ -0,0 +1,12 @@
+/**
+ * Kinesis Data Analytics Models
+ */
+
+const { Application, Input, Output, Query } = require('./application');
+
+module.exports = {
+  Application,
+  Input,
+  Output,
+  Query
+};