@opra/common 1.19.4 → 1.19.7

package/esm/document/factory/api-document.factory.js

@@ -8,7 +8,7 @@ import * as extendedTypes from '../data-type/extended-types/index.js';
 import * as primitiveTypes from '../data-type/primitive-types/index.js';
 import { DataTypeFactory } from './data-type.factory.js';
 import { HttpApiFactory } from './http-api.factory.js';
-import { RpcApiFactory } from './rpc-api.factory.js';
+import { MQApiFactory } from './mq-api.factory.js';
 const OPRA_SPEC_URL = 'https://oprajs.com/spec/v' + OpraSchema.SpecVersion;
 /**
  * @class ApiDocumentFactory
@@ -119,8 +119,8 @@ export class ApiDocumentFactory {
                     if (api)
                         document.api = api;
                 }
-                else if (init.api && init.api.transport === 'rpc') {
-                    const api = await RpcApiFactory.createApi(context, {
+                else if (init.api && init.api.transport === 'mq') {
+                    const api = await MQApiFactory.createApi(context, {
                         ...init.api,
                         owner: document,
                     });

package/esm/document/factory/{rpc-api.factory.js → mq-api.factory.js}

@@ -1,23 +1,23 @@
 import { isConstructor } from '@jsopen/objects';
 import { resolveThunk } from '../../helpers/index.js';
-import { RPC_CONTROLLER_METADATA } from '../constants.js';
-import { RpcApi } from '../rpc/rpc-api.js';
-import { RpcController } from '../rpc/rpc-controller.js';
-import { RpcHeader } from '../rpc/rpc-header.js';
-import { RpcOperation } from '../rpc/rpc-operation.js';
-import { RpcOperationResponse } from '../rpc/rpc-operation-response.js';
+import { MQ_CONTROLLER_METADATA } from '../constants.js';
+import { MQApi } from '../mq/mq-api.js';
+import { MQController } from '../mq/mq-controller.js';
+import { MQHeader } from '../mq/mq-header.js';
+import { MQOperation } from '../mq/mq-operation.js';
+import { MQOperationResponse } from '../mq/mq-operation-response.js';
 import { DataTypeFactory } from './data-type.factory.js';
 /**
- * @class RpcApiFactory
+ * @class MQApiFactory
  */
-export class RpcApiFactory {
+export class MQApiFactory {
     /**
-     * Generates RpcApi
+     * Generates MQApi
      * @param context
      * @param init
      */
     static async createApi(context, init) {
-        const api = new RpcApi(init);
+        const api = new MQApi(init);
         if (init.controllers) {
             await context.enterAsync('.controllers', async () => {
                 if (Array.isArray(init.controllers)) {
@@ -48,15 +48,15 @@ export class RpcApiFactory {
         let instance;
         // If thunk is a class
         if (typeof thunk === 'function') {
-            metadata = Reflect.getMetadata(RPC_CONTROLLER_METADATA, thunk);
+            metadata = Reflect.getMetadata(MQ_CONTROLLER_METADATA, thunk);
             if (!metadata)
-                return context.addError(`Class "${thunk.name}" doesn't have a valid RpcController metadata`);
+                return context.addError(`Class "${thunk.name}" doesn't have a valid MQController metadata`);
             ctor = thunk;
         }
         else {
-            // If thunk is an instance of a class decorated with RpcController()
+            // If thunk is an instance of a class decorated with MQController()
             ctor = Object.getPrototypeOf(thunk).constructor;
-            metadata = Reflect.getMetadata(RPC_CONTROLLER_METADATA, ctor);
+            metadata = Reflect.getMetadata(MQ_CONTROLLER_METADATA, ctor);
             if (metadata)
                 instance = thunk;
             else {
@@ -69,11 +69,11 @@ export class RpcApiFactory {
             }
         }
         if (!metadata)
-            return context.addError(`Class "${ctor.name}" is not decorated with RpcController()`);
+            return context.addError(`Class "${ctor.name}" is not decorated with MQController()`);
         name = name || metadata.name;
         if (!name)
             throw new TypeError(`Controller name required`);
-        const controller = new RpcController(parent, {
+        const controller = new MQController(parent, {
             ...metadata,
             name,
             instance,
@@ -99,7 +99,7 @@ export class RpcApiFactory {
                             if (!prmArgs.type)
                                 prmArgs.type = controller.node.getDataType('any');
                         });
-                        const prm = new RpcHeader(controller, prmArgs);
+                        const prm = new MQHeader(controller, prmArgs);
                         controller.headers.push(prm);
                     });
                 }
@@ -109,14 +109,14 @@ export class RpcApiFactory {
             await context.enterAsync('.operations', async () => {
                 for (const [operationName, operationMeta] of Object.entries(metadata.operations)) {
                     await context.enterAsync(`[${operationName}]`, async () => {
-                        const operation = new RpcOperation(controller, {
+                        const operation = new MQOperation(controller, {
                             ...operationMeta,
                             name: operationName,
                             types: undefined,
                             payloadType: undefined,
                             keyType: undefined,
                         });
-                        await this._initRpcOperation(context, operation, operationMeta);
+                        await this._initMQOperation(context, operation, operationMeta);
                         controller.operations.set(operation.name, operation);
                     });
                 }
@@ -125,13 +125,13 @@ export class RpcApiFactory {
         return controller;
     }
     /**
-     * Initializes RpcOperation
+     * Initializes MQOperation
      * @param context
      * @param operation
      * @param metadata
      * @protected
      */
-    static async _initRpcOperation(context, operation, metadata) {
+    static async _initMQOperation(context, operation, metadata) {
         if (metadata.types) {
             await context.enterAsync('.types', async () => {
                 await DataTypeFactory.addDataTypes(context, operation, metadata.types);
@@ -150,7 +150,7 @@ export class RpcApiFactory {
                         await context.enterAsync('.type', async () => {
                             prmArgs.type = await DataTypeFactory.resolveDataType(context, operation, v.type);
                         });
-                        const prm = new RpcHeader(operation, prmArgs);
+                        const prm = new MQHeader(operation, prmArgs);
                         operation.headers.push(prm);
                     });
                 }
@@ -158,24 +158,24 @@ export class RpcApiFactory {
         }
         if (metadata.response) {
             await context.enterAsync('.response', async () => {
-                const response = new RpcOperationResponse(operation, {
+                const response = new MQOperationResponse(operation, {
                     ...metadata.response,
                     payloadType: undefined,
                     keyType: undefined,
                 });
-                await this._initRpcOperationResponse(context, response, metadata.response);
+                await this._initMQOperationResponse(context, response, metadata.response);
                 operation.response = response;
             });
         }
     }
     /**
-     * Initializes RpcOperationResponse
+     * Initializes MQOperationResponse
      * @param context
      * @param response
      * @param metadata
      * @protected
      */
-    static async _initRpcOperationResponse(context, response, metadata) {
+    static async _initMQOperationResponse(context, response, metadata) {
         response.payloadType = await DataTypeFactory.resolveDataType(context, response, metadata.payloadType);
         if (metadata.keyType) {
             response.keyType = await DataTypeFactory.resolveDataType(context, response, metadata.keyType);
@@ -189,7 +189,7 @@ export class RpcApiFactory {
                         await context.enterAsync('.type', async () => {
                             prmArgs.type = await DataTypeFactory.resolveDataType(context, response, v.type);
                         });
-                        const prm = new RpcHeader(response, prmArgs);
+                        const prm = new MQHeader(response, prmArgs);
                         response.headers.push(prm);
                     });
                 }

package/esm/document/factory/ws-api.factory.js

@@ -0,0 +1,119 @@
+import { isConstructor } from '@jsopen/objects';
+import { resolveThunk } from '../../helpers/index.js';
+import { WS_CONTROLLER_METADATA } from '../constants.js';
+import { WSApi } from '../ws/ws-api.js';
+import { WSController } from '../ws/ws-controller.js';
+import { WSOperation } from '../ws/ws-operation.js';
+import { DataTypeFactory } from './data-type.factory.js';
+/**
+ * @class WSApiFactory
+ */
+export class WSApiFactory {
+    /**
+     * Generates MQApi
+     * @param context
+     * @param init
+     */
+    static async createApi(context, init) {
+        const api = new WSApi(init);
+        if (init.controllers) {
+            await context.enterAsync('.controllers', async () => {
+                if (Array.isArray(init.controllers)) {
+                    for (const c of init.controllers) {
+                        const controller = await this._createController(context, api, c);
+                        if (controller)
+                            api.controllers.set(controller.name, controller);
+                    }
+                }
+                else {
+                    for (const [k, v] of Object.entries(init.controllers)) {
+                        const controller = await this._createController(context, api, v, k);
+                        if (controller)
+                            api.controllers.set(controller.name, controller);
+                    }
+                }
+            });
+        }
+        return api;
+    }
+    static async _createController(context, parent, thunk, name) {
+        if (typeof thunk === 'function' && !isConstructor(thunk)) {
+            thunk = thunk();
+        }
+        thunk = await resolveThunk(thunk);
+        let ctor;
+        let metadata;
+        let instance;
+        // If thunk is a class
+        if (typeof thunk === 'function') {
+            metadata = Reflect.getMetadata(WS_CONTROLLER_METADATA, thunk);
+            if (!metadata)
+                return context.addError(`Class "${thunk.name}" doesn't have a valid WSController metadata`);
+            ctor = thunk;
+        }
+        else {
+            // If thunk is an instance of a class decorated with WSController()
+            ctor = Object.getPrototypeOf(thunk).constructor;
+            metadata = Reflect.getMetadata(WS_CONTROLLER_METADATA, ctor);
+            if (metadata)
+                instance = thunk;
+            else {
+                // If thunk is a DecoratorMetadata or InitArguments
+                metadata = thunk;
+                if (thunk.instance === 'object') {
+                    instance = thunk.instance;
+                    ctor = Object.getPrototypeOf(instance).constructor;
+                }
+            }
+        }
+        if (!metadata)
+            return context.addError(`Class "${ctor.name}" is not decorated with WSController()`);
+        name = name || metadata.name;
+        if (!name)
+            throw new TypeError(`Controller name required`);
+        const controller = new WSController(parent, {
+            ...metadata,
+            name,
+            instance,
+            ctor,
+        });
+        if (metadata.types) {
+            await context.enterAsync('.types', async () => {
+                await DataTypeFactory.addDataTypes(context, controller, metadata.types);
+            });
+        }
+        if (metadata.operations) {
+            await context.enterAsync('.operations', async () => {
+                for (const [operationName, operationMeta] of Object.entries(metadata.operations)) {
+                    await context.enterAsync(`[${operationName}]`, async () => {
+                        const operation = new WSOperation(controller, {
+                            ...operationMeta,
+                            name: operationName,
+                            types: undefined,
+                            payloadType: undefined,
+                            keyType: undefined,
+                        });
+                        await this._initWSOperation(context, operation, operationMeta);
+                        controller.operations.set(operation.name, operation);
+                    });
+                }
+            });
+        }
+        return controller;
+    }
+    /**
+     * Initializes WSOperation
+     * @param context
+     * @param operation
+     * @param metadata
+     * @protected
+     */
+    static async _initWSOperation(context, operation, metadata) {
+        if (metadata.types) {
+            await context.enterAsync('.types', async () => {
+                await DataTypeFactory.addDataTypes(context, operation, metadata.types);
+            });
+        }
+        operation.payloadType = await DataTypeFactory.resolveDataType(context, operation, metadata.payloadType);
+    }
+}

package/esm/document/index.js

@@ -8,8 +8,10 @@ import './decorators/http-operation-entity-get.decorator.js';
 import './decorators/http-operation-entity-replace.decorator.js';
 import './decorators/http-operation-entity-update.decorator.js';
 import './decorators/http-operation-entity-update-many.decorator.js';
-import * as RpcControllerDecorator_ from './decorators/rpc-controller.decorator.js';
-import * as RpcOperationDecorator_ from './decorators/rpc-operation.decorator.js';
+import * as MQControllerDecorator_ from './decorators/mq-controller.decorator.js';
+import * as MQOperationDecorator_ from './decorators/mq-operation.decorator.js';
+import * as WSControllerDecorator_ from './decorators/ws-controller.decorator.js';
+import * as WSOperationDecorator_ from './decorators/ws-operation.decorator.js';
 import * as DataTypeFactory_ from './factory/data-type.factory.js';
 import * as HttpApiFactory_ from './factory/http-api.factory.js';
 export * from './api-document.js';
@@ -44,14 +46,19 @@ export * from './http/http-operation-response.js';
 export * from './http/http-parameter.js';
 export * from './http/http-request-body.js';
 export * from './http/http-status-range.js';
-export * from './rpc/rpc-api.js';
-export * from './rpc/rpc-controller.js';
-export * from './rpc/rpc-header.js';
-export * from './rpc/rpc-operation.js';
+export * from './mq/mq-api.js';
+export * from './mq/mq-controller.js';
+export * from './mq/mq-header.js';
+export * from './mq/mq-operation.js';
+export * from './ws/ws-api.js';
+export * from './ws/ws-controller.js';
+export * from './ws/ws-operation.js';
 export var classes;
 (function (classes) {
     classes.HttpApiFactory = HttpApiFactory_.HttpApiFactory;
     classes.DataTypeFactory = DataTypeFactory_.DataTypeFactory;
-    classes.RpcOperationDecoratorFactory = RpcOperationDecorator_.RpcOperationDecoratorFactory;
-    classes.RpcControllerDecoratorFactory = RpcControllerDecorator_.RpcControllerDecoratorFactory;
+    classes.MQOperationDecoratorFactory = MQOperationDecorator_.MQOperationDecoratorFactory;
+    classes.MQControllerDecoratorFactory = MQControllerDecorator_.MQControllerDecoratorFactory;
+    classes.WSOperationDecoratorFactory = WSOperationDecorator_.WSOperationDecoratorFactory;
+    classes.WSControllerDecoratorFactory = WSControllerDecorator_.WSControllerDecoratorFactory;
 })(classes || (classes = {}));

package/esm/document/{rpc/rpc-api.js → mq/mq-api.js}

@@ -1,14 +1,14 @@
 import { ResponsiveMap } from '../../helpers/index.js';
 import { ApiBase } from '../common/api-base.js';
 /**
- * @class RpcApi
+ * @class MQApi
  */
-export class RpcApi extends ApiBase {
+export class MQApi extends ApiBase {
     constructor(init) {
         super(init);
         // noinspection JSUnusedGlobalSymbols
         this._controllerReverseMap = new WeakMap();
-        this.transport = 'rpc';
+        this.transport = 'mq';
         this.controllers = new ResponsiveMap();
         this.platform = init.platform;
     }

package/esm/document/{rpc/rpc-controller.js → mq/mq-controller.js}

@@ -5,22 +5,22 @@ import { OpraSchema } from '../../schema/index.js';
 import { DataTypeMap } from '../common/data-type-map.js';
 import { DocumentElement } from '../common/document-element.js';
 import { CLASS_NAME_PATTERN, DECORATOR, kDataTypeMap } from '../constants.js';
-import { RpcControllerDecoratorFactory } from '../decorators/rpc-controller.decorator.js';
+import { MQControllerDecoratorFactory } from '../decorators/mq-controller.decorator.js';
 import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom, } from '../utils/inspect.util.js';
 /**
- * RpcController
+ * MQController
  */
-export const RpcController = function (...args) {
+export const MQController = function (...args) {
     // ClassDecorator
     if (!this)
-        return RpcController[DECORATOR].apply(undefined, args);
+        return MQController[DECORATOR].apply(undefined, args);
     // Constructor
     const [owner, initArgs] = args;
     DocumentElement.call(this, owner);
     if (!CLASS_NAME_PATTERN.test(initArgs.name))
         throw new TypeError(`Invalid resource name (${initArgs.name})`);
     const _this = asMutable(this);
-    _this.kind = OpraSchema.RpcController.Kind;
+    _this.kind = OpraSchema.MQController.Kind;
     _this.types = _this.node[kDataTypeMap] = new DataTypeMap();
     _this.operations = new ResponsiveMap();
     _this.headers = [];
@@ -33,9 +33,9 @@ export const RpcController = function (...args) {
 };
 /**
  *
- * @class RpcController
+ * @class MQController
  */
-class RpcControllerClass extends DocumentElement {
+class MQControllerClass extends DocumentElement {
     findHeader(paramName, location) {
         const paramNameLower = paramName.toLowerCase();
         let prm;
@@ -48,7 +48,7 @@ class RpcControllerClass extends DocumentElement {
             if (prm.name instanceof RegExp && prm.name.test(paramName))
                 return prm;
         }
-        if (this.node.parent && this.node.parent.element instanceof RpcController) {
+        if (this.node.parent && this.node.parent.element instanceof MQController) {
             return this.node.parent.element.findHeader(paramName, location);
         }
     }
@@ -56,7 +56,7 @@ class RpcControllerClass extends DocumentElement {
      *
      */
     toString() {
-        return `[RpcController ${this.name}]`;
+        return `[MQController ${this.name}]`;
     }
     /**
      *
@@ -90,9 +90,9 @@ class RpcControllerClass extends DocumentElement {
      *
      */
     [nodeInspectCustom]() {
-        return `[${colorFgYellow}RpcController${colorFgMagenta + this.name + colorReset}]`;
+        return `[${colorFgYellow}MQController${colorFgMagenta + this.name + colorReset}]`;
     }
 }
-RpcController.prototype = RpcControllerClass.prototype;
-Object.assign(RpcController, RpcControllerDecoratorFactory);
-RpcController[DECORATOR] = RpcControllerDecoratorFactory;
+MQController.prototype = MQControllerClass.prototype;
+Object.assign(MQController, MQControllerDecoratorFactory);
+MQController[DECORATOR] = MQControllerDecoratorFactory;

package/esm/document/{rpc/rpc-header.js → mq/mq-header.js}

@@ -2,7 +2,7 @@ import { omitUndefined } from '@jsopen/objects';
 import { asMutable, } from 'ts-gems';
 import { Value } from '../common/value.js';
 import { parseRegExp } from '../utils/parse-regexp.util.js';
-export const RpcHeader = function (owner, initArgs) {
+export const MQHeader = function (owner, initArgs) {
     if (!this)
         throw new TypeError('"this" should be passed to call class constructor');
     Value.call(this, owner, initArgs);
@@ -22,9 +22,9 @@ export const RpcHeader = function (owner, initArgs) {
     _this.required = initArgs.required;
 };
 /**
- * @class RpcHeader
+ * @class MQHeader
  */
-class RpcHeaderClass extends Value {
+class MQHeaderClass extends Value {
     toJSON() {
         return omitUndefined({
             ...super.toJSON(),
@@ -34,4 +34,4 @@ class RpcHeaderClass extends Value {
         });
     }
 }
-RpcHeader.prototype = RpcHeaderClass.prototype;
+MQHeader.prototype = MQHeaderClass.prototype;

package/esm/document/{rpc/rpc-operation-response.js → mq/mq-operation-response.js}

@@ -2,9 +2,9 @@ import { omitUndefined } from '@jsopen/objects';
 import { DocumentElement } from '../common/document-element.js';
 import { DataType } from '../data-type/data-type.js';
 /**
- * @class RpcOperationResponse
+ * @class MQOperationResponse
  */
-export class RpcOperationResponse extends DocumentElement {
+export class MQOperationResponse extends DocumentElement {
     constructor(owner, initArgs) {
         super(owner);
         this.headers = [];

package/esm/document/{rpc/rpc-operation.js → mq/mq-operation.js}

@@ -5,16 +5,16 @@ import { DataTypeMap } from '../common/data-type-map.js';
 import { DocumentElement } from '../common/document-element.js';
 import { CLASS_NAME_PATTERN, DECORATOR, kDataTypeMap } from '../constants.js';
 import { DataType } from '../data-type/data-type.js';
-import { RpcOperationDecoratorFactory, } from '../decorators/rpc-operation.decorator.js';
+import { MQOperationDecoratorFactory, } from '../decorators/mq-operation.decorator.js';
 /**
- *  RpcOperation
+ *  MQOperation
  */
-export const RpcOperation = function (...args) {
+export const MQOperation = function (...args) {
     // Decorator
     if (!this) {
         const [payloadType, options] = args;
         const decoratorChain = [];
-        return RpcOperation[DECORATOR].call(undefined, decoratorChain, payloadType, options);
+        return MQOperation[DECORATOR].call(undefined, decoratorChain, payloadType, options);
     }
     // Constructor
     const [resource, initArgs] = args;
@@ -41,9 +41,9 @@ export const RpcOperation = function (...args) {
     }
 };
 /**
- * @class RpcOperation
+ * @class MQOperation
  */
-class RpcOperationClass extends DocumentElement {
+class MQOperationClass extends DocumentElement {
     findHeader(paramName) {
         const paramNameLower = paramName.toLowerCase();
         let prm;
@@ -59,7 +59,7 @@ class RpcOperationClass extends DocumentElement {
     }
     toJSON() {
         const out = omitUndefined({
-            kind: OpraSchema.RpcOperation.Kind,
+            kind: OpraSchema.MQOperation.Kind,
             description: this.description,
             channel: this.channel,
             payloadType: this.payloadType.name
@@ -81,5 +81,5 @@ class RpcOperationClass extends DocumentElement {
         return out;
     }
 }
-RpcOperation.prototype = RpcOperationClass.prototype;
-RpcOperation[DECORATOR] = RpcOperationDecoratorFactory;
+MQOperation.prototype = MQOperationClass.prototype;
+MQOperation[DECORATOR] = MQOperationDecoratorFactory;

package/esm/document/ws/ws-api.js

@@ -0,0 +1,48 @@
+import { ResponsiveMap } from '../../helpers/index.js';
+import { ApiBase } from '../common/api-base.js';
+/**
+ * @class WSApi
+ */
+export class WSApi extends ApiBase {
+    constructor(init) {
+        super(init);
+        // noinspection JSUnusedGlobalSymbols
+        this._controllerReverseMap = new WeakMap();
+        this.transport = 'ws';
+        this.controllers = new ResponsiveMap();
+    }
+    findController(arg0) {
+        if (typeof arg0 === 'function') {
+            /** Check for cached mapping */
+            const controller = this._controllerReverseMap.get(arg0);
+            if (controller != null)
+                return controller;
+            /** Lookup for ctor in all controllers */
+            for (const c of this.controllers.values()) {
+                if (c.ctor === arg0) {
+                    this._controllerReverseMap.set(arg0, c);
+                    return c;
+                }
+            }
+            this._controllerReverseMap.set(arg0, null);
+            return;
+        }
+        return this.controllers.get(arg0);
+    }
+    findOperation(arg0, operationName) {
+        const controller = this.findController(arg0);
+        return controller?.operations.get(operationName);
+    }
+    toJSON() {
+        const schema = super.toJSON();
+        const out = {
+            ...schema,
+            transport: this.transport,
+            controllers: {},
+        };
+        for (const v of this.controllers.values()) {
+            out.controllers[v.name] = v.toJSON();
+        }
+        return out;
+    }
+}

package/esm/document/ws/ws-controller.js

@@ -0,0 +1,75 @@
+import { omitUndefined } from '@jsopen/objects';
+import { asMutable } from 'ts-gems';
+import { ResponsiveMap } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { DataTypeMap } from '../common/data-type-map.js';
+import { DocumentElement } from '../common/document-element.js';
+import { CLASS_NAME_PATTERN, DECORATOR, kDataTypeMap } from '../constants.js';
+import { WSControllerDecoratorFactory } from '../decorators/ws-controller.decorator.js';
+import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom, } from '../utils/inspect.util.js';
+/**
+ * WSController
+ */
+export const WSController = function (...args) {
+    // ClassDecorator
+    if (!this)
+        return WSController[DECORATOR].apply(undefined, args);
+    // Constructor
+    const [owner, initArgs] = args;
+    DocumentElement.call(this, owner);
+    if (!CLASS_NAME_PATTERN.test(initArgs.name))
+        throw new TypeError(`Invalid resource name (${initArgs.name})`);
+    const _this = asMutable(this);
+    _this.kind = OpraSchema.WSController.Kind;
+    _this.types = _this.node[kDataTypeMap] = new DataTypeMap();
+    _this.operations = new ResponsiveMap();
+    _this.name = initArgs.name;
+    _this.description = initArgs.description;
+    _this.instance = initArgs.instance;
+    _this.ctor = initArgs.ctor;
+    _this._controllerReverseMap = new WeakMap();
+    _this._initialize?.(initArgs);
+};
+/**
+ *
+ * @class WSController
+ */
+class WSControllerClass extends DocumentElement {
+    /**
+     *
+     */
+    toString() {
+        return `[WSController ${this.name}]`;
+    }
+    /**
+     *
+     */
+    toJSON() {
+        const out = omitUndefined({
+            kind: this.kind,
+            description: this.description,
+        });
+        if (this.operations.size) {
+            out.operations = {};
+            for (const v of this.operations.values()) {
+                out.operations[v.name] = v.toJSON();
+            }
+        }
+        if (this.types.size) {
+            out.types = {};
+            for (const v of this.types.values()) {
+                out.types[v.name] = v.toJSON();
+            }
+        }
+        return out;
+    }
+    /**
+     *
+     */
+    [nodeInspectCustom]() {
+        return `[${colorFgYellow}WSController${colorFgMagenta + this.name + colorReset}]`;
+    }
+}
+WSController.prototype = WSControllerClass.prototype;
+Object.assign(WSController, WSControllerDecoratorFactory);
+WSController[DECORATOR] = WSControllerDecoratorFactory;