@genesislcap/foundation-auth 15.14.2-FUI-2603.2 → 15.14.2-FUI-2603.3

package/dist/esm/machine/dto.js

@@ -1,76 +0,0 @@
-import { isAPIError, isDoneInvokeEvent, isErrorCustomEvent, isErrorEvent, } from '@genesislcap/foundation-state-machine';
-import { isFailedAuthDTO } from '../mapper/utils';
-const hasMessageType = (value) => typeof value === 'object' && value !== null && 'MESSAGE_TYPE' in value;
-/**
- * Unwrap a Genesis auth DTO from FetchMachine output or APIError.
- * @public
- */
-export function unwrapAuthDto(value) {
-    if (value == null) {
-        return undefined;
-    }
-    if (isAPIError(value)) {
-        return unwrapAuthDto(value.data);
-    }
-    if (hasMessageType(value)) {
-        return value;
-    }
-    if (typeof value === 'object' && 'data' in value) {
-        return unwrapAuthDto(value.data);
-    }
-    return undefined;
-}
-function eventErrorPayload(event) {
-    var _a, _b;
-    return (_b = (_a = event.data) !== null && _a !== void 0 ? _a : event.error) !== null && _b !== void 0 ? _b : event.output;
-}
-/**
- * Read the auth DTO from a fetch done/error event.
- * @public
- */
-export function authDtoFromMachineEvent(event) {
-    var _a;
-    if (isDoneInvokeEvent(event)) {
-        return unwrapAuthDto(event.output);
-    }
-    if (isErrorEvent(event) || isErrorCustomEvent(event)) {
-        return unwrapAuthDto(eventErrorPayload(event));
-    }
-    return unwrapAuthDto((_a = eventErrorPayload(event)) !== null && _a !== void 0 ? _a : event);
-}
-/**
- * True when a fetch done/error event carries a Genesis NACK / ERROR payload.
- * @public
- */
-export function isAuthNackEvent(event) {
-    return isFailedAuthDTO(authDtoFromMachineEvent(event));
-}
-/**
- * True when fetch completed in the failed final state without a Genesis NACK body.
- * @public
- */
-export function isFetchFailureOutput(event) {
-    if (!isDoneInvokeEvent(event)) {
-        return false;
-    }
-    const output = event.output;
-    if ((output === null || output === void 0 ? void 0 : output.error) == null) {
-        return false;
-    }
-    return !isAuthNackEvent(event);
-}
-/**
- * Fire-and-forget credential persistence so xstate does not hold pending on the Promise.
- * @public
- */
-export function persistCredentials(store, data) {
-    try {
-        const result = store(data);
-        if (result && typeof result.then === 'function') {
-            void result.catch(() => undefined);
-        }
-    }
-    catch (_a) {
-        // Credential storage is best-effort.
-    }
-}

package/dist/esm/machine/dto.test.js

@@ -1,88 +0,0 @@
-import { __awaiter } from "tslib";
-import { APIError } from '@genesislcap/foundation-state-machine';
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { StatusCodes } from 'http-status-codes';
-import { authDtoFromMachineEvent, isAuthNackEvent, isFetchFailureOutput, persistCredentials, unwrapAuthDto, } from './dto';
-const Suite = createLogicSuite('authDtoFromMachineEvent');
-const mfaNack = {
-    ERROR: [
-        {
-            '@type': 'LoginError',
-            CODE: 'MFA_REQUIRED',
-            TEXT: 'Problem logging in',
-            STATUS_CODE: '403 Forbidden',
-        },
-    ],
-    WARNING: [],
-    MESSAGE_TYPE: 'EVENT_LOGIN_AUTH_NACK',
-    SOURCE_REF: 'ref',
-};
-const eventAck = {
-    MESSAGE_TYPE: 'EVENT_ACK',
-    SOURCE_REF: 'ack-ref',
-};
-Suite('unwraps DTO from FetchMachineOutput', () => {
-    const dto = unwrapAuthDto({ data: mfaNack, response: { ok: false } });
-    assert.is(dto.MESSAGE_TYPE, 'EVENT_LOGIN_AUTH_NACK');
-});
-Suite('unwraps DTO from APIError', () => {
-    const dto = unwrapAuthDto(new APIError(StatusCodes.FORBIDDEN, mfaNack));
-    assert.is(dto.MESSAGE_TYPE, 'EVENT_LOGIN_AUTH_NACK');
-});
-Suite('treats HTTP 403 MFA NACK as auth nack on error.platform', () => {
-    assert.ok(isAuthNackEvent({
-        type: 'error.platform.loginFetcher',
-        data: new APIError(StatusCodes.FORBIDDEN, mfaNack),
-    }));
-});
-Suite('treats HTTP 403 MFA NACK as auth nack on done.invoke wrapping APIError', () => {
-    assert.ok(isAuthNackEvent({
-        type: 'done.invoke.loginFetcher',
-        output: new APIError(StatusCodes.FORBIDDEN, mfaNack),
-    }));
-});
-Suite('does not treat EVENT_ACK as nack', () => {
-    assert.not.ok(isAuthNackEvent({
-        type: 'done.invoke.resetPasswordFetcher',
-        output: { data: eventAck, response: { ok: true } },
-    }));
-    assert.is(authDtoFromMachineEvent({
-        type: 'done.invoke.resetPasswordFetcher',
-        output: { data: eventAck, response: { ok: true } },
-    }).MESSAGE_TYPE, 'EVENT_ACK');
-});
-Suite('unwraps DTO from xstate error payload on error field', () => {
-    assert.ok(isAuthNackEvent({
-        type: 'xstate.error.actor.0',
-        error: new APIError(StatusCodes.FORBIDDEN, mfaNack),
-    }));
-});
-Suite('does not treat HTTP 403 MFA NACK as a generic fetch failure', () => {
-    assert.not.ok(isFetchFailureOutput({
-        type: 'done.invoke.loginFetcher',
-        output: {
-            data: mfaNack,
-            error: new APIError(StatusCodes.FORBIDDEN, mfaNack),
-        },
-    }));
-});
-Suite('treats network/API failure without NACK as fetch failure', () => {
-    assert.ok(isFetchFailureOutput({
-        type: 'done.invoke.loginFetcher',
-        output: {
-            data: undefined,
-            error: new APIError(StatusCodes.INTERNAL_SERVER_ERROR),
-        },
-    }));
-});
-Suite('persistCredentials does not return the storage Promise', () => __awaiter(void 0, void 0, void 0, function* () {
-    let stored;
-    const result = persistCredentials((data) => new Promise((resolve) => {
-        stored = data;
-        resolve(true);
-    }), { id: 'jane', name: 'jane', password: 'x' });
-    assert.is(result, undefined);
-    yield Promise.resolve();
-    assert.is(stored === null || stored === void 0 ? void 0 : stored.id, 'jane');
-}));
-Suite.run();

package/dist/esm/machine/guards.test.js

@@ -1,53 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { is200Nack } from './guards';
-import { isResetPasswordParams } from './types';
-const Suite = createLogicSuite('auth machine password reset guards');
-const nackDto = {
-    MESSAGE_TYPE: 'EVENT_NACK',
-    SOURCE_REF: 'ref',
-    ERROR: [
-        {
-            '@type': 'StandardError',
-            CODE: 'INTERNAL_ERROR',
-            TEXT: 'Password validation failed',
-            STATUS_CODE: '500 Internal Server Error',
-        },
-    ],
-    WARNING: [],
-};
-Suite('is200Nack is true for FetchMachineOutput wrapping EVENT_NACK', () => {
-    assert.ok(is200Nack({
-        type: 'done.invoke.resetPasswordFetcher',
-        output: { data: nackDto, response: { ok: true } },
-    }));
-});
-Suite('is200Nack is true for EVENT_NACK even when HTTP is not ok', () => {
-    assert.ok(is200Nack({
-        type: 'done.invoke.resetPasswordFetcher',
-        output: { data: nackDto, response: { ok: false } },
-    }));
-});
-Suite('is200Nack is false for EVENT_ACK without errors', () => {
-    assert.not.ok(is200Nack({
-        type: 'done.invoke.resetPasswordFetcher',
-        output: { data: { MESSAGE_TYPE: 'EVENT_ACK', SOURCE_REF: 'ref' }, response: { ok: true } },
-    }));
-});
-Suite('isResetPasswordParams requires username, token and new password', () => {
-    assert.ok(isResetPasswordParams({
-        username: 'JaneDee',
-        resetToken: 'token',
-        newPassword: 'Password11*',
-    }));
-    assert.not.ok(isResetPasswordParams({
-        username: '',
-        resetToken: 'token',
-        newPassword: 'Password11*',
-    }));
-    assert.not.ok(isResetPasswordParams({
-        username: 'JaneDee',
-        resetToken: '',
-        newPassword: 'Password11*',
-    }));
-});
-Suite.run();

package/dist/esm/mapper/utils.test.js

@@ -1,56 +0,0 @@
-import { APIError } from '@genesislcap/foundation-state-machine';
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { StatusCodes } from 'http-status-codes';
-import { nackErrorFromUnknown } from '../machine/errors';
-import { hasDTOErrors, isFailedAuthDTO, isNackDTO } from './utils';
-const Suite = createLogicSuite('password-reset response handling');
-const passwordValidationNack = {
-    WARNING: [],
-    ERROR: [
-        {
-            '@type': 'StandardError',
-            CODE: 'INTERNAL_ERROR',
-            TEXT: 'Password validation failed Password must be 8 or more characters in length.\nPassword must contain 1 or more special characters.',
-            STATUS_CODE: '500 Internal Server Error',
-        },
-    ],
-    MESSAGE_TYPE: 'EVENT_NACK',
-    SOURCE_REF: '17605761-55cb-4b5a-a1ec-7235d3cae393',
-};
-const eventAck = {
-    MESSAGE_TYPE: 'EVENT_ACK',
-    SOURCE_REF: 'ack-ref',
-};
-Suite('detects EVENT_NACK as failure', () => {
-    assert.ok(isNackDTO(passwordValidationNack));
-    assert.ok(isFailedAuthDTO(passwordValidationNack));
-    assert.ok(hasDTOErrors(passwordValidationNack));
-});
-Suite('detects ERROR payload as failure even without NACK suffix', () => {
-    const ackWithErrors = Object.assign(Object.assign({}, eventAck), { ERROR: passwordValidationNack.ERROR });
-    assert.not.ok(isNackDTO(ackWithErrors));
-    assert.ok(hasDTOErrors(ackWithErrors));
-    assert.ok(isFailedAuthDTO(ackWithErrors));
-});
-Suite('treats EVENT_ACK without ERROR as success', () => {
-    assert.not.ok(isNackDTO(eventAck));
-    assert.not.ok(hasDTOErrors(eventAck));
-    assert.not.ok(isFailedAuthDTO(eventAck));
-});
-Suite('extracts strong-password error text from EVENT_NACK', () => {
-    const error = nackErrorFromUnknown(passwordValidationNack);
-    assert.ok(error);
-    assert.ok(error.message.includes('Password validation failed'));
-    assert.is(error.status, StatusCodes.INTERNAL_SERVER_ERROR);
-});
-Suite('extracts NACK from FetchMachineOutput and APIError wrappers', () => {
-    const fromFetch = nackErrorFromUnknown({ data: passwordValidationNack, response: { ok: true } });
-    assert.ok(fromFetch === null || fromFetch === void 0 ? void 0 : fromFetch.message.includes('Password validation failed'));
-    const fromApiError = nackErrorFromUnknown(new APIError(StatusCodes.INTERNAL_SERVER_ERROR, passwordValidationNack));
-    assert.ok(fromApiError === null || fromApiError === void 0 ? void 0 : fromApiError.message.includes('Password validation failed'));
-});
-Suite('does not treat EVENT_ACK as an error', () => {
-    assert.is(nackErrorFromUnknown(eventAck), null);
-    assert.is(nackErrorFromUnknown({ data: eventAck }), null);
-});
-Suite.run();

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

@@ -1,99 +0,0 @@
-/**
- * Identity captured during forgot-password so the token reset screen can
- * submit USER_NAME without asking the user to type it again.
- */
-export const RESET_IDENTITY_STORAGE_KEY = 'foundation-auth:password-reset-identity';
-const getStorage = (storage) => {
-    if (storage) {
-        return storage;
-    }
-    try {
-        return globalThis.localStorage;
-    }
-    catch (_a) {
-        return undefined;
-    }
-};
-/**
- * @public
- */
-export function persistResetIdentity(identity, storage) {
-    var _a, _b;
-    if (!((_a = identity === null || identity === void 0 ? void 0 : identity.username) === null || _a === void 0 ? void 0 : _a.trim())) {
-        return;
-    }
-    const target = getStorage(storage);
-    if (!target) {
-        return;
-    }
-    try {
-        target.setItem(RESET_IDENTITY_STORAGE_KEY, JSON.stringify({
-            username: identity.username.trim(),
-            organisation: ((_b = identity.organisation) === null || _b === void 0 ? void 0 : _b.trim()) || undefined,
-        }));
-    }
-    catch (_c) {
-        // Storage may be unavailable (private mode, SSR).
-    }
-}
-/**
- * @public
- */
-export function readResetIdentity(storage) {
-    var _a, _b;
-    const target = getStorage(storage);
-    if (!target) {
-        return undefined;
-    }
-    try {
-        const raw = target.getItem(RESET_IDENTITY_STORAGE_KEY);
-        if (!raw) {
-            return undefined;
-        }
-        const parsed = JSON.parse(raw);
-        if ((_a = parsed === null || parsed === void 0 ? void 0 : parsed.username) === null || _a === void 0 ? void 0 : _a.trim()) {
-            return {
-                username: parsed.username.trim(),
-                organisation: ((_b = parsed.organisation) === null || _b === void 0 ? void 0 : _b.trim()) || undefined,
-            };
-        }
-    }
-    catch (_c) {
-        // Ignore malformed payloads.
-    }
-    return undefined;
-}
-/**
- * @public
- */
-export function clearResetIdentity(storage) {
-    const target = getStorage(storage);
-    if (!target) {
-        return;
-    }
-    try {
-        target.removeItem(RESET_IDENTITY_STORAGE_KEY);
-    }
-    catch (_a) {
-        // Storage may be unavailable.
-    }
-}
-/**
- * @public
- */
-export function resolveResetUsername(queryParams = {}, stored) {
-    return (queryParams.username ||
-        queryParams.user ||
-        queryParams.USER_NAME ||
-        (stored === null || stored === void 0 ? void 0 : stored.username) ||
-        '').trim();
-}
-/**
- * Username is required by EVENT_PASSWORD_RESET_ACTION. Hide it only when a
- * reset token is present and the username is already known.
- *
- * @public
- */
-export function shouldShowIdentityFields(passwordResetToken, username) {
-    return !passwordResetToken || !username.trim();
-}

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

@@ -1,55 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { clearResetIdentity, persistResetIdentity, readResetIdentity, resolveResetUsername, RESET_IDENTITY_STORAGE_KEY, shouldShowIdentityFields, } from './reset-identity';
-const Suite = createLogicSuite('reset-identity');
-const createMemoryStorage = () => {
-    const map = new Map();
-    return {
-        get length() {
-            return map.size;
-        },
-        clear: () => map.clear(),
-        getItem: (key) => { var _a; return (_a = map.get(key)) !== null && _a !== void 0 ? _a : null; },
-        key: (index) => { var _a; return (_a = [...map.keys()][index]) !== null && _a !== void 0 ? _a : null; },
-        removeItem: (key) => {
-            map.delete(key);
-        },
-        setItem: (key, value) => {
-            map.set(key, value);
-        },
-    };
-};
-Suite('hides username when token is present and username is known', () => {
-    assert.not.ok(shouldShowIdentityFields('reset-token', 'JaneDee'));
-});
-Suite('shows username when token is present but username is missing', () => {
-    assert.ok(shouldShowIdentityFields('reset-token', ''));
-    assert.ok(shouldShowIdentityFields('reset-token', '   '));
-});
-Suite('shows username when token is absent', () => {
-    assert.ok(shouldShowIdentityFields('', 'JaneDee'));
-    assert.ok(shouldShowIdentityFields(undefined, ''));
-});
-Suite('resolves username from query params before stored identity', () => {
-    const stored = { username: 'stored-user' };
-    assert.is(resolveResetUsername({ username: 'query-user' }, stored), 'query-user');
-    assert.is(resolveResetUsername({ user: 'alias-user' }, stored), 'alias-user');
-    assert.is(resolveResetUsername({ USER_NAME: 'legacy-user' }, stored), 'legacy-user');
-});
-Suite('resolves username from stored identity when query has no username', () => {
-    assert.is(resolveResetUsername({ password: 'token' }, { username: 'stored-user' }), 'stored-user');
-    assert.is(resolveResetUsername({ password: 'token' }), '');
-});
-Suite('persists, reads and clears reset identity', () => {
-    const storage = createMemoryStorage();
-    persistResetIdentity({ username: ' JaneDee ', organisation: ' FBN ' }, storage);
-    assert.equal(readResetIdentity(storage), { username: 'JaneDee', organisation: 'FBN' });
-    assert.ok(storage.getItem(RESET_IDENTITY_STORAGE_KEY));
-    clearResetIdentity(storage);
-    assert.is(readResetIdentity(storage), undefined);
-});
-Suite('does not persist empty username', () => {
-    const storage = createMemoryStorage();
-    persistResetIdentity({ username: '  ' }, storage);
-    assert.is(readResetIdentity(storage), undefined);
-});
-Suite.run();