@riaskov/nevo-messaging 1.0.1 → 1.1.2

package/dist/common/base.controller.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseMessageController = void 0;
 const _1 = require("./");
+const access_control_1 = require("./access-control");
 class BaseMessageController {
     constructor(serviceName, serviceInstances, methodHandlers, options) {
         this.methodRegistry = {};
@@ -11,6 +12,7 @@ class BaseMessageController {
         this.beforeHook = options?.onBefore;
         this.afterHook = options?.onAfter;
         this.debug = options?.debug || false;
+        this.accessControl = options?.accessControl;
         this.systemBeforeHook = (context) => {
             if (this.debug) {
                 console.log(`[${this.constructor.name}] Received:`, {
@@ -67,6 +69,50 @@ class BaseMessageController {
             throw error;
         }
     }
+    suggestClosestMethod(method) {
+        const candidates = Object.keys(this.methodRegistry || {});
+        if (!candidates.length) {
+            return null;
+        }
+        const normalized = method.toLowerCase();
+        let best = null;
+        for (const candidate of candidates) {
+            const score = this.levenshteinDistance(normalized, candidate.toLowerCase());
+            if (!best || score < best.score) {
+                best = { name: candidate, score };
+            }
+        }
+        if (!best) {
+            return null;
+        }
+        const threshold = Math.max(2, Math.floor(method.length * 0.4));
+        return best.score <= threshold ? best.name : null;
+    }
+    levenshteinDistance(a, b) {
+        if (a === b) {
+            return 0;
+        }
+        if (!a.length) {
+            return b.length;
+        }
+        if (!b.length) {
+            return a.length;
+        }
+        const matrix = Array.from({ length: a.length + 1 }, () => []);
+        for (let i = 0; i <= a.length; i++) {
+            matrix[i][0] = i;
+        }
+        for (let j = 0; j <= b.length; j++) {
+            matrix[0][j] = j;
+        }
+        for (let i = 1; i <= a.length; i++) {
+            for (let j = 1; j <= b.length; j++) {
+                const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+                matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
+            }
+        }
+        return matrix[a.length][b.length];
+    }
     async formatResult(result) {
         if (result instanceof Promise) {
             result = await result;
@@ -100,12 +146,13 @@ class BaseMessageController {
         };
     }
     async processMessage(data) {
-        const { method, uuid, params } = this.extractMessageData(data);
+        const { method, uuid, params, meta } = this.extractMessageData(data);
         const baseContext = {
             method,
             serviceName: this.serviceName,
             uuid,
-            rawData: data
+            rawData: data,
+            meta
         };
         const requestContext = {
             ...baseContext,
@@ -120,10 +167,26 @@ class BaseMessageController {
                     processedParams = hookResult;
                 }
             }
+            const callerService = (0, access_control_1.extractCallerService)(meta);
+            const topic = this.serviceName;
+            if (!(0, access_control_1.isAccessAllowed)(this.accessControl, topic, method, callerService)) {
+                (0, access_control_1.logAccessDenied)(this.accessControl, { topic, method, serviceName: this.serviceName, callerService });
+                return {
+                    uuid,
+                    method,
+                    params: {
+                        result: "error",
+                        error: (0, access_control_1.createAccessDeniedError)(method, this.serviceName, callerService)
+                    },
+                    meta
+                };
+            }
             const handler = this.methodRegistry[method];
             if (!handler) {
+                const suggestion = this.suggestClosestMethod(method);
+                const message = suggestion ? `Invalid method name '${method}', did you mean '${suggestion}'?` : `Method handler not found: ${method}`;
                 throw new _1.MessagingError(_1.ErrorCode.UNKNOWN, {
-                    message: `Method handler not found: ${method}`
+                    message
                 });
             }
             const result = await this.executeHandler(handler, processedParams);
@@ -131,7 +194,8 @@ class BaseMessageController {
             let response = {
                 uuid,
                 method,
-                params: { result: formattedResult }
+                params: { result: formattedResult },
+                meta
             };
             const responseContext = {
                 ...baseContext,

package/dist/common/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_SUBSCRIPTION_SUFFIX = "-events.sub";
+export declare const DEFAULT_EVENTS_SUFFIX = "-events";
+export declare const DEFAULT_BROADCAST_TOPIC = "__broadcast";
+export declare const DEFAULT_DISCOVERY_TOPIC = "__nevo.discovery";

package/dist/common/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DISCOVERY_TOPIC = exports.DEFAULT_BROADCAST_TOPIC = exports.DEFAULT_EVENTS_SUFFIX = exports.DEFAULT_SUBSCRIPTION_SUFFIX = void 0;
+exports.DEFAULT_SUBSCRIPTION_SUFFIX = "-events.sub";
+exports.DEFAULT_EVENTS_SUFFIX = "-events";
+exports.DEFAULT_BROADCAST_TOPIC = "__broadcast";
+exports.DEFAULT_DISCOVERY_TOPIC = "__nevo.discovery";

package/dist/common/discovery.d.ts

@@ -0,0 +1,8 @@
+import { DiscoveryAnnouncement, DiscoveryEntry } from "./types";
+export declare class DiscoveryRegistry {
+    private readonly services;
+    update(announcement: DiscoveryAnnouncement): void;
+    prune(ttlMs: number): void;
+    list(): DiscoveryEntry[];
+    isAvailable(serviceName: string, ttlMs: number): boolean;
+}

package/dist/common/discovery.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoveryRegistry = void 0;
+class DiscoveryRegistry {
+    constructor() {
+        this.services = new Map();
+    }
+    update(announcement) {
+        const now = Date.now();
+        const entry = {
+            ...announcement,
+            lastSeen: now
+        };
+        this.services.set(announcement.serviceName, entry);
+    }
+    prune(ttlMs) {
+        const now = Date.now();
+        for (const [serviceName, entry] of this.services.entries()) {
+            if (now - entry.lastSeen > ttlMs) {
+                this.services.delete(serviceName);
+            }
+        }
+    }
+    list() {
+        return [...this.services.values()];
+    }
+    isAvailable(serviceName, ttlMs) {
+        const entry = this.services.get(serviceName);
+        if (!entry) {
+            return false;
+        }
+        return Date.now() - entry.lastSeen <= ttlMs;
+    }
+}
+exports.DiscoveryRegistry = DiscoveryRegistry;

package/dist/common/error-code.d.ts

@@ -1,3 +1,4 @@
 export declare enum ErrorCode {
-    UNKNOWN = 0
+    UNKNOWN = 0,
+    UNAUTHORIZED = 1
 }

package/dist/common/error-code.js

@@ -4,4 +4,5 @@ exports.ErrorCode = void 0;
 var ErrorCode;
 (function (ErrorCode) {
     ErrorCode[ErrorCode["UNKNOWN"] = 0] = "UNKNOWN";
+    ErrorCode[ErrorCode["UNAUTHORIZED"] = 1] = "UNAUTHORIZED";
 })(ErrorCode || (exports.ErrorCode = ErrorCode = {}));

package/dist/common/error-messages.js

@@ -3,5 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorMessages = void 0;
 const _1 = require("./");
 exports.ErrorMessages = {
-    [_1.ErrorCode.UNKNOWN]: "An unknown error occurred"
+    [_1.ErrorCode.UNKNOWN]: "An unknown error occurred",
+    [_1.ErrorCode.UNAUTHORIZED]: "Access denied"
 };

package/dist/common/index.d.ts

@@ -6,3 +6,6 @@ export * from "./service-utils";
 export * from "./error-code";
 export * from "./error-messages";
 export * from "./bigint.utils";
+export * from "./constants";
+export * from "./access-control";
+export * from "./discovery";

package/dist/common/index.js

@@ -22,3 +22,6 @@ __exportStar(require("./service-utils"), exports);
 __exportStar(require("./error-code"), exports);
 __exportStar(require("./error-messages"), exports);
 __exportStar(require("./bigint.utils"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./access-control"), exports);
+__exportStar(require("./discovery"), exports);

package/dist/common/service-utils.d.ts

@@ -17,5 +17,7 @@ export declare function mapServiceMethods<T>(service: T, customMappings?: Record
 export declare const createServiceClient: <T extends ServiceMethodMap>(serviceName: string) => {
     query: <M extends keyof T & string>(method: M, params: T[M]["params"]) => Promise<T[M]["result"]>;
     emit: <M extends keyof T & string>(method: M, params: T[M]["params"]) => Promise<void>;
+    publish: <M extends keyof T & string>(method: M, params: T[M]["params"]) => Promise<void>;
+    subscribe: <M extends keyof T & string>(method: M, handler: (data: T[M]["result"]) => void) => Promise<void>;
 };
 export declare function createMethodHandlers(mappings: Record<string, [string, ((params: unknown) => unknown[])?, ((result: unknown) => unknown)?]>): ServiceMethodMapping;

package/dist/common/service-utils.js

@@ -38,6 +38,14 @@ const createServiceClient = (serviceName) => ({
     // @ts-ignore
     emit: (method, params) => {
         throw new Error("Implementation required in subclass");
+    },
+    // @ts-ignore
+    publish: (method, params) => {
+        throw new Error("Implementation required in subclass");
+    },
+    // @ts-ignore
+    subscribe: (method, handler) => {
+        throw new Error("Implementation required in subclass");
     }
 });
 exports.createServiceClient = createServiceClient;

package/dist/common/types.d.ts

@@ -6,10 +6,20 @@ export interface MessagePayload {
     key: string;
     value: string;
 }
+export type MessageType = "query" | "emit" | "sub" | "broadcast" | "discovery";
+export interface MessageMeta {
+    type?: MessageType;
+    service?: string;
+    ts?: number;
+    auth?: {
+        token?: string;
+    };
+}
 export interface MessageRequest<T = unknown> {
     uuid: string;
     method: string;
     params: T;
+    meta?: MessageMeta;
 }
 export interface MessageResponse<T = unknown> {
     uuid: string;
@@ -18,6 +28,7 @@ export interface MessageResponse<T = unknown> {
         result: T | "error";
         error?: ErrorDetails;
     };
+    meta?: MessageMeta;
 }
 export interface ErrorDetails {
     code: number;
@@ -31,6 +42,7 @@ export interface HookContext {
     serviceName: string;
     uuid: string;
     rawData: unknown;
+    meta?: MessageMeta;
 }
 export interface BeforeHookContext extends HookContext {
     params: unknown;
@@ -57,16 +69,66 @@ export interface ServiceMethodMapping {
 }
 export interface TransportClientOptions {
     clientId?: string;
+    serviceName?: string;
+    authToken?: string;
     timeout?: number;
     debug?: boolean;
+    backoff?: {
+        enabled?: boolean;
+        baseMs?: number;
+        maxMs?: number;
+        maxAttempts?: number;
+        jitter?: boolean;
+    };
+    discovery?: {
+        enabled?: boolean;
+        heartbeatIntervalMs?: number;
+        ttlMs?: number;
+    };
     [key: string]: any;
 }
 export interface TransportServerOptions {
     serviceName: string;
     debug?: boolean;
+    authToken?: string;
     [key: string]: any;
 }
 export interface MicroserviceConfig {
     serviceName: string;
     clientName: string;
 }
+export interface SubscriptionOptions {
+    ack?: boolean;
+    durableKey?: string;
+    groupId?: string;
+    fromBeginning?: boolean;
+}
+export interface SubscriptionContext {
+    ack(): Promise<void>;
+    nack?(reason?: string): Promise<void>;
+    meta: MessageMeta;
+}
+export interface Subscription {
+    unsubscribe(): Promise<void>;
+}
+export interface AccessRule {
+    topic?: string;
+    method?: string;
+    allow?: string[];
+    deny?: string[];
+}
+export interface AccessControlConfig {
+    rules?: AccessRule[];
+    allowAllByDefault?: boolean;
+    logDenied?: boolean;
+}
+export interface DiscoveryAnnouncement {
+    serviceName: string;
+    clientId?: string;
+    transport: string;
+    ts: number;
+    meta?: Record<string, unknown>;
+}
+export interface DiscoveryEntry extends DiscoveryAnnouncement {
+    lastSeen: number;
+}

package/dist/signal-router.utils.d.ts

@@ -1,15 +1,17 @@
 import { Type } from "@nestjs/common";
-import { BeforeHook, AfterHook } from "./common";
+import { BeforeHook, AfterHook, AccessControlConfig, MessageMeta } from "./common";
 export interface SignalRouterOptions {
     before?: BeforeHook;
     after?: AfterHook;
     debug?: boolean;
     eventPattern?: string;
+    accessControl?: AccessControlConfig;
 }
 export interface MessageData {
     method: string;
     params: any;
     uuid: string;
+    meta?: MessageMeta;
 }
 export type MessageExtractor = (data: any) => MessageData;
 export declare function findPropertyByType(obj: any, type: Type<any>): string | null;

package/dist/signal-router.utils.js

@@ -5,6 +5,8 @@ exports.findServiceInstances = findServiceInstances;
 exports.createErrorResponse = createErrorResponse;
 exports.createSignalRouterDecorator = createSignalRouterDecorator;
 const common_1 = require("./common");
+const access_control_1 = require("./common/access-control");
+const common_2 = require("./common");
 const signal_decorator_1 = require("./signal.decorator");
 function findPropertyByType(obj, type) {
     for (const prop in obj) {
@@ -34,6 +36,49 @@ function createErrorResponse(message, uuid, method, code = 0) {
         }
     };
 }
+function levenshteinDistance(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    if (!a.length) {
+        return b.length;
+    }
+    if (!b.length) {
+        return a.length;
+    }
+    const matrix = Array.from({ length: a.length + 1 }, () => []);
+    for (let i = 0; i <= a.length; i++) {
+        matrix[i][0] = i;
+    }
+    for (let j = 0; j <= b.length; j++) {
+        matrix[0][j] = j;
+    }
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
+        }
+    }
+    return matrix[a.length][b.length];
+}
+function suggestClosestMethod(method, candidates) {
+    if (!candidates.length) {
+        return null;
+    }
+    const normalized = method.toLowerCase();
+    let best = null;
+    for (const candidate of candidates) {
+        const score = levenshteinDistance(normalized, candidate.toLowerCase());
+        if (!best || score < best.score) {
+            best = { name: candidate, score };
+        }
+    }
+    if (!best) {
+        return null;
+    }
+    const threshold = Math.max(2, Math.floor(method.length * 0.4));
+    return best.score <= threshold ? best.name : null;
+}
 function createSignalRouterDecorator(serviceType, options = {}, messageExtractor, registerHandler) {
     const debug = options?.debug || process.env["NODE_ENV"] !== "production";
     return function (target) {
@@ -45,7 +90,7 @@ function createSignalRouterDecorator(serviceType, options = {}, messageExtractor
                     console.log(`[${eventPattern}] Received message:`, (0, common_1.stringifyWithBigInt)(data));
                 }
                 const messageData = messageExtractor(data);
-                const { method, params, uuid } = messageData;
+                const { method, params, uuid, meta } = messageData;
                 if (!method) {
                     console.error("Missing 'method' field in message");
                     return createErrorResponse("Invalid message format");
@@ -58,6 +103,20 @@ function createSignalRouterDecorator(serviceType, options = {}, messageExtractor
                     console.error(`No service instances found for:`, serviceType);
                     return createErrorResponse("Service not found", uuid, method);
                 }
+                const callerService = (0, access_control_1.extractCallerService)(meta);
+                const topic = eventPattern;
+                if (!(0, access_control_1.isAccessAllowed)(options.accessControl, topic, method, callerService)) {
+                    (0, access_control_1.logAccessDenied)(options.accessControl, { topic, method, serviceName: eventPattern, callerService });
+                    return {
+                        uuid,
+                        method,
+                        params: {
+                            result: "error",
+                            error: (0, access_control_1.createAccessDeniedError)(method, eventPattern, callerService)
+                        },
+                        meta
+                    };
+                }
                 let processedParams = params;
                 if (options.before) {
                     const hookResult = await options.before({
@@ -65,7 +124,8 @@ function createSignalRouterDecorator(serviceType, options = {}, messageExtractor
                         serviceName: eventPattern,
                         uuid,
                         rawData: data,
-                        params
+                        params,
+                        meta
                     });
                     if (hookResult !== undefined) {
                         processedParams = hookResult;
@@ -75,7 +135,9 @@ function createSignalRouterDecorator(serviceType, options = {}, messageExtractor
                 const signalHandler = signals.find((s) => s.signalName === method);
                 if (!signalHandler) {
                     console.error(`No handler found for method:`, method);
-                    return createErrorResponse(`Method ${method} not found`, uuid, method);
+                    const suggestion = suggestClosestMethod(method, signals.map((s) => s.signalName));
+                    const message = suggestion ? `Invalid method name '${method}', did you mean '${suggestion}'?` : `Method ${method} not found`;
+                    return createErrorResponse(message, uuid, method);
                 }
                 let serviceInstance = null;
                 const serviceMethod = signalHandler.methodName;
@@ -101,7 +163,8 @@ function createSignalRouterDecorator(serviceType, options = {}, messageExtractor
                 let response = {
                     uuid,
                     method,
-                    params: { result: serializedResult }
+                    params: { result: serializedResult },
+                    meta
                 };
                 if (options.after) {
                     const hookResponse = await options.after({
@@ -111,7 +174,8 @@ function createSignalRouterDecorator(serviceType, options = {}, messageExtractor
                         rawData: data,
                         params: processedParams,
                         result: serializedResult,
-                        response
+                        response,
+                        meta
                     });
                     if (hookResponse !== undefined) {
                         response = hookResponse;
@@ -122,7 +186,7 @@ function createSignalRouterDecorator(serviceType, options = {}, messageExtractor
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : "Unknown error";
                 console.error(`[${eventPattern}] Processing error:`, error);
-                return createErrorResponse(errorMessage, data.uuid, data.method, error.code);
+                return createErrorResponse(errorMessage, data.uuid, data.method, error.code || common_2.ErrorCode.UNKNOWN);
             }
         };
         registerHandler(target, eventPattern, handlerName);

package/dist/transports/http/http.client-base.d.ts

@@ -0,0 +1,13 @@
+import { NevoHttpClient } from "./nevo-http.client";
+export declare abstract class HttpClientBase {
+    protected readonly universalClient: NevoHttpClient;
+    protected constructor(universalClient: NevoHttpClient);
+    protected query<T = any>(serviceName: string, method: string, params: any): Promise<T>;
+    protected emit(serviceName: string, method: string, params: any): Promise<void>;
+    protected publish(serviceName: string, method: string, params: any): Promise<void>;
+    protected broadcast(method: string, params: any): Promise<void>;
+    protected subscribe<T = any>(serviceName: string, method: string, options: Parameters<NevoHttpClient["subscribe"]>[2], handler: Parameters<NevoHttpClient["subscribe"]>[3]): Promise<import("../..").Subscription>;
+    protected getAvailableServices(): string[];
+    protected getDiscoveredServices(): import("../..").DiscoveryEntry[];
+    protected isServiceAvailable(serviceName: string): boolean;
+}

package/dist/transports/http/http.client-base.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClientBase = void 0;
+class HttpClientBase {
+    constructor(universalClient) {
+        this.universalClient = universalClient;
+    }
+    async query(serviceName, method, params) {
+        return this.universalClient.query(serviceName, method, params);
+    }
+    async emit(serviceName, method, params) {
+        return this.universalClient.emit(serviceName, method, params);
+    }
+    async publish(serviceName, method, params) {
+        return this.universalClient.publish(serviceName, method, params);
+    }
+    async broadcast(method, params) {
+        return this.universalClient.broadcast(method, params);
+    }
+    async subscribe(serviceName, method, options, handler) {
+        return this.universalClient.subscribe(serviceName, method, options, handler);
+    }
+    getAvailableServices() {
+        return this.universalClient.getAvailableServices();
+    }
+    getDiscoveredServices() {
+        return this.universalClient.getDiscoveredServices();
+    }
+    isServiceAvailable(serviceName) {
+        return this.universalClient.isServiceAvailable(serviceName);
+    }
+}
+exports.HttpClientBase = HttpClientBase;

package/dist/transports/http/http.config.d.ts

@@ -0,0 +1,8 @@
+import { NevoHttpClient, NevoHttpClientOptions } from "./nevo-http.client";
+export interface HttpClientFactoryOptions extends NevoHttpClientOptions {
+    clientIdPrefix: string;
+}
+export declare const createNevoHttpClient: (serviceUrls: Record<string, string>, options: HttpClientFactoryOptions) => {
+    provide: string;
+    useFactory: () => Promise<NevoHttpClient>;
+};

package/dist/transports/http/http.config.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNevoHttpClient = void 0;
+const nevo_http_client_1 = require("./nevo-http.client");
+const createNevoHttpClient = (serviceUrls, options) => {
+    return {
+        provide: "NEVO_HTTP_CLIENT",
+        useFactory: async () => {
+            return new nevo_http_client_1.NevoHttpClient(serviceUrls, {
+                ...options,
+                serviceName: options.serviceName || options.clientIdPrefix
+            });
+        }
+    };
+};
+exports.createNevoHttpClient = createNevoHttpClient;

package/dist/transports/http/http.signal-router.decorator.d.ts

@@ -0,0 +1,3 @@
+import { Type } from "@nestjs/common";
+import { SignalRouterOptions } from "../../signal-router.utils";
+export declare function HttpSignalRouter(serviceType: Type<any> | Type<any>[], options?: SignalRouterOptions): (target: any) => any;

package/dist/transports/http/http.signal-router.decorator.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpSignalRouter = HttpSignalRouter;
+const common_1 = require("@nestjs/common");
+const signal_router_utils_1 = require("../../signal-router.utils");
+function HttpSignalRouter(serviceType, options) {
+    return (0, signal_router_utils_1.createSignalRouterDecorator)(serviceType, options, (data) => {
+        const messageData = data || {};
+        return {
+            method: messageData.method,
+            params: messageData.params,
+            uuid: messageData.uuid,
+            meta: messageData.meta
+        };
+    }, (target, eventPattern, handlerName) => {
+        (0, common_1.Post)(`/${eventPattern}`)(target.prototype, handlerName, Object.getOwnPropertyDescriptor(target.prototype, handlerName));
+    });
+}

package/dist/transports/http/http.transport.controller.d.ts

@@ -0,0 +1,21 @@
+import { Observable } from "rxjs";
+export declare class HttpTransportController {
+    streamDiscovery(): Observable<{
+        data: string;
+    }>;
+    publishDiscovery(payload: any): {
+        ok: boolean;
+    };
+    streamSubscription(service: string): Observable<{
+        data: string;
+    }>;
+    publishSubscription(payload: any): {
+        ok: boolean;
+    };
+    streamBroadcast(): Observable<{
+        data: string;
+    }>;
+    publishBroadcast(payload: any): {
+        ok: boolean;
+    };
+}