Code Quality Standards Skill¶

// ❌ INTERDIT
console.log('Debug info');
console.info('User data:', user);

// ✅ AUTORISÉ (warnings/errors)
console.warn('Deprecated API used');
console.error('Critical error:', error);

// ✅ RECOMMANDÉ (logger)
this.logger.info('User logged in', { userId: user.id });
this.logger.debug('Processing document', { docId });

// ❌ INTERDIT
function processData(data: any) {
  debugger; // Ne doit pas être commité
  return data.map(x => x * 2);
}

// ✅ CORRECT
function processData(data: number[]): number[] {
  return data.map(x => x * 2);
}

// ❌ INTERDIT
function processData(data: any): any {
  return data.value;
}

// ✅ CORRECT (type explicite)
function processData(data: DocumentData): ProcessedData {
  return data.value;
}

// ✅ CORRECT (generic)
function processData<T>(data: T): T {
  return data;
}

// ✅ ACCEPTABLE (unknown + type guard)
function processData(data: unknown): ProcessedData {
  if (!isDocumentData(data)) {
    throw new Error('Invalid data');
  }
  return data.value;
}

// ⚠️ WARNING (type inference OK mais explicite recommandé)
function getUser(id: string) {
  return this.userRepository.findOne(id);
}

// ✅ RECOMMANDÉ (type explicite)
async function getUser(id: string): Promise<User | null> {
  return this.userRepository.findOne(id);
}

// ❌ INTERDIT
function processDocument(doc: Document, options: Options) {
  // 'options' non utilisé
  return doc.content;
}

// ✅ CORRECT (préfixe _ pour paramètres intentionnellement non utilisés)
function processDocument(doc: Document, _options: Options) {
  return doc.content;
}

// ✅ MEILLEUR (ne pas déclarer si non utilisé)
function processDocument(doc: Document) {
  return doc.content;
}

// ❌ ERREUR TypeScript (strict null checks)
function getUser(id: string): User {
  const user = this.users.find(u => u.id === id);
  return user; // Error: Type 'User | undefined' not assignable to 'User'
}

// ✅ CORRECT (gestion explicite de null)
function getUser(id: string): User | null {
  const user = this.users.find(u => u.id === id);
  return user ?? null;
}

// ✅ CORRECT (throw si not found)
function getUser(id: string): User {
  const user = this.users.find(u => u.id === id);
  if (!user) {
    throw new NotFoundException(`User ${id} not found`);
  }
  return user;
}

// ❌ ERREUR TypeScript
function processData(data) { // Error: Parameter 'data' implicitly has 'any' type
  return data.value;
}

// ✅ CORRECT
function processData(data: DocumentData): string {
  return data.value;
}

// ❌ ERREUR TypeScript
class DocumentService {
  private repository: DocumentRepository; // Error: not initialized

  constructor(private config: ConfigService) {
    // repository not assigned
  }
}

// ✅ CORRECT (initialisation dans constructor)
class DocumentService {
  private repository: DocumentRepository;

  constructor(
    private config: ConfigService,
    repository: DocumentRepository
  ) {
    this.repository = repository;
  }
}

// ✅ CORRECT (injection NestJS)
class DocumentService {
  constructor(
    private readonly repository: DocumentRepository
  ) {}
}

// ✅ CORRECT (avec !)
class DocumentService {
  private repository!: DocumentRepository; // Assertion (utiliser avec précaution)

  async onModuleInit() {
    this.repository = await this.initRepository();
  }
}

// ❌ CRITICAL - Math.random() pour crypto
const token = Math.random().toString(36);

// ✅ CORRECT - CSPRNG
import { randomBytes } from 'crypto';
const token = randomBytes(32).toString('hex');

// ❌ MAJOR - Cognitive complexity 18 (> 15)
function validateDocument(doc: Document) {
  if (doc.type === 'PDF') {
    if (doc.size > MAX_SIZE) {
      if (doc.encrypted) {
        if (doc.password) {
          return validateEncryptedPDF(doc);
        } else {
          throw new Error('Password required');
        }
      } else {
        return validatePlainPDF(doc);
      }
    } else {
      throw new Error('File too large');
    }
  } else if (doc.type === 'DOCX') {
    // ...
  }
}

// ✅ CORRECT - Refactored (complexity 5)
function validateDocument(doc: Document): ValidationResult {
  const validator = this.getValidator(doc.type);
  this.checkSize(doc);
  return validator.validate(doc);
}

// ❌ DUPLICATION (détecté par Sonar)
function encryptDocument(doc: Document) {
  const key = deriveKey(doc.id);
  const iv = randomBytes(12);
  const cipher = createCipheriv('aes-256-gcm', key, iv);
  const ciphertext = Buffer.concat([cipher.update(doc.content), cipher.final()]);
  return { ciphertext, iv, tag: cipher.getAuthTag() };
}

function encryptFile(file: File) {
  const key = deriveKey(file.id);
  const iv = randomBytes(12);
  const cipher = createCipheriv('aes-256-gcm', key, iv);
  const ciphertext = Buffer.concat([cipher.update(file.content), cipher.final()]);
  return { ciphertext, iv, tag: cipher.getAuthTag() };
}

// ✅ CORRECT - Extraction commune
function encrypt(data: Buffer, id: string) {
  const key = deriveKey(id);
  const iv = randomBytes(12);
  const cipher = createCipheriv('aes-256-gcm', key, iv);
  const ciphertext = Buffer.concat([cipher.update(data), cipher.final()]);
  return { ciphertext, iv, tag: cipher.getAuthTag() };
}

function encryptDocument(doc: Document) {
  return encrypt(doc.content, doc.id);
}

function encryptFile(file: File) {
  return encrypt(file.content, file.id);
}

// ✅ CORRECT (formaté par Prettier)
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';

@Injectable()
export class DocumentService {
  constructor(
    @InjectRepository(Document)
    private readonly documentRepository: Repository<Document>
  ) {}

  async findAll(): Promise<Document[]> {
    return this.documentRepository.find();
  }
}

// 1. Node built-ins
import { randomBytes } from 'crypto';
import { readFileSync } from 'fs';

// 2. External libraries
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';

// 3. Internal modules
import { CryptoService } from '@/crypto/crypto.service';
import { Document } from '@/entities/document.entity';

// 4. Types
import type { EncryptionResult } from '@/types/encryption';

// ❌ BAD (magic numbers)
if (user.role === 1) {
  // ...
}
const key = randomBytes(32);

// ✅ GOOD (constantes nommées)
enum UserRole {
  ADMIN = 1,
  USER = 2
}

if (user.role === UserRole.ADMIN) {
  // ...
}

const AES_256_KEY_LENGTH = 32;
const key = randomBytes(AES_256_KEY_LENGTH);

// ❌ BAD (> 100 lignes)
function processDocument(doc: Document) {
  // 150 lignes de code...
}

// ✅ GOOD (décomposé)
function processDocument(doc: Document) {
  validateDocument(doc);
  const encrypted = encryptDocument(doc);
  saveDocument(encrypted);
  notifyUser(doc.userId);
}

// ❌ BAD (> 3 niveaux)
if (user) {
  if (user.isActive) {
    if (user.hasPermission('read')) {
      if (document.isPublic || document.owner === user.id) {
        return document;
      }
    }
  }
}

// ✅ GOOD (early returns)
if (!user || !user.isActive) {
  throw new UnauthorizedException();
}

if (!user.hasPermission('read')) {
  throw new ForbiddenException();
}

if (!document.isPublic && document.owner !== user.id) {
  throw new ForbiddenException();
}

return document;

// ❌ BAD (commentaire inutile)
// Get the user by ID
const user = await getUserById(id);

// ✅ GOOD (code self-documenting)
const user = await this.userRepository.findOneOrFail(id);

// ✅ GOOD (commentaire justifié)
// HACK: Workaround for CloudHSM API bug (JIRA-1234)
// Remove after CloudHSM v2.0 upgrade
await sleep(100);