beer-swagger 4.0.1 → 4.0.2

package/generate-apis.js

@@ -2,7 +2,7 @@
 
 import fs from 'fs';
 import path from 'path';
-import { createInterface } from 'readline';
+import {createInterface} from 'readline';
 
 const ENV_PATH = path.join(process.cwd(), '.env');
 const SKIPPED_SERVICES = new Set([
@@ -166,12 +166,12 @@ function getBodyTypeName(requestBody, schemas) {
   if (!requestBody || !requestBody.content) {
     return '';
   }
-  const { content } = requestBody;
+  const {content} = requestBody;
   const firstContent = content['application/json'] || content['application/*+json'] || Object.values(content)[0];
   if (!firstContent || !firstContent.schema) {
     return '';
   }
-  const { schema } = firstContent;
+  const {schema} = firstContent;
   if (!schema.$ref) {
     return '';
   }
@@ -182,6 +182,49 @@ function getBodyTypeName(requestBody, schemas) {
   return stripped || normalized;
 }
 
+// Return the path segment immediately above the operation segment.
+function getParentPathSegment(pathStr) {
+  const segments = pathStr.split('/')
+    .filter(Boolean)
+    .filter((part) => !part.startsWith('{'));
+  return segments.length > 1 ? segments[segments.length - 2] : '';
+}
+
+// Compare two names using normalized Levenshtein similarity.
+function nameSimilarity(left, right) {
+  const a = String(left || '').replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
+  const b = String(right || '').replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
+  if (!a || !b) {
+    return 0;
+  }
+  if (a === b) {
+    return 1;
+  }
+  const previous = Array.from({length: b.length + 1}, (_, index) => index);
+  for (let i = 1; i <= a.length; i += 1) {
+    let diagonal = previous[0];
+    previous[0] = i;
+    for (let j = 1; j <= b.length; j += 1) {
+      const above = previous[j];
+      previous[j] = a[i - 1] === b[j - 1]
+        ? diagonal
+        : Math.min(previous[j] + 1, previous[j - 1] + 1, diagonal + 1);
+      diagonal = above;
+    }
+  }
+  return 1 - previous[b.length] / Math.max(a.length, b.length);
+}
+
+// A POST whose parent resource matches its defined request entity is a save.
+function shouldSaveByPathEntity(pathStr, method, requestBody, schemas) {
+  if (method !== 'post') {
+    return false;
+  }
+  const parentPath = getParentPathSegment(pathStr);
+  const bodyTypeName = getBodyTypeName(requestBody, schemas);
+  return !!parentPath && !!bodyTypeName && nameSimilarity(parentPath, bodyTypeName) >= 0.8;
+}
+
 // Map a Swagger schema to a runtime return type.
 function mapSchemaToType(schema, schemas, useTypes) {
   if (!schema) {
@@ -255,7 +298,7 @@ function mapParamSchemaToType(schema, schemas, useTypes, isQuery = false) {
     type,
     format
   } = schema;
-  const { items } = schema;
+  const {items} = schema;
   if ($ref) {
     const refName = normalizeDtoName($ref.split('/')
       .pop());
@@ -290,7 +333,11 @@ function mapParamSchemaToType(schema, schemas, useTypes, isQuery = false) {
 
 // Resolve parameter type for a parameter definition.
 function resolveParamType(param, schemas) {
-  const schemaToUse = param.schema || (param.type ? { type: param.type, format: param.format, items: param.items } : null);
+  const schemaToUse = param.schema || (param.type ? {
+    type: param.type,
+    format: param.format,
+    items: param.items
+  } : null);
   const isQuery = param.in === 'query';
   return mapParamSchemaToType(schemaToUse, schemas, true, isQuery);
 }
@@ -310,9 +357,9 @@ function isEventStreamResponse(op) {
 
 // Resolve default response type from Swagger responses.
 function getDefaultReturnType(op, schemas, useTypes) {
-  const { responses = {} } = op;
+  const {responses = {}} = op;
   const res = responses['200'] || responses['201'] || responses.default || {};
-  const { content = {} } = res;
+  const {content = {}} = res;
   const firstContent = content['application/json'] || content['application/*+json'] || Object.values(content)[0];
   if (!firstContent) {
     return 'object';
@@ -322,7 +369,7 @@ function getDefaultReturnType(op, schemas, useTypes) {
 
 // Collect query/path parameters.
 function getParams(op) {
-  const { parameters = [] } = op;
+  const {parameters = []} = op;
   const params = Array.isArray(parameters) ? parameters : [];
   return params.filter((p) => p.in === 'query' || p.in === 'path');
 }
@@ -421,15 +468,28 @@ function toPascal(value) {
   return value[0].toUpperCase() + value.slice(1);
 }
 
+// Join path prefixes while keeping a single separator at their boundary.
+function joinPathPrefixes(...prefixes) {
+  return prefixes
+    .map((prefix) => typeof prefix === 'string' ? prefix.trim() : '')
+    .filter(Boolean)
+    .reduce((result, prefix) => {
+      if (!result) {
+        return prefix;
+      }
+      return `${result.replace(/\/+$/, '')}/${prefix.replace(/^\/+/, '')}`;
+    }, '');
+}
+
 // Generate API file content for a service.
-function generateForSpec(spec, serviceName, fileBase, isDefaultFetch) {
+function generateForSpec(spec, serviceName, fileBase, isDefaultFetch, responsePathPrefix = '') {
   const {
     components = {},
     tags: specTags = [],
     paths = {}
   } = spec;
-  const defaultPathPrefix = typeof spec.pathPrefix === 'string' ? spec.pathPrefix : '';
-  const { schemas = {} } = components;
+  const defaultPathPrefix = joinPathPrefixes(responsePathPrefix, spec.pathPrefix);
+  const {schemas = {}} = components;
   const tagDescriptions = {};
   if (Array.isArray(specTags)) {
     for (const tag of specTags) {
@@ -544,10 +604,15 @@ function generateForSpec(spec, serviceName, fileBase, isDefaultFetch) {
         name = `${name}${facadePrefix}`;
       }
       const isDynamicPath = entryParams.some((p) => p.in === 'path') || entryPath.includes('{');
-      if (seen.has(name) && isDynamicPath && (entryMethod === 'post' || entryMethod === 'put')) {
+      const saveByPathEntity = shouldSaveByPathEntity(
+        entryPath,
+        entryMethod,
+        entryHasBody ? entryOp.requestBody : null,
+        schemas
+      );
+      if (saveByPathEntity || (seen.has(name) && isDynamicPath && (entryMethod === 'post' || entryMethod === 'put'))) {
         const hasSavePrefix = name.startsWith('save') && (name.length === 4 || /^[A-Z]/.test(name.slice(4)));
-        const saveName = hasSavePrefix ? name : `save${toPascal(name)}`;
-        name = saveName;
+        name = hasSavePrefix ? name : `save${toPascal(name)}`;
       }
       const baseName = name;
       if (seen.has(name)) {
@@ -585,9 +650,9 @@ function generateForSpec(spec, serviceName, fileBase, isDefaultFetch) {
       });
 
       let bodyType = 'object';
-      const { requestBody: opRequestBody } = entryOp;
+      const {requestBody: opRequestBody} = entryOp;
       if (entryHasBody && opRequestBody && opRequestBody.content) {
-        const { content } = opRequestBody;
+        const {content} = opRequestBody;
         const firstContent = content['application/json'] || content['application/*+json'] || Object.values(content)[0];
         if (firstContent && firstContent.schema) {
           bodyType = mapSchemaToType(firstContent.schema, schemas, true);
@@ -880,8 +945,8 @@ function isAnySchema(schema) {
 
 // Generate DTO/type definitions file content.
 function generateTypes(spec) {
-  const { components = {} } = spec;
-  const { schemas = {} } = components;
+  const {components = {}} = spec;
+  const {schemas = {}} = components;
   const lines = [];
   lines.push('/*');
   lines.push(' * This file is auto-generated. Do not edit manually.');
@@ -925,7 +990,7 @@ function generateTypes(spec) {
         }
         def.props[prop] = propType;
         def.required[prop] = requiredSet.has(prop);
-        const { description } = propSchema || {};
+        const {description} = propSchema || {};
         const desc = description
           ? description.replace(/\n/g, ' ')
             .trim()
@@ -977,6 +1042,26 @@ async function fetchJson(url) {
   return response.json();
 }
 
+// Fetch JSON together with response headers needed by API generation.
+async function fetchJsonWithHeaders(url) {
+  console.log(`Fetching ${url}`);
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.status}`);
+  }
+  const responseText = await response.text();
+  if (responseText === '') {
+    return {
+      data: {},
+      pathPrefix: response.headers.get('x-path-prefix') || ''
+    };
+  }
+  return {
+    data: JSON.parse(responseText),
+    pathPrefix: response.headers.get('x-path-prefix') || ''
+  };
+}
+
 // Read key/value pairs from .env without extra dependencies.
 function readEnvFile() {
   if (!fs.existsSync(ENV_PATH)) {
@@ -1005,7 +1090,7 @@ function readEnvFile() {
 // Persist values into .env (overwrite or append keys).
 function writeEnvFile(nextEnv) {
   const existing = readEnvFile();
-  const merged = { ...existing, ...nextEnv };
+  const merged = {...existing, ...nextEnv};
   const lines = Object.entries(merged)
     .map(([key, value]) => `${key}=${value}`);
   fs.writeFileSync(ENV_PATH, `${lines.join('\n')}\n`, 'utf8');
@@ -1040,7 +1125,7 @@ async function promptForMissing(env) {
     rl.question(q, resolve);
   });
 
-  const result = { ...env };
+  const result = {...env};
   if (!result.SWAGGER_BASE_URL) {
     result.SWAGGER_BASE_URL = (await ask('BASE_URL: ')).trim();
   }
@@ -1064,7 +1149,7 @@ async function main() {
     SWAGGER_BASE_URL: baseUrl,
     SWAGGER_OUT_DIRECTORY: directory,
     IS_DEFAULT_FETCH: isDefaultFetch
-  } = { ...process.env, ...envFile };
+  } = {...process.env, ...envFile};
   isDefaultFetch = normalizeBoolean(isDefaultFetch);
 
   if (!baseUrl || !directory || isDefaultFetch === undefined) {
@@ -1109,10 +1194,10 @@ async function main() {
   }
 
   if (!fs.existsSync(outputDirectory)) {
-    fs.mkdirSync(outputDirectory, { recursive: true });
+    fs.mkdirSync(outputDirectory, {recursive: true});
   }
   if (!fs.existsSync(typesDirectory)) {
-    fs.mkdirSync(typesDirectory, { recursive: true });
+    fs.mkdirSync(typesDirectory, {recursive: true});
   }
 
   for (const service of services) {
@@ -1127,9 +1212,9 @@ async function main() {
       continue;
     }
     const specUrl = `${baseUrl}${url}`;
-    const spec = await fetchJson(specUrl);
+    const {data: spec, pathPrefix} = await fetchJsonWithHeaders(specUrl);
     const fileBase = toFileBase(serviceName);
-    const content = generateForSpec(spec, serviceName, fileBase, isDefaultFetch);
+    const content = generateForSpec(spec, serviceName, fileBase, isDefaultFetch, pathPrefix);
     const typesContent = generateTypes(spec);
 
     const outPath = path.join(outputDirectory, `${fileBase}.ts`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beer-swagger",
-  "version": "4.0.1",
+  "version": "4.0.2",
   "bin": {
     "beer-swagger": "./generate-apis.js"
   },