@openapi-qraft/plugin 1.13.1 → 1.14.0-beta.2

package/src/lib/predefineSchemaParameters.ts

@@ -4,14 +4,16 @@ import {
   PathItemObject,
   ReferenceObject,
 } from 'openapi-typescript/src/types.js';
+import { createServicePathMatch } from './createServicePathMatch.js';
 import {
-  createServicePathMatch,
-  parsePathGlobs,
-} from './createServicePathMatch.js';
+  OperationGlobMethods,
+  parseOperationGlobs,
+} from './parseOperationGlobs.js';
+import { splitCommaSeparatedGlobs } from './splitCommaSeparatedGlobs.js';
 
 export function predefineSchemaParameters(
   schema: OpenAPI3,
-  predefinedParametersGlobMap: PredefinedParametersGlobMap
+  predefinedParametersGlobs: PredefinedParametersGlob[]
 ): OpenAPI3 {
   const predefinedSchemaPaths: typeof schema.paths = {};
 
@@ -31,9 +33,7 @@ export function predefineSchemaParameters(
       const operation = service[method];
       assertIsOperationObject(operation);
 
-      for (const predefinedParametersGlob of Object.values(
-        predefinedParametersGlobMap
-      )) {
+      for (const predefinedParametersGlob of predefinedParametersGlobs) {
         if (!predefinedParametersGlob.paths.includes(path)) {
           continue;
         }
@@ -82,11 +82,6 @@ export function predefineSchemaParameters(
   };
 }
 
-type PredefinedParametersOptionMap = Record<
-  string,
-  Pick<ParameterObject, 'in' | 'name'>[]
->;
-
 /**
  * Parses the given configuration string into a structured format.
  *
@@ -100,80 +95,90 @@ type PredefinedParametersOptionMap = Record<
  */
 function parseOperationPredefinedParametersOption(
   ...optionItems: string[]
-): PredefinedParametersOptionMap {
-  const globParametersMap: PredefinedParametersOptionMap = {};
+): ParsedPredefinedParametersOption[] {
+  const globParametersMap = new Map<string, ParsedPredefinedParametersOption>();
 
   for (const optionItem of optionItems) {
-    const [pathGlob, options] = optionItem.split(':').map((s) => s.trim());
+    const operationGlobsRaw = optionItem.slice(
+      0,
+      Math.max(0, optionItem.indexOf(':')) || optionItem.length // the second part after the `:` is optional for the predefined parameters option
+    );
+    const parameterGlobs = optionItem.slice(operationGlobsRaw.length + 1);
+
     const parameters: Record<'header' | 'query' | 'cookie', string[]> = {
       header: [],
       query: [],
       cookie: [],
     };
 
-    if (options) {
-      options
-        .split(',')
-        .map((option) => option.trim())
-        .filter(Boolean)
-        .forEach((option) => {
-          const [type, key] = option.split('.').map((s) => s.trim());
-
-          if (type !== 'header' && type !== 'query' && type !== 'cookie')
-            throw new Error(
-              `Invalid option type: ${type} in ${option}. Must be one of 'header', 'query', or 'cookie'`
-            );
+    if (parameterGlobs) {
+      splitCommaSeparatedGlobs(parameterGlobs).forEach((option) => {
+        const [type, key] = option.split('.').map((s) => s.trim());
 
-          if (!parameters[type].includes(key)) parameters[type].push(key);
-        });
+        if (type !== 'header' && type !== 'query' && type !== 'cookie')
+          throw new Error(
+            `Invalid option type: ${type} in ${option}. Must be one of 'header', 'query', or 'cookie'`
+          );
+
+        if (!parameters[type].includes(key)) parameters[type].push(key);
+      });
     }
 
-    if (pathGlob in globParametersMap) {
-      throw new Error(`Duplicate path: ${pathGlob} in config string.`);
+    const { pathGlobs, methods: methodList } =
+      parseOperationGlobs(operationGlobsRaw);
+
+    const methods = methodList ? methodList.join(',') : '';
+
+    const globKey = `${methods}${pathGlobs}`;
+
+    if (globParametersMap.has(globKey)) {
+      throw new Error(
+        `Duplicate path: ${methods ? methods + ' ' : ''}${pathGlobs} in config string.`
+      );
     }
 
-    globParametersMap[pathGlob] = Object.entries(parameters).flatMap(
-      ([inLocation, names]) =>
+    globParametersMap.set(globKey, {
+      parameters: Object.entries(parameters).flatMap(([inLocation, names]) =>
         names.map((name) => ({ in: inLocation as ParameterObject['in'], name }))
-    );
+      ),
+      methods: methodList,
+      pathGlobs,
+    });
   }
 
-  return globParametersMap;
+  return Array.from(globParametersMap.values());
 }
 
-type PredefinedParametersGlobMap = {
-  [glob: string]: {
-    paths: string[];
-    parameters: ParameterObject[];
-    errors: string[];
-  };
-};
-
-export function createPredefinedParametersGlobMap(
+export function createPredefinedParametersGlobs(
   schema: OpenAPI3,
-  predefinedParameters: PredefinedParametersOptionMap
-): PredefinedParametersGlobMap {
-  const predefinedParametersGlobMap: PredefinedParametersGlobMap = {};
-
-  const servicePredefinedParametersList = Object.entries(
-    predefinedParameters
-  ).map(([pathGlobs, parameters]) => {
-    const globs = parsePathGlobs(pathGlobs);
-    if (!globs)
-      throw new Error(
-        `Invalid path glob: ${pathGlobs}. Must be a comma-separated list of globs.`
-      );
+  predefinedParameters: ParsedPredefinedParametersOption[]
+): Array<PredefinedParametersGlob> {
+  const predefinedParametersGlobMap = new Map<
+    string,
+    PredefinedParametersGlob
+  >();
+
+  const servicePredefinedParametersList = predefinedParameters.map(
+    ({ pathGlobs, parameters, methods }) => {
+      const globs = splitCommaSeparatedGlobs(pathGlobs);
+      if (!globs.length)
+        throw new Error(
+          `Invalid path glob: ${pathGlobs}. Must be a comma-separated list of globs.`
+        );
 
-    return {
-      pathGlobs,
-      parameters,
-      isPathMatch: createServicePathMatch(globs),
-    };
-  });
+      return {
+        methods,
+        pathGlobs,
+        parameters,
+        isPathMatch: createServicePathMatch(globs),
+      };
+    }
+  );
 
   for (const path in schema.paths) {
     if (!Object.prototype.hasOwnProperty.call(schema.paths, path)) continue;
     for (const {
+      methods,
       pathGlobs,
       parameters: parametersToPredefine,
       isPathMatch,
@@ -187,6 +192,11 @@ export function createPredefinedParametersGlobMap(
       for (const _method in service) {
         const method = _method as keyof typeof service;
         if (!Object.prototype.hasOwnProperty.call(service, method)) continue;
+        if (
+          methods !== undefined &&
+          !methods.includes(method as OperationGlobMethods)
+        )
+          continue;
 
         const operation = service[method];
         assertIsOperationObject(operation);
@@ -194,14 +204,18 @@ export function createPredefinedParametersGlobMap(
         const operationParameters = operation.parameters ?? [];
         assertIsParameterObjects(operationParameters);
 
-        if (!(pathGlobs in predefinedParametersGlobMap))
-          predefinedParametersGlobMap[pathGlobs] = {
+        if (!predefinedParametersGlobMap.has(pathGlobs))
+          predefinedParametersGlobMap.set(pathGlobs, {
+            methods: [],
             paths: [],
             parameters: [],
             errors: [],
-          };
+          });
 
-        const predefinedPathGlob = predefinedParametersGlobMap[pathGlobs];
+        const predefinedPathGlob = predefinedParametersGlobMap.get(pathGlobs);
+
+        if (!predefinedPathGlob)
+          throw new Error('predefinedPathGlob not found');
 
         for (const parameterSchemaToPredefine of parametersToPredefine) {
           const parameterToPredefine = findPredefinedOperationParameter(
@@ -209,6 +223,15 @@ export function createPredefinedParametersGlobMap(
             operationParameters
           );
 
+          if (
+            !predefinedPathGlob.methods?.includes(
+              method as OperationGlobMethods
+            )
+          ) {
+            if (!predefinedPathGlob.methods) predefinedPathGlob.methods = [];
+            predefinedPathGlob.methods.push(method as OperationGlobMethods);
+          }
+
           if (!parameterToPredefine) {
             predefinedPathGlob.errors.push(
               `Missing predefined parameter '${parameterSchemaToPredefine.in}' '${parameterSchemaToPredefine.name}' in '${method} ${path}' in '${pathGlobs}'`
@@ -246,17 +269,18 @@ export function createPredefinedParametersGlobMap(
     }
   }
 
-  Object.entries(predefinedParameters).forEach(([pathGlobs]) => {
-    if (!predefinedParametersGlobMap[pathGlobs]) {
-      predefinedParametersGlobMap[pathGlobs] = {
+  predefinedParameters.forEach(({ pathGlobs, methods }) => {
+    if (!predefinedParametersGlobMap.has(pathGlobs)) {
+      predefinedParametersGlobMap.set(pathGlobs, {
+        methods,
         paths: [],
         parameters: [],
         errors: [`No matching paths found for '${pathGlobs}'`],
-      };
+      });
     }
   });
 
-  return predefinedParametersGlobMap;
+  return Array.from(predefinedParametersGlobMap.values());
 }
 
 function findPredefinedOperationParameter(
@@ -307,4 +331,17 @@ export function assertIsParameterObjects(
   });
 }
 
+type ParsedPredefinedParametersOption = {
+  methods: OperationGlobMethods[] | undefined;
+  pathGlobs: string;
+  parameters: Pick<ParameterObject, 'in' | 'name'>[];
+};
+
+type PredefinedParametersGlob = {
+  methods: OperationGlobMethods[] | undefined;
+  paths: string[];
+  parameters: Pick<ParameterObject, 'in' | 'name'>[];
+  errors: string[];
+};
+
 export { parseOperationPredefinedParametersOption };

package/src/lib/processOperationNameModifierOption.ts

@@ -0,0 +1,205 @@
+import { createServicePathMatch } from './createServicePathMatch.js';
+import { Service } from './open-api/getServices.js';
+import {
+  OperationGlobMethods,
+  parseOperationGlobs,
+} from './parseOperationGlobs.js';
+import { splitCommaSeparatedGlobs } from './splitCommaSeparatedGlobs.js';
+
+export const processOperationNameModifierOption = (
+  modifiers: OperationNameModifier[],
+  services: Service[]
+) => {
+  if (!modifiers.length)
+    return {
+      errors: [],
+      services,
+    };
+
+  const operationNameModifiers = modifiers.map((modifier) => ({
+    ...modifier,
+    isPathMatch: createServicePathMatch(
+      splitCommaSeparatedGlobs(modifier.pathGlobs)
+    ),
+  }));
+
+  type ServiceName = string;
+  type ReplacedOperationNameMap = string;
+  type OriginalOperationName = string;
+
+  const serviceOperationReplacements = new Map<
+    ServiceName,
+    Map<
+      ReplacedOperationNameMap,
+      Map<OriginalOperationName, OperationNameModifier[]>
+    >
+  >();
+
+  const replacedOperationNamesServices = services.map((service) => {
+    serviceOperationReplacements.set(service.name, new Map());
+
+    return {
+      ...service,
+      operations: service.operations.map((operation) => {
+        const operationReplacements = serviceOperationReplacements.get(
+          service.name
+        );
+
+        if (!operationReplacements)
+          throw new Error('operationReplacements not found');
+
+        const operationModifiers = operationNameModifiers.filter(
+          (modifier) =>
+            modifier.isPathMatch(operation.path) &&
+            (modifier.methods === undefined ||
+              modifier.methods.includes(operation.method)) &&
+            normalizeOperationNameModifierRegex(
+              modifier.operationNameModifierRegex
+            ).test(operation.name)
+        );
+
+        const replacedOperationName = operationModifiers.reduce<string>(
+          (operationName, modifier) =>
+            operationName.replace(
+              normalizeOperationNameModifierRegex(
+                modifier.operationNameModifierRegex
+              ),
+              modifier.operationNameModifierReplace
+            ),
+          operation.name
+        );
+
+        if (replacedOperationName !== operation.name) {
+          if (!operationReplacements.has(replacedOperationName))
+            operationReplacements.set(replacedOperationName, new Map());
+          operationReplacements.get(replacedOperationName)?.set(
+            operation.name,
+            operationModifiers.map(
+              ({ isPathMatch: _, ...operationModifiersRest }) =>
+                operationModifiersRest
+            )
+          );
+        }
+
+        return {
+          ...operation,
+          name: replacedOperationName,
+        };
+      }),
+    };
+  });
+
+  const errors = Array.from(serviceOperationReplacements).flatMap(
+    ([serviceName, modifiedOperations]) =>
+      Array.from(modifiedOperations).flatMap(
+        ([replacedOperationName, operationModifierMap]) => {
+          if (operationModifierMap.size > 1) {
+            return Array.from(operationModifierMap).map(
+              ([originalOperationName, modifiers]) => ({
+                serviceName,
+                replacedOperationName,
+                originalOperationName,
+                modifiers,
+              })
+            );
+          }
+
+          const [originalOperationName, modifiers] =
+            Array.from(operationModifierMap).at(0) ?? [];
+
+          if (modifiers && modifiers.length > 1) {
+            return [
+              {
+                serviceName,
+                replacedOperationName,
+                originalOperationName,
+                modifiers,
+              },
+            ];
+          }
+
+          return [];
+        }
+      )
+  );
+
+  return {
+    errors,
+    services: replacedOperationNamesServices,
+  };
+};
+
+function normalizeOperationNameModifierRegex(regex: string) {
+  return new RegExp(regex, 'g');
+}
+
+export type OperationNameModifier = {
+  methods: OperationGlobMethods[] | undefined;
+  /**
+   * Glob pattern to match service paths, eg: `/foo,/bar/**`
+   */
+  pathGlobs: string;
+  /**
+   * Regular expression to match operation names
+   */
+  operationNameModifierRegex: string;
+  /**
+   * Replacement string for matched operation names
+   */
+  operationNameModifierReplace: string;
+};
+
+/**
+ * Parses the given options string into a structured format.
+ *
+ * @param optionItems - The configuration string to parse. Eg. `/foo,/bar/**:post[A-Z][A-Za-z]+sId[A-Z][A-Za-z]+ ==> createOne` or `post /** ==> createOne`
+ * @returns The parsed configuration.
+ *
+ * @example
+ * ```ts
+ * const parsedConfig = parseOperationNameModifier("/foo,/bar/**:/**:post[A-Z][A-Za-z]+sId[A-Z][A-Za-z]+ ==> createOne");
+ * ```
+ */
+export function parseOperationNameModifier(
+  ...optionItems: string[]
+): OperationNameModifier[] {
+  const globOperationNameModifierMap: Array<OperationNameModifier> = [];
+
+  for (const optionItem of optionItems) {
+    const operationGlobsRaw = optionItem.slice(
+      0,
+      Math.max(0, optionItem.indexOf(':'))
+    );
+
+    if (!operationGlobsRaw.length)
+      throw new Error(
+        `Invalid operation name modifier: ${optionItem}. Must be in the format of 'pathGlobs:operationNameModifierRegex ==> operationNameModifierReplace'`
+      );
+
+    const modifierPattern = optionItem.slice(operationGlobsRaw.length + 1);
+
+    const patternRegex = modifierPattern.slice(
+      0,
+      modifierPattern.indexOf('==>')
+    );
+    const patternReplace = modifierPattern.slice(
+      modifierPattern.indexOf('==>') + '==>'.length + 1
+    );
+
+    const { methods, pathGlobs } = parseOperationGlobs(operationGlobsRaw);
+
+    if (!splitCommaSeparatedGlobs(pathGlobs).length)
+      throw new Error(
+        `Invalid path glob: ${pathGlobs}. Must be a comma-separated list of globs.`
+      );
+
+    globOperationNameModifierMap.push({
+      methods,
+      pathGlobs,
+      operationNameModifierRegex: patternRegex.trim(),
+      operationNameModifierReplace: patternReplace.trim(),
+    });
+  }
+
+  return globOperationNameModifierMap;
+}

package/src/lib/splitCommaSeparatedGlobs.ts

@@ -0,0 +1,16 @@
+/**
+ * Normalize a comma-separated list of globs
+ * @param commaSeparatedGlobs - Example: `/foo ,    /bar/**, ,`
+ * @returns Example: `/foo,/bar/**`
+ */
+export function splitCommaSeparatedGlobs(
+  commaSeparatedGlobs: string | undefined
+): string[] {
+  if (commaSeparatedGlobs === undefined) return [];
+  if (typeof commaSeparatedGlobs !== 'string') throw new Error('Invalid input');
+
+  return commaSeparatedGlobs
+    .split(',')
+    .map((path) => path.trim())
+    .filter(Boolean);
+}

package/src/packageVersion.ts

@@ -1,2 +1,2 @@
 // This file was generated automatically
-export const packageVersion = '1.13.1';
+export const packageVersion = '1.14.0-beta.2';