@opra/core 0.20.3 → 0.21.0

package/cjs/adapter/http/request-parsers/batch-request-parser.js

@@ -0,0 +1,169 @@
+"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/cjs/adapter/http/request-parsers/parse-collection-request.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCollectionRequest = void 0;
+const common_1 = require("@opra/common");
+const request_host_js_1 = require("../../request.host.js");
+async function parseCollectionRequest(incoming, resource, url) {
+    if ((incoming.method === 'POST' || incoming.method === 'PATCH') &&
+        incoming.headers['content-type'] !== 'application/json')
+        throw new common_1.BadRequestError({ message: 'Unsupported Content-Type' });
+    url.searchParams.define({
+        '$search': { codec: 'string' },
+        '$pick': { codec: 'string', array: 'strict' },
+        '$omit': { codec: 'string', array: 'strict' },
+        '$include': { codec: 'string', array: 'strict' },
+        '$sort': { codec: 'string', array: 'strict' },
+        '$filter': { codec: 'filter' },
+        '$limit': { codec: 'number' },
+        '$skip': { codec: 'number' },
+        '$distinct': { codec: 'boolean' },
+        '$count': { codec: 'boolean' },
+    });
+    url.parse(incoming.url || '');
+    const contentId = incoming.headers['content-id'];
+    const p = url.path.get(0);
+    const params = url.searchParams;
+    switch (incoming.method) {
+        case 'POST': {
+            if (!p.key) {
+                const pick = params.get('$pick');
+                const omit = params.get('$omit');
+                const include = params.get('$include');
+                return new request_host_js_1.RequestHost({
+                    http: incoming,
+                    kind: 'CollectionCreateRequest',
+                    contentId,
+                    resource,
+                    operation: 'create',
+                    crud: 'create',
+                    many: false,
+                    args: {
+                        data: incoming.body,
+                        pick: pick && resource.normalizeFieldPath(pick),
+                        omit: omit && resource.normalizeFieldPath(omit),
+                        include: include && resource.normalizeFieldPath(include)
+                    }
+                });
+            }
+            break;
+        }
+        case 'DELETE': {
+            if (p.key) {
+                return new request_host_js_1.RequestHost({
+                    http: incoming,
+                    kind: 'CollectionDeleteRequest',
+                    contentId,
+                    resource,
+                    operation: 'delete',
+                    crud: 'delete',
+                    many: false,
+                    args: {
+                        key: resource.parseKeyValue(p.key)
+                    }
+                });
+            }
+            const filter = resource.normalizeFilter(params.get('$filter'));
+            return new request_host_js_1.RequestHost({
+                http: incoming,
+                kind: 'CollectionDeleteManyRequest',
+                contentId,
+                resource,
+                operation: 'deleteMany',
+                crud: 'delete',
+                many: true,
+                args: {
+                    filter
+                }
+            });
+        }
+        case 'GET': {
+            const pick = params.get('$pick');
+            const omit = params.get('$omit');
+            const include = params.get('$include');
+            if (p.key) {
+                return new request_host_js_1.RequestHost({
+                    http: incoming,
+                    kind: 'CollectionGetRequest',
+                    contentId,
+                    resource,
+                    operation: 'get',
+                    crud: 'read',
+                    many: false,
+                    args: {
+                        key: resource.parseKeyValue(p.key),
+                        pick: pick && resource.normalizeFieldPath(pick),
+                        omit: omit && resource.normalizeFieldPath(omit),
+                        include: include && resource.normalizeFieldPath(include)
+                    }
+                });
+            }
+            const filter = resource.normalizeFilter(params.get('$filter'));
+            const sort = params.get('$sort');
+            return new request_host_js_1.RequestHost({
+                http: incoming,
+                kind: 'CollectionFindManyRequest',
+                contentId,
+                resource,
+                operation: 'findMany',
+                crud: 'read',
+                many: true,
+                args: {
+                    pick: pick && resource.normalizeFieldPath(pick),
+                    omit: omit && resource.normalizeFieldPath(omit),
+                    include: include && resource.normalizeFieldPath(include),
+                    sort: sort && resource.normalizeSortFields(sort),
+                    filter,
+                    limit: params.get('$limit'),
+                    skip: params.get('$skip'),
+                    distinct: params.get('$distinct'),
+                    count: params.get('$count'),
+                }
+            });
+        }
+        case 'PATCH': {
+            if (p.key) {
+                const pick = params.get('$pick');
+                const omit = params.get('$omit');
+                const include = params.get('$include');
+                return new request_host_js_1.RequestHost({
+                    http: incoming,
+                    kind: 'CollectionUpdateRequest',
+                    contentId,
+                    resource,
+                    operation: 'update',
+                    crud: 'update',
+                    many: false,
+                    args: {
+                        key: resource.parseKeyValue(p.key),
+                        data: incoming.body,
+                        pick: pick && resource.normalizeFieldPath(pick),
+                        omit: omit && resource.normalizeFieldPath(omit),
+                        include: include && resource.normalizeFieldPath(include),
+                    }
+                });
+            }
+            const filter = resource.normalizeFilter(params.get('$filter'));
+            return new request_host_js_1.RequestHost({
+                http: incoming,
+                kind: 'CollectionUpdateManyRequest',
+                contentId,
+                resource,
+                operation: 'updateMany',
+                crud: 'update',
+                many: true,
+                args: {
+                    data: incoming.body,
+                    filter,
+                }
+            });
+        }
+    }
+    throw new common_1.MethodNotAllowedError({
+        message: `Collection resource does not accept http "${incoming.method}" method`
+    });
+}
+exports.parseCollectionRequest = parseCollectionRequest;

package/cjs/adapter/http/request-parsers/parse-request.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRequest = void 0;
+const common_1 = require("@opra/common");
+const parse_collection_request_js_1 = require("./parse-collection-request.js");
+const parse_singleton_request_js_1 = require("./parse-singleton-request.js");
+async function parseRequest(api, incoming) {
+    const url = new common_1.OpraURL(incoming.url);
+    if (!url.path.size) {
+        // Batch
+        if (incoming.headers['content-type'] === 'multipart/mixed') {
+            // todo
+        }
+        throw new common_1.BadRequestError();
+    }
+    const p = url.path.get(0);
+    const resource = api.getResource(p.resource);
+    if (resource instanceof common_1.Collection)
+        return await (0, parse_collection_request_js_1.parseCollectionRequest)(incoming, resource, url);
+    if (resource instanceof common_1.Singleton)
+        return await (0, parse_singleton_request_js_1.parseSingletonRequest)(incoming, resource, url);
+    throw new common_1.BadRequestError();
+}
+exports.parseRequest = parseRequest;

package/cjs/adapter/http/request-parsers/parse-singleton-request.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSingletonRequest = void 0;
+const common_1 = require("@opra/common");
+const request_host_js_1 = require("../../request.host.js");
+async function parseSingletonRequest(incoming, resource, url) {
+    if ((incoming.method === 'POST' || incoming.method === 'PATCH') &&
+        incoming.headers['content-type'] !== 'application/json')
+        throw new common_1.BadRequestError({ message: 'Unsupported Content-Type' });
+    url.searchParams.define({
+        '$pick': { codec: 'string', array: 'strict' },
+        '$omit': { codec: 'string', array: 'strict' },
+        '$include': { codec: 'string', array: 'strict' }
+    });
+    url.parse(incoming.url || '');
+    const contentId = incoming.headers['content-id'];
+    const params = url.searchParams;
+    switch (incoming.method) {
+        case 'POST': {
+            const pick = params.get('$pick');
+            const omit = params.get('$omit');
+            const include = params.get('$include');
+            return new request_host_js_1.RequestHost({
+                http: incoming,
+                kind: 'SingletonCreateRequest',
+                contentId,
+                resource,
+                operation: 'create',
+                crud: 'create',
+                many: false,
+                args: {
+                    data: incoming.body,
+                    pick: pick && resource.normalizeFieldPath(pick),
+                    omit: omit && resource.normalizeFieldPath(omit),
+                    include: include && resource.normalizeFieldPath(include),
+                }
+            });
+        }
+        case 'DELETE': {
+            return new request_host_js_1.RequestHost({
+                http: incoming,
+                kind: 'SingletonDeleteRequest',
+                contentId,
+                resource,
+                operation: 'delete',
+                crud: 'delete',
+                many: false,
+                args: {}
+            });
+        }
+        case 'GET': {
+            const pick = params.get('$pick');
+            const omit = params.get('$omit');
+            const include = params.get('$include');
+            return new request_host_js_1.RequestHost({
+                http: incoming,
+                kind: 'SingletonGetRequest',
+                contentId,
+                resource,
+                operation: 'get',
+                crud: 'read',
+                many: false,
+                args: {
+                    pick: pick && resource.normalizeFieldPath(pick),
+                    omit: omit && resource.normalizeFieldPath(omit),
+                    include: include && resource.normalizeFieldPath(include),
+                }
+            });
+        }
+        case 'PATCH': {
+            const pick = params.get('$pick');
+            const omit = params.get('$omit');
+            const include = params.get('$include');
+            return new request_host_js_1.RequestHost({
+                http: incoming,
+                kind: 'SingletonUpdateRequest',
+                contentId,
+                resource,
+                operation: 'update',
+                crud: 'update',
+                many: false,
+                args: {
+                    data: incoming.body,
+                    pick: pick && resource.normalizeFieldPath(pick),
+                    omit: omit && resource.normalizeFieldPath(omit),
+                    include: include && resource.normalizeFieldPath(include),
+                }
+            });
+        }
+        default:
+            throw new common_1.MethodNotAllowedError({
+                message: `Singleton resource does not accept http "${incoming.method}" method`
+            });
+    }
+}
+exports.parseSingletonRequest = parseSingletonRequest;

package/cjs/adapter/request-context.host.js

@@ -10,6 +10,14 @@ class RequestContextHost extends strict_typed_events_1.AsyncEventEmitter {
         this.api = api;
         this._request = _request;
         this._response = _response;
+        if (this.protocol === 'http') {
+            this._http = {
+                platform,
+                request: this._request.switchToHttp(),
+                response: this._response.switchToHttp(),
+                switchToContext: () => this
+            };
+        }
     }
     get request() {
         return this._request;
@@ -18,13 +26,19 @@ class RequestContextHost extends strict_typed_events_1.AsyncEventEmitter {
         return this._response;
     }
     switchToHttp() {
-        throw new TypeError('Not executing in an "Http" protocol');
+        if (this._http)
+            return this._http;
+        throw new TypeError('Not executing in an "Http" context');
     }
     switchToWs() {
-        throw new TypeError('Not executing in an "WebSocket" protocol');
+        if (this._ws)
+            return this._ws;
+        throw new TypeError('Not executing in an "WebSocket" context');
     }
     switchToRpc() {
-        throw new TypeError('Not executing in an "RPC" protocol');
+        if (this._rpc)
+            return this._rpc;
+        throw new TypeError('Not executing in an "RPC" context');
     }
 }
 exports.RequestContextHost = RequestContextHost;

package/cjs/adapter/request.host.js

@@ -3,17 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestHost = void 0;
 class RequestHost {
     constructor(init) {
+        this.contentId = '';
         Object.assign(this, init);
         this.resourceKind = this.resource.kind;
     }
     switchToHttp() {
-        throw new TypeError('Not executing in an "Http" protocol');
+        if (this.http)
+            return this.http;
+        throw new TypeError('Not executing in an "Http" context');
     }
     switchToWs() {
-        throw new TypeError('Not executing in an "WebSocket" protocol');
+        throw new TypeError('Not executing in an "WebSocket" context');
     }
     switchToRpc() {
-        throw new TypeError('Not executing in an "RPC" protocol');
+        throw new TypeError('Not executing in an "RPC" context');
     }
 }
 exports.RequestHost = RequestHost;

package/cjs/adapter/response.host.js

@@ -8,13 +8,15 @@ class ResponseHost {
         this.errors = this.errors || [];
     }
     switchToHttp() {
-        throw new TypeError('Not executing in an "Http" protocol');
+        if (this.http)
+            return this.http;
+        throw new TypeError('Not executing in an "Http" context');
     }
     switchToWs() {
-        throw new TypeError('Not executing in an "WebSocket" protocol');
+        throw new TypeError('Not executing in an "WebSocket" context');
     }
     switchToRpc() {
-        throw new TypeError('Not executing in an "RPC" protocol');
+        throw new TypeError('Not executing in an "RPC" context');
     }
 }
 exports.ResponseHost = ResponseHost;

package/cjs/index.js

@@ -7,8 +7,10 @@ tslib_1.__exportStar(require("./types.js"), exports);
 tslib_1.__exportStar(require("./adapter/adapter.js"), exports);
 tslib_1.__exportStar(require("./adapter/http/express-adapter.js"), exports);
 tslib_1.__exportStar(require("./adapter/http/http-adapter.js"), exports);
-tslib_1.__exportStar(require("./adapter/http/http-request-message.js"), exports);
-tslib_1.__exportStar(require("./adapter/http/http-response-message.js"), exports);
+tslib_1.__exportStar(require("./adapter/http/impl/http-server-request.js"), exports);
+tslib_1.__exportStar(require("./adapter/http/impl/http-server-response.js"), exports);
+tslib_1.__exportStar(require("./adapter/http/impl/http-incoming-message-host.js"), exports);
+tslib_1.__exportStar(require("./adapter/http/impl/http-outgoing-message-host.js"), exports);
 tslib_1.__exportStar(require("./adapter/interfaces/request-context.interface.js"), exports);
 tslib_1.__exportStar(require("./adapter/interfaces/logger.interface.js"), exports);
 tslib_1.__exportStar(require("./adapter/interfaces/request.interface.js"), exports);

package/esm/adapter/adapter.js

@@ -28,7 +28,7 @@ export class OpraAdapter extends AsyncEventEmitter {
             await this.i18n.init();
         if (options?.onRequest)
             this.on('request', options.onRequest);
-        this._internalDoc = await DocumentFactory.createDocument({
+        this._apiRoot = await DocumentFactory.createDocument({
             version: OpraSchema.SpecVersion,
             info: {
                 version: OpraSchema.SpecVersion,
@@ -83,7 +83,7 @@ export class OpraAdapter extends AsyncEventEmitter {
                 if (typeof response.value === 'object')
                     affected = response.value.affectedRows || response.value.affected;
                 response.value = {
-                    operation: request.operation,
+                    operation: request.crud,
                     affected
                 };
             }

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

@@ -1,21 +1,21 @@
-import bodyParser from 'body-parser';
 import { normalizePath } from '@opra/common';
 import { OpraHttpAdapter } from './http-adapter.js';
-const noOp = () => void 0;
+import { HttpServerRequest } from './impl/http-server-request.js';
+import { HttpServerResponse } from './impl/http-server-response.js';
 export class OpraExpressAdapter extends OpraHttpAdapter {
     constructor() {
         super(...arguments);
         this.platform = 'express';
     }
     static async create(app, document, options) {
+        const express = await import('express');
         const adapter = new OpraExpressAdapter(document);
         await adapter.init(options);
         const prefix = '/' + normalizePath(options?.prefix, true);
-        app.use(prefix, bodyParser.json());
+        app.use(prefix, express.json());
         app.use(prefix, (req, res, next) => {
-            req.end = noOp;
-            req.send = noOp;
-            adapter.handler(req, res).catch(e => next(e));
+            adapter.handler(HttpServerRequest.create(req), HttpServerResponse.create(res))
+                .catch(e => next(e));
         });
         return adapter;
     }

package/esm/adapter/http/helpers/common.js

@@ -0,0 +1,60 @@
+/*
+  This file contains code blocks from open source NodeJs project
+  https://github.com/nodejs/
+ */
+const tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
+const nodeInternalPrefix = '__node_internal_';
+/**
+ * Verifies that the given val is a valid HTTP token
+ * per the rules defined in RFC 7230
+ * See https://tools.ietf.org/html/rfc7230#section-3.2.6
+ *
+ * https://github.com/nodejs/node/blob/main/lib/_http_common.js
+ */
+export function checkIsHttpToken(val) {
+    return typeof val === 'string' && tokenRegExp.exec(val) !== null;
+}
+const headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
+/**
+ * True if val contains an invalid field-vchar
+ *  field-value    = *( field-content / obs-fold )
+ *  field-content  = field-vchar [ 1*( SP / HTAB ) field-vchar ]
+ *  field-vchar    = VCHAR / obs-text
+ *
+ *  https://github.com/nodejs/node/blob/main/lib/_http_common.js
+ */
+function checkInvalidHeaderChar(val) {
+    // noinspection SuspiciousTypeOfGuard
+    return typeof val === 'string' && headerCharRegex.exec(val) !== null;
+}
+/**
+ * This function removes unnecessary frames from Node.js core errors.
+ *
+ * https://github.com/nodejs/node/blob/main/lib/internal/errors.js
+ */
+export function hideStackFrames(fn) {
+    // We rename the functions that will be hidden to cut off the stacktrace
+    // at the outermost one
+    const hidden = nodeInternalPrefix + fn.name;
+    // @ts-ignore
+    Object.defineProperty(fn, 'name', { __proto__: null, value: hidden });
+    return fn;
+}
+export const validateHeaderName = hideStackFrames((name, label) => {
+    // noinspection SuspiciousTypeOfGuard
+    if (typeof name !== 'string' || !name || !checkIsHttpToken(name)) {
+        throw new TypeError(`${label || 'Header name'} must be a valid HTTP token ["${name}"]`);
+    }
+});
+export const validateHeaderValue = hideStackFrames((name, value) => {
+    if (value === undefined) {
+        throw new TypeError(`Invalid value "${value}" for header "${name}"`);
+    }
+    if (checkInvalidHeaderChar(value)) {
+        throw new TypeError(`Invalid character in header content ["${name}"]`);
+    }
+});
+export function validateString(value, name) {
+    if (typeof value !== 'string')
+        throw new TypeError(`Invalid ${name ? name + ' ' : ''}argument. Value must be a string`);
+}