@wirebench/engine 2.2.1 → 3.1.0-rc.1

package/dist/rest/openapi/update.js

@@ -0,0 +1,456 @@
+/**
+ * Update Definition for an OpenAPI-imported REST API: a per-operation report of what a new version of
+ * the document changes.
+ *
+ * An operation is identified by its lower-cased method and its path exactly as the document writes
+ * it, the same key a request's contract link uses — so a renamed path is a removal plus an addition,
+ * never a guess by `operationId`.
+ *
+ * Schemas arrive `$ref`-resolved, which means shared and even cyclic object graphs, so nothing here
+ * serialises them: {@link sameStructure} walks both sides together and remembers the pairs it is
+ * already comparing.
+ *
+ * Applying one follows the AsyncAPI rule: both documents are re-mapped with the importer's own
+ * {@link apiFromDocument}, and a generated value follows the new document only while it still equals
+ * what the old document generated. Nothing is ever deleted: a request whose operation is gone is
+ * flagged `orphaned`, and one whose operation came back has the flag cleared.
+ *
+ * Pure: it reads two parsed documents and writes nothing.
+ */
+import { generateId } from '../../project/model.js';
+import { uniqueSlug } from '../../project/paths.js';
+import { hookKey } from '../../webhooks/model.js';
+import { createFolder } from '../model.js';
+import { apiFromDocument, webhookSourcesOf, webhooksFromDocument } from './map.js';
+/**
+ * Structural equality that terminates on cycles: a pair already under comparison is assumed equal,
+ * which is sound because any real difference is found along some other finite path.
+ */
+export function sameStructure(a, b) {
+    return compare(a, b, new Map());
+}
+function compare(a, b, seen) {
+    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;
+    let partners = seen.get(a);
+    if (partners?.has(b) === true)
+        return true;
+    if (partners === undefined) {
+        partners = new Set();
+        seen.set(a, partners);
+    }
+    partners.add(b);
+    if (Array.isArray(a)) {
+        const other = b;
+        return a.length === other.length && a.every((item, index) => compare(item, other[index], seen));
+    }
+    const left = a;
+    const right = b;
+    const keys = Object.keys(left).filter((key) => left[key] !== undefined);
+    const otherKeys = Object.keys(right).filter((key) => right[key] !== undefined);
+    return (keys.length === otherKeys.length &&
+        keys.every((key) => Object.prototype.hasOwnProperty.call(right, key) && compare(left[key], right[key], seen)));
+}
+const keyOf = (op) => `${op.method.toLowerCase()} ${op.path}`;
+function opRef(op) {
+    const ref = { method: op.method.toLowerCase(), path: op.path };
+    return op.summary === undefined ? ref : { ...ref, summary: op.summary };
+}
+/** Parameters keyed by location and name, so a reordered list is not a change. */
+function parametersByKey(parameters) {
+    const byKey = {};
+    for (const parameter of parameters)
+        byKey[`${parameter.in}:${parameter.name}`] = parameter;
+    return byKey;
+}
+/**
+ * Why one operation differs. `servers` is part of the vocabulary but never produced here: the model
+ * keeps no per-operation servers, so a server change is reported once, at the API level.
+ */
+function reasonsFor(a, b) {
+    const reasons = [];
+    if (!sameStructure(parametersByKey(a.parameters), parametersByKey(b.parameters)))
+        reasons.push('parameters');
+    if (!sameStructure(a.requestBody, b.requestBody))
+        reasons.push('request-body');
+    if (!sameStructure(a.responses, b.responses))
+        reasons.push('responses');
+    if (!sameStructure(a.security, b.security))
+        reasons.push('security');
+    return reasons;
+}
+function apiReasons(old, next) {
+    const reasons = [];
+    if (!sameStructure(old.servers, next.servers))
+        reasons.push('servers');
+    if (!sameStructure(old.security, next.security) || !sameStructure(old.securitySchemes, next.securitySchemes)) {
+        reasons.push('security');
+    }
+    if (old.info.version !== next.info.version)
+        reasons.push('version');
+    return reasons;
+}
+/**
+ * What moving from `old` to `next` would change: added and changed operations in `next`'s document
+ * order, removed ones in `old`'s, and the API-level differences.
+ */
+export function planRestUpdate(old, next) {
+    const before = new Map();
+    for (const op of old.operations)
+        if (!before.has(keyOf(op)))
+            before.set(keyOf(op), op);
+    const after = new Set(next.operations.map(keyOf));
+    const added = [];
+    const changed = [];
+    const handled = new Set();
+    for (const op of next.operations) {
+        const key = keyOf(op);
+        if (handled.has(key))
+            continue;
+        handled.add(key);
+        const previous = before.get(key);
+        if (previous === undefined) {
+            added.push(opRef(op));
+            continue;
+        }
+        const reasons = reasonsFor(previous, op);
+        if (reasons.length > 0)
+            changed.push({ op: opRef(op), reasons });
+    }
+    const removed = [...before.entries()].filter(([key]) => !after.has(key)).map(([, op]) => opRef(op));
+    return { added, removed, changed, api: apiReasons(old, next), webhooks: planWebhookUpdate(old, next) };
+}
+/**
+ * What moving from `old` to `next` would change among webhooks and callbacks: added and changed
+ * items keyed as {@link hookKey} matches them, removed ones the same way. Mirrors
+ * {@link planRestUpdate}'s per-operation comparison, over {@link webhookSourcesOf} instead of
+ * `document.operations`.
+ */
+export function planWebhookUpdate(old, next) {
+    const before = new Map(webhookSourcesOf(old).map((source) => [source.ref.key, source]));
+    const after = new Map(webhookSourcesOf(next).map((source) => [source.ref.key, source]));
+    const added = [...after.values()].filter((source) => !before.has(source.ref.key)).map((source) => source.ref);
+    const removed = [...before.values()].filter((source) => !after.has(source.ref.key)).map((source) => source.ref);
+    const changed = [];
+    for (const [key, source] of after) {
+        const previous = before.get(key);
+        if (previous === undefined)
+            continue;
+        const reasons = reasonsFor(previous.operation, source.operation);
+        if (reasons.length > 0)
+            changed.push({ item: source.ref, reasons });
+    }
+    return { added, removed, changed };
+}
+const contractKey = (request) => request.contract === undefined ? undefined : `${request.contract.method} ${request.contract.path}`;
+function requestsOf(api) {
+    const walk = (folder) => [...folder.requests, ...folder.folders.flatMap(walk)];
+    return [...api.requests, ...api.folders.flatMap(walk)];
+}
+function byContract(api) {
+    const map = new Map();
+    for (const request of requestsOf(api)) {
+        const key = contractKey(request);
+        if (key !== undefined && !map.has(key))
+            map.set(key, request);
+    }
+    return map;
+}
+/** A row's identity within its table: headers are case-insensitive, path and query names are not. */
+const rowKey = (row, caseless) => (caseless ? row.name.toLowerCase() : row.name);
+const sameRow = (a, b) => a.value === b.value && a.enabled === b.enabled;
+/**
+ * One parameter table under the per-row rule: an untouched generated row follows (or goes, when the
+ * new document dropped it), an edited or user-added row stays, and a row new to the document is
+ * appended.
+ *
+ * With one exception, {@link promoteRequired}: a row the user edited still follows the document from
+ * optional to required.
+ */
+function mergeRows(current, before, after, caseless) {
+    const index = (rows) => {
+        const map = new Map();
+        for (const row of rows)
+            if (!map.has(rowKey(row, caseless)))
+                map.set(rowKey(row, caseless), row);
+        return map;
+    };
+    const oldRows = index(before);
+    const newRows = index(after);
+    const rows = [];
+    let removed = 0;
+    let changed = false;
+    /**
+     * The one thing a kept row still follows: a parameter the new document made required turns its
+     * row on, so the request stays sendable as the document now demands. Only the box changes — the
+     * user's value is kept — and a row the user added by hand has no generated counterpart and is
+     * left alone, since the document never claimed it. In practice this is a query parameter: a path
+     * row is always on and a header row never is, so neither can make this crossing.
+     */
+    const promoteRequired = (row, generated) => {
+        if (generated === undefined || generated.enabled || row.enabled)
+            return row;
+        return newRows.get(rowKey(row, caseless))?.enabled === true ? { ...row, enabled: true } : row;
+    };
+    // Only the first untouched row of a name follows; a duplicate of it is the user's and stays.
+    const replaced = new Set();
+    for (const row of current) {
+        const key = rowKey(row, caseless);
+        const generated = oldRows.get(key);
+        if (generated === undefined || !sameRow(row, generated) || replaced.has(key)) {
+            const kept = promoteRequired(row, generated);
+            if (kept !== row)
+                changed = true;
+            rows.push(kept);
+            continue;
+        }
+        replaced.add(key);
+        const replacement = newRows.get(key);
+        if (replacement === undefined) {
+            removed += 1;
+            changed = true;
+            continue;
+        }
+        if (!sameStructure(row, replacement))
+            changed = true;
+        rows.push(replacement);
+    }
+    const present = new Set(current.map((row) => rowKey(row, caseless)));
+    let added = 0;
+    for (const [key, row] of newRows) {
+        if (oldRows.has(key) || present.has(key))
+            continue;
+        rows.push(row);
+        added += 1;
+        changed = true;
+    }
+    return { rows, added, removed, changed };
+}
+/**
+ * One request as *Update definition* follows it: orphaned when `target` is gone, restored when it
+ * came back, and otherwise the per-row and whole-field follow rule against `before` (what the old
+ * document mapped it to) and `target` (what the new one does) — untouched url/body/auth follow the
+ * new document, `pathParams`/`query`/`headers` merge row by row. Shared by an API's own requests and
+ * a webhook group's, which is why `before` may be absent (an API row with no operation to compare
+ * against) as well as `target` (an orphan).
+ */
+function followRequest(request, before, target, counters) {
+    if (target === undefined) {
+        if (request.orphaned === true)
+            return request;
+        counters.orphaned += 1;
+        return { ...request, orphaned: true };
+    }
+    let out = request;
+    if (request.orphaned === true) {
+        counters.restored += 1;
+        const { orphaned, ...rest } = request;
+        void orphaned;
+        out = rest;
+    }
+    if (before === undefined)
+        return out;
+    let rewritten = false;
+    if (out.url === before.url && out.url !== target.url) {
+        out = { ...out, url: target.url };
+        rewritten = true;
+    }
+    for (const table of ['pathParams', 'query', 'headers']) {
+        const merged = mergeRows(out[table], before[table], target[table], table === 'headers');
+        if (!merged.changed)
+            continue;
+        out = { ...out, [table]: merged.rows };
+        counters.rowsAdded += merged.added;
+        counters.rowsRemoved += merged.removed;
+        rewritten = true;
+    }
+    if (sameStructure(out.body, before.body) && !sameStructure(out.body, target.body)) {
+        out = { ...out, body: target.body };
+        rewritten = true;
+    }
+    if (sameStructure(out.auth, before.auth) && !sameStructure(out.auth, target.auth)) {
+        out = { ...out, auth: target.auth };
+        rewritten = true;
+    }
+    if (rewritten)
+        counters.rewritten += 1;
+    return out;
+}
+/**
+ * Applies `next` to an API imported from `old`: the request of every operation still in `next`
+ * follows it where untouched, the request of every operation gone is orphaned, and every new
+ * operation gets a request in the folder the importer would have put it in. Never deletes a request
+ * or a folder.
+ */
+export function applyRestUpdate(api, old, next, options = {}) {
+    const newId = options.newId ?? generateId;
+    // The old mapping's ids are never kept: only its generated values are compared.
+    const oldMapped = apiFromDocument(old, { ...options, newId: () => 'old' }).api;
+    const nextMapped = apiFromDocument(next, { ...options, newId }).api;
+    const oldReqs = byContract(oldMapped);
+    const nextReqs = byContract(nextMapped);
+    const counters = { orphaned: 0, restored: 0, rewritten: 0, rowsAdded: 0, rowsRemoved: 0 };
+    const update = (request) => {
+        const key = contractKey(request);
+        if (key === undefined)
+            return request;
+        return followRequest(request, oldReqs.get(key), nextReqs.get(key), counters);
+    };
+    const updateFolder = (folder) => ({
+        ...folder,
+        folders: folder.folders.map(updateFolder),
+        requests: folder.requests.map(update),
+    });
+    let result = { ...api, folders: api.folders.map(updateFolder), requests: api.requests.map(update) };
+    // Operations the API has no request for yet: into the folder the importer names, else the root.
+    const have = byContract(result);
+    let requestsAdded = 0;
+    let requestsAlreadyPresent = 0;
+    for (const [key, fresh] of nextReqs) {
+        if (have.has(key)) {
+            // A request the user made by hand already claims this contract; the plan still lists it as
+            // added, so it is counted here rather than silently dropped.
+            if (!oldReqs.has(key))
+                requestsAlreadyPresent += 1;
+            continue;
+        }
+        const home = nextMapped.folders.find((folder) => folder.requests.some((r) => r.id === fresh.id));
+        const place = (siblings) => ({
+            ...fresh,
+            slug: uniqueSlug(fresh.name, new Set(siblings.map((r) => r.slug))),
+            order: siblings.reduce((n, r) => Math.max(n, r.order + 1), 0),
+        });
+        requestsAdded += 1;
+        // Which existing folder is this tag's? The one with the tag's name, else — for a folder the
+        // user renamed — the one already holding a request for another of the tag's operations.
+        const existing = home === undefined ? undefined : folderFor(result, home);
+        if (home === undefined) {
+            result = { ...result, requests: [...result.requests, place(result.requests)] };
+        }
+        else if (existing !== undefined) {
+            result = {
+                ...result,
+                folders: result.folders.map((folder) => folder.id === existing.id ? { ...folder, requests: [...folder.requests, place(folder.requests)] } : folder),
+            };
+        }
+        else {
+            const folder = createFolder(home.name, {
+                id: newId(),
+                slug: uniqueSlug(home.name, new Set(result.folders.map((f) => f.slug))),
+                order: result.folders.reduce((n, f) => Math.max(n, f.order + 1), 0),
+                ...(home.description !== undefined ? { description: home.description } : {}),
+                requests: [place([])],
+            });
+            result = { ...result, folders: [...result.folders, folder] };
+        }
+    }
+    // API level: the same follow rule, against what the old document mapped to.
+    // A value absent on both sides stays absent rather than coming back as an `undefined` key.
+    if (result.baseUrl === oldMapped.baseUrl && nextMapped.baseUrl !== undefined) {
+        result = { ...result, baseUrl: nextMapped.baseUrl };
+    }
+    if (sameStructure(result.servers, oldMapped.servers) &&
+        nextMapped.servers !== undefined) {
+        result = { ...result, servers: nextMapped.servers };
+    }
+    if (sameStructure(result.auth, oldMapped.auth) && !sameStructure(result.auth, nextMapped.auth)) {
+        const { auth, ...rest } = result;
+        void auth;
+        result = nextMapped.auth === undefined ? rest : { ...rest, auth: nextMapped.auth };
+    }
+    if (result.definition !== undefined) {
+        result = { ...result, definition: { ...result.definition, version: next.declaredVersion } };
+    }
+    return {
+        api: result,
+        requestsAdded,
+        requestsAlreadyPresent,
+        requestsOrphaned: counters.orphaned,
+        requestsRestored: counters.restored,
+        requestsRewritten: counters.rewritten,
+        rowsAdded: counters.rowsAdded,
+        rowsRemoved: counters.rowsRemoved,
+    };
+}
+/**
+ * The folder in `api` that stands for the new document's tag folder `home`: the one with the tag's
+ * name, else — for a folder the user renamed — the one already holding a request for another of the
+ * tag's operations. Name first: a request the user *moved* out of the tag folder would otherwise
+ * make its new home look like the tag's, and put the new operation somewhere the user did not mean.
+ */
+function folderFor(api, home) {
+    const byName = api.folders.find((folder) => folder.name === home.name);
+    if (byName !== undefined)
+        return byName;
+    const keys = new Set(home.requests.map(contractKey).filter((key) => key !== undefined));
+    return api.folders.find((folder) => folder.requests.some((request) => {
+        const key = contractKey(request);
+        return key !== undefined && keys.has(key);
+    }));
+}
+/**
+ * Applies `next` to a webhook group imported from `old`: the same follow rule as
+ * {@link applyRestUpdate}, matched by {@link hookKey} across the group's whole tree instead of by
+ * contract. A request with no `hook` (added by hand) is left untouched; an item's `hook` — including
+ * a callback's `expression` — follows the new document, since a renamed expression is not a new
+ * item. A new webhook or callback method is appended to the group root with a unique slug and an
+ * increasing `order` — but only one truly new to `next`: an item `old` already offered and the group
+ * never held (an import that used `only` to leave it unticked) stays absent rather than coming back.
+ * Never deletes a request or a folder.
+ */
+export function applyWebhookUpdate(folder, old, next, options = {}) {
+    const newId = options.newId ?? generateId;
+    const index = (document, ids) => {
+        const mapped = webhooksFromDocument(document, { ...options, apiId: folder.source?.apiId ?? '', newId: ids });
+        const map = new Map();
+        for (const request of mapped?.folder.requests ?? []) {
+            if (request.hook !== undefined)
+                map.set(hookKey(request.hook, request.method), request);
+        }
+        return map;
+    };
+    // The old mapping's ids are never kept: only its generated values are compared.
+    const before = index(old, () => 'old');
+    const after = index(next, newId);
+    const counters = { orphaned: 0, restored: 0, rewritten: 0, rowsAdded: 0, rowsRemoved: 0 };
+    const seen = new Set();
+    const follow = (request) => {
+        if (request.hook === undefined)
+            return request;
+        const key = hookKey(request.hook, request.method);
+        seen.add(key);
+        const target = after.get(key);
+        const followed = followRequest(request, before.get(key), target, counters);
+        return target?.hook !== undefined ? { ...followed, hook: target.hook } : followed;
+    };
+    const walk = (node) => ({
+        ...node,
+        folders: node.folders.map(walk),
+        requests: node.requests.map(follow),
+    });
+    const walked = walk(folder);
+    const requests = [...walked.requests];
+    const taken = new Set(requests.map((request) => request.slug));
+    let order = requests.reduce((max, request) => Math.max(max, request.order + 1), 0);
+    let added = 0;
+    for (const [key, fresh] of after) {
+        if (seen.has(key) || before.has(key))
+            continue;
+        const slug = uniqueSlug(fresh.name, taken);
+        taken.add(slug);
+        requests.push({ ...fresh, slug, order });
+        order += 1;
+        added += 1;
+    }
+    return {
+        folder: { ...walked, requests },
+        added,
+        orphaned: counters.orphaned,
+        restored: counters.restored,
+        rewritten: counters.rewritten,
+    };
+}

package/dist/rest/postman/map.d.ts

@@ -26,3 +26,4 @@ export interface MappedPostmanApi {
  * Maps a parsed Postman Collection into a Wirebench REST API and import summary.
  */
 export declare function apiFromPostmanCollection(collection: PostmanCollection, options?: MapPostmanOptions): MappedPostmanApi;
+export declare function unsupportedCalls(text: string): string[];

package/dist/rest/postman/map.js

@@ -44,7 +44,10 @@ export function apiFromPostmanCollection(collection, options = {}) {
     const apiAuth = mapPostmanAuth(collection.auth, false, warnings);
     let folderCount = 0;
     let requestCount = 0;
-    const mapItems = (items, depth) => {
+    let scriptedRequests = 0;
+    const unsupported = new Map();
+    const collectionParts = scriptParts(collection.event, `the collection "${name}"`);
+    const mapItems = (items, depth, inherited, trail) => {
         if (depth > MAX_POSTMAN_DEPTH) {
             throw tooDeep();
         }
@@ -65,7 +68,8 @@ export function apiFromPostmanCollection(collection, options = {}) {
                 const slug = uniqueSlug(item.name, folderSlugs);
                 folderSlugs.add(slug);
                 const folderAuth = mapPostmanAuth(item.auth, false, warnings);
-                const children = mapItems(item.item, depth + 1);
+                const folderTrail = [...trail, item.name];
+                const children = mapItems(item.item, depth + 1, joinParts(inherited, scriptParts(item.event, `the folder "${folderTrail.join(' / ')}"`)), folderTrail);
                 folders.push(createFolder(item.name, {
                     id: newId(),
                     slug,
@@ -82,12 +86,26 @@ export function apiFromPostmanCollection(collection, options = {}) {
                 const slug = uniqueSlug(item.name, requestSlugs);
                 requestSlugs.add(slug);
                 const mappedRequest = mapRequest(item.name, slug, requests.length, item, newId, baseUrl, warnings);
-                requests.push(mappedRequest);
+                const parts = joinParts(inherited, scriptParts(item.event, 'the request'));
+                const scripts = importedScripts(parts);
+                if (scripts !== undefined) {
+                    scriptedRequests += 1;
+                    const calls = unsupportedCalls([...parts.pre, ...parts.post].map((part) => part.text).join('\n'));
+                    if (calls.length > 0)
+                        unsupported.set([...trail, item.name].join(' / '), new Set(calls));
+                }
+                requests.push(scripts !== undefined ? { ...mappedRequest, scripts } : mappedRequest);
             }
         }
         return { folders, requests };
     };
-    const root = mapItems(collection.item, 1);
+    const root = mapItems(collection.item, 1, collectionParts, []);
+    if (scriptedRequests > 0) {
+        warnings.push(`Scripts on ${String(scriptedRequests)} ${scriptedRequests === 1 ? 'request was' : 'requests were'} imported switched off: read them on each request's Scripts tab, then switch them on`);
+    }
+    for (const [path, calls] of unsupported) {
+        warnings.push(`The scripts of "${path}" call what Wirebench does not run: ${[...calls].sort().join(', ')}`);
+    }
     if (unmappedVariables.size > 0) {
         warnings.push(`Collection and folder variables were not imported; define them as properties: ${[...unmappedVariables].sort().join(', ')}`);
     }
@@ -425,3 +443,47 @@ function inferBaseUrl(items, depth) {
     }
     return '';
 }
+function scriptParts(events, from) {
+    const pre = [];
+    const post = [];
+    for (const event of events ?? []) {
+        (event.listen === 'prerequest' ? pre : post).push({ from, text: event.exec });
+    }
+    return { pre, post };
+}
+function joinParts(outer, inner) {
+    return { pre: [...outer.pre, ...inner.pre], post: [...outer.post, ...inner.post] };
+}
+/** The parts concatenated in the order Postman runs them, each under a comment saying where it came from. */
+function scriptText(parts) {
+    return parts.map((part) => `// --- From ${part.from} ---\n${part.text.replace(/\s+$/, '')}\n`).join('\n');
+}
+/**
+ * A request's imported scripts: the collection's, then each enclosing folder's, then its own,
+ * written against the Postman layer and switched off until someone has read them (#63).
+ */
+function importedScripts(parts) {
+    if (parts.pre.length === 0 && parts.post.length === 0)
+        return undefined;
+    return {
+        ...(parts.pre.length > 0 ? { pre: { text: scriptText(parts.pre) } } : {}),
+        ...(parts.post.length > 0 ? { post: { text: scriptText(parts.post) } } : {}),
+        api: 'postman',
+        enabled: false,
+        secrets: [],
+    };
+}
+/** The Postman calls a script makes that the layer does not run (spec §Postman), found by name. */
+const UNSUPPORTED_CALLS = [
+    [/\bpm\.sendRequest\b/, 'pm.sendRequest'],
+    [/\bpm\.cookies\.jar\b/, 'pm.cookies.jar'],
+    [/\bpm\.visualizer\b/, 'pm.visualizer'],
+    [/\bpm\.execution\.setNextRequest\b/, 'pm.execution.setNextRequest'],
+    [/\bpostman\.setNextRequest\b/, 'postman.setNextRequest'],
+    [/\brequire\s*\(/, 'require'],
+    [/\bpm\.iterationData\b/, 'pm.iterationData'],
+    [/\bpm\.vault\b/, 'pm.vault'],
+];
+export function unsupportedCalls(text) {
+    return UNSUPPORTED_CALLS.filter(([pattern]) => pattern.test(text)).map(([, name]) => name);
+}

package/dist/rest/postman/model.d.ts

@@ -91,9 +91,16 @@ export interface PostmanRequest {
     readonly auth?: PostmanAuth;
     readonly description?: string;
 }
+/** One of an item's scripts: `prerequest` or `test`, with its source joined into one text. */
+export interface PostmanEvent {
+    readonly listen: 'prerequest' | 'test';
+    readonly exec: string;
+}
 export interface PostmanItem {
     readonly name: string;
     readonly description?: string;
+    /** The item's scripts, kept as source (#63). */
+    readonly event?: readonly PostmanEvent[];
     readonly item?: readonly PostmanItem[];
     readonly request?: PostmanRequest | string;
     readonly auth?: PostmanAuth;
@@ -102,6 +109,8 @@ export interface PostmanItem {
 export interface PostmanCollection {
     readonly info: PostmanInfo;
     readonly item: readonly PostmanItem[];
+    /** The collection's own scripts, which run around every request in it. */
+    readonly event?: readonly PostmanEvent[];
     readonly auth?: PostmanAuth;
     readonly variable?: readonly PostmanVariable[];
     /** Problems found while parsing that the import summary should report. */

package/dist/rest/postman/parse.js

@@ -89,7 +89,7 @@ export function parsePostmanCollection(root) {
         throw new PostmanError('postman-not-a-collection', 'This file does not contain a Postman Collection (v2.0 or v2.1)');
     }
     const doc = root;
-    const ctx = { dynamic: new Set(), skippedItems: 0, scriptedItems: 0 };
+    const ctx = { dynamic: new Set(), skippedItems: 0 };
     const rawInfo = doc['info'];
     const desc = extractDescription(rawInfo['description']);
     const version = asString(rawInfo['version']);
@@ -106,28 +106,50 @@ export function parsePostmanCollection(root) {
     const item = parseItems(rawItems, ctx, 1);
     const auth = isRecord(doc['auth']) ? parseAuth(doc['auth'], ctx) : undefined;
     const variable = Array.isArray(doc['variable']) ? parseVariables(doc['variable'], ctx) : undefined;
-    if (hasEvents(doc))
-        ctx.scriptedItems += 1;
+    const event = parseEvents(doc);
     const warnings = [];
     if (ctx.skippedItems > 0) {
         warnings.push(`${itemCount(ctx.skippedItems)} without a request ${ctx.skippedItems === 1 ? 'was' : 'were'} skipped`);
     }
-    if (ctx.scriptedItems > 0) {
-        warnings.push(`Scripts on ${itemCount(ctx.scriptedItems)} (pre-request and test) were not imported`);
-    }
     if (ctx.dynamic.size > 0) {
         warnings.push(`Dynamic variables are not generated and must be defined as properties: ${[...ctx.dynamic].sort().join(', ')}`);
     }
     return {
         info,
         item,
+        ...(event.length > 0 ? { event } : {}),
         ...(auth !== undefined ? { auth } : {}),
         ...(variable !== undefined ? { variable } : {}),
         ...(warnings.length > 0 ? { warnings } : {}),
     };
 }
-function hasEvents(raw) {
-    return Array.isArray(raw['event']) && raw['event'].length > 0;
+/**
+ * An item's `prerequest` and `test` scripts, each as one text. `exec` may be a list of lines or one
+ * string; a script of another kind, or with no source, is left out.
+ */
+function parseEvents(raw) {
+    if (!Array.isArray(raw['event']))
+        return [];
+    const events = [];
+    for (const entry of raw['event']) {
+        if (!isRecord(entry))
+            continue;
+        const listen = entry['listen'];
+        if (listen !== 'prerequest' && listen !== 'test')
+            continue;
+        const script = isRecord(entry['script']) ? entry['script'] : undefined;
+        if (script !== undefined && script['disabled'] === true)
+            continue;
+        const exec = script?.['exec'];
+        const text = Array.isArray(exec)
+            ? exec.filter((line) => typeof line === 'string').join('\n')
+            : typeof exec === 'string'
+                ? exec
+                : '';
+        if (text.trim() !== '')
+            events.push({ listen, exec: text });
+    }
+    return events;
 }
 function parseItems(raw, ctx, depth) {
     if (depth > MAX_POSTMAN_DEPTH) {
@@ -148,14 +170,14 @@ function parseItem(raw, ctx, depth) {
     const description = extractDescription(raw['description']);
     const auth = isRecord(raw['auth']) ? parseAuth(raw['auth'], ctx) : undefined;
     const variable = Array.isArray(raw['variable']) ? parseVariables(raw['variable'], ctx) : undefined;
-    if (hasEvents(raw))
-        ctx.scriptedItems += 1;
+    const event = parseEvents(raw);
     if (Array.isArray(raw['item'])) {
         // Folder item
         const children = parseItems(raw['item'], ctx, depth + 1);
         return {
             name,
             item: children,
+            ...(event.length > 0 ? { event } : {}),
             ...(description !== undefined ? { description } : {}),
             ...(auth !== undefined ? { auth } : {}),
             ...(variable !== undefined ? { variable } : {}),
@@ -170,6 +192,7 @@ function parseItem(raw, ctx, depth) {
     return {
         name,
         request,
+        ...(event.length > 0 ? { event } : {}),
         ...(description !== undefined ? { description } : {}),
         ...(auth !== undefined ? { auth } : {}),
         ...(variable !== undefined ? { variable } : {}),