feat: implement OpenAPI 3.1 patternProperties feature

Author: carson2222

packages/openapi-ts/src/ir/types.d.ts

@@ -174,10 +174,16 @@ interface IRSchemaObject
    * @default 'or'
    */
   logicalOperator?: 'and' | 'or';
+  /**
+   * When type is `object`, `patternProperties` can be used to define a schema
+   * for properties that match a specific regex pattern.
+   */
+  patternProperties?: Record<string, IRSchemaObject>;
   /**
    * When type is `object`, `properties` will contain a map of its properties.
    */
   properties?: Record<string, IRSchemaObject>;
+
   /**
    * The names of `properties` can be validated against a schema, irrespective
    * of their values. This can be useful if you don't want to enforce specific

packages/openapi-ts/src/openApi/3.1.x/parser/schema.ts

@@ -295,7 +295,9 @@ const parseObject = ({
     const isEmptyObjectInAllOf =
       state.inAllOf &&
       schema.additionalProperties === false &&
-      (!schema.properties || Object.keys(schema.properties).length === 0);
+      (!schema.properties || Object.keys(schema.properties).length === 0) &&
+      (!schema.patternProperties ||
+        Object.keys(schema.patternProperties).length === 0);
 
     if (!isEmptyObjectInAllOf) {
       irSchema.additionalProperties = {
@@ -311,6 +313,24 @@ const parseObject = ({
     irSchema.additionalProperties = irAdditionalPropertiesSchema;
   }
 
+  if (schema.patternProperties) {
+    const patternProperties: Record<string, IR.SchemaObject> = {};
+
+    for (const pattern in schema.patternProperties) {
+      const patternSchema = schema.patternProperties[pattern]!;
+      const irPatternSchema = schemaToIrSchema({
+        context,
+        schema: patternSchema,
+        state,
+      });
+      patternProperties[pattern] = irPatternSchema;
+    }
+
+    if (Object.keys(patternProperties).length) {
+      irSchema.patternProperties = patternProperties;
+    }
+  }
+
   if (schema.propertyNames) {
     irSchema.propertyNames = schemaToIrSchema({
       context,
@@ -781,6 +801,16 @@ const parseOneOf = ({
   return irSchema;
 };
 
+const parsePatternProperties = ({
+  context,
+  schema,
+  state,
+}: {
+  context: IR.Context;
+  schema: SchemaWithRequired<SchemaObject, 'patternProperties'>;
+  state: SchemaState;
+}): IR.SchemaObject => parseObject({ context, schema, state });
+
 const parseRef = ({
   context,
   schema,
@@ -1064,6 +1094,14 @@ export const schemaToIrSchema = ({
     });
   }
 
+  if (schema.patternProperties) {
+    return parsePatternProperties({
+      context,
+      schema: schema as SchemaWithRequired<SchemaObject, 'patternProperties'>,
+      state,
+    });
+  }
+
   // infer object based on the presence of properties
   if (schema.type || schema.properties) {
     return parseType({

packages/openapi-ts/src/plugins/@hey-api/typescript/plugin.ts

@@ -246,14 +246,41 @@ const objectTypeToIdentifier = ({
     }
   }
 
-  if (
-    schema.additionalProperties &&
-    (schema.additionalProperties.type !== 'never' || !indexPropertyItems.length)
-  ) {
-    if (schema.additionalProperties.type === 'never') {
-      indexPropertyItems = [schema.additionalProperties];
-    } else {
-      indexPropertyItems.unshift(schema.additionalProperties);
+  // include pattern value schemas into the index union
+  if (schema.patternProperties) {
+    for (const pattern in schema.patternProperties) {
+      const ir = schema.patternProperties[pattern]!;
+      indexPropertyItems.unshift(ir);
+    }
+  }
+
+  const hasPatterns =
+    !!schema.patternProperties &&
+    Object.keys(schema.patternProperties).length > 0;
+
+  const addPropsRaw = schema.additionalProperties;
+  const addPropsObj =
+    addPropsRaw !== false && addPropsRaw
+      ? (addPropsRaw as IR.SchemaObject)
+      : undefined;
+  const shouldCreateIndex =
+    hasPatterns ||
+    (!!addPropsObj &&
+      (addPropsObj.type !== 'never' || !indexPropertyItems.length));
+
+  if (shouldCreateIndex) {
+    // only inject additionalProperties when it’s not "never"
+    const addProps = addPropsObj;
+    if (addProps && addProps.type !== 'never') {
+      indexPropertyItems.unshift(addProps);
+    } else if (
+      !hasPatterns &&
+      !indexPropertyItems.length &&
+      addProps &&
+      addProps.type === 'never'
+    ) {
+      // keep "never" only when there are NO patterns and NO explicit properties
+      indexPropertyItems = [addProps];
     }
 
     if (hasOptionalProperties) {
@@ -265,18 +292,20 @@ const objectTypeToIdentifier = ({
     indexProperty = {
       isRequired: !schema.propertyNames,
       name: 'key',
-      type: schemaToType({
-        onRef,
-        plugin,
-        schema:
-          indexPropertyItems.length === 1
-            ? indexPropertyItems[0]!
-            : {
-                items: indexPropertyItems,
-                logicalOperator: 'or',
-              },
-        state,
-      }),
+      type:
+        indexPropertyItems.length === 1
+          ? schemaToType({
+              onRef,
+              plugin,
+              schema: indexPropertyItems[0]!,
+              state,
+            })
+          : schemaToType({
+              onRef,
+              plugin,
+              schema: { items: indexPropertyItems, logicalOperator: 'or' },
+              state,
+            }),
     };
 
     if (schema.propertyNames?.$ref) {
@@ -291,6 +320,8 @@ const objectTypeToIdentifier = ({
     }
   }
 
+  // removed duplicate legacy block
+
   return tsc.typeInterfaceNode({
     indexKey,
     indexProperty,