@opra/core 0.5.0 → 0.6.0

package/cjs/adapter/http-adapter.js

@@ -2,49 +2,138 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpraHttpAdapter = void 0;
 const common_1 = require("@opra/common");
-const exception_1 = require("@opra/exception");
-const schema_1 = require("@opra/schema");
-const url_1 = require("@opra/url");
 const adapter_js_1 = require("./adapter.js");
-const query_context_js_1 = require("./query-context.js");
+const single_request_context_js_1 = require("./request-contexts/single-request-context.js");
 class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
-    prepareRequests(executionContext) {
-        const req = executionContext.getRequestWrapper();
-        // todo implement batch requests
-        if (this.isBatch(executionContext)) {
-            throw new Error('not implemented yet');
+    async parse(executionContext) {
+        const req = executionContext.getRequest();
+        const contentType = req.getHeader('content-type');
+        if (!contentType || contentType === 'application/json') {
+            const body = req.getBody();
+            const url = new common_1.OpraURL(req.getUrl());
+            return this.parseSingleQuery({
+                executionContext,
+                url,
+                method: req.getMethod(),
+                headers: req.getHeaders(),
+                body
+            });
+        }
+        if (typeof contentType === 'string' && contentType.startsWith('multipart/mixed')) {
+            // const m = BOUNDARY_PATTERN.exec(contentType);
+            // if (!m)
+            //   throw new BadRequestError({message: 'Content-Type header does not match required format'});
+            // const url = new OpraURL(req.getUrl());
+            // return await this.parseMultiPart(executionContext, url, req.getHeaders(), req.getStream(), m[1]);
         }
-        const url = new url_1.OpraURL(req.getUrl());
-        return [
-            this.prepareRequest(executionContext, url, req.getMethod(), new common_1.HeadersMap(req.getHeaders()), req.getBody())
-        ];
+        throw new common_1.BadRequestError({ message: 'Unsupported Content-Type' });
     }
-    prepareRequest(executionContext, url, method, headers, body) {
+    parseSingleQuery(args) {
+        const { executionContext, url, method, headers, body, contentId } = args;
         if (!url.path.size)
-            throw new exception_1.BadRequestError();
+            throw new common_1.BadRequestError();
         if (method !== 'GET' && url.path.size > 1)
-            throw new exception_1.BadRequestError();
+            throw new common_1.BadRequestError();
         const query = this.buildQuery(url, method, body);
         if (!query)
-            throw new exception_1.MethodNotAllowedError({
+            throw new common_1.MethodNotAllowedError({
                 message: `Method "${method}" is not allowed by target endpoint`
             });
-        return new query_context_js_1.QueryContext({
+        return new single_request_context_js_1.SingleRequestContext({
             service: this.document,
             executionContext,
+            headers,
             query,
-            headers: new common_1.HeadersMap(),
             params: url.searchParams,
+            contentId,
             continueOnError: query.operation === 'read'
         });
     }
+    // async parseMultiPart(
+    //     executionContext: 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({
+    //               executionContext,
+    //               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,
+    //           executionContext,
+    //           headers,
+    //           queries,
+    //           params: url.searchParams,
+    //           continueOnError: false
+    //         });
+    //         resolve(batch);
+    //       });
+    //     });
+    //     input.pipe(dicer);
+    //   });
+    // }
     buildQuery(url, method, body) {
         const pathLen = url.path.size;
         let p = url.path.get(0);
         let resource = this._internalResources.get(p.resource) || this.document.getResource(p.resource);
         let container;
         let pathIndex = 0;
-        while (resource && resource instanceof schema_1.ContainerResourceInfo) {
+        while (resource && resource instanceof common_1.ContainerResourceInfo) {
             container = resource;
             p = url.path.get(++pathIndex);
             resource = container.getResource(p.resource);
@@ -52,19 +141,24 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
         try {
             method = method.toUpperCase();
             let query;
-            if (resource instanceof schema_1.SingletonResourceInfo && !p.key) {
+            if (resource instanceof common_1.SingletonResourceInfo && !p.key) {
                 switch (method) {
                     case 'GET': {
-                        query = new schema_1.SingletonGetQuery(resource);
+                        const searchParams = url.searchParams;
+                        query = new common_1.SingletonGetQuery(resource, {
+                            pick: searchParams.get('$pick'),
+                            omit: searchParams.get('$omit'),
+                            include: searchParams.get('$include')
+                        });
                     }
                 }
             }
-            else if (resource instanceof schema_1.CollectionResourceInfo) {
+            else if (resource instanceof common_1.CollectionResourceInfo) {
                 switch (method) {
                     case 'GET': {
                         if (p.key) {
                             const searchParams = url.searchParams;
-                            query = new schema_1.CollectionGetQuery(resource, p.key, {
+                            query = new common_1.CollectionGetQuery(resource, p.key, {
                                 pick: searchParams.get('$pick'),
                                 omit: searchParams.get('$omit'),
                                 include: searchParams.get('$include')
@@ -72,7 +166,7 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                         }
                         else {
                             const searchParams = url.searchParams;
-                            query = new schema_1.CollectionSearchQuery(resource, {
+                            query = new common_1.CollectionSearchQuery(resource, {
                                 filter: searchParams.get('$filter'),
                                 limit: searchParams.get('$limit'),
                                 skip: searchParams.get('$skip'),
@@ -89,8 +183,8 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                     case 'DELETE': {
                         const searchParams = url.searchParams;
                         query = p.key
-                            ? new schema_1.CollectionDeleteQuery(resource, p.key)
-                            : new schema_1.CollectionDeleteManyQuery(resource, {
+                            ? new common_1.CollectionDeleteQuery(resource, p.key)
+                            : new common_1.CollectionDeleteManyQuery(resource, {
                                 filter: searchParams.get('$filter'),
                             });
                         break;
@@ -98,7 +192,7 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                     case 'POST': {
                         if (!p.key) {
                             const searchParams = url.searchParams;
-                            query = new schema_1.CollectionCreateQuery(resource, body, {
+                            query = new common_1.CollectionCreateQuery(resource, body, {
                                 pick: searchParams.get('$pick'),
                                 omit: searchParams.get('$omit'),
                                 include: searchParams.get('$include')
@@ -109,7 +203,7 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                     case 'PATCH': {
                         if (p.key) {
                             const searchParams = url.searchParams;
-                            query = new schema_1.CollectionUpdateQuery(resource, p.key, body, {
+                            query = new common_1.CollectionUpdateQuery(resource, p.key, body, {
                                 pick: searchParams.get('$pick'),
                                 omit: searchParams.get('$omit'),
                                 include: searchParams.get('$include')
@@ -117,7 +211,7 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                         }
                         else {
                             const searchParams = url.searchParams;
-                            query = new schema_1.CollectionUpdateManyQuery(resource, body, {
+                            query = new common_1.CollectionUpdateManyQuery(resource, body, {
                                 filter: searchParams.get('$filter')
                             });
                         }
@@ -126,8 +220,8 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                 }
             }
             else
-                throw new exception_1.InternalServerError();
-            if (query instanceof schema_1.SingletonGetQuery || query instanceof schema_1.CollectionGetQuery || query instanceof schema_1.FieldGetQuery) {
+                throw new common_1.InternalServerError();
+            if (query instanceof common_1.SingletonGetQuery || query instanceof common_1.CollectionGetQuery || query instanceof common_1.FieldGetQuery) {
                 // Move through properties
                 let parentType;
                 const curPath = [];
@@ -135,68 +229,152 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                 while (++pathIndex < pathLen) {
                     p = url.path.get(pathIndex);
                     parentType = parent.dataType;
-                    if (parent.dataType instanceof schema_1.UnionType) {
+                    if (parent.dataType instanceof common_1.UnionType) {
                         if (parent.dataType.name === 'any')
                             parentType = this.document.getComplexDataType('object');
                         else
                             throw new TypeError(`"${resource.name}.${curPath.join()}" is a UnionType and needs type casting.`);
                     }
-                    if (!(parentType instanceof schema_1.ComplexType))
+                    if (!(parentType instanceof common_1.ComplexType))
                         throw new TypeError(`"${resource.name}.${curPath.join()}" is not a ComplexType and has no fields.`);
                     curPath.push(p.resource);
-                    parent.child = new schema_1.FieldGetQuery(parent, p.resource, { castingType: parentType });
+                    parent.child = new common_1.FieldGetQuery(parent, p.resource, { castingType: parentType });
                     parent = parent.child;
                 }
             }
             return query;
         }
         catch (e) {
-            if (e instanceof exception_1.OpraException)
+            if (e instanceof common_1.OpraException)
                 throw e;
-            throw new exception_1.BadRequestError(e);
+            throw new common_1.BadRequestError(e);
         }
     }
-    async sendResponse(executionContext, queryContexts) {
-        const outputPackets = [];
-        for (const ctx of queryContexts) {
-            const v = this.createOutput(ctx);
-            outputPackets.push(v);
-        }
-        if (this.isBatch(executionContext)) {
-            // this.writeError([], new InternalServerError({message: 'Not implemented yet'}));
-            return;
-        }
-        if (!outputPackets.length)
-            return this.sendError(executionContext, new exception_1.NotFoundError());
-        const out = outputPackets[0];
-        const resp = executionContext.getResponseWrapper();
+    async sendResponse(executionContext, requestContext) {
+        // if (requestContext instanceof BatchRequestContext)
+        //   return this.sendBatchResponse(executionContext, requestContext);
+        if (requestContext instanceof single_request_context_js_1.SingleRequestContext)
+            return this.sendSingleResponse(executionContext, requestContext);
+        /* istanbul ignore next */
+        throw new TypeError('Invalid request context instance');
+    }
+    // protected async sendBatchResponse(executionContext: TExecutionContext, requestContext: BatchRequestContext) {
+    //   const resp = executionContext.getResponse();
+    //   resp.setStatus(HttpStatus.OK);
+    //   resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');
+    //   resp.setHeader(HttpHeaders.Pragma, 'no-cache');
+    //   resp.setHeader(HttpHeaders.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(HttpHeaders.Content_Type, 'multipart/mixed;boundary=' + boundary);
+    //   resp.setHeader(HttpHeaders.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();
+    // }
+    async sendSingleResponse(executionContext, requestContext) {
+        const out = this.createOutput(requestContext);
+        const resp = executionContext.getResponse();
         resp.setStatus(out.status);
-        resp.setHeader(common_1.HttpHeaders.Content_Type, 'application/json');
         resp.setHeader(common_1.HttpHeaders.Cache_Control, 'no-cache');
         resp.setHeader(common_1.HttpHeaders.Pragma, 'no-cache');
         resp.setHeader(common_1.HttpHeaders.Expires, '-1');
-        resp.setHeader(common_1.HttpHeaders.X_Opra_Version, schema_1.OpraSchema.Version);
         if (out.headers) {
             for (const [k, v] of Object.entries(out.headers)) {
-                resp.setHeader(k, v);
+                if (v)
+                    resp.setHeader(k, v);
             }
         }
-        resp.send(JSON.stringify(out.body));
+        resp.setHeader(common_1.HttpHeaders.X_Opra_Version, common_1.OpraSchema.Version);
+        if (out.body)
+            resp.send(out.body);
         resp.end();
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    isBatch(executionContext) {
-        return false;
-    }
     createOutput(ctx) {
         const { query } = ctx;
         let body;
         let status = ctx.status || 0;
-        const errors = ctx.errors.map(e => (0, exception_1.wrapException)(e));
+        const errors = ctx.errors.map(e => (0, common_1.wrapException)(e));
         if (errors && errors.length) {
             // Sort errors from fatal to info
             errors.sort((a, b) => {
-                const i = exception_1.IssueSeverity.Keys.indexOf(a.issue.severity) - exception_1.IssueSeverity.Keys.indexOf(b.issue.severity);
+                const i = common_1.IssueSeverity.Keys.indexOf(a.issue.severity) - common_1.IssueSeverity.Keys.indexOf(b.issue.severity);
                 if (i === 0)
                     return b.status - a.status;
                 return i;
@@ -206,30 +384,35 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                 if (status < common_1.HttpStatus.BAD_REQUEST)
                     status = common_1.HttpStatus.INTERNAL_SERVER_ERROR;
             }
-            body = {
+            body = this.i18n.deep({
                 operation: ctx.query.method,
                 errors: errors.map(e => e.issue)
-            };
+            });
+            body = JSON.stringify(body);
+            ctx.responseHeaders['content-type'] = 'application/json; charset=utf-8';
         }
         else {
-            body = ctx.response;
+            if (typeof ctx.response === 'object' && !((0, common_1.isReadable)(ctx.response) || Buffer.isBuffer(ctx.response))) {
+                body = this.i18n.deep(ctx.response);
+                body = JSON.stringify(body);
+                ctx.responseHeaders['content-type'] = 'application/json; charset=utf-8';
+            }
             status = status || (query.operation === 'create' ? common_1.HttpStatus.CREATED : common_1.HttpStatus.OK);
         }
-        body = this.i18n.deep(body);
         return {
             status,
-            headers: ctx.responseHeaders.toObject(),
+            headers: (0, common_1.normalizeHeaders)(ctx.responseHeaders),
             body
         };
     }
     async sendError(executionContext, error) {
-        const resp = executionContext.getResponseWrapper();
+        const resp = executionContext.getResponse();
         resp.setStatus(error.status || 500);
         resp.setHeader(common_1.HttpHeaders.Content_Type, 'application/json');
         resp.setHeader(common_1.HttpHeaders.Cache_Control, 'no-cache');
         resp.setHeader(common_1.HttpHeaders.Pragma, 'no-cache');
         resp.setHeader(common_1.HttpHeaders.Expires, '-1');
-        resp.setHeader(common_1.HttpHeaders.X_Opra_Version, schema_1.OpraSchema.Version);
+        resp.setHeader(common_1.HttpHeaders.X_Opra_Version, common_1.OpraSchema.Version);
         const issue = this.i18n.deep(error.issue);
         const body = {
             operation: 'unknown',
@@ -239,3 +422,22 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
     }
 }
 exports.OpraHttpAdapter = OpraHttpAdapter;
+// async function callMiddlewares(req: HttpRequest, middlewares: NextHandleFunction[]): Promise<void> {
+//   return new Promise<void>((resolve, reject) => {
+//     let i = 0;
+//     const next = (err?: any) => {
+//       if (err)
+//         return reject(err);
+//       const fn = middlewares[i++];
+//       if (!fn)
+//         return resolve();
+//       try {
+//         fn(req as any, {} as any, next);
+//       } catch (e) {
+//         reject(e);
+//       }
+//     }
+//     next();
+//   });
+//
+// }

package/cjs/adapter/request-contexts/batch-request-context.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchRequestContext = void 0;
+const request_context_js_1 = require("./request-context.js");
+class BatchRequestContext extends request_context_js_1.RequestContext {
+    queries;
+    constructor(args) {
+        super(args);
+        this.queries = args.queries;
+    }
+}
+exports.BatchRequestContext = BatchRequestContext;

package/cjs/adapter/{query-context.js → request-contexts/request-context.js}

@@ -1,31 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryContext = void 0;
+exports.RequestContext = void 0;
 const common_1 = require("@opra/common");
-const url_1 = require("@opra/url");
-class QueryContext {
+class RequestContext {
     service;
     executionContext;
-    query;
     params;
     headers;
+    contentId;
     parentValue;
     resultPath;
     responseHeaders;
     response;
     errors = [];
     status;
-    userContext;
     continueOnError;
     constructor(args) {
-        // Object.assign(this, args);
         this.service = args.service;
         this.executionContext = args.executionContext;
-        this.query = args.query;
-        // this.response = new QueryResponse();
-        this.params = this.params || new url_1.OpraURLSearchParams();
-        this.headers = new common_1.HeadersMap(args.headers);
-        this.responseHeaders = new common_1.HeadersMap();
+        this.params = this.params || new common_1.OpraURLSearchParams();
+        this.headers = args.headers;
+        this.contentId = args.contentId;
+        this.responseHeaders = {};
         this.resultPath = this.resultPath || '';
     }
     get type() {
@@ -37,4 +33,4 @@ class QueryContext {
         return this.executionContext;
     }
 }
-exports.QueryContext = QueryContext;
+exports.RequestContext = RequestContext;

package/cjs/adapter/request-contexts/single-request-context.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingleRequestContext = void 0;
+const request_context_js_1 = require("./request-context.js");
+class SingleRequestContext extends request_context_js_1.RequestContext {
+    query;
+    constructor(args) {
+        super(args);
+        this.query = args.query;
+    }
+    get userContext() {
+        return this.executionContext.userContext;
+    }
+}
+exports.SingleRequestContext = SingleRequestContext;

package/cjs/index.js

@@ -5,7 +5,8 @@ require("reflect-metadata");
 tslib_1.__exportStar(require("./types.js"), exports);
 tslib_1.__exportStar(require("./interfaces/execution-context.interface.js"), exports);
 tslib_1.__exportStar(require("./interfaces/resource.interface.js"), exports);
-tslib_1.__exportStar(require("./adapter/query-context.js"), exports);
+tslib_1.__exportStar(require("./interfaces/i18n-options.interface.js"), exports);
+tslib_1.__exportStar(require("./adapter/request-contexts/single-request-context.js"), exports);
 tslib_1.__exportStar(require("./adapter/adapter.js"), exports);
 tslib_1.__exportStar(require("./adapter/http-adapter.js"), exports);
 tslib_1.__exportStar(require("./adapter/express-adapter.js"), exports);

package/cjs/interfaces/i18n-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });