@opra/core 0.33.13 → 1.0.0-alpha.2

package/cjs/http/utils/body-reader.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BodyReader = void 0;
+const tslib_1 = require("tslib");
+const base64_stream_1 = require("base64-stream");
+const bytes_1 = tslib_1.__importDefault(require("bytes"));
+const content_type_1 = require("content-type");
+const events_1 = require("events");
+const iconv_lite_1 = tslib_1.__importDefault(require("iconv-lite"));
+const stream_1 = require("stream");
+const zlib = tslib_1.__importStar(require("zlib"));
+const type_is_1 = tslib_1.__importDefault(require("@browsery/type-is"));
+const common_1 = require("@opra/common");
+/**
+ *
+ * @class BodyReader
+ */
+class BodyReader extends events_1.EventEmitter {
+    constructor(req, options) {
+        super();
+        this.req = req;
+        this._completed = false;
+        this._receivedSize = 0;
+        this.onAborted = () => this._onAborted();
+        this.onData = (chunk) => this._onData(chunk);
+        this.onEnd = (err) => this._onEnd(err);
+        this.cleanup = () => this._cleanup();
+        this.limit = options?.limit
+            ? typeof options.limit === 'number'
+                ? options.limit
+                : (0, bytes_1.default)(options.limit)
+            : undefined;
+    }
+    async read() {
+        /* istanbul ignore next */
+        if (this._completed)
+            throw new common_1.InternalServerError({
+                message: 'Stream already read',
+                code: 'STREAM_ALREADY_READ',
+            });
+        if (!this.req.readable) {
+            throw new common_1.InternalServerError({
+                message: 'Stream is not readable',
+                code: 'STREAM_NOT_READABLE',
+            });
+        }
+        return new Promise((resolve, reject) => {
+            // eslint-disable-next-line prefer-const
+            let sizeStream;
+            this.once('finish', (error, data) => {
+                if (sizeStream)
+                    this.req.unpipe(sizeStream);
+                if (error)
+                    return reject(error);
+                resolve(data);
+            });
+            /**
+             * Check if a request has a request body.
+             * A request with a body __must__ either have `transfer-encoding`
+             * or `content-length` headers set.
+             * http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.3
+             */
+            const contentLength = parseInt(this.req.headers['content-length'] || '0', 10);
+            if (this.req.headers['transfer-encoding'] === undefined && !(contentLength && !isNaN(contentLength)))
+                return this.onEnd();
+            // check the length and limit options.
+            // note: we intentionally leave the stream paused,
+            // so users should handle the stream themselves.
+            if (this.limit != null && contentLength != null && contentLength > this.limit) {
+                return this.onEnd(new common_1.OpraHttpError({
+                    message: 'Content Too Large',
+                    code: 'HTTP.CONTENT_TOO_LARGE',
+                    details: {
+                        length: contentLength,
+                        limit: this.limit,
+                    },
+                }, 413));
+            }
+            // Pipe to a Writable stream to count received bytes
+            const _this = this;
+            sizeStream = new stream_1.Writable({
+                write(chunk, encoding, callback) {
+                    if (_this._completed)
+                        return;
+                    _this._receivedSize += chunk.length;
+                    if (_this.limit != null && _this._receivedSize > _this.limit) {
+                        callback(new common_1.OpraHttpError({
+                            message: 'Content Too Large',
+                            code: 'HTTP.CONTENT_TOO_LARGE',
+                            details: {
+                                limit: _this.limit,
+                                received: _this._receivedSize,
+                            },
+                        }, 413));
+                    }
+                },
+            });
+            this.req.pipe(sizeStream);
+            let stream = BodyReader.encoderPipeline(this.req);
+            const mediaType = (0, content_type_1.parse)(this.req.headers['content-type'] || '');
+            let charset = (mediaType.parameters.charset || '').toLowerCase();
+            if (!charset && type_is_1.default.is(mediaType.type, ['json', 'xml', 'txt']))
+                charset = 'utf-8';
+            if (charset) {
+                const newStream = iconv_lite_1.default.decodeStream(charset);
+                stream.pipe(newStream);
+                stream = newStream;
+            }
+            this._stream = stream;
+            // attach listeners
+            stream.on('aborted', this.onAborted);
+            stream.on('close', this.cleanup);
+            stream.on('data', this.onData);
+            stream.on('end', this.onEnd);
+            stream.on('error', this.onEnd);
+        });
+    }
+    _onEnd(error) {
+        if (this._completed)
+            return;
+        this._completed = true;
+        if (error) {
+            this._stream?.unpipe();
+            this._stream?.pause();
+        }
+        if (error)
+            this.emit('finish', error);
+        else if (Array.isArray(this._buffer))
+            this.emit('finish', error, Buffer.concat(this._buffer));
+        else
+            this.emit('finish', error, this._buffer);
+        this._cleanup();
+    }
+    _cleanup() {
+        if (this._stream) {
+            this._stream.removeListener('aborted', this.onAborted);
+            this._stream.removeListener('close', this.cleanup);
+            this._stream.removeListener('data', this.onData);
+            this._stream.removeListener('end', this.onEnd);
+            this._stream.removeListener('error', this.onEnd);
+        }
+    }
+    _onAborted() {
+        if (this._completed)
+            return;
+        this.onEnd(new common_1.BadRequestError({
+            message: 'request aborted',
+            code: 'ECONNABORTED',
+            details: {
+                length,
+                received: this._receivedSize,
+            },
+        }));
+    }
+    _onData(chunk) {
+        if (this._completed)
+            return;
+        if (typeof chunk === 'string') {
+            this._buffer = this._buffer || '';
+            this._buffer += chunk;
+        }
+        else {
+            this._buffer = this._buffer || [];
+            this._buffer.push(chunk);
+        }
+    }
+    static async read(req, options) {
+        const bodyReady = new BodyReader(req, options);
+        return bodyReady.read();
+    }
+    static encoderPipeline(req) {
+        const contentEncoding = req.headers['content-encoding'] || 'identity';
+        const contentEncodings = (Array.isArray(contentEncoding) ? contentEncoding : contentEncoding.split(/\s*,\s*/))
+            .map(s => s.toLowerCase())
+            .reverse();
+        return contentEncodings.reduce((prev, encoding) => {
+            switch (encoding) {
+                case 'gzip':
+                case 'x-gzip': {
+                    const newStream = zlib.createGunzip();
+                    prev.pipe(newStream);
+                    return newStream;
+                }
+                case 'deflate':
+                case 'x-deflate': {
+                    const newStream = zlib.createInflate();
+                    prev.pipe(newStream);
+                    return newStream;
+                }
+                case 'br': {
+                    const newStream = zlib.createBrotliDecompress();
+                    prev.pipe(newStream);
+                    return newStream;
+                }
+                case 'base64': {
+                    const newStream = new base64_stream_1.Base64Decode();
+                    prev.pipe(newStream);
+                    return newStream;
+                }
+                case 'identity':
+                    // prev.length = 0;
+                    return prev;
+                default:
+                    throw new common_1.BadRequestError({
+                        message: 'unsupported content encoding "' + encoding + '"',
+                        code: '',
+                        details: {
+                            encoding,
+                        },
+                    }, 415);
+            }
+        }, req);
+    }
+}
+exports.BodyReader = BodyReader;

package/cjs/http/{helpers → utils}/convert-to-raw-headers.js

@@ -3,8 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertToRawHeaders = void 0;
 const match_known_fields_js_1 = require("./match-known-fields.js");
 function convertToRawHeaders(src) {
-    return Object.entries(src)
-        .reduce((a, [field, v]) => {
+    return Object.entries(src).reduce((a, [field, v]) => {
         const [name, flag] = (0, match_known_fields_js_1.matchKnownFields)(field);
         if (flag === match_known_fields_js_1.ARRAY_FIELD) {
             if (Array.isArray(v))

package/cjs/http/{helpers → utils}/match-known-fields.js

@@ -6,9 +6,7 @@ exports.NO_DUPLICATES_FIELD = 0;
 exports.COMMA_DELIMITED_FIELD = 1;
 exports.SEMICOLON_DELIMITED_FIELD = 2;
 exports.ARRAY_FIELD = 3;
-const ARRAY_HEADERS = [
-    'set-cookie'
-];
+const ARRAY_HEADERS = ['set-cookie'];
 const NO_DUPLICATES_HEADERS = [
     'age',
     'from',
@@ -30,13 +28,17 @@ const NO_DUPLICATES_HEADERS = [
     'if-unmodified-since',
 ];
 const SEMICOLON_DELIMITED_HEADERS = ['cookie'];
-const KNOWN_FIELDS = Object.values(common_1.HttpHeaderCodes)
-    .reduce((o, k) => {
+const KNOWN_FIELDS = Object.values(common_1.HttpHeaderCodes).reduce((o, k) => {
     const n = k.toLowerCase();
-    o[n] = [k,
-        (NO_DUPLICATES_HEADERS.includes(n) ? exports.NO_DUPLICATES_FIELD :
-            (ARRAY_HEADERS.includes(n) ? exports.ARRAY_FIELD :
-                (SEMICOLON_DELIMITED_HEADERS.includes(n) ? exports.SEMICOLON_DELIMITED_FIELD : exports.COMMA_DELIMITED_FIELD)))
+    o[n] = [
+        k,
+        NO_DUPLICATES_HEADERS.includes(n)
+            ? exports.NO_DUPLICATES_FIELD
+            : ARRAY_HEADERS.includes(n)
+                ? exports.ARRAY_FIELD
+                : SEMICOLON_DELIMITED_HEADERS.includes(n)
+                    ? exports.SEMICOLON_DELIMITED_FIELD
+                    : exports.COMMA_DELIMITED_FIELD,
     ];
     return o;
 }, {});

package/cjs/http/utils/wrap-exception.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapException = void 0;
+const common_1 = require("@opra/common");
+function wrapException(error) {
+    if (error instanceof common_1.OpraHttpError)
+        return error;
+    let status = 500;
+    if (typeof error.status === 'number')
+        status = error.status;
+    else if (typeof error.getStatus === 'function')
+        status = error.getStatus();
+    switch (status) {
+        case 400:
+            return new common_1.BadRequestError(error);
+        case 401:
+            return new common_1.UnauthorizedError(error);
+        case 403:
+            return new common_1.ForbiddenError(error);
+        case 404:
+            return new common_1.NotFoundError(error);
+        case 405:
+            return new common_1.MethodNotAllowedError(error);
+        case 406:
+            return new common_1.NotAcceptableError(error);
+        case 422:
+            return new common_1.UnprocessableEntityError(error);
+        case 424:
+            return new common_1.FailedDependencyError(error);
+        default:
+            return new common_1.InternalServerError(error);
+    }
+}
+exports.wrapException = wrapException;

package/cjs/index.js

@@ -1,33 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.classes = void 0;
 const tslib_1 = require("tslib");
 require("reflect-metadata");
 require("./augmentation/18n.augmentation.js");
-require("./augmentation/resource.augmentation.js");
-require("./augmentation/collection.augmentation.js");
-require("./augmentation/container.augmentation.js");
-require("./augmentation/singleton.augmentation.js");
-require("./augmentation/storage.augmentation.js");
+require("./augmentation/http-controller.augmentation.js");
+const HttpIncomingHost_ = tslib_1.__importStar(require("./http/impl/http-incoming.host.js"));
+const HttpOutgoingHost_ = tslib_1.__importStar(require("./http/impl/http-outgoing.host.js"));
+const NodeIncomingMessageHost_ = tslib_1.__importStar(require("./http/impl/node-incoming-message.host.js"));
+const NodeOutgoingMessageHost_ = tslib_1.__importStar(require("./http/impl/node-outgoing-message.host.js"));
 tslib_1.__exportStar(require("./execution-context.js"), exports);
-tslib_1.__exportStar(require("./execution-context.host.js"), exports);
 tslib_1.__exportStar(require("./platform-adapter.js"), exports);
-tslib_1.__exportStar(require("./platform-adapter.host.js"), exports);
-tslib_1.__exportStar(require("./request.js"), exports);
-tslib_1.__exportStar(require("./request.host.js"), exports);
-tslib_1.__exportStar(require("./request-context.js"), exports);
-tslib_1.__exportStar(require("./response.js"), exports);
-tslib_1.__exportStar(require("./response.host.js"), exports);
-tslib_1.__exportStar(require("./http/adapters/express-adapter.js"), exports);
-tslib_1.__exportStar(require("./http/adapters/express-adapter.host.js"), exports);
-tslib_1.__exportStar(require("./http/adapters/node-http-adapter.js"), exports);
-tslib_1.__exportStar(require("./http/adapters/node-http-adapter.host.js"), exports);
-tslib_1.__exportStar(require("./http/impl/http-incoming-message.host.js"), exports);
-tslib_1.__exportStar(require("./http/impl/http-outgoing-message.host.js"), exports);
-tslib_1.__exportStar(require("./http/http-server-request.js"), exports);
-tslib_1.__exportStar(require("./http/http-server-response.js"), exports);
-tslib_1.__exportStar(require("./http/helpers/multipart-helper.js"), exports);
-tslib_1.__exportStar(require("./interfaces/interceptor.interface.js"), exports);
+tslib_1.__exportStar(require("./type-guards.js"), exports);
+tslib_1.__exportStar(require("./helpers/logger.js"), exports);
+tslib_1.__exportStar(require("./helpers/service-base.js"), exports);
+tslib_1.__exportStar(require("./http/express-adapter.js"), exports);
+tslib_1.__exportStar(require("./http/http-adapter.js"), exports);
+tslib_1.__exportStar(require("./http/http-context.js"), exports);
+tslib_1.__exportStar(require("./http/interfaces/http-incoming.interface.js"), exports);
+tslib_1.__exportStar(require("./http/interfaces/http-outgoing.interface.js"), exports);
+tslib_1.__exportStar(require("./http/interfaces/node-incoming-message.interface.js"), exports);
+tslib_1.__exportStar(require("./http/interfaces/node-outgoing-message.interface.js"), exports);
+tslib_1.__exportStar(require("./http/impl/multipart-reader.js"), exports);
+tslib_1.__exportStar(require("./http/utils/wrap-exception.js"), exports);
 tslib_1.__exportStar(require("./interfaces/logger.interface.js"), exports);
-tslib_1.__exportStar(require("./interfaces/request-handler.interface.js"), exports);
-tslib_1.__exportStar(require("./services/logger.js"), exports);
-tslib_1.__exportStar(require("./services/api-service.js"), exports);
+var classes;
+(function (classes) {
+    classes.HttpIncomingHost = HttpIncomingHost_.HttpIncomingHost;
+    classes.HttpOutgoingHost = HttpOutgoingHost_.HttpOutgoingHost;
+    classes.NodeIncomingMessageHost = NodeIncomingMessageHost_.NodeIncomingMessageHost;
+    classes.NodeOutgoingMessageHost = NodeOutgoingMessageHost_.NodeOutgoingMessageHost;
+})(classes || (exports.classes = classes = {}));

package/cjs/platform-adapter.js

@@ -1,2 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatformAdapter = void 0;
+require("./augmentation/18n.augmentation.js");
+const strict_typed_events_1 = require("strict-typed-events");
+const common_1 = require("@opra/common");
+const constants_js_1 = require("./constants.js");
+const logger_js_1 = require("./helpers/logger.js");
+const asset_cache_js_1 = require("./http/impl/asset-cache.js");
+/**
+ * @class PlatformAdapter
+ */
+class PlatformAdapter extends strict_typed_events_1.AsyncEventEmitter {
+    constructor(document, options) {
+        super();
+        this[constants_js_1.kAssetCache] = new asset_cache_js_1.AssetCache();
+        this.document = document;
+        this.logger =
+            options?.logger && options.logger instanceof logger_js_1.Logger ? options.logger : new logger_js_1.Logger({ instance: options?.logger });
+        this.i18n = options?.i18n || common_1.I18n.defaultInstance;
+    }
+}
+exports.PlatformAdapter = PlatformAdapter;

package/cjs/type-guards.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHttpOutgoing = exports.isNodeOutgoingMessage = exports.isHttpIncoming = exports.isNodeIncomingMessage = void 0;
+const common_1 = require("@opra/common");
+function isNodeIncomingMessage(v) {
+    return v && typeof v.method === 'string' && Array.isArray(v.rawHeaders) && (0, common_1.isReadable)(v);
+}
+exports.isNodeIncomingMessage = isNodeIncomingMessage;
+function isHttpIncoming(v) {
+    return (isNodeIncomingMessage(v) &&
+        typeof v.header === 'function' &&
+        typeof v.acceptsLanguages === 'function' &&
+        typeof v.readBody === 'function');
+}
+exports.isHttpIncoming = isHttpIncoming;
+function isNodeOutgoingMessage(v) {
+    return v && typeof v.getHeaders === 'function' && (0, common_1.isStream)(v);
+}
+exports.isNodeOutgoingMessage = isNodeOutgoingMessage;
+function isHttpOutgoing(v) {
+    return isNodeOutgoingMessage(v) && typeof v.clearCookie === 'function' && typeof v.cookie === 'function';
+}
+exports.isHttpOutgoing = isHttpOutgoing;

package/esm/augmentation/18n.augmentation.js

@@ -1,9 +1,22 @@
 import fs from 'fs';
 import path from 'path';
-import { I18n, isUrlString } from '@opra/common';
-I18n.prototype.loadResourceBundle = async function (lang, ns, filePath, deep, overwrite) {
+import { getStackFileName, I18n as I18n_ } from '@opra/common';
+I18n_.load = async function (options) {
+    const opts = {
+        ...options,
+    };
+    delete opts.resourceDirs;
+    const instance = I18n_.createInstance(opts);
+    await instance.init();
+    await instance.loadResourceDir(path.resolve(getStackFileName(), '../../../i18n'));
+    if (options?.resourceDirs)
+        for (const dir of options.resourceDirs)
+            await instance.loadResourceDir(dir);
+    return instance;
+};
+I18n_.prototype.loadResourceBundle = async function (lang, ns, filePath, deep, overwrite) {
     let obj;
-    if (isUrlString(filePath)) {
+    if (URL.canParse(filePath)) {
         obj = (await fetch(filePath, { headers: { accept: 'application/json' } })).json();
     }
     else {
@@ -12,20 +25,20 @@ I18n.prototype.loadResourceBundle = async function (lang, ns, filePath, deep, ov
     }
     this.addResourceBundle(lang, ns, obj, deep, overwrite);
 };
-I18n.prototype.loadResourceDir = async function (dirnames, deep, overwrite) {
+I18n_.prototype.loadResourceDir = async function (dirnames, deep, overwrite) {
     for (const dirname of Array.isArray(dirnames) ? dirnames : [dirnames]) {
         /* istanbul ignore next */
-        if (!(fs.existsSync(dirname)))
+        if (!fs.existsSync(dirname))
             continue;
         const languageDirs = fs.readdirSync(dirname);
         for (const lang of languageDirs) {
             const langDir = path.join(dirname, lang);
-            if ((fs.statSync(langDir)).isDirectory()) {
+            if (fs.statSync(langDir).isDirectory()) {
                 const nsDirs = fs.readdirSync(langDir);
                 for (const nsfile of nsDirs) {
                     const nsFilePath = path.join(langDir, nsfile);
                     const ext = path.extname(nsfile);
-                    if (ext === '.json' && (fs.statSync(nsFilePath)).isFile()) {
+                    if (ext === '.json' && fs.statSync(nsFilePath).isFile()) {
                         const ns = path.basename(nsfile, ext);
                         await this.loadResourceBundle(lang, ns, nsFilePath, deep, overwrite);
                     }

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

@@ -0,0 +1,23 @@
+import { HTTP_CONTROLLER_METADATA, HttpController } from '@opra/common';
+// @ts-ignore
+const oldInitialize = HttpController.prototype._initialize;
+// @ts-ignore
+HttpController.prototype._initialize = function (initArgs) {
+    oldInitialize?.call(this, initArgs);
+    this.onInit = initArgs.onInit;
+    this.onShutdown = initArgs.onShutdown;
+};
+HttpController.OnInit = function () {
+    return (target, propertyKey) => {
+        const sourceMetadata = (Reflect.getOwnMetadata(HTTP_CONTROLLER_METADATA, target.constructor) || {});
+        sourceMetadata.onInit = target[propertyKey];
+        Reflect.defineMetadata(HTTP_CONTROLLER_METADATA, target.constructor, sourceMetadata);
+    };
+};
+HttpController.OnShutdown = function () {
+    return (target, propertyKey) => {
+        const sourceMetadata = (Reflect.getOwnMetadata(HTTP_CONTROLLER_METADATA, target.constructor) || {});
+        sourceMetadata.onShutdown = target[propertyKey];
+        Reflect.defineMetadata(HTTP_CONTROLLER_METADATA, target.constructor, sourceMetadata);
+    };
+};

package/esm/constants.js

@@ -0,0 +1,2 @@
+export const kHandler = Symbol.for('kHandler');
+export const kAssetCache = Symbol.for('kAssetCache');

package/esm/execution-context.js

@@ -1,13 +1,25 @@
-import { ExecutionContextHost } from './execution-context.host.js';
-export var ExecutionContext;
-(function (ExecutionContext) {
-    function is(v) {
-        return v instanceof ExecutionContextHost ||
-            (typeof v.protocol === 'string' &&
-                typeof v.platform === 'string' &&
-                typeof v.switchToHttp === 'function' &&
-                typeof v.switchToWs === 'function' &&
-                typeof v.switchToRpc === 'function');
-    }
-    ExecutionContext.is = is;
-})(ExecutionContext || (ExecutionContext = {}));
+import { AsyncEventEmitter } from 'strict-typed-events';
+/**
+ * @class ExecutionContext
+ */
+export class ExecutionContext extends AsyncEventEmitter {
+    constructor(init) {
+        super();
+        this.document = init.document;
+        this.protocol = init.protocol;
+        this.platform = init.platform;
+        this.platformArgs = init.platformArgs;
+    }
+    addListener(event, listener) {
+        return super.addListener(event, listener);
+    }
+    removeListener(event, listener) {
+        return super.removeListener(event, listener);
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+}

package/esm/{services → helpers}/logger.js

@@ -1,7 +1,6 @@
 export class Logger {
     constructor(options = {}) {
-        this._instance = options.instance ||
-            (!(process.env.NODE_ENV || '').includes('test') ? globalThis.console : {});
+        this._instance = options.instance || (!(process.env.NODE_ENV || '').includes('test') ? globalThis.console : {});
     }
     info(message, ...optionalParams) {
         (this._instance.info || this._instance.log)?.(message, ...optionalParams);

package/esm/{services/api-service.js → helpers/service-base.js}

@@ -1,4 +1,4 @@
-export class ApiService {
+export class ServiceBase {
     get context() {
         if (!this._context)
             throw new Error(`No context assigned for ${Object.getPrototypeOf(this).constructor.name}`);
@@ -15,11 +15,11 @@ export class ApiService {
         Object.setPrototypeOf(instance, this);
         if (overwriteProperties)
             Object.assign(instance, overwriteProperties);
-        if (this[ApiService.extendSymbol])
-            this[ApiService.extendSymbol](instance);
+        if (this[ServiceBase.extendSymbol])
+            this[ServiceBase.extendSymbol](instance);
         return instance;
     }
 }
-(function (ApiService) {
-    ApiService.extendSymbol = Symbol('extend');
-})(ApiService || (ApiService = {}));
+(function (ServiceBase) {
+    ServiceBase.extendSymbol = Symbol('extend');
+})(ServiceBase || (ServiceBase = {}));