@opra/common 1.0.0-beta.3 → 1.0.0-beta.5

package/esm/document/api-document.js

@@ -7,7 +7,7 @@ import { DocumentElement } from './common/document-element.js';
 import { BUILTIN, kDataTypeMap, kTypeNSMap, NAMESPACE_PATTERN } from './constants.js';
 import { DataType } from './data-type/data-type.js';
 import { HttpApi } from './http/http-api.js';
-import { MsgApi } from './msg/msg-api.js';
+import { RpcApi } from './rpc/rpc-api.js';
 /**
  *
  * @class ApiDocument
@@ -49,9 +49,9 @@ export class ApiDocument extends DocumentElement {
         }
         return this.api;
     }
-    get msgApi() {
-        if (!(this.api && this.api instanceof MsgApi)) {
-            throw new TypeError('The document do not contains MsgApi instance');
+    get rpcApi() {
+        if (!(this.api && this.api instanceof RpcApi)) {
+            throw new TypeError('The document do not contains RpcApi instance');
         }
         return this.api;
     }

package/esm/document/constants.js

@@ -1,6 +1,6 @@
 export const DATATYPE_METADATA = Symbol.for('opra.type.metadata');
 export const HTTP_CONTROLLER_METADATA = Symbol('opra.http-controller.metadata');
-export const MSG_CONTROLLER_METADATA = Symbol('opra.msg-controller.metadata');
+export const RPC_CONTROLLER_METADATA = Symbol('opra.rpc-controller.metadata');
 export const DECODER = Symbol.for('opra.type.decoder');
 export const ENCODER = Symbol('opra.type.encoder');
 export const DECORATOR = Symbol.for('DECORATOR');

package/esm/document/decorators/{msg-controller.decorator.js → rpc-controller.decorator.js}

@@ -1,9 +1,10 @@
 import omit from 'lodash.omit';
 import merge from 'putil-merge';
 import { OpraSchema } from '../../schema/index.js';
-import { MSG_CONTROLLER_METADATA } from '../constants.js';
+import { RPC_CONTROLLER_METADATA } from '../constants.js';
 const CLASS_NAME_PATTERN = /^(.*)(Controller)$/;
-export function MsgControllerDecoratorFactory(options) {
+const augmentationRegistry = [];
+export function RpcControllerDecoratorFactory(options) {
     const decoratorChain = [];
     /**
      *
@@ -13,22 +14,22 @@ export function MsgControllerDecoratorFactory(options) {
         if (!name)
             name = CLASS_NAME_PATTERN.exec(target.name)?.[1] || target.name;
         const metadata = {};
-        const baseMetadata = Reflect.getOwnMetadata(MSG_CONTROLLER_METADATA, Object.getPrototypeOf(target));
+        const baseMetadata = Reflect.getOwnMetadata(RPC_CONTROLLER_METADATA, Object.getPrototypeOf(target));
         if (baseMetadata)
             merge(metadata, baseMetadata, { deep: true });
-        const oldMetadata = Reflect.getOwnMetadata(MSG_CONTROLLER_METADATA, target);
+        const oldMetadata = Reflect.getOwnMetadata(RPC_CONTROLLER_METADATA, target);
         if (oldMetadata)
             merge(metadata, oldMetadata, { deep: true });
         merge(metadata, {
-            kind: OpraSchema.MsgController.Kind,
+            kind: OpraSchema.RpcController.Kind,
             name,
             path: name,
             ...omit(options, ['kind', 'name', 'instance', 'endpoints', 'key']),
         }, { deep: true });
-        Reflect.defineMetadata(MSG_CONTROLLER_METADATA, metadata, target);
+        Reflect.defineMetadata(RPC_CONTROLLER_METADATA, metadata, target);
         for (const fn of decoratorChain)
-            fn(metadata);
-        Reflect.defineMetadata(MSG_CONTROLLER_METADATA, metadata, target);
+            fn(metadata, target);
+        Reflect.defineMetadata(RPC_CONTROLLER_METADATA, metadata, target);
     };
     /**
      *
@@ -56,5 +57,9 @@ export function MsgControllerDecoratorFactory(options) {
         });
         return decorator;
     };
+    augmentationRegistry.forEach(fn => fn(decorator, decoratorChain, options));
     return decorator;
 }
+RpcControllerDecoratorFactory.augment = function (fn) {
+    augmentationRegistry.push(fn);
+};

package/esm/document/decorators/{msg-operation.decorator.js → rpc-operation.decorator.js}

@@ -1,8 +1,8 @@
 import omit from 'lodash.omit';
 import { OpraSchema } from '../../schema/index.js';
-import { MSG_CONTROLLER_METADATA } from '../constants.js';
+import { RPC_CONTROLLER_METADATA } from '../constants.js';
 const augmentationRegistry = [];
-export function MsgOperationDecoratorFactory(decoratorChain, payloadType, options) {
+export function RpcOperationDecoratorFactory(decoratorChain, payloadType, options) {
     let inResponse = false;
     /**
      *
@@ -11,18 +11,18 @@ export function MsgOperationDecoratorFactory(decoratorChain, payloadType, option
         if (typeof propertyKey !== 'string')
             throw new TypeError(`Symbol properties can not be decorated`);
         const operationMetadata = {
-            kind: OpraSchema.MsgOperation.Kind,
+            kind: OpraSchema.RpcOperation.Kind,
             channel: propertyKey,
             ...omit(options, ['kind']),
             payloadType,
         };
-        const controllerMetadata = (Reflect.getOwnMetadata(MSG_CONTROLLER_METADATA, target.constructor) ||
+        const controllerMetadata = (Reflect.getOwnMetadata(RPC_CONTROLLER_METADATA, target.constructor) ||
             {});
         controllerMetadata.operations = controllerMetadata.operations || {};
         controllerMetadata.operations[propertyKey] = operationMetadata;
         for (const fn of decoratorChain)
             fn(operationMetadata, target, propertyKey);
-        Reflect.defineMetadata(MSG_CONTROLLER_METADATA, controllerMetadata, target.constructor);
+        Reflect.defineMetadata(RPC_CONTROLLER_METADATA, controllerMetadata, target.constructor);
     });
     /**
      *
@@ -71,6 +71,6 @@ export function MsgOperationDecoratorFactory(decoratorChain, payloadType, option
     augmentationRegistry.forEach(fn => fn(decorator, decoratorChain, payloadType, options));
     return decorator;
 }
-MsgOperationDecoratorFactory.augment = function (fn) {
+RpcOperationDecoratorFactory.augment = function (fn) {
     augmentationRegistry.push(fn);
 };

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

@@ -8,7 +8,7 @@ import { Base64Type, DateStringType, DateTimeStringType, DateTimeType, DateType,
 import { AnyType, BigintType, BooleanType, IntegerType, NullType, NumberType, ObjectType, StringType, } from '../data-type/primitive-types/index.js';
 import { DataTypeFactory } from './data-type.factory.js';
 import { HttpApiFactory } from './http-api.factory.js';
-import { MsgApiFactory } from './msg-api.factory.js';
+import { RpcApiFactory } from './rpc-api.factory.js';
 const OPRA_SPEC_URL = 'https://oprajs.com/spec/v' + OpraSchema.SpecVersion;
 /**
  * @class ApiDocumentFactory
@@ -114,8 +114,8 @@ export class ApiDocumentFactory {
                     if (api)
                         document.api = api;
                 }
-                else if (init.api && init.api.transport === 'msg') {
-                    const api = await MsgApiFactory.createApi(context, { ...init.api, owner: document });
+                else if (init.api && init.api.transport === 'rpc') {
+                    const api = await RpcApiFactory.createApi(context, { ...init.api, owner: document });
                     if (api)
                         document.api = api;
                 }

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

@@ -1,22 +1,22 @@
 import { isConstructor, resolveThunk } from '../../helpers/index.js';
-import { MSG_CONTROLLER_METADATA } from '../constants.js';
-import { MsgApi } from '../msg/msg-api.js';
-import { MsgController } from '../msg/msg-controller.js';
-import { MsgHeader } from '../msg/msg-header.js';
-import { MsgOperation } from '../msg/msg-operation.js';
-import { MsgOperationResponse } from '../msg/msg-operation-response.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 { DataTypeFactory } from './data-type.factory.js';
 /**
- * @class MsgApiFactory
+ * @class RpcApiFactory
  */
-export class MsgApiFactory {
+export class RpcApiFactory {
     /**
-     * Generates MsgApi
+     * Generates RpcApi
      * @param context
      * @param init
      */
     static async createApi(context, init) {
-        const api = new MsgApi(init);
+        const api = new RpcApi(init);
         if (init.controllers) {
             await context.enterAsync('.controllers', async () => {
                 if (Array.isArray(init.controllers)) {
@@ -47,15 +47,15 @@ export class MsgApiFactory {
         let instance;
         // If thunk is a class
         if (typeof thunk === 'function') {
-            metadata = Reflect.getMetadata(MSG_CONTROLLER_METADATA, thunk);
+            metadata = Reflect.getMetadata(RPC_CONTROLLER_METADATA, thunk);
             if (!metadata)
-                return context.addError(`Class "${thunk.name}" doesn't have a valid MsgController metadata`);
+                return context.addError(`Class "${thunk.name}" doesn't have a valid RpcController metadata`);
             ctor = thunk;
         }
         else {
-            // If thunk is an instance of a class decorated with MsgController()
+            // If thunk is an instance of a class decorated with RpcController()
             ctor = Object.getPrototypeOf(thunk).constructor;
-            metadata = Reflect.getMetadata(MSG_CONTROLLER_METADATA, ctor);
+            metadata = Reflect.getMetadata(RPC_CONTROLLER_METADATA, ctor);
             if (metadata)
                 instance = thunk;
             else {
@@ -68,11 +68,11 @@ export class MsgApiFactory {
             }
         }
         if (!metadata)
-            return context.addError(`Class "${ctor.name}" is not decorated with MsgController()`);
+            return context.addError(`Class "${ctor.name}" is not decorated with RpcController()`);
         name = name || metadata.name;
         if (!name)
             throw new TypeError(`Controller name required`);
-        const controller = new MsgController(parent, {
+        const controller = new RpcController(parent, {
             ...metadata,
             name,
             instance,
@@ -98,7 +98,7 @@ export class MsgApiFactory {
                             if (!prmArgs.type)
                                 prmArgs.type = controller.node.getDataType('any');
                         });
-                        const prm = new MsgHeader(controller, prmArgs);
+                        const prm = new RpcHeader(controller, prmArgs);
                         controller.headers.push(prm);
                     });
                 }
@@ -108,14 +108,14 @@ export class MsgApiFactory {
             await context.enterAsync('.operations', async () => {
                 for (const [operationName, operationMeta] of Object.entries(metadata.operations)) {
                     await context.enterAsync(`[${operationName}]`, async () => {
-                        const operation = new MsgOperation(controller, {
+                        const operation = new RpcOperation(controller, {
                             ...operationMeta,
                             name: operationName,
                             types: undefined,
                             payloadType: undefined,
                             keyType: undefined,
                         });
-                        await this._initMsgOperation(context, operation, operationMeta);
+                        await this._initRpcOperation(context, operation, operationMeta);
                         controller.operations.set(operation.name, operation);
                     });
                 }
@@ -124,13 +124,13 @@ export class MsgApiFactory {
         return controller;
     }
     /**
-     * Initializes MsgOperation
+     * Initializes RpcOperation
      * @param context
      * @param operation
      * @param metadata
      * @protected
      */
-    static async _initMsgOperation(context, operation, metadata) {
+    static async _initRpcOperation(context, operation, metadata) {
         if (metadata.types) {
             await context.enterAsync('.types', async () => {
                 await DataTypeFactory.addDataTypes(context, operation, metadata.types);
@@ -149,7 +149,7 @@ export class MsgApiFactory {
                         await context.enterAsync('.type', async () => {
                             prmArgs.type = await DataTypeFactory.resolveDataType(context, operation, v.type);
                         });
-                        const prm = new MsgHeader(operation, prmArgs);
+                        const prm = new RpcHeader(operation, prmArgs);
                         operation.headers.push(prm);
                     });
                 }
@@ -157,24 +157,24 @@ export class MsgApiFactory {
         }
         if (metadata.response) {
             await context.enterAsync('.response', async () => {
-                const response = new MsgOperationResponse(operation, {
+                const response = new RpcOperationResponse(operation, {
                     ...metadata.response,
                     payloadType: undefined,
                     keyType: undefined,
                 });
-                await this._initMsgOperationResponse(context, response, metadata.response);
+                await this._initRpcOperationResponse(context, response, metadata.response);
                 operation.response = response;
             });
         }
     }
     /**
-     * Initializes MsgOperationResponse
+     * Initializes RpcOperationResponse
      * @param context
      * @param response
      * @param metadata
      * @protected
      */
-    static async _initMsgOperationResponse(context, response, metadata) {
+    static async _initRpcOperationResponse(context, response, metadata) {
         response.payloadType = await DataTypeFactory.resolveDataType(context, response, metadata.payloadType);
         if (metadata.keyType) {
             response.keyType = await DataTypeFactory.resolveDataType(context, response, metadata.keyType);
@@ -188,7 +188,7 @@ export class MsgApiFactory {
                         await context.enterAsync('.type', async () => {
                             prmArgs.type = await DataTypeFactory.resolveDataType(context, response, v.type);
                         });
-                        const prm = new MsgHeader(response, prmArgs);
+                        const prm = new RpcHeader(response, prmArgs);
                         response.headers.push(prm);
                     });
                 }

package/esm/document/http/http-operation.js

@@ -74,6 +74,12 @@ class HttpOperationClass extends DocumentElement {
             composition: this.composition,
             requestBody: this.requestBody?.toJSON(),
         });
+        if (this.types.size) {
+            out.types = {};
+            for (const v of this.types.values()) {
+                out.types[v.name] = v.toJSON();
+            }
+        }
         if (this.parameters.length) {
             out.parameters = [];
             for (const prm of this.parameters) {

package/esm/document/index.js

@@ -1,5 +1,6 @@
 import 'reflect-metadata';
-import * as MsgOperationDecorator_ from './decorators/msg-operation.decorator.js';
+import * as RpcControllerDecorator_ from './decorators/rpc-controller.decorator.js';
+import * as RpcOperationDecorator_ from './decorators/rpc-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';
@@ -34,13 +35,14 @@ 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 './msg/msg-api.js';
-export * from './msg/msg-controller.js';
-export * from './msg/msg-header.js';
-export * from './msg/msg-operation.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 var classes;
 (function (classes) {
     classes.HttpApiFactory = HttpApiFactory_.HttpApiFactory;
     classes.DataTypeFactory = DataTypeFactory_.DataTypeFactory;
-    classes.MsgOperationDecoratorFactory = MsgOperationDecorator_.MsgOperationDecoratorFactory;
+    classes.RpcOperationDecoratorFactory = RpcOperationDecorator_.RpcOperationDecoratorFactory;
+    classes.RpcControllerDecoratorFactory = RpcControllerDecorator_.RpcControllerDecoratorFactory;
 })(classes || (classes = {}));

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

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

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

@@ -3,23 +3,23 @@ import { omitUndefined, 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, MSG_CONTROLLER_METADATA } from '../constants.js';
-import { MsgControllerDecoratorFactory } from '../decorators/msg-controller.decorator.js';
+import { CLASS_NAME_PATTERN, DECORATOR, kDataTypeMap, RPC_CONTROLLER_METADATA } from '../constants.js';
+import { RpcControllerDecoratorFactory } from '../decorators/rpc-controller.decorator.js';
 import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../utils/inspect.util.js';
 /**
- * MsgController
+ * RpcController
  */
-export const MsgController = function (...args) {
+export const RpcController = function (...args) {
     // ClassDecorator
     if (!this)
-        return MsgController[DECORATOR].apply(undefined, args);
+        return RpcController[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.MsgController.Kind;
+    _this.kind = OpraSchema.RpcController.Kind;
     _this.types = _this.node[kDataTypeMap] = new DataTypeMap();
     _this.operations = new ResponsiveMap();
     _this.headers = [];
@@ -34,9 +34,9 @@ export const MsgController = function (...args) {
 };
 /**
  *
- * @class MsgController
+ * @class RpcController
  */
-class MsgControllerClass extends DocumentElement {
+class RpcControllerClass extends DocumentElement {
     findHeader(paramName, location) {
         const paramNameLower = paramName.toLowerCase();
         let prm;
@@ -49,7 +49,7 @@ class MsgControllerClass extends DocumentElement {
             if (prm.name instanceof RegExp && prm.name.test(paramName))
                 return prm;
         }
-        if (this.node.parent && this.node.parent.element instanceof MsgController) {
+        if (this.node.parent && this.node.parent.element instanceof RpcController) {
             return this.node.parent.element.findHeader(paramName, location);
         }
     }
@@ -57,7 +57,7 @@ class MsgControllerClass extends DocumentElement {
      *
      */
     toString() {
-        return `[MsgController ${this.name}]`;
+        return `[RpcController ${this.name}]`;
     }
     /**
      *
@@ -91,23 +91,23 @@ class MsgControllerClass extends DocumentElement {
      *
      */
     [nodeInspectCustom]() {
-        return `[${colorFgYellow}MsgController${colorFgMagenta + this.name + colorReset}]`;
+        return `[${colorFgYellow}RpcController${colorFgMagenta + this.name + colorReset}]`;
     }
 }
-MsgController.prototype = MsgControllerClass.prototype;
-Object.assign(MsgController, MsgControllerDecoratorFactory);
-MsgController[DECORATOR] = MsgControllerDecoratorFactory;
-MsgController.OnInit = function () {
+RpcController.prototype = RpcControllerClass.prototype;
+Object.assign(RpcController, RpcControllerDecoratorFactory);
+RpcController[DECORATOR] = RpcControllerDecoratorFactory;
+RpcController.OnInit = function () {
     return (target, propertyKey) => {
-        const sourceMetadata = (Reflect.getOwnMetadata(MSG_CONTROLLER_METADATA, target.constructor) || {});
+        const sourceMetadata = (Reflect.getOwnMetadata(RPC_CONTROLLER_METADATA, target.constructor) || {});
         sourceMetadata.onInit = target[propertyKey];
-        Reflect.defineMetadata(MSG_CONTROLLER_METADATA, target.constructor, sourceMetadata);
+        Reflect.defineMetadata(RPC_CONTROLLER_METADATA, target.constructor, sourceMetadata);
     };
 };
-MsgController.OnShutdown = function () {
+RpcController.OnShutdown = function () {
     return (target, propertyKey) => {
-        const sourceMetadata = (Reflect.getOwnMetadata(MSG_CONTROLLER_METADATA, target.constructor) || {});
+        const sourceMetadata = (Reflect.getOwnMetadata(RPC_CONTROLLER_METADATA, target.constructor) || {});
         sourceMetadata.onShutdown = target[propertyKey];
-        Reflect.defineMetadata(MSG_CONTROLLER_METADATA, target.constructor, sourceMetadata);
+        Reflect.defineMetadata(RPC_CONTROLLER_METADATA, target.constructor, sourceMetadata);
     };
 };

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

@@ -2,7 +2,7 @@ import { asMutable } from 'ts-gems';
 import { omitUndefined } from '../../helpers/index.js';
 import { Value } from '../common/value.js';
 import { parseRegExp } from '../utils/parse-regexp.util.js';
-export const MsgHeader = function (owner, initArgs) {
+export const RpcHeader = 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 MsgHeader = function (owner, initArgs) {
     _this.required = initArgs.required;
 };
 /**
- * @class MsgHeader
+ * @class RpcHeader
  */
-class MsgHeaderClass extends Value {
+class RpcHeaderClass extends Value {
     toJSON() {
         return omitUndefined({
             ...super.toJSON(),
@@ -34,4 +34,4 @@ class MsgHeaderClass extends Value {
         });
     }
 }
-MsgHeader.prototype = MsgHeaderClass.prototype;
+RpcHeader.prototype = RpcHeaderClass.prototype;

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

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

package/esm/document/{msg/msg-operation.js → rpc/rpc-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 { MsgOperationDecoratorFactory } from '../decorators/msg-operation.decorator.js';
+import { RpcOperationDecoratorFactory } from '../decorators/rpc-operation.decorator.js';
 /**
- *  MsgOperation
+ *  RpcOperation
  */
-export const MsgOperation = function (...args) {
+export const RpcOperation = function (...args) {
     // Decorator
     if (!this) {
         const [payloadType, options] = args;
         const decoratorChain = [];
-        return MsgOperation[DECORATOR].call(undefined, decoratorChain, payloadType, options);
+        return RpcOperation[DECORATOR].call(undefined, decoratorChain, payloadType, options);
     }
     // Constructor
     const [resource, initArgs] = args;
@@ -39,9 +39,9 @@ export const MsgOperation = function (...args) {
     }
 };
 /**
- * @class MsgOperation
+ * @class RpcOperation
  */
-class MsgOperationClass extends DocumentElement {
+class RpcOperationClass extends DocumentElement {
     findHeader(paramName) {
         const paramNameLower = paramName.toLowerCase();
         let prm;
@@ -57,7 +57,7 @@ class MsgOperationClass extends DocumentElement {
     }
     toJSON() {
         const out = omitUndefined({
-            kind: OpraSchema.MsgOperation.Kind,
+            kind: OpraSchema.RpcOperation.Kind,
             description: this.description,
             channel: this.channel,
             payloadType: this.payloadType.name ? this.payloadType.name : this.payloadType.toJSON(),
@@ -73,5 +73,5 @@ class MsgOperationClass extends DocumentElement {
         return out;
     }
 }
-MsgOperation.prototype = MsgOperationClass.prototype;
-MsgOperation[DECORATOR] = MsgOperationDecoratorFactory;
+RpcOperation.prototype = RpcOperationClass.prototype;
+RpcOperation[DECORATOR] = RpcOperationDecoratorFactory;

package/esm/schema/opra-schema.js

@@ -16,9 +16,9 @@ export * from './http/http-operation-response.interface.js';
 export * from './http/http-parameter.interface.js';
 export * from './http/http-request-body.interface.js';
 export * from './http/http-status-range.interface.js';
-export * from './msg/msg-controller.interface.js';
-export * from './msg/msg-header.interface.js';
-export * from './msg/msg-operation.interface.js';
+export * from './rpc/rpc-controller.interface.js';
+export * from './rpc/rpc-header.interface.js';
+export * from './rpc/rpc-operation.interface.js';
 export * from './type-guards.js';
 export * from './types.js';
 export * from './value.interface.js';

package/esm/schema/rpc/rpc-controller.interface.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @namespace RpcController
+ */
+export var RpcController;
+(function (RpcController) {
+    RpcController.Kind = 'RpcController';
+})(RpcController || (RpcController = {}));

package/esm/schema/rpc/rpc-operation.interface.js

@@ -0,0 +1,4 @@
+export var RpcOperation;
+(function (RpcOperation) {
+    RpcOperation.Kind = 'RpcOperation';
+})(RpcOperation || (RpcOperation = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "1.0.0-beta.3",
+  "version": "1.0.0-beta.5",
   "description": "Opra common package",
   "author": "Panates",
   "license": "MIT",

package/types/document/api-document.d.ts

@@ -7,7 +7,7 @@ import { kTypeNSMap } from './constants.js';
 import { DataType } from './data-type/data-type.js';
 import type { EnumType } from './data-type/enum-type.js';
 import { HttpApi } from './http/http-api.js';
-import { MsgApi } from './msg/msg-api.js';
+import { RpcApi } from './rpc/rpc-api.js';
 /**
  *
  * @class ApiDocument
@@ -19,7 +19,7 @@ export declare class ApiDocument extends DocumentElement {
     info: OpraSchema.DocumentInfo;
     references: ResponsiveMap<ApiDocument>;
     types: DataTypeMap;
-    api?: HttpApi | MsgApi;
+    api?: HttpApi | RpcApi;
     constructor();
     /**
      * Returns NS of datatype. Returns undefined if not found
@@ -28,7 +28,7 @@ export declare class ApiDocument extends DocumentElement {
     getDataTypeNs(nameOrCtor: string | Type | Function | EnumType.EnumArray | EnumType.EnumObject | DataType): string | undefined;
     findDocument(id: string): ApiDocument | undefined;
     get httpApi(): HttpApi;
-    get msgApi(): MsgApi;
+    get rpcApi(): RpcApi;
     toJSON(): OpraSchema.ApiDocument;
     /**
      * Export as Opra schema definition object

package/types/document/constants.d.ts

@@ -1,6 +1,6 @@
 export declare const DATATYPE_METADATA: unique symbol;
 export declare const HTTP_CONTROLLER_METADATA: unique symbol;
-export declare const MSG_CONTROLLER_METADATA: unique symbol;
+export declare const RPC_CONTROLLER_METADATA: unique symbol;
 export declare const DECODER: unique symbol;
 export declare const ENCODER: unique symbol;
 export declare const DECORATOR: unique symbol;

package/types/document/decorators/rpc-controller.decorator.d.ts

@@ -0,0 +1,20 @@
+import type { TypeThunkAsync } from 'ts-gems';
+import type { RpcController } from '../rpc/rpc-controller';
+import type { RpcHeader } from '../rpc/rpc-header';
+export interface RpcControllerDecorator<T extends RpcControllerDecorator<any> = RpcControllerDecorator<any>> extends ClassDecorator {
+    Header(name: string | RegExp, optionsOrType?: RpcHeader.Options | string | TypeThunkAsync | false): T;
+    UseType(...type: TypeThunkAsync[]): T;
+}
+export interface RpcControllerDecoratorFactory {
+    <T extends RpcController.Options>(options?: T): RpcControllerDecorator;
+}
+/**
+ * @namespace RpcControllerDecoratorFactory
+ */
+export declare namespace RpcControllerDecoratorFactory {
+    type AugmentationFunction = (decorator: RpcControllerDecorator, decoratorChain: Function[], options?: RpcController.Options) => void;
+}
+export declare function RpcControllerDecoratorFactory<O extends RpcController.Options>(options?: O): RpcControllerDecorator;
+export declare namespace RpcControllerDecoratorFactory {
+    var augment: (fn: RpcControllerDecoratorFactory.AugmentationFunction) => void;
+}