Middy.js - A powerful Node.js middleware framework for your lambdas

Middy.js
A powerful Node.js middleware framework for your lambdas
Luciano Mammino ( )@loige
loige.link/middy-gcs29/01/2020, Dublin 1

Hello, I am Luciano!Hello, I am Luciano!
2

Fullstack Dev & Cloud Architect
2

Fullstack Dev & Cloud Architect
Blog:
Twitter:
GitHub:
loige.co
@loige
@lmammino
2

Ask questions here:
loige.link/middy-gcsloige.link/middy-gcs
loige.link/middy-gcs-qa@loige 3

What is serverlessWhat is serverless
Compute as functions (FaaS)Compute as functions (FaaS)
Event-based modelEvent-based model
Managed resourcesManaged resources
@loige loige.link/middy-gcs-qa4

Why serverless is goodWhy serverless is good
Focus on business logicFocus on business logic
ScalabilityScalability
Pay-per-use model (compute time * memory)Pay-per-use model (compute time * memory)
Forces you to think micro-servicesForces you to think micro-services

My Serverless experienceMy Serverless experience
Open source
A semi-automated weekly newsletter ( )
A middleware framework for AWS Lambda ( )
Enterprise
Trading, Billing engine, Market data aggregator solutions ( )
Big data pipeline to make network metadata searchable ( )
Organised various workshops around Europe ( )
Fullstack bulletin
middy.js.org
ESB
Vectra.ai
Serverlesslab.com

♀ ♀ DISCLAIMERDISCLAIMER

Serverless is more than just FaaSServerless is more than just FaaS

... but here we will focus mostly on AWS Lamda... but here we will focus mostly on AWS Lamda

Quickest intro to Lambda (ever)!Quickest intro to Lambda (ever)!

@loige loige.link/middy-gcs-qa
code
8

code
⚡
event
8

code
⚡
event
=
8

code
⚡
event proﬁt
=
8

code
⚡
event proﬁt
=
* real life coding with Lambda is a little bit more complicated™ than this...
8

exports.myLambda = async function (
event,
context
) {
// get input from event and context
// return output or throw an error
}
Anatomy of a Node.js lambda on AWSAnatomy of a Node.js lambda on AWS

exports.myLambda = async function (event, context) {
const name = event.queryStringParameters.name
const message = `Hello ${name || 'World'}!`
return ({
statusCode: 200,
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({ message })
})
}
Hello World!Hello World!

exports.MyLambda = async function (event, context) {
// decrypt environment variables with KMS
// deserialize the content of the event
// validate input, authentication, authorization
// REAL BUSINESS LOGIC
// (process input, generate output)
// validate output
// serialize response
// handle errors
}
Real WorldReal World vsvs Hello WorldHello World

exports.MyLambda = async function (event, context) {
// decrypt environment variables with KMS
// deserialize the content of the event
// validate input, authentication, authorization
// REAL BUSINESS LOGIC
// (process input, generate output)
// validate output
// serialize response
// handle errors
}
Real WorldReal World vsvs Hello WorldHello World
LOTS of BOILERPLATE

♀ ♀
In a real project with many lambdas,In a real project with many lambdas,
we might end up with a lot of code duplication!we might end up with a lot of code duplication!

Can we avoid a bit of clutter by separating "Can we avoid a bit of clutter by separating "purepure
business logicbusiness logic" from the "" from the "boilerplateboilerplate"?"?

A solution...A solution...

npm install @middy/core
Note: using (beta)version 1.0.0

npm install @middy/core
Note: using (beta)version 1.0.0
Give it moar love

UsageUsage
const middy = require('@middy/core')
const { middleware1, middleware2, middleware3 } = require('some-middlewares')
const originalHandler = async (event, context) => {
/* your business logic */
}
const handler = middy(originalHandler)
handler
.use(middleware1())
.use(middleware2())
.use(middleware3())
module.exports = { handler }

UsageUsage
}
handler
.use(middleware1())
.use(middleware2())
.use(middleware3())
1. deﬁne handler

UsageUsage
}
handler
.use(middleware1())
.use(middleware2())
.use(middleware3())
2. "middify" the handler

UsageUsage
}
handler
.use(middleware1())
.use(middleware2())
.use(middleware3())
3. attach middlewares

UsageUsage
}
handler
.use(middleware1())
.use(middleware2())
.use(middleware3())
module.exports = { handler } 4. export "middyﬁed" handler

UsageUsage
}
handler
.use(middleware1())
.use(middleware2())
.use(middleware3())

UsageUsage
}
handler
.use(middleware1())
.use(middleware2())
.use(middleware3())
Business logic

UsageUsage
}
handler
.use(middleware1())
.use(middleware2())
.use(middleware3())
Business logic
Boilerplate

Middy comes with a built-in collectionMiddy comes with a built-in collection
of useful middlewaresof useful middlewares
Some examples:
Cache
Database manager
HTTP error handler
HTTP content negotiation
HTTP CORS
HTTP JSON body parser
HTTP Multipart body parser
HTTP Security headers
Secrets manager
SSM
Validator
Warmup

const urlEncodedBodyParser = require('@middy/http-urlencode-body-parser')
const validator = require('@middy/validator')
const httpErrorHandler = require('@middy/http-error-handler')
const processPaymentHandler = async (event, context) => {
const {
creditCardNumber, expiryMonth, expiryYear, cvc, nameOnCard, amount
} = event.body
// do stuff with this data ...
return ({
statusCode: 200,
body: 'payment processed correctly'
})
}
const inputSchema = {
// define validation schema here ...
}
const handler = middy(processPaymentHandler)
.use(urlEncodedBodyParser())
.use(validator(inputSchema))
.use(httpErrorHandler())
19

const {
} = event.body
return ({
statusCode: 200,
})
}
}
Dependencies
19

const {
} = event.body
return ({
statusCode: 200,
})
}
}
Handler
(business logic)
19

const {
} = event.body
return ({
statusCode: 200,
})
}
}
Deﬁne the input schema
(uses )JSON-schema
19

const {
} = event.body
return ({
statusCode: 200,
})
}
}
Attach middlewares
19

const {
} = event.body
return ({
statusCode: 200,
})
}
}
module.exports = { handler } Export enhanced handler 19

Why?Why?

Why?Why?
Simplify code

Why?Why?
Simplify code
Reusability
input parsing
input & output validation
output serialization
error handling...

Why?Why?
Simplify code
Reusability
input parsing
input & output validation
output serialization
error handling...
Focus (even) MORE on business logic
Testability

How it worksHow it works

Execution orderExecution order
@loige 22loige.link/middy-gcs-qa

1. middleware1 (before)

4. handler

4. handler
5. middleware3 (after)

4. handler

When an error happens...When an error happens...
Flow is stopped
First middleware implementing `onError` gets control
It can choose to handle the error, or delegate it to the next handler
If the error is handler a response is returned
If the error is not handled the execution fails reporting the unhandled error

Writing a middlewareWriting a middleware
const myMiddleware = (config) => {
// might set default options in config
return ({
before: (handler, next) => {
// might read options from `config`
},
after: (handler, next) => {
},
onError: (handler, next) => {
}
})
}
module.exports = myMiddleware

Inline middlewaresInline middlewares
const handler = middy((event, context, callback) => {
// do stuff
})
handler.before((handler, next) => {
// do something in the before phase
next()
})
handler.after((handler, next) => {
// do something in the after phase
next()
})
handler.onError((handler, next) => {
// do something in the on error phase
next()
})
@loige

In summaryIn summary
Serverless is cool, it helps you to build apps quickly and with a greater
focus on business logic, rather than on infrastructure!
Middy helps you to keep focusing on your business logic ﬁrst
You can add extra behaviours with very minimal changes to your core
logic by introducing dedicated middlewares
You can easily share common functionality through middlewares

If you like MiddyIf you like Middy
Use itUse it
Give feedback:Give feedback:
Contribute (I am looking for co-maintainers)Contribute (I am looking for co-maintainers)
Version 1.0 (stable) coming soonVersion 1.0 (stable) coming soon
github.com/middyjs/middy/issuesgithub.com/middyjs/middy/issues

Your turn...Your turn...

THANKS!THANKS!
A special thank you to all the amazing Middy users
and !contributors
@loige
loige.link/middy-gcsloige.link/middy-gcs 29

Middy.js - A powerful Node.js middleware framework for your lambdas

More Related Content

What's hot (20)

Similar to Middy.js - A powerful Node.js middleware framework for your lambdas (20)

More from Luciano Mammino (20)

Recently uploaded (20)