@opra/core 0.33.13 → 1.0.0-alpha.2

package/cjs/augmentation/18n.augmentation.js

@@ -4,9 +4,22 @@ const tslib_1 = require("tslib");
 const fs_1 = tslib_1.__importDefault(require("fs"));
 const path_1 = tslib_1.__importDefault(require("path"));
 const common_1 = require("@opra/common");
+common_1.I18n.load = async function (options) {
+    const opts = {
+        ...options,
+    };
+    delete opts.resourceDirs;
+    const instance = common_1.I18n.createInstance(opts);
+    await instance.init();
+    await instance.loadResourceDir(path_1.default.resolve((0, common_1.getStackFileName)(), '../../../i18n'));
+    if (options?.resourceDirs)
+        for (const dir of options.resourceDirs)
+            await instance.loadResourceDir(dir);
+    return instance;
+};
 common_1.I18n.prototype.loadResourceBundle = async function (lang, ns, filePath, deep, overwrite) {
     let obj;
-    if ((0, common_1.isUrlString)(filePath)) {
+    if (URL.canParse(filePath)) {
         obj = (await fetch(filePath, { headers: { accept: 'application/json' } })).json();
     }
     else {
@@ -18,17 +31,17 @@ common_1.I18n.prototype.loadResourceBundle = async function (lang, ns, filePath,
 common_1.I18n.prototype.loadResourceDir = async function (dirnames, deep, overwrite) {
     for (const dirname of Array.isArray(dirnames) ? dirnames : [dirnames]) {
         /* istanbul ignore next */
-        if (!(fs_1.default.existsSync(dirname)))
+        if (!fs_1.default.existsSync(dirname))
             continue;
         const languageDirs = fs_1.default.readdirSync(dirname);
         for (const lang of languageDirs) {
             const langDir = path_1.default.join(dirname, lang);
-            if ((fs_1.default.statSync(langDir)).isDirectory()) {
+            if (fs_1.default.statSync(langDir).isDirectory()) {
                 const nsDirs = fs_1.default.readdirSync(langDir);
                 for (const nsfile of nsDirs) {
                     const nsFilePath = path_1.default.join(langDir, nsfile);
                     const ext = path_1.default.extname(nsfile);
-                    if (ext === '.json' && (fs_1.default.statSync(nsFilePath)).isFile()) {
+                    if (ext === '.json' && fs_1.default.statSync(nsFilePath).isFile()) {
                         const ns = path_1.default.basename(nsfile, ext);
                         await this.loadResourceBundle(lang, ns, nsFilePath, deep, overwrite);
                     }

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@opra/common");
+// @ts-ignore
+const oldInitialize = common_1.HttpController.prototype._initialize;
+// @ts-ignore
+common_1.HttpController.prototype._initialize = function (initArgs) {
+    oldInitialize?.call(this, initArgs);
+    this.onInit = initArgs.onInit;
+    this.onShutdown = initArgs.onShutdown;
+};
+common_1.HttpController.OnInit = function () {
+    return (target, propertyKey) => {
+        const sourceMetadata = (Reflect.getOwnMetadata(common_1.HTTP_CONTROLLER_METADATA, target.constructor) || {});
+        sourceMetadata.onInit = target[propertyKey];
+        Reflect.defineMetadata(common_1.HTTP_CONTROLLER_METADATA, target.constructor, sourceMetadata);
+    };
+};
+common_1.HttpController.OnShutdown = function () {
+    return (target, propertyKey) => {
+        const sourceMetadata = (Reflect.getOwnMetadata(common_1.HTTP_CONTROLLER_METADATA, target.constructor) || {});
+        sourceMetadata.onShutdown = target[propertyKey];
+        Reflect.defineMetadata(common_1.HTTP_CONTROLLER_METADATA, target.constructor, sourceMetadata);
+    };
+};

package/cjs/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kAssetCache = exports.kHandler = void 0;
+exports.kHandler = Symbol.for('kHandler');
+exports.kAssetCache = Symbol.for('kAssetCache');

package/cjs/execution-context.js

@@ -1,16 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExecutionContext = void 0;
-const execution_context_host_js_1 = require("./execution-context.host.js");
-var ExecutionContext;
-(function (ExecutionContext) {
-    function is(v) {
-        return v instanceof execution_context_host_js_1.ExecutionContextHost ||
-            (typeof v.protocol === 'string' &&
-                typeof v.platform === 'string' &&
-                typeof v.switchToHttp === 'function' &&
-                typeof v.switchToWs === 'function' &&
-                typeof v.switchToRpc === 'function');
+const strict_typed_events_1 = require("strict-typed-events");
+/**
+ * @class ExecutionContext
+ */
+class ExecutionContext extends strict_typed_events_1.AsyncEventEmitter {
+    constructor(init) {
+        super();
+        this.document = init.document;
+        this.protocol = init.protocol;
+        this.platform = init.platform;
+        this.platformArgs = init.platformArgs;
     }
-    ExecutionContext.is = is;
-})(ExecutionContext || (exports.ExecutionContext = ExecutionContext = {}));
+    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);
+    }
+}
+exports.ExecutionContext = ExecutionContext;

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

@@ -3,8 +3,7 @@ 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 : {});
+        this._instance = options.instance || (!(process.env.NODE_ENV || '').includes('test') ? globalThis.console : {});
     }
     info(message, ...optionalParams) {
         (this._instance.info || this._instance.log)?.(message, ...optionalParams);

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiService = void 0;
-class ApiService {
+exports.ServiceBase = void 0;
+class ServiceBase {
     get context() {
         if (!this._context)
             throw new Error(`No context assigned for ${Object.getPrototypeOf(this).constructor.name}`);
@@ -18,12 +18,12 @@ 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;
     }
 }
-exports.ApiService = ApiService;
-(function (ApiService) {
-    ApiService.extendSymbol = Symbol('extend');
-})(ApiService || (exports.ApiService = ApiService = {}));
+exports.ServiceBase = ServiceBase;
+(function (ServiceBase) {
+    ServiceBase.extendSymbol = Symbol('extend');
+})(ServiceBase || (exports.ServiceBase = ServiceBase = {}));

package/cjs/http/express-adapter.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressAdapter = void 0;
+const tslib_1 = require("tslib");
+const express_1 = require("express");
+const nodePath = tslib_1.__importStar(require("path"));
+const common_1 = require("@opra/common");
+const constants_js_1 = require("../constants.js");
+const http_adapter_js_1 = require("./http-adapter.js");
+const http_context_js_1 = require("./http-context.js");
+const http_incoming_interface_js_1 = require("./interfaces/http-incoming.interface.js");
+const http_outgoing_interface_js_1 = require("./interfaces/http-outgoing.interface.js");
+class ExpressAdapter extends http_adapter_js_1.HttpAdapter {
+    constructor(app, document, options) {
+        super(document, options);
+        this._controllerInstances = new Map();
+        this.app = app;
+        if (!(this.document.api instanceof common_1.HttpApi))
+            throw new TypeError('document.api must be instance of HttpApi');
+        for (const c of this.api.controllers.values())
+            this._createControllers(c);
+        this._initRouter(options?.basePath);
+    }
+    get platform() {
+        return 'express';
+    }
+    async close() {
+        const processResource = async (resource) => {
+            if (resource.controllers.size) {
+                const subResources = Array.from(resource.controllers.values());
+                subResources.reverse();
+                for (const subResource of subResources) {
+                    await processResource(subResource);
+                }
+            }
+            if (resource.onShutdown) {
+                const instance = this._controllerInstances.get(resource) || resource.instance;
+                if (instance)
+                    try {
+                        await resource.onShutdown.call(instance, resource);
+                    }
+                    catch (e) {
+                        this.logger.error(e);
+                    }
+            }
+        };
+        for (const c of this.api.controllers.values())
+            await processResource(c);
+        this._controllerInstances.clear();
+    }
+    getControllerInstance(controllerPath) {
+        const controller = this.api.findController(controllerPath);
+        return controller && this._controllerInstances.get(controller);
+    }
+    _initRouter(basePath) {
+        const router = (0, express_1.Router)();
+        if (basePath) {
+            if (!basePath.startsWith('/'))
+                basePath = '/' + basePath;
+            if (basePath)
+                this.app.use(basePath, router);
+        }
+        else
+            this.app.use(router);
+        const createContext = (_req, _res, args) => {
+            const request = http_incoming_interface_js_1.HttpIncoming.from(_req);
+            const response = http_outgoing_interface_js_1.HttpOutgoing.from(_res);
+            const platformArgs = {
+                request: _req,
+                response: _res,
+            };
+            return new http_context_js_1.HttpContext({
+                adapter: this,
+                platform: this.platform,
+                platformArgs,
+                request,
+                response,
+                controller: args?.controller,
+                controllerInstance: args?.controllerInstance,
+                operation: args?.operation,
+                operationHandler: args?.operationHandler,
+            });
+        };
+        /** Add an endpoint that returns document schema */
+        router.get('*', (_req, _res, next) => {
+            if (_req.url.includes('/$schema')) {
+                const url = (_req.url.includes('?') ? _req.url.substring(0, _req.url.indexOf('?')) : _req.url).toLowerCase();
+                if (url === '/$schema') {
+                    const context = createContext(_req, _res);
+                    this[constants_js_1.kHandler].sendDocumentSchema(context).catch(next);
+                    return;
+                }
+            }
+            next();
+        });
+        /** Add operation endpoints */
+        if (this.api.controllers.size) {
+            const processResource = (controller, currentPath) => {
+                currentPath = nodePath.join(currentPath, controller.path);
+                for (const operation of controller.operations.values()) {
+                    const routePath = currentPath + (operation.path || '');
+                    const controllerInstance = this._controllerInstances.get(controller);
+                    const operationHandler = controllerInstance[operation.name];
+                    if (!operationHandler)
+                        continue;
+                    /** Define router callback */
+                    router[operation.method.toLowerCase()](routePath, (_req, _res, _next) => {
+                        const context = createContext(_req, _res, {
+                            controller,
+                            controllerInstance,
+                            operation,
+                            operationHandler,
+                        });
+                        this[constants_js_1.kHandler]
+                            .handleRequest(context)
+                            .then(() => {
+                            if (!_res.headersSent)
+                                _next();
+                        })
+                            .catch((e) => this.logger.fatal(e));
+                    });
+                }
+                if (controller.controllers.size) {
+                    for (const child of controller.controllers.values())
+                        processResource(child, currentPath);
+                }
+            };
+            for (const c of this.api.controllers.values())
+                processResource(c, '/');
+        }
+        /** Add an endpoint that returns 404 error at last */
+        router.use('*', (_req, _res, next) => {
+            const res = http_outgoing_interface_js_1.HttpOutgoing.from(_res);
+            // const url = new URL(_req.originalUrl, '')
+            this[constants_js_1.kHandler]
+                .sendErrorResponse(res, [
+                new common_1.NotFoundError({
+                    message: `No endpoint found for [${_req.method}]${_req.baseUrl}`,
+                    details: {
+                        path: _req.baseUrl,
+                        method: _req.method,
+                    },
+                }),
+            ])
+                .catch(next);
+        });
+    }
+    _createControllers(controller) {
+        let instance = controller.instance;
+        if (!instance && controller.ctor)
+            instance = new controller.ctor();
+        if (instance) {
+            if (typeof instance.onInit === 'function')
+                instance.onInit.call(instance, this);
+            this._controllerInstances.set(controller, instance);
+            // Initialize sub resources
+            for (const r of controller.controllers.values()) {
+                this._createControllers(r);
+            }
+        }
+        return instance;
+    }
+}
+exports.ExpressAdapter = ExpressAdapter;

package/cjs/http/http-adapter.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpAdapter = void 0;
+const common_1 = require("@opra/common");
+const constants_js_1 = require("../constants.js");
+const platform_adapter_js_1 = require("../platform-adapter.js");
+const http_handler_js_1 = require("./impl/http-handler.js");
+/**
+ *
+ * @class HttpAdapter
+ */
+class HttpAdapter extends platform_adapter_js_1.PlatformAdapter {
+    constructor(document, options) {
+        super(document, options);
+        this.protocol = 'http';
+        if (!(document.api instanceof common_1.HttpApi))
+            throw new TypeError(`The document does not expose an HTTP Api`);
+        this[constants_js_1.kHandler] = new http_handler_js_1.HttpHandler(this);
+        this.interceptors = [...(options?.interceptors || [])];
+        if (options?.onRequest)
+            this.on('request', options.onRequest);
+    }
+    get api() {
+        return this.document.api;
+    }
+}
+exports.HttpAdapter = HttpAdapter;

package/cjs/http/http-context.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpContext = void 0;
+const tslib_1 = require("tslib");
+const valgen_1 = require("valgen");
+const type_is_1 = tslib_1.__importDefault(require("@browsery/type-is"));
+const common_1 = require("@opra/common");
+const constants_js_1 = require("../constants.js");
+const execution_context_js_1 = require("../execution-context.js");
+const multipart_reader_js_1 = require("./impl/multipart-reader.js");
+class HttpContext extends execution_context_js_1.ExecutionContext {
+    constructor(init) {
+        super({ ...init, document: init.adapter.document, protocol: 'http' });
+        this.adapter = init.adapter;
+        this.protocol = 'http';
+        if (init.controller)
+            this.controller = init.controller;
+        if (init.controllerInstance)
+            this.controllerInstance = init.controllerInstance;
+        if (init.operation)
+            this.operation = init.operation;
+        if (init.operationHandler)
+            this.operationHandler = init.operationHandler;
+        this.request = init.request;
+        this.response = init.response;
+        this.mediaType = init.mediaType;
+        this.cookies = init.cookies || {};
+        this.headers = init.headers || {};
+        this.pathParams = init.pathParams || {};
+        this.queryParams = init.queryParams || {};
+        this._body = init.body;
+    }
+    get isMultipart() {
+        return !!this.request.is('multipart');
+    }
+    async getMultipartReader() {
+        if (!this.isMultipart)
+            throw new common_1.InternalServerError('Request content is not a multipart content');
+        if (this._multipartReader)
+            return this._multipartReader;
+        const { request, mediaType } = this;
+        if (mediaType?.contentType) {
+            const arr = Array.isArray(mediaType.contentType) ? mediaType.contentType : [mediaType.contentType];
+            const contentType = arr.find(ct => type_is_1.default.is(ct, ['multipart']));
+            if (!contentType)
+                throw new common_1.NotAcceptableError('This endpoint does not accept multipart requests');
+        }
+        const reader = new multipart_reader_js_1.MultipartReader(request, {
+            maxFields: mediaType?.maxFields,
+            maxFieldsSize: mediaType?.maxFieldsSize,
+            maxFiles: mediaType?.maxFiles,
+            maxFileSize: mediaType?.maxFileSize,
+            maxTotalFileSize: mediaType?.maxTotalFileSize,
+            minFileSize: mediaType?.minFileSize,
+        });
+        this._multipartReader = reader;
+        return reader;
+    }
+    async getBody() {
+        if (this._body !== undefined)
+            return this._body;
+        const { request, operation, mediaType } = this;
+        if (this.isMultipart) {
+            const reader = await this.getMultipartReader();
+            /** Retrieve all fields */
+            const parts = await reader.getAll();
+            /** Filter fields according to configuration */
+            this._body = [];
+            const multipartFields = mediaType?.multipartFields;
+            if (mediaType && multipartFields?.length) {
+                const fieldsFound = new Map();
+                for (const item of parts) {
+                    const field = mediaType.findMultipartField(item.fieldName, item.type);
+                    if (field) {
+                        fieldsFound.set(field, true);
+                        this._body.push(item);
+                    }
+                }
+                /** Check required fields */
+                for (const field of multipartFields) {
+                    if (field.required && !fieldsFound.get(field))
+                        throw new common_1.BadRequestError({
+                            message: `Multipart field (${field.fieldName}) is required`,
+                        });
+                }
+            }
+            return this._body;
+        }
+        this._body = await this.request.readBody({ limit: operation.requestBody?.maxContentSize });
+        if (this._body != null) {
+            // Convert Buffer to string if media is text
+            if (Buffer.isBuffer(this._body) && request.is(['json', 'xml', 'txt', 'text']))
+                this._body = this._body.toString('utf-8');
+            // Transform text to Object if media is JSON
+            if (typeof this._body === 'string' && request.is(['json']))
+                this._body = JSON.parse(this._body);
+        }
+        if (mediaType) {
+            // Decode/Validate the data object according to data model
+            if (this._body && mediaType.type) {
+                let decode = this.adapter[constants_js_1.kAssetCache].get(mediaType, 'decode');
+                if (!decode) {
+                    decode =
+                        mediaType.type?.generateCodec('decode', {
+                            partial: operation.requestBody?.partial,
+                            projection: '*',
+                        }) || valgen_1.vg.isAny();
+                    this.adapter[constants_js_1.kAssetCache].set(mediaType, 'decode', decode);
+                }
+                this._body = decode(this._body);
+            }
+        }
+        return this._body;
+    }
+}
+exports.HttpContext = HttpContext;

package/cjs/http/impl/asset-cache.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetCache = void 0;
+class AssetCache {
+    constructor() {
+        this._items = new WeakMap();
+    }
+    get(obj, name) {
+        const cache = this._items.get(obj);
+        return cache && cache[name];
+    }
+    set(obj, name, asset) {
+        let cache = this._items.get(obj);
+        if (!cache) {
+            cache = {};
+            this._items.set(obj, cache);
+        }
+        cache[name] = asset;
+    }
+}
+exports.AssetCache = AssetCache;