beer-swagger 1.0.4 → 4.0.1

package/generate-apis.js

@@ -5,7 +5,6 @@ import path from 'path';
 import { createInterface } from 'readline';
 
 const ENV_PATH = path.join(process.cwd(), '.env');
-const CLIENT_TYPES = new Set(['WEB', 'WeChatMiniProgram']);
 const SKIPPED_SERVICES = new Set([
   'billbear-common-web-gateway',
   'billbear-common-data-panel'
@@ -117,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;
@@ -126,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 = {
@@ -186,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,
@@ -202,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}[]`;
@@ -235,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}[]`;
@@ -247,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,
@@ -260,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 '[]';
@@ -284,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.
@@ -296,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);
 }
@@ -403,7 +422,7 @@ function toPascal(value) {
 }
 
 // Generate API file content for a service.
-function generateForSpec(spec, serviceName, fileBase, clientType) {
+function generateForSpec(spec, serviceName, fileBase, isDefaultFetch) {
   const {
     components = {},
     tags: specTags = [],
@@ -456,8 +475,8 @@ function generateForSpec(spec, serviceName, fileBase, clientType) {
         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);
@@ -499,6 +518,11 @@ function generateForSpec(spec, serviceName, fileBase, clientType) {
     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;
@@ -519,21 +543,28 @@ function generateForSpec(spec, serviceName, fileBase, clientType) {
       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;
@@ -544,17 +575,16 @@ function generateForSpec(spec, serviceName, fileBase, clientType) {
 
       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;
@@ -606,17 +636,43 @@ function generateForSpec(spec, serviceName, fileBase, clientType) {
         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});`);
@@ -702,7 +758,7 @@ function generateForSpec(spec, serviceName, fileBase, clientType) {
   lines.push(' * This file is auto-generated. Do not edit manually.');
   lines.push(' * To update, run the generate-apis.js script.');
   lines.push(' */');
-  const fetchImport = clientType === 'WeChatMiniProgram' ? './fetch' : 'beer-network/api';
+  const fetchImport = isDefaultFetch ? 'beer-network/api' : './fetch';
   lines.push(`import type { JsonResponse } from '${fetchImport}';`);
   lines.push(`import Fetch from '${fetchImport}';`);
   if (fileBase) {
@@ -734,7 +790,7 @@ function generateForSpec(spec, serviceName, fileBase, clientType) {
 // Map Swagger schema to a TS type for DTO output.
 function mapSchemaToTsType(schema, schemas) {
   if (!schema) {
-    return '{}';
+    return 'object';
   }
   const {
     $ref,
@@ -752,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);
   }
@@ -764,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';
   }
@@ -785,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.
@@ -830,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
@@ -918,22 +1011,23 @@ function writeEnvFile(nextEnv) {
   fs.writeFileSync(ENV_PATH, `${lines.join('\n')}\n`, 'utf8');
 }
 
-function normalizeClientType(value) {
-  if (!value) {
-    return '';
+function normalizeBoolean(value) {
+  if (value === undefined || value === null || value === '') {
+    return undefined;
   }
-  if (CLIENT_TYPES.has(value)) {
+  if (typeof value === 'boolean') {
     return value;
   }
-  if (value.toUpperCase() === 'WEB') {
-    return 'WEB';
-  }
-  const normalized = value.replace(/[-_\s]/g, '')
+  const normalized = String(value)
+    .trim()
     .toLowerCase();
-  if (normalized === 'wechatminiprogram') {
-    return 'WeChatMiniProgram';
+  if (['true', '1', 'yes', 'y'].includes(normalized)) {
+    return true;
+  }
+  if (['false', '0', 'no', 'n'].includes(normalized)) {
+    return false;
   }
-  return '';
+  return undefined;
 }
 
 // Ask user for missing values via CLI.
@@ -953,13 +1047,12 @@ async function promptForMissing(env) {
   if (!result.SWAGGER_OUT_DIRECTORY) {
     result.SWAGGER_OUT_DIRECTORY = (await ask('DIRECTORY: ')).trim();
   }
-  if (!result.CLIENT_TYPE || !CLIENT_TYPES.has(result.CLIENT_TYPE)) {
-    let selected = '';
-    while (!CLIENT_TYPES.has(selected)) {
-      selected = normalizeClientType((await ask('CLIENT_TYPE (WEB/WeChatMiniProgram): ')).trim());
-    }
-    result.CLIENT_TYPE = selected;
+  let isDefaultFetch = normalizeBoolean(result.IS_DEFAULT_FETCH);
+  while (isDefaultFetch === undefined) {
+    const selected = (await ask('IS_DEFAULT_FETCH (true/false): ')).trim();
+    isDefaultFetch = normalizeBoolean(selected);
   }
+  result.IS_DEFAULT_FETCH = String(isDefaultFetch);
   rl.close();
   return result;
 }
@@ -970,23 +1063,23 @@ async function main() {
   let {
     SWAGGER_BASE_URL: baseUrl,
     SWAGGER_OUT_DIRECTORY: directory,
-    CLIENT_TYPE: clientType
+    IS_DEFAULT_FETCH: isDefaultFetch
   } = { ...process.env, ...envFile };
-  clientType = normalizeClientType(clientType);
+  isDefaultFetch = normalizeBoolean(isDefaultFetch);
 
-  if (!baseUrl || !directory || !clientType) {
+  if (!baseUrl || !directory || isDefaultFetch === undefined) {
     const filled = await promptForMissing({
       SWAGGER_BASE_URL: baseUrl || '',
       SWAGGER_OUT_DIRECTORY: directory || '',
-      CLIENT_TYPE: clientType || ''
+      IS_DEFAULT_FETCH: isDefaultFetch === undefined ? '' : String(isDefaultFetch)
     });
     baseUrl = filled.SWAGGER_BASE_URL;
     directory = filled.SWAGGER_OUT_DIRECTORY;
-    clientType = normalizeClientType(filled.CLIENT_TYPE);
+    isDefaultFetch = normalizeBoolean(filled.IS_DEFAULT_FETCH);
     writeEnvFile({
       SWAGGER_BASE_URL: baseUrl,
       SWAGGER_OUT_DIRECTORY: directory,
-      CLIENT_TYPE: clientType
+      IS_DEFAULT_FETCH: String(isDefaultFetch)
     });
   }
 
@@ -996,10 +1089,9 @@ async function main() {
   if (!directory) {
     throw new Error('SWAGGER_OUT_DIRECTORY is required.');
   }
-  if (!clientType) {
-    throw new Error('CLIENT_TYPE is required.');
+  if (isDefaultFetch === undefined) {
+    throw new Error('IS_DEFAULT_FETCH is required.');
   }
-
   const configUrl = `${baseUrl}/v3/api-docs/swagger-config`;
   const outputDirectory = path.isAbsolute(directory) ? directory : path.join(process.cwd(), directory);
   const typesDirectory = path.join(outputDirectory, 'types');
@@ -1037,7 +1129,7 @@ async function main() {
     const specUrl = `${baseUrl}${url}`;
     const spec = await fetchJson(specUrl);
     const fileBase = toFileBase(serviceName);
-    const content = generateForSpec(spec, serviceName, fileBase, clientType);
+    const content = generateForSpec(spec, serviceName, fileBase, isDefaultFetch);
     const typesContent = generateTypes(spec);
 
     const outPath = path.join(outputDirectory, `${fileBase}.ts`);

package/package.json

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