Support patternProperties general case as a fallback

Signed-off-by: Juan Cruz Viotti <jv@jviotti.com>

Author: jviotti

README.markdown

@@ -32,7 +32,7 @@ to use a JSON Schema validator at runtime to enforce remaining constraints.
 | Applicator (2020-12) | `items` | Yes |
 | Applicator (2020-12) | `prefixItems` | Yes |
 | Applicator (2020-12) | `anyOf` | Yes |
-| Applicator (2020-12) | `patternProperties` | **PARTIAL** (Prefix patterns only) |
+| Applicator (2020-12) | `patternProperties` | **PARTIAL GIVEN LANGUAGE LIMITATIONS** |
 | Applicator (2020-12) | `propertyNames` | Ignored |
 | Applicator (2020-12) | `dependentSchemas` | Pending |
 | Applicator (2020-12) | `contains` | Ignored |

src/generator/typescript.cc

@@ -1,7 +1,8 @@
 #include <sourcemeta/codegen/generator.h>
 
-#include <iomanip> // std::hex, std::setfill, std::setw
-#include <sstream> // std::ostringstream
+#include <algorithm> // std::ranges::any_of
+#include <iomanip>   // std::hex, std::setfill, std::setw
+#include <sstream>   // std::ostringstream
 
 namespace {
 
@@ -137,7 +138,12 @@ auto TypeScript::operator()(const IRObject &entry) -> void {
   }
 
   for (const auto &pattern_property : entry.pattern) {
-    this->output << "  [key: `" << pattern_property.prefix << "${string}`]: "
+    if (!pattern_property.prefix.has_value()) {
+      continue;
+    }
+
+    this->output << "  [key: `" << pattern_property.prefix.value()
+                 << "${string}`]: "
                  << mangle(this->prefix, pattern_property.pointer,
                            pattern_property.symbol, this->cache);
 
@@ -146,11 +152,11 @@ auto TypeScript::operator()(const IRObject &entry) -> void {
     // is a sub-prefix of another (i.e. "x-data-" starts with "x-"),
     // intersect the types so the constraint is satisfied
     for (const auto &other : entry.pattern) {
-      if (&other == &pattern_property) {
+      if (&other == &pattern_property || !other.prefix.has_value()) {
         continue;
       }
 
-      if (pattern_property.prefix.starts_with(other.prefix)) {
+      if (pattern_property.prefix.value().starts_with(other.prefix.value())) {
         this->output << " & "
                      << mangle(this->prefix, other.pointer, other.symbol,
                                this->cache);
@@ -160,9 +166,14 @@ auto TypeScript::operator()(const IRObject &entry) -> void {
     this->output << ";\n";
   }
 
+  const auto has_non_prefix_pattern{
+      std::ranges::any_of(entry.pattern, [](const auto &pattern_property) {
+        return !pattern_property.prefix.has_value();
+      })};
+
   if (allows_any_additional) {
     this->output << "  [key: string]: unknown | undefined;\n";
-  } else if (has_typed_additional) {
+  } else if (has_typed_additional || has_non_prefix_pattern) {
     // TypeScript index signatures must be a supertype of all property value
     // types. We use a union of all member types plus the additional properties
     // type plus undefined (for optional properties).
@@ -186,11 +197,14 @@ auto TypeScript::operator()(const IRObject &entry) -> void {
                    << " |\n";
     }
 
-    const auto &additional_type{std::get<IRType>(entry.additional)};
-    this->output << "    "
-                 << mangle(this->prefix, additional_type.pointer,
-                           additional_type.symbol, this->cache)
-                 << " |\n";
+    if (has_typed_additional) {
+      const auto &additional_type{std::get<IRType>(entry.additional)};
+      this->output << "    "
+                   << mangle(this->prefix, additional_type.pointer,
+                             additional_type.symbol, this->cache)
+                   << " |\n";
+    }
+
     this->output << "    undefined;\n";
   }
 

src/ir/include/sourcemeta/codegen/ir.h

@@ -64,7 +64,7 @@ struct IRObjectValue : IRType {
 
 /// @ingroup ir
 struct IRObjectPatternProperty : IRType {
-  std::string prefix;
+  std::optional<std::string> prefix;
 };
 
 /// @ingroup ir

src/ir/ir_default_compiler.h

@@ -146,19 +146,18 @@ auto handle_object(const sourcemeta::core::JSON &schema,
           frame.traverse(sourcemeta::core::to_weak_pointer(pattern_pointer))};
       assert(pattern_location.has_value());
 
+      std::optional<std::string> prefix{std::nullopt};
       const auto regex{sourcemeta::core::to_regex(entry.first)};
-      if (!regex.has_value() ||
-          !std::holds_alternative<sourcemeta::core::RegexTypePrefix>(
+      if (regex.has_value() &&
+          std::holds_alternative<sourcemeta::core::RegexTypePrefix>(
               regex.value())) {
-        throw UnsupportedKeywordValueError(
-            schema, location.pointer, "patternProperties",
-            "Only prefix patterns are supported");
+        prefix = std::get<sourcemeta::core::RegexTypePrefix>(regex.value());
       }
 
       pattern.push_back(IRObjectPatternProperty{
           {.pointer = std::move(pattern_pointer),
            .symbol = symbol(frame, pattern_location.value().get())},
-          std::get<sourcemeta::core::RegexTypePrefix>(regex.value())});
+          std::move(prefix)});
     }
   }
 

test/e2e/typescript/2020-12/pattern_properties_full_hybrid/expected.d.ts

@@ -0,0 +1,25 @@
+export type HybridName = string;
+
+export type HybridAge = number;
+
+export type HybridX = string;
+
+export type Hybrid_09_id = number;
+
+export type HybridAdditionalProperties = boolean;
+
+export interface Hybrid {
+  "name": HybridName;
+  "age"?: HybridAge;
+  [key: `x-${string}`]: HybridX;
+  [key: string]:
+    // As a notable limitation, TypeScript requires index signatures
+    // to also include the types of all of its properties, so we must
+    // match a superset of what JSON Schema allows
+    HybridName |
+    HybridAge |
+    HybridX |
+    Hybrid_09_id |
+    HybridAdditionalProperties |
+    undefined;
+}

test/e2e/typescript/2020-12/pattern_properties_full_hybrid/options.json

@@ -0,0 +1,3 @@
+{
+  "defaultPrefix": "Hybrid"
+}

test/e2e/typescript/2020-12/pattern_properties_full_hybrid/schema.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "name": { "type": "string" },
+    "age": { "type": "integer" }
+  },
+  "required": [ "name" ],
+  "patternProperties": {
+    "^x-": { "type": "string" },
+    "[0-9]+_id": { "type": "integer" }
+  },
+  "additionalProperties": { "type": "boolean" }
+}

test/e2e/typescript/2020-12/pattern_properties_full_hybrid/test.ts

@@ -0,0 +1,47 @@
+import { Hybrid } from "./expected";
+
+// All features together
+const test1: Hybrid = {
+  name: "hello",
+  age: 30,
+  "x-custom": "extension",
+  "123_id": 42,
+  flag: true
+};
+
+// Required name only
+const test2: Hybrid = {
+  name: "hello"
+};
+
+// Missing required name
+// @ts-expect-error
+const test3: Hybrid = {
+  age: 30
+};
+
+// Prefix pattern enforced: x- must be string, not number
+const test4: Hybrid = {
+  name: "hello",
+  // @ts-expect-error
+  "x-custom": 42
+};
+
+// Additional property must be in the union (no arrays)
+const test5: Hybrid = {
+  name: "hello",
+  // @ts-expect-error
+  extra: [ 1, 2, 3 ]
+};
+
+// Additional property with boolean works (additionalProperties type)
+const test6: Hybrid = {
+  name: "hello",
+  flag: true
+};
+
+// Additional property with number works (in union via member/pattern types)
+const test7: Hybrid = {
+  name: "hello",
+  extra: 42
+};

test/e2e/typescript/2020-12/pattern_properties_mixed_prefix_and_fallback/expected.d.ts

@@ -0,0 +1,8 @@
+export type MixedFallbackX = string;
+
+export type MixedFallback_09 = number;
+
+export interface MixedFallback {
+  [key: `x-${string}`]: MixedFallbackX;
+  [key: string]: unknown | undefined;
+}

test/e2e/typescript/2020-12/pattern_properties_mixed_prefix_and_fallback/options.json

@@ -0,0 +1 @@
+{ "defaultPrefix": "MixedFallback" }