proteum 1.0.2 → 2.0.0-1

package/server/services/disks/drivers/s3/index.ts

@@ -12,17 +12,14 @@ import path from 'path';
 import AWS from 'aws-sdk';
 import dayjs from 'dayjs';
 
-// Core
-import type { Application } from '@server/app';
-import type { TServiceArgs } from '@server/app/service';
-
 // Specific
-import DiskDriver, { 
-    TDrivercnfig, 
-    SourceFile, 
+import DiskDriver, {
+    TDrivercnfig,
+    SourceFile,
     TOutputFileOptions,
-    TReadFileOptions 
+    TReadFileOptions,
 } from '@server/services/disks/driver';
+import type { TSetupConfig } from '@server/app/service';
 
 /*----------------------------------
 - CONFIG
@@ -34,268 +31,224 @@ const debug = false;
 - TYPES
 ----------------------------------*/
 
-export type TConfig = TDrivercnfig & {
-    accessKeyId: string, 
-    secretAccessKey: string, 
-    region: string,
-}
+export type TConfig = TDrivercnfig & { accessKeyId: string; secretAccessKey: string; region: string };
 
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
 export default class S3Driver<
     Config extends TConfig = TConfig,
-    TBucketName = keyof Config["buckets"]
-> extends DiskDriver<TConfig> {
-
-    public s3: AWS.S3; 
+    TBucketName extends Extract<keyof Config['buckets'], string> = Extract<keyof Config['buckets'], string>,
+> extends DiskDriver<Config, TBucketName> {
+    public s3: AWS.S3;
 
-    public constructor( config: TConfig, app: Application ) {
+    private getBucketName(bucketName: TBucketName) {
+        const bucket = this.config.buckets[bucketName];
+        if (bucket === undefined) throw new Error(`Bucket "${bucketName}" not found in configuration`);
+        return bucket;
+    }
 
+    public constructor(config: TSetupConfig<Config>, app: DiskDriver<Config, TBucketName>['app']) {
         super(config, app);
 
-        AWS.config.update({
-            accessKeyId: this.config.accessKeyId,
-            secretAccessKey: this.config.secretAccessKey,
-        });
+        AWS.config.update({ accessKeyId: this.config.accessKeyId, secretAccessKey: this.config.secretAccessKey });
 
-        this.s3 = new AWS.S3(); 
+        this.s3 = new AWS.S3();
     }
 
-	/*----------------------------------
+    /*----------------------------------
     - DISK LIFECYCLE
     ----------------------------------*/
 
-    public async mount() {
-       
-    }
+    public async mount() {}
 
-    public async unmount() {
-       
-    }
+    public async unmount() {}
 
     /*----------------------------------
     - ACTIONS
     ----------------------------------*/
 
-    public getFileUrl(
-        bucketName: TBucketName, 
-        filename: string
-    ) {
-
-        const bucket = this.config.buckets[bucketName];
-        if (bucket === undefined)
-            throw new Error(`Bucket "${bucketName}" not found in configuration`);
-        return `https://${bucket}.s3.${this.config.region}.amazonaws.com/${filename}`
+    public getFileUrl(bucketName: TBucketName, filename: string) {
+        const bucket = this.getBucketName(bucketName);
+        return `https://${bucket}.s3.${this.config.region}.amazonaws.com/${filename}`;
     }
 
-    public readDir( bucketName: TBucketName, dirname?: string ) {
-        const bucket = this.config.buckets[bucketName];
+    public readDir(bucketName: TBucketName, dirname?: string) {
+        const bucket = this.getBucketName(bucketName);
         return new Promise<SourceFile[]>((resolve, reject) => {
-           debug && console.log(`readDir ` + (dirname === undefined ? bucket : path.join( bucket, dirname )));
+            debug && console.log(`readDir ` + (dirname === undefined ? bucket : path.join(bucket, dirname)));
             this.s3.listObjectsV2({ Bucket: bucket }, async (err, data) => {
-
                 if (err) return reject(err);
 
                 const files: SourceFile[] = [];
-                for (const file of data.Contents) {
-                    
+                for (const file of data.Contents || []) {
+                    if (!file.Key) continue;
+
                     const [source, ...hierarchy] = file.Key.split('/');
-                    if (hierarchy.length > 1) // Take only direct childs
+                    if (hierarchy.length > 1)
+                        // Take only direct childs
                         continue;
 
                     const filename = hierarchy.join('/');
-                    if (!filename.endsWith('.csv'))
-                        continue;
+                    if (!filename.endsWith('.csv')) continue;
 
                     debug && console.log('-', file.Key);
 
-                    const fileContent = await this.readFile( bucketName, file.Key );
-                    const rowsCount = (fileContent as unknown as string).split('\n').length - 1;
+                    const fileContent = await this.readFile(bucketName, file.Key, { encoding: 'string' });
+                    const rowsCount = String(fileContent).split('\n').length - 1;
 
-                    const name = dayjs(file.LastModified).format('DD/MM HH:mm:ss') 
-                        + ' : ' + path.join( source, filename )
-                        + ' : ' + rowsCount + ' contacts'
+                    const name =
+                        dayjs(file.LastModified).format('DD/MM HH:mm:ss') +
+                        ' : ' +
+                        path.join(source, filename) +
+                        ' : ' +
+                        rowsCount +
+                        ' contacts';
 
                     files.push({
                         name,
                         path: file.Key,
                         source: source,
-                        modified: file.LastModified,
-                        parentFolder: source
+                        modified: file.LastModified?.getTime() || 0,
+                        parentFolder: source,
                     });
-
                 }
-                
+
                 debug && console.log(`readDir ${bucket}/${dirname || ''}: ${files.length} objects`);
                 resolve(files);
             });
         });
     }
 
-    public readFile( 
-        bucketName: TBucketName, 
-        filename: string,
-        options: TReadFileOptions = {}
-    ) {
-        const bucket = this.config.buckets[bucketName];
+    public readFile(bucketName: TBucketName, filename: string, options: TReadFileOptions = {}) {
+        const bucket = this.getBucketName(bucketName);
         debug && console.log(`readFile ${bucket}/${filename}`);
-        return new Promise<string>(( resolve, reject ) => {
-            this.s3.getObject({ 
-                Bucket: bucket,  
-                Key: filename
-            }, (err, data) => {
-
+        return new Promise<Buffer | string>((resolve, reject) => {
+            this.s3.getObject({ Bucket: bucket, Key: filename }, (err, data) => {
                 if (err) return reject(err);
 
                 let body: any;
                 switch (options.encoding) {
                     case 'string':
-                        body = data.Body?.toString()
+                        body = data.Body?.toString();
                         break;
                     default:
                         body = data.Body;
                         break;
                 }
 
-                resolve( body );
+                resolve(body);
             });
-        })
+        });
     }
 
-    public createReadStream( bucketName: TBucketName, filename: string ) {
-        const bucket = this.config.buckets[bucketName];
+    public createReadStream(bucketName: TBucketName, filename: string) {
+        const bucket = this.getBucketName(bucketName);
         debug && console.log(`createReadStream ${bucket}/${filename}`);
-        return this.s3.getObject({ 
-            Bucket: bucket,  
-            Key: filename
-        }).createReadStream();
+        return this.s3.getObject({ Bucket: bucket, Key: filename }).createReadStream();
     }
 
-    public exists( bucketName: TBucketName, filename: string ) {
-        const bucket = this.config.buckets[bucketName];
+    public exists(bucketName: TBucketName, filename: string) {
+        const bucket = this.getBucketName(bucketName);
         debug && console.log(`exists`, path.join(bucket, filename));
-        return new Promise<boolean>(( resolve, reject ) => {
-            this.s3.headObject({ 
-                Bucket: bucket,  
-                Key: filename
-            }, (err, metadata) => {
-
-                if (!err)
-                    resolve(true); 
-                else if (err.name === 'NotFound')
-                    resolve(false);
-                else
-                    reject(err);
+        return new Promise<boolean>((resolve, reject) => {
+            this.s3.headObject({ Bucket: bucket, Key: filename }, (err, metadata) => {
+                if (!err) resolve(true);
+                else if (err.name === 'NotFound') resolve(false);
+                else reject(err);
             });
-        })
+        });
     }
 
-    public async move( bucketName: TBucketName, source: string, destination: string, options: { overwrite?: boolean } = {}) {
-        const bucket = this.config.buckets[bucketName];
+    public async move(
+        bucketName: TBucketName,
+        source: string,
+        destination: string,
+        options: { overwrite?: boolean } = {},
+    ) {
+        const bucket = this.getBucketName(bucketName);
         debug && console.log(`move ${bucket}/${source} to ${bucket}/${destination}`);
 
-        if (options.overwrite)
-            await this.s3.deleteObject({
-                Bucket: bucket,
-                Key: destination,
-            }).promise();
-            
-        await this.s3.copyObject({
-            Bucket: bucket,  
-            CopySource: source,
-            Key: destination
-        }).promise();
+        if (options.overwrite) await this.s3.deleteObject({ Bucket: bucket, Key: destination }).promise();
 
-        debug && console.log(`Move ${bucket}/${source} to ${bucket}/${destination}: OK`);
+        await this.s3.copyObject({ Bucket: bucket, CopySource: source, Key: destination }).promise();
 
+        debug && console.log(`Move ${bucket}/${source} to ${bucket}/${destination}: OK`);
     }
 
-    public outputFile( 
-        bucketName: TBucketName, 
-        filename: string, 
-        content: string | Buffer, 
-        options?: TOutputFileOptions 
+    public outputFile(
+        bucketName: TBucketName,
+        filename: string,
+        content: string | Buffer,
+        options?: TOutputFileOptions,
     ) {
-        const bucket = this.config.buckets[bucketName];
+        const bucket = this.getBucketName(bucketName);
         debug && console.log(`outputFile ${bucket}/${filename}`);
-        return new Promise(( resolve, reject ) => {
-            this.s3.upload({
-                Bucket: bucket,
-                Key: filename,
-                Body: content,
-            }, (err, data) => {
-
-                if (err) return reject(err);
-                debug && console.log(`outputFile ${bucket}/${filename}: OK (${data.Location})`);
-
-                resolve({
-                    path: data.Location
-                });
-            });
-        })
+        return new Promise<{ path: string }>((resolve, reject) => {
+            this.s3.upload(
+                { Bucket: bucket, Key: filename, Body: content },
+                (err: Error | null, data: AWS.S3.ManagedUpload.SendData) => {
+                    if (err) return reject(err);
+                    debug && console.log(`outputFile ${bucket}/${filename}: OK (${data.Location})`);
+
+                    resolve({ path: data.Location || `s3://${bucket}/${filename}` });
+                },
+            );
+        });
     }
 
-    public async readJSON( bucketName: TBucketName, filename: string ) {
-        const bucket = this.config.buckets[bucketName];
+    public async readJSON(bucketName: TBucketName, filename: string) {
+        const bucket = this.getBucketName(bucketName);
         debug && console.log(`readJSON ${bucket}/${filename}`);
         const filecontent = await this.readFile(bucketName, filename);
         try {
             debug && console.log(`readJSON: ${bucket}/${filename} : PARSE JSON`);
-            return JSON.parse(filecontent);
+            return JSON.parse(String(filecontent));
         } catch (error) {
             console.error(`Failed to parse file "${filename}" as JSON: `, error);
             throw new Error(`Failed to parse file "${filename}" as JSON: ` + error);
         }
     }
 
-    public delete( bucketName: TBucketName, filename: string ) {
-        const bucket = this.config.buckets[bucketName];
+    public delete(bucketName: TBucketName, filename: string) {
+        const bucket = this.getBucketName(bucketName);
         debug && console.log(`delete ${bucket}/${filename}`);
-        return new Promise<boolean>(( resolve, reject ) => {
-            this.s3.deleteObject({ 
-                Bucket: bucket,  
-                Key: filename
-            }, (err, metadata) => {
-
-                if (!err)
-                    resolve(true); 
-                else if (err.name === 'NotFound')
-                    resolve(false);
-                else
-                    reject(err);
+        return new Promise<boolean>((resolve, reject) => {
+            this.s3.deleteObject({ Bucket: bucket, Key: filename }, (err, metadata) => {
+                if (!err) resolve(true);
+                else if (err.name === 'NotFound') resolve(false);
+                else reject(err);
             });
-        })
+        });
     }
 
-    public async deleteDir( bucketName: TBucketName, directoryPath: string ) {
-        const bucket = this.config.buckets[bucketName];
+    public async deleteDir(bucketName: TBucketName, directoryPath: string) {
+        const bucket = this.getBucketName(bucketName);
         debug && console.log(`delete ${bucket}/${directoryPath}`);
         try {
             // Liste des objets dans le répertoire
-            const listedObjects = await this.s3.listObjectsV2({
-                Bucket: bucket,
-                Prefix: directoryPath
-            }).promise();
+            const listedObjects = await this.s3.listObjectsV2({ Bucket: bucket, Prefix: directoryPath }).promise();
 
-            if (!listedObjects.Contents?.length) return;
+            if (!listedObjects.Contents?.length) return false;
 
             // Supprimer les objets
-            await this.s3.deleteObjects({
-                Bucket: bucket,
-                Delete: {
-                    Objects: listedObjects.Contents.map(({ Key }) => ({ Key }))
-                }
-            }).promise();
+            await this.s3
+                .deleteObjects({
+                    Bucket: bucket,
+                    Delete: {
+                        Objects: listedObjects.Contents.flatMap(({ Key }) => (Key ? [{ Key }] : [])),
+                    },
+                })
+                .promise();
 
             // Récursivement, traiter d'autres pages d'objets si elles existent
             //if (listedObjects.IsTruncated) await deleteDirectory();
 
             console.log(`Le répertoire ${directoryPath} a été supprimé.`);
-            
+            return true;
         } catch (error) {
-            console.error("Erreur lors de la suppression :", error);
+            console.error('Erreur lors de la suppression :', error);
+            throw error;
         }
     }
-
-}
+}

package/server/services/disks/index.ts

@@ -3,7 +3,7 @@
 ----------------------------------*/
 
 // Core
-import type { Application } from '@server/app';
+import type { Application } from '@server/app/index';
 import Service, { AnyService, TRegisteredServicesIndex, TServiceArgs } from '@server/app/service';
 
 // Specific
@@ -15,76 +15,61 @@ export type { default as Driver } from './driver';
 ----------------------------------*/
 
 type Config = {
-    debug: boolean,
-    default: string,//keyof MountpointList,
-    drivers: {
-        [driverId: string]: Driver
-    }
-}
+    debug: boolean;
+    default: string; //keyof MountpointList,
+    drivers: { [driverId: string]: Driver };
+};
 
-export type Hooks = {
+export type Hooks = {};
 
-}
-
-export type Services = {
-    [diskId: string]: Driver
-}
+export type Services = { [diskId: string]: Driver };
 
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
 export default class DisksManager<
     MountpointList extends Services,
-    TConfig extends Config,
-    TApplication extends Application
+    TConfig extends Config & { default: keyof MountpointList & string; drivers: MountpointList },
+    TApplication extends Application,
 > extends Service<TConfig, Hooks, TApplication, TApplication> {
-
-    public default!: Driver;
+    public default!: MountpointList[keyof MountpointList & string];
 
     /*----------------------------------
     - LIFECYCLE
     ----------------------------------*/
 
-    public constructor( ...args: TServiceArgs<DisksManager<MountpointList, TConfig, TApplication>>) {
-
+    public constructor(...args: TServiceArgs<DisksManager<MountpointList, TConfig, TApplication>>) {
         super(...args);
 
         const drivers = this.config.drivers;
-        
-        if (Object.keys( drivers ).length === 0)
-            throw new Error("At least one disk driver should be mounted.");
+
+        if (Object.keys(drivers).length === 0) throw new Error('At least one disk driver should be mounted.');
 
         // Bind current instance of the service as parent
         /*for (const driverId in drivers) {
             drivers[driverId].parent = this;
         }*/
 
-        const defaultDisk = drivers[ this.config.default ];
-        if (defaultDisk === undefined)
-            console.log(`Default disk "${this.config.default as string}" not mounted.`);
+        const defaultDisk = drivers[this.config.default];
+        if (defaultDisk === undefined) console.log(`Default disk "${this.config.default as string}" not mounted.`);
 
         this.default = defaultDisk;
-
     }
 
-    public async shutdown() {
-
-    }
+    public async shutdown() {}
 
     /*----------------------------------
     - LIFECYCLE
     ----------------------------------*/
 
-    public get( diskName?: 'default' | keyof MountpointList ): Driver {
+    public get(diskName?: 'default' | keyof MountpointList) {
+        const disk =
+            diskName === 'default' || diskName === undefined
+                ? this.default
+                : this.config.drivers[diskName as keyof MountpointList];
 
-        const disk = diskName == 'default' || diskName === undefined
-            ? this.default 
-            : this.config.drivers[diskName];
-
-        if (disk === undefined)
-            throw new Error(`Disk "${diskName as string}" not found.`);
+        if (disk === undefined) throw new Error(`Disk "${diskName as string}" not found.`);
 
         return disk;
     }
-
-}
+}