perf: Improve customer account query [DEV-4965] (#673)

* perf: Improve customer account query

* perf: Cache customer accounts [DEV-4973] (#674)

perf: Cache customer accounts

* Regenerate lockfile

* generate migration

---------

Co-authored-by: Tasos Derisiotis <50984242+Eengineer1@users.noreply.github.com>

Author: DaevMithran

package-lock.json

@@ -12,6 +12,8 @@ import type {
 } from '../../types/admin.js';
 import { PaymentAccountService } from '../../services/api/payment-account.js';
 import { CheqdNetwork } from '@cheqd/sdk';
+import { LocalStore } from '../../database/cache/store.js';
+import { PaymentAccountEntity } from '../../database/entities/payment.account.entity.js';
 
 dotenv.config();
 
@@ -73,16 +75,23 @@ export class OrganisationController {
 				email,
 				description,
 			});
-			const paymentAccount = await PaymentAccountService.instance.find({ customer: customer });
 
-			if (!customer || paymentAccount.length === 0) {
+			const cachedAccounts = LocalStore.instance.getCustomerAccounts(response.locals.customer.customerId);
+			let paymentAccounts: PaymentAccountEntity[];
+			if (cachedAccounts?.length == 2) {
+				paymentAccounts = cachedAccounts;
+			} else {
+				paymentAccounts = await PaymentAccountService.instance.find({ customer: response.locals.customer });
+			}
+
+			if (!customer || paymentAccounts.length === 0) {
 				response.status(StatusCodes.NOT_FOUND).json({
 					error: 'Customer for updating not found',
 				} satisfies AdminOrganisationUpdateUnsuccessfulResponseBody);
 			}
 
-			const testnetAddress = paymentAccount.find((acc) => acc.namespace === CheqdNetwork.Testnet)?.address;
-			const mainnetAddress = paymentAccount.find((acc) => acc.namespace === CheqdNetwork.Mainnet)?.address;
+			const testnetAddress = paymentAccounts.find((acc) => acc.namespace === CheqdNetwork.Testnet)?.address;
+			const mainnetAddress = paymentAccounts.find((acc) => acc.namespace === CheqdNetwork.Mainnet)?.address;
 
 			return response.status(StatusCodes.OK).json({
 				name: customer.name,

src/controllers/admin/organisation.ts

@@ -32,6 +32,8 @@ import { SubscriptionService } from '../../services/admin/subscription.js';
 import { RoleService } from '../../services/api/role.js';
 import { getStripeObjectKey } from '../../utils/index.js';
 import { KeyService } from '../../services/api/key.js';
+import { LocalStore } from '../../database/cache/store.js';
+
 dotenv.config();
 
 export class AccountController {
@@ -76,7 +78,14 @@ export class AccountController {
 					error: 'Bad state cause there is no customer assigned to the user yet. Please contact administrator.',
 				} satisfies UnsuccessfulQueryCustomerResponseBody);
 			}
-			const paymentAccounts = await PaymentAccountService.instance.find({ customer: response.locals.customer });
+
+			const cachedAccounts = LocalStore.instance.getCustomerAccounts(response.locals.customer.customerId);
+			let paymentAccounts: PaymentAccountEntity[];
+			if (cachedAccounts?.length == 2) {
+				paymentAccounts = cachedAccounts;
+			} else {
+				paymentAccounts = await PaymentAccountService.instance.find({ customer: response.locals.customer });
+			}
 			const result: QueryCustomerResponseBody = {
 				customer: {
 					customerId: response.locals.customer.customerId,

src/controllers/api/account.ts

@@ -0,0 +1,26 @@
+import NodeCache from 'node-cache';
+import * as dotenv from 'dotenv';
+
+import { PaymentAccountEntity } from '../entities/payment.account.entity.js';
+
+dotenv.config();
+
+let { LOCAL_STORE_TTL = 600 } = process.env;
+
+export class LocalStore {
+	private cache: NodeCache;
+
+	public static instance = new LocalStore();
+
+	constructor() {
+		this.cache = new NodeCache();
+	}
+
+	setCustomerAccounts(key: string, data: PaymentAccountEntity[]) {
+		this.cache.set(key, data, +LOCAL_STORE_TTL);
+	}
+
+	getCustomerAccounts(key: string) {
+		return this.cache.get(key) as PaymentAccountEntity[] | undefined;
+	}
+}

src/database/cache/store.ts

@@ -1,4 +1,4 @@
-import { BeforeInsert, BeforeUpdate, Column, Entity, JoinColumn, ManyToOne } from 'typeorm';
+import { BeforeInsert, BeforeUpdate, Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
 
 import * as dotenv from 'dotenv';
 import { namespaceEnum } from './../types/enum.js';
@@ -8,6 +8,7 @@ import type { KeyEntity } from './key.entity.js';
 dotenv.config();
 
 @Entity('paymentAccount')
+@Index(['customer', 'namespace'], { unique: true })
 export class PaymentAccountEntity {
 	@Column({
 		type: 'text',

src/database/entities/payment.account.entity.ts

@@ -0,0 +1,13 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class IndexPaymentAccountTable1746513196390 implements MigrationInterface {
+	public async up(queryRunner: QueryRunner): Promise<void> {
+		await queryRunner.query(
+			`CREATE UNIQUE INDEX "IDX_e252516d4b5a966d291ee0ab61" ON "paymentAccount" ("customerId", "namespace") `
+		);
+	}
+
+	public async down(queryRunner: QueryRunner): Promise<void> {
+		await queryRunner.query(`DROP INDEX "public"."IDX_e252516d4b5a966d291ee0ab61"`);
+	}
+}

src/database/migrations/IndexPaymentAccountTable.ts

@@ -40,6 +40,8 @@ import { CreateSubscritpionTable1695740346003 } from '../migrations/CreateSubscr
 import { AlterAPIKeyTable1695740346004 } from '../migrations/AlterAPIKeyTable.js';
 import { AlterCustomerTableAddEmail1695740346005 } from '../migrations/AlterCustomerTableAddEmail.js';
 import { AlterCustomerTableUpdateEmail1695740346006 } from '../migrations/AlterCustomerTableUniqueEmail.js';
+import { IndexPaymentAccountTable1746513196390 } from '../migrations/IndexPaymentAccountTable.js';
+
 dotenv.config();
 
 const { EXTERNAL_DB_CONNECTION_URL, EXTERNAL_DB_CERT } = process.env;
@@ -118,6 +120,8 @@ export class Postgres implements AbstractDatabase {
 				AlterCustomerTableAddEmail1695740346005,
 				// Add unique constraint to email field
 				AlterCustomerTableUpdateEmail1695740346006,
+				// Add unique index in PaymentAccount table
+				IndexPaymentAccountTable1746513196390,
 			],
 			entities: [
 				...Entities,

src/database/types/types.ts

@@ -84,10 +84,17 @@ export class PaymentAccountService {
 		});
 	}
 
-	public async find(where: Record<string, unknown>) {
+	public async find(where: Record<string, unknown>, relations?: string[]) {
 		return await this.paymentAccountRepository.find({
 			where: where,
-			relations: ['customer', 'key'],
+			relations,
+		});
+	}
+
+	public async findOne(where: Record<string, unknown>, relations?: string[]) {
+		return await this.paymentAccountRepository.findOne({
+			where: where,
+			relations,
 		});
 	}
 }

src/services/api/payment-account.ts

@@ -57,6 +57,8 @@ import type { TPublicKeyEd25519 } from '@cheqd/did-provider-cheqd';
 import { toTPublicKeyEd25519 } from '../helpers.js';
 import type { APIServiceOptions } from '../../types/admin.js';
 import { SupportedKeyTypes } from '@veramo/utils';
+import { PaymentAccountEntity } from '../../database/entities/payment.account.entity.js';
+import { LocalStore } from '../../database/cache/store.js';
 
 dotenv.config();
 
@@ -89,36 +91,32 @@ export class PostgresIdentityService extends DefaultIdentityService {
 
 	async createCheqdProvider(
 		customer: CustomerEntity,
-		namespace: CheqdNetwork
+		namespace: CheqdNetwork,
+		paymentAccounts: PaymentAccountEntity[]
 	): Promise<CheqdDIDProvider | undefined> {
 		let rpcUrl = '';
 		if (namespace === CheqdNetwork.Mainnet) {
 			rpcUrl = MAINNET_RPC_URL || DefaultRPCUrls.mainnet;
 		} else {
 			rpcUrl = TESTNET_RPC_URL || DefaultRPCUrls.testnet;
 		}
-		const paymentAccount = await PaymentAccountService.instance.find({
-			namespace: namespace,
-			customer: customer,
-		});
-		if (paymentAccount.length > 1) {
-			throw new Error(`More than one payment account for ${namespace} found`);
+		const paymentAccount = paymentAccounts.find((acc) => acc.namespace === namespace);
+		if (paymentAccount === undefined) {
+			return undefined;
 		}
-		if (paymentAccount.length === 1) {
-			const privateKey = (await this.getPrivateKey(paymentAccount[0].key.kid))?.privateKeyHex;
 
-			if (!privateKey) {
-				throw new Error(`No keys is initialized`);
-			}
+		const privateKey = (await this.getPrivateKey(paymentAccount.key.kid))?.privateKeyHex;
 
-			return new CheqdDIDProvider({
-				defaultKms: 'postgres',
-				cosmosPayerSeed: privateKey,
-				networkType: namespace,
-				rpcUrl: rpcUrl,
-			});
+		if (!privateKey) {
+			throw new Error(`No keys is initialized`);
 		}
-		return undefined;
+
+		return new CheqdDIDProvider({
+			defaultKms: 'postgres',
+			cosmosPayerSeed: privateKey,
+			networkType: namespace,
+			rpcUrl: rpcUrl,
+		});
 	}
 
 	async createAgent(customer: CustomerEntity): Promise<VeramoAgent> {
@@ -133,10 +131,22 @@ export class PostgresIdentityService extends DefaultIdentityService {
 		}
 		const dbConnection = Connection.instance.dbConnection;
 
+		const cachedAccounts = LocalStore.instance.getCustomerAccounts(customer.customerId);
+		let paymentAccounts: PaymentAccountEntity[];
+		if (cachedAccounts?.length == 2) {
+			paymentAccounts = cachedAccounts;
+		} else {
+			paymentAccounts = await PaymentAccountService.instance.find({ customer }, ['key']);
+
+			if (paymentAccounts.length > 0) {
+				LocalStore.instance.setCustomerAccounts(customer.customerId, paymentAccounts);
+			}
+		}
+
 		// One customer may / may not have one Mainnet paymentAccount
-		const providerMainnet = await this.createCheqdProvider(customer, CheqdNetwork.Mainnet);
+		const providerMainnet = await this.createCheqdProvider(customer, CheqdNetwork.Mainnet, paymentAccounts);
 		// One customer may / may not have one Testnet paymentAccount
-		const providerTestnet = await this.createCheqdProvider(customer, CheqdNetwork.Testnet);
+		const providerTestnet = await this.createCheqdProvider(customer, CheqdNetwork.Testnet, paymentAccounts);
 		// did:key provider
 		providers['did:key'] = new KeyDIDProvider({ defaultKms: 'postgres' });
 		if (providerMainnet) {