@opra/core 0.20.3 → 0.22.0

package/esm/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/esm/adapter/http/request-parsers/parse-collection-request.js

@@ -0,0 +1,161 @@
+import { BadRequestError, MethodNotAllowedError } from '@opra/common';
+import { RequestHost } from '../../request.host.js';
+export async function parseCollectionRequest(incoming, resource, url) {
+    if ((incoming.method === 'POST' || incoming.method === 'PATCH') &&
+        incoming.headers['content-type'] !== 'application/json')
+        throw new 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 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 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 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 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 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 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 RequestHost({
+                http: incoming,
+                kind: 'CollectionUpdateManyRequest',
+                contentId,
+                resource,
+                operation: 'updateMany',
+                crud: 'update',
+                many: true,
+                args: {
+                    data: incoming.body,
+                    filter,
+                }
+            });
+        }
+    }
+    throw new MethodNotAllowedError({
+        message: `Collection resource does not accept http "${incoming.method}" method`
+    });
+}

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

@@ -0,0 +1,20 @@
+import { BadRequestError, Collection, OpraURL, Singleton } from '@opra/common';
+import { parseCollectionRequest } from './parse-collection-request.js';
+import { parseSingletonRequest } from './parse-singleton-request.js';
+export async function parseRequest(api, incoming) {
+    const url = new OpraURL(incoming.url);
+    if (!url.path.size) {
+        // Batch
+        if (incoming.headers['content-type'] === 'multipart/mixed') {
+            // todo
+        }
+        throw new BadRequestError();
+    }
+    const p = url.path.get(0);
+    const resource = api.getResource(p.resource);
+    if (resource instanceof Collection)
+        return await parseCollectionRequest(incoming, resource, url);
+    if (resource instanceof Singleton)
+        return await parseSingletonRequest(incoming, resource, url);
+    throw new BadRequestError();
+}

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

@@ -0,0 +1,92 @@
+import { BadRequestError, MethodNotAllowedError } from '@opra/common';
+import { RequestHost } from '../../request.host.js';
+export async function parseSingletonRequest(incoming, resource, url) {
+    if ((incoming.method === 'POST' || incoming.method === 'PATCH') &&
+        incoming.headers['content-type'] !== 'application/json')
+        throw new 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 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 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 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 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 MethodNotAllowedError({
+                message: `Singleton resource does not accept http "${incoming.method}" method`
+            });
+    }
+}

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

@@ -7,6 +7,14 @@ export class RequestContextHost extends 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;
@@ -15,12 +23,18 @@ export class RequestContextHost extends 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');
     }
 }

package/esm/adapter/request.host.js

@@ -1,15 +1,18 @@
 export 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');
     }
 }

package/esm/adapter/response.host.js

@@ -5,12 +5,14 @@ export 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');
     }
 }

package/esm/index.js

@@ -4,8 +4,10 @@ export * from './types.js';
 export * from './adapter/adapter.js';
 export * from './adapter/http/express-adapter.js';
 export * from './adapter/http/http-adapter.js';
-export * from './adapter/http/http-request-message.js';
-export * from './adapter/http/http-response-message.js';
+export * from './adapter/http/impl/http-server-request.js';
+export * from './adapter/http/impl/http-server-response.js';
+export * from './adapter/http/impl/http-incoming-message-host.js';
+export * from './adapter/http/impl/http-outgoing-message-host.js';
 export * from './adapter/interfaces/request-context.interface.js';
 export * from './adapter/interfaces/logger.interface.js';
 export * from './adapter/interfaces/request.interface.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/core",
-  "version": "0.20.3",
+  "version": "0.22.0",
   "description": "Opra schema package",
   "author": "Panates",
   "license": "MIT",
@@ -27,23 +27,24 @@
     "clean:cover": "rimraf ../../coverage/core"
   },
   "dependencies": {
-    "@opra/common": "^0.20.3",
+    "@opra/common": "^0.22.0",
     "accepts": "^1.3.8",
     "content-disposition": "^0.5.4",
     "content-type": "^1.0.5",
     "cookie": "^0.5.0",
-    "lodash.isnil": "^4.0.0",
-    "lodash.omitby": "^4.6.0",
+    "cookie-signature": "^1.2.1",
+    "encodeurl": "^1.0.2",
+    "formidable": "^3.5.0",
+    "fresh": "^0.5.2",
     "mime-types": "^2.1.35",
     "power-tasks": "^1.7.0",
-    "putil-isplainobject": "^1.1.5",
-    "putil-merge": "^3.10.3",
     "putil-varhelpers": "^1.6.5",
+    "range-parser": "^1.2.1",
     "strict-typed-events": "^2.3.1",
-    "type-is": "^1.6.18"
+    "type-is": "^1.6.18",
+    "vary": "^1.1.2"
   },
   "peerDependencies": {
-    "body-parser": "^1.20.2",
     "express": "^4.x.x || ^5.x.x"
   },
   "devDependencies": {
@@ -52,11 +53,15 @@
     "@types/content-disposition": "^0.5.5",
     "@types/content-type": "^1.1.5",
     "@types/cookie": "^0.5.1",
-    "@types/dicer": "^0.2.2",
+    "@types/cookie-signature": "^1.1.0",
+    "@types/encodeurl": "^1.0.0",
     "@types/express": "^4.17.17",
+    "@types/formidable": "^3.4.0",
+    "@types/fresh": "^0.5.0",
     "@types/mime-types": "^2.1.1",
+    "@types/range-parser": "^1.2.4",
     "@types/type-is": "^1.6.3",
-    "cors": "^2.8.5",
+    "@types/vary": "^1.1.0",
     "crypto-browserify": "^3.12.0",
     "path-browserify": "^1.0.1",
     "ts-gems": "^2.4.0"
@@ -88,11 +93,10 @@
     "opra",
     "rest",
     "api",
-    "oas",
-    "open",
-    "swagger",
-    "raml",
+    "openapi",
     "http",
-    "web"
+    "web",
+    "swagger",
+    "raml"
   ]
 }

package/types/adapter/adapter.d.ts

@@ -44,7 +44,7 @@ export declare namespace OpraAdapter {
  */
 export declare abstract class OpraAdapter extends AsyncEventEmitter {
     readonly api: ApiDocument;
-    protected _internalDoc: ApiDocument;
+    protected _apiRoot: ApiDocument;
     i18n: I18n;
     logger?: ILogger;
     protected constructor(api: ApiDocument);

package/types/adapter/http/helpers/common.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 declare function checkIsHttpToken(val: any): boolean;
+/**
+ * This function removes unnecessary frames from Node.js core errors.
+ *
+ * https://github.com/nodejs/node/blob/main/lib/internal/errors.js
+ */
+export declare function hideStackFrames(fn: Function): Function;
+export declare const validateHeaderName: Function;
+export declare const validateHeaderValue: Function;
+export declare function validateString(value: any, name?: string): void;

package/types/adapter/http/helpers/convert-to-headers.d.ts

@@ -0,0 +1,2 @@
+export declare function convertToHeaders<T>(src: string[], dst: T, joinDuplicateHeaders?: boolean): T;
+export declare function convertToHeadersDistinct<T>(src: string[], dst: T): T;

package/types/adapter/http/helpers/convert-to-raw-headers.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { IncomingHttpHeaders } from 'http';
+export declare function convertToRawHeaders(src: IncomingHttpHeaders | Record<string, any>): string[];

package/types/adapter/http/helpers/match-known-fields.d.ts

@@ -0,0 +1,6 @@
+export declare const NO_DUPLICATES_FIELD = 0;
+export declare const COMMA_DELIMITED_FIELD = 1;
+export declare const SEMICOLON_DELIMITED_FIELD = 2;
+export declare const ARRAY_FIELD = 3;
+export type FIELD_FLAG = typeof NO_DUPLICATES_FIELD | typeof COMMA_DELIMITED_FIELD | typeof SEMICOLON_DELIMITED_FIELD | typeof ARRAY_FIELD;
+export declare function matchKnownFields(field: string): [string, FIELD_FLAG];