@jambonz/node-red-contrib-jambonz 2.4.23 → 2.4.25

package/src/nodes/dub.html

@@ -0,0 +1,135 @@
+<!-- Javascript -->
+<script type="text/javascript">
+  var mustacheType = {
+    value: 'mustache',
+    label: 'mustache',
+    hasvalue: true,
+    icon: 'resources/@jambonz/node-red-contrib-jambonz/icons/mustache.svg'
+  }
+  RED.nodes.registerType("dub", {
+    category: "jambonz",
+    color: "#bbabaa",
+    defaults: {
+      name: { value: "" },
+      action: { value: "addTrack" },
+      track: { value: "" },
+      trackType: { value: "str" },
+      play: { value: "" },
+      playType: { value: "str" },
+      say: { value: "" },
+      sayType: { value: "str" },
+      loop: { value: false },
+      gain: {
+        value: "",
+        validate: function (v) {
+          if (v.length) {
+            return v.match(/([+-]?\d+(\.\d+)?)\s*db/i) !== null;
+          }
+          return true;
+        },
+      },
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: "font-awesome/fa-cubes",
+    label: function () {
+      return this.name || "dub";
+    },
+    oneditprepare: function () {
+      var node = this;
+      $("#node-input-track").typedInput({
+        types: ["str", "msg", "flow", "global", "jsonata", "env", mustacheType],
+        typeField: $("#node-input-trackType"),
+      });
+      $("#node-input-play").typedInput({
+        types: ["str", "msg", "flow", "global", "jsonata", "env", mustacheType],
+        typeField: $("#node-input-playType"),
+      });
+      $("#node-input-say").typedInput({
+        types: ["str", "msg", "flow", "global", "jsonata", "env", mustacheType],
+        typeField: $("#node-input-sayType"),
+      });
+    },
+  });
+</script>
+
+<!-- HTML -->
+<script type="text/html" data-template-name="dub">
+  <div class="form-row">
+    <label for="node-input-name"><i class="icon-tag"></i> Name</label>
+    <input type="text" id="node-input-name" placeholder="Name" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-action">Action</label>
+    <select id="node-input-action">
+      <option value="addTrack">addTrack</option>
+      <option value="removeTrack">removeTrack</option>
+      <option value="silenceTrack">silenceTrack</option>
+      <option value="playOnTrack">playOnTrack</option>
+      <option value="sayOnTrack">sayOnTrack</option>
+    </select>
+  </div>
+  <div class="form-row">
+    <label for="node-input-track">Track</label>
+    <input type="text" id="node-input-track" placeholder="The label for the track">
+    <input type="hidden" id="node-input-trackType">
+  </div>
+  <div class="form-row">
+    <label for="node-input-play">Play</label>
+    <input type="text" id="node-input-play" placeholder="The http(s) url to an mp3 file">
+    <input type="hidden" id="node-input-playType">
+  </div>
+  <div class="form-row">
+    <label for="node-input-say">Say</label>
+    <input type="text" id="node-input-say" placeholder="The label for the play">
+    <input type="hidden" id="node-input-sayType">
+  </div>
+  <div class="form-row">
+    <label for="node-input-loop">Loop</label>
+    <input type="checkbox" id="node-input-loop" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-gain">Gain</label>
+    <input
+      type="text"
+      id="node-input-gain"
+      placeholder="The value must be between +- 50 dB"
+    />
+  </div>
+</script>
+
+<!-- Help Text -->
+<script type="text/html" data-help-name="dub">
+  <p>Adds one or more additional audio tracks</p>
+  <h3>Inputs</h3>
+  <h3>Properties</h3>
+  <p>
+    <code>Action</code> - One of 'addTrack', 'removeTrack', 'silenceTrack',
+    'playOnTrack', or 'sayOnTrack'.
+  </p>
+  <p><code>Track</code> - Label for the track</p>
+  <p>
+    <code>Play</code> - An http(s) url to an mp3 file to play into the track
+  </p>
+  <p><code>Loop</code> - Loop the mp3</p>
+  <p>
+    <code>Gain</code> - Decibels to boost or reduce the strength of the audio
+    signal
+  </p>
+
+  <h3>Details</h3>
+  The dub verb adds one or more additional audio tracks into the conversation
+  (currently, a max of two additional audio tracks may be added). Audio can then
+  be inserted into these tracks and it will be blended with the play or say
+  content being sent to the caller/called party. The source of the audio content
+  can be either text to speech or mp3 audio accessible via http(s).
+
+  <h3>References</h3>
+  <ul>
+    <li>
+      <a href="https://www.jambonz.org/docs/webhooks/dub/"
+        >Jambonz dub reference</a
+      >
+    </li>
+  </ul>
+</script>

package/src/nodes/dub.js

@@ -0,0 +1,24 @@
+var {appendVerb, new_resolve} = require('./libs')
+
+module.exports = function(RED) {
+  /** dub */
+  function dub(config) {
+    RED.nodes.createNode(this, config);
+    var node = this;
+
+    node.on('input', async function(msg) {
+      var obj = {
+        verb: 'dub',
+        action: config.action,
+        track: await new_resolve(RED, config.track, config.trackType, node, msg),
+        play: await new_resolve(RED, config.play, config.playType, node, msg),
+        say: await new_resolve(RED, config.say, config.sayType, node, msg),
+        loop: config.loop,
+        gain: config.gain
+      };
+      appendVerb(msg, obj);
+      node.send(msg);
+    });
+  }
+  RED.nodes.registerType('dub', dub);
+}

package/src/nodes/enqueue.js

@@ -5,13 +5,13 @@ module.exports = function(RED) {
   function enqueue(config) {
     RED.nodes.createNode(this, config);
     var node = this;
-    node.on('input', function(msg, send, done) {
+    node.on('input', async function(msg, send, done) {
       appendVerb(msg, {
         verb: 'enqueue',
-        name:  new_resolve(RED, config.queue, config.queueType, node, msg),
-        priority:  new_resolve(RED, config.priority, config.priorityType, node, msg),
-        actionHook: new_resolve(RED, config.actionHook, config.actionHookType, node, msg),
-        waitHook: new_resolve(RED, config.waitHook, config.waitHookType, node, msg)
+        name:  await new_resolve(RED, config.queue, config.queueType, node, msg),
+        priority:  await new_resolve(RED, config.priority, config.priorityType, node, msg),
+        actionHook: await new_resolve(RED, config.actionHook, config.actionHookType, node, msg),
+        waitHook: await new_resolve(RED, config.waitHook, config.waitHookType, node, msg)
       });
       node.send(msg);
     });

package/src/nodes/gather.js

@@ -5,14 +5,14 @@ module.exports = function(RED) {
   function gather(config) {
     RED.nodes.createNode(this, config);
     var node = this;
-    node.on('input', function(msg) {
+    node.on('input', async function(msg) {
 
       // simple properties
       node.log(`config: ${JSON.stringify(config)}`);
 
       var obj = {verb: 'gather', input: []};
-      if (config.actionhook) obj.actionHook = new_resolve(RED, config.actionhook, config.actionhookType, node, msg)
-      if (config.partialresulthook) obj.partialResultHook = new_resolve(RED, config.partialresulthook, config.partialresulthookType, node, msg)
+      if (config.actionhook) obj.actionHook = await new_resolve(RED, config.actionhook, config.actionhookType, node, msg)
+      if (config.partialresulthook) obj.partialResultHook = await new_resolve(RED, config.partialresulthook, config.partialresulthookType, node, msg)
 
       // input
       if (config.speechinput) {
@@ -22,9 +22,9 @@ module.exports = function(RED) {
           language: config.recognizerlang
         };
         if (recognizer.vendor === 'google') {
-          var hints = new_resolve(RED, config.transcriptionhints, config.transcriptionhintsType, node, msg);
-          var altlangs = new_resolve(RED, config.recognizeraltlang, config.recognizeraltlangType, node, msg);
-          var naics = new_resolve(RED, config.naics, config.naicsType, node, msg);
+          var hints = await new_resolve(RED, config.transcriptionhints, config.transcriptionhintsType, node, msg);
+          var altlangs = await new_resolve(RED, config.recognizeraltlang, config.recognizeraltlangType, node, msg);
+          var naics = await new_resolve(RED, config.naics, config.naicsType, node, msg);
           Object.assign(recognizer, {
             profanityFilter: config.profanityfilter,
             hints: hints.length > 0 ?
@@ -37,8 +37,8 @@ module.exports = function(RED) {
           }
         }
         else if (recognizer.vendor === 'aws') {
-          var vocab = new_resolve(RED, config.vocabularyname, config.vocabularynameType, node, msg);
-          var vocabFilter = new_resolve(RED, config.vocabularyfiltername, config.vocabularyfilternameType, node, msg);
+          var vocab = await new_resolve(RED, config.vocabularyname, config.vocabularynameType, node, msg);
+          var vocabFilter = await new_resolve(RED, config.vocabularyfiltername, config.vocabularyfilternameType, node, msg);
           Object.assign(recognizer, {
             vocabularyName: vocab,
             vocabularyFilterName: vocabFilter,
@@ -74,7 +74,7 @@ module.exports = function(RED) {
           });
         }
       }
-      else obj.play = {url: new_resolve(RED, config.playurl, config.playurlType, node, msg)};
+      else obj.play = {url: await new_resolve(RED, config.playurl, config.playurlType, node, msg)};
 
       node.log(`gather: ${JSON.stringify(obj)}`);
 

package/src/nodes/get_alerts.js

@@ -7,11 +7,11 @@ module.exports = function(RED) {
         var node = this;
         const server = RED.nodes.getNode(config.server);
         const {accountSid, apiToken} = server.credentials;
-        node.on('input', async(msg, send, done) => {
+        node.on('input', async (msg, send, done) => {
             const data = {
-                page: new_resolve(RED, config.page, config.pageType, node, msg),
-                count: new_resolve(RED, config.count, config.countType, node, msg),
-                days: new_resolve(RED, config.days, config.daysType, node, msg),
+                page: await new_resolve(RED, config.page, config.pageType, node, msg),
+                count: await new_resolve(RED, config.count, config.countType, node, msg),
+                days: await new_resolve(RED, config.days, config.daysType, node, msg),
             }
             Object.keys(data).forEach((k) => data[k] == null || data[k] == '' && delete data[k]);
             const params = new URLSearchParams(data).toString()           

package/src/nodes/get_call.js

@@ -8,7 +8,7 @@ module.exports = function (RED) {
     const server = RED.nodes.getNode(config.server);
     const { accountSid, apiToken } = server.credentials;
     node.on("input", async (msg, send, done) => {
-      const callSid = new_resolve(RED, config.callSid, config.callSidType, node, msg);
+      const callSid = await new_resolve(RED, config.callSid, config.callSidType, node, msg);
       if (!callSid) {
         if (done) done(new Error('CallSid empty'));
           else node.error(new Error('CallSid empty'), msg);

package/src/nodes/get_calls.js

@@ -9,10 +9,10 @@ module.exports = function (RED) {
     const { accountSid, apiToken } = server.credentials;
     node.on("input", async (msg, send, done) => {
       const data = {
-        direction: new_resolve(RED, config.direction, config.directionType, node, msg),
-        from: new_resolve(RED, config.from, config.fromType, node, msg),
-        to: new_resolve(RED, config.to, config.toType, node, msg),
-        callStatus: new_resolve(RED, config.callStatus, config.callStatusType, node, msg),
+        direction: await new_resolve(RED, config.direction, config.directionType, node, msg),
+        from: await new_resolve(RED, config.from, config.fromType, node, msg),
+        to: await new_resolve(RED, config.to, config.toType, node, msg),
+        callStatus: await new_resolve(RED, config.callStatus, config.callStatusType, node, msg),
       };
       Object.keys(data).forEach(
         (k) => data[k] == null || (data[k] == '' && delete data[k])

package/src/nodes/get_recent_calls.js

@@ -7,13 +7,13 @@ module.exports = function(RED) {
         var node = this;
         const server = RED.nodes.getNode(config.server);
         const {accountSid, apiToken} = server.credentials;
-        node.on('input', async(msg, send, done) => {
+        node.on('input', async (msg, send, done) => {
             const data = {
-                direction: new_resolve(RED, config.direction, config.directionType, node, msg),
-                trunk: new_resolve(RED, config.trunk, config.trunkType, node, msg),
-                page: new_resolve(RED, config.page, config.pageType, node, msg),
-                count: new_resolve(RED, config.count, config.countType, node, msg),
-                days: new_resolve(RED, config.days, config.daysType, node, msg),
+                direction: await new_resolve(RED, config.direction, config.directionType, node, msg),
+                trunk: await new_resolve(RED, config.trunk, config.trunkType, node, msg),
+                page: await new_resolve(RED, config.page, config.pageType, node, msg),
+                count: await new_resolve(RED, config.count, config.countType, node, msg),
+                days: await new_resolve(RED, config.days, config.daysType, node, msg),
             }
             Object.keys(data).forEach((k) => data[k] == null || data[k] == '' && delete data[k]);
             const params = new URLSearchParams(data).toString();       

package/src/nodes/hangup.js

@@ -4,7 +4,7 @@ module.exports = function(RED) {
     function hangup(config) {
         RED.nodes.createNode(this, config);
         var node = this;
-        node.on('input', function(msg) {
+        node.on('input', async function(msg) {
           var data = {
             verb: 'hangup'
           };

package/src/nodes/lcc.js

@@ -8,12 +8,12 @@ function lcc(config) {
     var node = this;
     const server = RED.nodes.getNode(config.server);
 
-    node.on('input', async(msg, send, done) => {
+    node.on('input', async (msg, send, done) => {
       send = send || function() { node.send.apply(node, arguments);};
 
       const {accountSid, apiToken} = server.credentials;
       const url = server.url;
-      const callSid = new_resolve(RED, config.callSid, config.callSidType, node, msg);
+      const callSid = await new_resolve(RED, config.callSid, config.callSidType, node, msg);
       if (!url || !accountSid || !apiToken || !callSid) {
         node.log(`invalid / missing credentials or callSid, skipping LCC node: ${JSON.stringify(server.credentials)}`);
         send(msg);
@@ -51,14 +51,14 @@ function lcc(config) {
           opts.transcribe_status = 'resume';
           break;
         case 'redirect':
-          opts.call_hook = {url: new_resolve(RED, config.callHook, config.callHookType, node, msg)};
+          opts.call_hook = {url: await new_resolve(RED, config.callHook, config.callHookType, node, msg)};
           if (config.childCallHook) {
-            opts.child_call_hook = {url: new_resolve(RED, config.childCallHook, config.childCallHookType, node, msg)};
+            opts.child_call_hook = {url: await new_resolve(RED, config.childCallHook, config.childCallHookType, node, msg)};
           }
           break;
         case 'hold_conf':
           opts.conf_hold_status = 'hold';
-          opts.wait_hook = {url: new_resolve(RED, config.waitHook, config.waitHookType, node, msg)};
+          opts.wait_hook = {url: await new_resolve(RED, config.waitHook, config.waitHookType, node, msg)};
           break;
         case 'unhold_conf':
           opts.conf_hold_status = 'unhold';
@@ -82,16 +82,16 @@ function lcc(config) {
         case 'sip_request':
           opts.sip_request = { 
             method: config.sipRequestMethod,
-            content_type: new_resolve(RED, config.sipRequestContentType, config.sipRequestContentTypeType, node, msg),
-            content: new_resolve(RED, config.sipRequestBody, config.sipRequestBodyType, node, msg),
-            headers: new_resolve(RED, config.sipRequestHeaders, config.sipRequestHeadersType, node, msg) || {}
+            content_type: await new_resolve(RED, config.sipRequestContentType, config.sipRequestContentTypeType, node, msg),
+            content: await new_resolve(RED, config.sipRequestBody, config.sipRequestBodyType, node, msg),
+            headers: await new_resolve(RED, config.sipRequestHeaders, config.sipRequestHeadersType, node, msg) || {}
           };
           break;
         case 'start_call_recording':
           opts.record = { 
             action: 'startCallRecording',
-            siprecServerURL: new_resolve(RED, config.siprecServerURL, config.siprecServerURLType, node, msg),
-            recordingID: new_resolve(RED, config.recordingID, config.recordingIDType, node, msg) || crypto.randomUUID()
+            siprecServerURL: await new_resolve(RED, config.siprecServerURL, config.siprecServerURLType, node, msg),
+            recordingID: await new_resolve(RED, config.recordingID, config.recordingIDType, node, msg) || crypto.randomUUID()
           };
           // SIPREC headers
           if (config.siprecHeaders) {
@@ -115,12 +115,12 @@ function lcc(config) {
           break;
         case 'send_dtmf':
           opts.dtmf = { 
-            digit: new_resolve(RED, config.dtmfDigit, config.dtmfDigitType, node, msg),
-            duration: new_resolve(RED, config.dtmfDuration, config.dtmfDurationType, node, msg) || '250'
+            digit: await new_resolve(RED, config.dtmfDigit, config.dtmfDigitType, node, msg),
+            duration: await new_resolve(RED, config.dtmfDuration, config.dtmfDurationType, node, msg) || '250'
           };
           break;
         case 'tag':
-            opts.tag = new_resolve(RED, config.tag, config.tagType, node, msg);
+            opts.tag = await new_resolve(RED, config.tag, config.tagType, node, msg);
             break;
         default:
           node.log(`invalid action: ${config.action}`);

package/src/nodes/lex.js

@@ -6,27 +6,27 @@ module.exports = function(RED) {
     RED.nodes.createNode(this, config);
     var node = this;
     const awsCreds = RED.nodes.getNode(config.aws);
-    node.on('input', function(msg) {
+    node.on('input', async function(msg) {
       let accessKey, secretAccessKey;
       if (awsCreds && awsCreds.credentials) {
         accessKey = awsCreds.credentials.accessKey;
         secretAccessKey = awsCreds.credentials.secretAccessKey;
       }
-      var eventHook = new_resolve(RED, config.eventHook, config.eventHookType, node, msg);
-      var actionHook = new_resolve(RED, config.actionHook, config.actionHookType, node, msg);
-      var botId = new_resolve(RED, config.bot, config.botType, node, msg);
-      var botAlias = new_resolve(RED, config.alias, config.aliasType, node, msg);
-      var locale = new_resolve(RED, config.locale, config.localeType, node, msg) || 'en_US';  
-      var val = new_resolve(RED, config.inputTimeout, config.inputTimeoutType, node, msg);
+      var eventHook = await new_resolve(RED, config.eventHook, config.eventHookType, node, msg);
+      var actionHook = await new_resolve(RED, config.actionHook, config.actionHookType, node, msg);
+      var botId = await new_resolve(RED, config.bot, config.botType, node, msg);
+      var botAlias = await new_resolve(RED, config.alias, config.aliasType, node, msg);
+      var locale = await new_resolve(RED, config.locale, config.localeType, node, msg) || 'en_US';  
+      var val = await new_resolve(RED, config.inputTimeout, config.inputTimeoutType, node, msg);
       var timeout = /^\d+$/.test(val) ? parseInt(val) : 0;
       var slots, intentName;
       if (config.specifyIntent) {
-        intentName =  new_resolve(RED, config.intent, config.intentType, node, msg);
+        intentName =  await new_resolve(RED, config.intent, config.intentType, node, msg);
         if (intentName) {
-          slots =  new_resolve(RED, config.slots, config.slotsType, node, msg);
+          slots =  await new_resolve(RED, config.slots, config.slotsType, node, msg);
         }
       }
-      var metadata =  new_resolve(RED, config.metadata, config.metadataType, node, msg);
+      var metadata =  await new_resolve(RED, config.metadata, config.metadataType, node, msg);
 
       const obj = {
         verb: 'lex',

package/src/nodes/libs.js

@@ -45,7 +45,7 @@ exports.appendVerb = (msg, obj) => {
     return mustache.render('{{' + val + '}}', data);
   }
   
-  exports.new_resolve = (RED, val, valtype, node, msg) => {
+  exports.new_resolve = async (RED, val, valtype, node, msg) => {
     if (!val || !valtype) return val;
     switch (valtype) {
       case 'str': 
@@ -56,7 +56,12 @@ exports.appendVerb = (msg, obj) => {
       case 'flow': 
       case 'global':
       case 'jsonata':
-        return RED.util.evaluateNodeProperty(val, valtype, node, msg);
+        try {
+          return await asyncEvaluateNodeProperty(RED, val, valtype, node, msg);
+        } catch (e) { 
+          node.error(`Error evaluating ${valtype} property: ${e.message}`);
+          return null;
+        }
       case 'mustache': 
         let data = dataobject(node.context(), msg);
         return mustache.render(val, data);
@@ -64,6 +69,19 @@ exports.appendVerb = (msg, obj) => {
         return JSON.parse(val);
     }
   }
+
+  function asyncEvaluateNodeProperty(RED, value, type, node, msg) {
+    return new Promise(function (resolve, reject) {
+      RED.util.evaluateNodeProperty(value, type, node, msg, function (e, r) {
+        if (e) {
+          reject(e);
+        } else {
+          resolve(r);
+        }
+      });
+    });
+  }
+
   function dataobject(context, msg){
     let data = Object.assign({}, msg);
     data.global = {};

package/src/nodes/listen.js

@@ -4,11 +4,11 @@ module.exports = function(RED) {
   function listen(config) {
     RED.nodes.createNode(this, config);
     var node = this;
-    node.on('input', function(msg) {
+    node.on('input', async function(msg) {
       const obj = {
         verb: 'listen',
-        url: new_resolve(RED, config.url, config.urlType, node, msg),
-        actionHook: new_resolve(RED, config.actionhook, config.actionhookType, node, msg),
+        url: await new_resolve(RED, config.url, config.urlType, node, msg),
+        actionHook: await new_resolve(RED, config.actionhook, config.actionhookType, node, msg),
         finishOnKey: config.finishonkey,
         mixType: config.mixtype,
         playBeep: config.beep,
@@ -17,8 +17,8 @@ module.exports = function(RED) {
         sampleRate: config.sampleRate,
       };
 
-      const authUser = new_resolve(RED, config.authuser, config.authuserType, node, msg);
-      const authPass = new_resolve(RED, config.authpass, config.authpassType, node, msg);
+      const authUser = await new_resolve(RED, config.authuser, config.authuserType, node, msg);
+      const authPass = await new_resolve(RED, config.authpass, config.authpassType, node, msg);
       if (authUser && authPass) {
         obj.wsAuth = {
           username: authUser,
@@ -35,11 +35,11 @@ module.exports = function(RED) {
           diarization: config.diarization
         };
         if (recognizer.vendor === 'google') {
-          var diarizationMin = new_resolve(RED, config.diarizationmin, config.diarizationminType, node, msg);
-          var diarizationMax = new_resolve(RED, config.diarizationmax, config.diarizationmaxType, node, msg);
-          var hints = new_resolve(RED, config.transcriptionhints, config.transcriptionhintsType, node, msg);
-          var altlangs = new_resolve(RED, config.recognizeraltlang, config.recognizeraltlangType, node, msg);
-          var naics = new_resolve(RED, config.naics, config.naicsType, node, msg);
+          var diarizationMin = await new_resolve(RED, config.diarizationmin, config.diarizationminType, node, msg);
+          var diarizationMax = await new_resolve(RED, config.diarizationmax, config.diarizationmaxType, node, msg);
+          var hints = await new_resolve(RED, config.transcriptionhints, config.transcriptionhintsType, node, msg);
+          var altlangs = await new_resolve(RED, config.recognizeraltlang, config.recognizeraltlangType, node, msg);
+          var naics = await new_resolve(RED, config.naics, config.naicsType, node, msg);
           Object.assign(recognizer, {
             profanityFilter: config.profanityfilter,
             hints: hints.length > 0 ?
@@ -60,8 +60,8 @@ module.exports = function(RED) {
           }
         }
         else if (recognizer.vendor === 'aws') {
-          var vocab = new_resolve(RED, config.vocabularyname, config.vocabularynameType, node, msg);
-          var vocabFilter = new_resolve(RED, config.vocabularyfiltername, config.vocabularyfilternameType, node, msg);
+          var vocab = await new_resolve(RED, config.vocabularyname, config.vocabularynameType, node, msg);
+          var vocabFilter = await new_resolve(RED, config.vocabularyfiltername, config.vocabularyfilternameType, node, msg);
           Object.assign(recognizer, {
             vocabularyName: vocab,
             vocabularyFilterName: vocabFilter,
@@ -69,7 +69,7 @@ module.exports = function(RED) {
           });
         }
         obj.transcribe = {
-          transcriptionHook: new_resolve(RED, config.transcriptionhook, config.transcriptionhookType, node, msg),
+          transcriptionHook: await new_resolve(RED, config.transcriptionhook, config.transcriptionhookType, node, msg),
           recognizer
         };
       }
@@ -77,7 +77,7 @@ module.exports = function(RED) {
       if (/^\d+$/.test(config.maxlength)) obj.maxLength = parseInt(config.maxLength);
       if (config.finishonkey.length) obj.finishOnKey = config.finishonkey;
 
-      var data = new_resolve(RED, config.metadata, config.metadataType, node, msg);
+      var data = await new_resolve(RED, config.metadata, config.metadataType, node, msg);
       if (data) obj.metadata = data;
 
       appendVerb(msg, obj);

package/src/nodes/message.js

@@ -4,11 +4,11 @@ module.exports = function (RED) {
   function message(config) {
     RED.nodes.createNode(this, config);
     var node = this;
-    node.on("input", function (msg, send, done) {
-      var from = new_resolve(RED, config.from, config.fromType, node, msg);
-      var to =new_resolve(RED, config.to, config.toType, node, msg);
-      var text = new_resolve(RED, config.text, config.textType, node, msg);
-      var provider = new_resolve(RED, config.provider, config.providerType, node, msg);
+    node.on("input", async function(msg, send, done) {
+      var from = await new_resolve(RED, config.from, config.fromType, node, msg);
+      var to = await new_resolve(RED, config.to, config.toType, node, msg);
+      var text = await new_resolve(RED, config.text, config.textType, node, msg);
+      var provider = await new_resolve(RED, config.provider, config.providerType, node, msg);
       if ((!provider || 0 === provider.length) && msg.sms.provider) {
         provider = msg.sms.provider;
       }

package/src/nodes/pause.js

@@ -5,8 +5,8 @@ module.exports = function(RED) {
   function pause(config) {
     RED.nodes.createNode(this, config);
     var node = this;
-    node.on('input', function(msg) {
-      var length = new_resolve(RED, config.len, config.lenType, node, msg);
+    node.on('input', async function(msg) {
+      var length = await new_resolve(RED, config.len, config.lenType, node, msg);
       appendVerb(msg, {
         verb: 'pause',
         length

package/src/nodes/play.js

@@ -4,15 +4,15 @@ module.exports = function(RED) {
   function play(config) {
     RED.nodes.createNode(this, config);
     var node = this;
-    node.on('input', function(msg) {
+    node.on('input', async function(msg) {
       appendVerb(msg,  {
         verb: 'play',
-        url: new_resolve(RED, config.url, config.urlType, node, msg),
+        url: await new_resolve(RED, config.url, config.urlType, node, msg),
         earlyMedia: config.early,
         loop: config.loop,
-        timeoutSecs: config.timeout ? new_resolve(RED, config.timeout, config.timeoutType, node, msg) : null,
-        seekOffset: config.offset ? new_resolve(RED, config.offset, config.offsetType, node, msg) : null,
-        actionHook: config.hook ? new_resolve(RED, config.hook, config.hookType, node, msg) : null
+        timeoutSecs: config.timeout ? await new_resolve(RED, config.timeout, config.timeoutType, node, msg) : null,
+        seekOffset: config.offset ? await new_resolve(RED, config.offset, config.offsetType, node, msg) : null,
+        actionHook: config.hook ? await new_resolve(RED, config.hook, config.hookType, node, msg) : null
       });
       node.send(msg);
     });

package/src/nodes/rasa.js

@@ -4,12 +4,12 @@ module.exports = function(RED) {
     function rasa(config) {
         RED.nodes.createNode(this, config);
         var node = this;
-        node.on('input', function(msg) {
+        node.on('input', async function(msg) {
           obj = {verb: 'rasa'}
-          obj.url = new_resolve(RED, config.url, config.urlType, node, msg);
-          obj.prompt = new_resolve(RED, config.prompt, config.promptType, node, msg);
-          obj.eventHook = new_resolve(RED, config.eventHook, config.eventHookType, node, msg);
-          obj.actionHook = new_resolve(RED, config.actionHook, config.actionHookType, node, msg);
+          obj.url = await new_resolve(RED, config.url, config.urlType, node, msg);
+          obj.prompt = await new_resolve(RED, config.prompt, config.promptType, node, msg);
+          obj.eventHook = await new_resolve(RED, config.eventHook, config.eventHookType, node, msg);
+          obj.actionHook = await new_resolve(RED, config.actionHook, config.actionHookType, node, msg);
           appendVerb(msg, obj);
           node.send(msg);
         });

package/src/nodes/redirect.js

@@ -5,8 +5,8 @@ module.exports = function(RED) {
   function redirect(config) {
     RED.nodes.createNode(this, config);
     var node = this;
-    node.on('input', function(msg, send, done) {
-      var actionHook = new_resolve(RED, config.hook, config.hookType, node, msg);
+    node.on('input', async function(msg, send, done) {
+      var actionHook = await new_resolve(RED, config.hook, config.hookType, node, msg);
       appendVerb(msg, {
         verb: 'redirect',
         actionHook

package/src/nodes/say.js

@@ -9,8 +9,8 @@ module.exports = function(RED) {
     this.loop = config.loop;
     var node = this;
 
-    node.on('input', function(msg) {
-      const text = new_resolve(RED, config.text, 'mustache', node, msg);
+    node.on('input', async function(msg) {
+      const text = await new_resolve(RED, config.text, 'mustache', node, msg);
       var obj = {
         verb: 'say',
         text,

package/src/nodes/sip-decline.js

@@ -5,15 +5,15 @@ module.exports = function(RED) {
   function sip_decline(config) {
     RED.nodes.createNode(this, config);
     var node = this;
-    node.on('input', function(msg) {
-      var status = new_resolve(RED, config.status, config.statusType, node, msg);
-      var reason = new_resolve(RED, config.reason, config.reasonType, node, msg);
+    node.on('input', async function(msg) {
+      var status = await new_resolve(RED, config.status, config.statusType, node, msg);
+      var reason = await new_resolve(RED, config.reason, config.reasonType, node, msg);
       var obj = {
         verb: 'sip:decline',
         status: parseInt(status),
         reason
       }
-      config.headers ? obj.headers = new_resolve(RED, config.headers, config.headersType, node, msg) : null
+      config.headers ? obj.headers = await new_resolve(RED, config.headers, config.headersType, node, msg) : null
       if (typeof obj.headers == 'string'){
         obj.headers = JSON.parse(obj.headers)
       }