Feature/adding query

README.md

@@ -542,6 +542,19 @@ custom:
           attributeType: S
         action: GetItem
         cors: true
+    - dynamodb:
+        path: /dynamodb
+        method: get
+        tableName: { Ref: 'YourTable' }
+        indexName: 'myIndex'
+        hashKey:
+          queryStringParam: id # use query string parameter
+          attributeType: S
+        rangeKey:
+          queryStringParam: sort
+          attributeType: S
+        action: Query
+        cors: true
     - dynamodb:
         path: /dynamodb/{id}
         method: delete
@@ -644,6 +657,35 @@ custom:
                 #set($item = $input.path('$.Item')){ "Item": $item }
 
 ```
+#### Using Query with Index(GSI)
+If you want to use GSI to get some information, you must use the Query action and add the attribute "indexName"
+with the name of the Index that you want to use.
+When you use it, the action on Dynamo will transform in Query action and it will use the HashKey and, if provided, the RangeKey to create the query unsing the equal operator.
+
+You can change the operator for other allowed by AWS, just add the attribute "queryOperator" to the specific
+key (Rash or Hange) information:
+
+```yaml
+  - dynamodb:
+      path: /dynamodb
+      method: query
+      tableName: { Ref: 'YourTable' }
+      indexName: 'myIndex'
+      hashKey:
+        queryStringParam: id # use query string parameter
+        attributeType: S
+        queryOperator: ">"
+      rangeKey:
+        queryStringParam: sort
+        attributeType: S
+        queryOperator: "<"
+      action: Query
+      cors: true
+
+```
+
+If used some reponse template customazitaion, be aware that the response is different from the GetItem
+returning an array containing the atributte Items
 
 ### EventBridge
 

__tests__/integration/dynamodb/multiple-integrations/service/serverless.yml

@@ -37,6 +37,20 @@ custom:
           queryStringParam: sort
           attributeType: S
         cors: true
+    - dynamodb:
+        path: /dynamodb/index/{indexRange}/{indexSort}
+        method: get
+        indexName: myTestIndex
+        tableName:
+          Ref: MyMuTestTable
+        action: Query
+        hashKey:
+          pathParam: indexSort
+          attributeType: S
+        rangeKey:
+          pathParam: indexRange
+          attributeType: S
+        cors: true
     - dynamodb:
         path: /dynamodb/{id}
         method: delete
@@ -62,11 +76,27 @@ resources:
             AttributeType: S
           - AttributeName: sort
             AttributeType: S
+          - AttributeName: indexRange
+            AttributeType: S
+          - AttributeName: indexSort
+            AttributeType: S
         KeySchema:
           - AttributeName: id
             KeyType: HASH
           - AttributeName: sort
             KeyType: RANGE
+        GlobalSecondaryIndexes:
+          - IndexName: myTestIndex
+            KeySchema:
+              - AttributeName: indexSort
+                KeyType: HASH
+              - AttributeName: indexRange
+                KeyType: RANGE
+            Projection:
+              ProjectionType: ALL
+            ProvisionedThroughput:
+              ReadCapacityUnits: 1
+              WriteCapacityUnits: 1
         ProvisionedThroughput:
           ReadCapacityUnits: 1
           WriteCapacityUnits: 1

__tests__/integration/dynamodb/multiple-integrations/tests.js

@@ -89,6 +89,40 @@ describe('Multiple Dynamodb Proxies Integration Test', () => {
     })
   })
 
+  it('should get correct response from dynamodb Query with index', async () => {
+    await putDynamodbItem(
+      tableName,
+      _.merge(
+        {},
+        { [hashKeyAttribute]: hashKey, [rangeKeyAttribute]: sortKey },
+        {
+          message: { S: 'testtest' },
+          indexRange: { S: 'rangeTest' },
+          indexSort: { S: 'sortTest' }
+        }
+      )
+    )
+    const getEndpoint = `${endpoint}/dynamodb/index/rangeTest/sortTest`
+
+    const getResponse = await fetch(getEndpoint, {
+      method: 'GET',
+      headers: { 'Content-Type': 'application/json' }
+    })
+    expect(getResponse.headers.get('access-control-allow-origin')).to.deep.equal('*')
+    expect(getResponse.status).to.be.equal(200)
+
+    const item = await getResponse.json()
+    expect(item).to.be.deep.equal([
+      {
+        id: hashKey.S,
+        sort: sortKey.S,
+        message: 'testtest',
+        indexRange: 'rangeTest',
+        indexSort: 'sortTest'
+      }
+    ])
+  })
+
   it('should get correct response from dynamodb DeleteItem action endpoint', async () => {
     await putDynamodbItem(
       tableName,

lib/apiGateway/schema.js

@@ -148,12 +148,13 @@ const partitionKey = Joi.alternatives().try([
     )
 ])
 
-const allowedDynamodbActions = ['PutItem', 'GetItem', 'DeleteItem']
+const allowedDynamodbActions = ['PutItem', 'GetItem', 'DeleteItem', 'Query']
 const dynamodbDefaultKeyScheme = Joi.object()
   .keys({
     pathParam: Joi.string(),
     queryStringParam: Joi.string(),
-    attributeType: Joi.string().required()
+    attributeType: Joi.string().required(),
+    queryOperator: Joi.string().valid(['=', '<', '<=', '>', '>='])
   })
   .xor('pathParam', 'queryStringParam')
   .error(
@@ -298,6 +299,7 @@ const proxiesSchemas = {
         .required(),
       tableName: stringOrRef.required(),
       condition: Joi.string(),
+      indexName: Joi.string(),
       hashKey: dynamodbDefaultKeyScheme.required(),
       rangeKey: dynamodbDefaultKeyScheme,
       requestParameters,

lib/apiGateway/validate.test.js

@@ -2209,7 +2209,7 @@ describe('#validateServiceProxies()', () => {
       }
 
       expect(() => serverlessApigatewayServiceProxy.validateServiceProxies()).to.throw(
-        'child "action" fails because ["action" must be one of [PutItem, GetItem, DeleteItem]'
+        'child "action" fails because ["action" must be one of [PutItem, GetItem, DeleteItem, Query]'
       )
     })
 
@@ -2271,6 +2271,86 @@ describe('#validateServiceProxies()', () => {
 
       expect(() => serverlessApigatewayServiceProxy.validateServiceProxies()).to.not.throw()
     })
+
+    it('should throw error if the "indexName" parameter is not a string', () => {
+      serverlessApigatewayServiceProxy.serverless.service.custom = {
+        apiGatewayServiceProxies: [
+          {
+            dynamodb: {
+              tableName: 'yourTable',
+              path: 'dynamodb',
+              method: 'put',
+              action: 'PutItem',
+              hashKey: { pathParam: 'id', attributeType: 'S' },
+              indexName: { a: 'b' }
+            }
+          }
+        ]
+      }
+
+      expect(() => serverlessApigatewayServiceProxy.validateServiceProxies()).to.throw(
+        'child "indexName" fails because ["indexName" must be a string]'
+      )
+    })
+
+    it('should not throw error if the "indexName" parameter is a string', () => {
+      serverlessApigatewayServiceProxy.serverless.service.custom = {
+        apiGatewayServiceProxies: [
+          {
+            dynamodb: {
+              tableName: 'yourTable',
+              path: 'dynamodb',
+              method: 'put',
+              action: 'PutItem',
+              hashKey: { pathParam: 'id', attributeType: 'S' },
+              indexName: 'test'
+            }
+          }
+        ]
+      }
+
+      expect(() => serverlessApigatewayServiceProxy.validateServiceProxies()).to.not.throw()
+    })
+
+    it('should not throw error if the "attributeType" parameter is one of the valid ones', () => {
+      serverlessApigatewayServiceProxy.serverless.service.custom = {
+        apiGatewayServiceProxies: [
+          {
+            dynamodb: {
+              tableName: 'yourTable',
+              path: 'dynamodb',
+              method: 'put',
+              action: 'PutItem',
+              hashKey: { pathParam: 'id', attributeType: 'S', queryOperator: '=' },
+              indexName: 'test'
+            }
+          }
+        ]
+      }
+
+      expect(() => serverlessApigatewayServiceProxy.validateServiceProxies()).to.not.throw()
+    })
+
+    it('should throw error if the "attributeType" parameter is not of the valid ones', () => {
+      serverlessApigatewayServiceProxy.serverless.service.custom = {
+        apiGatewayServiceProxies: [
+          {
+            dynamodb: {
+              tableName: 'yourTable',
+              path: 'dynamodb',
+              method: 'put',
+              action: 'PutItem',
+              hashKey: { pathParam: 'id', attributeType: 'S', queryOperator: '?' },
+              indexName: 'test'
+            }
+          }
+        ]
+      }
+
+      expect(() => serverlessApigatewayServiceProxy.validateServiceProxies()).to.throw(
+        'child "dynamodb" fails because [child "hashKey" fails because [child "queryOperator" fails because ["queryOperator" must be one of [=, <, <=, >, >=]]]]'
+      )
+    })
   })
 
   describe('eventbridge', () => {

lib/package/dynamodb/compileIamRoleToDynamodb.js

@@ -21,14 +21,13 @@ module.exports = {
     }
 
     const permissions = tableNameActions.map(({ tableName, action }) => {
+      const baiscArn =
+        'arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}'
       return {
         Effect: 'Allow',
         Action: `dynamodb:${action}`,
         Resource: {
-          'Fn::Sub': [
-            'arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}',
-            { tableName }
-          ]
+          'Fn::Sub': [action === 'Query' ? baiscArn + '/*' : baiscArn, { tableName }]
         }
       }
     })

lib/package/dynamodb/compileIamRoleToDynamodb.test.js

@@ -59,6 +59,17 @@ describe('#compileIamRoleToDynamodb()', () => {
               queryStringParam: 'id'
             }
           }
+        },
+        {
+          dynamodb: {
+            path: '/dynamodb/v1',
+            tableName: 'mytable',
+            method: 'get',
+            action: 'Query',
+            hashKey: {
+              queryStringParam: 'id'
+            }
+          }
         }
       ]
     }
@@ -126,6 +137,18 @@ describe('#compileIamRoleToDynamodb()', () => {
                         }
                       ]
                     }
+                  },
+                  {
+                    Effect: 'Allow',
+                    Action: 'dynamodb:Query',
+                    Resource: {
+                      'Fn::Sub': [
+                        'arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/*',
+                        {
+                          tableName: 'mytable'
+                        }
+                      ]
+                    }
                   }
                 ]
               }