@opra/core 0.22.0 → 0.23.1

package/esm/adapter/http/request-handlers/entity-request-handler.js

@@ -0,0 +1,400 @@
+import bodyParser from 'body-parser';
+import { toBoolean, toInt } from 'putil-varhelpers';
+import * as valgen from 'valgen';
+import { BadRequestError, Collection, HttpHeaderCodes, HttpStatusCodes, InternalServerError, MethodNotAllowedError, OpraException, ResourceNotFoundError, Singleton, translate, } from '@opra/common';
+import { OperationContext } from '../../operation-context.js';
+import { RequestHost } from '../../request.host.js';
+import { ResponseHost } from '../../response.host.js';
+import { parseArrayParam } from '../helpers/query-parsers.js';
+import { RequestHandlerBase } from './request-handler-base.js';
+/**
+ * @class EntityRequestHandler
+ */
+export class EntityRequestHandler extends RequestHandlerBase {
+    constructor(adapter) {
+        super(adapter);
+        this.adapter = adapter;
+        this.bodyLoaders = new WeakMap();
+    }
+    async processRequest(executionContext) {
+        const { incoming, outgoing } = executionContext.switchToHttp();
+        // Parse incoming message and create Request object
+        const request = await this.parseRequest(incoming);
+        if (!request)
+            return;
+        const response = new ResponseHost({ http: outgoing });
+        const context = OperationContext.from(executionContext, request, response);
+        // Execute operation
+        await this.executeOperation(context);
+        if (response.errors.length) {
+            context.errors.push(...response.errors);
+            return;
+        }
+        try {
+            await this.sendResponse(context);
+        }
+        catch (e) {
+            if (e instanceof OpraException)
+                throw e;
+            if (e instanceof valgen.ValidationError) {
+                throw new InternalServerError({
+                    message: translate('error:RESPONSE_VALIDATION,', 'Response validation failed'),
+                    code: 'RESPONSE_VALIDATION',
+                    details: e.issues
+                }, e);
+            }
+            throw new InternalServerError(e);
+        }
+    }
+    async parseRequest(incoming) {
+        const p = incoming.parsedUrl.path[0];
+        const resource = this.adapter.api.getResource(p.resource);
+        try {
+            if (resource instanceof Collection)
+                return await this.parseCollectionRequest(resource, incoming);
+            if (resource instanceof Singleton)
+                return await this.parseSingletonRequest(resource, incoming);
+        }
+        catch (e) {
+            if (e instanceof OpraException)
+                throw e;
+            if (e instanceof valgen.ValidationError) {
+                throw new BadRequestError({
+                    message: translate('error:REQUEST_VALIDATION,', 'Request validation failed'),
+                    code: 'REQUEST_VALIDATION',
+                    details: e.issues
+                }, e);
+            }
+            throw new BadRequestError(e);
+        }
+    }
+    async executeOperation(context) {
+        const request = context.request;
+        const { response } = context;
+        const resource = request.resource;
+        // Call operation handler method
+        let value;
+        try {
+            value = await request.controller[request.operation].call(request.controller, context);
+            if (value == null)
+                value = response.value;
+            const { operation } = request;
+            if (operation === 'delete' || operation === 'deleteMany' || operation === 'updateMany') {
+                let affected = 0;
+                if (typeof value === 'number')
+                    affected = value;
+                if (typeof value === 'boolean')
+                    affected = value ? 1 : 0;
+                if (typeof value === 'object')
+                    affected = value.affected || value.affectedRows ||
+                        (operation === 'updateMany' ? value.updated : value.deleted);
+                response.value = affected;
+            }
+            else {
+                // "get" and "update" operations must return the entity instance, otherwise it means resource not found
+                if (value == null && (request.operation === 'get' || request.operation === 'update'))
+                    throw new ResourceNotFoundError(resource.name, request.key);
+                // "findMany" operation should return array of entity instances
+                if (request.operation === 'findMany')
+                    value = value == null ? [] : Array.isArray(value) ? value : [value];
+                else
+                    value = value == null ? {} : Array.isArray(value) ? value[0] : value;
+                response.value = value;
+            }
+        }
+        catch (error) {
+            response.errors.push(error);
+        }
+    }
+    async sendResponse(context) {
+        const { request, response } = context;
+        const resource = request.resource;
+        const outgoing = response.switchToHttp();
+        let responseObject;
+        if (request.operation === 'delete' || request.operation === 'deleteMany' || request.operation === 'updateMany') {
+            responseObject = {
+                resource: resource.name,
+                operation: request.operation,
+                affected: response.value
+            };
+        }
+        else {
+            if (!response.value)
+                throw new InternalServerError(`"${request.operation}" operation should return value`);
+            const encode = resource.getEncoder(request.operation);
+            const data = encode(response.value, { coerce: true });
+            if (request.operation === 'create')
+                outgoing.statusCode = 201;
+            responseObject = {
+                resource: resource.name,
+                operation: request.operation,
+                data
+            };
+            if (request.operation === 'create' || request.operation === 'update')
+                responseObject.affected = 1;
+            if (request.operation === 'findMany' && response.count != null && response.count >= 0)
+                responseObject.totalCount = response.count;
+        }
+        outgoing.statusCode = outgoing.statusCode || HttpStatusCodes.OK;
+        const body = this.adapter._i18n.deep(responseObject);
+        outgoing.setHeader(HttpHeaderCodes.Content_Type, 'application/json; charset=utf-8');
+        outgoing.send(JSON.stringify(body));
+        outgoing.end();
+    }
+    async parseCollectionRequest(resource, incoming) {
+        if ((incoming.method === 'POST' || incoming.method === 'PATCH') &&
+            incoming.headers['content-type'] !== 'application/json')
+            throw new BadRequestError({ message: 'Unsupported Content-Type' });
+        const contentId = incoming.headers['content-id'];
+        const p = incoming.parsedUrl.path[0];
+        const params = incoming.parsedUrl.searchParams;
+        switch (incoming.method) {
+            case 'POST': {
+                if (p.key == null) {
+                    const operationMeta = await this.assertOperation(resource, 'create');
+                    const jsonReader = this.getBodyLoader(operationMeta);
+                    const decode = resource.getDecoder('create');
+                    let data = await jsonReader(incoming);
+                    data = decode(data, { coerce: true });
+                    const pick = parseArrayParam(params.get('$pick'));
+                    const omit = parseArrayParam(params.get('$omit'));
+                    const include = parseArrayParam(params.get('$include'));
+                    return new RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        contentId,
+                        resource,
+                        operation: 'create',
+                        data,
+                        params: {
+                            pick: pick && resource.normalizeFieldPath(pick),
+                            omit: omit && resource.normalizeFieldPath(omit),
+                            include: include && resource.normalizeFieldPath(include)
+                        }
+                    });
+                }
+                break;
+            }
+            case 'DELETE': {
+                if (p.key != null) {
+                    const operationMeta = await this.assertOperation(resource, 'delete');
+                    return new RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        contentId,
+                        resource,
+                        operation: 'delete',
+                        key: resource.parseKeyValue(p.key)
+                    });
+                }
+                const operationMeta = await this.assertOperation(resource, 'deleteMany');
+                const filter = resource.normalizeFilter(params.get('$filter'));
+                return new RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'deleteMany',
+                    params: {
+                        filter
+                    }
+                });
+            }
+            case 'GET': {
+                const pick = parseArrayParam(params.get('$pick'));
+                const omit = parseArrayParam(params.get('$omit'));
+                const include = parseArrayParam(params.get('$include'));
+                if (p.key != null) {
+                    const operationMeta = await this.assertOperation(resource, 'get');
+                    return new RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        contentId,
+                        resource,
+                        operation: 'get',
+                        key: resource.parseKeyValue(p.key),
+                        params: {
+                            pick: pick && resource.normalizeFieldPath(pick),
+                            omit: omit && resource.normalizeFieldPath(omit),
+                            include: include && resource.normalizeFieldPath(include)
+                        }
+                    });
+                }
+                const operationMeta = await this.assertOperation(resource, 'findMany');
+                const filter = resource.normalizeFilter(params.get('$filter'));
+                const sort = parseArrayParam(params.get('$sort'));
+                return new RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'findMany',
+                    params: {
+                        pick: pick && resource.normalizeFieldPath(pick),
+                        omit: omit && resource.normalizeFieldPath(omit),
+                        include: include && resource.normalizeFieldPath(include),
+                        sort: sort && resource.normalizeSortFields(sort),
+                        filter,
+                        limit: toInt(params.get('$limit')),
+                        skip: toInt(params.get('$skip')),
+                        distinct: toBoolean(params.get('$distinct')),
+                        count: toBoolean(params.get('$count')),
+                    }
+                });
+            }
+            case 'PATCH': {
+                if (p.key != null) {
+                    const operationMeta = await this.assertOperation(resource, 'update');
+                    const jsonReader = this.getBodyLoader(operationMeta);
+                    const decode = resource.getDecoder('update');
+                    let data = await jsonReader(incoming);
+                    data = decode(data, { coerce: true });
+                    const pick = parseArrayParam(params.get('$pick'));
+                    const omit = parseArrayParam(params.get('$omit'));
+                    const include = parseArrayParam(params.get('$include'));
+                    return new RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        contentId,
+                        resource,
+                        operation: 'update',
+                        key: resource.parseKeyValue(p.key),
+                        data,
+                        params: {
+                            pick: pick && resource.normalizeFieldPath(pick),
+                            omit: omit && resource.normalizeFieldPath(omit),
+                            include: include && resource.normalizeFieldPath(include),
+                        }
+                    });
+                }
+                const operationMeta = await this.assertOperation(resource, 'updateMany');
+                const jsonReader = this.getBodyLoader(operationMeta);
+                const decode = resource.getDecoder('updateMany');
+                let data = await jsonReader(incoming);
+                data = decode(data, { coerce: true });
+                const filter = resource.normalizeFilter(params.get('$filter'));
+                return new RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'updateMany',
+                    data,
+                    params: {
+                        filter,
+                    }
+                });
+            }
+        }
+        throw new MethodNotAllowedError({
+            message: `Collection resources do not accept http "${incoming.method}" method`
+        });
+    }
+    async parseSingletonRequest(resource, incoming) {
+        if ((incoming.method === 'POST' || incoming.method === 'PATCH') &&
+            incoming.headers['content-type'] !== 'application/json')
+            throw new BadRequestError({ message: 'Unsupported Content-Type' });
+        const contentId = incoming.headers['content-id'];
+        const params = incoming.parsedUrl.searchParams;
+        switch (incoming.method) {
+            case 'POST': {
+                const operationMeta = await this.assertOperation(resource, 'create');
+                const jsonReader = this.getBodyLoader(operationMeta);
+                const decode = resource.getDecoder('create');
+                let data = await jsonReader(incoming);
+                data = decode(data, { coerce: true });
+                const pick = parseArrayParam(params.get('$pick'));
+                const omit = parseArrayParam(params.get('$omit'));
+                const include = parseArrayParam(params.get('$include'));
+                return new RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'create',
+                    data,
+                    params: {
+                        pick: pick && resource.normalizeFieldPath(pick),
+                        omit: omit && resource.normalizeFieldPath(omit),
+                        include: include && resource.normalizeFieldPath(include)
+                    }
+                });
+            }
+            case 'DELETE': {
+                const operationMeta = await this.assertOperation(resource, 'delete');
+                return new RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'delete',
+                });
+            }
+            case 'GET': {
+                const operationMeta = await this.assertOperation(resource, 'get');
+                const pick = parseArrayParam(params.get('$pick'));
+                const omit = parseArrayParam(params.get('$omit'));
+                const include = parseArrayParam(params.get('$include'));
+                return new RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'get',
+                    params: {
+                        pick: pick && resource.normalizeFieldPath(pick),
+                        omit: omit && resource.normalizeFieldPath(omit),
+                        include: include && resource.normalizeFieldPath(include)
+                    }
+                });
+            }
+            case 'PATCH': {
+                const operationMeta = await this.assertOperation(resource, 'update');
+                const jsonReader = this.getBodyLoader(operationMeta);
+                const decode = resource.getDecoder('update');
+                let data = await jsonReader(incoming);
+                data = decode(data, { coerce: true });
+                const pick = parseArrayParam(params.get('$pick'));
+                const omit = parseArrayParam(params.get('$omit'));
+                const include = parseArrayParam(params.get('$include'));
+                return new RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'update',
+                    data,
+                    params: {
+                        pick: pick && resource.normalizeFieldPath(pick),
+                        omit: omit && resource.normalizeFieldPath(omit),
+                        include: include && resource.normalizeFieldPath(include),
+                    }
+                });
+            }
+        }
+        throw new MethodNotAllowedError({
+            message: `Singleton resources do not accept http "${incoming.method}" method`
+        });
+    }
+    getBodyLoader(operation) {
+        let bodyLoader = this.bodyLoaders.get(operation);
+        if (!bodyLoader) {
+            const parser = bodyParser.json({
+                limit: operation.input?.maxContentSize,
+                type: 'json'
+            });
+            bodyLoader = (incoming) => {
+                return new Promise((resolve, reject) => {
+                    const next = (error) => {
+                        if (error)
+                            return reject(error);
+                        resolve(incoming.body);
+                    };
+                    parser(incoming, {}, next);
+                });
+            };
+            this.bodyLoaders.set(operation, bodyLoader);
+        }
+        return bodyLoader;
+    }
+}

package/esm/adapter/http/request-handlers/request-handler-base.js

@@ -0,0 +1,23 @@
+import { ForbiddenError, translate } from '@opra/common';
+/**
+ * @class RequestHandlerBase
+ */
+export class RequestHandlerBase {
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    async assertOperation(resource, operation) {
+        const controller = await this.adapter.getController(resource);
+        const operationMeta = (typeof controller?.[operation] === 'function') && resource.operations[operation];
+        if (operationMeta)
+            return {
+                ...operationMeta,
+                controller
+            };
+        throw new ForbiddenError({
+            message: translate('RESOLVER_FORBIDDEN', { resource: resource.name, operation }, `'{{resource}}' endpoint does not accept '{{operation}}' operations`),
+            severity: 'error',
+            code: 'RESOLVER_FORBIDDEN'
+        });
+    }
+}

package/esm/adapter/http/request-handlers/storage-request-handler.js

@@ -0,0 +1,129 @@
+import fs from 'fs/promises';
+import os from 'os';
+import { BadRequestError, HttpStatusCodes, isReadable, OpraException, Storage, uid } from '@opra/common';
+import { OperationContext } from '../../operation-context.js';
+import { RequestHost } from '../../request.host.js';
+import { ResponseHost } from '../../response.host.js';
+import { MultipartIterator } from '../helpers/multipart-helper.js';
+import { RequestHandlerBase } from './request-handler-base.js';
+/**
+ * @class StorageRequestHandler
+ */
+export class StorageRequestHandler extends RequestHandlerBase {
+    constructor(adapter, options) {
+        super(adapter);
+        this.adapter = adapter;
+        this._uploadDir = options?.uploadDir || os.tmpdir();
+    }
+    async processRequest(executionContext) {
+        const { incoming, outgoing } = executionContext.switchToHttp();
+        // Parse incoming message and create Request object
+        const request = await this.parseRequest(executionContext, incoming);
+        if (!request)
+            return;
+        const response = new ResponseHost({ http: outgoing });
+        const context = OperationContext.from(executionContext, request, response);
+        // Execute operation
+        await this.executeOperation(context);
+        if (response.errors.length) {
+            context.errors.push(...response.errors);
+            return;
+        }
+        await this.sendResponse(context);
+    }
+    async parseRequest(executionContext, incoming) {
+        const contentId = incoming.headers['content-id'];
+        const p = incoming.parsedUrl.path[0];
+        const resource = this.adapter.api.getResource(p.resource);
+        try {
+            if (!(resource instanceof Storage))
+                return;
+            switch (incoming.method) {
+                case 'GET': {
+                    const operationMeta = await this.assertOperation(resource, 'get');
+                    return new RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        resource,
+                        operation: 'get',
+                        contentId
+                    });
+                }
+                case 'DELETE': {
+                    const operationMeta = await this.assertOperation(resource, 'delete');
+                    return new RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        resource,
+                        operation: 'delete',
+                        contentId
+                    });
+                }
+                case 'POST': {
+                    const operationMeta = await this.assertOperation(resource, 'post');
+                    await fs.mkdir(this._uploadDir, { recursive: true });
+                    const multipartIterator = new MultipartIterator(incoming, {
+                        ...operationMeta,
+                        filename: () => this.adapter.serviceName + '_p' + process.pid +
+                            't' + String(Date.now()).substring(8) + 'r' + uid(12)
+                    });
+                    multipartIterator.pause();
+                    // Add an hook to clean up files after request finished
+                    executionContext.on('finish', async () => {
+                        multipartIterator.cancel();
+                        await multipartIterator.deleteFiles().catch(() => void 0);
+                    });
+                    return new RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        resource,
+                        operation: 'post',
+                        contentId,
+                        parts: multipartIterator
+                    });
+                }
+            }
+        }
+        catch (e) {
+            if (e instanceof OpraException)
+                throw e;
+            throw new BadRequestError(e);
+        }
+    }
+    async executeOperation(context) {
+        const request = context.request;
+        const { response } = context;
+        // Call operation handler method
+        let value;
+        try {
+            value = await request.controller[request.operation].call(request.controller, context);
+            if (response.value == null)
+                response.value = value;
+        }
+        catch (error) {
+            response.errors.push(error);
+        }
+    }
+    async sendResponse(context) {
+        const { response } = context;
+        const outgoing = response.switchToHttp();
+        outgoing.statusCode = outgoing.statusCode || HttpStatusCodes.OK;
+        if (response.value != null) {
+            if (typeof response.value === 'string') {
+                if (!outgoing.hasHeader('content-type'))
+                    outgoing.setHeader('content-type', 'text/plain');
+                outgoing.send(response.value);
+            }
+            else if (Buffer.isBuffer(response.value) || isReadable(response.value)) {
+                if (!outgoing.hasHeader('content-type'))
+                    outgoing.setHeader('content-type', 'application/octet-stream');
+                outgoing.send(response.value);
+            }
+            else {
+                outgoing.setHeader('content-type', 'application/json; charset=utf-8');
+                outgoing.send(JSON.stringify(response.value));
+            }
+        }
+        outgoing.end();
+    }
+}

package/esm/adapter/operation-context.js

@@ -0,0 +1,13 @@
+export var OperationContext;
+(function (OperationContext) {
+    function from(executionContext, request, response) {
+        const out = {
+            request,
+            response,
+            requestScope: {}
+        };
+        Object.setPrototypeOf(out, executionContext);
+        return out;
+    }
+    OperationContext.from = from;
+})(OperationContext || (OperationContext = {}));

package/esm/adapter/platform-adapter.host.js

@@ -0,0 +1,102 @@
+import path from 'path';
+import { pascalCase } from 'putil-varhelpers';
+import { AsyncEventEmitter } from 'strict-typed-events';
+import { getStackFileName, I18n, Resource } from '@opra/common';
+import { Logger } from './services/logger.js';
+/**
+ * @class PlatformAdapterHost
+ */
+export class PlatformAdapterHost extends AsyncEventEmitter {
+    constructor(api, options) {
+        super();
+        this.api = api;
+        this._controllers = new WeakMap();
+        this._initialized = false;
+        this._options = options || {};
+        this._logger = options?.logger && options.logger instanceof Logger
+            ? options.logger
+            : new 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 = pascalCase((api.info.title || '').replace(/[^a-z0-9_ ]/ig, '')) || 'OpraService';
+        if (!/^[a-z]/i.test(this._serviceName))
+            this._serviceName = 'X' + this._serviceName;
+    }
+    get platform() {
+        return this._platform;
+    }
+    get protocol() {
+        return this._protocol;
+    }
+    get serviceName() {
+        return this.api.info.title;
+    }
+    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))());
+        }
+        await Promise.allSettled(promises);
+    }
+    /**
+     * Initializes the adapter
+     */
+    async init() {
+        if (this._initialized)
+            return;
+        // Init I18n
+        if (this._options?.i18n instanceof I18n)
+            this._i18n = this._options.i18n;
+        else if (typeof this._options?.i18n === 'function')
+            this._i18n = await this._options.i18n();
+        else
+            this._i18n = await this._createI18n(this._options?.i18n);
+        this._i18n = this._i18n || I18n.defaultInstance;
+        if (!this._i18n.isInitialized)
+            await this._i18n.init();
+        // Initialize all controllers
+        for (const resource of this.api.resources.values()) {
+            await this.getController(resource);
+        }
+        this._initialized = true;
+    }
+    async getController(resource) {
+        resource = typeof resource === 'object' && resource instanceof 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);
+            }
+        }
+        return controller;
+    }
+    async _createI18n(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;
+    }
+}

package/esm/adapter/request.host.js

@@ -1,8 +1,7 @@
 export class RequestHost {
     constructor(init) {
-        this.contentId = '';
         Object.assign(this, init);
-        this.resourceKind = this.resource.kind;
+        this.params = this.params || {};
     }
     switchToHttp() {
         if (this.http)

package/esm/adapter/request.js

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