@opra/core 0.14.0 → 0.15.0

package/cjs/adapter/http/http-adapter.js

@@ -0,0 +1,466 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraHttpAdapter = void 0;
+const power_tasks_1 = require("power-tasks");
+const common_1 = require("@opra/common");
+const adapter_js_1 = require("../adapter.js");
+const http_request_host_js_1 = require("./http-request.host.js");
+const http_request_context_host_js_1 = require("./http-request-context.host.js");
+const http_response_host_js_1 = require("./http-response.host.js");
+/**
+ *
+ * @class OpraHttpAdapter
+ */
+class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
+    /**
+     * Main http request handler
+     * @param incoming
+     * @param outgoing
+     * @protected
+     */
+    async handler(incoming, outgoing) {
+        try {
+            // Batch
+            if (incoming.is('multipart/mixed')) {
+                throw new common_1.BadRequestError({ message: 'Not implemented yet' });
+            }
+            if (!(incoming.method === 'POST' || incoming.method === 'PATCH') || incoming.is('json')) {
+                const request = await this.parseRequest(incoming);
+                const response = new http_response_host_js_1.HttpResponseHost({}, outgoing);
+                const context = new http_request_context_host_js_1.HttpRequestContextHost(this.platform, this.api, request, response);
+                const task = new power_tasks_1.Task(async () => {
+                    try {
+                        await this.executeRequest(context);
+                        if (request.operation === 'search' && request.args.count && response.count != null) {
+                            response.switchToHttp().header(common_1.HttpHeaderCodes.X_Opra_Total_Matches, String(response.count));
+                        }
+                    }
+                    catch (error) {
+                        return this.errorHandler(incoming, outgoing, [error]);
+                    }
+                    await this.sendResponse(context);
+                }, {
+                    id: incoming.get('content-id'),
+                    exclusive: request.crud !== 'read'
+                });
+                await task.toPromise().catch(e => {
+                    this.logger?.error?.(e);
+                    outgoing.sendStatus(500);
+                });
+                return;
+            }
+            throw new common_1.BadRequestError({ message: 'Unsupported Content-Type' });
+        }
+        catch (error) {
+            await this.errorHandler(incoming, outgoing, [error]);
+        }
+    }
+    async errorHandler(incoming, outgoing, errors) {
+        errors.forEach(e => {
+            this.log((e instanceof common_1.OpraException) ? 'error' : 'fatal', incoming, e); // todo. implement a better logger
+        });
+        errors = errors.map(common_1.wrapException);
+        let status = outgoing.statusCode || 0;
+        // Sort errors from fatal to info
+        errors.sort((a, b) => {
+            const i = common_1.IssueSeverity.Keys.indexOf(a.issue.severity) - common_1.IssueSeverity.Keys.indexOf(b.issue.severity);
+            if (i === 0)
+                return b.status - a.status;
+            return i;
+        });
+        if (!status || status < common_1.HttpStatusCodes.BAD_REQUEST) {
+            status = errors[0].status;
+            if (status < common_1.HttpStatusCodes.BAD_REQUEST)
+                status = common_1.HttpStatusCodes.INTERNAL_SERVER_ERROR;
+        }
+        const body = this.i18n.deep({
+            errors: errors.map(e => e.issue)
+        });
+        outgoing.set(common_1.HttpHeaderCodes.Content_Type, 'application/json; charset=utf-8');
+        outgoing.set(common_1.HttpHeaderCodes.Cache_Control, 'no-cache');
+        outgoing.set(common_1.HttpHeaderCodes.Pragma, 'no-cache');
+        outgoing.set(common_1.HttpHeaderCodes.Expires, '-1');
+        outgoing.set(common_1.HttpHeaderCodes.X_Opra_Version, common_1.OpraSchema.SpecVersion);
+        outgoing.status(status);
+        outgoing.send(JSON.stringify(body));
+        outgoing.end();
+    }
+    log(logType, incoming, message, ...optionalParams) {
+        const logFn = logType === 'fatal'
+            ? this.logger?.fatal || this.logger?.error
+            : this.logger?.[logType];
+        if (!logFn)
+            return;
+        logFn.apply(this.logger, [String(message), ...optionalParams]);
+    }
+    async afterExecuteRequest(context) {
+        await super.afterExecuteRequest(context);
+        const { request } = context;
+        const response = context.response;
+        const { crud } = request;
+        const httpResponse = response.switchToHttp();
+        if (request.resource instanceof common_1.Singleton || request.resource instanceof common_1.Collection) {
+            httpResponse.set(common_1.HttpHeaderCodes.X_Opra_Data_Type, request.resource.type.name);
+            httpResponse.set(common_1.HttpHeaderCodes.X_Opra_Operation, request.operation);
+        }
+        if (crud === 'create') {
+            if (!response.value)
+                throw new common_1.InternalServerError();
+            // todo validate
+            httpResponse.status(201);
+        }
+    }
+    /**
+     *
+     * @param incoming
+     * @protected
+     */
+    async parseRequest(incoming) {
+        try {
+            const url = new common_1.OpraURL();
+            url.searchParams.define({
+                '$pick': { codec: 'string', array: true },
+                '$omit': { codec: 'string', array: true },
+                '$include': { codec: 'string', array: true },
+                '$sort': { codec: 'string', array: true },
+                '$filter': { codec: 'filter' },
+                '$limit': { codec: 'number' },
+                '$skip': { codec: 'number' },
+                '$distinct': { codec: 'boolean' },
+                '$count': { codec: 'boolean' },
+            });
+            url.parse(incoming.url);
+            // const {context, url, method, headers, body, contentId} = args;
+            if (!url.path.size)
+                throw new common_1.BadRequestError();
+            const method = incoming.method;
+            if (method !== 'GET' && url.path.size > 1)
+                throw new common_1.BadRequestError();
+            // const pathLen = url.path.size;
+            // let pathIndex = 0;
+            const params = url.searchParams;
+            const p = url.path.get(0);
+            const resource = this._internalDoc.getResource(p.resource);
+            // let container: IResourceContainer | undefined;
+            // while (resource && resource instanceof ContainerResourceInfo) {
+            //   container = resource;
+            //   p = url.path.get(++pathIndex);
+            //   resource = container.getResource(p.resource);
+            // }
+            // const headers = incoming.headers;
+            /*
+             * Collection
+             */
+            if (resource instanceof common_1.Collection) {
+                switch (method) {
+                    case 'POST': {
+                        if (!p.key) {
+                            return new http_request_host_js_1.HttpRequestHost({
+                                kind: 'CollectionCreateRequest',
+                                resource,
+                                operation: 'create',
+                                crud: 'create',
+                                many: false,
+                                args: {
+                                    data: incoming.body,
+                                    pick: resource.normalizeFieldNames(params.get('$pick')),
+                                    omit: resource.normalizeFieldNames(params.get('$omit')),
+                                    include: resource.normalizeFieldNames(params.get('$include'))
+                                }
+                            }, incoming);
+                        }
+                        break;
+                    }
+                    case 'DELETE': {
+                        if (p.key) {
+                            return new http_request_host_js_1.HttpRequestHost({
+                                kind: 'CollectionDeleteRequest',
+                                resource,
+                                operation: 'delete',
+                                crud: 'delete',
+                                many: false,
+                                args: {
+                                    key: resource.parseKeyValue(p.key)
+                                }
+                            }, incoming);
+                        }
+                        return new http_request_host_js_1.HttpRequestHost({
+                            kind: 'CollectionDeleteManyRequest',
+                            resource,
+                            operation: 'deleteMany',
+                            crud: 'delete',
+                            many: true,
+                            args: {
+                                filter: resource.normalizeFilterFields(params.get('$filter'))
+                            }
+                        }, incoming);
+                    }
+                    case 'GET': {
+                        if (p.key) {
+                            return new http_request_host_js_1.HttpRequestHost({
+                                kind: 'CollectionGetRequest',
+                                resource,
+                                operation: 'get',
+                                crud: 'read',
+                                many: false,
+                                args: {
+                                    key: resource.parseKeyValue(p.key),
+                                    pick: resource.normalizeFieldNames(params.get('$pick')),
+                                    omit: resource.normalizeFieldNames(params.get('$omit')),
+                                    include: resource.normalizeFieldNames(params.get('$include'))
+                                }
+                            }, incoming);
+                        }
+                        return new http_request_host_js_1.HttpRequestHost({
+                            kind: 'CollectionSearchRequest',
+                            resource,
+                            operation: 'search',
+                            crud: 'read',
+                            many: true,
+                            args: {
+                                sort: resource.normalizeSortFields(params.get('$sort')),
+                                pick: resource.normalizeFieldNames(params.get('$pick')),
+                                omit: resource.normalizeFieldNames(params.get('$omit')),
+                                include: resource.normalizeFieldNames(params.get('$include')),
+                                filter: resource.normalizeFilterFields(params.get('$filter')),
+                                limit: params.get('$limit'),
+                                skip: params.get('$skip'),
+                                distinct: params.get('$distinct'),
+                                count: params.get('$count'),
+                            }
+                        }, incoming);
+                    }
+                    case 'PATCH': {
+                        if (p.key) {
+                            return new http_request_host_js_1.HttpRequestHost({
+                                kind: 'CollectionUpdateRequest',
+                                resource,
+                                operation: 'update',
+                                crud: 'update',
+                                many: false,
+                                args: {
+                                    key: resource.parseKeyValue(p.key),
+                                    data: incoming.body,
+                                    pick: resource.normalizeFieldNames(params.get('$pick')),
+                                    omit: resource.normalizeFieldNames(params.get('$omit')),
+                                    include: resource.normalizeFieldNames(params.get('$include'))
+                                }
+                            }, incoming);
+                        }
+                        return new http_request_host_js_1.HttpRequestHost({
+                            kind: 'CollectionUpdateManyRequest',
+                            resource,
+                            operation: 'updateMany',
+                            crud: 'update',
+                            many: true,
+                            args: {
+                                data: incoming.body,
+                                filter: resource.normalizeFilterFields(params.get('$filter'))
+                            }
+                        }, incoming);
+                    }
+                }
+            }
+            else 
+            /*
+             * Singleton
+             */
+            if (resource instanceof common_1.Singleton && !p.key) {
+                switch (method) {
+                    case 'POST': {
+                        return new http_request_host_js_1.HttpRequestHost({
+                            kind: 'SingletonCreateRequest',
+                            resource,
+                            operation: 'create',
+                            crud: 'create',
+                            many: false,
+                            args: {
+                                data: incoming.body,
+                                pick: resource.normalizeFieldNames(params.get('$pick')),
+                                omit: resource.normalizeFieldNames(params.get('$omit')),
+                                include: resource.normalizeFieldNames(params.get('$include'))
+                            }
+                        }, incoming);
+                    }
+                    case 'DELETE': {
+                        return new http_request_host_js_1.HttpRequestHost({
+                            kind: 'SingletonDeleteRequest',
+                            resource,
+                            operation: 'delete',
+                            crud: 'delete',
+                            many: false,
+                            args: {}
+                        }, incoming);
+                    }
+                    case 'GET': {
+                        return new http_request_host_js_1.HttpRequestHost({
+                            kind: 'SingletonGetRequest',
+                            resource,
+                            operation: 'get',
+                            crud: 'read',
+                            many: false,
+                            args: {
+                                pick: resource.normalizeFieldNames(params.get('$pick')),
+                                omit: resource.normalizeFieldNames(params.get('$omit')),
+                                include: resource.normalizeFieldNames(params.get('$include'))
+                            }
+                        }, incoming);
+                    }
+                    case 'PATCH': {
+                        return new http_request_host_js_1.HttpRequestHost({
+                            kind: 'SingletonUpdateRequest',
+                            resource,
+                            operation: 'update',
+                            crud: 'update',
+                            many: false,
+                            args: {
+                                data: incoming.body,
+                                pick: resource.normalizeFieldNames(params.get('$pick')),
+                                omit: resource.normalizeFieldNames(params.get('$omit')),
+                                include: resource.normalizeFieldNames(params.get('$include'))
+                            }
+                        }, incoming);
+                    }
+                }
+            }
+            else
+                throw new common_1.InternalServerError();
+            // if (query instanceof SingletonGetQuery || query instanceof CollectionGetQuery || query instanceof ElementReadQuery) {
+            //   // Move through properties
+            //   let parentType: DataType;
+            //   const curPath: string[] = [];
+            //   let parent: SingletonGetQuery | CollectionGetQuery | ElementReadQuery = query;
+            //   while (++pathIndex < pathLen) {
+            //     p = url.path.get(pathIndex);
+            //     parentType = parent.type;
+            //     if (parent.type instanceof UnionType) {
+            //       if (parent.type.name === 'any')
+            //         parentType = this.document.getComplexType('object');
+            //       else
+            //         throw new TypeError(`"${resource.name}.${curPath.join()}" is a UnionType and needs type casting.`);
+            //     }
+            //     if (!(parentType instanceof ComplexType))
+            //       throw new TypeError(`"${resource.name}.${curPath.join()}" is not a ComplexType and has no fields.`);
+            //     curPath.push(p.resource);
+            //     parent.child = new ElementReadQuery(parent, p.resource, {castingType: parentType});
+            //     parent = parent.child;
+            //   }
+            // }
+            throw new common_1.MethodNotAllowedError({
+                message: `Method "${method}" is not allowed by target endpoint`
+            });
+        }
+        catch (e) {
+            if (e instanceof common_1.OpraException)
+                throw e;
+            throw new common_1.BadRequestError(e);
+        }
+    }
+    // async parseMultiPart(
+    //     context: TExecutionContext,
+    //     url: OpraURL,
+    //     headers: IncomingHttpHeaders,
+    //     input: Readable,
+    //     boundary: string
+    // ): Promise<BatchRequestContext> {
+    //   return await new Promise((resolve, reject) => {
+    //     let _resolved = false;
+    //     const dicer = new Dicer({boundary});
+    //     const doReject = (e) => {
+    //       if (_resolved) return;
+    //       _resolved = true;
+    //       reject(e);
+    //       taskQueue.clearQueue();
+    //       dicer.destroy();
+    //     }
+    //     const taskQueue = new TaskQueue({concurrency: 1});
+    //     taskQueue.on('error', doReject);
+    //
+    //     const queries: SingleRequestContext[] = [];
+    //     let partCounter = 0;
+    //     dicer.on('error', doReject);
+    //     dicer.on('part', part => {
+    //       const partIndex = partCounter++;
+    //       let header: any;
+    //       const chunks: Buffer[] = [];
+    //       part.on('error', doReject);
+    //       part.on('header', (_header) => header = normalizeHeaders(_header));
+    //       part.on('data', (chunk: Buffer) => chunks.push(chunk));
+    //       part.on('end', () => {
+    //         if (_resolved || !(header || chunks.length))
+    //           return;
+    //         const ct = header['content-type'];
+    //         if (ct === 'application/http') {
+    //           taskQueue.enqueue(async () => {
+    //             const data = Buffer.concat(chunks);
+    //             if (!(data && data.length))
+    //               return;
+    //             const r = HttpRequest.parse(data);
+    //             await callMiddlewares(r, [jsonBodyParser]);
+    //             const subUrl = new OpraURL(r.url);
+    //             const contentId = header && header['content-id'];
+    //             queries.push(this.parseSingleQuery({
+    //               context,
+    //               url: subUrl,
+    //               method: r.method,
+    //               headers: r.headers,
+    //               body: r.body,
+    //               contentId
+    //             }));
+    //           });
+    //         } else doReject(new BadRequestError({
+    //           message: 'Unaccepted "content-type" header in multipart data',
+    //           details: {
+    //             position: `${boundary}[${partIndex}]`
+    //           }
+    //         }))
+    //       });
+    //     });
+    //     dicer.on('finish', () => {
+    //       taskQueue.enqueue(() => {
+    //         if (_resolved) return;
+    //         _resolved = true;
+    //         const batch = new BatchRequestContext({
+    //           service: this.document,
+    //           context,
+    //           headers,
+    //           queries,
+    //           params: url.searchParams,
+    //           continueOnError: false
+    //         });
+    //         resolve(batch);
+    //       });
+    //     });
+    //     input.pipe(dicer);
+    //   });
+    // }
+    async sendResponse(context) {
+        const { request, response } = context;
+        const outgoing = response.switchToHttp();
+        const errors = response.errors?.map(e => (0, common_1.wrapException)(e));
+        if (errors && errors.length) {
+            await this.errorHandler(request.switchToHttp(), outgoing, errors);
+            return;
+        }
+        outgoing.set(common_1.HttpHeaderCodes.Cache_Control, 'no-cache');
+        outgoing.set(common_1.HttpHeaderCodes.Pragma, 'no-cache');
+        outgoing.set(common_1.HttpHeaderCodes.Expires, '-1');
+        outgoing.set(common_1.HttpHeaderCodes.X_Opra_Version, common_1.OpraSchema.SpecVersion);
+        outgoing.status(outgoing.statusCode || common_1.HttpStatusCodes.OK);
+        if (response.value) {
+            if (typeof response.value === 'object') {
+                if ((0, common_1.isReadable)(response.value) || Buffer.isBuffer(response.value))
+                    outgoing.send(response.value);
+                else {
+                    const body = this.i18n.deep(response.value);
+                    outgoing.set(common_1.HttpHeaderCodes.Content_Type, 'application/json; charset=utf-8');
+                    outgoing.send(JSON.stringify(body));
+                }
+            }
+            else
+                outgoing.send(JSON.stringify(response.value));
+        }
+        outgoing.end();
+    }
+}
+exports.OpraHttpAdapter = OpraHttpAdapter;

package/cjs/adapter/http/http-request-context.host.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRequestContextHost = void 0;
+const request_context_host_js_1 = require("../request-context.host.js");
+class HttpRequestContextHost extends request_context_host_js_1.RequestContextHost {
+    constructor(platform, api, _request, _response) {
+        super('http', platform, api, _request, _response);
+        this.platform = platform;
+        this.api = api;
+        this._request = _request;
+        this._response = _response;
+    }
+    switchToHttp() {
+        const obj = {
+            request: this._request.switchToHttp(),
+            response: this._response.switchToHttp()
+        };
+        Object.setPrototypeOf(obj, this);
+        return obj;
+    }
+    switchToWs() {
+        throw new TypeError('Not executing in an "WebSocket" protocol');
+    }
+    switchToRpc() {
+        throw new TypeError('Not executing in an "RPC" protocol');
+    }
+}
+exports.HttpRequestContextHost = HttpRequestContextHost;

package/cjs/adapter/http/http-request.host.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRequestHost = void 0;
+const request_host_js_1 = require("../request.host.js");
+class HttpRequestHost extends request_host_js_1.RequestHost {
+    constructor(init, _incoming) {
+        super(init);
+        this._incoming = _incoming;
+    }
+    switchToHttp() {
+        return this._incoming;
+    }
+}
+exports.HttpRequestHost = HttpRequestHost;

package/cjs/adapter/http/http-response.host.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpResponseHost = void 0;
+const response_host_js_1 = require("../response.host.js");
+class HttpResponseHost extends response_host_js_1.ResponseHost {
+    constructor(init, _outgoing) {
+        super(init);
+        this._outgoing = _outgoing;
+    }
+    switchToHttp() {
+        return this._outgoing;
+    }
+}
+exports.HttpResponseHost = HttpResponseHost;

package/cjs/adapter/internal/metadata.resource.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataResource = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@opra/common");
+let MetadataResource = class MetadataResource {
+    constructor(document) {
+        this.document = document;
+        this._schema = document.exportSchema();
+    }
+    get() {
+        return (0, common_1.cloneObject)(this.document.exportSchema(), true);
+    }
+};
+tslib_1.__decorate([
+    common_1.Singleton.GetOperation(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", []),
+    tslib_1.__metadata("design:returntype", void 0)
+], MetadataResource.prototype, "get", null);
+MetadataResource = tslib_1.__decorate([
+    (0, common_1.Singleton)(Object, {
+        name: '$metadata',
+    }),
+    tslib_1.__metadata("design:paramtypes", [common_1.ApiDocument])
+], MetadataResource);
+exports.MetadataResource = MetadataResource;

package/cjs/adapter/request-context.host.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestContextHost = void 0;
+const strict_typed_events_1 = require("strict-typed-events");
+class RequestContextHost extends strict_typed_events_1.AsyncEventEmitter {
+    constructor(protocol, platform, api, _request, _response) {
+        super();
+        this.protocol = protocol;
+        this.platform = platform;
+        this.api = api;
+        this._request = _request;
+        this._response = _response;
+    }
+    get request() {
+        return this._request;
+    }
+    get response() {
+        return this._response;
+    }
+    switchToHttp() {
+        throw new TypeError('Not executing in an "Http" protocol');
+    }
+    switchToWs() {
+        throw new TypeError('Not executing in an "WebSocket" protocol');
+    }
+    switchToRpc() {
+        throw new TypeError('Not executing in an "RPC" protocol');
+    }
+}
+exports.RequestContextHost = RequestContextHost;

package/cjs/adapter/request.host.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestHost = void 0;
+class RequestHost {
+    constructor(init) {
+        Object.assign(this, init);
+        this.resourceKind = this.resource.kind;
+    }
+    switchToHttp() {
+        throw new TypeError('Not executing in an "Http" protocol');
+    }
+    switchToWs() {
+        throw new TypeError('Not executing in an "WebSocket" protocol');
+    }
+    switchToRpc() {
+        throw new TypeError('Not executing in an "RPC" protocol');
+    }
+}
+exports.RequestHost = RequestHost;

package/cjs/adapter/response.host.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseHost = void 0;
+class ResponseHost {
+    constructor(init) {
+        if (init)
+            Object.assign(this, init);
+        this.errors = this.errors || [];
+    }
+    switchToHttp() {
+        throw new TypeError('Not executing in an "Http" protocol');
+    }
+    switchToWs() {
+        throw new TypeError('Not executing in an "WebSocket" protocol');
+    }
+    switchToRpc() {
+        throw new TypeError('Not executing in an "RPC" protocol');
+    }
+}
+exports.ResponseHost = ResponseHost;

package/cjs/augmentation/resource.augmentation.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@opra/common");
+// @ts-ignore
+const oldConstruct = common_1.Resource.prototype._construct;
+// @ts-ignore
+common_1.Resource.prototype._construct = function (init) {
+    oldConstruct.call(this, init);
+    const _this = this;
+    _this.onInit = init.onInit;
+    _this.onShutdown = init.onShutdown;
+};
+common_1.Collection.OnInit = common_1.Singleton.OnInit = function () {
+    return (target, propertyKey) => {
+        const resourceMetadata = (Reflect.getOwnMetadata(common_1.METADATA_KEY, target.constructor) || {});
+        resourceMetadata.onInit = target[propertyKey];
+        Reflect.defineMetadata(common_1.METADATA_KEY, target.constructor, resourceMetadata);
+    };
+};
+common_1.Collection.OnShutdown = common_1.Singleton.OnShutdown = function () {
+    return (target, propertyKey) => {
+        const resourceMetadata = (Reflect.getOwnMetadata(common_1.METADATA_KEY, target.constructor) || {});
+        resourceMetadata.onShutdown = target[propertyKey];
+        Reflect.defineMetadata(common_1.METADATA_KEY, target.constructor, resourceMetadata);
+    };
+};

package/cjs/index.js

@@ -2,13 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 require("reflect-metadata");
+require("./augmentation/resource.augmentation.js");
 tslib_1.__exportStar(require("./types.js"), exports);
-tslib_1.__exportStar(require("./interfaces/execution-context.interface.js"), exports);
-tslib_1.__exportStar(require("./interfaces/resource.interface.js"), exports);
-tslib_1.__exportStar(require("./interfaces/i18n-options.interface.js"), exports);
-tslib_1.__exportStar(require("./adapter/request-contexts/single-request-context.js"), exports);
 tslib_1.__exportStar(require("./adapter/adapter.js"), exports);
-tslib_1.__exportStar(require("./adapter/http-adapter.js"), exports);
-tslib_1.__exportStar(require("./adapter/express-adapter.js"), exports);
-tslib_1.__exportStar(require("./services/data-service.js"), exports);
-tslib_1.__exportStar(require("./services/json-singleton-service.js"), exports);
+tslib_1.__exportStar(require("./adapter/http/express-adapter.js"), exports);
+tslib_1.__exportStar(require("./adapter/http/http-adapter.js"), exports);
+tslib_1.__exportStar(require("./adapter/interfaces/request-context.interface.js"), exports);
+tslib_1.__exportStar(require("./adapter/interfaces/logger.interface.js"), exports);
+tslib_1.__exportStar(require("./adapter/interfaces/request.interface.js"), exports);
+tslib_1.__exportStar(require("./adapter/interfaces/response.interface.js"), exports);