proteum 1.0.2 → 2.0.0-1

package/server/services/cron/index.ts

@@ -3,7 +3,7 @@
 ----------------------------------*/
 
 // Core
-import type { Application } from '@server/app';
+import type { Application } from '@server/app/index';
 import Service from '@server/app/service';
 import { NotFound } from '@common/errors';
 import context from '@server/context';
@@ -20,25 +20,18 @@ export { default as CronTask } from './CronTask';
 - SERVICE CONFIG
 ----------------------------------*/
 
-export type Config = {
-   debug?: boolean
-}
-
-export type Hooks = {
-
-}
+export type Config = { debug?: boolean };
 
-export type Services = {
+export type Hooks = {};
 
-}
+export type Services = {};
 
 /*----------------------------------
 - CLASSE
 ----------------------------------*/
 
 export default class CronManager extends Service<Config, Hooks, Application, Application> {
-
-    public static taches: { [nom: string]: CronTask } = {}
+    public static taches: { [nom: string]: CronTask } = {};
     public static timer: NodeJS.Timeout;
 
     /*----------------------------------
@@ -46,15 +39,10 @@ export default class CronManager extends Service<Config, Hooks, Application, App
     ----------------------------------*/
 
     public async ready() {
-
         clearInterval(CronManager.timer);
         CronManager.timer = setInterval(() => {
-
-            for (const id in CronManager.taches)
-                CronManager.taches[id].run();
-
+            for (const id in CronManager.taches) CronManager.taches[id].run();
         }, 10000);
-  
     }
 
     /*----------------------------------
@@ -67,46 +55,36 @@ export default class CronManager extends Service<Config, Hooks, Application, App
      * @param frequence When to execute this task.
      *  - Date: The date at which to execute this task (one time execution)
      *  - string: Cron expression to define the interval for executing this task
-     * @param run Function to run 
+     * @param run Function to run
      * @param autoexec true to execute the task immediatly
      * @returns The CronTask that just have been created
      */
     public task(nom: string, frequence: TFrequence, run: TRunner, autoexec?: boolean) {
         return new Promise<CronTask>((resolve, reject) => {
             context.run({ channelType: 'cron', channelId: nom }, async () => {
-
                 CronManager.taches[nom] = new CronTask(this, nom, frequence, run, autoexec);
 
-                if (autoexec)
-                    await CronManager.taches[nom].run(true);
+                if (autoexec) await CronManager.taches[nom].run(true);
 
-                resolve( CronManager.taches[nom] );
-
-            })
+                resolve(CronManager.taches[nom]);
+            });
         });
-
     }
 
     public async exec(nom: string) {
-
         const tache = CronManager.taches[nom];
 
-        if (tache === undefined)
-            throw new NotFound("Tâche NotFound: " + nom);
+        if (tache === undefined) throw new NotFound('Tâche NotFound: ' + nom);
 
         await tache.run(true);
-
     }
     public get(): typeof CronManager.taches;
     public get(name: string): CronTask;
     public get(name?: string): CronTask | typeof CronManager.taches {
-
-        if (name === undefined)
-            return CronManager.taches;
+        if (name === undefined) return CronManager.taches;
 
         const cron = CronManager.taches[name];
-        if (cron === undefined)
-            throw new Error(`L'instance de la tâche cron ${name} n'a pas été trouvée`);
+        if (cron === undefined) throw new Error(`L'instance de la tâche cron ${name} n'a pas été trouvée`);
         return cron;
     }
-}
+}

package/server/services/disks/driver.ts

@@ -3,51 +3,35 @@
 ----------------------------------*/
 
 // Core
-import type { Application } from '@server/app';
-import Service from '@server/app/service';
+import type { Application } from '@server/app/index';
+import Service, { TSetupConfig } from '@server/app/service';
 
 /*----------------------------------
 - CONFIG
 ----------------------------------*/
 
-export type THooks = {
+export type THooks = {};
 
-}
-
-export type Services = {
-
-}
+export type Services = {};
 
 /*----------------------------------
 - TYPE
 ----------------------------------*/
 
 export type TDrivercnfig = {
+    debug: boolean;
 
-    debug: boolean,
+    rootDir: string;
+    buckets: { [id: string]: string };
+};
 
-    rootDir: string,
-    buckets: {
-        [id: string]: string
-    }
-}
+export type SourceFile = { name: string; path: string; modified: number; parentFolder: string; source: string };
 
-export type SourceFile = { 
-    name: string, 
-    path: string, 
-    modified: number, 
-    parentFolder: string,
-    source: string 
-}
+export type TOutputFileOptions = { encoding: string };
 
-export type TOutputFileOptions = {
-    encoding: string
-}
+export type TReadFileOptions = { encoding?: 'string' | 'buffer'; withMetas?: boolean };
 
-export type TReadFileOptions = {
-    encoding?: 'string'|'buffer',
-    withMetas?: boolean
-}
+type TBucketNameFromConfig<TConfig extends TDrivercnfig> = Extract<keyof TConfig['buckets'], string>;
 
 /*----------------------------------
 - CLASS
@@ -55,49 +39,47 @@ export type TReadFileOptions = {
 
 export default abstract class FsDriver<
     Config extends TDrivercnfig = TDrivercnfig,
-    TBucketName = keyof Config["buckets"]
+    TBucketName extends TBucketNameFromConfig<Config> = TBucketNameFromConfig<Config>,
 > extends Service<Config, {}, Application, Application> {
-
-    public constructor( config: Config, app: Application ) {
+    public constructor(config: TSetupConfig<Config>, app: Application) {
         super(app, config, app);
     }
 
     public abstract mount(): Promise<void>;
 
-    public abstract getFileUrl(
-        bucketName: TBucketName, 
-        filename: string
-    ): string;
-    
-    public abstract readDir( bucketName: TBucketName, dirname?: string ): Promise<SourceFile[]>;
+    public abstract getFileUrl(bucketName: TBucketName, filename: string): string;
 
-    public abstract readFile( 
-        bucketName: TBucketName, 
-        filename: string, 
-        options: TReadFileOptions
-    ): Promise<Buffer>;
+    public abstract readDir(bucketName: TBucketName, dirname?: string): Promise<SourceFile[]>;
 
-    public abstract createReadStream( bucketName: TBucketName, filename: string );
+    public abstract readFile(
+        bucketName: TBucketName,
+        filename: string,
+        options?: TReadFileOptions,
+    ): Promise<Buffer | string>;
 
-    public abstract exists( bucketName: TBucketName, filename: string ): Promise<boolean>;
+    public abstract createReadStream(bucketName: TBucketName, filename: string): unknown;
 
-    public abstract move( bucketName: TBucketName, source: string, destination: string, options: { overwrite?: boolean }): Promise<void>;
+    public abstract exists(bucketName: TBucketName, filename: string): Promise<boolean>;
 
-    public abstract outputFile( 
-        bucketName: TBucketName, 
-        filename: string, 
-        content: string | Buffer, 
-        options?: TOutputFileOptions 
-    ): Promise<{
-        path: string
-    }>;
+    public abstract move(
+        bucketName: TBucketName,
+        source: string,
+        destination: string,
+        options: { overwrite?: boolean },
+    ): Promise<void>;
 
-    public abstract readJSON( bucketName: TBucketName, filename: string ): Promise<any>;
+    public abstract outputFile(
+        bucketName: TBucketName,
+        filename: string,
+        content: string | Buffer,
+        options?: TOutputFileOptions,
+    ): Promise<{ path: string }>;
 
-    public abstract delete( bucketName: TBucketName, filename: string ): Promise<boolean>;
+    public abstract readJSON(bucketName: TBucketName, filename: string): Promise<any>;
 
-    public abstract deleteDir( bucketName: TBucketName, dirname: string ): Promise<boolean>;
+    public abstract delete(bucketName: TBucketName, filename: string): Promise<boolean>;
 
-    public abstract unmount(): Promise<void>;
+    public abstract deleteDir(bucketName: TBucketName, dirname: string): Promise<boolean>;
 
-}
+    public abstract unmount(): Promise<void>;
+}

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

@@ -16,7 +16,7 @@ import fs from 'fs-extra';
 import AppContainer from '@server/app/container';
 
 // Specific
-import DiskDriver, { TDrivercnfig, SourceFile, TOutputFileOptions } from '../../driver';
+import DiskDriver, { TDrivercnfig, SourceFile, TOutputFileOptions, TReadFileOptions } from '../../driver';
 
 /*----------------------------------
 - CONFIG
@@ -26,163 +26,152 @@ import DiskDriver, { TDrivercnfig, SourceFile, TOutputFileOptions } from '../../
 - TYPES
 ----------------------------------*/
 
-export type TConfig = TDrivercnfig & {
-
-}
+export type TConfig = TDrivercnfig & {};
 
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
 export default class LocalFS<
     Config extends TConfig = TConfig,
-    TBucketName = keyof Config["buckets"]
-> extends DiskDriver<TConfig> {
-
+    TBucketName extends Extract<keyof Config['buckets'], string> = Extract<keyof Config['buckets'], string>,
+> extends DiskDriver<Config, TBucketName> {
     public rootDir = AppContainer.path.var;
 
-    public async mount() {
-
+    private getBucketDir(bucketName: TBucketName) {
+        const bucketDir = this.config.buckets[bucketName];
+        if (bucketDir === undefined) throw new Error(`Bucket "${bucketName}" not found in configuration`);
+        return bucketDir;
     }
 
-    public async unmount() {
+    public async mount() {}
 
-    }
+    public async unmount() {}
 
     /*----------------------------------
     - ACTIONS
     ----------------------------------*/
 
-    public getFileUrl(
-        bucketName: TBucketName, 
-        filename: string
-    ) {
-        const bucketDir = this.config.buckets[bucketName];
-        const fullPath = path.join( this.rootDir, bucketDir, filename || '.' );
+    public getFileUrl(bucketName: TBucketName, filename: string) {
+        const bucketDir = this.getBucketDir(bucketName);
+        const fullPath = path.join(this.rootDir, bucketDir, filename || '.');
         return fullPath;
     }
 
-    public async readDir( bucketName: TBucketName, dirname?: string ) {
+    public async readDir(bucketName: TBucketName, dirname?: string) {
+        const bucketDir = this.getBucketDir(bucketName);
 
-        const bucketDir = this.config.buckets[bucketName];
-        
-        const fullPath = path.join( this.rootDir, bucketDir, dirname || '.' );
+        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 });
+        const sources = fs.readdirSync(fullPath, { withFileTypes: true });
         for (const source of sources) {
-
-            if (!source.isDirectory())
-                continue;
+            if (!source.isDirectory()) continue;
 
             const parentFolder = source.name;
-            const csvFiles = fs.readdirSync( 
-                path.join( fullPath, parentFolder ), 
-                { withFileTypes: true }
-            );
+            const csvFiles = fs.readdirSync(path.join(fullPath, parentFolder), { withFileTypes: true });
 
             for (const file of csvFiles) {
+                if (!file.isFile() || !file.name.endsWith('.csv')) continue;
 
-                if (!file.isFile() || !file.name.endsWith('.csv'))
-                    continue;
-
-                const relPath = path.join( source.name, file.name );
-                const fullpath = path.join( fullPath, relPath );
+                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 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
-                });
+                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 );
+    public async readFile(bucketName: TBucketName, filename: string, options: TReadFileOptions = {}) {
+        const bucketDir = this.getBucketDir(bucketName);
+        const fullPath = path.join(this.rootDir, bucketDir, filename);
 
         this.config.debug && console.log(`readFile ${fullPath}`);
-        return fs.readFileSync( fullPath );
+        return options.encoding === 'string' ? fs.readFileSync(fullPath, 'utf8') : fs.readFileSync(fullPath);
     }
 
-    public createReadStream( bucketName: TBucketName, filename: string ) {
-        
-        const bucketDir = this.config.buckets[bucketName];
-        const fullPath = path.join( this.rootDir, bucketDir, filename );
+    public createReadStream(bucketName: TBucketName, filename: string) {
+        const bucketDir = this.getBucketDir(bucketName);
+        const fullPath = path.join(this.rootDir, bucketDir, filename);
 
         this.config.debug && console.log(`createReadStream ${fullPath}`);
-        return fs.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 );
+    public async exists(bucketName: TBucketName, filename: string) {
+        const bucketDir = this.getBucketDir(bucketName);
+        const fullPath = path.join(this.rootDir, bucketDir, filename);
 
         this.config.debug && console.log(`exists ${fullPath}`);
-        return fs.existsSync( 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 );
+    public async move(
+        bucketName: TBucketName,
+        source: string,
+        destination: string,
+        options: { overwrite?: boolean } = {},
+    ) {
+        const bucketDir = this.getBucketDir(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 
+    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 );
+        const bucketDir = this.getBucketDir(bucketName);
+        const fullPath = path.join(this.rootDir, bucketDir, filename);
         this.config.debug && console.log(`outputFile`, fullPath);
 
-        fs.outputFileSync( fullPath, content, options );
+        fs.outputFileSync(fullPath, content, options);
 
-        return {
-            path: fullPath
-        }
+        return { path: fullPath };
     }
 
-    public async readJSON( bucketName: TBucketName, filename: string ) {
-        
-        const bucketDir = this.config.buckets[bucketName];
-        const fullPath = path.join( this.rootDir, bucketDir, filename );
+    public async readJSON(bucketName: TBucketName, filename: string) {
+        const bucketDir = this.getBucketDir(bucketName);
+        const fullPath = path.join(this.rootDir, bucketDir, filename);
 
         this.config.debug && console.log(`readJSON ${fullPath}`);
-        return fs.readJsonSync( 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 );
+    public async delete(bucketName: TBucketName, filename: string) {
+        const bucketDir = this.getBucketDir(bucketName);
+        const fullPath = path.join(this.rootDir, bucketDir, filename);
 
         this.config.debug && console.log(`delete ${fullPath}`);
-        fs.removeSync( fullPath );
+        fs.removeSync(fullPath);
         return true;
     }
 
-}
+    public async deleteDir(bucketName: TBucketName, dirname: string) {
+        const bucketDir = this.getBucketDir(bucketName);
+        const fullPath = path.join(this.rootDir, bucketDir, dirname);
+
+        this.config.debug && console.log(`deleteDir ${fullPath}`);
+        fs.removeSync(fullPath);
+        return true;
+    }
+}