@requesto/cli 1.9.0 → 1.10.1

package/dist/index.mjs

@@ -56,6 +56,9 @@ var require_variable_substitution = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.substituteVariables = substituteVariables;
+    exports.substituteJsonVariables = substituteJsonVariables;
+    exports.isNumericLiteral = isNumericLiteral2;
+    exports.inferType = inferType3;
     exports.substituteInRequest = substituteInRequest2;
     exports.substituteInAuth = substituteInAuth2;
     function substituteVariables(text, environment) {
@@ -63,17 +66,44 @@ var require_variable_substitution = __commonJS({
         return text;
       const values = getResolvedValues(environment);
       let result = text;
-      for (const [key, value] of values) {
+      for (const [key, entry] of values) {
         const pattern = new RegExp(`{{\\s*${escapeRegex(key)}\\s*}}`, "g");
-        result = result.replace(pattern, value);
+        result = result.replace(pattern, entry.value);
       }
       return result;
     }
+    function substituteJsonVariables(text, environment) {
+      if (!environment)
+        return text;
+      const values = getResolvedValues(environment);
+      let result = text;
+      for (const [key, entry] of values) {
+        const keyPattern = escapeRegex(key);
+        const quoted = new RegExp(`"{{\\s*${keyPattern}\\s*}}"`, "g");
+        const literal = typedJsonLiteral(entry.value, entry.type);
+        result = result.replace(quoted, literal ?? JSON.stringify(entry.value));
+        const plain = new RegExp(`{{\\s*${keyPattern}\\s*}}`, "g");
+        result = result.replace(plain, entry.value);
+      }
+      return result;
+    }
+    function typedJsonLiteral(value, type2) {
+      if (type2 === "boolean") {
+        return value === "true" || value === "false" ? value : null;
+      }
+      if (type2 === "number") {
+        return isNumericLiteral2(value) ? value : null;
+      }
+      return null;
+    }
     function getResolvedValues(environment) {
       const raw = /* @__PURE__ */ new Map();
       for (const variable of environment.variables) {
         if (variable.enabled) {
-          raw.set(variable.key, variable.currentValue ?? variable.value);
+          raw.set(variable.key, {
+            value: variable.currentValue ?? variable.value,
+            type: variable.type
+          });
         }
       }
       const resolved = /* @__PURE__ */ new Map();
@@ -82,33 +112,55 @@ var require_variable_substitution = __commonJS({
         const memo = resolved.get(key);
         if (memo !== void 0)
           return memo;
-        if (visiting.has(key))
-          return raw.get(key) ?? "";
+        if (visiting.has(key)) {
+          const entry2 = raw.get(key);
+          return { value: entry2?.value ?? "", type: entry2?.type };
+        }
         visiting.add(key);
-        const rawValue = raw.get(key) ?? "";
-        const value = rawValue.replace(/\{\{\s*([^{}]+?)\s*\}\}/g, (match, name) => {
+        const entry = raw.get(key) ?? { value: "", type: void 0 };
+        const value = entry.value.replace(/\{\{\s*([^{}]+?)\s*\}\}/g, (match, name) => {
           const referenced = name.trim();
-          return raw.has(referenced) ? resolve3(referenced) : match;
+          return raw.has(referenced) ? resolve3(referenced).value : match;
         });
         visiting.delete(key);
-        resolved.set(key, value);
-        return value;
+        const result = { value, type: entry.type };
+        resolved.set(key, result);
+        return result;
       };
       for (const key of raw.keys())
         resolve3(key);
       return resolved;
     }
+    function isNumericLiteral2(value) {
+      return /^-?(0|[1-9]\d*)(\.\d+)?([eE][+-]?\d+)?$/.test(value.trim());
+    }
+    function inferType3(value) {
+      if (typeof value === "number") {
+        return Number.isFinite(value) ? "number" : "string";
+      }
+      if (typeof value === "boolean")
+        return "boolean";
+      if (typeof value === "string") {
+        if (value === "true" || value === "false")
+          return "boolean";
+        if (isNumericLiteral2(value))
+          return "number";
+      }
+      return "string";
+    }
     function escapeRegex(str2) {
       return str2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     }
     function substituteInRequest2(request, environment) {
+      const jsonMode = request.bodyType === "json" || !request.bodyType && !!request.body;
+      const bodySub = jsonMode ? substituteJsonVariables : substituteVariables;
       return {
-        url: substituteVariables(request.url, environment),
+        url: substituteUrlVariables(request.url, environment),
         headers: request.headers ? Object.fromEntries(Object.entries(request.headers).map(([key, value]) => [
           key,
           substituteVariables(value, environment)
         ])) : void 0,
-        body: request.body ? substituteVariables(request.body, environment) : void 0,
+        body: request.body ? bodySub(request.body, environment) : void 0,
         formDataEntries: request.formDataEntries ? request.formDataEntries.map((entry) => ({
           ...entry,
           key: substituteVariables(entry.key, environment),
@@ -116,6 +168,21 @@ var require_variable_substitution = __commonJS({
         })) : void 0
       };
     }
+    function substituteUrlVariables(url, environment) {
+      const substituted = substituteVariables(url, environment);
+      if (!environment || !substituted.includes("="))
+        return substituted;
+      try {
+        const parsed = new URL(substituted);
+        const variables = parsed.searchParams.get("variables");
+        if (variables && variables.includes("{{")) {
+          parsed.searchParams.set("variables", substituteJsonVariables(variables, environment));
+          return parsed.toString();
+        }
+      } catch {
+      }
+      return substituted;
+    }
     function substituteInAuth2(auth, environment) {
       if (!auth)
         return auth;
@@ -101351,7 +101418,7 @@ var require_proxy_service = __commonJS({
         const { method, url, headers, body, bodyType, formDataEntries, auth, insecureTls } = req;
         const hasEnvOverride = Object.prototype.hasOwnProperty.call(opts, "environment");
         const effectiveEnv = hasEnvOverride ? opts.environment ?? null : this.environmentService.getActive();
-        const substituted = (0, variable_substitution_1.substituteInRequest)({ url, headers, body, formDataEntries }, effectiveEnv);
+        const substituted = (0, variable_substitution_1.substituteInRequest)({ url, headers, body, bodyType, formDataEntries }, effectiveEnv);
         const substitutedAuth = (0, variable_substitution_1.substituteInAuth)(auth, effectiveEnv);
         if (!isValidUrl(substituted.url)) {
           throw new Error(`Invalid URL format: ${substituted.url}`);
@@ -101426,7 +101493,7 @@ var require_proxy_service = __commonJS({
         if (!isValidUrl(url)) {
           throw new Error("Invalid URL format");
         }
-        const substituted = this.environmentService.substituteInRequest({ url, headers, body, formDataEntries });
+        const substituted = this.environmentService.substituteInRequest({ url, headers, body, bodyType, formDataEntries });
         const substitutedAuth = this.environmentService.substituteInAuth(auth);
         const authenticated = await (0, auth_1.applyAuthentication)(substitutedAuth, substituted.headers, substituted.url, this.oauthResolver);
         const built = buildBodyAndHeaders({
@@ -116576,16 +116643,21 @@ function requireLoader() {
       state.result += _result;
     }
   }
+  function chargeMergeWork(state) {
+    state.totalMergeKeys++;
+    if (state.maxTotalMergeKeys !== -1 && state.totalMergeKeys > state.maxTotalMergeKeys) {
+      throwError(state, "merge keys exceeded maxTotalMergeKeys (" + state.maxTotalMergeKeys + ")");
+    }
+  }
   function mergeMappings(state, destination, source, overridableKeys) {
     if (!common2.isObject(source)) {
       throwError(state, "cannot merge mappings; the provided source object is unacceptable");
     }
+    chargeMergeWork(state);
     const sourceKeys = Object.keys(source);
     for (let index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
       const key = sourceKeys[index];
-      if (state.maxTotalMergeKeys !== -1 && ++state.totalMergeKeys > state.maxTotalMergeKeys) {
-        throwError(state, "merge keys exceeded maxTotalMergeKeys (" + state.maxTotalMergeKeys + ")");
-      }
+      chargeMergeWork(state);
       if (!_hasOwnProperty.call(destination, key)) {
         setProperty(destination, key, source[key]);
         overridableKeys[key] = true;
@@ -116613,6 +116685,9 @@ function requireLoader() {
     }
     if (keyTag === "tag:yaml.org,2002:merge") {
       if (Array.isArray(valueNode)) {
+        if (valueNode.length > 100) {
+          throwError(state, "abnormal merge sequence size");
+        }
         for (let index = 0, quantity = valueNode.length; index < quantity; index += 1) {
           mergeMappings(state, _result, valueNode[index], overridableKeys);
         }
@@ -131271,12 +131346,13 @@ function isExcluded(collection, selectors) {
   return lower2.includes(collection.name.toLowerCase()) || lower2.includes(collection.id.toLowerCase());
 }
 function applyEnvOverrides(env2, overrides) {
-  if (!env2 || Object.keys(overrides).length === 0)
+  const { envOverrides, envTypes } = overrides;
+  if (!env2 || Object.keys(envOverrides).length === 0)
     return env2;
-  const variables = env2.variables.map((v) => Object.prototype.hasOwnProperty.call(overrides, v.key) ? { ...v, currentValue: overrides[v.key] } : v);
-  for (const [key, value] of Object.entries(overrides)) {
+  const variables = env2.variables.map((v) => Object.prototype.hasOwnProperty.call(envOverrides, v.key) ? { ...v, currentValue: envOverrides[v.key], type: envTypes?.[v.key] ?? v.type } : v);
+  for (const [key, value] of Object.entries(envOverrides)) {
     if (!variables.some((v) => v.key === key)) {
-      variables.push({ key, value, currentValue: value, enabled: true });
+      variables.push({ key, value, currentValue: value, enabled: true, type: envTypes?.[key] ?? "string" });
     }
   }
   return { ...env2, variables };
@@ -131335,6 +131411,7 @@ async function runCollections(opts) {
           url: proxyReq.url,
           headers: proxyReq.headers,
           body: proxyReq.body,
+          bodyType: proxyReq.bodyType,
           formDataEntries: proxyReq.formDataEntries
         }, liveEnv);
         const auth = (0, import_variable_substitution.substituteInAuth)(proxyReq.auth, liveEnv);
@@ -131354,7 +131431,7 @@ async function runCollections(opts) {
             duration: response.duration
           }, { method: proxyReq.method, url: proxyReq.url, headers: proxyReq.headers, body: proxyReq.body }, envRecord(liveEnv));
           testResults = outcome.testResults;
-          liveEnv = applyEnvOverrides(liveEnv, outcome.envOverrides);
+          liveEnv = applyEnvOverrides(liveEnv, outcome);
         }
         const allPassed = testResults.every((t2) => t2.passed);
         const status = allPassed ? "passed" : "failed";
@@ -131394,6 +131471,9 @@ async function runCollections(opts) {
   };
 }
 
+// ../../packages/engine/dist/scripts/sandbox-core.js
+var import_variable_substitution2 = __toESM(require_variable_substitution(), 1);
+
 // ../../packages/engine/dist/scripts/node-scripts.js
 import { Worker } from "node:worker_threads";
 import fs2 from "node:fs";
@@ -131435,7 +131515,7 @@ function runInWorker(message) {
 }
 async function runPreRequestScript(script, env2, request) {
   if (!script.trim())
-    return {};
+    return { envOverrides: {}, envTypes: {} };
   const result = await runInWorker({
     type: "pre-request",
     script,
@@ -131444,12 +131524,12 @@ async function runPreRequestScript(script, env2, request) {
   if ("error" in result)
     throw new Error(result.error);
   if ("envOverrides" in result)
-    return result.envOverrides;
-  return {};
+    return { envOverrides: result.envOverrides, envTypes: result.envTypes };
+  return { envOverrides: {}, envTypes: {} };
 }
 async function runTestScript(script, response, request, env2) {
   if (!script.trim())
-    return { testResults: [], envOverrides: {} };
+    return { testResults: [], envOverrides: {}, envTypes: {} };
   const result = await runInWorker({
     type: "test",
     script,
@@ -131457,15 +131537,19 @@ async function runTestScript(script, response, request, env2) {
   });
   if ("error" in result)
     throw new Error(result.error);
-  if ("testResults" in result)
-    return { testResults: result.testResults, envOverrides: result.envOverrides };
-  return { testResults: [], envOverrides: {} };
+  if ("testResults" in result) {
+    return { testResults: result.testResults, envOverrides: result.envOverrides, envTypes: result.envTypes ?? {} };
+  }
+  return { testResults: [], envOverrides: {}, envTypes: {} };
 }
 var nodeScriptRunner = {
   runPreRequest: (script, env2, request) => runPreRequestScript(script, env2, request),
   runTest: (script, response, request, env2) => runTestScript(script, response, request, env2)
 };
 
+// ../../packages/engine/dist/index.js
+var import_variable_substitution3 = __toESM(require_variable_substitution(), 1);
+
 // ../../packages/engine/dist/isolation/scratch-workspace.js
 var IsolationHttpError = class extends Error {
   status;
@@ -131678,18 +131762,18 @@ function applyVarOverrides(env2, overrides) {
   const variables = base.variables.map((v) => {
     if (overrides.has(v.key)) {
       used.add(v.key);
-      return { ...v, currentValue: overrides.get(v.key) };
+      return { ...v, currentValue: overrides.get(v.key), type: (0, import_variable_substitution3.inferType)(overrides.get(v.key)) };
     }
     const normalisedMatch = [...normalised.entries()].find(([key]) => normalizeKey(v.key) === key);
     if (normalisedMatch) {
       used.add(normalisedMatch[0]);
-      return { ...v, currentValue: normalisedMatch[1] };
+      return { ...v, currentValue: normalisedMatch[1], type: (0, import_variable_substitution3.inferType)(normalisedMatch[1]) };
     }
     return v;
   });
   for (const [key, value] of overrides) {
     if (used.has(key) || used.has(normalizeKey(key))) continue;
-    variables.push({ key, value, currentValue: value, enabled: true });
+    variables.push({ key, value, currentValue: value, enabled: true, type: (0, import_variable_substitution3.inferType)(value) });
   }
   return { ...base, variables };
 }

package/dist/sandbox-worker.js

@@ -1,7 +1,193 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../backend/dist/utils/variable-substitution.js
+var require_variable_substitution = __commonJS({
+  "../backend/dist/utils/variable-substitution.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.substituteVariables = substituteVariables;
+    exports.substituteJsonVariables = substituteJsonVariables;
+    exports.isNumericLiteral = isNumericLiteral;
+    exports.inferType = inferType2;
+    exports.substituteInRequest = substituteInRequest;
+    exports.substituteInAuth = substituteInAuth;
+    function substituteVariables(text, environment) {
+      if (!environment)
+        return text;
+      const values = getResolvedValues(environment);
+      let result = text;
+      for (const [key, entry] of values) {
+        const pattern = new RegExp(`{{\\s*${escapeRegex(key)}\\s*}}`, "g");
+        result = result.replace(pattern, entry.value);
+      }
+      return result;
+    }
+    function substituteJsonVariables(text, environment) {
+      if (!environment)
+        return text;
+      const values = getResolvedValues(environment);
+      let result = text;
+      for (const [key, entry] of values) {
+        const keyPattern = escapeRegex(key);
+        const quoted = new RegExp(`"{{\\s*${keyPattern}\\s*}}"`, "g");
+        const literal = typedJsonLiteral(entry.value, entry.type);
+        result = result.replace(quoted, literal ?? JSON.stringify(entry.value));
+        const plain = new RegExp(`{{\\s*${keyPattern}\\s*}}`, "g");
+        result = result.replace(plain, entry.value);
+      }
+      return result;
+    }
+    function typedJsonLiteral(value, type) {
+      if (type === "boolean") {
+        return value === "true" || value === "false" ? value : null;
+      }
+      if (type === "number") {
+        return isNumericLiteral(value) ? value : null;
+      }
+      return null;
+    }
+    function getResolvedValues(environment) {
+      const raw = /* @__PURE__ */ new Map();
+      for (const variable of environment.variables) {
+        if (variable.enabled) {
+          raw.set(variable.key, {
+            value: variable.currentValue ?? variable.value,
+            type: variable.type
+          });
+        }
+      }
+      const resolved = /* @__PURE__ */ new Map();
+      const visiting = /* @__PURE__ */ new Set();
+      const resolve = (key) => {
+        const memo = resolved.get(key);
+        if (memo !== void 0)
+          return memo;
+        if (visiting.has(key)) {
+          const entry2 = raw.get(key);
+          return { value: entry2?.value ?? "", type: entry2?.type };
+        }
+        visiting.add(key);
+        const entry = raw.get(key) ?? { value: "", type: void 0 };
+        const value = entry.value.replace(/\{\{\s*([^{}]+?)\s*\}\}/g, (match, name) => {
+          const referenced = name.trim();
+          return raw.has(referenced) ? resolve(referenced).value : match;
+        });
+        visiting.delete(key);
+        const result = { value, type: entry.type };
+        resolved.set(key, result);
+        return result;
+      };
+      for (const key of raw.keys())
+        resolve(key);
+      return resolved;
+    }
+    function isNumericLiteral(value) {
+      return /^-?(0|[1-9]\d*)(\.\d+)?([eE][+-]?\d+)?$/.test(value.trim());
+    }
+    function inferType2(value) {
+      if (typeof value === "number") {
+        return Number.isFinite(value) ? "number" : "string";
+      }
+      if (typeof value === "boolean")
+        return "boolean";
+      if (typeof value === "string") {
+        if (value === "true" || value === "false")
+          return "boolean";
+        if (isNumericLiteral(value))
+          return "number";
+      }
+      return "string";
+    }
+    function escapeRegex(str) {
+      return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    function substituteInRequest(request, environment) {
+      const jsonMode = request.bodyType === "json" || !request.bodyType && !!request.body;
+      const bodySub = jsonMode ? substituteJsonVariables : substituteVariables;
+      return {
+        url: substituteUrlVariables(request.url, environment),
+        headers: request.headers ? Object.fromEntries(Object.entries(request.headers).map(([key, value]) => [
+          key,
+          substituteVariables(value, environment)
+        ])) : void 0,
+        body: request.body ? bodySub(request.body, environment) : void 0,
+        formDataEntries: request.formDataEntries ? request.formDataEntries.map((entry) => ({
+          ...entry,
+          key: substituteVariables(entry.key, environment),
+          value: entry.type === "text" ? substituteVariables(entry.value, environment) : entry.value
+        })) : void 0
+      };
+    }
+    function substituteUrlVariables(url, environment) {
+      const substituted = substituteVariables(url, environment);
+      if (!environment || !substituted.includes("="))
+        return substituted;
+      try {
+        const parsed = new URL(substituted);
+        const variables = parsed.searchParams.get("variables");
+        if (variables && variables.includes("{{")) {
+          parsed.searchParams.set("variables", substituteJsonVariables(variables, environment));
+          return parsed.toString();
+        }
+      } catch {
+      }
+      return substituted;
+    }
+    function substituteInAuth(auth, environment) {
+      if (!auth)
+        return auth;
+      const sub = (v) => substituteVariables(v, environment);
+      switch (auth.type) {
+        case "basic":
+          return auth.basic ? { ...auth, basic: { username: sub(auth.basic.username), password: sub(auth.basic.password) } } : auth;
+        case "bearer":
+          return auth.bearer ? { ...auth, bearer: { token: sub(auth.bearer.token) } } : auth;
+        case "api-key":
+          return auth.apiKey ? { ...auth, apiKey: { ...auth.apiKey, key: sub(auth.apiKey.key), value: sub(auth.apiKey.value) } } : auth;
+        case "digest":
+          return auth.digest ? { ...auth, digest: { username: sub(auth.digest.username), password: sub(auth.digest.password) } } : auth;
+        case "oauth":
+        case "none":
+        default:
+          return auth;
+      }
+    }
+  }
+});
+
 // ../../packages/engine/dist/scripts/sandbox-worker.js
 import { parentPort } from "node:worker_threads";
 
 // ../../packages/engine/dist/scripts/sandbox-core.js
+var import_variable_substitution = __toESM(require_variable_substitution(), 1);
 var SHADOWED_GLOBALS = `
 "use strict";
 const self = undefined;
@@ -58,28 +244,31 @@ function createExpect(actual, inverted = false) {
 }
 function createEnvironment(env) {
   const envStore = { ...env };
+  const typeStore = {};
   return {
     store: envStore,
+    types: typeStore,
     api: {
       get: (key) => envStore[key] ?? "",
       set: (key, value) => {
         envStore[key] = String(value);
+        typeStore[key] = (0, import_variable_substitution.inferType)(value);
       }
     }
   };
 }
 function executePreRequestScript(script, context) {
-  const { store, api } = createEnvironment(context.env);
+  const { store, types, api } = createEnvironment(context.env);
   const request = { ...context.request };
   const fn = new Function("environment", "request", `${SHADOWED_GLOBALS}
 ${script}`);
   fn(api, request);
-  return { envOverrides: store };
+  return { envOverrides: store, envTypes: types };
 }
 function executeTestScript(script, context) {
   const results = [];
   const { response: responseCtx, request } = context;
-  const { store, api } = createEnvironment(context.env);
+  const { store, types, api } = createEnvironment(context.env);
   const response = {
     status: responseCtx.status,
     statusText: responseCtx.statusText,
@@ -104,7 +293,7 @@ function executeTestScript(script, context) {
   const fn = new Function("test", "expect", "response", "request", "environment", `${SHADOWED_GLOBALS}
 ${script}`);
   fn(test, expect, response, request, api);
-  return { testResults: results, envOverrides: store };
+  return { testResults: results, envOverrides: store, envTypes: types };
 }
 
 // ../../packages/engine/dist/scripts/sandbox-worker.js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@requesto/cli",
-  "version": "1.9.0",
+  "version": "1.10.1",
   "description": "Run your Requesto collections from the terminal and CI pipelines",
   "type": "module",
   "main": "dist/index.mjs",
@@ -26,8 +26,8 @@
   "devDependencies": {
     "@types/node": "^26.4.1",
     "esbuild": "^0.28.2",
-    "requesto-backend": "1.9.0",
-    "requesto-engine": "1.9.0",
+    "requesto-backend": "1.10.1",
+    "requesto-engine": "1.10.1",
     "tsx": "^4.23.13",
     "typescript": "^7.0.2",
     "vitest": "^5.0.0"