@opra/common 1.0.0-alpha.1 → 1.0.0-alpha.11

package/esm/document/factory/data-type.factory.js

@@ -4,6 +4,7 @@ import { DocumentInitContext } from '../common/document-init-context.js';
 import { DATATYPE_METADATA, DECODER, ENCODER, kCtorMap, kDataTypeMap } from '../constants.js';
 import { ComplexType } from '../data-type/complex-type.js';
 import { ComplexTypeBase } from '../data-type/complex-type-base.js';
+import { DataType } from '../data-type/data-type.js';
 import { EnumType } from '../data-type/enum-type.js';
 import { MappedType } from '../data-type/mapped-type.js';
 import { MixinType } from '../data-type/mixin-type.js';
@@ -91,10 +92,10 @@ export class DataTypeFactory {
                     thunk = await resolveThunk(thunk);
                     const metadata = Reflect.getMetadata(DATATYPE_METADATA, thunk) || thunk[DATATYPE_METADATA];
                     if (!(metadata && metadata.name)) {
-                        if (typeof thunk === 'function')
+                        if (typeof thunk === 'function') {
                             return context.addError(`Class "${thunk.name}" doesn't have a valid data type metadata`);
-                        else
-                            return context.addError(`Object doesn't have a valid data type metadata`);
+                        }
+                        return context.addError(`Object doesn't have a valid data type metadata`);
                     }
                     importQueue.set(metadata.name, thunk);
                 });
@@ -113,8 +114,9 @@ export class DataTypeFactory {
                 continue;
             const dt = await this._importDataTypeArgs(context, owner, name);
             // istanbul ignore next
-            if (dt && typeof dt !== 'string')
+            if (dt && typeof dt !== 'string') {
                 context.addError(`Embedded data type can't be loaded into document node directly`);
+            }
         }
         return Array.from(initArgsMap.values());
     }
@@ -130,7 +132,7 @@ export class DataTypeFactory {
         const { importQueue, initArgsMap } = context;
         // Check if data type already exist (maybe a builtin type or already imported)
         const dataType = owner.node.findDataType(thunk);
-        if (dataType)
+        if (dataType instanceof DataType)
             return dataType.name;
         let metadata;
         let ctor;
@@ -178,8 +180,9 @@ export class DataTypeFactory {
                         const baseArgs = await this._importDataTypeArgs(context, owner, metadata.name);
                         if (!baseArgs)
                             return;
-                        if (typeof baseArgs === 'object' && baseArgs.kind !== OpraSchema.SimpleType.Kind)
+                        if (typeof baseArgs === 'object' && baseArgs.kind !== OpraSchema.SimpleType.Kind) {
                             return context.addError('Kind of base data type is not same');
+                        }
                         return {
                             kind: OpraSchema.SimpleType.Kind,
                             name: undefined,
@@ -209,11 +212,16 @@ export class DataTypeFactory {
             /** Mark "out" object as initializing. This will help us to detect circular dependencies */
             out[initializingSymbol] = true;
             try {
-                if (out.name && importQueue?.has(out.name)) {
-                    initArgsMap?.set(metadata.name, out);
+                if (out.name) {
+                    if (importQueue?.has(out.name)) {
+                        initArgsMap?.set(metadata.name, out);
+                        out._instance = { name: metadata.name };
+                        out[kDataTypeMap] = owner.node[kDataTypeMap];
+                    }
+                    else {
+                        return context.addError(`Data Type (${out.name}) must be explicitly added to type list in the document scope`);
+                    }
                 }
-                else if (out.name)
-                    return context.addError(`Data Type (${out.name}) must be explicitly added to type list in the document scope`);
                 switch (out.kind) {
                     case OpraSchema.ComplexType.Kind:
                         out.ctor = ctor;
@@ -260,8 +268,9 @@ export class DataTypeFactory {
             }
             else if (initArgs.ctor) {
                 const baseClass = Object.getPrototypeOf(initArgs.ctor.prototype).constructor;
-                if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass))
+                if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass)) {
                     baseArgs = await this._importDataTypeArgs(context, owner, baseClass);
+                }
             }
             if (!baseArgs)
                 return;
@@ -270,14 +279,16 @@ export class DataTypeFactory {
         });
         // Initialize additionalFields
         if (metadata.additionalFields != null) {
-            if (typeof metadata.additionalFields === 'boolean' || Array.isArray(metadata.additionalFields))
+            if (typeof metadata.additionalFields === 'boolean' || Array.isArray(metadata.additionalFields)) {
                 initArgs.additionalFields = metadata.additionalFields;
-            else
+            }
+            else {
                 await context.enterAsync('.additionalFields', async () => {
                     const t = await this._importDataTypeArgs(context, owner, metadata.additionalFields);
                     if (t)
                         initArgs.additionalFields = preferName(t);
                 });
+            }
         }
         if (metadata.fields) {
             initArgs.fields = {};
@@ -285,9 +296,10 @@ export class DataTypeFactory {
                 for (const [k, v] of Object.entries(metadata.fields)) {
                     await context.enterAsync(`[${k}]`, async () => {
                         const fieldMeta = typeof v === 'string' ? { type: v } : v;
-                        if (fieldMeta.isArray && !fieldMeta.type)
+                        if (fieldMeta.isArray && !fieldMeta.type) {
                             return context.addError(`"type" must be defined explicitly for array fields`);
-                        const t = await this._importDataTypeArgs(context, owner, fieldMeta.type);
+                        }
+                        const t = await this._importDataTypeArgs(context, owner, fieldMeta.type || 'any');
                         if (!t)
                             return;
                         initArgs.fields[k] = {
@@ -320,8 +332,9 @@ export class DataTypeFactory {
             }
             else if (initArgs.ctor) {
                 const baseClass = Object.getPrototypeOf(initArgs.ctor.prototype).constructor;
-                if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass))
+                if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass)) {
                     baseArgs = await this._importDataTypeArgs(context, owner, baseClass);
+                }
             }
             if (!baseArgs)
                 return;
@@ -329,14 +342,17 @@ export class DataTypeFactory {
             initArgs.ctor = initArgs.ctor || baseArgs.ctor;
         });
         initArgs.properties = metadata.properties;
+        initArgs.nameMappings = metadata.nameMappings;
         if (!initArgs.properties && initArgs.ctor)
             initArgs.properties = new initArgs.ctor();
         if (metadata.attributes)
             initArgs.attributes = cloneObject(metadata.attributes);
-        if (typeof initArgs.properties?.[DECODER] === 'function')
+        if (typeof initArgs.properties?.[DECODER] === 'function') {
             initArgs.generateDecoder = initArgs.properties?.[DECODER].bind(initArgs.properties);
-        if (typeof initArgs.properties?.[ENCODER] === 'function')
+        }
+        if (typeof initArgs.properties?.[ENCODER] === 'function') {
             initArgs.generateEncoder = initArgs.properties?.[ENCODER].bind(initArgs.properties);
+        }
     }
     static async _prepareMappedTypeArgs(context, owner, initArgs, metadata) {
         await this._prepareDataTypeArgs(context, initArgs, metadata);
@@ -347,8 +363,9 @@ export class DataTypeFactory {
             }
             else if (initArgs.ctor) {
                 const baseClass = Object.getPrototypeOf(initArgs.ctor.prototype).constructor;
-                if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass))
+                if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass)) {
                     baseArgs = await this._importDataTypeArgs(context, owner, baseClass);
+                }
             }
             if (!baseArgs)
                 return;
@@ -359,10 +376,12 @@ export class DataTypeFactory {
             initArgs.pick = [...metadata.pick];
         else if (metadata.omit)
             initArgs.omit = [...metadata.omit];
-        else if (metadata.partial)
+        else if (metadata.partial) {
             initArgs.partial = Array.isArray(metadata.partial) ? [...metadata.partial] : metadata.partial;
-        else if (metadata.required)
+        }
+        else if (metadata.required) {
             initArgs.required = Array.isArray(metadata.required) ? [...metadata.required] : metadata.required;
+        }
     }
     static async _prepareMixinTypeArgs(context, owner, initArgs, metadata) {
         await this._prepareDataTypeArgs(context, initArgs, metadata);
@@ -381,43 +400,52 @@ export class DataTypeFactory {
         });
     }
     static _createDataType(context, owner, args) {
+        let dataType = owner.node.findDataType(typeof args === 'string' ? args : args.name || '');
+        if (dataType instanceof DataType)
+            return dataType;
         const initArgs = typeof args === 'string' ? context.initArgsMap?.get(args) : args;
-        switch (initArgs?.kind) {
-            case OpraSchema.ComplexType.Kind:
-                return this._createComplexType(context, owner, initArgs);
-            case OpraSchema.EnumType.Kind:
-                return this._createEnumType(context, owner, initArgs);
-            case OpraSchema.MappedType.Kind:
-                return this._createMappedType(context, owner, initArgs);
-            case OpraSchema.MixinType.Kind:
-                return this._createMixinType(context, owner, initArgs);
-            case OpraSchema.SimpleType.Kind:
-                return this._createSimpleType(context, owner, initArgs);
+        if (initArgs) {
+            const dataTypeMap = initArgs[kDataTypeMap];
+            if (!dataTypeMap)
+                delete initArgs._instance;
+            dataType = initArgs._instance;
+            if (dataType?.name && dataTypeMap) {
+                dataTypeMap.set(dataType.name, dataType);
+            }
+            switch (initArgs?.kind) {
+                case OpraSchema.ComplexType.Kind:
+                    return this._createComplexType(context, owner, initArgs);
+                case OpraSchema.EnumType.Kind:
+                    return this._createEnumType(context, owner, initArgs);
+                case OpraSchema.MappedType.Kind:
+                    return this._createMappedType(context, owner, initArgs);
+                case OpraSchema.MixinType.Kind:
+                    return this._createMixinType(context, owner, initArgs);
+                case OpraSchema.SimpleType.Kind:
+                    return this._createSimpleType(context, owner, initArgs);
+                default:
+                    break;
+            }
         }
         context.addError(`Unknown data type (${String(args)})`);
     }
     static _createComplexType(context, owner, args) {
+        const dataType = args._instance || {};
+        Object.setPrototypeOf(dataType, ComplexType.prototype);
         const initArgs = cloneObject(args);
         if (args.base) {
             context.enter('.base', () => {
-                initArgs.base = (owner.node.findDataType(args.base) ||
-                    this._createDataType(context, owner, args.base));
+                initArgs.base = this._createDataType(context, owner, args.base);
             });
         }
         /** Set additionalFields */
         if (args.additionalFields) {
             context.enter('.additionalFields', () => {
-                if (typeof args.additionalFields === 'boolean' || Array.isArray(args.additionalFields))
+                if (typeof args.additionalFields === 'boolean' || Array.isArray(args.additionalFields)) {
                     initArgs.additionalFields = args.additionalFields;
+                }
                 else {
-                    if (typeof args.additionalFields === 'string') {
-                        initArgs.additionalFields =
-                            owner.node.findDataType(args.additionalFields) ||
-                                this._createDataType(context, owner, args.additionalFields);
-                    }
-                    else {
-                        initArgs.additionalFields = this._createDataType(context, owner, args.additionalFields);
-                    }
+                    initArgs.additionalFields = this._createDataType(context, owner, args.additionalFields);
                 }
             });
         }
@@ -427,40 +455,49 @@ export class DataTypeFactory {
             context.enter('.fields', () => {
                 for (const [k, v] of Object.entries(args.fields)) {
                     context.enter(`[${k}]`, () => {
-                        const type = owner.node.findDataType(v.type) || this._createDataType(context, owner, v.type);
-                        if (type)
+                        const type = this._createDataType(context, owner, v.type);
+                        if (type) {
                             initArgs.fields[k] = {
                                 ...v,
                                 name: k,
                                 type,
                             };
+                        }
                     });
                 }
             });
         }
-        return new ComplexType(owner, initArgs);
+        ComplexType.apply(dataType, [owner, initArgs]);
+        return dataType;
     }
     static _createEnumType(context, owner, args) {
+        const dataType = args._instance || {};
+        Object.setPrototypeOf(dataType, EnumType.prototype);
         const initArgs = cloneObject(args);
         if (args.base) {
             context.enter('.base', () => {
-                initArgs.base = (owner.node.findDataType(args.base) ||
-                    this._createDataType(context, owner, args.base));
+                initArgs.base = this._createDataType(context, owner, args.base);
             });
         }
         initArgs.attributes = args.attributes;
-        return new EnumType(owner, initArgs);
+        EnumType.apply(dataType, [owner, initArgs]);
+        return dataType;
     }
     static _createMappedType(context, owner, args) {
+        const dataType = args._instance || {};
+        Object.setPrototypeOf(dataType, MappedType.prototype);
         const initArgs = cloneObject(args);
         if (args.base) {
             context.enter('.base', () => {
-                initArgs.base = (owner.node.findDataType(args.base) || this._createDataType(context, owner, args.base));
+                initArgs.base = this._createDataType(context, owner, args.base);
             });
         }
-        return new MappedType(owner, initArgs);
+        MappedType.apply(dataType, [owner, initArgs]);
+        return dataType;
     }
     static _createMixinType(context, owner, args) {
+        const dataType = args._instance || {};
+        Object.setPrototypeOf(dataType, MixinType.prototype);
         const initArgs = cloneObject(args);
         if (args.types) {
             context.enter('.types', () => {
@@ -468,25 +505,29 @@ export class DataTypeFactory {
                 let i = 0;
                 for (const t of args.types) {
                     context.enter(`[${i++}]`, () => {
-                        const base = owner.node.findDataType(t) || this._createDataType(context, owner, t);
-                        if (!(base instanceof ComplexTypeBase))
+                        const base = this._createDataType(context, owner, t);
+                        if (!(base instanceof ComplexTypeBase)) {
                             throw new TypeError(`"${base?.kind}" can't be set as base for a "${initArgs.kind}"`);
+                        }
                         initArgs.types.push(base);
                     });
                 }
             });
         }
-        return new MixinType(owner, initArgs);
+        MixinType.apply(dataType, [owner, initArgs]);
+        return dataType;
     }
     static _createSimpleType(context, owner, args) {
+        const dataType = args._instance || {};
+        Object.setPrototypeOf(dataType, SimpleType.prototype);
         const initArgs = cloneObject(args);
         if (args.base) {
             context.enter('.base', () => {
-                initArgs.base = (owner.node.findDataType(args.base) ||
-                    this._createDataType(context, owner, args.base));
+                initArgs.base = this._createDataType(context, owner, args.base);
             });
         }
-        return new SimpleType(owner, initArgs);
+        SimpleType.apply(dataType, [owner, initArgs]);
+        return dataType;
     }
 }
 function preferName(initArgs) {

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

@@ -21,6 +21,7 @@ export class HttpApiFactory {
      */
     static async createApi(context, document, init) {
         const api = new HttpApi(document);
+        api.name = init.name;
         api.description = init.description;
         api.url = init.url;
         if (init.controllers) {
@@ -44,8 +45,9 @@ export class HttpApiFactory {
         return api;
     }
     static async _createController(context, parent, thunk, name) {
-        if (typeof thunk === 'function' && !isConstructor(thunk))
+        if (typeof thunk === 'function' && !isConstructor(thunk)) {
             thunk = parent instanceof HttpController ? thunk(parent.instance) : thunk();
+        }
         thunk = await resolveThunk(thunk);
         let ctor;
         let metadata;
@@ -205,7 +207,7 @@ export class HttpApiFactory {
             });
         }
         if (metadata.requestBody) {
-            await context.enter('.requestBody', async () => {
+            await context.enterAsync('.requestBody', async () => {
                 const requestBody = new HttpRequestBody(operation);
                 await this._initHttpRequestBody(context, requestBody, metadata.requestBody);
                 operation.requestBody = requestBody;

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

@@ -28,8 +28,8 @@ export class HttpApi extends ApiBase {
             url: this.url,
             controllers: {},
         };
-        for (const [name, v] of this.controllers.entries()) {
-            out.controllers[name] = v.toJSON();
+        for (const v of this.controllers.values()) {
+            out.controllers[v.name] = v.toJSON();
         }
         return out;
     }

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

@@ -1,3 +1,4 @@
+import nodePath from 'node:path';
 import { asMutable } from 'ts-gems';
 import { omitUndefined, ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
@@ -58,7 +59,7 @@ class HttpControllerClass extends DocumentElement {
                 if (c.controllers.size) {
                     controller = c.findController(arg0);
                     if (controller) {
-                        this._controllerReverseMap.set(arg0, c);
+                        this._controllerReverseMap.set(arg0, controller);
                         return controller;
                     }
                 }
@@ -79,15 +80,25 @@ class HttpControllerClass extends DocumentElement {
         return this.controllers.get(arg0);
     }
     findParameter(paramName, location) {
-        paramName = paramName.toLowerCase();
-        for (const prm of this.parameters) {
-            if ((!location || location === prm.location) &&
-                ((prm.name instanceof RegExp && prm.name.test(paramName)) ||
-                    (typeof prm.name === 'string' && prm.name.toLowerCase() === paramName)))
+        const paramNameLower = paramName.toLowerCase();
+        let prm;
+        for (prm of this.parameters) {
+            if (location && location !== prm.location)
+                continue;
+            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 HttpController)
+        if (this.node.parent && this.node.parent.element instanceof HttpController) {
             return this.node.parent.element.findParameter(paramName, location);
+        }
+    }
+    getFullUrl() {
+        return nodePath.posix.join(this.owner instanceof HttpController ? this.owner.getFullUrl() : '/', this.path);
     }
     /**
      *
@@ -106,20 +117,20 @@ class HttpControllerClass extends DocumentElement {
         });
         if (this.operations.size) {
             out.operations = {};
-            for (const [name, v] of this.operations.entries()) {
-                out.operations[name] = v.toJSON();
+            for (const v of this.operations.values()) {
+                out.operations[v.name] = v.toJSON();
             }
         }
         if (this.controllers.size) {
             out.controllers = {};
-            for (const [name, v] of this.controllers.entries()) {
-                out.controllers[name] = v.toJSON();
+            for (const v of this.controllers.values()) {
+                out.controllers[v.name] = v.toJSON();
             }
         }
         if (this.types.size) {
             out.types = {};
-            for (const [name, v] of this.types.entries()) {
-                out.types[name] = v.toJSON();
+            for (const v of this.types.values()) {
+                out.types[v.name] = v.toJSON();
             }
         }
         if (this.parameters.length) {

package/esm/document/http/http-media-type.js

@@ -22,8 +22,9 @@ export const HttpMediaType = function (owner, initArgs) {
     _this.maxFileSize = initArgs.maxFileSize;
     _this.maxTotalFileSize = initArgs.maxTotalFileSize;
     _this.minFileSize = initArgs.minFileSize;
-    if (initArgs?.type)
+    if (initArgs?.type) {
         _this.type = initArgs?.type instanceof DataType ? initArgs.type : _this.owner.node.getDataType(initArgs.type);
+    }
     _this.isArray = initArgs.isArray;
 };
 /**
@@ -35,8 +36,9 @@ class HttpMediaTypeClass extends DocumentElement {
             return;
         for (const f of this.multipartFields) {
             if ((!fieldType || fieldType === f.fieldType) &&
-                ((f.fieldName instanceof RegExp && f.fieldName.test(fieldName)) || f.fieldName === fieldName))
+                ((f.fieldName instanceof RegExp && f.fieldName.test(fieldName)) || f.fieldName === fieldName)) {
                 return f;
+            }
         }
     }
     toJSON() {

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

@@ -16,8 +16,9 @@ export class HttpOperationResponse extends HttpMediaType {
         paramName = paramName.toLowerCase();
         for (const prm of this.parameters) {
             if ((!location || location === prm.location) &&
-                ((prm.name instanceof RegExp && prm.name.test(paramName)) || prm.name === paramName))
+                ((prm.name instanceof RegExp && prm.name.test(paramName)) || prm.name === paramName)) {
                 return prm;
+            }
         }
     }
     toJSON() {

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

@@ -1,3 +1,4 @@
+import nodePath from 'node:path';
 import { asMutable } from 'ts-gems';
 import { cloneObject, omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
@@ -36,18 +37,30 @@ export const HttpOperation = function (...args) {
  */
 class HttpOperationClass extends DocumentElement {
     findParameter(paramName, location) {
-        paramName = paramName.toLowerCase();
-        for (const prm of this.parameters) {
-            if ((!location || location === prm.location) &&
-                ((prm.name instanceof RegExp && prm.name.test(paramName)) || prm.name === paramName))
+        const paramNameLower = paramName.toLowerCase();
+        let prm;
+        for (prm of this.parameters) {
+            if (location && location !== prm.location)
+                continue;
+            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;
         }
     }
+    getFullUrl() {
+        const out = this.owner.getFullUrl();
+        return out ? (this.path ? nodePath.posix.join(out, this.path) : out) : this.path || '/';
+    }
     toJSON() {
         const out = omitUndefined({
             kind: OpraSchema.HttpOperation.Kind,
             description: this.description,
             method: this.method,
+            path: this.path,
             composition: this.composition,
             requestBody: this.requestBody?.toJSON(),
         });

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

@@ -22,6 +22,7 @@ export const HttpParameter = function (owner, initArgs) {
     _this.deprecated = initArgs.deprecated;
     _this.required = initArgs.required;
     _this.arraySeparator = initArgs.arraySeparator;
+    _this.keyParam = initArgs.keyParam;
 };
 /**
  * @class HttpParameter
@@ -33,6 +34,7 @@ class HttpParameterClass extends Value {
             name: this.name,
             location: this.location,
             arraySeparator: this.arraySeparator,
+            keyParam: this.keyParam,
             required: this.required,
             deprecated: this.deprecated,
         });

package/esm/document/http/http-status-range.js

@@ -28,8 +28,7 @@ export class HttpStatusRange {
     toString() {
         if (this.start === this.end)
             return String(this.start);
-        else
-            return String(this.start) + '-' + String(this.end);
+        return String(this.start) + '-' + String(this.end);
     }
     toJSON() {
         return !this.end || this.start === this.end ? this.start : { start: this.start, end: this.end };

package/esm/document/index.js

@@ -2,36 +2,36 @@ import 'reflect-metadata';
 import * as DataTypeFactory_ from './factory/data-type.factory.js';
 import * as HttpApiFactory_ from './factory/http-api.factory.js';
 export * from './api-document.js';
-export * from './constants.js';
 export * from './common/api-base.js';
 export * from './common/data-type-map.js';
 export * from './common/document-element.js';
 export * from './common/document-init-context.js';
 export * from './common/document-node.js';
 export * from './common/opra-document-error.js';
+export * from './constants.js';
+export * from './data-type/api-field.js';
 export * from './data-type/complex-type.js';
 export * from './data-type/data-type.js';
 export * from './data-type/enum-type.js';
-export * from './data-type/api-field.js';
+export * from './data-type/extended-types/index.js';
 export * from './data-type/mapped-type.js';
 export * from './data-type/mixin-type.js';
 export * from './data-type/omit-type.js';
 export * from './data-type/partial-type.js';
 export * from './data-type/pick-type.js';
+export * from './data-type/primitive-types/index.js';
 export * from './data-type/required-type.js';
 export * from './data-type/simple-type.js';
-export * from './data-type/primitive-types/index.js';
-export * from './data-type/extended-types/index.js';
 export * from './decorators/http-operation-entity.decorator.js';
 export * from './factory/api-document.factory.js';
 export * from './http/http-api.js';
+export * from './http/http-controller.js';
 export * from './http/http-media-type.js';
 export * from './http/http-multipart-field.js';
 export * from './http/http-operation.js';
 export * from './http/http-operation-response.js';
 export * from './http/http-parameter.js';
 export * from './http/http-request-body.js';
-export * from './http/http-controller.js';
 export * from './http/http-status-range.js';
 export var classes;
 (function (classes) {

package/esm/exception/index.js

@@ -1,7 +1,4 @@
-export * from './opra-exception.js';
-export * from './opra-http-error.js';
 export * from './error-issue.js';
-export * from './issue-severity.enum.js';
 export * from './http-errors/bad-request.error.js';
 export * from './http-errors/conflict.error.js';
 export * from './http-errors/failed-dependency.error.js';
@@ -10,8 +7,11 @@ export * from './http-errors/internal-server.error.js';
 export * from './http-errors/method-not-allowed.error.js';
 export * from './http-errors/not-acceptable.error.js';
 export * from './http-errors/not-found.error.js';
-export * from './http-errors/unauthorized.error.js';
-export * from './http-errors/unprocessable-entity.error.js';
 export * from './http-errors/permission.error.js';
 export * from './http-errors/resource-conflict.error.js';
 export * from './http-errors/resource-not.available.error.js';
+export * from './http-errors/unauthorized.error.js';
+export * from './http-errors/unprocessable-entity.error.js';
+export * from './issue-severity.enum.js';
+export * from './opra-exception.js';
+export * from './opra-http-error.js';