@opra/core 0.25.5 → 0.26.1

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

@@ -1,424 +0,0 @@
-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 { EndpointContext } from '../../endpoint-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 = EndpointContext.from(executionContext, request, response);
-        await this.callEndpoint(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, true);
-        if (!resource)
-            throw new BadRequestError({
-                message: translate('error:SOURCE_NOT_FOUND,', 'Resource not found'),
-                code: 'SOURCE_NOT_FOUND',
-                details: {
-                    path: incoming.parsedUrl.address
-                }
-            });
-        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 callEndpoint(context) {
-        const request = context.request;
-        const { response } = context;
-        const resource = request.resource;
-        // Call endpoint handler method
-        let value;
-        try {
-            value = await request.controller[request.endpoint].call(request.controller, context);
-            if (value == null)
-                value = response.value;
-            const { endpoint } = request;
-            if (endpoint === 'delete' || endpoint === 'deleteMany' || endpoint === '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 ||
-                        (endpoint === 'updateMany' ? value.updated : value.deleted);
-                response.value = affected;
-            }
-            else {
-                // "get" and "update" endpoints must return the entity instance, otherwise it means resource not found
-                if (value == null && (request.endpoint === 'get' || request.endpoint === 'update'))
-                    throw new ResourceNotFoundError(resource.name, request.key);
-                // "findMany" endpoint should return array of entity instances
-                if (request.endpoint === '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.endpoint === 'delete' || request.endpoint === 'deleteMany') {
-            responseObject = {
-                resource: resource.name,
-                operation: 'delete',
-                affected: response.value
-            };
-        }
-        else if (request.endpoint === 'updateMany') {
-            responseObject = {
-                resource: resource.name,
-                operation: 'update',
-                affected: response.value
-            };
-        }
-        else {
-            if (!response.value)
-                throw new InternalServerError(`"${request.endpoint}" endpoint should return value`);
-            const encode = resource.getEncoder(request.endpoint);
-            const data = encode(response.value, { coerce: true });
-            if (request.endpoint === 'create')
-                outgoing.statusCode = 201;
-            responseObject = {
-                resource: resource.name,
-                endpoint: request.endpoint,
-                data
-            };
-            if (request.endpoint === 'create' || request.endpoint === 'update')
-                responseObject.affected = 1;
-            if (request.endpoint === '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/opra+json; charset=utf-8');
-        outgoing.send(JSON.stringify(body));
-        outgoing.end();
-    }
-    async parseCollectionRequest(resource, incoming) {
-        if ((incoming.method === 'POST' || incoming.method === 'PATCH') && !incoming.is('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 endpointMeta = await this.assertEndpoint(resource, 'create');
-                    const jsonReader = this.getBodyLoader(endpointMeta);
-                    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: endpointMeta.controller,
-                        http: incoming,
-                        contentId,
-                        resource,
-                        endpoint: 'create',
-                        data,
-                        params: {
-                            ...this.parseParameters(incoming.parsedUrl, endpointMeta),
-                            pick: pick && resource.normalizeFieldPath(pick),
-                            omit: omit && resource.normalizeFieldPath(omit),
-                            include: include && resource.normalizeFieldPath(include)
-                        }
-                    });
-                }
-                break;
-            }
-            case 'DELETE': {
-                if (p.key != null) {
-                    const endpointMeta = await this.assertEndpoint(resource, 'delete');
-                    return new RequestHost({
-                        controller: endpointMeta.controller,
-                        http: incoming,
-                        contentId,
-                        resource,
-                        endpoint: 'delete',
-                        key: resource.parseKeyValue(p.key),
-                        params: this.parseParameters(incoming.parsedUrl, endpointMeta)
-                    });
-                }
-                const endpointMeta = await this.assertEndpoint(resource, 'deleteMany');
-                const filter = resource.normalizeFilter(params.get('$filter'));
-                return new RequestHost({
-                    controller: endpointMeta.controller,
-                    http: incoming,
-                    contentId,
-                    resource,
-                    endpoint: 'deleteMany',
-                    params: {
-                        ...this.parseParameters(incoming.parsedUrl, endpointMeta),
-                        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 endpointMeta = await this.assertEndpoint(resource, 'get');
-                    return new RequestHost({
-                        controller: endpointMeta.controller,
-                        http: incoming,
-                        contentId,
-                        resource,
-                        endpoint: 'get',
-                        key: resource.parseKeyValue(p.key),
-                        params: {
-                            ...this.parseParameters(incoming.parsedUrl, endpointMeta),
-                            pick: pick && resource.normalizeFieldPath(pick),
-                            omit: omit && resource.normalizeFieldPath(omit),
-                            include: include && resource.normalizeFieldPath(include)
-                        }
-                    });
-                }
-                const endpointMeta = await this.assertEndpoint(resource, 'findMany');
-                const filter = resource.normalizeFilter(params.get('$filter'));
-                const sort = parseArrayParam(params.get('$sort'));
-                return new RequestHost({
-                    controller: endpointMeta.controller,
-                    http: incoming,
-                    contentId,
-                    resource,
-                    endpoint: 'findMany',
-                    params: {
-                        ...this.parseParameters(incoming.parsedUrl, endpointMeta),
-                        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 endpointMeta = await this.assertEndpoint(resource, 'update');
-                    const jsonReader = this.getBodyLoader(endpointMeta);
-                    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: endpointMeta.controller,
-                        http: incoming,
-                        contentId,
-                        resource,
-                        endpoint: 'update',
-                        key: resource.parseKeyValue(p.key),
-                        data,
-                        params: {
-                            ...this.parseParameters(incoming.parsedUrl, endpointMeta),
-                            pick: pick && resource.normalizeFieldPath(pick),
-                            omit: omit && resource.normalizeFieldPath(omit),
-                            include: include && resource.normalizeFieldPath(include),
-                        }
-                    });
-                }
-                const endpointMeta = await this.assertEndpoint(resource, 'updateMany');
-                const jsonReader = this.getBodyLoader(endpointMeta);
-                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: endpointMeta.controller,
-                    http: incoming,
-                    contentId,
-                    resource,
-                    endpoint: 'updateMany',
-                    data,
-                    params: {
-                        ...this.parseParameters(incoming.parsedUrl, endpointMeta),
-                        filter,
-                    }
-                });
-            }
-        }
-        throw new MethodNotAllowedError({
-            message: `Collection resource 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 endpointMeta = await this.assertEndpoint(resource, 'create');
-                const jsonReader = this.getBodyLoader(endpointMeta);
-                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: endpointMeta.controller,
-                    http: incoming,
-                    contentId,
-                    resource,
-                    endpoint: 'create',
-                    data,
-                    params: {
-                        ...this.parseParameters(incoming.parsedUrl, endpointMeta),
-                        pick: pick && resource.normalizeFieldPath(pick),
-                        omit: omit && resource.normalizeFieldPath(omit),
-                        include: include && resource.normalizeFieldPath(include)
-                    }
-                });
-            }
-            case 'DELETE': {
-                const endpointMeta = await this.assertEndpoint(resource, 'delete');
-                return new RequestHost({
-                    controller: endpointMeta.controller,
-                    http: incoming,
-                    contentId,
-                    resource,
-                    endpoint: 'delete',
-                    params: this.parseParameters(incoming.parsedUrl, endpointMeta)
-                });
-            }
-            case 'GET': {
-                const endpointMeta = await this.assertEndpoint(resource, 'get');
-                const pick = parseArrayParam(params.get('$pick'));
-                const omit = parseArrayParam(params.get('$omit'));
-                const include = parseArrayParam(params.get('$include'));
-                return new RequestHost({
-                    controller: endpointMeta.controller,
-                    http: incoming,
-                    contentId,
-                    resource,
-                    endpoint: 'get',
-                    params: {
-                        ...this.parseParameters(incoming.parsedUrl, endpointMeta),
-                        pick: pick && resource.normalizeFieldPath(pick),
-                        omit: omit && resource.normalizeFieldPath(omit),
-                        include: include && resource.normalizeFieldPath(include)
-                    }
-                });
-            }
-            case 'PATCH': {
-                const endpointMeta = await this.assertEndpoint(resource, 'update');
-                const jsonReader = this.getBodyLoader(endpointMeta);
-                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: endpointMeta.controller,
-                    http: incoming,
-                    contentId,
-                    resource,
-                    endpoint: 'update',
-                    data,
-                    params: {
-                        ...this.parseParameters(incoming.parsedUrl, endpointMeta),
-                        pick: pick && resource.normalizeFieldPath(pick),
-                        omit: omit && resource.normalizeFieldPath(omit),
-                        include: include && resource.normalizeFieldPath(include),
-                    }
-                });
-            }
-        }
-        throw new MethodNotAllowedError({
-            message: `Singleton resource do not accept http "${incoming.method}" method`
-        });
-    }
-    getBodyLoader(endpoint) {
-        let bodyLoader = this.bodyLoaders.get(endpoint);
-        if (!bodyLoader) {
-            const parser = bodyParser.json({
-                limit: endpoint.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(endpoint, bodyLoader);
-        }
-        return bodyLoader;
-    }
-}

package/esm/http/request-handlers/parse-batch-request.js

@@ -1,169 +0,0 @@
-"use strict";
-// async parseMultiPart(
-//     context: TExecutionContext,
-//     url: OpraURL,
-//     headers: IncomingHttpHeaders,
-//     input: Readable,
-//     boundary: string
-// ): Promise<BatchRequestContext> {
-//   return await new Promise((resolve, reject) => {
-//     let _resolved = false;
-//     const dicer = new Dicer({boundary});
-//     const doReject = (e) => {
-//       if (_resolved) return;
-//       _resolved = true;
-//       reject(e);
-//       taskQueue.clearQueue();
-//       dicer.destroy();
-//     }
-//     const taskQueue = new TaskQueue({concurrency: 1});
-//     taskQueue.on('error', doReject);
-//
-//     const queries: SingleRequestContext[] = [];
-//     let partCounter = 0;
-//     dicer.on('error', doReject);
-//     dicer.on('part', part => {
-//       const partIndex = partCounter++;
-//       let header: any;
-//       const chunks: Buffer[] = [];
-//       part.on('error', doReject);
-//       part.on('header', (_header) => header = normalizeHeaders(_header));
-//       part.on('data', (chunk: Buffer) => chunks.push(chunk));
-//       part.on('end', () => {
-//         if (_resolved || !(header || chunks.length))
-//           return;
-//         const ct = header['content-type'];
-//         if (ct === 'application/http') {
-//           taskQueue.enqueue(async () => {
-//             const data = Buffer.concat(chunks);
-//             if (!(data && data.length))
-//               return;
-//             const r = HttpRequest.parse(data);
-//             await callMiddlewares(r, [jsonBodyParser]);
-//             const subUrl = new OpraURL(r.url);
-//             const contentId = header && header['content-id'];
-//             queries.push(this.parseSingleQuery({
-//               context,
-//               url: subUrl,
-//               method: r.method,
-//               headers: r.headers,
-//               body: r.body,
-//               contentId
-//             }));
-//           });
-//         } else doReject(new BadRequestError({
-//           message: 'Unaccepted "content-type" header in multipart data',
-//           details: {
-//             position: `${boundary}[${partIndex}]`
-//           }
-//         }))
-//       });
-//     });
-//     dicer.on('finish', () => {
-//       taskQueue.enqueue(() => {
-//         if (_resolved) return;
-//         _resolved = true;
-//         const batch = new BatchRequestContext({
-//           service: this.document,
-//           context,
-//           headers,
-//           queries,
-//           params: url.searchParams,
-//           continueOnError: false
-//         });
-//         resolve(batch);
-//       });
-//     });
-//     input.pipe(dicer);
-//   });
-// }
-// protected async sendBatchResponse(context: TExecutionContext, requestContext: BatchRequestContext) {
-//   const resp = context.getResponse();
-//   resp.setStatus(HttpStatus.OK);
-//   resp.setHeader(HttpHeaderCodes.Cache_Control, 'no-cache');
-//   resp.setHeader(HttpHeaderCodes.Pragma, 'no-cache');
-//   resp.setHeader(HttpHeaderCodes.Expires, '-1');
-//   if (requestContext.headers) {
-//     for (const [k, v] of Object.entries(requestContext.headers)) {
-//       if (v)
-//         resp.setHeader(k, v);
-//     }
-//   }
-//   const boundary = 'batch_' + uuid();
-//   resp.setHeader(HttpHeaderCodes.Content_Type, 'multipart/mixed;boundary=' + boundary);
-//   resp.setHeader(HttpHeaderCodes.X_Opra_Version, OpraSchema.Version);
-//
-//   const bodyBuilder = new HttpMultipartData();
-//
-//   const chunks: any[] = [];
-//   let msgIdx = 0;
-//   for (const ctx of requestContext.queries) {
-//     msgIdx++;
-//     const out = this.createOutput(ctx);
-//
-//
-//     // chunks.push('--' + boundary + CRLF);
-//     // let s = 'Content-Type: application/http' + CRLF +
-//     //     'Content-Transfer-Encoding: binary' + CRLF +
-//     //     'Content-ID:' + (ctx.contentId || msgIdx) + CRLF +
-//     //     CRLF +
-//     //     'HTTP/1.1 ' + out.status + (HttpStatus[out.status] || 'Unknown') + CRLF;
-//
-//     let body = out.body;
-//     const headers = out.headers || {};
-//     if (body) {
-//       const contentType = String(headers['content-type'] || '').split(/\s*;\s*/);
-//       let charset = '';
-//       if (Highland.isStream(body)) {
-//         const l = parseInt(String(headers['content-length']), 10);
-//         if (isNaN(l))
-//           throw new TypeError('"content-length" header required for streamed responses');
-//       } else if (typeof body === 'object') {
-//         if (typeof body.stream === 'function') { // File and Blob
-//           contentType[0] = body.type || 'binary';
-//           headers['content-length'] = String(body.size);
-//           body = body.stream();
-//         } else if (Buffer.isBuffer(body)) {
-//           headers['content-length'] = String(body.length);
-//         } else {
-//           contentType[0] = contentType[0] || 'application/json';
-//           charset = 'utf-8';
-//           body = Buffer.from(JSON.stringify(body), 'utf-8');
-//           headers['content-length'] = String(body.length);
-//         }
-//       } else {
-//         contentType[0] = contentType[0] || 'text/plain';
-//         charset = 'utf-8';
-//         body = Buffer.from(String(body), 'utf-8');
-//         headers['content-length'] = String(body.length);
-//       }
-//       if (contentType[0]) {
-//         if (charset) {
-//           const i = contentType.findIndex(x => CHARSET_PATTERN.test(String(x)));
-//           if (i > 0) contentType[i] = 'charset=' + charset;
-//           else contentType.join('charset=' + charset);
-//         }
-//         headers['content-type'] = contentType.join(';');
-//       }
-//     }
-//     for (const [k, v] of Object.entries(headers))
-//       s += k + ': ' + (Array.isArray(v) ? v.join(';') : v) + CRLF
-//
-//     chunks.push(s + CRLF);
-//
-//     if (body) {
-//       if (typeof body === 'string')
-//         chunks.push(body + CRLF + CRLF);
-//       else {
-//         chunks.push(body);
-//         chunks.push(CRLF + CRLF);
-//       }
-//     }
-//   }
-//
-//   chunks.push('--' + boundary + '--' + CRLF);
-//
-//   resp.setHeader('content-type', 'multipart/mixed;boundary=' + boundary);
-//   resp.send(Highland(chunks).flatten());
-//   resp.end();
-// }

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

@@ -1,33 +0,0 @@
-import { ForbiddenError, translate } from '@opra/common';
-/**
- * @class RequestHandlerBase
- */
-export class RequestHandlerBase {
-    constructor(adapter) {
-        this.adapter = adapter;
-    }
-    async assertEndpoint(resource, endpoint) {
-        const controller = await this.adapter.getController(resource);
-        const endpointMeta = (typeof controller?.[endpoint] === 'function') && resource.operations[endpoint];
-        if (endpointMeta)
-            return {
-                ...endpointMeta,
-                controller
-            };
-        throw new ForbiddenError({
-            message: translate('RESOLVER_FORBIDDEN', { resource: resource.name, endpoint }, `'{{resource}}' endpoint does not accept '{{endpoint}}' operations`),
-            severity: 'error',
-            code: 'RESOLVER_FORBIDDEN'
-        });
-    }
-    parseParameters(parsedUrl, metadata) {
-        if (!metadata.parameters)
-            return;
-        const searchParams = parsedUrl.searchParams;
-        const out = {};
-        for (const [k] of Object.entries(metadata.parameters)) {
-            out[k] = searchParams.get(k);
-        }
-        return out;
-    }
-}