feat: add lifecycle preview functionality in API and UI

tacxou · tacxou · commit 051535c8e566 · 2026-06-11T12:21:49.000+02:00
- Introduced new methods in LifecycleConfigService for previewing lifecycle mutations and filters.
- Updated LifecycleController to handle preview requests for both mutations and filters.
- Enhanced lifecycle-config.dto.ts with new DTOs for mutation and filter previews.
- Modified lifecycle.vue to include UI elements for previewing lifecycle configurations, ensuring proper access controls.
diff --git a/apps/api/src/_common/functions/resolve-config-variables.function.ts b/apps/api/src/_common/functions/resolve-config-variables.function.ts
@@ -28,6 +28,18 @@ liquidEngine.registerFilter('unixSeconds', (value: unknown) => {
   return normalizeDate(value).unix();
 });
 
+export function getTemplateContextSummary(): Record<string, string> {
+  const now = dayjs();
+  return {
+    'date.today': now.format('YYYY-MM-DD'),
+    'date.yesterday': now.subtract(1, 'day').format('YYYY-MM-DD'),
+    'date.tomorrow': dayjs().add(1, 'day').format('YYYY-MM-DD'),
+    'date.isoNow': dayjs().toISOString(),
+    'date.unix': `${dayjs().valueOf()}`,
+    'date.unixSeconds': `${dayjs().unix()}`,
+  };
+}
+
 function buildTemplateContext(): Record<string, unknown> {
   const now = dayjs();
   return {
diff --git a/apps/api/src/management/lifecycle/_dto/lifecycle-config.dto.ts b/apps/api/src/management/lifecycle/_dto/lifecycle-config.dto.ts
@@ -1,6 +1,18 @@
 import { ApiProperty, PartialType } from '@nestjs/swagger';
 import { Type } from 'class-transformer';
-import { IsArray, IsBoolean, IsNotEmpty, IsNumber, IsString, Matches, ValidateNested } from 'class-validator';
+import {
+  IsArray,
+  IsBoolean,
+  IsNotEmpty,
+  IsNumber,
+  IsObject,
+  IsOptional,
+  IsString,
+  Matches,
+  Max,
+  Min,
+  ValidateNested,
+} from 'class-validator';
 import { ConfigRulesObjectIdentitiesDTO } from './config-rules.dto';
 import { LifecycleStateDTO } from './config-states.dto';
 
@@ -55,6 +67,57 @@ export class LifecycleRuleFileCreateDto {
 
 export class LifecycleRuleFileUpdateDto extends PartialType(LifecycleRuleFileCreateDto) {}
 
+export class LifecyclePreviewMutationDto {
+  @IsObject()
+  @ApiProperty({
+    type: 'object',
+    description: 'Mutation brute telle que définie dans la règle lifecycle',
+    additionalProperties: true,
+  })
+  mutation: Record<string, unknown>;
+}
+
+export class LifecyclePreviewFilterDto {
+  @IsArray()
+  @IsString({ each: true })
+  @ApiProperty({ type: [String], description: 'États source de la règle' })
+  sources: string[];
+
+  @IsOptional()
+  @IsObject()
+  @ApiProperty({
+    type: 'object',
+    description: 'Filtre MongoDB brut (rules)',
+    additionalProperties: true,
+  })
+  rules?: Record<string, unknown>;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty({
+    type: String,
+    description: 'Valeur brute du trigger (-1, secondes, 90d, 5s, 50m, ...)',
+    required: false,
+  })
+  triggerInput?: string;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty({
+    type: String,
+    description: 'Clé de date utilisée pour le filtre temporel',
+    required: false,
+  })
+  dateKey?: string;
+
+  @IsOptional()
+  @IsNumber()
+  @Min(1)
+  @Max(25)
+  @ApiProperty({ type: Number, required: false, default: 5 })
+  sampleLimit?: number;
+}
+
 export class LifecycleStatesUpdateDto {
   @IsArray()
   @ValidateNested({ each: true })
diff --git a/apps/api/src/management/lifecycle/_functions/parse-lifecycle-trigger-input.function.ts b/apps/api/src/management/lifecycle/_functions/parse-lifecycle-trigger-input.function.ts
@@ -0,0 +1,71 @@
+const SECONDS_IN_DAY = 24 * 60 * 60;
+
+export function parseLifecycleTriggerInput(
+  input: string | number | null | undefined,
+): number | string | null | undefined {
+  if (input === undefined || input === null) {
+    return undefined;
+  }
+
+  if (typeof input === 'number') {
+    return input;
+  }
+
+  const trimmed = `${input}`.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+
+  if (trimmed === '-1') {
+    return -1;
+  }
+
+  if (/^\d+[dms]$/.test(trimmed)) {
+    return trimmed;
+  }
+
+  if (/^\d+$/.test(trimmed)) {
+    const seconds = parseInt(trimmed, 10);
+    if (seconds > 0) {
+      return seconds;
+    }
+  }
+
+  return null;
+}
+
+export function lifecycleTriggerToSeconds(value: number | string | null | undefined): number | undefined {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+
+  if (value === -1) {
+    return -1;
+  }
+
+  if (typeof value === 'number') {
+    if (value >= SECONDS_IN_DAY) {
+      return value;
+    }
+    return value * SECONDS_IN_DAY;
+  }
+
+  const match = value.match(/^(\d+)([dms])$/);
+  if (!match) {
+    return undefined;
+  }
+
+  const numValue = parseInt(match[1], 10);
+  const unit = match[2];
+
+  switch (unit) {
+    case 'd':
+      return numValue * SECONDS_IN_DAY;
+    case 'm':
+      return numValue * 60;
+    case 's':
+      return numValue;
+    default:
+      return undefined;
+  }
+}
diff --git a/apps/api/src/management/lifecycle/lifecycle-config.service.ts b/apps/api/src/management/lifecycle/lifecycle-config.service.ts
@@ -13,8 +13,15 @@ import {
   LifecycleRuleFileUpdateDto,
   LifecycleStatesUpdateDto,
 } from './_dto/lifecycle-config.dto';
+import { resolveConfigVariables, getTemplateContextSummary } from '~/_common/functions/resolve-config-variables.function';
+import { IdentitiesCrudService } from '../identities/identities-crud.service';
 import { loadLifecycleRules } from './_functions/load-lifecycle-rules.function';
+import {
+  lifecycleTriggerToSeconds,
+  parseLifecycleTriggerInput,
+} from './_functions/parse-lifecycle-trigger-input.function';
 import { validateLifecycleCronRules } from './_functions/validate-lifecycle-cron-rules.function';
+import { LifecyclePreviewFilterDto, LifecyclePreviewMutationDto } from './_dto/lifecycle-config.dto';
 import { LifecycleCrudService } from './lifecycle-crud.service';
 import { LifecycleHooksService } from './lifecycle-hooks.service';
 
@@ -33,6 +40,7 @@ export class LifecycleConfigService {
   public constructor(
     private readonly lifecycleHooksService: LifecycleHooksService,
     private readonly lifecycleCrudService: LifecycleCrudService,
+    private readonly identitiesCrudService: IdentitiesCrudService,
   ) {}
 
   public async searchRules(
@@ -153,6 +161,91 @@ export class LifecycleConfigService {
     return this.lifecycleCrudService.getCustomStates();
   }
 
+  public async previewMutation(payload: LifecyclePreviewMutationDto): Promise<{
+    raw: Record<string, unknown>;
+    resolved: Record<string, unknown>;
+    templateVariables: Record<string, string>;
+  }> {
+    const raw = payload.mutation || {};
+    const resolved = (await resolveConfigVariables(raw)) as Record<string, unknown>;
+
+    return {
+      raw,
+      resolved,
+      templateVariables: getTemplateContextSummary(),
+    };
+  }
+
+  public async previewFilter(payload: LifecyclePreviewFilterDto): Promise<{
+    query: Record<string, unknown>;
+    resolvedRules: Record<string, unknown>;
+    count: number;
+    samples: Array<Record<string, unknown>>;
+    temporalFilter: { applied: boolean; dateKey?: string; before?: string; note?: string };
+  }> {
+    if (!payload.sources?.length) {
+      throw new BadRequestException('Au moins un état source est requis pour la prévisualisation.');
+    }
+
+    const resolvedRules = (await resolveConfigVariables(payload.rules ?? {})) as Record<string, unknown>;
+    const parsedTrigger = parseLifecycleTriggerInput(payload.triggerInput);
+    const triggerSeconds = lifecycleTriggerToSeconds(parsedTrigger ?? undefined);
+    const dateKey = payload.dateKey?.trim() || 'lastSync';
+
+    const query: Record<string, unknown> = {
+      ...resolvedRules,
+      lifecycle: { $in: payload.sources },
+      ignoreLifecycle: { $ne: true },
+      deletedFlag: { $ne: true },
+    };
+
+    const temporalFilter: {
+      applied: boolean;
+      dateKey?: string;
+      before?: string;
+      note?: string;
+    } = {
+      applied: false,
+      note: 'Aucun filtre temporel appliqué (trigger absent, -1, ou immédiat).',
+    };
+
+    if (typeof triggerSeconds === 'number' && triggerSeconds > 0) {
+      const checkDate = new Date(Date.now() - triggerSeconds * 1000);
+      query[dateKey] = { $lte: checkDate };
+      temporalFilter.applied = true;
+      temporalFilter.dateKey = dateKey;
+      temporalFilter.before = checkDate.toISOString();
+      temporalFilter.note = `Identités dont ${dateKey} est antérieur ou égal à ${checkDate.toISOString()}.`;
+    } else if (triggerSeconds === -1) {
+      temporalFilter.note = 'Trigger -1 : exécution cron/CLI sans filtre temporel.';
+    }
+
+    const sampleLimit = payload.sampleLimit ?? 5;
+    const [count, samples] = await Promise.all([
+      this.identitiesCrudService.model.countDocuments(query),
+      this.identitiesCrudService.model
+        .find(query)
+        .limit(sampleLimit)
+        .select('_id lifecycle inetOrgPerson.cn inetOrgPerson.mail metadata.lastUpdatedAt lastSync')
+        .lean(),
+    ]);
+
+    return {
+      query,
+      resolvedRules,
+      count,
+      samples: samples.map((sample) => ({
+        _id: sample._id,
+        lifecycle: sample.lifecycle,
+        cn: (sample as { inetOrgPerson?: { cn?: string } }).inetOrgPerson?.cn,
+        mail: (sample as { inetOrgPerson?: { mail?: string } }).inetOrgPerson?.mail,
+        lastSync: (sample as { lastSync?: Date }).lastSync,
+        lastUpdatedAt: (sample as { metadata?: { lastUpdatedAt?: Date } }).metadata?.lastUpdatedAt,
+      })),
+      temporalFilter,
+    };
+  }
+
   public async updateCustomStates(payload: LifecycleStatesUpdateDto): Promise<IdentityLifecycleState[]> {
     const config = plainToInstance(ConfigStatesDTO, { states: payload.states });
     await validateOrReject(config, { whitelist: true });
diff --git a/apps/api/src/management/lifecycle/lifecycle.controller.ts b/apps/api/src/management/lifecycle/lifecycle.controller.ts
@@ -23,6 +23,8 @@ import { AbstractController } from '~/_common/abstracts/abstract.controller';
 import { ObjectIdValidationPipe } from '~/_common/pipes/object-id-validation.pipe';
 import { Lifecycle } from './_schemas/lifecycle.schema';
 import {
+  LifecyclePreviewFilterDto,
+  LifecyclePreviewMutationDto,
   LifecycleRuleFileCreateDto,
   LifecycleRuleFileSummaryDto,
   LifecycleRuleFileUpdateDto,
@@ -178,6 +180,39 @@ export class LifecycleController extends AbstractController {
    *   }
    * }
    */
+  @Post('config/preview/mutation')
+  @UseRoles({
+    resource: '/management/lifecycle',
+    action: AC_ACTIONS.READ,
+    possession: AC_DEFAULT_POSSESSION,
+  })
+  public async previewConfigMutation(
+    @Body() body: LifecyclePreviewMutationDto,
+    @Res() res: Response,
+  ): Promise<Response> {
+    const data = await this.lifecycleConfigService.previewMutation(body);
+
+    return res.json({
+      statusCode: HttpStatus.OK,
+      data,
+    });
+  }
+
+  @Post('config/preview/filter')
+  @UseRoles({
+    resource: '/management/lifecycle',
+    action: AC_ACTIONS.READ,
+    possession: AC_DEFAULT_POSSESSION,
+  })
+  public async previewConfigFilter(@Body() body: LifecyclePreviewFilterDto, @Res() res: Response): Promise<Response> {
+    const data = await this.lifecycleConfigService.previewFilter(body);
+
+    return res.json({
+      statusCode: HttpStatus.OK,
+      data,
+    });
+  }
+
   @Get('config/rules')
   @UseRoles({
     resource: '/management/lifecycle',
diff --git a/apps/web/src/pages/settings/lifecycle.vue b/apps/web/src/pages/settings/lifecycle.vue
