@programisto/edrm-storage 0.3.1

package/dist/modules/edrm-storage/migrations/edrm-storage.migration.js

@@ -0,0 +1,151 @@
+// Migration pour créer la collection files du module edrm-storage
+// Ce fichier peut être exécuté pour initialiser la base de données
+import mongoose from 'mongoose';
+export async function createFilesCollection() {
+    try {
+        // Vérifier si la connexion MongoDB est établie
+        if (!mongoose.connection.db) {
+            throw new Error('Connexion MongoDB non établie');
+        }
+        // Vérifier si la collection existe déjà
+        const collections = await mongoose.connection.db.listCollections().toArray();
+        const filesCollectionExists = collections.some(col => col.name === 'files');
+        if (!filesCollectionExists) {
+            // Créer la collection avec des index optimisés
+            await mongoose.connection.db.createCollection('files');
+            // Créer les index pour optimiser les requêtes
+            await mongoose.connection.db.collection('files').createIndexes([
+                // Index sur tenantId pour l'isolation multi-tenant
+                { key: { tenantId: 1 } },
+                // Index sur entityName et entityId pour les requêtes par entité
+                { key: { entityName: 1, entityId: 1 } },
+                // Index sur status pour filtrer par statut
+                { key: { status: 1 } },
+                // Index sur provider pour filtrer par provider
+                { key: { provider: 1 } },
+                // Index sur uploadedBy pour les requêtes par utilisateur
+                { key: { uploadedBy: 1 } },
+                // Index sur createdAt pour le tri chronologique
+                { key: { createdAt: -1 } },
+                // Index sur lastAccessedAt pour les statistiques
+                { key: { lastAccessedAt: -1 } },
+                // Index composé pour les requêtes fréquentes
+                { key: { tenantId: 1, entityName: 1, entityId: 1, status: 1 } },
+                // Index sur les tags pour la recherche
+                { key: { tags: 1 } },
+                // Index sur le type de fichier
+                { key: { type: 1 } },
+                // Index sur expiresAt pour le nettoyage automatique
+                { key: { expiresAt: 1 } }
+            ]);
+            console.log('Collection "files" créée avec succès avec tous les index');
+        }
+        else {
+            console.log('Collection "files" existe déjà');
+        }
+        // Créer des index supplémentaires si nécessaire
+        if (mongoose.connection.db) {
+            await mongoose.connection.db.collection('files').createIndexes([
+                // Index textuel pour la recherche dans les métadonnées
+                {
+                    key: {
+                        originalName: 'text',
+                        description: 'text'
+                    },
+                    name: 'text_search_index'
+                }
+            ]);
+        }
+        console.log('Migration edrm-storage terminée avec succès');
+    }
+    catch (error) {
+        console.error('Erreur lors de la migration edrm-storage:', error);
+        throw error;
+    }
+}
+// Fonction pour nettoyer les fichiers expirés
+export async function cleanupExpiredFiles() {
+    try {
+        if (!mongoose.connection.db) {
+            throw new Error('Connexion MongoDB non établie');
+        }
+        const result = await mongoose.connection.db.collection('files').deleteMany({
+            expiresAt: { $lt: new Date() },
+            status: { $in: ['PENDING', 'FAILED'] }
+        });
+        console.log(`${result.deletedCount} fichiers expirés supprimés`);
+    }
+    catch (error) {
+        console.error('Erreur lors du nettoyage des fichiers expirés:', error);
+        throw error;
+    }
+}
+// Fonction pour créer des statistiques
+export async function createFileStatistics() {
+    try {
+        if (!mongoose.connection.db) {
+            throw new Error('Connexion MongoDB non établie');
+        }
+        const stats = await mongoose.connection.db.collection('files').aggregate([
+            {
+                $group: {
+                    _id: null,
+                    totalFiles: { $sum: 1 },
+                    totalSize: { $sum: '$size' },
+                    avgFileSize: { $avg: '$size' },
+                    filesByStatus: {
+                        $push: {
+                            status: '$status',
+                            count: 1
+                        }
+                    },
+                    filesByProvider: {
+                        $push: {
+                            provider: '$provider',
+                            count: 1
+                        }
+                    },
+                    filesByType: {
+                        $push: {
+                            type: '$type',
+                            count: 1
+                        }
+                    }
+                }
+            }
+        ]).toArray();
+        console.log('Statistiques des fichiers:', stats[0]);
+        return stats[0];
+    }
+    catch (error) {
+        console.error('Erreur lors de la création des statistiques:', error);
+        throw error;
+    }
+}
+// Fonction pour migrer les données existantes (si nécessaire)
+export async function migrateExistingFiles() {
+    try {
+        // Cette fonction peut être utilisée pour migrer des fichiers existants
+        // vers le nouveau système edrm-storage
+        console.log('Migration des fichiers existants terminée');
+    }
+    catch (error) {
+        console.error('Erreur lors de la migration des fichiers existants:', error);
+        throw error;
+    }
+}
+// Fonction principale pour exécuter toutes les migrations
+export async function runEdrmStorageMigrations() {
+    try {
+        console.log('Début des migrations edrm-storage...');
+        await createFilesCollection();
+        await cleanupExpiredFiles();
+        await createFileStatistics();
+        await migrateExistingFiles();
+        console.log('Toutes les migrations edrm-storage terminées avec succès');
+    }
+    catch (error) {
+        console.error('Erreur lors des migrations edrm-storage:', error);
+        throw error;
+    }
+}

package/dist/modules/edrm-storage/models/file.model.d.ts

@@ -0,0 +1,78 @@
+import { EnduranceSchema } from '@programisto/endurance-core';
+export declare enum FileStatus {
+    PENDING = "PENDING",
+    UPLOADING = "UPLOADING",
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    DELETED = "DELETED"
+}
+export declare enum FileProvider {
+    S3 = "S3",
+    MINIO = "MINIO",
+    LOCAL = "LOCAL",
+    GCS = "GCS"
+}
+export declare enum FileType {
+    DOCUMENT = "DOCUMENT",
+    IMAGE = "IMAGE",
+    VIDEO = "VIDEO",
+    AUDIO = "AUDIO",
+    ARCHIVE = "ARCHIVE",
+    OTHER = "OTHER"
+}
+export interface IFile {
+    filename: string;
+    originalName: string;
+    mimeType: string;
+    size: number;
+    provider: FileProvider;
+    bucket: string;
+    key: string;
+    url: string;
+    status: FileStatus;
+    type?: FileType;
+    metadata?: Record<string, any>;
+    tags?: string[];
+    description?: string;
+    checksum?: string;
+    etag?: string;
+    versionId?: string;
+    tenantId?: string;
+    entityName?: string;
+    entityId?: string;
+    uploadedBy?: string;
+    expiresAt?: Date;
+    lastAccessedAt?: Date;
+    accessCount?: number;
+}
+declare class File extends EnduranceSchema implements IFile {
+    filename: string;
+    originalName: string;
+    mimeType: string;
+    size: number;
+    provider: FileProvider;
+    bucket: string;
+    key: string;
+    url: string;
+    status: FileStatus;
+    type: FileType;
+    metadata: Record<string, any>;
+    tags: string[];
+    description: string;
+    checksum: string;
+    etag: string;
+    versionId: string;
+    tenantId: string;
+    entityName: string;
+    entityId: string;
+    uploadedBy: string;
+    expiresAt: Date;
+    lastAccessedAt: Date;
+    accessCount: number;
+    static getModel(): import("@typegoose/typegoose").ReturnModelType<typeof File, import("@typegoose/typegoose/lib/types").BeAnObject>;
+}
+declare const FileModel: import("@typegoose/typegoose").ReturnModelType<typeof File, import("@typegoose/typegoose/lib/types").BeAnObject>;
+export declare const FileStatusValues: FileStatus[];
+export declare const FileProviderValues: FileProvider[];
+export declare const FileTypeValues: FileType[];
+export default FileModel;

package/dist/modules/edrm-storage/models/file.model.js

@@ -0,0 +1,190 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { EnduranceSchema, EnduranceModelType } from '@programisto/endurance-core';
+// Enums pour les statuts de fichiers
+export var FileStatus;
+(function (FileStatus) {
+    FileStatus["PENDING"] = "PENDING";
+    FileStatus["UPLOADING"] = "UPLOADING";
+    FileStatus["COMPLETED"] = "COMPLETED";
+    FileStatus["FAILED"] = "FAILED";
+    FileStatus["DELETED"] = "DELETED";
+})(FileStatus || (FileStatus = {}));
+// Enums pour les providers de stockage
+export var FileProvider;
+(function (FileProvider) {
+    FileProvider["S3"] = "S3";
+    FileProvider["MINIO"] = "MINIO";
+    FileProvider["LOCAL"] = "LOCAL";
+    FileProvider["GCS"] = "GCS";
+})(FileProvider || (FileProvider = {}));
+// Enums pour les types de fichiers
+export var FileType;
+(function (FileType) {
+    FileType["DOCUMENT"] = "DOCUMENT";
+    FileType["IMAGE"] = "IMAGE";
+    FileType["VIDEO"] = "VIDEO";
+    FileType["AUDIO"] = "AUDIO";
+    FileType["ARCHIVE"] = "ARCHIVE";
+    FileType["OTHER"] = "OTHER";
+})(FileType || (FileType = {}));
+let File = class File extends EnduranceSchema {
+    filename;
+    originalName;
+    mimeType;
+    size;
+    provider;
+    bucket;
+    key;
+    url;
+    status;
+    type;
+    metadata;
+    tags;
+    description;
+    checksum;
+    etag;
+    versionId;
+    tenantId;
+    entityName;
+    entityId;
+    uploadedBy;
+    expiresAt;
+    lastAccessedAt;
+    accessCount;
+    static getModel() {
+        return FileModel;
+    }
+};
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], File.prototype, "filename", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], File.prototype, "originalName", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], File.prototype, "mimeType", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true, type: Number }),
+    __metadata("design:type", Number)
+], File.prototype, "size", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true, enum: FileProvider }),
+    __metadata("design:type", String)
+], File.prototype, "provider", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], File.prototype, "bucket", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], File.prototype, "key", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], File.prototype, "url", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true, enum: FileStatus, default: FileStatus.PENDING }),
+    __metadata("design:type", String)
+], File.prototype, "status", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false, enum: FileType }),
+    __metadata("design:type", String)
+], File.prototype, "type", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false }),
+    __metadata("design:type", Object)
+], File.prototype, "metadata", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false }),
+    __metadata("design:type", Array)
+], File.prototype, "tags", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false }),
+    __metadata("design:type", String)
+], File.prototype, "description", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false }),
+    __metadata("design:type", String)
+], File.prototype, "checksum", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false }),
+    __metadata("design:type", String)
+], File.prototype, "etag", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false }),
+    __metadata("design:type", String)
+], File.prototype, "versionId", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false }),
+    __metadata("design:type", String)
+], File.prototype, "tenantId", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false }),
+    __metadata("design:type", String)
+], File.prototype, "entityName", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false }),
+    __metadata("design:type", String)
+], File.prototype, "entityId", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false }),
+    __metadata("design:type", String)
+], File.prototype, "uploadedBy", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false }),
+    __metadata("design:type", Date)
+], File.prototype, "expiresAt", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false }),
+    __metadata("design:type", Date)
+], File.prototype, "lastAccessedAt", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false }),
+    __metadata("design:type", Number)
+], File.prototype, "accessCount", void 0);
+File = __decorate([
+    EnduranceModelType.modelOptions({
+        options: {
+            allowMixed: EnduranceModelType.Severity.ALLOW
+        }
+    })
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    ,
+    EnduranceModelType.pre('save', async function (next) {
+        try {
+            if (this.status) {
+                this.status = this.status.toUpperCase();
+            }
+            if (this.provider) {
+                this.provider = this.provider.toUpperCase();
+            }
+            if (this.type) {
+                this.type = this.type.toUpperCase();
+            }
+            next();
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            next(new Error('Erreur lors du pré-enregistrement: ' + errorMessage));
+        }
+    })
+], File);
+const FileModel = EnduranceModelType.getModelForClass(File);
+// Exports explicites pour éviter les warnings ESLint sur les enums non utilisés
+export const FileStatusValues = Object.values(FileStatus);
+export const FileProviderValues = Object.values(FileProvider);
+export const FileTypeValues = Object.values(FileType);
+export default FileModel;

package/dist/modules/edrm-storage/providers/s3-storage.provider.d.ts

@@ -0,0 +1,18 @@
+import { StorageProvider, UploadInitResponse, DownloadUrlResponse, FileMetadata } from '../interfaces/storage-provider.interface.js';
+import { FileProvider } from '../models/file.model.js';
+export declare class S3StorageProvider implements StorageProvider {
+    provider: FileProvider;
+    private client;
+    private region;
+    constructor(region: string, accessKeyId?: string, secretAccessKey?: string);
+    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/providers/s3-storage.provider.js

@@ -0,0 +1,95 @@
+import { S3Client, PutObjectCommand, GetObjectCommand, DeleteObjectCommand, HeadObjectCommand, CopyObjectCommand, ListObjectsV2Command } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { FileProvider } from '../models/file.model.js';
+export class S3StorageProvider {
+    provider = FileProvider.S3;
+    client;
+    region;
+    constructor(region, accessKeyId, secretAccessKey) {
+        this.region = region;
+        this.client = new S3Client({
+            region: this.region,
+            credentials: accessKeyId && secretAccessKey
+                ? {
+                    accessKeyId,
+                    secretAccessKey
+                }
+                : undefined
+        });
+    }
+    async initUpload(bucket, key, contentType, expiresIn = 3600) {
+        const command = new PutObjectCommand({
+            Bucket: bucket,
+            Key: key,
+            ContentType: contentType
+        });
+        const presignedUrl = await getSignedUrl(this.client, command, {
+            expiresIn
+        });
+        return {
+            uploadId: `${bucket}-${key}-${Date.now()}`,
+            presignedUrl,
+            expiresAt: new Date(Date.now() + expiresIn * 1000),
+            bucket,
+            key
+        };
+    }
+    async getFileMetadata(bucket, key) {
+        const command = new HeadObjectCommand({
+            Bucket: bucket,
+            Key: key
+        });
+        const response = await this.client.send(command);
+        return {
+            size: response.ContentLength || 0,
+            etag: response.ETag?.replace(/"/g, '') || '',
+            lastModified: response.LastModified || new Date(),
+            contentType: response.ContentType || 'application/octet-stream',
+            metadata: response.Metadata
+        };
+    }
+    async getDownloadUrl(bucket, key, filename, expiresIn = 3600) {
+        const command = new GetObjectCommand({
+            Bucket: bucket,
+            Key: key,
+            ResponseContentDisposition: filename ? `attachment; filename="${filename}"` : undefined
+        });
+        const url = await getSignedUrl(this.client, command, {
+            expiresIn
+        });
+        return {
+            url,
+            expiresAt: new Date(Date.now() + expiresIn * 1000),
+            filename: filename || key.split('/').pop() || 'file',
+            contentType: 'application/octet-stream'
+        };
+    }
+    async deleteFile(bucket, key) {
+        const command = new DeleteObjectCommand({
+            Bucket: bucket,
+            Key: key
+        });
+        await this.client.send(command);
+    }
+    async copyFile(sourceBucket, sourceKey, destBucket, destKey) {
+        const command = new CopyObjectCommand({
+            CopySource: `${sourceBucket}/${sourceKey}`,
+            Bucket: destBucket,
+            Key: destKey
+        });
+        await this.client.send(command);
+    }
+    async listFiles(bucket, prefix, maxKeys = 1000) {
+        const command = new ListObjectsV2Command({
+            Bucket: bucket,
+            Prefix: prefix,
+            MaxKeys: maxKeys
+        });
+        const response = await this.client.send(command);
+        return (response.Contents || []).map(obj => ({
+            key: obj.Key || '',
+            size: obj.Size || 0,
+            lastModified: obj.LastModified || new Date()
+        }));
+    }
+}

package/dist/modules/edrm-storage/routes/edrm-storage.router.d.ts

@@ -0,0 +1,8 @@
+import { EnduranceRouter } from '@programisto/endurance-core';
+declare class EdrmStorageRouter extends EnduranceRouter {
+    private storageService;
+    constructor();
+    setupRoutes(): void;
+}
+declare const router: EdrmStorageRouter;
+export default router;