@elench/testkit 0.1.82 → 0.1.84

package/lib/runtime-src/k6/http.js

@@ -36,13 +36,21 @@ export function createHttpClient(config) {
     throw new Error("baseUrl is required");
   }
 
-  function buildHeaders(builder, context, extraHeaders = {}) {
-    return {
-      ...defaultHeaders,
+  function buildHeaders(builder, context, extraHeaders = {}, options = {}) {
+    const { includeDefaultHeaders = true, contentTypeJson = true } = options;
+    const resolvedHeaders = {
+      ...(includeDefaultHeaders ? defaultHeaders : {}),
       ...safeHeaders(builder, context),
       ...routeHeaders,
       ...extraHeaders,
     };
+
+    if (contentTypeJson === false) {
+      delete resolvedHeaders["Content-Type"];
+      delete resolvedHeaders["content-type"];
+    }
+
+    return resolvedHeaders;
   }
 
   function buildHeaderContext(actorName = null) {
@@ -60,23 +68,75 @@ export function createHttpClient(config) {
     }
   }
 
-  function requestAs(actorName, method, path, body, extraHeaders = {}) {
+  function resolvedHeadersFor(actorName, extraHeaders = {}) {
+    ensureKnownActor(actorName);
+    const headerContext = buildHeaderContext(actorName);
+    return buildHeaders(getHeaders, headerContext, extraHeaders);
+  }
+
+  function resolvedRawHeadersFor(actorName = null, extraHeaders = {}) {
+    ensureKnownActor(actorName);
+    const headerContext = buildHeaderContext(actorName);
+    return buildHeaders(getRawHeaders, headerContext, extraHeaders);
+  }
+
+  function requestAs(actorName, method, path, body, extraHeaders = {}, options = {}) {
     ensureKnownActor(actorName);
     const url = `${baseUrl}${path}`;
     const headerContext = buildHeaderContext(actorName);
-    const headers = buildHeaders(getHeaders, headerContext, extraHeaders);
-    return runHttpRequest(method, path, url, body, headers, headerContext.actor);
+    const headers = buildHeaders(getHeaders, headerContext, extraHeaders, {
+      contentTypeJson: options.contentTypeJson !== false,
+      includeDefaultHeaders: options.includeDefaultHeaders !== false,
+    });
+    return runHttpRequest(method, path, url, body, headers, headerContext.actor, options);
   }
 
-  function raw(method, path, body, extraHeaders = {}) {
+  function rawAs(actorName, method, path, body, extraHeaders = {}, options = {}) {
+    ensureKnownActor(actorName);
     const url = `${baseUrl}${path}`;
-    const headerContext = buildHeaderContext(null);
-    const headers = buildHeaders(getRawHeaders, headerContext, extraHeaders);
-    return runHttpRequest(method, path, url, body, headers, null);
+    const headerContext = buildHeaderContext(actorName);
+    const headers = buildHeaders(getRawHeaders, headerContext, extraHeaders, {
+      contentTypeJson: options.contentTypeJson !== false,
+      includeDefaultHeaders: options.includeDefaultHeaders !== false,
+    });
+    return runHttpRequest(method, path, url, body, headers, headerContext.actor, options);
+  }
+
+  function raw(method, path, body, extraHeaders = {}) {
+    return rawAs(null, method, path, body, extraHeaders);
+  }
+
+  function requestMultipart(actorName, method, path, payload, extraHeaders = {}, options = {}) {
+    const body = buildMultipartBody(payload);
+    return requestAs(actorName, method, path, body, extraHeaders, {
+      ...options,
+      contentTypeJson: false,
+      includeDefaultHeaders: false,
+      serialize: "raw",
+    });
+  }
+
+  function rawMultipart(actorName, method, path, payload, extraHeaders = {}, options = {}) {
+    const body = buildMultipartBody(payload);
+    return rawAs(actorName, method, path, body, extraHeaders, {
+      ...options,
+      contentTypeJson: false,
+      includeDefaultHeaders: false,
+      serialize: "raw",
+    });
   }
 
   function createActorClient(actorName) {
+    const actorRawReq = createRawInvoker(actorName);
+
     return {
+      headers(extraHeaders = {}) {
+        return resolvedHeadersFor(actorName, extraHeaders);
+      },
+      rawHeaders(extraHeaders = {}) {
+        return resolvedRawHeadersFor(actorName, extraHeaders);
+      },
+      rawReq: actorRawReq,
       delete(path, extraHeaders = {}) {
         return requestAs(actorName, "DELETE", path, null, extraHeaders);
       },
@@ -95,19 +155,98 @@ export function createHttpClient(config) {
       request(method, path, body, extraHeaders = {}) {
         return requestAs(actorName, method, path, body, extraHeaders);
       },
+      raw(method, path, body, extraHeaders = {}) {
+        return actorRawReq(method, path, body, extraHeaders);
+      },
+      rawDelete(path, extraHeaders = {}) {
+        return actorRawReq.delete(path, extraHeaders);
+      },
+      rawGet(path, extraHeaders = {}) {
+        return actorRawReq.get(path, extraHeaders);
+      },
+      rawPatch(path, body, extraHeaders = {}) {
+        return actorRawReq.patch(path, body, extraHeaders);
+      },
+      rawPost(path, body, extraHeaders = {}) {
+        return actorRawReq.post(path, body, extraHeaders);
+      },
+      rawPut(path, body, extraHeaders = {}) {
+        return actorRawReq.put(path, body, extraHeaders);
+      },
+      multipart: {
+        post(path, payload, extraHeaders = {}) {
+          return requestMultipart(actorName, "POST", path, payload, extraHeaders);
+        },
+        put(path, payload, extraHeaders = {}) {
+          return requestMultipart(actorName, "PUT", path, payload, extraHeaders);
+        },
+        patch(path, payload, extraHeaders = {}) {
+          return requestMultipart(actorName, "PATCH", path, payload, extraHeaders);
+        },
+      },
+      rawMultipart: {
+        post(path, payload, extraHeaders = {}) {
+          return actorRawReq.multipart.post(path, payload, extraHeaders);
+        },
+        put(path, payload, extraHeaders = {}) {
+          return actorRawReq.multipart.put(path, payload, extraHeaders);
+        },
+        patch(path, payload, extraHeaders = {}) {
+          return actorRawReq.multipart.patch(path, payload, extraHeaders);
+        },
+      },
+    };
+  }
+
+  function createRawInvoker(defaultRawActor = null) {
+    const invoker = (method, path, body, extraHeaders = {}) =>
+      rawAs(defaultRawActor, method, path, body, extraHeaders);
+
+    invoker.request = (method, path, body, extraHeaders = {}) =>
+      rawAs(defaultRawActor, method, path, body, extraHeaders);
+    invoker.get = (path, extraHeaders = {}) => rawAs(defaultRawActor, "GET", path, null, extraHeaders);
+    invoker.post = (path, body, extraHeaders = {}) => rawAs(defaultRawActor, "POST", path, body, extraHeaders);
+    invoker.put = (path, body, extraHeaders = {}) => rawAs(defaultRawActor, "PUT", path, body, extraHeaders);
+    invoker.patch = (path, body, extraHeaders = {}) => rawAs(defaultRawActor, "PATCH", path, body, extraHeaders);
+    invoker.delete = (path, extraHeaders = {}) =>
+      rawAs(defaultRawActor, "DELETE", path, null, extraHeaders);
+    invoker.headers = (extraHeaders = {}) => resolvedRawHeadersFor(defaultRawActor, extraHeaders);
+    invoker.as = (actorName) => {
+      ensureKnownActor(actorName);
+      return createRawInvoker(actorName);
+    };
+    invoker.multipart = {
+      post(path, payload, extraHeaders = {}) {
+        return rawMultipart(defaultRawActor, "POST", path, payload, extraHeaders);
+      },
+      put(path, payload, extraHeaders = {}) {
+        return rawMultipart(defaultRawActor, "PUT", path, payload, extraHeaders);
+      },
+      patch(path, payload, extraHeaders = {}) {
+        return rawMultipart(defaultRawActor, "PATCH", path, payload, extraHeaders);
+      },
     };
+
+    return invoker;
   }
 
   const defaultClient = createActorClient(defaultActor);
+  const rawClient = createRawInvoker(null);
 
   return {
     rawHttp: http,
+    headers(extraHeaders = {}) {
+      return resolvedHeadersFor(defaultActor, extraHeaders);
+    },
+    rawHeaders(actorName = null, extraHeaders = {}) {
+      return resolvedRawHeadersFor(actorName, extraHeaders);
+    },
     as(actorName) {
       ensureKnownActor(actorName);
       return createActorClient(actorName);
     },
     request: defaultClient.request,
-    raw,
+    raw: rawClient,
     get(path, extraHeaders = {}) {
       return defaultClient.get(path, extraHeaders);
     },
@@ -124,19 +263,41 @@ export function createHttpClient(config) {
       return defaultClient.delete(path, extraHeaders);
     },
     rawGet(path, extraHeaders = {}) {
-      return raw("GET", path, null, extraHeaders);
+      return rawClient.get(path, extraHeaders);
     },
     rawPost(path, body, extraHeaders = {}) {
-      return raw("POST", path, body, extraHeaders);
+      return rawClient.post(path, body, extraHeaders);
     },
     rawPut(path, body, extraHeaders = {}) {
-      return raw("PUT", path, body, extraHeaders);
+      return rawClient.put(path, body, extraHeaders);
     },
     rawPatch(path, body, extraHeaders = {}) {
-      return raw("PATCH", path, body, extraHeaders);
+      return rawClient.patch(path, body, extraHeaders);
     },
     rawDelete(path, extraHeaders = {}) {
-      return raw("DELETE", path, null, extraHeaders);
+      return rawClient.delete(path, extraHeaders);
+    },
+    multipart: {
+      post(path, payload, extraHeaders = {}) {
+        return requestMultipart(defaultActor, "POST", path, payload, extraHeaders);
+      },
+      put(path, payload, extraHeaders = {}) {
+        return requestMultipart(defaultActor, "PUT", path, payload, extraHeaders);
+      },
+      patch(path, payload, extraHeaders = {}) {
+        return requestMultipart(defaultActor, "PATCH", path, payload, extraHeaders);
+      },
+    },
+    rawMultipart: {
+      post(path, payload, extraHeaders = {}) {
+        return rawClient.multipart.post(path, payload, extraHeaders);
+      },
+      put(path, payload, extraHeaders = {}) {
+        return rawClient.multipart.put(path, payload, extraHeaders);
+      },
+      patch(path, payload, extraHeaders = {}) {
+        return rawClient.multipart.patch(path, payload, extraHeaders);
+      },
     },
   };
 }
@@ -159,7 +320,7 @@ export function makeRawReq(baseUrl, routeHeaders = {}, getRawHeaders = null) {
   }).raw;
 }
 
-function runHttpRequest(method, path, url, body, headers, actorRecord = null) {
+function runHttpRequest(method, path, url, body, headers, actorRecord = null, requestOptions = {}) {
   const ordinal = nextTraceOrdinal();
   const requestId = buildRequestId(ordinal);
   const finalHeaders = {
@@ -175,14 +336,15 @@ function runHttpRequest(method, path, url, body, headers, actorRecord = null) {
     actorRecord,
     requestHeaders: finalHeaders,
   });
-  const options = { headers: finalHeaders };
+  const transportOptions = { headers: finalHeaders };
 
   let rawResponse;
-  if (method === "GET") rawResponse = http.get(url, options);
-  else if (method === "PUT") rawResponse = http.put(url, JSON.stringify(body), options);
-  else if (method === "POST") rawResponse = http.post(url, JSON.stringify(body), options);
-  else if (method === "PATCH") rawResponse = http.patch(url, JSON.stringify(body), options);
-  else if (method === "DELETE") rawResponse = http.del(url, null, options);
+  const requestBody = serializeRequestBody(body, requestOptions.serialize || "json");
+  if (method === "GET") rawResponse = http.get(url, transportOptions);
+  else if (method === "PUT") rawResponse = http.put(url, requestBody, transportOptions);
+  else if (method === "POST") rawResponse = http.post(url, requestBody, transportOptions);
+  else if (method === "PATCH") rawResponse = http.patch(url, requestBody, transportOptions);
+  else if (method === "DELETE") rawResponse = http.del(url, null, transportOptions);
   else throw new Error(`unsupported method: ${method}`);
 
   finalizeTrace(trace, rawResponse);
@@ -420,3 +582,31 @@ function decodeQueryComponent(value) {
     return String(value || "");
   }
 }
+
+function serializeRequestBody(body, mode = "json") {
+  if (body == null) return body;
+  if (mode === "raw") return body;
+  if (typeof body === "string") return body;
+  return JSON.stringify(body);
+}
+
+function buildMultipartBody(payload = {}) {
+  const fields = payload?.fields || {};
+  const files = Array.isArray(payload?.files) ? payload.files : [];
+  const body = { ...fields };
+
+  for (const fileEntry of files) {
+    if (!fileEntry || typeof fileEntry !== "object") {
+      throw new Error("multipart file entries must be objects");
+    }
+
+    const field = String(fileEntry.field || "").trim();
+    if (!field) {
+      throw new Error("multipart file entries require a field name");
+    }
+
+    body[field] = http.file(fileEntry.data, fileEntry.filename, fileEntry.contentType);
+  }
+
+  return body;
+}

package/lib/runtime-src/shared/error-body.mjs

@@ -0,0 +1,42 @@
+export function extractErrorMessageFromBody(body) {
+  if (!body || typeof body !== "object") return null;
+
+  if ("error" in body) {
+    const error = body.error;
+    if (typeof error === "string" && error.length > 0) return error;
+    if (error && typeof error === "object" && "message" in error) {
+      const message = error.message;
+      if (typeof message === "string" && message.length > 0) return message;
+    }
+  }
+
+  if ("message" in body) {
+    const message = body.message;
+    if (typeof message === "string" && message.length > 0) return message;
+  }
+
+  return null;
+}
+
+export function hasStandardErrorShape(body) {
+  if (!body || typeof body !== "object") return false;
+  const error = body.error;
+  if (!error || typeof error !== "object") return false;
+  return typeof error.code === "string" && typeof error.message === "string";
+}
+
+export function deriveDeterministicIp(seed, offset = 0) {
+  const hash = numericSeed(`${seed}:${offset}`);
+  const thirdOctet = (hash % 250) + 1;
+  const fourthOctet = (Math.floor(hash / 250) % 250) + 1;
+  return `198.51.${thirdOctet}.${fourthOctet}`;
+}
+
+function numericSeed(seed) {
+  let hash = 0;
+  const text = String(seed);
+  for (let index = 0; index < text.length; index += 1) {
+    hash = (hash * 31 + text.charCodeAt(index)) >>> 0;
+  }
+  return hash;
+}

package/lib/runtime-src/shared/http-parsing.mjs

@@ -0,0 +1,68 @@
+export function parseJsonBody(response) {
+  return JSON.parse(response.body);
+}
+
+export function extractCookie(response, cookieName) {
+  const cookies = Object.entries(response?.headers || {})
+    .filter(([name]) => String(name).toLowerCase() === "set-cookie")
+    .flatMap(([, value]) => (Array.isArray(value) ? value : value ? [value] : []));
+
+  if (cookies.length === 0) return null;
+
+  const cookiePattern = new RegExp(`(?:^|,\\s*)${escapeRegExp(cookieName)}=([^;,]+)`);
+  for (const headerValue of cookies) {
+    const match = cookiePattern.exec(String(headerValue));
+    if (match?.[1]) {
+      return match[1];
+    }
+  }
+
+  return null;
+}
+
+export function parseSseEvents(body) {
+  return String(body || "")
+    .split(/\n\n+/)
+    .map((block) => block.trim())
+    .filter(Boolean)
+    .map((block) => {
+      const lines = block.split("\n");
+      let event = null;
+      const dataLines = [];
+
+      for (const line of lines) {
+        if (line.startsWith("event:")) {
+          event = line.slice("event:".length).trim() || null;
+        }
+        if (line.startsWith("data:")) {
+          dataLines.push(line.slice("data:".length).trim());
+        }
+      }
+
+      const rawData = dataLines.join("\n");
+      if (!rawData) {
+        return { event, data: null };
+      }
+
+      try {
+        return {
+          event,
+          data: JSON.parse(rawData),
+        };
+      } catch {
+        return {
+          event,
+          data: rawData,
+        };
+      }
+    });
+}
+
+export function getSseEventData(body, eventName) {
+  const match = parseSseEvents(body).find((event) => event.event === eventName);
+  return match?.data ?? null;
+}
+
+function escapeRegExp(value) {
+  return String(value || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/node_modules/@elench/next-analysis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/next-analysis",
-  "version": "0.1.82",
+  "version": "0.1.84",
   "description": "SWC-backed Next.js source analysis primitives for Erench tools",
   "type": "module",
   "exports": {

package/node_modules/@elench/testkit-bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-bridge",
-  "version": "0.1.82",
+  "version": "0.1.84",
   "description": "Browser bridge helpers for testkit",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@elench/testkit-protocol": "0.1.82"
+    "@elench/testkit-protocol": "0.1.84"
   },
   "private": false
 }

package/node_modules/@elench/testkit-protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-protocol",
-  "version": "0.1.82",
+  "version": "0.1.84",
   "description": "Shared browser protocol for testkit bridge and extension consumers",
   "type": "module",
   "main": "./dist/index.js",

package/node_modules/@elench/ts-analysis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/ts-analysis",
-  "version": "0.1.82",
+  "version": "0.1.84",
   "description": "TypeScript compiler-backed source analysis primitives for Erench tools",
   "type": "module",
   "exports": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit",
-  "version": "0.1.82",
+  "version": "0.1.84",
   "description": "CLI for discovering and running local HTTP, DAL, and Playwright test suites",
   "type": "module",
   "workspaces": [
@@ -66,7 +66,8 @@
   "files": [
     "bin/",
     "lib/",
-    "vendor/"
+    "vendor/",
+    "!lib/**/*.test.*"
   ],
   "bundleDependencies": [
     "@elench/next-analysis",
@@ -81,10 +82,10 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.29.0",
-    "@elench/next-analysis": "0.1.82",
-    "@elench/testkit-bridge": "0.1.82",
-    "@elench/testkit-protocol": "0.1.82",
-    "@elench/ts-analysis": "0.1.82",
+    "@elench/next-analysis": "0.1.84",
+    "@elench/testkit-bridge": "0.1.84",
+    "@elench/testkit-protocol": "0.1.84",
+    "@elench/ts-analysis": "0.1.84",
     "@oclif/core": "^4.10.6",
     "esbuild": "^0.25.11",
     "execa": "^9.5.0",

package/lib/app/configs.test.mjs

@@ -1,34 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  collectRequiredConfigs,
-  filterConfigsByService,
-  resolveTargetConfig,
-  topologicallySortConfigs,
-} from "./configs.mjs";
-
-function makeConfig(name, dependsOn = [], provider = null) {
-  return {
-    name,
-    testkit: {
-      dependsOn,
-      database: provider ? { provider } : undefined,
-    },
-  };
-}
-
-describe("app config helpers", () => {
-  it("filters and resolves target configs", () => {
-    const configs = [makeConfig("api"), makeConfig("frontend", ["api"], "local")];
-
-    expect(filterConfigsByService(configs, "api")).toEqual([configs[0]]);
-    expect(resolveTargetConfig(configs)).toBe(configs[1]);
-    expect(() => filterConfigsByService(configs, "missing")).toThrow('Service "missing" not found');
-  });
-
-  it("collects dependencies and sorts them topologically", () => {
-    const configs = [makeConfig("frontend", ["api"]), makeConfig("api"), makeConfig("worker", ["api"])];
-
-    expect(collectRequiredConfigs(configs, "frontend").map((config) => config.name).sort()).toEqual(["api", "frontend"]);
-    expect(topologicallySortConfigs(configs).map((config) => config.name)).toEqual(["api", "frontend", "worker"]);
-  });
-});

package/lib/app/typecheck.test.mjs

@@ -1,24 +0,0 @@
-import path from "path";
-import { describe, expect, it } from "vitest";
-import { buildTypecheckCompilerOptions } from "./typecheck.mjs";
-
-describe("typecheck app helpers", () => {
-  it("preserves inherited service alias paths when generating next-service configs", () => {
-    const fixtureRoot = "/home/georgedlr/workspace/elench/bourne";
-    const extendsPath = path.join(fixtureRoot, "frontend", "tsconfig.json");
-    const generatedTsconfig = path.join(fixtureRoot, ".testkit", "_typecheck", "frontend.tsconfig.json");
-
-    const compilerOptions = buildTypecheckCompilerOptions({
-      tsconfigPath: generatedTsconfig,
-      extendsPath,
-    });
-
-    expect(compilerOptions.paths?.["@/*"]).toEqual(["../../frontend/src/*"]);
-    expect(compilerOptions.paths?.["@playwright-fixtures/*"]).toEqual([
-      "../../frontend/tests/playwright-fixtures/*",
-    ]);
-    expect(compilerOptions.paths?.["@elench/testkit/config"]?.[0]).toMatch(
-      /(?:\.\.\/)+(?:node_modules\/@elench\/testkit|testkit)\/lib\/config-api\/index\.d\.ts$/
-    );
-  });
-});