@aerogel/plugin-local-first 0.0.0 → 0.1.0

package/src/lib/mirroring.ts

@@ -5,18 +5,18 @@ import {
     requireUrlParentDirectory,
     required,
     tap,
-    toString,
     urlResolveDirectory,
     urlRoute,
 } from '@noeldemartin/utils';
 import { App } from '@aerogel/core';
 import { getTrackedModels, trackModelsCollection as trackSoukaiModelsCollection } from '@aerogel/plugin-soukai';
 import { Solid } from '@aerogel/plugin-solid';
-import { PropertyOperation, SolidContainer, SolidContainsRelation, Tombstone } from 'soukai-solid';
+import { PropertyOperation, SolidContainer, SolidContainsRelation, Tombstone, isContainerClass } from 'soukai-solid';
 import type { ObjectsMap } from '@noeldemartin/utils';
 import type { Attributes } from 'soukai';
-import type { SolidModel, SolidModelConstructor, SolidSchemaDefinition } from 'soukai-solid';
+import type { Operation, SolidModel, SolidModelConstructor, SolidSchemaDefinition } from 'soukai-solid';
 
+import DocumentsCache from '@aerogel/plugin-local-first/services/DocumentsCache';
 import SyncQueue from '@aerogel/plugin-local-first/lib/SyncQueue';
 import { getContainerRelations, getRelatedAppModels } from '@aerogel/plugin-local-first/lib/inference';
 
@@ -88,6 +88,10 @@ export async function trackModelsCollection(modelClass: SolidModelConstructor, c
         [modelClass.modelName]: (Cloud.modelCollections[modelClass.modelName] ?? []).concat(collection),
     });
 
+    if (!Cloud.modelCollections[modelClass.modelName]?.includes(modelClass.collection)) {
+        modelClass.collection = collection;
+    }
+
     await trackSoukaiModelsCollection(modelClass, collection);
 }
 
@@ -107,24 +111,24 @@ export async function updateRemoteModel(localModel: SolidModel): Promise<void> {
             },
     });
 
+    await DocumentsCache.forget(localModel.requireDocumentUrl());
+
     if (Cloud.autoPush && Cloud.ready && !Cloud.syncing) {
         SyncQueue.push(localModel);
     }
 }
 
-export function clearLocalModelUpdates(models?: SolidModel[], malformedDocuments?: Set<string>): void {
-    const syncedModelUrls = models?.map((model) => toString(model.getDeletedPrimaryKey() ?? model.getPrimaryKey()));
+export function clearLocalModelUpdates(syncedModelUrls: Set<string>, documentsWithErrors?: Set<string>): void {
     const localModelUpdates = {} as Record<string, number>;
+    const syncedModelUrlsArray = Array.from(syncedModelUrls);
 
     for (const [url, count] of Object.entries(Cloud.localModelUpdates)) {
         const documentUrl = urlRoute(url);
         const wasSynced =
-            !syncedModelUrls ||
-            syncedModelUrls.some(
-                (modelUrl) => url === modelUrl || (modelUrl.endsWith('/') && url.startsWith(modelUrl)),
-            );
+            syncedModelUrls.has(url) ||
+            syncedModelUrlsArray.some((modelUrl) => modelUrl.endsWith('/') && url.startsWith(modelUrl));
 
-        if (wasSynced && !malformedDocuments?.has(documentUrl)) {
+        if (wasSynced && !documentsWithErrors?.has(documentUrl)) {
             continue;
         }
 
@@ -177,24 +181,27 @@ export function cloneRemoteModel(remoteModel: SolidModel): SolidModel {
 export async function completeRemoteModels(
     localModels: SolidModel[],
     remoteModels: SolidModel[],
-    malformedDocuments: Set<string>,
+    documentsWithErrors: Set<string>,
 ): Promise<SolidModel[]> {
     const RemoteTombstone = getRemoteClass(Tombstone);
     const remoteModelUrls = remoteModels.map((remoteModel) => remoteModel.url);
     const missingModelDocumentUrls = localModels
         .filter((localModel) => !remoteModelUrls.includes(localModel.url))
         .map((localModel) => localModel.requireDocumentUrl())
-        .filter((documentUrl) => !malformedDocuments.has(documentUrl));
+        .filter((documentUrl) => !documentsWithErrors.has(documentUrl));
     const tombstones = await RemoteTombstone.all({ $in: missingModelDocumentUrls });
 
     return remoteModels.concat(tombstones);
 }
 
 export function ignoreModelUpdates(localModel: SolidModel): boolean {
-    const updatedAt = localModel.metadata.updatedAt?.getTime();
+    const documentModels = localModel.getDocumentModels();
+    const documentOperations = documentModels.flatMap(
+        (model) => model.operations?.map((operation) => [model, operation] as [SolidModel, Operation]) ?? [],
+    );
 
-    return !localModel.operations.some((operation) => {
-        if (operation.date.getTime() !== updatedAt) {
+    return !documentOperations.some(([model, operation]) => {
+        if (operation.date.getTime() !== model.metadata?.updatedAt?.getTime()) {
             return false;
         }
 
@@ -202,7 +209,7 @@ export function ignoreModelUpdates(localModel: SolidModel): boolean {
             return true;
         }
 
-        return !localModel.ignoreRdfPropertyHistory(operation.property, true);
+        return !model.ignoreRdfPropertyHistory(operation.property, true);
     });
 }
 
@@ -211,7 +218,9 @@ export function getLocalModel(remoteModel: SolidModel, localModels: ObjectsMap<S
 }
 
 export function getLocalModels(): SolidModel[] {
-    return [...Cloud.registeredModels].map(({ modelClass }) => getTrackedModels(modelClass)).flat();
+    return [...Cloud.registeredModels]
+        .map(({ modelClass }) => getTrackedModels(modelClass, { includeSoftDeleted: true }))
+        .flat();
 }
 
 export function getSchemaMigrations(): Map<SolidModelConstructor, SolidModelConstructor | SolidSchemaDefinition> {
@@ -232,12 +241,27 @@ export function getRemoteClass<T extends SolidModelConstructor>(localClass: T):
     return (remoteClasses.get(localClass) as T) ?? makeRemoteClass(localClass);
 }
 
-export function getRemoteContainersCollection(path?: string): string {
+export function getRemoteContainersCollection(modelClass: SolidModelConstructor, path?: string): string {
     const rootStorage = Solid.requireUser().storageUrls[0];
+    const containedClass =
+        isContainerClass(modelClass) &&
+        getContainerRelations(modelClass)
+            .map((relation) => {
+                const relatedClass = modelClass
+                    .instance()
+                    .requireRelation<SolidContainsRelation>(relation).relatedClass;
+
+                if (isContainerClass(relatedClass)) {
+                    return null;
+                }
+
+                return relatedClass;
+            })
+            .filter(Boolean)[0];
+
+    path ??= `/${(containedClass || modelClass).modelName.toLowerCase()}s/`;
 
-    return path
-        ? urlResolveDirectory((path.startsWith('/') ? rootStorage.slice(0, -1) : rootStorage) + path)
-        : rootStorage;
+    return urlResolveDirectory((path.startsWith('/') ? rootStorage.slice(0, -1) : rootStorage) + path);
 }
 
 export function getRemoteModel(localModel: SolidModel, remoteModels: ObjectsMap<SolidModel>): SolidModel {

package/src/services/Cloud.ts

@@ -6,13 +6,15 @@ import {
     getLocationQueryParameter,
     hasLocationQueryParameter,
     isArray,
+    isTesting,
     parseBoolean,
 } from '@noeldemartin/utils';
-import { App, Errors, Events, dispatch, translateWithDefault } from '@aerogel/core';
+import { Errors, Events, dispatch, translateWithDefault } from '@aerogel/core';
 import { Solid } from '@aerogel/plugin-solid';
-import { SolidModel, Tombstone, isContainer, isContainerClass } from 'soukai-solid';
+import { SolidContainer, SolidModel, Tombstone, isContainer, isContainerClass, isSolidModel } from 'soukai-solid';
 import { getTrackedModels, trackModels, trackModelsCollection } from '@aerogel/plugin-soukai';
 import { watchEffect } from 'vue';
+import { getBootedModels } from 'soukai';
 import type { Authenticator } from '@aerogel/plugin-solid';
 import type { Engine } from 'soukai';
 import type { JobListener } from '@aerogel/core';
@@ -27,6 +29,7 @@ import {
     updateRemoteModel,
 } from '@aerogel/plugin-local-first/lib/mirroring';
 import Backup from '@aerogel/plugin-local-first/jobs/Backup';
+import DocumentsCache from '@aerogel/plugin-local-first/services/DocumentsCache';
 import Migrate from '@aerogel/plugin-local-first/jobs/Migrate';
 import Sync from '@aerogel/plugin-local-first/jobs/Sync';
 import SyncQueue from '@aerogel/plugin-local-first/lib/SyncQueue';
@@ -43,9 +46,10 @@ export interface RegisterOptions {
 }
 
 export interface SyncOptions extends JobListener {
-    refreshUserProfile?: boolean;
     model?: SolidModel;
     models?: SolidModel[];
+    refreshUserProfile?: boolean;
+    syncDirty?: boolean;
 }
 
 export class CloudService extends Service {
@@ -116,8 +120,8 @@ export class CloudService extends Service {
         }
 
         await this.asyncLock.run(async () => {
+            let models = options.model ? [options.model] : options.models;
             const start = Date.now();
-            const models = options.model ? [options.model] : options.models;
 
             this.syncError = null;
             this.status = CloudStatus.Syncing;
@@ -131,23 +135,33 @@ export class CloudService extends Service {
                     await Solid.refreshUserProfile();
                 }
 
-                this.syncJob = new Sync(models);
+                const syncDirty = options.syncDirty ?? true;
+                let syncs = 0;
 
-                this.syncJob.listeners.add(options);
+                do {
+                    this.syncJob = new Sync(models);
 
-                await dispatch(this.syncJob);
+                    this.syncJob.listeners.add(options);
 
-                if (this.syncJob.cancelled) {
-                    return;
-                }
+                    await dispatch(this.syncJob);
 
-                if (!App.testing) {
+                    if (this.syncJob.cancelled) {
+                        return;
+                    }
+
+                    syncs++;
+                    models = this.getDirtyLocalModels().filter(
+                        (model) => !this.syncJob?.documentsWithErrors.has(model.requireDocumentUrl()),
+                    );
+                } while (syncDirty && models.length > 0 && syncs < 3);
+
+                if (!isTesting('unit')) {
                     await after({ milliseconds: Math.max(500, 1000 - (Date.now() - start)) });
                 }
 
                 this.syncJob = null;
             } catch (error) {
-                if (App.testing) {
+                if (isTesting()) {
                     throw error;
                 }
 
@@ -226,17 +240,18 @@ export class CloudService extends Service {
         }
 
         this.whenReady(() => {
-            if (!isContainerClass(modelClass)) {
-                return;
-            }
+            const [existingCollection] = this.modelCollections[modelClass.modelName] ?? [];
 
-            modelClass.collection = getRemoteContainersCollection(options.path);
+            modelClass.useSoftDeletes(true);
+
+            modelClass.collection = existingCollection ?? getRemoteContainersCollection(modelClass, options.path);
         });
 
         await trackModels(modelClass, {
-            created: (model) => createRemoteModel(model),
-            updated: (model) => updateRemoteModel(model),
-            deleted: (model) => clearLocalModelUpdates([model]),
+            created: (model) => this.ready && createRemoteModel(model),
+            updated: (model) => this.ready && updateRemoteModel(model),
+            deleted: (model) =>
+                this.ready && clearLocalModelUpdates(new Set([model.url ?? model.getDeletedPrimaryKey()])),
         });
 
         if (isContainerClass(modelClass)) {
@@ -245,9 +260,13 @@ export class CloudService extends Service {
                     .instance()
                     .requireRelation<SolidContainsRelation>(relation).relatedClass;
 
-                relatedClass.on('created', (model) => createRemoteModel(model));
-                relatedClass.on('updated', (model) => updateRemoteModel(model));
-                relatedClass.on('deleted', (model) => clearLocalModelUpdates([model]));
+                relatedClass.on('created', (model) => this.ready && createRemoteModel(model));
+                relatedClass.on('updated', (model) => this.ready && updateRemoteModel(model));
+                relatedClass.on(
+                    'deleted',
+                    (model) =>
+                        this.ready && clearLocalModelUpdates(new Set([model.url ?? model.getDeletedPrimaryKey()])),
+                );
             });
         }
 
@@ -271,7 +290,7 @@ export class CloudService extends Service {
                 continue;
             }
 
-            return getRemoteContainersCollection(registration.path);
+            return getRemoteContainersCollection(registration.modelClass, registration.path);
         }
 
         throw new Error(`Failed resolving remote collection for '${modelClass.modelName}' model`);
@@ -298,6 +317,9 @@ export class CloudService extends Service {
 
             this.pollingInterval = setInterval(() => this.sync(), this.pollingMinutes * 60 * 1000);
         });
+
+        await this.bustDocumentsCache();
+        await this.registerModels();
     }
 
     protected getDirtyLocalModels(): SolidModel[] {
@@ -305,7 +327,7 @@ export class CloudService extends Service {
         const dirtyLocalModels = [];
 
         for (const { modelClass } of this.registeredModels) {
-            for (const model of getTrackedModels(modelClass)) {
+            for (const model of getTrackedModels(modelClass, { includeSoftDeleted: true })) {
                 dirtyLocalModels.push(...this.getModelsIn(urls, model));
             }
         }
@@ -362,7 +384,7 @@ export class CloudService extends Service {
             }
 
             const localCollection = modelClass.collection;
-            const remoteCollection = getRemoteContainersCollection(path);
+            const remoteCollection = getRemoteContainersCollection(modelClass, path);
 
             modelClass.collection = remoteCollection;
 
@@ -398,6 +420,8 @@ export class CloudService extends Service {
         this.status = CloudStatus.Online;
         this.engine = authenticator.engine;
 
+        getRemoteClass(SolidContainer).setEngine(this.engine);
+
         for (const relatedClass of relatedClasses) {
             getRemoteClass(relatedClass).setEngine(this.engine);
         }
@@ -405,6 +429,7 @@ export class CloudService extends Service {
 
     protected logout(): void {
         this.setState({
+            autoPush: true,
             localModelUpdates: {},
             migrationDismissed: false,
             migrationJob: null,
@@ -413,10 +438,13 @@ export class CloudService extends Service {
             pollingEnabled: true,
             pollingMinutes: 10,
             ready: false,
+            schemaMigrations: new Map(),
             setupDismissed: false,
             setupOngoing: false,
             startupSync: true,
             status: CloudStatus.Disconnected,
+            syncError: null,
+            syncJob: null,
         });
     }
 
@@ -432,6 +460,30 @@ export class CloudService extends Service {
         return this.startupSync;
     }
 
+    private async bustDocumentsCache(): Promise<void> {
+        if (
+            !hasLocationQueryParameter('bustDocumentsCache') ||
+            !parseBoolean(getLocationQueryParameter('bustDocumentsCache'))
+        ) {
+            return;
+        }
+
+        await DocumentsCache.booted;
+        await DocumentsCache.clear();
+    }
+
+    private async registerModels(): Promise<void> {
+        const models = getBootedModels();
+
+        for (const model of models.values()) {
+            if (!isSolidModel(model) || !model.cloud) {
+                continue;
+            }
+
+            await this.register(model, typeof model.cloud === 'boolean' ? {} : model.cloud);
+        }
+    }
+
 }
 
 export default facade(CloudService);
@@ -448,3 +500,10 @@ declare module '@aerogel/core' {
         'cloud:sync-completed': SolidModel[] | undefined;
     }
 }
+
+declare module 'soukai-solid' {
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    namespace SolidModel {
+        export const cloud: boolean | RegisterOptions | undefined;
+    }
+}

package/src/services/DocumentsCache.ts

@@ -1,9 +1,9 @@
-import { Events, Service } from '@aerogel/core';
+import { Events, Service, appNamespace } from '@aerogel/core';
 import { IndexedDBMap, facade } from '@noeldemartin/utils';
 
 export class DocumentsCacheService extends Service {
 
-    private cache = new IndexedDBMap<{ modifiedAt: number }>('documents-cache');
+    private cache = new IndexedDBMap<{ modifiedAt: number }>(`${appNamespace()}-documents-cache`);
 
     public async isFresh(documentUrl: string, modifiedAt: Date | number): Promise<boolean> {
         const meta = await this.cache.get(documentUrl);
@@ -22,6 +22,10 @@ export class DocumentsCacheService extends Service {
         await this.cache.delete(documentUrl);
     }
 
+    public async clear(): Promise<void> {
+        await this.cache.clear();
+    }
+
     protected override async boot(): Promise<void> {
         Events.on('auth:logout', async () => {
             await this.cache.clear();

package/src/testing/cloud.ts

@@ -128,7 +128,7 @@ export function containerResponse(
     `);
 }
 
-export function movieResponse(title: string): Response {
+export function movieResponse(title: string = 'Spirited Away'): Response {
     return FakeResponse.success(`
         @prefix schema: <https://schema.org/>.
         @prefix xsd: <http://www.w3.org/2001/XMLSchema#>.

package/src/testing/setup.ts

@@ -1,12 +1,13 @@
 import 'fake-indexeddb/auto';
 
-import { installVitestSolidMatchers } from '@noeldemartin/solid-utils/testing';
-import { FakeLocalStorage, FakeServer, setupFacadeMocks } from '@noeldemartin/testing';
+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');

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/dist/InruptAuthenticator.lazy-BvpQLGoj-BvpQLGoj.js

@@ -1,9 +0,0 @@
-import { events as n, fetch as t, handleIncomingRedirect as c, login as g, logout as i } from "@inrupt/solid-client-authn-browser";
-export {
-  n as events,
-  t as fetch,
-  c as handleIncomingRedirect,
-  g as login,
-  i as logout
-};
-//# sourceMappingURL=InruptAuthenticator.lazy-BvpQLGoj-BvpQLGoj.js.map

package/dist/InruptAuthenticator.lazy-BvpQLGoj-BvpQLGoj.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"InruptAuthenticator.lazy-BvpQLGoj-BvpQLGoj.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/LegacyAuthenticator.lazy-ChFFqP14-ChFFqP14.js

@@ -1,5 +0,0 @@
-import { default as l } from "solid-auth-client";
-export {
-  l as SolidAuthClient
-};
-//# sourceMappingURL=LegacyAuthenticator.lazy-ChFFqP14-ChFFqP14.js.map

package/dist/LegacyAuthenticator.lazy-ChFFqP14-ChFFqP14.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"LegacyAuthenticator.lazy-ChFFqP14-ChFFqP14.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/src/components/AGCloudStatus.vue

@@ -1,31 +0,0 @@
-<template>
-    <AGSolidStatus>
-        <template #logged-in="{ session }: IAGSolidStatusLoggedInSlotProps">
-            <AGMarkdown v-if="$cloud.syncing" :text="$td('cloud.syncing', 'Syncing...')" />
-            <div v-else class="flex flex-col gap-3">
-                <AGMarkdown
-                    :text="
-                        $td('solid.loggedIn', 'You are logged in as [{userName}]({userWebId})', {
-                            userName: session.user.name ?? session.user.webId,
-                            userWebId: session.user.webId,
-                        })
-                    "
-                />
-                <AGButton @click="$cloud.sync(), $emit('sync')">
-                    {{ $td('cloud.sync', 'Synchronize') }}
-                </AGButton>
-                <AGButton @click="$solid.logout()">
-                    {{ $td('solid.logout', 'Logout') }}
-                </AGButton>
-            </div>
-        </template>
-    </AGSolidStatus>
-</template>
-
-<script setup lang="ts">
-import { AGButton, AGMarkdown } from '@aerogel/core';
-import { AGSolidStatus } from '@aerogel/plugin-solid';
-import type { IAGSolidStatusLoggedInSlotProps } from '@aerogel/plugin-solid';
-
-defineEmits(['sync']);
-</script>