@solidstarters/solid-core 1.2.87 → 1.2.89

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.87",
+  "version": "1.2.89",
   "description": "This module is a NestJS module containing all the required core providers required by a Solid application",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/controllers/export-template.controller.ts

@@ -5,6 +5,7 @@ import { ExportTemplateService } from '../services/export-template.service';
 import { CreateExportTemplateDto } from '../dtos/create-export-template.dto';
 import { UpdateExportTemplateDto } from '../dtos/update-export-template.dto';
 import { Response } from 'express';
+import { StartExportSyncDto } from 'src/dtos/export.dto';
 
 @ApiTags('Solid') 
 @Controller('export-template') //FIXME: Change this to the model plural name 
@@ -74,13 +75,19 @@ export class ExportTemplateController {
   }
 
   @ApiBearerAuth("jwt")
-  @Post(':id/startExport/sync')
-  async startExportSync(@Param('id') id: number, @Res() res: Response) {
-    const exportFileInfo = await this.service.startExportSync(+id);
+  @Post('/startExport/sync')
+  async startExportSync(@Body() dto: StartExportSyncDto, @Res() res: Response) {
+    const { filters, ...rest } = dto;
+    let updateDto = { ...rest };
+    // Check if templateName is present → create template
+    if (updateDto?.templateName) {
+      const newTemplate = await this.service.create(updateDto, []);
+      updateDto = { ...updateDto, id: newTemplate.id };
+    }
+    const exportFileInfo = await this.service.startExportSync(updateDto, filters);
     if (exportFileInfo.exportStream === null) {
       throw new InternalServerErrorException("Export stream is null");
     }
-
     // ✅ Set response headers for streaming
     res.setHeader('Content-Disposition', `attachment; filename="${exportFileInfo.fileName}"`);
     res.setHeader('Content-Type', exportFileInfo.mimeType);
@@ -90,9 +97,15 @@ export class ExportTemplateController {
   }
 
   @ApiBearerAuth("jwt")
-  @Post(':id/startExport/async')
-  async startExportAsync(@Param('id') id: number) {
-    return this.service.startExportAsync(+id);
+  @Post('/startExport/async')
+  async startExportAsync(@Body() dto: StartExportSyncDto) {
+    const { filters, ...rest } = dto;
+    let updateDto = { ...rest };
+    if (updateDto.templateName) {
+      const newTemplate = await this.service.create(updateDto, []);
+      updateDto = { ...updateDto, id: newTemplate.id };
+    }
+    return this.service.startExportAsync(updateDto, filters);
   }
 
 }

package/src/dtos/export.dto.ts

@@ -0,0 +1,5 @@
+import { UpdateExportTemplateDto } from "./update-export-template.dto";
+
+export class StartExportSyncDto extends UpdateExportTemplateDto {
+    filters?: any;
+  }

package/src/entities/export-transaction.entity.ts

@@ -17,6 +17,6 @@ export class ExportTransaction extends CommonEntity {
     @Column({ type: "text", nullable: true })
     error: string;
     @Index()
-    @ManyToOne(() => ExportTemplate, { onDelete: "CASCADE", nullable: false })
+    @ManyToOne(() => ExportTemplate, { onDelete: "CASCADE", nullable: true })
     exportTemplate: ExportTemplate;
 }

package/src/seeders/seed-data/solid-core-metadata.json

@@ -3564,7 +3564,7 @@
             "displayName": "Related Export Template",
             "type": "relation",
             "ormType": "int",
-            "required": true,
+            "required": false,
             "unique": false,
             "index": true,
             "private": false,

package/src/services/authentication.service.ts

@@ -859,31 +859,45 @@ export class AuthenticationService {
     }
 
     async generateTokens(user: User) {
-        const refreshTokenId = randomUUID();
-
-        // const userRoleNames = user.roles.map((role) => role.name).join(';')
-        const userRoleNames = user.roles.map((role) => role.name);
 
         const [accessToken, refreshToken] = await Promise.all([
-            this.signToken<Partial<ActiveUserData>>(
-                user.id,
-                this.jwtConfiguration.accessTokenTtl,
-                { username: user.username, email: user.email, roles: userRoleNames },
-            ),
-            this.signToken(user.id, this.jwtConfiguration.refreshTokenTtl, {
-                refreshTokenId,
-            }),
+            this.generateAccessToken(user),
+            this.generateRefreshToken(user),
         ]);
 
-        // store the refresh token id in the redis storage.
-        await this.refreshTokenIdsStorage.insert(user.id, refreshTokenId);
-
         return {
             accessToken,
             refreshToken,
         };
     }
 
+    async generateAccessToken(user: User) {
+
+        // const userRoleNames = user.roles.map((role) => role.name).join(';')
+        const userRoleNames = user.roles.map((role) => role.name);
+
+        const accessToken = await this.signToken<Partial<ActiveUserData>>(
+            user.id,
+            this.jwtConfiguration.accessTokenTtl,
+            { username: user.username, email: user.email, roles: userRoleNames },
+        );
+
+        return accessToken;
+    }
+
+    async generateRefreshToken(user: User) {
+        const refreshTokenId = randomUUID();
+
+        const refreshToken = await this.signToken(user.id, this.jwtConfiguration.refreshTokenTtl, {
+            refreshTokenId,
+        })
+
+        // store the refresh token id in the redis storage.
+        await this.refreshTokenIdsStorage.insert(user.id, refreshToken);
+
+        return refreshToken;
+    }
+
     async refreshTokens(refreshTokenDto: RefreshTokenDto) {
         try {
             const { sub, refreshTokenId } = await this.jwtService.verifyAsync<Pick<ActiveUserData, 'sub'> & { refreshTokenId: string }>(refreshTokenDto.refreshToken, {
@@ -904,14 +918,21 @@ export class AuthenticationService {
                 throw new UnauthorizedException();
             }
 
-            const isValid = await this.refreshTokenIdsStorage.validate(user.id, refreshTokenId);
-            if (isValid) {
-                // Refresh token rotation.
-                await this.refreshTokenIdsStorage.invalidate(user.id);
-            } else {
-                throw new Error('Refresh token is invalid');
-            }
-            return this.generateTokens(user);
+            // TODO: Replace the if else condition below with a call to validateAndRotate - Done
+            // const isValid = await this.refreshTokenIdsStorage.validate(user.id, refreshTokenId);
+            // if (isValid) {
+            //     // Refresh token rotation.
+            //     await this.refreshTokenIdsStorage.invalidate(user.id);
+            // } else {
+            //     throw new Error('Refresh token is invalid');
+            // }
+
+            const currentRefreshToken = await this.refreshTokenIdsStorage.validateAndRotate(user, refreshTokenDto.refreshToken);
+
+            return {
+                accessToken: await this.generateAccessToken(user),
+                refreshToken: currentRefreshToken,
+            };
         } catch (err) {
             if (err instanceof InvalidatedRefreshTokenError) {
                 // Take action: notify user that his refresh token might have been stolen?

package/src/services/export-template.service.ts

@@ -18,35 +18,36 @@ import { ExportTransaction } from 'src/entities/export-transaction.entity';
 import { Readable } from 'stream';
 import { ExportTemplate } from '../entities/export-template.entity';
 import { ExportTransactionFileInfo, ExportTransactionService } from './export-transaction.service';
+import { UpdateExportTemplateDto } from 'src/dtos/update-export-template.dto';
 
 @Injectable()
 export class ExportTemplateService extends CRUDService<ExportTemplate>{
-  async startExportSync(id: number): Promise<ExportTransactionFileInfo> {
+  async startExportSync(updateDto: UpdateExportTemplateDto, filters:any): Promise<ExportTransactionFileInfo> {
     // Create the export transaction entry, with status 'started'
     const exportTransaction: CreateExportTransactionDto =  await this.exportTransactionService.toDto({
       datetime: new Date(),
       status: 'started',
-      exportTemplateId: id,
+      exportTemplateId: updateDto?.id ? updateDto?.id : null,
     });
     const exportTransactionEntity = await this.exportTransactionService.create(exportTransaction);
 
     // Trigger the export process
-    const exportFileInfo = await this.exportTransactionService.triggerExportSync(exportTransactionEntity.id);
+    const exportFileInfo = await this.exportTransactionService.triggerExportSync(exportTransactionEntity.id, exportTransactionEntity, updateDto, filters);
     // It should return the export transaction id
     return exportFileInfo;
   }
 
-  async startExportAsync(id: number): Promise<ExportTransaction>{
+  async startExportAsync(updateDto: UpdateExportTemplateDto,  filters:any): Promise<ExportTransaction>{
     // Create the export transaction entry, with status 'started'
     const exportTransaction: CreateExportTransactionDto =  await this.exportTransactionService.toDto({
       datetime: new Date(),
       status: 'started',
-      exportTemplateId: id,
+      exportTemplateId: updateDto?.id ? updateDto?.id : null,
     });
     const exportTransactionEntity = await this.exportTransactionService.create(exportTransaction);
 
     // Trigger the export process
-    this.exportTransactionService.triggerExportAsync(exportTransactionEntity.id);
+    this.exportTransactionService.triggerExportAsync(exportTransactionEntity.id, exportTransactionEntity, updateDto, filters);
 
     // It should return the export transaction id, so client can use this to check the status
     return exportTransactionEntity;

package/src/services/export-transaction.service.ts

@@ -26,6 +26,8 @@ import { CsvService } from './csv.service';
 import { ExcelService } from './excel.service';
 import { getMediaStorageProvider } from './mediaStorageProviders';
 import { SolidIntrospectService } from './solid-introspect.service';
+import { ModelMetadata } from 'src/entities/model-metadata.entity';
+import { UpdateExportTemplateDto } from 'src/dtos/update-export-template.dto';
 
 const EXPORT_CHUNK_SIZE = 100;
 enum ExportStatus {
@@ -67,19 +69,30 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
     // readonly fieldMetadataService: FieldMetadataService,
     @InjectRepository(FieldMetadata, 'default')
     readonly fieldRepo: Repository<FieldMetadata>,
+    @InjectRepository(ModelMetadata, 'default')
+    readonly ModelMetadataRepo : Repository<ModelMetadata>,
     readonly moduleRef: ModuleRef
   ) {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'exportTransaction', 'solid-core',moduleRef);
   }
 
   // Return the export stream
-  async triggerExportSync(id: number): Promise<ExportTransactionFileInfo> {
+  async triggerExportSync(id: number, exportTransactionEntity: any, updateDto: UpdateExportTemplateDto , filters: any): Promise<ExportTransactionFileInfo> {
     try {
-      const loadedExportTransaction = await this.loadExportTransaction(id);
-      const { exportStream, templateName, uuid, exportTransaction } = await this.getExportStreamDetails(loadedExportTransaction);
+      // const loadedExportTransaction = await this.loadExportTransaction(id);
+      // from updateDto, get modelId and get modelMetadata
+      const modeldata = await this.ModelMetadataRepo.findOne({
+        where: { id:  updateDto?.modelMetadataId},
+        relations: { fields: true},
+      })
+      const modelName = modeldata?.singularName;
+      const modelTemplateName = modelName;
+      const fields = JSON.parse(updateDto?.fields);
+      const templateFormat = updateDto?.templateFormat;
+      const { exportStream, templateName, uuid, exportTransaction } = await this.getExportStreamDetails(modelName, modelTemplateName, fields, modeldata, templateFormat, id, exportTransactionEntity, filters);
       this.updateExportTransaction(id, ExportStatus.COMPLETED);
-      const fileName = this.getFileName(templateName, uuid, loadedExportTransaction.exportTemplate.templateFormat);
-      const mimeType = this.getMimeType(loadedExportTransaction.exportTemplate.templateFormat);
+      const fileName = this.getFileName(templateName, uuid, templateFormat);
+      const mimeType = this.getMimeType(templateFormat);
       return { exportStream, fileName, mimeType, exportTransaction };
     } catch (error) {
       this.updateExportTransaction(id, ExportStatus.FAILED, error.message);
@@ -88,13 +101,22 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
   }
 
   // Store the export stream using the appropriate storage provider
-  async triggerExportAsync(id: number): Promise<void> {
+  async triggerExportAsync(id: number, exportTransactionEntity: any, updateDto: UpdateExportTemplateDto, filters:any): Promise<void> {
     try {
-      const loadedExportTransaction = await this.loadExportTransaction(id)
-      const { exportStream, templateName, uuid, exportTransaction } = await this.getExportStreamDetails(loadedExportTransaction);
-      const fileFormat = loadedExportTransaction.exportTemplate.templateFormat;
+      // const loadedExportTransaction = await this.loadExportTransaction(id)
+      // from updateDto, get modelId and get modelMetadata
+      const modeldata = await this.ModelMetadataRepo.findOne({
+        where: { id:  updateDto?.modelMetadataId},
+        relations: { fields: true},
+      })
+      const modelName = modeldata?.singularName;
+      const modelTemplateName = modelName;
+      const fields = JSON.parse(updateDto?.fields);
+      const templateFormat = updateDto?.templateFormat;
+      const { exportStream, templateName, uuid, exportTransaction } = await this.getExportStreamDetails(modelName, modelTemplateName, fields, modeldata, templateFormat, id, exportTransactionEntity, filters);
+      // const fileFormat = loadedExportTransaction.exportTemplate.templateFormat;
       // Store the file using the appropriate storage provider
-      await this.storeExportStream(exportStream, exportTransaction, this.getFileName(templateName, uuid, fileFormat));
+      await this.storeExportStream(exportStream, exportTransaction, this.getFileName(templateName, uuid, templateFormat));
       this.updateExportTransaction(id, ExportStatus.COMPLETED);
     } catch (error) {
       this.updateExportTransaction(id, ExportStatus.FAILED, error.message);
@@ -106,7 +128,7 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
   private async loadExportTransaction(id: number) {
     return await this.repo.findOne({
       where: { id: id },
-      relations: { exportTemplate: { modelMetadata: true } },
+      relations: { exportTemplate: { modelMetadata: {fields: true} }},
     }
     );
   }
@@ -115,22 +137,26 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
     await this.repo.update(id, { status, error });
   }
 
-  private async getExportStreamDetails(exportTransaction: ExportTransaction) {
+  private async getExportStreamDetails(modelName: string, templateName: string, fields:any, modelData:any, templateFormat:string, id:number, exportTransaction: any, filters: any) {
     // Get the columns which need to be exported & the model id
-    const fields = JSON.parse(exportTransaction.exportTemplate.fields);
-
-    // Get the appropriate service for the model by trying to fetch a model service matching a particular name
-    const modelName = exportTransaction.exportTemplate.modelMetadata.singularName;
-    const modelService = this.introspectService.getProvider(`${classify(modelName)}Service`);
-    const templateName = exportTransaction.exportTemplate.templateName;
-    const uuid = exportTransaction.exportTransactionId; //TODO can be renamed to exportTransactionUUID
+    // const fields = JSON.parse(exportTransaction.exportTemplate.fields);
 
+    // // Get the appropriate service for the model by trying to fetch a model service matching a particular name
+    // const modelName = exportTransaction.exportTemplate.modelMetadata.singularName;
+     const modelService = this.introspectService.getProvider(`${classify(modelName)}Service`);
+    // const templateName = exportTransaction.exportTemplate.templateName;
+     const uuid = String(id); //TODO can be renamed to exportTransactionUUID
+    // const modelData = exportTransaction.exportTemplate.modelMetadata;
 
     // Get the data records function
-    const dataRecordsFunc = await this.getDataRecordsFunc(fields, modelService);
+    //const dataRecordsFunc = await this.getDataRecordsFunc(fields, modelService,modelData, filters);
+    const dataRecordsFunc = await this.getDataRecordsFunc(fields, modelService, modelData, filters);
 
     // Get the export passthru stream (since it is a passthru stream, nothing is stored in memory & it is streamed directly when the stream is read)
-    let exportStream = await this.getExportStream(exportTransaction.exportTemplate.templateFormat, dataRecordsFunc);
+    // let exportStream = await this.getExportStream(exportTransaction.exportTemplate.templateFormat, dataRecordsFunc);
+    // return { exportStream, templateName, uuid, exportTransaction };
+
+    let exportStream = await this.getExportStream(templateFormat, dataRecordsFunc);
     return { exportStream, templateName, uuid, exportTransaction };
   }
 
@@ -181,20 +207,78 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
     return (fileFormat === ExportFormat.EXCEL) ? 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' : 'text/csv';
   }
 
-  private async getDataRecordsFunc(fields: any, modelService: InstanceWrapper<any>): Promise<(chunkIndex: number, chunkSize: number) => Promise<any[]>> {
+  private async getDataRecordsFunc(fields: any, modelService: InstanceWrapper<any>, modelMetadata: any, filters:any): Promise<(chunkIndex: number, chunkSize: number) => Promise<any[]>> {
     // Return a function which will take the chunkIndex & chunkSize and return the data
+    // Get the relation fields to populate
+    const relatedFieldNames = modelMetadata?.fields
+    .filter((field: { relationType: any; }) => field.relationType !== null)
+    .map((field: { name: any; }) => field.name);
+
+    //Get the model metadata of relation field with userKey details
+    const relatedModelsUserKeyMap = new Map<string, string>();
+    for (const field of modelMetadata?.fields || []) {
+      if (field.relationType && field.relationCoModelSingularName && fields.includes(field.name)) {
+        const relatedModelMetadata = await this.ModelMetadataRepo.findOne({
+          where: { singularName: field.relationCoModelSingularName },
+          relations: ['userKeyField'],
+        });
+
+        if (relatedModelMetadata?.userKeyField?.name) {
+          relatedModelsUserKeyMap.set(field.name, relatedModelMetadata.userKeyField.name);
+        }
+      }
+    }
+
     return async (chunkIndex: number, chunkSize: number) => {
       const offset = chunkIndex * chunkSize;
       const recordFilterDto: BasicFilterDto = {
-        fields,
         limit: chunkSize,
         offset,
+        populate: relatedFieldNames
       };
+      const cleanedFilters = cleanNullsFromObject(filters);
+
+      if (cleanedFilters && Object.keys(cleanedFilters).length > 0) {
+        recordFilterDto.filters = cleanedFilters;
+      }
+
+      //Get the non relation fields which are in fields array passed to this function
+      const nonRelationalFieldSet = new Set(
+        modelMetadata?.fields
+          .filter((field: { name: any; relationType: any; }) => fields.includes(field.name) && field.relationType === null)
+          .map((field: { name: any; }) => field.name)
+      );
       const data = await modelService.instance.find(recordFilterDto);
       const records = data.records ?? [];
-      return records;
-    }
+    const cleanedRecords = records.map((record: Record<string, any>) => {
+      const newRecord: Record<string, any> = {};
+    
+      // Include non-relational fields
+      for (const key of nonRelationalFieldSet as Set<string>) {
+        newRecord[key] = record[key];
+      }
+    
+      // Include userKey from each related field
+      for (const [relatedFieldName, userKeyFieldName] of relatedModelsUserKeyMap.entries()) {
+        const relatedData = record[relatedFieldName];
+    
+        if (Array.isArray(relatedData)) {
+          // For many-to-many or one-to-many
+          const values = relatedData.map(item => item?.[userKeyFieldName]).filter(Boolean);
+          newRecord[relatedFieldName] = values.join(', ');
+        } else if (relatedData && typeof relatedData === 'object') {
+          // For many-to-one or one-to-one
+          newRecord[relatedFieldName] = relatedData?.[userKeyFieldName] ?? null;
+        } else {
+          newRecord[relatedFieldName] = null;
+        }
+      }
+    
+      return newRecord;
+    });
+    return cleanedRecords
   }
+}
 
   async toDto(data: Partial<CreateExportTransactionDto>): Promise<CreateExportTransactionDto> {
     const dto = new CreateExportTransactionDto(data);
@@ -206,3 +290,30 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
     return dto;
   }
 }
+
+function cleanNullsFromObject(obj: any): any {
+  if (Array.isArray(obj)) {
+    return obj
+      .filter(item => item !== null && item !== undefined)
+      .map(cleanNullsFromObject);
+  } else if (typeof obj === 'object' && obj !== null) {
+    const newObj: any = {};
+    for (const key in obj) {
+      const value = obj[key];
+      if (value !== null && value !== undefined) {
+        const cleanedValue = cleanNullsFromObject(value);
+        // Only assign non-empty objects/arrays or non-null primitives
+        if (
+          (typeof cleanedValue === 'object' && Object.keys(cleanedValue).length > 0) ||
+          (Array.isArray(cleanedValue) && cleanedValue.length > 0) ||
+          typeof cleanedValue !== 'object'
+        ) {
+          newObj[key] = cleanedValue;
+        }
+      }
+    }
+    return newObj;
+  }
+  return obj;
+}
+

package/src/services/refresh-token-ids-storage.service.ts

@@ -1,6 +1,7 @@
 import { CACHE_MANAGER } from '@nestjs/cache-manager';
-import { Inject, Injectable } from '@nestjs/common';
+import { Inject, Injectable, forwardRef } from '@nestjs/common';
 import { Cache } from 'cache-manager';
+import { AuthenticationService } from './authentication.service';
 
 // TODO: Ideally this should be in a separate file - putting this here for brevity
 export class InvalidatedRefreshTokenError extends Error { }
@@ -21,24 +22,106 @@ export class RefreshTokenIdsStorageService {
     //     return this.redisClient.quit();
     // }
 
-    constructor(@Inject(CACHE_MANAGER) private cacheManager: Cache) {}
+    constructor(
+        @Inject(CACHE_MANAGER) private cacheManager: Cache,
+        @Inject(forwardRef(() => AuthenticationService))
+        private readonly authenticationService: AuthenticationService
+    ) { }
 
-    async insert(userId: number, tokenId: string): Promise<void> {
-        await this.cacheManager.set(this.getKey(userId), tokenId);
+    async insert(userId: number, refreshToken: string): Promise<void> {
+        // TODO: save a refresh token object with this shape {"currentRefreshToken": "", "previousRefreshToken": ""}
+        // Save a refresh token object with the shape: { currentRefreshToken: string, previousRefreshToken: string }
+        const existing = (await this.cacheManager.get(this.getKey(userId))) as { currentRefreshToken?: string, previousRefreshToken?: string } | undefined;
+        const refreshTokenState = {
+            currentRefreshToken: refreshToken,
+            previousRefreshToken: "",
+        };
+        await this.cacheManager.set(this.getKey(userId), refreshTokenState);
     }
 
-    async validate(userId: number, tokenId: string): Promise<boolean> {
+    async validate(userId: number, refreshToken: string): Promise<boolean> {
+        // TODO: Assume you get this shape out of the cache {"currentRefreshToken": "", "previousRefreshToken": ""}
+        // Then you will compare against the currentRefreshToken.
         const storedId = await this.cacheManager.get(this.getKey(userId));
-        if (storedId !== tokenId) {
+        if (storedId !== refreshToken) {
             throw new InvalidatedRefreshTokenError();
         }
-        return storedId === tokenId;
+        return storedId === refreshToken;
     }
 
     async invalidate(userId: number): Promise<void> {
         await this.cacheManager.del(this.getKey(userId));
     }
 
+    async validateAndRotate(user: any, refreshToken: string): Promise<string> {
+        let valid = false;
+
+        // TODO: Assume you get this shape out of the cache {"currentRefreshToken": "", "previousRefreshToken": ""}
+        // Then you will compare against the currentRefreshToken.
+        const refreshTokenState = await this.cacheManager.get(this.getKey(user.id));
+        console.log("refreshTokenState", refreshTokenState);
+
+        // Use the authentication service to generate a new refresh token, set it in the currentRefreshToken in scenario 1 and return.
+
+        // if UI.refresh_token is matching with Cache.currentRefreshToken
+        //   then invalidate (updated cache state, no need to delete anything), then generate new token and return.
+        //   also set a setTimeout to run after X minutes, this will simply update the RefreshTokenCacheState to this object {"currentRefreshToken": "R2","justInvalidatedRefreshToken": ""}
+        // valid=true
+
+        //   - if UI.refresh_token is matching Cache.justInvalidatedRefreshToken        
+        //       then use the Cache.currentRefreshToken, generate new access token and return.
+        //       We do not modify the cache state at all.
+        // valid=true
+
+        let newRefreshToken: string | undefined;
+        if (
+            refreshTokenState &&
+            typeof refreshTokenState === 'object' &&
+            'currentRefreshToken' in refreshTokenState &&
+            'previousRefreshToken' in refreshTokenState
+        ) {
+            if (refreshTokenState.currentRefreshToken === refreshToken) {
+                // Scenario 1: Token matches currentRefreshToken
+                valid = true;
+                // Rotate tokens: move current to previous, set new current (simulate generation)
+                newRefreshToken = await this.authenticationService.generateRefreshToken(user); // Replace with real token generation logic
+
+
+                //   updated cache state
+                await this.cacheManager.set(this.getKey(user.id), {
+                    currentRefreshToken: newRefreshToken,
+                    previousRefreshToken: refreshTokenState.currentRefreshToken,
+                });
+
+                // Optionally, set a timeout to clear previousRefreshToken after X minutes
+                setTimeout(async () => {
+                    const state = (await this.cacheManager.get(this.getKey(user.id))) as any;
+                    if (state && state.currentRefreshToken === newRefreshToken) {
+                        await this.cacheManager.set(this.getKey(user.id), {
+                            currentRefreshToken: newRefreshToken,
+                            previousRefreshToken: "",
+                        });
+                    }
+                }, 1 * 60 * 1000); // 5 minutes
+            } else if (refreshTokenState.previousRefreshToken === refreshToken) {
+                // Scenario 2: Token matches previousRefreshToken
+                valid = true;
+                // Do not modify cache
+                // Generate new refresh token based on currentRefreshToken
+                const existingRefreshTokenState = (await this.cacheManager.get(this.getKey(user.id))) as { currentRefreshToken?: string, previousRefreshToken?: string } | undefined;
+                newRefreshToken = existingRefreshTokenState?.currentRefreshToken;
+            }
+        }
+
+
+        if (!valid) {
+            throw new InvalidatedRefreshTokenError();
+        }
+
+        // TODO: return the refresh token either currentRefreshToken
+        return newRefreshToken; // Fallback to the provided tokenId if no new token was generated
+    }
+
     private getKey(userId: number): string {
         return `user-${userId}`;
     }