@aerogel/plugin-local-first 0.0.0 → 0.1.0

package/src/jobs/Sync.ts

@@ -1,11 +1,21 @@
-import { App, Job } from '@aerogel/core';
-import { isInstanceOf, map, mixed, requireUrlParentDirectory, required, round } from '@noeldemartin/utils';
+import {
+    isInstanceOf,
+    map,
+    mixed,
+    requireUrlParentDirectory,
+    required,
+    round,
+    toString,
+    urlRoute,
+} from '@noeldemartin/utils';
+import { App, Errors, Job } from '@aerogel/core';
+import { InvalidModelAttributes, requireBootedModel } from 'soukai';
 import { MalformedSolidDocumentError } from '@noeldemartin/solid-utils';
 import { Solid } from '@aerogel/plugin-solid';
-import { SolidModel, Tombstone, isContainer, isContainerClass } from 'soukai-solid';
+import { SolidContainer, SolidModel, Tombstone, isContainer, isContainerClass } from 'soukai-solid';
 import type { ObjectsMap } from '@noeldemartin/utils';
 import type { JobListener, JobStatus } from '@aerogel/core';
-import type { SolidContainsRelation, SolidEngine, SolidTypeRegistration } from 'soukai-solid';
+import type { SolidContainsRelation, SolidEngine, SolidTypeIndex } from 'soukai-solid';
 
 import {
     clearLocalModelUpdates,
@@ -51,29 +61,32 @@ function isRootStatus(status?: JobStatus): status is SyncJobStatus {
 
 export default class Sync extends mixed(BaseJob, [LoadsChildren, LoadsTypeIndex, TracksLocalModels]) {
 
+    public readonly documentsWithErrors: Set<string>;
     protected models?: SolidModel[];
     protected dirtyRemoteModels?: SolidModel[];
     protected rootLocalModels: SolidModel[];
     protected tombstones: ObjectsMap<Tombstone>;
-    protected malformedDocuments: Set<string>;
+    protected syncedModelUrls: Set<string>;
     protected documentsModifiedAt: Record<string, Date>;
+    protected screenLock: Promise<void | { release(): Promise<void> }> | null = null;
     protected override localModels: ObjectsMap<SolidModel>;
 
     constructor(models?: SolidModel[]) {
         super();
 
+        this.documentsWithErrors = new Set();
         this.models = models;
         this.rootLocalModels = [];
         this.localModels = map([], 'url');
         this.tombstones = map([], 'resourceUrl');
-        this.malformedDocuments = new Set();
+        this.syncedModelUrls = new Set();
         this.documentsModifiedAt = {};
     }
 
     protected async run(): Promise<void> {
         const engine = Solid.requireAuthenticator().engine as SolidEngine;
-        const updateDocumentDate = (url: string, { headers }: { headers: Headers }) => {
-            const date = headers?.get('last-modified');
+        const updateDocumentDate = (url: string, { headers }: { headers?: Headers }, fallbackDate?: Date) => {
+            const date = headers?.get('last-modified') ?? fallbackDate;
 
             if (!date || url.endsWith('/')) {
                 return;
@@ -82,21 +95,50 @@ export default class Sync extends mixed(BaseJob, [LoadsChildren, LoadsTypeIndex,
             this.documentsModifiedAt[url] = new Date(date);
         };
         const clearListener = engine.listeners.add({
-            onDocumentRead: updateDocumentDate,
-            onDocumentUpdated: updateDocumentDate,
+            onDocumentRead: (url, metadata) => updateDocumentDate(url, metadata),
+            onDocumentUpdated: (url, metadata) => updateDocumentDate(url, metadata, new Date()),
         });
 
         try {
+            this.lockScreen();
             this.rootLocalModels = this.models ?? getLocalModels();
 
             await this.indexLocalModels(this.rootLocalModels);
             await this.pullChanges();
             await this.pushChanges();
         } finally {
+            this.releaseScreen();
             clearListener();
         }
     }
 
+    protected lockScreen(): void {
+        const typedNavigator = navigator as {
+            wakeLock?: { request(type?: 'screen'): Promise<{ release(): Promise<void> }> };
+        };
+
+        if (!typedNavigator.wakeLock) {
+            return;
+        }
+
+        try {
+            this.screenLock = typedNavigator.wakeLock.request('screen').catch((error) => {
+                Errors.reportDevelopmentError(error, 'Could not request screen wake lock');
+            });
+        } catch (error) {
+            Errors.reportDevelopmentError(error, 'Could not request screen wake lock');
+        }
+    }
+
+    protected releaseScreen(): void {
+        if (!this.screenLock) {
+            return;
+        }
+
+        this.screenLock.then((lock) => lock?.release());
+        this.screenLock = null;
+    }
+
     protected override getInitialStatus(): SyncJobStatus {
         return {
             root: true,
@@ -148,7 +190,7 @@ export default class Sync extends mixed(BaseJob, [LoadsChildren, LoadsTypeIndex,
                 remoteModel.enableHistory();
                 remoteModel.enableTombstone();
 
-                await remoteModel.delete();
+                await remoteModel.forceDelete();
                 await this.updateProgress(() => (childStatus.completed = true));
 
                 return;
@@ -163,60 +205,27 @@ export default class Sync extends mixed(BaseJob, [LoadsChildren, LoadsTypeIndex,
             await DocumentsCache.remember(documentUrl, modifiedAt);
         }
 
-        clearLocalModelUpdates(this.models, this.malformedDocuments);
+        clearLocalModelUpdates(this.syncedModelUrls, this.documentsWithErrors);
 
         await this.updateProgress((status) => (status.children[1].completed = true));
     }
 
     private async fetchRemoteModels(): Promise<SolidModel[]> {
         const pullStatus = this.status.children[0];
-        const typeIndex = await this.loadTypeIndex();
+        const typeIndex = await this.loadTypeIndex({ fresh: true });
 
         if (!typeIndex) {
             return [];
         }
 
         const remoteModels: SolidModel[] = [];
-        const processedContainerUrls = new Set();
-        const registeredModels = [...Cloud.registeredModels].map(({ modelClass }) => {
-            const registeredChildren = isContainerClass(modelClass) ? getContainerRegisteredClasses(modelClass) : [];
-
-            return {
-                modelClass,
-                rdfsClasses:
-                    registeredChildren.length > 0
-                        ? registeredChildren.map((childrenClass) => childrenClass.rdfsClasses).flat()
-                        : modelClass.rdfsClasses,
-            };
-        });
-        const registrations = typeIndex.registrations
-            .map((registration) => {
-                const registeredModel = registeredModels.find(
-                    ({ rdfsClasses }) =>
-                        !!registration.instanceContainer &&
-                        rdfsClasses.some((rdfsClass) => registration.forClass.includes(rdfsClass)),
-                );
-
-                if (
-                    !registeredModel ||
-                    !registration.instanceContainer ||
-                    processedContainerUrls.has(registration.instanceContainer)
-                ) {
-                    return null;
-                }
-
-                processedContainerUrls.add(registration.instanceContainer);
-
-                return [registration, registeredModel] as [SolidTypeRegistration, (typeof registeredModels)[number]];
-            })
-            .filter((match) => !!match);
+        const registrations = this.getTypeRegistrations(typeIndex);
 
         pullStatus.children = registrations.map(() => ({ completed: false }));
 
         for (let index = 0; index < registrations.length; index++) {
-            await this.ignoringMalformedDocumentErrors(async () => {
-                const registration = required(registrations[index])[0];
-                const registeredModel = required(registrations[index])[1];
+            await this.ignoringDocumentErrors(async () => {
+                const { registration, registeredModel } = required(registrations[index]);
                 const remoteClass = getRemoteClass(registeredModel.modelClass);
 
                 if (!registration.instanceContainer) {
@@ -250,7 +259,7 @@ export default class Sync extends mixed(BaseJob, [LoadsChildren, LoadsTypeIndex,
             });
         }
 
-        return completeRemoteModels(this.rootLocalModels, remoteModels, this.malformedDocuments);
+        return completeRemoteModels(this.rootLocalModels, remoteModels, this.documentsWithErrors);
     }
 
     private async fetchRemoteModelsForLocal(models: SolidModel[]): Promise<SolidModel[]> {
@@ -258,7 +267,7 @@ export default class Sync extends mixed(BaseJob, [LoadsChildren, LoadsTypeIndex,
         const statusChildren = (this.status.children[0].children = models.map(() => ({ completed: false })));
 
         for (let index = 0; index < models.length; index++) {
-            await this.ignoringMalformedDocumentErrors(async () => {
+            await this.ignoringDocumentErrors(async () => {
                 const localModel = models[index] as SolidModel;
                 const childStatus = statusChildren[index] as JobStatus;
                 const remoteModel = await getRemoteClass(localModel.static()).find(localModel.url);
@@ -277,15 +286,70 @@ export default class Sync extends mixed(BaseJob, [LoadsChildren, LoadsTypeIndex,
             });
         }
 
-        return completeRemoteModels(models, remoteModels, this.malformedDocuments);
+        return completeRemoteModels(models, remoteModels, this.documentsWithErrors);
+    }
+
+    private getTypeRegistrations(typeIndex: SolidTypeIndex) {
+        const processedContainerUrls = new Set();
+        const registeredModels = [...Cloud.registeredModels].map(({ modelClass }) => {
+            const registeredChildren = isContainerClass(modelClass) ? getContainerRegisteredClasses(modelClass) : [];
+
+            return {
+                modelClass,
+                rdfsClasses:
+                    registeredChildren.length > 0
+                        ? registeredChildren.map((childrenClass) => childrenClass.rdfsClasses).flat()
+                        : modelClass.rdfsClasses,
+            };
+        });
+        const registrations = typeIndex.registrations
+            .map((registration) => {
+                const registeredModel = registeredModels.find(
+                    ({ rdfsClasses }) =>
+                        !!registration.instanceContainer &&
+                        rdfsClasses.some((rdfsClass) => registration.forClass.includes(rdfsClass)),
+                );
+
+                if (
+                    !registeredModel ||
+                    !registration.instanceContainer ||
+                    processedContainerUrls.has(registration.instanceContainer)
+                ) {
+                    return null;
+                }
+
+                processedContainerUrls.add(registration.instanceContainer);
+
+                return { registration, registeredModel };
+            })
+            .filter((match) => !!match);
+
+        // Removed nested registrations.
+        const containerUrls = registrations.map(({ registration }) => registration.instanceContainer);
+
+        return registrations.filter(({ registration }) => {
+            return !containerUrls.some(
+                (containerUrl) =>
+                    containerUrl &&
+                    containerUrl !== registration.instanceContainer &&
+                    registration.instanceContainer?.startsWith(containerUrl),
+            );
+        });
     }
 
     private async updateTypeRegistrations(remoteModel: SolidModel): Promise<void> {
-        if (!isContainer(remoteModel) || !isRegisteredModel(remoteModel)) {
+        if (!isRegisteredModel(remoteModel)) {
             return;
         }
 
-        const registeredChildren = getContainerRegisteredClasses(remoteModel.static());
+        const registeredChildren = isContainer(remoteModel)
+            ? getContainerRegisteredClasses(remoteModel.static())
+            : [remoteModel.static()];
+
+        const RemoteSolidContainer = getRemoteClass(SolidContainer);
+        const container = isContainer(remoteModel)
+            ? remoteModel
+            : new RemoteSolidContainer({ url: remoteModel.requireContainerUrl() });
 
         if (registeredChildren.length === 0) {
             return;
@@ -297,7 +361,7 @@ export default class Sync extends mixed(BaseJob, [LoadsChildren, LoadsTypeIndex,
             return;
         }
 
-        await remoteModel.register(typeIndex, registeredChildren);
+        await container.register(typeIndex, registeredChildren);
     }
 
     private async loadChildren(model: SolidModel, childStatus?: JobStatus): Promise<void> {
@@ -309,12 +373,19 @@ export default class Sync extends mixed(BaseJob, [LoadsChildren, LoadsTypeIndex,
 
         const children = await this.loadContainedModels(model, {
             status: childStatus,
-            onLoaded: async () => {
+            onDocumentError: (error) => this.handleDocumentError(error),
+            onDocumentRead: (document) => {
+                if (document.url.endsWith('/') || !document.updatedAt || document.url in this.documentsModifiedAt) {
+                    return;
+                }
+
+                this.documentsModifiedAt[document.url] = document.updatedAt;
+            },
+            onDocumentLoaded: async () => {
                 this.assertNotCancelled();
 
                 await this.updateProgress();
             },
-            onMalformedDocument: (url) => this.malformedDocuments.add(url),
         });
 
         for (let index = 0; index < children.length; index++) {
@@ -361,7 +432,7 @@ export default class Sync extends mixed(BaseJob, [LoadsChildren, LoadsTypeIndex,
             }
         }
 
-        await child.delete();
+        await child.forceDelete();
     }
 
     private async saveModelAndChildren(model: SolidModel, status?: JobStatus): Promise<void> {
@@ -370,25 +441,34 @@ export default class Sync extends mixed(BaseJob, [LoadsChildren, LoadsTypeIndex,
         if (isRemoteModel(model) && model.isSoftDeleted()) {
             model.enableHistory();
             model.enableTombstone();
-            await model.delete();
+
+            await model.forceDelete();
 
             return;
         }
 
-        if (this.malformedDocuments.has(model.requireDocumentUrl())) {
+        if (this.documentsWithErrors.has(model.requireDocumentUrl())) {
             return;
         }
 
+        const wasDirty = model.isDirty();
+
         await model.save();
 
+        if (wasDirty || isRemoteModel(model)) {
+            this.syncedModelUrls.add(model.url);
+        }
+
         if (!isContainer(model)) {
             if (isRemoteModel(model)) {
                 const documentUrl = model.requireDocumentUrl();
-                const modifiedAt = this.documentsModifiedAt[documentUrl] ?? new Date();
+                const modifiedAt = this.documentsModifiedAt[documentUrl];
 
-                await DocumentsCache.remember(documentUrl, modifiedAt);
+                if (modifiedAt) {
+                    await DocumentsCache.remember(documentUrl, modifiedAt);
 
-                delete this.documentsModifiedAt[documentUrl];
+                    delete this.documentsModifiedAt[documentUrl];
+                }
             }
 
             return;
@@ -425,7 +505,7 @@ export default class Sync extends mixed(BaseJob, [LoadsChildren, LoadsTypeIndex,
                 const localModel = this.localModels.get(remoteModel.resourceUrl);
 
                 if (localModel) {
-                    await localModel.delete();
+                    await localModel.forceDelete();
 
                     deletedModels.add(localModel);
                 }
@@ -435,6 +515,10 @@ export default class Sync extends mixed(BaseJob, [LoadsChildren, LoadsTypeIndex,
 
             const localModel = getLocalModel(remoteModel, this.localModels);
 
+            if (!localModel.exists()) {
+                this.syncedModelUrls.add(localModel.url);
+            }
+
             await this.loadChildren(localModel);
             await SolidModel.synchronize(localModel, remoteModel);
             await this.reconcileInconsistencies(localModel, remoteModel);
@@ -503,11 +587,14 @@ export default class Sync extends mixed(BaseJob, [LoadsChildren, LoadsTypeIndex,
                 continue;
             }
 
-            await this.reconcileInconsistencies(localRelatedModel, remoteRelatedModels.require(localRelatedModel.url));
+            await this.reconcileInconsistencies(
+                localRelatedModel,
+                remoteRelatedModels.require(localRelatedModel.url),
+                processedModels,
+            );
         }
 
         if (localModel.isDirty()) {
-            await localModel.save();
             await SolidModel.synchronize(localModel, remoteModel);
         }
     }
@@ -539,6 +626,7 @@ export default class Sync extends mixed(BaseJob, [LoadsChildren, LoadsTypeIndex,
 
             localRelation.addRelated(localModel);
             localModels.add(localModel);
+            this.syncedModelUrls.add(localModel.url);
         }
 
         for (const localModel of localModels.items()) {
@@ -552,11 +640,13 @@ export default class Sync extends mixed(BaseJob, [LoadsChildren, LoadsTypeIndex,
     private async rememberModelDocuments(model: SolidModel): Promise<void> {
         if (!isContainer(model)) {
             const documentUrl = model.requireDocumentUrl();
-            const modifiedAt = this.documentsModifiedAt[documentUrl] ?? new Date();
+            const modifiedAt = this.documentsModifiedAt[documentUrl];
 
-            await DocumentsCache.remember(documentUrl, modifiedAt);
+            if (modifiedAt) {
+                await DocumentsCache.remember(documentUrl, modifiedAt);
 
-            delete this.documentsModifiedAt[documentUrl];
+                delete this.documentsModifiedAt[documentUrl];
+            }
 
             return;
         }
@@ -570,21 +660,37 @@ export default class Sync extends mixed(BaseJob, [LoadsChildren, LoadsTypeIndex,
         }
     }
 
-    private async ignoringMalformedDocumentErrors(operation: Function): Promise<void> {
+    private async ignoringDocumentErrors(operation: Function): Promise<void> {
         try {
             await operation();
         } catch (error) {
-            if (isInstanceOf(error, MalformedSolidDocumentError)) {
-                // eslint-disable-next-line no-console
-                console.warn(error.message);
+            this.handleDocumentError(error);
+        }
+    }
 
-                error.documentUrl && this.malformedDocuments.add(error.documentUrl);
+    private handleDocumentError(error: unknown): void {
+        if (isInstanceOf(error, MalformedSolidDocumentError)) {
+            // eslint-disable-next-line no-console
+            console.warn(error.message);
 
-                return;
-            }
+            error.documentUrl && this.documentsWithErrors.add(error.documentUrl);
+
+            return;
+        }
+
+        if (isInstanceOf(error, InvalidModelAttributes)) {
+            // eslint-disable-next-line no-console
+            console.warn(error.message);
+
+            const primaryKey = error.attributes[requireBootedModel(error.modelName).primaryKey];
+            const documentUrl = primaryKey && urlRoute(toString(primaryKey));
 
-            throw error;
+            documentUrl && this.documentsWithErrors.add(documentUrl);
+
+            return;
         }
+
+        throw error;
     }
 
 }

package/src/jobs/mixins/LoadsChildren.ts

@@ -1,6 +1,5 @@
 import { arrayChunk, arrayFrom, isInstanceOf, map, required } from '@noeldemartin/utils';
 import { DocumentNotFound } from 'soukai';
-import { MalformedSolidDocumentError } from '@noeldemartin/solid-utils';
 import { Tombstone } from 'soukai-solid';
 import type { JobStatus } from '@aerogel/core';
 import type { ObjectsMap } from '@noeldemartin/utils';
@@ -25,8 +24,9 @@ export default class LoadsChildren {
         options: {
             ignoreTombstones?: boolean;
             status?: ResourceJobStatus;
-            onLoaded?: (urls: string[]) => unknown;
-            onMalformedDocument?: (url: string) => unknown;
+            onDocumentLoaded?: () => unknown;
+            onDocumentError?: (error: unknown) => unknown;
+            onDocumentRead?: (document: SolidDocument) => unknown;
         } = {},
     ): Promise<SolidModel[]> {
         if (isLocalModel(model)) {
@@ -60,7 +60,13 @@ export default class LoadsChildren {
             await Promise.all(
                 documentUrls.map(async (documentUrl) => {
                     const { children: documentChildren, tombstones: documentTombstones } =
-                        await this.loadDocumentChildren(model, documentUrl, documents, options.onMalformedDocument);
+                        await this.loadDocumentChildren(
+                            model,
+                            documentUrl,
+                            documents,
+                            options.onDocumentError,
+                            options.onDocumentRead,
+                        );
 
                     tombstones.push(...documentTombstones);
 
@@ -69,18 +75,16 @@ export default class LoadsChildren {
 
                         relationChildren.push(...documentModels);
                     }
-                }),
-            );
 
-            for (const documentUrl of documentUrls) {
-                if (documentUrl.endsWith('/')) {
-                    continue;
-                }
+                    if (documentUrl.endsWith('/')) {
+                        return;
+                    }
 
-                required(statusChildrenMap.get(documentUrl)).completed = true;
-            }
+                    required(statusChildrenMap.get(documentUrl)).completed = true;
 
-            await options.onLoaded?.(documentUrls);
+                    await options.onDocumentLoaded?.();
+                }),
+            );
         }
 
         for (const [relation, relationModels] of Object.entries(children)) {
@@ -101,16 +105,18 @@ export default class LoadsChildren {
     }
 
     protected async loadDocumentChildren(
-        model: SolidModel,
+        model: SolidContainer,
         documentUrl: string,
         documents: ObjectsMap<SolidDocument>,
-        onMalformedDocument?: (url: string) => unknown,
+        onDocumentError?: (error: unknown) => unknown,
+        onDocumentRead?: (document: SolidDocument) => unknown,
     ): Promise<{ children: Record<string, SolidModel[]>; tombstones: Tombstone[] }> {
         const document = documents.get(documentUrl);
 
         if (
             document &&
-            (await DocumentsCache.isFresh(document.url, document.updatedAt ?? new Date())) &&
+            document.updatedAt &&
+            (await DocumentsCache.isFresh(document.url, document.updatedAt)) &&
             this.localModels?.hasKey(model.url)
         ) {
             return {
@@ -119,7 +125,7 @@ export default class LoadsChildren {
             };
         }
 
-        return this.loadDocumentChildrenFromRemote(model, documentUrl, onMalformedDocument);
+        return this.loadDocumentChildrenFromRemote(model, documentUrl, onDocumentError, onDocumentRead);
     }
 
     protected async loadDocumentChildrenFromLocal(
@@ -148,14 +154,16 @@ export default class LoadsChildren {
     }
 
     protected async loadDocumentChildrenFromRemote(
-        model: SolidModel,
+        model: SolidContainer,
         documentUrl: string,
-        onMalformedDocument?: (url: string) => unknown,
+        onDocumentError?: (error: unknown) => unknown,
+        onDocumentRead?: (document: SolidDocument) => unknown,
     ): Promise<{ children: Record<string, SolidModel[]>; tombstones: Tombstone[] }> {
         const children: Record<string, SolidModel[]> = {};
         const tombstones: Tombstone[] = [];
         const readDocument = lazy(async () => {
             try {
+                const documentModel = model.documents.find((document) => document.url === documentUrl);
                 const document = await model.requireEngine().readOne(model.static('collection'), documentUrl);
                 const documentTombstones = await Tombstone.createManyFromEngineDocuments({
                     [documentUrl]: document,
@@ -163,22 +171,23 @@ export default class LoadsChildren {
 
                 tombstones.push(...documentTombstones);
 
+                if (documentModel) {
+                    onDocumentRead?.(documentModel);
+                }
+
                 return document;
             } catch (error) {
                 if (isInstanceOf(error, DocumentNotFound)) {
                     return null;
                 }
 
-                if (isInstanceOf(error, MalformedSolidDocumentError)) {
-                    // eslint-disable-next-line no-console
-                    console.warn(error.message);
-
-                    await onMalformedDocument?.(documentUrl);
-
-                    return null;
+                if (!onDocumentError) {
+                    throw error;
                 }
 
-                throw error;
+                onDocumentError(error);
+
+                return null;
             }
         });
 
@@ -197,11 +206,19 @@ export default class LoadsChildren {
                 continue;
             }
 
-            const documentChildren = await relationInstance.relatedClass.createManyFromEngineDocuments({
-                [documentUrl]: document,
-            });
+            try {
+                const documentChildren = await relationInstance.relatedClass.createManyFromEngineDocuments({
+                    [documentUrl]: document,
+                });
+
+                children[relation] = documentChildren;
+            } catch (error) {
+                if (!onDocumentError) {
+                    throw error;
+                }
 
-            children[relation] = documentChildren;
+                onDocumentError(error);
+            }
         }
 
         return { children, tombstones };

package/src/jobs/mixins/LoadsTypeIndex.ts

@@ -6,15 +6,17 @@ const typeIndexes: WeakMap<SolidUserProfile, SolidTypeIndex | null> = new WeakMa
 
 export default class LoadsTypeIndex {
 
-    protected async loadTypeIndex(options: { create: true }): Promise<SolidTypeIndex>;
-    protected async loadTypeIndex(options?: { create: false }): Promise<SolidTypeIndex | null>;
-    protected async loadTypeIndex(options: { create?: boolean } = {}): Promise<SolidTypeIndex | null> {
+    protected async loadTypeIndex(options?: { create?: false; fresh?: boolean }): Promise<SolidTypeIndex | null>;
+    protected async loadTypeIndex(options?: { create?: true; fresh?: boolean }): Promise<SolidTypeIndex>;
+    protected async loadTypeIndex(options: { create?: boolean; fresh?: boolean } = {}): Promise<SolidTypeIndex | null> {
         const user = Solid.requireUser();
 
+        if (options.fresh || !typeIndexes.has(user)) {
+            typeIndexes.set(user, await Solid.findPrivateTypeIndex({ fresh: options.fresh }));
+        }
+
         if (options.create && !typeIndexes.get(user)) {
             typeIndexes.set(user, await Solid.findOrCreatePrivateTypeIndex());
-        } else if (!typeIndexes.has(user)) {
-            typeIndexes.set(user, await Solid.findPrivateTypeIndex());
         }
 
         return typeIndexes.get(user) ?? null;

package/src/jobs/mixins/TracksLocalModels.ts

@@ -1,11 +1,11 @@
 import type { ObjectsMap } from '@noeldemartin/utils';
 import type { SolidModel } from 'soukai-solid';
 
-import { getContainerRelations } from '@aerogel/plugin-local-first/lib/inference';
+import { getContainerRelations, getRelatedAppModels } from '@aerogel/plugin-local-first/lib/inference';
 
 export default class TracksLocalModels {
 
-    declare protected localModels?: ObjectsMap<SolidModel>;
+    declare protected localModels: ObjectsMap<SolidModel>;
 
     protected async indexLocalModels(models: SolidModel[]): Promise<void> {
         for (const localModel of models) {
@@ -14,7 +14,7 @@ export default class TracksLocalModels {
     }
 
     protected async addLocalModel(localModel: SolidModel): Promise<void> {
-        if (!this.localModels || this.localModels.hasKey(localModel.url)) {
+        if (this.localModels.hasKey(localModel.url)) {
             return;
         }
 
@@ -24,7 +24,7 @@ export default class TracksLocalModels {
             await localModel.loadRelationIfUnloaded(relation);
         }
 
-        for (const relatedModel of localModel.getRelatedModels()) {
+        for (const relatedModel of getRelatedAppModels(localModel)) {
             await this.addLocalModel(relatedModel);
         }
     }