@genesislcap/foundation-auth 14.71.1-auth-mf.21 → 14.99.0-auth-mf.22

package/dist/esm/routes/login/login.js

@@ -1,9 +1,9 @@
 import { __awaiter, __decorate } from "tslib";
 import { inIFrame, inSymphonyDesktop, openPopup } from '@genesislcap/foundation-utils';
-import { customElement, DOM, volatile } from '@microsoft/fast-element';
+import { customElement, volatile } from '@microsoft/fast-element';
 import { CredentialManager, CredentialType } from '../../credential';
 import { User } from '../../user';
-import { getSSOLoginURL, logger } from '../../utils';
+import { logger } from '../../utils';
 import { BaseRoute } from '../base';
 import { LoginStyles as styles } from './login.styles';
 import { LoginTemplate as template } from './login.template';
@@ -11,14 +11,14 @@ let Login = class Login extends BaseRoute {
     connectedCallback() {
         super.connectedCallback();
         /**
-         * Retaining the logic that logs authenticated users out when this route is visited for now.
-         * TODO: Revisit as shouldn't load mf if logged in already.
+         * For now, I'm retaining the logic that logs authenticated users out when this route is visited. However, this
+         * shouldn't happen. We shouldn't be loading this screen if logged-in.
+         * TODO: Remove pending investigation.
          */
         if (this.user.isAuthenticated) {
             this.logout();
             return;
         }
-        this.attemptAutofill();
     }
     attemptBasicLogin() {
         const basicCredentials = {
@@ -34,13 +34,16 @@ let Login = class Login extends BaseRoute {
         this.login(basicCredentials);
     }
     get ssoToggleLabel() {
-        const { selectedIDP, ssoToggled } = this.store.formEntry;
-        const selectedIDPLabel = selectedIDP ? ` - ${selectedIDP}` : '';
+        const { selectedIdp, ssoToggled } = this.store.formEntry;
+        const selectedIDPLabel = selectedIdp ? ` - ${selectedIdp.id}` : '';
         return ssoToggled ? 'SSO Enabled' + selectedIDPLabel : 'Enable SSO?';
     }
     onSSOLogin() {
-        const selectedIDP = this.store.formEntry.idps.find((idp) => idp.id === this.store.formEntry.selectedIDP);
-        const ssoLoginUrl = getSSOLoginURL(selectedIDP);
+        const ssoLoginUrl = this.store.formEntry.ssoLoginUrl;
+        if (!ssoLoginUrl) {
+            logger.error(`SSO login url invalid, aborting login attempt.`);
+            return;
+        }
         if (inIFrame()) {
             if (inSymphonyDesktop()) {
                 // symphony/electron opens new window in the default browser instead
@@ -57,9 +60,7 @@ let Login = class Login extends BaseRoute {
     }
     onLoginSubmit() {
         return __awaiter(this, void 0, void 0, function* () {
-            DOM.queueUpdate(() => {
-                this.attemptBasicLogin();
-            });
+            this.attemptBasicLogin();
         });
     }
     login(params) {

package/dist/esm/routes/login/login.template.js

@@ -62,13 +62,13 @@ const ssoLogin = html `
         <${selectTag}
           name="sso"
           data-test-id="sso"
-          @change="${selectEmit('auth-selectedIDP-changed')}"
+          @change="${selectEmit('auth-selectedIdp-changed')}"
           ?disabled=${(x) => !x.store.formEntry.idps.length}
         >
           ${repeat((x) => x.store.formEntry.idps, html `
               <${listboxOptionTag}
                 value=${({ id }) => id}
-                ?selected=${(x, c) => c.parent.store.formEntry.selectedIDP == x.id}
+                ?selected=${(x, c) => c.parent.store.formEntry.selectedIdp === x}
               >
                 ${({ id }) => id}
               </${listboxOptionTag}>
@@ -80,7 +80,7 @@ const ssoLogin = html `
           appearance="primary-gradient"
           @click="${(x) => x.onSSOLogin()}"
           data-test-id="sso-login"
-          ?disabled=${(x) => !x.store.formEntry.selectedIDP}
+          ?disabled=${(x) => !x.store.formEntry.selectedIdp}
         >
           SSO Login
         </${buttonTag}>

package/dist/esm/routes/reset-password/reset-password.js

@@ -9,10 +9,6 @@ let ResetPassword = class ResetPassword extends BaseRoute {
         this.hasPasswordExpired = false;
         this.passwordResetToken = '';
     }
-    connectedCallback() {
-        super.connectedCallback();
-        this.attemptAutofill();
-    }
     enter(phase) {
         this.hasPasswordExpired = !!phase.route.queryParams.expired;
         this.passwordResetToken = phase.route.queryParams.password;

package/dist/esm/services/idp.js

@@ -0,0 +1,71 @@
+import { __awaiter, __decorate } from "tslib";
+import { FetchMachine } from '@genesislcap/foundation-state-machine';
+import { DI } from '@microsoft/fast-foundation';
+import { SSO_LIST_URL, SSO_LOGIN_URL } from '../env';
+import { fromIDPDTO } from '../mapper';
+/**
+ * Default IDPService.
+ * @public
+ */
+export class DefaultIDPService {
+    constructor() {
+        /**
+         * The pattern matches `{property}` values in the string.
+         * @internal
+         */
+        this.loginUrlReplacePattern = /{\s*(\w+?)\s*}/g;
+        /** {@inheritDoc IDPService.getList} */
+        this.getList = (url = SSO_LIST_URL) => __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const fetcher = this.fetchMachine.getFromContainer();
+                fetcher.provide({
+                    actions: {
+                        successCallback: ({ context }) => {
+                            const { data } = context;
+                            /**
+                             * Format reference:
+                             * const IDPS: IDP[] = [
+                             *   { ID: 'hsbc', DESCRIPTION: 'hsbc', TYPE: 'saml' },
+                             *   { ID: 'mufg', DESCRIPTION: 'mufg', TYPE: 'saml' },
+                             * ];
+                             */
+                            const IDPS = data === null || data === void 0 ? void 0 : data.IDPS;
+                            if (!IDPS || !IDPS.length) {
+                                reject(Error('Identity provider list empty'));
+                                return;
+                            }
+                            const idps = IDPS.map((dto) => fromIDPDTO(dto));
+                            resolve(idps);
+                        },
+                        errorCallback: () => reject(Error('Failed to fetch identity providers')),
+                    },
+                });
+                fetcher.start();
+                fetcher.send({
+                    type: 'fetch',
+                    params: {
+                        /**
+                         * Used `url: 'https://hsbc-uat-priss1/gwf/sso/list'` during testing.
+                         */
+                        url,
+                    },
+                });
+            });
+        });
+        /** {@inheritDoc IDPService.getLoginUrl} */
+        this.getLoginUrl = (idp, urlTemplate = SSO_LOGIN_URL) => {
+            if (!idp || !idp.type || !idp.id) {
+                throw new Error(`Invalid IDP: ${JSON.stringify(idp)}`);
+            }
+            return urlTemplate.replace(this.loginUrlReplacePattern, (_, token) => idp[token] || '');
+        };
+    }
+}
+__decorate([
+    FetchMachine
+], DefaultIDPService.prototype, "fetchMachine", void 0);
+/**
+ * IDPService DI key.
+ * @internal
+ */
+export const IDPService = DI.createInterface((x) => x.singleton(DefaultIDPService));

package/dist/esm/services/index.js

@@ -0,0 +1 @@
+export * from './idp';

package/dist/esm/store/auth.js

@@ -1,10 +1,10 @@
 import { __decorate, __param } from "tslib";
 import { AbstractStoreRoot, registerStore, } from '@genesislcap/foundation-store';
 import { AuthConfig } from '../config/config';
-import { AuthMachine } from '../machine';
+import { AuthMachine } from '../machine/machine';
 import { AuthFormEntryStore } from './authFormEntry';
 /**
- * Default implementation of the store.
+ * Default AuthStore.
  * @public
  */
 let DefaultAuthStore = class DefaultAuthStore extends AbstractStoreRoot {
@@ -13,28 +13,50 @@ let DefaultAuthStore = class DefaultAuthStore extends AbstractStoreRoot {
         this.config = config;
         this.authMachine = authMachine;
         this.formEntry = formEntry;
+        /** {@inheritDoc AuthStore.onMachineEvent} */
         this.onMachineEvent = this.createListener('auth-machine-event', (event) => this.authMachine.send(event));
+        /** {@inheritDoc AuthStore.onLogin} */
         this.onLogin = this.createListener('auth-login', (params) => this.authMachine.send({
             type: 'login',
             params,
         }));
+        /** {@inheritDoc AuthStore.onLogout} */
         this.onLogout = this.createListener('auth-logout', () => this.authMachine.send({ type: 'logout' }));
+        /** {@inheritDoc AuthStore.onChangePassword} */
         this.onChangePassword = this.createListener('auth-change-password', (params) => this.authMachine.send({
             type: 'change-password',
             params,
         }));
+        /** {@inheritDoc AuthStore.onForgotPassword} */
         this.onForgotPassword = this.createListener('auth-forgot-password', (params) => this.authMachine.send({
             type: 'forgot-password',
             params,
         }));
+        /** {@inheritDoc AuthStore.onResetPassword} */
         this.onResetPassword = this.createListener('auth-reset-password', (params) => this.authMachine.send({
             type: 'reset-password',
             params,
         }));
     }
+    /** {@inheritDoc AuthStore.isPending} */
     get isPending() {
         return !this.ready || this.authMachine.hasTag('pending');
     }
+    /** {@inheritDoc AuthStore.metaMessages} */
+    get metaMessages() {
+        return this.authMachine.getMetaValuesByKey();
+    }
+    /** {@inheritDoc AuthStore.errorMessages} */
+    get errorMessages() {
+        const messages = [];
+        for (const { message } of this.authMachine.errors.values()) {
+            messages.push(message);
+        }
+        for (const { message } of this.formEntry.errors.values()) {
+            messages.push(message);
+        }
+        return messages;
+    }
 };
 DefaultAuthStore = __decorate([
     __param(0, AuthConfig),
@@ -43,7 +65,7 @@ DefaultAuthStore = __decorate([
 ], DefaultAuthStore);
 export { DefaultAuthStore };
 /**
- * DI key of the store.
+ * AuthStore DI key.
  * @internal
  */
 export const AuthStore = registerStore(DefaultAuthStore, 'AuthStore');

package/dist/esm/store/authFormEntry.js

@@ -1,15 +1,16 @@
 import { __awaiter, __decorate } from "tslib";
-import { FetchMachine } from '@genesislcap/foundation-state-machine';
 import { AbstractStore, registerStore } from '@genesislcap/foundation-store';
 import { observable, volatile } from '@microsoft/fast-element';
 import { AuthConfig } from '../config/config';
 import { CredentialManager, credentialSeparator } from '../credential';
-import { fetchIDPs, logger } from '../utils';
+import { IDPService } from '../services';
+import { logger } from '../utils';
 /**
- * Default implementation of the store.
+ * Default AuthFormEntryStore.
  * @public
  */
 export class DefaultAuthFormEntryStore extends AbstractStore {
+    /** {@inheritDoc AuthFormEntryStore.orgUsername} */
     get orgUsername() {
         return this.config.fields.organisation && this.organisation.trim() !== ''
             ? `${this.username.trim()}:${this.organisation.trim()}`
@@ -18,55 +19,101 @@ export class DefaultAuthFormEntryStore extends AbstractStore {
     constructor() {
         var _a, _b;
         super();
-        this.host = '';
+        /** {@inheritDoc AuthFormEntryStore.organisation} */
         this.organisation = '';
+        /** {@inheritDoc AuthFormEntryStore.username} */
         this.username = '';
+        /** {@inheritDoc AuthFormEntryStore.email} */
         this.email = '';
+        /** {@inheritDoc AuthFormEntryStore.password} */
         this.password = '';
-        this.password2 = ''; // < New, confirm etc.
+        /** {@inheritDoc AuthFormEntryStore.password2} */
+        this.password2 = '';
+        /** {@inheritDoc AuthFormEntryStore.showPasswords} */
         this.showPasswords = false;
+        /** {@inheritDoc AuthFormEntryStore.hasPasswordExpired} */
         this.hasPasswordExpired = false;
+        /** {@inheritDoc AuthFormEntryStore.passwordResetToken} */
         this.passwordResetToken = '';
-        this.message = '';
-        this.hasErrors = false;
+        /** {@inheritDoc AuthFormEntryStore.mfaCode} */
         this.mfaCode = '';
+        /** {@inheritDoc AuthFormEntryStore.idps} */
         this.idps = [];
-        this.selectedIDP = '';
+        /** {@inheritDoc AuthFormEntryStore.ssoToggled} */
         this.ssoToggled = false;
+        /** {@inheritDoc AuthFormEntryStore.termsAgreed} */
         this.termsAgreed = false;
+        /** {@inheritDoc AuthFormEntryStore.autofilling} */
         this.autofilling = false;
+        /** {@inheritDoc AuthFormEntryStore.onAutofillForm} */
         this.onAutofillForm = this.createListener('auth-autofill-form', () => this.autofill());
+        /** {@inheritDoc AuthFormEntryStore.onOrganisationChanged} */
         this.onOrganisationChanged = this.createListener('auth-organisation-changed', (detail) => (this.commit.organisation = detail));
+        /** {@inheritDoc AuthFormEntryStore.onUsernameChanged} */
         this.onUsernameChanged = this.createListener('auth-username-changed', (detail) => (this.commit.username = detail));
+        /** {@inheritDoc AuthFormEntryStore.onEmailChanged} */
         this.onEmailChanged = this.createListener('auth-email-changed', (detail) => (this.commit.email = detail));
+        /** {@inheritDoc AuthFormEntryStore.onPasswordChanged} */
         this.onPasswordChanged = this.createListener('auth-password-changed', (detail) => (this.commit.password = detail));
+        /** {@inheritDoc AuthFormEntryStore.onPassword2Changed} */
         this.onPassword2Changed = this.createListener('auth-password2-changed', (detail) => (this.commit.password2 = detail));
+        /** {@inheritDoc AuthFormEntryStore.onShowPasswordsChanged} */
         this.onShowPasswordsChanged = this.createListener('auth-showPasswords-changed', (detail) => (this.commit.showPasswords = detail));
-        this.onSelectedIDPChanged = this.createListener('auth-selectedIDP-changed', (detail) => (this.commit.selectedIDP = detail));
+        /** {@inheritDoc AuthFormEntryStore.onSelectedIdpChanged} */
+        this.onSelectedIdpChanged = this.createListener('auth-selectedIdp-changed', (detail) => {
+            this.commit.selectedIdp = Array.isArray(this.idps)
+                ? this.idps.find((idp) => idp.id === detail)
+                : undefined;
+        });
+        /** {@inheritDoc AuthFormEntryStore.onSSOToggleChanged} */
         this.onSSOToggleChanged = this.createListener('auth-ssoToggled-changed', (detail) => (this.commit.ssoToggled = detail));
+        /**
+         * @privateRemarks
+         * Internally observed given constructor assignment.
+         * @internal
+         */
+        this.ssoToggledChanged = (prev, next) => __awaiter(this, void 0, void 0, function* () {
+            if (!next) {
+                this.resetIDPState();
+                this.commit.errors.delete('auth-fetch-idps-error');
+                return;
+            }
+            try {
+                const idps = yield this.idpService.getList();
+                this.emit('auth-fetch-idps-success', idps);
+            }
+            catch (e) {
+                this.emit('auth-fetch-idps-error', e);
+            }
+        });
         this.ssoToggled = (_b = (_a = this.config.sso) === null || _a === void 0 ? void 0 : _a.toggled) !== null && _b !== void 0 ? _b : false;
         /**
          * Listeners not on the public interface can be created anonymously
          */
         this.createListener('auth-fetch-idps-success', (idps) => {
             this.commit.idps = idps;
-            this.commit.selectedIDP = idps && idps.length ? idps[0].id : '';
+            this.commit.selectedIdp = Array.isArray(idps) ? idps[0] : undefined;
         });
         this.createErrorListener('auth-fetch-idps-error', () => this.resetIDPState());
     }
+    /**
+     * @internal
+     */
     resetIDPState() {
         this.commit.idps = [];
-        this.commit.selectedIDP = '';
+        this.commit.selectedIdp = undefined;
     }
+    /**
+     * @internal
+     */
     autofill() {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             let credentialData;
             try {
                 /**
-                 * TODO: Revert back to `credentialManager.getCredentials()` after Neptune deployment.
-                 * Neptune was using cookies directly. To provide them with a seamless upgrade, we should load from cookies if the
-                 * container is empty. These stored cookies become irrelevant after their first login in the new system.
+                 * Neptune was using cookies to store user credentials. To provide them with a seamless upgrade, we should load
+                 * from cookies if the container is empty. These cookies become irrelevant after first login using container.
                  */
                 this.autofilling = true;
                 const containerData = yield this.credentialManager.getCredentialsFromContainer();
@@ -101,28 +148,9 @@ export class DefaultAuthFormEntryStore extends AbstractStore {
             return Promise.resolve(!!credentialData);
         });
     }
-    ssoToggledChanged(prev, next) {
-        var _a, _b;
-        if (!next) {
-            this.resetIDPState();
-            return;
-        }
-        const path = `${(_b = (_a = this.config.sso) === null || _a === void 0 ? void 0 : _a.identityProvidersPath) !== null && _b !== void 0 ? _b : 'sso/list'}`;
-        this.errors.delete('auth-fetch-idps-error');
-        const emitError = () => this.emit('auth-fetch-idps-error', Error('Failed to fetch identity providers.'));
-        /**
-         * TODO: Port to FetchMachine, need to sort out all the utils/sso stuff.
-         */
-        fetchIDPs(path)
-            .then((idps) => {
-            var _a;
-            if (!idps.length || (idps.length === 1 && ((_a = idps[0]) === null || _a === void 0 ? void 0 : _a.id) === 'error')) {
-                emitError();
-                return;
-            }
-            this.emit('auth-fetch-idps-success', idps);
-        })
-            .catch(() => emitError());
+    /** {@inheritDoc AuthFormEntryStore.ssoLoginUrl} */
+    get ssoLoginUrl() {
+        return this.selectedIdp ? this.idpService.getLoginUrl(this.selectedIdp) : null;
     }
 }
 __decorate([
@@ -132,11 +160,8 @@ __decorate([
     CredentialManager
 ], DefaultAuthFormEntryStore.prototype, "credentialManager", void 0);
 __decorate([
-    FetchMachine
-], DefaultAuthFormEntryStore.prototype, "fetchMachine", void 0);
-__decorate([
-    observable
-], DefaultAuthFormEntryStore.prototype, "host", void 0);
+    IDPService
+], DefaultAuthFormEntryStore.prototype, "idpService", void 0);
 __decorate([
     observable
 ], DefaultAuthFormEntryStore.prototype, "organisation", void 0);
@@ -161,12 +186,6 @@ __decorate([
 __decorate([
     observable
 ], DefaultAuthFormEntryStore.prototype, "passwordResetToken", void 0);
-__decorate([
-    observable
-], DefaultAuthFormEntryStore.prototype, "message", void 0);
-__decorate([
-    observable
-], DefaultAuthFormEntryStore.prototype, "hasErrors", void 0);
 __decorate([
     observable
 ], DefaultAuthFormEntryStore.prototype, "mfaCode", void 0);
@@ -175,7 +194,7 @@ __decorate([
 ], DefaultAuthFormEntryStore.prototype, "idps", void 0);
 __decorate([
     observable
-], DefaultAuthFormEntryStore.prototype, "selectedIDP", void 0);
+], DefaultAuthFormEntryStore.prototype, "selectedIdp", void 0);
 __decorate([
     observable
 ], DefaultAuthFormEntryStore.prototype, "ssoToggled", void 0);
@@ -189,7 +208,7 @@ __decorate([
     volatile
 ], DefaultAuthFormEntryStore.prototype, "orgUsername", null);
 /**
- * DI key of the store.
+ * AuthFormEntryStore DI key.
  * @internal
  */
 export const AuthFormEntryStore = registerStore(DefaultAuthFormEntryStore, 'AuthFormEntryStore');

package/dist/esm/tags/tags.js

@@ -52,26 +52,8 @@ export const textFieldTag = tagFor(templateOptions.textField);
 /**
  * @internal
  */
-export const progressRingTag = tagFor(templateOptions.progressRing);
+export const progressTag = tagFor(templateOptions.progress);
 /**
- * @privateRemarks
- * An alternative pattern under test.
  * @internal
  */
-export function getTags() {
-    var _a;
-    const config = DI.getOrCreateDOMContainer().get(AuthConfig);
-    const components = (_a = config === null || config === void 0 ? void 0 : config.templateOptions) !== null && _a !== void 0 ? _a : defaultTemplateOptions;
-    return {
-        anchor: tagFor(components.anchor),
-        button: tagFor(components.button),
-        card: tagFor(components.card),
-        checkbox: tagFor(components.checkbox),
-        listboxOption: tagFor(components.listboxOption),
-        provider: tagFor(components.provider),
-        router: tagFor(components.router),
-        select: tagFor(components.select),
-        textField: tagFor(components.textField),
-        progressRing: tagFor(components.progressRing),
-    };
-}
+export const progressRingTag = tagFor(templateOptions.progressRing);

package/dist/esm/utils/index.js

@@ -1,2 +1 @@
 export * from './logger';
-export * from './sso';

package/dist/esm/utils/logger.js

@@ -1,4 +1,4 @@
-import { createLogger } from '@genesislcap/foundation-utils';
+import { createLogger } from '@genesislcap/foundation-logger';
 /**
  * @public
  */