feat: add test coverage command and integrate @vitest/coverage-v8 for enhanced testing capabilities, update package dependencies and configurations

Author: hairyf

package.json

@@ -10,6 +10,7 @@
     "lint": "eslint --cache .",
     "typecheck": "pnpm -r run typecheck",
     "test": "vitest",
+    "test:coverage": "vitest run --coverage",
     "automd": "pnpm --filter '@genapi/*' exec automd",
     "release": "bumpp -r && pnpm -r publish --access public",
     "prepare": "simple-git-hooks && skills-manifest install"
@@ -19,6 +20,7 @@
     "@antfu/ni": "catalog:cli",
     "@antfu/utils": "catalog:inlined",
     "@types/node": "catalog:types",
+    "@vitest/coverage-v8": "catalog:testing",
     "automd": "catalog:cli",
     "bumpp": "catalog:cli",
     "eslint": "catalog:cli",

packages/parser/src/index.ts

@@ -1,4 +1,4 @@
-export * from './create-parser'
+export * from './parser'
 export * from './parses'
 export * from './transform'
 export * from './traverse'

packages/parser/src/create-parser.ts packages/parser/src/parser.tspackages/parser/src/create-parser.ts renamed to packages/parser/src/parser.ts

@@ -45,9 +45,7 @@ export function createParser(pathHandler: PathHandler) {
     if (source.definitions)
       transformDefinitions(source.definitions)
 
-    traversePaths(source.paths ?? {}, (config) => {
-      pathHandler(config, inject() as ParserContext)
-    })
+    traversePaths(source.paths ?? {}, config => pathHandler(config, inject() as ParserContext))
 
     configRead.graphs.comments = comments
     configRead.graphs.functions = functions

packages/parser/src/transform/definitions.ts

@@ -1,4 +1,4 @@
-import type { ApiPipeline, StatementInterface } from '@genapi/shared'
+import type { ApiPipeline, StatementField, StatementInterface } from '@genapi/shared'
 import type { Definitions, Schema } from 'openapi-specification-types'
 import { inject } from '@genapi/shared'
 import { parseSchemaType } from '../parses'
@@ -10,43 +10,23 @@ export interface DefinitionTransformOptions {
 
 export function transformDefinitions(definitions: Definitions) {
   const { interfaces, configRead } = inject()
-  const config = (configRead?.config || {}) as ApiPipeline.Config
+  const config = configRead?.config || {} as ApiPipeline.Config
   const transformDef = config.transform?.definition
   const patchDefinitions = config.patch?.definitions || {}
 
-  // Map from original interface name to renamed interface name
-  // Used by parseSchemaType to resolve $ref to renamed interfaces
-  const nameMapping: Record<string, string> = {}
+  for (let [name, definition] of Object.entries(definitions)) {
+    const defProperties = definition.properties || {}
+    let properties = Object.keys(defProperties)
+      .map(name => defToFields(name, defProperties[name])) as StatementField[]
+    name = varName(name)
 
-  for (const [name, definition] of Object.entries(definitions)) {
-    const { properties = {} } = definition
-
-    const interfaceName = varName(name)
-
-    // Build a structural type string for this definition so `transform.definition`
-    // and `patch.definitions` can operate on it.
-    const baseType = buildDefinitionType(interfaceName, properties)
-    const patchResult = applyDefinitionTransformsAndPatches({
-      baseName: interfaceName,
-      baseType,
-      configRead,
-      transformDef,
-      patchDefinitions,
-    })
-
-    // If patch only renames (no type override), use the new name for the interface
-    // Otherwise, keep original name and create type alias
-    const finalInterfaceName = patchResult.shouldRename ? patchResult.aliasName : interfaceName
-
-    // Store mapping for parseSchemaType to use
-    if (finalInterfaceName !== interfaceName) {
-      nameMapping[interfaceName] = finalInterfaceName
-    }
+    ;({ name, properties } = applyPatch(transformDef?.(name, properties)))
+    ;({ name, properties } = applyPatch(patchDefinitions[name]))
 
     interfaces.push({
+      name,
       export: true,
-      name: finalInterfaceName,
-      properties: Object.keys(properties).map(name => defToFields(name, properties[name])),
+      properties,
     })
 
     function defToFields(name: string, propertie: Schema) {
@@ -59,109 +39,20 @@ export function transformDefinitions(definitions: Definitions) {
         required: required ?? (typeof propertie.required === 'boolean' ? propertie.required : undefined),
       }
     }
-  }
-
-  // Store name mapping in config for parseSchemaType to use
-  if (configRead?.config) {
-    (configRead.config as any).__definitionNameMapping = nameMapping
-  }
-}
-
-function buildDefinitionType(interfaceName: string, properties: Definitions[string]['properties'] = {}) {
-  const entries = Object.entries(properties)
-  if (entries.length === 0)
-    return 'any'
-
-  const fields = entries.map(([propName, schema]) => {
-    const type = parseSchemaType(schema as Schema)
-    return `${varFiled(propName)}: ${type}`
-  })
-
-  return `{ ${fields.join(', ')} }`
-}
-
-interface DefinitionPatchContext {
-  baseName: string
-  baseType: string
-  configRead: ApiPipeline.ConfigRead
-  transformDef?: (name: string, type: string) => ApiPipeline.Definition
-  patchDefinitions: Record<string, ApiPipeline.Definition>
-}
 
-/**
- * Applies `config.transform.definition` (global) and `config.patch.definitions` (static)
- * to a single Swagger/OpenAPI definition.
- *
- * Semantics:
- * - Rename only (string or name only): `'Order': 'OrderDTO'` → interface renamed to `OrderDTO`
- * - Rename + override type:
- *   `'SessionDto': { name: 'Session', type: '{ name: string }' }`
- *   → interface stays `SessionDto`, creates `export type Session = { name: string }`
- *
- * When only renaming, the interface itself is renamed so all references automatically
- * use the new name. When type is overridden, the original interface is preserved
- * and a type alias is created.
- */
-function applyDefinitionTransformsAndPatches(ctx: DefinitionPatchContext) {
-  const {
-    baseName,
-    baseType,
-    configRead,
-    transformDef,
-    patchDefinitions,
-  } = ctx
-
-  let aliasName = baseName
-  let aliasType = baseType
-  let hasTypeOverride = false
-
-  function applyPatch(patch?: ApiPipeline.Definition) {
-    if (!patch)
-      return
-
-    if (typeof patch === 'string') {
-      aliasName = patch
-      return
-    }
+    function applyPatch(patch?: ApiPipeline.Definition) {
+      if (!patch)
+        return { name, properties }
+      if (typeof patch === 'string') {
+        name = patch
+        return { name, properties }
+      }
+      if (patch.name)
+        name = patch.name
+      if (patch.type)
+        properties = patch.type
 
-    if (patch.name)
-      aliasName = patch.name
-    if (patch.type) {
-      aliasType = patch.type
-      hasTypeOverride = true
+      return { name, properties }
     }
   }
-
-  // Global transform first.
-  if (transformDef) {
-    const patch = transformDef(baseName, baseType)
-    applyPatch(patch)
-  }
-
-  // Then static patch; allow matching by original or transformed name.
-  const staticPatch = patchDefinitions[baseName] ?? patchDefinitions[aliasName]
-  applyPatch(staticPatch)
-
-  const hasNameChange = aliasName !== baseName
-  const hasTypeChange = aliasType !== baseType
-
-  if (!hasNameChange && !hasTypeChange)
-    return { aliasName: baseName, shouldRename: false }
-
-  // If only renaming (no type override), rename the interface itself
-  // Otherwise, create a type alias
-  const shouldRename = hasNameChange && !hasTypeOverride
-
-  if (!shouldRename) {
-    // Create type alias when type is overridden
-    const aliasValue = hasTypeChange ? aliasType : baseName
-    configRead.graphs.typings = configRead.graphs.typings || []
-    configRead.graphs.typings.push({
-      export: true,
-      name: aliasName,
-      value: aliasValue,
-    })
-  }
-
-  return { aliasName, shouldRename }
 }

packages/parser/test/transform/definitions.test.ts

@@ -126,18 +126,16 @@ describe('transformDefinitions', () => {
       // Interface renamed to User
       expect(interfaces.find((i: any) => i.name === 'User')).toBeDefined()
       expect(interfaces.find((i: any) => i.name === 'UserDto')).toBeUndefined()
-      // No type alias created when only renaming
-      expect(configRead.graphs.typings).toHaveLength(0)
     })
 
-    it('creates type alias with custom type when patch provides type override', () => {
+    it('applies name and type when patch provides both', () => {
       const interfaces: any[] = []
       provide({ interfaces, configRead })
       configRead.config.patch = {
         definitions: {
           SessionDto: {
             name: 'Session',
-            type: '{ name: string, age: number }',
+            type: [{ name: 'name', type: 'string' }, { name: 'age', type: 'number' }],
           },
         },
       }
@@ -153,11 +151,12 @@ describe('transformDefinitions', () => {
       }
       transformDefinitions(definitions as any)
 
-      // Original interface preserved when type is overridden
-      expect(interfaces.find((i: any) => i.name === 'SessionDto')).toBeDefined()
-      expect(configRead.graphs.typings).toHaveLength(1)
-      expect(configRead.graphs.typings![0].name).toBe('Session')
-      expect(configRead.graphs.typings![0].value).toBe('{ name: string, age: number }')
+      // Interface renamed to Session with patch type as properties
+      const session = interfaces.find((i: any) => i.name === 'Session')
+      expect(session).toBeDefined()
+      expect(session!.properties).toHaveLength(2)
+      expect(session!.properties.map((p: any) => p.name)).toEqual(['name', 'age'])
+      expect(interfaces.find((i: any) => i.name === 'SessionDto')).toBeUndefined()
     })
 
     it('handles multiple definition patches', () => {
@@ -182,10 +181,9 @@ describe('transformDefinitions', () => {
       }
       transformDefinitions(definitions as any)
 
-      // Interfaces renamed, no type aliases created
+      // Interfaces renamed
       expect(interfaces.find((i: any) => i.name === 'User')).toBeDefined()
       expect(interfaces.find((i: any) => i.name === 'Order')).toBeDefined()
-      expect(configRead.graphs.typings).toHaveLength(0)
     })
 
     it('renames interface when patch matches transformed name', () => {
@@ -215,7 +213,6 @@ describe('transformDefinitions', () => {
 
       // Interface renamed to UserAlias (transform: UserDto -> User, patch: User -> UserAlias)
       expect(interfaces.find((i: any) => i.name === 'UserAlias')).toBeDefined()
-      expect(configRead.graphs.typings).toHaveLength(0)
     })
 
     it('renames interface when patch only renames', () => {
@@ -275,11 +272,9 @@ describe('transformDefinitions', () => {
 
       // Transform: UserDto -> User
       // Patch: User -> UserEntity
-      // Interface should be renamed to UserEntity (no typings created)
       expect(interfaces.find((i: any) => i.name === 'UserEntity')).toBeDefined()
       expect(interfaces.find((i: any) => i.name === 'User')).toBeUndefined()
       expect(interfaces.find((i: any) => i.name === 'UserDto')).toBeUndefined()
-      expect(configRead.graphs.typings).toHaveLength(0)
     })
 
     it('renames interface when transform returns string', () => {
@@ -301,18 +296,17 @@ describe('transformDefinitions', () => {
       // Interface renamed to RenamedType
       expect(interfaces.find((i: any) => i.name === 'RenamedType')).toBeDefined()
       expect(interfaces.find((i: any) => i.name === 'OriginalType')).toBeUndefined()
-      expect(configRead.graphs.typings).toHaveLength(0)
     })
 
-    it('creates type alias with custom type when transform returns object with type', () => {
+    it('applies name and type when transform returns object with type', () => {
       const interfaces: any[] = []
       provide({ interfaces, configRead })
       configRead.config.transform = {
         operation: () => '',
-        definition: (name, type) => {
+        definition: (name) => {
           return {
             name: `${name}Alias`,
-            type: `Custom${type}`,
+            type: [{ name: 'id', type: 'integer' }],
           }
         },
       }
@@ -325,19 +319,19 @@ describe('transformDefinitions', () => {
       }
       transformDefinitions(definitions as any)
 
-      // Original interface preserved when type is overridden
-      expect(interfaces.find((i: any) => i.name === 'Test')).toBeDefined()
-      expect(configRead.graphs.typings).toHaveLength(1)
-      expect(configRead.graphs.typings![0].name).toBe('TestAlias')
-      expect(configRead.graphs.typings![0].value).toContain('Custom')
+      // Interface renamed to TestAlias with transform type as properties
+      const testAlias = interfaces.find((i: any) => i.name === 'TestAlias')
+      expect(testAlias).toBeDefined()
+      expect(testAlias!.properties).toHaveLength(1)
+      expect(testAlias!.properties[0]).toEqual({ name: 'id', type: 'integer', required: undefined, description: undefined })
     })
 
-    it('does not create alias when transform returns same name and type', () => {
+    it('keeps interface unchanged when transform returns same name and type', () => {
       const interfaces: any[] = []
       provide({ interfaces, configRead })
       configRead.config.transform = {
         operation: () => '',
-        definition: (name, type) => ({ name, type }), // No-op transform
+        definition: (name, properties) => ({ name, type: properties }), // No-op transform
       }
 
       const definitions = {
@@ -348,8 +342,8 @@ describe('transformDefinitions', () => {
       }
       transformDefinitions(definitions as any)
 
-      // No typings should be created since nothing changed
-      expect(configRead.graphs.typings).toHaveLength(0)
+      expect(interfaces.find((i: any) => i.name === 'Unchanged')).toBeDefined()
+      expect(interfaces.find((i: any) => i.name === 'Unchanged')!.properties).toHaveLength(1)
     })
   })
 })

packages/presets/src/ofetch/js/config/index.ts

@@ -11,8 +11,8 @@ export function config(userConfig: ApiPipeline.Config): ApiPipeline.ConfigRead {
   const configRead = _config(userConfig)
 
   configRead.graphs.imports.push({
-    name: 'ofetch',
     value: userConfig.import.http,
+    names: ['ofetch'],
   })
 
   return configRead

packages/presets/src/ofetch/ts/config/index.ts

@@ -8,8 +8,7 @@ export function config(userConfig: ApiPipeline.Config): ApiPipeline.ConfigRead {
   const configRead = _config(userConfig)
 
   configRead.graphs.imports.push({
-    name: 'ofetch',
-    names: userConfig.import.http === 'ofetch' ? ['FetchOptions'] : undefined,
+    names: userConfig.import.http === 'ofetch' ? ['FetchOptions', 'ofetch'] : ['ofetch'],
     value: userConfig.import.http,
   })
 

packages/shared/src/types/config.ts

@@ -104,7 +104,7 @@ export namespace ApiPipeline {
   }
   export type Definition = string | {
     name?: string
-    type?: string
+    type?: StatementField[]
   }
 
   export interface Patch {
@@ -149,7 +149,7 @@ export namespace ApiPipeline {
      * @description
      * Transform the definition type
      */
-    definition?: (name: string, type: string) => Definition
+    definition?: (name: string, type: StatementField[]) => Definition
   }
 
   export interface Config extends PreInputs, PreOutput, Meta {

playground/package.json

@@ -10,11 +10,11 @@
     "@genapi/pipeline": "workspace:*",
     "@genapi/presets": "workspace:*",
     "@genapi/transform": "workspace:*",
-    "ofetch": "catalog:",
     "wpapi-to-swagger": "catalog:playground"
   },
   "devDependencies": {
     "@uni-helper/uni-network": "catalog:playground",
-    "fetchdts": "catalog:"
+    "fetchdts": "catalog:inlined",
+    "ofetch": "catalog:inlined"
   }
 }