@requesto/cli 1.8.1 → 1.10.0

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.8.1",
+  "version": "1.10.0",
   "description": "Run your Requesto collections from the terminal and CI pipelines",
   "type": "module",
   "main": "dist/index.mjs",
@@ -24,13 +24,13 @@
     "commander": "^15.0.0"
   },
   "devDependencies": {
-    "@types/node": "^26.4.0",
-    "esbuild": "^0.28.1",
-    "requesto-backend": "1.8.0",
-    "requesto-engine": "1.8.0",
-    "tsx": "^4.23.1",
+    "@types/node": "^26.4.1",
+    "esbuild": "^0.28.2",
+    "requesto-backend": "1.10.0",
+    "requesto-engine": "1.10.0",
+    "tsx": "^4.23.13",
     "typescript": "^7.0.2",
-    "vitest": "^4.1.10"
+    "vitest": "^5.0.0"
   },
   "publishConfig": {
     "access": "public"