@usejourney/k6-adapter 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 femoral <me@femoral.dev>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+interface ExportK6Options {
+    /** Absolute or cwd-relative path to the `.journey.ts` file. */
+    journeyFile: string;
+    /** Output path for the emitted k6 script. Wins over `outDir` when both are set. */
+    outFile?: string;
+    /** Output directory; emitted file is `<outDir>/<basename>.k6.js`. Ignored when `outFile` is set. */
+    outDir?: string;
+    /**
+     * k6 options block to bake into the emitted script as `export const options = {...}`.
+     * Same shape as `JourneyOptions['k6']` from `@usejourney/core`; kept loose here so the
+     * adapter does not pull a runtime dep on core. JSON-serialized verbatim.
+     */
+    k6Options?: Record<string, unknown>;
+}
+interface ExportK6Result {
+    outFile: string;
+    source: string;
+}
+declare function exportToK6(opts: ExportK6Options): Promise<ExportK6Result>;
+
+export { type ExportK6Options, type ExportK6Result, exportToK6 };

package/dist/index.js

@@ -0,0 +1,343 @@
+// src/index.ts
+import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import { basename, dirname as dirname2, resolve as resolve2 } from "path";
+import { transform } from "esbuild";
+
+// src/inline.ts
+import { readFile } from "fs/promises";
+import { dirname, isAbsolute, resolve } from "path";
+var IMPORT_RE = /^\s*import\s+[^;]*?from\s+["']([^"']+)["'];?\s*$/gm;
+function stripCoreImports(source) {
+  return source.replace(IMPORT_RE, (match, specifier) => {
+    if (specifier === "@usejourney/core") return "";
+    return match;
+  });
+}
+function stripTypeImports(source) {
+  return source.replace(/^\s*import\s+type\s+[^;]*?from\s+["'][^"']+["'];?\s*$/gm, "");
+}
+function findRelativeImports(source, fromFile) {
+  const out = [];
+  IMPORT_RE.lastIndex = 0;
+  let m;
+  while (m = IMPORT_RE.exec(source)) {
+    const spec = m[1];
+    if (!spec.startsWith(".")) continue;
+    const base = dirname(fromFile);
+    const abs = isAbsolute(spec) ? spec : resolve(base, spec);
+    const withExt = abs.endsWith(".ts") || abs.endsWith(".js") ? abs : null;
+    const candidates = withExt ? [withExt] : [`${abs}.ts`, `${abs}.js`, abs.replace(/\.js$/, ".ts")];
+    out.push({ specifier: spec, sourcePath: candidates[0] });
+  }
+  return out;
+}
+async function inlineRelativeImports(journeySource, journeyPath, visited = /* @__PURE__ */ new Set()) {
+  const imports = findRelativeImports(journeySource, journeyPath);
+  let out = journeySource;
+  for (const imp of imports) {
+    const tryPaths = imp.sourcePath.endsWith(".ts") || imp.sourcePath.endsWith(".js") ? [imp.sourcePath, imp.sourcePath.replace(/\.js$/, ".ts")] : [`${imp.sourcePath}.ts`, `${imp.sourcePath}.js`];
+    let resolved;
+    for (const p of tryPaths) {
+      try {
+        const content = await readFile(p, "utf8");
+        resolved = { path: p, content };
+        break;
+      } catch {
+      }
+    }
+    const importLineRe = new RegExp(
+      `^\\s*import\\s+[^;]*?from\\s+["']${imp.specifier.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&")}["'];?\\s*$`,
+      "m"
+    );
+    if (!resolved) continue;
+    if (visited.has(resolved.path)) {
+      out = out.replace(importLineRe, "");
+      continue;
+    }
+    visited.add(resolved.path);
+    const cleaned = stripCoreImports(stripTypeImports(resolved.content));
+    const recursed = await inlineRelativeImports(cleaned, resolved.path, visited);
+    const converted = recursed.replace(/^\s*export\s+(const|function|class)\s+/gm, "$1 ");
+    out = out.replace(
+      importLineRe,
+      `
+// ----- inlined from ${imp.specifier} -----
+${converted}
+// ----- end inlined -----
+`
+    );
+  }
+  return out;
+}
+
+// src/shim.ts
+var SHIM_SOURCE = `import http from "k6/http";
+import { check, group } from "k6";
+
+const __BASE_URL = __ENV.JOURNEY_BASE_URL || "";
+const __journeys = [];
+let __currentNodes = null;
+let __outputSlot = null;
+const __MAX_SUB_DEPTH = 8;
+
+// Sub-journey output cache \u2014 mirrors the runtime's MemorySubJourneyCache.
+// Scope is per-VU: k6 gives each VU its own JS runtime, and module-scoped state
+// persists across that VU's iterations (there is no cross-VU mutable shared
+// state \u2014 SharedArray is read-only). So a cached value is reused across the
+// iterations of one VU; each VU warms its own copy. Set JOURNEY_CACHE=off to
+// force every iteration cold (true per-iteration cost for load measurement).
+const __subCache = {};
+const __cacheOff = __ENV.JOURNEY_CACHE === "off";
+function __cacheGet(key) {
+  const e = __subCache[key];
+  if (!e) return undefined;
+  if (e.expiresAt !== undefined && Date.now() >= e.expiresAt) {
+    delete __subCache[key];
+    return undefined;
+  }
+  return e;
+}
+function __cacheSet(key, value, ttlMs) {
+  __subCache[key] = ttlMs !== undefined ? { value: value, expiresAt: Date.now() + ttlMs } : { value: value };
+}
+
+// Minimal no-op stand-in for zod. Reusable journeys declare \`inputs\` / \`outputs\`
+// schemas via \`z\`, but k6 has no zod runtime and the schemas are not enforced
+// in exported scripts \u2014 every access or call returns the same chainable proxy.
+const z = new Proxy(function () {}, {
+  get() { return z; },
+  apply() { return z; },
+  construct() { return z; },
+});
+
+// Sub-journey cacheKey / cacheTtlMs / cache opts ARE honored \u2014 see __runSub
+// and the per-VU note on __subCache above.
+function journey(name, optsOrBody, maybeBody) {
+  const body = typeof optsOrBody === "function" ? optsOrBody : maybeBody;
+  const opts = typeof optsOrBody === "function" ? null : optsOrBody;
+  if (opts && opts.reusable === true) {
+    return { __journeyHandle: true, name, body };
+  }
+  __journeys.push({ name, body });
+}
+
+function step(name, opts) {
+  if (!__currentNodes) {
+    throw new Error("step(" + JSON.stringify(name) + ") called outside a journey(...) body");
+  }
+  __currentNodes.push({ kind: "step", name, opts });
+}
+
+function invokeJourney(handle, opts) {
+  if (!__currentNodes) {
+    throw new Error("invokeJourney(...) called outside a journey(...) body");
+  }
+  __currentNodes.push({ kind: "sub", handle, opts: opts || {} });
+}
+
+function output(value) {
+  if (__outputSlot) __outputSlot.value = value;
+}
+
+function env(key) {
+  const v = __ENV[key];
+  if (v === undefined) throw new Error("env: missing " + key);
+  return v;
+}
+
+function deepEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const ak = Object.keys(a); const bk = Object.keys(b);
+  if (ak.length !== bk.length) return false;
+  for (const k of ak) if (!deepEqual(a[k], b[k])) return false;
+  return true;
+}
+
+function expect(value) {
+  const fail = (msg) => { const e = new Error(msg); e.name = "AssertionError"; throw e; };
+  return {
+    toBe(expected) { if (!Object.is(value, expected)) fail("expected " + JSON.stringify(value) + " to be " + JSON.stringify(expected)); },
+    toEqual(expected) { if (!deepEqual(value, expected)) fail("expected " + JSON.stringify(value) + " to equal " + JSON.stringify(expected)); },
+    toBeDefined() { if (value === undefined) fail("expected value to be defined"); },
+    toContain(expected) {
+      if (typeof value === "string") { if (!value.includes(expected)) fail("expected string to contain " + JSON.stringify(expected)); return; }
+      if (Array.isArray(value)) { if (!value.some((v) => deepEqual(v, expected))) fail("expected array to contain " + JSON.stringify(expected)); return; }
+      fail("toContain only supports strings and arrays");
+    },
+    toMatch(expected) {
+      if (typeof value !== "string") fail("toMatch only supports strings");
+      const re = typeof expected === "string" ? new RegExp(expected) : expected;
+      if (!re.test(value)) fail("expected " + JSON.stringify(value) + " to match " + re);
+    },
+  };
+}
+
+function __parseBody(res) {
+  const ct = (res.headers && (res.headers["Content-Type"] || res.headers["content-type"])) || "";
+  if (ct.indexOf("json") !== -1) { try { return res.json(); } catch (e) { return null; } }
+  return res.body;
+}
+
+function __interpolate(path, params) {
+  if (!params) return path;
+  let out = path;
+  for (const k of Object.keys(params)) out = out.replace("{" + k + "}", encodeURIComponent(String(params[k])));
+  return out;
+}
+
+function __mergeHeaders(h) {
+  const out = {};
+  if (h) for (const k of Object.keys(h)) out[k] = h[k];
+  return out;
+}
+
+function __buildQuery(query) {
+  if (!query) return "";
+  const parts = [];
+  for (const k of Object.keys(query)) {
+    const v = query[k];
+    if (v !== undefined) parts.push(encodeURIComponent(k) + "=" + encodeURIComponent(String(v)));
+  }
+  return parts.length ? "?" + parts.join("&") : "";
+}
+
+// Evaluate a journey body, collecting its pipeline nodes (step + sub).
+function __collectNodes(body, input) {
+  const nodes = [];
+  const prev = __currentNodes;
+  __currentNodes = nodes;
+  try { body(input); } finally { __currentNodes = prev; }
+  return nodes;
+}
+
+function __executeStep(current, journeyName) {
+  const opts = current.opts;
+  const headers = typeof opts.headers === "function" ? opts.headers() : (opts.headers || {});
+  const body = typeof opts.body === "function" ? opts.body() : opts.body;
+  // params and query are lazy in the core runtime \u2014 resolve a function form
+  // before interpolating the path / building the query string, like headers/body.
+  const params = typeof opts.params === "function" ? opts.params() : opts.params;
+  const query = typeof opts.query === "function" ? opts.query() : opts.query;
+  const path = __interpolate(opts.endpoint.path, params);
+  const base = opts.endpoint.baseUrl || __BASE_URL;
+  const url = base + path + __buildQuery(query);
+  const requestHeaders = __mergeHeaders(headers);
+  if (body !== undefined && !("Content-Type" in requestHeaders) && !("content-type" in requestHeaders)) {
+    requestHeaders["Content-Type"] = "application/json";
+  }
+  const res = http.request(
+    opts.endpoint.method,
+    url,
+    body !== undefined ? (typeof body === "string" ? body : JSON.stringify(body)) : null,
+    { headers: requestHeaders },
+  );
+  const wrapped = { status: res.status, headers: res.headers, body: __parseBody(res) };
+  if (opts.assert) {
+    const name = journeyName + " \u203A " + current.name;
+    check(wrapped, {
+      [name]: (r) => {
+        try { opts.assert(r); return true; } catch (e) { console.error(name + ": " + (e && e.message ? e.message : e)); return false; }
+      },
+    });
+  }
+  if (opts.after) opts.after(wrapped);
+}
+
+// Inline a sub-journey node under a k6 group() named after the child journey.
+// On a cache hit the child's requests are skipped entirely and the stored
+// output is replayed; the parent's assert/after still run either way.
+function __runSub(node, depth) {
+  if (depth >= __MAX_SUB_DEPTH) {
+    throw new Error("invokeJourney: sub-journey nesting exceeded " + __MAX_SUB_DEPTH + " levels");
+  }
+  const handle = node.handle;
+  const opts = node.opts || {};
+  const label = opts.name || handle.name;
+  let input = opts.inputs;
+  if (typeof input === "function") input = input();
+
+  // Cache active only when a cacheKey is supplied and not disabled \u2014 mirrors
+  // the core runtime. Composite key is childName:resolvedKey.
+  let resolvedKey;
+  if (opts.cacheKey !== undefined) {
+    resolvedKey = typeof opts.cacheKey === "function" ? opts.cacheKey(input) : opts.cacheKey;
+  }
+  const cacheKeyStr =
+    !__cacheOff && resolvedKey !== undefined && opts.cache !== "off"
+      ? handle.name + ":" + resolvedKey
+      : undefined;
+
+  const prevSlot = __outputSlot;
+  const slot = { value: undefined };
+  __outputSlot = slot;
+  try {
+    let hit = false;
+    if (cacheKeyStr !== undefined) {
+      const entry = __cacheGet(cacheKeyStr);
+      if (entry !== undefined) { slot.value = entry.value; hit = true; }
+    }
+    if (!hit) {
+      const childNodes = __collectNodes(handle.body, input);
+      group(label, () => { __runNodes(childNodes, handle.name, depth + 1); });
+      if (cacheKeyStr !== undefined) __cacheSet(cacheKeyStr, slot.value, opts.cacheTtlMs);
+    }
+  } finally {
+    __outputSlot = prevSlot;
+  }
+  if (opts.assert) opts.assert(slot.value);
+  if (opts.after) opts.after(slot.value);
+}
+
+function __runNodes(nodes, journeyName, depth) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (node.kind === "sub") __runSub(node, depth);
+    else __executeStep(node, journeyName);
+  }
+}
+`;
+var ENTRY_SOURCE = `
+export default function () {
+  for (let i = 0; i < __journeys.length; i++) {
+    const j = __journeys[i];
+    const nodes = __collectNodes(j.body, undefined);
+    __runNodes(nodes, j.name, 0);
+  }
+}
+`;
+
+// src/index.ts
+var HEADER = `// AUTO-GENERATED BY @usejourney/k6-adapter \u2014 do not edit by hand.
+// Usage: JOURNEY_BASE_URL=https://api.example.com k6 run <this-file>
+`;
+async function exportToK6(opts) {
+  const journeyPath = resolve2(process.cwd(), opts.journeyFile);
+  const rawSource = await readFile2(journeyPath, "utf8");
+  const withoutTypeImports = stripTypeImports(rawSource);
+  const inlined = await inlineRelativeImports(withoutTypeImports, journeyPath);
+  const withoutCore = stripCoreImports(inlined);
+  const { code: userCode } = await transform(withoutCore, {
+    loader: "ts",
+    format: "esm"
+  });
+  const fileBase = basename(journeyPath).replace(/\.journey\.ts$/, "");
+  const outFile = opts.outFile ? resolve2(process.cwd(), opts.outFile) : opts.outDir ? resolve2(process.cwd(), opts.outDir, `${fileBase}.k6.js`) : resolve2(dirname2(journeyPath), `${fileBase}.k6.js`);
+  const optionsBlock = opts.k6Options ? `export const options = ${JSON.stringify(opts.k6Options, null, 2)};
+` : "";
+  const source = [
+    HEADER,
+    SHIM_SOURCE,
+    optionsBlock,
+    "// ===== user journey =====",
+    userCode.trimStart(),
+    ENTRY_SOURCE
+  ].join("\n");
+  await mkdir(dirname2(outFile), { recursive: true });
+  await writeFile(outFile, source, "utf8");
+  return { outFile, source };
+}
+export {
+  exportToK6
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@usejourney/k6-adapter",
+  "version": "0.1.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/femoral/journey.git",
+    "directory": "packages/k6-adapter"
+  },
+  "homepage": "https://github.com/femoral/journey#readme",
+  "bugs": "https://github.com/femoral/journey/issues",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "esbuild": "^0.21.5"
+  },
+  "devDependencies": {
+    "@usejourney/core": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests"
+  }
+}