@nmtjs/core 0.14.5 → 0.15.0-beta.2

package/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2024 Denis Ilchyshyn
+Copyright (c) 2025 Denys Ilchyshyn
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/README.md

@@ -6,4 +6,4 @@
 - binary data streaming and event subscriptions
 - contract-based API
 - end-to-end type safety
-- CPU-intensive task execution on separate workers
+- CPU-intensive task execution on separate workers

package/dist/constants.js

@@ -3,10 +3,7 @@ export const kInjectable = Symbol.for('neemata:InjectableKey');
 export const kLazyInjectable = Symbol.for('neemata:LazyInjectableKey');
 export const kValueInjectable = Symbol.for('neemata:ValueInjectableKey');
 export const kFactoryInjectable = Symbol.for('neemata:FactoryInjectableKey');
-export const kClassInjectable = Symbol.for('neemata:ClassInjectableKey');
-export const kClassInjectableCreate = Symbol.for('neemata:ClassInjectableCreateKey');
-export const kClassInjectableDispose = Symbol.for('neemata:ClassInjectableDisposeKey');
 export const kProvider = Symbol.for('neemata:ProviderKey');
-export const kHookCollection = Symbol.for('neemata:HookCollectionKey');
 export const kPlugin = Symbol.for('neemata:PluginKey');
 export const kMetadata = Symbol.for('neemata:MetadataKey');
+export const kHook = Symbol.for('neemata:HookKey');

package/dist/container.js

@@ -1,20 +1,18 @@
 import assert from 'node:assert';
 import { tryCaptureStackTrace } from '@nmtjs/common';
-import { kClassInjectableCreate, kClassInjectableDispose } from "./constants.js";
 import { Scope } from "./enums.js";
-import { CoreInjectables, compareScope, createExtendableClassInjectable, createValueInjectable, getDepedencencyInjectable, isClassInjectable, isFactoryInjectable, isInjectable, isLazyInjectable, isOptionalInjectable, isValueInjectable, } from "./injectables.js";
+import { CoreInjectables, compareScope, createValueInjectable, getDepedencencyInjectable, isFactoryInjectable, isInjectable, isLazyInjectable, isOptionalInjectable, isValueInjectable, provide, } from "./injectables.js";
 export class Container {
-    application;
+    runtime;
     scope;
     parent;
     instances = new Map();
     resolvers = new Map();
     injectables = new Set();
     dependants = new Map();
-    // private readonly transients = new Map<any, any>()
     disposing = false;
-    constructor(application, scope = Scope.Global, parent) {
-        this.application = application;
+    constructor(runtime, scope = Scope.Global, parent) {
+        this.runtime = runtime;
         this.scope = scope;
         this.parent = parent;
         if (scope === Scope.Transient) {
@@ -22,38 +20,56 @@ export class Container {
         }
         this.provide(CoreInjectables.inject, this.createInjectFunction());
         this.provide(CoreInjectables.dispose, this.createDisposeFunction());
-        this.provide(CoreInjectables.registry, application.registry);
     }
-    async load() {
+    async initialize(injectables) {
+        const measurements = [];
         const traverse = (dependencies) => {
             for (const key in dependencies) {
                 const dependency = dependencies[key];
                 const injectable = getDepedencencyInjectable(dependency);
-                this.injectables.add(injectable);
+                if (injectable.scope === this.scope) {
+                    this.injectables.add(injectable);
+                }
                 traverse(injectable.dependencies);
             }
         };
-        for (const dependant of this.application.registry.getDependants()) {
+        for (const dependant of injectables) {
             traverse(dependant.dependencies);
         }
-        const injectables = Array.from(this.findCurrentScopeInjectables());
-        await Promise.all(injectables.map((injectable) => this.resolve(injectable)));
+        await Promise.all([...this.injectables].map((injectable) => this.resolve(injectable, measurements)));
+        return measurements;
     }
     fork(scope) {
-        return new Container(this.application, scope, this);
+        return new Container(this.runtime, scope, this);
+    }
+    find(scope) {
+        if (this.scope === scope) {
+            return this;
+        }
+        else {
+            return this.parent?.find(scope);
+        }
+    }
+    async [Symbol.asyncDispose]() {
+        await this.dispose();
     }
     async dispose() {
-        this.application.logger.trace('Disposing [%s] scope context...', this.scope);
+        this.runtime.logger.trace('Disposing [%s] scope context...', this.scope);
         // Prevent new resolutions during disposal
         this.disposing = true;
         // Get proper disposal order using topological sort
         const disposalOrder = this.getDisposalOrder();
-        // Dispose in the correct order
-        for (const injectable of disposalOrder) {
-            if (this.instances.has(injectable)) {
-                await this.disposeInjectableInstances(injectable);
+        try {
+            // Dispose in the correct order
+            for (const injectable of disposalOrder) {
+                if (this.instances.has(injectable)) {
+                    await this.disposeInjectableInstances(injectable);
+                }
             }
         }
+        catch (error) {
+            this.runtime.logger.fatal({ error }, 'Potential memory leak: error during container disposal');
+        }
         this.instances.clear();
         this.injectables.clear();
         this.resolvers.clear();
@@ -79,44 +95,67 @@ export class Container {
         }
         throw new Error('No instance found');
     }
-    resolve(injectable) {
-        return this.resolveInjectable(injectable);
+    resolve(injectable, measurements) {
+        return this.resolveInjectable(injectable, undefined, undefined, measurements);
     }
     async createContext(dependencies) {
         return this.createInjectableContext(dependencies);
     }
-    async createInjectableContext(dependencies, dependant) {
+    async provide(injectable, ...[value]) {
+        const injections = Array.isArray(injectable)
+            ? injectable
+            : [provide(injectable, value)];
+        await Promise.all(injections.map(async ({ token, value }) => {
+            if (compareScope(token.scope, '>', this.scope)) {
+                // TODO: more informative error
+                throw new Error('Invalid scope');
+            }
+            const _value = isInjectable(value) ? await this.resolve(value) : value;
+            this.instances.set(token, [
+                { private: _value, public: _value, context: undefined },
+            ]);
+        }));
+    }
+    satisfies(injectable) {
+        return compareScope(injectable.scope, '<=', this.scope);
+    }
+    async disposeInjectableInstances(injectable) {
+        try {
+            if (this.instances.has(injectable)) {
+                const wrappers = this.instances.get(injectable);
+                await Promise.all(wrappers.map((wrapper) => this.disposeInjectableInstance(injectable, wrapper.private, wrapper.context)));
+            }
+        }
+        catch (cause) {
+            const error = new Error('Injectable disposal error. Potential memory leak', { cause });
+            this.runtime.logger.error(error);
+        }
+        finally {
+            this.instances.delete(injectable);
+        }
+    }
+    async disposeInjectableInstance(injectable, instance, context) {
+        if (isFactoryInjectable(injectable)) {
+            const { dispose } = injectable;
+            if (dispose)
+                await dispose(instance, context);
+        }
+    }
+    async createInjectableContext(dependencies, dependant, measurements) {
         const injections = {};
         const deps = Object.entries(dependencies);
         const resolvers = Array(deps.length);
         for (let i = 0; i < deps.length; i++) {
             const [key, dependency] = deps[i];
+            const isOptional = isOptionalInjectable(dependency);
             const injectable = getDepedencencyInjectable(dependency);
-            const resolver = this.resolveInjectable(injectable, dependant);
+            const resolver = this.resolveInjectable(injectable, dependant, isOptional, measurements);
             resolvers[i] = resolver.then((value) => (injections[key] = value));
         }
         await Promise.all(resolvers);
         return Object.freeze(injections);
     }
-    async provide(injectable, instance) {
-        if (compareScope(injectable.scope, '>', this.scope)) {
-            throw new Error('Invalid scope'); // TODO: more informative error
-        }
-        this.instances.set(injectable, [
-            { private: instance, public: instance, context: undefined },
-        ]);
-    }
-    satisfies(injectable) {
-        return compareScope(injectable.scope, '<=', this.scope);
-    }
-    *findCurrentScopeInjectables() {
-        for (const injectable of this.injectables) {
-            if (injectable.scope === this.scope) {
-                yield injectable;
-            }
-        }
-    }
-    resolveInjectable(injectable, dependant) {
+    resolveInjectable(injectable, dependant, isOptional, measurements) {
         if (this.disposing) {
             return Promise.reject(new Error('Cannot resolve during disposal'));
         }
@@ -130,7 +169,7 @@ export class Container {
         else if (this.parent?.contains(injectable) ||
             (this.parent?.satisfies(injectable) &&
                 compareScope(this.parent.scope, '<', this.scope))) {
-            return this.parent.resolveInjectable(injectable, dependant);
+            return this.parent.resolveInjectable(injectable, dependant, undefined, measurements);
         }
         else {
             const { stack, label } = injectable;
@@ -151,14 +190,20 @@ export class Container {
             else {
                 const isLazy = isLazyInjectable(injectable);
                 if (isLazy) {
-                    const isOptional = isOptionalInjectable(injectable);
                     if (isOptional)
                         return Promise.resolve(undefined);
                     return Promise.reject(new Error(`No instance provided for ${label || 'an'} injectable:\n${stack}`));
                 }
                 else {
-                    const resolution = this.createResolution(injectable).finally(() => {
+                    const measure = measurements
+                        ? performance.measure(injectable.label || injectable.stack || '')
+                        : null;
+                    const resolution = this.createResolution(injectable, measurements).finally(() => {
                         this.resolvers.delete(injectable);
+                        // biome-ignore lint: false
+                        // @ts-ignore
+                        if (measurements && measure)
+                            measurements.push(measure);
                     });
                     if (injectable.scope !== Scope.Transient) {
                         this.resolvers.set(injectable, resolution);
@@ -168,9 +213,9 @@ export class Container {
             }
         }
     }
-    async createResolution(injectable) {
+    async createResolution(injectable, measurements) {
         const { dependencies } = injectable;
-        const context = await this.createInjectableContext(dependencies, injectable);
+        const context = await this.createInjectableContext(dependencies, injectable, measurements);
         const wrapper = {
             private: null,
             public: null,
@@ -180,12 +225,6 @@ export class Container {
             wrapper.private = await Promise.resolve(injectable.factory(wrapper.context));
             wrapper.public = injectable.pick(wrapper.private);
         }
-        else if (isClassInjectable(injectable)) {
-            const instance = new injectable(context);
-            wrapper.private = instance;
-            wrapper.public = wrapper.private;
-            await instance[kClassInjectableCreate]?.call(instance);
-        }
         else {
             throw new Error('Invalid injectable type');
         }
@@ -198,7 +237,10 @@ export class Container {
         return wrapper.public;
     }
     createInjectFunction() {
-        const inject = (injectable, context) => {
+        const inject = (injectable, context, scope = this.scope) => {
+            const container = this.find(scope);
+            if (!container)
+                throw new Error('No container found for the specified scope');
             const dependencies = { ...injectable.dependencies };
             for (const key in context) {
                 const dep = context[key];
@@ -209,27 +251,29 @@ export class Container {
                     dependencies[key] = createValueInjectable(dep);
                 }
             }
-            const newInjectable = isClassInjectable(injectable)
-                ? createExtendableClassInjectable(injectable, dependencies, Scope.Transient, 1)
-                : {
-                    ...injectable,
-                    dependencies,
-                    scope: Scope.Transient,
-                    stack: tryCaptureStackTrace(1),
-                };
-            return this.resolve(newInjectable);
+            const newInjectable = {
+                ...injectable,
+                dependencies,
+                scope: Scope.Transient,
+                stack: tryCaptureStackTrace(1),
+            };
+            return container.resolve(newInjectable);
         };
-        const explicit = async (injectable, context) => {
+        const explicit = async (injectable, context, scope = this.scope) => {
             if ('asyncDispose' in Symbol === false) {
                 throw new Error('Symbol.asyncDispose is not supported in this environment');
             }
+            const container = this.find(scope);
+            if (!container)
+                throw new Error('No container found for the specified scope');
             const instance = await inject(injectable, context);
-            const dispose = this.createDisposeFunction();
-            return Object.assign(instance, {
+            const dispose = container.createDisposeFunction();
+            return {
+                instance,
                 [Symbol.asyncDispose]: async () => {
                     await dispose(injectable, instance);
                 },
-            });
+            };
         };
         return Object.assign(inject, { explicit });
     }
@@ -281,29 +325,4 @@ export class Container {
         }
         return result;
     }
-    async disposeInjectableInstances(injectable) {
-        try {
-            if (this.instances.has(injectable)) {
-                const wrappers = this.instances.get(injectable);
-                await Promise.all(wrappers.map((wrapper) => this.disposeInjectableInstance(injectable, wrapper.private, wrapper.context)));
-            }
-        }
-        catch (cause) {
-            const error = new Error('Injectable disposal error. Potential memory leak', { cause });
-            this.application.logger.error(error);
-        }
-        finally {
-            this.instances.delete(injectable);
-        }
-    }
-    async disposeInjectableInstance(injectable, instance, context) {
-        if (isFactoryInjectable(injectable)) {
-            const { dispose } = injectable;
-            if (dispose)
-                await dispose(instance, context);
-        }
-        else if (isClassInjectable(injectable)) {
-            await instance[kClassInjectableDispose]?.();
-        }
-    }
 }

package/dist/enums.js

@@ -5,16 +5,3 @@ export var Scope;
     Scope["Call"] = "Call";
     Scope["Transient"] = "Transient";
 })(Scope || (Scope = {}));
-export var Hook;
-(function (Hook) {
-    Hook["BeforeInitialize"] = "BeforeInitialize";
-    Hook["AfterInitialize"] = "AfterInitialize";
-    Hook["BeforeStart"] = "BeforeStart";
-    Hook["AfterStart"] = "AfterStart";
-    Hook["BeforeStop"] = "BeforeStop";
-    Hook["AfterStop"] = "AfterStop";
-    Hook["BeforeTerminate"] = "BeforeTerminate";
-    Hook["AfterTerminate"] = "AfterTerminate";
-    Hook["OnConnect"] = "OnConnect";
-    Hook["OnDisconnect"] = "OnDisconnect";
-})(Hook || (Hook = {}));

package/dist/hooks.js

@@ -1,43 +1,11 @@
-import { kHookCollection } from "./constants.js";
-export class Hooks {
-    static merge(from, to) {
-        for (const [name, callbacks] of from[kHookCollection]) {
-            for (const callback of callbacks) {
-                to.add(name, callback);
-            }
-        }
-    }
-    [kHookCollection] = new Map();
-    add(name, callback) {
-        let hooks = this[kHookCollection].get(name);
-        if (!hooks)
-            this[kHookCollection].set(name, (hooks = new Set()));
-        hooks.add(callback);
-        return () => this.remove(name, callback);
-    }
-    remove(name, callback) {
-        const hooks = this[kHookCollection].get(name);
-        if (hooks)
-            hooks.delete(callback);
-    }
-    async call(name, options, ...args) {
-        const { concurrent = true, reverse = false } = options ?? {};
-        const hooks = this[kHookCollection].get(name);
-        if (!hooks)
-            return;
-        const hooksArr = Array.from(hooks);
-        if (concurrent) {
-            await Promise.all(hooksArr.map((hook) => hook(...args)));
-        }
-        else {
-            if (reverse)
-                hooksArr.reverse();
-            for (const hook of hooksArr)
-                await hook(...args);
-        }
-    }
-    clear() {
-        this[kHookCollection].clear();
+import { Hookable } from 'hookable';
+export class Hooks extends Hookable {
+    _;
+    createSignal(hook) {
+        const controller = new AbortController();
+        const unregister = this.hookOnce(String(hook), 
+        //@ts-expect-error
+        () => controller.abort());
+        return { controller, signal: controller.signal, unregister };
     }
 }
-export const createErrForHook = (hook) => `Error during [${hook}] hook`;

package/dist/index.js

@@ -9,6 +9,5 @@ export * from "./injectables.js";
 export * from "./logger.js";
 export * from "./metadata.js";
 export * from "./plugin.js";
-export * from "./registry.js";
 export * from "./types.js";
 export * from "./utils/index.js";

package/dist/injectables.js

@@ -1,7 +1,6 @@
 import { tryCaptureStackTrace } from '@nmtjs/common';
-import { kClassInjectable, kClassInjectableCreate, kClassInjectableDispose, kFactoryInjectable, kHookCollection, kInjectable, kLazyInjectable, kOptionalDependency, kValueInjectable, } from "./constants.js";
+import { kFactoryInjectable, kInjectable, kLazyInjectable, kOptionalDependency, kValueInjectable, } from "./constants.js";
 import { Scope } from "./enums.js";
-import { Hooks } from "./hooks.js";
 const ScopeStrictness = {
     [Scope.Transient]: Number.NaN, // this should make it always fail to compare with other scopes
     [Scope.Global]: 1,
@@ -10,7 +9,6 @@ const ScopeStrictness = {
 };
 export const isLazyInjectable = (injectable) => injectable[kLazyInjectable];
 export const isFactoryInjectable = (injectable) => injectable[kFactoryInjectable];
-export const isClassInjectable = (injectable) => injectable[kClassInjectable];
 export const isValueInjectable = (injectable) => injectable[kValueInjectable];
 export const isInjectable = (injectable) => injectable[kInjectable];
 export const isOptionalInjectable = (injectable) => injectable[kOptionalDependency];
@@ -42,14 +40,17 @@ export function createOptionalInjectable(injectable) {
     });
 }
 export function createLazyInjectable(scope = Scope.Global, label, stackTraceDepth = 0) {
-    return Object.freeze({
+    const injectable = Object.freeze({
         scope,
         dependencies: {},
         label,
         stack: tryCaptureStackTrace(stackTraceDepth),
+        optional: () => createOptionalInjectable(injectable),
+        $withType: () => injectable,
         [kInjectable]: true,
         [kLazyInjectable]: true,
     });
+    return injectable;
 }
 export function createValueInjectable(value, label, stackTraceDepth = 0) {
     return Object.freeze({
@@ -73,75 +74,13 @@ export function createFactoryInjectable(paramsOrFactory, label, stackTraceDepth
         pick: params.pick ?? ((instance) => instance),
         label,
         stack: tryCaptureStackTrace(stackTraceDepth),
+        optional: () => createOptionalInjectable(injectable),
         [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 {
-        $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 [kClassInjectableCreate]() { }
-        async [kClassInjectableDispose]() { }
-    };
-    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() {
-            // 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;
@@ -152,16 +91,12 @@ export function substitute(injectable, substitution, stackTraceDepth = 0) {
             if (isInjectable(value)) {
                 dependencies[key] = value;
             }
-            else if (isClassInjectable(original) || isFactoryInjectable(original)) {
+            else if (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)) {
+    if (isFactoryInjectable(injectable)) {
         // @ts-expect-error
         return createFactoryInjectable({ ...injectable, dependencies }, injectable.label, depth);
     }
@@ -187,35 +122,20 @@ export function compareScope(left, operator, right) {
             throw new Error('Invalid operator');
     }
 }
-const logger = createLazyInjectable(Scope.Global, 'Logger');
-const registry = createLazyInjectable(Scope.Global, 'Registry');
+const logger = Object.assign((label) => createFactoryInjectable({
+    dependencies: { logger },
+    scope: Scope.Global,
+    factory: ({ logger }) => logger.child({ $label: label }),
+}), createLazyInjectable(Scope.Global, 'Logger'));
 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();
-    },
-});
 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;
 }
-export const CoreInjectables = { logger, registry, inject, dispose, hook };
+export const CoreInjectables = { logger, inject, dispose };
+export const provide = (token, value) => {
+    return { token, value };
+};

package/dist/logger.js

@@ -1,6 +1,7 @@
 import { threadId } from 'node:worker_threads';
 import { pino, stdTimeFunctions } from 'pino';
 import { build as pretty } from 'pino-pretty';
+import { errWithCause } from 'pino-std-serializers';
 // 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`;
@@ -31,25 +32,28 @@ const levelLabels = {
     60: ' FATAL ',
     [Number.POSITIVE_INFINITY]: 'SILENT',
 };
-export const createLogger = (options = {}, $group) => {
+export const createLogger = (options = {}, $lable) => {
     let { destinations, pinoOptions } = options;
     if (!destinations || !destinations?.length) {
-        destinations = [createConsolePrettyDestination('info')];
+        destinations = [
+            createConsolePrettyDestination((options.pinoOptions?.level || '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 });
+    const serializers = { ...pinoOptions?.serializers, err: errWithCause };
+    return pino({ timestamp: stdTimeFunctions.isoTime, ...pinoOptions, level, serializers }, pino.multistream(destinations)).child({ $lable, $threadId: threadId });
 };
 export const createConsolePrettyDestination = (level, sync = true) => ({
     level,
     stream: pretty({
         colorize: true,
-        ignore: 'hostname,$group,$threadId',
+        ignore: 'hostname,$lable,$threadId',
         errorLikeObjectKeys: ['err', 'error', 'cause'],
         messageFormat: (log, messageKey) => {
-            const group = fg(`[${log.$group}]`, 11);
+            const group = fg(`[${log.$lable}]`, 11);
             const msg = fg(log[messageKey], messageColors[log.level]);
             const thread = fg(`(Thread-${log.$threadId})`, 89);
             return `\x1b[0m${thread} ${group} ${msg}`;

package/dist/plugin.js

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

package/dist/utils/functions.js

@@ -1,31 +1,4 @@
-/**
- * Very simple pattern matching function.
- */
-export function match(value, pattern) {
-    if (typeof pattern === 'function') {
-        return pattern(value);
-    }
-    else if (typeof pattern === 'string') {
-        if (pattern === '*' || pattern === '**') {
-            return true;
-        }
-        else if (pattern.at(0) === '*' && pattern.at(-1) === '*') {
-            return value.includes(pattern.slice(1, -1));
-        }
-        else if (pattern.at(-1) === '*') {
-            return value.startsWith(pattern.slice(0, -1));
-        }
-        else if (pattern.at(0) === '*') {
-            return value.endsWith(pattern.slice(1));
-        }
-        else {
-            return value === pattern;
-        }
-    }
-    else {
-        return pattern.test(value);
-    }
-}
+export { match } from '@nmtjs/common';
 export function isJsFile(name) {
     if (name.endsWith('.d.ts'))
         return false;
@@ -33,3 +6,12 @@ export function isJsFile(name) {
     const ext = leading.join('.');
     return ['js', 'mjs', 'cjs', 'ts', 'mts', 'cts'].includes(ext);
 }
+export function pick(obj, keys) {
+    const result = {};
+    for (const key in keys) {
+        if (key in obj) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+}

package/package.json

@@ -2,38 +2,36 @@
   "name": "@nmtjs/core",
   "type": "module",
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "module-sync": "./dist/index.js"
-    },
-    "./constants": {
-      "types": "./dist/constants.d.ts",
-      "import": "./dist/constants.js",
-      "module-sync": "./dist/constants.js"
-    }
+    ".": "./dist/index.js",
+    "./constants": "./dist/constants.js"
   },
   "peerDependencies": {
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0",
-    "@nmtjs/common": "0.14.5",
-    "@nmtjs/type": "0.14.5"
+    "@nmtjs/common": "0.15.0-beta.2",
+    "@nmtjs/type": "0.15.0-beta.2"
   },
   "devDependencies": {
-    "@types/node": "^20",
+    "@types/node": "^24",
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0",
-    "@nmtjs/common": "0.14.5",
-    "@nmtjs/type": "0.14.5"
+    "@nmtjs/common": "0.15.0-beta.2",
+    "@nmtjs/type": "0.15.0-beta.2"
   },
   "files": [
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.14.5",
+  "dependencies": {
+    "hookable": "6.0.0-rc.1",
+    "pino-std-serializers": "^7.0.0"
+  },
+  "version": "0.15.0-beta.2",
   "scripts": {
+    "clean-build": "rm -rf ./dist",
     "build": "tsc",
+    "dev": "tsc --watch",
     "type-check": "tsc --noEmit"
   }
 }

package/dist/constants.d.ts

@@ -1,24 +0,0 @@
-export declare const kOptionalDependency: unique symbol;
-export type kOptionalDependency = typeof kOptionalDependency;
-export declare const kInjectable: unique symbol;
-export type kInjectable = typeof kInjectable;
-export declare const kLazyInjectable: unique symbol;
-export type kLazyInjectable = typeof kLazyInjectable;
-export declare const kValueInjectable: unique symbol;
-export type kValueInjectable = typeof kValueInjectable;
-export declare const kFactoryInjectable: unique symbol;
-export type kFactoryInjectable = typeof kFactoryInjectable;
-export declare const kClassInjectable: unique symbol;
-export type kClassInjectable = typeof kClassInjectable;
-export declare const kClassInjectableCreate: unique symbol;
-export type kClassInjectableCreate = typeof kClassInjectableCreate;
-export declare const kClassInjectableDispose: unique symbol;
-export type kClassInjectableDispose = typeof kClassInjectableDispose;
-export declare const kProvider: unique symbol;
-export type kProvider = typeof kProvider;
-export declare const kHookCollection: unique symbol;
-export type kHookCollection = typeof kHookCollection;
-export declare const kPlugin: unique symbol;
-export type kPlugin = typeof kPlugin;
-export declare const kMetadata: unique symbol;
-export type kMetadata = typeof kMetadata;

package/dist/container.d.ts

@@ -1,46 +0,0 @@
-import type { AnyInjectable, Dependencies, DependencyContext, ResolveInjectableType } from './injectables.ts';
-import type { Logger } from './logger.ts';
-import type { Registry } from './registry.ts';
-import { Scope } from './enums.ts';
-type InstanceWrapper = {
-    private: any;
-    public: any;
-    context: any;
-};
-type ContainerOptions = {
-    registry: Registry;
-    logger: Logger;
-};
-export declare class Container {
-    private readonly application;
-    readonly scope: Exclude<Scope, Scope.Transient>;
-    private readonly parent?;
-    readonly instances: Map<AnyInjectable, InstanceWrapper[]>;
-    private readonly resolvers;
-    private readonly injectables;
-    private readonly dependants;
-    private disposing;
-    constructor(application: ContainerOptions, scope?: Exclude<Scope, Scope.Transient>, parent?: Container | undefined);
-    load(): Promise<void>;
-    fork(scope: Exclude<Scope, Scope.Transient>): Container;
-    dispose(): Promise<void>;
-    containsWithinSelf(injectable: AnyInjectable): boolean;
-    contains(injectable: AnyInjectable): boolean;
-    get<T extends AnyInjectable>(injectable: T): ResolveInjectableType<T>;
-    resolve<T extends AnyInjectable>(injectable: T): Promise<ResolveInjectableType<T>>;
-    createContext<T extends Dependencies>(dependencies: T): Promise<DependencyContext<T>>;
-    private createInjectableContext;
-    provide<T extends AnyInjectable>(injectable: T, instance: ResolveInjectableType<T>): Promise<void>;
-    satisfies(injectable: AnyInjectable): boolean;
-    private findCurrentScopeInjectables;
-    private resolveInjectable;
-    private createResolution;
-    private createInjectFunction;
-    private createDisposeFunction;
-    private getDisposalOrder;
-    private disposeInjectableInstances;
-    private disposeInjectableInstance;
-}
-export type InjectFn = ReturnType<Container['createInjectFunction']>;
-export type DisposeFn = ReturnType<Container['createDisposeFunction']>;
-export {};

package/dist/enums.d.ts

@@ -1,18 +0,0 @@
-export declare enum Scope {
-    Global = "Global",
-    Connection = "Connection",
-    Call = "Call",
-    Transient = "Transient"
-}
-export declare enum Hook {
-    BeforeInitialize = "BeforeInitialize",
-    AfterInitialize = "AfterInitialize",
-    BeforeStart = "BeforeStart",
-    AfterStart = "AfterStart",
-    BeforeStop = "BeforeStop",
-    AfterStop = "AfterStop",
-    BeforeTerminate = "BeforeTerminate",
-    AfterTerminate = "AfterTerminate",
-    OnConnect = "OnConnect",
-    OnDisconnect = "OnDisconnect"
-}

package/dist/hooks.d.ts

@@ -1,19 +0,0 @@
-import type { Callback } from '@nmtjs/common';
-import type { Hook } from './enums.ts';
-import { kHookCollection } from './constants.ts';
-export interface HookType {
-    [key: string]: (...args: any[]) => any;
-}
-export type CallHook<T extends string> = (hook: T, ...args: T extends keyof HookType ? Parameters<HookType[T]> : any[]) => Promise<void>;
-export declare class Hooks {
-    static merge(from: Hooks, to: Hooks): void;
-    [kHookCollection]: Map<string, Set<Callback>>;
-    add(name: string, callback: Callback): () => void;
-    remove(name: string, callback: Callback): void;
-    call<T extends string | Hook>(name: T, options: {
-        concurrent?: boolean;
-        reverse?: boolean;
-    } | undefined, ...args: T extends Hook ? Parameters<HookType[T]> : any[]): Promise<void>;
-    clear(): void;
-}
-export declare const createErrForHook: (hook: Hook | (object & string)) => string;

package/dist/index.d.ts

@@ -1,11 +0,0 @@
-export * from './constants.ts';
-export * from './container.ts';
-export * from './enums.ts';
-export * from './hooks.ts';
-export * from './injectables.ts';
-export * from './logger.ts';
-export * from './metadata.ts';
-export * from './plugin.ts';
-export * from './registry.ts';
-export * from './types.ts';
-export * from './utils/index.ts';

package/dist/injectables.d.ts

@@ -1,119 +0,0 @@
-import type { Async, ClassConstructor, ClassConstructorArgs, ClassInstance } from '@nmtjs/common';
-import type { Hook } from './enums.ts';
-import type { HookType } from './hooks.ts';
-import type { Logger } from './logger.ts';
-import type { Registry } from './registry.ts';
-import { kClassInjectable, kClassInjectableCreate, kClassInjectableDispose, kFactoryInjectable, kInjectable, kLazyInjectable, kOptionalDependency, kValueInjectable } from './constants.ts';
-import { Scope } from './enums.ts';
-import { Hooks } from './hooks.ts';
-export type DependencyOptional<T extends AnyInjectable = AnyInjectable> = {
-    [kOptionalDependency]: any;
-    injectable: T;
-};
-export type Depedency = DependencyOptional | AnyInjectable;
-export type Dependencies = Record<string, Depedency>;
-export type ResolveInjectableType<T extends AnyInjectable> = T extends Injectable<infer Type, any, any> ? Type : never;
-export interface Dependant<Deps extends Dependencies = Dependencies> {
-    dependencies: Deps;
-    label?: string;
-    stack?: string;
-}
-export type DependencyInjectable<T extends Depedency> = T extends AnyInjectable ? T : T extends DependencyOptional ? T['injectable'] : never;
-export type DependencyContext<Deps extends Dependencies> = {
-    readonly [K in keyof Deps as Deps[K] extends AnyInjectable ? K : never]: Deps[K] extends AnyInjectable ? ResolveInjectableType<Deps[K]> : never;
-} & {
-    readonly [K in keyof Deps as Deps[K] extends DependencyOptional ? K : never]?: Deps[K] extends DependencyOptional ? ResolveInjectableType<Deps[K]['injectable']> : never;
-};
-export type InjectableFactoryType<InjectableType, InjectableDeps extends Dependencies> = (context: DependencyContext<InjectableDeps>) => Async<InjectableType>;
-export type InjectablePickType<Input, Output> = (injectable: Input) => Output;
-export type InjectableDisposeType<InjectableType, InjectableDeps extends Dependencies> = (instance: InjectableType, context: DependencyContext<InjectableDeps>) => any;
-export interface LazyInjectable<T, S extends Scope = Scope.Global> extends Dependant<{}> {
-    scope: S;
-    [kInjectable]: any;
-    [kLazyInjectable]: T;
-}
-export interface ValueInjectable<T> extends Dependant<{}> {
-    scope: Scope.Global;
-    value: T;
-    [kInjectable]: any;
-    [kValueInjectable]: any;
-}
-export interface FactoryInjectable<T, D extends Dependencies = {}, S extends Scope = Scope.Global, P = T> extends Dependant<D> {
-    scope: S;
-    factory: InjectableFactoryType<P, D>;
-    pick: InjectablePickType<P, T>;
-    dispose?: InjectableDisposeType<P, D>;
-    [kInjectable]: any;
-    [kFactoryInjectable]: any;
-}
-export interface BaseClassInjectable<T, D extends Dependencies = {}, S extends Scope = Scope.Global> extends Dependant<D> {
-    new (...args: any[]): T;
-    scope: S;
-    [kInjectable]: any;
-    [kClassInjectable]: any;
-}
-export interface ClassInjectable<T, D extends Dependencies = {}, S extends Scope = Scope.Global, A extends any[] = []> extends Dependant<D> {
-    new ($context: DependencyContext<D>, ...args: A): T & {
-        $context: DependencyContext<D>;
-        [kClassInjectableCreate]?: () => Promise<void>;
-        [kClassInjectableDispose]?: () => Promise<void>;
-    };
-    scope: S;
-    [kInjectable]: any;
-    [kClassInjectable]: any;
-}
-export type Injectable<V = any, D extends Dependencies = {}, S extends Scope = Scope> = LazyInjectable<V, S> | ValueInjectable<V> | FactoryInjectable<V, D, S, any> | BaseClassInjectable<V, D, S>;
-export type AnyInjectable<T = any, S extends Scope = Scope> = Injectable<T, any, S>;
-export declare const isLazyInjectable: (injectable: any) => injectable is LazyInjectable<any>;
-export declare const isFactoryInjectable: (injectable: any) => injectable is FactoryInjectable<any>;
-export declare const isClassInjectable: (injectable: any) => injectable is ClassInjectable<any>;
-export declare const isValueInjectable: (injectable: any) => injectable is ValueInjectable<any>;
-export declare const isInjectable: (injectable: any) => injectable is AnyInjectable<any>;
-export declare const isOptionalInjectable: (injectable: any) => injectable is DependencyOptional<any>;
-export declare function getInjectableScope(injectable: AnyInjectable): Scope;
-export declare function getDepedencencyInjectable(dependency: Depedency): AnyInjectable;
-export declare function createOptionalInjectable<T extends AnyInjectable>(injectable: T): DependencyOptional<T>;
-export declare function createLazyInjectable<T, S extends Scope = Scope.Global>(scope?: S, label?: string, stackTraceDepth?: number): LazyInjectable<T, S>;
-export declare function createValueInjectable<T>(value: T, label?: string, stackTraceDepth?: number): ValueInjectable<T>;
-export declare function createFactoryInjectable<T, D extends Dependencies = {}, S extends Scope = Scope.Global, P = T>(paramsOrFactory: {
-    dependencies?: D;
-    scope?: S;
-    pick?: InjectablePickType<P, T>;
-    factory: InjectableFactoryType<P, D>;
-    dispose?: InjectableDisposeType<P, D>;
-} | InjectableFactoryType<P, D>, label?: string, stackTraceDepth?: number): FactoryInjectable<null extends T ? P : T, D, S, P>;
-export declare const createClassInjectable: <D extends Dependencies = {}, S extends Scope = Scope.Global>(dependencies?: D, scope?: S, stackTraceDepth?: number) => ClassInjectable<ClassInstance<{
-    new ($context: DependencyContext<D>): {
-        $context: DependencyContext<D>;
-        [kClassInjectableCreate](): Promise<void>;
-        [kClassInjectableDispose](): Promise<void>;
-    };
-    dependencies: D;
-    scope: S;
-    stack: string | undefined;
-    get label(): string;
-    [kInjectable]: boolean;
-    [kClassInjectable]: boolean;
-}>, D, S>;
-export declare function createExtendableClassInjectable<B extends ClassConstructor<any>, D extends Dependencies = {}, S extends Scope = Scope.Global>(baseClass: B, dependencies?: D, scope?: S, stackTraceDepth?: number): B extends ClassInjectable<any> ? ClassInjectable<ClassInstance<B>, D, S> : ClassInjectable<ClassInstance<B>, D, S, ClassConstructorArgs<B, []>>;
-export type DependenciesSubstitution<T extends Dependencies> = {
-    [K in keyof T]?: T[K] extends AnyInjectable<infer Type> ? AnyInjectable<Type> | DependenciesSubstitution<T[K]['dependencies']> : never;
-};
-export declare function substitute<T extends FactoryInjectable<any, any, Scope> | BaseClassInjectable<any, any, Scope>>(injectable: T, substitution: DependenciesSubstitution<T['dependencies']>, stackTraceDepth?: number): T;
-export declare function compareScope(left: Scope, operator: '>' | '<' | '>=' | '<=' | '=' | '!=', right: Scope): boolean;
-export declare const CoreInjectables: {
-    logger: LazyInjectable<Logger, Scope.Global>;
-    registry: LazyInjectable<Registry, Scope.Global>;
-    inject: LazyInjectable<(<T extends AnyInjectable>(injectable: T, context: { [K in keyof T["dependencies"]]?: ResolveInjectableType<T["dependencies"][K]> | AnyInjectable<ResolveInjectableType<T["dependencies"][K]>> | undefined; }) => Promise<ResolveInjectableType<T>>) & {
-        explicit: <T extends AnyInjectable>(injectable: T, context: { [K in keyof T["dependencies"]]?: ResolveInjectableType<T["dependencies"][K]> | AnyInjectable<ResolveInjectableType<T["dependencies"][K]>> | undefined; }) => Promise<Awaited<ResolveInjectableType<T>> & {
-            [Symbol.asyncDispose]: () => Promise<void>;
-        }>;
-    }, Scope.Global>;
-    dispose: LazyInjectable<(<T extends AnyInjectable>(injectable: T, instance?: any) => Promise<void>), Scope.Global>;
-    hook: FactoryInjectable<(<T extends Hook>(name: T, callback: HookType[T]) => () => void), {
-        registry: LazyInjectable<Registry, Scope.Global>;
-    }, Scope.Transient, {
-        hooks: Hooks;
-        on: <T extends Hook>(name: T, callback: HookType[T]) => () => void;
-    }>;
-};

package/dist/logger.d.ts

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

package/dist/metadata.d.ts

@@ -1,13 +0,0 @@
-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/plugin.d.ts

@@ -1,12 +0,0 @@
-import type { Async } from '@nmtjs/common';
-import type { PluginContext } from './types.ts';
-import { kPlugin } from './constants.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/registry.d.ts

@@ -1,21 +0,0 @@
-import type { Hook } from './enums.ts';
-import type { HookType } from './hooks.ts';
-import type { AnyInjectable, Dependant } from './injectables.ts';
-import type { Logger } from './logger.ts';
-import { Scope } from './enums.ts';
-import { Hooks } from './hooks.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;

package/dist/registry.js

@@ -1,24 +0,0 @@
-import { Scope } from "./enums.js";
-import { Hooks } from "./hooks.js";
-import { getInjectableScope } from "./injectables.js";
-export class Registry {
-    application;
-    hooks = new Hooks();
-    constructor(application) {
-        this.application = application;
-    }
-    registerHooks(hooks) {
-        Hooks.merge(hooks, this.hooks);
-    }
-    registerHook(name, callback) {
-        this.hooks.add(name, callback);
-    }
-    *getDependants() { }
-    clear() {
-        this.hooks.clear();
-    }
-}
-export const scopeErrorMessage = (name, scope = Scope.Global) => `${name} must be a ${scope} scope (including all nested dependencies)`;
-export function hasInvalidScopeDeps(injectables, scope = Scope.Global) {
-    return injectables.some((injectable) => getInjectableScope(injectable) !== scope);
-}

package/dist/types.d.ts

@@ -1,11 +0,0 @@
-import type { Container } from './container.ts';
-import type { Hooks } from './hooks.ts';
-import type { Logger } from './logger.ts';
-import type { Registry } from './registry.ts';
-export interface PluginContext {
-    logger: Logger;
-    registry: Registry;
-    hooks: Hooks;
-    container: Container;
-}
-export type Pattern = RegExp | string | ((value: string) => boolean);

package/dist/utils/functions.d.ts

@@ -1,6 +0,0 @@
-import type { Pattern } from '../types.ts';
-/**
- * Very simple pattern matching function.
- */
-export declare function match(value: string, pattern: Pattern): boolean;
-export declare function isJsFile(name: string): boolean;

package/dist/utils/index.d.ts

@@ -1,3 +0,0 @@
-export * from './functions.ts';
-export * from './pool.ts';
-export * from './semaphore.ts';

package/dist/utils/pool.d.ts

@@ -1,18 +0,0 @@
-interface PoolOptions {
-    timeout?: number;
-}
-export declare class PoolError extends Error {
-}
-export declare class Pool<T = unknown> {
-    #private;
-    private readonly options;
-    constructor(options?: PoolOptions);
-    add(item: T): void;
-    remove(item: T): void;
-    capture(timeout?: number | undefined): Promise<T>;
-    next(exclusive?: boolean, timeout?: number | undefined): Promise<T>;
-    release(item: T): void;
-    isFree(item: T): boolean;
-    get items(): T[];
-}
-export {};

package/dist/utils/semaphore.d.ts

@@ -1,13 +0,0 @@
-export declare class SemaphoreError extends Error {
-}
-export declare class Semaphore {
-    private readonly size;
-    private readonly timeout;
-    private counter;
-    private readonly queue;
-    constructor(concurrency: number, size?: number, timeout?: number);
-    enter(): Promise<void>;
-    leave(): void;
-    get isEmpty(): boolean;
-    get queueLength(): number;
-}