beer-swagger 1.1.1 → 4.0.1

package/generate-apis.js

@@ -116,7 +116,7 @@ function appendParamSuffix(baseName, paramSuffix) {
 }
 
 // Add a verb when the HTTP method should be reflected in the name.
-function addVerbForSingleSegment(name, method, hasPathParams = false) {
+function addVerbForSingleSegment(name, method) {
   const lower = name.toLowerCase();
   if (KEEP_METHOD_NAMES.has(lower)) {
     return name;
@@ -125,7 +125,7 @@ function addVerbForSingleSegment(name, method, hasPathParams = false) {
     const suffix = name[0].toUpperCase() + name.slice(1);
     return `removeBy${suffix}`;
   }
-  if ((method === 'post' || method === 'put') && !hasPathParams) {
+  if (method === 'post' || method === 'put') {
     return name;
   }
   const verbMap = {
@@ -185,7 +185,7 @@ function getBodyTypeName(requestBody, schemas) {
 // Map a Swagger schema to a runtime return type.
 function mapSchemaToType(schema, schemas, useTypes) {
   if (!schema) {
-    return '{}';
+    return 'object';
   }
   const {
     $ref,
@@ -201,18 +201,18 @@ function mapSchemaToType(schema, schemas, useTypes) {
       if (responseSchema && responseSchema.properties && responseSchema.properties.data) {
         return mapSchemaToType(responseSchema.properties.data, schemas, useTypes);
       }
-      return '{}';
+      return 'object';
     }
     const refName = normalizeDtoName(rawRefName);
     const refSchema = schemas[rawRefName] || schemas[refName];
     if (refSchema && refSchema.properties && refSchema.properties.data) {
       return mapSchemaToType(refSchema.properties.data, schemas, useTypes);
     }
-    return useTypes ? `Types.${refName}` : '{}';
+    return useTypes ? `Types.${refName}` : 'object';
   }
   if (!type && items) {
     const itemType = mapSchemaToType(items, schemas, useTypes);
-    if (itemType === '{}' || itemType === '[]') {
+    if (itemType === '[]') {
       return '[]';
     }
     return `${itemType}[]`;
@@ -234,7 +234,7 @@ function mapSchemaToType(schema, schemas, useTypes) {
   }
   if (type === 'array') {
     const itemType = mapSchemaToType(items, schemas, useTypes);
-    if (itemType === '{}' || itemType === '[]') {
+    if (itemType === '[]') {
       return '[]';
     }
     return `${itemType}[]`;
@@ -246,9 +246,9 @@ function mapSchemaToType(schema, schemas, useTypes) {
 }
 
 // Map parameter schema to a type for method signatures.
-function mapParamSchemaToType(schema, schemas, useTypes) {
+function mapParamSchemaToType(schema, schemas, useTypes, isQuery = false) {
   if (!schema) {
-    return '{}';
+    return isQuery ? 'Record<string, string | undefined>' : 'object';
   }
   const {
     $ref,
@@ -259,7 +259,7 @@ function mapParamSchemaToType(schema, schemas, useTypes) {
   if ($ref) {
     const refName = normalizeDtoName($ref.split('/')
       .pop());
-    return useTypes ? `Types.${refName}` : '{}';
+    return useTypes ? `Types.${refName}` : 'object';
   }
   if (!type && items) {
     return '[]';
@@ -283,9 +283,29 @@ function mapParamSchemaToType(schema, schemas, useTypes) {
     return '[]';
   }
   if (type === 'object') {
-    return 'object';
+    return isQuery ? 'Record<string, string | undefined>' : 'object';
   }
-  return 'object';
+  return isQuery ? 'Record<string, string | undefined>' : 'object';
+}
+
+// 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 isQuery = param.in === 'query';
+  return mapParamSchemaToType(schemaToUse, schemas, true, isQuery);
+}
+
+// Detect event streams in successful or default responses.
+function isEventStreamResponse(op) {
+  return Object.entries(op.responses || {}).some(([status, response]) => {
+    if (!/^2(?:\d{2}|XX)$/i.test(status) && status !== 'default') {
+      return false;
+    }
+    return Object.keys(response.content || {}).some((mediaType) => {
+      const type = mediaType.split(';')[0].trim().toLowerCase();
+      return type === 'text/event-stream' || type === 'event-stream';
+    });
+  });
 }
 
 // Resolve default response type from Swagger responses.
@@ -295,7 +315,7 @@ function getDefaultReturnType(op, schemas, useTypes) {
   const { content = {} } = res;
   const firstContent = content['application/json'] || content['application/*+json'] || Object.values(content)[0];
   if (!firstContent) {
-    return '{}';
+    return 'object';
   }
   return mapSchemaToType(firstContent.schema, schemas, useTypes);
 }
@@ -455,8 +475,8 @@ function generateForSpec(spec, serviceName, fileBase, isDefaultFetch) {
         const pathSegments = p.split('/')
           .filter(Boolean)
           .filter((part) => !part.startsWith('{'));
-        const shouldAddVerb = pathSegments.length === 1 || ((method === 'post' || method === 'put') && pathParams.length > 0);
-        name = shouldAddVerb ? addVerbForSingleSegment(inferred, method, pathParams.length > 0) : inferred;
+        const shouldAddVerb = pathSegments.length === 1;
+        name = shouldAddVerb ? addVerbForSingleSegment(inferred, method) : inferred;
       }
       if (!KEEP_METHOD_NAMES.has(name.toLowerCase())) {
         name = fixVerbCase(name);
@@ -498,6 +518,11 @@ function generateForSpec(spec, serviceName, fileBase, isDefaultFetch) {
     const className = toClassName(tag);
     const facadePrefix = toFacadePrefix(className);
     const sortedEntries = [...entries].sort((a, b) => {
+      const aDynamic = a.params.some((p) => p.in === 'path') || a.path.includes('{') ? 1 : 0;
+      const bDynamic = b.params.some((p) => p.in === 'path') || b.path.includes('{') ? 1 : 0;
+      if (aDynamic !== bDynamic) {
+        return aDynamic - bDynamic;
+      }
       const aScore = (a.hasBody ? 1 : 0) + (a.params.length ? 1 : 0);
       const bScore = (b.hasBody ? 1 : 0) + (b.params.length ? 1 : 0);
       return aScore - bScore;
@@ -518,21 +543,28 @@ function generateForSpec(spec, serviceName, fileBase, isDefaultFetch) {
       if (!KEEP_METHOD_NAMES.has(name.toLowerCase()) && (name === 'get' || name === 'delete') && facadePrefix) {
         name = `${name}${facadePrefix}`;
       }
+      const isDynamicPath = entryParams.some((p) => p.in === 'path') || entryPath.includes('{');
+      if (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;
+      }
+      const baseName = name;
       if (seen.has(name)) {
         const bodyTypeName = entryHasBody ? getBodyTypeName(entryOp.requestBody, schemas) : '';
         if (bodyTypeName) {
-          name = `${entryName}By${toPascal(bodyTypeName)}`;
+          name = `${baseName}By${toPascal(bodyTypeName)}`;
         }
       }
       if (seen.has(name)) {
         const paramSuffix = toParamSuffix(entryParams, paramNameMap);
         if (paramSuffix) {
-          name = appendParamSuffix(entryName, paramSuffix);
+          name = appendParamSuffix(baseName, paramSuffix);
         }
       }
       if (seen.has(name)) {
         const methodSuffix = entryMethod[0].toUpperCase() + entryMethod.slice(1);
-        name = `${entryName}${methodSuffix}`;
+        name = `${baseName}${methodSuffix}`;
       }
       seen.add(name);
       const defaultType = entryDefaultReturnType;
@@ -543,17 +575,16 @@ function generateForSpec(spec, serviceName, fileBase, isDefaultFetch) {
 
       const paramArgs = orderedParams.map((p) => {
         const {
-          schema: paramSchema,
           required,
           name: paramName
         } = p;
         const mappedName = paramNameMap.get(paramName) || paramName;
-        const paramType = mapParamSchemaToType(paramSchema, schemas, true);
+        const paramType = resolveParamType(p, schemas);
         const optional = required ? '' : '?';
         return `${mappedName}${optional}: ${paramType}`;
       });
 
-      let bodyType = '{}';
+      let bodyType = 'object';
       const { requestBody: opRequestBody } = entryOp;
       if (entryHasBody && opRequestBody && opRequestBody.content) {
         const { content } = opRequestBody;
@@ -605,17 +636,43 @@ function generateForSpec(spec, serviceName, fileBase, isDefaultFetch) {
         methods.push('   */');
       }
 
-      const queryParamNames = entryParams.filter((p) => p.in === 'query')
-        .map((p) => {
+      const queryParams = entryParams.filter((p) => p.in === 'query');
+      let paramsObject = 'undefined';
+      if (queryParams.length === 1) {
+        const p = queryParams[0];
+        const paramType = resolveParamType(p, schemas);
+        const mappedName = paramNameMap.get(p.name) || p.name;
+        if (paramType === 'Record<string, string | undefined>') {
+          paramsObject = mappedName;
+        } else {
+          const key = formatObjectKey(p.name);
+          const prop = mappedName === p.name ? key : `${key}: ${mappedName}`;
+          paramsObject = `{ ${prop} }`;
+        }
+      } else if (queryParams.length > 1) {
+        const entries = queryParams.map((p) => {
+          const paramType = resolveParamType(p, schemas);
           const mappedName = paramNameMap.get(p.name) || p.name;
+          if (paramType === 'Record<string, string | undefined>') {
+            return `...${mappedName}`;
+          }
           const key = formatObjectKey(p.name);
           return mappedName === p.name ? key : `${key}: ${mappedName}`;
         });
-      const paramsObject = queryParamNames.length ? `{ ${queryParamNames.join(', ')} }` : 'undefined';
+        paramsObject = `{ ${entries.join(', ')} }`;
+      }
 
       const pathTemplate = withPathParams(entryPath, entryParams, paramNameMap);
       const pathLiteral = pathTemplate.includes('${') ? `\`${pathTemplate}\`` : `'${pathTemplate}'`;
 
+      if (isEventStreamResponse(entryOp)) {
+        methods.push(`  public ${name}(${sigParts}): EventSource {`);
+        methods.push(`    return this.sse(${pathLiteral}, ${paramsObject});`);
+        methods.push('  }');
+        methods.push('');
+        continue;
+      }
+
       if (entryMethod === 'get') {
         methods.push(`  public async ${name}<T = ${defaultType}>(${sigParts}): Promise<JsonResponse<T>> {`);
         methods.push(`    return await this.get<T>(${pathLiteral}, ${paramsObject});`);
@@ -733,7 +790,7 @@ function generateForSpec(spec, serviceName, fileBase, isDefaultFetch) {
 // Map Swagger schema to a TS type for DTO output.
 function mapSchemaToTsType(schema, schemas) {
   if (!schema) {
-    return '{}';
+    return 'object';
   }
   const {
     $ref,
@@ -751,7 +808,7 @@ function mapSchemaToTsType(schema, schemas) {
       if (refSchema && refSchema.properties && refSchema.properties.data) {
         return mapSchemaToTsType(refSchema.properties.data, schemas);
       }
-      return '{}';
+      return 'object';
     }
     return normalizeDtoName(refName);
   }
@@ -763,6 +820,9 @@ function mapSchemaToTsType(schema, schemas) {
     return schemaEnum.map((v) => (typeof v === 'string' ? `'${v}'` : String(v)))
       .join(' | ');
   }
+  if (type === 'any') {
+    return 'any';
+  }
   if (type === 'string') {
     return 'string';
   }
@@ -784,11 +844,38 @@ function mapSchemaToTsType(schema, schemas) {
   }
   if (type === 'object') {
     if (additionalProperties) {
-      return 'Record<string, {}>';
+      return 'Record<string, object>';
     }
-    return '{}';
+    return 'object';
   }
-  return '{}';
+  return 'object';
+}
+
+// Swagger treats schemas without a type constraint as any.
+function isAnySchema(schema) {
+  if (schema === true || schema === null || schema === undefined) {
+    return true;
+  }
+  if (typeof schema !== 'object' || Array.isArray(schema)) {
+    return false;
+  }
+  if (schema.type === 'any') {
+    return true;
+  }
+  const typeConstraints = [
+    '$ref',
+    'type',
+    'items',
+    'enum',
+    'const',
+    'properties',
+    'additionalProperties',
+    'allOf',
+    'oneOf',
+    'anyOf',
+    'not'
+  ];
+  return !typeConstraints.some((key) => schema[key] !== undefined);
 }
 
 // Generate DTO/type definitions file content.
@@ -829,7 +916,14 @@ function generateTypes(spec) {
       const def = typeDefs.get(normalizedName);
       const requiredSet = new Set(required || []);
       for (const [prop, propSchema] of Object.entries(properties)) {
-        def.props[prop] = mapSchemaToTsType(propSchema, schemas);
+        if (isAnySchema(propSchema)) {
+          continue;
+        }
+        const propType = mapSchemaToTsType(propSchema, schemas);
+        if (propType === 'any') {
+          continue;
+        }
+        def.props[prop] = propType;
         def.required[prop] = requiredSet.has(prop);
         const { description } = propSchema || {};
         const desc = description

package/package.json

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