@aerogel/plugin-solid 0.0.1 → 0.1.0

package/src/services/Solid.ts

@@ -1,39 +1,69 @@
 import {
-    PromisedValue,
+    after,
     arrayFilter,
     arrayUnique,
     arrayWithout,
+    asyncMemo,
     facade,
     fail,
     getLocationQueryParameter,
     hasLocationQueryParameter,
+    isDevelopment,
     objectWithout,
+    objectWithoutEmpty,
     parseBoolean,
+    requireUrlParse,
+    resetAsyncMemo,
+    setAsyncMemo,
     tap,
     urlRoot,
 } from '@noeldemartin/utils';
+import { App, Errors, Events, Storage, UI, translateWithDefault } from '@aerogel/core';
 import { fetchLoginUserProfile } from '@noeldemartin/solid-utils';
-import { App, Errors, Events, UI, translateWithDefault } from '@aerogel/core';
+import { setEngine } from 'soukai';
+import { SolidACLAuthorization, SolidContainer, SolidDocument, SolidTypeIndex } from 'soukai-solid';
+import type { ErrorSource } from '@aerogel/core';
 import type { Fetch, SolidModelConstructor } from 'soukai-solid';
-import { SolidACLAuthorization, SolidContainer, SolidTypeIndex } from 'soukai-solid';
-import type { SolidUserProfile } from '@noeldemartin/solid-utils';
-
-import AuthenticationCancelledError from '@/errors/AuthenticationCancelledError';
-import { ContainerAlreadyInUse } from '@/errors';
-import { getAuthenticator } from '@/auth';
-import type { AuthenticatorName } from '@/auth';
-import type Authenticator from '@/auth/Authenticator';
-import type { AuthSession } from '@/auth/Authenticator';
-
-import Service from './Solid.state';
+import type { NullablePartial } from '@noeldemartin/utils';
+import type { SolidStore, SolidUserProfile } from '@noeldemartin/solid-utils';
+
+import AuthenticationCancelledError from '@aerogel/plugin-solid/errors/AuthenticationCancelledError';
+import { ContainerAlreadyInUse } from '@aerogel/plugin-solid/errors';
+import { getAuthenticator } from '@aerogel/plugin-solid/auth';
+import type Authenticator from '@aerogel/plugin-solid/auth/Authenticator';
+import type { AuthenticatorName } from '@aerogel/plugin-solid/auth';
+import type { AuthSession } from '@aerogel/plugin-solid/auth/Authenticator';
+
+import Service, { DEFAULT_STATE } from './Solid.state';
+
+export type LoginOptions = NullablePartial<{
+    authenticator: AuthenticatorName;
+    onError(error: ErrorSource): unknown;
+    fallbackUrl: string;
+    loading: boolean;
+}>;
+
+export type UserProfileOptions = NullablePartial<{
+    required: boolean;
+    markStale: boolean;
+}>;
+
+export type ReconnectOptions = Omit<LoginOptions, 'authenticator'> & {
+    force?: boolean;
+};
 
 export class SolidService extends Service {
 
-    protected publicTypeIndexes: Record<string, PromisedValue<SolidTypeIndex>> = {};
-    protected privateTypeIndexes: Record<string, PromisedValue<SolidTypeIndex>> = {};
-
     public isLoggedIn(): this is { session: AuthSession; user: SolidUserProfile; authenticator: Authenticator } {
-        return this.loggedIn;
+        return !!this.session;
+    }
+
+    public wasLoggedIn(): this is { user: SolidUserProfile } {
+        return !!this.previousSession;
+    }
+
+    public hasLoggedIn(): this is { user: SolidUserProfile } {
+        return !!(this.session || this.previousSession);
     }
 
     public requireAuthenticator(): Authenticator {
@@ -41,26 +71,49 @@ export class SolidService extends Service {
     }
 
     public requireUser(): SolidUserProfile {
-        return this.user ?? fail('Could not get user profile');
+        return this.user ?? fail('Could not get user profile (are you logged in?)');
     }
 
     public requireUserProfile(url: string): Promise<SolidUserProfile> {
-        return this.getUserProfile(url, true);
+        return this.getUserProfile(url, { required: true });
     }
 
-    public async getUserProfile(url: string, required: true): Promise<SolidUserProfile>;
-    public async getUserProfile(url: string, required?: false): Promise<SolidUserProfile | null>;
-    public async getUserProfile(url: string, required: boolean = false): Promise<SolidUserProfile | null> {
-        return (
+    /* eslint-disable max-len */
+    public async getUserProfile(url: string, options: Omit<UserProfileOptions, 'required'> & { required: true }): Promise<SolidUserProfile>; // prettier-ignore
+    public async getUserProfile(url: string, options?: UserProfileOptions): Promise<SolidUserProfile | null>;
+    /* eslint-enable max-len */
+
+    public async getUserProfile(url: string, options: UserProfileOptions = {}): Promise<SolidUserProfile | null> {
+        let profileStore: SolidStore | null = null;
+        const markStale = options.markStale ?? !this.authenticator?.getAuthenticatedFetch();
+        const userProfile =
             this.profiles[url] ??
-            tap(
+            (await tap(
                 await fetchLoginUserProfile(url, {
                     fetch: this.fetch,
-                    required,
+                    required: options.required ?? false,
+                    onLoaded(store) {
+                        profileStore = store;
+                    },
                 }),
-                (profile) => profile && this.rememberProfile(profile),
-            )
-        );
+                async (profile) => {
+                    if (!profile) {
+                        return;
+                    }
+
+                    if (profileStore) {
+                        await Events.emit('solid:user-profile-loaded', [profile, profileStore]);
+                    }
+
+                    this.rememberProfile(profile);
+                },
+            ));
+
+        if (userProfile && markStale) {
+            this.setState({ staleProfiles: arrayUnique(this.staleProfiles.concat([userProfile.webId])) });
+        }
+
+        return userProfile;
     }
 
     public async refreshUserProfile(): Promise<void> {
@@ -80,14 +133,17 @@ export class SolidService extends Service {
         });
     }
 
-    public async login(loginUrl: string, authenticatorName?: AuthenticatorName): Promise<boolean> {
-        authenticatorName = authenticatorName ?? this.preferredAuthenticator ?? 'default';
+    public async login(loginUrl: string, options: LoginOptions = {}): Promise<boolean> {
+        if (isDevelopment() && loginUrl === 'dev') {
+            loginUrl = 'http://localhost:3000';
+        }
 
-        if (App.isDevelopment && loginUrl === 'devserver') {
-            loginUrl = 'http://localhost:4000';
+        if (!/^https?:\/\//.test(loginUrl)) {
+            options.fallbackUrl ??= `http://${loginUrl}`;
+            loginUrl = `https://${loginUrl}`;
         }
 
-        if (this.loggedIn) {
+        if (this.isLoggedIn()) {
             return true;
         }
 
@@ -95,59 +151,84 @@ export class SolidService extends Service {
             throw new Error('Authentication already in progress');
         }
 
-        const staleTimeout = setTimeout(() => (this.loginStale = true), 10000);
-        this.loginOngoing = true;
-
-        try {
-            const profile = await this.getUserProfile(loginUrl);
-            const oidcIssuerUrl = profile?.oidcIssuerUrl ?? urlRoot(profile?.webId ?? loginUrl);
-            const authenticator = await this.bootAuthenticator(authenticatorName);
-
-            this.setState({
-                dismissed: false,
-                ignorePreviousSessionError: true,
-                previousSession: {
-                    loginUrl,
-                    avatarUrl: profile?.avatarUrl,
-                    authenticator: authenticatorName,
-                    error: translateWithDefault(
-                        'auth.stuckConnecting',
-                        'We didn\'t hear back from the identity provider, maybe try reconnecting?',
-                    ),
-                },
-            });
-
-            await authenticator.login(oidcIssuerUrl);
-
-            return true;
-        } catch (error) {
-            if (error instanceof AuthenticationCancelledError) {
-                return false;
-            }
-
-            App.isMounted ? Errors.report(error) : this.setState({ loginError: error });
-
-            return false;
-        } finally {
-            clearTimeout(staleTimeout);
-
-            this.loginOngoing = false;
-            this.loginStale = false;
+        if (!options.loading) {
+            return this.attemptLogin(loginUrl, options);
         }
+
+        return UI.loading(translateWithDefault('solid.loginOngoing', 'Logging in...'), () => {
+            return this.attemptLogin(loginUrl, options);
+        });
     }
 
-    public async reconnect(force: boolean = false): Promise<void> {
-        if (this.loggedIn || !this.previousSession || (this.previousSession.error !== null && !force)) {
+    public async reconnect(options: ReconnectOptions = {}): Promise<void> {
+        const { force, ...loginOptions } = options;
+        if (this.isLoggedIn() || !this.previousSession || (this.previousSession.error !== null && !force)) {
             return;
         }
 
-        await this.login(this.previousSession.loginUrl, this.previousSession.authenticator);
+        await this.login(this.previousSession.loginUrl, {
+            authenticator: this.previousSession.authenticator,
+            ...loginOptions,
+            loading: loginOptions.loading ?? false,
+        });
     }
 
     public async logout(force: boolean = false): Promise<void> {
-        const confirmLogout =
-            force ||
-            (await UI.confirm(translateWithDefault('solid.logoutConfirm', 'Are you sure you want to log out?')));
+        const isCloudReady = !App.plugin('@aerogel/local-first') || !!App.service('$cloud')?.ready;
+        const hasLocalChanges = !App.plugin('@aerogel/local-first') || !!App.service('$cloud')?.dirty;
+        const [confirmLogout, options] = force
+            ? [true, { wipeLocalData: isCloudReady }]
+            : await UI.confirm(
+                isCloudReady
+                    ? translateWithDefault('solid.logoutConfirmTitle', 'Log out from this device?')
+                    : translateWithDefault('solid.disconnectConfirmTitle', 'Disconnect account?'),
+                isCloudReady
+                    ? hasLocalChanges
+                        ? translateWithDefault(
+                            'solid.logoutConfirmMessageWithLocalChanges',
+                            'There are some changes that haven\'t been synchronized and will be lost, ' +
+                                    'but the rest of the data will remain in your Solid POD.',
+                        )
+                        : translateWithDefault(
+                            'solid.logoutConfirmMessage',
+                            'Logging out will remove all the data from this device, ' +
+                                    'but you\'ll still have it in your Solid POD.',
+                        )
+                    : translateWithDefault(
+                        'solid.disconnectConfirmMessage',
+                        'You\'ll need to introduce your credentials again to connect to your Solid POD.',
+                    ),
+                {
+                    acceptText: translateWithDefault('solid.logoutConfirmAccept', 'Log out'),
+                    acceptVariant: 'danger',
+                    cancelText: translateWithDefault(
+                        'solid.logoutConfirmCancel',
+                        translateWithDefault('ui.cancel', 'Cancel'),
+                    ),
+                    checkboxes: isCloudReady
+                        ? hasLocalChanges
+                            ? {
+                                wipeLocalData: {
+                                    label: translateWithDefault(
+                                        'solid.logoutConfirmWipeNotice',
+                                        'I understand that changes that haven\'t been synchronized will be lost.',
+                                    ),
+                                    default: false,
+                                    required: true,
+                                },
+                            }
+                            : undefined
+                        : {
+                            wipeLocalData: {
+                                label: translateWithDefault(
+                                    'solid.logoutConfirmWipe',
+                                    'Also remove all existing data',
+                                ),
+                                default: false,
+                            },
+                        },
+                },
+            );
 
         if (!confirmLogout) {
             return;
@@ -157,10 +238,36 @@ export class SolidService extends Service {
             return;
         }
 
-        this.setState({ previousSession: null });
-        this.isLoggedIn() && (await this.authenticator.logout());
+        await UI.loading(translateWithDefault('solid.logoutOngoing', 'Logging out...'), async () => {
+            this.setState({
+                dismissed: false,
+                ignorePreviousSessionError: false,
+                loginStartupError: null,
+                previousSession: null,
+                ...DEFAULT_STATE,
+            });
+
+            this.isLoggedIn() && (await this.authenticator.logout());
 
-        await Events.emit('logout');
+            if (options.wipeLocalData ?? true) {
+                await Storage.purge();
+            }
+
+            await Events.emit('auth:logout');
+            await Events.emit('auth:after-logout');
+        });
+    }
+
+    public async whenLoggedIn<T>(callback: (session: AuthSession) => T): Promise<T> {
+        if (this.isLoggedIn()) {
+            return callback(this.session);
+        }
+
+        return new Promise((resolve) => {
+            const onLogin = (session: AuthSession) => resolve(callback(session));
+
+            Events.once('auth:login', onLogin);
+        });
     }
 
     public dismiss(): void {
@@ -168,40 +275,48 @@ export class SolidService extends Service {
     }
 
     public async findOrCreatePrivateTypeIndex(): Promise<SolidTypeIndex> {
-        if (!this.isLoggedIn()) {
-            throw new Error('Can\'t find or create a type index because the user is not logged in');
+        return (await this.findPrivateTypeIndex()) ?? (await this.createPrivateTypeIndex());
+    }
+
+    public async findPrivateTypeIndex(options: { fresh?: boolean } = {}): Promise<SolidTypeIndex | null> {
+        const { webId, privateTypeIndexUrl } = this.requireUser();
+        const engine = this.requireAuthenticator().engine;
+
+        if (!privateTypeIndexUrl) {
+            return null;
         }
 
-        const webId = this.user.webId;
+        if (options.fresh) {
+            resetAsyncMemo(`${webId}-privateTypeIndex`);
+        }
 
-        return (this.privateTypeIndexes[webId] =
-            this.privateTypeIndexes[webId] ??
-            PromisedValue.from(
-                (async () => (await this.findPrivateTypeIndex()) ?? (await this.createPrivateTypeIndex()))(),
-            ));
+        return asyncMemo(`${webId}-privateTypeIndex`, () =>
+            SolidTypeIndex.withEngine(engine).find(privateTypeIndexUrl));
     }
 
     public async findOrCreatePublicTypeIndex(): Promise<SolidTypeIndex> {
-        if (!this.isLoggedIn()) {
-            throw new Error('Can\'t find or create a type index because the user is not logged in');
+        return (await this.findPublicTypeIndex()) ?? (await this.createPublicTypeIndex());
+    }
+
+    public async findPublicTypeIndex(options: { fresh?: boolean } = {}): Promise<SolidTypeIndex | null> {
+        const { webId, publicTypeIndexUrl } = this.requireUser();
+        const engine = this.requireAuthenticator().engine;
+
+        if (!publicTypeIndexUrl) {
+            return null;
         }
 
-        const webId = this.user.webId;
+        if (options.fresh) {
+            resetAsyncMemo(`${webId}-publicTypeIndex`);
+        }
 
-        return (this.publicTypeIndexes[webId] =
-            this.publicTypeIndexes[webId] ??
-            PromisedValue.from(
-                (async () => (await this.findPublicTypeIndex()) ?? (await this.createPublicTypeIndex()))(),
-            ));
+        return asyncMemo(`${webId}-publicTypeIndex`, () => SolidTypeIndex.withEngine(engine).find(publicTypeIndexUrl));
     }
 
     public async createPrivateContainer(options: {
         url: string;
-        name: string;
-        register?: {
-            typeIndex: SolidTypeIndex;
-            modelClass: SolidModelConstructor;
-        };
+        name?: string;
+        registerFor?: SolidModelConstructor;
         reuseExisting?: boolean;
     }): Promise<SolidContainer> {
         const engine = this.requireAuthenticator().engine;
@@ -213,18 +328,21 @@ export class SolidService extends Service {
                 throw new ContainerAlreadyInUse(existingContainer);
             }
 
-            const container = existingContainer ?? new SolidContainer({ url: options.url, name: options.url });
+            const container = existingContainer ?? new SolidContainer({ url: options.url, name: options.name });
 
             await container.save();
 
-            options.register && (await container.register(options.register.typeIndex.url, options.register.modelClass));
+            if (options.registerFor) {
+                const typeIndex = await this.findOrCreatePrivateTypeIndex();
+
+                await container.register(typeIndex, options.registerFor);
+            }
 
             return container;
         });
     }
 
-    protected async boot(): Promise<void> {
-        await super.boot();
+    protected override async boot(): Promise<void> {
         await Errors.booted;
 
         if (hasLocationQueryParameter('authenticator')) {
@@ -245,47 +363,99 @@ export class SolidService extends Service {
         await this.startupReconnect();
     }
 
-    protected async findPrivateTypeIndex(): Promise<SolidTypeIndex | null> {
+    protected async createPrivateTypeIndex(): Promise<SolidTypeIndex> {
         const user = this.requireUser();
         const authenticator = this.requireAuthenticator();
+        const typeIndex = await SolidTypeIndex.withEngine(authenticator.engine).createPrivate(user);
+
+        return tap(typeIndex, () => {
+            user.privateTypeIndexUrl = typeIndex.url;
 
-        return SolidTypeIndex.withEngine(authenticator.engine, () => SolidTypeIndex.find(user.privateTypeIndexUrl));
+            setAsyncMemo(`${user.webId}-privateTypeIndex`, typeIndex);
+
+            this.rememberProfile(user);
+        });
     }
 
-    protected async createPrivateTypeIndex(): Promise<SolidTypeIndex> {
+    public async createPublicTypeIndex(): Promise<SolidTypeIndex> {
         const user = this.requireUser();
         const authenticator = this.requireAuthenticator();
-        const typeIndex = await SolidTypeIndex.withEngine(authenticator.engine).createPrivate(user);
+        const typeIndex = await SolidTypeIndex.withEngine(authenticator.engine).createPublic(user);
 
         return tap(typeIndex, () => {
             user.privateTypeIndexUrl = typeIndex.url;
 
+            setAsyncMemo(`${user.webId}-publicTypeIndex`, typeIndex);
+
             this.rememberProfile(user);
         });
     }
 
-    protected async findPublicTypeIndex(): Promise<SolidTypeIndex | null> {
-        if (!this.user?.publicTypeIndexUrl) {
-            return null;
-        }
+    protected async attemptLogin(loginUrl: string, options: LoginOptions): Promise<boolean> {
+        const authenticatorName = options.authenticator ?? this.preferredAuthenticator ?? 'default';
+        const handleLoginError =
+            options.onError ??
+            ((error: ErrorSource) =>
+                App.isMounted() ? Errors.report(error) : this.setState({ loginStartupError: error }));
+        const staleTimeout = setTimeout(() => (this.loginStale = true), 10000);
+        const initialState = {
+            dismissed: this.dismissed,
+            ignorePreviousSessionError: this.ignorePreviousSessionError,
+            previousSession: this.previousSession,
+        };
 
-        return SolidTypeIndex.find(this.user.publicTypeIndexUrl);
-    }
+        this.loginOngoing = true;
 
-    public async createPublicTypeIndex(): Promise<SolidTypeIndex> {
-        if (!this.isLoggedIn()) {
-            throw new Error('Can\'t create a type index because the user is not logged in');
-        }
+        try {
+            const profile = await this.getUserProfile(loginUrl, { markStale: true });
+            const oidcIssuerUrl = profile?.oidcIssuerUrl ?? urlRoot(profile?.webId ?? loginUrl);
+            const authenticator = await this.bootAuthenticator(authenticatorName);
+            const { domain: loginDomain } = requireUrlParse(loginUrl);
+
+            this.setState({
+                dismissed: false,
+                ignorePreviousSessionError: true,
+                previousSession: objectWithoutEmpty({
+                    profile,
+                    loginUrl,
+                    authenticator: authenticatorName,
+                    error: translateWithDefault(
+                        'solid.stuckConnecting',
+                        'We didn\'t hear back from the identity provider at `{domain}`, maybe try reconnecting?',
+                        { domain: loginDomain },
+                    ),
+                }),
+            });
 
-        const user = this.user;
-        const typeIndex = await SolidTypeIndex.withEngine(this.authenticator.engine, () =>
-            SolidTypeIndex.createPublic(user));
+            await Events.emit('auth:before-login');
 
-        return tap(typeIndex, () => {
-            user.publicTypeIndexUrl = typeIndex.url;
+            // This should redirect away from the app, so in most cases
+            // the rest of the code won't be reached.
+            await authenticator.login(oidcIssuerUrl, profile);
 
-            this.rememberProfile(user);
-        });
+            return true;
+        } catch (error) {
+            this.setState(initialState);
+
+            if (error instanceof AuthenticationCancelledError) {
+                return false;
+            }
+
+            if (options.fallbackUrl) {
+                return after().then(() => this.login(options.fallbackUrl ?? '', objectWithout(options, 'fallbackUrl')));
+            }
+
+            handleLoginError(error);
+
+            return false;
+        } finally {
+            clearTimeout(staleTimeout);
+
+            this.setState({
+                loginOngoing: false,
+                loginStale: false,
+            });
+        }
     }
 
     private async restorePreviousSession(): Promise<void> {
@@ -301,7 +471,7 @@ export class SolidService extends Service {
             return;
         }
 
-        await this.reconnect();
+        await this.reconnect({ force: this.forcingReconnect() });
     }
 
     private reconnectOnStartup(): boolean {
@@ -312,6 +482,10 @@ export class SolidService extends Service {
         return this.autoReconnect;
     }
 
+    private forcingReconnect(): boolean {
+        return hasLocationQueryParameter('autoReconnect') && parseBoolean(getLocationQueryParameter('autoReconnect'));
+    }
+
     private async bootAuthenticator(name: AuthenticatorName): Promise<Authenticator> {
         const authenticator = getAuthenticator(name);
 
@@ -322,27 +496,28 @@ export class SolidService extends Service {
                     previousSession: {
                         authenticator: authenticator.name,
                         loginUrl: session.loginUrl,
-                        avatarUrl: session.user.avatarUrl,
+                        profile: session.user,
                         error: null,
                     },
                 });
 
-                if (
-                    session.user.cloaked ||
-                    !session.user.writableProfileUrl ||
-                    this.staleProfiles.includes(session.user.webId)
-                ) {
+                if (this.staleProfiles.includes(session.user.webId)) {
                     await this.refreshUserProfile();
                 }
 
+                App.plugin('@aerogel/local-first') || setEngine(session.authenticator.engine);
+
                 SolidACLAuthorization.setEngine(session.authenticator.engine);
+                SolidTypeIndex.setEngine(session.authenticator.engine);
+                SolidDocument.setEngine(session.authenticator.engine);
 
-                await Events.emit('login', session);
+                await Events.emit('auth:login', session);
             },
             onSessionFailed: async (loginUrl, error) => {
                 this.setState({
                     session: null,
                     previousSession: {
+                        profile: this.previousSession?.profile,
                         authenticator: authenticator.name,
                         loginUrl,
                         error,
@@ -350,7 +525,7 @@ export class SolidService extends Service {
                 });
             },
             onSessionEnded: () => this.setState({ session: null }),
-            onAuthenticatedFetchReady: (fetch) => Events.emit('authenticated-fetch-ready', fetch),
+            onAuthenticatedFetchReady: (fetch) => Events.emit('auth:fetch-ready', fetch),
         });
 
         await authenticator.boot();
@@ -370,12 +545,15 @@ export class SolidService extends Service {
 
 }
 
-export default facade(new SolidService());
+export default facade(SolidService);
 
 declare module '@aerogel/core' {
     export interface EventsPayload {
-        'authenticated-fetch-ready': Fetch;
-        login: AuthSession;
-        logout: void;
+        'auth:fetch-ready': Fetch;
+        'auth:before-login': void;
+        'auth:login': AuthSession;
+        'auth:logout': void;
+        'auth:after-logout': void;
+        'solid:user-profile-loaded': [SolidUserProfile, SolidStore];
     }
 }

package/src/testing/setup.ts

@@ -0,0 +1,11 @@
+import { FakeLocalStorage } from '@noeldemartin/testing';
+import { vi } from 'vitest';
+
+vi.mock('@aerogel/core', async () => {
+    const original = (await vi.importActual('@aerogel/core')) as object;
+
+    FakeLocalStorage.reset();
+    FakeLocalStorage.patchGlobal();
+
+    return original;
+});

package/src/types/env.d.ts

@@ -0,0 +1 @@
+/// <reference types="@aerogel/plugin-local-first" />

package/src/types/solid-auth-client.d.ts

@@ -0,0 +1,21 @@
+declare module 'solid-auth-client' {
+    export type Session = {
+        webId: string;
+    };
+
+    export class SolidAuthClient {
+
+        public fetch(...args: any[]): Promise<Response>;
+
+        public login(loginUrl: string): Promise<Session | void>;
+
+        public currentSession(): Promise<Session | void>;
+
+        public logout(): Promise<void>;
+    
+    }
+
+    const auth: SolidAuthClient;
+
+    export default auth;
+}