fix: pathItem's parameters field support

src/internal/OpenApiTools/Walker/Operation.ts

@@ -8,6 +8,15 @@ export interface State {
   [operationId: string]: CodeGenerator.OpenApiOperation;
 }
 
+type UniqueParameterMap = Record<string, OpenApi.Parameter>;
+
+const uniqParameters = (rawParameters: OpenApi.Parameter[]): OpenApi.Parameter[] => {
+  const parameterMap = rawParameters.reduce<UniqueParameterMap>((all, parameter) => {
+    return { ...all, [`${parameter.in}:${parameter.name}`]: parameter };
+  }, {});
+  return Object.values(parameterMap);
+};
+
 export const create = (rootSchema: OpenApi.Document): State => {
   const paths = rootSchema.paths || {};
   const state: State = {};
@@ -20,13 +29,15 @@ export const create = (rootSchema: OpenApi.Document): State => {
       if (!operation.operationId) {
         return;
       }
+      const parameters = [...(pathItem.parameters || []), ...(operation.parameters || [])] as OpenApi.Parameter[];
+
       state[operation.operationId] = {
         httpMethod,
         requestUri,
         comment: [operation.summary, operation.description].filter(Boolean).join(EOL),
         deprecated: !!operation.deprecated,
         requestBody: operation.requestBody as OpenApi.RequestBody,
-        parameters: operation.parameters as OpenApi.Parameter[],
+        parameters: uniqParameters(parameters),
         responses: operation.responses as CodeGenerator.OpenApiResponses,
       };
     });

src/internal/OpenApiTools/Walker/Store.ts

@@ -16,7 +16,7 @@ class Store {
   private state: State.Type;
   private operator: Structure.OperatorType;
   private getChildByPaths: Structure.GetChildByPaths;
-  constructor(private factory: Factory.Type, private rootDocument: OpenApi.Document) {
+  constructor(private factory: Factory.Type, rootDocument: OpenApi.Document) {
     this.state = State.createDefaultState(rootDocument);
     const { operator, getChildByPaths } = Structure.create();
     this.operator = operator;

src/internal/OpenApiTools/components/Operation.ts

@@ -31,7 +31,6 @@ const generateComment = (operation: OpenApi.Operation): string => {
   return comments.join(EOL);
 };
 
-// 使わない可能性あり
 export const generateNamespace = (
   entryPoint: string,
   currentPoint: string,
@@ -40,6 +39,7 @@ export const generateNamespace = (
   parentPath: string,
   name: string,
   operation: OpenApi.Operation,
+  pathItemParameters: OpenApi.PathItem["parameters"],
   context: ToTypeNode.Context,
   converterContext: ConverterContext.Types,
 ): void => {
@@ -55,7 +55,9 @@ export const generateNamespace = (
     deprecated: operation.deprecated,
   });
 
-  if (operation.parameters) {
+  const parameters = [...pathItemParameters || [], ...operation.parameters || []];
+
+  if (parameters.length > 0) {
     const parameterName = "Parameter";
     store.addStatement(`${basePath}/Parameter`, {
       kind: "interface",
@@ -66,7 +68,7 @@ export const generateNamespace = (
         store,
         factory,
         parameterName,
-        operation.parameters,
+        parameters,
         context,
         converterContext,
       ),
@@ -136,6 +138,7 @@ export const generateStatements = (
   requestUri: string,
   httpMethod: string, // PUT POST PATCH
   operation: OpenApi.Operation,
+  pathItemParameters: OpenApi.PathItem["parameters"],
   context: ToTypeNode.Context,
   converterContext: ConverterContext.Types,
 ): ts.Statement[] => {
@@ -145,7 +148,8 @@ export const generateStatements = (
     throw new Error("not setting operationId\n" + JSON.stringify(operation));
   }
   store.updateOperationState(httpMethod, requestUri, operationId, {});
-  if (operation.parameters) {
+  const parameters = [...pathItemParameters || [], ...operation.parameters || []];
+  if (parameters.length > 0) {
     const parameterName = converterContext.generateParameterName(operationId);
     statements.push(
       Parameter.generateAliasInterface(
@@ -154,7 +158,7 @@ export const generateStatements = (
         store,
         factory,
         parameterName,
-        operation.parameters,
+        parameters,
         context,
         converterContext,
       ),

src/internal/OpenApiTools/components/Parameter.ts

@@ -36,32 +36,38 @@ export const generateTypeAlias = (
   });
 };
 
-export const generatePropertySignature = (
+export const generatePropertySignatureObject = (
   entryPoint: string,
   currentPoint: string,
   store: Walker.Store,
   factory: Factory.Type,
   parameter: OpenApi.Parameter | OpenApi.Reference,
   context: ToTypeNode.Context,
   converterContext: ConverterContext.Types,
-): ts.PropertySignature => {
+): { name: string; typeElement: ts.PropertySignature } => {
   if (Guard.isReference(parameter)) {
     const reference = Reference.generate<OpenApi.Parameter>(entryPoint, currentPoint, parameter);
     if (reference.type === "local") {
       context.setReferenceHandler(currentPoint, reference);
       const localRef = store.getParameter(reference.path);
-      return factory.PropertySignature.create({
-        name: converterContext.escapePropertySignatureName(localRef.name),
+      const name = converterContext.escapePropertySignatureName(localRef.name);
+      const typeElement = factory.PropertySignature.create({
+        name: name,
         optional: false,
         comment: localRef.description,
         type: factory.TypeReferenceNode.create({
           name: context.resolveReferencePath(currentPoint, reference.path).name,
         }),
       });
+      return {
+        name,
+        typeElement: typeElement,
+      };
     }
     const isPathProperty = reference.data.in === "path";
-    return factory.PropertySignature.create({
-      name: converterContext.escapePropertySignatureName(reference.data.name),
+    const name = converterContext.escapePropertySignatureName(reference.data.name);
+    const typeElement = factory.PropertySignature.create({
+      name: name,
       optional: isPathProperty ? false : !reference.data.required,
       comment: reference.data.description,
       type: ToTypeNode.convert(
@@ -73,14 +79,23 @@ export const generatePropertySignature = (
         converterContext,
       ),
     });
+    return {
+      name,
+      typeElement: typeElement,
+    };
   }
   const isPathProperty = parameter.in === "path";
-  return factory.PropertySignature.create({
-    name: converterContext.escapePropertySignatureName(parameter.name),
+  const name = converterContext.escapePropertySignatureName(parameter.name);
+  const typeElement = factory.PropertySignature.create({
+    name: name,
     optional: isPathProperty ? false : !parameter.required,
     type: ToTypeNode.convert(entryPoint, currentPoint, factory, parameter.schema || { type: "null" }, context, converterContext),
     comment: parameter.description,
   });
+  return {
+    name,
+    typeElement: typeElement,
+  };
 };
 
 export const generatePropertySignatures = (
@@ -92,9 +107,11 @@ export const generatePropertySignatures = (
   context: ToTypeNode.Context,
   converterContext: ConverterContext.Types,
 ): ts.PropertySignature[] => {
-  return parameters.map(parameter => {
-    return generatePropertySignature(entryPoint, currentPoint, store, factory, parameter, context, converterContext);
-  });
+  const typeElementMap = parameters.reduce<Record<string, ts.PropertySignature>>((all, parameter) => {
+    const { name, typeElement } = generatePropertySignatureObject(entryPoint, currentPoint, store, factory, parameter, context, converterContext);
+    return { ...all, [name]: typeElement };
+  }, {});
+  return Object.values(typeElementMap);
 };
 
 export const generateInterface = (
@@ -103,7 +120,7 @@ export const generateInterface = (
   store: Walker.Store,
   factory: Factory.Type,
   name: string,
-  parameters: [OpenApi.Parameter | OpenApi.Reference],
+  parameters: (OpenApi.Parameter | OpenApi.Reference)[],
   context: ToTypeNode.Context,
   converterContext: ConverterContext.Types,
 ): ts.InterfaceDeclaration => {

src/internal/OpenApiTools/components/PathItem.ts

@@ -29,28 +29,28 @@ export const generateNamespace = (
     comment: Servers.addComment([topComment, pathItem.description], pathItem.servers),
   });
   if (pathItem.get) {
-    Operation.generateNamespace(entryPoint, currentPoint, store, factory, basePath, "GET", pathItem.get, context, converterContext);
+    Operation.generateNamespace(entryPoint, currentPoint, store, factory, basePath, "GET", pathItem.get, pathItem.parameters, context, converterContext);
   }
   if (pathItem.put) {
-    Operation.generateNamespace(entryPoint, currentPoint, store, factory, basePath, "PUT", pathItem.put, context, converterContext);
+    Operation.generateNamespace(entryPoint, currentPoint, store, factory, basePath, "PUT", pathItem.put, pathItem.parameters,context, converterContext);
   }
   if (pathItem.post) {
-    Operation.generateNamespace(entryPoint, currentPoint, store, factory, basePath, "POST", pathItem.post, context, converterContext);
+    Operation.generateNamespace(entryPoint, currentPoint, store, factory, basePath, "POST", pathItem.post, pathItem.parameters, context, converterContext);
   }
   if (pathItem.delete) {
-    Operation.generateNamespace(entryPoint, currentPoint, store, factory, basePath, "DELETE", pathItem.delete, context, converterContext);
+    Operation.generateNamespace(entryPoint, currentPoint, store, factory, basePath, "DELETE", pathItem.delete, pathItem.parameters, context, converterContext);
   }
   if (pathItem.options) {
-    Operation.generateNamespace(entryPoint, currentPoint, store, factory, basePath, "OPTIONS", pathItem.options, context, converterContext);
+    Operation.generateNamespace(entryPoint, currentPoint, store, factory, basePath, "OPTIONS", pathItem.options, pathItem.parameters, context, converterContext);
   }
   if (pathItem.head) {
-    Operation.generateNamespace(entryPoint, currentPoint, store, factory, basePath, "HEAD", pathItem.head, context, converterContext);
+    Operation.generateNamespace(entryPoint, currentPoint, store, factory, basePath, "HEAD", pathItem.head, pathItem.parameters, context, converterContext);
   }
   if (pathItem.patch) {
-    Operation.generateNamespace(entryPoint, currentPoint, store, factory, basePath, "PATCH", pathItem.patch, context, converterContext);
+    Operation.generateNamespace(entryPoint, currentPoint, store, factory, basePath, "PATCH", pathItem.patch, pathItem.parameters, context, converterContext);
   }
   if (pathItem.trace) {
-    Operation.generateNamespace(entryPoint, currentPoint, store, factory, basePath, "TRACE", pathItem.trace, context, converterContext);
+    Operation.generateNamespace(entryPoint, currentPoint, store, factory, basePath, "TRACE", pathItem.trace, pathItem.parameters, context, converterContext);
   }
   if (pathItem.parameters) {
     Parameters.generateNamespaceWithList(entryPoint, currentPoint, store, factory, pathItem.parameters, context, converterContext);
@@ -70,22 +70,22 @@ export const generateStatements = (
   const statements: ts.Statement[][] = [];
   if (pathItem.get) {
     statements.push(
-      Operation.generateStatements(entryPoint, currentPoint, store, factory, requestUri, "GET", pathItem.get, context, converterContext),
+      Operation.generateStatements(entryPoint, currentPoint, store, factory, requestUri, "GET", pathItem.get, pathItem.parameters, context, converterContext),
     );
   }
   if (pathItem.put) {
     statements.push(
-      Operation.generateStatements(entryPoint, currentPoint, store, factory, requestUri, "PUT", pathItem.put, context, converterContext),
+      Operation.generateStatements(entryPoint, currentPoint, store, factory, requestUri, "PUT", pathItem.put, pathItem.parameters, context, converterContext),
     );
   }
   if (pathItem.post) {
     statements.push(
-      Operation.generateStatements(entryPoint, currentPoint, store, factory, requestUri, "POST", pathItem.post, context, converterContext),
+      Operation.generateStatements(entryPoint, currentPoint, store, factory, requestUri, "POST", pathItem.post, pathItem.parameters, context, converterContext),
     );
   }
   if (pathItem.delete) {
     statements.push(
-      Operation.generateStatements(entryPoint, currentPoint, store, factory, requestUri, "DELETE", pathItem.delete, context, converterContext),
+      Operation.generateStatements(entryPoint, currentPoint, store, factory, requestUri, "DELETE", pathItem.delete, pathItem.parameters, context, converterContext),
     );
   }
   if (pathItem.options) {
@@ -98,24 +98,25 @@ export const generateStatements = (
         requestUri,
         "OPTIONS",
         pathItem.options,
+        pathItem.parameters,
         context,
         converterContext,
       ),
     );
   }
   if (pathItem.head) {
     statements.push(
-      Operation.generateStatements(entryPoint, currentPoint, store, factory, requestUri, "HEAD", pathItem.head, context, converterContext),
+      Operation.generateStatements(entryPoint, currentPoint, store, factory, requestUri, "HEAD", pathItem.head, pathItem.parameters, context, converterContext),
     );
   }
   if (pathItem.patch) {
     statements.push(
-      Operation.generateStatements(entryPoint, currentPoint, store, factory, requestUri, "PATCH", pathItem.patch, context, converterContext),
+      Operation.generateStatements(entryPoint, currentPoint, store, factory, requestUri, "PATCH", pathItem.patch, pathItem.parameters, context, converterContext),
     );
   }
   if (pathItem.trace) {
     statements.push(
-      Operation.generateStatements(entryPoint, currentPoint, store, factory, requestUri, "TRACE", pathItem.trace, context, converterContext),
+      Operation.generateStatements(entryPoint, currentPoint, store, factory, requestUri, "TRACE", pathItem.trace, pathItem.parameters, context, converterContext),
     );
   }
   // if (pathItem.parameters) {

src/typedef/OpenApi.ts

@@ -246,7 +246,7 @@ export interface Operation {
   description?: string;
   externalDocs?: ExternalDocumentation;
   operationId?: string;
-  parameters?: [Parameter | Reference];
+  parameters?: (Parameter | Reference)[];
   requestBody?: RequestBody | Reference;
   responses?: Responses;
   callbacks?: Record<string, Callback | Reference>;