@opra/core 0.14.0 → 0.16.0

package/esm/adapter/adapter.js

@@ -1,318 +1,118 @@
-import { Task } from 'power-tasks';
-import { AsyncEventEmitter } from 'strict-typed-events';
-import { CollectionCountQuery, CollectionResourceInfo, CollectionSearchQuery, ComplexType, FailedDependencyError, ForbiddenError, HttpHeaderCodes, I18n, InternalServerError, ResourceNotFoundError, ResponsiveMap, SingletonResourceInfo, translate, wrapException } from '@opra/common';
-import { createI18n } from '../utils/create-i18n.js';
-import { MetadataResource } from './classes/metadata.resource.js';
-import { BatchRequestContext } from './request-contexts/batch-request-context.js';
-import { SingleRequestContext } from './request-contexts/single-request-context.js';
-const noOp = () => void 0;
-export class OpraAdapter {
-    constructor(document) {
-        this.document = document;
-        this._internalResources = new ResponsiveMap();
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraAdapter = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const strict_typed_events_1 = require("strict-typed-events");
+const common_1 = require("@opra/common");
+const metadata_resource_js_1 = require("./internal/metadata.resource.js");
+/**
+ * @class OpraAdapter
+ */
+class OpraAdapter extends strict_typed_events_1.AsyncEventEmitter {
+    constructor(api) {
+        super();
+        this.api = api;
     }
-    async close() {
-        const promises = [];
-        for (const r of this.document.resources.values()) {
-            if (r.instance) {
-                const shutDown = r.instance.shutDown;
-                if (shutDown)
-                    promises.push((async () => shutDown.call(r.instance))());
-            }
-        }
-        await Promise.allSettled(promises);
-    }
-    async handler(executionContext) {
-        let requestContext;
-        let failed = false;
-        try {
-            if (this.userContextResolver)
-                executionContext.userContext = this.userContextResolver(executionContext);
-            requestContext = await this.parse(executionContext);
-            const task = this._requestContextToTask(executionContext, requestContext);
-            await task.toPromise().catch(noOp);
-            await this.sendResponse(executionContext, requestContext);
-        }
-        catch (e) {
-            failed = true;
-            const error = wrapException(e);
-            await this.sendError(executionContext, error);
-            if (this.logger)
-                try {
-                    this.logger.error(e);
-                }
-                catch {
-                    // noop
-                }
-        }
-        finally {
-            if (executionContext instanceof AsyncEventEmitter) {
-                await executionContext
-                    .emitAsyncSerial('finish', {
-                    context: executionContext,
-                    failed
-                }).catch();
-            }
-        }
-    }
-    _requestContextToTask(executionContext, requestContext) {
-        if (requestContext instanceof BatchRequestContext) {
-            const children = requestContext.queries.map(q => this._requestContextToTask(executionContext, q));
-            return new Task(children, { bail: true });
-        }
-        else if (requestContext instanceof SingleRequestContext) {
-            const { query } = requestContext;
-            const task = new Task(async () => {
-                if (query.resource) {
-                    const { resource } = query;
-                    // call pre_xxx method
-                    const fn = resource.metadata['pre_' + query.method];
-                    if (fn && typeof fn === 'function') {
-                        await fn(requestContext);
-                    }
-                    await this._executeResourceQuery(this.document, resource, requestContext);
-                    // todo execute sub property queries
-                    return;
-                }
-                throw new InternalServerError('Not implemented yet');
-            }, {
-                id: requestContext.contentId,
-                exclusive: query.operation !== 'read'
-            });
-            task.on('finish', () => {
-                if (task.error) {
-                    if (task.failedDependencies)
-                        requestContext.errors.push(new FailedDependencyError());
-                    else
-                        requestContext.errors.push(wrapException(task.error));
-                    if (this.logger)
-                        try {
-                            this.logger.error(task.error);
-                        }
-                        catch {
-                            // noop
-                        }
-                    return;
-                }
-            });
-            return task;
-        }
-        /* istanbul ignore next */
-        throw new TypeError('Invalid request context instance');
-    }
-    async _init(options) {
+    /**
+     * Initializes the adapter
+     * @param options
+     * @protected
+     */
+    async init(options) {
         this.logger = options?.logger;
-        if (options?.i18n instanceof 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 createI18n(options?.i18n);
-        this.i18n = this.i18n || I18n.defaultInstance;
+            this.i18n = await this._createI18n(options?.i18n);
+        this.i18n = this.i18n || common_1.I18n.defaultInstance;
         if (!this.i18n.isInitialized)
             await this.i18n.init();
-        this.userContextResolver = options?.userContext;
-        const metadataResource = new MetadataResource();
-        const metadataResourceInfo = new SingletonResourceInfo(this.document, '$metadata', this.document.getComplexDataType('object'), {
-            kind: 'SingletonResource',
-            type: 'object',
-            instance: metadataResource,
-            get: {
-                handler: metadataResource.get.bind(metadataResource)
-            }
+        if (options?.onRequest)
+            this.on('request', options.onRequest);
+        this._internalDoc = await common_1.DocumentFactory.createDocument({
+            version: common_1.OpraSchema.SpecVersion,
+            info: {
+                version: common_1.OpraSchema.SpecVersion,
+                title: 'Internal resources',
+            },
+            references: { 'api': this.api },
+            resources: [new metadata_resource_js_1.MetadataResource(this.api)]
         });
-        this._internalResources.set(metadataResourceInfo.name, metadataResourceInfo);
-        metadataResource.init(metadataResourceInfo);
-        for (const r of this.document.resources.values()) {
-            if (r.instance) {
-                const init = r.instance.init;
-                if (init)
-                    await init.call(r.instance, r);
-            }
+        const promises = [];
+        for (const r of this.api.resources.values()) {
+            const onInit = r.onInit;
+            if (onInit)
+                promises.push((async () => onInit.call(r.controller, r))());
         }
+        await Promise.all(promises);
     }
-    async _executeResourceQuery(document, resource, context) {
-        if (resource instanceof CollectionResourceInfo) {
-            const { query } = context;
-            if (query instanceof CollectionSearchQuery) {
-                const promises = [];
-                let search;
-                promises.push(this._executeCollectionResource(document, resource, context)
-                    .then(v => search = v));
-                if (query.count && resource.metadata.count) {
-                    const ctx = {
-                        query: new CollectionCountQuery(query.resource, { filter: query.filter }),
-                        resultPath: ''
-                    };
-                    Object.setPrototypeOf(ctx, context);
-                    promises.push(this._executeCollectionResource(document, resource, ctx)
-                        .then(r => {
-                        context.responseHeaders[HttpHeaderCodes.X_Opra_Count] = r;
-                    }));
-                }
-                await Promise.all(promises);
-                context.response = search;
-                return;
-            }
-            context.response = await this._executeCollectionResource(document, resource, context);
-            return;
-        }
-        else if (resource instanceof SingletonResourceInfo) {
-            context.response = await this._executeSingletonResource(document, resource, context);
-            return;
+    /**
+     * Calls shutDown hook for all resources
+     */
+    async close() {
+        const promises = [];
+        for (const r of this.api.resources.values()) {
+            const onShutdown = r.onShutdown;
+            if (onShutdown)
+                promises.push((async () => onShutdown.call(r.controller, r))());
         }
-        throw new Error(`Executing "${resource.kind}" has not been implemented yet`);
+        await Promise.allSettled(promises);
     }
-    async _executeCollectionResource(document, resource, context) {
-        const method = context.query.method;
-        const handler = resource.getHandler(method);
-        if (!handler)
-            throw new ForbiddenError({
-                message: translate('RESOLVER_FORBIDDEN', { method }, `The resource endpoint does not accept '{{method}}' operations`),
-                severity: 'error',
-                code: 'RESOLVER_FORBIDDEN'
-            });
-        let result;
-        switch (method) {
-            case 'create': {
-                const query = context.query;
-                result = await handler(context, query.data, query);
-                result = Array.isArray(result) ? result[0] : result;
-                if (result)
-                    context.status = 201;
-                context.responseHeaders[HttpHeaderCodes.X_Opra_DataType] = resource.dataType.name;
-                return result;
-            }
-            case 'count': {
-                const query = context.query;
-                result = await handler(context, query);
-                return result;
-            }
-            case 'get': {
-                const query = context.query;
-                result = await handler(context, query.keyValue, query);
-                result = Array.isArray(result) ? result[0] : result;
-                if (!result)
-                    throw new ResourceNotFoundError(resource.name, query.keyValue);
-                const v = await this._pathWalkThrough(query, query.dataType, result, resource.name);
-                if (v.value === undefined)
-                    throw new ResourceNotFoundError(v.path);
-                if (v.dataType)
-                    context.responseHeaders[HttpHeaderCodes.X_Opra_DataType] = v.dataType.name;
-                return v.value;
-            }
-            case 'search': {
-                const query = context.query;
-                result = await handler(context, query);
-                const items = Array.isArray(result) ? result : (context.response ? [result] : []);
-                context.responseHeaders[HttpHeaderCodes.X_Opra_DataType] = resource.dataType.name;
-                return items;
-            }
-            case 'update': {
-                const query = context.query;
-                result = await handler(context, query.keyValue, query.data, query);
-                result = Array.isArray(result) ? result[0] : result;
-                if (!result)
-                    throw new ResourceNotFoundError(resource.name, query.keyValue);
-                context.responseHeaders[HttpHeaderCodes.X_Opra_DataType] = resource.dataType.name;
-                return result;
-            }
-            case 'delete':
-            case 'deleteMany':
-            case 'updateMany': {
-                switch (method) {
-                    case 'delete': {
-                        const query = context.query;
-                        result = await handler(context, query.keyValue, query);
-                        break;
-                    }
-                    case 'deleteMany': {
-                        const query = context.query;
-                        result = await handler(context, query);
-                        break;
-                    }
-                    case 'updateMany': {
-                        const query = context.query;
-                        result = await handler(context, query.data, query);
-                        break;
-                    }
-                }
-                let affected;
-                if (typeof result === 'number')
-                    affected = result;
-                if (typeof result === 'boolean')
-                    affected = result ? 1 : 0;
-                if (typeof result === 'object')
-                    affected = result.affectedRows || result.affected;
-                return {
-                    operation: context.query.method,
+    async executeRequest(context) {
+        await this.emitAsync('request', context);
+        const { request, response } = context;
+        const { resource, operation } = request;
+        if (resource instanceof common_1.Collection || resource instanceof common_1.Singleton) {
+            const endpoint = resource.operations[operation];
+            if (!endpoint?.handler)
+                throw new common_1.ForbiddenError({
+                    message: (0, common_1.translate)('RESOLVER_FORBIDDEN', { operation }, `The resource endpoint does not accept '{{operation}}' operations`),
+                    severity: 'error',
+                    code: 'RESOLVER_FORBIDDEN'
+                });
+            const value = await endpoint.handler(context);
+            // if (value == null)
+            if (value != null)
+                response.value = value;
+            const { crud, many } = request;
+            if (crud === 'delete' || (crud === 'update' && many)) {
+                let affected = 0;
+                if (typeof response.value === 'number')
+                    affected = response.value;
+                if (typeof response.value === 'boolean')
+                    affected = response.value ? 1 : 0;
+                if (typeof response.value === 'object')
+                    affected = response.value.affectedRows || response.value.affected;
+                response.value = {
+                    operation: request.operation,
                     affected
                 };
             }
-        }
-    }
-    async _executeSingletonResource(document, resource, context) {
-        const method = context.query.method;
-        const resolverInfo = resource.metadata[method];
-        if (!(resolverInfo && resolverInfo.handler))
-            throw new ForbiddenError({
-                message: translate('RESOLVER_FORBIDDEN', { method }, `The resource endpoint does not accept '{{method}}' operations`),
-                severity: 'error',
-                code: 'RESOLVER_FORBIDDEN'
-            });
-        let result = await resolverInfo.handler(context);
-        switch (method) {
-            case 'get': {
-                const query = context.query;
-                result = await resolverInfo.handler(context, query);
-                result = Array.isArray(result) ? result[0] : result;
-                if (!result)
-                    throw new ResourceNotFoundError(resource.name);
-                const v = await this._pathWalkThrough(query, query.dataType, result, resource.name);
-                if (v.value === undefined)
-                    throw new ResourceNotFoundError(v.path);
-                if (v.dataType)
-                    context.responseHeaders[HttpHeaderCodes.X_Opra_DataType] = v.dataType.name;
-                return v.value;
-            }
-        }
-        if (!result)
-            return;
-        result = Array.isArray(result) ? result[0] : result;
-        let dataType = resource.dataType;
-        if (context.resultPath) {
-            const pathArray = context.resultPath.split('.');
-            for (const field of pathArray) {
-                const prop = dataType instanceof ComplexType ? dataType.fields.get(field) : undefined;
-                dataType = prop && prop.type ? this.document.types.get(prop.type) : undefined;
-                result = result && typeof result === 'object' && result[field];
+            else if (response.value != null) {
+                if (!request.many)
+                    response.value = Array.isArray(response.value) ? response.value[0] : response.value;
+                else
+                    response.value = Array.isArray(response.value) ? response.value : [response.value];
             }
+            if ((request.operation === 'get' || request.operation === 'update') && response.value == null)
+                throw new common_1.ResourceNotFoundError(resource.name, request.args.key);
         }
-        if (method === 'create')
-            context.status = 201;
-        context.responseHeaders[HttpHeaderCodes.X_Opra_DataType] = resource.dataType.name;
-        return result;
     }
-    async _pathWalkThrough(query, dataType, value, parentPath) {
-        const { child } = query;
-        if (!child)
-            return { value, dataType, path: parentPath };
-        // Make a case in sensitive lookup
-        const fieldNameLower = child.fieldName.toLowerCase();
-        const path = parentPath + (parentPath ? '.' : '') + child.fieldName;
-        for (const key of Object.keys(value)) {
-            if (key.toLowerCase() === fieldNameLower) {
-                let v = value[key];
-                if (v == null)
-                    return { path };
-                if (child.child && child.dataType instanceof ComplexType) {
-                    if (Array.isArray(v))
-                        v = v[0];
-                    return this._pathWalkThrough(child, child.dataType, v, path);
-                }
-                return { value: v, dataType: child.dataType, path };
-            }
-        }
-        return { path };
+    async _createI18n(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;
     }
 }
+exports.OpraAdapter = OpraAdapter;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraExpressAdapter = void 0;
+const tslib_1 = require("tslib");
+const body_parser_1 = tslib_1.__importDefault(require("body-parser"));
+const common_1 = require("@opra/common");
+const http_adapter_js_1 = require("./http-adapter.js");
+const noOp = () => void 0;
+class OpraExpressAdapter extends http_adapter_js_1.OpraHttpAdapter {
+    constructor() {
+        super(...arguments);
+        this.platform = 'express';
+    }
+    static async create(app, document, options) {
+        const adapter = new OpraExpressAdapter(document);
+        await adapter.init(options);
+        const prefix = '/' + (0, common_1.normalizePath)(options?.prefix, true);
+        app.use(prefix, body_parser_1.default.json());
+        app.use(prefix, (req, res, next) => {
+            req.end = noOp;
+            req.send = noOp;
+            adapter.handler(req, res).catch(e => next(e));
+        });
+        return adapter;
+    }
+}
+exports.OpraExpressAdapter = OpraExpressAdapter;