@httpc/kit/dist/esm/events/handling.js

httpc toolbox for building function-based API with minimal code and end-to-end type safety

import { HttpCServerError, useContext } from "@httpc/server";
import { container as globalContainer } from "tsyringe";
import { KEY, RESOLVE } from "../di";
export function handle(event) {
    return (target, property) => {
        if (!event) {
            event = Reflect.getMetadata("design:paramtypes", target, property)?.[0];
        }
        const eventName = event && new event().$event_name;
        if (!eventName) {
            throw new Error("Invalid EventConstructor");
        }
        globalContainer.registerInstance(KEY("IInitialize"), {
            initialize() {
                const bus = RESOLVE(globalContainer, "IEventBus");
                bus.addListener(eventName, (payload) => {
                    let instance;
                    try {
                        instance = resolveInContext(target.constructor);
                    }
                    catch (err) {
                        getLogger(instance)?.error(err);
                        return;
                    }
                    execute(() => instance[property].call(instance, payload));
                });
                getLogger()?.verbose("Registered %s(%s.%s)", eventName, target.constructor.name, property);
            }
        });
    };
}
let logger;
function getLogger(service) {
    if (service && service.logger && typeof service.logger.log === "function") {
        return service.logger;
    }
    if (!logger) {
        try {
            logger = RESOLVE(globalContainer, "ILogService").createLogger("Handlers");
        }
        catch { }
    }
    return logger;
}
function resolveInContext(target) {
    const container = useContext("optional")?.container || globalContainer;
    if (!container) {
        throw new HttpCServerError("invalidState", "Missing container");
    }
    return container.resolve(target);
}
function execute(func) {
    async function wrap() {
        try {
            await func();
        }
        catch (err) {
            getLogger()?.error(err);
        }
    }
    return setImmediate(wrap);
}