feat: allow private

Author: iteanjd123

lib/apiGateway/schema.js

@@ -23,6 +23,8 @@ const method = Joi.string()
   .valid(['get', 'post', 'put', 'patch', 'options', 'head', 'delete', 'any'])
   .insensitive()
 
+const privateField = Joi.boolean().default(false)
+
 const cors = Joi.alternatives().try(
   Joi.boolean(),
   Joi.object({
@@ -98,6 +100,7 @@ const proxy = Joi.object({
   pathOverride,
   method,
   cors,
+  private: privateField,
   authorizationType,
   authorizerId,
   authorizationScopes,

lib/apiGateway/validate.test.js

@@ -137,6 +137,75 @@ describe('#validateServiceProxies()', () => {
       expect(() => serverlessApigatewayServiceProxy.validateServiceProxies()).to.not.throw()
     })
 
+    it('should work if "private" property is missing', () => {
+      serverlessApigatewayServiceProxy.serverless.service.custom = {
+        apiGatewayServiceProxies: [
+          {
+            kinesis: {
+              path: '/kinesis',
+              streamName: 'streamName',
+              method: 'POST'
+            }
+          }
+        ]
+      }
+
+      expect(() => serverlessApigatewayServiceProxy.validateServiceProxies()).to.not.throw()
+    })
+
+    it('should work if "private" property is true', () => {
+      serverlessApigatewayServiceProxy.serverless.service.custom = {
+        apiGatewayServiceProxies: [
+          {
+            kinesis: {
+              path: '/kinesis',
+              streamName: 'streamName',
+              method: 'POST',
+              private: true
+            }
+          }
+        ]
+      }
+
+      expect(() => serverlessApigatewayServiceProxy.validateServiceProxies()).to.not.throw()
+    })
+
+    it('should work if "private" property is false', () => {
+      serverlessApigatewayServiceProxy.serverless.service.custom = {
+        apiGatewayServiceProxies: [
+          {
+            kinesis: {
+              path: '/kinesis',
+              streamName: 'streamName',
+              method: 'POST',
+              private: false
+            }
+          }
+        ]
+      }
+
+      expect(() => serverlessApigatewayServiceProxy.validateServiceProxies()).to.not.throw()
+    })
+
+    it('should throw if "private" property is set to unsupported type', () => {
+      serverlessApigatewayServiceProxy.serverless.service.custom = {
+        apiGatewayServiceProxies: [
+          {
+            kinesis: {
+              path: '/kinesis',
+              streamName: 'streamName',
+              method: 'POST',
+              private: 'xxxxx'
+            }
+          }
+        ]
+      }
+      expect(() => serverlessApigatewayServiceProxy.validateServiceProxies()).to.throw(
+        serverless.classes.Error,
+        'child "kinesis" fails because [child "private" fails because ["private" must be a boolean]]'
+      )
+    })
+
     it('should process cors defaults', () => {
       serverlessApigatewayServiceProxy.serverless.service.custom = {
         apiGatewayServiceProxies: [

lib/package/sqs/compileMethodsToSqs.test.js

@@ -221,6 +221,105 @@ describe('#compileMethodsToSqs()', () => {
     })
   })
 
+  it('should create corresponding resources when sqs proxies are given with private', () => {
+    serverlessApigatewayServiceProxy.validated = {
+      events: [
+        {
+          serviceName: 'sqs',
+          http: {
+            queueName: 'myQueue',
+            path: 'sqs',
+            method: 'post',
+            auth: {
+              authorizationType: 'NONE'
+            },
+            private: true
+          }
+        }
+      ]
+    }
+    serverlessApigatewayServiceProxy.apiGatewayRestApiLogicalId = 'ApiGatewayRestApi'
+    serverlessApigatewayServiceProxy.apiGatewayResources = {
+      sqs: {
+        name: 'sqs',
+        resourceLogicalId: 'ApiGatewayResourceSqs'
+      }
+    }
+
+    serverlessApigatewayServiceProxy.compileMethodsToSqs()
+
+    expect(serverless.service.provider.compiledCloudFormationTemplate.Resources).to.deep.equal({
+      ApiGatewayMethodsqsPost: {
+        Type: 'AWS::ApiGateway::Method',
+        Properties: {
+          HttpMethod: 'POST',
+          RequestParameters: {},
+          AuthorizationType: 'NONE',
+          AuthorizationScopes: undefined,
+          AuthorizerId: undefined,
+          ApiKeyRequired: true,
+          ResourceId: { Ref: 'ApiGatewayResourceSqs' },
+          RestApiId: { Ref: 'ApiGatewayRestApi' },
+          Integration: {
+            IntegrationHttpMethod: 'POST',
+            Type: 'AWS',
+            Credentials: { 'Fn::GetAtt': ['ApigatewayToSqsRole', 'Arn'] },
+            Uri: {
+              'Fn::Sub': [
+                'arn:aws:apigateway:${AWS::Region}:sqs:path//${AWS::AccountId}/${queueName}',
+                {
+                  queueName: 'myQueue'
+                }
+              ]
+            },
+            RequestParameters: {
+              'integration.request.querystring.Action': "'SendMessage'",
+              'integration.request.querystring.MessageBody': 'method.request.body'
+            },
+            RequestTemplates: { 'application/json': '{statusCode:200}' },
+            IntegrationResponses: [
+              {
+                StatusCode: 200,
+                SelectionPattern: 200,
+                ResponseParameters: {},
+                ResponseTemplates: {}
+              },
+              {
+                StatusCode: 400,
+                SelectionPattern: 400,
+                ResponseParameters: {},
+                ResponseTemplates: {}
+              },
+              {
+                StatusCode: 500,
+                SelectionPattern: 500,
+                ResponseParameters: {},
+                ResponseTemplates: {}
+              }
+            ]
+          },
+          MethodResponses: [
+            {
+              ResponseParameters: {},
+              ResponseModels: {},
+              StatusCode: 200
+            },
+            {
+              ResponseParameters: {},
+              ResponseModels: {},
+              StatusCode: 400
+            },
+            {
+              ResponseParameters: {},
+              ResponseModels: {},
+              StatusCode: 500
+            }
+          ]
+        }
+      }
+    })
+  })
+
   it('should not create corresponding resources when other proxies are given', () => {
     serverlessApigatewayServiceProxy.validated = {
       events: [