jaredce / serverless-openapi-documenter Goto Github PK

serverless.yml (extract)

documentation:
            summary: 'Get a QuickSight dasbhoard URL'
            description: 'Used to get a QuickSight dashboard URL based on its id'
            requestHeaders:
              - name: 'env'
                description: 'Genesys Cloud environment (e.g. mypurecloud.com)'
                schema:
                  type: 'string'
              - name: 'token'
                description: 'Genesys Cloud OAuth token'
                schema:
                  type: 'string'
            pathParams:
              - name: 'id'
                description: 'The QuickSight dashboard id'
                schema:
                  type: 'string'
                  pattern: '^[-a-z0-9_]+$'
            methodResponses:
              - statusCode: 200
                responseBody:
                  description: 'Success'
                responseModels:
                  application/json: 'SuccessResponse'

const deReferencedSchema = await dereferenceSchema(schema);
const convertedSchemas = SchemaFactory.convert(deReferencedSchema, 'UserResponse');

**Expected behavior**
It should generate the document even if the interface is self-referencing or has circular dependencies.

**Desktop (please complete the following information):**
 - Serverless version: [e.g. 3.34.0]
 - serverless-openapi-documenter version : 0.0.72

serverless.yml
service: abc
provider:
  name: aws

custom:
  documentation:
    description: abc
    version: 1.0.0
    models:
      - name: externalFile
      - description: An external definition
      - contentType: application/json
      - schema: https://raw.githubusercontent.com/JaredCE/serverless-openapi-documenter/main/test/models/ErrorResponse.json

service: '${env:APINAME}-V1'

plugins:
  - serverless-import-plugin
  - serverless-reqvalidator-plugin
  - serverless-aws-documentation
  - serverless-openapi-documenter
  - serverless-prune-plugin
  - serverless-iam-roles-per-function
  - serverless-api-gateway-caching

provider:
  name: aws
  environment: ${file(../../../serverless/environment.yml)}
  stage: ${sls:stage, self:custom.default.stage}
  region: ${opt:region,  self:custom.default.region}

custom:
  default:
    stage: dev
    region: eu-west-1

  documentation:
    version: "1"
    title: "My API"
    description: "This is my API"

  import:
    - another/service/v1
    - ../../../common.yml

Generating OpenAPI Description
✖ ERROR: An error was thrown generating the OpenAPI v3 Description
Environment: darwin, node 18.7.0, framework 3.36.0 (local) 3.34.0v (global), plugin 7.1.0, SDK 4.4.0
Docs:        docs.serverless.com
Support:     forum.serverless.com
Bugs:        github.com/serverless/serverless/issues

Error:
ServerlessError: TypeError: Cannot read properties of undefined (reading 'description')

2 deprecations found: run 'serverless doctor' for more details
Error: 

custom:
  documentation:
    models:
      -
        name: "Address"
        description: "This is an address"
        contentType: "application/json"
        schema:
          type: "object"
          properties:
            street:
              type: "string"
      -
        name: "Customer"
        description: "This is a customer"
        contentType: "application/json"
        schema:
          type: "object"
          properties:
            name:
              type: "string"
            address:
              $ref: "{{model: Address}}"       <--------------

 Error ---------------------------------------------------
 
  Error: Cannot find module 'ajv/dist/core'
  Require stack: <blah>

1. run `npm install` running node 14.21.3
2. run `npm run openapi` with the above script configured in your 'scripts' section of your package.json file.

npx serverless openapi generate --format yaml --output openapi.yml

handler: lambda/functions/patchStatus/main.go
timeout: 30
events:
  - http:
      path: /v1/request/{id}/status/{subId}
      method: patch
      cors: true
      private: true

      documentation:
        summary: "Patch Status"
        description: "updates a status"
        pathParams:
          - name: "id"
            description: "The id of the request to mark as complete"
            required: true
            schema:
              type: "string"
          - name: "subId"
            description: "The status you want to apply to a request"
            required: true
            schema:
              type: "string"
        requestModels:
          "application/json": "RequestStatusRequest"
        methodResponses:
          - statusCode: "204"
            responseBody:
              description: No content
          - statusCode: "404"
            responseBody:
              description: Not found
            responseModels:
              "application/json": "RequestServiceError"
          - statusCode: "400"
            responseBody:
              description: Bad request
            responseModels:
              "application/json": "RequestServiceError"

        '204':
          description: The resource was deleted successfully.

documentation:
  version: 1.0.0
  description: 'My API description'
  servers:
    - url: https://my.{env}.url
      description: Dev & Staging server
      variables:
        env:
          enum:
            - dev
            - stage
          default: dev
    - url: https://my.url
      description: Production server
  ...

if (server.variables) {
    obj.variables = server.variables
}

security:
  - BearerAuth: []
  
components:
  securitySchemes:
    BearerAuth:
      bearerFormat: JWT
      scheme: bearer
      type: http

{
  "title": "Child",
  "type": "object",
  "properties": {
    "child_property": {
      "type": "string"
    }
  }
}

{
  "title": "Parent",
  "type": "object",
  "properties": {
    "parent_property": {
      "type": "string"
    },
    "child_reference": {
      "$ref": "src/serverless/schemas/Child.json"
    }
  }
}

"child_reference": {
      "$ref": "Child.json"
}

{
  "title": "Grandpa",
  "type": "object",
  "properties": {
    "grandpa_property": {
      "type": "string"
    },
    "parent_reference": {
      "$ref": "src/features/songs/serverless/schemas/Parent.json"
    }
  }
}

Error:
ServerlessError: ResolverError: Error opening file "/home/user/project/src/serverless/schemas/src/serverless/schemas/Child.json"
ENOENT: no such file or directory, open '/home/user/project/src/serverless/schemas/src/serverless/schemas/Child.json'

"parent_reference": {
      "$ref": "./Parent.json"
 }

ServerlessError: ResolverError: Error opening file "/home/user/project/Parent.json"
ENOENT: no such file or directory, open '/home/user/project/Parent.json'

"parent_reference": {
      "$ref": "src/serverless/schema/Parent.json"
 }


ServerlessError: ResolverError: Error opening file "/home/user/project/src/serverless/schema/Parent.json"
ENOENT: no such file or directory, open '/home/user/project/src/serverless/schema/Parent.json'

  documentation:
    version: '1'
    title: 'My API'
    description: 'This is my API'
    models: { }
    externalDocumentation:
      url: https://google.com
      description: A link to google
    servers:
      url: https://example.com
      description: The server
    tags:
      - name: tag1
        description: this is a tag
        externalDocumentation:
          url: https://npmjs.com
          description: A link to npm

  events:
    - http:
        path: path_to_my_existing_function/action/{param1}/{param2}
        method: delete
        cors:
          origin: '*'
          headers:
            - Content-Type
            - X-Amz-Date
            - Authorization
            - X-Api-Key
            - X-Amz-Security-Token
            - X-Amz-User-Agent
            - X-Auth-Token
        documentation:
          summary: "Create User"
          description: "Creates a user and then sends a generated password email"
          requestBody:
            description: "A user information object"
          requestModels:
            application/json: "PutDocumentRequest"
          queryParams:
            - name: "membershipType"
              description: "The user's Membership Type"
              schema:
                type: "string"
                enum:
                  - "premium"
                  - "standard"
          methodResponses:
            - statusCode: 201
              responseBody:
                description: "A user object along with generated API Keys"
              responseModels:
                application/json: "PutDocumentResponse"
            - statusCode: 500
              responseBody:
                description: "An error message when creating a new user"
              responseModels:
                application/json: "ErrorResponse"

$: serverless openapi generate -o openapi_test.yml -f yaml -a 3.0.3 --stage mike
Running "serverless" from node_modules
OpenAPI v3 Document Generation
[OPTIONS]
  openApiVersion: "3.0.3"
  format: "yaml"
  output file: "openapi_test.yml"
  indentation: "2"
  
Environment: linux, node 16.16.0, framework 3.30.1 (local) 3.30.1v (global), plugin 6.2.3, SDK 4.3.2
Credentials: Local, "default" profile
Docs:        docs.serverless.com
Support:     forum.serverless.com
Bugs:        github.com/serverless/serverless/issues

Error:
TypeError: this.documentation?.models?.map is not a function

{
  "name": "versionId",
  "in": "path",
  "description": "Id of the version. Uses the latest version by default.",
  "required": false, #!
  "schema": {
    "$ref": "#/components/schemas/versionId"
  }
},

- name: versionId
  description: 'Id of the version. Uses the latest version by default.'
  required: false # doesn't work
  schema:
    type: string

{
  "name": "versionId",
  "in": "path",
  "description": "Id of the version. Uses the latest version by default.",
  "required": true,
  "schema": {
    "$ref": "#/components/schemas/versionId"
  }
},

functions:
myLambda:
...
events:
- httpApi:
  method: GET
  path: hello
  documentation:
    ....
  ...

const documentation = event.http.documentation || event.httpApi.documentation

const documentation = event.http?.documentation || event.httpApi?.documentation

custom:
  modelsList: ${file(resources/models/modelList.yml)}
  documentation:
    [...]
functions:
  AgencyList:
    name: bla
    handler: bla
    events:
      - http:
          path: api/v1/agencies
          method: get
          documentation:
            summary: "Gets the agency list"
            methodResponses:
              - statusCode: 200
                responseModels:
                  application/json: "AgencyList"
                responseBody:
                  description: "Test"

---
- name: "Agency"
  description: "This is a Agency"
  contentType: "application/json"
  schema: "${file(resources/models/Agency.json)}"
- name: "AgencyList"
  description: "This is a AgencyList"
  contentType: "application/json"
  schema: "${file(resources/models/AgencyList.json)}"

{
  "type" : "object",
  "properties" : {
    "agencies" : {
      "type" : "array",
      "items" : {
        "$ref" : "#/components/schemas/Agency"
      }
    }
  }
}

{
  "type" : "object",
  "properties" : {
    "id" : {
      "type" : "string"
    }
  }
}

	
custom:
  documentation:
    version: '1'
    title: 'My API'


    prefix: R1


    description: 'This is my API'
    models: {}
    externalDocumentation:
      url: https://google.com
      description: A link to google
    servers:
      url: https://example.com
      description: The server
    tags:
      - name: tag1
        description: this is a tag
        externalDocumentation:
          url: https://npmjs.com
          description: A link to npm

custom:
   apiGatewayServiceProxies:
      - sns:
          path: /testEndpoint
          method: post
          topicName: SNStopic
          request:
             template:
             ...

SuccessResponse.json

{
  "Status": 200,
  "EmbedUrl": "url",
  "RequestId": "b35fc1ff-578b-4bb4-a975-1abe5574da1b"
}

  ServerlessError: AssertionError: expected Object {
    default: '1',
    allOf: Array [
      Object {
        title: 'Reason',
        description: 'An enumeration.',
        enum: Array [ '1', '2' ],
        type: 'string'
      }
    ]
  } to have property type

 "contact": {
    "name": "API Support",
    "url": "http://www.example.com/support",
    "email": "[email protected]"
  }

  x-api-id: e9bc9584aasdsd4380-860a-9asd7495de6f200
  x-audience: company-internal
  x-logo:
    url: 'https://www.google.de/wp-content/logo/logo-black.svg'
    altText: company logo

serverless.docs.yml

documentation:
 contact:
    name: API Support
    url: http://www.example.com/support
    email: [email protected]
  x-api-id: e9bc9584aasdsd4380-860a-9asd7495de6f200
  x-audience: company-internal
  x-logo:
    url: 'https://www.google.de/wp-content/logo/logo-black.svg'
    altText: company logo
  additionalInfoAttributes:
    - x-api-id
    - x-audience
    - contact
    - x-logo

definitionGenerator.js

    createInfo() {
        const service = this.serverless.service
        const documentation = this.serverless.service.custom.documentation;
        const additionalInfoAttributes = documentation?.additionalInfoAttributes || [];

        const info = {
            title: documentation?.title || service.service,
            description: documentation?.description || '',
            version: documentation?.version || uuid(),
        }

        for (const attribute of additionalInfoAttributes){
            info[attribute] = documentation[attribute];
        }  
        
        Object.assign(this.openAPI, {info})
    }

functions:
  myLambda1:
  ...
  events:
    - httpApi:
        method: GET
        path: /user/{id}
  myLambda2:
  ...
  events:
    - httpApi:
        method: PUT
        path: /user/{id}
  ...

if (paths[slashPath]) {
    Object.assign(paths[slashPath], path);
} else {
    Object.assign(paths, {[slashPath]: path});
}

# main serverless.yml
service: auth

provider:
  name: aws
  stage: dev
  region: sa-east-1
  runtime: nodejs18.x
  apiGateway:
    restApiId: ${param:ApiGW}
    restApiRootResourceId: ${param:ApiGWRootResourceId}
    websocketApiId: ${param:WebsocketsApi}
  environment:
    USER_POOL_ID: !Ref UserPool
    CLIENT_ID: !Ref UserPoolClient
  iam:
    role:
      statements:
        - Effect: Allow
          Action:
            - cognito-idp:AdminInitiateAuth
            - cognito-idp:AdminCreateUser
            - cognito-idp:AdminSetUserPassword
            - cognito-idp:AdminAddUserToGroup
            - cognito-idp:AdminListGroupsForUser
          Resource: !GetAtt UserPool.Arn

functions:
  signup:
    handler: src/signup.handler
    events:
      - http:
          path: auth/signup
          method: post
          cors: true
          documentation: ${file(docs/serverless.doc.yaml):endpoints.signup}

  requestVerifyEmail:
    handler: src/requestVerifyEmail.handler
    events:
      - http:
          path: auth/requestVerifyEmail
          method: post
          cors: true
          documentation: ${file(docs/serverless.doc.yaml):endpoints.requestVerifyEmail}

  verifyEmail:
    handler: src/verifyEmail.handler
    events:
      - http:
          path: auth/verifyEmail
          method: post
          cors: true
          documentation: ${file(docs/serverless.doc.yaml):endpoints.verifyEmail}
          authorizer:
            name: PrivateAuthorizer
            type: COGNITO_USER_POOLS
            arn: !GetAtt UserPool.Arn

  login:
    handler: src/login.handler
    events:
      - http:
          path: auth/login
          method: post
          cors: true
          documentation: ${file(docs/serverless.doc.yaml):endpoints.login}

  refresh:
    handler: src/refresh.handler
    events:
      - http:
          path: auth/refresh
          method: post
          cors: true
          documentation: ${file(docs/serverless.doc.yaml):endpoints.login}

  forgotPassword:
    handler: src/forgotPassword.handler
    events:
      - http:
          path: auth/forgotPassword
          method: post
          cors: true
          documentation: ${file(docs/serverless.doc.yaml):endpoints.forgotPassword}

  resetPassword:
    handler: src/resetPassword.handler
    events:
      - http:
          path: auth/resetPassword
          method: post
          cors: true
          documentation: ${file(docs/serverless.doc.yaml):endpoints.resetPassword}

  changePassword:
    handler: src/changePassword.handler
    events:
      - http:
          path: auth/changePassword
          method: post
          cors: true
          documentation: ${file(docs/serverless.doc.yaml):endpoints.changePassword}
  
  privateAPI:
    handler: src/private.handler
    events:
      - http:
          path: auth/private
          method: post
          cors: true
          documentation: ${file(docs/serverless.doc.yaml):endpoints.privateAPI}
          authorizer:
            name: PrivateAuthorizer
            type: COGNITO_USER_POOLS
            arn: !GetAtt UserPool.Arn

  idTokenGeneration:
    handler: src/idTokenGeneration.handler
    events:
      - cognitoUserPool:
          pool: ${self:service}-pool-${sls:stage}
          # pool: !GetAtt UserPool.Name
          trigger: PreTokenGeneration
          existing: true

resources:
  Resources:
    UserPool:
      Type: AWS::Cognito::UserPool
      Properties:
        UserPoolName: ${self:service}-pool-${sls:stage}
        Schema:
          - Name: email
            Required: true
            Mutable: true
          - Name: admin
            DeveloperOnlyAttribute: true
            AttributeDataType: String
            Mutable: false
            Required: false
        Policies:
          PasswordPolicy:
            MinimumLength: 6
        EmailConfiguration:
          EmailSendingAccount: COGNITO_DEFAULT
        VerificationMessageTemplate:
          DefaultEmailOption: CONFIRM_WITH_CODE

    CognitoUserPoolGroupAdmin:
      Type: AWS::Cognito::UserPoolGroup
      Properties: 
        Description: "Admin priviledges"
        GroupName: "admin"
        UserPoolId: !Ref UserPool

    CognitoUserPoolGroupMaintainer:
      Type: AWS::Cognito::UserPoolGroup
      Properties: 
        Description: "Access to admin functions only when approved by admins"
        GroupName: "maintainer"
        UserPoolId: !Ref UserPool

    CognitoUserPoolGroupPhysician:
      Type: AWS::Cognito::UserPoolGroup
      Properties: 
        Description: "Access to physician functions"
        GroupName: "physician"
        UserPoolId: !Ref UserPool

    CognitoUserPoolGroupPatient:
      Type: AWS::Cognito::UserPoolGroup
      Properties: 
        Description: "Regular users"
        GroupName: "patient"
        UserPoolId: !Ref UserPool

    UserPoolClient:
      Type: AWS::Cognito::UserPoolClient
      Properties:
        ClientName: ${self:service}-pool-client-${sls:stage}
        GenerateSecret: false
        UserPoolId: !Ref UserPool
        AccessTokenValidity: 5
        IdTokenValidity: 5
        ExplicitAuthFlows:
          - ADMIN_NO_SRP_AUTH
          # - REFRESH_TOKEN_AUTH

    # CognitoUserPoolIdentityProvider:
    #   Type: AWS::Cognito::UserPoolIdentityProvider
    #   Properties: 
    #     ProviderName: Google
    #     AttributeMapping:
    #       email: emailAddress
    #     ProviderDetails:
    #       client_id: ${env:GOOGLE_CLIENT_ID}
    #       client_secret: ${env:GOOGLE_CLIENT_SECRET}
    #       authorize_scopes: email name openid
    #     ProviderType: Google
    #     UserPoolId: !Ref UserPool

plugins:
  - serverless-esbuild
  - serverless-openapi-documenter
  - serverless-stack-output

package:
  individually: true

custom:
  documentation: ${file(docs/serverless.doc.yaml):documentation}

  output:
    file: ../.serverless/stack.json

  esbuild:
    bundle: true
    minify: true

# serverless-compose.yaml
services:
  rest:
    path: rest

  auth:
    path: auth
    params:
      ApiGW: ${rest.ApiGW}
      ApiGWRootResourceId: ${rest.ApiGWRootResourceId}
      WebsocketsApi: ${rest.WebsocketsApi}

# reat service serverless.yaml
service: rest-api

provider:
  name: aws
  stage: dev
  region: sa-east-1
  runtime: nodejs18.x

resources:
  Resources:
    ApiGW:
      Type: AWS::ApiGateway::RestApi
      Properties:
        Name: ApiGW

    WebsocketsApi:
      Type: AWS::ApiGatewayV2::Api
      Properties:
        Name: WebsocketsApi
        ProtocolType: WEBSOCKET
        RouteSelectionExpression: '$request.body.action'

  Outputs:
    ApiGW:
      Value: !Ref ApiGW

    ApiGWRootResourceId:
      Value: !GetAtt ApiGW.RootResourceId

    WebsocketsApi:
      Value: !Ref WebsocketsApi

# When running from serverless-compose folder
The variable "${rest.ApiGW}" cannot be resolved: the referenced output does not exist.

# When running from auth service folder
Cannot resolve serverless.yaml: Variables resolution errored with:
  - Cannot resolve variable at "provider.apiGateway.restApiId": The param "ApiGW" cannot be resolved from CLI options or stage params. If you are using Serverless Framework Compose, make sure to run commands via Compose so that all parameters can be resolved,
  - Cannot resolve variable at "provider.apiGateway.restApiRootResourceId": The param "ApiGWRootResourceId" cannot be resolved from CLI options or stage params. If you are using Serverless Framework Compose, make sure to run commands via Compose so that all parameters can be resolved,
  - Cannot resolve variable at "provider.apiGateway.websocketApiId": The param "WebsocketsApi" cannot be resolved from CLI options or stage params. If you are using Serverless Framework Compose, make sure to run commands via Compose so that all parameters can be resolved

      - name: DashboardsSuccessResponse
        description: Dashboards Success response
        content:
          application/json:
            schema:
              type: array
              items:
                $ref: '#/custom/documentation/models/DashboardItem' <-- This fails
      - name: DashboardItem
        description: Dashboard item
        content:
          properties:
            Arn:
              type: string
            DashboardId:
              type: string
            Name:
              type: string
            CreatedTime:
              type: string
            LastUpdatedTime:
              type: string
            PublishedVersionNumber:
              type: number
            LastPublishedTime:
              type: string

Use serverless openapi generate command. The above error is thrown sometimes and the error message appears to be vague and does not specify what has failed and where.

temp.json

{
  "$ref": "#/definitions/AWSObject",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "definitions": {
    "AWSObject": {
      "additionalProperties": false,
      "properties": {
        "Name": {
          "type": "string"
        },
        "Status": {
          "type": "string"
        }
      },
      "type": "object"
    }
  }
}

serverless.ts

...
        {
          name: 'temp',
          contentType: 'application/json',
          schema: '${file(temp.json)}',
        }
...

        {
          statusCode: 201,
          responseBody: {
            description: 'Temp response',
          },
          responseModels: {
            'application/json': 'temp',
          },
        },

{
  "components": {
    "schemas": {
      "temp": {
        "properties": {
          "AWSObject": {
            "additionalProperties": false,
            "properties": {
              "Name": {
                "type": "string"
              },
              "Status": {
                "type": "string"
              }
            },
            "type": "object"
          }
        }
      }
    }
  }
}

{
  "components": {
    "schemas": {
      "temp": {
        "additionalProperties": false,
        "properties": {
          "Name": {
            "type": "string"
          },
          "Status": {
            "type": "string"
          }
        },
        "type": "object"
      }
    }
  }
}

serverless.yml

service: aws
#org: ccportal
app: aws
custom:
  documentation:
    version: '1'
    title: 'My API'
    description: 'This is my API'
    externalDocumentation:
      url: https://google.com
      description: A link to google
    servers:
      url: https://example.com
      description: The server
    tags:
      - name: tag1
        description: this is a tag
        externalDocumentation:
          url: https://npmjs.com
          description: A link to npm
    models:
      - name: 'SuccessResponse'
        description: 'Success response'
        content:
          application/json:
            schema: ${file(models/SuccessResponse.json)}
      - name: 'ErrorResponse'
        description: 'This is an error'
        content:
          application/json:
            schema: ${file(models/ErrorResponse.json)}
      - name: 'PutDocumentResponse'
        description: 'PUT Document response model (external reference example)'
        content:
          application/json:
            schema: ${file(models/PutDocumentResponse.json)}
      - name: 'PutDocumentRequest'
        description: 'PUT Document request model (inline example)'
        content:
          application/json:
            schema:
              $schema: 'http://json-schema.org/draft-04/schema#'
              properties:
                SomeObject:
                  type: 'object'
                  properties:
                    SomeAttribute:
                      type: 'string'
  secrets_AWS: ${ssm:/aws/reference/secretsmanager/ccportal/aws}
  serverless-offline:
    httpPort: 4000
    # useChildProcesses: true # Do not use with this API as it has unexpected effects (API won't respond any more)
  prune:
    automatic: true
    number: 1
  cors-config:
    origins:
      - '*'
    headers:
      - Content-Type
      - X-Amz-Date
      - Authorization
      - X-Api-Key
      - X-Amz-Security-Token
      - X-Amz-User-Agent
      - env
      - token
    allowCredentials: false
provider:
  name: aws
  runtime: nodejs16.x
  memorySize: 8192
  profile: ccportal
  lambdaHashingVersion: '20201221'
  stage: dev
  region: eu-central-1
  deploymentBucket:
    name: my.dev.serverless.deploys
  versionFunctions: false
  tracing:
    lambda: true
  logRetentionInDays: 7
  timeout: 30 # If using web sockets, you can increase this. It will cause a warning when running 'serverless deploy' but you can ignore it.
  environment:
    NODE_ENV: ${file(./.env.yml):${opt:stage, self:provider.stage}.NODE_ENV}
    AWS_ACCOUNT_ID: ${self:custom.secrets_AWS.ACCOUNT_ID}
    AWS_QUICKSIGHT_USER_ARN: ${self:custom.secrets_AWS.quickSight_user_arn}
    STAGE: ${opt:stage, self:provider.stage}
  iamRoleStatements:
    - Effect: Allow
      Action:
        - lambda:InvokeFunction
        - dynamodb:*
        - s3:*
        - quicksight:GetDashboardEmbedUrl
        - quicksight:GetAnonymousUserEmbedUrl
        - quicksight:GenerateEmbedUrlForRegisteredUser
        - quicksight:ListDashboards
      Resource:
        - '*'
  apiGateway:
    restApiId:
      'Fn::ImportValue': ${opt:stage, self:provider.stage}-CCPortalGW-restApiId
    restApiRootResourceId:
      'Fn::ImportValue': ${opt:stage, self:provider.stage}-CCPortalGW-rootResourceId
functions:
  getQuickSightDashboardUrl:
    handler: handler.getQuickSightDashboardUrl
    events:
      - http:
          path: aws/quicksight/dashboardUrl/{id}
          method: get
          cors: ${self:custom.cors-config}
          documentation:
            summary: 'Get a QuickSight dasbhoard URL'
            description: 'Used to get a QuickSight dashboard URL based on its id'
            tags:
              - aws
              - quicksights
            pathParams:
              - name: 'id'
                description: 'The QuickSight dashboard id'
                schema:
                  type: 'string'
                  pattern: '^[-a-z0-9_]+$'
            methodResponses:
              - statusCode: 200
                responseBody:
                  description: 'Success'
  getDashboardList:
    handler: handler.listdashboards
    events:
      - http:
          path: aws/quicksight/dashboards
          method: get
          cors: ${self:custom.cors-config}
          documentation:
            summary: 'Get a list of QuickSight dasbhoards'
            description: 'Gets the list of QuickSights dashboards'
            tags:
              - aws
              - quicksights
            methodResponses:
              - statusCode: 200
                responseBody:
                  description: 'Success'
  getQuickSightSearchBar:
    handler: handler.getQuickSightSearchBar
    events:
      - http:
          path: aws/quicksight/searchBarUrl/{id}
          method: get
          cors: ${self:custom.cors-config}
          documentation:
            summary: 'Gets a QuickSights search bar URL'
            description: 'Used to get a QuickSights search bar URL based on its id'
            tags:
              - aws
              - quicksights
            pathParams:
              - name: 'id'
                description: 'The QuickSight search bar id'
                schema:
                  type: 'string'
                  pattern: '^[-a-z0-9_]+$'
            methodResponses:
              - statusCode: 200
                responseBody:
                  description: 'Success'
                responseModels:
                  application/json: 'SuccessResponse'

package:
  exclude:
    - .dynamodb/**
    - .nyc_output/**
    - coverage/**
    - test/**
    - .git/**
    - serverless.yml
    - .serverless/**
    - requests.http
    - snowflake.log
    - node_modules/puppeteer/.local-chromium/**
plugins:
  - serverless-offline
  - serverless-prune-plugin
  - serverless-plugin-common-excludes
  - serverless-openapi-documenter