@programisto/edrm-storage 0.3.1

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

@@ -0,0 +1,141 @@
+import { EdrmStorageService } from '../services/edrm-storage.service.js';
+import { FileProvider } from '../models/file.model.js';
+import { validateEdrmStorageConfig } from '../config/environment.example.js';
+describe('EDRM Storage Integration Tests', () => {
+    let storageService;
+    beforeAll(async () => {
+        // Vérifier la configuration
+        const configValidation = validateEdrmStorageConfig();
+        if (!configValidation.valid) {
+            console.warn('Configuration invalide:', configValidation.errors);
+        }
+        storageService = new EdrmStorageService();
+    });
+    describe('Configuration', () => {
+        it('devrait valider la configuration d\'environnement', () => {
+            const validation = validateEdrmStorageConfig();
+            expect(validation.valid).toBeDefined();
+            expect(Array.isArray(validation.errors)).toBe(true);
+        });
+    });
+    describe('Service Initialization', () => {
+        it('devrait initialiser le service sans erreur', () => {
+            expect(storageService).toBeDefined();
+            expect(storageService).toBeInstanceOf(EdrmStorageService);
+        });
+    });
+    describe('Upload Flow', () => {
+        it('devrait initialiser un upload avec succès', async () => {
+            const testData = {
+                originalName: 'test-integration.pdf',
+                mimeType: 'application/pdf',
+                size: 1024,
+                tenantId: 'test-tenant',
+                entityName: 'test-entity',
+                entityId: 'test-id-123'
+            };
+            try {
+                const result = await storageService.initUpload(testData.originalName, testData.mimeType, testData.size, testData.tenantId, testData.entityName, testData.entityId, FileProvider.S3);
+                expect(result).toBeDefined();
+                expect(result.fileId).toBeDefined();
+                expect(result.presignedUrl).toBeDefined();
+                expect(result.bucket).toBeDefined();
+                expect(result.key).toBeDefined();
+                console.log('Upload initialisé avec succès:', {
+                    fileId: result.fileId,
+                    bucket: result.bucket,
+                    key: result.key
+                });
+            }
+            catch (error) {
+                // Si les credentials AWS ne sont pas configurés, c'est normal
+                console.log('Test d\'upload ignoré - credentials AWS non configurés');
+            }
+        }, 10000);
+        it('devrait gérer les erreurs de paramètres invalides', async () => {
+            await expect(storageService.initUpload('', // nom vide
+            'application/pdf', 1024, 'tenant', 'entity', 'id')).rejects.toThrow();
+        });
+    });
+    describe('File Management', () => {
+        it('devrait lister les fichiers', async () => {
+            try {
+                const result = await storageService.listFiles('test-tenant', 'test-entity', 'test-id', undefined, 1, 10);
+                expect(result).toBeDefined();
+                expect(result.files).toBeDefined();
+                expect(Array.isArray(result.files)).toBe(true);
+                expect(result.total).toBeDefined();
+                expect(result.page).toBe(1);
+                expect(result.totalPages).toBeDefined();
+            }
+            catch (error) {
+                console.log('Test de listing ignoré - base de données non connectée');
+            }
+        });
+        it('devrait gérer les erreurs de fichier inexistant', async () => {
+            await expect(storageService.getFileById('non-existent-id')).rejects.toThrow('Fichier non trouvé');
+        });
+    });
+    describe('Provider Management', () => {
+        it('devrait supporter le provider S3', () => {
+            // Le provider S3 devrait être disponible par défaut
+            expect(FileProvider.S3).toBe('S3');
+        });
+        it('devrait gérer les providers non supportés', async () => {
+            // Test avec un provider inexistant
+            await expect(storageService.initUpload('test.pdf', 'application/pdf', 1024, 'tenant', 'entity', 'id', 'INVALID_PROVIDER')).rejects.toThrow('Provider INVALID_PROVIDER non supporté');
+        });
+    });
+    describe('Error Handling', () => {
+        it('devrait gérer les erreurs de connexion S3', async () => {
+            // Test avec des credentials invalides
+            const originalAccessKey = process.env.AWS_ACCESS_KEY_ID;
+            const originalSecretKey = process.env.AWS_SECRET_ACCESS_KEY;
+            // Simuler des credentials invalides
+            process.env.AWS_ACCESS_KEY_ID = 'invalid';
+            process.env.AWS_SECRET_ACCESS_KEY = 'invalid';
+            try {
+                await storageService.initUpload('test.pdf', 'application/pdf', 1024, 'tenant', 'entity', 'id');
+            }
+            catch (error) {
+                expect(error).toBeDefined();
+                console.log('Erreur S3 attendue avec credentials invalides');
+            }
+            finally {
+                // Restaurer les credentials originaux
+                if (originalAccessKey)
+                    process.env.AWS_ACCESS_KEY_ID = originalAccessKey;
+                if (originalSecretKey)
+                    process.env.AWS_SECRET_ACCESS_KEY = originalSecretKey;
+            }
+        });
+    });
+    describe('Performance', () => {
+        it('devrait gérer les uploads multiples', async () => {
+            const uploads = [];
+            const testData = {
+                originalName: 'test-multiple.pdf',
+                mimeType: 'application/pdf',
+                size: 1024,
+                tenantId: 'test-tenant',
+                entityName: 'test-entity',
+                entityId: 'test-id'
+            };
+            try {
+                // Créer plusieurs uploads simultanés
+                for (let i = 0; i < 3; i++) {
+                    uploads.push(storageService.initUpload(`${testData.originalName}-${i}`, testData.mimeType, testData.size, testData.tenantId, testData.entityName, `${testData.entityId}-${i}`));
+                }
+                const results = await Promise.all(uploads);
+                expect(results).toHaveLength(3);
+                results.forEach((result, index) => {
+                    expect(result.fileId).toBeDefined();
+                    expect(result.presignedUrl).toBeDefined();
+                });
+            }
+            catch (error) {
+                console.log('Test de performance ignoré - credentials AWS non configurés');
+            }
+        }, 15000);
+    });
+});

package/package.json

@@ -0,0 +1,81 @@
+{
+  "type": "module",
+  "name": "@programisto/edrm-storage",
+  "version": "0.3.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "an api for online storage with providers like S3",
+  "main": "app.js",
+  "scripts": {
+    "start": "node ./dist/bin/www",
+    "dev": "tsc-watch --onSuccess \"node ./dist/bin/www\"",
+    "test": "jest",
+    "build": "tsc && npm run copy-files",
+    "copy-files": "copyfiles -u 1 'src/**/*.txt' dist",
+    "lint": "eslint \"**/*.{ts,tsx}\"",
+    "prepare": "husky install"
+  },
+  "dependencies": {
+    "@programisto/endurance-core": "^1.1.6",
+    "aws-sdk": "^2.1692.0",
+    "debug": "^4.3.7",
+    "fs": "^0.0.1-security",
+    "http": "^0.0.1-security",
+    "jsonwebtoken": "^9.0.2",
+    "mongoose": "^8.8.3",
+    "multer": "^1.4.5-lts.2",
+    "multer-s3": "^3.0.1",
+    "mustache": "^4.2.0",
+    "nodemailer": "^6.10.1",
+    "openai": "^4.100.0",
+    "path": "^0.12.7",
+    "to-regex-range": "^5.0.1",
+    "tsc-watch": "^6.2.1",
+    "url": "^0.11.4",
+    "uuid": "^11.0.3"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^19.8.1",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^11.0.3",
+    "@semantic-release/npm": "^12.0.1",
+    "@semantic-release/release-notes-generator": "^14.0.3",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.16.5",
+    "@typescript-eslint/eslint-plugin": "^8.26.0",
+    "@typescript-eslint/parser": "^8.26.0",
+    "commitlint": "^19.8.1",
+    "copyfiles": "^2.4.1",
+    "eslint": "^8.57.1",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-promise": "^6.6.0",
+    "husky": "^9.1.7",
+    "jest": "^30.1.2",
+    "mocha": "^11.0.1",
+    "nodemon": "^3.1.4",
+    "semantic-release": "^24.2.5",
+    "supertest": "^3.0.0",
+    "ts-jest": "^29.4.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/programisto-labs/edrm-storage.git"
+  },
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/programisto-labs/edrm-storage/issues"
+  },
+  "homepage": "https://github.com/programisto-labs/edrm-storage#readme",
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}