wip: decouple

Author: mnahkies

packages/openapi-code-generator/src/core/input.ts

@@ -23,6 +23,7 @@ import type {
   IRModelObject,
   IRModelString,
   IROperation,
+  IROperationParams,
   IRParameter,
   IRParameterBase,
   IRParameterCookie,
@@ -31,6 +32,7 @@ import type {
   IRParameterQuery,
   IRPreprocess,
   IRRef,
+  IRRequestBody,
   IRResponse,
   IRServer,
   IRServerVariable,
@@ -59,7 +61,7 @@ export class Input {
   constructor(
     readonly loader: OpenapiLoader,
     readonly config: InputConfig,
-    private readonly schemaNormalizer = new SchemaNormalizer(config),
+    readonly schemaNormalizer = new SchemaNormalizer(config),
     private readonly parameterNormalizer = new ParameterNormalizer(
       schemaNormalizer,
     ),
@@ -89,8 +91,10 @@ export class Input {
 
     return Object.fromEntries(
       Object.entries(schemas).map(([name, maybeSchema]) => {
-        // TODO: double normalization?
-        return [name, this.schema(this.schemaNormalizer.normalize(maybeSchema))]
+        const schema = this.schemaNormalizer.normalize(
+          this.loader.schema(maybeSchema),
+        )
+        return [name, schema]
       }),
     )
   }
@@ -119,8 +123,6 @@ export class Input {
     )) {
       paths = this.loader.paths(paths)
 
-      const params = this.normalizeParameters(paths.parameters)
-
       const additionalAttributes = Object.fromEntries(
         Object.entries(paths).filter(
           ([key]) => key !== "parameters" && !isHttpMethod(key),
@@ -154,16 +156,18 @@ export class Input {
           throw new Error("callbacks are not supported")
         }
 
+        const parameters = (paths.parameters ?? []).concat(
+          definition.parameters ?? [],
+        )
+
         result.push({
           ...additionalAttributes,
           route,
           method,
           servers: this.normalizeServers(
             coalesce(definition.servers, paths.servers, []),
           ),
-          parameters: params.concat(
-            this.normalizeParameters(definition.parameters),
-          ),
+          params: this.normalizeParameters(operationId, parameters),
           operationId,
           tags: definition.tags ?? [],
           requestBody: this.normalizeRequestBodyObject(
@@ -235,9 +239,13 @@ export class Input {
     ).map(([name, operations]) => ({name, operations}))
   }
 
-  schema(maybeRef: Reference | Schema): IRModel {
-    const schema = this.loader.schema(maybeRef)
-    return this.schemaNormalizer.normalize(schema)
+  schema(maybeRef: MaybeIRModel): IRModel {
+    if (isRef(maybeRef)) {
+      const schema = this.loader.schema(maybeRef)
+      return this.schemaNormalizer.normalize(schema)
+    }
+
+    return maybeRef
   }
 
   preprocess(maybePreprocess: Reference | xInternalPreproccess): IRPreprocess {
@@ -288,7 +296,7 @@ export class Input {
   private normalizeRequestBodyObject(
     operationId: string,
     requestBody?: RequestBody | Reference,
-  ) {
+  ): IRRequestBody | undefined {
     if (!requestBody) {
       return undefined
     }
@@ -340,11 +348,73 @@ export class Input {
   }
 
   private normalizeParameters(
+    operationId: string,
     parameters: (Parameter | Reference)[] = [],
-  ): IRParameter[] {
-    return parameters
-      .map((it) => this.loader.parameter(it))
-      .map((it) => this.parameterNormalizer.normalizeParameter(it))
+  ): IROperationParams {
+    const allParameters = parameters.map((it) => this.loader.parameter(it))
+
+    const pathParameters = allParameters.filter((it) => it.in === "path")
+    const queryParameters = allParameters.filter((it) => it.in === "query")
+    const headerParameters = allParameters.filter((it) => it.in === "header")
+
+    const normalizedParameters = allParameters.map((it) =>
+      this.parameterNormalizer.normalizeParameter(it),
+    )
+
+    return {
+      all: normalizedParameters,
+      path: {
+        name: `${operationId}ParamSchema`,
+        list: normalizedParameters.filter((it) => it.in === "path"),
+        $ref: this.loader.addVirtualType(
+          operationId,
+          upperFirst(`${operationId}ParamSchema`),
+          this.reduceParametersToOpenApiSchema(pathParameters),
+        ),
+      },
+      query: {
+        name: `${operationId}QuerySchema`,
+        list: normalizedParameters.filter((it) => it.in === "query"),
+        $ref: this.loader.addVirtualType(
+          operationId,
+          upperFirst(`${operationId}QuerySchema`),
+          this.reduceParametersToOpenApiSchema(queryParameters),
+        ),
+      },
+      header: {
+        name: `${operationId}RequestHeaderSchema`,
+        list: normalizedParameters.filter((it) => it.in === "header"),
+        $ref: this.loader.addVirtualType(
+          operationId,
+          upperFirst(`${operationId}RequestHeaderSchema`),
+          this.reduceParametersToOpenApiSchema(headerParameters),
+        ),
+      },
+    }
+  }
+
+  private reduceParametersToOpenApiSchema(
+    parameters: Parameter[],
+  ): SchemaObject {
+    const properties: Record<string, Schema | Reference> = {}
+    const required: string[] = []
+
+    for (const parameter of parameters) {
+      properties[parameter.name] = parameter.schema
+
+      if (parameter.required) {
+        required.push(parameter.name)
+      }
+    }
+
+    return {
+      isIRModel: false,
+      type: "object",
+      properties,
+      required,
+      additionalProperties: false,
+      nullable: false,
+    }
   }
 
   private normalizeOperationId(
@@ -374,28 +444,28 @@ export class Input {
 
     return Object.fromEntries(
       filtered.map(([contentType, mediaType]) => {
-          return [
-            contentType,
-            {
-              schema: this.normalizeMediaTypeSchema(
-                operationId,
-                contentType,
-                mediaType.schema,
-                suffix,
-                hasMultipleMediaTypes,
-              ),
-              encoding: mediaType.encoding,
-            },
-          ]
-        }),
+        return [
+          contentType,
+          {
+            schema: this.normalizeMediaTypeSchema(
+              operationId,
+              contentType,
+              mediaType.schema,
+              suffix,
+              hasMultipleMediaTypes,
+            ),
+            encoding: mediaType.encoding,
+          },
+        ]
+      }),
     )
   }
 
   private normalizeMediaTypeSchema(
     operationId: string,
     mediaType: string,
     schema: Schema | Reference,
-    suffix: string,
+    suffix: "RequestBody" | `${string}Response`,
     hasMultipleMediaTypes: boolean,
   ): MaybeIRModel {
     const syntheticName = `${upperFirst(operationId)}${
@@ -405,15 +475,16 @@ export class Input {
     const result = this.schemaNormalizer.normalize(schema)
 
     const shouldCreateVirtualType =
-      this.config.extractInlineSchemas &&
+      (this.config.extractInlineSchemas || suffix === "RequestBody") &&
       !isRef(result) &&
+      !isRef(schema) &&
       (result.type === "object" ||
         (result.type === "array" &&
           !isRef(result.items) &&
           result.items.type === "object"))
 
     return shouldCreateVirtualType
-      ? this.loader.addVirtualType(operationId, syntheticName, result)
+      ? this.loader.addVirtualType(operationId, syntheticName, schema)
       : result
   }
 }
@@ -461,6 +532,17 @@ export class ParameterNormalizer {
           throwUnsupportedStyle(style)
         }
 
+        // todo: add if dereferenced(base.schema).type === "array
+        /*
+
+        "x-internal-preprocess": {
+            deserialize: {
+              fn: "(it: unknown) => Array.isArray(it) || it === undefined ? it : [it]",
+            },
+          },
+
+         */
+
         return {
           ...base,
           in: "query",
@@ -571,25 +653,30 @@ export class SchemaNormalizer {
       return schemaObject satisfies IRRef
     }
 
+    if (Reflect.get(schemaObject, "isIRModel")) {
+      throw new Error("double normalization!")
+    }
+
     // TODO: HACK: translates a type array into a a oneOf - unsure if this makes sense,
     //             or is the cleanest way to do it. I'm fairly sure this will work fine
     //             for most things though.
     if (Array.isArray(schemaObject.type)) {
       const nullable = Boolean(schemaObject.type.find((it) => it === "null"))
       return self.normalize({
+        isIRModel: false,
+        type: "object",
         oneOf: schemaObject.type
           .filter((it) => it !== "null")
-          .map((it) =>
-            self.normalize({
-              ...schemaObject,
-              type: it,
-              nullable,
-            }),
-          ),
+          .map((it) => ({
+            ...schemaObject,
+            type: it,
+            nullable,
+          })),
       })
     }
 
     const base: IRModelBase = {
+      isIRModel: true,
       nullable: schemaObject.nullable || false,
       readOnly: schemaObject.readOnly || false,
       default: schemaObject.default,
@@ -795,10 +882,11 @@ export class SchemaNormalizer {
           type: "never",
         }
       }
-      default:
+      default: {
         throw new Error(
           `unsupported type '${schemaObject.type satisfies never}'`,
         )
+      }
     }
 
     function normalizeProperties(

packages/openapi-code-generator/src/core/openapi-types-normalized.ts

@@ -1,4 +1,4 @@
-import type {Style} from "./openapi-types"
+import type {Reference, Style} from "./openapi-types"
 import type {HttpMethod} from "./utils"
 
 export interface IRRef {
@@ -7,6 +7,7 @@ export interface IRRef {
 }
 
 export interface IRModelBase {
+  isIRModel: true
   // Note: meaningless for top level objects, maybe we can exclude these somehow in that case
   nullable: boolean /* false */
   readOnly: boolean /* false */
@@ -166,14 +167,29 @@ export type IRParameter =
   | IRParameterPath
   | IRParameterQuery
   | IRParameterHeader
-  | IRParameterCookie
   | IRParameterRequestBody
+  | IRParameterCookie
+
+/**
+ * name - variable name for generated code
+ * $ref - location of the schema encapsulating params into an object
+ * list - list of the parameters
+ */
+export interface IROperationParams {
+  all: IRParameter[]
+  path: {name: string; list: IRParameterPath[]; $ref: Reference}
+  query: {name: string; list: IRParameterQuery[]; $ref: Reference}
+  header: {name: string; list: IRParameterHeader[]; $ref: Reference}
+}
 
 export interface IROperation {
+  operationId: string
+
   route: string
   method: HttpMethod
-  parameters: IRParameter[]
-  operationId: string
+
+  params: IROperationParams
+
   tags: string[]
   requestBody: IRRequestBody | undefined
   responses: