@vc-shell/framework 1.1.98-rc.4 → 1.1.99-alpha.0

package/core/composables/useNotifications/index.ts

@@ -1,6 +1,8 @@
 import { PushNotification, PushNotificationClient } from "./../../api/platform";
-import { computed, ComputedRef, ref, onUnmounted } from "vue";
+import { computed, ComputedRef, ref, onUnmounted, inject } from "vue";
 import * as _ from "lodash-es";
+import { AuthProviderKey } from "../../../injection-keys";
+import { shouldEnablePlatformFeatures } from "../../providers/auth-provider-utils";
 
 const notificationsClient = new PushNotificationClient();
 
@@ -29,6 +31,10 @@ const subscribers = new Map<
 let subscriberCounter = 0;
 
 export function useNotifications(notifyType?: string | string[]): INotifications {
+  // Check if we're using a custom auth provider
+  const authProvider = inject(AuthProviderKey);
+  const isPlatformProvider = shouldEnablePlatformFeatures(authProvider);
+
   if (notifyType) {
     const types = Array.isArray(notifyType) ? notifyType : [notifyType];
 
@@ -49,6 +55,12 @@ export function useNotifications(notifyType?: string | string[]): INotifications
   }
 
   async function loadFromHistory(take = 10) {
+    // Skip platform API calls for custom authentication providers
+    if (!isPlatformProvider) {
+      console.log("[useNotifications] Skipping loadFromHistory - custom authentication provider detected");
+      return;
+    }
+
     // TODO temporary workaround to get push notifications without base type
     try {
       const result = await fetch("/api/platform/pushnotifications", {
@@ -106,6 +118,25 @@ export function useNotifications(notifyType?: string | string[]): INotifications
   }
 
   async function markAllAsRead() {
+    // Skip platform API calls for custom authentication providers
+    if (!isPlatformProvider) {
+      console.log("[useNotifications] Skipping markAllAsRead - custom authentication provider detected");
+      // Still update local state
+      notifications.value = notifications.value.map((x) => {
+        if (x.isNew) {
+          x.isNew = false;
+        }
+        return x;
+      });
+      pushNotifications.value = pushNotifications.value.map((x) => {
+        if (x.isNew) {
+          x.isNew = false;
+        }
+        return x;
+      });
+      return;
+    }
+
     try {
       notifications.value = notifications.value.map((x) => {
         if (x.isNew) {

package/core/composables/useSettings/index.ts

@@ -1,8 +1,10 @@
 import { useAsync } from "./../useAsync";
 import { useApiClient } from "./../useApiClient";
-import { computed, Ref, ref, ComputedRef, onMounted } from "vue";
+import { computed, Ref, ref, ComputedRef, onMounted, inject } from "vue";
 import { SettingClient } from "./../../api/platform";
 import { useLoading } from "../useLoading";
+import { shouldEnablePlatformFeatures } from "../../providers/auth-provider-utils";
+import { AuthProviderKey } from "../../../injection-keys";
 
 interface IUISetting {
   contrast_logo?: string;
@@ -19,13 +21,16 @@ interface IUseSettings {
 }
 
 export function useSettings(): IUseSettings {
+  // Check if we're using a custom auth provider
+  const authProvider = inject(AuthProviderKey);
+  const isPlatformProvider = shouldEnablePlatformFeatures(authProvider);
   const uiSettings = ref<IUISetting | undefined>();
   const customSettingsApplied = ref(false);
 
   const { getApiClient } = useApiClient(SettingClient);
 
   const { loading, action: getUiCustomizationSettings } = useAsync(async () => {
-    if (customSettingsApplied.value) return;
+    if (customSettingsApplied.value || !isPlatformProvider) return;
 
     const result = await (await getApiClient()).getUICustomizationSetting();
     const settings = await JSON.parse(result.defaultValue ?? null);
@@ -51,7 +56,7 @@ export function useSettings(): IUseSettings {
   }
 
   onMounted(async () => {
-    if (!uiSettings.value && !customSettingsApplied.value) {
+    if (!uiSettings.value && !customSettingsApplied.value && isPlatformProvider) {
       await getUiCustomizationSettings();
     }
   });

package/core/composables/useUser/index.ts

@@ -1,211 +1,114 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { computed, Ref, ref, ComputedRef } from "vue";
+import { computed, inject, ComputedRef, getCurrentInstance } from "vue";
 import {
   UserDetail,
-  SecurityClient,
-  ResetPasswordConfirmRequest,
   SecurityResult,
-  ValidatePasswordResetTokenRequest,
   IdentityResult,
-  ChangePasswordRequest,
   LoginType,
-  LoginRequest,
   SignInResult,
+  IUserDetail,
+  ISecurityResult,
+  ILoginType,
+  IIdentityResult,
 } from "./../../api/platform";
-import { RequestPasswordResult } from "./../../types";
+import { RequestPasswordResult, IAuthProvider } from "./../../types";
 import { createSharedComposable } from "@vueuse/core";
-import { useExternalProvider } from "../../../shared/components/sign-in/useExternalProvider";
+import { AuthProviderKey } from "../../../injection-keys";
+import { authProviderManager } from "../../providers/auth-provider-manager";
 
-// Interface for the full internal API provided by _createInternalUserLogic
+/**
+ * Interface for the full internal API
+ * @deprecated This interface is kept for backward compatibility but will be removed in future versions
+ */
 export interface IUserInternalAPI {
-  user: ComputedRef<UserDetail | undefined>;
+  user: ComputedRef<IUserDetail | undefined>;
   loading: ComputedRef<boolean>;
   isAdministrator: ComputedRef<boolean | undefined>;
-  loadUser: () => Promise<UserDetail>;
+  loadUser: () => Promise<IUserDetail>;
   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>;
+  validatePassword: (password: string) => Promise<IIdentityResult>;
+  resetPasswordByToken: (userId: string, password: string, token: string) => Promise<ISecurityResult>;
   requestPasswordReset: (loginOrEmail: string) => Promise<RequestPasswordResult>;
-  changeUserPassword: (oldPassword: string, newPassword: string) => Promise<SecurityResult | undefined>;
-  getLoginType: () => Promise<LoginType[]>;
+  changeUserPassword: (oldPassword: string, newPassword: string) => Promise<ISecurityResult | undefined>;
+  getLoginType: () => Promise<ILoginType[]>;
   isAuthenticated: ComputedRef<boolean>;
 }
 
 export interface IAppUserAPI {
-  user: ComputedRef<UserDetail | undefined>;
+  user: ComputedRef<IUserDetail | undefined>;
   loading: ComputedRef<boolean>;
   isAuthenticated: ComputedRef<boolean>;
   isAdministrator: ComputedRef<boolean | undefined>;
-  loadUser: () => Promise<UserDetail>;
+  loadUser: () => Promise<IUserDetail>;
   signOut: () => Promise<void>;
 }
 
-const user: Ref<UserDetail | undefined> = ref();
-
-export function _createInternalUserLogic(): IUserInternalAPI {
-  const loading: Ref<boolean> = ref(false);
-
-  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;
+/**
+ * Get auth provider with fallback to global instance
+ * This allows composables to work before Vue app context is available
+ * Priority: Vue DI > Global Manager (always has default PlatformAuthProvider)
+ */
+function getAuthProvider(): IAuthProvider {
+  // Try to get from Vue DI first (preferred method for components)
+  const instance = getCurrentInstance();
+  if (instance) {
+    const injectedProvider = inject(AuthProviderKey, null);
+    if (injectedProvider) {
+      return injectedProvider;
     }
-    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 }> {
-    console.debug(`[@vc-shell/framework#_createInternalUserLogic:signIn] - Entry point`);
-    try {
-      loading.value = true;
-      const result = await securityClient.login(new LoginRequest({ userName: username, password }));
-      return await securityClient
-        .getCurrentUser()
-        .then((res) => {
-          if (res) {
-            user.value = res;
-            return result;
-          }
-          throw { succeeded: false };
-        })
-        .catch((e) => {
-          throw e;
-        });
-    } catch (e: any) {
-      //TODO: log error
-      console.log(e);
-      return { succeeded: false, error: e.message, status: e.status };
-    } finally {
-      loading.value = false;
-    }
-  }
-
-  async function signOut(): Promise<void> {
-    console.debug(`[@vc-shell/framework#_createInternalUserLogic:signOut] - Entry point`);
-
-    user.value = undefined;
-
-    if (externalSignInStorage.value?.providerType) {
-      await externalSignOut(externalSignInStorage.value.providerType);
-    } else {
-      securityClient.logout();
-    }
-  }
-
-  async function loadUser(): Promise<UserDetail> {
-    console.debug(`[@vc-shell/framework#_createInternalUserLogic:loadUser] - Entry point`);
-
-    try {
-      loading.value = true;
-      user.value = await securityClient.getCurrentUser();
-      console.log("[_createInternalUserLogic]: an user details has been loaded", user.value);
-    } catch (e: any) {
-      console.error(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) {
-      console.error(e);
-      throw e;
-    }
+  // Fallback to global provider (always available with default PlatformAuthProvider)
+  return authProviderManager.getProvider();
+}
 
-    return result;
-  }
+/**
+ * Internal user logic - delegates to auth provider
+ * @deprecated This function is kept for backward compatibility but will be removed in future versions
+ * Use auth provider directly or useUser/useUserManagement composables
+ */
+export function _createInternalUserLogic(): IUserInternalAPI {
+  const authProvider = getAuthProvider();
 
   return {
-    user: computed(() => user.value),
-    loading: computed(() => loading.value),
-    isAdministrator: computed(() => user.value?.isAdministrator),
-    isAuthenticated,
-    loadUser,
-    signIn,
-    signOut,
-    validateToken,
-    validatePassword,
-    resetPasswordByToken,
-    requestPasswordReset,
-    changeUserPassword,
-    getLoginType,
+    user: authProvider.user,
+    loading: authProvider.loading,
+    isAdministrator: authProvider.isAdministrator,
+    isAuthenticated: authProvider.isAuthenticated,
+    loadUser: authProvider.loadUser.bind(authProvider),
+    signIn: authProvider.signIn.bind(authProvider),
+    signOut: authProvider.signOut.bind(authProvider),
+    validateToken: authProvider.validateToken.bind(authProvider),
+    validatePassword: authProvider.validatePassword.bind(authProvider),
+    resetPasswordByToken: authProvider.resetPasswordByToken.bind(authProvider),
+    requestPasswordReset: authProvider.requestPasswordReset.bind(authProvider),
+    changeUserPassword: authProvider.changeUserPassword.bind(authProvider),
+    getLoginType: authProvider.getLoginType.bind(authProvider),
   };
 }
 
 export const useUser = createSharedComposable((): IAppUserAPI => {
-  const internals = _createInternalUserLogic();
+  // Get provider dynamically on each access to ensure correct provider is used
+  // This is important because custom auth providers may be set after composable creation
+
   return {
-    user: internals.user,
-    loading: internals.loading,
-    isAuthenticated: internals.isAuthenticated,
-    isAdministrator: internals.isAdministrator,
-    loadUser: internals.loadUser,
-    signOut: internals.signOut,
+    // Computed properties should get provider dynamically
+    get user() {
+      return getAuthProvider().user;
+    },
+    get loading() {
+      return getAuthProvider().loading;
+    },
+    get isAuthenticated() {
+      return getAuthProvider().isAuthenticated;
+    },
+    get isAdministrator() {
+      return getAuthProvider().isAdministrator;
+    },
+    // Methods get provider dynamically on each call
+    loadUser: () => getAuthProvider().loadUser(),
+    signOut: () => getAuthProvider().signOut(),
   };
 });

package/core/composables/useUserManagement/index.ts

@@ -1,45 +1,87 @@
-import { computed, ComputedRef } from "vue";
+import { inject, ComputedRef, getCurrentInstance } from "vue";
 import { createSharedComposable } from "@vueuse/core";
-import { _createInternalUserLogic, IUserInternalAPI } from "../useUser"; // Import the internal logic
-import { SecurityResult, IdentityResult, LoginType, UserDetail, SignInResult } from "./../../api/platform";
-import { RequestPasswordResult } from "./../../types";
+import {
+  SecurityResult,
+  IdentityResult,
+  LoginType,
+  UserDetail,
+  SignInResult,
+  IUserDetail,
+  IIdentityResult,
+  ISecurityResult,
+  ILoginType,
+} from "./../../api/platform";
+import { RequestPasswordResult, IAuthProvider } from "./../../types";
+import { AuthProviderKey } from "../../../injection-keys";
+import { authProviderManager } from "../../providers/auth-provider-manager";
 
 // Interface for the API exposed by useUserManagement (for framework/admin use)
 export interface IUserManagementAPI {
-  user: ComputedRef<UserDetail | undefined>;
+  user: ComputedRef<IUserDetail | undefined>;
   loading: ComputedRef<boolean>;
   isAdministrator: ComputedRef<boolean | undefined>;
   isAuthenticated: ComputedRef<boolean>;
   // Methods specific to user management
   validateToken: (userId: string, token: string) => Promise<boolean>;
-  validatePassword: (password: string) => Promise<IdentityResult>;
-  resetPasswordByToken: (userId: string, password: string, token: string) => Promise<SecurityResult>;
-  getLoginType: () => Promise<LoginType[]>;
-  loadUser: () => Promise<UserDetail>;
+  validatePassword: (password: string) => Promise<IIdentityResult>;
+  resetPasswordByToken: (userId: string, password: string, token: string) => Promise<ISecurityResult>;
+  getLoginType: () => Promise<ILoginType[]>;
+  loadUser: () => Promise<IUserDetail>;
   requestPasswordReset: (loginOrEmail: string) => Promise<RequestPasswordResult>;
-  changeUserPassword: (oldPassword: string, newPassword: string) => Promise<SecurityResult | undefined>;
+  changeUserPassword: (oldPassword: string, newPassword: string) => Promise<ISecurityResult | undefined>;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   signIn: (username: string, password: string) => Promise<SignInResult | { succeeded: boolean; error?: any }>;
   signOut: () => Promise<void>;
 }
 
+/**
+ * Get auth provider with fallback to global instance
+ * This allows composables to work before Vue app context is available
+ * Priority: Vue DI > Global Manager (always has default PlatformAuthProvider)
+ */
+function getAuthProvider(): IAuthProvider {
+  // Try to get from Vue DI first (preferred method for components)
+  const instance = getCurrentInstance();
+  if (instance) {
+    const injectedProvider = inject(AuthProviderKey, null);
+    if (injectedProvider) {
+      return injectedProvider;
+    }
+  }
+
+  // Fallback to global provider (always available with default PlatformAuthProvider)
+  return authProviderManager.getProvider();
+}
+
 export const useUserManagement = createSharedComposable((): IUserManagementAPI => {
-  // Utilize the same internal logic instance
-  const internals: IUserInternalAPI = _createInternalUserLogic();
+  // Get provider dynamically on each access to ensure correct provider is used
+  // This is important because custom auth providers may be set after composable creation
 
   return {
-    user: internals.user,
-    loading: internals.loading,
-    isAdministrator: internals.isAdministrator,
-    isAuthenticated: internals.isAuthenticated,
-    validateToken: internals.validateToken,
-    validatePassword: internals.validatePassword,
-    resetPasswordByToken: internals.resetPasswordByToken,
-    getLoginType: internals.getLoginType,
-    loadUser: internals.loadUser,
-    requestPasswordReset: internals.requestPasswordReset,
-    changeUserPassword: internals.changeUserPassword,
-    signIn: internals.signIn,
-    signOut: internals.signOut,
+    // Computed properties should get provider dynamically
+    get user() {
+      return getAuthProvider().user;
+    },
+    get loading() {
+      return getAuthProvider().loading;
+    },
+    get isAdministrator() {
+      return getAuthProvider().isAdministrator;
+    },
+    get isAuthenticated() {
+      return getAuthProvider().isAuthenticated;
+    },
+    // Methods get provider dynamically on each call
+    validateToken: (userId: string, token: string) => getAuthProvider().validateToken(userId, token),
+    validatePassword: (password: string) => getAuthProvider().validatePassword(password),
+    resetPasswordByToken: (userId: string, password: string, token: string) =>
+      getAuthProvider().resetPasswordByToken(userId, password, token),
+    getLoginType: () => getAuthProvider().getLoginType(),
+    loadUser: () => getAuthProvider().loadUser(),
+    requestPasswordReset: (loginOrEmail: string) => getAuthProvider().requestPasswordReset(loginOrEmail),
+    changeUserPassword: (oldPassword: string, newPassword: string) =>
+      getAuthProvider().changeUserPassword(oldPassword, newPassword),
+    signIn: (username: string, password: string) => getAuthProvider().signIn(username, password),
+    signOut: () => getAuthProvider().signOut(),
   };
 });

package/core/interceptors/index.ts

@@ -1,70 +1,33 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import { Router } from "vue-router";
-import { useUserManagement } from "../composables/useUserManagement";
 import { notification } from "../../shared";
+import { IAuthProvider } from "../types/auth-provider";
 
-export function registerInterceptors(router: Router) {
+export function registerInterceptors(router: Router, authProvider: IAuthProvider) {
   const { fetch: originalFetch } = window;
-  const { signOut, isAuthenticated } = useUserManagement();
 
   window.fetch = async (...args) => {
     /**
-     * Overrides the global `fetch` function to handle API calls in demo mode.
-     * If `window.__DEMO_MODE__` is true, the fetch is cancelled and a warning is logged.
-     * Otherwise, the original `fetch` function is called.
-     * @param args - The arguments passed to the `fetch` function.
-     * @returns A promise that resolves to the response from the API call.
+     * Intercepts fetch requests to handle authentication errors.
+     * Note: Demo mode should be handled by the auth provider itself, not by global interceptors.
      */
-    if (window.__DEMO_MODE__) {
-      console.warn("CANCELLED FETCH WHILE IN __DEMO_MODE__: ", ...args);
-      console.warn("Please logout and add APP_PLATFORM_URL into .env file of your application to enable API calls");
-      return new Promise((resolve: any) => {
-        /**
-         * This conditions are mocking login, currentuser API calls for demo purposes.
-         */
-        if (args[0] === "/api/platform/security/login") {
-          resolve({
-            status: 200,
-            text: async () => JSON.stringify({ succeeded: true }),
-          });
-        } else if (args[0] === "/api/platform/security/currentuser") {
-          notification.warning(
-            "You are currently in DEMO mode until the first page refresh. \n All API calls are disabled. Please add APP_PLATFORM_URL to your application's .env file to enable API calls.",
-            {
-              timeout: 10000,
-            },
-          );
-          resolve({
-            status: 200,
-            text: async () => JSON.stringify({ id: "demo_user_id", userName: "DEMO_USER" }),
-          });
-        } else {
-          resolve({
-            status: 200,
-            text: async () => JSON.stringify({}),
-          });
-        }
-      });
-    } else {
-      const response = await originalFetch(...args);
+    const response = await originalFetch(...args);
 
-      /**
-       * If the response is unauthorized, logout the user
-       */
-      if (response.status === 401) {
-        //logout user
-        if (isAuthenticated.value) {
-          signOut().then(() => {
-            redirect(router);
-            notification.error(
-              "Access Denied: Your session has expired or you do not have the necessary permissions.\nPlease log in again or contact the administrator for assistance.",
-            );
-          });
-        }
+    /**
+     * If the response is unauthorized, logout the user
+     */
+    if (response.status === 401) {
+      //logout user
+      if (authProvider.isAuthenticated.value) {
+        authProvider.signOut().then(() => {
+          redirect(router);
+          notification.error(
+            "Access Denied: Your session has expired or you do not have the necessary permissions.\nPlease log in again or contact the administrator for assistance.",
+          );
+        });
       }
-
-      return response;
     }
+
+    return response;
   };
 
   return window.fetch;

package/core/plugins/signalR/index.ts

@@ -1,9 +1,12 @@
-import { App, watch, ref, InjectionKey } from "vue";
+import { App, watch, ref, InjectionKey, inject } from "vue";
 import { HubConnection, HubConnectionBuilder, LogLevel } from "@microsoft/signalr";
 import { PushNotification } from "../../api/platform";
 import { useNotifications } from "./../../composables/useNotifications";
 import { useUserManagement } from "../../composables/useUserManagement";
 import { useCypressSignalRMock } from "cypress-signalr-mock";
+import { AuthProviderKey } from "../../../injection-keys";
+import { IAuthProvider } from "../../types/auth-provider";
+import { shouldEnablePlatformFeatures } from "../../providers/auth-provider-utils";
 
 const { addNotification } = useNotifications();
 const currentCreator = ref<string | undefined>();
@@ -31,8 +34,31 @@ export const signalR = {
     app: App,
     options?: {
       creator?: string;
+      authProvider?: IAuthProvider;
     },
   ) {
+    // Check if we should enable SignalR (only for platform providers)
+    const authProvider = options?.authProvider;
+
+    console.log("[SignalR] Auth provider: ", authProvider);
+
+    // Check if platform features should be enabled
+    if (!shouldEnablePlatformFeatures(authProvider)) {
+      console.log("[SignalR] Skipping initialization - custom authentication provider detected");
+      console.log("[SignalR] SignalR is only available with platform authentication");
+
+      // Provide empty implementations to prevent errors
+      app.config.globalProperties.$updateSignalRCreator = () => {
+        console.warn("[SignalR] Not available with custom authentication provider");
+      };
+      app.provide(updateSignalRCreatorSymbol, () => {
+        console.warn("[SignalR] Not available with custom authentication provider");
+      });
+
+      return;
+    }
+
+    console.log("[SignalR] Initializing with platform authentication");
     currentCreator.value = options?.creator;
     const { isAuthenticated } = useUserManagement();
     let reconnect = false;