....
constructor(private httpService: HttpService, private transactionsGateway: TransactionsGateway) {
        const keepAliveAgent = new https.Agent({ keepAlive: true });
        this.client = new Client({
            clientId: process.env.CLIENT_ID,
            clientSecret: process.env.CLIENT_SECRET,
            scopes: ["transactions", "subscriptions"],
            agent: keepAliveAgent,
        });
        this.accessToken = null;
        this.accessTokenExpiresAt = null; // Track the expiry of the token
    }
    username = process.env.USERNAME;
    password = process.env.PASSWORD;

    retryDelay = 180000; // Initial delay in milliseconds for exponential backoff
    maxRetries = 3; // Maximum number of retries


    async waitFor(delay) {
        return new Promise(resolve => setTimeout(resolve, delay));
    }

    async initiateMFA(retryCount = 0) {
        try {
            const tokenData: any = await this.client.auth.tokenManager.fetchTokenFromCredentials({
                username: this.username,
                password: this.password
            });
            this.accessToken = tokenData.accessToken;
            this.accessTokenExpiresAt = new Date(new Date().getTime() + tokenData.expires * 1000);

            const confirmedToken: any = await this.client.auth.push.getConfirmedToken();
            this.accessToken = confirmedToken.accessToken;
            this.accessTokenExpiresAt = new Date(new Date().getTime() + confirmedToken.expires * 1000);

            console.log("MFA confirmed. Access token is now confirmed.");
            this.retryDelay = 180000; // Reset retry delay upon success
        } catch (err) {
            if (err instanceof ChallengeExpiredError) {
                console.log("Challenge expired, trying again...");
                await this.initiateMFA(retryCount + 1); // Retry initiating MFA if the challenge expired
            } else if (err.status === 429 && retryCount < this.maxRetries) { // Check for rate limit error and retry count
                console.log(`Rate limit hit, retrying in ${this.retryDelay}ms...`);
                await this.waitFor(this.retryDelay);
                this.retryDelay *= 2; // Exponentially increase the delay
                await this.initiateMFA(retryCount + 1);
            } else {
                throw err; // Re-throw other errors that we're not handling here
            }
        }
    }

    async getAccessToken() {
        if (!this.accessToken || new Date() >= this.accessTokenExpiresAt) {
            await this.initiateMFA();
        }
        return this.accessToken;
    }

async subscribeNewTransactionByFiveSeconds(retryCount = 0) {
        const maxRetries = 3;
        const baseDelay = 180000; // 3 minutes
        const maxDelay = 600000; // 10 minutes

        try {
            const accessToken = await this.getAccessToken();
            const transactions = await this.client.models.transaction.fetch();
            // Filter transactions
            const fiveSecondsAgo = new Date(new Date().getTime() - 5 * 1000).toISOString();
            const transactionList = transactions.items;
            const searchResult = transactionList.filter(transaction => new Date(transaction.createdAt) > new Date(fiveSecondsAgo));
            if (searchResult.length > 0) {
                this.transactionsGateway.sendNewTransactionToClients(searchResult);
            }
            return searchResult;
        } catch (error) {
            console.error("subscribeNewTransactionByFiveSeconds error", error);
            if (error.status === 429) { // Rate limiting error
                console.log("Rate limiting error, retrying...");
                const delay = Math.min(baseDelay * Math.pow(2, retryCount), maxDelay);
                console.log(`Retrying after ${delay}ms...`);
                return new Promise((resolve, reject) => {
                    setTimeout(() => {
                        this.subscribeNewTransactionByFiveSeconds(retryCount + 1).then(resolve).catch(reject);
                    }, delay);
                });
            } else if (retryCount < maxRetries) {
                // Retry for other errors
                const delay = baseDelay;
                console.log(`Retrying for error after ${delay}ms...`);
                return new Promise((resolve, reject) => {
                    setTimeout(() => {
                        this.subscribeNewTransactionByFiveSeconds(retryCount + 1).then(resolve).catch(reject);
                    }, delay);
                });
            } else {
                throw error; // Rethrow after max retries
            }
        }
    }
...

@Injectable()
export class KontistService implements OnModuleInit {
    private client: ApolloClient<any>;
    private kontistClient: Client;

    constructor() {
        this.kontistClient = new Client({
            clientId: process.env.CLIENT_ID,
            clientSecret: process.env.CLIENT_SECRET,
            scopes: ["transactions", "subscriptions"]
        });
    }

    onModuleInit() {
        this.setupSubscription();
    }

    setupSubscription() {
        const username = process.env.USERNAME;
        const password = process.env.PASSWORD;
        this.kontistClient.auth.tokenManager.fetchTokenFromCredentials({ username: username, password: password }).then((tokenData) => {
            const accessToken = tokenData.accessToken;
            const wsClient = new SubscriptionClient(
                'wss://api.kontist.com/api/graphql',
                {
                    reconnect: true,
                    connectionParams: {
                        headers: {
                            Authorization: `Bearer ${accessToken}`,
                        },
                    },
                },
                WebSocket,
            );
            const link = new WebSocketLink(wsClient);
            this.client = new ApolloClient({
                link,
                cache: new InMemoryCache(),
            });
            this.subscribeToNewTransactions();
        });
    }

    subscribeToNewTransactions() {
        const SUBSCRIBE_TO_NEW_TRANSACTION = gql`
          subscription {
            newTransaction {
              id
              amount
              bookingDate
            }
          }
        `;

        console.log('Subscribing to new transactions')
        this.client.subscribe({
            query: SUBSCRIBE_TO_NEW_TRANSACTION,
        }).subscribe({
            next: (data) => {
                console.log('New transaction:', data);
                // Here, you can integrate with Prisma to save the transaction or perform any other logic
            },
            error: (err) => console.error('Error on new transaction subscription:', err),
        });
    }
 }

@Module({
    imports: [
        HttpModule,
        GraphQLModule.forRoot<ApolloDriverConfig>({
            driver: ApolloDriver,
            playground: false,
            typePaths: ['./**/*.graphql'],
            installSubscriptionHandlers: true,
            subscriptions: {
                'graphql-ws': true,
            }
        }),
    ],
    providers: [
        TransactionsService,
        TransactionsGateway,
        PrismaService,
        TransactionResolver,
        AuthService,
        JwtService,
        UsersService,
        KontistService,
    ],
    exports: [KontistService, TransactionsService, TransactionsGateway],
    controllers: [TransactionsController],
})
export class TransactionsModule {}

import { Resolver, Subscription } from '@nestjs/graphql';
import { PubSub } from 'graphql-subscriptions';
import {Transaction} from "kontist/dist/lib/graphql/transaction";

const pubSub = new PubSub();

@Resolver(of => Transaction)
export class TransactionResolver {
    @Subscription(returns => Transaction)
    newTransaction() {
        return pubSub.asyncIterator('newTransaction');
    }
}

@Controller('transactions')
@ApiTags('Transactions')
export class TransactionsController {
    constructor(private readonly service: TransactionsService, private readonly kontistService: KontistService) {}

    @Get('getAllList')
    async getAllTransactions() {
        const transactions = this.service.getAllTransactions();
        return transactions;
    }
 }