14 posts tagged “typescript”.
People hear "don't use vi.mock" and assume the alternative is "don't mock anything." That is not the argument.
The real distinction is simpler: mock explicit collaborators, not implicit imports.
Read More →Domain-Driven Design comes with a lot of vocabulary: aggregates, repositories, domain services, bounded contexts, ubiquitous language, anemic models.
That vocabulary can make DDD sound heavier than it really is.
The useful idea is simpler: keep domain behavior and domain boundaries central, and keep infrastructure, persistence, and framework wiring secondary.
fn(args, deps) does not do that modeling for you. What it gives you is a clear shape for application-layer code in TypeScript: one place for use-case input, one place for collaborators, and less room for domain decisions to drift into wiring.
A lot of developers learn the SOLID principles through class-heavy examples.
That is probably why the conversation so often gets stuck there.
People start to associate SOLID with inheritance hierarchies, interface forests, service classes, and object-oriented ceremony.
But the useful part is not the ceremony.
It is the design pressure.
One of the simplest ways to apply that pressure in plain TypeScript is this shape:
fn(args, deps)Where args is the input for this call and deps is the set of collaborators the function needs.
You can read that as: data in, capabilities in.
Read More →
fn(args, deps)is not a replacement for SOLID. It is a simple function shape that makes several SOLID ideas easier to apply without forcing you into class-heavy design.
Many software systems fail for one very boring reason.
Not because of microservices. Not because of monoliths. Not because of whatever methodology war is trending this week.
They fail because they are unpredictable.
If you make a change and you cannot reliably determine the impact, you cannot safely evolve the system. And when you cannot evolve it, it starts behaving like legacy.
Determinism is the bridge between "works on my machine" and "works every time, everywhere."
fn(args, deps) gets you there — not because it is a clever trick, but because it makes boundaries explicit. Your logic programs to interfaces, which is what lets you control sources of nondeterminism.
Just because two pieces of code look the same does not mean they are the same.
The most common architecture mistake is not too little abstraction. It is too much, too early. You see duplication, you extract a shared module, and six months later that module is a monster held together by special cases and boolean flags.
Dan Abramov gave a talk about this called The Wet Codebase. The core argument: the wrong abstraction is far more expensive than duplication. Once an abstraction exists, it creates inertia. Nobody wants to be the person who suggests copy-paste.
fn(args, deps) changes this calculus. It makes abstractions cheap to create, cheap to test, and cheap to undo.
When a function's deps grow too large, that can be a signal that some responsibility has stabilized into its own function — and that new function itself follows fn(args, deps). (This is basically SRP pressure showing up in your signature; see the SOLID post for that framing.)
Russian dolls. Each layer independently testable. Each layer reversible.
Hexagonal architecture often gets introduced with a lot of diagrams, vocabulary, and ceremony.
Ports. Adapters. Application core. Inbound and outbound boundaries.
That framing is useful, but it can also make the idea feel more abstract than it really is.
You may also hear this called "ports and adapters" — same idea, different name. The port is what a function needs; the adapter is what fulfils it.
A simpler way to understand it is this:
Hexagonal architecture is mostly about keeping business logic independent from delivery and infrastructure details.
One practical way to do that in plain TypeScript is this shape:
fn(args, deps);Where args is the input for this use case, and deps is the set of external capabilities it needs.
You can read that as: data in, capabilities in.
Read More →In plain TypeScript,
fn(args, deps)is a simple way to implement the core idea of hexagonal architecture without turning the pattern into ceremony.
A lot of developers hear "dependency injection" and immediately think of containers, decorators, registration APIs, lifecycle scopes, and framework magic.
That reaction is understandable.
But that association often leads people to overcomplicate a problem that has a much simpler starting point.
At its core, dependency injection just means this:
Pass collaborators in explicitly instead of reaching for them implicitly.
One of the simplest ways to do that in plain TypeScript is this shape (introduced in the series starting point: fn(args, deps)):
fn(args, deps)Where args is call-specific input and deps is the set of collaborators the function needs.
You can read that as: data in, capabilities in.
Read More →
fn(args, deps)is flexible enough to support composition, testing, and clean application wiring without forcing you into a DI framework.
Matt Pocock is once again on the money in his video “How To Make Codebases AI Agents Love”.
Here's why I agree with him.
Read More →AI coding agents produce code faster than you can review and understand it.
One pattern works in both new and legacy codebases because you can adopt it incrementally, without breaking callers.
For business logic, treat every function as having two inputs: data (args) and capabilities (deps).
Without a clear constraint, generated code becomes harder to reason about: dependencies disappear, side effects spread, composition gets messy. This is why visible structure is essential.
fn(args, deps) is that constraint
For existing code, start with:
functionName(args, deps = defaultDeps)Dependencies are explicit, not hidden.
There’s no framework and no package to install.
Read More →You have an Awaitly workflow: a few steps, some dependencies, typed results. It works. When someone asks "what does this do?" or you need to debug a run, you're left tracing through code.
What if you could see the same workflow as a diagram? awaitly-visualizer plugs into your workflow's events and turns them into that picture. For a checkout that runs fetchCart, validateCart, processPayment, then completeOrder, you get output like this:
┌── checkout ────┐
│ ✓ fetchCart │
│ ✓ validateCart│
│ ✓ processPayment
│ ✓ completeOrder
│ Completed │
└────────────────┘Same idea as Mermaid flowcharts: steps, order, success and failure. This post walks through adding it step by step. All of the code below lives in a test in the repo so you can run it yourself.
Read More →
We've all written this code:
const lambdaHandler = async () => {
try {
const db = await connectToDb();
const result = await errorHandler({ taskId, error }, { db });
return { statusCode: 200, body: { message: 'Success', task: result } };
} catch (error) {
return { statusCode: 500, body: { message: 'Error' } };
}
}That catch (error) swallows everything. Was it a "task not found"? A database connection failure? A permissions issue? Who knows.
Throwing exceptions for expected failures is like using GOTO. You lose the thread.
Awaitly fixes this by treating errors as data, not explosions. This guide teaches the patterns one concept at a time.
Read More →
Building a TypeScript library that is both maintainable and optimised for modern bundlers requires careful consideration of exporting functions, types, and other constructs from your modules.
With several strategies available, from wildcard re-exports to namespaced exports, explicitly named re-exports have emerged as the clear winner. This post explores the alternatives with examples based on an order management system.
We'll discuss the benefits of exporting types, how to organise multiple entry routes (such as in /src/orders and /src/users), and review the necessary TypeScript configuration options (such as verbatimModuleSyntax) and package.json tweaks. Additionally, we'll explain how this approach helps prevent circular dependency challenges by enforcing a clear dependency graph.
Having worked with many clients who struggled to maintain Javascript projects, Typescript was a no brainer when choosing what to use for the project I was leading.
In this post, I'll share what and how I managed the challenges of introducing and using Typescript.
Read More →Having experienced the pain of schema-first GraphQL projects, I wanted to use a different approach for a project I led at Cambridge University Press.
In this post, I'll describe what I used and how using code-first GraphQL worked out for us.
Read More →