serverless-offline 8.0.0 → 8.3.1

package/dist/events/http/authFunctionNameExtractor.js

@@ -10,12 +10,18 @@ var _serverlessLog2 = _interopRequireDefault(require("../../serverlessLog.js"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // FIXME "slessLog" param is only remaining for tests, should be removed
-function authFunctionNameExtractor(endpoint, slessLog) {
+function authFunctionNameExtractor(endpoint, slessLog, v3Utils) {
   const buildFailureResult = warningMessage => {
+    const log = v3Utils && v3Utils.log;
+
     const _serverlessLog = slessLog || _serverlessLog2.default; // FIXME remove
 
 
-    _serverlessLog(warningMessage);
+    if (log) {
+      log.warning(warningMessage);
+    } else {
+      _serverlessLog(`WARNING: ${warningMessage}`);
+    }
 
     return {
       unsupportedAuth: true
@@ -28,7 +34,7 @@ function authFunctionNameExtractor(endpoint, slessLog) {
 
   const handleStringAuthorizer = authorizerString => {
     if (authorizerString.toUpperCase() === 'AWS_IAM') {
-      return buildFailureResult('WARNING: Serverless Offline does not support the AWS_IAM authorization type');
+      return buildFailureResult('Serverless Offline does not support the AWS_IAM authorization type');
     }
 
     return buildSuccessResult(authorizerString);
@@ -43,19 +49,19 @@ function authFunctionNameExtractor(endpoint, slessLog) {
     } = authorizerObject;
 
     if (type && type.toUpperCase() === 'AWS_IAM') {
-      return buildFailureResult('WARNING: Serverless Offline does not support the AWS_IAM authorization type');
+      return buildFailureResult('Serverless Offline does not support the AWS_IAM authorization type');
     }
 
     if (arn) {
-      return buildFailureResult(`WARNING: Serverless Offline does not support non local authorizers (arn): ${arn}`);
+      return buildFailureResult(`Serverless Offline does not support non local authorizers (arn): ${arn}`);
     }
 
     if (authorizerId) {
-      return buildFailureResult(`WARNING: Serverless Offline does not support non local authorizers (authorizerId): ${authorizerId}`);
+      return buildFailureResult(`Serverless Offline does not support non local authorizers (authorizerId): ${authorizerId}`);
     }
 
     if (!name) {
-      return buildFailureResult('WARNING: Serverless Offline supports local authorizers but authorizer name is missing');
+      return buildFailureResult('Serverless Offline supports local authorizers but authorizer name is missing');
     }
 
     return buildSuccessResult(name);
@@ -77,5 +83,5 @@ function authFunctionNameExtractor(endpoint, slessLog) {
     return handleObjectAuthorizer(authorizer);
   }
 
-  return buildFailureResult('WARNING: Serverless Offline supports only local authorizers defined as string or object');
+  return buildFailureResult('Serverless Offline supports only local authorizers defined as string or object');
 }

package/dist/events/http/authJWTSettingsExtractor.js

@@ -9,9 +9,16 @@ var _serverlessLog = _interopRequireDefault(require("../../serverlessLog.js"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function authJWTSettingsExtractor(endpoint, provider, ignoreJWTSignature) {
+function authJWTSettingsExtractor(endpoint, provider, ignoreJWTSignature, {
+  log
+}) {
   const buildFailureResult = warningMessage => {
-    (0, _serverlessLog.default)(warningMessage);
+    if (log) {
+      log.warning(warningMessage);
+    } else {
+      (0, _serverlessLog.default)(`WARNING: ${warningMessage}`);
+    }
+
     return {
       unsupportedAuth: true
     };
@@ -39,25 +46,25 @@ function authJWTSettingsExtractor(endpoint, provider, ignoreJWTSignature) {
   }
 
   if (!authorizer.name) {
-    return buildFailureResult('WARNING: Serverless Offline supports only JWT authorizers referenced by name');
+    return buildFailureResult('Serverless Offline supports only JWT authorizers referenced by name');
   }
 
   const httpApiAuthorizer = provider.httpApi.authorizers[authorizer.name];
 
   if (!httpApiAuthorizer) {
-    return buildFailureResult(`WARNING: JWT authorizer ${authorizer.name} not found`);
+    return buildFailureResult(`JWT authorizer ${authorizer.name} not found`);
   }
 
   if (!httpApiAuthorizer.identitySource) {
-    return buildFailureResult(`WARNING: JWT authorizer ${authorizer.name} missing identity source`);
+    return buildFailureResult(`JWT authorizer ${authorizer.name} missing identity source`);
   }
 
   if (!httpApiAuthorizer.issuerUrl) {
-    return buildFailureResult(`WARNING: JWT authorizer ${authorizer.name} missing issuer url`);
+    return buildFailureResult(`JWT authorizer ${authorizer.name} missing issuer url`);
   }
 
   if (!httpApiAuthorizer.audience || httpApiAuthorizer.audience.length === 0) {
-    return buildFailureResult(`WARNING: JWT authorizer ${authorizer.name} missing audience`);
+    return buildFailureResult(`JWT authorizer ${authorizer.name} missing audience`);
   }
 
   const result = {

package/dist/events/http/createAuthScheme.js

@@ -17,7 +17,9 @@ var _index = require("../../utils/index.js");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function createAuthScheme(authorizerOptions, provider, lambda) {
+function createAuthScheme(authorizerOptions, provider, lambda, {
+  log
+}) {
   const authFunName = authorizerOptions.name;
   let identityHeader = 'authorization';
 
@@ -34,9 +36,15 @@ function createAuthScheme(authorizerOptions, provider, lambda) {
 
   return () => ({
     async authenticate(request, h) {
-      console.log(''); // Just to make things a little pretty
+      if (log) {
+        log.notice();
+        log.notice(`Running Authorization function for ${request.method} ${request.path} (λ: ${authFunName})`);
+      } else {
+        console.log(''); // Just to make things a little pretty
+
+        (0, _serverlessLog.default)(`Running Authorization function for ${request.method} ${request.path} (λ: ${authFunName})`);
+      } // Get Authorization header
 
-      (0, _serverlessLog.default)(`Running Authorization function for ${request.method} ${request.path} (λ: ${authFunName})`); // Get Authorization header
 
       const {
         req
@@ -87,7 +95,13 @@ function createAuthScheme(authorizerOptions, provider, lambda) {
         const identityValidationExpression = new RegExp(authorizerOptions.identityValidationExpression);
         const matchedAuthorization = identityValidationExpression.test(authorization);
         const finalAuthorization = matchedAuthorization ? authorization : '';
-        (0, _debugLog.default)(`Retrieved ${identityHeader} header "${finalAuthorization}"`);
+
+        if (log) {
+          log.debug(`Retrieved ${identityHeader} header "${finalAuthorization}"`);
+        } else {
+          (0, _debugLog.default)(`Retrieved ${identityHeader} header "${finalAuthorization}"`);
+        }
+
         event = { ...event,
           authorizationToken: finalAuthorization,
           type: 'TOKEN'
@@ -103,16 +117,31 @@ function createAuthScheme(authorizerOptions, provider, lambda) {
         const policy = result; // Validate that the policy document has the principalId set
 
         if (!policy.principalId) {
-          (0, _serverlessLog.default)(`Authorization response did not include a principalId: (λ: ${authFunName})`);
+          if (log) {
+            log.notice(`Authorization response did not include a principalId: (λ: ${authFunName})`);
+          } else {
+            (0, _serverlessLog.default)(`Authorization response did not include a principalId: (λ: ${authFunName})`);
+          }
+
           return _boom.default.forbidden('No principalId set on the Response');
         }
 
         if (!(0, _authCanExecuteResource.default)(policy.policyDocument, event.methodArn)) {
-          (0, _serverlessLog.default)(`Authorization response didn't authorize user to access resource: (λ: ${authFunName})`);
+          if (log) {
+            log.notice(`Authorization response didn't authorize user to access resource: (λ: ${authFunName})`);
+          } else {
+            (0, _serverlessLog.default)(`Authorization response didn't authorize user to access resource: (λ: ${authFunName})`);
+          }
+
           return _boom.default.forbidden('User is not authorized to access this resource');
         }
 
-        (0, _serverlessLog.default)(`Authorization function returned a successful response: (λ: ${authFunName})`);
+        if (log) {
+          log.notice(`Authorization function returned a successful response: (λ: ${authFunName})`);
+        } else {
+          (0, _serverlessLog.default)(`Authorization function returned a successful response: (λ: ${authFunName})`);
+        }
+
         const authorizer = {
           integrationLatency: '42',
           principalId: policy.principalId,
@@ -129,7 +158,12 @@ function createAuthScheme(authorizerOptions, provider, lambda) {
           }
         });
       } catch (err) {
-        (0, _serverlessLog.default)(`Authorization function returned an error response: (λ: ${authFunName})`);
+        if (log) {
+          log.notice(`Authorization function returned an error response: (λ: ${authFunName})`);
+        } else {
+          (0, _serverlessLog.default)(`Authorization function returned an error response: (λ: ${authFunName})`);
+        }
+
         return _boom.default.unauthorized('Unauthorized');
       }
     }

package/dist/events/http/createJWTAuthScheme.js

@@ -13,7 +13,9 @@ var _serverlessLog = _interopRequireDefault(require("../../serverlessLog.js"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function createAuthScheme(jwtOptions) {
+function createAuthScheme(jwtOptions, {
+  log
+}) {
   const authorizerName = jwtOptions.name;
   const identitySourceMatch = /^\$request.header.((?:\w+-?)+\w+)$/.exec(jwtOptions.identitySource);
 
@@ -25,12 +27,18 @@ function createAuthScheme(jwtOptions) {
 
   return () => ({
     async authenticate(request, h) {
-      console.log(''); // Just to make things a little pretty
-      // TODO: this only validates specific properties of the JWT
-      // it does not verify the JWT is correctly signed. That would
-      // be a great feature to add under an optional flag :)
+      if (log) {
+        log.notice();
+        log.notice(`Running JWT Authorization function for ${request.method} ${request.path} (${authorizerName})`);
+      } else {
+        console.log(''); // Just to make things a little pretty
+        // TODO: this only validates specific properties of the JWT
+        // it does not verify the JWT is correctly signed. That would
+        // be a great feature to add under an optional flag :)
+
+        (0, _serverlessLog.default)(`Running JWT Authorization function for ${request.method} ${request.path} (${authorizerName})`);
+      } // Get Authorization header
 
-      (0, _serverlessLog.default)(`Running JWT Authorization function for ${request.method} ${request.path} (${authorizerName})`); // Get Authorization header
 
       const {
         req
@@ -65,7 +73,12 @@ function createAuthScheme(jwtOptions) {
         const clientId = decoded.payload.client_id;
 
         if (iss !== jwtOptions.issuerUrl) {
-          (0, _serverlessLog.default)(`JWT Token not from correct issuer url`);
+          if (log) {
+            log.notice(`JWT Token not from correct issuer url`);
+          } else {
+            (0, _serverlessLog.default)(`JWT Token not from correct issuer url`);
+          }
+
           return _boom.default.unauthorized('JWT Token not from correct issuer url');
         }
 
@@ -74,7 +87,12 @@ function createAuthScheme(jwtOptions) {
         const validAudienceProvided = providedAudiences.some(a => validAudiences.includes(a));
 
         if (!validAudienceProvided && !validAudiences.includes(clientId)) {
-          (0, _serverlessLog.default)(`JWT Token does not contain correct audience`);
+          if (log) {
+            log.notice(`JWT Token does not contain correct audience`);
+          } else {
+            (0, _serverlessLog.default)(`JWT Token does not contain correct audience`);
+          }
+
           return _boom.default.unauthorized('JWT Token does not contain correct audience');
         }
 
@@ -82,7 +100,12 @@ function createAuthScheme(jwtOptions) {
 
         if (jwtOptions.scopes && jwtOptions.scopes.length) {
           if (!scope) {
-            (0, _serverlessLog.default)(`JWT Token missing valid scope`);
+            if (log) {
+              log.notice(`JWT Token missing valid scope`);
+            } else {
+              (0, _serverlessLog.default)(`JWT Token missing valid scope`);
+            }
+
             return _boom.default.forbidden('JWT Token missing valid scope');
           }
 
@@ -91,14 +114,24 @@ function createAuthScheme(jwtOptions) {
           if (scopes.every(s => {
             return !jwtOptions.scopes.includes(s);
           })) {
-            (0, _serverlessLog.default)(`JWT Token missing valid scope`);
+            if (log) {
+              log.notice(`JWT Token missing valid scope`);
+            } else {
+              (0, _serverlessLog.default)(`JWT Token missing valid scope`);
+            }
+
             return _boom.default.forbidden('JWT Token missing valid scope');
           }
         }
 
-        (0, _serverlessLog.default)(`JWT Token validated`); // Set the credentials for the rest of the pipeline
+        if (log) {
+          log.notice(`JWT Token validated`);
+        } else {
+          (0, _serverlessLog.default)(`JWT Token validated`);
+        } // Set the credentials for the rest of the pipeline
         // return resolve(
 
+
         return h.authenticated({
           credentials: {
             claims: decoded.payload,
@@ -106,8 +139,14 @@ function createAuthScheme(jwtOptions) {
           }
         });
       } catch (err) {
-        (0, _serverlessLog.default)(`JWT could not be decoded`);
-        (0, _serverlessLog.default)(err);
+        if (log) {
+          log.notice(`JWT could not be decoded`);
+          log.error(err);
+        } else {
+          (0, _serverlessLog.default)(`JWT could not be decoded`);
+          (0, _serverlessLog.default)(err);
+        }
+
         return _boom.default.unauthorized('Unauthorized');
       }
     }

package/dist/events/http/lambda-events/LambdaIntegrationEvent.js

@@ -17,16 +17,16 @@ var id = 0;
 
 function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
 
-var _path = _classPrivateFieldLooseKey("path");
+var _path = /*#__PURE__*/_classPrivateFieldLooseKey("path");
 
-var _request = _classPrivateFieldLooseKey("request");
+var _request = /*#__PURE__*/_classPrivateFieldLooseKey("request");
 
-var _requestTemplate = _classPrivateFieldLooseKey("requestTemplate");
+var _requestTemplate = /*#__PURE__*/_classPrivateFieldLooseKey("requestTemplate");
 
-var _stage = _classPrivateFieldLooseKey("stage");
+var _stage = /*#__PURE__*/_classPrivateFieldLooseKey("stage");
 
 class LambdaIntegrationEvent {
-  constructor(request, stage, requestTemplate, path) {
+  constructor(request, stage, requestTemplate, path, v3Utils) {
     Object.defineProperty(this, _path, {
       writable: true,
       value: null
@@ -47,11 +47,12 @@ class LambdaIntegrationEvent {
     _classPrivateFieldLooseBase(this, _request)[_request] = request;
     _classPrivateFieldLooseBase(this, _requestTemplate)[_requestTemplate] = requestTemplate;
     _classPrivateFieldLooseBase(this, _stage)[_stage] = stage;
+    this.v3Utils = v3Utils;
   }
 
   create() {
     const velocityContext = new _VelocityContext.default(_classPrivateFieldLooseBase(this, _request)[_request], _classPrivateFieldLooseBase(this, _stage)[_stage], _classPrivateFieldLooseBase(this, _request)[_request].payload || {}, _classPrivateFieldLooseBase(this, _path)[_path]).getContext();
-    const event = (0, _renderVelocityTemplateObject.default)(_classPrivateFieldLooseBase(this, _requestTemplate)[_requestTemplate], velocityContext);
+    const event = (0, _renderVelocityTemplateObject.default)(_classPrivateFieldLooseBase(this, _requestTemplate)[_requestTemplate], velocityContext, this.v3Utils);
     return event;
   }
 

package/dist/events/http/lambda-events/LambdaProxyIntegrationEvent.js

@@ -29,18 +29,18 @@ const {
 // https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html
 // http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-create-api-as-simple-proxy-for-lambda.html
 
-var _path = _classPrivateFieldLooseKey("path");
+var _path = /*#__PURE__*/_classPrivateFieldLooseKey("path");
 
-var _routeKey = _classPrivateFieldLooseKey("routeKey");
+var _routeKey = /*#__PURE__*/_classPrivateFieldLooseKey("routeKey");
 
-var _request = _classPrivateFieldLooseKey("request");
+var _request = /*#__PURE__*/_classPrivateFieldLooseKey("request");
 
-var _stage = _classPrivateFieldLooseKey("stage");
+var _stage = /*#__PURE__*/_classPrivateFieldLooseKey("stage");
 
-var _stageVariables = _classPrivateFieldLooseKey("stageVariables");
+var _stageVariables = /*#__PURE__*/_classPrivateFieldLooseKey("stageVariables");
 
 class LambdaProxyIntegrationEvent {
-  constructor(request, stage, path, stageVariables, routeKey = null) {
+  constructor(request, stage, path, stageVariables, routeKey = null, v3Utils) {
     Object.defineProperty(this, _path, {
       writable: true,
       value: null
@@ -66,6 +66,13 @@ class LambdaProxyIntegrationEvent {
     _classPrivateFieldLooseBase(this, _request)[_request] = request;
     _classPrivateFieldLooseBase(this, _stage)[_stage] = stage;
     _classPrivateFieldLooseBase(this, _stageVariables)[_stageVariables] = stageVariables;
+
+    if (v3Utils) {
+      this.log = v3Utils.log;
+      this.progress = v3Utils.progress;
+      this.writeText = v3Utils.writeText;
+      this.v3Utils = v3Utils;
+    }
   }
 
   create() {
@@ -78,7 +85,11 @@ class LambdaProxyIntegrationEvent {
       try {
         authAuthorizer = parse(process.env.AUTHORIZER);
       } catch (error) {
-        console.error('Serverless-offline: Could not parse process.env.AUTHORIZER, make sure it is correct JSON.');
+        if (this.log) {
+          this.log.error('Could not parse process.env.AUTHORIZER, make sure it is correct JSON');
+        } else {
+          console.error('Serverless-offline: Could not parse process.env.AUTHORIZER, make sure it is correct JSON.');
+        }
       }
     }
 

package/dist/events/http/lambda-events/LambdaProxyIntegrationEventV2.js

@@ -28,16 +28,16 @@ const {
 } = Object; // https://www.serverless.com/framework/docs/providers/aws/events/http-api/
 // https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
 
-var _routeKey = _classPrivateFieldLooseKey("routeKey");
+var _routeKey = /*#__PURE__*/_classPrivateFieldLooseKey("routeKey");
 
-var _request = _classPrivateFieldLooseKey("request");
+var _request = /*#__PURE__*/_classPrivateFieldLooseKey("request");
 
-var _stage = _classPrivateFieldLooseKey("stage");
+var _stage = /*#__PURE__*/_classPrivateFieldLooseKey("stage");
 
-var _stageVariables = _classPrivateFieldLooseKey("stageVariables");
+var _stageVariables = /*#__PURE__*/_classPrivateFieldLooseKey("stageVariables");
 
 class LambdaProxyIntegrationEventV2 {
-  constructor(request, stage, routeKey, stageVariables) {
+  constructor(request, stage, routeKey, stageVariables, v3Utils) {
     Object.defineProperty(this, _routeKey, {
       writable: true,
       value: null
@@ -58,6 +58,13 @@ class LambdaProxyIntegrationEventV2 {
     _classPrivateFieldLooseBase(this, _request)[_request] = request;
     _classPrivateFieldLooseBase(this, _stage)[_stage] = stage;
     _classPrivateFieldLooseBase(this, _stageVariables)[_stageVariables] = stageVariables;
+
+    if (v3Utils) {
+      this.log = v3Utils.log;
+      this.progress = v3Utils.progress;
+      this.writeText = v3Utils.writeText;
+      this.v3Utils = v3Utils;
+    }
   }
 
   create() {
@@ -68,7 +75,11 @@ class LambdaProxyIntegrationEventV2 {
       try {
         authAuthorizer = parse(process.env.AUTHORIZER);
       } catch (error) {
-        console.error('Serverless-offline: Could not parse process.env.AUTHORIZER, make sure it is correct JSON.');
+        if (this.log) {
+          this.log.error('Could not parse process.env.AUTHORIZER, make sure it is correct JSON');
+        } else {
+          console.error('Serverless-offline: Could not parse process.env.AUTHORIZER, make sure it is correct JSON.');
+        }
       }
     }
 

package/dist/events/http/lambda-events/VelocityContext.js

@@ -53,13 +53,13 @@ function escapeJavaScript(x) {
 */
 
 
-var _path = _classPrivateFieldLooseKey("path");
+var _path = /*#__PURE__*/_classPrivateFieldLooseKey("path");
 
-var _payload = _classPrivateFieldLooseKey("payload");
+var _payload = /*#__PURE__*/_classPrivateFieldLooseKey("payload");
 
-var _request = _classPrivateFieldLooseKey("request");
+var _request = /*#__PURE__*/_classPrivateFieldLooseKey("request");
 
-var _stage = _classPrivateFieldLooseKey("stage");
+var _stage = /*#__PURE__*/_classPrivateFieldLooseKey("stage");
 
 class VelocityContext {
   constructor(request, stage, payload, path) {

package/dist/events/http/lambda-events/index.js

@@ -15,16 +15,16 @@ Object.defineProperty(exports, "LambdaProxyIntegrationEvent", {
     return _LambdaProxyIntegrationEvent.default;
   }
 });
-Object.defineProperty(exports, "renderVelocityTemplateObject", {
+Object.defineProperty(exports, "VelocityContext", {
   enumerable: true,
   get: function () {
-    return _renderVelocityTemplateObject.default;
+    return _VelocityContext.default;
   }
 });
-Object.defineProperty(exports, "VelocityContext", {
+Object.defineProperty(exports, "renderVelocityTemplateObject", {
   enumerable: true,
   get: function () {
-    return _VelocityContext.default;
+    return _renderVelocityTemplateObject.default;
   }
 });
 

package/dist/events/http/lambda-events/renderVelocityTemplateObject.js

@@ -30,8 +30,9 @@ function tryToParseJSON(string) {
   return parsed || string;
 }
 
-function renderVelocityString(velocityString, context) {
-  // runs in a "polluted" (extended) String.prototype replacement scope
+function renderVelocityString(velocityString, context, v3Utils) {
+  const log = v3Utils && v3Utils.log; // runs in a "polluted" (extended) String.prototype replacement scope
+
   const renderResult = (0, _javaHelpers.default)(() => // This line can throw, but this function does not handle errors
   // Quick args explanation:
   // { escape: false } --> otherwise would escape &, < and > chars with html (&amp;, &lt; and &gt;)
@@ -39,7 +40,13 @@ function renderVelocityString(velocityString, context) {
   new _velocityjs.Compile((0, _velocityjs.parse)(velocityString), {
     escape: false
   }).render(context, null, true));
-  (0, _debugLog.default)('Velocity rendered:', renderResult || 'undefined'); // Haaaa Velocity... this language sure loves strings a lot
+
+  if (log) {
+    log.debug('Velocity rendered:', renderResult || 'undefined');
+  } else {
+    (0, _debugLog.default)('Velocity rendered:', renderResult || 'undefined');
+  } // Haaaa Velocity... this language sure loves strings a lot
+
 
   switch (renderResult) {
     case 'undefined':
@@ -65,8 +72,9 @@ function renderVelocityString(velocityString, context) {
 */
 
 
-function renderVelocityTemplateObject(templateObject, context) {
+function renderVelocityTemplateObject(templateObject, context, v3Utils) {
   const result = {};
+  const log = v3Utils && v3Utils.log;
   let toProcess = templateObject; // In some projects, the template object is a string, let us see if it's JSON
 
   if (typeof toProcess === 'string') {
@@ -76,10 +84,14 @@ function renderVelocityTemplateObject(templateObject, context) {
 
   if ((0, _index.isPlainObject)(toProcess)) {
     entries(toProcess).forEach(([key, value]) => {
-      (0, _debugLog.default)('Processing key:', key, '- value:', value);
+      if (log) {
+        log.debug('Processing key:', key, '- value:', value);
+      } else {
+        (0, _debugLog.default)('Processing key:', key, '- value:', value);
+      }
 
       if (typeof value === 'string') {
-        result[key] = renderVelocityString(value, context); // Go deeper
+        result[key] = renderVelocityString(value, context, v3Utils); // Go deeper
       } else if ((0, _index.isPlainObject)(value)) {
         result[key] = renderVelocityTemplateObject(value, context); // This should never happen: value should either be a string or a plain object
       } else {
@@ -88,7 +100,7 @@ function renderVelocityTemplateObject(templateObject, context) {
     }); // Still a string? Maybe it's some complex Velocity stuff
   } else if (typeof toProcess === 'string') {
     // If the plugin threw here then you should consider reviewing your template or posting an issue.
-    const alternativeResult = tryToParseJSON(renderVelocityString(toProcess, context));
+    const alternativeResult = tryToParseJSON(renderVelocityString(toProcess, context, v3Utils));
     return (0, _index.isPlainObject)(alternativeResult) ? alternativeResult : result;
   }