@usejourney/postman-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,154 @@
+import { StepDef } from '@usejourney/core';
+
+interface PostmanUrl {
+    raw: string;
+    host: string[];
+    path: string[];
+    query: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+interface PostmanHeader {
+    key: string;
+    value: string;
+}
+interface PostmanBody {
+    mode: "raw";
+    raw: string;
+    options: {
+        raw: {
+            language: "json";
+        };
+    };
+}
+interface PostmanRequest {
+    method: string;
+    header: PostmanHeader[];
+    url: PostmanUrl;
+    body?: PostmanBody;
+}
+interface PostmanItem {
+    name: string;
+    request: PostmanRequest;
+    /** Request-scoped pre-request / test scripts (used by state threading). */
+    event?: PostmanEvent[];
+}
+/** Folder-scoped variable — sub-journey inputs are serialized as these. */
+interface PostmanVariable {
+    key: string;
+    value: string;
+}
+/** A Postman script — `exec` is the source split into lines. */
+interface PostmanScript {
+    type: "text/javascript";
+    exec: string[];
+}
+/** A pre-request or test script bound to an item (request or folder). */
+interface PostmanEvent {
+    listen: "prerequest" | "test";
+    script: PostmanScript;
+}
+/**
+ * A Postman folder. `item` holds requests and/or nested folders, so a
+ * sub-journey invocation nests as a child folder among the parent's requests.
+ * `event` carries folder-scoped pre-request / test scripts (used to translate
+ * the sub-journey output cache — see `buildItems`).
+ */
+interface PostmanFolder {
+    name: string;
+    item: Array<PostmanItem | PostmanFolder>;
+    description?: string;
+    variable?: PostmanVariable[];
+    event?: PostmanEvent[];
+}
+interface PostmanInfo {
+    name: string;
+    schema: string;
+}
+interface PostmanCollection {
+    info: PostmanInfo;
+    item: PostmanFolder[];
+}
+interface PostmanEnvValue {
+    key: string;
+    value: string;
+    enabled: boolean;
+}
+interface PostmanEnvironment {
+    name: string;
+    values: PostmanEnvValue[];
+}
+/**
+ * The shape `buildFolder` walks. The CLI resolves a journey's `PipelineNode[]`
+ * into this tree — recursing into each sub-journey via `collectSubPipeline` —
+ * so the adapter stays free of a runtime dependency on `@usejourney/core`.
+ */
+type ExportNode = {
+    kind: "step";
+    def: StepDef;
+} | {
+    kind: "sub";
+    /** Timeline display label — the call's `name` override or the child journey's name. */
+    name: string;
+    /** Resolved call inputs, written as folder-scoped Postman variables. */
+    inputs?: Record<string, unknown>;
+    /**
+     * Under `--thread-state`, a sub-journey call with **dynamic** `inputs`
+     * (`() => ({ … })`) carries the closure source plus the child body's
+     * parameter name. The folder pre-request re-runs the closure against the
+     * carrier and seeds the result under `inputParam` so the child's own
+     * closures resolve `input.*`. Absent for static / `env()` inputs.
+     */
+    inputsSrc?: string;
+    inputParam?: string;
+    /** The child journey's own pipeline, already resolved. */
+    nodes: ExportNode[];
+    /**
+     * Composite cache key `childName:resolvedKey`, resolved at export time.
+     * Present only when the call opts into the cache (`cacheKey` set,
+     * `cache !== "off"`); its presence emits the folder cache scripts.
+     */
+    cacheKey?: string;
+    /** Per-call TTL in ms; absent → cache for the whole collection run. */
+    cacheTtlMs?: number;
+    /**
+     * The call's `after(out)` / `assert(out)` hooks. Under `--thread-state`
+     * they run on the sub-folder's terminal request, consuming the child's
+     * `output(...)`.
+     */
+    after?: (out: unknown) => void | Promise<void>;
+    assert?: (out: unknown) => void | Promise<void>;
+};
+declare const ENV_PROXY: Record<string, string>;
+/** Options for {@link buildFolder}. */
+interface BuildFolderOpts {
+    /**
+     * Experimental: thread journey closure-state through a collection variable so
+     * sub-journey outputs and step-to-step state reach later requests. Emits
+     * per-request pre-request/test scripts and a folder-level carrier reset.
+     */
+    threadState?: boolean;
+    /**
+     * With `threadState`: emit non-enforcing assertions (legacy swallow-all) so a
+     * failing `expect()` stays a console line instead of a red `pm.test`. Off by
+     * default — threaded assertions enforce. No effect without `threadState`.
+     */
+    lenient?: boolean;
+}
+/** Build the top-level Postman folder for a journey from its resolved tree. */
+declare function buildFolder(name: string, nodes: ReadonlyArray<ExportNode>, opts?: BuildFolderOpts): Promise<PostmanFolder>;
+/** Options for {@link buildCollection}. */
+interface BuildCollectionOpts {
+    /**
+     * Prepend a skipped reset request that clears the threaded carrier + cache
+     * slots at the start of a run, so a Postman Runner re-run starts cold (Postman
+     * persists collection variables across runs; Newman does not). Set when
+     * exporting with `--thread-state`.
+     */
+    reset?: boolean;
+}
+declare function buildCollection(name: string, folders: PostmanFolder[], opts?: BuildCollectionOpts): PostmanCollection;
+declare function buildEnvironment(name: string, values: Record<string, string>): PostmanEnvironment;
+
+export { type BuildCollectionOpts, type BuildFolderOpts, ENV_PROXY, type ExportNode, type PostmanBody, type PostmanCollection, type PostmanEnvValue, type PostmanEnvironment, type PostmanEvent, type PostmanFolder, type PostmanHeader, type PostmanInfo, type PostmanItem, type PostmanRequest, type PostmanScript, type PostmanUrl, type PostmanVariable, buildCollection, buildEnvironment, buildFolder };

package/dist/index.js

@@ -0,0 +1,411 @@
+// src/stateThread.ts
+var STATE_VAR = "__journey_state";
+function toCallable(src) {
+  const s = src.trim();
+  if (/^(async\s+)?function\b/.test(s) || /^(async\s*)?\(/.test(s) || /^(async\s+)?[A-Za-z_$][\w$]*\s*=>/.test(s)) {
+    return `(${s})`;
+  }
+  return `(${s.replace(
+    /^(async\s+)?[A-Za-z_$][\w$]*\s*\(/,
+    (m) => /^async/.test(m) ? "async function(" : "function("
+  )})`;
+}
+var JS_RESERVED = /* @__PURE__ */ new Set([
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "return",
+  "var",
+  "let",
+  "const",
+  "function",
+  "new",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "this",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "void",
+  "delete",
+  "try",
+  "catch",
+  "throw",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "async",
+  "await"
+]);
+function writeTargets(src, locals) {
+  const skip = /* @__PURE__ */ new Set([...locals, ...JS_RESERVED]);
+  const out = /* @__PURE__ */ new Set();
+  const re = /(^|[^.=!<>+\-*/%&|^\w$])([A-Za-z_$][\w$]*)\s*=(?![=>])/g;
+  let m;
+  while ((m = re.exec(src)) !== null) {
+    const name = m[2];
+    if (!skip.has(name)) out.add(name);
+  }
+  return [...out];
+}
+function paramNames(src) {
+  const s = src.trim();
+  const arrowBare = /^(async\s+)?([A-Za-z_$][\w$]*)\s*=>/.exec(s);
+  if (arrowBare) return [arrowBare[2]];
+  const paren = /^(?:async\s+)?(?:[A-Za-z_$][\w$]*)?\s*\(([^)]*)\)/.exec(s);
+  if (!paren) return [];
+  return paren[1].split(",").map((p) => p.trim().split(/[=:\s]/)[0]).filter(Boolean);
+}
+var PRELUDE = [
+  `var __s = JSON.parse(pm.collectionVariables.get(${JSON.stringify(STATE_VAR)}) || "{}");`,
+  `function __save(){ pm.collectionVariables.set(${JSON.stringify(STATE_VAR)}, JSON.stringify(__s)); }`,
+  `function env(k){ var v = pm.variables.get(k); return v === undefined ? pm.collectionVariables.get(k) : v; }`
+];
+function testShims(strict) {
+  if (!strict) {
+    return [
+      `function expect(v){ return {`,
+      `  toBe:function(e){ pm.expect(v).to.eql(e); },`,
+      `  toEqual:function(e){ pm.expect(v).to.eql(e); },`,
+      `  toBeDefined:function(){ pm.expect(v).to.not.be.undefined; },`,
+      `  toContain:function(e){ pm.expect(v).to.include(e); },`,
+      `  toMatch:function(e){ pm.expect(String(v)).to.match(typeof e === "string" ? new RegExp(e) : e); },`,
+      `}; }`,
+      `function output(v){ __s.__out = v; }`
+    ];
+  }
+  return [
+    `var __ai = 0;`,
+    `function __label(){ return (typeof __base !== "undefined" ? __base : "assertion") + " \xB7 assert " + (++__ai); }`,
+    `function expect(v){ return {`,
+    `  toBe:function(e){ pm.test(__label(), function(){ pm.expect(v).to.eql(e); }); },`,
+    `  toEqual:function(e){ pm.test(__label(), function(){ pm.expect(v).to.eql(e); }); },`,
+    `  toBeDefined:function(){ pm.test(__label(), function(){ pm.expect(v).to.not.be.undefined; }); },`,
+    `  toContain:function(e){ pm.test(__label(), function(){ pm.expect(v).to.include(e); }); },`,
+    `  toMatch:function(e){ pm.test(__label(), function(){ pm.expect(String(v)).to.match(typeof e === "string" ? new RegExp(e) : e); }); },`,
+    `}; }`,
+    `function output(v){ __s.__out = v; }`
+  ];
+}
+function runLazy(src) {
+  return `(new Function("__s","env","with(__s){ try { return ${toCallable(src).replace(/"/g, '\\"')}(); } catch (e) { return undefined; } }"))(__s, env)`;
+}
+function isFn(v) {
+  return typeof v === "function";
+}
+function subInputSeed(paramName, inputsSrc) {
+  return [
+    ...PRELUDE,
+    `var __in = ${runLazy(inputsSrc)};`,
+    `if (__in && typeof __in === "object") __s[${JSON.stringify(paramName)}] = __in;`,
+    `__save();`
+  ];
+}
+function stepPrerequest(step) {
+  const lines = [];
+  const { headers, params, query, body } = step.options;
+  if (isFn(headers)) {
+    lines.push(
+      `var __h = ${runLazy(headers.toString())};`,
+      `if (__h) Object.keys(__h).forEach(function(k){ pm.request.headers.upsert({ key: k, value: String(__h[k]) }); });`
+    );
+  }
+  if (isFn(params)) {
+    lines.push(
+      `var __p = ${runLazy(params.toString())};`,
+      `if (__p) Object.keys(__p).forEach(function(k){ pm.variables.set(k, String(__p[k])); });`
+    );
+  }
+  if (isFn(query)) {
+    lines.push(
+      `var __q = ${runLazy(query.toString())};`,
+      `if (__q) Object.keys(__q).forEach(function(k){ if (__q[k] !== undefined) pm.variables.set("__q_" + k, String(__q[k])); });`
+    );
+  }
+  if (isFn(body)) {
+    lines.push(
+      `var __b = ${runLazy(body.toString())};`,
+      `pm.variables.set("__journey_body", __b === undefined ? "" : (typeof __b === "string" ? __b : JSON.stringify(__b)));`
+    );
+  }
+  if (lines.length === 0) return null;
+  return [...PRELUDE, ...lines];
+}
+function runHook(src, resExpr) {
+  const targets = writeTargets(src, paramNames(src));
+  const seed = targets.map(
+    (t) => `if (!(${JSON.stringify(t)} in __s)) __s[${JSON.stringify(t)}] = undefined;`
+  );
+  const callable = toCallable(src).replace(/"/g, '\\"');
+  return [
+    ...seed,
+    `try { (new Function("__s","__arg","env","expect","output","with(__s){ ${callable}(__arg); }"))(__s, ${resExpr}, env, expect, output); } catch (e) { console.log("journey hook:", e && e.message ? e.message : e); }`
+  ];
+}
+function stepTest(step, parentHooks = [], cacheStore, strict = true) {
+  const assert = step.options.assert;
+  const after = step.options.after;
+  if (!isFn(assert) && !isFn(after) && parentHooks.length === 0 && !cacheStore) return null;
+  const lines = [
+    ...PRELUDE,
+    `var __base = ${JSON.stringify(step.name)};`,
+    ...testShims(strict),
+    `var res = { status: pm.response.code, headers: pm.response.headers && pm.response.headers.toObject ? pm.response.headers.toObject() : {}, body: (function(){ try { return pm.response.json(); } catch (e) { return pm.response.text(); } })() };`
+  ];
+  if (isFn(assert)) lines.push(...runHook(assert.toString(), "res"));
+  if (isFn(after)) lines.push(...runHook(after.toString(), "res"));
+  for (const hook of parentHooks) lines.push(...runHook(hook.toString(), "__s.__out"));
+  lines.push(`__save();`);
+  if (cacheStore) lines.push(...cacheStoreLines(cacheStore));
+  return lines;
+}
+function hookLines(srcs, outExpr) {
+  const lines = [];
+  for (const src of srcs) lines.push(...runHook(src, outExpr));
+  return lines;
+}
+function cacheHitPrerequest(store, hooks, strict = true) {
+  const hookSrcs = hooks.map((h) => h.toString());
+  return [
+    ...PRELUDE,
+    `var __base = "sub-journey";`,
+    ...testShims(strict),
+    `var __exp = pm.collectionVariables.get(${JSON.stringify(store.jcVar)});`,
+    `if (__exp && Date.now() < Number(__exp)) {`,
+    `  var __v = pm.collectionVariables.get(${JSON.stringify(store.jcvVar)});`,
+    `  if (__v) { try { __s.__out = JSON.parse(__v); } catch (e) {} }`,
+    ...hookLines(hookSrcs, "__s.__out").map((l) => "  " + l),
+    `  __save();`,
+    `  pm.execution.skipRequest();`,
+    `}`
+  ];
+}
+function cacheSkipPrerequest(store) {
+  return [
+    `var __exp = pm.collectionVariables.get(${JSON.stringify(store.jcVar)});`,
+    `if (__exp && Date.now() < Number(__exp)) { pm.execution.skipRequest(); }`
+  ];
+}
+function cacheExpirySet(store) {
+  return [
+    `var __exp = pm.collectionVariables.get(${JSON.stringify(store.jcVar)});`,
+    `if (!(__exp && Date.now() < Number(__exp))) { pm.collectionVariables.set(${JSON.stringify(store.jcVar)}, String(${store.expExpr})); }`
+  ];
+}
+function cacheStoreLines(store) {
+  return [
+    `var __exp = pm.collectionVariables.get(${JSON.stringify(store.jcVar)});`,
+    `if (!(__exp && Date.now() < Number(__exp))) {`,
+    `  pm.collectionVariables.set(${JSON.stringify(store.jcVar)}, String(${store.expExpr}));`,
+    `  if (__s.__out !== undefined) pm.collectionVariables.set(${JSON.stringify(store.jcvVar)}, JSON.stringify(__s.__out));`,
+    `}`
+  ];
+}
+function journeyResetEvent(journeyName) {
+  const v = JSON.stringify(STATE_VAR);
+  const n = JSON.stringify(journeyName);
+  return [
+    `var __s = JSON.parse(pm.collectionVariables.get(${v}) || "{}");`,
+    `if (__s.__journey !== ${n}) { pm.collectionVariables.set(${v}, JSON.stringify({ __journey: ${n} })); }`
+  ];
+}
+function collectionResetScript() {
+  return [
+    `var __all = pm.collectionVariables.toObject ? pm.collectionVariables.toObject() : {};`,
+    `Object.keys(__all).forEach(function(k){`,
+    `  if (k === ${JSON.stringify(STATE_VAR)} || k.indexOf("__jc_") === 0 || k.indexOf("__jcv_") === 0) {`,
+    `    pm.collectionVariables.unset(k);`,
+    `  }`,
+    `});`,
+    `if (pm.execution && pm.execution.skipRequest) pm.execution.skipRequest();`
+  ];
+}
+
+// src/index.ts
+var SUB_JOURNEY_NOTE = "Sub-journey invocation. Postman's sidebar lists folders above sibling requests, so a sub-journey invoked mid-pipeline looks reordered there \u2014 execution order (Collection Runner / Newman) still follows the journey pipeline.";
+var CACHE_NOTE = " Cached: a collection variable holds an expiry timestamp; while it is valid this folder's requests are skipped (pm.execution.skipRequest), so a shared sub-journey runs once per collection run. The window opens on the child's terminal request, so a multi-request child runs fully on the cold pass and skips as a whole on a hit. Without --thread-state the child's output() is not carried into Postman variables; with it, a hit still delivers the output.";
+var ENV_PROXY = new Proxy({}, {
+  get(_target, key) {
+    return `{{${key}}}`;
+  },
+  has() {
+    return true;
+  }
+});
+async function tryResolve(v) {
+  if (v === void 0) return void 0;
+  if (typeof v !== "function") return v;
+  try {
+    return await v();
+  } catch {
+    return void 0;
+  }
+}
+function isUnresolved(v) {
+  return v == null || typeof v === "number" && Number.isNaN(v);
+}
+function buildPostmanUrl(path, baseUrl, params, query) {
+  const substituted = path.replace(/\{([^}]+)\}/g, (_, key) => {
+    const val = params?.[key];
+    return isUnresolved(val) ? `{{${key}}}` : encodeURIComponent(String(val));
+  });
+  const raw = baseUrl + substituted;
+  const segments = substituted.replace(/^\//, "").split("/").filter(Boolean);
+  const queryItems = Object.entries(query ?? {}).filter(([, v]) => !isUnresolved(v)).map(([key, value]) => ({ key, value: String(value) }));
+  return {
+    raw: queryItems.length ? `${raw}?${queryItems.map((q) => `${q.key}=${q.value}`).join("&")}` : raw,
+    host: [baseUrl],
+    path: segments,
+    query: queryItems
+  };
+}
+async function buildRequestItem(s, threadState = false) {
+  const params = threadState && typeof s.options.params === "function" ? void 0 : await tryResolve(s.options.params);
+  let query = await tryResolve(s.options.query);
+  if (threadState && typeof s.options.query === "function" && query && typeof query === "object") {
+    query = Object.fromEntries(Object.keys(query).map((k) => [k, `{{__q_${k}}}`]));
+  }
+  const headers = await tryResolve(s.options.headers);
+  const body = threadState && typeof s.options.body === "function" ? "{{__journey_body}}" : await tryResolve(s.options.body);
+  const baseUrl = s.options.endpoint.baseUrl ?? "{{BASE_URL}}";
+  const url = buildPostmanUrl(s.options.endpoint.path, baseUrl, params, query);
+  const headerItems = Object.entries(headers ?? {}).map(([key, value]) => ({
+    key,
+    value: String(value)
+  }));
+  let postmanBody;
+  if (body !== void 0) {
+    postmanBody = {
+      mode: "raw",
+      raw: typeof body === "string" ? body : JSON.stringify(body, null, 2),
+      options: { raw: { language: "json" } }
+    };
+  }
+  return {
+    name: s.name,
+    request: {
+      method: s.options.endpoint.method.toUpperCase(),
+      header: headerItems,
+      url,
+      ...postmanBody ? { body: postmanBody } : {}
+    }
+  };
+}
+function inputsToVariables(inputs) {
+  if (!inputs || typeof inputs !== "object") return [];
+  return Object.entries(inputs).map(([key, value]) => ({
+    key,
+    value: typeof value === "string" ? value : JSON.stringify(value)
+  }));
+}
+var SCRIPT = (exec) => ({ type: "text/javascript", exec });
+async function buildItems(nodes, opts, parentHooks = [], cacheStore) {
+  const items = [];
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const isLast = i === nodes.length - 1;
+    const hooksHere = isLast ? parentHooks : [];
+    const storeHere = isLast ? cacheStore : void 0;
+    if (node.kind === "step") {
+      const item = await buildRequestItem(node.def, opts.threadState);
+      if (opts.threadState) {
+        const events = [];
+        const pre = stepPrerequest(node.def);
+        const test = stepTest(node.def, hooksHere, storeHere, opts.strict);
+        if (pre) events.push({ listen: "prerequest", script: SCRIPT(pre) });
+        if (test) events.push({ listen: "test", script: SCRIPT(test) });
+        if (events.length > 0) item.event = events;
+      } else if (storeHere) {
+        item.event = [{ listen: "test", script: SCRIPT(cacheExpirySet(storeHere)) }];
+      }
+      items.push(item);
+      continue;
+    }
+    const ownHooks = opts.threadState ? [node.assert, node.after].filter(Boolean) : [];
+    const childHooks = [...ownHooks, ...hooksHere];
+    let childStore = storeHere;
+    const folderPre = [];
+    if (opts.threadState && node.inputParam && node.inputsSrc) {
+      folderPre.push(...subInputSeed(node.inputParam, node.inputsSrc));
+    }
+    if (node.cacheKey) {
+      const safe = node.cacheKey.replace(/[^A-Za-z0-9]+/g, "_");
+      const store = {
+        jcVar: `__jc_${safe}`,
+        jcvVar: `__jcv_${safe}`,
+        expExpr: node.cacheTtlMs !== void 0 ? `Date.now() + ${node.cacheTtlMs}` : "9999999999999"
+      };
+      childStore = store;
+      folderPre.push(
+        ...opts.threadState ? cacheHitPrerequest(store, ownHooks, opts.strict) : cacheSkipPrerequest(store)
+      );
+    }
+    const folder = {
+      name: node.name,
+      item: await buildItems(node.nodes, opts, childHooks, childStore),
+      description: node.cacheKey ? SUB_JOURNEY_NOTE + CACHE_NOTE : SUB_JOURNEY_NOTE
+    };
+    const variables = inputsToVariables(node.inputs);
+    if (variables.length > 0) folder.variable = variables;
+    if (folderPre.length > 0) folder.event = [{ listen: "prerequest", script: SCRIPT(folderPre) }];
+    items.push(folder);
+  }
+  return items;
+}
+async function buildFolder(name, nodes, opts = {}) {
+  const threadState = opts.threadState ?? false;
+  const strict = threadState && !opts.lenient;
+  const folder = { name, item: await buildItems(nodes, { threadState, strict }) };
+  if (threadState) {
+    folder.event = [{ listen: "prerequest", script: SCRIPT(journeyResetEvent(name)) }];
+  }
+  return folder;
+}
+function resetFolder() {
+  return {
+    name: "Journey: reset state (auto)",
+    item: [
+      {
+        name: "reset",
+        event: [{ listen: "prerequest", script: SCRIPT(collectionResetScript()) }],
+        request: {
+          method: "GET",
+          header: [],
+          url: {
+            raw: "https://journey.invalid/reset",
+            host: ["journey", "invalid"],
+            path: ["reset"],
+            query: []
+          }
+        }
+      }
+    ]
+  };
+}
+function buildCollection(name, folders, opts = {}) {
+  return {
+    info: {
+      name,
+      schema: "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+    },
+    item: opts.reset ? [resetFolder(), ...folders] : [...folders]
+  };
+}
+function buildEnvironment(name, values) {
+  return {
+    name,
+    values: Object.entries(values).map(([key, value]) => ({ key, value, enabled: true }))
+  };
+}
+export {
+  ENV_PROXY,
+  buildCollection,
+  buildEnvironment,
+  buildFolder
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@usejourney/postman-adapter",
+  "version": "0.1.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/femoral/journey.git",
+    "directory": "packages/postman-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"
+  ],
+  "devDependencies": {
+    "@usejourney/core": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests"
+  }
+}