@gugananuvem/aws-local-simulator 1.0.22 → 1.0.26

package/src/services/cognito/simulator.js

@@ -87,10 +87,35 @@ class CognitoSimulator {
     this.loadIdentityPools();
     this.loadUsers();
     this.loadSessions();
+    this._watchUsersFile();
 
     logger.debug(`✅ Cognito Simulator inicializado com ${this.userPools.size} user pools, ${this.identityPools.size} identity pools, ${this.users.size} usuários`);
   }
 
+  _watchUsersFile() {
+    const fs = require("fs");
+    const usersFilePath = this.store.getFilePath("__users__");
+    if (!fs.existsSync(usersFilePath)) return;
+
+    let reloadTimeout = null;
+    fs.watch(usersFilePath, (eventType) => {
+      if (eventType !== "change") return;
+      // Debounce para evitar múltiplos reloads em edições rápidas
+      clearTimeout(reloadTimeout);
+      reloadTimeout = setTimeout(() => {
+        try {
+          this.users.clear();
+          this.loadUsers();
+          logger.info(`🔄 Cognito users recarregados do disco (${this.users.size} usuários)`);
+        } catch (err) {
+          logger.warn(`⚠️ Erro ao recarregar users: ${err.message}`);
+        }
+      }, 200);
+    });
+
+    logger.debug(`👁️ Watching: ${usersFilePath}`);
+  }
+
   // ============ User Pool Operations ============
 
   createUserPool(params) {
@@ -102,8 +127,8 @@ class CognitoSimulator {
       Name: PoolName,
       Arn: `arn:aws:cognito:local:000000000000:userpool/${poolId}`,
       Status: "ACTIVE",
-      CreationDate: new Date().toISOString(),
-      LastModifiedDate: new Date().toISOString(),
+      CreationDate: Math.floor(Date.now() / 1000),
+      LastModifiedDate: Math.floor(Date.now() / 1000),
       Policies: Policies || {
         PasswordPolicy: {
           MinimumLength: 8,
@@ -146,6 +171,22 @@ class CognitoSimulator {
     };
   }
 
+  updateUserPool(params) {
+    const { UserPoolId, LambdaConfig, MfaConfiguration, AutoVerifiedAttributes, Policies } = params;
+    const userPool = this.userPools.get(UserPoolId);
+    if (!userPool) throw new Error(`User pool ${UserPoolId} not found`);
+
+    if (LambdaConfig !== undefined) userPool.LambdaConfig = LambdaConfig;
+    if (MfaConfiguration !== undefined) userPool.MfaConfiguration = MfaConfiguration;
+    if (AutoVerifiedAttributes !== undefined) userPool.AutoVerifiedAttributes = AutoVerifiedAttributes;
+    if (Policies !== undefined) userPool.Policies = Policies;
+    userPool.LastModifiedDate = Math.floor(Date.now() / 1000);
+
+    this.persistUserPools();
+    logger.debug(`✅ User Pool atualizado: ${UserPoolId}`);
+    return {};
+  }
+
   listUserPools(params = {}) {
     const { MaxResults = 60, NextToken } = params;
     let userPools = Array.from(this.userPools.values());
@@ -361,7 +402,7 @@ class CognitoSimulator {
       // 2. Aplica nova senha e confirma usuário
       user.Password = this.hashPassword(newPassword);
       user.UserStatus = "CONFIRMED";
-      user.LastModifiedDate = new Date().toISOString();
+      user.LastModifiedDate = Math.floor(Date.now() / 1000);
       this.persistUsers();
       this.customAuthSessions.delete(params.Session);
 
@@ -399,8 +440,8 @@ class CognitoSimulator {
         AccessToken: accessToken,
         IdToken: idToken,
         RefreshToken: refreshToken,
-        CreatedAt: new Date().toISOString(),
-        ExpiresAt: new Date(Date.now() + 3600000).toISOString(),
+        CreatedAt: Math.floor(Date.now() / 1000),
+        ExpiresAt: Math.floor((Date.now() + 3600000) / 1000),
       };
       this.sessions.set(sessionId, authSession);
       this.accessTokens.set(accessToken, authSession);
@@ -482,8 +523,8 @@ class CognitoSimulator {
           AccessToken: accessToken,
           IdToken: idToken,
           RefreshToken: refreshToken,
-          CreatedAt: new Date().toISOString(),
-          ExpiresAt: new Date(Date.now() + 3600000).toISOString(),
+          CreatedAt: Math.floor(Date.now() / 1000),
+          ExpiresAt: Math.floor((Date.now() + 3600000) / 1000),
         };
 
         this.sessions.set(sessionId, authSession);
@@ -684,8 +725,8 @@ class CognitoSimulator {
       AllowedOAuthScopes: AllowedOAuthScopes || ["openid", "email", "profile"],
       CallbackURLs: CallbackURLs || [],
       LogoutURLs: LogoutURLs || [],
-      CreatedDate: new Date().toISOString(),
-      LastModifiedDate: new Date().toISOString(),
+      CreatedDate: Math.floor(Date.now() / 1000),
+      LastModifiedDate: Math.floor(Date.now() / 1000),
     };
 
     userPool.Clients.set(clientId, client);
@@ -739,8 +780,8 @@ class CognitoSimulator {
       Attributes: this.normalizeUserAttributes(UserAttributes || []),
       Enabled: true,
       UserStatus: "UNCONFIRMED",
-      CreatedDate: new Date().toISOString(),
-      LastModifiedDate: new Date().toISOString(),
+      CreatedDate: Math.floor(Date.now() / 1000),
+      LastModifiedDate: Math.floor(Date.now() / 1000),
       Password: this.hashPassword(Password),
       ConfirmationCode: confirmationCode,
       MfaOptions: [],
@@ -1460,7 +1501,16 @@ class CognitoSimulator {
     const saved = this.store.read("__userpools__");
     if (saved) {
       for (const [id, data] of Object.entries(saved)) {
+        // Sanitize dates
+        if (typeof data.CreationDate === 'string') data.CreationDate = Math.floor(new Date(data.CreationDate).getTime() / 1000);
+        if (typeof data.LastModifiedDate === 'string') data.LastModifiedDate = Math.floor(new Date(data.LastModifiedDate).getTime() / 1000);
+        
         data.Clients = new Map(Object.entries(data.Clients || {}));
+        for (const client of data.Clients.values()) {
+          if (typeof client.CreatedDate === 'string') client.CreatedDate = Math.floor(new Date(client.CreatedDate).getTime() / 1000);
+          if (typeof client.LastModifiedDate === 'string') client.LastModifiedDate = Math.floor(new Date(client.LastModifiedDate).getTime() / 1000);
+        }
+        
         data.Groups = new Map(Object.entries(data.Groups || {}));
         data.IdentityProviders = new Map(Object.entries(data.IdentityProviders || {}));
         data.ResourceServers = new Map(Object.entries(data.ResourceServers || {}));
@@ -1569,6 +1619,8 @@ class CognitoSimulator {
     const saved = this.store.read("__users__");
     if (saved) {
       for (const [id, user] of Object.entries(saved)) {
+        if (typeof user.CreatedDate === 'string') user.CreatedDate = Math.floor(new Date(user.CreatedDate).getTime() / 1000);
+        if (typeof user.LastModifiedDate === 'string') user.LastModifiedDate = Math.floor(new Date(user.LastModifiedDate).getTime() / 1000);
         this.users.set(id, user);
       }
     }

package/src/services/dynamodb/simulator.js

@@ -25,9 +25,38 @@ class DynamoDBSimulator {
   async initialize() {
     logger.debug("Inicializando DynamoDB Simulator...");
     this.loadTables();
+    this._watchTablesFile();
     logger.debug(`✅ DynamoDB Simulator inicializado com ${this.tables.size} tabelas`);
   }
 
+  _watchTablesFile() {
+    const fs = require("fs");
+    const tablesFilePath = this.store.getFilePath("__tables__");
+    if (!fs.existsSync(tablesFilePath)) return;
+
+    let reloadTimeout = null;
+    fs.watch(tablesFilePath, (eventType) => {
+      if (eventType !== "change") return;
+      clearTimeout(reloadTimeout);
+      reloadTimeout = setTimeout(() => {
+        try {
+          this.tables.clear();
+          const savedTables = this.store.read("__tables__");
+          if (savedTables) {
+            for (const [name, definition] of Object.entries(savedTables)) {
+              this.tables.set(name, definition);
+            }
+          }
+          logger.info(`🔄 DynamoDB schema recarregado (${this.tables.size} tabelas)`);
+        } catch (err) {
+          logger.warn(`⚠️ Erro ao recarregar schema: ${err.message}`);
+        }
+      }, 200);
+    });
+
+    logger.debug(`👁️ Watching: ${tablesFilePath}`);
+  }
+
   loadTables() {
     // Carrega tabelas existentes do disco PRIMEIRO para evitar sobrescrever definições persistidas
     const savedTables = this.store.read("__tables__");
@@ -196,6 +225,19 @@ class DynamoDBSimulator {
         })),
         ItemCount: items.length,
         TableSizeBytes: JSON.stringify(items).length,
+        GlobalSecondaryIndexes: Object.entries(table.globalSecondaryIndexes || {}).map(([indexName, gsi]) => ({
+          IndexName: indexName,
+          IndexStatus: "ACTIVE",
+          KeySchema: [
+            { AttributeName: gsi.hashKey, KeyType: "HASH" },
+            ...(gsi.rangeKey ? [{ AttributeName: gsi.rangeKey, KeyType: "RANGE" }] : []),
+          ],
+          Projection: { ProjectionType: "ALL" },
+          ProvisionedThroughput: {
+            ReadCapacityUnits: 5,
+            WriteCapacityUnits: 5,
+          },
+        })),
         ProvisionedThroughput: {
           ReadCapacityUnits: 5,
           WriteCapacityUnits: 5,
@@ -350,8 +392,12 @@ class DynamoDBSimulator {
         response.Attributes = this.marshallItem(oldItem, table);
         break;
       case "ALL_NEW":
+      case "UPDATED_NEW":
         response.Attributes = this.marshallItem(updatedItem, table);
         break;
+      case "UPDATED_OLD":
+        response.Attributes = this.marshallItem(oldItem, table);
+        break;
       default:
         break;
     }
@@ -469,7 +515,7 @@ class DynamoDBSimulator {
   }
 
   query(params) {
-    const { TableName, KeyConditionExpression, ExpressionAttributeValues, IndexName } = params;
+    const { TableName, KeyConditionExpression, ExpressionAttributeValues, ExpressionAttributeNames = {}, IndexName } = params;
     const table = this.tables.get(TableName);
 
     if (!table) {
@@ -478,7 +524,7 @@ class DynamoDBSimulator {
 
     let items = this.store.read(TableName);
 
-    // Resolve hash key e range key: usa GSI se IndexName estiver presente, caso contrário usa a tabela principal
+    // Resolve hash key e range key
     let hashKey;
     let rangeKey;
 
@@ -495,43 +541,56 @@ class DynamoDBSimulator {
       rangeKey = table.rangeKey;
     }
 
-    // Filtra pela chave de partição
-    const hashValueMatch = KeyConditionExpression.match(new RegExp(`${hashKey}\\s*=\\s*([^\\s]+)`));
-
-    if (hashValueMatch) {
-      const hashValuePlaceholder = hashValueMatch[1];
-      const rawHashValue = ExpressionAttributeValues[hashValuePlaceholder];
-      const hashValue = rawHashValue && typeof rawHashValue === 'object' ? Object.values(rawHashValue)[0] : rawHashValue;
-      items = items.filter((item) => item[hashKey] === hashValue);
-    }
-
-    // Filtra pela chave de ordenação se existir
-    if (rangeKey) {
-      const rangeConditionMatch = KeyConditionExpression.match(new RegExp(`${rangeKey}\\s*(=|>|<|>=|<=)\\s*([^\\s]+)`));
+    // Helper para resolver nomes de atributos (que podem ser placeholders como #n0)
+    const resolveAttributeName = (name) => {
+      if (name.startsWith("#")) return ExpressionAttributeNames[name] || name;
+      return name;
+    };
 
-      if (rangeConditionMatch) {
-        const operator = rangeConditionMatch[1];
-        const rangeValuePlaceholder = rangeConditionMatch[2];
-        const rawRangeValue = ExpressionAttributeValues[rangeValuePlaceholder];
-        const rangeValue = rawRangeValue && typeof rawRangeValue === 'object' ? Object.values(rawRangeValue)[0] : rawRangeValue;
+    // Helper para extrair valor de placeholder (ex: :v0)
+    const resolveValue = (placeholder) => {
+      const rawValue = ExpressionAttributeValues[placeholder];
+      if (rawValue === undefined) return undefined;
+      // Se for formato DynamoDB { S: "..." }, desmembra. Se for nativo (DocumentClient), usa direto.
+      if (rawValue !== null && typeof rawValue === 'object' && !Array.isArray(rawValue)) {
+        const keys = Object.keys(rawValue);
+        if (keys.length === 1 && ["S", "N", "BOOL", "NULL", "M", "L", "SS", "NS", "BS"].includes(keys[0])) {
+          return this.normalizeValue(rawValue, table);
+        }
+      }
+      return rawValue;
+    };
 
-        items = items.filter((item) => {
-          const itemValue = item[rangeKey];
-          switch (operator) {
-            case "=":
-              return itemValue === rangeValue;
-            case ">":
-              return itemValue > rangeValue;
-            case "<":
-              return itemValue < rangeValue;
-            case ">=":
-              return itemValue >= rangeValue;
-            case "<=":
-              return itemValue <= rangeValue;
-            default:
-              return true;
+    // Filtra pela KeyConditionExpression
+    // DynamoDB Query KeyConditionExpression tem formato restrito: PartitionKey = :val AND (SortKey operator :val)
+    if (KeyConditionExpression) {
+      const parts = KeyConditionExpression.split(/\s+AND\s+/i);
+      
+      for (const part of parts) {
+        const match = part.match(/([^\s]+)\s*(=|>|<|>=|<=|BEGINS_WITH|BETWEEN)\s*([^\s]+)(?:\s+AND\s+([^\s]+))?/i);
+        if (match) {
+          const attrPlaceholder = match[1];
+          const operator = match[2].toUpperCase();
+          const valPlaceholder = match[3];
+          
+          const attributeName = resolveAttributeName(attrPlaceholder);
+          const expectedValue = resolveValue(valPlaceholder);
+
+          if (operator === "=") {
+            items = items.filter(item => item[attributeName] === expectedValue);
+          } else if (operator === ">") {
+            items = items.filter(item => item[attributeName] > expectedValue);
+          } else if (operator === "<") {
+            items = items.filter(item => item[attributeName] < expectedValue);
+          } else if (operator === ">=") {
+            items = items.filter(item => item[attributeName] >= expectedValue);
+          } else if (operator === "<=") {
+            items = items.filter(item => item[attributeName] <= expectedValue);
+          } else if (operator === "BEGINS_WITH") {
+            const val = expectedValue;
+            items = items.filter(item => String(item[attributeName] || "").startsWith(String(val)));
           }
-        });
+        }
       }
     }
 
@@ -545,7 +604,7 @@ class DynamoDBSimulator {
   }
 
   scan(params) {
-    const { TableName, FilterExpression, ExpressionAttributeValues, Limit } = params;
+    const { TableName, FilterExpression, ExpressionAttributeValues, ExpressionAttributeNames = {}, Limit } = params;
     const table = this.tables.get(TableName);
 
     if (!table) {
@@ -556,7 +615,7 @@ class DynamoDBSimulator {
 
     // Aplica filtro se existir
     if (FilterExpression) {
-      items = this.applyFilter(items, FilterExpression, ExpressionAttributeValues, table);
+      items = this.applyFilter(items, FilterExpression, ExpressionAttributeValues, ExpressionAttributeNames, table);
     }
 
     // Aplica limite
@@ -573,6 +632,7 @@ class DynamoDBSimulator {
     };
   }
 
+
   // Métodos auxiliares
   normalizeItem(item, table) {
     const normalized = { ...item };
@@ -687,21 +747,71 @@ class DynamoDBSimulator {
     }
   }
 
-  applyFilter(items, expression, values, table) {
-    // Implementação simplificada
-    return items.filter((item) => {
-      const match = expression.match(/([^\s]+)\s*=\s*([^\s]+)/);
-      if (match) {
-        const [, attribute, placeholder] = match;
-        const rawValue = values[placeholder];
-        const expectedValue = rawValue && typeof rawValue === 'object' ? Object.values(rawValue)[0] : rawValue;
-        const actualValue = item[attribute];
-        return actualValue === expectedValue;
+  applyFilter(items, expression, values, names, table) {
+    if (!expression) return items;
+
+    const resolveAttributeName = (name) => {
+      if (name.startsWith("#")) return names[name] || name;
+      return name;
+    };
+
+    const resolveValue = (placeholder) => {
+      const rawValue = values[placeholder];
+      if (rawValue === undefined) return undefined;
+      if (rawValue !== null && typeof rawValue === 'object' && !Array.isArray(rawValue)) {
+        const keys = Object.keys(rawValue);
+        if (keys.length === 1 && ["S", "N", "BOOL", "NULL", "M", "L", "SS", "NS", "BS"].includes(keys[0])) {
+          return this.normalizeValue(rawValue, table);
+        }
       }
-      return true;
+      return rawValue;
+    };
+
+    const conditions = expression.split(/\s+AND\s+/i);
+    
+    return items.filter((item) => {
+      return conditions.every(cond => {
+        // Regex para match de funções como contains(#n, :v) ou begins_with(#n, :v)
+        const funcMatch = cond.match(/(contains|begins_with)\s*\(\s*([^\s,]+)\s*,\s*([^\s,)]+)\s*\)/i);
+        if (funcMatch) {
+          const func = funcMatch[1].toLowerCase();
+          const attrName = resolveAttributeName(funcMatch[2]);
+          const expectedVal = resolveValue(funcMatch[3]);
+          const actualVal = item[attrName];
+          
+          if (func === 'contains') {
+            if (Array.isArray(actualVal)) return actualVal.includes(expectedVal);
+            return String(actualVal || "").includes(String(expectedVal));
+          }
+          if (func === 'begins_with') {
+            return String(actualVal || "").startsWith(String(expectedVal));
+          }
+        }
+
+        // Regex para operadores básicos
+        const opMatch = cond.match(/([^\s]+)\s*(=|<>|<|<=|>|>=)\s*([^\s]+)/);
+        if (opMatch) {
+          const attrName = resolveAttributeName(opMatch[1]);
+          const operator = opMatch[2];
+          const expectedVal = resolveValue(opMatch[3]);
+          const actualVal = item[attrName];
+
+          switch (operator) {
+            case "=":  return actualVal === expectedVal;
+            case "<>": return actualVal !== expectedVal;
+            case "<":  return actualVal < expectedVal;
+            case "<=": return actualVal <= expectedVal;
+            case ">":  return actualVal > expectedVal;
+            case ">=": return actualVal >= expectedVal;
+            default:   return true;
+          }
+        }
+        return true;
+      });
     });
   }
 
+
   persistTables() {
     const tablesObj = {};
     for (const [name, table] of this.tables.entries()) {

package/src/services/kms/server.js

@@ -45,7 +45,21 @@ class KMSServer {
 
   _setupRoutes() {
     this.app.get('/__admin/health', (req, res) => res.json({ status: 'healthy', service: 'kms', timestamp: new Date().toISOString() }));
-    this.app.get('/__admin/keys', async (req, res) => { const r = await this.simulator.listKeys({}); res.json(r); });
+    this.app.get('/__admin/keys', async (req, res) => {
+      const keys = this.simulator.listKeysFull();
+      res.json(keys);
+    });
+
+    this.app.post('/__admin/keys', async (req, res) => {
+      try {
+        const result = await this.simulator.createKey(req.body);
+        res.status(201).json(result);
+      } catch (err) {
+        res.status(400).json({ __type: err.code || 'KMSInternalException', message: err.message });
+      }
+    });
+
+
 
     this.app.post('/', async (req, res) => {
       const target = req.headers['x-amz-target'];

package/src/services/kms/simulator.js

@@ -65,44 +65,56 @@ class KMSSimulator {
   }
 
   async createKey(params) {
-    const { Description, KeyUsage = 'ENCRYPT_DECRYPT', KeySpec = 'SYMMETRIC_DEFAULT', Tags = [], MultiRegion = false } = params || {};
+    const Description = params.Description || params.description || '';
+    const KeyUsage = params.KeyUsage || params.keyUsage || 'ENCRYPT_DECRYPT';
+    const KeySpec = params.KeySpec || params.keySpec || 'SYMMETRIC_DEFAULT';
+    const Tags = params.Tags || params.tags || [];
+    const MultiRegion = params.MultiRegion || params.multiRegion || false;
+
     const keyId = uuidv4();
     const keyArn = `arn:aws:kms:local:000000000000:key/${keyId}`;
     let keyMaterial;
     let publicKey = null;
     let privateKey = null;
 
-    if (KeySpec === 'SYMMETRIC_DEFAULT') {
-      keyMaterial = crypto.randomBytes(32);
-    } else if (KeySpec.startsWith('RSA_')) {
-      const bits = KeySpec === 'RSA_2048' ? 2048 : KeySpec === 'RSA_3072' ? 3072 : 4096;
-      const pair = crypto.generateKeyPairSync('rsa', {
-        modulusLength: bits,
-        publicKeyEncoding: { type: 'spki', format: 'pem' },
-        privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
-      });
-      publicKey = pair.publicKey;
-      privateKey = pair.privateKey;
-      keyMaterial = Buffer.from(privateKey);
-    } else if (KeySpec.startsWith('ECC_')) {
-      const curve = KeySpec.includes('P256') ? 'prime256v1' : KeySpec.includes('P384') ? 'secp384r1' : 'secp521r1';
-      const pair = crypto.generateKeyPairSync('ec', {
-        namedCurve: curve,
-        publicKeyEncoding: { type: 'spki', format: 'pem' },
-        privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
-      });
-      publicKey = pair.publicKey;
-      privateKey = pair.privateKey;
-      keyMaterial = Buffer.from(privateKey);
-    } else {
-      keyMaterial = crypto.randomBytes(32);
+    this.logger.debug(`KMS: Criando chave ${keyId} (Spec: ${KeySpec})`, 'kms');
+
+    try {
+      if (KeySpec === 'SYMMETRIC_DEFAULT') {
+        keyMaterial = crypto.randomBytes(32);
+      } else if (KeySpec.startsWith('RSA_')) {
+        const bits = KeySpec === 'RSA_2048' ? 2048 : KeySpec === 'RSA_3072' ? 3072 : 4096;
+        const pair = crypto.generateKeyPairSync('rsa', {
+          modulusLength: bits,
+          publicKeyEncoding: { type: 'spki', format: 'pem' },
+          privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
+        });
+        publicKey = pair.publicKey;
+        privateKey = pair.privateKey;
+        keyMaterial = Buffer.from(privateKey);
+      } else if (KeySpec.startsWith('ECC_')) {
+        const curve = KeySpec.includes('P256') ? 'prime256v1' : KeySpec.includes('P384') ? 'secp384r1' : 'secp521r1';
+        const pair = crypto.generateKeyPairSync('ec', {
+          namedCurve: curve,
+          publicKeyEncoding: { type: 'spki', format: 'pem' },
+          privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
+        });
+        publicKey = pair.publicKey;
+        privateKey = pair.privateKey;
+        keyMaterial = Buffer.from(privateKey);
+      } else {
+        keyMaterial = crypto.randomBytes(32);
+      }
+    } catch (err) {
+      this.logger.error(`KMS: Erro ao gerar material da chave: ${err.message}`, 'kms');
+      throw err;
     }
 
     this.keyMaterial.set(keyId, keyMaterial);
     const key = {
       KeyId: keyId,
       KeyArn: keyArn,
-      Description: Description || '',
+      Description,
       KeyUsage,
       KeySpec,
       KeyState: 'Enabled',
@@ -115,22 +127,30 @@ class KMSSimulator {
     };
     this.keys.set(keyId, key);
     await this._persistKeys();
-    this.logger.info(`KMS: chave criada: ${keyId}`, 'kms');
+    this.logger.info(`KMS: chave criada com sucesso: ${keyId}`, 'kms');
     this.audit.record({ eventName: 'CreateKey', readOnly: false, resources: [{ ARN: keyArn, type: 'AWS::KMS::Key' }], requestParameters: { description: Description, keyUsage: KeyUsage, keySpec: KeySpec } });
     return { KeyMetadata: this._sanitizeKey(key) };
   }
 
   async describeKey(params) {
-    const key = this._requireKey(params.KeyId);
+    const keyId = params.KeyId || params.keyId;
+    const key = this._requireKey(keyId);
     return { KeyMetadata: this._sanitizeKey(key) };
   }
 
   async listKeys(params) {
     const { Limit = 100 } = params || {};
     const keys = Array.from(this.keys.values()).slice(0, Limit);
+    // Para o Dashboard, retornamos mais detalhes se for solicitado via admin
+    // Mas para o SDK padrão, retornamos apenas o que o SDK espera
     return { Keys: keys.map(k => ({ KeyId: k.KeyId, KeyArn: k.KeyArn })) };
   }
 
+  listKeysFull() {
+    return Array.from(this.keys.values()).map(k => this._sanitizeKey(k));
+  }
+
+
   async enableKey(params) {
     const key = this._requireKey(params.KeyId);
     key.KeyState = 'Enabled'; key.Enabled = true;

package/src/services/lambda/server.js

@@ -80,6 +80,30 @@ class LambdaServer {
     this.app.get('/__admin/functions', (req, res) => {
       res.json(this.simulator.listLambdas());
     });
+    
+    this.app.post('/__admin/functions', async (req, res) => {
+      try {
+        const lambda = await this.simulator.createFunction(req.body);
+        res.status(201).json(lambda);
+      } catch (err) {
+        res.status(400).json({ error: err.message });
+      }
+    });
+
+    this.app.put('/__admin/functions/:name', async (req, res) => {
+      try {
+        const lambda = await this.simulator.updateFunction(req.params.name, req.body);
+        res.json(lambda);
+      } catch (err) {
+        res.status(400).json({ error: err.message });
+      }
+    });
+
+    this.app.delete('/__admin/functions/:name', async (req, res) => {
+      const deleted = await this.simulator.deleteFunction(req.params.name);
+      if (deleted) res.json({ message: 'Lambda deleted' });
+      else res.status(404).json({ error: 'Lambda not found' });
+    });
 
     this.app.post('/__admin/reload', async (req, res) => {
       await this.simulator.reloadLambdas();