@opra/core 0.21.0 → 0.23.0

package/cjs/adapter/response.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/adapter/services/logger.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+class Logger {
+    constructor(options = {}) {
+        this._instance = options.instance ||
+            (!(process.env.NODE_ENV || '').includes('test') ? globalThis.console : {});
+    }
+    info(message, ...optionalParams) {
+        (this._instance.info || this._instance.log)?.(message, ...optionalParams);
+    }
+    error(message, ...optionalParams) {
+        if (this._instance.error) {
+            this._instance.error(message, ...optionalParams);
+            return;
+        }
+        this.info(message, ...optionalParams);
+    }
+    fatal(message, ...optionalParams) {
+        if (this._instance.fatal) {
+            this._instance.fatal(message, ...optionalParams);
+            return;
+        }
+        this.error(message, ...optionalParams);
+    }
+    warn(message, ...optionalParams) {
+        this._instance.warn?.(message, ...optionalParams);
+    }
+    debug(message, ...optionalParams) {
+        this._instance.debug?.(message, ...optionalParams);
+    }
+    verbose(message, ...optionalParams) {
+        this._instance.verbose?.(message, ...optionalParams);
+    }
+}
+exports.Logger = Logger;

package/cjs/augmentation/collection.augmentation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/augmentation/singleton.augmentation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/augmentation/storage.augmentation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/index.js

@@ -3,16 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 require("reflect-metadata");
 require("./augmentation/resource.augmentation.js");
+require("./augmentation/collection.augmentation.js");
+require("./augmentation/singleton.augmentation.js");
+require("./augmentation/storage.augmentation.js");
 tslib_1.__exportStar(require("./types.js"), exports);
-tslib_1.__exportStar(require("./adapter/adapter.js"), exports);
+tslib_1.__exportStar(require("./adapter/execution-context.js"), exports);
+tslib_1.__exportStar(require("./adapter/operation-context.js"), exports);
+tslib_1.__exportStar(require("./adapter/platform-adapter.js"), exports);
+tslib_1.__exportStar(require("./adapter/request.js"), exports);
+tslib_1.__exportStar(require("./adapter/response.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/http/impl/http-server-request.js"), exports);
-tslib_1.__exportStar(require("./adapter/http/impl/http-server-response.js"), exports);
-tslib_1.__exportStar(require("./adapter/http/impl/http-incoming-message-host.js"), exports);
-tslib_1.__exportStar(require("./adapter/http/impl/http-outgoing-message-host.js"), exports);
-tslib_1.__exportStar(require("./adapter/interfaces/request-context.interface.js"), exports);
+tslib_1.__exportStar(require("./adapter/http/impl/http-incoming-message.host.js"), exports);
+tslib_1.__exportStar(require("./adapter/http/impl/http-outgoing-message.host.js"), exports);
+tslib_1.__exportStar(require("./adapter/http/http-server-request.js"), exports);
+tslib_1.__exportStar(require("./adapter/http/http-server-response.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);
-tslib_1.__exportStar(require("./shared/collection-resource-base.js"), exports);
+tslib_1.__exportStar(require("./adapter/interfaces/request-handler.interface.js"), exports);
+tslib_1.__exportStar(require("./adapter/services/logger.js"), exports);
+tslib_1.__exportStar(require("./adapter/http/helpers/multipart-helper.js"), exports);

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

@@ -0,0 +1,44 @@
+import { AsyncEventEmitter } from 'strict-typed-events';
+export class ExecutionContextHost extends 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');
+    }
+}

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

@@ -0,0 +1,20 @@
+import { OpraURLPath } from '@opra/common';
+import { HttpAdapterBase } from './http-adapter-base.js';
+import { HttpServerRequest } from './http-server-request.js';
+import { HttpServerResponse } from './http-server-response.js';
+export class ExpressAdapterHost extends HttpAdapterBase {
+    constructor(app, api, options) {
+        super(api, options);
+        this._platform = 'express';
+        const basePath = new OpraURLPath(options?.basePath);
+        app.use(basePath.toString(), (_req, _res) => {
+            const req = HttpServerRequest.from(_req);
+            const res = HttpServerResponse.from(_res);
+            this.handleIncoming(req, res)
+                .catch(() => void 0);
+        });
+    }
+    get app() {
+        return this._app;
+    }
+}

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

@@ -1,22 +1,13 @@
-import { normalizePath } from '@opra/common';
-import { OpraHttpAdapter } from './http-adapter.js';
-import { HttpServerRequest } from './impl/http-server-request.js';
-import { HttpServerResponse } from './impl/http-server-response.js';
-export class OpraExpressAdapter extends OpraHttpAdapter {
-    constructor() {
-        super(...arguments);
-        this.platform = 'express';
-    }
-    static async create(app, document, options) {
-        const express = await import('express');
-        const adapter = new OpraExpressAdapter(document);
-        await adapter.init(options);
-        const prefix = '/' + normalizePath(options?.prefix, true);
-        app.use(prefix, express.json());
-        app.use(prefix, (req, res, next) => {
-            adapter.handler(HttpServerRequest.create(req), HttpServerResponse.create(res))
-                .catch(e => next(e));
-        });
+import { ExpressAdapterHost } from './express-adapter.host.js';
+/**
+ * @namespace
+ */
+export var ExpressAdapter;
+(function (ExpressAdapter) {
+    async function create(app, api, options) {
+        const adapter = new ExpressAdapterHost(app, api, options);
+        await adapter.init();
         return adapter;
     }
-}
+    ExpressAdapter.create = create;
+})(ExpressAdapter || (ExpressAdapter = {}));

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

@@ -0,0 +1,16 @@
+import { PassThrough } from 'stream';
+export function concatReadable(...streams) {
+    const out = new PassThrough();
+    const pipeNext = () => {
+        const nextStream = streams.shift();
+        if (nextStream) {
+            nextStream.pipe(out, { end: false });
+            nextStream.once('end', () => pipeNext());
+        }
+        else {
+            out.end();
+        }
+    };
+    pipeNext();
+    return out;
+}

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

@@ -0,0 +1,91 @@
+import { EventEmitter } from 'events';
+import formidable from 'formidable';
+import fs from 'fs/promises';
+const noOp = () => void 0;
+export class MultipartIterator extends EventEmitter {
+    constructor(incoming, options) {
+        super();
+        this._cancelled = false;
+        this._items = [];
+        this._stack = [];
+        this.setMaxListeners(1000);
+        const form = this._form = formidable({
+            ...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 fs.unlink(file.filepath);
+            }).then(() => {
+                return 0;
+            }));
+        });
+        return Promise.allSettled(promises);
+    }
+}

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

@@ -0,0 +1,12 @@
+import { splitString } from 'fast-tokenizer';
+export function parseArrayParam(v) {
+    if (!v)
+        return;
+    return splitString(v, {
+        delimiters: ',',
+        quotes: true,
+        brackets: true,
+        keepBrackets: true,
+        keepQuotes: true
+    }).map(x => x.trim());
+}

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

@@ -0,0 +1,123 @@
+import { BadRequestError, HttpHeaderCodes, HttpStatusCodes, InternalServerError, IssueSeverity, OpraException, OpraSchema, wrapException } from '@opra/common';
+import { ExecutionContextHost } from '../execution-context.host.js';
+import { PlatformAdapterHost } from '../platform-adapter.host.js';
+import { EntityRequestHandler } from './request-handlers/entity-request-handler.js';
+import { StorageRequestHandler } from './request-handlers/storage-request-handler.js';
+/**
+ *
+ * @class HttpAdapterBase
+ */
+export class HttpAdapterBase extends PlatformAdapterHost {
+    constructor() {
+        super(...arguments);
+        this._protocol = 'http';
+        this._requestHandlers = [
+            new EntityRequestHandler(this),
+            new StorageRequestHandler(this)
+        ];
+    }
+    /**
+     * Main http request handler
+     * @param incoming
+     * @param outgoing
+     * @protected
+     */
+    async handleIncoming(incoming, outgoing) {
+        const context = new ExecutionContextHost(this.api, this.platform, { http: { incoming, outgoing } });
+        try {
+            /* istanbul ignore next */
+            if (!this._initialized)
+                throw new InternalServerError(`${Object.getPrototypeOf(this).constructor.name} has not been initialized yet`);
+            outgoing.setHeader(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
+            // Expose headers if cors enabled
+            if (outgoing.getHeader(HttpHeaderCodes.Access_Control_Allow_Origin)) {
+                // Expose X-Opra-* headers
+                outgoing.appendHeader(HttpHeaderCodes.Access_Control_Expose_Headers, Object.values(HttpHeaderCodes)
+                    .filter(k => k.toLowerCase().startsWith('x-opra-')));
+            }
+            await this.processRequest(context);
+        }
+        catch (error) {
+            context.errors.push(wrapException(error));
+        }
+        // If no response returned to the client we send an error
+        if (!outgoing.writableEnded) {
+            if (!context.errors.length)
+                context.errors.push(new 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 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 OpraException)
+                this._logger.fatal(x);
+            else
+                this._logger.error(x);
+        });
+        const wrappedErrors = errors.map(wrapException);
+        // Sort errors from fatal to info
+        wrappedErrors.sort((a, b) => {
+            const i = IssueSeverity.Keys.indexOf(a.issue.severity) - 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(HttpStatusCodes.BAD_REQUEST)) {
+            status = wrappedErrors[0].status;
+            if (status < Number(HttpStatusCodes.BAD_REQUEST))
+                status = HttpStatusCodes.INTERNAL_SERVER_ERROR;
+        }
+        outgoing.statusCode = status;
+        const body = this._i18n.deep({
+            errors: wrappedErrors.map(x => x.issue)
+        });
+        outgoing.setHeader(HttpHeaderCodes.Content_Type, 'application/json; charset=utf-8');
+        outgoing.setHeader(HttpHeaderCodes.Cache_Control, 'no-cache');
+        outgoing.setHeader(HttpHeaderCodes.Pragma, 'no-cache');
+        outgoing.setHeader(HttpHeaderCodes.Expires, '-1');
+        outgoing.setHeader(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
+        outgoing.send(JSON.stringify(body));
+        outgoing.end();
+    }
+}

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

@@ -0,0 +1,52 @@
+import http from 'http';
+import { HttpStatusCodes, HttpStatusMessages, OpraURL, OpraURLPath, } from '@opra/common';
+import { HttpAdapterBase } from './http-adapter-base.js';
+import { HttpServerRequest } from './http-server-request.js';
+import { HttpServerResponse } from './http-server-response.js';
+/**
+ * @class HttpAdapterHost
+ */
+export class HttpAdapterHost extends HttpAdapterBase {
+    constructor(api, options) {
+        super(api, options);
+        this._platform = 'http';
+        this._basePath = new OpraURLPath(options?.basePath);
+        this._server = http.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 OpraURL(originalUrl);
+        const relativePath = OpraURLPath.relative(parsedUrl.path, this.basePath);
+        if (!relativePath) {
+            serverResponse.statusCode = HttpStatusCodes.NOT_FOUND;
+            serverResponse.statusMessage = HttpStatusMessages[HttpStatusCodes.NOT_FOUND];
+            serverResponse.end();
+            return;
+        }
+        parsedUrl.path = relativePath;
+        incomingMessage.originalUrl = originalUrl;
+        incomingMessage.baseUrl = this.basePath.toString();
+        incomingMessage.parsedUrl = parsedUrl;
+        const req = HttpServerRequest.from(incomingMessage);
+        const res = 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();
+                });
+            });
+    }
+}

package/esm/adapter/http/http-adapter.js

@@ -1,130 +1,13 @@
-import { Task } from 'power-tasks';
-import { BadRequestError, Collection, HttpHeaderCodes, HttpStatusCodes, InternalServerError, isReadable, IssueSeverity, OpraException, OpraSchema, Singleton, wrapException } from '@opra/common';
-import { OpraAdapter } from '../adapter.js';
-import { RequestContextHost } from '../request-context.host.js';
-import { ResponseHost } from '../response.host.js';
-import { parseRequest } from './request-parsers/parse-request.js';
+import { HttpAdapterHost } from './http-adapter.host.js';
 /**
- *
- * @class OpraHttpAdapter
+ * @namespace HttpAdapter
  */
-export class OpraHttpAdapter extends OpraAdapter {
-    /**
-     * Main http request handler
-     * @param incoming
-     * @param outgoing
-     * @protected
-     */
-    async handler(incoming, outgoing) {
-        try {
-            try {
-                const request = await parseRequest(this._apiRoot, incoming);
-                const task = this.createRequestTask(request, outgoing);
-                await task.toPromise();
-            }
-            catch (e) {
-                if (e instanceof OpraException)
-                    throw e;
-                throw new BadRequestError(e);
-            }
-        }
-        catch (error) {
-            await this.handleError(incoming, outgoing, [error]);
-        }
-    }
-    createRequestTask(request, outgoing) {
-        return new Task(async () => {
-            const response = new ResponseHost({ http: outgoing });
-            const context = new 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 => wrapException(e));
-            await this.handleError(request.switchToHttp(), outgoing, errors);
-            return;
-        }
-        if (request.resource instanceof Singleton || request.resource instanceof Collection) {
-            outgoing.setHeader(HttpHeaderCodes.X_Opra_Data_Type, String(request.resource.type.name));
-            outgoing.setHeader(HttpHeaderCodes.X_Opra_Operation, request.operation);
-        }
-        if (request.crud === 'create') {
-            if (!response.value)
-                throw new InternalServerError();
-            // todo validate
-            outgoing.statusCode = 201;
-        }
-        if (request.resource instanceof Collection &&
-            request.crud === 'read' && request.many && request.args.count >= 0) {
-            outgoing.setHeader(HttpHeaderCodes.X_Opra_Total_Matches, String(response.count));
-        }
-        outgoing.statusCode = outgoing.statusCode || HttpStatusCodes.OK;
-        outgoing.setHeader(HttpHeaderCodes.Cache_Control, 'no-cache');
-        outgoing.setHeader(HttpHeaderCodes.Pragma, 'no-cache');
-        outgoing.setHeader(HttpHeaderCodes.Expires, '-1');
-        outgoing.setHeader(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
-        if (response.value) {
-            if (typeof response.value === 'object') {
-                if (isReadable(response.value) || Buffer.isBuffer(response.value))
-                    outgoing.send(response.value);
-                else {
-                    const body = this.i18n.deep(response.value);
-                    outgoing.setHeader(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 OpraException) ? 'error' : 'fatal', incoming, e); // todo. implement a better logger
-        });
-        errors = errors.map(wrapException);
-        let status = outgoing.statusCode || 0;
-        // Sort errors from fatal to info
-        errors.sort((a, b) => {
-            const i = IssueSeverity.Keys.indexOf(a.issue.severity) - IssueSeverity.Keys.indexOf(b.issue.severity);
-            if (i === 0)
-                return b.status - a.status;
-            return i;
-        });
-        if (!status || status < HttpStatusCodes.BAD_REQUEST) {
-            status = errors[0].status;
-            if (status < HttpStatusCodes.BAD_REQUEST)
-                status = HttpStatusCodes.INTERNAL_SERVER_ERROR;
-        }
-        const body = this.i18n.deep({
-            errors: errors.map(e => e.issue)
-        });
-        outgoing.statusCode = status;
-        outgoing.setHeader(HttpHeaderCodes.Content_Type, 'application/json; charset=utf-8');
-        outgoing.setHeader(HttpHeaderCodes.Cache_Control, 'no-cache');
-        outgoing.setHeader(HttpHeaderCodes.Pragma, 'no-cache');
-        outgoing.setHeader(HttpHeaderCodes.Expires, '-1');
-        outgoing.setHeader(HttpHeaderCodes.X_Opra_Version, 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]);
-    }
-}
+export var HttpAdapter;
+(function (HttpAdapter) {
+    async function create(api, options) {
+        const adapter = new HttpAdapterHost(api, options);
+        await adapter.init();
+        return adapter;
+    }
+    HttpAdapter.create = create;
+})(HttpAdapter || (HttpAdapter = {}));

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

@@ -6,22 +6,28 @@ import accepts from 'accepts';
 import fresh from 'fresh';
 import parseRange from 'range-parser';
 import typeIs from 'type-is';
-import { isReadable, mergePrototype } from '@opra/common';
-import { HttpIncomingMessageHost } from './http-incoming-message-host.js';
+import { isReadable, mergePrototype, OpraURL } from '@opra/common';
+import { HttpIncomingMessageHost } from './impl/http-incoming-message.host.js';
 function isHttpIncomingMessage(v) {
     return v && Array.isArray(v.rawHeaders) && isReadable(v);
 }
 export var HttpServerRequest;
 (function (HttpServerRequest) {
-    function create(instance) {
+    function from(instance) {
         if (!isHttpIncomingMessage(instance))
-            instance = HttpIncomingMessageHost.create(instance);
+            instance = HttpIncomingMessageHost.from(instance);
         mergePrototype(instance, HttpServerRequestHost.prototype);
-        return instance;
+        const req = instance;
+        req.baseUrl = req.baseUrl || '';
+        req.parsedUrl = req.parsedUrl || new OpraURL(req.url);
+        return req;
     }
-    HttpServerRequest.create = create;
+    HttpServerRequest.from = from;
 })(HttpServerRequest || (HttpServerRequest = {}));
 class HttpServerRequestHost {
+    constructor() {
+        this.basePath = '/';
+    }
     get protocol() {
         const proto = this.header('X-Forwarded-Proto') || 'http';
         const index = proto.indexOf(',');