@opra/core 0.22.0 → 0.23.0

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionContextHost = void 0;
+const strict_typed_events_1 = require("strict-typed-events");
+class ExecutionContextHost extends strict_typed_events_1.AsyncEventEmitter {
+    constructor(api, platform, protocol) {
+        super();
+        this.api = api;
+        this.platform = platform;
+        this.errors = [];
+        this.executionScope = {};
+        this.ws = protocol.ws;
+        this.rpc = protocol.rpc;
+        if (protocol.http) {
+            this.protocol = 'http';
+            this.http = {
+                platform,
+                incoming: protocol.http.incoming,
+                outgoing: protocol.http.outgoing,
+                switchToContext: () => this
+            };
+        }
+        else if (protocol.ws) {
+            this.protocol = 'ws';
+            this.ws = protocol.ws;
+        }
+        else if (protocol.rpc) {
+            this.protocol = 'rpc';
+            this.rpc = protocol.rpc;
+        }
+    }
+    switchToHttp() {
+        if (this.http)
+            return this.http;
+        throw new TypeError('Not executing in an "Http" context');
+    }
+    switchToWs() {
+        if (this.ws)
+            return this.ws;
+        throw new TypeError('Not executing in an "WebSocket" context');
+    }
+    switchToRpc() {
+        if (this.rpc)
+            return this.rpc;
+        throw new TypeError('Not executing in an "RPC" context');
+    }
+}
+exports.ExecutionContextHost = ExecutionContextHost;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressAdapterHost = void 0;
+const common_1 = require("@opra/common");
+const http_adapter_base_js_1 = require("./http-adapter-base.js");
+const http_server_request_js_1 = require("./http-server-request.js");
+const http_server_response_js_1 = require("./http-server-response.js");
+class ExpressAdapterHost extends http_adapter_base_js_1.HttpAdapterBase {
+    constructor(app, api, options) {
+        super(api, options);
+        this._platform = 'express';
+        const basePath = new common_1.OpraURLPath(options?.basePath);
+        app.use(basePath.toString(), (_req, _res) => {
+            const req = http_server_request_js_1.HttpServerRequest.from(_req);
+            const res = http_server_response_js_1.HttpServerResponse.from(_res);
+            this.handleIncoming(req, res)
+                .catch(() => void 0);
+        });
+    }
+    get app() {
+        return this._app;
+    }
+}
+exports.ExpressAdapterHost = ExpressAdapterHost;

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

@@ -1,49 +1,16 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpraExpressAdapter = void 0;
-const common_1 = require("@opra/common");
-const http_adapter_js_1 = require("./http-adapter.js");
-const http_server_request_js_1 = require("./impl/http-server-request.js");
-const http_server_response_js_1 = require("./impl/http-server-response.js");
-class OpraExpressAdapter extends http_adapter_js_1.OpraHttpAdapter {
-    constructor() {
-        super(...arguments);
-        this.platform = 'express';
-    }
-    static async create(app, document, options) {
-        const express = await Promise.resolve().then(() => __importStar(require('express')));
-        const adapter = new OpraExpressAdapter(document);
-        await adapter.init(options);
-        const prefix = '/' + (0, common_1.normalizePath)(options?.prefix, true);
-        app.use(prefix, express.json());
-        app.use(prefix, (req, res, next) => {
-            adapter.handler(http_server_request_js_1.HttpServerRequest.create(req), http_server_response_js_1.HttpServerResponse.create(res))
-                .catch(e => next(e));
-        });
+exports.ExpressAdapter = void 0;
+const express_adapter_host_js_1 = require("./express-adapter.host.js");
+/**
+ * @namespace
+ */
+var ExpressAdapter;
+(function (ExpressAdapter) {
+    async function create(app, api, options) {
+        const adapter = new express_adapter_host_js_1.ExpressAdapterHost(app, api, options);
+        await adapter.init();
         return adapter;
     }
-}
-exports.OpraExpressAdapter = OpraExpressAdapter;
+    ExpressAdapter.create = create;
+})(ExpressAdapter || (exports.ExpressAdapter = ExpressAdapter = {}));

package/cjs/adapter/http/helpers/concat-readable.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concatReadable = void 0;
+const stream_1 = require("stream");
+function concatReadable(...streams) {
+    const out = new stream_1.PassThrough();
+    const pipeNext = () => {
+        const nextStream = streams.shift();
+        if (nextStream) {
+            nextStream.pipe(out, { end: false });
+            nextStream.once('end', () => pipeNext());
+        }
+        else {
+            out.end();
+        }
+    };
+    pipeNext();
+    return out;
+}
+exports.concatReadable = concatReadable;

package/cjs/adapter/http/helpers/multipart-helper.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultipartIterator = void 0;
+const tslib_1 = require("tslib");
+const events_1 = require("events");
+const formidable_1 = tslib_1.__importDefault(require("formidable"));
+const promises_1 = tslib_1.__importDefault(require("fs/promises"));
+const noOp = () => void 0;
+class MultipartIterator extends events_1.EventEmitter {
+    constructor(incoming, options) {
+        super();
+        this._cancelled = false;
+        this._items = [];
+        this._stack = [];
+        this.setMaxListeners(1000);
+        const form = this._form = (0, formidable_1.default)({
+            ...options,
+            filter: (part) => {
+                return !this._cancelled && (!options?.filter || options.filter(part));
+            }
+        });
+        form.once('error', () => {
+            this._cancelled = true;
+            if (this.listenerCount('error') > 0)
+                this.emit('error');
+        });
+        form.on('field', (field, value) => {
+            const item = { field, value };
+            this._items.push(item);
+            this._stack.push(item);
+            this.emit('item', item);
+        });
+        form.on('file', (field, file) => {
+            const item = { field, file };
+            this._items.push(item);
+            this._stack.push(item);
+            this.emit('item', item);
+        });
+        form.parse(incoming).catch(noOp);
+    }
+    get items() {
+        return this._items;
+    }
+    getNext() {
+        if (this._form.ended)
+            return Promise.resolve(undefined);
+        this.resume();
+        return new Promise((resolve, reject) => {
+            if (this._stack.length)
+                return resolve(this._stack.shift());
+            this.once('item', () => resolve(this._stack.shift()));
+            this.once('error', (e) => reject(e));
+        });
+    }
+    getAll() {
+        if (this._form.ended)
+            return Promise.resolve([...this._items]);
+        this.resume();
+        return new Promise((resolve, reject) => {
+            this._form.once('error', reject);
+            this._form.once('end', () => {
+                resolve([...this._items]);
+            });
+        });
+    }
+    cancel() {
+        this._cancelled = true;
+        this.resume();
+    }
+    resume() {
+        this._form.resume();
+    }
+    pause() {
+        this._form.pause();
+    }
+    async deleteFiles() {
+        const promises = [];
+        this._items
+            .forEach(item => {
+            if (!item.file)
+                return;
+            const file = item.file;
+            promises.push(new Promise(resolve => {
+                if (file._writeStream.closed)
+                    return resolve();
+                file._writeStream.once('close', resolve);
+            }).then(() => {
+                return promises_1.default.unlink(file.filepath);
+            }).then(() => {
+                return 0;
+            }));
+        });
+        return Promise.allSettled(promises);
+    }
+}
+exports.MultipartIterator = MultipartIterator;

package/cjs/adapter/http/helpers/query-parsers.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArrayParam = void 0;
+const fast_tokenizer_1 = require("fast-tokenizer");
+function parseArrayParam(v) {
+    if (!v)
+        return;
+    return (0, fast_tokenizer_1.splitString)(v, {
+        delimiters: ',',
+        quotes: true,
+        brackets: true,
+        keepBrackets: true,
+        keepQuotes: true
+    }).map(x => x.trim());
+}
+exports.parseArrayParam = parseArrayParam;

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

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpAdapterBase = void 0;
+const common_1 = require("@opra/common");
+const execution_context_host_js_1 = require("../execution-context.host.js");
+const platform_adapter_host_js_1 = require("../platform-adapter.host.js");
+const entity_request_handler_js_1 = require("./request-handlers/entity-request-handler.js");
+const storage_request_handler_js_1 = require("./request-handlers/storage-request-handler.js");
+/**
+ *
+ * @class HttpAdapterBase
+ */
+class HttpAdapterBase extends platform_adapter_host_js_1.PlatformAdapterHost {
+    constructor() {
+        super(...arguments);
+        this._protocol = 'http';
+        this._requestHandlers = [
+            new entity_request_handler_js_1.EntityRequestHandler(this),
+            new storage_request_handler_js_1.StorageRequestHandler(this)
+        ];
+    }
+    /**
+     * Main http request handler
+     * @param incoming
+     * @param outgoing
+     * @protected
+     */
+    async handleIncoming(incoming, outgoing) {
+        const context = new execution_context_host_js_1.ExecutionContextHost(this.api, this.platform, { http: { incoming, outgoing } });
+        try {
+            /* istanbul ignore next */
+            if (!this._initialized)
+                throw new common_1.InternalServerError(`${Object.getPrototypeOf(this).constructor.name} has not been initialized yet`);
+            outgoing.setHeader(common_1.HttpHeaderCodes.X_Opra_Version, common_1.OpraSchema.SpecVersion);
+            // Expose headers if cors enabled
+            if (outgoing.getHeader(common_1.HttpHeaderCodes.Access_Control_Allow_Origin)) {
+                // Expose X-Opra-* headers
+                outgoing.appendHeader(common_1.HttpHeaderCodes.Access_Control_Expose_Headers, Object.values(common_1.HttpHeaderCodes)
+                    .filter(k => k.toLowerCase().startsWith('x-opra-')));
+            }
+            await this.processRequest(context);
+        }
+        catch (error) {
+            context.errors.push((0, common_1.wrapException)(error));
+        }
+        // If no response returned to the client we send an error
+        if (!outgoing.writableEnded) {
+            if (!context.errors.length)
+                context.errors.push(new common_1.BadRequestError(`Server can not process this request`));
+            await this.handleError(context);
+        }
+    }
+    async processRequest(context) {
+        try {
+            const { incoming, outgoing } = context.switchToHttp();
+            if (incoming.method === 'GET' &&
+                incoming.parsedUrl.path.length &&
+                incoming.parsedUrl.path[0].resource === '$metadata') {
+                outgoing.setHeader('content-type', 'application/json');
+                outgoing.end(JSON.stringify(this.api.exportSchema({ webSafe: true })));
+                return;
+            }
+            const { parsedUrl } = incoming;
+            if (!parsedUrl.path.length) {
+                // Batch
+                if (incoming.headers['content-type'] === 'multipart/mixed') {
+                    // todo
+                }
+                throw new common_1.BadRequestError();
+            }
+            // Iterate through request handlers until one of them sends response (end outgoing stream)
+            for (const requestHandler of this._requestHandlers) {
+                await requestHandler.processRequest(context);
+                if (outgoing.writableEnded)
+                    return;
+                if (context.errors.length) {
+                    await this.handleError(context);
+                    return;
+                }
+            }
+        }
+        finally {
+            await context.emitAsync('finish');
+        }
+    }
+    async handleError(context) {
+        const { errors } = context;
+        const { outgoing } = context.switchToHttp();
+        if (outgoing.headersSent) {
+            outgoing.end();
+            return;
+        }
+        errors.forEach(x => {
+            // todo. implement a better log mechanism
+            if (x instanceof common_1.OpraException)
+                this._logger.fatal(x);
+            else
+                this._logger.error(x);
+        });
+        const wrappedErrors = errors.map(common_1.wrapException);
+        // Sort errors from fatal to info
+        wrappedErrors.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;
+        });
+        let status = outgoing.statusCode || 0;
+        if (!status || status < Number(common_1.HttpStatusCodes.BAD_REQUEST)) {
+            status = wrappedErrors[0].status;
+            if (status < Number(common_1.HttpStatusCodes.BAD_REQUEST))
+                status = common_1.HttpStatusCodes.INTERNAL_SERVER_ERROR;
+        }
+        outgoing.statusCode = status;
+        const body = this._i18n.deep({
+            errors: wrappedErrors.map(x => x.issue)
+        });
+        outgoing.setHeader(common_1.HttpHeaderCodes.Content_Type, 'application/json; charset=utf-8');
+        outgoing.setHeader(common_1.HttpHeaderCodes.Cache_Control, 'no-cache');
+        outgoing.setHeader(common_1.HttpHeaderCodes.Pragma, 'no-cache');
+        outgoing.setHeader(common_1.HttpHeaderCodes.Expires, '-1');
+        outgoing.setHeader(common_1.HttpHeaderCodes.X_Opra_Version, common_1.OpraSchema.SpecVersion);
+        outgoing.send(JSON.stringify(body));
+        outgoing.end();
+    }
+}
+exports.HttpAdapterBase = HttpAdapterBase;

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpAdapterHost = void 0;
+const tslib_1 = require("tslib");
+const http_1 = tslib_1.__importDefault(require("http"));
+const common_1 = require("@opra/common");
+const http_adapter_base_js_1 = require("./http-adapter-base.js");
+const http_server_request_js_1 = require("./http-server-request.js");
+const http_server_response_js_1 = require("./http-server-response.js");
+/**
+ * @class HttpAdapterHost
+ */
+class HttpAdapterHost extends http_adapter_base_js_1.HttpAdapterBase {
+    constructor(api, options) {
+        super(api, options);
+        this._platform = 'http';
+        this._basePath = new common_1.OpraURLPath(options?.basePath);
+        this._server = http_1.default.createServer((incomingMessage, serverResponse) => this._serverListener(incomingMessage, serverResponse));
+    }
+    get basePath() {
+        return this._basePath;
+    }
+    get server() {
+        return this._server;
+    }
+    _serverListener(incomingMessage, serverResponse) {
+        const originalUrl = incomingMessage.url;
+        const parsedUrl = new common_1.OpraURL(originalUrl);
+        const relativePath = common_1.OpraURLPath.relative(parsedUrl.path, this.basePath);
+        if (!relativePath) {
+            serverResponse.statusCode = common_1.HttpStatusCodes.NOT_FOUND;
+            serverResponse.statusMessage = common_1.HttpStatusMessages[common_1.HttpStatusCodes.NOT_FOUND];
+            serverResponse.end();
+            return;
+        }
+        parsedUrl.path = relativePath;
+        incomingMessage.originalUrl = originalUrl;
+        incomingMessage.baseUrl = this.basePath.toString();
+        incomingMessage.parsedUrl = parsedUrl;
+        const req = http_server_request_js_1.HttpServerRequest.from(incomingMessage);
+        const res = http_server_response_js_1.HttpServerResponse.from(serverResponse);
+        this.handleIncoming(req, res)
+            .catch((e) => this._logger.fatal(e));
+    }
+    async close() {
+        await super.close();
+        if (this.server.listening)
+            await new Promise((resolve, reject) => {
+                this.server.close((err) => {
+                    if (err)
+                        return reject(err);
+                    resolve();
+                });
+            });
+    }
+}
+exports.HttpAdapterHost = HttpAdapterHost;

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

@@ -1,138 +1,16 @@
 "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 request_context_host_js_1 = require("../request-context.host.js");
-const response_host_js_1 = require("../response.host.js");
-const parse_request_js_1 = require("./request-parsers/parse-request.js");
+exports.HttpAdapter = void 0;
+const http_adapter_host_js_1 = require("./http-adapter.host.js");
 /**
- *
- * @class OpraHttpAdapter
+ * @namespace HttpAdapter
  */
-class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
-    /**
-     * Main http request handler
-     * @param incoming
-     * @param outgoing
-     * @protected
-     */
-    async handler(incoming, outgoing) {
-        try {
-            try {
-                const request = await (0, parse_request_js_1.parseRequest)(this._apiRoot, incoming);
-                const task = this.createRequestTask(request, outgoing);
-                await task.toPromise();
-            }
-            catch (e) {
-                if (e instanceof common_1.OpraException)
-                    throw e;
-                throw new common_1.BadRequestError(e);
-            }
-        }
-        catch (error) {
-            await this.handleError(incoming, outgoing, [error]);
-        }
+var HttpAdapter;
+(function (HttpAdapter) {
+    async function create(api, options) {
+        const adapter = new http_adapter_host_js_1.HttpAdapterHost(api, options);
+        await adapter.init();
+        return adapter;
     }
-    createRequestTask(request, outgoing) {
-        return new power_tasks_1.Task(async () => {
-            const response = new response_host_js_1.ResponseHost({ http: outgoing });
-            const context = new request_context_host_js_1.RequestContextHost('http', this.platform, this.api, request, response);
-            return this.executeRequest(context);
-        }, {
-            id: request.contentId,
-            exclusive: request.crud !== 'read'
-        });
-    }
-    async executeRequest(context) {
-        const { request, response } = context;
-        await super.executeRequest(context)
-            .catch(e => {
-            response.errors = response.errors || [];
-            response.errors.push(e);
-        });
-        const outgoing = response.switchToHttp();
-        if (response.errors?.length) {
-            const errors = response.errors.map(e => (0, common_1.wrapException)(e));
-            await this.handleError(request.switchToHttp(), outgoing, errors);
-            return;
-        }
-        if (request.crud === 'create') {
-            if (!response.value)
-                throw new common_1.InternalServerError();
-            // todo validate
-            outgoing.statusCode = 201;
-        }
-        if (request.resource instanceof common_1.Collection &&
-            request.crud === 'read' && request.many && request.args.count >= 0) {
-            outgoing.setHeader(common_1.HttpHeaderCodes.X_Total_Count, String(response.count));
-        }
-        outgoing.statusCode = outgoing.statusCode || common_1.HttpStatusCodes.OK;
-        outgoing.setHeader(common_1.HttpHeaderCodes.Cache_Control, 'no-cache');
-        outgoing.setHeader(common_1.HttpHeaderCodes.Pragma, 'no-cache');
-        outgoing.setHeader(common_1.HttpHeaderCodes.Expires, '-1');
-        outgoing.setHeader(common_1.HttpHeaderCodes.X_Opra_Version, common_1.OpraSchema.SpecVersion);
-        // Expose headers if cors enabled
-        if (outgoing.getHeader(common_1.HttpHeaderCodes.Access_Control_Allow_Origin)) {
-            // Expose X-Total-Count header
-            outgoing.appendHeader(common_1.HttpHeaderCodes.Access_Control_Expose_Headers, [common_1.HttpHeaderCodes.X_Total_Count]);
-            // Expose X-Opra-* headers
-            outgoing.appendHeader(common_1.HttpHeaderCodes.Access_Control_Expose_Headers, Object.values(common_1.HttpHeaderCodes)
-                .filter(k => k.toLowerCase().startsWith('x-opra-')));
-        }
-        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.setHeader(common_1.HttpHeaderCodes.Content_Type, 'application/json; charset=utf-8');
-                    outgoing.send(JSON.stringify(body));
-                }
-            }
-            else
-                outgoing.send(JSON.stringify(response.value));
-        }
-        outgoing.end();
-    }
-    async handleError(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 < Number(common_1.HttpStatusCodes.BAD_REQUEST)) {
-            status = errors[0].status;
-            if (status < Number(common_1.HttpStatusCodes.BAD_REQUEST))
-                status = common_1.HttpStatusCodes.INTERNAL_SERVER_ERROR;
-        }
-        const body = this.i18n.deep({
-            errors: errors.map(e => e.issue)
-        });
-        outgoing.statusCode = status;
-        outgoing.setHeader(common_1.HttpHeaderCodes.Content_Type, 'application/json; charset=utf-8');
-        outgoing.setHeader(common_1.HttpHeaderCodes.Cache_Control, 'no-cache');
-        outgoing.setHeader(common_1.HttpHeaderCodes.Pragma, 'no-cache');
-        outgoing.setHeader(common_1.HttpHeaderCodes.Expires, '-1');
-        outgoing.setHeader(common_1.HttpHeaderCodes.X_Opra_Version, common_1.OpraSchema.SpecVersion);
-        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]);
-    }
-}
-exports.OpraHttpAdapter = OpraHttpAdapter;
+    HttpAdapter.create = create;
+})(HttpAdapter || (exports.HttpAdapter = HttpAdapter = {}));

package/cjs/adapter/http/{impl/http-server-request.js → http-server-request.js}

@@ -11,21 +11,27 @@ const fresh_1 = tslib_1.__importDefault(require("fresh"));
 const range_parser_1 = tslib_1.__importDefault(require("range-parser"));
 const type_is_1 = tslib_1.__importDefault(require("type-is"));
 const common_1 = require("@opra/common");
-const http_incoming_message_host_js_1 = require("./http-incoming-message-host.js");
+const http_incoming_message_host_js_1 = require("./impl/http-incoming-message.host.js");
 function isHttpIncomingMessage(v) {
     return v && Array.isArray(v.rawHeaders) && (0, common_1.isReadable)(v);
 }
 var HttpServerRequest;
 (function (HttpServerRequest) {
-    function create(instance) {
+    function from(instance) {
         if (!isHttpIncomingMessage(instance))
-            instance = http_incoming_message_host_js_1.HttpIncomingMessageHost.create(instance);
+            instance = http_incoming_message_host_js_1.HttpIncomingMessageHost.from(instance);
         (0, common_1.mergePrototype)(instance, HttpServerRequestHost.prototype);
-        return instance;
+        const req = instance;
+        req.baseUrl = req.baseUrl || '';
+        req.parsedUrl = req.parsedUrl || new common_1.OpraURL(req.url);
+        return req;
     }
-    HttpServerRequest.create = create;
+    HttpServerRequest.from = from;
 })(HttpServerRequest || (exports.HttpServerRequest = HttpServerRequest = {}));
 class HttpServerRequestHost {
+    constructor() {
+        this.basePath = '/';
+    }
     get protocol() {
         const proto = this.header('X-Forwarded-Proto') || 'http';
         const index = proto.indexOf(',');

package/cjs/adapter/http/{impl/http-server-response.js → http-server-response.js}

@@ -16,20 +16,20 @@ const path_1 = tslib_1.__importDefault(require("path"));
 const putil_varhelpers_1 = require("putil-varhelpers");
 const vary_1 = tslib_1.__importDefault(require("vary"));
 const common_1 = require("@opra/common");
-const http_outgoing_message_host_js_1 = require("./http-outgoing-message-host.js");
+const http_outgoing_message_host_js_1 = require("./impl/http-outgoing-message.host.js");
 const charsetRegExp = /;\s*charset\s*=/;
 function isHttpIncomingMessage(v) {
     return v && typeof v.getHeaders === 'function' && (0, common_1.isStream)(v);
 }
 var HttpServerResponse;
 (function (HttpServerResponse) {
-    function create(instance) {
+    function from(instance) {
         if (!isHttpIncomingMessage(instance))
-            instance = http_outgoing_message_host_js_1.HttpOutgoingMessageHost.create(instance);
+            instance = new http_outgoing_message_host_js_1.HttpOutgoingMessageHost(instance);
         (0, common_1.mergePrototype)(instance, HttpServerResponseHost.prototype);
         return instance;
     }
-    HttpServerResponse.create = create;
+    HttpServerResponse.from = from;
 })(HttpServerResponse || (exports.HttpServerResponse = HttpServerResponse = {}));
 class HttpServerResponseHost {
     attachment(filename) {