wooks/dist/index.mjs

wooks

import { ProstoLogger, coloredConsole, createConsoleTransort } from "@prostojs/logger";
import { ProstoRouter } from "@prostojs/router";
import { getContextInjector, useAsyncEventContext, useEventId, useEventLogger, useRouteParams } from "@wooksjs/event-core";

//#region packages/wooks/src/wooks.ts
function getDefaultLogger(topic) {
	return new ProstoLogger({
		level: 4,
		transports: [createConsoleTransort({ format: coloredConsole })]
	}, topic);
}
var Wooks = class {
	router;
	logger;
	constructor(opts) {
		this.router = new ProstoRouter({
			silent: true,
			...opts?.router
		});
		this.logger = opts?.logger || getDefaultLogger(`[wooks]`);
	}
	getRouter() {
		return this.router;
	}
	getLogger(topic) {
		if (this.logger instanceof ProstoLogger) return this.logger.createTopic(topic);
		return this.logger;
	}
	getLoggerOptions() {
		if (this.logger instanceof ProstoLogger) return this.logger.getOptions();
		return {};
	}
	lookup(method, path) {
		const found = this.getRouter().lookup(method, path || "");
		useAsyncEventContext().store("routeParams").value = found?.ctx?.params || {};
		if (found?.route?.handlers.length) getContextInjector().hook(method, "Handler:routed", found.route.path);
		else getContextInjector().hook(method, "Handler:not_found");
		return {
			handlers: found?.route?.handlers || null,
			segments: found?.route?.segments || null,
			firstStatic: found?.route?.firstStatic || null,
			path: found?.route?.path || null
		};
	}
	on(method, path, handler) {
		return this.router.on(method, path, handler);
	}
};
let gWooks;
/**
* Clear global wooks instance
*
* (useful for tests or dev-mode)
*/
function clearGlobalWooks() {
	gWooks = void 0;
}
/**
* Creates global wooks singleton instance to share across adapters
* @param logger
* @param routerOpts
* @returns
*/
function getGlobalWooks(logger, routerOpts) {
	if (!gWooks) gWooks = new Wooks({
		logger,
		router: routerOpts
	});
	return gWooks;
}
var WooksAdapterBase = class WooksAdapterBase {
	wooks;
	constructor(wooks, logger, routerOpts) {
		if (wooks && wooks instanceof WooksAdapterBase) this.wooks = wooks.getWooks();
		else if (wooks && wooks instanceof Wooks) this.wooks = wooks;
		else this.wooks = getGlobalWooks(logger, routerOpts);
	}
	getWooks() {
		return this.wooks;
	}
	/**
	* Get logger instance for application logs
	* ```js
	* const app = createHttpApp()
	* const logger = app.getLogger('[app-logger]')
	* logger.log('My App log message')
	* ```
	* @param topic topic for logger
	* @returns logger instance
	*/
	getLogger(topic) {
		return this.getWooks().getLogger(topic);
	}
	getLoggerOptions() {
		return this.getWooks().getLoggerOptions();
	}
	mergeEventOptions(opts) {
		return {
			...opts,
			eventLogger: {
				...this.getLoggerOptions(),
				...opts?.eventLogger
			}
		};
	}
	on(method, path, handler) {
		return this.wooks.on(method, path, handler);
	}
};

//#endregion
export { Wooks, WooksAdapterBase, clearGlobalWooks, getGlobalWooks, useEventId, useEventLogger, useRouteParams };