@memberjunction/ng-bootstrap 0.0.1 → 3.1.1

package/dist/esm2022/lib/components/auth-shell.component.mjs

@@ -0,0 +1,148 @@
+/**
+ * MemberJunction 3.0 Auth Shell Component
+ *
+ * Handles authentication flow and initialization for MJ applications.
+ * This component encapsulates all the auth logic that was previously in app.component.ts
+ */
+import { Component, Inject } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { take } from 'rxjs/operators';
+import { SetProductionStatus, LogError } from '@memberjunction/core';
+import { MJ_ENVIRONMENT } from '../bootstrap.types';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@memberjunction/ng-auth-services";
+import * as i3 from "../services/initialization.service";
+import * as i4 from "@angular/common";
+export class MJAuthShellComponent {
+    router;
+    document;
+    authBase;
+    initService;
+    environment;
+    HasError = false;
+    ErrorMessage = '';
+    showValidationOnly = false;
+    subHeaderText = "Welcome back! Please log in to your account.";
+    initialPath = '/';
+    constructor(router, document, authBase, initService, environment) {
+        this.router = router;
+        this.document = document;
+        this.authBase = authBase;
+        this.initService = initService;
+        this.environment = environment;
+    }
+    async ngOnInit() {
+        console.log('🚀 MemberJunction 3.0 - Auth Shell Initializing');
+        SetProductionStatus(this.environment.production);
+        this.initialPath = window.location.pathname + (window.location.search ? window.location.search : '');
+        await this.setupAuth();
+    }
+    /**
+     * Handle successful login and initialize the application
+     */
+    async handleLogin(token, userInfo) {
+        if (!token)
+            return;
+        try {
+            // Initialize GraphQL client
+            await this.initService.initializeGraphQL(token, this.environment);
+            // Validate user access and refresh data
+            const validationResult = await this.initService.validateUserAccess();
+            if (!validationResult.success) {
+                this.HasError = true;
+                this.ErrorMessage = validationResult.error.message;
+                throw new Error(this.ErrorMessage);
+            }
+            // Run startup validation checks
+            this.initService.runValidationChecks();
+            // Navigate to initial route
+            this.initService.navigateToInitialRoute(this.initialPath, this.document);
+        }
+        catch (err) {
+            // Check for no roles error
+            if (this.initService.isNoUserRolesError(err)) {
+                this.showValidationOnly = true;
+                this.HasError = true;
+                const result = this.initService.handleNoRolesError();
+                return; // Don't throw, allow UI to show validation banner
+            }
+            // Try auth retry if applicable
+            const retried = await this.initService.handleAuthRetry(err);
+            if (retried) {
+                return; // Retry initiated
+            }
+            // Show error
+            this.HasError = true;
+            this.ErrorMessage = err;
+            LogError('Error Logging In: ' + err);
+            throw err;
+        }
+    }
+    /**
+     * Setup authentication and handle auth state changes
+     */
+    async setupAuth() {
+        // Auth provider already initialized by APP_INITIALIZER
+        // Listen for user info changes
+        this.authBase.getUserInfo()
+            .pipe(take(1))
+            .subscribe({
+            next: async (userInfo) => {
+                if (userInfo) {
+                    const token = await this.authBase.getIdToken();
+                    if (token) {
+                        await this.handleLogin(token, userInfo);
+                    }
+                    else {
+                        console.error('User info available but no token found');
+                    }
+                }
+            },
+            error: (err) => {
+                LogError('Error Logging In: ' + err);
+                this.subHeaderText = this.initService.getAuthErrorMessage(err);
+            }
+        });
+        // Check if user is authenticated
+        this.authBase.isAuthenticated()
+            .pipe(take(1))
+            .subscribe((loggedIn) => {
+            if (!loggedIn) {
+                // Display login screen - auth state is managed by provider
+                console.log('User not authenticated, showing login screen');
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MJAuthShellComponent, deps: [{ token: i1.Router }, { token: DOCUMENT }, { token: i2.MJAuthBase }, { token: i3.MJInitializationService }, { token: MJ_ENVIRONMENT }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: MJAuthShellComponent, selector: "mj-auth-shell", ngImport: i0, template: `
+    <div class="mj-auth-shell">
+      <ng-content *ngIf="!HasError || showValidationOnly"></ng-content>
+
+      <div *ngIf="HasError && !showValidationOnly" class="error-container">
+        <h2>Error</h2>
+        <p>{{ ErrorMessage }}</p>
+      </div>
+    </div>
+  `, isInline: true, styles: [".mj-auth-shell{width:100%;height:100%;display:block}.error-container{padding:20px;text-align:center}.error-container h2{color:#d32f2f;margin-bottom:10px}\n"], dependencies: [{ kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MJAuthShellComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mj-auth-shell', template: `
+    <div class="mj-auth-shell">
+      <ng-content *ngIf="!HasError || showValidationOnly"></ng-content>
+
+      <div *ngIf="HasError && !showValidationOnly" class="error-container">
+        <h2>Error</h2>
+        <p>{{ ErrorMessage }}</p>
+      </div>
+    </div>
+  `, styles: [".mj-auth-shell{width:100%;height:100%;display:block}.error-container{padding:20px;text-align:center}.error-container h2{color:#d32f2f;margin-bottom:10px}\n"] }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i2.MJAuthBase }, { type: i3.MJInitializationService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MJ_ENVIRONMENT]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth-shell.component.js","sourceRoot":"","sources":["../../../../src/lib/components/auth-shell.component.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * MemberJunction 3.0 Auth Shell Component\n *\n * Handles authentication flow and initialization for MJ applications.\n * This component encapsulates all the auth logic that was previously in app.component.ts\n */\n\nimport { Component, OnInit, Inject } from '@angular/core';\nimport { DOCUMENT } from '@angular/common';\nimport { Router } from '@angular/router';\nimport { take } from 'rxjs/operators';\nimport { SetProductionStatus, LogError, LogStatus } from '@memberjunction/core';\nimport { MJAuthBase, StandardUserInfo, AuthErrorType } from '@memberjunction/ng-auth-services';\nimport { MJInitializationService } from '../services/initialization.service';\nimport { MJEnvironmentConfig, MJ_ENVIRONMENT } from '../bootstrap.types';\n\n@Component({\n  selector: 'mj-auth-shell',\n  template: `\n    <div class=\"mj-auth-shell\">\n      <ng-content *ngIf=\"!HasError || showValidationOnly\"></ng-content>\n\n      <div *ngIf=\"HasError && !showValidationOnly\" class=\"error-container\">\n        <h2>Error</h2>\n        <p>{{ ErrorMessage }}</p>\n      </div>\n    </div>\n  `,\n  styles: [`\n    .mj-auth-shell {\n      width: 100%;\n      height: 100%;\n      display: block;\n    }\n\n    .error-container {\n      padding: 20px;\n      text-align: center;\n    }\n\n    .error-container h2 {\n      color: #d32f2f;\n      margin-bottom: 10px;\n    }\n  `]\n})\nexport class MJAuthShellComponent implements OnInit {\n  public HasError = false;\n  public ErrorMessage: any = '';\n  public showValidationOnly = false;\n  public subHeaderText: string = \"Welcome back! Please log in to your account.\";\n\n  private initialPath = '/';\n\n  constructor(\n    private router: Router,\n    @Inject(DOCUMENT) public document: Document,\n    public authBase: MJAuthBase,\n    private initService: MJInitializationService,\n    @Inject(MJ_ENVIRONMENT) private environment: MJEnvironmentConfig\n  ) {}\n\n  async ngOnInit() {\n    console.log('🚀 MemberJunction 3.0 - Auth Shell Initializing');\n\n    SetProductionStatus(this.environment.production);\n    this.initialPath = window.location.pathname + (window.location.search ? window.location.search : '');\n\n    await this.setupAuth();\n  }\n\n  /**\n   * Handle successful login and initialize the application\n   */\n  async handleLogin(token: string, userInfo: StandardUserInfo): Promise<void> {\n    if (!token) return;\n\n    try {\n      // Initialize GraphQL client\n      await this.initService.initializeGraphQL(token, this.environment);\n\n      // Validate user access and refresh data\n      const validationResult = await this.initService.validateUserAccess();\n\n      if (!validationResult.success) {\n        this.HasError = true;\n        this.ErrorMessage = validationResult.error!.message;\n        throw new Error(this.ErrorMessage);\n      }\n\n      // Run startup validation checks\n      this.initService.runValidationChecks();\n\n      // Navigate to initial route\n      this.initService.navigateToInitialRoute(this.initialPath, this.document);\n\n    } catch (err: any) {\n      // Check for no roles error\n      if (this.initService.isNoUserRolesError(err)) {\n        this.showValidationOnly = true;\n        this.HasError = true;\n        const result = this.initService.handleNoRolesError();\n        return; // Don't throw, allow UI to show validation banner\n      }\n\n      // Try auth retry if applicable\n      const retried = await this.initService.handleAuthRetry(err);\n      if (retried) {\n        return; // Retry initiated\n      }\n\n      // Show error\n      this.HasError = true;\n      this.ErrorMessage = err;\n      LogError('Error Logging In: ' + err);\n      throw err;\n    }\n  }\n\n  /**\n   * Setup authentication and handle auth state changes\n   */\n  async setupAuth(): Promise<void> {\n    // Auth provider already initialized by APP_INITIALIZER\n\n    // Listen for user info changes\n    this.authBase.getUserInfo()\n      .pipe(take(1))\n      .subscribe({\n        next: async (userInfo) => {\n          if (userInfo) {\n            const token = await this.authBase.getIdToken();\n\n            if (token) {\n              await this.handleLogin(token, userInfo);\n            } else {\n              console.error('User info available but no token found');\n            }\n          }\n        },\n        error: (err: unknown) => {\n          LogError('Error Logging In: ' + err);\n          this.subHeaderText = this.initService.getAuthErrorMessage(err);\n        }\n      });\n\n    // Check if user is authenticated\n    this.authBase.isAuthenticated()\n      .pipe(take(1))\n      .subscribe((loggedIn: boolean) => {\n        if (!loggedIn) {\n          // Display login screen - auth state is managed by provider\n          console.log('User not authenticated, showing login screen');\n        }\n      });\n  }\n}\n"]}

package/dist/esm2022/lib/services/initialization.service.mjs

@@ -0,0 +1,186 @@
+/**
+ * MemberJunction 3.0 Initialization Service
+ *
+ * Handles all core initialization tasks:
+ * - Generated entities loading
+ * - GraphQL client setup
+ * - Token refresh configuration
+ * - System validation
+ */
+import { Injectable, Inject } from '@angular/core';
+import { Metadata } from '@memberjunction/core';
+import { setupGraphQLClient, GraphQLProviderConfigData } from '@memberjunction/graphql-dataprovider';
+import { AuthErrorType } from '@memberjunction/ng-auth-services';
+import { SharedService } from '@memberjunction/ng-shared';
+import { MJ_STARTUP_VALIDATION } from '../bootstrap.types';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@memberjunction/ng-auth-services";
+export class MJInitializationService {
+    router;
+    authBase;
+    startupValidationService;
+    constructor(router, authBase, startupValidationService) {
+        this.router = router;
+        this.authBase = authBase;
+        this.startupValidationService = startupValidationService;
+    }
+    /**
+     * Initialize GraphQL client with authentication token and refresh callback
+     */
+    async initializeGraphQL(token, environment) {
+        const url = environment.GRAPHQL_URI;
+        const wsurl = environment.GRAPHQL_WS_URI;
+        const start = Date.now();
+        const config = new GraphQLProviderConfigData(token, url, wsurl, async () => {
+            // Token refresh callback - refreshToken() returns StandardAuthToken directly or throws
+            const token = await this.authBase.refreshToken();
+            return token.idToken;
+        }, environment.MJ_CORE_SCHEMA_NAME);
+        await setupGraphQLClient(config);
+        const end = Date.now();
+        console.log(`✓ GraphQL Client Setup Complete: ${end - start}ms`);
+    }
+    /**
+     * Refresh shared data and validate user access
+     */
+    async validateUserAccess() {
+        await SharedService.RefreshData(true);
+        const md = new Metadata();
+        if (!md.CurrentUser) {
+            return {
+                success: false,
+                error: {
+                    message: "You don't have access to the application, contact your system administrator.",
+                    type: 'no_access'
+                }
+            };
+        }
+        return { success: true };
+    }
+    /**
+     * Run startup validation checks (if validation service is provided)
+     */
+    runValidationChecks() {
+        if (!this.startupValidationService) {
+            return; // No validation service provided
+        }
+        // Small delay to ensure everything is initialized
+        setTimeout(() => {
+            this.startupValidationService?.validateSystemSetup();
+        }, 500);
+    }
+    /**
+     * Navigate to initial route after successful login
+     */
+    navigateToInitialRoute(initialPath, document) {
+        localStorage.removeItem('jwt-retry-ts');
+        if (initialPath === '/') {
+            // Use first nav item instead
+            setTimeout(() => {
+                // Find the KendoDrawer element and simulate a click for the first item
+                const drawerElement = document.querySelector('li.k-drawer-item.k-level-0');
+                if (drawerElement)
+                    drawerElement.click();
+            }, 10); // Wait for the drawer to finish render
+        }
+        else {
+            this.router.navigateByUrl(initialPath, { replaceUrl: true });
+        }
+    }
+    /**
+     * Check if error is related to missing user roles
+     */
+    isNoUserRolesError(err) {
+        try {
+            if (!err || typeof err !== 'object')
+                return false;
+            // Check for GraphQL-style errors
+            if (err.response && Array.isArray(err.response.errors)) {
+                return err.response.errors.some((e) => e && e.message && typeof e.message === 'string' &&
+                    e.message.includes('does not have read permissions on User Roles'));
+            }
+            // Check for specific "ResourceTypes" error
+            if (err.toString && typeof err.toString === 'function') {
+                const errorString = err.toString();
+                if (errorString.includes("Cannot read properties of undefined (reading 'ResourceTypes')")) {
+                    return true;
+                }
+            }
+            // Check for error message directly on the error object
+            if (err.message && typeof err.message === 'string') {
+                const message = err.message;
+                return message.includes('does not have read permissions on User Roles') ||
+                    message.includes("Cannot read properties of undefined (reading 'ResourceTypes')");
+            }
+            // Check for nested error object
+            if (err.error && typeof err.error === 'object') {
+                return this.isNoUserRolesError(err.error);
+            }
+            return false;
+        }
+        catch (e) {
+            console.error('Error while checking for user roles error:', e);
+            return false;
+        }
+    }
+    /**
+     * Handle no roles error by showing validation banner (if validation service is provided)
+     */
+    handleNoRolesError() {
+        this.startupValidationService?.addNoRolesValidationIssue();
+        return {
+            success: false,
+            error: {
+                message: 'User has no roles assigned',
+                type: 'no_roles',
+                showValidationOnly: true
+            }
+        };
+    }
+    /**
+     * Handle authentication retry logic
+     */
+    async handleAuthRetry(err) {
+        const retryKey = 'auth-retry-dt';
+        const lastRetryDateTime = localStorage.getItem(retryKey);
+        const yesterday = +new Date(Date.now() - 1 * 24 * 60 * 60 * 1000);
+        const retriedRecently = lastRetryDateTime && +new Date(lastRetryDateTime) > yesterday;
+        const authError = this.authBase.classifyError(err);
+        const isTokenExpired = authError.type === AuthErrorType.TOKEN_EXPIRED;
+        if (!retriedRecently && isTokenExpired) {
+            console.log('JWT Expired, retrying once: ' + err);
+            localStorage.setItem(retryKey, new Date().toISOString());
+            await this.authBase.login({ appState: { target: window.location.pathname } }).toPromise();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get auth error message for display
+     */
+    getAuthErrorMessage(err) {
+        const authError = this.authBase.classifyError(err);
+        switch (authError.type) {
+            case AuthErrorType.NO_ACTIVE_SESSION:
+                return "Welcome back! Please log in to your account.";
+            case AuthErrorType.INTERACTION_REQUIRED:
+            case AuthErrorType.TOKEN_EXPIRED:
+                return "Your session has expired. Please log in to your account.";
+            default:
+                return authError.userMessage || "Welcome back! Please log in to your account.";
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MJInitializationService, deps: [{ token: i1.Router }, { token: i2.MJAuthBase }, { token: MJ_STARTUP_VALIDATION }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MJInitializationService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MJInitializationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i2.MJAuthBase }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MJ_STARTUP_VALIDATION]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"initialization.service.js","sourceRoot":"","sources":["../../../../src/lib/services/initialization.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AACrG,OAAO,EAAgC,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAC/F,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAmE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;;;;AAc5H,MAAM,OAAO,uBAAuB;IAExB;IACA;IAC+B;IAHzC,YACU,MAAc,EACd,QAAoB,EACW,wBAA2D;QAF1F,WAAM,GAAN,MAAM,CAAQ;QACd,aAAQ,GAAR,QAAQ,CAAY;QACW,6BAAwB,GAAxB,wBAAwB,CAAmC;IACjG,CAAC;IAEJ;;OAEG;IACH,KAAK,CAAC,iBAAiB,CAAC,KAAa,EAAE,WAAgC;QACrE,MAAM,GAAG,GAAW,WAAW,CAAC,WAAW,CAAC;QAC5C,MAAM,KAAK,GAAW,WAAW,CAAC,cAAc,CAAC;QAEjD,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACzB,MAAM,MAAM,GAAG,IAAI,yBAAyB,CAC1C,KAAK,EACL,GAAG,EACH,KAAK,EACL,KAAK,IAAI,EAAE;YACT,uFAAuF;YACvF,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC;YACjD,OAAO,KAAK,CAAC,OAAO,CAAC;QACvB,CAAC,EACD,WAAW,CAAC,mBAAmB,CAChC,CAAC;QAEF,MAAM,kBAAkB,CAAC,MAAM,CAAC,CAAC;QACjC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,OAAO,CAAC,GAAG,CAAC,oCAAoC,GAAG,GAAG,KAAK,IAAI,CAAC,CAAC;IACnE,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,kBAAkB;QACtB,MAAM,aAAa,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAEtC,MAAM,EAAE,GAAG,IAAI,QAAQ,EAAE,CAAC;QAE1B,IAAI,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC;YACpB,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,KAAK,EAAE;oBACL,OAAO,EAAE,8EAA8E;oBACvF,IAAI,EAAE,WAAW;iBAClB;aACF,CAAC;QACJ,CAAC;QAED,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,mBAAmB;QACjB,IAAI,CAAC,IAAI,CAAC,wBAAwB,EAAE,CAAC;YACnC,OAAO,CAAC,iCAAiC;QAC3C,CAAC;QAED,kDAAkD;QAClD,UAAU,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,wBAAwB,EAAE,mBAAmB,EAAE,CAAC;QACvD,CAAC,EAAE,GAAG,CAAC,CAAC;IACV,CAAC;IAED;;OAEG;IACH,sBAAsB,CAAC,WAAmB,EAAE,QAAkB;QAC5D,YAAY,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;QAExC,IAAI,WAAW,KAAK,GAAG,EAAE,CAAC;YACxB,6BAA6B;YAC7B,UAAU,CAAC,GAAG,EAAE;gBACd,uEAAuE;gBACvE,MAAM,aAAa,GAAG,QAAQ,CAAC,aAAa,CAAC,4BAA4B,CAAQ,CAAC;gBAClF,IAAI,aAAa;oBAAE,aAAa,CAAC,KAAK,EAAE,CAAC;YAC3C,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,uCAAuC;QACjD,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,WAAW,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC;IAED;;OAEG;IACH,kBAAkB,CAAC,GAAQ;QACzB,IAAI,CAAC;YACH,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ;gBAAE,OAAO,KAAK,CAAC;YAElD,iCAAiC;YACjC,IAAI,GAAG,CAAC,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;gBACvD,OAAO,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CACzC,CAAC,IAAI,CAAC,CAAC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,KAAK,QAAQ;oBAC/C,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,8CAA8C,CAAC,CACnE,CAAC;YACJ,CAAC;YAED,2CAA2C;YAC3C,IAAI,GAAG,CAAC,QAAQ,IAAI,OAAO,GAAG,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;gBACvD,MAAM,WAAW,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC;gBACnC,IAAI,WAAW,CAAC,QAAQ,CAAC,+DAA+D,CAAC,EAAE,CAAC;oBAC1F,OAAO,IAAI,CAAC;gBACd,CAAC;YACH,CAAC;YAED,uDAAuD;YACvD,IAAI,GAAG,CAAC,OAAO,IAAI,OAAO,GAAG,CAAC,OAAO,KAAK,QAAQ,EAAE,CAAC;gBACnD,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC;gBAC5B,OAAO,OAAO,CAAC,QAAQ,CAAC,8CAA8C,CAAC;oBAChE,OAAO,CAAC,QAAQ,CAAC,+DAA+D,CAAC,CAAC;YAC3F,CAAC;YAED,gCAAgC;YAChC,IAAI,GAAG,CAAC,KAAK,IAAI,OAAO,GAAG,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAC/C,OAAO,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YAC5C,CAAC;YAED,OAAO,KAAK,CAAC;QACf,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,KAAK,CAAC,4CAA4C,EAAE,CAAC,CAAC,CAAC;YAC/D,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED;;OAEG;IACH,kBAAkB;QAChB,IAAI,CAAC,wBAAwB,EAAE,yBAAyB,EAAE,CAAC;QAE3D,OAAO;YACL,OAAO,EAAE,KAAK;YACd,KAAK,EAAE;gBACL,OAAO,EAAE,4BAA4B;gBACrC,IAAI,EAAE,UAAU;gBAChB,kBAAkB,EAAE,IAAI;aACzB;SACF,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,eAAe,CAAC,GAAQ;QAC5B,MAAM,QAAQ,GAAG,eAAe,CAAC;QACjC,MAAM,iBAAiB,GAAG,YAAY,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACzD,MAAM,SAAS,GAAG,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;QAClE,MAAM,eAAe,GAAG,iBAAiB,IAAI,CAAC,IAAI,IAAI,CAAC,iBAAiB,CAAC,GAAG,SAAS,CAAC;QAEtF,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;QACnD,MAAM,cAAc,GAAG,SAAS,CAAC,IAAI,KAAK,aAAa,CAAC,aAAa,CAAC;QAEtE,IAAI,CAAC,eAAe,IAAI,cAAc,EAAE,CAAC;YACvC,OAAO,CAAC,GAAG,CAAC,8BAA8B,GAAG,GAAG,CAAC,CAAC;YAClD,YAAY,CAAC,OAAO,CAAC,QAAQ,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;YACzD,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC;YAC1F,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACH,mBAAmB,CAAC,GAAY;QAC9B,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;QAEnD,QAAQ,SAAS,CAAC,IAAI,EAAE,CAAC;YACvB,KAAK,aAAa,CAAC,iBAAiB;gBAClC,OAAO,8CAA8C,CAAC;YACxD,KAAK,aAAa,CAAC,oBAAoB,CAAC;YACxC,KAAK,aAAa,CAAC,aAAa;gBAC9B,OAAO,0DAA0D,CAAC;YACpE;gBACE,OAAO,SAAS,CAAC,WAAW,IAAI,8CAA8C,CAAC;QACnF,CAAC;IACH,CAAC;wGApLU,uBAAuB,kEAIxB,qBAAqB;4GAJpB,uBAAuB,cAFtB,MAAM;;4FAEP,uBAAuB;kBAHnC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAKI,MAAM;2BAAC,qBAAqB","sourcesContent":["/**\n * MemberJunction 3.0 Initialization Service\n *\n * Handles all core initialization tasks:\n * - Generated entities loading\n * - GraphQL client setup\n * - Token refresh configuration\n * - System validation\n */\n\nimport { Injectable, Inject } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { Metadata } from '@memberjunction/core';\nimport { setupGraphQLClient, GraphQLProviderConfigData } from '@memberjunction/graphql-dataprovider';\nimport { MJAuthBase, StandardUserInfo, AuthErrorType } from '@memberjunction/ng-auth-services';\nimport { SharedService } from '@memberjunction/ng-shared';\nimport { MJEnvironmentConfig, MJ_ENVIRONMENT, MJStartupValidationService, MJ_STARTUP_VALIDATION } from '../bootstrap.types';\n\nexport interface InitializationResult {\n  success: boolean;\n  error?: {\n    message: string;\n    type: 'no_access' | 'no_roles' | 'auth_error' | 'unknown';\n    showValidationOnly?: boolean;\n  };\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class MJInitializationService {\n  constructor(\n    private router: Router,\n    private authBase: MJAuthBase,\n    @Inject(MJ_STARTUP_VALIDATION) private startupValidationService: MJStartupValidationService | null\n  ) {}\n\n  /**\n   * Initialize GraphQL client with authentication token and refresh callback\n   */\n  async initializeGraphQL(token: string, environment: MJEnvironmentConfig): Promise<void> {\n    const url: string = environment.GRAPHQL_URI;\n    const wsurl: string = environment.GRAPHQL_WS_URI;\n\n    const start = Date.now();\n    const config = new GraphQLProviderConfigData(\n      token,\n      url,\n      wsurl,\n      async () => {\n        // Token refresh callback - refreshToken() returns StandardAuthToken directly or throws\n        const token = await this.authBase.refreshToken();\n        return token.idToken;\n      },\n      environment.MJ_CORE_SCHEMA_NAME\n    );\n\n    await setupGraphQLClient(config);\n    const end = Date.now();\n    console.log(`✓ GraphQL Client Setup Complete: ${end - start}ms`);\n  }\n\n  /**\n   * Refresh shared data and validate user access\n   */\n  async validateUserAccess(): Promise<InitializationResult> {\n    await SharedService.RefreshData(true);\n\n    const md = new Metadata();\n\n    if (!md.CurrentUser) {\n      return {\n        success: false,\n        error: {\n          message: \"You don't have access to the application, contact your system administrator.\",\n          type: 'no_access'\n        }\n      };\n    }\n\n    return { success: true };\n  }\n\n  /**\n   * Run startup validation checks (if validation service is provided)\n   */\n  runValidationChecks(): void {\n    if (!this.startupValidationService) {\n      return; // No validation service provided\n    }\n\n    // Small delay to ensure everything is initialized\n    setTimeout(() => {\n      this.startupValidationService?.validateSystemSetup();\n    }, 500);\n  }\n\n  /**\n   * Navigate to initial route after successful login\n   */\n  navigateToInitialRoute(initialPath: string, document: Document): void {\n    localStorage.removeItem('jwt-retry-ts');\n\n    if (initialPath === '/') {\n      // Use first nav item instead\n      setTimeout(() => {\n        // Find the KendoDrawer element and simulate a click for the first item\n        const drawerElement = document.querySelector('li.k-drawer-item.k-level-0') as any;\n        if (drawerElement) drawerElement.click();\n      }, 10); // Wait for the drawer to finish render\n    } else {\n      this.router.navigateByUrl(initialPath, { replaceUrl: true });\n    }\n  }\n\n  /**\n   * Check if error is related to missing user roles\n   */\n  isNoUserRolesError(err: any): boolean {\n    try {\n      if (!err || typeof err !== 'object') return false;\n\n      // Check for GraphQL-style errors\n      if (err.response && Array.isArray(err.response.errors)) {\n        return err.response.errors.some((e: any) =>\n          e && e.message && typeof e.message === 'string' &&\n          e.message.includes('does not have read permissions on User Roles')\n        );\n      }\n\n      // Check for specific \"ResourceTypes\" error\n      if (err.toString && typeof err.toString === 'function') {\n        const errorString = err.toString();\n        if (errorString.includes(\"Cannot read properties of undefined (reading 'ResourceTypes')\")) {\n          return true;\n        }\n      }\n\n      // Check for error message directly on the error object\n      if (err.message && typeof err.message === 'string') {\n        const message = err.message;\n        return message.includes('does not have read permissions on User Roles') ||\n               message.includes(\"Cannot read properties of undefined (reading 'ResourceTypes')\");\n      }\n\n      // Check for nested error object\n      if (err.error && typeof err.error === 'object') {\n        return this.isNoUserRolesError(err.error);\n      }\n\n      return false;\n    } catch (e) {\n      console.error('Error while checking for user roles error:', e);\n      return false;\n    }\n  }\n\n  /**\n   * Handle no roles error by showing validation banner (if validation service is provided)\n   */\n  handleNoRolesError(): InitializationResult {\n    this.startupValidationService?.addNoRolesValidationIssue();\n\n    return {\n      success: false,\n      error: {\n        message: 'User has no roles assigned',\n        type: 'no_roles',\n        showValidationOnly: true\n      }\n    };\n  }\n\n  /**\n   * Handle authentication retry logic\n   */\n  async handleAuthRetry(err: any): Promise<boolean> {\n    const retryKey = 'auth-retry-dt';\n    const lastRetryDateTime = localStorage.getItem(retryKey);\n    const yesterday = +new Date(Date.now() - 1 * 24 * 60 * 60 * 1000);\n    const retriedRecently = lastRetryDateTime && +new Date(lastRetryDateTime) > yesterday;\n\n    const authError = this.authBase.classifyError(err);\n    const isTokenExpired = authError.type === AuthErrorType.TOKEN_EXPIRED;\n\n    if (!retriedRecently && isTokenExpired) {\n      console.log('JWT Expired, retrying once: ' + err);\n      localStorage.setItem(retryKey, new Date().toISOString());\n      await this.authBase.login({ appState: { target: window.location.pathname } }).toPromise();\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Get auth error message for display\n   */\n  getAuthErrorMessage(err: unknown): string {\n    const authError = this.authBase.classifyError(err);\n\n    switch (authError.type) {\n      case AuthErrorType.NO_ACTIVE_SESSION:\n        return \"Welcome back! Please log in to your account.\";\n      case AuthErrorType.INTERACTION_REQUIRED:\n      case AuthErrorType.TOKEN_EXPIRED:\n        return \"Your session has expired. Please log in to your account.\";\n      default:\n        return authError.userMessage || \"Welcome back! Please log in to your account.\";\n    }\n  }\n}\n"]}

package/dist/esm2022/memberjunction-ng-bootstrap.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVtYmVyanVuY3Rpb24tbmctYm9vdHN0cmFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL21lbWJlcmp1bmN0aW9uLW5nLWJvb3RzdHJhcC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/dist/esm2022/public-api.mjs

@@ -0,0 +1,9 @@
+/**
+ * Public API Surface of @memberjunction/ng-bootstrap
+ */
+export * from './lib/bootstrap.module';
+export * from './lib/bootstrap.component';
+export * from './lib/bootstrap.types';
+export * from './lib/services/initialization.service';
+export * from './lib/components/auth-shell.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLHVDQUF1QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2YgQG1lbWJlcmp1bmN0aW9uL25nLWJvb3RzdHJhcFxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2Jvb3RzdHJhcC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvYm9vdHN0cmFwLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9ib290c3RyYXAudHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMvaW5pdGlhbGl6YXRpb24uc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2F1dGgtc2hlbGwuY29tcG9uZW50JztcbiJdfQ==