@noeldemartin/solid-utils 0.6.0-next.cccdc9c7e033588e2df9d1887ceae49788344d84 → 0.6.0-next.cea357c45d71b0c9b778bcf63049fce19ae3129f

package/src/helpers/io.test.ts

@@ -1,6 +1,13 @@
 import { describe, expect, it } from 'vitest';
 
-import { jsonldToQuads, normalizeSparql, quadsToJsonLD, sparqlToQuadsSync, turtleToQuadsSync } from './io';
+import {
+    jsonldToQuads,
+    normalizeJsonLD,
+    normalizeSparql,
+    quadsToJsonLD,
+    sparqlToQuadsSync,
+    turtleToQuadsSync,
+} from './io';
 import type { Quad } from '@rdfjs/types';
 
 describe('IO', () => {
@@ -200,6 +207,45 @@ describe('IO', () => {
         expect(quads[1].object.value).toEqual('John Doe');
     });
 
+    it('normalizes jsonld', async () => {
+        // Arrange
+        const json = {
+            '@graph': [
+                {
+                    '@context': { '@vocab': 'https://schema.org/' },
+                    '@id': '#it',
+                    '@type': 'Movie',
+                    'name': 'Spirited Away',
+                },
+                {
+                    '@context': { '@vocab': 'https://vocab.noeldemartin.com/crdt/' },
+                    '@id': '#it-metadata',
+                    '@type': 'Metadata',
+                    'resource': { '@id': '#it' },
+                },
+            ],
+        };
+
+        // Act
+        const normalized = await normalizeJsonLD(json);
+
+        // Assert
+        expect(normalized).toEqual({
+            '@graph': [
+                {
+                    '@id': '#it',
+                    '@type': ['https://schema.org/Movie'],
+                    'https://schema.org/name': [{ '@value': 'Spirited Away' }],
+                },
+                {
+                    '@id': '#it-metadata',
+                    '@type': ['https://vocab.noeldemartin.com/crdt/Metadata'],
+                    'https://vocab.noeldemartin.com/crdt/resource': [{ '@id': '#it' }],
+                },
+            ],
+        });
+    });
+
     it('converts quads to jsonld', async () => {
         // Arrange
         const quads = turtleToQuadsSync(`

package/src/helpers/io.ts

@@ -1,7 +1,7 @@
+import jsonld from 'jsonld';
 import md5 from 'md5';
 import { arr, arrayFilter, arrayReplace, objectWithoutEmpty, stringMatchAll, tap } from '@noeldemartin/utils';
 import { BlankNode as N3BlankNode, Quad as N3Quad, Parser, Writer } from 'n3';
-import { fromRDF, toRDF } from 'jsonld';
 import type { JsonLdDocument } from 'jsonld';
 import type { Quad } from '@rdfjs/types';
 import type { Term } from 'n3';
@@ -117,21 +117,31 @@ function normalizeQuads(quads: Quad[]): string {
         .join('\n');
 }
 
-function preprocessSubjects(jsonld: JsonLD): void {
-    if (!jsonld['@id']?.startsWith('#')) {
+function preprocessSubjects(json: JsonLD): void {
+    if (!json['@id']?.startsWith('#')) {
         return;
     }
 
-    jsonld['@id'] = ANONYMOUS_PREFIX + jsonld['@id'];
+    json['@id'] = ANONYMOUS_PREFIX + json['@id'];
+
+    for (const [field, value] of Object.entries(json)) {
+        if (typeof value !== 'object' || value === null || !('@id' in value)) {
+            continue;
+        }
+
+        preprocessSubjects(json[field] as JsonLD);
+    }
 }
 
 function postprocessSubjects(quads: Quad[]): void {
     for (const quad of quads) {
-        if (!quad.subject.value.startsWith(ANONYMOUS_PREFIX)) {
-            continue;
+        if (quad.subject.value.startsWith(ANONYMOUS_PREFIX)) {
+            quad.subject.value = quad.subject.value.slice(ANONYMOUS_PREFIX_LENGTH);
         }
 
-        quad.subject.value = quad.subject.value.slice(ANONYMOUS_PREFIX_LENGTH);
+        if (quad.object.value.startsWith(ANONYMOUS_PREFIX)) {
+            quad.object.value = quad.object.value.slice(ANONYMOUS_PREFIX_LENGTH);
+        }
     }
 }
 
@@ -186,22 +196,28 @@ export async function fetchSolidDocumentIfFound(
     }
 }
 
-export async function jsonldToQuads(jsonld: JsonLD, baseIRI?: string): Promise<Quad[]> {
-    if (isJsonLDGraph(jsonld)) {
-        const graphQuads = await Promise.all(jsonld['@graph'].map((resource) => jsonldToQuads(resource, baseIRI)));
+export async function jsonldToQuads(json: JsonLD, baseIRI?: string): Promise<Quad[]> {
+    if (isJsonLDGraph(json)) {
+        const graphQuads = await Promise.all(json['@graph'].map((resource) => jsonldToQuads(resource, baseIRI)));
 
         return graphQuads.flat();
     }
 
-    preprocessSubjects(jsonld);
+    preprocessSubjects(json);
 
-    const quads = await (toRDF(jsonld as JsonLdDocument, { base: baseIRI }) as Promise<Quad[]>);
+    const quads = await (jsonld.toRDF(json as JsonLdDocument, { base: baseIRI }) as Promise<Quad[]>);
 
     postprocessSubjects(quads);
 
     return quads;
 }
 
+export async function normalizeJsonLD(json: JsonLD, baseIRI?: string): Promise<JsonLD> {
+    const quads = await jsonldToQuads(json, baseIRI);
+
+    return quadsToJsonLD(quads);
+}
+
 export function normalizeSparql(sparql: string): string {
     const quads = sparqlToQuadsSync(sparql);
 
@@ -263,7 +279,7 @@ export function parseTurtle(turtle: string, options: Partial<ParsingOptions> = {
 }
 
 export async function quadsToJsonLD(quads: Quad[]): Promise<JsonLDGraph> {
-    const graph = await fromRDF(quads);
+    const graph = await jsonld.fromRDF(quads);
 
     return {
         '@graph': graph as JsonLDResource[],

package/src/helpers/jsonld.ts

@@ -1,4 +1,4 @@
-import { compact } from 'jsonld';
+import jsonld from 'jsonld';
 import type { JsonLdDocument } from 'jsonld';
 
 export type JsonLD = Partial<{
@@ -13,8 +13,8 @@ export type JsonLDGraph = {
     '@graph': JsonLDResource[];
 };
 
-export async function compactJsonLDGraph(jsonld: JsonLDGraph): Promise<JsonLDGraph> {
-    const compactedJsonLD = await compact(jsonld as JsonLdDocument, {});
+export async function compactJsonLDGraph(json: JsonLDGraph): Promise<JsonLDGraph> {
+    const compactedJsonLD = await jsonld.compact(json as JsonLdDocument, {});
 
     if ('@graph' in compactedJsonLD) {
         return compactedJsonLD as JsonLDGraph;
@@ -27,6 +27,6 @@ export async function compactJsonLDGraph(jsonld: JsonLDGraph): Promise<JsonLDGra
     return { '@graph': [] };
 }
 
-export function isJsonLDGraph(jsonld: JsonLD): jsonld is JsonLDGraph {
-    return '@graph' in jsonld;
+export function isJsonLDGraph(json: JsonLD): json is JsonLDGraph {
+    return '@graph' in json;
 }

package/src/helpers/vocabs.ts

@@ -23,22 +23,19 @@ export function defineIRIPrefix(name: string, value: string): void {
 }
 
 export function expandIRI(iri: string, options: Partial<ExpandIRIOptions> = {}): string {
-    if (iri.startsWith('http'))
-        return iri;
+    if (iri.startsWith('http')) return iri;
 
     const [prefix, name] = iri.split(':');
 
     if (prefix && name) {
         const expandedPrefix = knownPrefixes[prefix] ?? options.extraContext?.[prefix] ?? null;
 
-        if (!expandedPrefix)
-            throw new Error(`Can't expand IRI with unknown prefix: '${iri}'`);
+        if (!expandedPrefix) throw new Error(`Can't expand IRI with unknown prefix: '${iri}'`);
 
         return expandedPrefix + name;
     }
 
-    if (!options.defaultPrefix)
-        throw new Error(`Can't expand IRI without a default prefix: '${iri}'`);
+    if (!options.defaultPrefix) throw new Error(`Can't expand IRI without a default prefix: '${iri}'`);
 
     return options.defaultPrefix + prefix;
 }

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from './errors';
 export * from './helpers';
 export * from './models';
+export * from './types';

package/src/testing/helpers.ts

@@ -0,0 +1,187 @@
+import { JSError, arrayRemove, pull, stringMatchAll } from '@noeldemartin/utils';
+import type { Quad, Quad_Object } from '@rdfjs/types';
+
+import {
+    jsonldToQuads,
+    quadToTurtle,
+    quadsToTurtle,
+    sparqlToQuadsSync,
+    turtleToQuadsSync,
+} from '@noeldemartin/solid-utils/helpers/io';
+import type { JsonLD } from '@noeldemartin/solid-utils/helpers/jsonld';
+
+let patternsRegExpsIndex: Record<string, RegExp> = {};
+const builtInPatterns: Record<string, string> = {
+    '%uuid%': '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}',
+};
+
+class ExpectedQuadAssertionError extends JSError {
+
+    constructor(public readonly expectedQuad: Quad) {
+        super(`Couldn't find the following triple: ${quadToTurtle(expectedQuad)}`);
+    }
+
+}
+
+function assertExpectedQuadsExist(expectedQuads: Quad[], actualQuads: Quad[]): void {
+    for (const expectedQuad of expectedQuads) {
+        const matchingQuad = actualQuads.find((actualQuad) => quadEquals(expectedQuad, actualQuad));
+
+        if (!matchingQuad) throw new ExpectedQuadAssertionError(expectedQuad);
+
+        arrayRemove(actualQuads, matchingQuad);
+    }
+}
+
+function containsPatterns(value: string): boolean {
+    return /\[\[(.*\]\[)?([^\]]+)\]\]/.test(value);
+}
+
+function createPatternRegexp(expected: string): RegExp {
+    const patternAliases = [];
+    const patternMatches = stringMatchAll<4, 1 | 2>(expected, /\[\[((.*?)\]\[)?([^\]]+)\]\]/g);
+    const patterns: string[] = [];
+    let expectedRegExp = expected;
+
+    for (const patternMatch of patternMatches) {
+        patternMatch[2] && patternAliases.push(patternMatch[2]);
+
+        patterns.push(patternMatch[3]);
+
+        expectedRegExp = expectedRegExp.replace(patternMatch[0], `%PATTERN${patterns.length - 1}%`);
+    }
+
+    expectedRegExp = expectedRegExp.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+
+    for (const [patternIndex, pattern] of Object.entries(patterns)) {
+        expectedRegExp = expectedRegExp.replace(`%PATTERN${patternIndex}%`, builtInPatterns[pattern] ?? pattern);
+    }
+
+    return new RegExp(expectedRegExp);
+}
+
+function quadValueEquals(expected: string, actual: string): boolean {
+    return containsPatterns(expected)
+        ? (patternsRegExpsIndex[expected] ??= createPatternRegexp(expected)).test(actual)
+        : expected === actual;
+}
+
+function quadObjectEquals(expected: Quad_Object, actual: Quad_Object): boolean {
+    if (expected.termType !== actual.termType) return false;
+
+    if (expected.termType === 'Literal' && actual.termType === 'Literal') {
+        if (expected.datatype.value !== actual.datatype.value) return false;
+
+        if (!containsPatterns(expected.value))
+            return expected.datatype.value === 'http://www.w3.org/2001/XMLSchema#dateTime'
+                ? new Date(expected.value).getTime() === new Date(actual.value).getTime()
+                : expected.value === actual.value;
+    }
+
+    return quadValueEquals(expected.value, actual.value);
+}
+
+function quadEquals(expected: Quad, actual: Quad): boolean {
+    return (
+        quadObjectEquals(expected.object, actual.object) &&
+        quadValueEquals(expected.subject.value, actual.subject.value) &&
+        quadValueEquals(expected.predicate.value, actual.predicate.value)
+    );
+}
+
+function resetPatterns(): void {
+    patternsRegExpsIndex = {};
+}
+
+export interface EqualityResult {
+    success: boolean;
+    message: string;
+    expected: string;
+    actual: string;
+}
+
+export async function jsonldEquals(expected: JsonLD, actual: JsonLD): Promise<EqualityResult> {
+    // TODO catch parsing errors and improve message.
+    resetPatterns();
+
+    const expectedQuads = await jsonldToQuads(expected);
+    const actualQuads = await jsonldToQuads(actual);
+    const expectedTurtle = quadsToTurtle(expectedQuads);
+    const actualTurtle = quadsToTurtle(actualQuads);
+    const result = (success: boolean, message: string) => ({
+        success,
+        message,
+        expected: expectedTurtle,
+        actual: actualTurtle,
+    });
+
+    if (expectedQuads.length !== actualQuads.length)
+        return result(false, `Expected ${expectedQuads.length} triples, found ${actualQuads.length}.`);
+
+    try {
+        assertExpectedQuadsExist(expectedQuads, actualQuads);
+    } catch (error) {
+        if (!(error instanceof ExpectedQuadAssertionError)) throw error;
+
+        return result(false, error.message);
+    }
+
+    return result(true, 'jsonld matches');
+}
+
+export function sparqlEquals(expected: string, actual: string): EqualityResult {
+    // TODO catch parsing errors and improve message.
+    resetPatterns();
+
+    const expectedOperations = sparqlToQuadsSync(expected, { normalizeBlankNodes: true });
+    const actualOperations = sparqlToQuadsSync(actual, { normalizeBlankNodes: true });
+    const result = (success: boolean, message: string) => ({ success, message, expected, actual });
+
+    for (const operation of Object.keys(expectedOperations)) {
+        if (!(operation in actualOperations)) return result(false, `Couldn't find expected ${operation} operation.`);
+
+        const expectedQuads = pull(expectedOperations, operation);
+        const actualQuads = pull(actualOperations, operation);
+
+        if (expectedQuads.length !== actualQuads.length)
+            return result(false, `Expected ${expectedQuads.length} ${operation} triples, found ${actualQuads.length}.`);
+
+        try {
+            assertExpectedQuadsExist(expectedQuads, actualQuads);
+        } catch (error) {
+            if (!(error instanceof ExpectedQuadAssertionError)) throw error;
+
+            return result(
+                false,
+                `Couldn't find the following ${operation} triple: ${quadToTurtle(error.expectedQuad)}`,
+            );
+        }
+    }
+
+    const unexpectedOperation = Object.keys(actualOperations)[0] ?? null;
+    if (unexpectedOperation) return result(false, `Did not expect to find ${unexpectedOperation} triples.`);
+
+    return result(true, 'sparql matches');
+}
+
+export function turtleEquals(expected: string, actual: string): EqualityResult {
+    // TODO catch parsing errors and improve message.
+    resetPatterns();
+
+    const expectedQuads = turtleToQuadsSync(expected, { normalizeBlankNodes: true });
+    const actualQuads = turtleToQuadsSync(actual, { normalizeBlankNodes: true });
+    const result = (success: boolean, message: string) => ({ success, message, expected, actual });
+
+    if (expectedQuads.length !== actualQuads.length)
+        return result(false, `Expected ${expectedQuads.length} triples, found ${actualQuads.length}.`);
+
+    try {
+        assertExpectedQuadsExist(expectedQuads, actualQuads);
+    } catch (error) {
+        if (!(error instanceof ExpectedQuadAssertionError)) throw error;
+
+        return result(false, error.message);
+    }
+
+    return result(true, 'turtle matches');
+}