@requesto/cli 1.8.0

package/dist/sandbox-worker.js

@@ -0,0 +1,121 @@
+// ../../packages/engine/dist/scripts/sandbox-worker.js
+import { parentPort } from "node:worker_threads";
+
+// ../../packages/engine/dist/scripts/sandbox-core.js
+var SHADOWED_GLOBALS = `
+"use strict";
+const self = undefined;
+const fetch = undefined;
+const XMLHttpRequest = undefined;
+const importScripts = undefined;
+const globalThis = undefined;
+const global = undefined;
+const process = undefined;
+const require = undefined;
+const Buffer = undefined;
+const module = undefined;
+const exports = undefined;
+`;
+function createExpect(actual, inverted = false) {
+  const pass = (condition, message) => {
+    const fails = inverted ? condition : !condition;
+    if (fails)
+      throw new Error(inverted ? `Expected NOT: ${message}` : message);
+  };
+  return {
+    toBe: (expected) => pass(Object.is(actual, expected), `Expected ${JSON.stringify(actual)} to be ${JSON.stringify(expected)}`),
+    toEqual: (expected) => pass(JSON.stringify(actual) === JSON.stringify(expected), `Expected ${JSON.stringify(actual)} to equal ${JSON.stringify(expected)}`),
+    toBeTruthy: () => pass(Boolean(actual), `Expected ${JSON.stringify(actual)} to be truthy`),
+    toBeFalsy: () => pass(!actual, `Expected ${JSON.stringify(actual)} to be falsy`),
+    toContain: (expected) => {
+      if (Array.isArray(actual)) {
+        pass(actual.includes(expected), `Expected array to contain ${JSON.stringify(expected)}`);
+      } else if (typeof actual === "string") {
+        pass(actual.includes(String(expected)), `Expected "${actual}" to contain "${String(expected)}"`);
+      } else {
+        throw new Error("toContain requires an array or string");
+      }
+    },
+    toHaveLength: (expected) => {
+      const len = actual?.length;
+      pass(len === expected, `Expected length ${String(len)} to equal ${String(expected)}`);
+    },
+    toBeGreaterThan: (expected) => pass(actual > expected, `Expected ${String(actual)} to be greater than ${String(expected)}`),
+    toBeLessThan: (expected) => pass(actual < expected, `Expected ${String(actual)} to be less than ${String(expected)}`),
+    toBeGreaterThanOrEqual: (expected) => pass(actual >= expected, `Expected ${String(actual)} to be >= ${String(expected)}`),
+    toBeLessThanOrEqual: (expected) => pass(actual <= expected, `Expected ${String(actual)} to be <= ${String(expected)}`),
+    toMatch: (pattern) => {
+      const regex = typeof pattern === "string" ? new RegExp(pattern) : pattern;
+      pass(regex.test(String(actual)), `Expected "${String(actual)}" to match ${String(regex)}`);
+    },
+    toBeNull: () => pass(actual === null, `Expected ${JSON.stringify(actual)} to be null`),
+    toBeUndefined: () => pass(actual === void 0, `Expected ${JSON.stringify(actual)} to be undefined`),
+    toBeDefined: () => pass(actual !== void 0, `Expected ${JSON.stringify(actual)} to be defined`),
+    get not() {
+      return createExpect(actual, !inverted);
+    }
+  };
+}
+function createEnvironment(env) {
+  const envStore = { ...env };
+  return {
+    store: envStore,
+    api: {
+      get: (key) => envStore[key] ?? "",
+      set: (key, value) => {
+        envStore[key] = String(value);
+      }
+    }
+  };
+}
+function executePreRequestScript(script, context) {
+  const { store, api } = createEnvironment(context.env);
+  const request = { ...context.request };
+  const fn = new Function("environment", "request", `${SHADOWED_GLOBALS}
+${script}`);
+  fn(api, request);
+  return { envOverrides: store };
+}
+function executeTestScript(script, context) {
+  const results = [];
+  const { response: responseCtx, request } = context;
+  const { store, api } = createEnvironment(context.env);
+  const response = {
+    status: responseCtx.status,
+    statusText: responseCtx.statusText,
+    headers: { ...responseCtx.headers },
+    body: responseCtx.body,
+    duration: responseCtx.duration,
+    json: () => JSON.parse(responseCtx.body)
+  };
+  const test = (name, fn2) => {
+    try {
+      fn2();
+      results.push({ name, passed: true });
+    } catch (err) {
+      results.push({
+        name,
+        passed: false,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  };
+  const expect = (actual) => createExpect(actual);
+  const fn = new Function("test", "expect", "response", "request", "environment", `${SHADOWED_GLOBALS}
+${script}`);
+  fn(test, expect, response, request, api);
+  return { testResults: results, envOverrides: store };
+}
+
+// ../../packages/engine/dist/scripts/sandbox-worker.js
+parentPort?.on("message", (message) => {
+  try {
+    if (message.type === "pre-request") {
+      parentPort?.postMessage(executePreRequestScript(message.script, message.context));
+    } else {
+      parentPort?.postMessage(executeTestScript(message.script, message.context));
+    }
+  } catch (err) {
+    parentPort?.postMessage({ error: err instanceof Error ? err.message : String(err) });
+  }
+});

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@requesto/cli",
+  "version": "1.8.0",
+  "description": "Run your Requesto collections from the terminal and CI pipelines",
+  "type": "module",
+  "main": "dist/index.mjs",
+  "bin": {
+    "requesto": "./dist/index.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "dev": "tsx src/bin.ts",
+    "build": "node scripts/bundle.mjs",
+    "start": "node dist/index.mjs",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "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",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}