@opra/core 0.4.0 → 0.6.0

package/cjs/adapter/adapter.js

@@ -1,150 +1,99 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpraAdapter = void 0;
+const power_tasks_1 = require("power-tasks");
 const strict_typed_events_1 = require("strict-typed-events");
 const common_1 = require("@opra/common");
-const exception_1 = require("@opra/exception");
-const i18n_1 = require("@opra/i18n");
-const schema_1 = require("@opra/schema");
-const index_js_1 = require("../enums/index.js");
 const create_i18n_js_1 = require("../utils/create-i18n.js");
-const metadata_resource_js_1 = require("./metadata-resource.js");
+const metadata_resource_js_1 = require("./classes/metadata.resource.js");
+const batch_request_context_js_1 = require("./request-contexts/batch-request-context.js");
+const single_request_context_js_1 = require("./request-contexts/single-request-context.js");
+const noOp = () => void 0;
 class OpraAdapter {
     document;
-    i18n;
     userContextResolver;
-    // protected _metadataResource: SingletonResourceInfo;
     _internalResources = new common_1.ResponsiveMap();
+    i18n;
     constructor(document) {
         this.document = document;
     }
     async handler(executionContext) {
-        let queryContexts;
-        let userContext;
+        let requestContext;
         let failed = false;
         try {
-            queryContexts = this.prepareRequests(executionContext);
-            let stop = false;
-            // Read requests can be executed simultaneously, write request should be executed one by one
-            let promises;
-            let exclusive = false;
-            for (const context of queryContexts) {
-                exclusive = exclusive || context.query.operation !== 'read';
-                // Wait previous read requests before executing update request
-                if (exclusive && promises) {
-                    await Promise.allSettled(promises);
-                    promises = undefined;
-                }
-                // If previous request in bucket had an error and executed an update
-                // we do not execute next requests
-                if (stop) {
-                    context.errors.push(new exception_1.FailedDependencyError());
-                    continue;
-                }
-                try {
-                    const promise = (async () => {
-                        // if (context.query.method === 'metadata') {
-                        //   await this._getSchemaExecute(context); //todo
-                        //   return;
-                        // }
-                        const resource = context.query.resource;
-                        await this._resourcePrepare(resource, context);
-                        if (this.userContextResolver && !userContext)
-                            userContext = this.userContextResolver({
-                                executionContext,
-                                isBatch: this.isBatch(executionContext)
-                            });
-                        context.userContext = userContext;
-                        await this._resourceExecute(this.document, resource, context);
-                    })().catch(e => {
-                        context.errors.push(e);
-                    });
-                    if (exclusive)
-                        await promise;
-                    else {
-                        promises = promises || [];
-                        promises.push(promise);
-                    }
-                    // todo execute sub property queries
-                }
-                catch (e) {
-                    context.errors.unshift(e);
-                }
-                if (context.errors.length) {
-                    // noinspection SuspiciousTypeOfGuard
-                    context.errors = context.errors.map(e => (0, exception_1.wrapException)(e));
-                    if (exclusive)
-                        stop = stop || !!context.errors.find(e => !(e.issue.severity === 'warning' || e.issue.severity === 'info'));
-                }
-            }
-            if (promises)
-                await Promise.allSettled(promises);
-            await this.sendResponse(executionContext, queryContexts);
+            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 = (0, exception_1.wrapException)(e);
+            const error = (0, common_1.wrapException)(e);
             await this.sendError(executionContext, error);
         }
         finally {
             if (executionContext instanceof strict_typed_events_1.AsyncEventEmitter) {
                 await executionContext
                     .emitAsyncSerial('finish', {
-                    userContext,
+                    context: executionContext,
                     failed
                 }).catch();
             }
         }
     }
-    async _resourcePrepare(resource, context) {
-        const { query } = context;
-        const fn = resource.metadata['pre_' + query.method];
-        if (fn && typeof fn === 'function') {
-            await fn(context);
+    _requestContextToTask(executionContext, requestContext) {
+        if (requestContext instanceof batch_request_context_js_1.BatchRequestContext) {
+            const children = requestContext.queries.map(q => this._requestContextToTask(executionContext, q));
+            return new power_tasks_1.Task(children, { bail: true });
         }
-    }
-    async _resourceExecute(document, resource, context) {
-        if (resource instanceof schema_1.CollectionResourceInfo) {
-            const { query } = context;
-            if (query.kind === 'SearchCollectionQuery') {
-                const promises = [];
-                let search;
-                promises.push(this._collectionResourceExecute(document, resource, context)
-                    .then(v => search = v));
-                if (query.count && resource.metadata.count) {
-                    const ctx = {
-                        query: new schema_1.CollectionCountQuery(query.resource, { filter: query.filter }),
-                        resultPath: ''
-                    };
-                    Object.setPrototypeOf(ctx, context);
-                    promises.push(this._collectionResourceExecute(document, resource, ctx));
+        else if (requestContext instanceof single_request_context_js_1.SingleRequestContext) {
+            const { query } = requestContext;
+            const task = new power_tasks_1.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;
                 }
-                await Promise.all(promises);
-                context.response = search;
-                return;
-            }
-            context.response = await this._collectionResourceExecute(document, resource, context);
-            return;
-        }
-        else if (resource instanceof schema_1.SingletonResourceInfo) {
-            context.response = await this._singletonResourceExecute(document, resource, context);
-            return;
+                throw new common_1.InternalServerError('Not implemented yet');
+            }, {
+                id: requestContext.contentId,
+                exclusive: query.operation !== 'read'
+            });
+            task.on('finish', () => {
+                if (task.error) {
+                    if (task.failedDependencies)
+                        requestContext.errors.push(new common_1.FailedDependencyError());
+                    else
+                        requestContext.errors.push((0, common_1.wrapException)(task.error));
+                    return;
+                }
+            });
+            return task;
         }
-        throw new Error(`Executing "${resource.kind}" has not been implemented yet`);
+        /* istanbul ignore next */
+        throw new TypeError('Invalid request context instance');
     }
     async _init(options) {
-        if (options?.i18n instanceof i18n_1.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 (0, create_i18n_js_1.createI18n)(options?.i18n);
-        this.i18n = this.i18n || i18n_1.I18n.defaultInstance;
+        this.i18n = this.i18n || common_1.I18n.defaultInstance;
         if (!this.i18n.isInitialized)
             await this.i18n.init();
         this.userContextResolver = options?.userContext;
         const metadataResource = new metadata_resource_js_1.MetadataResource();
-        const metadataResourceInfo = new schema_1.SingletonResourceInfo(this.document, '$metadata', this.document.getComplexDataType('object'), {
+        const metadataResourceInfo = new common_1.SingletonResourceInfo(this.document, '$metadata', this.document.getComplexDataType('object'), {
             kind: 'SingletonResource',
             type: 'object',
             instance: metadataResource,
@@ -162,12 +111,44 @@ class OpraAdapter {
             }
         }
     }
-    async _collectionResourceExecute(document, resource, context) {
+    async _executeResourceQuery(document, resource, context) {
+        if (resource instanceof common_1.CollectionResourceInfo) {
+            const { query } = context;
+            if (query instanceof common_1.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 common_1.CollectionCountQuery(query.resource, { filter: query.filter }),
+                        resultPath: ''
+                    };
+                    Object.setPrototypeOf(ctx, context);
+                    promises.push(this._executeCollectionResource(document, resource, ctx)
+                        .then(r => {
+                        context.responseHeaders[common_1.HttpHeaders.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 common_1.SingletonResourceInfo) {
+            context.response = await this._executeSingletonResource(document, resource, context);
+            return;
+        }
+        throw new Error(`Executing "${resource.kind}" has not been implemented yet`);
+    }
+    async _executeCollectionResource(document, resource, context) {
         const method = context.query.method;
         const resolverInfo = resource.metadata[method];
         if (!(resolverInfo && resolverInfo.handler))
-            throw new exception_1.ForbiddenError({
-                message: (0, i18n_1.translate)('RESOLVER_FORBIDDEN', { method }, `The resource endpoint does not accept '{{method}}' operations`),
+            throw new common_1.ForbiddenError({
+                message: (0, common_1.translate)('RESOLVER_FORBIDDEN', { method }, `The resource endpoint does not accept '{{method}}' operations`),
                 severity: 'error',
                 code: 'RESOLVER_FORBIDDEN'
             });
@@ -179,13 +160,12 @@ class OpraAdapter {
                 result = Array.isArray(result) ? result[0] : result;
                 if (result)
                     context.status = 201;
-                context.responseHeaders.set(index_js_1.HttpHeaders.X_Opra_DataType, resource.dataType.name);
+                context.responseHeaders[common_1.HttpHeaders.X_Opra_DataType] = resource.dataType.name;
                 return result;
             }
             case 'count': {
                 const query = context.query;
                 result = await resolverInfo.handler(context, query);
-                context.responseHeaders.set(index_js_1.HttpHeaders.X_Opra_Count, result);
                 return result;
             }
             case 'get': {
@@ -193,19 +173,19 @@ class OpraAdapter {
                 result = await resolverInfo.handler(context, query.keyValue, query);
                 result = Array.isArray(result) ? result[0] : result;
                 if (!result)
-                    throw new exception_1.ResourceNotFoundError(resource.name, query.keyValue);
+                    throw new common_1.ResourceNotFoundError(resource.name, query.keyValue);
                 const v = await this._pathWalkThrough(query, query.dataType, result, resource.name);
                 if (v.value === undefined)
-                    throw new exception_1.ResourceNotFoundError(v.path);
+                    throw new common_1.ResourceNotFoundError(v.path);
                 if (v.dataType)
-                    context.responseHeaders.set(index_js_1.HttpHeaders.X_Opra_DataType, v.dataType.name);
+                    context.responseHeaders[common_1.HttpHeaders.X_Opra_DataType] = v.dataType.name;
                 return v.value;
             }
             case 'search': {
                 const query = context.query;
                 result = await resolverInfo.handler(context, query);
                 const items = Array.isArray(result) ? result : (context.response ? [result] : []);
-                context.responseHeaders.set(index_js_1.HttpHeaders.X_Opra_DataType, resource.dataType.name);
+                context.responseHeaders[common_1.HttpHeaders.X_Opra_DataType] = resource.dataType.name;
                 return items;
             }
             case 'update': {
@@ -213,8 +193,8 @@ class OpraAdapter {
                 result = await resolverInfo.handler(context, query.keyValue, query.data, query);
                 result = Array.isArray(result) ? result[0] : result;
                 if (!result)
-                    throw new exception_1.ResourceNotFoundError(resource.name, query.keyValue);
-                context.responseHeaders.set(index_js_1.HttpHeaders.X_Opra_DataType, resource.dataType.name);
+                    throw new common_1.ResourceNotFoundError(resource.name, query.keyValue);
+                context.responseHeaders[common_1.HttpHeaders.X_Opra_DataType] = resource.dataType.name;
                 return result;
             }
             case 'delete':
@@ -251,12 +231,12 @@ class OpraAdapter {
             }
         }
     }
-    async _singletonResourceExecute(document, resource, context) {
+    async _executeSingletonResource(document, resource, context) {
         const method = context.query.method;
         const resolverInfo = resource.metadata[method];
         if (!(resolverInfo && resolverInfo.handler))
-            throw new exception_1.ForbiddenError({
-                message: (0, i18n_1.translate)('RESOLVER_FORBIDDEN', { method }, `The resource endpoint does not accept '{{method}}' operations`),
+            throw new common_1.ForbiddenError({
+                message: (0, common_1.translate)('RESOLVER_FORBIDDEN', { method }, `The resource endpoint does not accept '{{method}}' operations`),
                 severity: 'error',
                 code: 'RESOLVER_FORBIDDEN'
             });
@@ -267,12 +247,12 @@ class OpraAdapter {
                 result = await resolverInfo.handler(context, query);
                 result = Array.isArray(result) ? result[0] : result;
                 if (!result)
-                    throw new exception_1.ResourceNotFoundError(resource.name);
+                    throw new common_1.ResourceNotFoundError(resource.name);
                 const v = await this._pathWalkThrough(query, query.dataType, result, resource.name);
                 if (v.value === undefined)
-                    throw new exception_1.ResourceNotFoundError(v.path);
+                    throw new common_1.ResourceNotFoundError(v.path);
                 if (v.dataType)
-                    context.responseHeaders.set(index_js_1.HttpHeaders.X_Opra_DataType, v.dataType.name);
+                    context.responseHeaders[common_1.HttpHeaders.X_Opra_DataType] = v.dataType.name;
                 return v.value;
             }
         }
@@ -283,14 +263,14 @@ class OpraAdapter {
         if (context.resultPath) {
             const pathArray = context.resultPath.split('.');
             for (const field of pathArray) {
-                const prop = dataType instanceof schema_1.ComplexType ? dataType.fields.get(field) : undefined;
+                const prop = dataType instanceof common_1.ComplexType ? dataType.fields.get(field) : undefined;
                 dataType = prop && prop.type ? this.document.types.get(prop.type) : undefined;
                 result = result && typeof result === 'object' && result[field];
             }
         }
         if (method === 'create')
             context.status = 201;
-        context.responseHeaders.set(index_js_1.HttpHeaders.X_Opra_DataType, resource.dataType.name);
+        context.responseHeaders[common_1.HttpHeaders.X_Opra_DataType] = resource.dataType.name;
         return result;
     }
     async _pathWalkThrough(query, dataType, value, parentPath) {
@@ -305,7 +285,7 @@ class OpraAdapter {
                 let v = value[key];
                 if (v == null)
                     return { path };
-                if (child.child && child.dataType instanceof schema_1.ComplexType) {
+                if (child.child && child.dataType instanceof common_1.ComplexType) {
                     if (Array.isArray(v))
                         v = v[0];
                     return this._pathWalkThrough(child, child.dataType, v, path);

package/cjs/adapter/classes/execution-context.host.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionContextHost = void 0;
+const strict_typed_events_1 = require("strict-typed-events");
+class ExecutionContextHost extends strict_typed_events_1.AsyncEventEmitter {
+    userContext;
+    constructor() {
+        super();
+    }
+    switchToHttp() {
+        throw new Error(`This is not an http context`);
+    }
+    onFinish(fn) {
+        this.on('finish', fn);
+    }
+}
+exports.ExecutionContextHost = ExecutionContextHost;

package/cjs/adapter/classes/express-request-wrapper.host.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressRequestWrapperHost = void 0;
+class ExpressRequestWrapperHost {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    getInstance() {
+        return this.instance;
+    }
+    getMethod() {
+        return this.instance.method;
+    }
+    getUrl() {
+        return this.instance.url;
+    }
+    getHeaderNames() {
+        return Object.keys(this.instance.headers);
+    }
+    getHeader(name) {
+        return this.instance.get(name);
+    }
+    getHeaders() {
+        return this.instance.headers;
+    }
+    getBody() {
+        return this.instance.body;
+    }
+    isCompleted() {
+        return this.instance.complete;
+    }
+    getStream() {
+        return this.instance;
+    }
+}
+exports.ExpressRequestWrapperHost = ExpressRequestWrapperHost;

package/cjs/adapter/classes/express-response-wrapper.host.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressResponseWrapperHost = void 0;
+class ExpressResponseWrapperHost {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    getInstance() {
+        return this.instance;
+    }
+    getHeader(name) {
+        return this.instance.get(name);
+    }
+    getHeaders() {
+        return this.instance.getHeaders();
+    }
+    getHeaderNames() {
+        return this.instance.getHeaderNames();
+    }
+    hasHeader(name) {
+        return this.instance.hasHeader(name);
+    }
+    removeHeader(name) {
+        return this.instance.removeHeader(name);
+    }
+    setHeader(name, value) {
+        this.instance.setHeader(name, value);
+        return this;
+    }
+    getStatus() {
+        return this.instance.statusCode;
+    }
+    setStatus(value) {
+        // noinspection SuspiciousTypeOfGuard
+        this.instance.status(typeof value === 'number'
+            ? value
+            : parseInt(value, 10) || 500);
+        return this;
+    }
+    getStream() {
+        return this.instance;
+    }
+    send(body) {
+        if (typeof body === 'string' || Buffer.isBuffer(body))
+            this.instance.send(body);
+        else
+            this.instance.json(body);
+        return this;
+    }
+    end() {
+        this.instance.end();
+        return this;
+    }
+}
+exports.ExpressResponseWrapperHost = ExpressResponseWrapperHost;

package/cjs/adapter/classes/http-execution-context.host.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpExecutionContextHost = void 0;
+const execution_context_host_js_1 = require("./execution-context.host.js");
+class HttpExecutionContextHost extends execution_context_host_js_1.ExecutionContextHost {
+    _platform;
+    _request;
+    _response;
+    constructor(_platform, _request, _response) {
+        super();
+        this._platform = _platform;
+        this._request = _request;
+        this._response = _response;
+    }
+    getType() {
+        return 'http';
+    }
+    getPlatform() {
+        return this._platform;
+    }
+    getRequest() {
+        return this._request;
+    }
+    getResponse() {
+        return this._response;
+    }
+    switchToHttp() {
+        return this;
+    }
+}
+exports.HttpExecutionContextHost = HttpExecutionContextHost;

package/cjs/adapter/{metadata-resource.js → classes/metadata.resource.js}

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetadataResource = void 0;
 const tslib_1 = require("tslib");
-const schema_1 = require("@opra/schema");
-const json_singleton_service_js_1 = require("../services/json-singleton-service.js");
+const common_1 = require("@opra/common");
+const json_singleton_service_js_1 = require("../../services/json-singleton-service.js");
 let MetadataResource = class MetadataResource {
     service;
     init(resource) {
@@ -16,7 +16,7 @@ let MetadataResource = class MetadataResource {
     }
 };
 MetadataResource = tslib_1.__decorate([
-    (0, schema_1.OprSingletonResource)(Object, {
+    (0, common_1.OprSingletonResource)(Object, {
         name: '$metadata'
     })
 ], MetadataResource);

package/cjs/adapter/express-adapter.js

@@ -3,18 +3,20 @@ 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 strict_typed_events_1 = require("strict-typed-events");
-const url_1 = require("@opra/url");
+const common_1 = require("@opra/common");
+const express_request_wrapper_host_js_1 = require("./classes/express-request-wrapper.host.js");
+const express_response_wrapper_host_js_1 = require("./classes/express-response-wrapper.host.js");
+const http_execution_context_host_js_1 = require("./classes/http-execution-context.host.js");
 const http_adapter_js_1 = require("./http-adapter.js");
 class OpraExpressAdapter extends http_adapter_js_1.OpraHttpAdapter {
     static async init(app, document, options) {
         const adapter = new OpraExpressAdapter(document);
         await adapter._init(options);
-        const prefix = '/' + (0, url_1.normalizePath)(options?.prefix, true);
+        const prefix = '/' + (0, common_1.normalizePath)(options?.prefix, true);
         app.use(prefix, body_parser_1.default.json());
         app.use(prefix, (request, response, next) => {
             (async () => {
-                const executionContext = new ExpressExecutionContext(request, response);
+                const executionContext = new http_execution_context_host_js_1.HttpExecutionContextHost('express', new express_request_wrapper_host_js_1.ExpressRequestWrapperHost(request), new express_response_wrapper_host_js_1.ExpressResponseWrapperHost(response));
                 await adapter.handler(executionContext);
             })().catch(e => next(e));
         });
@@ -22,103 +24,3 @@ class OpraExpressAdapter extends http_adapter_js_1.OpraHttpAdapter {
     }
 }
 exports.OpraExpressAdapter = OpraExpressAdapter;
-class ExpressExecutionContext extends strict_typed_events_1.AsyncEventEmitter {
-    _request;
-    _response;
-    constructor(request, response) {
-        super();
-        this._request = new ExpressRequestWrapper(request);
-        this._response = new ExpressResponseWrapper(response);
-    }
-    getType() {
-        return 'http';
-    }
-    getPlatform() {
-        return 'express';
-    }
-    switchToHttp() {
-        return this;
-    }
-    getRequest() {
-        return this._request.getInstance();
-    }
-    getResponse() {
-        return this._response.getInstance();
-    }
-    getRequestWrapper() {
-        return this._request;
-    }
-    getResponseWrapper() {
-        return this._response;
-    }
-    onFinish(fn) {
-        this.on('finish', fn);
-    }
-}
-class ExpressRequestWrapper {
-    instance;
-    constructor(instance) {
-        this.instance = instance;
-    }
-    getInstance() {
-        return this.instance;
-    }
-    getMethod() {
-        return this.instance.method;
-    }
-    getUrl() {
-        return this.instance.url;
-    }
-    getHeaderNames() {
-        return Object.keys(this.instance.headers);
-    }
-    getHeader(name) {
-        return this.instance.get(name);
-    }
-    getHeaders() {
-        return this.instance.headers;
-    }
-    getBody() {
-        return this.instance.body;
-    }
-}
-class ExpressResponseWrapper {
-    instance;
-    constructor(instance) {
-        this.instance = instance;
-    }
-    getInstance() {
-        return this.instance;
-    }
-    getHeaderNames() {
-        return this.instance.getHeaderNames();
-    }
-    getHeader(name) {
-        return this.instance.get(name);
-    }
-    setHeader(name, value) {
-        this.instance.setHeader(name, value);
-        return this;
-    }
-    getStatus() {
-        return this.instance.statusCode;
-    }
-    setStatus(value) {
-        // noinspection SuspiciousTypeOfGuard
-        this.instance.status(typeof value === 'number'
-            ? value
-            : parseInt(value, 10) || 500);
-        return this;
-    }
-    send(body) {
-        if (typeof body === 'string' || Buffer.isBuffer(body))
-            this.instance.send(body);
-        else
-            this.instance.json(body);
-        return this;
-    }
-    end() {
-        this.instance.end();
-        return this;
-    }
-}