@fedify/vocab-runtime 2.4.0-dev.2122 → 2.4.0-dev.2129

package/src/internal/portable-dereference.test.ts

@@ -2,6 +2,7 @@ import { deepStrictEqual, ok, throws } from "node:assert/strict";
 import { test } from "node:test";
 import type { DocumentLoader } from "../docloader.ts";
 import { parseIri } from "../url.ts";
+import { createScopedContextLoader } from "./jsonld-cache.ts";
 import {
   createSnapshotContextLoader,
   getPortableGatewayCandidates,
@@ -104,3 +105,73 @@ test("createSnapshotContextLoader() does not nest released snapshots", async ()
   inner.release();
   outer.release();
 });
+
+test("context loaders unwrap mixed released wrappers", async () => {
+  const calls: string[] = [];
+  const base: DocumentLoader = (url) => {
+    calls.push(url);
+    return Promise.resolve({
+      contextUrl: null,
+      documentUrl: url,
+      document: { "@context": {} },
+    });
+  };
+  for (const snapshotFirst of [false, true]) {
+    let loader = base;
+    for (let i = 0; i < 10000; i++) {
+      const wrapper = (i % 2 === 0) === snapshotFirst
+        ? createSnapshotContextLoader(loader, true)
+        : createScopedContextLoader(loader, true);
+      wrapper.release();
+      loader = wrapper.loader;
+    }
+    const unwrapped = createScopedContextLoader(loader, false).loader;
+    deepStrictEqual(unwrapped, base);
+    await unwrapped("https://example.com/context");
+  }
+  deepStrictEqual(calls, [
+    "https://example.com/context",
+    "https://example.com/context",
+  ]);
+});
+
+test("mixed context wrappers preserve active suppression and snapshots", async () => {
+  for (const activeSnapshot of [false, true]) {
+    const calls: Parameters<DocumentLoader>[1][] = [];
+    const base: DocumentLoader = (url, options) => {
+      calls.push(options);
+      return Promise.resolve({
+        contextUrl: null,
+        documentUrl: url,
+        document: { "@context": {} },
+      });
+    };
+    const active = activeSnapshot
+      ? createSnapshotContextLoader(base, true)
+      : createScopedContextLoader(base, true);
+    let loader = active.loader;
+    for (let i = 0; i < 4; i++) {
+      const wrapper = i % 2 === 0
+        ? createScopedContextLoader(loader, true)
+        : createSnapshotContextLoader(loader, true);
+      wrapper.release();
+      loader = wrapper.loader;
+    }
+    const unwrapped = createScopedContextLoader(loader, false).loader;
+    deepStrictEqual(unwrapped, active.loader);
+    const options = { signal: new AbortController().signal };
+    const first = await unwrapped("https://example.com/context", options);
+    ok(first.document != null && typeof first.document === "object");
+    Reflect.set(first.document, "changed", true);
+    const second = await unwrapped("https://example.com/context", options);
+    deepStrictEqual(second.document, { "@context": {} });
+    deepStrictEqual(calls.length, activeSnapshot ? 1 : 2);
+    for (const call of calls) {
+      deepStrictEqual(call, { ...options, suppressError: true });
+    }
+    active.release();
+    deepStrictEqual(createScopedContextLoader(loader, false).loader, base);
+    await unwrapped("https://example.com/context", options);
+    deepStrictEqual(calls.at(-1), options);
+  }
+});

package/src/internal/portable-dereference.ts

@@ -7,6 +7,11 @@ import {
 import preloadedContexts from "../contexts.ts";
 import type { DocumentLoader, RemoteDocument } from "../docloader.ts";
 import jsonld from "../jsonld.ts";
+import {
+  createScopedContextLoader,
+  registerDocumentLoaderWrapper,
+  unwrapReleasedDocumentLoader,
+} from "./jsonld-cache.ts";
 import type {
   PortableObjectReferrer,
   PortableObjectVerification,
@@ -98,7 +103,15 @@ function getObjectId(object: unknown): URL | null {
 
 /**
  * Checks whether a vocabulary object is part of a chain of portable objects,
- * i.e., whether it has a portable ID or was obtained from a portable object.
+ * i.e., whether it has a portable ID, has an FEP-ef61 compatible identifier
+ * as its ID (even a malformed one, so that it fails closed), or was obtained
+ * from a portable object.  Accessors of such objects dereference references
+ * as portable objects.
+ *
+ * Being part of a chain does not mean that the object itself is verified:
+ * an object parsed from arbitrary JSON-LD is in a chain just because of its
+ * ID.  Only {@link dereferencePortableIri} records that an object was
+ * accepted by a verifier.
  *
  * @internal Technically exported for generated vocabulary classes, but not
  * part of the public API contract.  This is not considered public API for
@@ -107,7 +120,7 @@ function getObjectId(object: unknown): URL | null {
 export function isInPortableChain(object: object): boolean {
   if (provenances.has(object)) return true;
   const id = getObjectId(object);
-  return id != null && isPortableIri(id);
+  return id != null && (isPortableIri(id) || isCompatibleEf61Iri(id));
 }
 
 /**
@@ -562,17 +575,12 @@ function parseGatewayOrigin(gateway: string | URL): URL | null {
  */
 export function createSnapshotContextLoader(
   contextLoader: DocumentLoader,
+  suppressError?: boolean,
 ): { loader: DocumentLoader; release: () => void } {
   // Objects parsed during a dereference keep its loader, so later
   // dereferences from them would otherwise wrap released pass-throughs in
   // ever deeper chains:
-  for (
-    let wrapped = snapshotLoaders.get(contextLoader);
-    wrapped?.released;
-    wrapped = snapshotLoaders.get(contextLoader)
-  ) {
-    contextLoader = wrapped.base;
-  }
+  contextLoader = unwrapReleasedDocumentLoader(contextLoader);
   const cache = new Map<string, Promise<RemoteDocument>>();
   let released = false;
   const release = () => {
@@ -592,9 +600,10 @@ export function createSnapshotContextLoader(
     }
     let promise = cache.get(key);
     if (promise == null) {
-      const loading = contextLoader(url, options).then((document) =>
-        structuredClone(document)
-      );
+      const loading = contextLoader(
+        url,
+        suppressError ? { ...options, suppressError: true } : options,
+      ).then((document) => structuredClone(document));
       promise = loading;
       cache.set(key, loading);
       loading.catch(() => {
@@ -604,15 +613,10 @@ export function createSnapshotContextLoader(
     return structuredClone(await promise);
   };
   const state = { base: contextLoader, released: false };
-  snapshotLoaders.set(loader, state);
+  registerDocumentLoaderWrapper(loader, state);
   return { loader, release };
 }
 
-const snapshotLoaders = new WeakMap<
-  DocumentLoader,
-  { readonly base: DocumentLoader; released: boolean }
->();
-
 /**
  * Options for {@link dereferencePortableIri}.
  *
@@ -721,7 +725,7 @@ export async function dereferencePortableIri<T extends { id: URL | null }>(
   const fail = (error: unknown): null => {
     span?.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
     if (options.suppressError) {
-      logger.error("Failed to dereference {url}: {error}", {
+      logger.warn("Failed to dereference {url}: {error}", {
         url: lookupUrl,
         error,
       });
@@ -734,8 +738,9 @@ export async function dereferencePortableIri<T extends { id: URL | null }>(
     return fail(
       new TypeError(
         "Dereferencing the portable object " + lookupUrl + " requires the " +
-          "verifyPortableObject option, e.g., verifyPortableObjectProof() " +
-          "from @fedify/fedify.",
+          "verifyPortableObject option, e.g., verifyPortableObject() from " +
+          "@fedify/fedify.  Passing a Fedify Context as the options gives " +
+          "it, and objects parsed with the option use it by default.",
       ),
     );
   }
@@ -769,8 +774,15 @@ export async function dereferencePortableIri<T extends { id: URL | null }>(
     // retrieve the portable IRI itself:
     requestUrls.push({ url: lookupUrl, gateway: null });
   }
-  const snapshot = createSnapshotContextLoader(options.contextLoader);
+  const snapshot = createSnapshotContextLoader(
+    options.contextLoader,
+    options.suppressError,
+  );
   const contextLoader = snapshot.loader;
+  const scopedDocument = createScopedContextLoader(
+    options.documentLoader,
+    options.suppressError,
+  );
   const attempts: Attempt[] = [];
   const { signal } = options;
   const gatewayHints = explicitGateways == null && inferredGateways.length > 0
@@ -784,7 +796,7 @@ export async function dereferencePortableIri<T extends { id: URL | null }>(
       try {
         remoteDocument = response ?? await options.documentLoader(
           requestUrl,
-          signal == null ? undefined : { signal },
+          { signal, suppressError: options.suppressError },
         );
       } catch (error) {
         signal?.throwIfAborted();
@@ -808,7 +820,7 @@ export async function dereferencePortableIri<T extends { id: URL | null }>(
         let result: PortableObjectVerification;
         try {
           result = await verify(document, {
-            documentLoader: options.documentLoader,
+            documentLoader: scopedDocument.loader,
             contextLoader,
             tracerProvider: options.tracerProvider,
             ...(documentUrl == null ? {} : { documentUrl }),
@@ -866,6 +878,7 @@ export async function dereferencePortableIri<T extends { id: URL | null }>(
       }
     }
   } finally {
+    scopedDocument.release();
     snapshot.release();
   }
   const rejected = attempts.filter((a) => a.type === "rejected");

package/src/preprocessor.ts

@@ -1,5 +1,6 @@
 import type { DocumentLoader } from "./docloader.ts";
 import type { TracerProvider } from "@opentelemetry/api";
+import type { PortableObjectVerifier } from "./portable.ts";
 
 /**
  * JSON value shape passed to property preprocessors.
@@ -24,6 +25,12 @@ export interface PropertyPreprocessorContext {
   contextLoader?: DocumentLoader;
   /** OpenTelemetry tracer provider for instrumentation. */
   tracerProvider?: TracerProvider;
+  /**
+   * The default FEP-ef61 portable object verifier that objects returned by
+   * the preprocessor should use for their property accessors.
+   * @since 2.4.0
+   */
+  verifyPortableObject?: PortableObjectVerifier;
   /** Base URL for resolving relative references. */
   baseUrl?: URL;
 }

package/dist/tests/jsonld-CmDhHNTx.cjs

@@ -1,12 +0,0 @@
-const require_rolldown_runtime = require("./rolldown-runtime-emK7D4bc.cjs");
-let jsonld_dist_jsonld_esm_js = require("jsonld/dist/jsonld.esm.js");
-jsonld_dist_jsonld_esm_js = require_rolldown_runtime.__toESM(jsonld_dist_jsonld_esm_js, 1);
-//#region src/jsonld.ts
-var jsonld_default = jsonld_dist_jsonld_esm_js.default;
-//#endregion
-Object.defineProperty(exports, "jsonld_default", {
-	enumerable: true,
-	get: function() {
-		return jsonld_default;
-	}
-});

package/dist/tests/jsonld-DweIJ07b.mjs

@@ -1,5 +0,0 @@
-import jsonld from "jsonld/dist/jsonld.esm.js";
-//#region src/jsonld.ts
-var jsonld_default = jsonld;
-//#endregion
-export { jsonld_default as t };