Reject ambiguous decimal/string unions

Reject property ranges that mix xsd:string and xsd:decimal during
code generation, since both map to runtime strings and the generated
encoder cannot disambiguate them reliably.

Update the vocab-tools tests to cover the rejection path directly,
and document the restriction in the manual and changelog.

#640 (comment)

Co-Authored-By: OpenAI Codex <codex@openai.com>

Author: dahlia

CHANGES.md

@@ -150,7 +150,9 @@ To be released.
     with that range are now generated as `Decimal` in TypeScript, serialized
     as `xsd:decimal` JSON-LD literals, validated through
     `canParseDecimal()` when checking input data, and normalized through
-    `parseDecimal()` when decoded.  [[#617], [#640]]
+    `parseDecimal()` when decoded.  Code generation now also rejects property
+    ranges that mix `xsd:string` and `xsd:decimal`, since both map to runtime
+    strings and would make serialization ambiguous.  [[#617], [#640]]
 
  -  Added `typeless` field to the type YAML schema.  When set to `true`,
     the generated `toJsonLd()` method does not emit `@type` (or `type` in

docs/manual/vocab.md

@@ -551,6 +551,11 @@ decimal values such as prices and measurements.  `parseDecimal()` normalizes
 XML Schema whitespace before returning the branded value, so the runtime
 representation always uses the normalized lexical form.
 
+A property range must not combine `xsd:string` and `xsd:decimal`.  Both map to
+runtime strings, so the generated encoder cannot distinguish them reliably
+during JSON-LD serialization and Fedify rejects such schema definitions at code
+generation time.
+
 [`Temporal.Instant`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal/Instant
 [`Temporal.Duration`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal/Duration
 [`Uint8Array`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array

packages/vocab-tools/src/class.test.ts

@@ -1,8 +1,9 @@
-import { deepStrictEqual, match } from "node:assert";
+import { deepStrictEqual, match, rejects } from "node:assert";
 import { basename, dirname, extname, join } from "node:path";
 import { test } from "node:test";
 import metadata from "../deno.json" with { type: "json" };
 import { generateClasses, sortTopologically } from "./class.ts";
+import { getDataCheck } from "./type.ts";
 import { loadSchemaFiles, type TypeSchema } from "./schema.ts";
 
 test("sortTopologically()", () => {
@@ -80,9 +81,43 @@ test("generateClasses() imports Decimal helpers for xsd:decimal", async () => {
   match(entireCode, /parseDecimal\(v\["@value"\]\)/);
 });
 
-test("generateClasses() uses canParseDecimal() in xsd:decimal data checks", async () => {
-  const entireCode = await getDecimalUnionFixtureCode();
-  match(entireCode, /canParseDecimal\(v\["@value"\]\)/);
+test("getDataCheck() uses canParseDecimal() for xsd:decimal", () => {
+  const check = getDataCheck(
+    "http://www.w3.org/2001/XMLSchema#decimal",
+    {},
+    "v",
+  );
+  match(check, /canParseDecimal\(v\["@value"\]\)/);
+});
+
+test("generateClasses() rejects xsd:string and xsd:decimal unions", async () => {
+  await rejects(
+    Array.fromAsync(generateClasses({
+      "https://example.com/measure": {
+        name: "Measure",
+        uri: "https://example.com/measure",
+        compactName: "Measure",
+        entity: false,
+        description: "A measure.",
+        properties: [
+          {
+            singularName: "amount",
+            functional: true,
+            compactName: "amount",
+            uri: "https://example.com/amount",
+            description: "An exact decimal amount.",
+            range: [
+              "http://www.w3.org/2001/XMLSchema#decimal",
+              "http://www.w3.org/2001/XMLSchema#string",
+            ],
+          },
+        ],
+        defaultContext:
+          "https://example.com/context" as TypeSchema["defaultContext"],
+      },
+    })),
+    /cannot have both xsd:string and xsd:decimal in its range/,
+  );
 });
 
 if ("Deno" in globalThis) {
@@ -142,34 +177,6 @@ async function getDecimalFixtureCode() {
   return (await Array.fromAsync(generateClasses(types))).join("");
 }
 
-async function getDecimalUnionFixtureCode() {
-  const types: Record<string, TypeSchema> = {
-    "https://example.com/measure": {
-      name: "Measure",
-      uri: "https://example.com/measure",
-      compactName: "Measure",
-      entity: false,
-      description: "A measure.",
-      properties: [
-        {
-          singularName: "amount",
-          functional: true,
-          compactName: "amount",
-          uri: "https://example.com/amount",
-          description: "An exact decimal amount.",
-          range: [
-            "http://www.w3.org/2001/XMLSchema#decimal",
-            "http://www.w3.org/2001/XMLSchema#string",
-          ],
-        },
-      ],
-      defaultContext:
-        "https://example.com/context" as TypeSchema["defaultContext"],
-    },
-  };
-  return (await Array.fromAsync(generateClasses(types))).join("");
-}
-
 async function changeNodeSnapshotPath() {
   const { snapshot } = await import("node:test");
   snapshot.setResolveSnapshotPath(

packages/vocab-tools/src/class.ts

@@ -3,7 +3,7 @@ import { generateCloner, generateConstructor } from "./constructor.ts";
 import { generateFields } from "./field.ts";
 import { generateInspector, generateInspectorPostClass } from "./inspector.ts";
 import { generateProperties } from "./property.ts";
-import type { TypeSchema } from "./schema.ts";
+import { type TypeSchema, validateTypeSchemas } from "./schema.ts";
 import { emitOverride } from "./type.ts";
 
 /**
@@ -117,6 +117,7 @@ async function* generateClass(
 export async function* generateClasses(
   types: Record<string, TypeSchema>,
 ): AsyncIterable<string> {
+  validateTypeSchemas(types);
   const runtimeImports = [
     "canParseDecimal",
     "decodeMultibase",

packages/vocab-tools/src/schema.ts

@@ -240,6 +240,38 @@ export function hasSingularAccessor(property: PropertySchema): boolean {
     property.singularAccessor === true;
 }
 
+const XSD_STRING_URI = "http://www.w3.org/2001/XMLSchema#string";
+const XSD_DECIMAL_URI = "http://www.w3.org/2001/XMLSchema#decimal";
+
+/**
+ * Validates schema combinations that cannot be represented safely by the
+ * generated code.
+ *
+ * In particular, `xsd:string` and `xsd:decimal` cannot coexist in the same
+ * property range because both are represented as runtime strings, which makes
+ * JSON-LD serialization ambiguous and order-dependent.
+ *
+ * @param types The loaded type schemas to validate.
+ * @throws {TypeError} Thrown when an unsupported range combination is found.
+ */
+export function validateTypeSchemas(
+  types: Record<string, TypeSchema>,
+): void {
+  for (const type of Object.values(types)) {
+    for (const property of type.properties) {
+      const hasString = property.range.includes(XSD_STRING_URI);
+      const hasDecimal = property.range.includes(XSD_DECIMAL_URI);
+      if (hasString && hasDecimal) {
+        throw new TypeError(
+          `The property ${type.name}.${property.singularName} cannot have ` +
+            `both xsd:string and xsd:decimal in its range because the ` +
+            `generated encoder cannot disambiguate them at runtime.`,
+        );
+      }
+    }
+  }
+}
+
 /**
  * An error that occurred while loading a schema file.
  */