@fedify/vocab-tools 2.3.9-dev.2048 → 2.3.9

package/src/class.ts

@@ -222,6 +222,17 @@ export async function* generateClasses(
     isTemporalInstant,
 } from "@fedify/vocab-runtime/temporal";\n`;
   yield `
+function canDecodeIri(iri: string): boolean {
+  return URL.canParse(iri) || iri.startsWith("at://");
+}
+
+function decodeIri(iri: string): URL {
+  return !URL.canParse(iri) && iri.startsWith("at://")
+    ? new URL("at://" + encodeURIComponent(iri.substring(5)))
+    : new URL(iri);
+}
+`;
+  yield `
 function isValidLanguageTag(language: string): boolean {
   try {
     new Intl.Locale(language);

package/src/codec.ts

@@ -6,12 +6,14 @@ import {
   areAllScalarTypes,
   emitOverride,
   getAllProperties,
+  getDataCheck,
   getDecoder,
   getDecoders,
   getEncoders,
   getSubtypes,
   getTypeNames,
   isCompactableType,
+  skipsUnparsable,
 } from "./type.ts";
 
 function* generatePreprocessorBlock(
@@ -506,7 +508,13 @@ export async function* generateDecoder(
     yield `
       const decoded =
     `;
+    const lenient = property.range.length == 1 &&
+      skipsUnparsable(property.range[0]);
     if (property.range.length == 1) {
+      if (lenient) {
+        yield getDataCheck(property.range[0], types, "v");
+        yield " ? ";
+      }
       yield getDecoder(
         property.range[0],
         types,
@@ -514,6 +522,7 @@ export async function* generateDecoder(
         "options",
         propertyBaseUrl,
       );
+      if (lenient) yield " : undefined";
     } else {
       const decoders = getDecoders(
         property.range,

package/src/property.ts

@@ -302,14 +302,19 @@ async function* generateProperty(
             ${JSON.stringify(property.compactName)}];
           const doc = Array.isArray(prop) ? prop[0] : prop;
           if (doc != null && typeof doc === "object" && "@context" in doc) {
-      `;
-        yield `
-            v = await this.#${property.singularName}_fromJsonLd(doc, {
-              ...options,
-              baseUrl: ${cachedPropertyBaseUrl},
-            });
-      `;
-        yield `
+            try {
+              v = await this.#${property.singularName}_fromJsonLd(doc, {
+                ...options,
+                baseUrl: ${cachedPropertyBaseUrl},
+              });
+            } catch (error) {
+              if (!options.suppressError) throw error;
+              getLogger(["fedify", "vocab"]).debug(
+                "Failed to parse embedded value of {property}: {error}",
+                { property: ${JSON.stringify(property.uri)}, error },
+              );
+              return null;
+            }
           }
         }
         `;
@@ -408,14 +413,21 @@ async function* generateProperty(
               ${JSON.stringify(property.compactName)}];
             const obj = Array.isArray(prop) ? prop[i] : prop;
             if (obj != null && typeof obj === "object" && "@context" in obj) {
-      `;
-        yield `
-              v = await this.#${property.singularName}_fromJsonLd(obj, {
-                ...options,
-                baseUrl: ${cachedPropertyBaseUrl},
-              });
-      `;
-        yield `
+              try {
+                v = await this.#${property.singularName}_fromJsonLd(obj, {
+                  ...options,
+                  baseUrl: ${cachedPropertyBaseUrl},
+                });
+              } catch (error) {
+                if (!options.suppressError) throw error;
+                getLogger(["fedify", "vocab"]).debug(
+                  "Failed to parse embedded value of {property} at index {index}: {error}",
+                  { property: ${
+          JSON.stringify(property.uri)
+        }, index: i, error },
+                );
+                continue;
+              }
             }
           }
         `;

package/src/type.ts

@@ -17,6 +17,12 @@ interface ScalarType {
   compactEncoder?: (variable: string) => string;
   dataCheck(variable: string): string;
   decoder(variable: string, baseUrlVar: string): string;
+  /**
+   * Whether a value that fails `dataCheck()` should be skipped instead of
+   * being handed to `decoder()`.  Set this for types decoded from untrusted
+   * remote input, where one malformed value must not fail the whole object.
+   */
+  skipUnparsable?: boolean;
 }
 
 const scalarTypes: Record<string, ScalarType> = {
@@ -332,13 +338,16 @@ const scalarTypes: Record<string, ScalarType> = {
       return `${v}.href`;
     },
     dataCheck(v) {
-      return `typeof ${v} === "object" && "@value" in ${v}
-        && typeof ${v}["@value"] === "string"
-        && ${v}["@value"] !== "" && ${v}["@value"] !== "/"`;
+      return `typeof ${v} === "object" &&
+      ((typeof ${v}["@id"] === "string" && canDecodeIri(${v}["@id"])) ||
+       (typeof ${v}["@value"] === "string" && canDecodeIri(${v}["@value"])))`;
     },
     decoder(v) {
-      return `new URL(${v}["@value"])`;
+      return `decodeIri(
+        typeof ${v}["@id"] === "string" ? ${v}["@id"] : ${v}["@value"]
+      )`;
     },
+    skipUnparsable: true,
   },
   "fedify:publicKey": {
     name: "CryptoKey",
@@ -649,6 +658,10 @@ export function getDecoder(
   throw new Error(`Unknown type: ${typeUri}`);
 }
 
+export function skipsUnparsable(typeUri: string): boolean {
+  return scalarTypes[typeUri]?.skipUnparsable ?? false;
+}
+
 export function getDataCheck(
   typeUri: string,
   types: Record<string, TypeSchema>,