Function extractFromGraph

  • extractFromGraph<T = any>(
        iri: string,
        dataset: DatasetCore,
        schema: JSONSchema7,
        options?: Partial<ExtendedWalkerOptions<T>>,
        baseIRI?: string,
        context?: Record<string, string>,
        logger?: Logger,
    ): any

    Extracts data from an RDF graph according to a JSON Schema

    This is the main entry point for the new extractor implementation. It builds a traversal schema if needed (dereference + project), then uses that structure to guide extraction from the graph.

    Key improvements over the legacy implementation:

    • Uses traversal schemas (no $ref resolution during extraction)
    • Cleaner separation of concerns with dedicated extractor functions
    • Better handling of anyOf/oneOf patterns
    • Structured logging support
    • Depth control via schema structure (no infinite loops)

    Type Parameters

    • T = any

      The type to derive filter patterns from (typically z.infer)

    Parameters

    • iri: string

      The IRI of the entity to extract

    • dataset: DatasetCore

      The RDF dataset to extract from

    • schema: JSONSchema7

      The JSON Schema defining the structure to extract

    • options: Partial<ExtendedWalkerOptions<T>> = {}

      Walker options including filter options (select/include/omit)

    • baseIRI: string = "http://schema.org/"

      Optional base IRI for expanding property names (defaults to "http://schema.org/")

    • Optionalcontext: Record<string, string>

      Optional prefix mappings for property name expansion

    • Optionallogger: Logger

      Optional logger for debugging (defaults to no-op)

    Returns any

    The extracted data as a JavaScript object

    Example

    // Without type parameter (backward compatible)
    const result = extractFromGraph(
      "http://example.com/person1",
      dataset,
      personSchema,
      {
        includeRelationsByDefault: false,
        include: { friends: { take: 10 } },
        omit: ["internalId"],
      },
      "http://schema.org/",
      { dc: "http://purl.org/dc/elements/1.1/" }
    );

    // With Zod type inference for type safety
    import { z } from 'zod';
    const zodSchema = z.object({
      name: z.string(),
      friends: z.array(z.object({ name: z.string() }))
    });
    type Person = z.infer<typeof zodSchema>;

    const result2 = extractFromGraph<Person>(
      "http://example.com/person1",
      dataset,
      personSchema,
      {
        include: { friends: { take: 10 } } // Type-safe: only valid keys allowed
      }
    );

Settings

Member Visibility