@datalayer/core 0.0.1 → 0.0.3

package/lib/state/substates/IAMState.js

@@ -0,0 +1,291 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { Poll } from '@lumino/polling';
+import { useStore } from 'zustand';
+import { createStore } from 'zustand/vanilla';
+import { ANONYMOUS_USER_TOKEN, ANONYMOUS_USER, asUser, IAMProvidersSpecs } from '../../models';
+import { getStoredToken, getStoredUser, loadRefreshTokenFromCookie, storeToken, storeUser } from '../storage';
+import { requestDatalayerAPI } from '../../api';
+import { getCookie, setCookie, deleteCookie } from '../../utils';
+import { coreStore } from './CoreState';
+/**
+ * Limit to warn about low credits in milliseconds.
+ */
+export const RESERVATION_WARNING_TIME_MS = 5 * 60_000;
+export const iamStore = createStore((set, get) => {
+    return {
+        credits: undefined,
+        creditsReservations: [],
+        externalToken: loadRefreshTokenFromCookie() ?? undefined,
+        user: getStoredUser(),
+        token: getStoredToken(),
+        iamRunUrl: coreStore.getState().configuration?.iamRunUrl,
+        iamProvidersAuthorizationURL: {},
+        version: '',
+        addIAMProviderAuthorizationURL: (provider, authorizationURL) => {
+            set(state => ({
+                iamProvidersAuthorizationURL: {
+                    ...state.iamProvidersAuthorizationURL,
+                    [provider]: authorizationURL,
+                }
+            }));
+        },
+        login: async (token) => {
+            const { refreshUserByToken, iamRunUrl, logout } = get();
+            try {
+                const resp = await requestDatalayerAPI({
+                    url: `${iamRunUrl}/api/iam/v1/login`,
+                    method: 'POST',
+                    body: { token },
+                });
+                if (resp.success && resp.token) {
+                    refreshUserByToken(resp.token);
+                }
+                else {
+                    throw new Error('Invalid Token.');
+                }
+            }
+            catch (error) {
+                console.debug('Failed to login.', error);
+                if (error.name === 'RunResponseError' && error.response.status === 401) {
+                    console.debug('Received 401 error - Logging out.');
+                    logout();
+                }
+                throw error;
+            }
+        },
+        logout: () => {
+            storeUser();
+            storeToken();
+            set({
+                credits: undefined,
+                creditsReservations: [],
+                user: ANONYMOUS_USER,
+                token: ANONYMOUS_USER_TOKEN,
+                // externalToken: ANONYMOUS_EXTERNAL_TOKEN, // !!! Do not do that... otherwise the automatic login with refresh_token cookie will break!!!
+            });
+        },
+        checkIAMToken: async (token) => {
+            if (get().token !== token) {
+                await get().refreshUserByToken(token);
+            }
+        },
+        setIAMProviderAccessToken: (provider, accessToken) => {
+            const { user } = get();
+            if (!user) {
+                throw Error('You need to be authenticated to set an Access Token for an IAM provider.');
+            }
+            const iamProvider = IAMProvidersSpecs.getProvider(provider);
+            if (accessToken) {
+                setCookie(iamProvider.accessTokenCookieName(user), accessToken);
+            }
+            else {
+                deleteCookie(iamProvider.accessTokenCookieName(user));
+            }
+        },
+        // TODO passing the user as param for now, could/should be changed? If so, check the profile pages are still working on refresh...
+        getIAMProviderAccessToken: (user, provider) => {
+            const iamProvider = IAMProvidersSpecs.getProvider(provider);
+            const cookieName = iamProvider.accessTokenCookieName(user);
+            const accessToken = getCookie(cookieName);
+            return accessToken;
+        },
+        updateUser: (user) => set((state) => {
+            const updatedState = {
+                user: {
+                    ...state.user,
+                    ...user,
+                }
+            };
+            /*
+            if (state.user?.email && !updatedState.user.email) {
+              updatedState.user.email = state.user.email;
+            }
+            */
+            return updatedState;
+        }),
+        refreshCredits: async () => {
+            const { externalToken, token, iamRunUrl, logout } = get();
+            if (token) {
+                try {
+                    const creditsRaw = await requestDatalayerAPI({
+                        url: `${iamRunUrl}/api/iam/v1/usage/credits`,
+                        token,
+                        headers: externalToken
+                            ? {
+                                'X-External-Token': externalToken
+                            }
+                            : undefined
+                    });
+                    const { credits, reservations: creditsReservations = [] } = creditsRaw;
+                    let available = credits.quota !== null
+                        ? credits.quota - credits.credits
+                        : credits.credits;
+                    available -= creditsReservations.reduce((consumed, reservation) => consumed + reservation.credits, 0);
+                    set({
+                        credits: { ...credits, available: Math.max(0, available) },
+                        creditsReservations: creditsReservations
+                    });
+                }
+                catch (error) {
+                    console.error('Failed to refresh user credits.', error);
+                    if (error.name === 'RunResponseError' &&
+                        error.response.status === 401) {
+                        console.error('Received 401, logging out.');
+                        logout();
+                    }
+                    throw error;
+                }
+            }
+            else {
+                set({ credits: undefined });
+            }
+        },
+        refreshUser: async () => {
+            const { token, refreshUserByToken, logout } = get();
+            if (token) {
+                await refreshUserByToken(token);
+            }
+            else {
+                logout();
+            }
+        },
+        refreshUserByTokenStored: async () => {
+            const token = getStoredToken();
+            if (token) {
+                await get().refreshUserByToken(token);
+            }
+            else {
+                get().logout();
+            }
+        },
+        refreshUserByToken: async (token) => {
+            const { iamRunUrl, logout } = get();
+            try {
+                const data = await requestDatalayerAPI({
+                    url: `${iamRunUrl}/api/iam/v1/whoami`,
+                    token,
+                });
+                const user = asUser(data.profile);
+                storeUser(user);
+                storeToken(token);
+                set(() => ({ user, token }));
+                // TODO Centralize User Setting Management.
+                const aiagentsRunUrl = user.settings?.aiAgentsUrl;
+                if (aiagentsRunUrl) {
+                    coreStore.getState().setConfiguration({
+                        aiagentsRunUrl,
+                    });
+                }
+            }
+            catch (error) {
+                if (error.name === 'RunResponseError' &&
+                    error.response.status === 401) {
+                    console.debug('Invalid token - Received 401 error.');
+                }
+                else {
+                    console.debug('Failed to fetch user identity.', error);
+                }
+                logout();
+            }
+        },
+        setExternalToken: (externalToken) => set((state) => { return { externalToken }; }),
+        setLogin: (user, token) => set((state) => {
+            storeUser(user);
+            storeToken(token);
+            return {
+                user,
+                token
+            };
+        }),
+        setVersion: version => {
+            if (version && !get().version) {
+                set(state => ({ version }));
+            }
+        },
+    };
+});
+export function useIAMStore(selector) {
+    return useStore(iamStore, selector);
+}
+// Poll user credits.
+const creditsPoll = new Poll({
+    name: '@datalayer/ui:credits-refresh',
+    factory: () => iamStore.getState().refreshCredits(),
+    auto: false,
+    frequency: {
+        interval: 60 * 1000,
+        backoff: true,
+        max: 600 * 1000
+    },
+    standby: () => (iamStore.getState().user?.id ? 'when-hidden' : true)
+});
+// Initialize the IAM store with the stored token if it is valid.
+iamStore
+    .getState()
+    .refreshUserByTokenStored()
+    .catch(reason => {
+    console.error('Failed to refresh to validate the stored token.', reason);
+})
+    .finally(() => {
+    const { externalToken, iamRunUrl, checkIAMToken, token } = iamStore.getState();
+    // If the stored token is invalid and an external token exists, try authenticating with it.
+    if (!token && externalToken) {
+        console.debug('Can not login with token - Trying with the external token.');
+        requestDatalayerAPI({
+            url: `${iamRunUrl}/api/iam/v1/login`,
+            method: 'POST',
+            body: { token: externalToken }
+        })
+            .then(response => {
+            if (response.token) {
+                checkIAMToken(response.token);
+            }
+        })
+            .catch(reason => {
+            console.debug('Can not login with token.', token, reason);
+        });
+    }
+    if (token) {
+        console.log('Logged in with token and external token.');
+    }
+    else {
+        console.debug('Failed to login with token and no external token available.');
+    }
+    // Start the credits poll in any case after trying to validate the user token.
+    creditsPoll.start();
+    // Force a refresh when the user comeback to the application tab
+    // Useful for checkout platform redirecting to another tab to add credits.
+    document.addEventListener('visibilitychange', () => {
+        if (!document.hidden && iamStore.getState().user?.id) {
+            creditsPoll.refresh();
+        }
+    });
+});
+// Connect the core store with the iam store.
+coreStore.subscribe((state, prevState) => {
+    if (state.configuration?.iamRunUrl &&
+        state.configuration.iamRunUrl !== prevState.configuration?.iamRunUrl) {
+        const iamRunUrl = state.configuration.iamRunUrl;
+        console.log('Updating iamRunUrl with new value', iamRunUrl);
+        iamStore.setState({ iamRunUrl });
+        // Check the token is valid with the new server.
+        if (iamStore.getState().externalToken) {
+            iamStore.getState()
+                .login(iamStore.getState().externalToken)
+                .catch(reason => {
+                console.error('Failed to refresh the user after updating the IAM RUN URL.', reason);
+            });
+        }
+        else {
+            iamStore.getState()
+                .refreshUser()
+                .catch(reason => {
+                console.error('Failed to refresh the user after updating the IAM server URL.', reason);
+            });
+        }
+    }
+});
+export default useIAMStore;

package/lib/state/substates/JupyterLabState.d.ts

@@ -0,0 +1,16 @@
+import { JupyterLabAppAdapter } from '@datalayer/jupyter-react';
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+export type Plugin = JupyterFrontEndPlugin<any, any, any> & {
+    service: any;
+};
+export type IJupyterLabState = {
+    jupyterLabAdapter?: JupyterLabAppAdapter;
+};
+export type JupyterLabState = IJupyterLabState & {
+    setJupyterLabAdapter: (jupyterLabAdapter?: JupyterLabAppAdapter) => void;
+    plugin: (id: string) => Plugin | undefined;
+};
+export declare const jupyterLabStore: import("zustand").StoreApi<JupyterLabState>;
+export declare function useJupyterLabStore(): JupyterLabState;
+export declare function useJupyterLabStore<T>(selector: (state: JupyterLabState) => T): T;
+export default useJupyterLabStore;

package/lib/state/substates/JupyterLabState.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { createStore } from 'zustand/vanilla';
+import { useStore } from 'zustand';
+export const jupyterLabStore = createStore((set, get) => ({
+    jupyterLabAdapter: undefined,
+    setJupyterLabAdapter: (jupyterLabAdapter) => set((state) => ({ jupyterLabAdapter })),
+    plugin: (id) => {
+        return get().jupyterLabAdapter?.plugin(id);
+    }
+}));
+export function useJupyterLabStore(selector) {
+    return useStore(jupyterLabStore, selector);
+}
+export default useJupyterLabStore;

package/lib/state/substates/LayoutState.d.ts

@@ -0,0 +1,62 @@
+import { ReactPortal } from "react";
+import { IAnyOrganization, IAnySpace, IAnyTeam, ISpaceItem } from "../../models";
+export type BannerDisplayVariant = 'danger' | 'info' | 'success' | 'warning';
+export type LeftSidebarVariant = 'codefeed' | 'course' | 'empty' | 'guess-account' | 'guess-space' | 'guess-spaces' | 'organization' | 'organization-space' | 'organization-spaces' | 'organizations' | 'public' | 'unchanged' | 'user' | 'user-space' | 'user-spaces';
+export type BackdropDisplay = {
+    open: boolean;
+    message?: string | void;
+};
+type BannerDisplay = {
+    message: string;
+    variant: BannerDisplayVariant;
+    timestamp?: Date;
+};
+type PortalDisplay = {
+    portal: ReactPortal;
+    pinned: boolean;
+};
+export type ScreenshotDisplay = {
+    open: boolean;
+    message?: string | void;
+};
+export type ILayoutState = {
+    backdrop?: BackdropDisplay;
+    banner?: BannerDisplay;
+    bootstrapped: boolean;
+    item?: ISpaceItem;
+    itemsRefreshCount: number;
+    leftPortal?: PortalDisplay;
+    leftSidebarVariant: LeftSidebarVariant;
+    organization?: IAnyOrganization;
+    rightPortal?: PortalDisplay;
+    screenCapture?: string;
+    screenshot?: ScreenshotDisplay;
+    space?: IAnySpace;
+    team?: IAnyTeam;
+};
+export type LayoutState = ILayoutState & {
+    hideBackdrop: () => void;
+    hideScreenshot: () => void;
+    reset: () => void;
+    resetForcedLeftPortal: () => void;
+    resetForcedRightPortal: () => void;
+    resetLeftPortal: () => void;
+    resetRightPortal: () => void;
+    setBanner: (bannerDisplay: BannerDisplay) => void;
+    setBootstrapped: (bootstrapped: boolean) => void;
+    setItem: (item?: ISpaceItem) => void;
+    setLeftPortal: (leftPortal: PortalDisplay) => void;
+    setLeftSidebarVariant: (leftSidebarVariant: LeftSidebarVariant) => void;
+    setRightPortal: (rightPortal: PortalDisplay) => void;
+    setScreenCapture: (screenCapture?: string) => void;
+    showBackdrop: (message?: string) => void;
+    showScreenshot: (message?: string) => void;
+    triggerItemsRefresh: () => void;
+    updateLayoutOrganization: (organization?: Partial<IAnyOrganization>) => void;
+    updateLayoutSpace: (space?: Partial<IAnySpace>) => void;
+    updateLayoutTeam: (team?: Partial<IAnyTeam>) => void;
+};
+export declare const layoutStore: import("zustand").StoreApi<LayoutState>;
+export declare function useLayoutStore(): LayoutState;
+export declare function useLayoutStore<T>(selector: (state: LayoutState) => T): T;
+export default useLayoutStore;

package/lib/state/substates/LayoutState.js

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { createStore } from 'zustand/vanilla';
+import { useStore } from 'zustand';
+export const layoutStore = createStore((set, get) => ({
+    backdrop: undefined,
+    banner: undefined,
+    bootstrapped: false,
+    item: undefined,
+    itemsRefreshCount: 0,
+    leftPortal: undefined,
+    leftSidebarVariant: 'empty',
+    organization: undefined,
+    rightPortal: undefined,
+    screenCapture: undefined,
+    space: undefined,
+    team: undefined,
+    hideBackdrop: () => set((state) => ({ backdrop: { open: false, message: undefined } })),
+    hideScreenshot: () => set((state) => ({ screenshot: { open: false, message: undefined } })),
+    setBootstrapped: (bootstrapped) => set((state) => ({ bootstrapped })),
+    showBackdrop: (message) => set((state) => ({ backdrop: { open: true, message } })),
+    showScreenshot: (message) => set((state) => ({ screenshot: { open: true, message } })),
+    setBanner: (bannerDisplay) => set((state) => ({
+        banner: {
+            timestamp: new Date(),
+            message: bannerDisplay.message,
+            variant: bannerDisplay.variant,
+        }
+    })),
+    setLeftPortal: (leftPortal) => set((state) => ({ leftPortal })),
+    setRightPortal: (rightPortal) => set((state) => ({ rightPortal })),
+    resetLeftPortal: () => set((state) => ({ leftPortal: state.leftPortal?.pinned ? state.leftPortal : undefined, })),
+    resetRightPortal: () => set((state) => ({ rightPortal: state.rightPortal?.pinned ? state.rightPortal : undefined, })),
+    resetForcedLeftPortal: () => set((state) => ({ leftPortal: undefined })),
+    resetForcedRightPortal: () => set((state) => ({ rightPortal: undefined })),
+    setLeftSidebarVariant: (leftSidebarVariant) => set((state) => ({ leftSidebarVariant })),
+    updateLayoutOrganization: (organization) => set((state) => {
+        return ({
+            organization: organization ? {
+                ...state.organization,
+                ...organization,
+            }
+                : undefined
+        });
+    }),
+    updateLayoutTeam: (team) => set((state) => {
+        return ({
+            team: team ? {
+                ...state.team,
+                ...team,
+            }
+                : undefined
+        });
+    }),
+    updateLayoutSpace: (space) => set((state) => {
+        return ({
+            space: space ? {
+                ...state.space,
+                ...space,
+            }
+                : undefined
+        });
+    }),
+    setItem: (item) => set((state) => ({ item })),
+    triggerItemsRefresh: () => set((state) => ({ itemsRefreshCount: state.itemsRefreshCount + 1 })),
+    setScreenCapture: (screenCapture) => set((state) => ({ screenCapture })),
+    reset: () => set((state) => ({ bootstrapped: false, })),
+}));
+export function useLayoutStore(selector) {
+    return useStore(layoutStore, selector);
+}
+export default useLayoutStore;

package/lib/state/substates/NbformatState.d.ts

@@ -0,0 +1,13 @@
+type SaveRequest = {
+    counter: number;
+};
+export type INbformatState = {
+    saveRequest: SaveRequest;
+};
+export type NbformatState = INbformatState & {
+    save: (saveRequest: SaveRequest) => void;
+};
+export declare const nbformatStore: import("zustand").StoreApi<NbformatState>;
+export declare function useNbformatStore(): NbformatState;
+export declare function useNbformatStore<T>(selector: (state: NbformatState) => T): T;
+export default useNbformatStore;

package/lib/state/substates/NbformatState.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { createStore } from 'zustand/vanilla';
+import { useStore } from 'zustand';
+export const nbformatStore = createStore((set, get) => ({
+    saveRequest: {
+        counter: -1,
+    },
+    save: (saveRequest) => set((state) => ({ saveRequest })),
+}));
+export function useNbformatStore(selector) {
+    return useStore(nbformatStore, selector);
+}
+export default useNbformatStore;

package/lib/state/substates/OrganizationState.d.ts

@@ -0,0 +1,11 @@
+import { IAnyOrganization } from '../../models';
+export type IOrganizationState = {
+    organizations: IAnyOrganization[];
+};
+export type OrganizationState = IOrganizationState & {
+    updateOrganizations: (organizations: IAnyOrganization[]) => void;
+};
+export declare const organizationStore: import("zustand").StoreApi<OrganizationState>;
+export declare function useOrganizationStore(): OrganizationState;
+export declare function useOrganizationStore<T>(selector: (state: OrganizationState) => T): T;
+export default useOrganizationStore;

package/lib/state/substates/OrganizationState.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { createStore } from 'zustand/vanilla';
+import { useStore } from 'zustand';
+export const organizationStore = createStore((set, get) => ({
+    organizations: [],
+    updateOrganizations: (organizations) => set((state) => ({
+        organizations
+    })),
+}));
+export function useOrganizationStore(selector) {
+    return useStore(organizationStore, selector);
+}
+export default useOrganizationStore;

package/lib/state/substates/RuntimesState.d.ts

@@ -0,0 +1,88 @@
+import type { JupyterLabAppAdapter } from '@datalayer/jupyter-react';
+import type { IMultiServiceManager } from '../../api';
+import type { IRuntimesConfiguration } from '../../config';
+import type { IRuntimePod, IRuntimeSnapshot, IRuntimeModel } from '../../models';
+/**
+ * Datalayer Runtimes state.
+ */
+export type RuntimesState = {
+    /**
+     * Runtimes configuration
+     */
+    configuration: IRuntimesConfiguration;
+    setConfiguration: (config: IRuntimesConfiguration) => void;
+    /**
+     * Runtimes RUN URL.
+     */
+    runtimesRunUrl: string;
+    /**
+     * JupyterLabApp adapter.
+     */
+    jupyterLabAdapter?: JupyterLabAppAdapter;
+    /**
+     * Set the JupyterLabAdapter.
+     */
+    setJupyterLabAdapter: (jupyterLabAdapter: JupyterLabAppAdapter) => void;
+    tab: number;
+    getIntTab: () => number;
+    setTab: (tab: number) => void;
+    /**
+     * Runtime pods.
+     */
+    runtimePods: IRuntimePod[];
+    /**
+     * Refresh the runtime pods.
+     */
+    refreshRuntimePods: () => Promise<void>;
+    /**
+     * Cached runtime models.
+     */
+    runtimeModels: readonly IRuntimeModel[];
+    /**
+     * Add a runtime model.
+     */
+    addRuntimeModel: (model: IRuntimeModel) => void;
+    /**
+     * Remove a runtime model by ID.
+     */
+    removeRuntimeModel: (id: string) => void;
+    /**
+     * Set the runtimes models list.
+     */
+    setRuntimeModels: (models: readonly IRuntimeModel[]) => void;
+    /**
+     * Jupyter service manager.
+     */
+    multiServiceManager?: IMultiServiceManager;
+    setMultiServiceManager: (multiServiceManager: IMultiServiceManager) => void;
+    showDisclaimer: boolean;
+    setShowDisclaimer: (showDisclaimer: boolean) => void;
+    /**
+     * Runtime snapshots.
+     */
+    runtimeSnapshots: readonly IRuntimeSnapshot[];
+    /**
+     * Add a runtime snapshot.
+     */
+    addRuntimeSnapshot: (snapshot: IRuntimeSnapshot) => void;
+    /**
+     * Remove a Runtime Snapshot.
+     */
+    removeRuntimeSnapshot: (id: string) => void;
+    /**
+     * Set Runtime Snapshots.
+     */
+    setRuntimeSnapshots: (snapshots: IRuntimeSnapshot[]) => void;
+    /**
+     * Package version.
+     */
+    version: string;
+    setVersion: (version: string) => void;
+};
+/**
+ * Kernel store
+ */
+export declare const runtimesStore: import("zustand").StoreApi<RuntimesState>;
+export declare function useRuntimesStore(): RuntimesState;
+export declare function useRuntimesStore<T>(selector: (state: RuntimesState) => T): T;
+export default useRuntimesStore;