@fedify/vocab-tools 2.4.0-dev.2115 → 2.4.0-dev.2127

package/src/class.ts

@@ -14,6 +14,7 @@ const XSD_ANY_URI = "http://www.w3.org/2001/XMLSchema#anyURI";
 const FEDIFY_URL = "fedify:url";
 const INTERNAL_RUNTIME_IMPORTS = [
   "compactJsonLdCache",
+  "createScopedContextLoader",
   "getJsonLdContext",
   "isTrustedIriOrigin",
   "normalizeJsonLdIris",
@@ -109,6 +110,7 @@ async function* generateClass(
     readonly #documentLoader?: DocumentLoader;
     readonly #contextLoader?: DocumentLoader;
     readonly #tracerProvider?: TracerProvider;
+    readonly #verifyPortableObject?: PortableObjectVerifier;
     readonly #warning?: {
       category: string[];
       message: string;
@@ -131,6 +133,10 @@ async function* generateClass(
         return this.#tracerProvider;
     }
 
+    protected get _verifyPortableObject(): PortableObjectVerifier | undefined {
+      return this.#verifyPortableObject;
+    }
+
     protected get _warning(): {
         category: string[];
         message: string;

package/src/codec.ts

@@ -43,6 +43,7 @@ function* generatePreprocessorBlock(
             documentLoader: options.documentLoader,
             contextLoader: options.contextLoader,
             tracerProvider: options.tracerProvider,
+            verifyPortableObject: options.verifyPortableObject,
             baseUrl: ${baseUrlExpr},
           });
           if (_result instanceof Error) throw _result;
@@ -376,6 +377,10 @@ export async function* generateDecoder(
    *                - \`contextLoader\`: The loader for remote JSON-LD contexts.
    *                - \`tracerProvider\`: The OpenTelemetry tracer provider to use.
    *                  If omitted, the global tracer provider is used.
+   *                - \`verifyPortableObject\`: The default FEP-ef61 portable
+   *                  object verifier for the property accessors of the
+   *                  returned object and the objects obtained from it.  It
+   *                  does not verify the given \`json\` itself.
    * @returns The object of this type.
    * @throws {TypeError} If the given \`json\` is invalid.
    */
@@ -385,6 +390,7 @@ export async function* generateDecoder(
       documentLoader?: DocumentLoader,
       contextLoader?: DocumentLoader,
       tracerProvider?: TracerProvider,
+      verifyPortableObject?: PortableObjectVerifier,
       baseUrl?: URL,
     } = {},
   ): Promise<${type.name}> {
@@ -423,6 +429,7 @@ export async function* generateDecoder(
       documentLoader?: DocumentLoader,
       contextLoader?: DocumentLoader,
       tracerProvider?: TracerProvider,
+      verifyPortableObject?: PortableObjectVerifier,
       baseUrl?: URL,
     } = {},
   ): Promise<${type.name}> {

package/src/constructor.ts

@@ -89,6 +89,7 @@ export async function* generateConstructor(
       documentLoader?: DocumentLoader,
       contextLoader?: DocumentLoader,
       tracerProvider?: TracerProvider,
+      verifyPortableObject?: PortableObjectVerifier,
     } = {},
   ) {
   `;
@@ -97,6 +98,7 @@ export async function* generateConstructor(
     this.#documentLoader = options.documentLoader;
     this.#contextLoader = options.contextLoader;
     this.#tracerProvider = options.tracerProvider;
+    this.#verifyPortableObject = options.verifyPortableObject;
     const baseUrl = (options as { baseUrl?: URL }).baseUrl;
     this.#_baseUrl = baseUrl == null ? undefined : new URL(baseUrl.href);
     if ("$warning" in options) {
@@ -228,6 +230,7 @@ export async function* generateCloner(
     options: {
       documentLoader?: DocumentLoader,
       contextLoader?: DocumentLoader,
+      verifyPortableObject?: PortableObjectVerifier,
     } = {}
   ): ${type.name} {
     if (this._warning != null) {

package/src/property.ts

@@ -118,6 +118,9 @@ async function* generateProperty(
                   documentLoader,
                   contextLoader: parseOptions.contextLoader,
                   tracerProvider,
+                  // Only the parent's own default is inherited, never the
+                  // verifier given to this call:
+                  verifyPortableObject: this._verifyPortableObject,
                   baseUrl: parseOptions.baseUrl,
                 }),
             });
@@ -159,7 +162,9 @@ async function* generateProperty(
         }
         let fetchResult: RemoteDocument;
         try {
-          fetchResult = await documentLoader(lookupUrl);
+          fetchResult = await documentLoader(lookupUrl, {
+            suppressError: options.suppressError,
+          });
         } catch (error) {
           span.setStatus({
             code: SpanStatusCode.ERROR,
@@ -167,7 +172,7 @@ async function* generateProperty(
           });
           span.end();
           if (options.suppressError) {
-            getLogger(["fedify", "vocab"]).error(
+            getLogger(["fedify", "vocab"]).warn(
               "Failed to fetch {url}: {error}",
               { error, url: lookupUrl }
             );
@@ -179,8 +184,12 @@ async function* generateProperty(
         // In portable mode, the document may turn out to be a portable object,
         // which has to be verified with the same context documents:
         const snapshot = portableMode
-          ? createSnapshotContextLoader(contextLoader)
+          ? createSnapshotContextLoader(contextLoader, options.suppressError)
           : null;
+        const scopedContext = createScopedContextLoader(
+          snapshot?.loader ?? contextLoader,
+          snapshot == null && options.suppressError,
+        );
         try {
           let claim: PortableResponseClaim | null | undefined;
           try {
@@ -189,8 +198,9 @@ async function* generateProperty(
               document,
               {
                 documentLoader,
-                contextLoader: snapshot?.loader ?? contextLoader,
+                contextLoader: scopedContext.loader,
                 tracerProvider,
+                verifyPortableObject: this._verifyPortableObject,
                 baseUrl,
               }
             );
@@ -233,7 +243,7 @@ async function* generateProperty(
             }
           } catch (e) {
             if (options.suppressError) {
-              getLogger(["fedify", "vocab"]).error(
+              getLogger(["fedify", "vocab"]).warn(
                 "Failed to parse {url}: {error}",
                 { error: e, url: lookupUrl }
               );
@@ -259,6 +269,7 @@ async function* generateProperty(
             contextLoader: snapshot?.loader,
           });
         } finally {
+          scopedContext.release();
           snapshot?.release();
         }
       });
@@ -270,6 +281,7 @@ async function* generateProperty(
         documentLoader?: DocumentLoader,
         contextLoader?: DocumentLoader,
         tracerProvider?: TracerProvider,
+        verifyPortableObject?: PortableObjectVerifier,
         baseUrl?: URL
       }
     ): Promise<${getTypeNames(property.range, types)}> {
@@ -280,6 +292,7 @@ async function* generateProperty(
       const tracerProvider = options.tracerProvider ??
         this._tracerProvider ?? trace.getTracerProvider();
       const baseUrl = options.baseUrl;
+      const verifyPortableObject = options.verifyPortableObject;
     `;
     if (
       property.preprocessors != null &&
@@ -310,6 +323,7 @@ async function* generateProperty(
                 documentLoader,
                 contextLoader,
                 tracerProvider,
+                verifyPortableObject,
                 baseUrl,
               });
               if (_result instanceof Error) throw _result;
@@ -331,7 +345,13 @@ async function* generateProperty(
         try {
           return await ${rangeType.name}.fromJsonLd(
             jsonLd,
-            { documentLoader, contextLoader, tracerProvider, baseUrl },
+            {
+              documentLoader,
+              contextLoader,
+              tracerProvider,
+              verifyPortableObject,
+              baseUrl,
+            },
           );
         } catch (e) {
           if (!(e instanceof TypeError)) throw e;
@@ -384,6 +404,15 @@ async function* generateProperty(
           );
         }
         if (this.${await getFieldName(property.uri)}.length < 1) return null;
+        if (
+          options.verifyPortableObject == null &&
+          this._verifyPortableObject != null
+        ) {
+          options = {
+            ...options,
+            verifyPortableObject: this._verifyPortableObject,
+          };
+        }
         let v = this.${await getFieldName(property.uri)}[0];
         if (!(v instanceof URL) &&
             !this.${await getFieldName(property.uri, "#_trust")}.has(0)) {
@@ -434,6 +463,7 @@ async function* generateProperty(
         yield `
             v = await this.#${property.singularName}_fromJsonLd(doc, {
               ...options,
+              verifyPortableObject: this._verifyPortableObject,
               baseUrl: ${cachedPropertyBaseUrl},
             });
       `;
@@ -522,6 +552,15 @@ async function* generateProperty(
             this._warning.values
           );
         }
+        if (
+          options.verifyPortableObject == null &&
+          this._verifyPortableObject != null
+        ) {
+          options = {
+            ...options,
+            verifyPortableObject: this._verifyPortableObject,
+          };
+        }
         const vs = this.${await getFieldName(property.uri)};
         for (let i = 0; i < vs.length; i++) {
           let v = vs[i];
@@ -578,6 +617,7 @@ async function* generateProperty(
         yield `
               v = await this.#${property.singularName}_fromJsonLd(obj, {
                 ...options,
+                verifyPortableObject: this._verifyPortableObject,
                 baseUrl: ${cachedPropertyBaseUrl},
               });
       `;