@noeldemartin/solid-utils 0.1.1 → 0.2.0-next.ebb53edb2f1f27bc44c4c5ebd38761a0b30d3408

package/src/models/SolidDocument.ts

@@ -1,30 +1,38 @@
-import { parseDate } from '@noeldemartin/utils';
+import { arrayFilter, parseDate, stringMatch } from '@noeldemartin/utils';
 import type { Quad } from 'rdf-js';
 
 import { expandIRI } from '@/helpers/vocabs';
 
-import SolidThing from './SolidThing';
+import SolidStore from './SolidStore';
 
-export default class SolidDocument {
+export enum SolidDocumentPermission {
+    Read = 'read',
+    Write = 'write',
+    Append = 'append',
+    Control = 'control',
+}
+
+export default class SolidDocument extends SolidStore {
 
     public readonly url: string;
     public readonly headers: Headers;
-    private quads: Quad[];
 
     public constructor(url: string, quads: Quad[], headers: Headers) {
+        super(quads);
+
         this.url = url;
-        this.quads = quads;
         this.headers = headers;
     }
 
-    public isEmpty(): boolean {
-        return this.statements.length === 0;
+    public isACPResource(): boolean {
+        return !!this.headers.get('Link')
+            ?.match(/<http:\/\/www\.w3\.org\/ns\/solid\/acp#AccessControlResource>;[^,]+rel="type"/);
     }
 
     public isPersonalProfile(): boolean {
         return !!this.statement(
             this.url,
-            expandIRI('rdfs:type'),
+            expandIRI('rdf:type'),
             expandIRI('foaf:PersonalProfileDocument'),
         );
     }
@@ -33,41 +41,27 @@ export default class SolidDocument {
         return !!this.headers.get('Link')?.match(/<http:\/\/www\.w3\.org\/ns\/pim\/space#Storage>;[^,]+rel="type"/);
     }
 
-    public getLastModified(): Date | null {
-        return parseDate(this.headers.get('last-modified'))
-            ?? parseDate(this.statement(this.url, 'purl:modified')?.object.value)
-            ?? this.getLatestDocumentDate()
-            ?? null;
+    public isUserWritable(): boolean {
+        return this.getUserPermissions().includes(SolidDocumentPermission.Write);
     }
 
-    public statements(subject?: string, predicate?: string, object?: string): Quad[] {
-        return this.quads.filter(
-            statement =>
-                (!object || statement.object.value === expandIRI(object, { defaultPrefix: this.url })) &&
-                (!subject || statement.subject.value === expandIRI(subject, { defaultPrefix: this.url })) &&
-                (!predicate || statement.predicate.value === expandIRI(predicate, { defaultPrefix: this.url })),
-        );
+    public getUserPermissions(): SolidDocumentPermission[] {
+        return this.getPermissionsFromWAC('user');
     }
 
-    public statement(subject?: string, predicate?: string, object?: string): Quad | null {
-        const statement = this.quads.find(
-            statement =>
-                (!object || statement.object.value === expandIRI(object, { defaultPrefix: this.url })) &&
-                (!subject || statement.subject.value === expandIRI(subject, { defaultPrefix: this.url })) &&
-                (!predicate || statement.predicate.value === expandIRI(predicate, { defaultPrefix: this.url })),
-        );
-
-        return statement ?? null;
+    public getPublicPermissions(): SolidDocumentPermission[] {
+        return this.getPermissionsFromWAC('public');
     }
 
-    public contains(subject: string, predicate?: string, object?: string): boolean {
-        return this.statement(subject, predicate, object) !== null;
+    public getLastModified(): Date | null {
+        return parseDate(this.headers.get('last-modified'))
+            ?? parseDate(this.statement(this.url, 'purl:modified')?.object.value)
+            ?? this.getLatestDocumentDate()
+            ?? null;
     }
 
-    public getThing(subject: string): SolidThing {
-        const statements = this.statements(subject);
-
-        return new SolidThing(subject, statements);
+    protected expandIRI(iri: string): string {
+        return expandIRI(iri, { defaultPrefix: this.url });
     }
 
     private getLatestDocumentDate(): Date | null {
@@ -81,4 +75,16 @@ export default class SolidDocument {
         return dates.length > 0 ? dates.reduce((a, b) => a > b ? a : b) : null;
     }
 
+    private getPermissionsFromWAC(type: string): SolidDocumentPermission[] {
+        const wacAllow = this.headers.get('WAC-Allow') ?? '';
+        const publicModes = stringMatch<2>(wacAllow, new RegExp(`${type}="([^"]+)"`))?.[1] ?? '';
+
+        return arrayFilter([
+            publicModes.includes('read') && SolidDocumentPermission.Read,
+            publicModes.includes('write') && SolidDocumentPermission.Write,
+            publicModes.includes('append') && SolidDocumentPermission.Append,
+            publicModes.includes('control') && SolidDocumentPermission.Control,
+        ]);
+    }
+
 }

package/src/models/SolidStore.ts

@@ -0,0 +1,61 @@
+import type { Quad } from 'rdf-js';
+
+import { expandIRI } from '@/helpers/vocabs';
+
+import SolidThing from './SolidThing';
+
+export default class SolidStore {
+
+    private quads: Quad[];
+
+    public constructor(quads: Quad[] = []) {
+        this.quads = quads;
+    }
+
+    public isEmpty(): boolean {
+        return this.statements.length === 0;
+    }
+
+    public getQuads(): Quad[] {
+        return this.quads.slice(0);
+    }
+
+    public addQuads(quads: Quad[]): void {
+        this.quads.push(...quads);
+    }
+
+    public statements(subject?: string, predicate?: string, object?: string): Quad[] {
+        return this.quads.filter(
+            statement =>
+                (!object || statement.object.value === this.expandIRI(object)) &&
+                (!subject || statement.subject.value === this.expandIRI(subject)) &&
+                (!predicate || statement.predicate.value === this.expandIRI(predicate)),
+        );
+    }
+
+    public statement(subject?: string, predicate?: string, object?: string): Quad | null {
+        const statement = this.quads.find(
+            statement =>
+                (!object || statement.object.value === this.expandIRI(object)) &&
+                (!subject || statement.subject.value === this.expandIRI(subject)) &&
+                (!predicate || statement.predicate.value === this.expandIRI(predicate)),
+        );
+
+        return statement ?? null;
+    }
+
+    public contains(subject: string, predicate?: string, object?: string): boolean {
+        return this.statement(subject, predicate, object) !== null;
+    }
+
+    public getThing(subject: string): SolidThing {
+        const statements = this.statements(subject);
+
+        return new SolidThing(subject, statements);
+    }
+
+    protected expandIRI(iri: string): string {
+        return expandIRI(iri);
+    }
+
+}

package/src/models/index.ts

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

package/src/plugins/chai/assertions.ts

@@ -1,4 +1,4 @@
-import { sparqlEquals } from '@/helpers/testing';
+import { sparqlEquals, turtleEquals } from '@/helpers/testing';
 
 type CustomAssertions = {
     [assertion in keyof typeof assertions]: typeof assertions[assertion];
@@ -17,6 +17,15 @@ declare global {
 }
 
 const assertions: Record<string, (this: Chai.AssertionStatic, ...args: any[]) => void> = {
+    turtle(graph: string): void {
+        const self = this as unknown as Chai.AssertionStatic;
+        const actual = self._obj;
+        const assert = self.assert.bind(this);
+        const expected = graph;
+        const result = turtleEquals(expected, actual);
+
+        assert(result.success, result.message, '', result.expected, result.actual);
+    },
     sparql(query: string): void {
         const self = this as unknown as Chai.AssertionStatic;
         const actual = self._obj;
@@ -24,7 +33,7 @@ const assertions: Record<string, (this: Chai.AssertionStatic, ...args: any[]) =>
         const expected = query;
         const result = sparqlEquals(expected, actual);
 
-        assert(result.success, result.message, expected, actual);
+        assert(result.success, result.message, '', result.expected, result.actual);
     },
 };
 

package/src/plugins/cypress/types.d.ts

@@ -7,6 +7,7 @@ declare global {
         // TODO generate automatically
         interface Chainer<Subject> {
             (chainer: 'be.sparql', update: string): Cypress.Chainable<Subject>;
+            (chainer: 'be.turtle', graph: string): Cypress.Chainable<Subject>;
         }
 
     }

package/src/plugins/jest/matchers.ts

@@ -1,41 +1,54 @@
-import diff from 'jest-diff';
-
 import { normalizeSparql } from '@/helpers/io';
-import { sparqlEquals } from '@/helpers/testing';
+import { jsonldEquals, sparqlEquals } from '@/helpers/testing';
+import type { EqualityResult } from '@/helpers/testing';
+
+interface FormatResultOptions {
+    context: jest.MatcherContext;
+    hint: string;
+    expected: unknown;
+    received: unknown;
+}
+
+function formatResult(result: EqualityResult, options: FormatResultOptions) {
+    const pass = result.success;
+    const utils = options.context.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 };
+}
 
 const matchers: jest.ExpectExtendMap = {
+    async toEqualJsonLD(received, expected) {
+        const result = await jsonldEquals(expected, received);
+
+        return formatResult(result, {
+            context: this,
+            hint: 'toEqualJsonLD',
+            expected,
+            received,
+        });
+    },
     toEqualSparql(received, expected) {
         const result = sparqlEquals(expected, received);
-        const pass = result.success;
-        const normalizedReceived = normalizeSparql(received);
-        const normalizedExpected = normalizeSparql(expected);
-        const message = pass
-            ? () => [
-                result.message,
-                this.utils.matcherHint('toEqualSparql'),
-                [
-                    `Expected: not ${this.utils.printExpected(normalizedExpected)}`,
-                    `Received: ${this.utils.printReceived(normalizedReceived)}`,
-                ].join('\n'),
-            ].join('\n\n')
-            : () => {
-                const diffString = diff(normalizedExpected, normalizedReceived, {
-                    expand: this.expand,
-                });
-
-                return [
-                    result.message,
-                    this.utils.matcherHint('toEqualJsonLD'),
-                    diffString && diffString.includes('- Expect')
-                        ? `Difference:\n\n${diffString}`
-                        : [
-                            `Expected: ${this.utils.printExpected(normalizedExpected)}`,
-                            `Received: ${this.utils.printReceived(normalizedReceived)}`,
-                        ].join('\n'),
-                ].join('\n\n');
-            };
 
-        return { pass, message };
+        return formatResult(result, {
+            context: this,
+            hint: 'toEqualSparql',
+            expected: normalizeSparql(expected),
+            received: normalizeSparql(received),
+        });
     },
 };
 

package/src/plugins/jest/types.d.ts

@@ -5,6 +5,7 @@ declare global {
         // TODO generate automatically
         interface Matchers<R> {
             toEqualSparql(sparql: string): R;
+            toEqualJsonLD(jsonld: JsonLD): Promise<R>;
         }
 
     }

package/src/testing/ResponseStub.ts

@@ -0,0 +1,46 @@
+export default class ResponseStub implements Response {
+
+    private rawBody: string;
+
+    public readonly body!: ReadableStream<Uint8Array> | null;
+    public readonly bodyUsed!: boolean;
+    public readonly headers: Headers;
+    public readonly ok!: boolean;
+    public readonly redirected!: boolean;
+    public readonly status: number;
+    public readonly statusText!: string;
+    public readonly trailer!: Promise<Headers>;
+    public readonly type!: ResponseType;
+    public readonly url!: string;
+
+    public constructor(rawBody: string = '', headers: Record<string, string> = {}, status: number = 200) {
+        this.rawBody = rawBody;
+        this.headers = new Headers(headers);
+        this.status = status;
+    }
+
+    public async arrayBuffer(): Promise<ArrayBuffer> {
+        throw new Error('ResponseStub.arrayBuffer is not implemented');
+    }
+
+    public async blob(): Promise<Blob> {
+        throw new Error('ResponseStub.blob is not implemented');
+    }
+
+    public async formData(): Promise<FormData> {
+        throw new Error('ResponseStub.formData is not implemented');
+    }
+
+    public async json(): Promise<unknown> {
+        return JSON.parse(this.rawBody);
+    }
+
+    public async text(): Promise<string> {
+        return this.rawBody;
+    }
+
+    public clone(): Response {
+        return { ...this };
+    }
+
+}

package/src/testing/faking.ts

@@ -0,0 +1,36 @@
+import { faker } from '@faker-js/faker';
+import { stringToSlug } from '@noeldemartin/utils';
+
+export interface ContainerOptions {
+    baseUrl: string;
+}
+
+export interface DocumentOptions extends ContainerOptions {
+    containerUrl: string;
+    name: string;
+}
+
+export interface ResourceOptions extends DocumentOptions {
+    documentUrl: string;
+    hash: string;
+}
+
+export function fakeContainerUrl(options: Partial<ContainerOptions> = {}): string {
+    const baseUrl = options.baseUrl ?? faker.internet.url();
+
+    return baseUrl.endsWith('/') ? baseUrl : baseUrl + '/';
+}
+
+export function fakeDocumentUrl(options: Partial<DocumentOptions> = {}): string {
+    const containerUrl = options.containerUrl ?? fakeContainerUrl(options);
+    const name = options.name ?? faker.random.word();
+
+    return containerUrl + stringToSlug(name);
+}
+
+export function fakeResourceUrl(options: Partial<ResourceOptions> = {}): string {
+    const documentUrl = options.documentUrl ?? fakeDocumentUrl(options);
+    const hash = options.hash ?? 'it';
+
+    return documentUrl + '#' + hash;
+}

package/src/testing/index.ts

@@ -0,0 +1,3 @@
+export * from './faking';
+export * from './mocking';
+export { default as ResponseStub } from './ResponseStub';

package/src/testing/mocking.ts

@@ -0,0 +1,34 @@
+import { fail } from '@noeldemartin/utils';
+import type { GetClosureArgs, GetClosureResult } from '@noeldemartin/utils';
+
+import type { Fetch } from '@/helpers/io';
+
+import ResponseStub from './ResponseStub';
+
+export interface FetchMockMethods {
+    mockResponse(body?: string, headers?: Record<string, string>, status?: number): void;
+    mockNotFoundResponse(): void;
+}
+
+export type FetchMock = jest.Mock<GetClosureResult<Fetch>, GetClosureArgs<Fetch>> & Fetch & FetchMockMethods;
+
+export function mockFetch(): FetchMock {
+    const responses: ResponseStub[] = [];
+    const methods: FetchMockMethods = {
+        mockResponse(body, headers, status) {
+            responses.push(new ResponseStub(body, headers, status));
+        },
+        mockNotFoundResponse() {
+            responses.push(new ResponseStub('', {}, 404));
+        },
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const fetchMock = jest.fn(async (...args: GetClosureArgs<Fetch>) => {
+        return responses.shift() ?? fail<Response>('fetch mock called without response');
+    });
+
+    Object.assign(fetchMock, methods);
+
+    return fetchMock as FetchMock;
+}

package/src/types/n3.d.ts

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