Fix schema

Author: owjs3901

examples/vite/openapi.json

@@ -175,6 +175,20 @@
   },
   "components": {
     "schemas": {
+      "Post": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "integer"
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "date-time",
+            "default": "2021-01-01T00:00:00Z"
+          }
+        },
+        "required": ["id"]
+      },
       "User": {
         "type": "object",
         "properties": {

packages/core/src/options.ts

@@ -1,26 +1,31 @@
 export interface DevupApiTypeGeneratorOptions {
   /**
    * Case conversion type for API endpoint names and parameters
-   * @default 'camel'
+   * @default {'camel'}
    */
   convertCase?: 'snake' | 'camel' | 'pascal' | 'maintain'
   /**
    * Whether to make all properties non-nullable by default
-   * @default false
+   * @default {false}
    */
-  defaultNonNullable?: boolean
+  requestDefaultNonNullable?: boolean
+  /**
+   * Whether to make all request properties non-nullable by default
+   * @default {true}
+   */
+  responseDefaultNonNullable?: boolean
 }
 
 export interface DevupApiOptions extends DevupApiTypeGeneratorOptions {
   /**
    * Temporary directory for storing generated files
-   * @default 'df'
+   * @default {'df'}
    */
   tempDir?: string
 
   /**
    * OpenAPI file path
-   * @default 'openapi.json'
+   * @default {'openapi.json'}
    */
   openapiFile?: string
 }

packages/generator/src/generate-interface.ts

@@ -22,8 +22,16 @@ export interface EndpointDefinition {
   params?: Record<string, ParameterDefinition>
   body?: unknown
   query?: Record<string, ParameterDefinition>
+  response?: unknown
 }
 
+// Helper function to extract schema names from $ref
+function extractSchemaNameFromRef(ref: string): string | null {
+  if (ref.startsWith('#/components/schemas/')) {
+    return ref.replace('#/components/schemas/', '')
+  }
+  return null
+}
 export function generateInterface(
   schema: OpenAPIV3_1.Document,
   options?: DevupApiTypeGeneratorOptions,
@@ -40,14 +48,6 @@ export function generateInterface(
   } as const
   const convertCaseType = options?.convertCase ?? 'camel'
 
-  // Helper function to extract schema names from $ref
-  const extractSchemaNameFromRef = (ref: string): string | null => {
-    if (ref.startsWith('#/components/schemas/')) {
-      return ref.replace('#/components/schemas/', '')
-    }
-    return null
-  }
-
   // Helper function to collect schema names from a schema object
   const collectSchemaNames = (
     schemaObj: OpenAPIV3_1.SchemaObject | OpenAPIV3_1.ReferenceObject,
@@ -248,6 +248,94 @@ export function generateInterface(
           endpoint.body = requestBodyType
         }
 
+        // Extract response
+        // Check if response uses a component schema
+        let responseType: unknown
+        if (operation.responses) {
+          // Prefer 200 response, fallback to first available response
+          const successResponse =
+            operation.responses['200'] ||
+            operation.responses['201'] ||
+            Object.values(operation.responses)[0]
+
+          if (successResponse) {
+            if ('$ref' in successResponse) {
+              // ResponseObject reference - skip for now
+              // Could resolve if needed
+            } else if ('content' in successResponse) {
+              const content = successResponse.content
+              const jsonContent = content?.['application/json']
+              if (
+                jsonContent &&
+                'schema' in jsonContent &&
+                jsonContent.schema
+              ) {
+                // Check if schema is a direct reference to components.schemas
+                if ('$ref' in jsonContent.schema) {
+                  const schemaName = extractSchemaNameFromRef(
+                    jsonContent.schema.$ref,
+                  )
+                  // Check if schema exists in components.schemas and is used in response
+                  if (
+                    schemaName &&
+                    schema.components?.schemas?.[schemaName] &&
+                    responseSchemaNames.has(schemaName)
+                  ) {
+                    // Use component reference
+                    responseType = `DevupResponseComponentStruct['${schemaName}']`
+                  } else {
+                    // Extract schema type
+                    const { type: schemaType } = getTypeFromSchema(
+                      jsonContent.schema,
+                      schema,
+                    )
+                    responseType = schemaType
+                  }
+                } else {
+                  // Check if it's an array with items referencing a component schema
+                  const schemaObj =
+                    jsonContent.schema as OpenAPIV3_1.SchemaObject
+                  if (
+                    schemaObj.type === 'array' &&
+                    schemaObj.items &&
+                    '$ref' in schemaObj.items
+                  ) {
+                    const schemaName = extractSchemaNameFromRef(
+                      schemaObj.items.$ref,
+                    )
+                    // Check if schema exists in components.schemas and is used in response
+                    if (
+                      schemaName &&
+                      schema.components?.schemas?.[schemaName] &&
+                      responseSchemaNames.has(schemaName)
+                    ) {
+                      // Use component reference for array items
+                      responseType = `Array<DevupResponseComponentStruct['${schemaName}']>`
+                    } else {
+                      // Extract schema type
+                      const { type: schemaType } = getTypeFromSchema(
+                        jsonContent.schema,
+                        schema,
+                      )
+                      responseType = schemaType
+                    }
+                  } else {
+                    // Extract schema type
+                    const { type: schemaType } = getTypeFromSchema(
+                      jsonContent.schema,
+                      schema,
+                    )
+                    responseType = schemaType
+                  }
+                }
+              }
+            }
+          }
+        }
+        if (responseType !== undefined) {
+          endpoint.response = responseType
+        }
+
         // Generate path key (normalize path by replacing {param} with converted param and removing slashes)
         const normalizedPath = path.replace(/\{([^}]+)\}/g, (_, param) => {
           // Convert param name based on case type