@opra/common 1.0.0-beta.2 → 1.0.0-beta.4

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

@@ -0,0 +1,198 @@
+import { isConstructor, 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 { DataTypeFactory } from './data-type.factory.js';
+/**
+ * @class RpcApiFactory
+ */
+export class RpcApiFactory {
+    /**
+     * Generates RpcApi
+     * @param context
+     * @param init
+     */
+    static async createApi(context, init) {
+        const api = new RpcApi(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(RPC_CONTROLLER_METADATA, thunk);
+            if (!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 RpcController()
+            ctor = Object.getPrototypeOf(thunk).constructor;
+            metadata = Reflect.getMetadata(RPC_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 RpcController()`);
+        name = name || metadata.name;
+        if (!name)
+            throw new TypeError(`Controller name required`);
+        const controller = new RpcController(parent, {
+            ...metadata,
+            name,
+            instance,
+            ctor,
+        });
+        if (metadata.types) {
+            await context.enterAsync('.types', async () => {
+                await DataTypeFactory.addDataTypes(context, controller, metadata.types);
+            });
+        }
+        if (metadata.headers) {
+            await context.enterAsync('.headers', async () => {
+                let i = 0;
+                for (const v of metadata.headers) {
+                    await context.enterAsync(`[${i++}]`, async () => {
+                        const prmArgs = { ...v };
+                        await context.enterAsync('.type', async () => {
+                            if (v.type)
+                                prmArgs.type = controller.node.findDataType(v.type);
+                            if (!prmArgs.type && typeof v.type === 'object') {
+                                prmArgs.type = await DataTypeFactory.createDataType(context, controller, v.type);
+                            }
+                            if (!prmArgs.type)
+                                prmArgs.type = controller.node.getDataType('any');
+                        });
+                        const prm = new RpcHeader(controller, prmArgs);
+                        controller.headers.push(prm);
+                    });
+                }
+            });
+        }
+        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 RpcOperation(controller, {
+                            ...operationMeta,
+                            name: operationName,
+                            types: undefined,
+                            payloadType: undefined,
+                            keyType: undefined,
+                        });
+                        await this._initRpcOperation(context, operation, operationMeta);
+                        controller.operations.set(operation.name, operation);
+                    });
+                }
+            });
+        }
+        return controller;
+    }
+    /**
+     * Initializes RpcOperation
+     * @param context
+     * @param operation
+     * @param metadata
+     * @protected
+     */
+    static async _initRpcOperation(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);
+        if (metadata.keyType) {
+            operation.keyType = await DataTypeFactory.resolveDataType(context, operation, metadata.keyType);
+        }
+        if (metadata.headers) {
+            await context.enterAsync('.headers', async () => {
+                let i = 0;
+                for (const v of metadata.headers) {
+                    await context.enterAsync(`[${i++}]`, async () => {
+                        const prmArgs = { ...v };
+                        await context.enterAsync('.type', async () => {
+                            prmArgs.type = await DataTypeFactory.resolveDataType(context, operation, v.type);
+                        });
+                        const prm = new RpcHeader(operation, prmArgs);
+                        operation.headers.push(prm);
+                    });
+                }
+            });
+        }
+        if (metadata.response) {
+            await context.enterAsync('.response', async () => {
+                const response = new RpcOperationResponse(operation, {
+                    ...metadata.response,
+                    payloadType: undefined,
+                    keyType: undefined,
+                });
+                await this._initRpcOperationResponse(context, response, metadata.response);
+                operation.response = response;
+            });
+        }
+    }
+    /**
+     * Initializes RpcOperationResponse
+     * @param context
+     * @param response
+     * @param metadata
+     * @protected
+     */
+    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);
+        }
+        if (metadata.headers) {
+            await context.enterAsync('.headers', async () => {
+                let i = 0;
+                for (const v of metadata.headers) {
+                    await context.enterAsync(`[${i++}]`, async () => {
+                        const prmArgs = { ...v };
+                        await context.enterAsync('.type', async () => {
+                            prmArgs.type = await DataTypeFactory.resolveDataType(context, response, v.type);
+                        });
+                        const prm = new RpcHeader(response, prmArgs);
+                        response.headers.push(prm);
+                    });
+                }
+            });
+        }
+    }
+}

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

@@ -5,12 +5,13 @@ import { HttpController } from './http-controller.js';
  * @class HttpApi
  */
 export class HttpApi extends ApiBase {
-    constructor(owner) {
-        super(owner);
+    constructor(init) {
+        super(init);
         // noinspection JSUnusedGlobalSymbols
         this._controllerReverseMap = new WeakMap();
-        this.protocol = 'http';
+        this.transport = 'http';
         this.controllers = new ResponsiveMap();
+        this.url = init.url;
     }
     findController(arg0) {
         return HttpController.prototype.findController.call(this, arg0);
@@ -23,7 +24,7 @@ export class HttpApi extends ApiBase {
         const schema = super.toJSON();
         const out = {
             ...schema,
-            protocol: this.protocol,
+            transport: this.transport,
             url: this.url,
             controllers: {},
         };

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

@@ -4,7 +4,7 @@ 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 } from '../constants.js';
+import { CLASS_NAME_PATTERN, DECORATOR, HTTP_CONTROLLER_METADATA, kDataTypeMap } from '../constants.js';
 import { HttpControllerDecoratorFactory } from '../decorators/http-controller.decorator.js';
 import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../utils/inspect.util.js';
 /**
@@ -32,6 +32,8 @@ export const HttpController = function (...args) {
     _this.ctor = initArgs.ctor;
     _this._controllerReverseMap = new WeakMap();
     _this._initialize?.(initArgs);
+    _this.onInit = initArgs.onInit;
+    _this.onShutdown = initArgs.onShutdown;
 };
 /**
  *
@@ -151,3 +153,17 @@ class HttpControllerClass extends DocumentElement {
 HttpController.prototype = HttpControllerClass.prototype;
 Object.assign(HttpController, HttpControllerDecoratorFactory);
 HttpController[DECORATOR] = HttpControllerDecoratorFactory;
+HttpController.OnInit = function () {
+    return (target, propertyKey) => {
+        const sourceMetadata = (Reflect.getOwnMetadata(HTTP_CONTROLLER_METADATA, target.constructor) || {});
+        sourceMetadata.onInit = target[propertyKey];
+        Reflect.defineMetadata(HTTP_CONTROLLER_METADATA, target.constructor, sourceMetadata);
+    };
+};
+HttpController.OnShutdown = function () {
+    return (target, propertyKey) => {
+        const sourceMetadata = (Reflect.getOwnMetadata(HTTP_CONTROLLER_METADATA, target.constructor) || {});
+        sourceMetadata.onShutdown = target[propertyKey];
+        Reflect.defineMetadata(HTTP_CONTROLLER_METADATA, target.constructor, sourceMetadata);
+    };
+};

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,4 +1,6 @@
 import 'reflect-metadata';
+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';
@@ -33,8 +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 './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.RpcOperationDecoratorFactory = RpcOperationDecorator_.RpcOperationDecoratorFactory;
+    classes.RpcControllerDecoratorFactory = RpcControllerDecorator_.RpcControllerDecoratorFactory;
 })(classes || (classes = {}));

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

@@ -0,0 +1,50 @@
+import { ResponsiveMap } from '../../helpers/index.js';
+import { ApiBase } from '../common/api-base.js';
+/**
+ * @class RpcApi
+ */
+export class RpcApi extends ApiBase {
+    constructor(init) {
+        super(init);
+        // noinspection JSUnusedGlobalSymbols
+        this._controllerReverseMap = new WeakMap();
+        this.transport = 'rpc';
+        this.controllers = new ResponsiveMap();
+        this.platform = init.platform;
+    }
+    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,
+            platform: this.platform,
+            controllers: {},
+        };
+        for (const v of this.controllers.values()) {
+            out.controllers[v.name] = v.toJSON();
+        }
+        return out;
+    }
+}

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

@@ -0,0 +1,113 @@
+import { asMutable } from 'ts-gems';
+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, RPC_CONTROLLER_METADATA } from '../constants.js';
+import { RpcControllerDecoratorFactory } from '../decorators/rpc-controller.decorator.js';
+import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../utils/inspect.util.js';
+/**
+ * RpcController
+ */
+export const RpcController = function (...args) {
+    // ClassDecorator
+    if (!this)
+        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.RpcController.Kind;
+    _this.types = _this.node[kDataTypeMap] = new DataTypeMap();
+    _this.operations = new ResponsiveMap();
+    _this.headers = [];
+    _this.name = initArgs.name;
+    _this.description = initArgs.description;
+    _this.instance = initArgs.instance;
+    _this.ctor = initArgs.ctor;
+    _this._controllerReverseMap = new WeakMap();
+    _this._initialize?.(initArgs);
+    _this.onInit = initArgs.onInit;
+    _this.onShutdown = initArgs.onShutdown;
+};
+/**
+ *
+ * @class RpcController
+ */
+class RpcControllerClass extends DocumentElement {
+    findHeader(paramName, location) {
+        const paramNameLower = paramName.toLowerCase();
+        let prm;
+        for (prm of this.headers) {
+            if (typeof prm.name === 'string') {
+                prm._nameLower = prm._nameLower || prm.name.toLowerCase();
+                if (prm._nameLower === paramNameLower)
+                    return prm;
+            }
+            if (prm.name instanceof RegExp && prm.name.test(paramName))
+                return prm;
+        }
+        if (this.node.parent && this.node.parent.element instanceof RpcController) {
+            return this.node.parent.element.findHeader(paramName, location);
+        }
+    }
+    /**
+     *
+     */
+    toString() {
+        return `[RpcController ${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();
+            }
+        }
+        if (this.headers.length) {
+            out.headers = [];
+            for (const prm of this.headers) {
+                out.headers.push(prm.toJSON());
+            }
+        }
+        return out;
+    }
+    /**
+     *
+     */
+    [nodeInspectCustom]() {
+        return `[${colorFgYellow}RpcController${colorFgMagenta + this.name + colorReset}]`;
+    }
+}
+RpcController.prototype = RpcControllerClass.prototype;
+Object.assign(RpcController, RpcControllerDecoratorFactory);
+RpcController[DECORATOR] = RpcControllerDecoratorFactory;
+RpcController.OnInit = function () {
+    return (target, propertyKey) => {
+        const sourceMetadata = (Reflect.getOwnMetadata(RPC_CONTROLLER_METADATA, target.constructor) || {});
+        sourceMetadata.onInit = target[propertyKey];
+        Reflect.defineMetadata(RPC_CONTROLLER_METADATA, target.constructor, sourceMetadata);
+    };
+};
+RpcController.OnShutdown = function () {
+    return (target, propertyKey) => {
+        const sourceMetadata = (Reflect.getOwnMetadata(RPC_CONTROLLER_METADATA, target.constructor) || {});
+        sourceMetadata.onShutdown = target[propertyKey];
+        Reflect.defineMetadata(RPC_CONTROLLER_METADATA, target.constructor, sourceMetadata);
+    };
+};

package/esm/document/rpc/rpc-header.js

@@ -0,0 +1,37 @@
+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 RpcHeader = function (owner, initArgs) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    Value.call(this, owner, initArgs);
+    const _this = asMutable(this);
+    if (initArgs.name) {
+        _this.name =
+            initArgs.name instanceof RegExp
+                ? initArgs.name
+                : initArgs.name.startsWith('/')
+                    ? parseRegExp(initArgs.name, {
+                        includeFlags: 'i',
+                        excludeFlags: 'm',
+                    })
+                    : initArgs.name;
+    }
+    _this.deprecated = initArgs.deprecated;
+    _this.required = initArgs.required;
+};
+/**
+ * @class RpcHeader
+ */
+class RpcHeaderClass extends Value {
+    toJSON() {
+        return omitUndefined({
+            ...super.toJSON(),
+            name: this.name,
+            required: this.required,
+            deprecated: this.deprecated,
+        });
+    }
+}
+RpcHeader.prototype = RpcHeaderClass.prototype;

package/esm/document/rpc/rpc-operation-response.js

@@ -0,0 +1,54 @@
+import { omitUndefined } from '../../helpers/index.js';
+import { DocumentElement } from '../common/document-element.js';
+import { DataType } from '../data-type/data-type.js';
+/**
+ * @class RpcOperationResponse
+ */
+export class RpcOperationResponse extends DocumentElement {
+    constructor(owner, initArgs) {
+        super(owner);
+        this.headers = [];
+        this.channel = initArgs?.channel;
+        this.description = initArgs?.description;
+        if (initArgs?.payloadType) {
+            this.payloadType =
+                initArgs?.payloadType instanceof DataType
+                    ? initArgs.payloadType
+                    : this.owner.node.getDataType(initArgs.payloadType);
+        }
+        else
+            this.payloadType = this.owner.node.getDataType('any');
+        if (initArgs?.keyType) {
+            this.keyType =
+                initArgs?.keyType instanceof DataType ? initArgs.keyType : this.owner.node.getDataType(initArgs.keyType);
+        }
+    }
+    findHeader(paramName) {
+        const paramNameLower = paramName.toLowerCase();
+        let prm;
+        for (prm of this.headers) {
+            if (typeof prm.name === 'string') {
+                prm._nameLower = prm._nameLower || prm.name.toLowerCase();
+                if (prm._nameLower === paramNameLower)
+                    return prm;
+            }
+            if (prm.name instanceof RegExp && prm.name.test(paramName))
+                return prm;
+        }
+    }
+    toJSON() {
+        const out = omitUndefined({
+            description: this.description,
+            channel: this.channel,
+            payloadType: this.payloadType.name ? this.payloadType.name : this.payloadType.toJSON(),
+            keyType: this.keyType ? (this.keyType.name ? this.keyType.name : this.keyType.toJSON()) : undefined,
+        });
+        if (this.headers.length) {
+            out.headers = [];
+            for (const prm of this.headers) {
+                out.headers.push(prm.toJSON());
+            }
+        }
+        return out;
+    }
+}

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

@@ -0,0 +1,77 @@
+import { asMutable } from 'ts-gems';
+import { omitUndefined } 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 { DataType } from '../data-type/data-type.js';
+import { RpcOperationDecoratorFactory } from '../decorators/rpc-operation.decorator.js';
+/**
+ *  RpcOperation
+ */
+export const RpcOperation = function (...args) {
+    // Decorator
+    if (!this) {
+        const [payloadType, options] = args;
+        const decoratorChain = [];
+        return RpcOperation[DECORATOR].call(undefined, decoratorChain, payloadType, options);
+    }
+    // Constructor
+    const [resource, initArgs] = args;
+    DocumentElement.call(this, resource);
+    if (!CLASS_NAME_PATTERN.test(initArgs.name))
+        throw new TypeError(`Invalid operation name (${initArgs.name})`);
+    const _this = asMutable(this);
+    _this.headers = [];
+    _this.types = _this.node[kDataTypeMap] = new DataTypeMap();
+    _this.name = initArgs.name;
+    _this.description = initArgs.description;
+    _this.channel = initArgs.channel;
+    if (initArgs?.payloadType) {
+        _this.payloadType =
+            initArgs?.payloadType instanceof DataType
+                ? initArgs.payloadType
+                : _this.owner.node.getDataType(initArgs.payloadType);
+    }
+    if (initArgs?.keyType) {
+        _this.keyType =
+            initArgs?.keyType instanceof DataType ? initArgs.keyType : _this.owner.node.getDataType(initArgs.keyType);
+    }
+};
+/**
+ * @class RpcOperation
+ */
+class RpcOperationClass extends DocumentElement {
+    findHeader(paramName) {
+        const paramNameLower = paramName.toLowerCase();
+        let prm;
+        for (prm of this.headers) {
+            if (typeof prm.name === 'string') {
+                prm._nameLower = prm._nameLower || prm.name.toLowerCase();
+                if (prm._nameLower === paramNameLower)
+                    return prm;
+            }
+            if (prm.name instanceof RegExp && prm.name.test(paramName))
+                return prm;
+        }
+    }
+    toJSON() {
+        const out = omitUndefined({
+            kind: OpraSchema.RpcOperation.Kind,
+            description: this.description,
+            channel: this.channel,
+            payloadType: this.payloadType.name ? this.payloadType.name : this.payloadType.toJSON(),
+            keyType: this.keyType ? (this.keyType.name ? this.keyType.name : this.keyType.toJSON()) : undefined,
+            response: this.response?.toJSON(),
+        });
+        if (this.headers.length) {
+            out.headers = [];
+            for (const prm of this.headers) {
+                out.headers.push(prm.toJSON());
+            }
+        }
+        return out;
+    }
+}
+RpcOperation.prototype = RpcOperationClass.prototype;
+RpcOperation[DECORATOR] = RpcOperationDecoratorFactory;

package/esm/enums/index.js

@@ -0,0 +1,4 @@
+export * from './http-headers-codes.enum.js';
+export * from './http-status-codes.enum.js';
+export * from './http-status-messages.js';
+export * from './mime-types.enum.js';

package/esm/exception/http-errors/forbidden.error.js

@@ -1,4 +1,4 @@
-import { HttpStatusCode } from '../../http/index.js';
+import { HttpStatusCode } from '../../enums/index.js';
 import { translate } from '../../i18n/index.js';
 import { OpraHttpError } from '../opra-http-error.js';
 /**

package/esm/exception/http-errors/resource-not.available.error.js

@@ -1,4 +1,4 @@
-import { HttpStatusCode } from '../../http/index.js';
+import { HttpStatusCode } from '../../enums/index.js';
 import { translate } from '../../i18n/index.js';
 import { OpraHttpError } from '../opra-http-error.js';
 /**

package/esm/index.js

@@ -1,8 +1,8 @@
 export * from './document/index.js';
+export * from './enums/index.js';
 export * from './exception/index.js';
 export * from './filter/index.js';
 export * from './helpers/index.js';
-export * from './http/index.js';
 export * from './i18n/index.js';
 export * from './schema/index.js';
 export * from './types.js';

package/esm/schema/opra-schema.js

@@ -16,6 +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 './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';