@riaskov/nevo-messaging 1.0.1 → 1.1.1

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;
+    };
+}

package/dist/transports/http/http.transport.controller.js

@@ -0,0 +1,114 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpTransportController = void 0;
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const common_2 = require("../../common");
+class HttpSseBroker {
+    constructor() {
+        this.channels = new Map();
+    }
+    stream(channel) {
+        const subject = this.getChannel(channel);
+        return subject.asObservable().pipe((0, operators_1.map)((data) => ({ data })));
+    }
+    publish(channel, payload) {
+        const subject = this.getChannel(channel);
+        subject.next((0, common_2.stringifyWithBigInt)(payload));
+    }
+    getChannel(channel) {
+        let subject = this.channels.get(channel);
+        if (!subject) {
+            subject = new rxjs_1.Subject();
+            this.channels.set(channel, subject);
+        }
+        return subject;
+    }
+}
+const broker = new HttpSseBroker();
+let HttpTransportController = class HttpTransportController {
+    streamDiscovery() {
+        return broker.stream(common_2.DEFAULT_DISCOVERY_TOPIC);
+    }
+    publishDiscovery(payload) {
+        broker.publish(common_2.DEFAULT_DISCOVERY_TOPIC, payload);
+        return { ok: true };
+    }
+    streamSubscription(service) {
+        const channel = `${service.toLowerCase()}${common_2.DEFAULT_SUBSCRIPTION_SUFFIX}`;
+        return broker.stream(channel);
+    }
+    publishSubscription(payload) {
+        const serviceName = payload?.serviceName;
+        if (!serviceName) {
+            return { ok: false };
+        }
+        const channel = `${serviceName.toLowerCase()}${common_2.DEFAULT_SUBSCRIPTION_SUFFIX}`;
+        broker.publish(channel, payload);
+        return { ok: true };
+    }
+    streamBroadcast() {
+        return broker.stream(common_2.DEFAULT_BROADCAST_TOPIC);
+    }
+    publishBroadcast(payload) {
+        broker.publish(common_2.DEFAULT_BROADCAST_TOPIC, payload);
+        return { ok: true };
+    }
+};
+exports.HttpTransportController = HttpTransportController;
+__decorate([
+    (0, common_1.Sse)(`/${common_2.DEFAULT_DISCOVERY_TOPIC}`),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", rxjs_1.Observable)
+], HttpTransportController.prototype, "streamDiscovery", null);
+__decorate([
+    (0, common_1.Post)(`/${common_2.DEFAULT_DISCOVERY_TOPIC}`),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], HttpTransportController.prototype, "publishDiscovery", null);
+__decorate([
+    (0, common_1.Sse)(`/__nevo/subscribe`),
+    __param(0, (0, common_1.Query)("service")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", rxjs_1.Observable)
+], HttpTransportController.prototype, "streamSubscription", null);
+__decorate([
+    (0, common_1.Post)(`/__nevo/publish`),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], HttpTransportController.prototype, "publishSubscription", null);
+__decorate([
+    (0, common_1.Sse)(`/${common_2.DEFAULT_BROADCAST_TOPIC}`),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", rxjs_1.Observable)
+], HttpTransportController.prototype, "streamBroadcast", null);
+__decorate([
+    (0, common_1.Post)(`/${common_2.DEFAULT_BROADCAST_TOPIC}`),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], HttpTransportController.prototype, "publishBroadcast", null);
+exports.HttpTransportController = HttpTransportController = __decorate([
+    (0, common_1.Controller)()
+], HttpTransportController);

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

@@ -0,0 +1,5 @@
+export * from "./nevo-http.client";
+export * from "./http.client-base";
+export * from "./http.signal-router.decorator";
+export * from "./http.transport.controller";
+export * from "./http.config";

package/dist/transports/http/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./nevo-http.client"), exports);
+__exportStar(require("./http.client-base"), exports);
+__exportStar(require("./http.signal-router.decorator"), exports);
+__exportStar(require("./http.transport.controller"), exports);
+__exportStar(require("./http.config"), exports);