postman-code-generators

postman-code-generators is the engine behind Postman’s “Code” snippet panel, converting a Postman SDK Request object into runnable code across more than 30 language and library combinations — from cURL and Python Requests to Go, Rust Reqwest, and PowerShell. It exposes a small library API (getLanguageList, getOptions, convert) that any Node.js tool can call to turn an API request definition into copy-paste code for a target HTTP client, without needing to understand every target language’s request syntax.

Internally the project is a monorepo of independent codegen packages, one per language/variant pair, each implementing its own request parser and snippet builder behind a shared getOptions/convert contract. This isolates language-specific quirks — indentation styles, timeout options, multi-file form-data handling — inside each codegen package while the root package aggregates them into one unified, callback-based API surface.

What You Get

• A unified getLanguageList(), getOptions(), convert() API spanning 34 codegen packages for 20+ languages and their common HTTP client variants
• Per-codegen configurable options such as indentation style/count, request timeout, redirect-following, and request-body trimming
• Correct handling of Postman-specific request features — multipart form-data with multiple files per field, GraphQL bodies, and auto-injected Content-Type headers
• A shared structural test contract (structure.test.js) plus per-codegen Newman-based fixture tests, so every new language addition is verified against the same baseline
• CLI-friendly packaging scripts (npm run package) that produce a distributable zip per codegen for embedding in other tools

Common Use Cases

• Powering Postman’s own “Code” tab, which shows a ready-to-paste request snippet in the developer’s language of choice
• Building custom API documentation or developer portals that need to show multi-language request examples from a single request definition
• Generating client-side integration snippets for internal API testing or onboarding tools built on top of the Postman Collection SDK
• Extending API tooling with support for a new language/HTTP client pair by adding a self-contained codegen package that follows the shared contract

Under The Hood

Architecture The root package (lib/index.js) is a thin dispatcher: it loads a static languageMap registry (lib/assets/languages.js) that pairs every {lang, variant} combination with its codegen’s exported main module, then implements getLanguageList, getOptions, and convert purely by filtering and delegating into that map. Each of the 34 codegens/* folders is a fully self-contained package (own package.json, lib/, test/, npm/ scripts) exposing getOptions() and convert(request, options, callback), with request parsing (parseRequest.js) and formatting utilities (util.js) kept local to the codegen. Adding a new language means adding a new codegen folder and registering it in languages.js — the dispatch core never changes. One notable coupling point: the root reaches into postman-collection/lib/collection/request (an internal path) rather than the package’s public export, tying the two projects together more tightly than a typical peer dependency.

Tech Stack Node.js >=18, CommonJS throughout. Core dependencies are lodash, postman-collection (Postman’s own SDK for representing Request objects), async, shelljs, and detect-package-manager (used by internal build scripts, not by generated code). Each codegen sub-package additionally declares devDependencies matching the ecosystem it targets (e.g. axios, form-data, qs for nodejs-axios) solely to validate its own Newman-driven fixture tests — these are never bundled into the emitted snippet. Testing runs on Mocha/Chai with Istanbul/NYC coverage; linting uses ESLint 5.x configured with eslint-plugin-jsdoc, eslint-plugin-security, and eslint-plugin-lodash; browser bundling for applicable codegens goes through Browserify/Watchify. CI is GitHub Actions (test.yml, draft-new-release.yml, publish-new-release.yml), with a deepinstall.js script orchestrating per-codegen dependency installs across the monorepo.

Code Quality Testing is layered: root-level test/unit and test/system suites cover the aggregator API, while every codegen carries its own test/structure.test.js (a shared contract every codegen must satisfy — valid option objects, non-empty snippet output) plus test/sanity and test/newman suites that run the generated snippet against a real Newman-executed request to confirm it behaves correctly. Error handling is consistently Node-style error-first callbacks matching the public API’s own callback signature, with plain string error messages rather than custom error classes. Naming is consistent lowerCamelCase, and JSDoc comments annotate nearly every exported function (enforced via eslint-plugin-jsdoc). There are no TypeScript type definitions, and the toolchain (ESLint 5, Mocha 6) is dated relative to current tooling, though it is applied thoroughly and consistently across all 34 sub-packages.

What Makes It Unique The project’s distinguishing trait isn’t a novel algorithm but a disciplined structural contract enforced across 34 independently-maintained codegen packages: the same shared getOptions/convert interface, the same structure-test suite, and the same Newman-based verification step apply whether the target is cURL, PowerShell, R, or Rust. That consistency is what lets Postman ship one “Code” panel experience across such a wide language surface, and what lets contributors add a brand-new language without touching the aggregator’s dispatch logic — a plugin-registry pattern applied with unusual rigor rather than a conceptually new technique.