@noeldemartin/solid-utils 0.5.0 → 0.6.0-next.508449b33de64b0bcade86b642c9793381434231

package/src/models/index.ts

@@ -1,3 +1,5 @@
 export { default as SolidDocument, SolidDocumentPermission } from './SolidDocument';
 export { default as SolidStore } from './SolidStore';
 export { default as SolidThing } from './SolidThing';
+
+export * from './SolidStore';

package/src/{helpers/testing.ts → testing/helpers.ts}

@@ -1,8 +1,14 @@
 import { JSError, arrayRemove, pull, stringMatchAll } from '@noeldemartin/utils';
-import type { JsonLD } from '@/helpers/jsonld';
-import type { Quad, Quad_Object } from 'rdf-js';
+import type { Quad, Quad_Object } from '@rdfjs/types';
 
-import { jsonldToQuads, quadToTurtle, quadsToTurtle, sparqlToQuadsSync, turtleToQuadsSync } from './io';
+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> = {
@@ -19,10 +25,9 @@ class ExpectedQuadAssertionError extends JSError {
 
 function assertExpectedQuadsExist(expectedQuads: Quad[], actualQuads: Quad[]): void {
     for (const expectedQuad of expectedQuads) {
-        const matchingQuad = actualQuads.find(actualQuad => quadEquals(expectedQuad, actualQuad));
+        const matchingQuad = actualQuads.find((actualQuad) => quadEquals(expectedQuad, actualQuad));
 
-        if (!matchingQuad)
-            throw new ExpectedQuadAssertionError(expectedQuad);
+        if (!matchingQuad) throw new ExpectedQuadAssertionError(expectedQuad);
 
         arrayRemove(actualQuads, matchingQuad);
     }
@@ -34,10 +39,7 @@ function containsPatterns(value: string): boolean {
 
 function createPatternRegexp(expected: string): RegExp {
     const patternAliases = [];
-    const patternMatches = stringMatchAll<4, 1 | 2>(
-        expected,
-        /\[\[((.*?)\]\[)?([^\]]+)\]\]/g,
-    );
+    const patternMatches = stringMatchAll<4, 1 | 2>(expected, /\[\[((.*?)\]\[)?([^\]]+)\]\]/g);
     const patterns: string[] = [];
     let expectedRegExp = expected;
 
@@ -65,12 +67,10 @@ function quadValueEquals(expected: string, actual: string): boolean {
 }
 
 function quadObjectEquals(expected: Quad_Object, actual: Quad_Object): boolean {
-    if (expected.termType !== actual.termType)
-        return false;
+    if (expected.termType !== actual.termType) return false;
 
     if (expected.termType === 'Literal' && actual.termType === 'Literal') {
-        if (expected.datatype.value !== actual.datatype.value)
-            return false;
+        if (expected.datatype.value !== actual.datatype.value) return false;
 
         if (!containsPatterns(expected.value))
             return expected.datatype.value === 'http://www.w3.org/2001/XMLSchema#dateTime'
@@ -82,9 +82,11 @@ function quadObjectEquals(expected: Quad_Object, actual: Quad_Object): boolean {
 }
 
 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);
+    return (
+        quadObjectEquals(expected.object, actual.object) &&
+        quadValueEquals(expected.subject.value, actual.subject.value) &&
+        quadValueEquals(expected.predicate.value, actual.predicate.value)
+    );
 }
 
 function resetPatterns(): void {
@@ -119,8 +121,7 @@ export async function jsonldEquals(expected: JsonLD, actual: JsonLD): Promise<Eq
     try {
         assertExpectedQuadsExist(expectedQuads, actualQuads);
     } catch (error) {
-        if (!(error instanceof ExpectedQuadAssertionError))
-            throw error;
+        if (!(error instanceof ExpectedQuadAssertionError)) throw error;
 
         return result(false, error.message);
     }
@@ -137,8 +138,7 @@ export function sparqlEquals(expected: string, actual: string): EqualityResult {
     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.`);
+        if (!(operation in actualOperations)) return result(false, `Couldn't find expected ${operation} operation.`);
 
         const expectedQuads = pull(expectedOperations, operation);
         const actualQuads = pull(actualOperations, operation);
@@ -149,8 +149,7 @@ export function sparqlEquals(expected: string, actual: string): EqualityResult {
         try {
             assertExpectedQuadsExist(expectedQuads, actualQuads);
         } catch (error) {
-            if (!(error instanceof ExpectedQuadAssertionError))
-                throw error;
+            if (!(error instanceof ExpectedQuadAssertionError)) throw error;
 
             return result(
                 false,
@@ -160,8 +159,7 @@ export function sparqlEquals(expected: string, actual: string): EqualityResult {
     }
 
     const unexpectedOperation = Object.keys(actualOperations)[0] ?? null;
-    if (unexpectedOperation)
-        return result(false, `Did not expect to find ${unexpectedOperation} triples.`);
+    if (unexpectedOperation) return result(false, `Did not expect to find ${unexpectedOperation} triples.`);
 
     return result(true, 'sparql matches');
 }
@@ -180,8 +178,7 @@ export function turtleEquals(expected: string, actual: string): EqualityResult {
     try {
         assertExpectedQuadsExist(expectedQuads, actualQuads);
     } catch (error) {
-        if (!(error instanceof ExpectedQuadAssertionError))
-            throw error;
+        if (!(error instanceof ExpectedQuadAssertionError)) throw error;
 
         return result(false, error.message);
     }

package/src/testing/hepers.test.ts

@@ -0,0 +1,329 @@
+import { describe, expect, it } from 'vitest';
+
+import { sparqlEquals, turtleEquals } from './helpers';
+
+describe('Testing helpers', () => {
+
+    it('Compares sparql', () => {
+        // Arrange
+        const expected = 'INSERT DATA { <#me> a <http://xmlns.com/foaf/0.1/Person> . }';
+        const actual = 'INSERT DATA { <#me> a <http://xmlns.com/foaf/0.1/Person> . }';
+
+        // Act
+        const result = sparqlEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(true);
+    });
+
+    it('Compares sparql operations', () => {
+        // Arrange
+        const expected = `
+            INSERT DATA { <#me> <http://xmlns.com/foaf/0.1/name> "Amy Doe" . } ;
+            DELETE DATA { <#me> <http://xmlns.com/foaf/0.1/name> "John Doe" . }
+        `;
+        const actual = 'INSERT DATA { <#me> <http://xmlns.com/foaf/0.1/name> "Amy Doe" . }';
+
+        // Act
+        const result = sparqlEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(false);
+    });
+
+    it('Compares sparql triples', () => {
+        // Arrange
+        const expected = 'INSERT DATA { <#me> a <http://xmlns.com/foaf/0.1/Person> . }';
+        const actual = 'INSERT DATA { <#me> <http://xmlns.com/foaf/0.1/name> "Amy Doe" . }';
+
+        // Act
+        const result = sparqlEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(false);
+    });
+
+    it('Compares expanded ordered lists in Turtle', () => {
+        // Arrange
+        const expected = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeIngredient ( "Broth" "Noodles" ) .
+        `;
+        const actual = `
+            @prefix schema: <https://schema.org/> .
+            @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeIngredient _:b0 .
+
+            _:b0
+                rdf:first "Broth" ;
+                rdf:rest _:b1 .
+
+            _:b1
+                rdf:first "Noodles" ;
+                rdf:rest rdf:nil .
+        `;
+
+        // Act
+        const result = turtleEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(true);
+    });
+
+    it('Compares different ordered lists in Turtle', () => {
+        // Arrange
+        const expected = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeIngredient ( "Broth" "Noodles" ) .
+        `;
+        const actual = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeIngredient ( "Noodles" "Broth" ) .
+        `;
+
+        // Act
+        const result = turtleEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(false);
+    });
+
+    it('Compares different unordered lists in Turtle', () => {
+        // Arrange
+        const expected = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeIngredient "Broth", "Noodles" .
+        `;
+        const actual = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeIngredient "Noodles", "Broth" .
+        `;
+
+        // Act
+        const result = turtleEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(true);
+    });
+
+    it('Compares sparql using regex patterns', () => {
+        // Arrange
+        const expected = `
+            INSERT DATA {
+                @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+                @prefix foaf: <http://xmlns.com/foaf/> .
+                @prefix purl: <http://purl.org/dc/terms/> .
+
+                <#me>
+                    foaf:name "[[.*]] Doe" ;
+                    foaf:age 42 .
+
+                <#something-[[.*]]>
+                    purl:created "[[.*]]"^^xsd:dateTime ;
+                    purl:modified "2021-01-16T[[.*]]"^^xsd:dateTime ;
+                    purl:available "2021-01-16T12:34:56Z"^^xsd:dateTime .
+            }
+        `;
+        const actual = `
+            INSERT DATA {
+                @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+                @prefix foaf: <http://xmlns.com/foaf/> .
+                @prefix purl: <http://purl.org/dc/terms/> .
+
+                <#me>
+                    foaf:name "John Doe" ;
+                    foaf:age 42 .
+
+                <#something-123456>
+                    purl:created "2021-01-16T12:12:50.123Z"^^xsd:dateTime ;
+                    purl:modified "2021-01-16T12:12:50.123Z"^^xsd:dateTime ;
+                    purl:available "2021-01-16T12:34:56.000Z"^^xsd:dateTime .
+            }
+        `;
+
+        // Act
+        const result = sparqlEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(true);
+    });
+
+    it('supports aliases in regex patterns', () => {
+        // Arrange
+        const expected = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeInstructions <#[[step-1][.*]]>, <#[[step-2][.*]]> .
+
+            <#[[step-1][.*]]>
+                a schema:HowToStep ;
+                schema:text "Boil the noodles" .
+
+            <#[[step-2][.*]]>
+                a schema:HowToStep ;
+                schema:text "Dip them into the broth" .
+        `;
+        const actual = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeInstructions <#ramen-step-1>, <#ramen-step-2> .
+
+            <#ramen-step-1>
+                a schema:HowToStep ;
+                schema:text "Boil the noodles" .
+
+            <#ramen-step-2>
+                a schema:HowToStep ;
+                schema:text "Dip them into the broth" .
+        `;
+
+        // Act
+        const result = turtleEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(true);
+    });
+
+    it('counts matching triples only once', () => {
+        // Arrange
+        const expected = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen", "Ramen" .
+        `;
+        const actual = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:description "is life" .
+        `;
+
+        // Act
+        const result = turtleEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(false);
+    });
+
+    it('allows regex patterns to be mixed up', () => {
+        // Arrange
+        const expected = `
+            @prefix schema: <https://schema.org/> .
+
+            <#[[instruction-1][.*]]-operation-[[operation-1][.*]]> schema:object <#[[instruction-1][.*]]> .
+            <#[[instruction-1][.*]]-metadata> schema:object <#[[instruction-1][.*]]> .
+        `;
+        const actual = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen-step-1-metadata> schema:object <#ramen> .
+            <#ramen-step-1-operation-1> schema:object <#ramen> .
+        `;
+
+        // Act
+        const result = turtleEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(true);
+    });
+
+    it('matches built-in patterns', () => {
+        // Arrange
+        const expected = `
+            @prefix schema: <https://schema.org/> .
+
+            <#[[foobar][%uuid%]]> schema:description "Lorem ipsum" .
+            <#[[%uuid%]]> schema:description "Dolor sit amet" .
+        `;
+        const actual = `
+            @prefix schema: <https://schema.org/> .
+
+            <#20421db7-0c7d-419c-b27e-2c9b3cc026b3> schema:description "Lorem ipsum" .
+            <#d4b41533-dd5d-4a66-9d3f-316f80f135b2> schema:description "Dolor sit amet" .
+        `;
+
+        // Act
+        const result = turtleEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(true);
+    });
+
+    // TODO
+    it.skip('aliases match regex patterns', () => {
+        // Arrange
+        const expected = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeInstructions <#[[step-1][.*]]>, <#[[step-2][.*]]> .
+
+            <#[[step-1][.*]]>
+                a schema:HowToStep ;
+                schema:text "Boil the noodles" .
+
+            <#[[step-2][.*]]>
+                a schema:HowToStep ;
+                schema:text "Dip them into the broth" .
+        `;
+        const actual = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeInstructions <#ramen-step-1>, <#ramen-step-2> .
+
+            <#ramen-step-1>
+                a schema:HowToStep ;
+                schema:text "Boil the noodles" .
+
+            <#ramen-step-3>
+                a schema:HowToStep ;
+                schema:text "Dip them into the broth" .
+        `;
+
+        // Act
+        const result = turtleEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(false);
+    });
+
+});

package/src/testing/index.ts

@@ -1,2 +1 @@
-export * from './mocking';
-export { default as ResponseStub } from './ResponseStub';
+export * from './helpers';

package/src/types/index.ts

@@ -0,0 +1,2 @@
+export type { ChaiSolidAssertions } from '@noeldemartin/solid-utils/chai';
+export type { VitestSolidMatchers } from '@noeldemartin/solid-utils/vitest';

package/src/types/n3.d.ts

@@ -1,9 +1,7 @@
 import '@types/n3';
 
 declare module 'n3' {
-
     interface Parser {
         _resolveRelativeIRI(iri: string): string;
     }
-
 }

package/src/vitest/index.ts

@@ -0,0 +1,20 @@
+import { expect } from 'vitest';
+
+import matchers from './matchers';
+
+export type VitestSolidMatchers<R = unknown> = {
+    [K in keyof typeof matchers]: (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ...args: Parameters<(typeof matchers)[K]> extends [any, ...infer Rest] ? Rest : never
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) => ReturnType<(typeof matchers)[K]> extends Promise<any> ? Promise<R> : R;
+};
+
+export function installVitestSolidMatchers(): void {
+    expect.extend(matchers);
+}
+
+declare module '@vitest/expect' {
+    interface Assertion<T> extends VitestSolidMatchers<T> {}
+    interface AsymmetricMatchersContaining extends VitestSolidMatchers {}
+}

package/src/vitest/matchers.ts

@@ -0,0 +1,68 @@
+import type { MatcherState, MatchersObject } from '@vitest/expect';
+
+import { normalizeSparql, normalizeTurtle } from '@noeldemartin/solid-utils/helpers/io';
+import { jsonldEquals, sparqlEquals, turtleEquals } from '@noeldemartin/solid-utils/testing/helpers';
+import type { EqualityResult } from '@noeldemartin/solid-utils/testing/helpers';
+import type { JsonLD } from '@noeldemartin/solid-utils/helpers';
+
+interface FormatResultOptions {
+    state: MatcherState;
+    hint: string;
+    expected: unknown;
+    received: unknown;
+}
+
+function formatResult(result: EqualityResult, options: FormatResultOptions) {
+    const pass = result.success;
+    const utils = options.state.utils;
+    const message = pass
+        ? () => [result.message, utils.matcherHint(options.hint)].join('\n\n')
+        : () =>
+            [
+                result.message,
+                utils.matcherHint(options.hint),
+                [
+                    `Expected: not ${utils.printExpected(options.expected)}`,
+                    `Received: ${utils.printReceived(options.received)}`,
+                ].join('\n'),
+            ].join('\n\n');
+
+    return { pass, message };
+}
+
+export function defineMatchers<T extends MatchersObject>(matchers: T): T {
+    return matchers;
+}
+
+export default defineMatchers({
+    async toEqualJsonLD(received, expected: JsonLD) {
+        const result = await jsonldEquals(expected, received);
+
+        return formatResult(result, {
+            state: this,
+            hint: 'toEqualJsonLD',
+            expected,
+            received,
+        });
+    },
+    toEqualSparql(received, expected: string) {
+        const result = sparqlEquals(expected, received);
+
+        return formatResult(result, {
+            state: this,
+            hint: 'toEqualSparql',
+            expected: normalizeSparql(expected),
+            received: normalizeSparql(received),
+        });
+    },
+    toEqualTurtle(received, expected: string) {
+        const result = turtleEquals(expected, received);
+
+        return formatResult(result, {
+            state: this,
+            hint: 'toEqualTurtle',
+            expected: normalizeTurtle(expected),
+            received: normalizeTurtle(received),
+        });
+    },
+});

package/.github/workflows/ci.yml

@@ -1,16 +0,0 @@
-name: CI
-
-on: [push, pull_request]
-
-jobs:
-    ci:
-        runs-on: ubuntu-latest
-        steps:
-            - uses: actions/checkout@v3
-            - uses: actions/setup-node@v3
-              with:
-                  node-version-file: '.nvmrc'
-            - run: npm ci
-            - run: npm run build
-            - run: npm run lint
-            - run: npm run test

package/.nvmrc

@@ -1 +0,0 @@
-v16

package/CHANGELOG.md

@@ -1,70 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [v0.5.0](https://github.com/NoelDeMartin/solid-utils/releases/tag/v0.5.0) - 2025-01-05
-
-### Added
-
-- `ldp:` prefix.
-- `toEqualTurtle` matcher.
-
-### Fixed
-
-- Parsing JsonLD with anonymous subjects (meaning subjects with ids such as `#it`, without a full url).
-
-### Changed
-
-- `@types/rdf-js` dependency for `@rdfjs/types`.
-- Many of the `fetch*` helpers now take an options object instead of a `fetch` method.
-- Disabled caching when reading user profiles, in order to fix an issue with CSS v7.1.3 (See [CommunitySolidServer/CommunitySolidServer#1972](https://github.com/CommunitySolidServer/CommunitySolidServer/issues/1972)).
-
-### Removed
-
-- Faking helpers have been extracted into `@noeldemartin/testing` in order to avoid including them (and the `faker` dependency) on production bundles.
-
-## [v0.4.0](https://github.com/NoelDeMartin/solid-utils/releases/tag/v0.4.0) - 2023-12-17
-
-### Changed
-
-- Retrieving user profiles will now fail if no storage urls are found. In reality, this is only an improvement for the TypeScript types since [according to the spec](https://solidproject.org/TR/protocol#storage-resource) this should never happen.
-
-### Deprecated
-
-- Interoperability helpers such as `createPublicTypeIndex`, `createPrivateTypeIndex`, `findContainerRegistrations`, and `findInstanceRegistrations`. Use [soukai-solid interoperability helpers](https://github.com/noeldemartin/soukai-solid#interoperability) instead.
-
-### Removed
-
-- Required jest dependencies. This was previously causing some problems using other test runners like [Vitest](https://vitest.dev/).
-
-## [v0.3.0](https://github.com/NoelDeMartin/solid-utils/releases/tag/v0.3.0) - 2023-03-10
-
-### Fixed
-
-- Tree-shaking by declaring `"sideEffects": false`.
-
-### Changed
-
-- `fetchLoginUserProfile` now takes an options object instead of an optional fetch function.
-
-## [v0.2.0](https://github.com/NoelDeMartin/solid-utils/releases/tag/v0.2.0) - 2023-01-20
-
-### Added
-
-- `rdf:` prefix for `http://www.w3.org/1999/02/22-rdf-syntax-ns#` (previously was `rdfs:`).
-
-### Changed
-
-- The `rdfs:` has been changed to be `http://www.w3.org/2000/01/rdf-schema#`.
-
-## [v0.1.1](https://github.com/NoelDeMartin/solid-utils/releases/tag/v0.1.1) - 2021-09-04
-
-No documented changes.
-
-## [v0.1.0](https://github.com/NoelDeMartin/solid-utils/releases/tag/v0.1.0) - 2021-09-04
-
-### Added
-
-- Everything!