@nu-art/user-account-shared 0.400.5

package/_entity/account/api-def.d.ts

@@ -0,0 +1,115 @@
+import { ApiDefResolver, BodyApi, QueryApi } from '@nu-art/thunderstorm-shared';
+import { DB_BaseObject, UniqueId } from '@nu-art/ts-common';
+import { AccountType, DB_Account, UI_Account } from './types.js';
+import { DB_Session, QueryParam_RedirectUrl } from '../session/index.js';
+import { PasswordAssertionConfig } from '../../_enum/password-assertion/index.js';
+export type Response_Auth = UI_Account & DB_BaseObject;
+export type AccountEmail = {
+    email: string;
+};
+export type AccountEmailWithDevice = AccountEmail & {
+    deviceId: string;
+};
+export type AccountPassword = {
+    password: string;
+};
+export type PasswordWithCheck = AccountPassword & {
+    passwordCheck: string;
+};
+export type DBAccountType = {
+    type: AccountType;
+};
+export type AccountToAssertPassword = AccountEmail & Partial<PasswordWithCheck>;
+export type AccountToSpice = AccountEmail & AccountPassword;
+export type Request_RegisterAccount = DBAccountType & AccountEmailWithDevice & PasswordWithCheck;
+export type Account_RegisterAccount = {
+    request: AccountEmailWithDevice & PasswordWithCheck;
+    response: Response_Auth;
+};
+export type Account_CreateAccount = {
+    request: DBAccountType & AccountEmail & Partial<PasswordWithCheck>;
+    response: UI_Account & DB_BaseObject;
+};
+export type Account_ChangePassword = {
+    request: PasswordWithCheck & {
+        oldPassword: string;
+    };
+    response: Response_Auth;
+};
+export type Account_Login = {
+    request: AccountEmailWithDevice & AccountPassword;
+    response: Response_Auth;
+};
+export type Account_CreateToken = {
+    request: {
+        accountId: UniqueId;
+        ttl: number;
+        label: string;
+    };
+    response: {
+        token: string;
+    };
+};
+export type Account_SetPassword = {
+    request: PasswordWithCheck;
+    response: Response_Auth;
+};
+export type Account_GetSessions = {
+    request: DB_BaseObject;
+    response: {
+        sessions: DB_Session[];
+    };
+};
+export type Account_ChangeThumbnail = {
+    request: {
+        accountId: string;
+        hash: string;
+    };
+    response: {
+        account: DB_Account;
+    };
+};
+export type Account_GetPasswordAssertionConfig = {
+    request: void;
+    response: {
+        config: PasswordAssertionConfig | undefined;
+    };
+};
+export type ApiStruct_Account = {
+    _v1: {
+        registerAccount: BodyApi<Account_RegisterAccount['response'], Account_RegisterAccount['request']>;
+        refreshSession: QueryApi<void>;
+        createAccount: BodyApi<Account_CreateAccount['response'], Account_CreateAccount['request']>;
+        changePassword: BodyApi<Account_ChangePassword['response'], Account_ChangePassword['request']>;
+        login: BodyApi<Account_Login['response'], Account_Login['request']>;
+        logout: QueryApi<void>;
+        createToken: BodyApi<Account_CreateToken['response'], Account_CreateToken['request']>;
+        setPassword: BodyApi<Account_SetPassword['response'], Account_SetPassword['request']>;
+        getSessions: QueryApi<Account_GetSessions['response'], Account_GetSessions['request']>;
+        changeThumbnail: BodyApi<Account_ChangeThumbnail['response'], Account_ChangeThumbnail['request']>;
+        getPasswordAssertionConfig: QueryApi<Account_GetPasswordAssertionConfig['response']>;
+    };
+};
+export declare const ApiDef_Account: ApiDefResolver<ApiStruct_Account>;
+export type SAML_Login = {
+    request: {
+        [QueryParam_RedirectUrl]: string;
+        deviceId: string;
+    };
+    response: {
+        loginUrl: string;
+    };
+};
+export type SAML_Assert = {
+    request: {
+        RelayState: string;
+    };
+    response: void;
+};
+export type ApiStruct_SAML = {
+    _v1: {
+        loginSaml: QueryApi<SAML_Login['response'], SAML_Login['request']>;
+        assertSAML: BodyApi<SAML_Assert['response'], SAML_Assert['request']>;
+    };
+};
+export declare const ApiDef_SAML: ApiDefResolver<ApiStruct_SAML>;

package/_entity/account/api-def.js

@@ -0,0 +1,24 @@
+import { HttpMethod } from '@nu-art/thunderstorm-shared';
+import { Minute } from '@nu-art/ts-common';
+import { QueryParam_RedirectUrl } from '../session/index.js';
+export const ApiDef_Account = {
+    _v1: {
+        registerAccount: { method: HttpMethod.POST, path: '/v1/account/register-account' },
+        refreshSession: { method: HttpMethod.GET, path: '/v1/account/refresh-session' },
+        createAccount: { method: HttpMethod.POST, path: '/v1/account/create-account' },
+        changePassword: { method: HttpMethod.POST, path: '/v1/account/change-password' },
+        login: { method: HttpMethod.POST, path: 'v1/account/login', timeout: Minute },
+        logout: { method: HttpMethod.GET, path: 'v1/account/logout' },
+        createToken: { method: HttpMethod.POST, path: 'v1/account/create-token', timeout: Minute },
+        setPassword: { method: HttpMethod.POST, path: '/v1/account/set-password' },
+        getSessions: { method: HttpMethod.GET, path: 'v1/account/get-sessions' },
+        changeThumbnail: { method: HttpMethod.POST, path: '/v1/account/change-thumbnail' },
+        getPasswordAssertionConfig: { method: HttpMethod.GET, path: '/v1/account/get-password-assertion-config' }
+    }
+};
+export const ApiDef_SAML = {
+    _v1: {
+        loginSaml: { method: HttpMethod.GET, path: 'v1/account/login-saml' },
+        assertSAML: { method: HttpMethod.POST, path: 'v1/account/assert' }
+    }
+};

package/_entity/account/db-def.d.ts

@@ -0,0 +1,3 @@
+import { DBDef_V3 } from '@nu-art/ts-common';
+import { DBProto_Account } from './types.js';
+export declare const DBDef_Accounts: DBDef_V3<DBProto_Account>;

package/_entity/account/db-def.js

@@ -0,0 +1,30 @@
+import { tsValidateBoolean, tsValidateEmail, tsValidateString, tsValidateValue, tsValidator_nonMandatoryString } from '@nu-art/ts-common';
+import { _accountTypes } from './types.js';
+import { accountGroupName } from '../session/consts.js';
+const modifiablePropsValidator = {
+    email: tsValidateEmail,
+    type: tsValidateValue(_accountTypes),
+    thumbnail: tsValidateString(undefined, false),
+    displayName: tsValidateString(undefined, false),
+    description: tsValidateString(undefined, false)
+};
+const generatedPropsValidator = {
+    _auditorId: tsValidateString(),
+    _newPasswordRequired: tsValidateBoolean(false),
+    salt: tsValidator_nonMandatoryString,
+    saltedPassword: tsValidator_nonMandatoryString,
+};
+export const DBDef_Accounts = {
+    dbKey: 'user-account--accounts',
+    entityName: 'Account',
+    modifiablePropsValidator: modifiablePropsValidator,
+    generatedPropsValidator: generatedPropsValidator,
+    versions: ['1.0.0'],
+    frontend: {
+        group: accountGroupName,
+        name: 'account'
+    },
+    backend: {
+        name: 'user-account--accounts',
+    }
+};

package/_entity/account/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './db-def.js';
+export * from './api-def.js';

package/_entity/account/index.js

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './db-def.js';
+export * from './api-def.js';

package/_entity/account/types.d.ts

@@ -0,0 +1,34 @@
+import { AuditableV2, DB_BaseObject, DB_Object, DBProto, Proto_DB_Object, TypedKeyValue, VersionsDeclaration } from '@nu-art/ts-common';
+export declare const AccountType_User: AccountType;
+export declare const AccountType_Service: AccountType;
+export declare const _accountTypes: string[];
+export declare const accountTypes: readonly string[];
+export type AccountType = typeof accountTypes[number];
+type VersionTypes_Account = {
+    '1.0.0': DB_Account;
+};
+type Versions = VersionsDeclaration<['1.0.0'], VersionTypes_Account>;
+type Dependencies = {};
+type UniqueKeys = '_id';
+type GeneratedKeys = keyof AuditableV2 | '_newPasswordRequired' | 'salt' | 'saltedPassword';
+export declare const Account_DbKey = "user-account--accounts";
+type Proto = Proto_DB_Object<DB_Account, typeof Account_DbKey, GeneratedKeys, Versions, UniqueKeys, Dependencies>;
+export type DBProto_Account = DBProto<Proto>;
+export type UI_Account = DBProto_Account['uiType'];
+export type SafeDB_Account = UI_Account & DB_BaseObject;
+export type UI_SessionAccount = UI_Account & DB_BaseObject & SessionData_HasPassword;
+export type _SessionKey_Account = TypedKeyValue<'account', UI_SessionAccount>;
+export type DB_Account = DB_Object & AuditableV2 & {
+    type: AccountType;
+    email: string;
+    displayName?: string;
+    thumbnail?: string;
+    salt?: string;
+    saltedPassword?: string;
+    description?: string;
+    _newPasswordRequired?: boolean;
+};
+export type SessionData_HasPassword = {
+    hasPassword: boolean;
+};
+export {};

package/_entity/account/types.js

@@ -0,0 +1,5 @@
+export const AccountType_User = 'user';
+export const AccountType_Service = 'service';
+export const _accountTypes = ['user', 'service'];
+export const accountTypes = [..._accountTypes];
+export const Account_DbKey = 'user-account--accounts';

package/_entity/failed-login-attempt/consts.d.ts

@@ -0,0 +1,2 @@
+export declare const ErrorType_LoginBlocked = "BLOCKED_LOGIN";
+export declare const DefaultMaxLoginAttempts = 5;

package/_entity/failed-login-attempt/consts.js

@@ -0,0 +1,2 @@
+export const ErrorType_LoginBlocked = 'BLOCKED_LOGIN';
+export const DefaultMaxLoginAttempts = 5;

package/_entity/failed-login-attempt/db-def.d.ts

@@ -0,0 +1,3 @@
+import { DBDef_V3 } from '@nu-art/ts-common';
+import { DBProto_FailedLoginAttempt } from './types.js';
+export declare const DBDef_FailedLoginAttempt: DBDef_V3<DBProto_FailedLoginAttempt>;

package/_entity/failed-login-attempt/db-def.js

@@ -0,0 +1,22 @@
+import { tsValidateNumber, tsValidateUniqueId } from '@nu-art/ts-common';
+import { accountGroupName } from '../session/index.js';
+const Validator_ModifiableProps = {
+    count: tsValidateNumber(),
+    accountId: tsValidateUniqueId,
+    loginSuccessfulAt: tsValidateNumber(false)
+};
+const Validator_GeneratedProps = {};
+export const DBDef_FailedLoginAttempt = {
+    modifiablePropsValidator: Validator_ModifiableProps,
+    generatedPropsValidator: Validator_GeneratedProps,
+    versions: ['1.0.0'],
+    dbKey: 'failed-login-attempt',
+    entityName: 'failed-login-attempt',
+    frontend: {
+        group: accountGroupName,
+        name: 'failed-login-attempt'
+    },
+    backend: {
+        name: 'user-account--failed-login-attempt'
+    }
+};

package/_entity/failed-login-attempt/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './db-def.js';
+export * from './consts.js';

package/_entity/failed-login-attempt/index.js

@@ -0,0 +1,4 @@
+// Generated DB Item type: LoginAttempt
+export * from './types.js';
+export * from './db-def.js';
+export * from './consts.js';

package/_entity/failed-login-attempt/types.d.ts

@@ -0,0 +1,18 @@
+import { DB_Object, DBProto, Proto_DB_Object, UniqueId, VersionsDeclaration } from '@nu-art/ts-common';
+type VersionTypes_FailedLoginAttempt = {
+    '1.0.0': DB_FailedLoginAttempt;
+};
+type Versions = VersionsDeclaration<['1.0.0'], VersionTypes_FailedLoginAttempt>;
+type Dependencies = {};
+type UniqueKeys = '_id';
+type GeneratedProps = never;
+type DBKey = 'failed-login-attempt';
+type Proto = Proto_DB_Object<DB_FailedLoginAttempt, DBKey, GeneratedProps, Versions, UniqueKeys, Dependencies>;
+export type DBProto_FailedLoginAttempt = DBProto<Proto>;
+export type UI_FailedLoginAttempt = DBProto_FailedLoginAttempt['uiType'];
+export type DB_FailedLoginAttempt = DB_Object & {
+    accountId: UniqueId;
+    count: number;
+    loginSuccessfulAt?: number;
+};
+export {};

package/_entity/failed-login-attempt/types.js

@@ -0,0 +1 @@
+export {};

package/_entity/login-attempts/db-def.d.ts

@@ -0,0 +1,3 @@
+import { DBDef_V3 } from '@nu-art/ts-common';
+import { DBProto_LoginAttempt } from './types.js';
+export declare const DBDef_LoginAttempt: DBDef_V3<DBProto_LoginAttempt>;

package/_entity/login-attempts/db-def.js

@@ -0,0 +1,25 @@
+import { tsValidateIpAddress, tsValidateOptionalId, tsValidateUniqueId, tsValidateValue } from '@nu-art/ts-common';
+import { LoginStatus_Failed, LoginStatus_Success } from './types.js';
+const Validator_ModifiableProps = {
+    accountId: tsValidateUniqueId,
+    status: tsValidateValue([LoginStatus_Success, LoginStatus_Failed]),
+    metadata: {
+        ipAddress: tsValidateIpAddress(false),
+        deviceId: tsValidateOptionalId
+    }
+};
+const Validator_GeneratedProps = {};
+export const DBDef_LoginAttempt = {
+    modifiablePropsValidator: Validator_ModifiableProps,
+    generatedPropsValidator: Validator_GeneratedProps,
+    versions: ['1.0.0'],
+    dbKey: 'login-attempt',
+    entityName: 'login-attempt',
+    frontend: {
+        group: 'ts-default',
+        name: 'login-attempt'
+    },
+    backend: {
+        name: 'user-account--login-attempt'
+    }
+};

package/_entity/login-attempts/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './db-def.js';

package/_entity/login-attempts/index.js

@@ -0,0 +1,3 @@
+// Generated DB Item type: LoginAttempt
+export * from './types.js';
+export * from './db-def.js';

package/_entity/login-attempts/types.d.ts

@@ -0,0 +1,25 @@
+import { DB_Object, DBProto, Proto_DB_Object, UniqueId, VersionsDeclaration } from '@nu-art/ts-common';
+type VersionTypes_LoginAttempt = {
+    '1.0.0': DB_LoginAttempt;
+};
+type Versions = VersionsDeclaration<['1.0.0'], VersionTypes_LoginAttempt>;
+type Dependencies = {};
+type UniqueKeys = '_id';
+type GeneratedProps = never;
+type DBKey = 'login-attempt';
+type Proto = Proto_DB_Object<DB_LoginAttempt, DBKey, GeneratedProps, Versions, UniqueKeys, Dependencies>;
+export type DBProto_LoginAttempt = DBProto<Proto>;
+export type UI_LoginAttempt = DBProto_LoginAttempt['uiType'];
+export declare const LoginStatus_Success = "success";
+export declare const LoginStatus_Failed = "failed";
+export type LoginStatus = typeof LoginStatus_Failed | typeof LoginStatus_Success;
+export type LoginMetadata = {
+    ipAddress?: string;
+    deviceId?: string;
+};
+export type DB_LoginAttempt = DB_Object & {
+    accountId: UniqueId;
+    status: LoginStatus;
+    metadata: LoginMetadata;
+};
+export {};

package/_entity/login-attempts/types.js

@@ -0,0 +1,3 @@
+// login statuses
+export const LoginStatus_Success = 'success';
+export const LoginStatus_Failed = 'failed';

package/_entity/session/consts.d.ts

@@ -0,0 +1,5 @@
+export declare const accountGroupName = "account";
+export declare const QueryParam_Email = "userEmail";
+export declare const QueryParam_SessionId = "Authorization";
+export declare const QueryParam_RedirectUrl = "redirectUrl";
+export declare const HeaderKey_CurrentPage = "current-page";

package/_entity/session/consts.js

@@ -0,0 +1,6 @@
+import { HeaderKey_Authorization } from '@nu-art/thunderstorm-shared';
+export const accountGroupName = 'account';
+export const QueryParam_Email = 'userEmail';
+export const QueryParam_SessionId = HeaderKey_Authorization;
+export const QueryParam_RedirectUrl = 'redirectUrl';
+export const HeaderKey_CurrentPage = 'current-page';

package/_entity/session/db-def.d.ts

@@ -0,0 +1,5 @@
+import { DBDef_V3 } from '@nu-art/ts-common';
+import { DBProto_Session } from './types.js';
+export declare const Validator_Modifiable: DBProto_Session['modifiablePropsValidator'];
+export declare const Validator_Generated: DBProto_Session['generatedPropsValidator'];
+export declare const DBDef_Session: DBDef_V3<DBProto_Session>;

package/_entity/session/db-def.js

@@ -0,0 +1,25 @@
+import { tsValidateArray, tsValidateOptionalId, tsValidateString, tsValidateUniqueId } from '@nu-art/ts-common';
+import { accountGroupName } from './consts.js';
+export const Validator_Modifiable = {
+    label: tsValidateString(100, false),
+    accountId: tsValidateUniqueId,
+    deviceId: tsValidateUniqueId,
+    linkedSessionId: tsValidateOptionalId,
+    validSessionJwtMd5s: tsValidateArray(tsValidateUniqueId), //array of MD5s of previous sessions.
+    sessionIdJwt: tsValidateString(),
+};
+export const Validator_Generated = {};
+export const DBDef_Session = {
+    modifiablePropsValidator: Validator_Modifiable,
+    generatedPropsValidator: Validator_Generated,
+    dbKey: 'user-account--sessions',
+    entityName: 'Session',
+    versions: ['1.0.0'],
+    frontend: {
+        group: accountGroupName,
+        name: 'session',
+    },
+    backend: {
+        name: 'user-account--sessions'
+    }
+};

package/_entity/session/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './db-def.js';
+export * from './consts.js';

package/_entity/session/index.js

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './db-def.js';
+export * from './consts.js';

package/_entity/session/types.d.ts

@@ -0,0 +1,21 @@
+import { DB_Object, DBProto, Proto_DB_Object, TypedKeyValue, UniqueId, VersionsDeclaration } from '@nu-art/ts-common';
+type VersionTypes = {
+    '1.0.0': DB_Session;
+};
+type Versions = VersionsDeclaration<['1.0.0'], VersionTypes>;
+type UniqueIds = 'accountId' | 'deviceId';
+type DBKey = 'user-account--sessions';
+type GeneratedKeys = keyof DB_Object;
+type Proto = Proto_DB_Object<DB_Session, DBKey, GeneratedKeys, Versions, UniqueIds>;
+export type DBProto_Session = DBProto<Proto>;
+export type UI_Session = DBProto_Session['uiType'];
+export type DB_Session = DB_Object & {
+    validSessionJwtMd5s: UniqueId[];
+    label?: string;
+    accountId: UniqueId;
+    deviceId: UniqueId;
+    linkedSessionId?: UniqueId;
+    sessionIdJwt: string;
+};
+export type _SessionKey_SessionId = TypedKeyValue<'_id', UniqueId>;
+export {};

package/_entity/session/types.js

@@ -0,0 +1 @@
+export {};

package/_entity.d.ts

@@ -0,0 +1,4 @@
+export * from './_entity/account/index.js';
+export * from './_entity/session/index.js';
+export * from './_entity/login-attempts/index.js';
+export * from './_entity/failed-login-attempt/index.js';

package/_entity.js

@@ -0,0 +1,4 @@
+export * from './_entity/account/index.js';
+export * from './_entity/session/index.js';
+export * from './_entity/login-attempts/index.js';
+export * from './_entity/failed-login-attempt/index.js';

package/_enum/password-assertion/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './validator.js';

package/_enum/password-assertion/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './validator.js';

package/_enum/password-assertion/types.d.ts

@@ -0,0 +1,16 @@
+import { ResponseError } from '@nu-art/ts-common/core/exceptions/types';
+export declare const PasswordAssertionType_MinLength = "min-length";
+export declare const PasswordAssertionType_MaxLength = "max-length";
+export declare const PasswordAssertionType_SpecialChars = "special-chars";
+export declare const PasswordAssertionType_Numbers = "numbers";
+export declare const PasswordAssertionType_LowerCaseLetters = "lower-case-letters";
+export declare const PasswordAssertionType_CapitalLetters = "capital-letters";
+export declare const PasswordAssertionTypes: readonly ["min-length", "max-length", "special-chars", "numbers", "lower-case-letters", "capital-letters"];
+export type PasswordAssertionType = typeof PasswordAssertionTypes[number];
+export type PasswordAssertionConfig = {
+    [K in PasswordAssertionType]?: number;
+};
+export type PasswordFailureReport = {
+    [K in PasswordAssertionType]?: string;
+};
+export type PasswordAssertionResponseError = ResponseError<'password-assertion-error', PasswordFailureReport>;

package/_enum/password-assertion/types.js

@@ -0,0 +1,14 @@
+export const PasswordAssertionType_MinLength = 'min-length';
+export const PasswordAssertionType_MaxLength = 'max-length';
+export const PasswordAssertionType_SpecialChars = 'special-chars';
+export const PasswordAssertionType_Numbers = 'numbers';
+export const PasswordAssertionType_LowerCaseLetters = 'lower-case-letters';
+export const PasswordAssertionType_CapitalLetters = 'capital-letters';
+export const PasswordAssertionTypes = [
+    PasswordAssertionType_MinLength,
+    PasswordAssertionType_MaxLength,
+    PasswordAssertionType_SpecialChars,
+    PasswordAssertionType_Numbers,
+    PasswordAssertionType_LowerCaseLetters,
+    PasswordAssertionType_CapitalLetters,
+];

package/_enum/password-assertion/validator.d.ts

@@ -0,0 +1,2 @@
+import { PasswordAssertionConfig, PasswordFailureReport } from './types.js';
+export declare const assertPasswordRules: (password: string, assertionConfig?: PasswordAssertionConfig) => PasswordFailureReport | undefined;

package/_enum/password-assertion/validator.js

@@ -0,0 +1,39 @@
+import { _keys, generateArray, tsValidateRegexp, tsValidateResult, tsValidateString, tsValidateStringMinLength } from '@nu-art/ts-common';
+import { PasswordAssertionType_CapitalLetters, PasswordAssertionType_LowerCaseLetters, PasswordAssertionType_MaxLength, PasswordAssertionType_MinLength, PasswordAssertionType_Numbers, PasswordAssertionType_SpecialChars, PasswordAssertionTypes } from './types.js';
+const specialChars = '.*?[!@#$%^&*()_\\+\\-=\\[\\]{},.\\/;\':"<> |\\\\]';
+const numbers = '.*?[0-9]';
+const lowerCaseLetters = '.*?[a-z]';
+const capitalLetters = '.*?[A-Z]';
+const Validator_PasswordAssertion = {
+    [PasswordAssertionType_MinLength]: (amount) => tsValidateStringMinLength(amount),
+    [PasswordAssertionType_MaxLength]: (amount) => tsValidateString(amount),
+    [PasswordAssertionType_SpecialChars]: (amount) => tsValidateRegexp(new RegExp(generateArray(amount, _ => specialChars).join(''))),
+    [PasswordAssertionType_Numbers]: (amount) => tsValidateRegexp(new RegExp(generateArray(amount, _ => numbers).join(''))),
+    [PasswordAssertionType_LowerCaseLetters]: (amount) => tsValidateRegexp(new RegExp(generateArray(amount, _ => lowerCaseLetters).join(''))),
+    [PasswordAssertionType_CapitalLetters]: (amount) => tsValidateRegexp(new RegExp(generateArray(amount, _ => capitalLetters).join(''))),
+};
+const PasswordFailureMessages = {
+    [PasswordAssertionType_MinLength]: (amount) => `Password is shorter than ${amount} characters`,
+    [PasswordAssertionType_MaxLength]: (amount) => `Password is longer than ${amount} characters`,
+    [PasswordAssertionType_SpecialChars]: (amount) => `Password does not contain at least ${amount} special characters`,
+    [PasswordAssertionType_Numbers]: (amount) => `Password does not contain at least ${amount} numbers`,
+    [PasswordAssertionType_LowerCaseLetters]: (amount) => `Password does not contain at least ${amount} lower case characters`,
+    [PasswordAssertionType_CapitalLetters]: (amount) => `Password does not contain at least ${amount} capital letters`,
+};
+export const assertPasswordRules = (password, assertionConfig) => {
+    if (!assertionConfig)
+        return;
+    const results = _keys(assertionConfig).reduce((results, assertionKey) => {
+        if (!PasswordAssertionTypes.includes(assertionKey)) {
+            results[assertionKey] = `Unknown assertion key ${assertionKey}`;
+            return results;
+        }
+        const amount = assertionConfig[assertionKey];
+        const validator = Validator_PasswordAssertion[assertionKey](amount);
+        const result = tsValidateResult(password, validator);
+        if (result)
+            results[assertionKey] = PasswordFailureMessages[assertionKey](amount);
+        return results;
+    }, {});
+    return _keys(results).length ? results : undefined;
+};

package/_enum.d.ts

@@ -0,0 +1 @@
+export * from './_enum/password-assertion/index.js';

package/_enum.js

@@ -0,0 +1 @@
+export * from './_enum/password-assertion/index.js';

package/index.d.ts

@@ -0,0 +1,2 @@
+export * from './_enum.js';
+export * from './_entity.js';

package/index.js

@@ -0,0 +1,2 @@
+export * from './_enum.js';
+export * from './_entity.js';

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@nu-art/user-account-shared",
+  "version": "0.400.5",
+  "description": "User Account Shared",
+  "keywords": [
+    "TacB0sS",
+    "create account",
+    "express",
+    "infra",
+    "login",
+    "nu-art",
+    "saml",
+    "thunderstorm",
+    "typescript",
+    "user-account"
+  ],
+  "homepage": "https://github.com/nu-art-js/user-account",
+  "bugs": {
+    "url": "https://github.com/nu-art-js/user-account/issues"
+  },
+  "publishConfig": {
+    "directory": "dist",
+    "linkDirectory": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com:nu-art-js/user-account.git"
+  },
+  "license": "Apache-2.0",
+  "author": "TacB0sS",
+  "scripts": {
+    "build": "tsc",
+    "run-tests": "firebase emulators:exec \"npm run test\"",
+    "test": "ts-mocha -w -p src/test/tsconfig.json --timeout 0 --inspect=8107 --watch-files 'src/test/**/*.test.ts' src/test/**/*.test.ts"
+  },
+  "dependencies": {
+    "@nu-art/ts-common": "0.400.5",
+    "@nu-art/firebase-shared": "0.400.5",
+    "@nu-art/thunderstorm-shared": "0.400.5",
+    "@nu-art/ts-styles": "0.400.5",
+    "@nu-art/slack-shared": "0.400.5",
+    "firebase": "^11.9.0",
+    "firebase-admin": "13.4.0",
+    "firebase-functions": "6.3.2",
+    "react": "^18.0.0",
+    "moment": "^2.29.4",
+    "saml2-js": "^4.0.1",
+    "xmlbuilder": "^15.1.1",
+    "express": "^4.18.2",
+    "request": "^2.88.0",
+    "pako": "^2.1.0"
+  },
+  "devDependencies": {
+    "@nu-art/google-services-backend": "0.400.5",
+    "@types/react": "^18.0.0",
+    "@types/express": "^4.17.17",
+    "@types/history": "^4.7.2",
+    "@types/request": "^2.48.1",
+    "@types/saml2-js": "^1.6.8",
+    "@types/pako": "^2.0.0",
+    "@types/jsonwebtoken": "^9.0.6"
+  },
+  "unitConfig": {
+    "type": "typescript-lib"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "import": "./*.js"
+    }
+  }
+}