5htp-core 0.2.1 → 0.2.2-1

package/src/common/validation/schema.ts

@@ -3,7 +3,7 @@
 ----------------------------------*/
 
 // Core
-import { Erreur, TListeErreursSaisie, InputErrorSchema } from '@common/errors';
+import { CoreError, TListeErreursSaisie, InputErrorSchema } from '@common/errors';
 
 // Specific
 import { default as Validator, EXCLUDE_VALUE } from './validator';
@@ -15,10 +15,12 @@ import { default as Validator, EXCLUDE_VALUE } from './validator';
 export type TSchemaFields = { [fieldName: string]: Schema<{}> | Validator<any> }
 
 type TOptsValider = {
-    critique?: boolean,
-    validationComplete?: boolean,
-    avecDependances?: boolean,
-    corriger?: boolean,
+    debug?: boolean,
+    throwError?: boolean,
+
+    validateAll?: boolean,
+    validateDeps?: boolean,
+    autoCorrect?: boolean,
 }
 
 export type TValidationResult<TFields extends TSchemaFields> = {
@@ -36,8 +38,6 @@ export type TValidatedData<TFields extends TSchemaFields> = {
 - CONST
 ----------------------------------*/
 
-const debug = true;
-
 const LogPrefix = '[schema][validator]';
 
 /*----------------------------------
@@ -63,14 +63,15 @@ export default class Schema<TFields extends TSchemaFields> {
     ): TValidationResult<TFields> {
     
         opts = {
-            critique: false,
-            validationComplete: false,
-            avecDependances: true,
-            corriger: false,
+            debug: false,
+            throwError: false,
+            validateAll: false,
+            validateDeps: true,
+            autoCorrect: false,
             ...opts,
         }
     
-        const clesAvalider = Object.keys(opts.validationComplete === true ? this.fields : dataToValidate);
+        const clesAvalider = Object.keys(opts.validateAll === true ? this.fields : dataToValidate);
     
         let outputSchema = output;
         for (const branche of chemin)
@@ -84,7 +85,7 @@ export default class Schema<TFields extends TSchemaFields> {
             // La donnée est répertoriée dans le schema
             const field = this.fields[champ];
             if (field === undefined) {
-                debug && console.warn(LogPrefix, '[' + champ + ']', 'Exclusion (pas présent dans le schéma)');
+                opts.debug && console.warn(LogPrefix, '[' + champ + ']', 'Exclusion (pas présent dans le schéma)');
                 continue;
             }
     
@@ -140,24 +141,24 @@ export default class Schema<TFields extends TSchemaFields> {
                 // Validation
                 try {
     
-                    const val = field.validate(valOrigine, allData, output, opts.corriger);
+                    const val = field.validate(valOrigine, allData, output, opts.autoCorrect);
     
                     // Exclusion seulement si explicitement demandé
                     // IMPORTANT: Conserver les values undefined
                     //      La présence d'un valeur undefined peut être utile, par exemple, pour indiquer qu'on souhaite supprimer une donnée
                     //      Exemple: undefinec = suppression fichier | Absende donnée = conservation fihcier actuel
                     if (val === EXCLUDE_VALUE)
-                        debug && console.log(LogPrefix, '[' + cheminA + '] Exclusion demandée');
+                        opts.debug && console.log(LogPrefix, '[' + cheminA + '] Exclusion demandée');
                     else
                         outputSchema[champ] = val;
     
-                    debug && console.log(LogPrefix, '[' + cheminA + ']', valOrigine, '=>', val);
+                    opts.debug && console.log(LogPrefix, '[' + cheminA + ']', valOrigine, '=>', val);
     
                 } catch (error) {
     
-                    debug && console.warn(LogPrefix, '[' + cheminA + ']', valOrigine, '|| Erreur:', error);
+                    opts.debug && console.warn(LogPrefix, '[' + cheminA + ']', valOrigine, '|| CoreError:', error);
     
-                    if (error instanceof Erreur) {
+                    if (error instanceof CoreError) {
     
                         // Référencement erreur
                         erreurs[cheminAstr] = [error.message]
@@ -169,11 +170,11 @@ export default class Schema<TFields extends TSchemaFields> {
             }
         }
     
-        if (nbErreurs !== 0 && opts.critique === true) {
+        if (nbErreurs !== 0 && opts.throwError === true) {
             throw new InputErrorSchema(erreurs);
         }
     
-        debug && console.log(LogPrefix, '', dataToValidate, '=>', output);
+        opts.debug && console.log(LogPrefix, '', dataToValidate, '=>', output);
     
         return { 
             values: output as TValidatedData<TFields>,

package/src/common/validation/validators.ts

@@ -12,8 +12,7 @@ import {
 
 // Core
 import { InputError } from '@common/errors';
-import File from '@common/data/file';
-import NormalizedFile from '@common/data/file';
+import FileToUpload from '@client/components/inputv3/file/FileToUpload';
 
 // Speciific
 import Validator, { TValidator } from './validator'
@@ -26,7 +25,7 @@ import Dropdown from '@client/components/dropdown.old';
 - TYPES
 ----------------------------------*/
 
-export type TFileValidator = TValidator<NormalizedFile> & {
+export type TFileValidator = TValidator<FileToUpload> & {
     type?: (keyof typeof raccourcisMime) | string[], // Raccourci, ou liste de mimetype
     taille?: number
 }
@@ -274,9 +273,7 @@ export default class SchemaValidator {
         output: TObjetDonnees
     ): File | undefined => {
 
-        console.log('VALIDER FICHIER', type, val);
-
-        if (!(val instanceof NormalizedFile))
+        if (!(val instanceof FileToUpload))
             throw new InputError(`Must be a File (${typeof val} received)`);
 
         // MIME

package/src/server/app/commands.ts

@@ -0,0 +1,149 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import yargsParser from 'yargs-parser';
+
+// Core
+import Application, { Service } from '@server/app';
+import { NotFound } from '@common/errors';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+type CommandCallback<TArgs extends any[]> = (...args: TArgs) => Promise<any>
+
+export type CommandsList = {
+    [commandName: string]: Command
+}
+
+export type Command<TArgs extends any[] = any[]> = {
+    name: string,
+    description: string,
+    run?: CommandCallback<TArgs>
+    childrens: CommandsList
+}
+
+/*----------------------------------
+- SERVICE TYPES
+----------------------------------*/
+
+const LogPrefix = `[commands]`;
+
+export type Config = {
+    debug: boolean
+}
+
+export type Hooks = {
+
+}
+
+/*----------------------------------
+- SERVICE
+----------------------------------*/
+export default class CommandsManager extends Service<Config, Hooks, Application> {
+
+    public priority = 2 as 2;
+
+    public commandsIndex: CommandsList = {}
+
+    public async register() {
+
+        
+
+    }
+
+    public async start() {
+       
+    }
+
+    /*----------------------------------
+    - DEFINITIONS
+    ----------------------------------*/
+    public command<TArgs extends any[]>( 
+        ...args: (
+            [name: string, description: string, childrens: Command[]]
+            |
+            [name: string, description: string, run: CommandCallback<TArgs>, childrens?: Command[]]
+        )
+    ): Command {
+
+        let name: string, description: string;
+        let childrens: Command[] | undefined;
+        let run: CommandCallback<TArgs> | undefined;
+
+        if (typeof args[2] === 'object')
+            ([name, description, childrens] = args)
+        else
+            ([name, description, run, childrens] = args)
+        
+        const command: Command = {
+            name,
+            description,
+            run, 
+            childrens: childrens ? this.indexFromList(childrens) : {}
+        }
+
+        return command;
+    }
+
+    private indexFromList( list: Command[] ): CommandsList {
+
+        const index: CommandsList = {}
+        for (const command of list)
+            index[ command.name ] = command;
+
+        return index;
+    }
+
+    /*----------------------------------
+    - REGISTER
+    ----------------------------------*/
+    public fromList( list: Command[] ) {
+        for (const command of list) {
+
+            if (this.commandsIndex[ command.name ] !== undefined)
+                throw new Error(`Tried to register command "${command.name}", but it already has been defined.`);
+
+            this.commandsIndex[ command.name ] = command;
+        }
+    }
+
+    /*----------------------------------
+    - RUN
+    ----------------------------------*/
+    public async run( commandString: string ) {
+
+        const { _, ...args } = yargsParser(commandString);
+
+        this.config.debug && console.log(LogPrefix, `Run command: ${commandString} | Parsed:`, { _, ...args });
+
+        let command: Command | undefined;
+        for (const commandName of _) {
+
+            const commandsList: CommandsList = command === undefined 
+                ? this.commandsIndex
+                : command.childrens;
+
+            command = commandsList[commandName];
+
+            if (command === undefined)
+                break;
+        }
+
+        if (command === undefined)
+            throw new NotFound(`Command not found.`);
+
+        if (command.run === undefined)
+            throw new NotFound(`This command isn't runnable.`);
+
+        // TODO: order correctly & validate type according to injected typescript typedefs (command.run.params)
+        const argsList = Object.values(args);
+
+        const result = await command.run(argsList);
+
+        return result;    
+    }
+}

package/src/server/app/index.ts

@@ -10,13 +10,17 @@ import fs from 'fs-extra';
 // Core
 import ConfigParser, { TEnvConfig } from './config';
 import { default as Service, AnyService } from './service';
+import CommandsManager from './commands';
+
+// Built-in
 import type { default as Router, Request as ServerRequest } from '@server/services/router';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-export { default as Service, TPriority } from './service';
+export { default as Service } from './service';
+export type { TPriority } from './service';
 
 type Config = {
 
@@ -61,6 +65,8 @@ export default abstract class Application extends Service<Config, Hooks, /* TODO
 
     public path = {
         root: process.cwd(),
+        typings: process.cwd() + '/var/typings',
+        cache: process.cwd() + '/var/cache',
         data: process.cwd() + '/var/data',
         log: process.cwd() + '/var/log',
         public: process.cwd() + '/public',
@@ -81,7 +87,7 @@ export default abstract class Application extends Service<Config, Hooks, /* TODO
     ----------------------------------*/
 
     public env: TEnvConfig;
-    public abstract identity: Config.Identity;
+    public identity: Config.Identity;
 
     public constructor() {
 
@@ -90,15 +96,14 @@ export default abstract class Application extends Service<Config, Hooks, /* TODO
 
         // Gestion crash
         process.on('unhandledRejection', (error: any, promise: any) => {
-
-            console.error("Unhandled promise rejection:", error);
+            // We don't log the error here because it's the role of the app to decidehiw to log errors
             this.runHook('error', error);
-
         });
 
         // Load config files
         const configParser = new ConfigParser( this.path.root );
         this.env = configParser.env();
+        this.identity = configParser.identity();
     }
 
     /*----------------------------------
@@ -111,6 +116,16 @@ export default abstract class Application extends Service<Config, Hooks, /* TODO
         return this[ serviceName ];
     }
 
+    /*----------------------------------
+    - COMMANDS
+    ----------------------------------*/
+
+    private commandsManager = new CommandsManager(this, { debug: true });
+
+    public command( ...args: Parameters<CommandsManager["command"]> ) {
+        return this.commandsManager.command(...args);
+    }
+
     /*----------------------------------
     - LAUNCH
     ----------------------------------*/
@@ -153,6 +168,11 @@ export default abstract class Application extends Service<Config, Hooks, /* TODO
             if (service.register)
                 service.register();
 
+            // Register commands
+            if (service.commands)
+                this.commandsManager.fromList(service.commands);
+
+            // Start service
             if (service.start) {
                 service.started = service.start();
                 await service.started;

package/src/server/app/service.ts

@@ -2,7 +2,9 @@
 - DEPENDANCES
 ----------------------------------*/
 
+// Specific
 import Application from ".";
+import type { Command } from "./commands"; 
 
 /*----------------------------------
 - TYPES: OPTIONS
@@ -40,6 +42,8 @@ export default abstract class Service<
     public priority: TPriority = 0;
     public started?: Promise<void>;
 
+    public commands?: Command[];
+
     public constructor( 
         public app: TApplication, 
         public config: TConfig,

package/src/server/services/cache/commands.ts

@@ -0,0 +1,41 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import sizeOf from 'object-sizeof';
+
+// Core
+
+// Specific
+import type CacheManager from '.';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+/*----------------------------------
+- SERVICE
+----------------------------------*/
+export default (cache: CacheManager, app = cache.app) => [
+
+   app.command('cache', 'Manage the cache service', [
+
+        app.command('list', 'List cache entries', async () => {
+
+            return Object.entries(cache.data).map(([ key, entry ]) => ({
+                key,
+                type: typeof entry?.value,
+                size: sizeOf(entry?.value),
+                expires: entry?.expiration || 'No expiration'
+            }))
+        }),
+
+        app.command('delete', 'List cache entries', async (key?: string) => {
+
+            await cache.del(key);
+
+            return true;
+        })
+   ])
+]

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

@@ -12,7 +12,8 @@ import fs from 'fs-extra';
 // Core
 import Application, { Service } from '@server/app';
 
-// Libs
+// Specific
+import registerCommands from './commands';
 
 /*----------------------------------
 - CONFIG
@@ -30,13 +31,26 @@ type TPrimitiveValue = string | boolean | number | undefined | TPrimitiveValue[]
 
 type TExpirationDelay = 'never' | string | number | Date;
 
-type CacheEntry = { 
+type CacheEntry<TValue extends TPrimitiveValue =TPrimitiveValue > = { 
     // Value
-    value: TPrimitiveValue, 
+    value: TValue, 
     // Expiration Timestamp
-    expiration?: number 
+    expiration?: number,
+    changes: number
 };
 
+type TCacheGetOrUpdateArgs<TValeur extends TPrimitiveValue> = [
+    cle: string, 
+    func: (() => Promise<TValeur>),
+    expiration?: TExpirationDelay,
+    avecDetails?: boolean
+]
+
+type TCacheGetOnlyArgs = [
+    cle: string, 
+    avecDetails: true
+]
+
 /*----------------------------------
 - TYPES
 ----------------------------------*/
@@ -53,15 +67,16 @@ export type Hooks = {
 - SERVICE
 ----------------------------------*/
 export default class Cache extends Service<Config, Hooks, Application> {
-    
-    private cacheFile = path.join(this.app.path.data, 'cache/mem.json');
 
-    private data: {[key: string]: CacheEntry | undefined} = {};
+    public commands = registerCommands(this);
+    
+    private cacheDir = this.app.path.cache;
 
-    private changes: number = 0;
+    public data: {[key: string]: CacheEntry | undefined} = {};
     
     public async register() {
 
+        
 
     }
 
@@ -70,8 +85,20 @@ export default class Cache extends Service<Config, Hooks, Application> {
         setInterval(() => this.cleanMem(), 10000);
 
         // Restore persisted data
-        if (fs.existsSync(this.cacheFile))
-            this.data = fs.readJSONSync(this.cacheFile)
+        await this.restore();
+    }
+
+    private restore() {
+        const files = fs.readdirSync( this.cacheDir );
+        for (const file of files) {
+
+            if (!file.endsWith('.json'))
+                continue;
+
+            const entryKey = file.substring(0, file.length - 5);
+            this.data[ entryKey ] = fs.readJSONSync( path.join(this.cacheDir, file) );
+            console.log(LogPrefix, `Restored cache entry ${entryKey}`);
+        }
     }
 
     private cleanMem() {
@@ -87,13 +114,29 @@ export default class Cache extends Service<Config, Hooks, Application> {
         }
         
         // Write changes
-        if (this.changes > 0) {
-            fs.outputJSONSync(this.cacheFile, this.data);
-            this.config.debug && console.log(LogPrefix, `Flush ${this.changes} changes`);
-            this.changes = 0;
+        for (const entryKey in this.data) {
+
+            const entry = this.data[entryKey];
+            if (!entry?.changes)
+                continue;
+
+            this.config.debug && console.log(LogPrefix, `Flush ${entry.changes} changes for ${entryKey}`);
+
+            entry.changes = 0;
+            const entryFile = this.getEntryFile(entryKey);
+            fs.outputJSONSync(entryFile , this.data[entryKey]);
         }
     }
 
+    private getEntryFile( entryKey: string ) {
+        return path.join(this.cacheDir, entryKey + '.json');
+    }
+
+    public get<TValeur extends TPrimitiveValue>(
+        cle: string, 
+        avecDetails?: true
+    ): Promise<CacheEntry<TValeur> | TValeur | undefined>;
+
     // Expiration = Durée de vie en secondes ou date max
     // Retourne null quand pas de valeur
     public get<TValeur extends TPrimitiveValue>(
@@ -101,7 +144,7 @@ export default class Cache extends Service<Config, Hooks, Application> {
         func: (() => Promise<TValeur>),
         expiration: TExpirationDelay,
         avecDetails: true
-    ): Promise<CacheEntry>;
+    ): Promise<CacheEntry<TValeur>>;
 
     public get<TValeur extends TPrimitiveValue>(
         cle: string, 
@@ -110,14 +153,25 @@ export default class Cache extends Service<Config, Hooks, Application> {
         avecDetails?: false
     ): Promise<TValeur>;
 
-    public async get<TValeur extends TPrimitiveValue>(
-        cle: string, 
-        func: (() => Promise<TValeur>),
-        expiration: TExpirationDelay = 'never',
-        avecDetails?: boolean
-    ): Promise<TValeur | CacheEntry> {
+    public async get<TValeur extends TPrimitiveValue, TArgs extends TCacheGetOnlyArgs | TCacheGetOrUpdateArgs<TValeur> = TCacheGetOnlyArgs | TCacheGetOrUpdateArgs<TValeur>>(
+        ...args: TArgs
+    ): Promise< TValeur | CacheEntry<TValeur> | (TArgs extends TCacheGetOnlyArgs ? undefined : TValeur)> {
+
+        let cle: string;
+        let func: (() => Promise<TValeur>) | undefined;
+        let expiration: TExpirationDelay | undefined;
+        let avecDetails: boolean | undefined = true;
 
-        let entry: CacheEntry | undefined = this.data[cle];
+        if (typeof args[1] === 'function') {
+            ([ cle, func, expiration, avecDetails ] = args);
+        } else {
+            ([ cle, avecDetails ] = args);
+        }
+
+        if (expiration === undefined)
+            expiration = 'never';
+
+        let entry: CacheEntry<TValeur> | undefined = this.data[cle];
 
         // Expired
         if (entry?.expiration && entry.expiration < Date.now()){
@@ -126,22 +180,26 @@ export default class Cache extends Service<Config, Hooks, Application> {
         }
 
         // Donnée inexistante
-        if (entry === undefined) {
+        if (entry !== undefined) {
+
+            this.config.debug && console.log(LogPrefix, `Get "${cle}": restored via cache`);
+            
+        } else if (func !== undefined) {
 
             this.config.debug && console.log(LogPrefix, `Get "${cle}": refresh value`);
 
             // Rechargement
             entry = {
                 value: await func(),
-                expiration: this.delayToTimestamp(expiration)
+                expiration: this.delayToTimestamp(expiration),
+                changes: 0
             }
 
-            // undefined retourné = pas d'enregistrement
-            //if (entry.value !== undefined)
+            if (expiration !== 'now')
                 await this.set(cle, entry.value, expiration);
 
         } else
-            this.config.debug && console.log(LogPrefix, `Get "${cle}": restored via cache`);
+            return undefined;
 
         return avecDetails 
             ? entry
@@ -160,19 +218,29 @@ export default class Cache extends Service<Config, Hooks, Application> {
      * @returns A void promise
      */
     public set( cle: string, val: TPrimitiveValue, expiration: TExpirationDelay = 'never' ): void {
-        
+
+        // TODO: check is key contains illegal characters
+    
         this.config.debug && console.log(LogPrefix, "Updating cache " + cle);
         this.data[ cle ] = {
             value: val,
-            expiration: this.delayToTimestamp(expiration)
+            expiration: this.delayToTimestamp(expiration),
+            changes: 1
         }
-
-        this.changes++;
     };
 
-    public del( cle: string ): void {
-        this.data[ cle ] = undefined;
-        this.changes++;
+    public del( key?: string ): void {
+
+        if (key === undefined) {
+            this.data = {};
+            console.log(LogPrefix, "Deleting all keys from cache");
+            fs.removeSync( this.cacheDir );
+        } else {
+            this.data[ key ] = undefined;
+            console.log(LogPrefix, `Deleting key "${key}" from cache`);
+            const entryFile = this.getEntryFile(key);
+            fs.removeSync( entryFile );
+        }
     }
 
 

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

@@ -305,7 +305,7 @@ export default class Console extends Service<Config, Hooks, Application> {
     }
 
     public printSql = (requete: string) => highlight(
-        formatSql(requete, { indent: ' '.repeat(4) }),
+        requete,//formatSql(requete, { indent: ' '.repeat(4) }),
         { language: 'sql', ignoreIllegals: true }
     )