@nu-art/user-account-backend 0.500.0 → 0.500.6

package/_entity/account/ModuleBE_AccountDB.d.ts

@@ -1,11 +1,9 @@
 import { Dispatcher } from '@nu-art/ts-common';
 import { DB_BaseObject } from '@nu-art/db-api-shared';
-import { firestore } from 'firebase-admin';
 import { ModuleBE_BaseDB } from '@nu-art/db-api-backend';
 import { FirestoreQuery } from '@nu-art/firebase-shared';
 import { _SessionKey_Account, AccountEmail, AccountEmailWithDevice, AccountToAssertPassword, AccountToSpice, AccountType, API_UserAccount, DatabaseDef_Account, DB_Account, PasswordAssertionConfig, SafeDB_Account, UI_Account } from '@nu-art/user-account-shared';
 import { BaseSessionClaims, CollectSessionData } from '../session/ModuleBE_SessionDB.js';
-import Transaction = firestore.Transaction;
 type BaseAccount = {
     email: string;
     type: AccountType;
@@ -16,16 +14,19 @@ type SpicedAccount = BaseAccount & {
 };
 type AccountToCreate = SpicedAccount | BaseAccount;
 export interface OnNewUserRegistered {
-    __onNewUserRegistered(account: SafeDB_Account, transaction: Transaction): void;
+    __onNewUserRegistered(account: SafeDB_Account): void;
 }
 export interface OnUserLogin {
-    __onUserLogin(account: SafeDB_Account, transaction: Transaction): void;
+    __onUserLogin(account: SafeDB_Account): void;
 }
 export interface OnPreLogout {
     __onPreLogout: () => Promise<void>;
 }
-export declare const dispatch_onAccountLogin: Dispatcher<OnUserLogin, "__onUserLogin", [account: SafeDB_Account, transaction: firestore.Transaction], void>;
+export declare const dispatch_onAccountLogin: Dispatcher<OnUserLogin, "__onUserLogin", [account: SafeDB_Account], void>;
 export declare const dispatch_onPreLogout: Dispatcher<OnPreLogout, "__onPreLogout", [], void>;
+export interface OnAccountDeleted {
+    __onAccountDeleted: (account: SafeDB_Account) => Promise<void>;
+}
 type Config = {
     canRegister: boolean;
     passwordAssertion?: PasswordAssertionConfig;
@@ -46,8 +47,8 @@ export declare class ModuleBE_AccountDB_Class extends ModuleBE_BaseDB<DatabaseDe
     getSessions(params: API_UserAccount['getSessions']['Params']): Promise<API_UserAccount['getSessions']['Response']>;
     changeThumbnail(body: API_UserAccount['changeThumbnail']['Body']): Promise<API_UserAccount['changeThumbnail']['Response']>;
     getPasswordAssertionConfig(_params: API_UserAccount['getPasswordAssertionConfig']['Params']): Promise<API_UserAccount['getPasswordAssertionConfig']['Response']>;
+    deleteAccount(params: API_UserAccount['deleteAccount']['Params']): Promise<API_UserAccount['deleteAccount']['Response']>;
     manipulateQuery(query: FirestoreQuery<DB_Account>): FirestoreQuery<DB_Account>;
-    canDeleteItems(dbItems: DB_Account[], transaction?: FirebaseFirestore.Transaction): Promise<void>;
     __collectSessionData(data: BaseSessionClaims): Promise<{
         key: "account";
         value: {
@@ -71,22 +72,22 @@ export declare class ModuleBE_AccountDB_Class extends ModuleBE_BaseDB<DatabaseDe
             saltedPassword?: string | undefined;
         };
     }>;
-    protected preWriteProcessing(dbInstance: UI_Account, originalDbInstance: DatabaseDef_Account['dbType'], transaction?: Transaction): Promise<void>;
+    protected preWriteProcessing(dbInstance: UI_Account, originalDbInstance: DatabaseDef_Account['dbType']): Promise<void>;
     impl: {
         fixEmail: (objectWithEmail: {
             email: string;
         }) => void;
         assertPasswordCheck: (accountToAssert: AccountToAssertPassword) => void;
         spiceAccount: (accountToSpice: AccountToSpice) => SpicedAccount;
-        create: (accountToCreate: AccountToCreate, transaction: Transaction) => Promise<SafeDB_Account>;
+        create: (accountToCreate: AccountToCreate) => Promise<SafeDB_Account>;
         setAccountMemKeys: (account: SafeDB_Account) => Promise<void>;
-        onAccountCreated: (account: SafeDB_Account, transaction: Transaction) => Promise<void>;
-        onAccountLogin: (account: SafeDB_Account, transaction: Transaction) => Promise<void>;
-        queryUnsafeAccount: (credentials: AccountEmail, transaction?: Transaction) => Promise<DB_Account>;
-        querySafeAccount: (credentials: AccountEmail, transaction?: Transaction) => Promise<SafeDB_Account>;
+        onAccountCreated: (account: SafeDB_Account) => Promise<void>;
+        onAccountLogin: (account: SafeDB_Account) => Promise<void>;
+        queryUnsafeAccount: (credentials: AccountEmail) => Promise<DB_Account>;
+        querySafeAccount: (credentials: AccountEmail) => Promise<SafeDB_Account>;
     };
     account: {
-        register: (accountWithPassword: API_UserAccount["registerAccount"]["Body"], transaction?: Transaction) => Promise<API_UserAccount["registerAccount"]["Response"]>;
+        register: (accountWithPassword: API_UserAccount["registerAccount"]["Body"]) => Promise<API_UserAccount["registerAccount"]["Response"]>;
         login: (credentials: API_UserAccount["login"]["Body"]) => Promise<API_UserAccount["login"]["Response"]>;
         create: (createAccountRequest: API_UserAccount["createAccount"]["Body"]) => Promise<API_UserAccount["createAccount"]["Response"]>;
         saml: (oAuthAccount: AccountEmailWithDevice) => Promise<import("@nu-art/user-account-shared").DB_Session>;
@@ -97,6 +98,7 @@ export declare class ModuleBE_AccountDB_Class extends ModuleBE_BaseDB<DatabaseDe
             sessions: import("@nu-art/user-account-shared").DB_Session[];
         }>;
         changeThumbnail: (request: API_UserAccount["changeThumbnail"]["Body"]) => Promise<API_UserAccount["changeThumbnail"]["Response"]>;
+        delete: (request: API_UserAccount["deleteAccount"]["Params"]) => Promise<API_UserAccount["deleteAccount"]["Response"]>;
     };
     password: {
         assertPasswordExistence: (email: string, password?: string, passwordCheck?: string) => void;

package/_entity/account/ModuleBE_AccountDB.js

@@ -32,10 +32,9 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
     if (target) Object.defineProperty(target, contextIn.name, descriptor);
     done = true;
 };
-import { ApiException, BadImplementationException, cloneObj, compare, dispatch_onApplicationException, Dispatcher, exists, generateHex, hashPasswordWithSalt, md5, MUSTNeverHappenException, Year } from '@nu-art/ts-common';
+import { ApiException, BadImplementationException, cloneObj, compare, dispatch_onApplicationException, Dispatcher, exists, generateHex, hashPasswordWithSalt, md5, Year } from '@nu-art/ts-common';
 import { ModuleBE_BaseDB } from '@nu-art/db-api-backend';
 import { ApiHandler } from '@nu-art/http-server';
-import { FirestoreInterfaceV3 } from '@nu-art/firebase-backend/firestore-v3/FirestoreInterfaceV3';
 import { HttpCodes } from '@nu-art/ts-common/core/exceptions/http-codes';
 import { ApiDef_UserAccount, assertPasswordRules, DBDef_Accounts } from '@nu-art/user-account-shared';
 import { Header_Authorization, MemKey_AccountEmail, MemKey_AccountId, MemKey_AccountType, MemKey_DB_Session, SessionKey_Account_BE } from '../session/consts.js';
@@ -44,6 +43,7 @@ import { ModuleBE_FailedLoginAttemptDB } from '../failed-login-attempt/ModuleBE_
 export const dispatch_onAccountLogin = new Dispatcher('__onUserLogin');
 const dispatch_onAccountRegistered = new Dispatcher('__onNewUserRegistered');
 export const dispatch_onPreLogout = new Dispatcher('__onPreLogout');
+const dispatch_OnAccountDeleted = new Dispatcher('__onAccountDeleted');
 let ModuleBE_AccountDB_Class = (() => {
     let _classSuper = ModuleBE_BaseDB;
     let _instanceExtraInitializers = [];
@@ -58,6 +58,7 @@ let ModuleBE_AccountDB_Class = (() => {
     let _getSessions_decorators;
     let _changeThumbnail_decorators;
     let _getPasswordAssertionConfig_decorators;
+    let _deleteAccount_decorators;
     return class ModuleBE_AccountDB_Class extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
@@ -72,6 +73,7 @@ let ModuleBE_AccountDB_Class = (() => {
             _getSessions_decorators = [ApiHandler(ApiDef_UserAccount.getSessions)];
             _changeThumbnail_decorators = [ApiHandler(ApiDef_UserAccount.changeThumbnail)];
             _getPasswordAssertionConfig_decorators = [ApiHandler(ApiDef_UserAccount.getPasswordAssertionConfig)];
+            _deleteAccount_decorators = [ApiHandler(ApiDef_UserAccount.deleteAccount)];
             __esDecorate(this, null, _refreshSession_decorators, { kind: "method", name: "refreshSession", static: false, private: false, access: { has: obj => "refreshSession" in obj, get: obj => obj.refreshSession }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _registerAccount_decorators, { kind: "method", name: "registerAccount", static: false, private: false, access: { has: obj => "registerAccount" in obj, get: obj => obj.registerAccount }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _changePassword_decorators, { kind: "method", name: "changePassword", static: false, private: false, access: { has: obj => "changePassword" in obj, get: obj => obj.changePassword }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -83,6 +85,7 @@ let ModuleBE_AccountDB_Class = (() => {
             __esDecorate(this, null, _getSessions_decorators, { kind: "method", name: "getSessions", static: false, private: false, access: { has: obj => "getSessions" in obj, get: obj => obj.getSessions }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _changeThumbnail_decorators, { kind: "method", name: "changeThumbnail", static: false, private: false, access: { has: obj => "changeThumbnail" in obj, get: obj => obj.changeThumbnail }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getPasswordAssertionConfig_decorators, { kind: "method", name: "getPasswordAssertionConfig", static: false, private: false, access: { has: obj => "getPasswordAssertionConfig" in obj, get: obj => obj.getPasswordAssertionConfig }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _deleteAccount_decorators, { kind: "method", name: "deleteAccount", static: false, private: false, access: { has: obj => "deleteAccount" in obj, get: obj => obj.deleteAccount }, metadata: _metadata }, null, _instanceExtraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         Middleware = (__runInitializers(this, _instanceExtraInitializers), async () => {
@@ -134,15 +137,18 @@ let ModuleBE_AccountDB_Class = (() => {
                     : this.config.passwordAssertion
             };
         }
+        async deleteAccount(params) {
+            return this.account.delete(params);
+        }
         manipulateQuery(query) {
             return {
                 ...query,
                 select: ['__created', '_v', '__updated', 'email', '_newPasswordRequired', 'type', '_id', 'thumbnail', 'displayName', '_auditorId', 'description']
             };
         }
-        canDeleteItems(dbItems, transaction) {
-            throw HttpCodes._5XX.NOT_IMPLEMENTED('Account Deletion is not implemented yet');
-        }
+        // canDeleteItems(dbItems: DB_Account[], transaction?: FirebaseFirestore.Transaction): Promise<void> {
+        // 	throw HttpCodes._5XX.NOT_IMPLEMENTED('Account Deletion is not implemented yet');
+        // }
         async __collectSessionData(data) {
             const account = await this.query.uniqueAssert(data.accountId);
             return {
@@ -153,7 +159,7 @@ let ModuleBE_AccountDB_Class = (() => {
                 },
             };
         }
-        async preWriteProcessing(dbInstance, originalDbInstance, transaction) {
+        async preWriteProcessing(dbInstance, originalDbInstance) {
             try {
                 dbInstance._auditorId = MemKey_AccountId.get();
             }
@@ -178,53 +184,45 @@ let ModuleBE_AccountDB_Class = (() => {
                     saltedPassword: hashPasswordWithSalt(salt, accountToSpice.password)
                 };
             },
-            create: async (accountToCreate, transaction) => {
+            create: async (accountToCreate) => {
                 let dbAccount = (await this.query.custom({
                     where: { email: accountToCreate.email },
                     limit: 1
-                }, transaction))[0];
+                }))[0];
                 if (dbAccount)
                     throw new ApiException(422, `User with email "${accountToCreate.email}" already exists`);
-                dbAccount = await this.create.item(accountToCreate, transaction);
+                dbAccount = await this.create.item(accountToCreate);
                 return makeAccountSafe(dbAccount);
             },
             setAccountMemKeys: async (account) => {
                 MemKey_AccountId.set(account._id);
                 MemKey_AccountEmail.set(account.email);
             },
-            onAccountCreated: async (account, transaction) => {
-                await dispatch_onAccountRegistered.dispatchModuleAsync(account, transaction);
+            onAccountCreated: async (account) => {
+                await dispatch_onAccountRegistered.dispatchModuleAsync(account);
             },
-            onAccountLogin: async (account, transaction) => {
-                await dispatch_onAccountLogin.dispatchModuleAsync(account, transaction);
+            onAccountLogin: async (account) => {
+                await dispatch_onAccountLogin.dispatchModuleAsync(account);
             },
-            queryUnsafeAccount: async (credentials, transaction) => {
-                const firestoreQuery = FirestoreInterfaceV3.buildQuery(this.collection, { where: { email: credentials.email } });
-                let results;
-                if (transaction)
-                    results = (await transaction.get(firestoreQuery)).docs;
-                else
-                    results = (await firestoreQuery.get()).docs;
-                if (results.length !== 1)
-                    if (results.length === 0) {
-                        const apiException = new ApiException(401, `There is no account for email '${credentials.email}'.`);
-                        await dispatch_onApplicationException.dispatchModuleAsync(apiException, this);
-                        throw apiException;
-                    }
-                    else if (results.length > 1) {
-                        this.logWarningBold(`Too many accounts using this email! '${credentials.email}'`);
-                        throw new MUSTNeverHappenException('Too many accounts using this email');
-                    }
-                return results[0].data();
+            queryUnsafeAccount: async (credentials) => {
+                const results = await this.query.unManipulatedQuery({ where: { email: credentials.email } });
+                if (results.length === 0) {
+                    const apiException = new ApiException(401, `There is no account for email '${credentials.email}'.`);
+                    await dispatch_onApplicationException.dispatchModuleAsync(apiException, this);
+                    throw apiException;
+                }
+                if (results.length > 1)
+                    throw new BadImplementationException(`Too many accounts using this email: '${credentials.email}'`);
+                return results[0];
             },
-            querySafeAccount: async (credentials, transaction) => {
-                const account = await this.impl.queryUnsafeAccount(credentials, transaction);
+            querySafeAccount: async (credentials) => {
+                const account = await this.impl.queryUnsafeAccount(credentials);
                 return makeAccountSafe(account);
             }
         };
         account = {
             // this flow is for creating real human users with email and password
-            register: async (accountWithPassword, transaction) => {
+            register: async (accountWithPassword) => {
                 if (!this.config.canRegister)
                     throw new ApiException(418, 'Registration is disabled!!');
                 this.impl.fixEmail(accountWithPassword);
@@ -233,10 +231,10 @@ let ModuleBE_AccountDB_Class = (() => {
                     email: accountWithPassword.email,
                     password: accountWithPassword.password
                 });
-                const dbSafeAccount = await this.runTransaction(async (transaction) => {
-                    const dbSafeAccount = await this.impl.create(spicedAccount, transaction);
+                const dbSafeAccount = await this.runTransaction(async () => {
+                    const dbSafeAccount = await this.impl.create(spicedAccount);
                     await this.impl.setAccountMemKeys(dbSafeAccount);
-                    await this.impl.onAccountCreated(dbSafeAccount, transaction);
+                    await this.impl.onAccountCreated(dbSafeAccount);
                     return dbSafeAccount;
                 });
                 await this.account.login({
@@ -248,14 +246,11 @@ let ModuleBE_AccountDB_Class = (() => {
             },
             login: async (credentials) => {
                 this.impl.fixEmail(credentials);
-                const safeAccount = await this.runTransaction(async (transaction) => {
-                    const dbAccount = await this.impl.queryUnsafeAccount({ email: credentials.email }, transaction);
-                    await this.password.assertPasswordMatch(dbAccount, credentials.password);
-                    const safeAccount = makeAccountSafe(dbAccount);
-                    MemKey_AccountId.set(safeAccount._id);
-                    await this.impl.onAccountLogin(safeAccount, transaction);
-                    return safeAccount;
-                });
+                const dbAccount = await this.impl.queryUnsafeAccount({ email: credentials.email });
+                await this.password.assertPasswordMatch(dbAccount, credentials.password);
+                const safeAccount = makeAccountSafe(dbAccount);
+                MemKey_AccountId.set(safeAccount._id);
+                await this.impl.onAccountLogin(safeAccount);
                 const initialClaims = {
                     accountId: safeAccount._id,
                     deviceId: credentials.deviceId,
@@ -268,35 +263,35 @@ let ModuleBE_AccountDB_Class = (() => {
                 const password = createAccountRequest.password;
                 let dbSafeAccount;
                 this.impl.fixEmail(createAccountRequest);
-                return this.runTransaction(async (transaction) => {
+                return this.runTransaction(async () => {
                     if (exists(password) || exists(createAccountRequest.passwordCheck)) {
                         this.impl.assertPasswordCheck(createAccountRequest);
                         const spicedAccount = this.impl.spiceAccount(createAccountRequest);
-                        dbSafeAccount = await this.impl.create(spicedAccount, transaction);
+                        dbSafeAccount = await this.impl.create(spicedAccount);
                     }
                     else
-                        dbSafeAccount = await this.impl.create(createAccountRequest, transaction);
-                    await this.impl.onAccountCreated(dbSafeAccount, transaction);
+                        dbSafeAccount = await this.impl.create(createAccountRequest);
+                    await this.impl.onAccountCreated(dbSafeAccount);
                     return dbSafeAccount;
                 });
             },
             saml: async (oAuthAccount) => {
                 this.impl.fixEmail(oAuthAccount);
-                const dbSafeAccount = await this.runTransaction(async (transaction) => {
+                const dbSafeAccount = await this.runTransaction(async () => {
                     let dbSafeAccount;
                     try {
-                        dbSafeAccount = await this.impl.querySafeAccount({ ...oAuthAccount }, transaction);
+                        dbSafeAccount = await this.impl.querySafeAccount({ ...oAuthAccount });
                         this.logInfo('SAML login account');
                         MemKey_AccountId.set(dbSafeAccount._id);
-                        await this.impl.onAccountLogin(dbSafeAccount, transaction);
+                        await this.impl.onAccountLogin(dbSafeAccount);
                     }
                     catch (e) {
                         if (e.responseCode !== 401)
                             throw e;
                         this.logInfo('SAML register account');
-                        dbSafeAccount = await this.impl.create({ email: oAuthAccount.email, type: 'user' }, transaction);
+                        dbSafeAccount = await this.impl.create({ email: oAuthAccount.email, type: 'user' });
                         MemKey_AccountId.set(dbSafeAccount._id);
-                        await this.impl.onAccountCreated(dbSafeAccount, transaction);
+                        await this.impl.onAccountCreated(dbSafeAccount);
                     }
                     return dbSafeAccount;
                 });
@@ -304,7 +299,7 @@ let ModuleBE_AccountDB_Class = (() => {
                 return ModuleBE_SessionDB._session.create({ initialClaims });
             },
             changePassword: async (passwordToChange) => {
-                return this.runTransaction(async (transaction) => {
+                return this.runTransaction(async () => {
                     const email = MemKey_AccountEmail.get();
                     const deviceId = MemKey_DB_Session.get().deviceId;
                     await this.account.login({ email, deviceId, password: passwordToChange.oldPassword }); // perform login to make sure the old password holds
@@ -321,7 +316,7 @@ let ModuleBE_AccountDB_Class = (() => {
                         ...safeAccount,
                         salt: spicedAccount.salt,
                         saltedPassword: spicedAccount.saltedPassword
-                    }, transaction);
+                    });
                     const initialClaims = {
                         accountId: updatedAccount._id,
                         deviceId,
@@ -332,10 +327,10 @@ let ModuleBE_AccountDB_Class = (() => {
                 });
             },
             setPassword: async (passwordBody) => {
-                return this.runTransaction(async (transaction) => {
+                return this.runTransaction(async () => {
                     const email = MemKey_AccountEmail.get();
                     const deviceId = MemKey_DB_Session.get().deviceId;
-                    const dbAccount = await this.impl.queryUnsafeAccount({ email }, transaction);
+                    const dbAccount = await this.impl.queryUnsafeAccount({ email });
                     if (dbAccount.saltedPassword)
                         throw HttpCodes._4XX.FORBIDDEN('account already has password');
                     const safeAccount = makeAccountSafe(dbAccount);
@@ -345,7 +340,7 @@ let ModuleBE_AccountDB_Class = (() => {
                         ...safeAccount,
                         salt: spicedAccount.salt,
                         saltedPassword: spicedAccount.saltedPassword
-                    }, transaction);
+                    });
                     const initialClaims = {
                         accountId: updatedAccount._id,
                         deviceId,
@@ -373,6 +368,26 @@ let ModuleBE_AccountDB_Class = (() => {
                 return {
                     account: (await account.get()),
                 };
+            },
+            delete: async (request) => {
+                return await this.runTransaction(async () => {
+                    const account = await this.query.unique(request.accountId);
+                    if (!account)
+                        throw HttpCodes._4XX.NOT_FOUND(`Account with id ${request.accountId} Not Found!`);
+                    try {
+                        const safeAccount = makeAccountSafe(account);
+                        await dispatch_OnAccountDeleted.dispatchModuleAsyncSerial(safeAccount);
+                        await this.delete.item(account);
+                        return { account };
+                    }
+                    catch (err) {
+                        const error = err;
+                        if (error.responseCode === 422)
+                            throw error;
+                        this.logError('Failed deleting account', err);
+                        throw HttpCodes._5XX.INTERNAL_SERVER_ERROR('Failed to delete account', error.message, error);
+                    }
+                });
             }
         };
         password = {

package/_entity/account/module-pack.d.ts

@@ -1,3 +1,3 @@
 import { Module } from '@nu-art/ts-common';
-export declare const ModulePackBE_AccountDB: (import("./ModuleBE_AccountDB.js").ModuleBE_AccountDB_Class | import("@nu-art/db-api-backend").ModuleBE_BaseApi_Class<import("@nu-art/user-account-shared").DatabaseDef_Account>)[];
+export declare const ModulePackBE_AccountDB: (import("./ModuleBE_AccountDB.js").ModuleBE_AccountDB_Class | import("@nu-art/db-api-backend").ModuleBE_BaseApi_Class<import("@nu-art/user-account-shared").DatabaseDef_Account, any>)[];
 export declare const ModulePackBE_SAML: Module[];

package/_entity/failed-login-attempt/module-pack.d.ts

@@ -1 +1 @@
-export declare const ModulePackBE_FailedLoginAttemptDB: (import("./ModuleBE_FailedLoginAttemptDB.js").ModuleBE_FailedLoginAttemptDB_Class | import("@nu-art/db-api-backend").ModuleBE_BaseApi_Class<import("@nu-art/user-account-shared").DatabaseDef_FailedLoginAttempt>)[];
+export declare const ModulePackBE_FailedLoginAttemptDB: (import("./ModuleBE_FailedLoginAttemptDB.js").ModuleBE_FailedLoginAttemptDB_Class | import("@nu-art/db-api-backend").ModuleBE_BaseApi_Class<import("@nu-art/user-account-shared").DatabaseDef_FailedLoginAttempt, any>)[];

package/_entity/login-attempts/module-pack.d.ts

@@ -1 +1 @@
-export declare const ModulePackBE_LoginAttemptDB: (import("./ModuleBE_LoginAttemptDB.js").ModuleBE_LoginAttemptDB_Class | import("@nu-art/db-api-backend").ModuleBE_BaseApi_Class<import("@nu-art/user-account-shared").DatabaseDef_LoginAttempt>)[];
+export declare const ModulePackBE_LoginAttemptDB: (import("./ModuleBE_LoginAttemptDB.js").ModuleBE_LoginAttemptDB_Class | import("@nu-art/db-api-backend").ModuleBE_BaseApi_Class<import("@nu-art/user-account-shared").DatabaseDef_LoginAttempt, any>)[];

package/_entity/session/ModuleBE_SessionDB.d.ts

@@ -1,8 +1,7 @@
 import { AnyPrimitive, Dispatcher, RecursiveObjectOfPrimitives, TypedKeyValue } from '@nu-art/ts-common';
-import { firestore } from 'firebase-admin';
 import { ModuleBE_BaseDB } from '@nu-art/db-api-backend';
-import { DatabaseDef_Account, DatabaseDef_Session, DB_Session } from '@nu-art/user-account-shared';
-import Transaction = firestore.Transaction;
+import { DatabaseDef_Account, DatabaseDef_Session, DB_Session, SafeDB_Account } from '@nu-art/user-account-shared';
+import { OnAccountDeleted } from '../account/ModuleBE_AccountDB.js';
 export type BaseSessionClaims = {
     accountId: DatabaseDef_Account['id'];
     deviceId: string;
@@ -14,9 +13,9 @@ export type Props_CreateSession = {
     initialClaims: BaseSessionClaims;
 };
 export interface CollectSessionData<R extends TypedKeyValue<any, AnyPrimitive>> {
-    __collectSessionData(data: BaseSessionClaims, transaction?: Transaction): Promise<R>;
+    __collectSessionData(data: BaseSessionClaims): Promise<R>;
 }
-export declare const dispatch_CollectSessionData: Dispatcher<CollectSessionData<TypedKeyValue<any, RecursiveObjectOfPrimitives>>, "__collectSessionData", [data: BaseSessionClaims, transaction?: firestore.Transaction | undefined], TypedKeyValue<any, RecursiveObjectOfPrimitives>>;
+export declare const dispatch_CollectSessionData: Dispatcher<CollectSessionData<TypedKeyValue<any, RecursiveObjectOfPrimitives>>, "__collectSessionData", [data: BaseSessionClaims], TypedKeyValue<any, RecursiveObjectOfPrimitives>>;
 export declare const Const_Default_SessionJWT_SecretKey = "jwt-signer--account-session";
 type Config = {
     sessionTTLms: number;
@@ -29,40 +28,41 @@ type Config = {
 };
 export declare class ModuleBE_SessionDB_Class extends ModuleBE_BaseDB<DatabaseDef_Session, Config> implements CollectSessionData<TypedKeyValue<'session', {
     deviceId: string;
-}>> {
+}>>, OnAccountDeleted {
     private jwtHandler;
+    __onAccountDeleted: (account: SafeDB_Account) => Promise<void>;
     constructor();
     init(): void;
     private collectSessionData;
     preWriteProcessing: (instance: DatabaseDef_Session["dbType"]) => Promise<void>;
     token: {
-        create: (initialClaims: BaseSessionClaims, ttlInMs?: number, transaction?: Transaction) => Promise<string>;
+        create: (initialClaims: BaseSessionClaims, ttlInMs?: number) => Promise<string>;
         refresh: (jwtOrigin: string) => Promise<string>;
         verify: (jwt: string) => Promise<BaseSessionClaims & RecursiveObjectOfPrimitives & import("@nu-art/ts-common").JWT_BaseClaims>;
     };
     private __session;
     _session: {
         query: {
-            byJwt: (jwt: string, transaction?: Transaction) => Promise<DB_Session>;
+            byJwt: (jwt: string) => Promise<DB_Session>;
         };
         return: (dbSession: DB_Session) => Promise<string>;
-        save: (content: Props_CreateSession, jwt: string, transaction?: Transaction) => Promise<DB_Session>;
-        create: ((content: Props_CreateSession, ttlInMs?: number, transaction?: Transaction) => Promise<DB_Session>) & {
-            andReturn: (content: Props_CreateSession, ttlInMs?: number, transaction?: Transaction) => Promise<string>;
+        save: (content: Props_CreateSession, jwt: string) => Promise<DB_Session>;
+        create: ((content: Props_CreateSession, ttlInMs?: number) => Promise<DB_Session>) & {
+            andReturn: (content: Props_CreateSession, ttlInMs?: number) => Promise<string>;
         };
         rotate: {
             refreshIfNeeded: {
-                byJwt: (jwt: string, transaction?: Transaction) => Promise<DB_Session | undefined>;
-                bySession: (dbSession?: DB_Session, transaction?: Transaction) => Promise<DB_Session>;
+                byJwt: (jwt: string) => Promise<DB_Session | undefined>;
+                bySession: (dbSession?: DB_Session) => Promise<DB_Session>;
             };
             reissue: {
-                byJwt: (jwt: string, transaction?: Transaction) => Promise<DB_Session>;
-                bySession: (dbSession?: DB_Session, transaction?: Transaction) => Promise<DB_Session>;
+                byJwt: (jwt: string) => Promise<DB_Session>;
+                bySession: (dbSession?: DB_Session) => Promise<DB_Session>;
             };
         };
         invalidate: {
-            byJwt: (jwt: string, transaction?: Transaction) => Promise<void>;
-            bySession: (dbSession?: DB_Session, transaction?: Transaction) => Promise<void>;
+            byJwt: (jwt: string) => Promise<void>;
+            bySession: (dbSession?: DB_Session) => Promise<void>;
         };
     };
     readonly Middleware: () => Promise<void>;

package/_entity/session/ModuleBE_SessionDB.js

@@ -1,4 +1,4 @@
-import { ApiException, currentTimeMillis, Day, Dispatcher, filterKeys, isErrorOfType, JwtTools, md5, MUSTNeverHappenException } from '@nu-art/ts-common';
+import { ApiException, currentTimeMillis, Day, Dispatcher, filterKeys, isErrorOfType, JwtTools, MUSTNeverHappenException } from '@nu-art/ts-common';
 import { ModuleBE_BaseDB } from '@nu-art/db-api-backend';
 import { AccountType_Service, DBDef_Session } from '@nu-art/user-account-shared';
 import { Header_Authorization, MemKey_DB_Session, MemKey_Jwt, MemKey_SessionData, SessionKey_Account_BE } from './consts.js';
@@ -8,11 +8,14 @@ import { HttpCodes } from '@nu-art/ts-common/core/exceptions/http-codes';
 import { _EmptyQuery } from '@nu-art/firebase-shared';
 import { ModuleBE_AccountDB } from '../account/ModuleBE_AccountDB.js';
 import { ResponseHeaderKey_JWTToken } from '@nu-art/api-types';
-import { dbObjectToId, stringToUniqueId } from '@nu-art/db-api-shared';
+import { dbObjectToId, hashToUniqueId } from '@nu-art/db-api-shared';
 export const dispatch_CollectSessionData = new Dispatcher('__collectSessionData');
 export const Const_Default_SessionJWT_SecretKey = 'jwt-signer--account-session';
 export class ModuleBE_SessionDB_Class extends ModuleBE_BaseDB {
     jwtHandler;
+    __onAccountDeleted = async (account) => {
+        await this.delete.where({ accountId: account._id });
+    };
     constructor() {
         super(DBDef_Session);
         this.setDefaultConfig({
@@ -33,8 +36,8 @@ export class ModuleBE_SessionDB_Class extends ModuleBE_BaseDB {
             ...this.config.jwtSigner
         });
     }
-    collectSessionData = async (content, transaction) => {
-        const collectedData = (await dispatch_CollectSessionData.dispatchModuleAsync(content, transaction));
+    collectSessionData = async (content) => {
+        const collectedData = (await dispatch_CollectSessionData.dispatchModuleAsync(content));
         return collectedData.reduce((sessionData, moduleSessionData) => {
             // We don't skip existing keys. This allows us to override session data provided by infra, with session data provided by app. If wanted, add flag to symbolize this is intentional to all relevant places.
             sessionData[moduleSessionData.key] = moduleSessionData.value;
@@ -50,8 +53,8 @@ export class ModuleBE_SessionDB_Class extends ModuleBE_BaseDB {
             delete instance.prevSession;
     };
     token = {
-        create: async (initialClaims, ttlInMs, transaction) => {
-            const claims = await this.collectSessionData(initialClaims, transaction);
+        create: async (initialClaims, ttlInMs) => {
+            const claims = await this.collectSessionData(initialClaims);
             return await this.jwtHandler.create(claims, ttlInMs ?? this.config.sessionTTLms);
         },
         refresh: async (jwtOrigin) => {
@@ -83,7 +86,7 @@ export class ModuleBE_SessionDB_Class extends ModuleBE_BaseDB {
             // Determine if the session should be rotated:
             return remainingTTL / totalTTL < this.config.rotationFactor;
         },
-        refresh: async (dbSession = MemKey_DB_Session.get(), transaction) => {
+        refresh: async (dbSession = MemKey_DB_Session.get()) => {
             this.logInfo(`Refreshing JWT for Account: ${dbSession.accountId}`);
             const jwt = await this.token.refresh(dbSession.sessionIdJwt);
             const content = {
@@ -95,9 +98,9 @@ export class ModuleBE_SessionDB_Class extends ModuleBE_BaseDB {
                     label: `refreshed from ${dbSession._id}`,
                 }
             };
-            return await this._session.save(content, jwt, transaction);
+            return await this._session.save(content, jwt);
         },
-        reissue: async (dbSession = MemKey_DB_Session.get(), transaction) => {
+        reissue: async (dbSession = MemKey_DB_Session.get()) => {
             this.logInfo(`Reissuing JWT for Account: ${dbSession.accountId} from Session: ${dbSession._id}`);
             const claims = await this.token.verify(dbSession.sessionIdJwt);
             const initialClaims = {
@@ -105,24 +108,24 @@ export class ModuleBE_SessionDB_Class extends ModuleBE_BaseDB {
                 deviceId: claims.deviceId,
                 label: `reissued from ${dbSession._id}`,
             };
-            const jwt = await this.token.create(initialClaims, (claims.exp - claims.iat) * 1000, transaction);
+            const jwt = await this.token.create(initialClaims, (claims.exp - claims.iat) * 1000);
             const content = {
                 linkedSessionId: dbSession._id,
                 prevSessions: dbSession.validSessionJwtMd5s,
                 initialClaims: initialClaims
             };
-            return await this._session.save(content, jwt, transaction);
+            return await this._session.save(content, jwt);
         }
     };
     _session = {
         query: {
-            byJwt: async (jwt, transaction) => {
+            byJwt: async (jwt) => {
                 return await this.query.uniqueCustom({
                     // We use an md5 to save and query for the session object. The original sessionId(JWT) is too big.
-                    where: { validSessionJwtMd5s: { $ac: stringToUniqueId(md5(jwt)) } },
+                    where: { validSessionJwtMd5s: { $ac: hashToUniqueId(jwt) } },
                     orderBy: [{ key: '__created', order: 'desc' }],
                     limit: 1
-                }, transaction);
+                });
             }
         },
         return: async (dbSession) => {
@@ -132,8 +135,8 @@ export class ModuleBE_SessionDB_Class extends ModuleBE_BaseDB {
             MemKey_Jwt.set(jwt);
             return jwt;
         },
-        save: async (content, jwt, transaction) => {
-            const _id = stringToUniqueId(md5(jwt));
+        save: async (content, jwt) => {
+            const _id = hashToUniqueId(jwt);
             const validSessionJwtMd5s = content.prevSessions ? [_id, ...content.prevSessions] : [_id];
             if (validSessionJwtMd5s.length > this.config.maxPrevSession)
                 validSessionJwtMd5s.length = this.config.maxPrevSession;
@@ -148,56 +151,56 @@ export class ModuleBE_SessionDB_Class extends ModuleBE_BaseDB {
             }, ['linkedSessionId', 'label']);
             const idsToDelete = dbSession.validSessionJwtMd5s.slice(1);
             if (idsToDelete.length)
-                await this.delete.all(idsToDelete, transaction);
-            return await this.set.item(dbSession, transaction);
+                await this.delete.all(idsToDelete);
+            return await this.set.item(dbSession);
         },
-        create: Object.assign(async (content, ttlInMs, transaction) => {
+        create: Object.assign(async (content, ttlInMs) => {
             this.logInfo(`Creating JWT for Account: ${content.initialClaims.accountId}`);
-            const jwt = await this.token.create(content.initialClaims, ttlInMs, transaction);
-            return await this._session.save(content, jwt, transaction);
+            const jwt = await this.token.create(content.initialClaims, ttlInMs);
+            return await this._session.save(content, jwt);
         }, {
-            andReturn: async (content, ttlInMs, transaction) => {
-                const dbSession = await this._session.create(content, ttlInMs, transaction);
+            andReturn: async (content, ttlInMs) => {
+                const dbSession = await this._session.create(content, ttlInMs);
                 return await this._session.return(dbSession);
             },
         }),
         rotate: {
             refreshIfNeeded: {
-                byJwt: async (jwt, transaction) => {
+                byJwt: async (jwt) => {
                     if (!(await this.__session.shouldRefresh(jwt)))
                         return;
-                    const dbSession = await this._session.query.byJwt(jwt, transaction);
+                    const dbSession = await this._session.query.byJwt(jwt);
                     this.logInfo(`Refreshing Session by JWT for account(${dbSession.accountId}) sessionId(${dbSession._id})`);
-                    return await this.__session.refresh(dbSession, transaction);
+                    return await this.__session.refresh(dbSession);
                 },
-                bySession: async (dbSession = MemKey_DB_Session.get(), transaction) => {
+                bySession: async (dbSession = MemKey_DB_Session.get()) => {
                     if (!(await this.__session.shouldRefresh(dbSession.sessionIdJwt)))
                         return dbSession;
                     this.logInfo(`Refreshing Session by dbSession for account(${dbSession.accountId}) sessionId(${dbSession._id})`);
-                    return await this.__session.refresh(dbSession, transaction);
+                    return await this.__session.refresh(dbSession);
                 }
             },
             reissue: {
-                byJwt: async (jwt, transaction) => {
+                byJwt: async (jwt) => {
                     await this.jwtHandler.assert(jwt);
-                    const dbSession = await this._session.query.byJwt(jwt, transaction);
-                    return await this.__session.reissue(dbSession, transaction);
+                    const dbSession = await this._session.query.byJwt(jwt);
+                    return await this.__session.reissue(dbSession);
                 },
-                bySession: async (dbSession = MemKey_DB_Session.get(), transaction) => {
+                bySession: async (dbSession = MemKey_DB_Session.get()) => {
                     await this.jwtHandler.assert(dbSession.sessionIdJwt);
-                    return await this.__session.reissue(dbSession, transaction);
+                    return await this.__session.reissue(dbSession);
                 }
             }
         },
         invalidate: {
-            byJwt: async (jwt, transaction) => {
-                const session = await this._session.query.byJwt(jwt, transaction);
-                return await this._session.invalidate.bySession(session, transaction);
+            byJwt: async (jwt) => {
+                const session = await this._session.query.byJwt(jwt);
+                return await this._session.invalidate.bySession(session);
             },
-            bySession: async (dbSession = MemKey_DB_Session.get(), transaction) => {
+            bySession: async (dbSession = MemKey_DB_Session.get()) => {
                 if (!dbSession)
                     throw HttpCodes._4XX.UNAUTHORIZED('No session in context to invalidate');
-                await this.set.item({ ...dbSession, validSessionJwtMd5s: [] }, transaction);
+                await this.set.item({ ...dbSession, validSessionJwtMd5s: [] });
                 this.logInfo(`Session invalidated for account: ${dbSession.accountId}, sessionId: ${dbSession._id}`);
             }
         }
@@ -214,8 +217,16 @@ export class ModuleBE_SessionDB_Class extends ModuleBE_BaseDB {
     };
     async locateSession(jwt) {
         try {
-            const { dbSession, claims } = await this.runTransaction(async (t) => {
-                let dbSession = await this._session.query.byJwt(jwt);
+            const { dbSession, claims } = await this.runTransaction(async () => {
+                let dbSession;
+                try {
+                    dbSession = await this._session.query.byJwt(jwt);
+                }
+                catch (err) {
+                    if (isErrorOfType(err, ApiException)?.responseCode === HttpCodes._4XX.NOT_FOUND.code)
+                        throw HttpCodes._4XX.UNAUTHORIZED('JWT received in request was not found', err);
+                    throw err;
+                }
                 const latestJwtValidationResult = await this.jwtHandler.verifySignature(dbSession.sessionIdJwt);
                 if (!latestJwtValidationResult.validated)
                     throw new MUSTNeverHappenException(`JWT received from DB is invalid Session id = ${dbSession._id}`);
@@ -262,12 +273,13 @@ export class ModuleBE_SessionDB_Class extends ModuleBE_BaseDB {
                     sessionIdsToDelete.add(session._id);
                 }
             }
-            session.validSessionJwtMd5s.forEach(id => {
-                if (id !== session._id)
-                    sessionIdsToDelete.add(id);
-            });
-            if (!session.validSessionJwtMd5s.length)
+            if (!session.validSessionJwtMd5s?.length)
                 sessionIdsToDelete.add(session._id);
+            else
+                session.validSessionJwtMd5s.forEach(id => {
+                    if (id !== session._id)
+                        sessionIdsToDelete.add(id);
+                });
         });
         //Second pass - collect all sessions that are expired or has the old "sessionData" property in their decoded data
         await Promise.all(sessions.map(async (session) => {

package/module-pack.d.ts

@@ -1,3 +1,3 @@
 import { Module } from '@nu-art/ts-common';
-export declare const ModulePackBE_Accounts: Module<any, any, import("@nu-art/ts-common").Validator<any> | import("@nu-art/ts-common").TypeValidator<any>>[];
-export declare const ModulePackBE_Accounts_WOSAML: Module<any, any, import("@nu-art/ts-common").Validator<any> | import("@nu-art/ts-common").TypeValidator<any>>[];
+export declare const ModulePackBE_Accounts: Module<any>[];
+export declare const ModulePackBE_Accounts_WOSAML: Module<any>[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/user-account-backend",
-  "version": "0.500.0",
+  "version": "0.500.6",
   "description": "User Account Backend",
   "keywords": [
     "TacB0sS",
@@ -34,16 +34,16 @@
     "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/db-api-backend": "0.500.0",
-    "@nu-art/db-api-shared": "0.500.0",
-    "@nu-art/user-account-shared": "0.500.0",
-    "@nu-art/firebase-backend": "0.500.0",
-    "@nu-art/firebase-shared": "0.500.0",
-    "@nu-art/http-server": "{{THUNDERSTORM_VERSION}}",
-    "@nu-art/slack-backend": "0.500.0",
-    "@nu-art/slack-shared": "0.500.0",
-    "@nu-art/ts-common": "0.500.0",
-    "@nu-art/api-types": "{{THUNDERSTORM_VERSION}}",
+    "@nu-art/db-api-backend": "0.500.6",
+    "@nu-art/db-api-shared": "0.500.6",
+    "@nu-art/user-account-shared": "0.500.6",
+    "@nu-art/firebase-backend": "0.500.6",
+    "@nu-art/firebase-shared": "0.500.6",
+    "@nu-art/http-server": "0.500.6",
+    "@nu-art/slack-backend": "0.500.6",
+    "@nu-art/slack-shared": "0.500.6",
+    "@nu-art/ts-common": "0.500.6",
+    "@nu-art/api-types": "0.500.6",
     "express": "^4.18.2",
     "firebase": "^11.9.0",
     "firebase-admin": "13.4.0",
@@ -55,8 +55,8 @@
     "xmlbuilder": "^15.1.1"
   },
   "devDependencies": {
-    "@nu-art/testalot": "0.500.0",
-    "@nu-art/google-services-backend": "0.500.0",
+    "@nu-art/testalot": "0.500.6",
+    "@nu-art/google-services-backend": "0.500.6",
     "@types/react": "^18.0.0",
     "@types/express": "^4.17.17",
     "@types/history": "^4.7.2",