@nmtjs/core 0.14.4 → 0.15.0-beta.1

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/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.4",
-    "@nmtjs/type": "0.14.4"
+    "@nmtjs/common": "0.15.0-beta.1",
+    "@nmtjs/type": "0.15.0-beta.1"
   },
   "devDependencies": {
-    "@types/node": "^20",
+    "@types/node": "^24",
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0",
-    "@nmtjs/common": "0.14.4",
-    "@nmtjs/type": "0.14.4"
+    "@nmtjs/common": "0.15.0-beta.1",
+    "@nmtjs/type": "0.15.0-beta.1"
   },
   "files": [
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.14.4",
+  "dependencies": {
+    "hookable": "6.0.0-rc.1",
+    "pino-std-serializers": "^7.0.0"
+  },
+  "version": "0.15.0-beta.1",
   "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/constants.js

@@ -1,12 +0,0 @@
-export const kOptionalDependency = Symbol.for('neemata:OptionalDependencyKey');
-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');

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/container.js

@@ -1,309 +0,0 @@
-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";
-export class Container {
-    application;
-    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;
-        this.scope = scope;
-        this.parent = parent;
-        if (scope === Scope.Transient) {
-            throw new Error('Invalid scope');
-        }
-        this.provide(CoreInjectables.inject, this.createInjectFunction());
-        this.provide(CoreInjectables.dispose, this.createDisposeFunction());
-        this.provide(CoreInjectables.registry, application.registry);
-    }
-    async load() {
-        const traverse = (dependencies) => {
-            for (const key in dependencies) {
-                const dependency = dependencies[key];
-                const injectable = getDepedencencyInjectable(dependency);
-                this.injectables.add(injectable);
-                traverse(injectable.dependencies);
-            }
-        };
-        for (const dependant of this.application.registry.getDependants()) {
-            traverse(dependant.dependencies);
-        }
-        const injectables = Array.from(this.findCurrentScopeInjectables());
-        await Promise.all(injectables.map((injectable) => this.resolve(injectable)));
-    }
-    fork(scope) {
-        return new Container(this.application, scope, this);
-    }
-    async dispose() {
-        this.application.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);
-            }
-        }
-        this.instances.clear();
-        this.injectables.clear();
-        this.resolvers.clear();
-        this.dependants.clear();
-        this.disposing = false;
-    }
-    containsWithinSelf(injectable) {
-        return this.instances.has(injectable) || this.resolvers.has(injectable);
-    }
-    contains(injectable) {
-        return (this.containsWithinSelf(injectable) ||
-            (this.parent?.contains(injectable) ?? false));
-    }
-    get(injectable) {
-        if (injectable.scope === Scope.Transient) {
-            throw new Error('Cannot get transient injectable directly');
-        }
-        if (this.instances.has(injectable)) {
-            return this.instances.get(injectable).at(0).public;
-        }
-        if (this.parent?.contains(injectable)) {
-            return this.parent.get(injectable);
-        }
-        throw new Error('No instance found');
-    }
-    resolve(injectable) {
-        return this.resolveInjectable(injectable);
-    }
-    async createContext(dependencies) {
-        return this.createInjectableContext(dependencies);
-    }
-    async createInjectableContext(dependencies, dependant) {
-        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 injectable = getDepedencencyInjectable(dependency);
-            const resolver = this.resolveInjectable(injectable, dependant);
-            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) {
-        if (this.disposing) {
-            return Promise.reject(new Error('Cannot resolve during disposal'));
-        }
-        if (dependant && compareScope(dependant.scope, '<', injectable.scope)) {
-            // TODO: more informative error
-            return Promise.reject(new Error('Invalid scope: dependant is looser than injectable'));
-        }
-        if (isValueInjectable(injectable)) {
-            return Promise.resolve(injectable.value);
-        }
-        else if (this.parent?.contains(injectable) ||
-            (this.parent?.satisfies(injectable) &&
-                compareScope(this.parent.scope, '<', this.scope))) {
-            return this.parent.resolveInjectable(injectable, dependant);
-        }
-        else {
-            const { stack, label } = injectable;
-            if (dependant) {
-                let dependants = this.dependants.get(injectable);
-                if (!dependants) {
-                    this.dependants.set(injectable, (dependants = new Set()));
-                }
-                dependants.add(dependant);
-            }
-            const isTransient = injectable.scope === Scope.Transient;
-            if (!isTransient && this.instances.has(injectable)) {
-                return Promise.resolve(this.instances.get(injectable).at(0).public);
-            }
-            else if (!isTransient && this.resolvers.has(injectable)) {
-                return this.resolvers.get(injectable);
-            }
-            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(() => {
-                        this.resolvers.delete(injectable);
-                    });
-                    if (injectable.scope !== Scope.Transient) {
-                        this.resolvers.set(injectable, resolution);
-                    }
-                    return resolution;
-                }
-            }
-        }
-    }
-    async createResolution(injectable) {
-        const { dependencies } = injectable;
-        const context = await this.createInjectableContext(dependencies, injectable);
-        const wrapper = {
-            private: null,
-            public: null,
-            context,
-        };
-        if (isFactoryInjectable(injectable)) {
-            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');
-        }
-        let instances = this.instances.get(injectable);
-        if (!instances) {
-            instances = [];
-            this.instances.set(injectable, instances);
-        }
-        instances.push(wrapper);
-        return wrapper.public;
-    }
-    createInjectFunction() {
-        const inject = (injectable, context) => {
-            const dependencies = { ...injectable.dependencies };
-            for (const key in context) {
-                const dep = context[key];
-                if (isInjectable(dep) || isOptionalInjectable(dep)) {
-                    dependencies[key] = dep;
-                }
-                else {
-                    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 explicit = async (injectable, context) => {
-            if ('asyncDispose' in Symbol === false) {
-                throw new Error('Symbol.asyncDispose is not supported in this environment');
-            }
-            const instance = await inject(injectable, context);
-            const dispose = this.createDisposeFunction();
-            return Object.assign(instance, {
-                [Symbol.asyncDispose]: async () => {
-                    await dispose(injectable, instance);
-                },
-            });
-        };
-        return Object.assign(inject, { explicit });
-    }
-    createDisposeFunction() {
-        return async (injectable, instance) => {
-            if (injectable.scope === Scope.Transient) {
-                assert(instance, 'Instance is required for transient injectable disposal');
-                const wrappers = this.instances.get(injectable);
-                if (wrappers) {
-                    for (const wrapper of wrappers) {
-                        if (wrapper.public === instance) {
-                            await this.disposeInjectableInstance(injectable, wrapper.private, wrapper.context);
-                            const index = wrappers.indexOf(wrapper);
-                            wrappers.splice(index, 1);
-                        }
-                    }
-                    if (wrappers.length === 0) {
-                        this.instances.delete(injectable);
-                    }
-                }
-            }
-            else {
-                await this.disposeInjectableInstances(injectable);
-            }
-        };
-    }
-    getDisposalOrder() {
-        const visited = new Set();
-        const result = [];
-        const visit = (injectable) => {
-            if (visited.has(injectable))
-                return;
-            visited.add(injectable);
-            const dependants = this.dependants.get(injectable);
-            if (dependants) {
-                for (const dependant of dependants) {
-                    if (this.instances.has(dependant)) {
-                        visit(dependant);
-                    }
-                }
-            }
-            // Only add to result if this container owns the instance
-            if (this.instances.has(injectable)) {
-                result.push(injectable);
-            }
-        };
-        for (const injectable of this.instances.keys()) {
-            visit(injectable);
-        }
-        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.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/enums.js

@@ -1,20 +0,0 @@
-export var Scope;
-(function (Scope) {
-    Scope["Global"] = "Global";
-    Scope["Connection"] = "Connection";
-    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.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/hooks.js

@@ -1,43 +0,0 @@
-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();
-    }
-}
-export const createErrForHook = (hook) => `Error during [${hook}] hook`;

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/index.js

@@ -1,14 +0,0 @@
-// // biome-ignore lint/correctness/noUnusedImports: TSC wants it
-// // biome-ignore assist/source/organizeImports: TSC wants it
-// import {} from 'pino'
-export * from "./constants.js";
-export * from "./container.js";
-export * from "./enums.js";
-export * from "./hooks.js";
-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";