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

package/src/helpers/identifiers.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest';
+
+import { mintJsonLDIdentifiers } from '@noeldemartin/solid-utils/helpers';
+import { parseResourceSubject } from '@noeldemartin/solid-utils/helpers/identifiers';
+import type { JsonLD } from '@noeldemartin/solid-utils/helpers';
+
+describe('Identifiers helpers', () => {
+
+    it('mints JsonLD identifiers', () => {
+        // Arrange
+        const jsonld = {
+            '@context': { '@vocab': 'https://schema.org/' },
+            '@type': 'Recipe',
+            'name': 'Ramen',
+            'ingredients': ['Broth', 'Noodles'],
+            'instructions': [
+                {
+                    '@type': 'HowToStep',
+                    'text': 'Boil Noodles',
+                },
+                {
+                    '@type': 'HowToStep',
+                    'text': 'Dip them into the broth',
+                },
+            ],
+            'http://purl.org/dc/terms/created': {
+                '@type': 'http://www.w3.org/2001/XMLSchema#dateTime',
+                '@value': '1997-07-21T23:42:00.000Z',
+            },
+        };
+
+        // Act
+        const jsonldWithIds = mintJsonLDIdentifiers(jsonld);
+
+        // Assert
+        expect(jsonldWithIds['@id']).not.toBeUndefined();
+
+        const createdAt = jsonldWithIds['http://purl.org/dc/terms/created'] as Record<string, unknown>;
+        expect(createdAt['@id']).toBeUndefined();
+
+        const instructions = jsonldWithIds['instructions'] as [JsonLD, JsonLD];
+        expect(instructions[0]['@id']).not.toBeUndefined();
+        expect(instructions[1]['@id']).not.toBeUndefined();
+    });
+
+    it('parses subjects', () => {
+        expect(parseResourceSubject('https://my-pod.com/profile/card#me')).toEqual({
+            containerUrl: 'https://my-pod.com/profile/',
+            documentName: 'card',
+            resourceHash: 'me',
+        });
+        expect(parseResourceSubject('https://my-pod.com/about')).toEqual({
+            containerUrl: 'https://my-pod.com/',
+            documentName: 'about',
+        });
+        expect(parseResourceSubject('/profile/card#me')).toEqual({
+            containerUrl: '/profile/',
+            documentName: 'card',
+            resourceHash: 'me',
+        });
+        expect(parseResourceSubject('/about#sections')).toEqual({
+            containerUrl: '/',
+            documentName: 'about',
+            resourceHash: 'sections',
+        });
+        expect(parseResourceSubject('about#sections')).toEqual({
+            documentName: 'about',
+            resourceHash: 'sections',
+        });
+        expect(parseResourceSubject('about')).toEqual({
+            documentName: 'about',
+        });
+        expect(parseResourceSubject('')).toEqual({});
+    });
+
+});

package/src/helpers/identifiers.ts

@@ -1,6 +1,6 @@
 import { arr, isArray, isObject, objectDeepClone, objectWithoutEmpty, tap, urlParse, uuid } from '@noeldemartin/utils';
 import type { UrlParts } from '@noeldemartin/utils';
-import type { JsonLD, JsonLDResource } from '@/helpers';
+import type { JsonLD, JsonLDResource } from '@noeldemartin/solid-utils/helpers';
 
 export interface SubjectParts {
     containerUrl?: string;

package/src/helpers/index.ts

@@ -3,6 +3,5 @@ export * from './identifiers';
 export * from './interop';
 export * from './io';
 export * from './jsonld';
-export * from './testing';
 export * from './vocabs';
 export * from './wac';

package/src/helpers/interop.ts

@@ -1,8 +1,13 @@
 import { uuid } from '@noeldemartin/utils';
 
-import { createSolidDocument, fetchSolidDocument, solidDocumentExists, updateSolidDocument } from '@/helpers/io';
-import type { Fetch } from '@/helpers/io';
-import type { SolidUserProfile } from '@/helpers/auth';
+import {
+    createSolidDocument,
+    fetchSolidDocument,
+    solidDocumentExists,
+    updateSolidDocument,
+} from '@noeldemartin/solid-utils/helpers/io';
+import type { Fetch } from '@noeldemartin/solid-utils/helpers/io';
+import type { SolidUserProfile } from '@noeldemartin/solid-utils/helpers/auth';
 
 type TypeIndexType = 'public' | 'private';
 
@@ -12,7 +17,7 @@ async function mintTypeIndexUrl(user: SolidUserProfile, type: TypeIndexType, fet
     const storageUrl = user.storageUrls[0];
     const typeIndexUrl = `${storageUrl}settings/${type}TypeIndex`;
 
-    return await solidDocumentExists(typeIndexUrl, { fetch })
+    return (await solidDocumentExists(typeIndexUrl, { fetch }))
         ? `${storageUrl}settings/${type}TypeIndex-${uuid()}`
         : typeIndexUrl;
 }
@@ -25,9 +30,10 @@ async function createTypeIndex(user: SolidUserProfile, type: TypeIndexType, fetc
     fetch = fetch ?? window.fetch.bind(fetch);
 
     const typeIndexUrl = await mintTypeIndexUrl(user, type, fetch);
-    const typeIndexBody = type === 'public'
-        ? '<> a <http://www.w3.org/ns/solid/terms#TypeIndex> .'
-        : `
+    const typeIndexBody =
+        type === 'public'
+            ? '<> a <http://www.w3.org/ns/solid/terms#TypeIndex> .'
+            : `
             <> a
                 <http://www.w3.org/ns/solid/terms#TypeIndex>,
                 <http://www.w3.org/ns/solid/terms#UnlistedDocument> .
@@ -60,15 +66,16 @@ async function findRegistrations(
     const typeIndex = await fetchSolidDocument(typeIndexUrl, { fetch });
     const types = Array.isArray(type) ? type : [type];
 
-    return types.map(
-        type => typeIndex
-            .statements(undefined, 'rdf:type', 'solid:TypeRegistration')
-            .filter(statement => typeIndex.contains(statement.subject.value, 'solid:forClass', type))
-            .map(statement => typeIndex.statements(statement.subject.value, predicate))
-            .flat()
-            .map(statement => statement.object.value)
-            .filter(url => !!url),
-    ).flat();
+    return types
+        .map((_type) =>
+            typeIndex
+                .statements(undefined, 'rdf:type', 'solid:TypeRegistration')
+                .filter((statement) => typeIndex.contains(statement.subject.value, 'solid:forClass', _type))
+                .map((statement) => typeIndex.statements(statement.subject.value, predicate))
+                .flat()
+                .map((statement) => statement.object.value)
+                .filter((url) => !!url))
+        .flat();
 }
 
 /**

package/src/helpers/io.test.ts

@@ -0,0 +1,228 @@
+import { describe, expect, it } from 'vitest';
+
+import { jsonldToQuads, normalizeSparql, quadsToJsonLD, sparqlToQuadsSync, turtleToQuadsSync } from './io';
+import type { Quad } from '@rdfjs/types';
+
+describe('IO', () => {
+
+    it('parses jsonld', async () => {
+        // Arrange
+        const jsonld = {
+            '@context': { '@vocab': 'https://schema.org/' },
+            '@type': 'Movie',
+            'name': 'Spirited Away',
+        };
+
+        // Act
+        const quads = (await jsonldToQuads(jsonld)) as [Quad, Quad];
+
+        // Assert
+        expect(quads).toHaveLength(2);
+
+        expect(quads[0].subject.termType).toEqual('BlankNode');
+        expect(quads[0].predicate.termType).toEqual('NamedNode');
+        expect(quads[0].predicate.value).toEqual('http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
+        expect(quads[0].object.termType).toEqual('NamedNode');
+        expect(quads[0].object.value).toEqual('https://schema.org/Movie');
+
+        expect(quads[1].subject.termType).toEqual('BlankNode');
+        expect(quads[1].predicate.termType).toEqual('NamedNode');
+        expect(quads[1].predicate.value).toEqual('https://schema.org/name');
+        expect(quads[1].object.termType).toEqual('Literal');
+        expect(quads[1].object.value).toEqual('Spirited Away');
+    });
+
+    it('parses jsonld with anonymous subjects', async () => {
+        // Arrange
+        const jsonld = {
+            '@context': { '@vocab': 'https://schema.org/' },
+            '@id': '#it',
+            '@type': 'Movie',
+            'name': 'Spirited Away',
+        };
+
+        // Act
+        const quads = (await jsonldToQuads(jsonld)) as [Quad, Quad];
+
+        // Assert
+        expect(quads).toHaveLength(2);
+
+        expect(quads[0].subject.termType).toEqual('NamedNode');
+        expect(quads[0].subject.value).toEqual('#it');
+        expect(quads[0].predicate.termType).toEqual('NamedNode');
+        expect(quads[0].predicate.value).toEqual('http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
+        expect(quads[0].object.termType).toEqual('NamedNode');
+        expect(quads[0].object.value).toEqual('https://schema.org/Movie');
+
+        expect(quads[1].subject.termType).toEqual('NamedNode');
+        expect(quads[1].subject.value).toEqual('#it');
+        expect(quads[1].predicate.termType).toEqual('NamedNode');
+        expect(quads[1].predicate.value).toEqual('https://schema.org/name');
+        expect(quads[1].object.termType).toEqual('Literal');
+        expect(quads[1].object.value).toEqual('Spirited Away');
+    });
+
+    it('parses jsonld graphs', async () => {
+        // Arrange
+        const jsonld = {
+            '@graph': [
+                {
+                    '@context': { '@vocab': 'https://schema.org/' },
+                    '@id': 'solid://movies/spirited-away',
+                    '@type': 'Movie',
+                    'name': 'Spirited Away',
+                },
+                {
+                    '@context': { '@vocab': 'https://schema.org/' },
+                    '@id': 'solid://movies/spirited-away',
+                    '@type': 'Movie',
+                    'name': 'Spirited Away',
+                },
+            ],
+        };
+
+        // Act
+        const quads = await jsonldToQuads(jsonld);
+
+        // Assert
+        expect(quads).toHaveLength(4);
+
+        [0, 2].forEach((index) => {
+            expect(quads[index]?.subject.termType).toEqual('NamedNode');
+            expect(quads[index]?.subject.value).toEqual('solid://movies/spirited-away');
+            expect(quads[index]?.predicate.termType).toEqual('NamedNode');
+            expect(quads[index]?.predicate.value).toEqual('http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
+            expect(quads[index]?.object.termType).toEqual('NamedNode');
+            expect(quads[index]?.object.value).toEqual('https://schema.org/Movie');
+        });
+
+        [1, 3].forEach((index) => {
+            expect(quads[index]?.subject.termType).toEqual('NamedNode');
+            expect(quads[index]?.subject.value).toEqual('solid://movies/spirited-away');
+            expect(quads[index]?.predicate.termType).toEqual('NamedNode');
+            expect(quads[index]?.predicate.value).toEqual('https://schema.org/name');
+            expect(quads[index]?.object.termType).toEqual('Literal');
+            expect(quads[index]?.object.value).toEqual('Spirited Away');
+        });
+    });
+
+    it('normalizes sparql', () => {
+        // Arrange
+        const insertTurtle = `
+            @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+
+            <#me>
+                foaf:name "Amy" ;
+                foaf:lastName "Doe" .
+        `;
+        const deleteTurtle = `
+            @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+
+            <#me> foaf:name "John Doe" .
+        `;
+        const sparql = `
+            INSERT DATA { ${insertTurtle} } ;
+            DELETE DATA { ${deleteTurtle} }
+        `;
+
+        // Act
+        const normalized = normalizeSparql(sparql);
+
+        // Assert
+        expect(normalized).toEqual(
+            [
+                'INSERT DATA {',
+                '    <#me> <http://xmlns.com/foaf/0.1/lastName> "Doe" .',
+                '    <#me> <http://xmlns.com/foaf/0.1/name> "Amy" .',
+                '} ;',
+                'DELETE DATA {',
+                '    <#me> <http://xmlns.com/foaf/0.1/name> "John Doe" .',
+                '}',
+            ].join('\n'),
+        );
+    });
+
+    it('parses sparql', () => {
+        // Arrange
+        const insertTurtle = `
+            @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+
+            <#me> foaf:name "Amy Doe" .
+        `;
+        const deleteTurtle = `
+            @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+
+            <#me> foaf:name "John Doe" .
+        `;
+        const sparql = `
+            INSERT DATA { ${insertTurtle} } ;
+            DELETE DATA { ${deleteTurtle} }
+        `;
+
+        // Act
+        const quads = sparqlToQuadsSync(sparql);
+
+        // Assert
+        expect(Object.keys(quads)).toHaveLength(2);
+
+        expect(quads.insert).toEqual(turtleToQuadsSync(insertTurtle));
+        expect(quads.delete).toEqual(turtleToQuadsSync(deleteTurtle));
+    });
+
+    it('parses turtle synchronously', () => {
+        // Arrange
+        const turtle = `
+            @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+
+            <#me>
+                a foaf:Person ;
+                foaf:name "John Doe" .
+        `;
+
+        // Act
+        const quads = turtleToQuadsSync(turtle) as [Quad, Quad];
+
+        // Assert
+        expect(quads).toHaveLength(2);
+
+        expect(quads[0].subject.termType).toEqual('NamedNode');
+        expect(quads[0].subject.value).toEqual('#me');
+        expect(quads[0].predicate.termType).toEqual('NamedNode');
+        expect(quads[0].predicate.value).toEqual('http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
+        expect(quads[0].object.termType).toEqual('NamedNode');
+        expect(quads[0].object.value).toEqual('http://xmlns.com/foaf/0.1/Person');
+
+        expect(quads[1].subject.termType).toEqual('NamedNode');
+        expect(quads[1].subject.value).toEqual('#me');
+        expect(quads[1].predicate.termType).toEqual('NamedNode');
+        expect(quads[1].predicate.value).toEqual('http://xmlns.com/foaf/0.1/name');
+        expect(quads[1].object.termType).toEqual('Literal');
+        expect(quads[1].object.value).toEqual('John Doe');
+    });
+
+    it('converts quads to jsonld', async () => {
+        // Arrange
+        const quads = turtleToQuadsSync(`
+            @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+
+            <#me>
+                a foaf:Person ;
+                foaf:name "John Doe" .
+        `);
+
+        // Act
+        const jsonld = await quadsToJsonLD(quads);
+
+        // Assert
+        expect(jsonld).toEqual({
+            '@graph': [
+                {
+                    '@id': '#me',
+                    '@type': ['http://xmlns.com/foaf/0.1/Person'],
+                    'http://xmlns.com/foaf/0.1/name': [{ '@value': 'John Doe' }],
+                },
+            ],
+        });
+    });
+
+});

package/src/helpers/io.ts

@@ -1,24 +1,20 @@
 import md5 from 'md5';
-import {
-    TurtleParser,
-    TurtleWriter,
-    createBlankNode,
-    createQuad,
-    jsonLDFromRDF,
-    jsonLDToRDF,
-} from '@noeldemartin/solid-utils-external';
 import { arr, arrayFilter, arrayReplace, objectWithoutEmpty, stringMatchAll, tap } from '@noeldemartin/utils';
-import type { Quad } from 'rdf-js';
-import type { JsonLdDocument, Term } from '@noeldemartin/solid-utils-external';
-
-import SolidDocument from '@/models/SolidDocument';
-
-import MalformedSolidDocumentError, { SolidDocumentFormat } from '@/errors/MalformedSolidDocumentError';
-import NetworkRequestError from '@/errors/NetworkRequestError';
-import NotFoundError from '@/errors/NotFoundError';
-import UnauthorizedError from '@/errors/UnauthorizedError';
-import { isJsonLDGraph } from '@/helpers/jsonld';
-import type { JsonLD, JsonLDGraph, JsonLDResource } from '@/helpers/jsonld';
+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';
+
+import SolidDocument from '@noeldemartin/solid-utils/models/SolidDocument';
+
+// eslint-disable-next-line max-len
+import MalformedSolidDocumentError, { SolidDocumentFormat } from '@noeldemartin/solid-utils/errors/MalformedSolidDocumentError';
+import NetworkRequestError from '@noeldemartin/solid-utils/errors/NetworkRequestError';
+import NotFoundError from '@noeldemartin/solid-utils/errors/NotFoundError';
+import UnauthorizedError from '@noeldemartin/solid-utils/errors/UnauthorizedError';
+import { isJsonLDGraph } from '@noeldemartin/solid-utils/helpers/jsonld';
+import type { JsonLD, JsonLDGraph, JsonLDResource } from '@noeldemartin/solid-utils/helpers/jsonld';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export declare type AnyFetch = (input: any, options?: any) => Promise<Response>;
@@ -44,11 +40,9 @@ async function fetchRawSolidDocument(
         const fetch = options?.fetch ?? window.fetch;
         const response = await fetch(url, requestOptions);
 
-        if (response.status === 404)
-            throw new NotFoundError(url);
+        if (response.status === 404) throw new NotFoundError(url);
 
-        if ([401, 403].includes(response.status))
-            throw new UnauthorizedError(url, response.status);
+        if ([401, 403].includes(response.status)) throw new UnauthorizedError(url, response.status);
 
         const body = await response.text();
 
@@ -57,11 +51,9 @@ async function fetchRawSolidDocument(
             headers: response.headers,
         };
     } catch (error) {
-        if (error instanceof UnauthorizedError)
-            throw error;
+        if (error instanceof UnauthorizedError) throw error;
 
-        if (error instanceof NotFoundError)
-            throw error;
+        if (error instanceof NotFoundError) throw error;
 
         throw new NetworkRequestError(url, { cause: error });
     }
@@ -71,15 +63,14 @@ function normalizeBlankNodes(quads: Quad[]): Quad[] {
     const normalizedQuads = quads.slice(0);
     const quadsIndexes: Record<string, Set<number>> = {};
     const blankNodeIds = arr(quads)
-        .flatMap(
-            (quad, index) => tap(
+        .flatMap((quad, index) =>
+            tap(
                 arrayFilter([
                     quad.object.termType === 'BlankNode' ? quad.object.value : null,
                     quad.subject.termType === 'BlankNode' ? quad.subject.value : null,
                 ]),
-                ids => ids.forEach(id => (quadsIndexes[id] ??= new Set()).add(index)),
-            ),
-        )
+                (ids) => ids.forEach((id) => (quadsIndexes[id] ??= new Set()).add(index)),
+            ))
         .filter()
         .unique();
 
@@ -87,13 +78,10 @@ function normalizeBlankNodes(quads: Quad[]): Quad[] {
         const quadIndexes = quadsIndexes[originalId] as Set<number>;
         const normalizedId = md5(
             arr(quadIndexes)
-                .map(index => quads[index] as Quad)
+                .map((index) => quads[index] as Quad)
                 .filter(({ subject: { termType, value } }) => termType === 'BlankNode' && value === originalId)
-                .map(
-                    ({ predicate, object }) => object.termType === 'BlankNode'
-                        ? predicate.value
-                        : predicate.value + object.value,
-                )
+                .map(({ predicate, object }) =>
+                    object.termType === 'BlankNode' ? predicate.value : predicate.value + object.value)
                 .sorted()
                 .join(),
         );
@@ -106,20 +94,15 @@ function normalizeBlankNodes(quads: Quad[]): Quad[] {
             };
 
             for (const [termName, termValue] of Object.entries(terms)) {
-                if (termValue.termType !== 'BlankNode' || termValue.value !== originalId)
-                    continue;
+                if (termValue.termType !== 'BlankNode' || termValue.value !== originalId) continue;
 
-                terms[termName] = createBlankNode(normalizedId) as Term;
+                terms[termName] = new N3BlankNode(normalizedId) as Term;
             }
 
             arrayReplace(
                 normalizedQuads,
                 quad,
-                createQuad(
-                    terms.subject as Term,
-                    quad.predicate as Term,
-                    terms.object as Term,
-                ),
+                new N3Quad(terms.subject as Term, quad.predicate as Term, terms.object as Term),
             );
         }
     }
@@ -128,7 +111,10 @@ function normalizeBlankNodes(quads: Quad[]): Quad[] {
 }
 
 function normalizeQuads(quads: Quad[]): string {
-    return quads.map(quad => '    ' + quadToTurtle(quad)).sort().join('\n');
+    return quads
+        .map((quad) => '    ' + quadToTurtle(quad))
+        .sort()
+        .join('\n');
 }
 
 function preprocessSubjects(jsonld: JsonLD): void {
@@ -194,8 +180,7 @@ export async function fetchSolidDocumentIfFound(
 
         return document;
     } catch (error) {
-        if (!(error instanceof NotFoundError))
-            throw error;
+        if (!(error instanceof NotFoundError)) throw error;
 
         return null;
     }
@@ -203,14 +188,14 @@ 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)));
+        const graphQuads = await Promise.all(jsonld['@graph'].map((resource) => jsonldToQuads(resource, baseIRI)));
 
         return graphQuads.flat();
     }
 
     preprocessSubjects(jsonld);
 
-    const quads = await (jsonLDToRDF(jsonld as JsonLdDocument, { base: baseIRI }) as Promise<Quad[]>);
+    const quads = await (toRDF(jsonld as JsonLdDocument, { base: baseIRI }) as Promise<Quad[]>);
 
     postprocessSubjects(quads);
 
@@ -220,10 +205,9 @@ export async function jsonldToQuads(jsonld: JsonLD, baseIRI?: string): Promise<Q
 export function normalizeSparql(sparql: string): string {
     const quads = sparqlToQuadsSync(sparql);
 
-    return Object
-        .entries(quads)
-        .reduce((normalizedOperations, [operation, quads]) => {
-            const normalizedQuads = normalizeQuads(quads);
+    return Object.entries(quads)
+        .reduce((normalizedOperations, [operation, _quads]) => {
+            const normalizedQuads = normalizeQuads(_quads);
 
             return normalizedOperations.concat(`${operation.toUpperCase()} DATA {\n${normalizedQuads}\n}`);
         }, [] as string[])
@@ -238,7 +222,7 @@ export function normalizeTurtle(sparql: string): string {
 
 export function parseTurtle(turtle: string, options: Partial<ParsingOptions> = {}): Promise<RDFGraphData> {
     const parserOptions = objectWithoutEmpty({ baseIRI: options.baseIRI });
-    const parser = new TurtleParser(parserOptions);
+    const parser = new Parser(parserOptions);
     const data: RDFGraphData = {
         quads: [],
         containsRelativeIRIs: false,
@@ -257,11 +241,7 @@ export function parseTurtle(turtle: string, options: Partial<ParsingOptions> = {
         parser.parse(turtle, (error, quad) => {
             if (error) {
                 reject(
-                    new MalformedSolidDocumentError(
-                        options.baseIRI ?? null,
-                        SolidDocumentFormat.Turtle,
-                        error.message,
-                    ),
+                    new MalformedSolidDocumentError(options.baseIRI ?? null, SolidDocumentFormat.Turtle, error.message),
                 );
 
                 return;
@@ -283,7 +263,7 @@ export function parseTurtle(turtle: string, options: Partial<ParsingOptions> = {
 }
 
 export async function quadsToJsonLD(quads: Quad[]): Promise<JsonLDGraph> {
-    const graph = await jsonLDFromRDF(quads);
+    const graph = await fromRDF(quads);
 
     return {
         '@graph': graph as JsonLDResource[],
@@ -291,13 +271,13 @@ export async function quadsToJsonLD(quads: Quad[]): Promise<JsonLDGraph> {
 }
 
 export function quadsToTurtle(quads: Quad[]): string {
-    const writer = new TurtleWriter;
+    const writer = new Writer();
 
     return writer.quadsToString(quads);
 }
 
 export function quadToTurtle(quad: Quad): string {
-    const writer = new TurtleWriter;
+    const writer = new Writer();
 
     return writer.quadsToString([quad]).slice(0, -1);
 }
@@ -319,12 +299,14 @@ export async function sparqlToQuads(
     const operations = stringMatchAll<3>(sparql, /(\w+) DATA {([^}]+)}/g);
     const quads: Record<string, Quad[]> = {};
 
-    await Promise.all([...operations].map(async operation => {
-        const operationName = operation[1].toLowerCase();
-        const operationBody = operation[2];
+    await Promise.all(
+        [...operations].map(async (operation) => {
+            const operationName = operation[1].toLowerCase();
+            const operationBody = operation[2];
 
-        quads[operationName] = await turtleToQuads(operationBody, options);
-    }));
+            quads[operationName] = await turtleToQuads(operationBody, options);
+        }),
+    );
 
     return quads;
 }
@@ -351,14 +333,12 @@ export async function turtleToQuads(turtle: string, options: Partial<ParsingOpti
 
 export function turtleToQuadsSync(turtle: string, options: Partial<ParsingOptions> = {}): Quad[] {
     const parserOptions = objectWithoutEmpty({ baseIRI: options.baseIRI });
-    const parser = new TurtleParser(parserOptions);
+    const parser = new Parser(parserOptions);
 
     try {
         const quads = parser.parse(turtle);
 
-        return options.normalizeBlankNodes
-            ? normalizeBlankNodes(quads)
-            : quads;
+        return options.normalizeBlankNodes ? normalizeBlankNodes(quads) : quads;
     } catch (error) {
         throw new MalformedSolidDocumentError(
             options.baseIRI ?? null,

package/src/helpers/jsonld.ts

@@ -1,5 +1,5 @@
-import { compactJsonLD } from '@noeldemartin/solid-utils-external';
-import type { JsonLdDocument } from '@noeldemartin/solid-utils-external';
+import { compact } from 'jsonld';
+import type { JsonLdDocument } from 'jsonld';
 
 export type JsonLD = Partial<{
     '@context': Record<string, unknown>;
@@ -14,7 +14,7 @@ export type JsonLDGraph = {
 };
 
 export async function compactJsonLDGraph(jsonld: JsonLDGraph): Promise<JsonLDGraph> {
-    const compactedJsonLD = await compactJsonLD(jsonld as JsonLdDocument, {});
+    const compactedJsonLD = await compact(jsonld as JsonLdDocument, {});
 
     if ('@graph' in compactedJsonLD) {
         return compactedJsonLD as JsonLDGraph;