showcase: di-wise hono middleware

[ArjixWasTaken]

I wrote a simple hono.js middleware to integrate di-wise into your routing!

import { createMiddleware } from 'hono/factory';

import { Token } from 'di-wise';

// your custom global container
import { container } from '@/container';

type ExtractType<T> = T extends Token<infer U> ? U : never;

export const inject = <T, K extends Record<string, Token<T>>>(tokens: K) => {
    return createMiddleware<{ Variables: { [key in keyof K]: ExtractType<K[key]> } }>(async (ctx, next) => {
        for (const [key, token] of Object.entries(tokens)) {
            // @ts-ignore
            ctx.set(key, container.resolve(token));
        }

        return next();
    });
}

usage

import { Hono } from 'hono';

import { tokens } from '@/container';
import { inject } from '@/middleware';

const app = new Hono();

app.get('/login',
    inject({ userRepo: tokens.UserRepository }),
    async (ctx) => {
        ctx.var.userRepo.findByUsername(...)
    }
);

// or you can make it a global middleware!
app.use(inject({ userRepo: tokens.UserRepository }));

---

If you have any suggestions/improvements to make, please share them!

[ArjixWasTaken]

honestly, resolving multiple tokens in batch like this would be nice even outside of hono.js

e.g.

const { userRepo } = container.resolve({ userRepo: tokens.UserRepository });

that way we can have a lot of injections, w/o having a lot of container.resolves