@nmtjs/core 0.12.5 → 0.12.6

package/dist/injectables.js

@@ -1,12 +1,12 @@
-import { tryCaptureStackTrace } from "@nmtjs/common";
-import { kClassInjectable, kFactoryInjectable, kHookCollection, kInjectable, kLazyInjectable, kOptionalDependency, kValueInjectable } from "./constants.js";
+import { tryCaptureStackTrace, } from '@nmtjs/common';
+import { kClassInjectable, kFactoryInjectable, kHookCollection, kInjectable, kLazyInjectable, kOptionalDependency, kValueInjectable, } from "./constants.js";
 import { Scope } from "./enums.js";
 import { Hooks } from "./hooks.js";
 const ScopeStrictness = {
-	[Scope.Transient]: Number.NaN,
-	[Scope.Global]: 1,
-	[Scope.Connection]: 2,
-	[Scope.Call]: 3
+    [Scope.Transient]: Number.NaN, // this should make it always fail to compare with other scopes
+    [Scope.Global]: 1,
+    [Scope.Connection]: 2,
+    [Scope.Call]: 3,
 };
 export const isLazyInjectable = (injectable) => injectable[kLazyInjectable];
 export const isFactoryInjectable = (injectable) => injectable[kFactoryInjectable];
@@ -15,201 +15,216 @@ export const isValueInjectable = (injectable) => injectable[kValueInjectable];
 export const isInjectable = (injectable) => injectable[kInjectable];
 export const isOptionalInjectable = (injectable) => injectable[kOptionalDependency];
 export function getInjectableScope(injectable) {
-	let scope = injectable.scope;
-	const deps = injectable.dependencies;
-	for (const key in deps) {
-		const dependency = deps[key];
-		const injectable = getDepedencencyInjectable(dependency);
-		const dependencyScope = getInjectableScope(injectable);
-		if (dependencyScope !== Scope.Transient && scope !== Scope.Transient && compareScope(dependencyScope, ">", scope)) {
-			scope = dependencyScope;
-		}
-	}
-	return scope;
+    let scope = injectable.scope;
+    const deps = injectable.dependencies;
+    for (const key in deps) {
+        const dependency = deps[key];
+        const injectable = getDepedencencyInjectable(dependency);
+        const dependencyScope = getInjectableScope(injectable);
+        if (dependencyScope !== Scope.Transient &&
+            scope !== Scope.Transient &&
+            compareScope(dependencyScope, '>', scope)) {
+            scope = dependencyScope;
+        }
+    }
+    return scope;
 }
 export function getDepedencencyInjectable(dependency) {
-	if (kOptionalDependency in dependency) {
-		return dependency.injectable;
-	}
-	return dependency;
+    if (kOptionalDependency in dependency) {
+        return dependency.injectable;
+    }
+    return dependency;
 }
 export function createOptionalInjectable(injectable) {
-	return Object.freeze({
-		[kOptionalDependency]: true,
-		injectable
-	});
+    return Object.freeze({
+        [kOptionalDependency]: true,
+        injectable,
+    });
 }
 export function createLazyInjectable(scope = Scope.Global, label, stackTraceDepth = 0) {
-	return Object.freeze({
-		scope,
-		dependencies: {},
-		label,
-		stack: tryCaptureStackTrace(stackTraceDepth),
-		[kInjectable]: true,
-		[kLazyInjectable]: true
-	});
+    return Object.freeze({
+        scope,
+        dependencies: {},
+        label,
+        stack: tryCaptureStackTrace(stackTraceDepth),
+        [kInjectable]: true,
+        [kLazyInjectable]: true,
+    });
 }
 export function createValueInjectable(value, label, stackTraceDepth = 0) {
-	return Object.freeze({
-		value,
-		scope: Scope.Global,
-		dependencies: {},
-		label,
-		stack: tryCaptureStackTrace(stackTraceDepth),
-		[kInjectable]: true,
-		[kValueInjectable]: true
-	});
+    return Object.freeze({
+        value,
+        scope: Scope.Global,
+        dependencies: {},
+        label,
+        stack: tryCaptureStackTrace(stackTraceDepth),
+        [kInjectable]: true,
+        [kValueInjectable]: true,
+    });
 }
 export function createFactoryInjectable(paramsOrFactory, label, stackTraceDepth = 0) {
-	const isFactory = typeof paramsOrFactory === "function";
-	const params = isFactory ? { factory: paramsOrFactory } : paramsOrFactory;
-	const injectable = {
-		dependencies: params.dependencies ?? {},
-		scope: params.scope ?? Scope.Global,
-		factory: params.factory,
-		dispose: params.dispose,
-		pick: params.pick ?? ((instance) => instance),
-		label,
-		stack: tryCaptureStackTrace(stackTraceDepth),
-		[kInjectable]: true,
-		[kFactoryInjectable]: true
-	};
-	injectable.scope = resolveInjectableScope(typeof params.scope === "undefined", injectable);
-	return Object.freeze(injectable);
+    const isFactory = typeof paramsOrFactory === 'function';
+    const params = isFactory ? { factory: paramsOrFactory } : paramsOrFactory;
+    const injectable = {
+        dependencies: (params.dependencies ?? {}),
+        scope: (params.scope ?? Scope.Global),
+        factory: params.factory,
+        dispose: params.dispose,
+        pick: params.pick ?? ((instance) => instance),
+        label,
+        stack: tryCaptureStackTrace(stackTraceDepth),
+        [kInjectable]: true,
+        [kFactoryInjectable]: true,
+    };
+    injectable.scope = resolveInjectableScope(typeof params.scope === 'undefined', injectable);
+    return Object.freeze(injectable);
 }
 export const createClassInjectable = (dependencies = {}, scope, stackTraceDepth = 0) => {
-	const InjectableClass = class {
-		static dependencies = dependencies;
-		static scope = scope ?? Scope.Global;
-		static stack = tryCaptureStackTrace(stackTraceDepth + 2);
-		static [kInjectable] = true;
-		static [kClassInjectable] = true;
-		static get label() {
-			return this.name;
-		}
-		constructor($context) {
-			this.$context = $context;
-		}
-		async $onCreate() {}
-		async $onDispose() {}
-	};
-	InjectableClass.scope = resolveInjectableScope(typeof scope === "undefined", InjectableClass);
-	return InjectableClass;
+    const InjectableClass = class {
+        $context;
+        static dependencies = dependencies;
+        static scope = (scope ?? Scope.Global);
+        static stack = tryCaptureStackTrace(stackTraceDepth + 2);
+        static [kInjectable] = true;
+        static [kClassInjectable] = true;
+        static get label() {
+            // biome-ignore lint/complexity/noThisInStatic: ok
+            return this.name;
+        }
+        constructor($context) {
+            this.$context = $context;
+        }
+        async $onCreate() { }
+        async $onDispose() { }
+    };
+    InjectableClass.scope = resolveInjectableScope(typeof scope === 'undefined', InjectableClass);
+    return InjectableClass;
 };
 export function createExtendableClassInjectable(baseClass, dependencies = {}, scope, stackTraceDepth = 0) {
-	if (isClassInjectable(baseClass)) {
-		if (scope && compareScope(baseClass.scope, ">", scope)) {
-			throw new Error(`Invalid scope ${scope} for an extendable class injectable: base class have stricter scope - ${baseClass.scope}`);
-		} else {
-			scope = scope ?? baseClass.scope;
-		}
-		dependencies = Object.assign({}, baseClass.dependencies, dependencies);
-	}
-	const InjectableClass = class extends baseClass {
-		static dependencies = dependencies;
-		static scope = scope ?? Scope.Global;
-		static stack = tryCaptureStackTrace(stackTraceDepth);
-		static [kInjectable] = true;
-		static [kClassInjectable] = true;
-		static get label() {
-			return this.name;
-		}
-		$context;
-		constructor(...args) {
-			const [$context, ...baseClassArgs] = args;
-			if (isClassInjectable(baseClass)) {
-				super($context);
-			} else {
-				super(...baseClassArgs);
-			}
-			this.$context = $context;
-		}
-		async $onCreate() {
-			await super.$onCreate?.();
-		}
-		async $onDispose() {
-			await super.$onDispose?.();
-		}
-	};
-	InjectableClass.scope = resolveInjectableScope(typeof scope === "undefined", InjectableClass);
-	return InjectableClass;
+    if (isClassInjectable(baseClass)) {
+        if (scope && compareScope(baseClass.scope, '>', scope)) {
+            throw new Error(`Invalid scope ${scope} for an extendable class injectable: base class have stricter scope - ${baseClass.scope}`);
+        }
+        else {
+            scope = scope ?? baseClass.scope;
+        }
+        dependencies = Object.assign({}, baseClass.dependencies, dependencies);
+    }
+    const InjectableClass = class extends baseClass {
+        static dependencies = dependencies;
+        static scope = (scope ?? Scope.Global);
+        static stack = tryCaptureStackTrace(stackTraceDepth);
+        static [kInjectable] = true;
+        static [kClassInjectable] = true;
+        static get label() {
+            // biome-ignore lint/complexity/noThisInStatic: ok
+            return this.name;
+        }
+        $context;
+        constructor(...args) {
+            const [$context, ...baseClassArgs] = args;
+            if (isClassInjectable(baseClass)) {
+                super($context);
+            }
+            else {
+                super(...baseClassArgs);
+            }
+            this.$context = $context;
+        }
+        async $onCreate() {
+            await super.$onCreate?.();
+        }
+        async $onDispose() {
+            await super.$onDispose?.();
+        }
+    };
+    InjectableClass.scope = resolveInjectableScope(typeof scope === 'undefined', InjectableClass);
+    // @ts-expect-error
+    return InjectableClass;
 }
 export function substitute(injectable, substitution, stackTraceDepth = 0) {
-	const dependencies = { ...injectable.dependencies };
-	const depth = stackTraceDepth + 1;
-	for (const key in substitution) {
-		const value = substitution[key];
-		if (key in dependencies) {
-			const original = dependencies[key];
-			if (isInjectable(value)) {
-				dependencies[key] = value;
-			} else if (isClassInjectable(original) || isFactoryInjectable(original)) {
-				dependencies[key] = substitute(original, value, depth);
-			}
-		}
-	}
-	if (isClassInjectable(injectable)) {
-		return createExtendableClassInjectable(injectable, dependencies, injectable.scope, depth);
-	} else if (isFactoryInjectable(injectable)) {
-		return createFactoryInjectable({
-			...injectable,
-			dependencies
-		}, injectable.label, depth);
-	}
-	throw new Error("Invalid injectable type");
+    const dependencies = { ...injectable.dependencies };
+    const depth = stackTraceDepth + 1;
+    for (const key in substitution) {
+        const value = substitution[key];
+        if (key in dependencies) {
+            const original = dependencies[key];
+            if (isInjectable(value)) {
+                dependencies[key] = value;
+            }
+            else if (isClassInjectable(original) || isFactoryInjectable(original)) {
+                dependencies[key] = substitute(original, value, depth);
+            }
+        }
+    }
+    if (isClassInjectable(injectable)) {
+        // @ts-expect-error
+        return createExtendableClassInjectable(injectable, dependencies, injectable.scope, depth);
+    }
+    else if (isFactoryInjectable(injectable)) {
+        // @ts-expect-error
+        return createFactoryInjectable({
+            ...injectable,
+            dependencies,
+        }, injectable.label, depth);
+    }
+    throw new Error('Invalid injectable type');
 }
 export function compareScope(left, operator, right) {
-	const leftScope = ScopeStrictness[left];
-	const rightScope = ScopeStrictness[right];
-	switch (operator) {
-		case "=": return leftScope === rightScope;
-		case "!=": return leftScope !== rightScope;
-		case ">": return leftScope > rightScope;
-		case "<": return leftScope < rightScope;
-		case ">=": return leftScope >= rightScope;
-		case "<=": return leftScope <= rightScope;
-		default: throw new Error("Invalid operator");
-	}
+    const leftScope = ScopeStrictness[left];
+    const rightScope = ScopeStrictness[right];
+    switch (operator) {
+        case '=':
+            return leftScope === rightScope;
+        case '!=':
+            return leftScope !== rightScope;
+        case '>':
+            return leftScope > rightScope;
+        case '<':
+            return leftScope < rightScope;
+        case '>=':
+            return leftScope >= rightScope;
+        case '<=':
+            return leftScope <= rightScope;
+        default:
+            throw new Error('Invalid operator');
+    }
 }
-const logger = createLazyInjectable(Scope.Global, "Logger");
-const registry = createLazyInjectable(Scope.Global, "Registry");
-const inject = createLazyInjectable(Scope.Global, "Inject function");
-const dispose = createLazyInjectable(Scope.Global, "Dispose function");
+const logger = createLazyInjectable(Scope.Global, 'Logger');
+const registry = createLazyInjectable(Scope.Global, 'Registry');
+const inject = createLazyInjectable(Scope.Global, 'Inject function');
+const dispose = createLazyInjectable(Scope.Global, 'Dispose function');
 const hook = createFactoryInjectable({
-	scope: Scope.Transient,
-	dependencies: { registry },
-	factory: ({ registry }) => {
-		const hooks = new Hooks();
-		const on = (name, callback) => {
-			hooks.add(name, callback);
-			return registry.hooks.add(name, callback);
-		};
-		return {
-			hooks,
-			on
-		};
-	},
-	pick: ({ on }) => on,
-	dispose: ({ hooks }, { registry }) => {
-		for (const [hook, callbacks] of hooks[kHookCollection].entries()) {
-			for (const callback of callbacks) {
-				registry.hooks.remove(hook, callback);
-			}
-		}
-		hooks.clear();
-	}
+    scope: Scope.Transient,
+    dependencies: { registry },
+    factory: ({ registry }) => {
+        const hooks = new Hooks();
+        const on = (name, callback) => {
+            hooks.add(name, callback);
+            return registry.hooks.add(name, callback);
+        };
+        return { hooks, on };
+    },
+    pick: ({ on }) => on,
+    dispose: ({ hooks }, { registry }) => {
+        for (const [hook, callbacks] of hooks[kHookCollection].entries()) {
+            for (const callback of callbacks) {
+                registry.hooks.remove(hook, callback);
+            }
+        }
+        hooks.clear();
+    },
 });
 function resolveInjectableScope(isDefaultScope, injectable) {
-	const actualScope = getInjectableScope(injectable);
-	if (!isDefaultScope && compareScope(actualScope, ">", injectable.scope)) throw new Error(`Invalid scope ${injectable.scope} for an injectable: dependencies have stricter scope - ${actualScope}`);
-	return actualScope;
+    const actualScope = getInjectableScope(injectable);
+    if (!isDefaultScope && compareScope(actualScope, '>', injectable.scope))
+        throw new Error(`Invalid scope ${injectable.scope} for an injectable: dependencies have stricter scope - ${actualScope}`);
+    return actualScope;
 }
 export const CoreInjectables = {
-	logger,
-	registry,
-	inject,
-	dispose,
-	hook
+    logger,
+    registry,
+    inject,
+    dispose,
+    hook,
 };
-
-//# sourceMappingURL=injectables.js.map

package/dist/logger.d.ts

@@ -0,0 +1,9 @@
+import { type DestinationStream, type Level, type Logger as PinoLogger, pino, type StreamEntry } from 'pino';
+export type { StreamEntry } from 'pino';
+export type Logger = PinoLogger;
+export type LoggingOptions = {
+    destinations?: Array<DestinationStream | StreamEntry<Level>>;
+    pinoOptions?: any;
+};
+export declare const createLogger: (options: LoggingOptions | undefined, $group: string) => pino.Logger<never, boolean>;
+export declare const createConsolePrettyDestination: (level: Level, sync?: boolean) => StreamEntry;

package/dist/logger.js

@@ -1,70 +1,66 @@
-import { threadId } from "node:worker_threads";
-import { pino, stdTimeFunctions } from "pino";
-import { build as pretty } from "pino-pretty";
+import { threadId } from 'node:worker_threads';
+import { pino, stdTimeFunctions, } from 'pino';
+import { build as pretty } from 'pino-pretty';
+// TODO: use node:util inspect
 const bg = (value, color) => `\x1b[${color}m${value}\x1b[0m`;
 const fg = (value, color) => `\x1b[38;5;${color}m${value}\x1b[0m`;
 const levelColors = {
-	10: 100,
-	20: 102,
-	30: 106,
-	40: 104,
-	50: 101,
-	60: 105,
-	[Number.POSITIVE_INFINITY]: 0
+    10: 100,
+    20: 102,
+    30: 106,
+    40: 104,
+    50: 101,
+    60: 105,
+    [Number.POSITIVE_INFINITY]: 0,
 };
 const messageColors = {
-	10: 0,
-	20: 2,
-	30: 6,
-	40: 4,
-	50: 1,
-	60: 5,
-	[Number.POSITIVE_INFINITY]: 0
+    10: 0,
+    20: 2,
+    30: 6,
+    40: 4,
+    50: 1,
+    60: 5,
+    [Number.POSITIVE_INFINITY]: 0,
 };
 const levelLabels = {
-	10: " TRACE ",
-	20: " DEBUG ",
-	30: " INFO  ",
-	40: " WARN  ",
-	50: " ERROR ",
-	60: " FATAL ",
-	[Number.POSITIVE_INFINITY]: "SILENT"
+    10: ' TRACE ',
+    20: ' DEBUG ',
+    30: ' INFO  ',
+    40: ' WARN  ',
+    50: ' ERROR ',
+    60: ' FATAL ',
+    [Number.POSITIVE_INFINITY]: 'SILENT',
 };
 export const createLogger = (options = {}, $group) => {
-	let { destinations, pinoOptions } = options;
-	if (!destinations || !destinations?.length) {
-		destinations = [createConsolePrettyDestination("info")];
-	}
-	const lowestLevelValue = destinations.reduce((acc, destination) => Math.min(acc, "stream" in destination ? pino.levels.values[destination.level] : Number.POSITIVE_INFINITY), Number.POSITIVE_INFINITY);
-	const level = pino.levels.labels[lowestLevelValue];
-	return pino({
-		timestamp: stdTimeFunctions.isoTime,
-		...pinoOptions,
-		level
-	}, pino.multistream(destinations)).child({
-		$group,
-		$threadId: threadId
-	});
+    let { destinations, pinoOptions } = options;
+    if (!destinations || !destinations?.length) {
+        destinations = [createConsolePrettyDestination('info')];
+    }
+    const lowestLevelValue = destinations.reduce((acc, destination) => Math.min(acc, 'stream' in destination
+        ? pino.levels.values[destination.level]
+        : Number.POSITIVE_INFINITY), Number.POSITIVE_INFINITY);
+    const level = pino.levels.labels[lowestLevelValue];
+    return pino({
+        timestamp: stdTimeFunctions.isoTime,
+        ...pinoOptions,
+        level,
+    }, pino.multistream(destinations)).child({ $group, $threadId: threadId });
 };
 export const createConsolePrettyDestination = (level, sync = true) => ({
-	level,
-	stream: pretty({
-		colorize: true,
-		ignore: "hostname,$group,$threadId",
-		errorLikeObjectKeys: [
-			"err",
-			"error",
-			"cause"
-		],
-		messageFormat: (log, messageKey) => {
-			const group = fg(`[${log.$group}]`, 11);
-			const msg = fg(log[messageKey], messageColors[log.level]);
-			const thread = fg(`(Thread-${log.$threadId})`, 89);
-			return `\x1b[0m${thread} ${group} ${msg}`;
-		},
-		customPrettifiers: { level: (level) => bg(levelLabels[level], levelColors[level]) },
-		sync
-	})
+    level,
+    stream: pretty({
+        colorize: true,
+        ignore: 'hostname,$group,$threadId',
+        errorLikeObjectKeys: ['err', 'error', 'cause'],
+        messageFormat: (log, messageKey) => {
+            const group = fg(`[${log.$group}]`, 11);
+            const msg = fg(log[messageKey], messageColors[log.level]);
+            const thread = fg(`(Thread-${log.$threadId})`, 89);
+            return `\x1b[0m${thread} ${group} ${msg}`;
+        },
+        customPrettifiers: {
+            level: (level) => bg(levelLabels[level], levelColors[level]),
+        },
+        sync,
+    }),
 });
-
-//# sourceMappingURL=logger.js.map

package/dist/metadata.d.ts

@@ -0,0 +1,13 @@
+import { kMetadata } from './constants.ts';
+export type Metadata<T = any> = {
+    key: MetadataKey<T>;
+    value: T;
+};
+export type MetadataKey<T = any> = {
+    [kMetadata]: string;
+    as(value: T): Metadata<T>;
+};
+export declare const createMetadataKey: <T>(key: string) => MetadataKey<T>;
+export declare class MetadataStore extends Map<MetadataKey, Metadata> {
+    get<T>(key: MetadataKey<T>): T | undefined;
+}

package/dist/metadata.js

@@ -1,20 +1,15 @@
 import { kMetadata } from "./constants.js";
 export const createMetadataKey = (key) => {
-	const metadataKey = {
-		[kMetadata]: key,
-		as(value) {
-			return {
-				key: metadataKey,
-				value
-			};
-		}
-	};
-	return metadataKey;
+    const metadataKey = {
+        [kMetadata]: key,
+        as(value) {
+            return { key: metadataKey, value };
+        },
+    };
+    return metadataKey;
 };
 export class MetadataStore extends Map {
-	get(key) {
-		return super.get(key);
-	}
+    get(key) {
+        return super.get(key);
+    }
 }
-
-//# sourceMappingURL=metadata.js.map

package/dist/plugin.d.ts

@@ -0,0 +1,12 @@
+import type { Async } from '@nmtjs/common';
+import { kPlugin } from './constants.ts';
+import type { PluginContext } from './types.ts';
+export interface BasePlugin<Type = any, Options = unknown, Context extends PluginContext = PluginContext> {
+    name: string;
+    init: (context: Context, options: Options) => Async<Type>;
+}
+export interface Plugin<Type = void, Options = unknown, Context extends PluginContext = PluginContext> extends BasePlugin<Type, Options, Context> {
+    [kPlugin]: any;
+}
+export declare const createPlugin: <Options = unknown, Type = void>(name: string, init: Plugin<Type, Options>["init"]) => Plugin<Type, Options>;
+export declare const isPlugin: (value: any) => value is Plugin;

package/dist/plugin.js

@@ -1,9 +1,3 @@
 import { kPlugin } from "./constants.js";
-export const createPlugin = (name, init) => ({
-	name,
-	init,
-	[kPlugin]: true
-});
+export const createPlugin = (name, init) => ({ name, init, [kPlugin]: true });
 export const isPlugin = (value) => kPlugin in value;
-
-//# sourceMappingURL=plugin.js.map

package/dist/registry.d.ts

@@ -0,0 +1,19 @@
+import { type Hook, Scope } from './enums.ts';
+import { Hooks, type HookType } from './hooks.ts';
+import { type AnyInjectable, type Dependant } from './injectables.ts';
+import type { Logger } from './logger.ts';
+export declare class Registry {
+    protected readonly application: {
+        logger: Logger;
+    };
+    readonly hooks: Hooks;
+    constructor(application: {
+        logger: Logger;
+    });
+    registerHooks<T extends Hooks>(hooks: T): void;
+    registerHook<T extends Hook>(name: T, callback: HookType[T]): void;
+    getDependants(): Generator<Dependant>;
+    clear(): void;
+}
+export declare const scopeErrorMessage: (name: any, scope?: Scope) => string;
+export declare function hasInvalidScopeDeps(injectables: AnyInjectable[], scope?: Scope): boolean;