@jetkit/cdk
    TypeScript icon, indicating that this package has built-in type declarations

    1.122.10 • Public • Published

    JetKit/CDK

    Tests npm version Open in Visual Studio Code

    An anti-framework for building cloud-native serverless applications.

    This module provides convenient tools for writing Lambda functions, RESTful API views, and generating cloud infrastructure with AWS CDK.

    Motivation

    Frameworkless web applications.

    We want to build maintainable and scalable cloud-first applications, with cloud resources generated from application code.

    Using AWS CDK we can automate generating API Gateway routes and Lambda functions from class and function metadata.

    Each class or function view is a self-contained Lambda function that only pulls in the dependencies needed for its functioning, keeping startup times low and applications modular.

    Documentation

    Guides and API reference can be found at https://jetkit.dev/docs/.

    Super Quickstart

    Use this monorepo project template: typescript-cdk-template.

    Installation

    npm install @jetkit/cdk

    Synopsis

    API View

    import { HttpMethod } from "@aws-cdk/aws-apigatewayv2"
    import { badRequest, methodNotAllowed } from "@jdpnielsen/http-error"
    import { ApiView, SubRoute, ApiEvent, ApiResponse, ApiViewBase, apiViewHandler } from "@jetkit/cdk"
    
    @ApiView({
      path: "/album",
      memorySize: 512,
      environment: {
        LOG_LEVEL: "DEBUG",
      },
      bundling: { minify: true, metafile: true, sourceMap: true },
    })
    export class AlbumApi extends ApiViewBase {
      // define POST /album handler
      @SubRoute({ methods: [HttpMethod.POST] })
      async post() {
        return "Created new album"
      }
    
      // custom endpoint in the view
      // routes to the ApiView function
      @SubRoute({
        path: "/{albumId}/like", // will be /album/123/like
        methods: [HttpMethod.POST, HttpMethod.DELETE],
      })
      async like(event: ApiEvent): ApiResponse {
        const albumId = event.pathParameters?.albumId
        if (!albumId) throw badRequest("albumId is required in path")
    
        const method = event.requestContext.http.method
    
        // POST - mark album as liked
        if (method == HttpMethod.POST) return `Liked album ${albumId}`
        // DELETE - unmark album as liked
        else if (method == HttpMethod.DELETE) return `Unliked album ${albumId}`
        // should never be reached
        else return methodNotAllowed()
      }
    }
    export const handler = apiViewHandler(__filename, AlbumApi)

    Handler Function With Route

    import { HttpMethod } from "@aws-cdk/aws-apigatewayv2"
    import { Lambda, ApiEvent } from "@jetkit/cdk"
    
    // a simple standalone function with a route attached
    export async function topSongsHandler(event: ApiEvent) {
      return "top songs"
    }
    // define route and lambda properties
    Lambda({
      path: "/top-songs",
      methods: [HttpMethod.GET],
      memorySize: 384,
      environment: {
        LOG_LEVEL: "WARN",
      },
    })(topSongsHandler)
    
    // alternate, uglier way of writing the same thing
    const topSongsFuncInner = Lambda({
      path: "/top-songs-inner",
      methods: [HttpMethod.GET],
      memorySize: 384,
      environment: {
        LOG_LEVEL: "WARN",
      },
      // this function name should match the exported name
      // or you must specify the exported function name in `handler`
    })(async function topSongsFuncInner(event: ApiEvent) {
      return "top songs"
    })
    export { topSongsFuncInner }

    CDK Stack

    To start from scratch:

    npm install -g aws-cdk
    cdk init app --language typescript
    npm install @jetkit/cdk @aws-cdk/core @aws-cdk/aws-apigatewayv2

    See the guide for more details.

    To deploy your stack:

    cdk deploy

    To generate API Gateway routes and Lambda function handlers from your application code:

    import { CorsHttpMethod, HttpApi } from "@aws-cdk/aws-apigatewayv2"
    import { Construct, Duration, Stack, StackProps, App } from "@aws-cdk/core"
    import { ResourceGeneratorConstruct, AlbumApi, topSongsHandler } from "@jetkit/cdk"
    
    export class InfraStack extends Stack {
      constructor(scope: App, id: string, props?: StackProps) {
        super(scope, id, props)
    
        // create API Gateway
        const httpApi = new HttpApi(this, "Api", {
          corsPreflight: {
            allowHeaders: ["Authorization"],
            allowMethods: [CorsHttpMethod.ANY],
            allowOrigins: ["*"],
            maxAge: Duration.days(10),
          },
        })
    
        // transmute your app code into infrastructure
        new ResourceGeneratorConstruct(this, "Generator", {
          resources: [AlbumApi, topSongsHandler], // supply your functions and view classes here
          httpApi,
        })
      }
    }

    How It Works

    This library provides decorators that can be attached to view classes, methods, and functions. The decorator attaches metadata in the form of options for constructing the Lambda function and optionally API Gateway routes.

    It also includes some convenient CDK L3 constructs to generate the Lambda functions and API Gateway routes from your decorated application code.

    Local Development

    AWS SAM supports running CDK applications locally (in beta).

    Install

    npm i @jetkit/cdk

    DownloadsWeekly Downloads

    343

    Version

    1.122.10

    License

    MIT

    Unpacked Size

    1.71 MB

    Total Files

    382

    Last publish

    Collaborators

    • cybermischa
    • dmitry_sz
    • adamsz
    • annamedv
    • pawel91