@programisto/edrm-storage 0.3.1

package/dist/modules/edrm-storage/config/environment.example.js

@@ -0,0 +1,130 @@
+/**
+ * Configuration d'environnement pour le module EDRM Storage
+ * Copiez ce fichier vers .env et configurez vos valeurs
+ */
+export const EdrmStorageEnvironment = {
+    // Configuration AWS S3
+    AWS: {
+        REGION: process.env.AWS_REGION || 'us-east-1',
+        ACCESS_KEY_ID: process.env.AWS_ACCESS_KEY_ID || '',
+        SECRET_ACCESS_KEY: process.env.AWS_SECRET_ACCESS_KEY || '',
+        BUCKET: process.env.S3_BUCKET || 'edrm-storage'
+    },
+    // Configuration MinIO (optionnel)
+    MINIO: {
+        ENDPOINT: process.env.MINIO_ENDPOINT || 'http://localhost:9000',
+        ACCESS_KEY: process.env.MINIO_ACCESS_KEY || '',
+        SECRET_KEY: process.env.MINIO_SECRET_KEY || '',
+        BUCKET: process.env.MINIO_BUCKET || 'edrm-storage',
+        USE_SSL: process.env.MINIO_USE_SSL === 'true'
+    },
+    // Configuration générale
+    GENERAL: {
+        DEFAULT_PROVIDER: process.env.EDRM_STORAGE_PROVIDER || 'S3',
+        MAX_FILE_SIZE: parseInt(process.env.EDRM_MAX_FILE_SIZE || '104857600'), // 100MB
+        UPLOAD_EXPIRES_IN: parseInt(process.env.EDRM_UPLOAD_EXPIRES_IN || '3600'), // 1 heure
+        DOWNLOAD_EXPIRES_IN: parseInt(process.env.EDRM_DOWNLOAD_EXPIRES_IN || '3600'), // 1 heure
+        ALLOWED_MIME_TYPES: process.env.EDRM_ALLOWED_MIME_TYPES?.split(',') || [
+            'application/pdf',
+            'application/msword',
+            'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            'image/jpeg',
+            'image/png',
+            'image/gif',
+            'text/plain',
+            'application/zip',
+            'application/x-zip-compressed'
+        ]
+    },
+    // Configuration des événements
+    EVENTS: {
+        ENABLED: process.env.EDRM_EVENTS_ENABLED !== 'false',
+        EMIT_FILE_STORED: process.env.EDRM_EMIT_FILE_STORED !== 'false',
+        EMIT_FILE_DELETED: process.env.EDRM_EMIT_FILE_DELETED !== 'false',
+        EMIT_FILE_ACCESSED: process.env.EDRM_EMIT_FILE_ACCESSED !== 'false'
+    },
+    // Configuration de sécurité
+    SECURITY: {
+        PRESIGNED_URL_EXPIRES_IN: parseInt(process.env.EDRM_PRESIGNED_URL_EXPIRES_IN || '3600'),
+        MAX_CONCURRENT_UPLOADS: parseInt(process.env.EDRM_MAX_CONCURRENT_UPLOADS || '100'),
+        ENABLE_ANTIVIRUS: process.env.EDRM_ENABLE_ANTIVIRUS === 'true',
+        ENABLE_WATERMARKING: process.env.EDRM_ENABLE_WATERMARKING === 'true'
+    },
+    // Configuration de monitoring
+    MONITORING: {
+        ENABLE_METRICS: process.env.EDRM_ENABLE_METRICS !== 'false',
+        LOG_LEVEL: process.env.EDRM_LOG_LEVEL || 'info',
+        ENABLE_AUDIT_LOG: process.env.EDRM_ENABLE_AUDIT_LOG === 'true'
+    }
+};
+/**
+ * Validation de la configuration
+ */
+export function validateEdrmStorageConfig() {
+    const errors = [];
+    // Vérifier les variables AWS requises
+    if (!EdrmStorageEnvironment.AWS.ACCESS_KEY_ID) {
+        errors.push('AWS_ACCESS_KEY_ID est requis');
+    }
+    if (!EdrmStorageEnvironment.AWS.SECRET_ACCESS_KEY) {
+        errors.push('AWS_SECRET_ACCESS_KEY est requis');
+    }
+    if (!EdrmStorageEnvironment.AWS.BUCKET) {
+        errors.push('S3_BUCKET est requis');
+    }
+    // Vérifier les valeurs numériques
+    if (EdrmStorageEnvironment.GENERAL.MAX_FILE_SIZE <= 0) {
+        errors.push('EDRM_MAX_FILE_SIZE doit être positif');
+    }
+    if (EdrmStorageEnvironment.GENERAL.UPLOAD_EXPIRES_IN <= 0) {
+        errors.push('EDRM_UPLOAD_EXPIRES_IN doit être positif');
+    }
+    if (EdrmStorageEnvironment.GENERAL.DOWNLOAD_EXPIRES_IN <= 0) {
+        errors.push('EDRM_DOWNLOAD_EXPIRES_IN doit être positif');
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+/**
+ * Exemple de fichier .env
+ */
+export const ENV_EXAMPLE = `
+# Configuration AWS S3
+AWS_REGION=us-east-1
+AWS_ACCESS_KEY_ID=your_access_key_here
+AWS_SECRET_ACCESS_KEY=your_secret_key_here
+S3_BUCKET=edrm-storage
+
+# Configuration MinIO (optionnel)
+MINIO_ENDPOINT=http://localhost:9000
+MINIO_ACCESS_KEY=your_minio_key
+MINIO_SECRET_KEY=your_minio_secret
+MINIO_BUCKET=edrm-storage
+MINIO_USE_SSL=false
+
+# Configuration générale
+EDRM_STORAGE_PROVIDER=S3
+EDRM_MAX_FILE_SIZE=104857600
+EDRM_UPLOAD_EXPIRES_IN=3600
+EDRM_DOWNLOAD_EXPIRES_IN=3600
+EDRM_ALLOWED_MIME_TYPES=application/pdf,image/jpeg,image/png
+
+# Configuration des événements
+EDRM_EVENTS_ENABLED=true
+EDRM_EMIT_FILE_STORED=true
+EDRM_EMIT_FILE_DELETED=true
+EDRM_EMIT_FILE_ACCESSED=true
+
+# Configuration de sécurité
+EDRM_PRESIGNED_URL_EXPIRES_IN=3600
+EDRM_MAX_CONCURRENT_UPLOADS=100
+EDRM_ENABLE_ANTIVIRUS=false
+EDRM_ENABLE_WATERMARKING=false
+
+# Configuration de monitoring
+EDRM_ENABLE_METRICS=true
+EDRM_LOG_LEVEL=info
+EDRM_ENABLE_AUDIT_LOG=false
+`;

package/dist/modules/edrm-storage/examples/usage.example.d.ts

@@ -0,0 +1,52 @@
+import { FileProvider } from '../models/file.model.js';
+export declare class ExampleUsage {
+    private storageService;
+    constructor();
+    /**
+     * Exemple d'upload d'un CV pour une candidature
+     */
+    uploadCVForApplication(applicationId: string, originalName: string, mimeType: string, size: number): Promise<any>;
+    /**
+     * Exemple de récupération d'une URL de téléchargement
+     */
+    getDownloadUrl(fileId: string, filename?: string): Promise<any>;
+    /**
+     * Exemple de listing des fichiers d'une entité
+     */
+    listEntityFiles(entityName: string, entityId: string): Promise<{
+        files: any[];
+        total: number;
+        page: number;
+        totalPages: number;
+    }>;
+    /**
+     * Exemple d'upload de document de mission
+     */
+    uploadMissionDocument(applicationId: string, originalName: string, mimeType: string, size: number): Promise<{
+        fileId: import("mongoose").Types.ObjectId;
+        uploadId: string;
+        presignedUrl: string;
+        expiresAt: Date;
+        bucket: string;
+        key: string;
+    }>;
+    /**
+     * Exemple de suppression d'un fichier
+     */
+    deleteFile(fileId: string): Promise<boolean>;
+    /**
+     * Exemple d'utilisation avec différents providers
+     */
+    uploadWithDifferentProvider(originalName: string, mimeType: string, size: number, provider: FileProvider): Promise<{
+        fileId: import("mongoose").Types.ObjectId;
+        uploadId: string;
+        presignedUrl: string;
+        expiresAt: Date;
+        bucket: string;
+        key: string;
+    }>;
+}
+export declare const exampleRouterUsage: {
+    initUpload: (req: any, res: any) => Promise<void>;
+    downloadFile: (req: any, res: any) => Promise<void>;
+};

package/dist/modules/edrm-storage/examples/usage.example.js

@@ -0,0 +1,156 @@
+// Exemple d'utilisation du module EDRM Storage
+// Ce fichier montre comment intégrer le module dans un autre module Endurance
+import { EdrmStorageService } from '../services/edrm-storage.service.js';
+import { FileProvider } from '../models/file.model.js';
+export class ExampleUsage {
+    storageService;
+    constructor() {
+        this.storageService = new EdrmStorageService();
+    }
+    /**
+     * Exemple d'upload d'un CV pour une candidature
+     */
+    async uploadCVForApplication(applicationId, originalName, mimeType, size) {
+        try {
+            // 1. Initialiser l'upload
+            const uploadResult = await this.storageService.initUpload(originalName, mimeType, size, 'endurance', // tenantId
+            'job-application', applicationId.toString(), FileProvider.S3, {
+                category: 'cv',
+                applicationId,
+                type: 'resume'
+            }, ['cv', 'resume', 'application']);
+            console.log('Upload initialisé:', uploadResult);
+            // 2. Le client utilise l'URL présignée pour uploader directement vers S3
+            // uploadResult.presignedUrl
+            // 3. Finaliser l'upload après que le client ait uploadé
+            const completedFile = await this.storageService.completeUpload(uploadResult.fileId.toString());
+            console.log('Upload finalisé:', completedFile);
+            return completedFile;
+        }
+        catch (error) {
+            console.error('Erreur lors de l\'upload:', error);
+            throw error;
+        }
+    }
+    /**
+     * Exemple de récupération d'une URL de téléchargement
+     */
+    async getDownloadUrl(fileId, filename) {
+        try {
+            const downloadResult = await this.storageService.getDownloadUrl(fileId, filename, 3600 // 1 heure
+            );
+            console.log('URL de téléchargement générée:', downloadResult);
+            return downloadResult;
+        }
+        catch (error) {
+            console.error('Erreur lors de la génération de l\'URL:', error);
+            throw error;
+        }
+    }
+    /**
+     * Exemple de listing des fichiers d'une entité
+     */
+    async listEntityFiles(entityName, entityId) {
+        try {
+            const files = await this.storageService.listFiles('endurance', entityName, entityId, undefined, // status
+            1, // page
+            20 // limit
+            );
+            console.log('Fichiers trouvés:', files);
+            return files;
+        }
+        catch (error) {
+            console.error('Erreur lors du listing:', error);
+            throw error;
+        }
+    }
+    /**
+     * Exemple d'upload de document de mission
+     */
+    async uploadMissionDocument(applicationId, originalName, mimeType, size) {
+        try {
+            const uploadResult = await this.storageService.initUpload(originalName, mimeType, size, 'endurance', 'job-application', applicationId.toString(), FileProvider.S3, {
+                category: 'mission-doc',
+                applicationId,
+                type: 'mission'
+            }, ['mission', 'document', 'application']);
+            console.log('Upload document mission initialisé:', uploadResult);
+            return uploadResult;
+        }
+        catch (error) {
+            console.error('Erreur lors de l\'upload du document mission:', error);
+            throw error;
+        }
+    }
+    /**
+     * Exemple de suppression d'un fichier
+     */
+    async deleteFile(fileId) {
+        try {
+            await this.storageService.deleteFile(fileId);
+            console.log('Fichier supprimé avec succès');
+            return true;
+        }
+        catch (error) {
+            console.error('Erreur lors de la suppression:', error);
+            throw error;
+        }
+    }
+    /**
+     * Exemple d'utilisation avec différents providers
+     */
+    async uploadWithDifferentProvider(originalName, mimeType, size, provider) {
+        try {
+            const uploadResult = await this.storageService.initUpload(originalName, mimeType, size, 'endurance', 'test-entity', 'test-id', provider, {
+                category: 'test',
+                provider
+            }, ['test', provider.toLowerCase()]);
+            console.log(`Upload avec provider ${provider}:`, uploadResult);
+            return uploadResult;
+        }
+        catch (error) {
+            console.error(`Erreur avec provider ${provider}:`, error);
+            throw error;
+        }
+    }
+}
+// Exemple d'utilisation dans un routeur Express
+export const exampleRouterUsage = {
+    // Route pour initialiser un upload
+    initUpload: async (req, res) => {
+        const example = new ExampleUsage();
+        try {
+            const { originalName, mimeType, size, entityId } = req.body;
+            const result = await example.uploadCVForApplication(entityId, originalName, mimeType, size);
+            res.json({
+                success: true,
+                data: result
+            });
+        }
+        catch (error) {
+            res.status(500).json({
+                success: false,
+                message: 'Erreur lors de l\'initialisation de l\'upload'
+            });
+        }
+    },
+    // Route pour télécharger un fichier
+    downloadFile: async (req, res) => {
+        const example = new ExampleUsage();
+        try {
+            const { fileId } = req.params;
+            const { filename } = req.query;
+            const result = await example.getDownloadUrl(fileId, filename);
+            res.json({
+                success: true,
+                data: result
+            });
+        }
+        catch (error) {
+            res.status(500).json({
+                success: false,
+                message: 'Erreur lors de la génération de l\'URL de téléchargement'
+            });
+        }
+    }
+};

package/dist/modules/edrm-storage/index.d.ts

@@ -0,0 +1,5 @@
+export { default as FileModel, FileStatus, FileProvider, FileType } from './models/file.model.js';
+export type { StorageProvider, UploadInitResponse, DownloadUrlResponse, FileMetadata } from './interfaces/storage-provider.interface.js';
+export { S3StorageProvider } from './providers/s3-storage.provider.js';
+export { EdrmStorageService } from './services/edrm-storage.service.js';
+export { default as EdrmStorageRouter } from './routes/edrm-storage.router.js';

package/dist/modules/edrm-storage/index.js

@@ -0,0 +1,8 @@
+// Modèles
+export { default as FileModel, FileStatus, FileProvider, FileType } from './models/file.model.js';
+// Providers
+export { S3StorageProvider } from './providers/s3-storage.provider.js';
+// Services
+export { EdrmStorageService } from './services/edrm-storage.service.js';
+// Routes
+export { default as EdrmStorageRouter } from './routes/edrm-storage.router.js';

package/dist/modules/edrm-storage/integration/edrm-storage-integration.d.ts

@@ -0,0 +1,53 @@
+import EdrmStorageRouter from '../routes/edrm-storage.router.js';
+/**
+ * Classe d'intégration pour le module EDRM Storage
+ * Gère l'initialisation et l'intégration du module dans l'application principale
+ */
+export declare class EdrmStorageIntegration {
+    private static instance;
+    private isInitialized;
+    private constructor();
+    static getInstance(): EdrmStorageIntegration;
+    /**
+     * Initialise le module edrm-storage
+     * - Exécute les migrations nécessaires
+     * - Configure les variables d'environnement
+     * - Prépare les routeurs
+     */
+    initialize(): Promise<void>;
+    /**
+     * Valide les variables d'environnement requises
+     */
+    private validateEnvironmentVariables;
+    /**
+     * Exécute les migrations nécessaires
+     */
+    private runMigrations;
+    /**
+     * Configure les événements du module
+     */
+    private setupEvents;
+    /**
+     * Retourne le routeur principal du module
+     */
+    getRouter(): EdrmStorageRouter;
+    /**
+     * Retourne les informations de statut du module
+     */
+    getStatus(): {
+        initialized: boolean;
+        config: any;
+    };
+    /**
+     * Nettoie les ressources du module
+     */
+    cleanup(): Promise<void>;
+}
+/**
+ * Fonction utilitaire pour initialiser le module depuis l'application principale
+ */
+export declare function initializeEdrmStorage(): Promise<EdrmStorageIntegration>;
+/**
+ * Fonction utilitaire pour obtenir le routeur du module
+ */
+export declare function getEdrmStorageRouter(): EdrmStorageRouter;

package/dist/modules/edrm-storage/integration/edrm-storage-integration.js

@@ -0,0 +1,132 @@
+import EdrmStorageRouter from '../routes/edrm-storage.router.js';
+import { runEdrmStorageMigrations } from '../migrations/edrm-storage.migration.js';
+/**
+ * Classe d'intégration pour le module EDRM Storage
+ * Gère l'initialisation et l'intégration du module dans l'application principale
+ */
+export class EdrmStorageIntegration {
+    static instance;
+    isInitialized = false;
+    constructor() { }
+    static getInstance() {
+        if (!EdrmStorageIntegration.instance) {
+            EdrmStorageIntegration.instance = new EdrmStorageIntegration();
+        }
+        return EdrmStorageIntegration.instance;
+    }
+    /**
+     * Initialise le module edrm-storage
+     * - Exécute les migrations nécessaires
+     * - Configure les variables d'environnement
+     * - Prépare les routeurs
+     */
+    async initialize() {
+        if (this.isInitialized) {
+            console.log('Module EDRM Storage déjà initialisé');
+            return;
+        }
+        try {
+            console.log('Initialisation du module EDRM Storage...');
+            // Vérifier les variables d'environnement requises
+            this.validateEnvironmentVariables();
+            // Exécuter les migrations
+            await this.runMigrations();
+            // Configurer les événements
+            this.setupEvents();
+            this.isInitialized = true;
+            console.log('Module EDRM Storage initialisé avec succès');
+        }
+        catch (error) {
+            console.error('Erreur lors de l\'initialisation du module EDRM Storage:', error);
+            throw error;
+        }
+    }
+    /**
+     * Valide les variables d'environnement requises
+     */
+    validateEnvironmentVariables() {
+        const requiredVars = [
+            'AWS_REGION',
+            'AWS_ACCESS_KEY_ID',
+            'AWS_SECRET_ACCESS_KEY',
+            'S3_BUCKET'
+        ];
+        const missingVars = requiredVars.filter(varName => !process.env[varName]);
+        if (missingVars.length > 0) {
+            console.warn('Variables d\'environnement manquantes pour EDRM Storage:', missingVars);
+            console.warn('Le module peut ne pas fonctionner correctement');
+        }
+        // Définir des valeurs par défaut si nécessaire
+        if (!process.env.AWS_REGION) {
+            process.env.AWS_REGION = 'us-east-1';
+        }
+        if (!process.env.S3_BUCKET) {
+            process.env.S3_BUCKET = 'edrm-storage';
+        }
+    }
+    /**
+     * Exécute les migrations nécessaires
+     */
+    async runMigrations() {
+        try {
+            await runEdrmStorageMigrations();
+        }
+        catch (error) {
+            console.error('Erreur lors des migrations EDRM Storage:', error);
+            // Ne pas faire échouer l'initialisation si les migrations échouent
+            // Les migrations peuvent être exécutées manuellement plus tard
+        }
+    }
+    /**
+     * Configure les événements du module
+     */
+    setupEvents() {
+        // Ici on peut configurer des événements globaux si nécessaire
+        // Par exemple, des listeners pour les événements de fichiers
+        console.log('Événements EDRM Storage configurés');
+    }
+    /**
+     * Retourne le routeur principal du module
+     */
+    getRouter() {
+        if (!this.isInitialized) {
+            throw new Error('Module EDRM Storage non initialisé. Appelez initialize() d\'abord.');
+        }
+        return new EdrmStorageRouter();
+    }
+    /**
+     * Retourne les informations de statut du module
+     */
+    getStatus() {
+        return {
+            initialized: this.isInitialized,
+            config: {
+                awsRegion: process.env.AWS_REGION,
+                s3Bucket: process.env.S3_BUCKET,
+                hasAwsCredentials: !!(process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY)
+            }
+        };
+    }
+    /**
+     * Nettoie les ressources du module
+     */
+    async cleanup() {
+        console.log('Nettoyage du module EDRM Storage...');
+        this.isInitialized = false;
+    }
+}
+/**
+ * Fonction utilitaire pour initialiser le module depuis l'application principale
+ */
+export async function initializeEdrmStorage() {
+    const integration = EdrmStorageIntegration.getInstance();
+    await integration.initialize();
+    return integration;
+}
+/**
+ * Fonction utilitaire pour obtenir le routeur du module
+ */
+export function getEdrmStorageRouter() {
+    const integration = EdrmStorageIntegration.getInstance();
+    return integration.getRouter();
+}

package/dist/modules/edrm-storage/interfaces/storage-provider.interface.d.ts

@@ -0,0 +1,35 @@
+import { FileProvider } from '../models/file.model.js';
+export interface UploadInitResponse {
+    uploadId: string;
+    presignedUrl: string;
+    fields?: Record<string, string>;
+    expiresAt: Date;
+    bucket: string;
+    key: string;
+}
+export interface DownloadUrlResponse {
+    url: string;
+    expiresAt: Date;
+    filename: string;
+    contentType: string;
+}
+export interface FileMetadata {
+    size: number;
+    etag: string;
+    lastModified: Date;
+    contentType: string;
+    metadata?: Record<string, string>;
+}
+export interface StorageProvider {
+    provider: FileProvider;
+    initUpload(bucket: string, key: string, contentType: string, expiresIn?: number): Promise<UploadInitResponse>;
+    getFileMetadata(bucket: string, key: string): Promise<FileMetadata>;
+    getDownloadUrl(bucket: string, key: string, filename?: string, expiresIn?: number): Promise<DownloadUrlResponse>;
+    deleteFile(bucket: string, key: string): Promise<void>;
+    copyFile(sourceBucket: string, sourceKey: string, destBucket: string, destKey: string): Promise<void>;
+    listFiles(bucket: string, prefix?: string, maxKeys?: number): Promise<{
+        key: string;
+        size: number;
+        lastModified: Date;
+    }[]>;
+}

package/dist/modules/edrm-storage/interfaces/storage-provider.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/modules/edrm-storage/migrations/edrm-storage.migration.d.ts

@@ -0,0 +1,6 @@
+import mongoose from 'mongoose';
+export declare function createFilesCollection(): Promise<void>;
+export declare function cleanupExpiredFiles(): Promise<void>;
+export declare function createFileStatistics(): Promise<mongoose.mongo.BSON.Document>;
+export declare function migrateExistingFiles(): Promise<void>;
+export declare function runEdrmStorageMigrations(): Promise<void>;