Refactor

Author: owjs3901

packages/core/src/api-struct.ts

@@ -76,6 +76,34 @@ export type DevupDeleteApiStructKey<O extends string> = ConditionalKeys<
 export type DevupPatchApiStructKey<O extends string> = ConditionalKeys<
   DevupPatchApiStructScope<O>
 >
+export type DevupApiMethodKeys =
+  | 'get'
+  | 'post'
+  | 'put'
+  | 'delete'
+  | 'patch'
+  | 'GET'
+  | 'POST'
+  | 'PUT'
+  | 'DELETE'
+  | 'PATCH'
+
+export type DevupApiMethodScope<
+  S extends string,
+  M extends DevupApiMethodKeys,
+> = {
+  get: DevupGetApiStructScope<S>
+  post: DevupPostApiStructScope<S>
+  put: DevupPutApiStructScope<S>
+  delete: DevupDeleteApiStructScope<S>
+  patch: DevupPatchApiStructScope<S>
+  GET: DevupGetApiStructScope<S>
+  POST: DevupPostApiStructScope<S>
+  PUT: DevupPutApiStructScope<S>
+  DELETE: DevupDeleteApiStructScope<S>
+  PATCH: DevupPatchApiStructScope<S>
+}[M]
+
 export type DevupApiStructScope<O extends string> = DevupGetApiStructScope<O> &
   DevupPostApiStructScope<O> &
   DevupPutApiStructScope<O> &

packages/generator/src/__tests__/index.test.ts

@@ -30,5 +30,8 @@ test('index.ts exports', () => {
     extractSchemaNameFromRef: expect.any(Function),
     normalizeServerName: expect.any(Function),
     isErrorStatusCode: expect.any(Function),
+    isNullableSchema: expect.any(Function),
+    getPrimaryType: expect.any(Function),
+    collectSchemaNames: expect.any(Function),
   })
 })

packages/generator/src/generate-crud-config.ts

@@ -1,18 +1,9 @@
+import { toPascal } from '@devup-api/utils'
 import type { OpenAPIV3_1 } from 'openapi-types'
 import type { CrudConfig, CrudField } from './crud-types'
 import { parseCrudConfigsFromMultiple } from './parse-crud-tags'
 import { wrapInterfaceKeyGuard } from './wrap-interface-key-guard'
 
-/**
- * Convert string to PascalCase for component names
- */
-function toPascalCase(str: string): string {
-  return str
-    .split(/[-_]/)
-    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-    .join('')
-}
-
 /**
  * Convert string to title case for labels
  */
@@ -162,7 +153,7 @@ function generateFieldsComponent(
  */
 function generateCrudComponent(name: string, config: CrudConfig): string[] {
   const lines: string[] = []
-  const componentName = `${toPascalCase(name)}Crud`
+  const componentName = `${toPascal(name)}Crud`
   const fieldsComponentName = `${componentName}Fields`
 
   // Determine edit method and operationId
@@ -235,7 +226,7 @@ export function generateCrudConfigCode(
 
   // Generate component for each CRUD group
   for (const [name, config] of Object.entries(configs)) {
-    const componentName = `${toPascalCase(name)}Crud`
+    const componentName = `${toPascal(name)}Crud`
 
     // Get fields from create endpoint (primary form fields)
     const fields = config.create.fields ?? []
@@ -259,7 +250,7 @@ export function generateCrudConfigCode(
   // Default export
   lines.push('export default {')
   for (const name of Object.keys(configs)) {
-    const componentName = `${toPascalCase(name)}Crud`
+    const componentName = `${toPascal(name)}Crud`
     lines.push(`  ${name}: ${componentName},`)
   }
   lines.push('};')

packages/generator/src/generate-interface.ts

@@ -11,6 +11,7 @@ import {
   getTypeFromSchema,
 } from './generate-schema'
 import {
+  collectSchemaNames,
   extractSchemaNameFromRef,
   getRequestBodyContent,
   isErrorStatusCode,
@@ -145,73 +146,10 @@ function generateSchemaInterface(
   } as const
   const convertCaseType = options?.convertCase ?? 'camel'
 
-  // Helper function to collect schema names from a schema object
-  // Recursively traverses into referenced schemas to find all nested $refs
-  const collectSchemaNames = (
-    schemaObj: OpenAPIV3_1.SchemaObject | OpenAPIV3_1.ReferenceObject,
-    targetSet: Set<string>,
-    visited: Set<string> = new Set(),
-  ): void => {
-    if ('$ref' in schemaObj) {
-      const schemaName = extractSchemaNameFromRef(schemaObj.$ref)
-      if (schemaName) {
-        // Avoid infinite recursion for circular references
-        if (visited.has(schemaName)) {
-          return
-        }
-        targetSet.add(schemaName)
-        visited.add(schemaName)
-
-        // Recursively collect from the referenced schema
-        const referencedSchema = schema.components?.schemas?.[schemaName]
-        if (referencedSchema) {
-          collectSchemaNames(
-            referencedSchema as
-              | OpenAPIV3_1.SchemaObject
-              | OpenAPIV3_1.ReferenceObject,
-            targetSet,
-            visited,
-          )
-        }
-      }
-      return
-    }
-
-    const schemaObjTyped = schemaObj as OpenAPIV3_1.SchemaObject
-
-    // Check allOf, anyOf, oneOf
-    if (schemaObjTyped.allOf) {
-      schemaObjTyped.allOf.forEach((s) => {
-        collectSchemaNames(s, targetSet, visited)
-      })
-    }
-    if (schemaObjTyped.anyOf) {
-      schemaObjTyped.anyOf.forEach((s) => {
-        collectSchemaNames(s, targetSet, visited)
-      })
-    }
-    if (schemaObjTyped.oneOf) {
-      schemaObjTyped.oneOf.forEach((s) => {
-        collectSchemaNames(s, targetSet, visited)
-      })
-    }
-
-    // Check properties
-    if (schemaObjTyped.properties) {
-      Object.values(schemaObjTyped.properties).forEach((prop) => {
-        collectSchemaNames(prop, targetSet, visited)
-      })
-    }
-
-    // Check items (for arrays)
-    if (
-      schemaObjTyped.type === 'array' &&
-      'items' in schemaObjTyped &&
-      schemaObjTyped.items
-    ) {
-      collectSchemaNames(schemaObjTyped.items, targetSet, visited)
-    }
-  }
+  const collectOpts = {
+    followComponentRefs: true,
+    document: schema,
+  } as const
 
   // Track which schemas are used in request body and responses
   const requestSchemaNames = new Set<string>()
@@ -242,7 +180,11 @@ function generateSchemaInterface(
             const content = operation.requestBody.content
             const bodyContent = getRequestBodyContent(content)
             if (bodyContent && 'schema' in bodyContent && bodyContent.schema) {
-              collectSchemaNames(bodyContent.schema, requestSchemaNames)
+              collectSchemaNames(
+                bodyContent.schema,
+                requestSchemaNames,
+                collectOpts,
+              )
             }
           }
         }
@@ -272,9 +214,17 @@ function generateSchemaInterface(
                 jsonContent.schema
               ) {
                 if (isError) {
-                  collectSchemaNames(jsonContent.schema, errorSchemaNames)
+                  collectSchemaNames(
+                    jsonContent.schema,
+                    errorSchemaNames,
+                    collectOpts,
+                  )
                 } else {
-                  collectSchemaNames(jsonContent.schema, responseSchemaNames)
+                  collectSchemaNames(
+                    jsonContent.schema,
+                    responseSchemaNames,
+                    collectOpts,
+                  )
                 }
               }
             }

packages/generator/src/generate-schema.ts

@@ -1,6 +1,11 @@
 import type { OpenAPIV3_1 } from 'openapi-types'
 import type { ParameterDefinition } from './generate-interface'
-import { getRequestBodyContent, resolveRef } from './openapi-utils'
+import {
+  getPrimaryType,
+  getRequestBodyContent,
+  isNullableSchema,
+  resolveRef,
+} from './openapi-utils'
 import { wrapInterfaceKeyGuard } from './wrap-interface-key-guard'
 
 /**
@@ -83,35 +88,6 @@ function generateEnumName(
   return name
 }
 
-/**
- * Check if a schema is nullable (OpenAPI 3.0 or 3.1)
- * OpenAPI 3.0: uses `nullable: true`
- * OpenAPI 3.1: uses type array like `["string", "null"]`
- */
-function isNullable(schema: OpenAPIV3_1.SchemaObject): boolean {
-  // OpenAPI 3.0 style: nullable: true
-  if ('nullable' in schema && schema.nullable === true) {
-    return true
-  }
-
-  // OpenAPI 3.1 style: type is an array containing "null"
-  if (Array.isArray(schema.type) && schema.type.includes('null')) {
-    return true
-  }
-
-  return false
-}
-
-/**
- * Get the non-null type from OpenAPI 3.1 type array
- * e.g., ["string", "null"] -> "string"
- */
-function getNonNullType(
-  types: (OpenAPIV3_1.NonArraySchemaObjectType | 'array')[],
-): OpenAPIV3_1.NonArraySchemaObjectType | 'array' | undefined {
-  return types.find((t) => t !== 'null')
-}
-
 /**
  * Options for component reference handling
  */
@@ -241,7 +217,7 @@ export function getTypeFromSchema(
     }
 
     // Check if schema is nullable
-    const nullable = isNullable(schemaObj)
+    const nullable = isNullableSchema(schemaObj)
 
     // Handle enum
     if (schemaObj.enum) {
@@ -273,9 +249,7 @@ export function getTypeFromSchema(
     }
 
     // Get the actual type (handle OpenAPI 3.1 type arrays)
-    const actualType = Array.isArray(schemaObj.type)
-      ? getNonNullType(schemaObj.type)
-      : schemaObj.type
+    const actualType = getPrimaryType(schemaObj)
 
     // Handle primitive types
     if (actualType === 'string') {
@@ -718,7 +692,10 @@ export function extractRequestBody(
   }
 
   if ('$ref' in requestBody) {
-    const resolved = resolveRef(requestBody.$ref, document)
+    const resolved = resolveRef<OpenAPIV3_1.RequestBodyObject>(
+      requestBody.$ref,
+      document,
+    )
     if (resolved && 'content' in resolved && resolved.content) {
       const content =
         resolved.content as OpenAPIV3_1.RequestBodyObject['content']