@gugananuvem/aws-local-simulator 1.0.12 → 1.0.15

package/src/services/athena/index.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const http = require('http');
+const path = require('path');
+const { AthenaSimulator } = require('./simulator');
+const { createAthenaServer } = require('./server');
+const LocalStore = require('../../utils/local-store');
+
+class AthenaService {
+  constructor(config) {
+    this.config = config;
+    this.logger = require('../../utils/logger');
+    this.name = 'athena';
+    this.port = config?.ports?.athena || 4599;
+    this.store = null;
+    this.simulator = null;
+    this._server = null;
+    this.isRunning = false;
+  }
+
+  async initialize() {
+    this.logger.debug(`Inicializando Athena Service na porta ${this.port}...`);
+    const dataDir = process.env.AWS_LOCAL_SIMULATOR_DATA_DIR;
+    this.store = new LocalStore(path.join(dataDir, 'athena'));
+    this.simulator = new AthenaSimulator(this.config, this.store, this.logger);
+    await this.simulator.initialize();
+    this.app = createAthenaServer(this.simulator, this.logger);
+    this.logger.debug('Athena Service inicializado');
+  }
+
+  injectDependencies(server) {
+    const ct = server.getService('cloudtrail');
+    if (ct?.simulator) this.simulator.audit.setTrail(ct.simulator);
+  }
+
+  async start() {
+    if (this.isRunning) return;
+    return new Promise((resolve, reject) => {
+      this._server = http.createServer(this.app);
+      this._server.listen(this.port, () => {
+        this.isRunning = true;
+        this.logger.info(`🔍 Athena rodando em http://localhost:${this.port}`);
+        resolve();
+      });
+      this._server.on('error', reject);
+    });
+  }
+
+  async stop() {
+    if (!this.isRunning || !this._server) return;
+    return new Promise((resolve) => {
+      this._server.close(() => {
+        this.isRunning = false;
+        resolve();
+      });
+    });
+  }
+
+  async reset() {
+    await this.simulator.reset();
+  }
+
+  getStatus() {
+    return {
+      running: this.isRunning,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`,
+      ...this.simulator?.getStats(),
+    };
+  }
+
+  getSimulator() { return this.simulator; }
+}
+
+module.exports = { AthenaService };

package/src/services/athena/server.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const express = require('express');
+const cors = require('cors');
+
+/**
+ * Athena Server - protocolo JSON via x-amz-target
+ */
+function createAthenaServer(simulator, logger) {
+  const app = express();
+
+  app.use(cors());
+  app.use(express.json({ limit: '10mb', type: () => true }));
+
+  app.use((req, _res, next) => {
+    const target = req.headers['x-amz-target'] || '';
+    if (target) logger.debug(`[Athena] ${req.method} ${req.path} target=${target}`);
+    next();
+  });
+
+  // ── Rota principal ───────────────────────────────────────────────
+  app.post('/', async (req, res) => {
+    const target = (req.headers['x-amz-target'] || '').replace('AmazonAthena.', '');
+    const body = req.body || {};
+
+    try {
+      let result;
+
+      switch (target) {
+        case 'StartQueryExecution':
+          result = await simulator.startQueryExecution(body);
+          break;
+        case 'GetQueryExecution':
+          result = simulator.getQueryExecution(body);
+          break;
+        case 'GetQueryResults':
+          result = simulator.getQueryResults(body);
+          break;
+        case 'StopQueryExecution':
+          result = await simulator.stopQueryExecution(body);
+          break;
+        case 'ListQueryExecutions':
+          result = simulator.listQueryExecutions(body);
+          break;
+        case 'CreateNamedQuery':
+          result = await simulator.createNamedQuery(body);
+          break;
+        case 'GetNamedQuery':
+          result = simulator.getNamedQuery(body);
+          break;
+        case 'ListNamedQueries':
+          result = simulator.listNamedQueries(body);
+          break;
+        case 'DeleteNamedQuery':
+          result = await simulator.deleteNamedQuery(body);
+          break;
+        case 'CreateWorkGroup':
+          result = await simulator.createWorkGroup(body);
+          break;
+        case 'GetWorkGroup':
+          result = simulator.getWorkGroup(body);
+          break;
+        case 'ListWorkGroups':
+          result = simulator.listWorkGroups(body);
+          break;
+        case 'DeleteWorkGroup':
+          result = await simulator.deleteWorkGroup(body);
+          break;
+        default:
+          return res.status(400).json({ __type: 'InvalidRequestException', message: `Unknown action: ${target}` });
+      }
+
+      res.json(result || {});
+    } catch (err) {
+      logger.error(`[Athena] Error in ${target}: ${err.message}`);
+      res.status(err.statusCode || 500).json({ __type: err.code || 'InternalServerError', message: err.message });
+    }
+  });
+
+  // ── Admin ────────────────────────────────────────────────────────
+  app.get('/__admin/health', (_req, res) => {
+    res.json({ status: 'healthy', service: 'athena', ...simulator.getStats() });
+  });
+
+  app.get('/__admin/executions', (_req, res) => {
+    res.json({ executions: Array.from(simulator.queryExecutions.values()).map(({ _results, ...e }) => e) });
+  });
+
+  app.get('/__admin/workgroups', (_req, res) => {
+    res.json({ workGroups: Array.from(simulator.workGroups.values()) });
+  });
+
+  app.post('/__admin/reset', async (_req, res) => {
+    await simulator.reset();
+    res.json({ message: 'Athena data reset complete' });
+  });
+
+  return app;
+}
+
+module.exports = { createAthenaServer };