DEV Community: Keenan Olsen

Built a New TypeScript-first API framework (faster than Express/Fastify)

Keenan Olsen — Fri, 12 Sep 2025 20:27:19 +0000

Keenan Olsen

Sep 12 '25

Introducing MoroJS: A TypeScript-First API Framework Faster Than Express & Fastify

#node #javascript #typescript #performance

Comments

2 min read

Introducing MoroJS: A TypeScript-First API Framework Faster Than Express & Fastify

Keenan Olsen — Fri, 12 Sep 2025 20:12:26 +0000

🚀 Introducing MoroJS: A TypeScript-First API Framework Faster Than Express & Fastify

If you’ve ever built an API with Express or Fastify, you know the drill: boilerplate, validation, middleware juggling, and debugging at scale. They work, but they weren’t designed for today’s TypeScript-first, serverless-heavy world.

That’s why we built MoroJS — a new backend framework that combines speed, type safety, and extensibility into one package.

⚡ Performance That Speaks for Itself

Benchmarks don’t lie:

Hello World: ~68,392 req/sec (about 47% faster than Fastify)
Real APIs: ~52,992 req/sec for GET and ~37,863 req/sec for POST + validation
Latency: ~4–6ms even under load

👉 See full benchmarks here: MoroJS Benchmarks

🛠 Built for Developers

What makes MoroJS stand out:

TypeScript-first → full type safety, no guessing at runtime
Serverless-ready → works seamlessly with Cloudflare Workers, AWS Lambda, and Vercel
Batteries included → validation, middleware, caching, and rate-limiting out of the box
🔥 CLI → scaffold projects in seconds

# create a new MoroJS project
npx create-moro-app my-api
cd my-api
npm run dev

🧩 The Long Game: MoroJS Modules

The vision goes beyond just a framework. We’re building a modules directory — an ecosystem where you can plug in everything from auth to payments to analytics without reinventing the wheel.

Think of it like an app store for APIs.

📚 Get Started Today

Docs: https://morojs.com/docs

Examples: https://github.com/Moro-JS/examples

🙌 We Want Your Feedback

We’re looking for early adopters to kick the tires and tell us what you think:

What would make you switch from Express/Fastify?

What modules would save you the most time?

Where would you deploy first (Vercel, AWS, Cloudflare)?

Drop your thoughts in the comments — or better yet, try MoroJS on your next project and let us know how it goes.

No one beats this speed right now. Let’s build the future of APIs together.

Announcing the Spring 2021 Chainlink Hackathon!

Keenan Olsen — Tue, 23 Feb 2021 19:01:22 +0000

We're excited to announce the Spring 2021 Chainlink Virtual Hackathon from March 15th to April 11th!

Compete to win over $80k+ in prizes
Every participant that submits a valid project earns 1 LINK
Learn in workshops with top protocols in DeFi, gaming, and more
Team up with other devs to build a product that showcases your creativity
Be seen by top recruiters in the space

Join the Hackathon channels in the Chainlink Technical Discord to be part of building the future with Chainlink oracles. We can’t wait to see what you’ve been dreaming up, so sign up now and let’s get hacking.

How to use Chainlink with Truffle

Keenan Olsen — Tue, 31 Mar 2020 17:41:23 +0000

When working with Chainlink, a powerful development environment is essential to ensure your smart contracts are deployed successfully and securely on-chain. Truffle aims to be exactly that, offering an easy to use dApp framework to help make your developer's life a lot more manageable.

Working with Truffle is simple, thanks to the Truffle Boxes feature that allows you to download sample dApp boilerplates directly from your terminal. To help you get started, we've prepared a Chainlink Truffle Box for you. Inside is a sample Chainlinked smart contract titled “MyContract” as well as a pre-made test suite. To grab it, open up your terminal of choice and install truffle.

npm install truffle -g

Next, create a new directory and grab the box via the following commands:

mkdir Chainlink
cd Chainlink
truffle unbox smartcontractkit/box

Upon successful unboxing, you will notice some new directories have been added. These contain helpful boilerplate code and modules to get you started with Chainlinked smart contracts. For the purposes of this article, the smart contract we will be focusing on is “MyContract” and can be found under the contracts directory. This contains some basic Chainlink functionality to help us get a solid understanding of how Chainlinked contracts work.

Testing

First, it’s always a good idea to test your contracts to ensure correct functionality. You can do so via the following command:

npm test

This will run a variety of test cases on our sample contract, such as creating requests with and without Link tokens, sending these requests to oracle contract addresses, and testing contract ownership.

Note:

You may encounter some compilation warnings dealing with the various Link token contracts. This is because we are using an updated version of the Solidity compiler than what was used when these contracts were created initially. Thus, these warnings can be ignored. The Link token is already deployed and we are simply making these contracts available for local testing.

It is important to note that after every test is run, we redeploy each contract. This allows us to have true unit testing, as we do not want our tests to rely on the output of other tests. Furthermore, redeploying each contract takes time, but this is only for testing purposes and does not impact our actual performance run time.

Let’s now view these test cases for “MyContract” in more detail, which you can find under test/MyContract_test.js. If you have used Mocha.js for testing before, you’ll notice that the syntax is familiar. Truffle is based on the Mocha testing framework and has the additional function of working with smart contracts. Let’s go over some of these new features.

Defining the variables to be used for MyContract. In particular, the jobId value used for MyContract is never actually validated and is strictly a placeholder for demonstration purposes. If you would like to use actual jobId values, you can find them here

The contract() function behaves similarly to Mocha’s describe(), yet it incorporates Truffle’s clean-room-features. From the Truffle documentation, it works like this:

Before each contract() function is run, your contracts are redeployed to the running Ethereum client so the tests within it run with a clean contract state.
The contract() function provides a list of accounts made available by your Ethereum client which you can use to write tests.

Furthermore, our example “MyContract” requires artifacts from other smart contracts. To do so, we will make use of the artifacts.require() method, which essentially imports a specific smart contract’s artifacts as a contract abstraction. This data is stored as a JSON blob that Truffle can work with, and can be easily viewed under build/contracts/. Read more about how artifacts.require() works here.

Testing contract fulfillment requirements

With our helper contracts now stored as constant references, we can now start to create test cases. To do so, we will need to properly understand key test methods such as describe(), beforeEach(), it(), and context().

describe() allows us to group our test cases together. It takes two arguments, the first being a string for our test group name, and the second being a callback function. You will notice in our code example, the test cases involved are creating a request, fulfilling a request, canceling a request, and withdrawing LINK.
beforeEach() runs before each individual test in it’s block scope. For many tests, certain actions will have to take place first (such as awaiting a transfer of link) before we can run our test case.
it() is used for an individual test case. These are used to test our contract at different states, and should be explicit in what they are trying to accomplish. You will notice when we ran npm test, the strings in each it() functions’ parameters are output as logs, helping us clearly see our tests timeline.
context() is an alias for describe(), yet is meant to be used in more specific states of a contract’s execution. Put simply, it provides another way to keep tests easier to read and more organized.

Final thoughts

Truffle offers a powerful toolbox to help ensure your Chainlinked smart contracts are working as intended. Thanks to its world-class testing framework based on the popular and well-documented Mocha.js, many developers will find working with it to be friendly and familiar, helping you hit the ground running. With Truffle boxes, dApp companies are able to easily provide useful examples for their fellow developers, helping grow the blockchain ecosystem. We at Chainlink plan on providing more Chainlinked smart contracts for you to work within the near future. Stay tuned.

If you’re a developer, visit the Developer Documentation or join the technical discussion on Discord.