@opra/core 0.25.5 → 0.26.0

package/cjs/index.js

@@ -4,16 +4,17 @@ const tslib_1 = require("tslib");
 require("reflect-metadata");
 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");
 tslib_1.__exportStar(require("./types.js"), exports);
 tslib_1.__exportStar(require("./execution-context.js"), exports);
-tslib_1.__exportStar(require("./endpoint-context.js"), exports);
+tslib_1.__exportStar(require("./request-context.js"), exports);
 tslib_1.__exportStar(require("./platform-adapter.js"), exports);
 tslib_1.__exportStar(require("./request.js"), exports);
 tslib_1.__exportStar(require("./response.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/adapters/express-adapter.js"), exports);
+tslib_1.__exportStar(require("./http/adapters/node-http-adapter.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);

package/cjs/platform-adapter.host.js

@@ -7,32 +7,17 @@ const putil_varhelpers_1 = require("putil-varhelpers");
 const strict_typed_events_1 = require("strict-typed-events");
 const common_1 = require("@opra/common");
 const logger_js_1 = require("./services/logger.js");
+const resourceInitialized = Symbol.for('opra.resource.initialized');
 /**
  * @class PlatformAdapterHost
  */
 class PlatformAdapterHost extends strict_typed_events_1.AsyncEventEmitter {
-    constructor(api, options) {
-        super();
-        this.api = api;
-        this._controllers = new WeakMap();
-        this._initialized = false;
-        this._options = options || {};
-        this._interceptors = [...(options?.interceptors || [])];
-        this._logger = options?.logger && options.logger instanceof logger_js_1.Logger
-            ? options.logger
-            : new logger_js_1.Logger({ instance: options?.logger });
-        // Assign events
-        if (options?.on) {
-            for (const [event, fn] of Object.entries(options.on)) {
-                /* istanbul ignore next */
-                if (typeof fn === 'function')
-                    this.on(event, fn);
-            }
-        }
-        // Make a safe service name
-        this._serviceName = (0, putil_varhelpers_1.pascalCase)((api.info.title || '').replace(/[^a-z0-9_ ]/ig, '')) || 'OpraService';
-        if (!/^[a-z]/i.test(this._serviceName))
-            this._serviceName = 'X' + this._serviceName;
+    constructor() {
+        super(...arguments);
+        this._controllers = new Map();
+    }
+    get api() {
+        return this._api;
     }
     get platform() {
         return this._platform;
@@ -41,56 +26,100 @@ class PlatformAdapterHost extends strict_typed_events_1.AsyncEventEmitter {
         return this._protocol;
     }
     get serviceName() {
-        return this.api.info.title;
+        return this._serviceName;
+    }
+    get i18n() {
+        return this._i18n;
     }
     async close() {
         const promises = [];
-        for (const r of this.api.resources.values()) {
-            const onShutdown = r.onShutdown;
+        for (const r of this._controllers.values()) {
+            const onShutdown = r?.onShutdown;
             if (onShutdown)
                 promises.push((async () => onShutdown.call(r.controller, r))());
         }
         await Promise.allSettled(promises);
+        this._controllers.clear();
     }
     /**
      * Initializes the adapter
      */
-    async init() {
-        if (this._initialized)
-            return;
+    async init(api, options) {
+        if (this._api)
+            throw new Error(`Already initialized`);
+        this._api = api;
+        this._interceptors = [...(options?.interceptors || [])];
+        this._logger = options?.logger && options.logger instanceof logger_js_1.Logger
+            ? options.logger
+            : new logger_js_1.Logger({ instance: options?.logger });
+        // Assign events
+        if (options?.on) {
+            for (const [event, fn] of Object.entries(options.on)) {
+                /* istanbul ignore next */
+                if (typeof fn === 'function')
+                    this.on(event, fn);
+            }
+        }
+        // Make a safe service name
+        this._serviceName = (0, putil_varhelpers_1.pascalCase)((api.info.title || '').replace(/[^a-z0-9_ ]/ig, '')) || 'OpraService';
+        if (!/^[a-z]/i.test(this._serviceName))
+            this._serviceName = 'X' + this._serviceName;
         // Init I18n
-        if (this._options?.i18n instanceof common_1.I18n)
-            this._i18n = this._options.i18n;
-        else if (typeof this._options?.i18n === 'function')
-            this._i18n = await this._options.i18n();
+        if (options?.i18n instanceof common_1.I18n)
+            this._i18n = options.i18n;
+        else if (typeof options?.i18n === 'function')
+            this._i18n = await options.i18n();
         else
-            this._i18n = await this._createI18n(this._options?.i18n);
+            this._i18n = await this._createI18n(options?.i18n);
         this._i18n = this._i18n || common_1.I18n.defaultInstance;
         if (!this._i18n.isInitialized)
             await this._i18n.init();
         // Initialize all resources
-        for (const resource of this.api.resources.values()) {
-            await this.getController(resource);
-        }
-        this._initialized = true;
+        await this.getController(this.api.root);
     }
     async getController(resource) {
         resource = typeof resource === 'object' && resource instanceof common_1.Resource
             ? resource : this.api.getResource(resource);
         let controller = this._controllers.get(resource);
         if (!controller) {
-            if (resource.controller) {
-                controller = typeof resource.controller === 'function' ?
-                    new resource.controller()
-                    : resource.controller;
-                // Initialize controller
-                if (typeof controller.onInit === 'function')
-                    await controller.onInit.call(controller);
-                this._controllers.set(resource, controller);
+            controller = resource.controller;
+            if (!controller && resource.ctor) {
+                controller = new resource.ctor();
+            }
+            this._controllers.set(resource, controller);
+        }
+        if (controller && !controller[resourceInitialized]) {
+            controller[resourceInitialized] = true;
+            // Initialize controller
+            if (typeof controller.onInit === 'function')
+                await controller.onInit.call(controller);
+            // Initialize sub resources of Container
+            if (resource instanceof common_1.Container) {
+                for (const r of resource.resources.values()) {
+                    await this.getController(r);
+                }
             }
         }
         return controller;
     }
+    async getOperationHandler(resource, operationOrAction) {
+        resource = typeof resource === 'object' && resource instanceof common_1.Resource
+            ? resource
+            : this.api.getResource(resource);
+        const controller = await this.getController(resource);
+        const endpoint = (resource instanceof common_1.CrudResource && resource.operations.get(operationOrAction)) ||
+            resource.actions.get(operationOrAction);
+        if (endpoint) {
+            const handler = typeof controller[operationOrAction] === 'function' ? controller[operationOrAction] : undefined;
+            if (handler)
+                return { controller, endpoint, handler };
+        }
+        throw new common_1.ForbiddenError({
+            message: (0, common_1.translate)('OPERATION_FORBIDDEN', { resource: resource.name, endpoint: operationOrAction }, `'{{resource}}' does not accept '{{endpoint}}' operations`),
+            severity: 'error',
+            code: 'OPERATION_FORBIDDEN'
+        });
+    }
     async _createI18n(options) {
         const opts = {
             ...options,

package/cjs/{endpoint-context.js → request-context.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EndpointContext = void 0;
-var EndpointContext;
-(function (EndpointContext) {
+exports.RequestContext = void 0;
+var RequestContext;
+(function (RequestContext) {
     function from(executionContext, request, response) {
         const out = {
             request,
@@ -12,5 +12,5 @@ var EndpointContext;
         Object.setPrototypeOf(out, executionContext);
         return out;
     }
-    EndpointContext.from = from;
-})(EndpointContext || (exports.EndpointContext = EndpointContext = {}));
+    RequestContext.from = from;
+})(RequestContext || (exports.RequestContext = RequestContext = {}));

package/cjs/request.host.js

@@ -6,6 +6,9 @@ class RequestHost {
         Object.assign(this, init);
         this.params = this.params || {};
     }
+    get resource() {
+        return this.endpoint.resource;
+    }
     switchToHttp() {
         if (this.http)
             return this.http;

package/esm/augmentation/container.augmentation.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,30 @@
+import { OpraURLPath } from '@opra/common';
+import { HttpAdapterHost } from '../http-adapter-host.js';
+import { HttpServerRequest } from '../http-server-request.js';
+import { HttpServerResponse } from '../http-server-response.js';
+export class ExpressAdapterHost extends HttpAdapterHost {
+    constructor(app) {
+        super();
+        this._platform = 'express';
+        this._app = app;
+    }
+    get app() {
+        return this._app;
+    }
+    async init(api, options) {
+        await super.init(api, options);
+        this._api = api;
+        const basePath = new OpraURLPath(options?.basePath);
+        this._app.use(basePath.toString(), (_req, _res) => {
+            const req = HttpServerRequest.from(_req);
+            const res = HttpServerResponse.from(_res);
+            this.handleHttp(req, res)
+                .catch((e) => this._logger.fatal(e));
+        });
+    }
+    static async create(app, api, options) {
+        const adapter = new ExpressAdapterHost(app);
+        await adapter.init(api, options);
+        return adapter;
+    }
+}

package/esm/http/{express-adapter.js → adapters/express-adapter.js}

@@ -5,9 +5,7 @@ import { ExpressAdapterHost } from './express-adapter.host.js';
 export var ExpressAdapter;
 (function (ExpressAdapter) {
     async function create(app, api, options) {
-        const adapter = new ExpressAdapterHost(app, api, options);
-        await adapter.init();
-        return adapter;
+        return ExpressAdapterHost.create(app, api, options);
     }
     ExpressAdapter.create = create;
 })(ExpressAdapter || (ExpressAdapter = {}));

package/esm/http/{http-adapter.host.js → adapters/node-http-adapter.host.js}

@@ -1,17 +1,15 @@
 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';
+import { HttpAdapterHost } from '../http-adapter-host.js';
+import { HttpServerRequest } from '../http-server-request.js';
+import { HttpServerResponse } from '../http-server-response.js';
 /**
- * @class HttpAdapterHost
+ * @class NodeHttpAdapterHost
  */
-export class HttpAdapterHost extends HttpAdapterBase {
-    constructor(api, options) {
-        super(api, options);
+export class NodeHttpAdapterHost extends HttpAdapterHost {
+    constructor() {
+        super(...arguments);
         this._platform = 'http';
-        this._basePath = new OpraURLPath(options?.basePath);
-        this._server = http.createServer((incomingMessage, serverResponse) => this._serverListener(incomingMessage, serverResponse));
     }
     get basePath() {
         return this._basePath;
@@ -19,6 +17,22 @@ export class HttpAdapterHost extends HttpAdapterBase {
     get server() {
         return this._server;
     }
+    async close() {
+        await super.close();
+        if (this.server.listening)
+            await new Promise((resolve, reject) => {
+                this.server.close((err) => {
+                    if (err)
+                        return reject(err);
+                    resolve();
+                });
+            });
+    }
+    async init(api, options) {
+        await super.init(api, options);
+        this._basePath = new OpraURLPath(options?.basePath);
+        this._server = http.createServer((incomingMessage, serverResponse) => this._serverListener(incomingMessage, serverResponse));
+    }
     _serverListener(incomingMessage, serverResponse) {
         const originalUrl = incomingMessage.url;
         const parsedUrl = new OpraURL(originalUrl);
@@ -40,18 +54,12 @@ export class HttpAdapterHost extends HttpAdapterBase {
         });
         const req = HttpServerRequest.from(incomingMessage);
         const res = HttpServerResponse.from(serverResponse);
-        this.handleIncoming(req, res)
+        this.handleHttp(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();
-                });
-            });
+    static async create(api, options) {
+        const adapter = new NodeHttpAdapterHost();
+        await adapter.init(api, options);
+        return adapter;
     }
 }

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

@@ -0,0 +1,11 @@
+import { NodeHttpAdapterHost } from './node-http-adapter.host.js';
+/**
+ * @namespace NodeHttpAdapter
+ */
+export var NodeHttpAdapter;
+(function (NodeHttpAdapter) {
+    async function create(api, options) {
+        return NodeHttpAdapterHost.create(api, options);
+    }
+    NodeHttpAdapter.create = create;
+})(NodeHttpAdapter || (NodeHttpAdapter = {}));

package/esm/http/helpers/json-body-loader.js

@@ -0,0 +1,24 @@
+import bodyParser from 'body-parser';
+const bodyLoaderCache = new WeakMap();
+export function jsonBodyLoader(options, cachePoint) {
+    let bodyLoader = cachePoint ? bodyLoaderCache.get(cachePoint) : undefined;
+    if (bodyLoader)
+        return bodyLoader;
+    const parser = bodyParser.json({
+        ...options,
+        type: 'json'
+    });
+    bodyLoader = (incoming) => {
+        return new Promise((resolve, reject) => {
+            const next = (error) => {
+                if (error)
+                    return reject(error);
+                resolve(incoming.body);
+            };
+            parser(incoming, {}, next);
+        });
+    };
+    if (cachePoint)
+        bodyLoaderCache.set(cachePoint, bodyLoader);
+    return bodyLoader;
+}