@fedify/vocab-tools 2.5.0-dev.2339 → 2.5.0-dev.2358

package/src/class.ts

@@ -12,6 +12,7 @@ import { emitOverride } from "./type.ts";
 
 const XSD_ANY_URI = "http://www.w3.org/2001/XMLSchema#anyURI";
 const FEDIFY_URL = "fedify:url";
+const FEDIFY_ABSOLUTE_IRI = "fedify:absoluteIri";
 const INTERNAL_RUNTIME_IMPORTS = [
   "compactJsonLdCache",
   "createScopedContextLoader",
@@ -255,7 +256,8 @@ function canContainIriValue(
   types: Record<string, TypeSchema>,
 ): boolean {
   return property.range.some((typeUri) =>
-    typeUri === XSD_ANY_URI || typeUri === FEDIFY_URL || types[typeUri]?.entity
+    typeUri === XSD_ANY_URI || typeUri === FEDIFY_URL ||
+    typeUri === FEDIFY_ABSOLUTE_IRI || types[typeUri]?.entity
   );
 }
 
@@ -334,7 +336,45 @@ function isValidLanguageTag(language: string): boolean {
   }
 }
 `;
-  // Contexts are activated by expanded property IRIs left after compaction.
+  if (
+    Object.values(types).some((type) =>
+      type.properties.some((property) =>
+        property.range.includes(FEDIFY_ABSOLUTE_IRI)
+      )
+    )
+  ) {
+    // An absolute IRI may arrive as an IRI node or, when the publisher's
+    // context does not coerce the term, as a string or IRI-typed literal.
+    // It is never resolved against a base IRI.
+    yield `
+function getAbsoluteIriValue(value: unknown): string | undefined {
+  if (value == null || typeof value !== "object") return undefined;
+  const node = value as Record<string, unknown>;
+  if (typeof node["@id"] === "string") {
+    return node["@id"].startsWith("_:") ? undefined : node["@id"];
+  }
+  // A language tag can come from a context's default language, so it does
+  // not make a literal any less of an IRI:
+  if (typeof node["@value"] !== "string") return undefined;
+  const type = node["@type"];
+  return type == null ||
+      type === "http://www.w3.org/2001/XMLSchema#string" ||
+      type === "http://www.w3.org/2001/XMLSchema#anyURI"
+    ? node["@value"]
+    : undefined;
+}
+
+function isAbsoluteIriValue(value: unknown): boolean {
+  const iri = getAbsoluteIriValue(value);
+  return iri != null && canDecodeIri(iri);
+}
+`;
+  }
+  // Contexts are activated by the expanded property IRIs of the values to be
+  // compacted, and by the contexts that already serialized children carry.
+  // They are detected before compaction, because a default context may
+  // define a prefix that would otherwise hide a property IRI behind a compact
+  // IRI such as `dc:license`.
   const extraContexts = Object.fromEntries(
     Object.values(types).flatMap((type) =>
       type.properties.flatMap((property) =>
@@ -349,6 +389,9 @@ function isValidLanguageTag(language: string): boolean {
 const extraPropertyContexts: Readonly<Record<string, string>> =
   ${JSON.stringify(extraContexts)};
 
+const extraContextUrls: readonly string[] =
+  ${JSON.stringify([...new Set(Object.values(extraContexts))])};
+
 function getExtraContexts(document: unknown): string[] {
   const contexts = new Set<string>();
   const pending: unknown[] = [document];
@@ -361,7 +404,16 @@ function getExtraContexts(document: unknown): string[] {
     }
     if ("@value" in value) continue;
     for (const [key, child] of globalThis.Object.entries(value)) {
-      if (key === "@context") continue;
+      if (key === "@context") {
+        for (const context of Array.isArray(child) ? child : [child]) {
+          if (
+            typeof context === "string" && extraContextUrls.includes(context)
+          ) {
+            contexts.add(context);
+          }
+        }
+        continue;
+      }
       if (globalThis.Object.hasOwn(extraPropertyContexts, key)) {
         contexts.add(extraPropertyContexts[key]);
       }

package/src/codec.test.ts

@@ -59,7 +59,12 @@ async function withFixture(
   const terms: Record<string, unknown> = { ...context };
   for (const name of ["value", "first", "second"]) {
     const term: Record<string, unknown> = { "@id": `${NS}${name}` };
-    if (property.range[0] === `${XSD}anyURI`) term["@type"] = "@id";
+    if (
+      property.range[0] === `${XSD}anyURI` ||
+      property.range[0] === "fedify:absoluteIri"
+    ) {
+      term["@type"] = "@id";
+    }
     if ("container" in property && property.container != null) {
       term["@container"] = `@${property.container}`;
     }
@@ -407,3 +412,68 @@ for (const functional of [false, true]) {
     }
   });
 }
+
+test("absolute IRIs are read from nodes and plain literals without a base", async () => {
+  await withFixture({
+    range: ["fedify:absoluteIri"],
+    redundantPropertiesWrite: "canonical",
+    redundantProperties: [{ uri: `${NS}first` }],
+  }, async (Fixture, contextLoader, source) => {
+    match(source, /PORTABLE_IRI_KEYS[^\n]+https:\/\/example.com\/value/);
+    match(source, /PORTABLE_IRI_KEYS[^\n]+https:\/\/example.com\/first/);
+    const values = [
+      { "@id": "https://example.com/node" },
+      literal("urn:example:literal"),
+      { "@value": "https://example.com/any-uri", "@type": `${XSD}anyURI` },
+      { "@value": "https://example.com/string", "@type": `${XSD}string` },
+      // A context's default language tags uncoerced strings:
+      { "@value": "https://example.com/tagged", "@language": "und" },
+      // Relative IRIs are never resolved against the object's ID:
+      { "@id": "CC-BY-4.0" },
+      { "@id": "_:b0" },
+      literal("Creative Commons Attribution 4.0 International"),
+      { "@value": "https://example.com/date", "@type": `${XSD}date` },
+    ];
+    const expected = [
+      new URL("https://example.com/node"),
+      new URL("urn:example:literal"),
+      new URL("https://example.com/any-uri"),
+      new URL("https://example.com/string"),
+      new URL("https://example.com/tagged"),
+    ];
+    for (const key of ["value", "first"]) {
+      const parsed = await Fixture.fromJsonLd(
+        {
+          "@id": "https://example.com/objects/1",
+          ...document({ [`${NS}${key}`]: values }),
+        },
+        { contextLoader, baseUrl: new URL("https://example.com/base/") },
+      );
+      deepStrictEqual(parsed.values, expected);
+    }
+    // An invalid canonical set is not replaced by a synonym:
+    const invalid = await Fixture.fromJsonLd(
+      document({
+        [`${NS}value`]: [{ "@id": "CC-BY-4.0" }],
+        [`${NS}first`]: [{ "@id": "https://example.com/fallback" }],
+      }),
+      { contextLoader },
+    );
+    deepStrictEqual(invalid.values, []);
+    const instance = new Fixture({ values: expected });
+    const expanded = await instance.toJsonLd({
+      format: "expand",
+      contextLoader,
+    }) as unknown as Record<string, unknown>[];
+    deepStrictEqual(
+      expanded[0][`${NS}value`],
+      expected.map((url) => ({ "@id": url.href })),
+    );
+    ok(!(`${NS}first` in expanded[0]));
+    const compact = await instance.toJsonLd({
+      format: "compact",
+      contextLoader,
+    });
+    deepStrictEqual(compact.value, expected.map((url) => url.href));
+  });
+});

package/src/codec.ts

@@ -288,17 +288,33 @@ export async function* generateEncoder(
     }
     let docContext: Parameters<typeof jsonld.compact>[1] = options.context ??
       ${JSON.stringify(type.defaultContext)};
+  `;
+  const hasExtraContexts = Object.values(types).some((t) =>
+    t.properties.some((p) => p.extraContext != null)
+  );
+  if (hasExtraContexts) {
+    yield `
+    if (options.context == null) {
+      const currentContexts = Array.isArray(docContext) ? docContext : [docContext];
+      const additionalContexts = getExtraContexts(values).filter(
+        context => !currentContexts.includes(context)
+      );
+      if (additionalContexts.length > 0) {
+        docContext = [...currentContexts, ...additionalContexts];
+      }
+    }
+    `;
+  }
+  yield `
     let compacted = await jsonld.compact(
       values,
       docContext,
       { documentLoader: options.contextLoader },
     );
   `;
-  if (
-    Object.values(types).some((t) =>
-      t.properties.some((p) => p.extraContext != null)
-    )
-  ) {
+  if (hasExtraContexts) {
+    // A cached child may map a property with its own inline context, which
+    // the scan above cannot recognize; compaction then leaves its full IRI:
     yield `
     if (options.context == null) {
       const currentContexts = Array.isArray(docContext) ? docContext : [docContext];

package/src/type.ts

@@ -334,6 +334,25 @@ const scalarTypes: Record<string, ScalarType> = {
     },
     skipUnparsable: true,
   },
+  "fedify:absoluteIri": {
+    name: "URL",
+    typeGuard(v) {
+      return `${v} instanceof URL`;
+    },
+    encoder(v) {
+      return `{ "@id": formatIri(${v}) }`;
+    },
+    compactEncoder(v) {
+      return `formatIri(${v})`;
+    },
+    dataCheck(v) {
+      return `isAbsoluteIriValue(${v})`;
+    },
+    decoder(v) {
+      return `decodeIri(getAbsoluteIriValue(${v})!)`;
+    },
+    skipUnparsable: true,
+  },
   "fedify:gatewayUrl": {
     name: "URL",
     typeGuard(v) {