Add support for _bg, remove legacy :bg support

Author: keithwhor

lib/gateway.js

@@ -158,27 +158,23 @@ class Gateway extends EventEmitter {
     return headers;
   }
 
-  __background__ (req, res, definition, params) {
+  __beginBackgroundExecution__ (req, res, definition, params, headers) {
     let bgResponse = this.supportedBgModes[definition.bg && definition.bg.mode] ||
       this.supportedBgModes[this.defaultBgMode];
     let value = bgResponse(definition, params);
-    let initialHeaders = {
-      'x-execution-uuid': req._uuid
-    };
-    let headers = this.__createHeaders__(req, initialHeaders);
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
     headers['content-type'] = headers['content-type'] ||
       (value instanceof Buffer ? 'application/octet-stream' : 'application/json');
     value = value instanceof Buffer ? value : JSON.stringify(value);
     res.headersSent || res.writeHead(202, this.__formatHeaders__(headers));
     res.finished || res.end(value);
   }
 
-  __beginServerSentEvent__ (req, res, definition, params) {
-    let initialHeaders = {
-      'content-type': 'text/event-stream',
-      'x-execution-uuid': req._uuid
-    };
-    let headers = this.__createHeaders__(req, initialHeaders);
+  __beginServerSentEvent__ (req, res, definition, params, headers) {
+    headers = headers || {};
+    headers = this.__createHeaders__(req, headers);
+    headers['content-type'] = 'text/event-stream';
     res.headersSent || res.writeHead(200, this.__formatHeaders__(headers));
     // Create SSE Instance
     let sseInstance = {
@@ -928,13 +924,16 @@ class Gateway extends EventEmitter {
     let errors = {};
 
     // Handle special parameters
-    if (params._stream) {
-      try {
-        params._stream = types.parse('object', null, params._stream, convert);
-      } catch (e) {
-        params._stream = params._stream;
+    let specialParams = ['_bg', '_stream', '_debug'];
+    specialParams.forEach(key => {
+      if (params[key]) {
+        try {
+          params[key] = types.parse('object', null, params[key], convert);
+        } catch (e) {
+          params[key] = params[key];
+        }
       }
-    }
+    });
 
     let paramsList = definition.params.map(param => {
       // Catch where there is a mismatch
@@ -1089,37 +1088,17 @@ class Gateway extends EventEmitter {
     this._requestCount += 1;
 
     let urlinfo = url.parse(req.url);
-    let pathinfo = urlinfo.pathname.split(':');
-    let pathname = pathinfo[0];
+    let pathname = urlinfo.pathname;
     req.url = [pathname, urlinfo.search].join('');
 
-    // Legacy, will deprecate
-    let pathquery;
-    try {
-      pathquery = this.__parseParamsFromEncodedURL__(pathinfo[1] || '');
-    } catch (e) {
-      return this.__parameterParseError__(req, res, e.message, 400);
-    }
-    if ('bg' in pathquery) {
-      req._background = true;
-      this.log(req, `Background Function Initiated`);
-    }
-
     if (
       this.trailingSlashRedirectMethods[req.method] &&
       req.headers['user-agent'] &&
       !pathname.endsWith('/') &&
       pathname.split('/').pop().indexOf('.') === -1
     ) {
       this.log(req, `Redirect`);
-      if (pathinfo.length === 2) {
-        pathinfo[0] = pathname + '/';
-        pathinfo[1] = pathinfo[1].endsWith('/') ?
-          pathinfo[1].substr(0, pathinfo[1].length - 1) :
-          pathinfo[1];
-        return this.__redirect__(req, res, pathinfo.join(':') + (urlinfo.search || ''));
-      }
-      return this.__redirect__(req, res, [pathinfo.join(':'), urlinfo.search].join('/'));
+      return this.__redirect__(req, res, [pathname, urlinfo.search].join('/'));
     } else if (!(req.method in this.supportedMethods)) {
       this.log(req, `Not Implemented`, 'error');
       return this.__clientError__(req, res, `Not Implemented`, 501);
@@ -1150,6 +1129,12 @@ class Gateway extends EventEmitter {
       this.log(req, `Request Received (Size ${buffer.length})`);
       this.resolve(req, res, buffer, (err, definition, data, buffer, proxyParameters) => {
 
+        let headers = {};
+        headers['x-execution-uuid'] = req._uuid;
+        if (definition && definition.allowOrigin) {
+          headers['access-control-allow-origin'] = definition.allowOrigin;
+        }
+
         if (err) {
           if (err.accessSourceError) {
             return this.__accessSourceError__(req, res, err.message);
@@ -1209,22 +1194,28 @@ class Gateway extends EventEmitter {
           return this.__parameterError__(req, res, validated.errors);
         }
 
-        if (req._background) {
-          this.log(req, `Background Function Responded to Client`);
-          this.__background__(req, res, definition, validated.params);
-        }
-
         if (
-          validated.params._stream === '' ||
-          validated.params._stream
+          definition.bg && (
+            validated.params._bg === '' ||
+            validated.params._bg
+          )
+        ) {
+          this.log(req, `Background Function Responded to Client`);
+          this.__beginBackgroundExecution__(req, res, definition, validated.params, headers);
+        } else if (
+          definition.streams &&
+          definition.streams.length > 0 && (
+            validated.params._stream === '' ||
+            validated.params._stream
+          )
         ) {
           let streamValidated = this.__validateStreams__(validated.params._stream, definition.streams);
           if (streamValidated.errors) {
             this.log(req, `Stream Listener Error`, 'error');
             return this.__streamListenerError__(req, res, streamValidated.errors);
           }
           this.log(req, `Begin Server-Sent Event`);
-          this.__beginServerSentEvent__(req, res, definition, validated.params);
+          this.__beginServerSentEvent__(req, res, definition, validated.params, headers);
         }
 
         let context = this.createContext(req, definition, validated.params, data, buffer);
@@ -1241,7 +1232,8 @@ class Gateway extends EventEmitter {
             res,
             definition,
             data,
-            functionArgs
+            functionArgs,
+            headers
           );
         });
 
@@ -1317,7 +1309,7 @@ class Gateway extends EventEmitter {
     !this._requestCount && this.emit('empty');
   }
 
-  __requestHandler__ (req, res, definition, data, functionArgs, context) {
+  __requestHandler__ (req, res, definition, data, functionArgs, headers) {
     let nullable = (definition.returns || {}).defaultValue === null;
     this.log(req, `Execution Start`);
     let t = new Date().valueOf();
@@ -1326,9 +1318,7 @@ class Gateway extends EventEmitter {
       definition.format.language &&
       definition.format.language === 'static'
     );
-    this.execute(definition, functionArgs, data, (err, value, headers, executionUuid) => {
-      headers = headers || {};
-      headers['x-execution-uuid'] = executionUuid;
+    this.execute(definition, functionArgs, data, headers, (err, value, headers, executionUuid) => {
       let dt = new Date().valueOf() - t;
       err = err === undefined ? null : err;
       // Catch where there is a mismatch
@@ -1713,7 +1703,8 @@ class Gateway extends EventEmitter {
     }
   }
 
-  execute (definition, functionArgs, data, callback) {
+  execute (definition, functionArgs, data, headers, callback) {
+    headers = headers || {};
     let fn;
     let complete = false;
     let callbackWrapper = (err, result, headers, executionUuid) => {
@@ -1735,7 +1726,7 @@ class Gateway extends EventEmitter {
       let error = new Error(`Timeout of ${this.defaultTimeout}ms exceeded.`);
       error.timeoutError = true;
       error.fatal = true;
-      return callbackWrapper(error, null, null, executionUuid);
+      return callbackWrapper(error, null, headers, executionUuid);
     }, this.defaultTimeout);
     let executionUuid = data.context.uuid || uuid.v4();
     if (definition.format.language === 'static') {
@@ -1744,7 +1735,6 @@ class Gateway extends EventEmitter {
         this.preloadFiles[definition.pathname] ||
         fs.readFileSync(path.join(process.cwd(), this.root, definition.pathname))
       );
-      let headers = {};
       let statusCode = definition.name.endsWith(':notfound')
         ? 404
         : 200;
@@ -1786,7 +1776,7 @@ class Gateway extends EventEmitter {
       return callbackWrapper(
         null,
         {statusCode: statusCode, headers: headers, body: buffer},
-        null,
+        headers,
         executionUuid
       );
     } else if (definition.format.language === 'nodejs') {
@@ -1804,7 +1794,7 @@ class Gateway extends EventEmitter {
             this._inlineCache[definition.pathname] = fn;
           } catch (e) {
             e.fatal = true;
-            return callbackWrapper(e, null, null, executionUuid);
+            return callbackWrapper(e, null, headers, executionUuid);
           }
         }
       } else {
@@ -1854,28 +1844,31 @@ class Gateway extends EventEmitter {
             e.value = value;
           }
           e.fatal = true;
-          return callbackWrapper(e, null, null, executionUuid);
+          return callbackWrapper(e, null, headers, executionUuid);
         }
       }
       // Catch unhandled promise rejections once, starting now.
       //   This applies to local testing only.
       process.removeAllListeners('unhandledRejection');
-      process.once('unhandledRejection', (err, p) => callbackWrapper(err, null, null, executionUuid));
+      process.once('unhandledRejection', (err, p) => callbackWrapper(err, null, headers, executionUuid));
       if (definition.format.async) {
         fn.apply(null, functionArgs)
-          .then(result => callbackWrapper(null, result, null, executionUuid))
+          .then(result => callbackWrapper(null, result, headers, executionUuid))
           .catch(e => {
             if (!(e instanceof Error)) {
               let value = e;
               e = new Error(e || '');
               e.value = value;
             }
             e.thrown = true;
-            callbackWrapper(e, null, null, executionUuid);
+            callbackWrapper(e, null, headers, executionUuid);
           });
       } else {
         try {
-          fn.apply(null, functionArgs.concat((err, result, headers) => {
+          fn.apply(null, functionArgs.concat((err, result, responseHeaders) => {
+            Object.keys(responseHeaders || {}).forEach(key => {
+              headers[key.toLowerCase()] = responseHeaders[key];
+            });
             return callbackWrapper(err, result, headers, executionUuid);
           }));
         } catch (e) {
@@ -1885,11 +1878,16 @@ class Gateway extends EventEmitter {
             e.value = value;
           }
           e.thrown = true;
-          return callbackWrapper(e, null, null, executionUuid);
+          return callbackWrapper(e, null, headers, executionUuid);
         }
       }
     } else {
-      return callbackWrapper(new Error(`Gateway does not support language "${definition.format.language}"`))
+      return callbackWrapper(
+        new Error(`Gateway does not support language "${definition.format.language}"`),
+        null,
+        headers,
+        executionUuid
+      );
     }
   }
 

lib/parser/nodejs/validate_parameter_name.js

@@ -2,6 +2,7 @@ const babelParser = require('@babel/parser');
 
 const RESERVED_NAMES = [
   '_stream',
+  '_debug',
   '_bg',
   'context'
 ];