@powerduck/openapi-codegen 0.4.1 → 0.4.3

package/README.md

@@ -6,6 +6,7 @@ Generate runnable HTTP request examples from parsed OpenAPI documents for **21 l
 
 ## Features
 
+- No need for Node environment support
 - Supports parsed OpenAPI documents, including OpenAPI 3.2
 - Generates readable HTTP request examples across 41 generators
 - Resolves path, query, header, and cookie parameters
@@ -415,129 +416,6 @@ Before committing snapshot changes, inspect the diff:
 git diff
 ```
 
-## Releasing
-
-Before releasing, verify that:
-
-- The working tree is clean
-- You are on the intended branch
-- The full validation suite passes
-- You are authenticated with npm
-- The package is owned by your npm account or organization
-- The Git remote points to the intended repository
-
-Check the repository state:
-
-```bash
-git status
-git remote -v
-```
-
-Sign in to npm:
-
-```bash
-npm login
-```
-
-Inspect the package contents without publishing:
-
-```bash
-npm pack --dry-run
-```
-
-### Patch Release
-
-Use a patch release for backward-compatible bug fixes:
-
-```bash
-npm run release:patch
-```
-
-Example:
-
-```text
-0.4.0 → 0.4.1
-```
-
-### Minor Release
-
-Use a minor release for backward-compatible features:
-
-```bash
-npm run release:minor
-```
-
-Example:
-
-```text
-0.4.0 → 0.5.0
-```
-
-### Major Release
-
-Use a major release for breaking changes:
-
-```bash
-npm run release:major
-```
-
-Example:
-
-```text
-0.4.0 → 1.0.0
-```
-
-The release scripts run the configured checks, update the package version, create a Git commit and tag, and push the commit and tags.
-
-Publish the public scoped package:
-
-```bash
-npm publish --access public
-```
-
-## Initial GitHub Setup
-
-Initialize the repository and push it to GitHub:
-
-```bash
-git init
-git branch -M main
-git remote add origin https://github.com/PowerDuckie/-powerduck-openapi-codegen.git
-git add .
-git commit -m "feat: initialize OpenAPI code generator"
-git push -u origin main
-```
-
-If `origin` already exists, update it:
-
-```bash
-git remote set-url origin https://github.com/PowerDuckie/-powerduck-openapi-codegen.git
-git push -u origin main
-```
-
-## Project Structure
-
-A typical project layout is:
-
-```text
-.
-├── demo/
-├── src/
-│   ├── core/
-│   ├── emitters/
-│   ├── generators/
-│   ├── common.ts
-│   ├── index.ts
-│   └── types.ts
-├── tests/
-│   ├── fixtures/
-│   ├── fuzz.test.ts
-│   └── snapshot.test.ts
-├── package.json
-├── README.md
-└── tsconfig.json
-```
-
 ## Security
 
 Generated source code can contain request URLs, headers, parameter values, and credentials supplied to the generator.

package/dist/index.js

@@ -877,161 +877,235 @@ function form(value) {
 }
 
 // src/core/normalize.ts
-function assertIsRecord(v) {
-  if (!isRecord(v)) throw new TypeError("expected record object");
+var HTTP_METHODS = /* @__PURE__ */ new Set([
+  "get",
+  "put",
+  "post",
+  "delete",
+  "options",
+  "head",
+  "patch",
+  "trace"
+]);
+var CONTENT_PREFERENCES = [
+  /^application\/(?:[a-z0-9.+-]+\+)?json(?:\s*;.*)?$/i,
+  /^application\/x-www-form-urlencoded(?:\s*;.*)?$/i,
+  /^multipart\/form-data(?:\s*;.*)?$/i,
+  /^text\/[a-z0-9.+-]+(?:\s*;.*)?$/i,
+  /^application\/octet-stream(?:\s*;.*)?$/i
+];
+function own(object, key2) {
+  return Object.prototype.hasOwnProperty.call(object, key2);
+}
+function nonBlankString2(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function normalizeMethod2(value) {
+  const method = nonBlankString2(value)?.toLowerCase();
+  if (!method || !HTTP_METHODS.has(method)) {
+    throw new Error(`Unsupported HTTP method: ${String(value)}`);
+  }
+  return method;
 }
 function pickContent(content) {
-  if (!content) {
-    return void 0;
-  }
-  const entries = Object.entries(content);
-  const preferred = [
-    /^application\/([a-z0-9.+-]+\+)?json(?:;.*)?$/i,
-    /^application\/x-www-form-urlencoded(?:;.*)?$/i,
-    /^multipart\/form-data(?:;.*)?$/i,
-    /^text\//i,
-    /^application\/octet-stream(?:;.*)?$/i
-  ];
-  for (const matcher of preferred) {
-    const match = entries.find(([mediaType]) => matcher.test(mediaType));
-    if (match) {
-      return match;
-    }
+  if (!isRecord(content)) return void 0;
+  const entries = Object.entries(content).filter(
+    ([mediaType]) => mediaType.trim().length > 0
+  );
+  for (const matcher of CONTENT_PREFERENCES) {
+    const match = entries.find(([mediaType]) => matcher.test(mediaType.trim()));
+    if (match) return match;
   }
   return entries[0];
 }
 function mergeParameters(pathParameters, operationParameters, resolver) {
   const merged = /* @__PURE__ */ new Map();
-  for (const entry of [...pathParameters, ...operationParameters]) {
-    const parameter2 = resolver.deref(entry);
-    if (!isRecord(parameter2)) continue;
-    const nameVal = parameter2.name;
-    const inVal = parameter2.in;
-    if (typeof nameVal !== "string" || typeof inVal !== "string") continue;
-    const key2 = `${inVal}:${nameVal}`;
-    if (!merged.has(key2)) {
-      merged.set(key2, parameter2);
+  const add = (entries, overwrite) => {
+    if (!Array.isArray(entries)) return;
+    for (const entry of entries) {
+      const parameter2 = resolver.deref(entry);
+      if (!isRecord(parameter2)) continue;
+      const name = nonBlankString2(parameter2.name);
+      const location = nonBlankString2(parameter2.in)?.toLowerCase();
+      if (!name || !location) continue;
+      const key2 = `${location}\0${name}`;
+      if (overwrite || !merged.has(key2)) {
+        merged.set(key2, parameter2);
+      }
     }
-  }
+  };
+  add(pathParameters, false);
+  add(operationParameters, true);
   return [...merged.values()];
 }
-function readExampleForMediaType(mediaTypeObject, resolver, ctx) {
-  if (!isRecord(mediaTypeObject)) return void 0;
-  if (mediaTypeObject.example !== void 0) {
-    return mediaTypeObject.example;
-  }
-  if (isRecord(mediaTypeObject.examples)) {
-    const first = Object.values(mediaTypeObject.examples)[0];
-    if (first !== void 0) {
-      const resolvedExampleObj = resolver.deref(first);
-      if (isRecord(resolvedExampleObj) && resolvedExampleObj.value !== void 0) {
-        return resolvedExampleObj.value;
-      }
+function readFirstExampleValue(examples, resolver) {
+  if (!isRecord(examples)) return void 0;
+  for (const entry of Object.values(examples)) {
+    const resolved = resolver.deref(entry);
+    if (isRecord(resolved) && own(resolved, "value")) {
+      return resolved.value;
+    }
+    if (!isRecord(resolved) && resolved !== void 0) {
+      return resolved;
     }
   }
-  return example(mediaTypeObject.schema, resolver, void 0, 0, ctx);
+  return void 0;
 }
-function readFirstExampleValue(examples, resolver) {
-  if (!isRecord(examples)) {
-    return void 0;
-  }
-  const firstEntry = Object.values(examples)[0];
-  if (firstEntry === void 0) {
-    return void 0;
+function readExampleForMediaType(mediaTypeObject, resolver, context) {
+  const resolved = resolver.deref(mediaTypeObject);
+  if (!isRecord(resolved)) return void 0;
+  if (own(resolved, "example")) {
+    return resolved.example;
+  }
+  const examplesValue = readFirstExampleValue(resolved.examples, resolver);
+  if (examplesValue !== void 0) {
+    return examplesValue;
+  }
+  return example(resolved.schema, resolver, void 0, 0, context);
+}
+function resolveServerUrl(server) {
+  if (!isRecord(server)) return void 0;
+  let url = nonBlankString2(server.url);
+  if (!url) return void 0;
+  const variables = isRecord(server.variables) ? server.variables : void 0;
+  url = url.replace(/\{([^{}]+)\}/g, (placeholder, variableName) => {
+    if (!variables) return placeholder;
+    const variable = variables[variableName];
+    if (!isRecord(variable)) return placeholder;
+    const value = firstDefined(variable.default, variable.example);
+    return value === void 0 ? placeholder : encodeURIComponent(String(value));
+  });
+  return url;
+}
+function firstServerUrl(servers) {
+  if (!Array.isArray(servers)) return void 0;
+  for (const server of servers) {
+    const url = resolveServerUrl(server);
+    if (url) return url;
   }
-  const resolved = resolver.deref(firstEntry);
-  return isRecord(resolved) ? resolved.value : void 0;
+  return void 0;
 }
-function normalize(options) {
-  const root = options.document;
-  const preWarnings = lightweightOpenAPIPreCheck(root);
-  const resolver = new RefResolver(root, !!options.softRefMode);
-  const rootRec = isRecord(root) ? root : void 0;
-  const paths = rootRec?.paths;
-  let pathItem;
-  if (isRecord(paths)) {
-    pathItem = resolver.deref(paths[options.path]);
-  }
-  const methodLower = String(options.method).toLowerCase();
-  const operation = isRecord(pathItem) ? resolver.deref(pathItem[methodLower]) : void 0;
-  if (!isRecord(operation)) {
-    throw new Error("Operation not found");
-  }
-  const pathItemParams = isRecord(pathItem) && Array.isArray(pathItem.parameters) ? pathItem.parameters : [];
-  const opParams = Array.isArray(operation.parameters) ? operation.parameters : [];
-  const mergedParameters = mergeParameters(pathItemParams, opParams, resolver);
-  const parameterEntries = mergedParameters.map((parameter2) => {
-    assertIsRecord(parameter2);
-    return {
-      name: String(parameter2.name),
-      in: String(parameter2.in),
-      value: firstDefined(
-        parameter2.example,
-        readFirstExampleValue(parameter2.examples, resolver),
-        example(parameter2.schema, resolver)
-      ),
-      style: typeof parameter2.style === "string" ? parameter2.style : void 0,
-      explode: typeof parameter2.explode === "boolean" ? parameter2.explode : void 0,
-      allowReserved: typeof parameter2.allowReserved === "boolean" ? parameter2.allowReserved : void 0
-    };
-  });
-  const requestBody = resolver.deref(operation.requestBody);
-  const chosen = isRecord(requestBody) ? pickContent(requestBody.content) : void 0;
-  const bodyCtx = { isRequestBody: true, isResponse: false };
-  const body = chosen ? {
-    mediaType: chosen[0],
-    value: readExampleForMediaType(chosen[1], resolver, bodyCtx),
-    encoding: isRecord(chosen[1]) ? chosen[1].encoding : void 0
-  } : void 0;
-  const security = [];
-  let effectiveSecurity = [];
-  if (Array.isArray(operation.security)) {
-    effectiveSecurity = operation.security;
-  } else if (rootRec && Array.isArray(rootRec.security)) {
-    effectiveSecurity = rootRec.security;
-  }
-  const components = rootRec?.components;
-  const securitySchemes = isRecord(components) ? components.securitySchemes : void 0;
-  for (const requirement of effectiveSecurity) {
+function resolveBaseUrl(explicitServerUrl, operation, pathItem, root) {
+  return nonBlankString2(explicitServerUrl) ?? firstServerUrl(operation.servers) ?? firstServerUrl(pathItem.servers) ?? firstServerUrl(root.servers) ?? "https://example.com";
+}
+function resolveSecuritySchemes(root) {
+  if (!isRecord(root.components)) return void 0;
+  return isRecord(root.components.securitySchemes) ? root.components.securitySchemes : void 0;
+}
+function normalizeSecurity(root, operation, resolver, securityValues) {
+  const requirements = Array.isArray(operation.security) ? operation.security : Array.isArray(root.security) ? root.security : [];
+  const schemes = resolveSecuritySchemes(root);
+  if (!schemes) return [];
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const requirement of requirements) {
     if (!isRecord(requirement)) continue;
     for (const name of Object.keys(requirement)) {
-      let scheme;
-      if (isRecord(securitySchemes)) {
-        scheme = resolver.deref(securitySchemes[name]);
-      }
+      if (seen.has(name)) continue;
+      const scheme = resolver.deref(schemes[name]);
       if (!isRecord(scheme)) continue;
-      security.push({
+      const type = nonBlankString2(scheme.type);
+      if (!type) continue;
+      seen.add(name);
+      result.push({
         name,
-        type: String(scheme.type),
-        scheme: typeof scheme.scheme === "string" ? scheme.scheme : void 0,
-        in: typeof scheme.in === "string" ? scheme.in : void 0,
-        paramName: typeof scheme.name === "string" ? scheme.name : void 0,
-        value: options.securityValues?.[name] ?? `{{${name}}}`
+        type,
+        scheme: nonBlankString2(scheme.scheme)?.toLowerCase(),
+        in: nonBlankString2(scheme.in)?.toLowerCase(),
+        paramName: nonBlankString2(scheme.name),
+        value: securityValues?.[name] ?? `{{${name}}}`
       });
     }
   }
-  let baseUrl = options.serverUrl;
-  if (!baseUrl && Array.isArray(operation.servers) && isRecord(operation.servers[0])) {
-    baseUrl = String(operation.servers[0].url);
+  return result;
+}
+function normalize(options) {
+  if (!isRecord(options)) {
+    throw new TypeError("normalize options must be an object");
+  }
+  if (!isRecord(options.document)) {
+    throw new TypeError("OpenAPI document root must be a plain object");
   }
-  if (!baseUrl && isRecord(pathItem) && Array.isArray(pathItem.servers) && isRecord(pathItem.servers[0])) {
-    baseUrl = String(pathItem.servers[0].url);
+  const root = options.document;
+  const preWarnings = lightweightOpenAPIPreCheck(root);
+  const resolver = new RefResolver(root, options.softRefMode === true);
+  const path = nonBlankString2(options.path);
+  if (!path) {
+    throw new TypeError("OpenAPI path must be a non-empty string");
   }
-  if (!baseUrl && Array.isArray(rootRec?.servers) && isRecord((rootRec?.servers)[0])) {
-    baseUrl = String(
-      (rootRec?.servers)[0].url
-    );
+  const method = normalizeMethod2(options.method);
+  if (!isRecord(root.paths)) {
+    throw new Error("OpenAPI document does not define a valid paths object");
   }
-  if (!baseUrl) {
-    baseUrl = "https://example.com";
+  if (!own(root.paths, path)) {
+    throw new Error(`Path not found: ${path}`);
   }
+  const pathItem = resolver.deref(root.paths[path]);
+  if (!isRecord(pathItem)) {
+    throw new Error(`Invalid Path Item Object: ${path}`);
+  }
+  const operation = resolver.deref(pathItem[method]);
+  if (!isRecord(operation)) {
+    throw new Error(`Operation not found: ${method.toUpperCase()} ${path}`);
+  }
+  const mergedParameters = mergeParameters(
+    pathItem.parameters,
+    operation.parameters,
+    resolver
+  );
+  const parameters = mergedParameters.map(
+    (parameter2) => {
+      const name = nonBlankString2(parameter2.name);
+      const location = nonBlankString2(parameter2.in)?.toLowerCase();
+      if (!name || !location) {
+        throw new TypeError("Resolved parameter must define name and in");
+      }
+      const parameterExample = own(parameter2, "example") ? parameter2.example : void 0;
+      return {
+        name,
+        in: location,
+        value: firstDefined(
+          parameterExample,
+          readFirstExampleValue(parameter2.examples, resolver),
+          example(parameter2.schema, resolver)
+        ),
+        style: nonBlankString2(parameter2.style),
+        explode: typeof parameter2.explode === "boolean" ? parameter2.explode : void 0,
+        allowReserved: typeof parameter2.allowReserved === "boolean" ? parameter2.allowReserved : void 0
+      };
+    }
+  );
+  const requestBody = resolver.deref(operation.requestBody);
+  const chosen = isRecord(requestBody) ? pickContent(requestBody.content) : void 0;
+  const bodyContext = {
+    isRequestBody: true,
+    isResponse: false
+  };
+  let body;
+  if (chosen) {
+    const mediaTypeObject = resolver.deref(chosen[1]);
+    body = {
+      mediaType: chosen[0],
+      value: readExampleForMediaType(mediaTypeObject, resolver, bodyContext),
+      encoding: isRecord(mediaTypeObject) ? mediaTypeObject.encoding : void 0
+    };
+  }
+  const security = normalizeSecurity(
+    root,
+    operation,
+    resolver,
+    options.securityValues
+  );
+  const baseUrl = resolveBaseUrl(options.serverUrl, operation, pathItem, root);
   return {
     preWarnings,
-    method: String(options.method).toUpperCase(),
+    method: method.toUpperCase(),
     baseUrl,
-    path: options.path,
-    parameters: parameterEntries,
-    headers: parameterEntries.filter((parameter2) => parameter2.in === "header"),
+    path,
+    parameters,
+    headers: parameters.filter((parameter2) => parameter2.in === "header"),
     body,
     security
   };
@@ -1075,7 +1149,7 @@ function escapeCString(value) {
   }
   return `${escaped}"`;
 }
-function nonBlankString2(value, fallback) {
+function nonBlankString3(value, fallback) {
   return typeof value === "string" && value.trim().length > 0 ? value : fallback;
 }
 function safeComment(value) {
@@ -1157,9 +1231,9 @@ function emit(request) {
       );
       if (entry.file && isFileValue(entry.value)) {
         const fileValue = entry.value;
-        const path = nonBlankString2(fileValue.path, DEFAULT_FILE_PATH);
-        const name = nonBlankString2(fileValue.name, DEFAULT_FILE_NAME);
-        const contentType = nonBlankString2(
+        const path = nonBlankString3(fileValue.path, DEFAULT_FILE_PATH);
+        const name = nonBlankString3(fileValue.name, DEFAULT_FILE_NAME);
+        const contentType = nonBlankString3(
           fileValue.contentType,
           DEFAULT_BINARY_MEDIA_TYPE
         );
@@ -1281,7 +1355,7 @@ function emit(request) {
 var libcurl_default = createGenerator("c", "libcurl", (request) => emit(request));
 
 // src/emitters/csharp/restsharp.ts
-function nonBlankString3(value, fallback) {
+function nonBlankString4(value, fallback) {
   return typeof value === "string" && value.trim().length > 0 ? value : fallback;
 }
 function safeComment2(value) {
@@ -1313,9 +1387,9 @@ function emit2(request) {
       const fieldName = String(item.name);
       if (item.file && isFileValue(item.value)) {
         const fileValue = item.value;
-        const filePath = nonBlankString3(fileValue.path, DEFAULT_FILE_PATH);
-        const fileName = nonBlankString3(fileValue.name, DEFAULT_FILE_NAME);
-        const contentType = nonBlankString3(
+        const filePath = nonBlankString4(fileValue.path, DEFAULT_FILE_PATH);
+        const fileName = nonBlankString4(fileValue.name, DEFAULT_FILE_NAME);
+        const contentType = nonBlankString4(
           fileValue.contentType,
           DEFAULT_BINARY_MEDIA_TYPE
         );
@@ -1604,7 +1678,7 @@ function emit4(request) {
 var http_default = createGenerator("dart", "http", (request) => emit4(request));
 
 // src/emitters/fsharp/httpclient.ts
-function nonBlankString4(value, fallback) {
+function nonBlankString5(value, fallback) {
   return typeof value === "string" && value.trim().length > 0 ? value : fallback;
 }
 function safeComment3(value) {
@@ -1643,9 +1717,9 @@ function emit5(request) {
       const fieldName = String(item.name);
       if (item.file && isFileValue(item.value)) {
         const fileValue = item.value;
-        const filePath = nonBlankString4(fileValue.path, DEFAULT_FILE_PATH);
-        const fileName = nonBlankString4(fileValue.name, DEFAULT_FILE_NAME);
-        const contentType = nonBlankString4(
+        const filePath = nonBlankString5(fileValue.path, DEFAULT_FILE_PATH);
+        const fileName = nonBlankString5(fileValue.name, DEFAULT_FILE_NAME);
+        const contentType = nonBlankString5(
           fileValue.contentType,
           DEFAULT_BINARY_MEDIA_TYPE
         );
@@ -1780,7 +1854,7 @@ function emit5(request) {
 var httpclient_default2 = createGenerator("fsharp", "httpclient", (request) => emit5(request));
 
 // src/emitters/go/new-request.ts
-function nonBlankString5(value, fallback) {
+function nonBlankString6(value, fallback) {
   return typeof value === "string" && value.trim().length > 0 ? value : fallback;
 }
 function safeComment4(value) {
@@ -1833,9 +1907,9 @@ function emit6(request) {
       const fieldName = String(item.name);
       if (item.file && isFileValue(item.value)) {
         const fileValue = item.value;
-        const filePath = nonBlankString5(fileValue.path, DEFAULT_FILE_PATH);
-        const fileName = nonBlankString5(fileValue.name, DEFAULT_FILE_NAME);
-        const contentType = nonBlankString5(
+        const filePath = nonBlankString6(fileValue.path, DEFAULT_FILE_PATH);
+        const fileName = nonBlankString6(fileValue.name, DEFAULT_FILE_NAME);
+        const contentType = nonBlankString6(
           fileValue.contentType,
           DEFAULT_BINARY_MEDIA_TYPE
         );
@@ -2603,7 +2677,7 @@ function emit10(request) {
 var okhttp_default = createGenerator("java", "okhttp", (request) => emit10(request));
 
 // src/emitters/java/unirest.ts
-function nonBlankString6(value, fallback) {
+function nonBlankString7(value, fallback) {
   return typeof value === "string" && value.trim().length > 0 ? value : fallback;
 }
 function safeComment8(value) {
@@ -2665,7 +2739,7 @@ function emit11(request) {
       const fieldName = String(entry.name);
       if (entry.file && isFileValue(entry.value)) {
         const fileValue = entry.value;
-        const filePath = nonBlankString6(fileValue.path, DEFAULT_FILE_PATH);
+        const filePath = nonBlankString7(fileValue.path, DEFAULT_FILE_PATH);
         if (typeof fileValue.path !== "string" || fileValue.path.trim().length === 0) {
           comments.push(`// ${safeComment8(fileComment(filePath, fieldName))}`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powerduck/openapi-codegen",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Generate HTTP client examples from OpenAPI documents.",
   "type": "module",
   "main": "./dist/index.js",