Feat: Add support for pattern properties

.changeset/eleven-shoes-mate.md

@@ -0,0 +1,5 @@
+---
+"openapi-typescript": minor
+---
+
+Add support for patternProperties

packages/openapi-typescript/src/transform/schema-object.ts

@@ -443,6 +443,7 @@ function transformSchemaObjectCore(schemaObject: SchemaObject, options: Transfor
   if (
     ("properties" in schemaObject && schemaObject.properties && Object.keys(schemaObject.properties).length) ||
     ("additionalProperties" in schemaObject && schemaObject.additionalProperties) ||
+    ("patternProperties" in schemaObject && schemaObject.patternProperties) ||
     ("$defs" in schemaObject && schemaObject.$defs)
   ) {
     // properties
@@ -542,13 +543,35 @@ function transformSchemaObjectCore(schemaObject: SchemaObject, options: Transfor
       );
     }
 
-    // additionalProperties
-    if (schemaObject.additionalProperties || options.ctx.additionalProperties) {
+    // additionalProperties / patternProperties
+    if (schemaObject.additionalProperties || options.ctx.additionalProperties || schemaObject.patternProperties) {
       const hasExplicitAdditionalProperties =
         typeof schemaObject.additionalProperties === "object" && Object.keys(schemaObject.additionalProperties).length;
-      const addlType = hasExplicitAdditionalProperties
-        ? transformSchemaObject(schemaObject.additionalProperties as SchemaObject, options)
-        : UNKNOWN;
+      const hasImplicitAdditionalProperties =
+        schemaObject.additionalProperties === true ||
+        (typeof schemaObject.additionalProperties === "object" &&
+          Object.keys(schemaObject.additionalProperties).length === 0);
+      const hasExplicitPatternProperties =
+        typeof schemaObject.patternProperties === "object" && Object.keys(schemaObject.patternProperties).length;
+      const addlTypes = [];
+      if (hasExplicitAdditionalProperties) {
+        addlTypes.push(transformSchemaObject(schemaObject.additionalProperties as SchemaObject, options));
+      }
+      if (hasImplicitAdditionalProperties || (!schemaObject.additionalProperties && options.ctx.additionalProperties)) {
+        addlTypes.push(UNKNOWN);
+      }
+      if (hasExplicitPatternProperties) {
+        for (const [_, v] of getEntries(schemaObject.patternProperties ?? {}, options.ctx)) {
+          addlTypes.push(transformSchemaObject(v, options));
+        }
+      }
+
+      if (addlTypes.length === 0) {
+        return;
+      }
+
+      const addlType = tsUnion(addlTypes);
+
       return tsIntersection([
         ...(coreObjectType.length ? [ts.factory.createTypeLiteralNode(coreObjectType)] : []),
         ts.factory.createTypeLiteralNode([

packages/openapi-typescript/src/types.ts

@@ -502,6 +502,7 @@ export interface ObjectSubtype {
   type: "object" | ["object", "null"];
   properties?: { [name: string]: SchemaObject | ReferenceObject };
   additionalProperties?: boolean | Record<string, never> | SchemaObject | ReferenceObject;
+  patternProperties?: Record<string, SchemaObject | ReferenceObject>;
   required?: string[];
   allOf?: (SchemaObject | ReferenceObject)[];
   anyOf?: (SchemaObject | ReferenceObject)[];

packages/openapi-typescript/test/transform/schema-object/object.test.ts

@@ -99,6 +99,95 @@ describe("transformSchemaObject > object", () => {
         // options: DEFAULT_OPTIONS,
       },
     ],
+    [
+      "patternProperties > empty object",
+      {
+        given: { type: "object", patternProperties: {} },
+        want: "Record<string, never>",
+      },
+    ],
+    [
+      "patternProperties > empty object with options.additionalProperties=true",
+      {
+        given: { type: "object", patternProperties: {} },
+        want: `{
+    [key: string]: unknown;
+}`,
+        options: {
+          ...DEFAULT_OPTIONS,
+          ctx: { ...DEFAULT_CTX, additionalProperties: true },
+        },
+      },
+    ],
+    [
+      "patternProperties > basic",
+      {
+        given: { type: "object", patternProperties: { "^a": { type: "string" } } },
+        want: `{
+    [key: string]: string;
+}`,
+      },
+    ],
+    [
+      "patternProperties > enum",
+      {
+        given: { type: "object", patternProperties: { "^a": { type: "string", enum: ["a", "b", "c"] } } },
+        want: `{
+    [key: string]: "a" | "b" | "c";
+}`,
+      },
+    ],
+    [
+      "patternProperties > multiple patterns",
+      {
+        given: { type: "object", patternProperties: { "^a": { type: "string" }, "^b": { type: "number" } } },
+        want: `{
+    [key: string]: string | number;
+}`,
+      },
+    ],
+    [
+      "patternProperties > additional=true and patterns",
+      {
+        given: {
+          type: "object",
+          additionalProperties: true,
+          patternProperties: { "^a": { type: "string" } },
+        },
+        want: `{
+    [key: string]: unknown | string;
+}`,
+      },
+    ],
+    [
+      "patternProperties > additional and patterns",
+      {
+        given: {
+          type: "object",
+          additionalProperties: { type: "number" },
+          patternProperties: { "^a": { type: "string" } },
+        },
+        want: `{
+    [key: string]: number | string;
+}`,
+      },
+    ],
+    [
+      "patternProperties > patterns with options.additionalProperties=true",
+      {
+        given: {
+          type: "object",
+          patternProperties: { "^a": { type: "string" } },
+        },
+        want: `{
+    [key: string]: unknown | string;
+}`,
+        options: {
+          ...DEFAULT_OPTIONS,
+          ctx: { ...DEFAULT_CTX, additionalProperties: true },
+        },
+      },
+    ],
     [
       "nullable",
       {