@aerogel/plugin-local-first 0.0.0-next.004d5deedf15bedf609a660bfd4543d3c0df9d9d

package/src/testing/cloud.ts

@@ -0,0 +1,193 @@
+import { App } from '@aerogel/core';
+import { bootSolidModels } from 'soukai-solid';
+import { uuid } from '@noeldemartin/utils';
+import { InMemoryEngine, bootModels, resetModelListeners, setEngine } from 'soukai';
+import { it } from 'vitest';
+import { resetTrackedModels } from '@aerogel/plugin-soukai';
+import { Solid } from '@aerogel/plugin-solid';
+import type { App as AppInstance } from 'vue';
+
+import Cloud from '@aerogel/plugin-local-first/services/Cloud';
+
+import Movie from '@aerogel/plugin-local-first/testing/stubs/Movie';
+import MoviesContainer from '@aerogel/plugin-local-first/testing/stubs/MoviesContainer';
+import SolidMock from '@aerogel/plugin-local-first/testing/mocks/Solid.mock';
+import Task from '@aerogel/plugin-local-first/testing/stubs/Task';
+import TaskSchema from '@aerogel/plugin-local-first/testing/stubs/Task.schema';
+import TasksList from '@aerogel/plugin-local-first/testing/stubs/TasksList';
+import Workspace from '@aerogel/plugin-local-first/testing/stubs/Workspace';
+import { FakeResponse, mock } from '@noeldemartin/testing';
+
+export async function setupCloudTests(): Promise<void> {
+    bootSolidModels();
+    bootModels({ Movie, MoviesContainer, Task, TasksList, Workspace });
+    setEngine(new InMemoryEngine());
+    resetTrackedModels();
+    resetModelListeners();
+
+    await Task.updateSchema(TaskSchema);
+
+    App.instance = mock<AppInstance>({ config: { globalProperties: { $cloud: Cloud } } });
+
+    Solid.mock();
+    Cloud.reset();
+}
+
+export function testVariants<T, Variants extends Record<string, T>>(
+    description: string,
+    variants: Variants,
+    test: (variantData: T, variantName: keyof Variants) => unknown,
+    options: { skip?: boolean; only?: boolean | keyof Variants } = {},
+): void {
+    const only = typeof options.only === 'string' ? [options.only] : options.only ? Object.keys(variants) : [];
+    const skip = typeof options.skip === 'string' ? [options.skip] : options.skip ? Object.keys(variants) : [];
+
+    for (const [name, data] of Object.entries(variants)) {
+        if (only.includes(name)) {
+            it.only(`[${name}] ${description}`, () => test(data, name));
+
+            continue;
+        }
+
+        if (skip.includes(name)) {
+            it.skip(`[${name}] ${description}`, () => test(data, name));
+
+            continue;
+        }
+
+        it(`[${name}] ${description}`, () => test(data, name));
+    }
+}
+
+export function testRegisterVariants(
+    description: string,
+    test: (registerModels: () => unknown, variant: 'model registration' | 'container registration') => unknown,
+    options: { skip?: boolean; only?: boolean | 'model registration' | 'container registration' } = {},
+): void {
+    testVariants(
+        description,
+        {
+            'model registration': () => Cloud.register(Movie),
+            'container registration': () => Cloud.register(MoviesContainer),
+        },
+        test,
+        options,
+    );
+}
+
+export function typeIndexResponse(containers?: Record<string, string>): Response {
+    const typeIndexUrl = SolidMock.requireUser().privateTypeIndexUrl ?? '';
+    const registrations = Object.entries(containers ?? []).map(
+        ([containerUrl, forClass]) => `
+            <#${uuid()}>
+                a solid:TypeRegistration ;
+                solid:forClass ${forClass} ;
+                solid:instanceContainer <${containerUrl}> .
+        `,
+    );
+
+    return FakeResponse.success(`
+        @prefix solid: <http://www.w3.org/ns/solid/terms#>.
+
+        <${typeIndexUrl}> a solid:TypeIndex .
+
+        ${registrations.join('\n')}
+    `);
+}
+
+export function containerResponse(
+    options: { name?: string; documentUrls?: string[]; createdAt?: Date; updatedAt?: Date; append?: string } = {},
+): Response {
+    const name = options.name ?? 'Movies';
+    const documentUrls = options.documentUrls ?? [];
+    const createdAt = options.createdAt ?? new Date();
+    const updatedAt = options.updatedAt ?? new Date();
+
+    return FakeResponse.success(`
+        @prefix dc: <http://purl.org/dc/terms/>.
+        @prefix ldp: <http://www.w3.org/ns/ldp#>.
+        @prefix posix: <http://www.w3.org/ns/posix/stat#>.
+        @prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
+        @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
+        @prefix crdt: <https://vocab.noeldemartin.com/crdt/>.
+
+        <./> a ldp:Container, ldp:BasicContainer, ldp:Resource;
+            rdfs:label "${name}";
+            dc:created "2024-02-05T12:28:42Z"^^xsd:dateTime;
+            dc:modified "2024-02-05T12:28:42Z"^^xsd:dateTime;
+            ${documentUrls.length > 0 ? `ldp:contains ${documentUrls.map((url) => `<${url}>`).join(',')};` : ''}
+            posix:mtime 1707136122.
+
+        <./#metadata>
+            a crdt:Metadata ;
+            crdt:resource <./> ;
+            crdt:createdAt "${createdAt.toISOString()}"^^xsd:dateTime ;
+            crdt:updatedAt "${updatedAt.toISOString()}"^^xsd:dateTime .
+
+        ${options.append ?? ''}
+    `);
+}
+
+export function movieResponse(title: string = 'Spirited Away'): Response {
+    return FakeResponse.success(`
+        @prefix schema: <https://schema.org/>.
+        @prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
+        @prefix crdt: <https://vocab.noeldemartin.com/crdt/> .
+
+        <#it>
+            a schema:Movie;
+            schema:datePublished "2001-07-20T00:00:00Z"^^xsd:dateTime;
+            schema:name "${title}".
+
+        <#it-metadata> a crdt:Metadata;
+            crdt:resource <#it>;
+            crdt:createdAt "2024-02-10T00:00:00Z"^^xsd:dateTime;
+            crdt:updatedAt "2024-02-10T00:00:00Z"^^xsd:dateTime.
+    `);
+}
+
+export function taskResponse(name?: string): Response {
+    return FakeResponse.success(`
+        @prefix schema: <https://schema.org/>.
+        @prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
+        @prefix crdt: <https://vocab.noeldemartin.com/crdt/> .
+
+        <#it>
+            a schema:Action;
+            schema:name "${name ?? 'Task'}".
+
+        <#it-metadata> a crdt:Metadata;
+            crdt:resource <#it>;
+            crdt:createdAt "2024-02-10T00:00:00Z"^^xsd:dateTime;
+            crdt:updatedAt "2024-02-10T00:00:00Z"^^xsd:dateTime.
+    `);
+}
+
+export function legacyTaskResponse(name?: string): Response {
+    return FakeResponse.success(`
+        @prefix ical: <http://www.w3.org/2002/12/cal/ical#>.
+        @prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
+        @prefix crdt: <https://vocab.noeldemartin.com/crdt/> .
+
+        <#it>
+            a ical:Vtodo;
+            ical:summary "${name ?? 'Task'}".
+
+        <#it-metadata> a crdt:Metadata;
+            crdt:resource <#it>;
+            crdt:createdAt "2024-02-10T00:00:00Z"^^xsd:dateTime;
+            crdt:updatedAt "2024-02-10T00:00:00Z"^^xsd:dateTime.
+    `);
+}
+
+export function tombstoneResponse(): Response {
+    return FakeResponse.success(`
+        @prefix crdt: <https://vocab.noeldemartin.com/crdt/> .
+        @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+        <#it-metadata>
+            a crdt:Tombstone ;
+            crdt:resource <#it> ;
+            crdt:deletedAt  "2025-03-03T00:00:00Z"^^xsd:dateTime .
+    `);
+}

package/src/testing/mocks/Solid.mock.ts

@@ -0,0 +1,34 @@
+import { FakeServer, fakeContainerUrl, fakeDocumentUrl, mock } from '@noeldemartin/testing';
+import { facade } from '@noeldemartin/utils';
+import { SolidACLAuthorization, SolidDocument, SolidEngine, SolidTypeIndex } from 'soukai-solid';
+import { SolidService } from '@aerogel/plugin-solid';
+import type { AuthSession } from '@aerogel/plugin-solid';
+
+export class SolidMockService extends SolidService {
+
+    constructor() {
+        super();
+
+        const engine = new SolidEngine(FakeServer.fetch);
+
+        this.setState('session', {
+            user: mock({
+                privateTypeIndexUrl: fakeDocumentUrl(),
+                storageUrls: [fakeContainerUrl()],
+            }),
+            authenticator: mock({
+                engine,
+                requireAuthenticatedFetch: () => FakeServer.fetch,
+            }),
+        } as unknown as AuthSession);
+
+        SolidACLAuthorization.setEngine(engine);
+        SolidTypeIndex.setEngine(engine);
+        SolidDocument.setEngine(engine);
+
+        this.booted.resolve();
+    }
+
+}
+
+export default facade(SolidMockService);

package/src/testing/setup.ts

@@ -0,0 +1,33 @@
+import 'fake-indexeddb/auto';
+
+import { installVitestSolidMatchers } from '@noeldemartin/solid-utils/vitest';
+import { FakeLocalStorage, FakeServer, mock, setupFacadeMocks } from '@noeldemartin/testing';
+import { resetAsyncMemo } from '@noeldemartin/utils';
+import { beforeEach, vi } from 'vitest';
+
+setupFacadeMocks();
+installVitestSolidMatchers();
+globalThis.location = mock<Location>({ href: 'https://example.com' });
+
+beforeEach(async () => {
+    const { Solid } = await import('@aerogel/plugin-solid');
+    const { default: SolidMock } = await import('./mocks/Solid.mock');
+    const { resetPiniaStore } = await import('@aerogel/core');
+    const { resetTrackedModels } = await import('@aerogel/plugin-soukai');
+
+    FakeLocalStorage.requireInstance().clear();
+    Solid.setMockFacade(SolidMock);
+    FakeServer.reset();
+
+    resetAsyncMemo();
+    resetPiniaStore();
+    resetTrackedModels();
+});
+
+vi.mock('@aerogel/core', async () => {
+    const original = (await vi.importActual('@aerogel/core')) as object;
+
+    FakeLocalStorage.patchGlobal();
+
+    return original;
+});

package/src/testing/stubs/LegacyTask.schema.ts

@@ -0,0 +1,15 @@
+import { FieldType } from 'soukai';
+import { defineSolidModelSchema } from 'soukai-solid';
+
+export default defineSolidModelSchema({
+    rdfContext: 'http://www.w3.org/2002/12/cal/ical#',
+    rdfsClass: 'Vtodo',
+    history: true,
+    tombstone: false,
+    fields: {
+        name: {
+            type: FieldType.String,
+            rdfProperty: 'summary',
+        },
+    },
+});

package/src/testing/stubs/Movie.schema.ts

@@ -0,0 +1,15 @@
+import { FieldType } from 'soukai';
+import { defineSolidModelSchema } from 'soukai-solid';
+
+export default defineSolidModelSchema({
+    rdfContext: 'https://schema.org/',
+    history: true,
+    tombstone: false,
+    fields: {
+        name: FieldType.String,
+        releaseDate: {
+            type: FieldType.Date,
+            rdfProperty: 'schema:datePublished',
+        },
+    },
+});

package/src/testing/stubs/Movie.ts

@@ -0,0 +1,3 @@
+import Model from './Movie.schema';
+
+export default class Movie extends Model {}

package/src/testing/stubs/MoviesContainer.ts

@@ -0,0 +1,20 @@
+import { SolidContainer } from 'soukai-solid';
+import type { Relation } from 'soukai';
+import type { SolidContainsRelation } from 'soukai-solid';
+
+import Movie from './Movie';
+
+export default class MoviesContainer extends SolidContainer {
+
+    public static override history = true;
+    public static override timestamps = true;
+    public static override tombstone = false;
+
+    declare public movies?: Movie[];
+    declare public relatedMovies: SolidContainsRelation<this, Movie, typeof Movie>;
+
+    public moviesRelationship(): Relation {
+        return this.contains(Movie);
+    }
+
+}

package/src/testing/stubs/Person.schema.ts

@@ -0,0 +1,9 @@
+import { FieldType } from 'soukai';
+import { defineSolidModelSchema } from 'soukai-solid';
+
+export default defineSolidModelSchema({
+    rdfContext: 'https://schema.org/',
+    fields: {
+        name: FieldType.String,
+    },
+});

package/src/testing/stubs/Person.ts

@@ -0,0 +1,18 @@
+import type { SolidHasManyRelation } from 'soukai-solid';
+import type { Relation } from 'soukai';
+
+import Model from './Person.schema';
+import Post from './Post';
+
+export default class Person extends Model {
+
+    public static override timestamps = false;
+
+    declare public posts?: Post[];
+    declare public relatedPosts: SolidHasManyRelation<Person, Post, typeof Post>;
+
+    public postsRelationship(): Relation {
+        return this.hasMany(Post, 'authorUrl');
+    }
+
+}

package/src/testing/stubs/Post.schema.ts

@@ -0,0 +1,17 @@
+import { FieldType } from 'soukai';
+import { defineSolidModelSchema } from 'soukai-solid';
+
+export default defineSolidModelSchema({
+    rdfContext: 'https://schema.org/',
+    rdfsClass: 'Article',
+    fields: {
+        title: {
+            type: FieldType.String,
+            rdfProperty: 'name',
+        },
+        authorUrl: {
+            type: FieldType.Key,
+            rdfProperty: 'author',
+        },
+    },
+});

package/src/testing/stubs/Post.ts

@@ -0,0 +1,18 @@
+import type { Relation } from 'soukai';
+import type { SolidBelongsToOneRelation } from 'soukai-solid';
+
+import Model from './Post.schema';
+import Person from './Person';
+
+export default class Post extends Model {
+
+    public static override timestamps = false;
+
+    declare public author?: Person;
+    declare public relatedAuthor: SolidBelongsToOneRelation<Post, Person, typeof Person>;
+
+    public authorRelationship(): Relation {
+        return this.belongsToOne(Person, 'authorUrl');
+    }
+
+}

package/src/testing/stubs/Task.schema.ts

@@ -0,0 +1,12 @@
+import { FieldType } from 'soukai';
+import { defineSolidModelSchema } from 'soukai-solid';
+
+export default defineSolidModelSchema({
+    rdfContext: 'https://schema.org/',
+    rdfsClass: 'Action',
+    history: true,
+    tombstone: false,
+    fields: {
+        name: FieldType.String,
+    },
+});

package/src/testing/stubs/Task.ts

@@ -0,0 +1,3 @@
+import Model from './Task.schema';
+
+export default class Task extends Model {}

package/src/testing/stubs/TasksList.ts

@@ -0,0 +1,20 @@
+import { SolidContainer } from 'soukai-solid';
+import type { Relation } from 'soukai';
+import type { SolidContainsRelation } from 'soukai-solid';
+
+import Task from './Task';
+
+export default class TasksList extends SolidContainer {
+
+    public static override history = true;
+    public static override timestamps = true;
+    public static override tombstone = false;
+
+    declare public tasks?: Task[];
+    declare public relatedTasks: SolidContainsRelation<this, Task, typeof Task>;
+
+    public tasksRelationship(): Relation {
+        return this.contains(Task);
+    }
+
+}

package/src/testing/stubs/Workspace.ts

@@ -0,0 +1,15 @@
+import type { Relation } from 'soukai';
+import type { SolidContainsRelation } from 'soukai-solid';
+
+import TasksList from './TasksList';
+
+export default class Workspace extends TasksList {
+
+    declare public lists?: TasksList[];
+    declare public relatedLists: SolidContainsRelation<this, TasksList, typeof TasksList>;
+
+    public listsRelationship(): Relation {
+        return this.contains(TasksList);
+    }
+
+}

package/src/types/shims.d.ts

@@ -0,0 +1,7 @@
+declare module '*.vue' {
+    import type { ComponentOptions } from 'vue';
+
+    const component: ComponentOptions;
+
+    export default component;
+}