5htp-core 0.2.9 → 0.3.0

package/src/server/services/database/stats.ts

@@ -6,9 +6,10 @@
 import hInterval from 'human-interval';
 
 // Core
+import type { Application } from '@server/app';
 import Service from '@server/app/service';
 import type CacheService from '../cache';
-import type SQL from '../database';
+import type SQL from '.';
 
 /*----------------------------------
 - CONST
@@ -76,8 +77,7 @@ export default class StatsService extends Service<TStatsServiceConfig> {
 
     }
 
-    public async register() {}
-    public async start() {}
+    protected async start() {}
 
     public async fetchStats<TDonnees extends TObjDonneesStats>(
         

package/src/server/services/disks/driver.ts

@@ -3,7 +3,8 @@
 ----------------------------------*/
 
 // Core
-import Application, { Service } from '@server/app';
+import type { Application } from '@server/app';
+import Service from '@server/app/service';
 
 /*----------------------------------
 - CONFIG
@@ -51,11 +52,7 @@ export type TReadFileOptions = {
 export default abstract class FsDriver<
     Config extends TDrivercnfig = TDrivercnfig,
     TBucketName = keyof Config["buckets"]
-> {
-
-    public constructor( public app: Application, public config: Config ) {
-
-    }
+> extends Service<Config, {}, Application> {
 
     public abstract mount(): Promise<void>;
     
@@ -73,7 +70,12 @@ export default abstract class FsDriver<
 
     public abstract move( bucketName: TBucketName, source: string, destination: string, options: { overwrite?: boolean }): Promise<void>;
 
-    public abstract outputFile( bucketName: TBucketName, filename: string, content: string, encoding: TOutputFileOptions ): Promise<{
+    public abstract outputFile( 
+        bucketName: TBucketName, 
+        filename: string, 
+        content: string | Buffer, 
+        options?: TOutputFileOptions 
+    ): Promise<{
         path: string
     }>;
 

package/src/server/services/disks/drivers/local/index.ts

@@ -0,0 +1,199 @@
+/*----------------------------------
+- DEPS
+----------------------------------*/
+/*
+    A simple adapter to use fs-extra functions with AWS S3 buckets
+*/
+
+// Node
+import path from 'path';
+import dayjs from 'dayjs';
+
+// Npm
+import fs from 'fs-extra';
+
+// Core
+import AppContainer from '@server/app/container';
+
+// Specific
+import DiskDriver, { TDrivercnfig, SourceFile, TOutputFileOptions } from '../../driver';
+
+/*----------------------------------
+- CONFIG
+----------------------------------*/
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+export type TConfig = TDrivercnfig & {
+
+}
+
+/*----------------------------------
+- SERVICE
+----------------------------------*/
+export default class LocalFS<
+    Config extends TConfig = TConfig,
+    TBucketName = keyof Config["buckets"]
+> extends DiskDriver<TConfig> {
+
+    public rootDir = AppContainer.path.var;
+
+    /*----------------------------------
+    - SERVICE LIFECYCLE
+    ----------------------------------*/
+
+    public async start() {
+        
+    }
+
+    public async ready() {
+
+    }
+
+    public async shutdown() {
+
+    }
+
+	/*----------------------------------
+    - DISK LIFECYCLE
+    ----------------------------------*/
+
+    public async mount() {
+
+    }
+
+    public async unmount() {
+
+    }
+
+    /*----------------------------------
+    - ACTIONS
+    ----------------------------------*/
+
+    public async readDir( bucketName: TBucketName, dirname?: string ) {
+
+        const bucketDir = this.config.buckets[bucketName];
+        
+        const fullPath = path.join( this.rootDir, bucketDir, dirname || '.' );
+
+        // Combine the files list of all source directory
+        const files: SourceFile[] = [];
+        const sources = fs.readdirSync( fullPath, { withFileTypes: true });
+        for (const source of sources) {
+
+            if (!source.isDirectory())
+                continue;
+
+            const parentFolder = source.name;
+            const csvFiles = fs.readdirSync( 
+                path.join( fullPath, parentFolder ), 
+                { withFileTypes: true }
+            );
+
+            for (const file of csvFiles) {
+
+                if (!file.isFile() || !file.name.endsWith('.csv'))
+                    continue;
+
+                const relPath = path.join( source.name, file.name );
+                const fullpath = path.join( fullPath, relPath );
+                const stats = fs.statSync(fullpath);
+
+                const rowsCount = fs.readFileSync( fullpath, 'utf-8').split('\n').length - 1;
+
+                const name = dayjs(stats.mtime).format('DD/MM HH:mm:ss') 
+                    + ' : ' + path.join( source.name, file.name )
+                    + ' : ' + rowsCount + ' contacts'
+
+                files.push({
+                    name,
+                    path: relPath,
+                    parentFolder,
+                    source: source.name,
+                    modified: stats.mtimeMs
+                });
+
+            }
+        }
+        
+        this.config.debug && console.log(`readDir ${fullPath}: ${files.length} objects`);
+        return files;
+    }
+
+    public async readFile( bucketName: TBucketName, filename: string ) {
+        
+        const bucketDir = this.config.buckets[bucketName];
+        const fullPath = path.join( this.rootDir, bucketDir, filename );
+
+        this.config.debug && console.log(`readFile ${fullPath}`);
+        return fs.readFileSync( fullPath ).toString();
+    }
+
+    public createReadStream( bucketName: TBucketName, filename: string ) {
+        
+        const bucketDir = this.config.buckets[bucketName];
+        const fullPath = path.join( this.rootDir, bucketDir, filename );
+
+        this.config.debug && console.log(`createReadStream ${fullPath}`);
+        return fs.createReadStream( fullPath );
+    }
+
+    public async exists( bucketName: TBucketName, filename: string ) {
+        
+        const bucketDir = this.config.buckets[bucketName];
+        const fullPath = path.join( this.rootDir, bucketDir, filename );
+
+        this.config.debug && console.log(`exists ${fullPath}`);
+        return fs.existsSync( fullPath );
+    }
+
+    public async move( bucketName: TBucketName, source: string, destination: string, options: { overwrite?: boolean } = {}) {
+        
+        const bucketDir = this.config.buckets[bucketName];
+        const fullPathSource = path.join( this.rootDir, bucketDir, source );
+        const fullPathDestination = path.join( this.rootDir, bucketDir, destination );
+
+        this.config.debug && console.log(`move ${fullPathSource} to ${fullPathDestination}`);
+        return fs.moveSync(fullPathSource, fullPathDestination, options);
+    }
+
+    public async outputFile( 
+        bucketName: TBucketName, 
+        filename: string, 
+        content: string | Buffer, 
+        options?: TOutputFileOptions 
+    ) {
+
+        const bucketDir = this.config.buckets[bucketName];
+        const fullPath = path.join( this.rootDir, bucketDir, filename );
+        this.config.debug && console.log(`outputFile`, fullPath);
+
+        fs.outputFileSync( fullPath, content, options );
+
+        return {
+            path: fullPath
+        }
+    }
+
+    public async readJSON( bucketName: TBucketName, filename: string ) {
+        
+        const bucketDir = this.config.buckets[bucketName];
+        const fullPath = path.join( this.rootDir, bucketDir, filename );
+
+        this.config.debug && console.log(`readJSON ${fullPath}`);
+        return fs.readJsonSync( fullPath );
+    }
+
+    public async delete( bucketName: TBucketName, filename: string ) {
+        
+        const bucketDir = this.config.buckets[bucketName];
+        const fullPath = path.join( this.rootDir, bucketDir, filename );
+
+        this.config.debug && console.log(`delete ${fullPath}`);
+        fs.removeSync( fullPath );
+        return true;
+    }
+
+}

package/src/server/services/disks/drivers/local/service.json

@@ -0,0 +1,6 @@
+{
+    "id": "Core/Disks/Local",
+    "name": "LocalDiskDriver",
+    "parent": "disks",
+    "dependences": []
+}

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

@@ -0,0 +1,282 @@
+/*----------------------------------
+- DEPS
+----------------------------------*/
+/*
+    A simple adapter to use fs-extra functions with AWS S3 buckets
+*/
+
+// Node
+import path from 'path';
+
+// Npm
+import AWS from 'aws-sdk';
+import dayjs from 'dayjs';
+
+// Core
+import type { Application } from '@server/app';
+import type { AnyService, TRegisteredServicesIndex } from '@server/app/service';
+
+// Specific
+import DiskDriver, { 
+    TDrivercnfig, 
+    SourceFile, 
+    TOutputFileOptions,
+    TReadFileOptions 
+} from '@server/services/disks/driver';
+
+/*----------------------------------
+- CONFIG
+----------------------------------*/
+
+const debug = false;
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+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; 
+
+    public constructor( 
+        public parent: AnyService, 
+        public config: TConfig,
+        public services: TRegisteredServicesIndex,
+        public app: Application
+    ) {
+
+        super( parent, config, services, app );
+
+        AWS.config.update({
+            accessKeyId: this.config.accessKeyId,
+            secretAccessKey: this.config.secretAccessKey,
+        });
+
+        this.s3 = new AWS.S3(); 
+    }
+
+    /*----------------------------------
+    - SERVICE LIFECYCLE
+    ----------------------------------*/
+
+    public async start() {
+        
+    }
+
+    public async ready() {
+
+    }
+
+    public async shutdown() {
+
+    }
+
+	/*----------------------------------
+    - DISK LIFECYCLE
+    ----------------------------------*/
+
+    public async mount() {
+       
+    }
+
+    public async unmount() {
+       
+    }
+
+    /*----------------------------------
+    - ACTIONS
+    ----------------------------------*/
+
+    public readDir( bucketName: TBucketName, dirname?: string ) {
+        const bucket = this.config.buckets[bucketName];
+        return new Promise<SourceFile[]>((resolve, reject) => {
+           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) {
+                    
+                    const [source, ...hierarchy] = file.Key.split('/');
+                    if (hierarchy.length > 1) // Take only direct childs
+                        continue;
+
+                    const filename = hierarchy.join('/');
+                    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 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
+                    });
+
+                }
+                
+                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];
+        debug && console.log(`readFile ${bucket}/${filename}`);
+        return new Promise<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()
+                        break;
+                    default:
+                        body = data.Body;
+                        break;
+                }
+
+                resolve( body );
+            });
+        })
+    }
+
+    public createReadStream( bucketName: TBucketName, filename: string ) {
+        const bucket = this.config.buckets[bucketName];
+        debug && console.log(`createReadStream ${bucket}/${filename}`);
+        return this.s3.getObject({ 
+            Bucket: bucket,  
+            Key: filename
+        }).createReadStream();
+    }
+
+    public exists( bucketName: TBucketName, filename: string ) {
+        const bucket = this.config.buckets[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);
+            });
+        })
+    }
+
+    public async move( bucketName: TBucketName, source: string, destination: string, options: { overwrite?: boolean } = {}) {
+        const bucket = this.config.buckets[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();
+
+        debug && console.log(`Move ${bucket}/${source} to ${bucket}/${destination}: OK`);
+
+    }
+
+    public outputFile( 
+        bucketName: TBucketName, 
+        filename: string, 
+        content: string | Buffer, 
+        options?: TOutputFileOptions 
+    ) {
+        const bucket = this.config.buckets[bucketName];
+        debug && console.log(`outputFile ${bucket}/${filename}`);
+        return new Promise(( resolve, reject ) => {
+            this.s3.upload({
+                Bucket: bucket,
+                Key: filename,
+                Body: content,
+                ACL: 'public-read'
+            }, (err, data) => {
+
+                if (err) return reject(err);
+                debug && console.log(`outputFile ${bucket}/${filename}: OK (${data.Location})`);
+
+                resolve({
+                    path: data.Location
+                });
+            });
+        })
+    }
+
+    public async readJSON( bucketName: TBucketName, filename: string ) {
+        const bucket = this.config.buckets[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);
+        } 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];
+        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);
+            });
+        })
+    }
+
+}

package/src/server/services/disks/drivers/s3/service.json

@@ -0,0 +1,6 @@
+{
+    "id": "Core/Disks/S3",
+    "name": "S3DiskDriver",
+    "parent": "disks",
+    "dependences": []
+}

package/src/server/services/disks/index.ts

@@ -3,61 +3,92 @@
 ----------------------------------*/
 
 // Core
-import Application, { Service } from '@server/app';
+import type { Application } from '@server/app';
+import Service, { AnyService } from '@server/app/service';
+import type { TRegisteredServicesIndex } from '@server/app/service/container';
 
 // Specific
 import type Driver from './driver';
+export type { default as Driver } from './driver';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-type TMountpointList = { [name: string]: Driver }
-
-type Config<MountpointList extends TMountpointList> = {
-    default: keyof MountpointList,
+type Config = {
+    debug: boolean,
+    default: string,//keyof MountpointList,
 }
 
 export type Hooks = {
 
 }
 
+type TMountpointList = { [name: string]: Driver }
+
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
 export default class DisksManager<
     MountpointList extends TMountpointList = {},
-    TConfig extends Config<MountpointList> = Config<MountpointList>,
+    TConfig extends Config = Config,
     TApplication extends Application = Application
 > extends Service<TConfig, Hooks, TApplication> {
 
     public default: Driver;
 
+    public mounted: TMountpointList = this.services;
+
     public constructor( 
-        public app: TApplication, 
-        public config: TConfig,
-        public mounted:  MountpointList
+        parent: AnyService, 
+        config: TConfig,
+        drivers: TRegisteredServicesIndex< Driver >,
+        app: TApplication, 
     ) {
 
-        super(app, config);
+        super(parent, config, drivers, app);
+
+        if (Object.keys( drivers ).length === 0)
+            throw new Error("At least one disk driver should be mounted.");
+
+    }
+
+    /*----------------------------------
+    - LIFECYCLE
+    ----------------------------------*/
 
-        if (Object.keys( mounted ).length === 0)
-            throw new Error("At least one disk should be mounted.");
+    public async start() {
 
-        const defaultDisk = mounted[ config.default ];
+        const defaultDisk = this.mounted[ this.config.default ];
         if (defaultDisk === undefined)
-            console.log(`Default disk "${config.default as string}" not mounted.`);
+            console.log(`Default disk "${this.config.default as string}" not mounted.`);
 
         this.default = defaultDisk;
+        
+    }
+
+    public async ready() {
 
     }
 
-    public async register() {
+    public async shutdown() {
 
     }
 
-    public async start() {
+    /*----------------------------------
+    - LIFECYCLE
+    ----------------------------------*/
+
+    public get( diskName?: 'default' | keyof MountpointList ): Driver {
+
+        const disk = diskName == 'default' || diskName === undefined
+            ? this.default 
+            : this.mounted[diskName];
+
+        if (disk === undefined)
+            throw new Error(`Disk "${diskName as string}" not found.`);
 
+        return disk;
     }
 
 }

package/src/server/services/disks/service.json

@@ -0,0 +1,6 @@
+{
+    "id": "Core/Disks",
+    "name": "Disks",
+    "parent": "app",
+    "dependences": []
+}