@vc-shell/framework 1.2.4-beta.8 → 2.0.0-alpha.1

package/core/composables/useToolbar/index.ts

@@ -1,117 +0,0 @@
-import { inject, provide, computed, getCurrentInstance, getCurrentScope, onBeforeUnmount, onScopeDispose } from "vue";
-import type { ComputedRef } from "vue";
-import { BladeInstance, ToolbarServiceKey } from "@framework/injection-keys";
-import { IToolbarItem, IToolbarService, createToolbarService, toolbarBus } from "@core/services/toolbar-service";
-import { FALLBACK_BLADE_ID } from "@core/constants";
-import type { IBladeInstance } from "@shared/components/blade-navigation/types";
-
-// Global toolbar service (if not provided through provide/inject)
-let globalToolbarService: IToolbarService | null = null;
-
-export interface UseToolbarOptions {
-  /**
-   * Clears all toolbar items for the current blade on component unmount.
-   * Enabled by default for backward compatibility.
-   */
-  autoCleanup?: boolean;
-}
-
-export function provideToolbarService(): IToolbarService {
-  const existingService = inject(ToolbarServiceKey, null);
-  if (existingService) {
-    return existingService;
-  }
-
-  const service = createToolbarService();
-  provide(ToolbarServiceKey, service);
-
-  if (getCurrentScope()) {
-    onScopeDispose(() => toolbarBus.dispose(service));
-  }
-
-  return service;
-}
-
-/**
- * Composable for working with the toolbar
- * @returns Methods for managing toolbar buttons
- */
-export function useToolbar(options: UseToolbarOptions = {}) {
-  const { autoCleanup = true } = options;
-
-  // Try to get the service from dependency injection
-  const toolbarService = inject<IToolbarService | null>(ToolbarServiceKey, null);
-
-  // If the service is not injected, create a global one
-  if (!toolbarService && !globalToolbarService) {
-    globalToolbarService = createToolbarService();
-  }
-
-  const service = toolbarService || globalToolbarService;
-
-  if (!service) {
-    throw new Error("Toolbar service is not available");
-  }
-
-  // Get the ID of the current blade
-  const blade = inject<ComputedRef<IBladeInstance>>(
-    BladeInstance,
-    computed(() => ({
-      id: FALLBACK_BLADE_ID,
-      expandable: false,
-      maximized: false,
-      error: undefined,
-      navigation: undefined,
-      breadcrumbs: undefined,
-    })),
-  );
-
-  const bladeId = computed(() => blade.value?.id ?? FALLBACK_BLADE_ID);
-
-  // Functions for working with the toolbar
-  /**
-   * Registers a toolbar button
-   * @param toolbarItem - Toolbar button object
-   * @param toolbarItem.id - Unique identifier of the button
-   * @param toolbarItem.priority - Button priority (higher - more important, displayed at the beginning). Default is 0.
-   */
-  const resolveBladeId = (targetBladeId?: string): string => targetBladeId ?? bladeId.value;
-
-  const registerToolbarItem = (toolbarItem: IToolbarItem, targetBladeId?: string) => {
-    service.registerToolbarItem(toolbarItem, resolveBladeId(targetBladeId));
-  };
-
-  const unregisterToolbarItem = (toolbarItemId: string, targetBladeId?: string) => {
-    service.unregisterToolbarItem(toolbarItemId, resolveBladeId(targetBladeId));
-  };
-
-  const updateToolbarItem = (id: string, toolbarItem: Partial<IToolbarItem>, targetBladeId?: string) => {
-    service.updateToolbarItem({ id, bladeId: resolveBladeId(targetBladeId), toolbarItem });
-  };
-
-  const getToolbarItems = (targetBladeId?: string) => {
-    return service.getToolbarItems(resolveBladeId(targetBladeId));
-  };
-
-  const clearBladeToolbarItems = (targetBladeId?: string) => {
-    service.clearBladeToolbarItems(resolveBladeId(targetBladeId));
-  };
-
-  // Automatic cleanup when the component is unmounted
-  const instance = getCurrentInstance();
-  if (instance && autoCleanup) {
-    onBeforeUnmount(() => {
-      clearBladeToolbarItems();
-    });
-  }
-
-  return {
-    registerToolbarItem,
-    unregisterToolbarItem,
-    updateToolbarItem,
-    getToolbarItems,
-    clearBladeToolbarItems,
-    isToolbarItemRegistered: service.isToolbarItemRegistered,
-    registeredToolbarItems: service.registeredToolbarItems,
-  };
-}

package/core/composables/useUser/index.ts

@@ -1,406 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { computed, Ref, ref, ComputedRef } from "vue";
-import {
-  UserDetail,
-  SecurityClient,
-  ResetPasswordConfirmRequest,
-  SecurityResult,
-  ValidatePasswordResetTokenRequest,
-  IdentityResult,
-  ChangePasswordRequest,
-  LoginType,
-  LoginRequest,
-  SignInResult,
-} from "@core/api/platform";
-import type { RequestPasswordResult } from "@core/types";
-import { createSharedComposable } from "@vueuse/core";
-import { useExternalProvider } from "@shared/components/sign-in/useExternalProvider";
-import { createLogger } from "@core/utilities";
-
-export interface TokenData {
-  token: string | null;
-  access_token: string | null;
-  refresh_token: string | null;
-  expires_at: number | null;
-}
-
-const AUTH_STORAGE_KEY = "vc_auth_data";
-
-const logger = createLogger("use-user");
-
-// Interface for the full internal API provided by _createInternalUserLogic
-export interface IUserInternalAPI {
-  user: ComputedRef<UserDetail | undefined>;
-  loading: ComputedRef<boolean>;
-  isAdministrator: ComputedRef<boolean | undefined>;
-  loadUser: () => Promise<UserDetail>;
-  signIn: (username: string, password: string) => Promise<SignInResult | { succeeded: boolean; error?: any }>;
-  signOut: () => Promise<void>;
-  validateToken: (userId: string, token: string) => Promise<boolean>;
-  validatePassword: (password: string) => Promise<IdentityResult>;
-  resetPasswordByToken: (userId: string, password: string, token: string) => Promise<SecurityResult>;
-  requestPasswordReset: (loginOrEmail: string) => Promise<RequestPasswordResult>;
-  changeUserPassword: (oldPassword: string, newPassword: string) => Promise<SecurityResult | undefined>;
-  getLoginType: () => Promise<LoginType[]>;
-  getAccessToken: () => Promise<string | null>;
-  isAuthenticated: ComputedRef<boolean>;
-}
-
-export interface IAppUserAPI {
-  user: ComputedRef<UserDetail | undefined>;
-  loading: ComputedRef<boolean>;
-  isAuthenticated: ComputedRef<boolean>;
-  isAdministrator: ComputedRef<boolean | undefined>;
-  loadUser: () => Promise<UserDetail>;
-  signOut: () => Promise<void>;
-  getAccessToken: () => Promise<string | null>;
-}
-
-const user: Ref<UserDetail | undefined> = ref();
-
-function readAuthData(): TokenData | null {
-  try {
-    const stored = localStorage.getItem(AUTH_STORAGE_KEY);
-    if (stored) {
-      return JSON.parse(stored) as TokenData;
-    }
-  } catch (e) {
-    logger.error("Failed to read auth data from storage:", e);
-  }
-  return null;
-}
-
-function storeAuthData(data: TokenData): void {
-  try {
-    logger.debug("storeAuthData - Saving:", data);
-    localStorage.setItem(AUTH_STORAGE_KEY, JSON.stringify(data));
-    logger.debug("storeAuthData - Saved successfully");
-  } catch (e) {
-    logger.error("Failed to store auth data:", e);
-  }
-}
-
-function clearAuthData(): void {
-  try {
-    localStorage.removeItem(AUTH_STORAGE_KEY);
-  } catch (e) {
-    logger.error("Failed to clear auth data:", e);
-  }
-}
-
-// Direct fetch to /connect/token endpoint
-async function fetchToken(params: Record<string, string>): Promise<TokenData | null> {
-  try {
-    const body = new URLSearchParams(params).toString();
-
-    const response = await fetch("/connect/token", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-      },
-      body,
-    });
-
-    if (!response.ok) {
-      const errorBody = await response.text();
-      logger.error("fetchToken - HTTP error:", response.status, response.statusText, errorBody);
-      return null;
-    }
-
-    const data = await response.json();
-    logger.debug("fetchToken - Response:", data);
-
-    const accessToken = data.access_token;
-    const refreshToken = data.refresh_token;
-    const expiresIn = data.expires_in;
-
-    if (data.error || !accessToken) {
-      logger.error("fetchToken - Error:", data.error_description || data.error || "No access token");
-      return null;
-    }
-
-    const expiresAt = expiresIn ? Date.now() + expiresIn * 1000 : null;
-
-    return {
-      token: accessToken,
-      access_token: accessToken,
-      refresh_token: refreshToken ?? null,
-      expires_at: expiresAt,
-    };
-  } catch (e) {
-    logger.error("fetchToken - Exception:", e);
-    return null;
-  }
-}
-
-export function _createInternalUserLogic(): IUserInternalAPI {
-  const loading: Ref<boolean> = ref(false);
-  const authData: Ref<TokenData | null> = ref(null);
-
-  const { storage: externalSignInStorage, signOut: externalSignOut } = useExternalProvider();
-
-  const securityClient = new SecurityClient();
-
-  const isAuthenticated = computed(() => user.value?.userName != null);
-
-  async function validateToken(userId: string, token: string): Promise<boolean> {
-    let result = false;
-    try {
-      loading.value = true;
-      result = await securityClient.validatePasswordResetToken(userId, {
-        token,
-      } as ValidatePasswordResetTokenRequest);
-    } catch (e) {
-      //TODO: log error
-    } finally {
-      loading.value = false;
-    }
-    return result;
-  }
-
-  async function validatePassword(password: string): Promise<IdentityResult> {
-    return securityClient.validatePassword(password);
-  }
-
-  async function resetPasswordByToken(userId: string, password: string, token: string): Promise<SecurityResult> {
-    return securityClient.resetPasswordByToken(userId, {
-      newPassword: password,
-      token,
-    } as ResetPasswordConfirmRequest);
-  }
-
-  async function signIn(
-    username: string,
-    password: string,
-  ): Promise<SignInResult | { succeeded: boolean; error?: any; status?: number }> {
-    logger.debug("signIn - Entry point");
-    try {
-      loading.value = true;
-
-      // First do the standard login to set cookies/session
-      const result = await securityClient.login(new LoginRequest({ userName: username, password }));
-      logger.debug("signIn - Cookie login completed:", result);
-
-      if (!result.succeeded) {
-        return result;
-      }
-
-      // Then get OAuth token for API calls (direct fetch, bypasses API client)
-      // Request offline_access scope to get refresh_token for automatic token renewal
-      logger.debug("signIn - Requesting token...");
-      const tokenData = await fetchToken({
-        grant_type: "password",
-        username,
-        password,
-        scope: "offline_access",
-      });
-
-      if (tokenData) {
-        authData.value = tokenData;
-        storeAuthData(authData.value);
-        logger.debug("signIn - Token saved:", authData.value);
-      }
-
-      // Load current user info
-      const userInfo = await securityClient.getCurrentUser();
-      if (userInfo) {
-        user.value = userInfo;
-        return result;
-      }
-
-      throw { succeeded: false };
-    } catch (e: any) {
-      logger.error("signIn failed:", e);
-
-      // Extract human-readable error from ApiException.response (raw JSON from server)
-      let error = e.message;
-      if (e.response) {
-        try {
-          const body = JSON.parse(e.response);
-          error = body.errorDescription || body.errors?.[0]?.description || body.error || error;
-        } catch {
-          // response is not JSON, keep e.message
-        }
-      }
-
-      return { succeeded: false, error, status: e.status };
-    } finally {
-      loading.value = false;
-    }
-  }
-
-  async function signOut(): Promise<void> {
-    logger.debug("signOut - Entry point");
-
-    user.value = undefined;
-
-    // Clear stored auth data
-    clearAuthData();
-    authData.value = null;
-
-    if (externalSignInStorage.value?.providerType) {
-      await externalSignOut(externalSignInStorage.value.providerType);
-    } else {
-      securityClient.logout();
-    }
-  }
-
-  async function loadUser(): Promise<UserDetail> {
-    logger.debug("loadUser - Entry point");
-
-    try {
-      loading.value = true;
-      performance.mark("vc:auth-start");
-
-      // getCurrentUser() and getAccessToken() have no data dependency.
-      // getAccessToken() reads from localStorage (sync ~0ms) or refreshes via /connect/token.
-      // Running in parallel saves one sequential round-trip on token refresh paths.
-      const [userDetail] = await Promise.all([
-        securityClient.getCurrentUser(),
-        getAccessToken(),
-      ]);
-
-      user.value = userDetail;
-      performance.mark("vc:auth-done");
-      logger.debug("User details loaded:", user.value);
-    } catch (e: any) {
-      logger.error("loadUser failed:", e);
-    } finally {
-      loading.value = false;
-    }
-
-    return { ...user.value } as UserDetail;
-  }
-
-  async function requestPasswordReset(loginOrEmail: string): Promise<RequestPasswordResult> {
-    try {
-      loading.value = true;
-      await securityClient.requestPasswordReset(loginOrEmail);
-      return { succeeded: true };
-    } catch (e) {
-      //TODO: log error
-      return { succeeded: false, error: e as string };
-    } finally {
-      loading.value = false;
-    }
-  }
-
-  async function changeUserPassword(oldPassword: string, newPassword: string): Promise<SecurityResult | undefined> {
-    let result;
-
-    try {
-      loading.value = true;
-      const command = new ChangePasswordRequest({
-        oldPassword,
-        newPassword,
-      });
-
-      result = await securityClient.changeCurrentUserPassword(command);
-    } catch (e: any) {
-      return { succeeded: false, errors: [e.message] } as SecurityResult;
-    } finally {
-      loading.value = false;
-    }
-
-    return result;
-  }
-
-  async function getLoginType() {
-    let result: LoginType[] | null = null;
-    try {
-      result = await securityClient.getLoginTypes();
-    } catch (e) {
-      logger.error("getLoginType failed:", e);
-      throw e;
-    }
-
-    return result;
-  }
-
-  // Buffer time in ms - refresh token this much before actual expiration
-  const TOKEN_REFRESH_BUFFER_MS = 60 * 1000; // 60 seconds
-
-  async function getAccessToken(): Promise<string | null> {
-    logger.debug("getAccessToken - Entry point");
-
-    // Load auth data from storage if not yet loaded
-    if (!authData.value) {
-      authData.value = readAuthData();
-    }
-
-    // No auth data available
-    if (!authData.value) {
-      logger.debug("getAccessToken - No auth data available");
-      return null;
-    }
-
-    // Check if token is expired or about to expire (with buffer)
-    const now = Date.now();
-    const expiresAt = authData.value.expires_at;
-    const shouldRefresh = expiresAt ? now >= expiresAt - TOKEN_REFRESH_BUFFER_MS : false;
-
-    logger.debug("getAccessToken - Token status:", {
-      hasToken: !!authData.value.access_token,
-      expiresAt: expiresAt ? new Date(expiresAt).toISOString() : "not set",
-      now: new Date(now).toISOString(),
-      shouldRefresh,
-      hasRefreshToken: !!authData.value.refresh_token,
-    });
-
-    if (shouldRefresh && authData.value.refresh_token) {
-      logger.debug("getAccessToken - Token expired or expiring soon, attempting refresh");
-
-      const tokenData = await fetchToken({
-        grant_type: "refresh_token",
-        refresh_token: authData.value.refresh_token,
-        scope: "offline_access",
-      });
-
-      if (tokenData) {
-        // Keep old refresh_token if new one not provided
-        tokenData.refresh_token = tokenData.refresh_token ?? authData.value.refresh_token;
-        authData.value = tokenData;
-        storeAuthData(authData.value);
-        logger.debug("getAccessToken - Token refreshed successfully, new expiry:", {
-          expiresAt: tokenData.expires_at ? new Date(tokenData.expires_at).toISOString() : "not set",
-        });
-      } else {
-        // Refresh failed - log error but return existing token (it might still work)
-        // Don't clear auth data - let the API call fail naturally if token is truly invalid
-        logger.warn("getAccessToken - Failed to refresh token, returning existing token");
-      }
-    }
-
-    return authData.value?.access_token ?? authData.value?.token ?? null;
-  }
-
-  return {
-    user: computed(() => user.value),
-    loading: computed(() => loading.value),
-    isAdministrator: computed(() => user.value?.isAdministrator),
-    isAuthenticated,
-    loadUser,
-    signIn,
-    signOut,
-    validateToken,
-    validatePassword,
-    resetPasswordByToken,
-    requestPasswordReset,
-    changeUserPassword,
-    getLoginType,
-    getAccessToken,
-  };
-}
-
-export const useUser = createSharedComposable((): IAppUserAPI => {
-  const internals = _createInternalUserLogic();
-  return {
-    user: internals.user,
-    loading: internals.loading,
-    isAuthenticated: internals.isAuthenticated,
-    isAdministrator: internals.isAdministrator,
-    loadUser: internals.loadUser,
-    signOut: internals.signOut,
-    getAccessToken: internals.getAccessToken,
-  };
-});

package/core/composables/useUser/useUser.test.ts

@@ -1,155 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// --- Stable mock function references ---
-// These live at module scope so the SecurityClient mock factory can close over them.
-// Each test configures getCurrentUser behavior via mockImplementationOnce / mockResolvedValueOnce.
-const mockGetCurrentUser = vi.fn();
-const mockPerformanceMark = vi.fn();
-
-vi.mock("@core/utilities", () => ({
-  createLogger: () => ({
-    debug: vi.fn(),
-    error: vi.fn(),
-    warn: vi.fn(),
-  }),
-}));
-
-vi.mock("@shared/components/sign-in/useExternalProvider", () => ({
-  useExternalProvider: () => ({
-    storage: { value: null },
-    signOut: vi.fn(),
-  }),
-}));
-
-vi.mock("@core/api/platform", () => ({
-  SecurityClient: vi.fn().mockImplementation(() => ({
-    getCurrentUser: mockGetCurrentUser,
-    login: vi.fn(),
-    logout: vi.fn(),
-    validatePasswordResetToken: vi.fn(),
-    validatePassword: vi.fn(),
-    resetPasswordByToken: vi.fn(),
-    requestPasswordReset: vi.fn(),
-    changeCurrentUserPassword: vi.fn(),
-    getLoginTypes: vi.fn(),
-  })),
-  LoginRequest: vi.fn().mockImplementation((args: unknown) => args),
-}));
-
-// Import after mocks are registered
-import { _createInternalUserLogic } from "./index";
-
-// Use a single store reference accessible across tests for localStorage mock
-let localStorageStore: Record<string, string> = {};
-
-beforeEach(() => {
-  // Reset only the mock functions' call history and implementation queues.
-  // Do NOT call vi.restoreAllMocks() — it also restores vi.mock()-created mocks
-  // (including SecurityClient), breaking them for subsequent tests.
-  mockGetCurrentUser.mockReset();
-  mockPerformanceMark.mockReset();
-
-  // Fresh localStorage per test
-  localStorageStore = {};
-  vi.spyOn(Storage.prototype, "getItem").mockImplementation((key) => localStorageStore[key] ?? null);
-  vi.spyOn(Storage.prototype, "setItem").mockImplementation((key, value) => {
-    localStorageStore[key] = value;
-  });
-  vi.spyOn(Storage.prototype, "removeItem").mockImplementation((key) => {
-    delete localStorageStore[key];
-  });
-
-  // Stub performance.mark globally (jsdom exposes performance.mark natively,
-  // but we want to spy on it to verify it's called with the right marks)
-  vi.stubGlobal("performance", { mark: mockPerformanceMark });
-});
-
-// NOTE: No afterEach with vi.restoreAllMocks() — this would restore SecurityClient
-// mock and break subsequent tests. Each beforeEach resets what it needs.
-
-describe("loadUser() - parallelization", () => {
-  it("Test 1: getCurrentUser() starts immediately when loadUser() is called", async () => {
-    let getCurrentUserStarted = false;
-    let resolveCurrentUser!: (value: any) => void;
-
-    mockGetCurrentUser.mockImplementationOnce(
-      () =>
-        new Promise<any>((resolve) => {
-          getCurrentUserStarted = true;
-          resolveCurrentUser = resolve;
-        }),
-    );
-
-    const logic = _createInternalUserLogic();
-    const loadUserPromise = logic.loadUser();
-
-    // After one microtask, getCurrentUser should already have been called
-    await Promise.resolve();
-    expect(getCurrentUserStarted).toBe(true);
-    expect(mockGetCurrentUser).toHaveBeenCalledTimes(1);
-
-    // Resolve to let loadUser complete
-    resolveCurrentUser({ userName: "concurrent@vc.com", isAdministrator: false });
-    await loadUserPromise;
-  });
-
-  it("Test 2: loadUser() returns the UserDetail from getCurrentUser()", async () => {
-    const expectedUser = { userName: "admin@vc.com", isAdministrator: true };
-    mockGetCurrentUser.mockResolvedValueOnce(expectedUser);
-
-    const logic = _createInternalUserLogic();
-    const result = await logic.loadUser();
-
-    expect(result.userName).toBe("admin@vc.com");
-    expect(result.isAdministrator).toBe(true);
-  });
-
-  it("Test 3: loadUser() sets user.value to the getCurrentUser() result", async () => {
-    const expectedUser = { userName: "user@vc.com", isAdministrator: false };
-    mockGetCurrentUser.mockResolvedValueOnce(expectedUser);
-
-    const logic = _createInternalUserLogic();
-    await logic.loadUser();
-
-    // user is module-level ref; loadUser sets it to the getCurrentUser() result
-    expect(logic.user.value?.userName).toBe("user@vc.com");
-    expect(logic.user.value?.isAdministrator).toBe(false);
-  });
-
-  it("Test 4: loadUser() catches errors from getCurrentUser() and does not throw", async () => {
-    mockGetCurrentUser.mockRejectedValueOnce(new Error("Network error"));
-
-    const logic = _createInternalUserLogic();
-
-    // Should not throw — error is caught internally and logged
-    await expect(logic.loadUser()).resolves.not.toThrow();
-  });
-
-  it("Test 5: loadUser() resets loading to false in finally block — even after error", async () => {
-    mockGetCurrentUser.mockRejectedValueOnce(new Error("Server error"));
-
-    const logic = _createInternalUserLogic();
-    await logic.loadUser();
-
-    expect(logic.loading.value).toBe(false);
-  });
-
-  it("emits vc:auth-start and vc:auth-done performance marks in correct order", async () => {
-    const expectedUser = { userName: "perf@vc.com", isAdministrator: false };
-    mockGetCurrentUser.mockResolvedValueOnce(expectedUser);
-
-    const logic = _createInternalUserLogic();
-    await logic.loadUser();
-
-    expect(mockPerformanceMark).toHaveBeenCalledWith("vc:auth-start");
-    expect(mockPerformanceMark).toHaveBeenCalledWith("vc:auth-done");
-
-    // auth-start must come before auth-done
-    const calls = mockPerformanceMark.mock.calls.map((c: string[]) => c[0]);
-    const startIdx = calls.indexOf("vc:auth-start");
-    const doneIdx = calls.indexOf("vc:auth-done");
-    expect(startIdx).toBeGreaterThanOrEqual(0);
-    expect(doneIdx).toBeGreaterThanOrEqual(0);
-    expect(startIdx).toBeLessThan(doneIdx);
-  });
-});