beer-swagger 1.0.1

package/.idea/beer-swaager.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/jsLibraryMappings.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="JavaScriptLibraryMappings">
+    <includedPredefinedLibrary name="Node.js Core" />
+  </component>
+</project>

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/beer-swaager.iml" filepath="$PROJECT_DIR$/.idea/beer-swaager.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

package/generate-apis.js

@@ -0,0 +1,1021 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+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'
+]);
+
+const VERBS = [
+  'get',
+  'list',
+  'query',
+  'search',
+  'find',
+  'fetch',
+  'create',
+  'save',
+  'update',
+  'set',
+  'add',
+  'remove',
+  'delete',
+  'enable',
+  'disable',
+  'upload',
+  'download',
+  'export',
+  'import',
+  'cancel',
+  'confirm',
+  'apply',
+  'check',
+  'handle',
+  'open',
+  'close'
+];
+
+const KEEP_METHOD_NAMES = new Set(['enable', 'disable', 'create', 'search']);
+const SERVICE_NAME_OVERRIDES = {
+  authcenter: 'authCenter',
+  datatask: 'dataTask',
+  usercenter: 'userCenter'
+};
+
+// Detect server response wrapper types.
+function isResponseWrapper(name) {
+  return /^ResponseData/.test(name);
+}
+
+// Convert string to lower camel case.
+function toCamel(value) {
+  if (!value) {
+    return 'unnamed';
+  }
+  if (!/[^a-zA-Z0-9]/.test(value) && /[A-Z]/.test(value)) {
+    return value[0].toLowerCase() + value.slice(1);
+  }
+  const parts = value.split(/[^a-zA-Z0-9]+/)
+    .filter(Boolean);
+  if (!parts.length) {
+    return 'unnamed';
+  }
+  const first = parts[0].toLowerCase();
+  const rest = parts.slice(1)
+    .map((p) => p[0].toUpperCase() + p.slice(1));
+  return [first, ...rest].join('');
+}
+
+// Check if a name is all lowercase/number characters.
+function isAllLowerWord(value) {
+  return /^[a-z0-9]+$/.test(value) && !/[A-Z]/.test(value);
+}
+
+// Derive a method name from the last non-path-parameter segment.
+function pathToName(pathStr) {
+  const segments = pathStr.split('/')
+    .filter(Boolean)
+    .filter((part) => !part.startsWith('{'));
+  if (!segments.length) {
+    return 'unnamed';
+  }
+  const last = segments[segments.length - 1];
+  const lowerLast = last.toLowerCase();
+  if (lowerLast === 'get' || lowerLast === 'put' || lowerLast === 'delete') {
+    const suffix = lowerLast + 'By';
+    return toCamel(suffix);
+  }
+  const normalized = last.replace(/[_-]+/g, ' ');
+  return toCamel(normalized);
+}
+
+// Build suffix from path parameters for collision handling.
+function toParamSuffix(params, nameMap) {
+  const names = params.filter((p) => p.in === 'path')
+    .map((p) => nameMap?.get(p.name) || p.name);
+  if (!names.length) {
+    return '';
+  }
+  return 'By' + names.map((n) => toPascal(toCamel(n)))
+    .join('');
+}
+
+// Add a verb for single-segment paths when needed.
+function addVerbForSingleSegment(name, method) {
+  const lower = name.toLowerCase();
+  if (KEEP_METHOD_NAMES.has(lower)) {
+    return name;
+  }
+  if (method === 'delete') {
+    const suffix = name[0].toUpperCase() + name.slice(1);
+    return `removeBy${suffix}`;
+  }
+  const verbMap = {
+    get: 'get',
+    post: 'save',
+    put: 'save'
+  };
+  const verb = verbMap[method];
+  if (!verb) {
+    return name;
+  }
+  if (name.startsWith(verb)) {
+    return name;
+  }
+  return verb + name[0].toUpperCase() + name.slice(1);
+}
+
+// Fix verb casing for names like getflight -> getFlight.
+function fixVerbCase(name) {
+  if (/^[a-z0-9]+$/.test(name)) {
+    for (const verb of VERBS) {
+      if (name.startsWith(verb) && name.length > verb.length) {
+        const tail = name.slice(verb.length);
+        return verb + tail[0].toUpperCase() + tail.slice(1);
+      }
+    }
+  }
+  return name;
+}
+
+// Remove DTO suffix from type names.
+function normalizeDtoName(name) {
+  return name.replace(/DTO$/, '');
+}
+
+// Get request body type name for disambiguation (strip DTO/Request suffix).
+function getBodyTypeName(requestBody, schemas) {
+  if (!requestBody || !requestBody.content) {
+    return '';
+  }
+  const { content } = requestBody;
+  const firstContent = content['application/json'] || content['application/*+json'] || Object.values(content)[0];
+  if (!firstContent || !firstContent.schema) {
+    return '';
+  }
+  const { schema } = firstContent;
+  if (!schema.$ref) {
+    return '';
+  }
+  const rawRefName = schema.$ref.split('/')
+    .pop();
+  const normalized = normalizeDtoName(rawRefName);
+  const stripped = normalized.replace(/Request$/, '');
+  return stripped || normalized;
+}
+
+// Map a Swagger schema to a runtime return type.
+function mapSchemaToType(schema, schemas, useTypes) {
+  if (!schema) {
+    return '{}';
+  }
+  const {
+    $ref,
+    type,
+    format,
+    items
+  } = schema;
+  if ($ref) {
+    const rawRefName = $ref.split('/')
+      .pop();
+    if (isResponseWrapper(rawRefName)) {
+      const responseSchema = schemas[rawRefName];
+      if (responseSchema && responseSchema.properties && responseSchema.properties.data) {
+        return mapSchemaToType(responseSchema.properties.data, schemas, useTypes);
+      }
+      return '{}';
+    }
+    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}` : '{}';
+  }
+  if (type === 'string') {
+    return 'string';
+  }
+  if (type === 'integer') {
+    if (format === 'int64' || format === 'long') {
+      return 'string';
+    }
+    return 'number';
+  }
+  if (type === 'number') {
+    return 'number';
+  }
+  if (type === 'boolean') {
+    return 'boolean';
+  }
+  if (type === 'array') {
+    const itemType = mapSchemaToType(items, schemas, useTypes);
+    if (itemType === '{}' || itemType === '[]') {
+      return '[]';
+    }
+    return `${itemType}[]`;
+  }
+  if (type === 'object') {
+    return '{}';
+  }
+  return '{}';
+}
+
+// Map parameter schema to a type for method signatures.
+function mapParamSchemaToType(schema, schemas, useTypes) {
+  if (!schema) {
+    return '{}';
+  }
+  const {
+    $ref,
+    type,
+    format
+  } = schema;
+  if ($ref) {
+    const refName = normalizeDtoName($ref.split('/')
+      .pop());
+    return useTypes ? `Types.${refName}` : '{}';
+  }
+  if (type === 'string') {
+    return 'string';
+  }
+  if (type === 'integer') {
+    if (format === 'int64' || format === 'long') {
+      return 'string';
+    }
+    return 'number';
+  }
+  if (type === 'number') {
+    return 'number';
+  }
+  if (type === 'boolean') {
+    return 'boolean';
+  }
+  if (type === 'array') {
+    return '[]';
+  }
+  if (type === 'object') {
+    return '{}';
+  }
+  return '{}';
+}
+
+// Resolve default response type from Swagger responses.
+function getDefaultReturnType(op, schemas, useTypes) {
+  const { responses = {} } = op;
+  const res = responses['200'] || responses['201'] || responses.default || {};
+  const { content = {} } = res;
+  const firstContent = content['application/json'] || content['application/*+json'] || Object.values(content)[0];
+  if (!firstContent) {
+    return '{}';
+  }
+  return mapSchemaToType(firstContent.schema, schemas, useTypes);
+}
+
+// Collect query/path parameters.
+function getParams(op) {
+  const { parameters = [] } = op;
+  const params = Array.isArray(parameters) ? parameters : [];
+  return params.filter((p) => p.in === 'query' || p.in === 'path');
+}
+
+// Inject path params into the URL template.
+function withPathParams(pathStr, params, nameMap) {
+  let out = pathStr;
+  for (const p of params) {
+    if (p.in === 'path') {
+      const mappedName = nameMap?.get(p.name) || p.name;
+      out = out.replace(`{${p.name}}`, `\${${mappedName}}`);
+    }
+  }
+  return out;
+}
+
+function formatObjectKey(name) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : `'${name}'`;
+}
+
+function buildParamNameMap(params) {
+  const used = new Set();
+  const map = new Map();
+  for (const param of params) {
+    const base = toCamel(param.name) || 'param';
+    let candidate = base;
+    let index = 1;
+    while (used.has(candidate)) {
+      candidate = `${base}${index}`;
+      index += 1;
+    }
+    used.add(candidate);
+    map.set(param.name, candidate);
+  }
+  return map;
+}
+
+// Normalize class name from tag.
+function toClassName(tag) {
+  const cleaned = tag.replace(/[^a-zA-Z0-9_]/g, '');
+  return cleaned.replace(/Facade$/, '');
+}
+
+// Build instance property name for a facade.
+function toPropName(className) {
+  if (/^[A-Z0-9]+$/.test(className) && className.length > 1) {
+    return className.toLowerCase();
+  }
+  return toCamel(className);
+}
+
+// Strip common suffixes for name disambiguation.
+function toFacadePrefix(className) {
+  return className
+    .replace(/ClientFacade$/, '')
+    .replace(/Facade$/, '')
+    .replace(/Client$/, '');
+}
+
+// Skip unsupported facades.
+function isSkippedFacade(tag) {
+  return tag === 'core-error-controller';
+}
+
+// Convert service name to file base name.
+function toFileBase(serviceName) {
+  if (serviceName.startsWith('billbear-coral-')) {
+    return serviceName.replace('billbear-coral-', '');
+  }
+  if (serviceName.startsWith('billbear-common-')) {
+    return serviceName.replace('billbear-common-', '');
+  }
+  if (serviceName.startsWith('billbear-')) {
+    return serviceName.replace('billbear-', '');
+  }
+  return serviceName;
+}
+
+// Map service name to a stable camel base.
+function toServiceBaseName(serviceName) {
+  const fileBase = toFileBase(serviceName);
+  const parts = fileBase.split(/[-_]/g)
+    .filter(Boolean);
+  const mapped = parts.map((part) => {
+    const key = part.toLowerCase();
+    return SERVICE_NAME_OVERRIDES[key] || part;
+  });
+  return toCamel(mapped.join('-'));
+}
+
+// Uppercase the first letter.
+function toPascal(value) {
+  if (!value) {
+    return 'Unnamed';
+  }
+  return value[0].toUpperCase() + value.slice(1);
+}
+
+// Generate API file content for a service.
+function generateForSpec(spec, serviceName, fileBase, clientType) {
+  const {
+    components = {},
+    tags: specTags = [],
+    paths = {}
+  } = spec;
+  const defaultPathPrefix = typeof spec.pathPrefix === 'string' ? spec.pathPrefix : '';
+  const { schemas = {} } = components;
+  const tagDescriptions = {};
+  if (Array.isArray(specTags)) {
+    for (const tag of specTags) {
+      if (tag) {
+        const {
+          name,
+          description
+        } = tag;
+        if (name && description) {
+          tagDescriptions[name] = description.replace(/\n/g, ' ')
+            .trim();
+        }
+      }
+    }
+  }
+  const methodsOrder = ['get', 'post', 'put', 'delete', 'patch', 'head', 'options'];
+  const byTag = new Map();
+
+  for (const [p, ops] of Object.entries(paths)) {
+    for (const method of methodsOrder) {
+      const op = ops[method];
+      if (!op) {
+        continue;
+      }
+      const {
+        tags: opTags,
+        operationId,
+        summary,
+        requestBody
+      } = op;
+      const tags = opTags && opTags.length ? opTags : ['DefaultFacade'];
+      const opId = operationId || summary || `${method}_${p}`;
+      let name = pathToName(p);
+      if (name === 'unnamed') {
+        name = toCamel(opId);
+      }
+      if (!KEEP_METHOD_NAMES.has(name.toLowerCase()) && isAllLowerWord(name)) {
+        const inferred = pathToName(p);
+        const pathSegments = p.split('/')
+          .filter(Boolean)
+          .filter((part) => !part.startsWith('{'));
+        name = pathSegments.length === 1 ? addVerbForSingleSegment(inferred, method) : inferred;
+      }
+      if (!KEEP_METHOD_NAMES.has(name.toLowerCase())) {
+        name = fixVerbCase(name);
+      }
+      const hasBody = !!requestBody;
+      const defaultReturnType = getDefaultReturnType(op, schemas, true);
+      const params = getParams(op);
+      for (const tag of tags) {
+        if (isSkippedFacade(tag)) {
+          continue;
+        }
+        if (!tag.endsWith('Facade')) {
+          continue;
+        }
+        if (!byTag.has(tag)) {
+          byTag.set(tag, []);
+        }
+        byTag.get(tag)
+          .push({
+            path: p,
+            method,
+            name,
+            hasBody,
+            params,
+            op,
+            defaultReturnType
+          });
+      }
+    }
+  }
+
+  const classDefs = [];
+  const apiProps = [];
+  const apiInit = [];
+
+  for (const [tag, entries] of byTag.entries()) {
+    const seen = new Set();
+    const methods = [];
+    const className = toClassName(tag);
+    const facadePrefix = toFacadePrefix(className);
+    const sortedEntries = [...entries].sort((a, b) => {
+      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;
+    });
+
+    for (const entry of sortedEntries) {
+      const {
+        name: entryName,
+        params: entryParams,
+        method: entryMethod,
+        op: entryOp,
+        path: entryPath,
+        hasBody: entryHasBody,
+        defaultReturnType: entryDefaultReturnType
+      } = entry;
+      const paramNameMap = buildParamNameMap(entryParams);
+      let name = entryName;
+      if (!KEEP_METHOD_NAMES.has(name.toLowerCase()) && (name === 'get' || name === 'delete') && facadePrefix) {
+        name = `${name}${facadePrefix}`;
+      }
+      if (seen.has(name)) {
+        const bodyTypeName = entryHasBody ? getBodyTypeName(entryOp.requestBody, schemas) : '';
+        if (bodyTypeName) {
+          name = `${entryName}By${toPascal(bodyTypeName)}`;
+        }
+      }
+      if (seen.has(name)) {
+        const paramSuffix = toParamSuffix(entryParams, paramNameMap);
+        if (paramSuffix) {
+          name = `${entryName}${paramSuffix}`;
+        }
+      }
+      if (seen.has(name)) {
+        const methodSuffix = entryMethod[0].toUpperCase() + entryMethod.slice(1);
+        name = `${entryName}${methodSuffix}`;
+      }
+      seen.add(name);
+      const defaultType = entryDefaultReturnType;
+
+      const requiredParams = entryParams.filter((p) => p.required);
+      const optionalParams = entryParams.filter((p) => !p.required);
+      const orderedParams = [...requiredParams, ...optionalParams];
+
+      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 optional = required ? '' : '?';
+        return `${mappedName}${optional}: ${paramType}`;
+      });
+
+      let bodyType = '{}';
+      const { requestBody: opRequestBody } = entryOp;
+      if (entryHasBody && opRequestBody && opRequestBody.content) {
+        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);
+        }
+      }
+      const bodyArg = entryHasBody ? [`body?: ${bodyType}`] : [];
+      const signatureParts = [...paramArgs, ...bodyArg];
+      const sigParts = signatureParts.length >= 3
+        ? `\n    ${signatureParts.join(',\n    ')}\n  `
+        : signatureParts.join(', ');
+
+      const {
+        summary: opSummary,
+        description: opDescription
+      } = entryOp;
+      const comment = (opSummary || opDescription || '').replace(/\n/g, ' ')
+        .trim();
+      const bodyDescription = opRequestBody && opRequestBody.description
+        ? opRequestBody.description.replace(/\n/g, ' ')
+          .trim()
+        : '';
+      const paramDocs = [];
+      for (const p of orderedParams) {
+        const {
+          description,
+          name: paramName
+        } = p;
+        const mappedName = paramNameMap.get(paramName) || paramName;
+        const desc = (description || '').replace(/\n/g, ' ')
+          .trim();
+        const text = desc && desc !== paramName ? desc : paramName;
+        if (text) {
+          paramDocs.push(`   * @param ${mappedName} ${text}`);
+        }
+      }
+      if (entryHasBody) {
+        const bodyText = bodyDescription || 'body';
+        paramDocs.push(`   * @param body ${bodyText}`);
+      }
+      if (comment || paramDocs.length) {
+        methods.push('  /**');
+        if (comment) {
+          methods.push(`   * ${comment}`);
+        }
+        for (const line of paramDocs) methods.push(line);
+        methods.push('   */');
+      }
+
+      const queryParamNames = entryParams.filter((p) => p.in === 'query')
+        .map((p) => {
+          const mappedName = paramNameMap.get(p.name) || p.name;
+          const key = formatObjectKey(p.name);
+          return mappedName === p.name ? key : `${key}: ${mappedName}`;
+        });
+      const paramsObject = queryParamNames.length ? `{ ${queryParamNames.join(', ')} }` : 'undefined';
+
+      const pathTemplate = withPathParams(entryPath, entryParams, paramNameMap);
+      const pathLiteral = pathTemplate.includes('${') ? `\`${pathTemplate}\`` : `'${pathTemplate}'`;
+
+      if (entryMethod === 'get') {
+        methods.push(`  public async ${name}<T = ${defaultType}>(${sigParts}): Promise<JsonResponse<T>> {`);
+        methods.push(`    return this.get<T>(${pathLiteral}, ${paramsObject});`);
+        methods.push('  }');
+        methods.push('');
+        continue;
+      }
+
+      if (entryMethod === 'delete') {
+        if (entryHasBody) {
+          methods.push(`  public async ${name}<T = ${defaultType}>(${sigParts}): Promise<JsonResponse<T>> {`);
+          methods.push(`    return this.deleteBody<T>(${pathLiteral}, ${paramsObject}, body);`);
+          methods.push('  }');
+          methods.push('');
+        } else {
+          methods.push(`  public async ${name}<T = ${defaultType}>(${sigParts}): Promise<JsonResponse<T>> {`);
+          methods.push(`    return this.delete<T>(${pathLiteral}, ${paramsObject});`);
+          methods.push('  }');
+          methods.push('');
+        }
+        continue;
+      }
+
+      if (entryMethod === 'post') {
+        if (entryHasBody) {
+          methods.push(`  public async ${name}<T = ${defaultType}>(${sigParts}): Promise<JsonResponse<T>> {`);
+          methods.push(`    return this.postBody<T>(${pathLiteral}, ${paramsObject}, body);`);
+          methods.push('  }');
+          methods.push('');
+        } else {
+          methods.push(`  public async ${name}<T = ${defaultType}>(${sigParts}): Promise<JsonResponse<T>> {`);
+          methods.push(`    return this.post<T>(${pathLiteral}, ${paramsObject});`);
+          methods.push('  }');
+          methods.push('');
+        }
+        continue;
+      }
+
+      if (entryMethod === 'put') {
+        if (entryHasBody) {
+          methods.push(`  public async ${name}<T = ${defaultType}>(${sigParts}): Promise<JsonResponse<T>> {`);
+          methods.push(`    return this.putBody<T>(${pathLiteral}, ${paramsObject}, body);`);
+          methods.push('  }');
+          methods.push('');
+        } else {
+          methods.push(`  public async ${name}<T = ${defaultType}>(${sigParts}): Promise<JsonResponse<T>> {`);
+          methods.push(`    return this.put<T>(${pathLiteral}, ${paramsObject});`);
+          methods.push('  }');
+          methods.push('');
+        }
+        continue;
+      }
+
+      methods.push(`  public async ${name}<T = ${defaultType}>(${sigParts}): Promise<JsonResponse<T>> {`);
+      methods.push(`    return this.postBody<T>(${pathLiteral}, ${paramsObject}, body);`);
+      methods.push('  }');
+      methods.push('');
+    }
+
+    classDefs.push(`export class ${className} extends Fetch {`);
+    classDefs.push('');
+    classDefs.push(...methods);
+    classDefs.push('}');
+    classDefs.push('');
+
+    const propName = toPropName(className);
+    const tagDesc = tagDescriptions[tag];
+    if (tagDesc) {
+      apiProps.push('  /**');
+      apiProps.push(`   * ${tagDesc}`);
+      apiProps.push('   */');
+    }
+    apiProps.push(`  public readonly ${propName}: ${className};`);
+    apiInit.push(`    this.${propName} = new ${className}(this.pathPrefix);`);
+  }
+
+  const baseName = toServiceBaseName(serviceName);
+  const apiClassName = `${toPascal(baseName)}Api`;
+  const factoryName = `get${apiClassName}`;
+  const cacheName = `${baseName}ApiCache`;
+  const lines = [];
+  lines.push('/*');
+  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';
+  lines.push(`import Fetch, { JsonResponse } from '${fetchImport}';`);
+  if (fileBase) {
+    lines.push(`import type * as Types from './types/${fileBase}-type';`);
+  }
+  lines.push('');
+  lines.push(...classDefs);
+  lines.push(`export class ${apiClassName} {`);
+  lines.push('  public readonly pathPrefix: string;');
+  lines.push(...apiProps);
+  lines.push('  constructor(pathPrefix = \'\') {');
+  lines.push(`    this.pathPrefix = (pathPrefix ?? '') + '${defaultPathPrefix}';`);
+  lines.push(...apiInit);
+  lines.push('  }');
+  lines.push('}');
+  lines.push('');
+  lines.push(`const ${cacheName} = new Map<string, ${apiClassName}>();`);
+  lines.push(`export function ${factoryName}(pathPrefix = '') {`);
+  lines.push(`  if (!${cacheName}.has(pathPrefix)) {`);
+  lines.push(`    ${cacheName}.set(pathPrefix, new ${apiClassName}(pathPrefix));`);
+  lines.push('  }');
+  lines.push(`  return ${cacheName}.get(pathPrefix)!;`);
+  lines.push('}');
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+// Map Swagger schema to a TS type for DTO output.
+function mapSchemaToTsType(schema, schemas) {
+  if (!schema) {
+    return '{}';
+  }
+  const {
+    $ref,
+    enum: schemaEnum,
+    type,
+    format,
+    items,
+    additionalProperties
+  } = schema;
+  if ($ref) {
+    const refName = $ref.split('/')
+      .pop();
+    if (isResponseWrapper(refName)) {
+      const refSchema = schemas && schemas[refName];
+      if (refSchema && refSchema.properties && refSchema.properties.data) {
+        return mapSchemaToTsType(refSchema.properties.data, schemas);
+      }
+      return '{}';
+    }
+    return normalizeDtoName(refName);
+  }
+  if (schemaEnum && schemaEnum.length) {
+    return schemaEnum.map((v) => (typeof v === 'string' ? `'${v}'` : String(v)))
+      .join(' | ');
+  }
+  if (type === 'string') {
+    return 'string';
+  }
+  if (type === 'integer') {
+    if (format === 'int64' || format === 'long') {
+      return 'string';
+    }
+    return 'number';
+  }
+  if (type === 'number') {
+    return 'number';
+  }
+  if (type === 'boolean') {
+    return 'boolean';
+  }
+  if (type === 'array') {
+    const itemType = mapSchemaToTsType(items, schemas);
+    return `${itemType}[]`;
+  }
+  if (type === 'object') {
+    if (additionalProperties) {
+      return 'Record<string, {}>';
+    }
+    return '{}';
+  }
+  return '{}';
+}
+
+// Generate DTO/type definitions file content.
+function generateTypes(spec) {
+  const { components = {} } = spec;
+  const { schemas = {} } = components;
+  const lines = [];
+  lines.push('/*');
+  lines.push(' * This file is auto-generated. Do not edit manually.');
+  lines.push(' * To update, run the generate-apis.js script.');
+  lines.push(' */');
+  lines.push('');
+
+  const typeDefs = new Map();
+
+  for (const [name, schema] of Object.entries(schemas)) {
+    if (!schema) {
+      continue;
+    }
+    if (isResponseWrapper(name)) {
+      continue;
+    }
+    const {
+      type: schemaType,
+      properties,
+      required
+    } = schema;
+    const normalizedName = normalizeDtoName(name);
+    if (schemaType === 'object' && properties) {
+      if (!typeDefs.has(normalizedName) || typeDefs.get(normalizedName).kind !== 'object') {
+        typeDefs.set(normalizedName, {
+          kind: 'object',
+          props: {},
+          required: {},
+          desc: {}
+        });
+      }
+      const def = typeDefs.get(normalizedName);
+      const requiredSet = new Set(required || []);
+      for (const [prop, propSchema] of Object.entries(properties)) {
+        def.props[prop] = mapSchemaToTsType(propSchema, schemas);
+        def.required[prop] = requiredSet.has(prop);
+        const { description } = propSchema || {};
+        const desc = description
+          ? description.replace(/\n/g, ' ')
+            .trim()
+          : '';
+        if (desc) {
+          def.desc[prop] = desc;
+        }
+      }
+      continue;
+    }
+
+    const type = mapSchemaToTsType(schema, schemas);
+    typeDefs.set(normalizedName, {
+      kind: 'alias',
+      type
+    });
+  }
+
+  for (const [name, def] of typeDefs.entries()) {
+    if (def.kind === 'object') {
+      lines.push(`export interface ${name} {`);
+      for (const [prop, type] of Object.entries(def.props)) {
+        const optional = def.required[prop] ? '' : '?';
+        const desc = def.desc[prop];
+        if (desc) {
+          lines.push('  /**');
+          lines.push(`   * ${desc}`);
+          lines.push('   */');
+        }
+        lines.push(`  ${prop}${optional}: ${type};`);
+      }
+      lines.push('}');
+      lines.push('');
+      continue;
+    }
+    lines.push(`export type ${name} = ${def.type};`);
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+// Fetch JSON from a URL.
+async function fetchJson(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.status}`);
+  }
+  return response.json();
+}
+
+// Read key/value pairs from .env without extra dependencies.
+function readEnvFile() {
+  if (!fs.existsSync(ENV_PATH)) {
+    return {};
+  }
+  const content = fs.readFileSync(ENV_PATH, 'utf8');
+  const lines = content.split(/\r?\n/);
+  const env = {};
+  for (const line of lines) {
+    if (!line || line.trim()
+      .startsWith('#')) {
+      continue;
+    }
+    const idx = line.indexOf('=');
+    if (idx === -1) {
+      continue;
+    }
+    const key = line.slice(0, idx)
+      .trim();
+    env[key] = line.slice(idx + 1)
+      .trim();
+  }
+  return env;
+}
+
+// Persist values into .env (overwrite or append keys).
+function writeEnvFile(nextEnv) {
+  const existing = readEnvFile();
+  const merged = { ...existing, ...nextEnv };
+  const lines = Object.entries(merged)
+    .map(([key, value]) => `${key}=${value}`);
+  fs.writeFileSync(ENV_PATH, `${lines.join('\n')}\n`, 'utf8');
+}
+
+function normalizeClientType(value) {
+  if (!value) {
+    return '';
+  }
+  if (CLIENT_TYPES.has(value)) {
+    return value;
+  }
+  if (value.toUpperCase() === 'WEB') {
+    return 'WEB';
+  }
+  const normalized = value.replace(/[-_\s]/g, '')
+    .toLowerCase();
+  if (normalized === 'wechatminiprogram') {
+    return 'WeChatMiniProgram';
+  }
+  return '';
+}
+
+// Ask user for missing values via CLI.
+async function promptForMissing(env) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const ask = (q) => new Promise((resolve) => {
+    rl.question(q, resolve);
+  });
+
+  const result = { ...env };
+  if (!result.SWAGGER_BASE_URL) {
+    result.SWAGGER_BASE_URL = (await ask('BASE_URL: ')).trim();
+  }
+  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;
+  }
+  rl.close();
+  return result;
+}
+
+// Main CLI entrypoint.
+async function main() {
+  const envFile = readEnvFile();
+  let {
+    SWAGGER_BASE_URL: baseUrl,
+    SWAGGER_OUT_DIRECTORY: directory,
+    CLIENT_TYPE: clientType
+  } = { ...process.env, ...envFile };
+  clientType = normalizeClientType(clientType);
+
+  if (!baseUrl || !directory || !clientType) {
+    const filled = await promptForMissing({
+      SWAGGER_BASE_URL: baseUrl || '',
+      SWAGGER_OUT_DIRECTORY: directory || '',
+      CLIENT_TYPE: clientType || ''
+    });
+    baseUrl = filled.SWAGGER_BASE_URL;
+    directory = filled.SWAGGER_OUT_DIRECTORY;
+    clientType = normalizeClientType(filled.CLIENT_TYPE);
+    writeEnvFile({
+      SWAGGER_BASE_URL: baseUrl,
+      SWAGGER_OUT_DIRECTORY: directory,
+      CLIENT_TYPE: clientType
+    });
+  }
+
+  if (!baseUrl) {
+    throw new Error('SWAGGER_BASE_URL is required.');
+  }
+  if (!directory) {
+    throw new Error('SWAGGER_OUT_DIRECTORY is required.');
+  }
+  if (!clientType) {
+    throw new Error('CLIENT_TYPE 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');
+
+  const args = process.argv.slice(2);
+  const filter = args.length ? new Set(args) : null;
+
+  const config = await fetchJson(configUrl);
+  const services = config.urls ?? [];
+  if (config.url !== undefined) {
+    services.push({
+      name: 'api',
+      url: config.url
+    });
+  }
+
+  if (!fs.existsSync(outputDirectory)) {
+    fs.mkdirSync(outputDirectory, { recursive: true });
+  }
+  if (!fs.existsSync(typesDirectory)) {
+    fs.mkdirSync(typesDirectory, { recursive: true });
+  }
+
+  for (const service of services) {
+    const {
+      name: serviceName,
+      url
+    } = service;
+    if (SKIPPED_SERVICES.has(serviceName)) {
+      continue;
+    }
+    if (filter && !filter.has(serviceName)) {
+      continue;
+    }
+    const specUrl = `${baseUrl}${url}`;
+    const spec = await fetchJson(specUrl);
+    const fileBase = toFileBase(serviceName);
+    const content = generateForSpec(spec, serviceName, fileBase, clientType);
+    const typesContent = generateTypes(spec);
+
+    const outPath = path.join(outputDirectory, `${fileBase}.ts`);
+    const typesPath = path.join(typesDirectory, `${fileBase}-type.ts`);
+    fs.writeFileSync(outPath, content, 'utf8');
+    fs.writeFileSync(typesPath, typesContent, 'utf8');
+    console.log(`Generated ${outPath}`);
+    console.log(`Generated ${typesPath}`);
+  }
+}
+
+main()
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "beer-swagger",
+  "version": "1.0.1",
+  "bin": {
+    "beer-swagger": "./generate-apis.js"
+  },
+  "scripts": {
+    "pub-m": "npm publish --access public"
+  },
+  "dependencies": {
+  },
+  "devDependencies": {
+    "@types/node": "22.19.7"
+  },
+  "resolutions": {
+    "dayjs": "^1.11.10"
+  },
+  "browserslist": {
+    "production": [
+      ">0.2%",
+      "not dead",
+      "not op_mini all"
+    ],
+    "development": [
+      "last 1 chrome version",
+      "last 1 firefox version",
+      "last 1 safari version"
+    ]
+  }
+}

package/tsconfig.node.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true
+  },
+  "include": [
+    "vite.config.ts"
+  ]
+}