feat: update ESLint configuration to disable 'no-template-curly-in-string' rule, upgrade openapi-specification-types version to 0.3.0, and enhance parser functionality with additional parameter handling

Author: hairyf

eslint.config.js

@@ -9,6 +9,7 @@ export default antfu(
   },
   {
     rules: {
+      'no-template-curly-in-string': 'off',
       'ts/explicit-function-return-type': 'off',
       'ts/no-namespace': 'off',
     },

packages/core/vitest.config.ts

@@ -26,6 +26,7 @@
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",
+    "test": "vitest run",
     "typecheck": "tsc --noEmit",
     "automd": "automd",
     "prepublishOnly": "nr build"

packages/parser/package.json

@@ -36,9 +36,10 @@ export function createParser(pathHandler: PathHandler) {
 
     provide({ interfaces, functions })
     transformBaseURL(source)
-    transformDefinitions(source.definitions)
+    if (source.definitions)
+      transformDefinitions(source.definitions)
 
-    traversePaths(source.paths, (config) => {
+    traversePaths(source.paths ?? {}, (config) => {
       pathHandler(config, inject() as ParserContext)
     })
 

packages/parser/src/create-parser.ts

@@ -1,5 +1,5 @@
-import type { OpenAPISpecificationV2 } from 'openapi-specification-types'
-import type { OpenAPISpecificationV3 } from 'openapi-specification-types/index-v3'
+import type { OpenAPISpecificationV2, OpenAPISpecificationV3 } from 'openapi-specification-types'
+
 import { swagger2ToSwagger3 } from '@genapi/transform'
 
 /**

packages/parser/src/parses/common.ts

@@ -1,4 +1,3 @@
-/* eslint-disable ts/ban-ts-comment */
 import type { StatementField, StatementInterface } from '@genapi/shared'
 import type { Parameter } from 'openapi-specification-types'
 import type { PathMethod } from '../traverse'
@@ -18,12 +17,14 @@ export type { InSchemas }
  */
 export function parseMethodParameters({ method, parameters, path }: PathMethod, schemas?: InSchemas) {
   const { config: userConfig } = inject()
-  const requestConfigs = {
-    body: [] as StatementField[],
-    formData: [] as StatementField[],
-    path: [] as StatementField[],
-    query: [] as StatementField[],
-    header: [] as StatementField[],
+  const requestConfigs: Record<string, StatementField[]> = {
+    body: [],
+    formData: [],
+    path: [],
+    query: [],
+    header: [],
+    cookie: [],
+    querystring: [],
   }
 
   const config = {
@@ -32,14 +33,17 @@ export function parseMethodParameters({ method, parameters, path }: PathMethod,
     interfaces: [] as StatementInterface[],
   }
 
-  for (const parameter of parameters)
-    requestConfigs[parameter.in].push(parseParameterFiled(parameter))
+  for (const parameter of parameters) {
+    const key = parameter.in
+    if (key in requestConfigs)
+      requestConfigs[key].push(parseParameterFiled(parameter))
+  }
 
-  for (const [inType, properties] of Object.entries(requestConfigs) as [Parameter['in'], StatementField[]][]) {
+  for (const [inType, properties] of Object.entries(requestConfigs)) {
     if (properties.length === 0)
       continue
 
-    const name = toUndefField(inType, schemas)
+    const name = toUndefField(inType as Parameter['in'], schemas)
 
     if (inType !== 'path')
       config.options.push(name)
@@ -56,7 +60,7 @@ export function parseMethodParameters({ method, parameters, path }: PathMethod,
       continue
     }
 
-    if (['header', 'path', 'query'].includes(inType)) {
+    if (['header', 'path', 'query', 'cookie', 'querystring'].includes(inType)) {
       const typeName = varName([method, path, inType])
       config.interfaces.push({ name: typeName, properties, export: true })
       const required = inType === 'path' || isRequiredParameter(properties) || userConfig?.parametersRequired
@@ -87,25 +91,30 @@ export function parseMethodParameters({ method, parameters, path }: PathMethod,
 
 export function parseMethodMetadata({ method, path, responses, options: meta }: PathMethod) {
   const { configRead, interfaces } = inject()
+  const metaAny = meta as { consumes?: string[] }
   const comments = [
     meta.summary && `@summary ${meta.summary}`,
     meta.description && `@description ${meta.description}`,
     `@method ${method}`,
-    meta.tags && `@tags ${meta.tags.join(' | ') || '-'}`,
-    meta.consumes && `@consumes ${meta.consumes.join('; ') || '-'}`,
-  ]
+    meta.tags?.length ? `@tags ${meta.tags.join(' | ') || '-'}` : undefined,
+    metaAny.consumes?.length ? `@consumes ${metaAny.consumes.join('; ') || '-'}` : undefined,
+  ].filter((c): c is string => typeof c === 'string')
 
   const name = camelCase(`${method}/${path}`)
 
   const url = `${path.replace(/(\{)/g, '${paths.')}`
-  const responseSchema
-    // @ts-expect-error
-    = responses.default?.content?.['application/json']?.schema
-    // @ts-expect-error
-      || responses['200']?.content?.['application/json']?.schema
-      || responses['200']?.schema
-      || responses['200']
-  const responseType = responseSchema ? parseSchemaType(responseSchema) : 'void'
+  function hasContent(r: unknown): r is { content?: Record<string, { schema?: unknown }> } {
+    return r != null && typeof r === 'object' && 'content' in r
+  }
+  const resDefault = responses.default && hasContent(responses.default) ? responses.default : null
+  const res200 = responses['200'] && typeof responses['200'] === 'object' ? responses['200'] : null
+  const contentDefault = resDefault?.content?.['application/json']
+  const content200 = res200 && hasContent(res200) ? res200.content?.['application/json'] : null
+  const schemaFromContent = (contentDefault && typeof contentDefault === 'object' && 'schema' in contentDefault ? (contentDefault as { schema: unknown }).schema : null)
+    ?? (content200 && typeof content200 === 'object' && 'schema' in content200 ? (content200 as { schema: unknown }).schema : null)
+  const schemaFromRes200 = res200 && typeof res200 === 'object' && 'schema' in res200 && !('content' in res200) ? (res200 as { schema: unknown }).schema : null
+  const responseSchema = schemaFromContent ?? schemaFromRes200
+  const responseType = responseSchema && typeof responseSchema === 'object' ? parseSchemaType(responseSchema as Parameters<typeof parseSchemaType>[0]) : 'void'
 
   if (configRead.config.responseRequired)
     deepSignRequired(interfaces.find(v => v.name === responseType)?.properties || [])
@@ -119,5 +128,5 @@ export function parseMethodMetadata({ method, path, responses, options: meta }:
     }
   }
 
-  return { description: comments.filter(Boolean), name, url, responseType, body: [] as string[] }
+  return { description: comments, name, url, responseType, body: [] as string[] }
 }

packages/parser/src/parses/method.ts

@@ -19,12 +19,14 @@ export function parseParameterFiled(parameter: Parameter) {
     field.description = `@description ${field.description}`
 
   if (parameter.in === 'query' && parameter.type === 'array') {
-    const enums = spliceEnumDescription(parameter.name, parameter.items?.enum)
-    field.description = [field.description || '', enums].filter(Boolean)
+    const rawEnum = parameter.items?.enum
+    const enums = Array.isArray(rawEnum) ? rawEnum.filter((e): e is string => typeof e === 'string') : []
+    const enumsDesc = spliceEnumDescription(parameter.name, enums)
+    field.description = [field.description || '', enumsDesc].filter(Boolean)
   }
 
   if (['formData', 'body', 'header', 'path', 'query'].includes(parameter.in))
-    field.type = parseSchemaType(parameter)
+    field.type = parseSchemaType(parameter as Parameters<typeof parseSchemaType>[0])
 
   if (!field.description)
     delete field.description

packages/parser/src/parses/parameter.ts

@@ -1,10 +1,20 @@
 import type { StatementField } from '@genapi/shared'
-import type { Properties, Schema } from 'openapi-specification-types'
+import type { Properties, Schema, SchemaType } from 'openapi-specification-types'
 import { inject } from '@genapi/shared'
 import { isArray, uniq } from '@hairy/utils'
 import { spliceEnumType, useRefMap, varName } from '../utils'
 
-type SchemaWithAllOf = Schema & { allOf?: Schema[] }
+type SchemaWithAllOf = Schema & { allOf?: Schema[], schema?: Schema }
+type SchemaLike = SchemaWithAllOf & { required?: boolean | string[] }
+
+function schemaRequired(schema: SchemaLike, field?: string): boolean {
+  const r = schema.required
+  if (r === undefined)
+    return true
+  if (typeof r === 'boolean')
+    return r
+  return field !== undefined ? r.includes(field) : true
+}
 
 /**
  * parse schema to type
@@ -56,7 +66,7 @@ export function parseSchemaType(propertie: SchemaWithAllOf): string {
           isMerge = true
         fields[field] = {
           type,
-          required: item.required ?? true,
+          required: schemaRequired(item as SchemaLike, field),
           description: item.description,
           name: field,
         }
@@ -77,18 +87,23 @@ export function parseSchemaType(propertie: SchemaWithAllOf): string {
     return name
   }
 
-  if (propertie.schema)
-    return parseSchemaType(propertie.schema)
+  const schemaRef = (propertie as SchemaWithAllOf).schema
+  if (schemaRef && typeof schemaRef === 'object')
+    return parseSchemaType(schemaRef)
 
   // TODO: handle additionalProperties
-  if (propertie.additionalProperties)
-    return `Record<string, ${parseSchemaType(propertie.additionalProperties)}>`
+  const addProps = propertie.additionalProperties
+  if (addProps === true)
+    return 'Record<string, any>'
+  if (addProps && typeof addProps === 'object')
+    return `Record<string, ${parseSchemaType(addProps)}>`
   if (propertie.type === 'object') {
     const fields: Record<string, StatementField> = {}
     for (const [field, item] of Object.entries(propertie.properties || {})) {
+      const itemLike = item as SchemaLike
       fields[field] = {
         type: parseSchemaType(item),
-        required: item.required,
+        required: schemaRequired(itemLike, field),
         description: item.description,
         name: field,
       }
@@ -100,8 +115,11 @@ export function parseSchemaType(propertie: SchemaWithAllOf): string {
     return 'any'
 
   if (propertie.type === 'array') {
-    if (propertie.items?.enum)
-      return ['string', spliceEnumType(propertie.items.enum)].filter(Boolean).join(' | ')
+    const itemsEnum = propertie.items?.enum
+    if (Array.isArray(itemsEnum)) {
+      const enumStrs = itemsEnum.filter((e): e is string => typeof e === 'string')
+      return ['string', spliceEnumType(enumStrs)].filter(Boolean).join(' | ')
+    }
 
     let itemsType = parseSchemaType(propertie.items!)
     itemsType = itemsType.includes('|') ? `(${itemsType})` : itemsType
@@ -111,8 +129,10 @@ export function parseSchemaType(propertie: SchemaWithAllOf): string {
   if (propertie.type === 'boolean')
     return propertie.type
 
-  if (isArray(propertie.type))
-    return uniq(propertie.type.map(type => parseSchemaType({ type }))).join(' | ')
+  if (isArray(propertie.type)) {
+    const types = (propertie.type as unknown[]).filter((t): t is string => typeof t === 'string')
+    return uniq(types.map(type => parseSchemaType({ type: type as SchemaType }))).join(' | ')
+  }
 
   if (['integer', 'long', 'float', 'byte', 'TypesLong', 'number'].includes(propertie.type))
     return 'number'

packages/parser/src/parses/schema.ts

@@ -21,15 +21,13 @@ export function transformDefinitions(definitions: Definitions) {
     })
 
     function defToFields(name: string, propertie: Schema) {
-      propertie.required = definition?.required?.includes(name)
-      if (propertie.description)
-        propertie.description = `@description ${propertie.description}`
-
+      const required = Array.isArray(definition?.required) ? definition.required.includes(name) : undefined
+      const description = propertie.description ? `@description ${propertie.description}` : undefined
       return {
         name: varFiled(name),
         type: parseSchemaType(propertie),
-        description: propertie.description,
-        required: propertie.required,
+        description,
+        required: required ?? (typeof propertie.required === 'boolean' ? propertie.required : undefined),
       }
     }
   }

packages/parser/src/transform/definitions.ts

@@ -1,5 +1,15 @@
 import type { Method, Parameter, Paths, RequestBody, Responses } from 'openapi-specification-types'
 
+const HTTP_METHODS = ['get', 'put', 'post', 'delete', 'patch', 'head', 'options'] as const
+
+function isParameter(p: Parameter | { $ref?: string }): p is Parameter {
+  return p != null && 'name' in p && 'in' in p
+}
+
+function isOperationObject(value: unknown): value is Method {
+  return value != null && typeof value === 'object' && 'responses' in value
+}
+
 export interface PathMethod {
   path: string
   parameters: Parameter[]
@@ -17,19 +27,23 @@ export interface PathMethod {
  */
 export function traversePaths(paths: Paths, callback: (options: PathMethod) => void) {
   for (const [path, _others] of Object.entries(paths)) {
-    let { parameters = [], ...methods } = _others
-    for (const method in methods) {
-      const options = methods[method as keyof typeof methods]
+    if (typeof _others === 'string' || Array.isArray(_others))
+      continue
+    const pathParameters = (Array.isArray(_others.parameters) ? _others.parameters : [])
+      .filter(isParameter)
+    for (const method of HTTP_METHODS) {
+      const options = _others[method]
+      if (!isOperationObject(options))
+        continue
       const parametersMap = new Map<string, Parameter>()
-
-      for (const parameter of parameters)
+      for (const parameter of pathParameters)
         parametersMap.set(parameter.name, parameter)
-      for (const parameter of (options.parameters || []))
+      const opParams = (options.parameters ?? []).filter(isParameter)
+      for (const parameter of opParams)
         parametersMap.set(parameter.name, parameter)
-
-      parameters = [...parametersMap.values()]
-
-      extendsRequestBody(parameters, options.requestBody)
+      const parameters = [...parametersMap.values()]
+      if (options.requestBody && 'content' in options.requestBody)
+        extendsRequestBody(parameters, options.requestBody)
       callback({
         responses: options.responses,
         path,
@@ -42,24 +56,25 @@ export function traversePaths(paths: Paths, callback: (options: PathMethod) => v
 }
 
 function extendsRequestBody(parameters: Parameter[], requestBody?: RequestBody) {
-  if (!requestBody)
+  if (!requestBody?.content)
     return
-  if (requestBody.content['multipart/form-data']) {
-    const properties = requestBody.content['multipart/form-data'].schema.properties!
-    for (const name in Object.keys(properties)) {
+  const multipart = requestBody.content['multipart/form-data']
+  if (multipart && 'schema' in multipart && multipart.schema?.properties) {
+    const properties = multipart.schema.properties
+    for (const name of Object.keys(properties)) {
       parameters.push({
         in: 'formData',
         name,
         description: requestBody.description,
-        ...properties[name],
+        ...(properties[name] as object),
       })
     }
     return
   }
-
-  if (requestBody.content['application/json']) {
+  const json = requestBody.content['application/json']
+  if (json && typeof json === 'object') {
     parameters.push({
-      ...requestBody.content['application/json'] as any,
+      ...(json as object),
       description: requestBody.description,
       in: 'body',
       name: 'body',