@venizia/ardor-admin 0.4.8-5 → 0.4.8-6

package/dist/common/types.d.ts

@@ -63,7 +63,10 @@ export interface IAuthRejection {
 }
 /** The auth provider of an ARDOR application: react-admin's methods, the user's roles and a token refresh. */
 export interface IAuthProvider extends IReactAdminAuthProvider {
-    /** The roles of the signed-in user. */
+    /**
+     * The roles of the signed-in user, as the browser holds them: they only show or hide interface, and
+     * the backend must check every permission on every request.
+     */
     getRoles: (params?: unknown) => Promise<Set<string>>;
     /** `true` when the session was refreshed, `false` when there is no refresh to make. */
     refreshToken: () => Promise<boolean>;

package/dist/components/application.js

@@ -1,10 +1,12 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
 import { LoggerFactory } from '@venizia/ignis-helpers/core';
+import { QueryClient } from '@tanstack/react-query';
 import { CoreAdmin, CustomRoutes, Resource } from 'ra-core';
 import { Provider as ReduxProvider } from 'react-redux';
 import { Route } from 'react-router-dom';
 import { Features } from '../features/feature.js';
+import { CoreBindings } from '@venizia/ardor-kernel';
 import { ApplicationContext } from '@venizia/ardor-react';
 import { ApplicationProviders } from './resolve.js';
 const Wrapper = ({ applicationName = 'ArdorApplication', container, reduxStore, suspense, logger, children, }) => {
@@ -70,7 +72,31 @@ export const ArdorApplication = (props) => {
     const providers = React.useMemo(() => {
         return ApplicationProviders.resolve({ container });
     }, [container]);
-    const adminProps = { ...providers, ...reactAdminProps };
+    // The cache is owned here, so it can be emptied when the session ends by any route (a sign-out
+    // button empties it itself; a failed refresh, or code that calls `cleanUp`, does not).
+    const queryClient = React.useMemo(() => {
+        return reactAdminProps.queryClient ?? new QueryClient();
+    }, [reactAdminProps.queryClient]);
+    React.useEffect(() => {
+        const authService = container.get({
+            key: CoreBindings.DEFAULT_AUTH_SERVICE,
+            isOptional: true,
+        });
+        return authService?.subscribe({
+            listener: () => {
+                if (!authService.getAuth()?.value) {
+                    // After the redirect to the sign-in page, as react-admin's own sign-out does.
+                    setTimeout(() => {
+                        // Not when the next user signed in meanwhile.
+                        if (!authService.getAuth()?.value) {
+                            queryClient.clear();
+                        }
+                    }, 0);
+                }
+            },
+        });
+    }, [container, queryClient]);
+    const adminProps = { ...providers, ...reactAdminProps, queryClient };
     const isMessagesReady = useFeatureMessagesReady({
         features,
         i18nProvider: providers.i18nProvider,

package/dist/components/resolve.d.ts

@@ -1,18 +1,28 @@
 import type { Container } from '@venizia/ignis-inversion';
 import type { I18nProvider } from 'ra-core';
 import type { IAuthProvider, IDataProvider } from '../common/index.js';
+interface IResolvedProviders {
+    dataProvider: IDataProvider;
+    authProvider?: IAuthProvider;
+    i18nProvider: I18nProvider;
+}
 /** Resolves the providers `ArdorApplication` hands to react-admin. */
 export declare class ApplicationProviders {
     /**
      * What `ArdorApplication` resolves from the container when it mounts: the one place, so a test of
-     * the boot resolves exactly what the app does.
+     * the boot resolves exactly what the app does. With `isAuthRequired: true`, for an application that
+     * always binds a sign-in, `authProvider` is typed as present and an unbound one throws.
      */
     static resolve(opts: {
         container: Container;
-    }): {
-        dataProvider: IDataProvider;
-        authProvider?: IAuthProvider;
-        i18nProvider: I18nProvider;
+        isAuthRequired: true;
+    }): IResolvedProviders & {
+        authProvider: IAuthProvider;
     };
+    static resolve(opts: {
+        container: Container;
+        isAuthRequired?: boolean;
+    }): IResolvedProviders;
 }
+export {};
 //# sourceMappingURL=resolve.d.ts.map

package/dist/components/resolve.js

@@ -1,12 +1,8 @@
 import { CoreBindings } from '@venizia/ardor-kernel';
 /** Resolves the providers `ArdorApplication` hands to react-admin. */
 export class ApplicationProviders {
-    /**
-     * What `ArdorApplication` resolves from the container when it mounts: the one place, so a test of
-     * the boot resolves exactly what the app does.
-     */
     static resolve(opts) {
-        const { container } = opts;
+        const { container, isAuthRequired } = opts;
         const dataProvider = container.get({
             key: CoreBindings.DEFAULT_REST_DATA_PROVIDER,
         });
@@ -14,7 +10,7 @@ export class ApplicationProviders {
         // without an auth provider - every page is public.
         const authProvider = container.get({
             key: CoreBindings.DEFAULT_AUTH_PROVIDER,
-            isOptional: true,
+            isOptional: !isAuthRequired,
         });
         const i18nProvider = container.get({
             key: CoreBindings.DEFAULT_I18N_PROVIDER,

package/dist/providers/auth.d.ts

@@ -68,8 +68,8 @@ export declare class DefaultAuthProvider<TResource extends string = string> exte
     private hookQueue;
     /** Where `login` posts: `paths.signIn`, else the IGNIS auth controller's route. */
     protected get signInPath(): string;
-    /** Where the admin goes once `login` resolves: `paths.afterLogin`, else `/`. */
-    protected get afterLoginPath(): string;
+    /** Where the admin goes once `login` resolves: `paths.afterLogin`, else `/`; `false` stays on the page. */
+    protected get afterLoginPath(): string | false;
     /** The route of the login page, which `checkAuth` and a `401` redirect to. */
     protected get loginPagePath(): string;
     /** The route a `403` redirects to; the application mounts it. */
@@ -171,9 +171,16 @@ export declare class DefaultAuthProvider<TResource extends string = string> exte
     private clearSession;
     /** Announces the session in the store, when there is one. */
     private startStoredSession;
+    /**
+     * Runs when the session is gone, however it ended (sign-out, a `401`, a failed refresh, other
+     * code calling `cleanUp`): removes what the user stored under the store prefix of this
+     * application (`@app/store/`, or `@app/store/<id>/` with an application `id`) in `localStorage` and `sessionStorage`, so the next user does not see it.
+     * Override it to keep preferences, or put them under another prefix.
+     */
+    protected clearStoredData(): void;
     /**
      * Posts the sign-in body to `signInPath`, stores the session and resolves `{ ...response,
-     * redirectTo }`, where `redirectTo` is `afterLoginPath`. Rejects when the request fails, when the
+     * redirectTo }`, where `redirectTo` is `afterLoginPath` (`false` when it is `false`). Rejects when the request fails, when the
      * response carries no token or user id, or when `beforeSaveSession` throws; no session is stored
      * then. Typed `Promise<unknown>` so that a subclass override of `login` keeps compiling.
      */
@@ -196,7 +203,10 @@ export declare class DefaultAuthProvider<TResource extends string = string> exte
     getIdentity(_params?: unknown): Promise<any>;
     /** Resolves with nothing; the roles come from `getRoles`. */
     getPermissions(_params?: unknown): Promise<void>;
-    /** Resolves the roles of the stored session. */
+    /**
+     * Resolves the roles of the stored session. They are read from browser storage, which the user can
+     * edit: use them to show or hide interface only, and let the backend check every permission.
+     */
     getRoles(_params?: unknown): Promise<Set<string>>;
     /**
      * Refreshes the session through the network service's `refresh`, the one place a refresh is made:

package/dist/providers/auth.js

@@ -13,7 +13,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 var DefaultAuthProvider_1;
 import { getError, inject } from '@venizia/ignis-inversion';
 import { removeDoubleSlashes } from 'ra-core';
-import { BaseProvider, CoreBindings, RequestMethods, } from '@venizia/ardor-kernel';
+import { BaseProvider, BrowserStorage, CoreBindings, LocalStorageKeys, RequestMethods, StorageAreas, } from '@venizia/ardor-kernel';
 /** Why `onSessionCleared` was called. */
 export class SessionClearReasons {
     /** `logout` ran. */
@@ -84,7 +84,7 @@ let DefaultAuthProvider = DefaultAuthProvider_1 = class DefaultAuthProvider exte
     get signInPath() {
         return this.authProviderOptions.paths?.signIn ?? '/auth/sign-in';
     }
-    /** Where the admin goes once `login` resolves: `paths.afterLogin`, else `/`. */
+    /** Where the admin goes once `login` resolves: `paths.afterLogin`, else `/`; `false` stays on the page. */
     get afterLoginPath() {
         return this.authProviderOptions.paths?.afterLogin ?? '/';
     }
@@ -293,9 +293,17 @@ let DefaultAuthProvider = DefaultAuthProvider_1 = class DefaultAuthProvider exte
     }
     /** Announces or ends the session after the service saved or cleared it. */
     syncSession() {
-        return this.authService.getAuth()?.value
-            ? this.startStoredSession()
-            : this.endSession({ reason: this.clearing ?? SessionClearReasons.EXTERNAL });
+        if (this.authService.getAuth()?.value) {
+            return this.startStoredSession();
+        }
+        try {
+            this.clearStoredData();
+        }
+        catch (error) {
+            // An override that throws must not stop the session from ending.
+            this.logger.error('[clearStoredData] failed, the session ends anyway | error: %o', error);
+        }
+        return this.endSession({ reason: this.clearing ?? SessionClearReasons.EXTERNAL });
     }
     async clearSession(opts) {
         this.clearing = opts.reason;
@@ -315,10 +323,21 @@ let DefaultAuthProvider = DefaultAuthProvider_1 = class DefaultAuthProvider exte
         }
         return this.startSession({ token, user: this.authService.getUser() });
     }
+    /**
+     * Runs when the session is gone, however it ended (sign-out, a `401`, a failed refresh, other
+     * code calling `cleanUp`): removes what the user stored under the store prefix of this
+     * application (`@app/store/`, or `@app/store/<id>/` with an application `id`) in `localStorage` and `sessionStorage`, so the next user does not see it.
+     * Override it to keep preferences, or put them under another prefix.
+     */
+    clearStoredData() {
+        const prefix = this.authService.keys.storePrefix;
+        BrowserStorage.removeWhere({ storage: StorageAreas.LOCAL, prefix });
+        BrowserStorage.removeWhere({ storage: StorageAreas.SESSION, prefix });
+    }
     // --- react-admin's auth provider -------------------------------------------------------------
     /**
      * Posts the sign-in body to `signInPath`, stores the session and resolves `{ ...response,
-     * redirectTo }`, where `redirectTo` is `afterLoginPath`. Rejects when the request fails, when the
+     * redirectTo }`, where `redirectTo` is `afterLoginPath` (`false` when it is `false`). Rejects when the request fails, when the
      * response carries no token or user id, or when `beforeSaveSession` throws; no session is stored
      * then. Typed `Promise<unknown>` so that a subclass override of `login` keeps compiling.
      */
@@ -337,9 +356,10 @@ let DefaultAuthProvider = DefaultAuthProvider_1 = class DefaultAuthProvider exte
         await this.startSession(stored?.value === session.token.value
             ? { token: stored, user: this.authService.getUser() }
             : { token: session.token, user: { userId: session.userId, username } });
+        const afterLogin = this.afterLoginPath;
         return {
             ...response,
-            redirectTo: removeDoubleSlashes(`/${this.afterLoginPath}`),
+            redirectTo: afterLogin === false ? false : removeDoubleSlashes(`/${afterLogin}`),
         };
     }
     /** Clears the session and resolves. */
@@ -410,7 +430,10 @@ let DefaultAuthProvider = DefaultAuthProvider_1 = class DefaultAuthProvider exte
     getPermissions(_params) {
         return Promise.resolve();
     }
-    /** Resolves the roles of the stored session. */
+    /**
+     * Resolves the roles of the stored session. They are read from browser storage, which the user can
+     * edit: use them to show or hide interface only, and let the backend check every permission.
+     */
     getRoles(_params) {
         return Promise.resolve(this.authService.getRoles());
     }
@@ -440,6 +463,18 @@ let DefaultAuthProvider = DefaultAuthProvider_1 = class DefaultAuthProvider exte
         return isRefreshed;
     }
     value(container) {
+        // A subclass of DefaultAuthService with its own constructor must forward the application info to
+        // super(info): without it the service keeps the unscoped session, silently shared with every other
+        // application of the origin. Refuse that here, where the application info is at hand.
+        const id = container.get({
+            key: CoreBindings.APPLICATION_INFO,
+            isOptional: true,
+        })?.id;
+        if (id !== undefined && this.authService.keys.token !== LocalStorageKeys.scoped({ id }).token) {
+            throw getError({
+                message: `[DefaultAuthProvider] The auth service does not use the application id '${id}': a subclass of DefaultAuthService with its own constructor passes the application info to super(info)`,
+            });
+        }
         // A subclass with its own constructor rarely forwards the optional 4th argument to `super`.
         const permissionProvider = this.permissionProvider ??
             container.get({

package/dist/providers/rest-data.d.ts

@@ -1,6 +1,6 @@
 import { type Container } from '@venizia/ignis-inversion';
 import type { CreateParams, CreateResult, DeleteManyParams, DeleteManyResult, DeleteParams, DeleteResult, GetListParams, GetListResult, GetManyParams, GetManyReferenceParams, GetManyReferenceResult, GetManyResult, GetOneParams, GetOneResult, Identifier, QueryFunctionContext, RaRecord, UpdateManyParams, UpdateManyResult, UpdateParams, UpdateResult } from 'ra-core';
-import { BaseProvider, DefaultNetworkRequestService, type IApplicationInfo, type INetworkResponse, type ICustomParams, type IRestDataProviderOptions, type ISendParams, type TRequestType } from '@venizia/ardor-kernel';
+import { BaseProvider, type DefaultAuthService, DefaultNetworkRequestService, type IApplicationInfo, type INetworkResponse, type ICustomParams, type IRestDataProviderOptions, type ISendParams, type TRequestType } from '@venizia/ardor-kernel';
 import type { TExtraRequest } from '@venizia/ignis-kernel/repository';
 import type { IDataProvider, IRestRequestOptions } from '../common/index.js';
 import { type IListFilter } from './list-filter.js';
@@ -35,7 +35,8 @@ export declare class DefaultRestDataProvider<TResource extends string = string>
     protected restDataProviderOptions: IRestDataProviderOptions;
     protected applicationInfo: IApplicationInfo;
     private cachedNetworkService?;
-    private authService?;
+    /** The auth service of the container, set when `value` builds the provider; pass it to the network service you return from `createNetworkService`. */
+    protected authService?: DefaultAuthService;
     constructor(restDataProviderOptions: IRestDataProviderOptions, applicationInfo: IApplicationInfo);
     /**
      * Builds the network service this provider sends through. Override it to return a subclass of

package/dist/providers/rest-data.js

@@ -14,6 +14,25 @@ var DefaultRestDataProvider_1;
 import { getError, inject } from '@venizia/ignis-inversion';
 import { BaseProvider, CoreBindings, DefaultNetworkRequestService, ValueUtility, NetworkHeaders, RequestCountData, RequestMethods, RequestTypes, } from '@venizia/ardor-kernel';
 import { ListFilterBuilder } from './list-filter.js';
+/**
+ * The path of one record: the id is a single path segment, whatever characters it holds. An empty
+ * id, `.` and `..` (dot segments even when written `%2E`) and a lone surrogate (which cannot be
+ * encoded) are refused, without naming the id.
+ */
+const recordPaths = (opts) => {
+    let segment = '';
+    try {
+        segment = encodeURIComponent(`${opts.id}`);
+        // eslint-disable-next-line venizia/no-silent-catch -- a lone surrogate cannot be encoded: the empty segment below refuses it
+    }
+    catch {
+        segment = '';
+    }
+    if (segment === '' || segment === '.' || segment === '..') {
+        throw getError({ message: '[recordPaths] The record id is not a valid path segment' });
+    }
+    return [opts.resource, segment];
+};
 /**
  * The react-admin data provider over an IGNIS REST API. Each method takes one `opts` object
  * (`{ resource, params }`) and resolves the result react-admin expects; it rejects with the error
@@ -167,7 +186,7 @@ let DefaultRestDataProvider = DefaultRestDataProvider_1 = class DefaultRestDataP
             resource,
             type: RequestTypes.GET_ONE,
             method: RequestMethods.GET,
-            paths: [resource, `${params.id}`],
+            paths: recordPaths({ resource, id: params.id }),
             query: { ...queryKey, filter },
         });
     }
@@ -217,7 +236,7 @@ let DefaultRestDataProvider = DefaultRestDataProvider_1 = class DefaultRestDataP
             resource,
             type: RequestTypes.UPDATE,
             method: RequestMethods.PATCH,
-            paths: [resource, `${params.id}`],
+            paths: recordPaths({ resource, id: params.id }),
             body: params.data,
         });
     }
@@ -265,7 +284,7 @@ let DefaultRestDataProvider = DefaultRestDataProvider_1 = class DefaultRestDataP
             resource,
             type: RequestTypes.DELETE,
             method: RequestMethods.DELETE,
-            paths: [resource, `${params.id}`],
+            paths: recordPaths({ resource, id: params.id }),
         });
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@venizia/ardor-admin",
-  "version": "0.4.8-5",
+  "version": "0.4.8-6",
   "description": "ARDOR react-admin adapter - the REST data provider, auth provider and i18n provider wired through IGNIS inversion, the ArdorApplication root component, the translate and notify hooks, and the English and Vietnamese message bundles.",
   "keywords": [
     "admin",
@@ -61,8 +61,8 @@
     "prepublishOnly": "make rebuild"
   },
   "dependencies": {
-    "@venizia/ardor-kernel": "0.4.8-5",
-    "@venizia/ardor-react": "0.4.8-5"
+    "@venizia/ardor-kernel": "0.4.8-6",
+    "@venizia/ardor-react": "0.4.8-6"
   },
   "devDependencies": {
     "@happy-dom/global-registrator": "^21.0.4",
@@ -73,10 +73,10 @@
     "@types/bun": "^1.4.3",
     "@types/react": "^19",
     "@venizia/dev-configs": "^0.4.8-2",
-    "@venizia/ignis-filter": "^0.4.7-2",
-    "@venizia/ignis-helpers": "^0.4.8-4",
+    "@venizia/ignis-filter": "^0.4.7-3",
+    "@venizia/ignis-helpers": "^0.4.8-5",
     "@venizia/ignis-inversion": "^0.4.7-2",
-    "@venizia/ignis-kernel": "^0.4.8-4",
+    "@venizia/ignis-kernel": "^0.4.8-5",
     "eslint": "^10.13.0",
     "oxlint": "1.89.0",
     "oxlint-tsgolint": "7.0.2004",
@@ -94,10 +94,10 @@
   "peerDependencies": {
     "@reduxjs/toolkit": ">=2.13.0",
     "@tanstack/react-query": ">=5.104.5",
-    "@venizia/ignis-filter": "^0.4.7-2",
-    "@venizia/ignis-helpers": "^0.4.8-4",
+    "@venizia/ignis-filter": "^0.4.7-3",
+    "@venizia/ignis-helpers": "^0.4.8-5",
     "@venizia/ignis-inversion": "^0.4.7-2",
-    "@venizia/ignis-kernel": "^0.4.8-4",
+    "@venizia/ignis-kernel": "^0.4.8-5",
     "ra-core": ">=5.15.5",
     "ra-i18n-polyglot": ">=5.15.5",
     "react": ">=19.3.1",
@@ -124,7 +124,7 @@
         "react-redux",
         "react-router-dom"
       ],
-      "limit": "10850 B"
+      "limit": "11200 B"
     }
   ],
   "engines": {