fix: fully unwrap union aliases in mapped keys to avoid generating incorrect additionalProperties

src/NodeParser/MappedTypeNodeParser.ts

@@ -16,7 +16,7 @@ import { ObjectProperty, ObjectType } from "../Type/ObjectType.js";
 import { StringType } from "../Type/StringType.js";
 import { SymbolType } from "../Type/SymbolType.js";
 import { UnionType } from "../Type/UnionType.js";
-import { derefAnnotatedType, derefType } from "../Utils/derefType.js";
+import { derefAnnotatedType, derefType, isDeepLiteralUnion } from "../Utils/derefType.js";
 import { getKey } from "../Utils/nodeKey.js";
 import { preserveAnnotation } from "../Utils/preserveAnnotation.js";
 import { removeUndefined } from "../Utils/removeUndefined.js";
@@ -158,6 +158,10 @@ export class MappedTypeNodeParser implements SubNodeParser {
         keyListType: UnionType,
         context: Context,
     ): BaseType | boolean {
+        if (isDeepLiteralUnion(keyListType)) {
+            return this.additionalProperties;
+        }
+
         const key = keyListType.getTypes().filter((type) => !(derefType(type) instanceof LiteralType))[0];
 
         if (key) {

src/Utils/derefType.ts

@@ -3,8 +3,10 @@ import { AnnotatedType } from "../Type/AnnotatedType.js";
 import type { BaseType } from "../Type/BaseType.js";
 import { DefinitionType } from "../Type/DefinitionType.js";
 import { HiddenType } from "../Type/HiddenType.js";
+import { LiteralType } from "../Type/LiteralType.js";
 import { NeverType } from "../Type/NeverType.js";
 import { ReferenceType } from "../Type/ReferenceType.js";
+import { UnionType } from "../Type/UnionType.js";
 
 /**
  * Dereference the type as far as possible.
@@ -38,6 +40,23 @@ export function isHiddenType(type: BaseType): boolean {
     return false;
 }
 
+/**
+ * Recursively checks whether the given type is a union composed entirely of literal types.
+ */
+export function isDeepLiteralUnion(type: BaseType): boolean {
+    const resolved = derefType(type);
+
+    if (resolved instanceof LiteralType) {
+        return true;
+    }
+
+    if (resolved instanceof UnionType) {
+        return resolved.getTypes().every((t) => isDeepLiteralUnion(t));
+    }
+
+    return false;
+}
+
 export function derefAliasedType(type: BaseType): BaseType {
     if (type instanceof AliasType) {
         return derefAliasedType(type.getType());

test/valid-data/type-mapped-pick-union-alias/main.ts

@@ -1,9 +1,19 @@
 interface SomeInterface {
-    foo: string;
-    bar: number;
+    a: number;
+    b: string;
+    c: boolean;
+    d: string[];
+    e: null;
 }
 
-type KeyFoo = "foo";
-type KeyBar = "bar";
+type A = "a";
+type B = "b";
+type C = "c";
+type D = "d";
+type E = "e";
 
-export type PickAliasedLiteralUnion = Pick<SomeInterface, KeyFoo | KeyBar>;
+type AB = A | B;
+type ABC = AB | C;
+type ABCD = ABC | D;
+
+export type PickAliasedLiteralUnion = Pick<SomeInterface, ABCD | E>;

test/valid-data/type-mapped-pick-union-alias/schema.json

@@ -5,16 +5,31 @@
     "PickAliasedLiteralUnion": {
       "additionalProperties": false,
       "properties": {
-        "bar": {
+        "a": {
           "type": "number"
         },
-        "foo": {
+        "b": {
           "type": "string"
+        },
+        "c": {
+          "type": "boolean"
+        },
+        "d": {
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "e": {
+          "type": "null"
         }
       },
       "required": [
-        "foo",
-        "bar"
+        "a",
+        "b",
+        "c",
+        "d",
+        "e"
       ],
       "type": "object"
     }

test/valid-data/type-mapped-union-union/schema.json

@@ -3,9 +3,7 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "definitions": {
     "MyType": {
-      "additionalProperties": {
-        "type": "string"
-      },
+      "additionalProperties": false,
       "properties": {
         "s1": {
           "type": "string"