@gugananuvem/aws-local-simulator 1.0.25 → 1.0.26

package/src/services/apigateway/simulator.js

@@ -33,6 +33,7 @@ class APIGatewaySimulator {
   async initialize() {
     logger.debug('Inicializando API Gateway Simulator...');
     this.loadAPIs();
+    this._loadStaticAPIs();
     this.loadWebSocketAPIs();
     this.loadDeployments();
     this.loadStages();
@@ -44,9 +45,62 @@ class APIGatewaySimulator {
     this.loadApiKeys();
     this.loadDomainNames();
     
-    logger.debug(`✅ API Gateway Simulator inicializado com ${this.apis.size} APIs, ${this.resources.size} resources, ${this.methods.size} methods`);
+    logger.debug(`✅ API Gateway Simulator inicializado com ${this.apis.size} APIs (${Array.from(this.apis.values()).filter(a => a.isStatic).length} estáticas)`);
   }
 
+  _loadStaticAPIs() {
+    const staticApis = this.config.apigateway?.apis || [];
+    staticApis.forEach((apiConfig, index) => {
+      const apiId = `static_${index}`;
+      
+      const api = {
+        id: apiId,
+        name: apiConfig.name,
+        description: apiConfig.description || 'Configured in aws-local-simulator.json',
+        version: 'config',
+        createdDate: new Date().toISOString(),
+        isStatic: true,
+        apiKeySource: 'HEADER',
+        endpointConfiguration: { types: ['REGIONAL'] },
+        resources: new Map(),
+        stages: new Map(),
+        deployments: new Map(),
+        models: new Map(),
+        authorizers: new Map()
+      };
+      
+      // Adiciona recursos a partir dos endpoints configurados
+      (apiConfig.endpoints || []).forEach((ep, epIndex) => {
+        const resId = `res_${apiId}_${epIndex}`;
+        api.resources.set(resId, {
+          id: resId,
+          path: ep.path,
+          pathPart: ep.path.split('/').pop() || '/',
+          resourceMethods: new Map([[ep.method, {
+            httpMethod: ep.method,
+            authorizationType: ep.authorizerRequired ? 'COGNITO_USER_POOLS' : 'NONE',
+            apiKeyRequired: false,
+            integration: {
+              type: ep.integrationType === 'lambda' ? 'AWS_PROXY' : 'HTTP',
+              uri: ep.lambdaName,
+              integrationHttpMethod: 'POST'
+            }
+          }]])
+        });
+      });
+      
+      // Adiciona um stage padrão
+      api.stages.set('local', {
+        stageName: 'local',
+        createdDate: new Date().toISOString(),
+        deploymentId: 'static-deploy'
+      });
+      
+      this.apis.set(apiId, api);
+    });
+  }
+
+
   // ============ REST API Operations ============
 
   createRestApi(params) {
@@ -104,11 +158,15 @@ class APIGatewaySimulator {
         description: api.description,
         version: api.version,
         createdDate: api.createdDate,
-        apiKeySource: api.apiKeySource
+        apiKeySource: api.apiKeySource,
+        isStatic: api.isStatic || false,
+        resourceCount: api.resources.size,
+        stageCount: api.stages.size
       }))
     };
   }
 
+
   getRestApi(params) {
     const { restApiId } = params;
     const api = this.apis.get(restApiId);
@@ -129,6 +187,27 @@ class APIGatewaySimulator {
     };
   }
 
+  updateRestApi(params) {
+    const { restApiId, name, description } = params;
+    const api = this.apis.get(restApiId);
+    
+    if (!api) {
+      throw new Error(`API ${restApiId} not found`);
+    }
+    
+    if (name !== undefined) api.name = name;
+    if (description !== undefined) api.description = description;
+    
+    if (api.isStatic) {
+      // Once edited, the API is no longer static and will be persisted
+      api.isStatic = false;
+    }
+    
+    this.persistAPIs();
+    
+    return this.getRestApi({ restApiId });
+  }
+
   deleteRestApi(params) {
     const { restApiId } = params;
     
@@ -142,8 +221,67 @@ class APIGatewaySimulator {
     return {};
   }
 
+  // ============ Simplified Dashboard Endpoint Operations ============
+
+  putEndpoint(params) {
+    const { restApiId, path, method, integrationType, lambdaName, authorizerRequired } = params;
+    const api = this.apis.get(restApiId);
+    if (!api) throw new Error(`API ${restApiId} not found`);
+
+    if (api.isStatic) api.isStatic = false;
+
+    // Ensure resource exists
+    let resource = Array.from(api.resources.values()).find(r => r.path === path);
+    if (!resource) {
+      const resourceId = `res_${Date.now()}`;
+      resource = {
+        id: resourceId,
+        path: path,
+        pathPart: path.split('/').pop() || '/',
+        parentId: null, // Simplified
+        resourceMethods: new Map()
+      };
+      api.resources.set(resourceId, resource);
+    }
+
+    // Put method
+    resource.resourceMethods.set(method.toUpperCase(), {
+      httpMethod: method.toUpperCase(),
+      authorizationType: authorizerRequired ? 'COGNITO_USER_POOLS' : 'NONE',
+      apiKeyRequired: false,
+      integration: {
+        type: integrationType === 'lambda' ? 'AWS_PROXY' : 'HTTP',
+        uri: lambdaName,
+        integrationHttpMethod: 'POST'
+      }
+    });
+
+    this.persistAPIs();
+    return { resourceId: resource.id, path, method };
+  }
+
+  deleteEndpoint(params) {
+    const { restApiId, path, method } = params;
+    const api = this.apis.get(restApiId);
+    if (!api) throw new Error(`API ${restApiId} not found`);
+
+    if (api.isStatic) api.isStatic = false;
+
+    const resource = Array.from(api.resources.values()).find(r => r.path === path);
+    if (resource) {
+      resource.resourceMethods.delete(method.toUpperCase());
+      // If no methods left and not root, we could delete the resource, but keeping it is fine.
+      if (resource.resourceMethods.size === 0 && resource.path !== '/') {
+        api.resources.delete(resource.id);
+      }
+      this.persistAPIs();
+    }
+    return {};
+  }
+
   // ============ Resource Operations ============
 
+
   createResource(params) {
     const { restApiId, parentId, pathPart } = params;
     const api = this.apis.get(restApiId);
@@ -1054,7 +1192,10 @@ class APIGatewaySimulator {
     if (saved) {
       for (const [id, data] of Object.entries(saved)) {
         // Reconstitui Maps
-        data.resources = new Map(Object.entries(data.resources || {}));
+        data.resources = new Map(Object.entries(data.resources || {}).map(([rid, r]) => {
+          r.resourceMethods = new Map(Object.entries(r.resourceMethods || {}));
+          return [rid, r];
+        }));
         data.stages = new Map(Object.entries(data.stages || {}));
         data.deployments = new Map(Object.entries(data.deployments || {}));
         data.models = new Map(Object.entries(data.models || {}));
@@ -1064,6 +1205,7 @@ class APIGatewaySimulator {
     }
   }
 
+
   loadWebSocketAPIs() {
     const saved = this.store.read('__websocket_apis__');
     if (saved) {
@@ -1157,9 +1299,10 @@ class APIGatewaySimulator {
   persistAPIs() {
     const apisObj = {};
     for (const [id, api] of this.apis.entries()) {
+      if (api.isStatic) continue;
       apisObj[id] = {
         ...api,
-        resources: Object.fromEntries(api.resources),
+        resources: Object.fromEntries(Array.from(api.resources.entries()).map(([rid, r]) => [rid, { ...r, resourceMethods: Object.fromEntries(r.resourceMethods) }])),
         stages: Object.fromEntries(api.stages),
         deployments: Object.fromEntries(api.deployments),
         models: Object.fromEntries(api.models),
@@ -1169,6 +1312,7 @@ class APIGatewaySimulator {
     this.store.write('__apis__', apisObj);
   }
 
+
   persistResources(apiId) {
     const api = this.apis.get(apiId);
     if (api) {

package/src/services/cognito/server.js

@@ -18,19 +18,10 @@ class CognitoServer {
 
   setupMiddlewares() {
     this.app.use(cors());
-    this.app.use(express.raw({ type: '*/*', limit: '10mb' }));
-    this.app.use((req, res, next) => {
-      if (req.body && Buffer.isBuffer(req.body)) {
-        try {
-          req.body = JSON.parse(req.body.toString('utf8'));
-        } catch (e) {
-          req.body = {};
-        }
-      } else if (!req.body) {
-        req.body = {};
-      }
-      next();
-    });
+    this.app.use(express.json({
+      limit: '10mb',
+      type: ['application/json', 'application/x-amz-json-1.1']
+    }));
     
     if (logger.currentLogLevel === 'verboso') {
       this.app.use((req, res, next) => {
@@ -73,7 +64,8 @@ class CognitoServer {
 
       try {
         const result = await this.handleRequest(target, req.body || {});
-        res.json(result);
+        res.setHeader('Content-Type', 'application/x-amz-json-1.1');
+        res.send(JSON.stringify(result));
       } catch (error) {
         logger.error('Cognito Error:', error.message);
         res.status(400).json({
@@ -108,6 +100,8 @@ class CognitoServer {
         return this.simulator.describeUserPool(params);
       case 'DeleteUserPool':
         return this.simulator.deleteUserPool(params);
+      case 'UpdateUserPool':
+        return this.simulator.updateUserPool(params);
       
       case 'ListUsers':
         return this.simulator.listUsers(params);

package/src/services/cognito/simulator.js

@@ -127,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,
@@ -171,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());
@@ -386,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);
 
@@ -424,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);
@@ -507,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);
@@ -709,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);
@@ -764,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: [],
@@ -1485,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 || {}));
@@ -1594,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

@@ -225,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,
@@ -502,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) {
@@ -511,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;
 
@@ -528,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)));
           }
-        });
+        }
       }
     }
 
@@ -578,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) {
@@ -589,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
@@ -606,6 +632,7 @@ class DynamoDBSimulator {
     };
   }
 
+
   // Métodos auxiliares
   normalizeItem(item, table) {
     const normalized = { ...item };
@@ -720,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'];