npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2024 – Pkg Stats / Ryan Hefner

@genie-solutions/lambda-toolbelt

v2.16.2

Published

Toolbelt for creating Lambda functions

Downloads

206

Readme

Genie Lambda Toolbelt

Set of reusable tools to make writing new Lambda functions a breeze.

How to publish a new version

After your branch has been merged into master:

  1. Checkout the master branch: git checkout master.
  2. Pull down the latest changes on master: git pull.
  3. Run the correct command out of the following, depending on if your change was a patch (bug fix), minor (non-breaking change), major (breaking change): 3.1 Patch: npm version patch 3.2 Minor: npm version minor 3.3 Major: npm version major

Sample Usage

import { applyMiddleware, httpHandler, withJSONBody, HTTPEvent, HTTPContext } from '@genie-solutions/lambda-toolbelt';

const myHelloWorldFunction = async (event: HTTPEvent, context: HTTPContext): Promise<object> => {
  const { genie: { body } } = context;
  return {
    message: `Hello, ${body.name}`,
  };
};

export default applyMiddleware(httpHandler, withJSONBody)(myHelloWorldFunction);

sqsHandler

import {
  sqsHandler,
  SQSCallback,
} from '../src/index';

interface MySqsRecordBody {
  a: string,
  b: number,
  c?: number[],
}

const mySuperSweetFunction: SQSCallback<MySqsRecordBody> = async (sqsRecordBody: MySqsRecordBody, sqsRecord?: AWSLambda.SQSRecord): Promise<object> => {
  console.log('a is:', sqsRecordBody.a);
  console.log('b is:', sqsRecordBody.b);
  console.log('c is:', sqsRecordBody.c);
  console.log('sqsRecord is:', sqsRecord);
  return {};
};

export default sqsHandler<MySqsRecordBody>(mySuperSweetFunction, ['a', 'b']);

withJWTPayload

Automatically verifies and parses the payload of a JWT token being provided via a HTTP header.

Example:

import { createParameterStore, applyMiddleware, httpHandler, withJWTPayload } from '@genie-solutions/lambda-toolbelt';

const mySuperSecretFunction = async (event: HTTPEvent, context: HTTPContext): Promise<object> => {
  const { userId, tenantId, roleId } = context.genie.jwt.role;
  return Promise.resolve('Oll Korrect (yep, that is what OK stands for)');
};

const parameterStore = createParameterStore();
const getPublicKey = () => parameterStore('JWT_PUBLIC_KEY');

export default applyMiddleware(
  httpHandler,
  withJWTPayload({
    getPublicKey,
    algorithm: 'RS256',
    headerName: 'X-GENIE-ROLES',
    payloadKey: 'role',
  }),
)(mySuperSecretFunction);

withParameters

Automatically add parameters into genie context and validate any required params.

Example:

import {
  applyMiddleware,
  httpHandler,
  withJSONBody,
  withParameters,
  HTTPEvent,
  HTTPContext
} from '@genie-solutions/lambda-toolbelt';

// These interfaces should be in type.ts, here is just quick example
interface MyPathParamsContext {
  pathParameters: {
    pathParam1: string;
  }
}

interface MyQueryStringParamsContext {
  queryStringParameters: {
    qsParam1: string;
    qsParam2: string;
  }
}

interface MyBodyContext {
  body: {
    bodyParam1: string;
    bodyParam2: number;
  }
}

type MyCustomContext = HTTPContext<MyBodyContext & MyPathParamsContext & MyQueryStringParamsContext>;

const mySuperSweetFunction = async (event: HTTPEvent, context: MyCustomContext): Promise<object> => {
  const genie = context.genie;
  const { pathParam1 } = genie.pathParameters;
  const { qsParam1, qsParam2 } = genie.queryStringParameters;
  const { bodyParam1, bodyParam2 } = genie.body;

  return {};
};

export default applyMiddleware(
  httpHandler,
  withJSONBody,
  withParameters({
    // These fields should be defined when actually required
    requiredPathParams: ['pathParam1'],
    requiredJsonBodyParams: ['bodyParam1', 'bodyParam2'],
    requiredQueryStringParams: ['qsParam1', 'qsParam2'],
  }),
)(mySuperSweetFunction);

withClientId

Automatically validate required clientId and assign to genie

Example:

import { applyMiddleware, httpHandler, withClientId, withJSONBody, HTTPContext, ClientIdContext } from '@genie-solutions/lambda-toolbelt';

// These interfaces should be in type.ts, here is just quick example
type MyCustomContext = HTTPContext<ClientIdContext>;

const mySuperSweetFunction = async (event: HTTPEvent, context: MyCustomContext): Promise<object> => {
  const { genie: { clientId } } = event;

  return {};
};

export default applyMiddleware(
  httpHandler,
  withJSONBody,
  withClientId,
)(mySuperSweetFunction);

withAuthenticationId

Automatically validate required authenticationId and assign to genie

Example:

import { applyMiddleware, httpHandler, withAuthenticationId, withJSONBody, HTTPContext, AuthenticationIdContext } from '@genie-solutions/lambda-toolbelt';

// These interfaces should be in type.ts, here is just quick example
type MyCustomContext = HTTPContext<AuthenticationContext>;

const mySuperSweetFunction = async (event: HTTPEvent, context: MyCustomContext): Promise<object> => {
  const { genie: { authenticationId } } = event;

  return {};
};

export default applyMiddleware(
  httpHandler,
  withJSONBody,
  withAuthenticationId,
)(mySuperSweetFunction);

HOW TO EXTEND HTTPContext

Many times you will want to custom your own HTTPContext and extends it with many other available Context such as ClientIdContext, JwtContext To do this, you can leverage HTTPContext<T1 & T2 & ... & TN> to mix n-contexts into One Final Interface

Example:

import {
  applyMiddleware,
  httpHandler,
  withClientId,
  withJSONBody,
  HTTPEvent,
  HTTPContext,
  JwtContext,
  ClientIdContext
} from '@genie-solutions/lambda-toolbelt';

interface MyBodyContext {
  body: {
    bodyParam1: string;
    bodyParam2: number;
  }
}

type MyCustomContext = HTTPContext<MyBodyContext & ClientIdContext & JwtContext>;

const mySuperSweetFunction = async (event: HTTPEvent, context: MyCustomContext): Promise<object> => {
  // Then you can use your Customized Context with the combined structure
  const genie = context.genie;
  const { bodyParam1, bodyParam2 } = genie.body;
  const { roles } = genie.jwt;
  const { clientId } = genie;

  return {};
};

export default applyMiddleware(
  httpHandler,
  withJSONBody,
  withClientId,
)(mySuperSweetFunction);

HOW TO SET context.callbackWaitsForEmptyEventLoop TO FALSE

In some case, you may want to set context.callbackWaitsForEmptyEventLoop to false to have a shared instance. e.g. we need this to connect lambda to MongoDb Atlas https://docs.atlas.mongodb.com/best-practices-connecting-to-aws-lambda/

To do this, you must import withWaitForEmptyEventLoopDisabled before httpHandler Example:

import {
  applyMiddleware,
  httpHandler,
  withWaitForEmptyEventLoopDisabled,
} from '@genie-solutions/lambda-toolbelt';

export default applyMiddleware(
  withWaitForEmptyEventLoopDisabled,
  httpHandler,
)(mySuperSweetFunction);

errorTesting4xx5xx method

This method is designed to go on any AWS API Gateway, to allow us to mock 4XX and 5XX errors to testing. It can be added to the cloudformation code, to allow each API Gateway to have mock errors. Whatever you send it, it will return. Example:

curl -X POST \
  https://fake-api.endpoint.com/testing \
  -H 'Accept: */*' \
  -H 'Content-Type: application/json' \
  -H 'Host: api.endpoint.com' \
  -d '{
    "response": 404
}'

This would return a 404 error resposne, with some examples, etc..:

{"code":404,"body":"\"Returning the code of: 404\"","callWith":{"response":"2XX | 4XX | 5XX | Any status code"},"example":{"response":500}}

withHttpHandler and httpHandler

They are the same functions. httpHandler is withHttpHandler exported with the default 200 status code to maintain backwards compatibility. This way httpHandler can be used in the same way.

withHttpHandler (NEW)

This method provides you with the option to return a status code other that 200 with the response. Add this function to applyMiddleware and specify the status code as a number there:

import {
  applyMiddleware,
  withHttpHandler,
} from '@genie-solutions/lambda-toolbelt';

export default applyMiddleware(
  withHttpHandler({ statusCode: 202 }),
)(myLambdaFunction);

httpHander

This method returns 200 unless there's an error. If you don't need to return a specific status code, use this method.

import {
  applyMiddleware,
  httpHandler,
} from '@genie-solutions/lambda-toolbelt';

export default applyMiddleware(
  httpHandler,
)(myLambdaFunction);

validateTenantId

Validates that tenantId in the pathParameters is the same as the tenantId in the roles token. If the roles tenantId is not found a 403 will be thrown. If the pathParameters does not contain a tenantId a 403 will be thrown. If the tenants don't match then a 403 is returned. You need to use the withRoles and withParameters middleware first.

import {
  applyMiddleware,
  httpHandler,
  withParameters,
  withRoles,
  validateTenant,
} from '@genie-solutions/lambda-toolbelt';

export default applyMiddleware(
  httpHandler,
  withParameters({
    requiredPathParams: ['tenantId'],
  }),
  withRoles,
  validateTenant,
)(myLambdaFunction);