5htp-core 0.0.7 → 0.0.8-2

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "5htp-core",
 	"description": "5-HTP, scientifically called 5-Hydroxytryptophan, is the precursor of happiness neurotransmitter.",
-	"version": "0.0.7",
+	"version": "0.0.8-2",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/5htp-core.git",
 	"license": "MIT",
@@ -58,7 +58,6 @@
 		"nodemailer": "^6.6.3",
 		"path-to-regexp": "^6.2.0",
 		"picomatch": "^2.3.1",
-		"preact-render-to-string": "^5.1.19",
 		"react-scrollbars-custom": "^4.0.27",
 		"react-slider": "^2.0.1",
 		"react-textarea-autosize": "^8.3.3",
@@ -73,7 +72,9 @@
 		"uuid-by-string": "^3.0.4",
 		"validator": "^13.7.0",
 		"ws": "^8.2.2",
-		"yaml": "^1.10.2"
+		"yaml": "^1.10.2",
+        "preact": "^10.5.15",
+		"preact-render-to-string": "^5.1.19"
 	},
 	"devDependencies": {
 		"@types/cookie": "^0.4.1",

package/src/client/assets/css/components/button.less

@@ -18,7 +18,7 @@
     font-weight: 600;
 
     // Colors
-    background: #fff;
+    background: transparent;
     color: var(--cTxtBase); 
 
     &,

package/src/client/context/index.ts

@@ -202,7 +202,7 @@ export class ClientContext {
     public handleError(e: Error) {
         switch (e.http) {
             case 401:
-                this.page?.redirect('/');
+                this.page?.go('/');
                 break;
             default:
                 this.toast.error(e.title || "Uh Oh ...", e.message, null, { autohide: false });
@@ -225,12 +225,13 @@ export class ClientContext {
         }
     }
 
+    // Services
     public modal = createDialog(this, false);
     public toast = createDialog(this, true);
-
     public socket = new SocketClient(this)
     public captcha = new Recaptcha(this);
 
+    // Tracking
     public event( name: string, params?: object ) {
         if (!window.gtag) return;
         if (name === 'pageview')

package/src/client/index.tsx

@@ -33,7 +33,8 @@ declare global {
     interface Window {
         dev: boolean,
         context: ClientContext,
-        user: User
+        user: User,
+        gtag: (action: string, name: string, params?: any) => void
     }
 }
 

package/src/client/router/component.tsx

@@ -69,10 +69,10 @@ export default () => {
 
     const [pages, setPages] = React.useState<{
         current: undefined | PageResponse,
-        previous: undefined | PageResponse
+        //previous: undefined | PageResponse
     }>({
         current: gui.page,
-        previous: undefined
+        //previous: undefined
     });
     
     const resolvePage = async (request: ClientRequest, locationUpdate?: Update) => {
@@ -116,13 +116,13 @@ export default () => {
             if (oldPage !== undefined) {
                 setTimeout(() => setPages({ 
                     current: newpage,
-                    previous: undefined
+                    //previous: undefined
                 }), 500);
             }
 
             return  {
                 current: newpage,
-                previous: oldPage
+                //previous: oldPage
             }
         });
     }
@@ -175,9 +175,9 @@ export default () => {
     
     // Render the page component
     return <>
-        {pages.previous && (
+        {/*pages.previous && (
             <Page page={pages.previous} key={pages.previous.id === undefined ? undefined : 'page_' + pages.previous.id} />
-        )}
+        )*/}
 
         {pages.current && (
             <Page page={pages.current} isCurrent key={pages.current.id === undefined ? undefined : 'page_' + pages.current.id} />

package/src/server/app/index.ts

@@ -15,7 +15,7 @@ import ConfigParser, { TEnvConfig } from './config';
 ----------------------------------*/
 
 type THookName = 'ready' | 'cleanup' | 'error'
-type THook = () => void;
+type THook = () => Promise<void>;
 
 type TServiceOptions = {
     instanciate: boolean
@@ -91,6 +91,20 @@ export class App {
     ----------------------------------*/
 
     public constructor() {
+
+        // Gestion crash
+        process.on('unhandledRejection', (error: any, promise: any) => {
+
+            console.error("Unhandled promise rejection:", error);
+
+            // Send email report
+            if (this.isLoaded('console'))
+                $.console.bugReport.server(error);
+            else
+                console.error(`Unable to send bug report: console service not loaded.`);
+
+        });
+
         // Load config files
         const configParser = new ConfigParser( this.path.root );
         this.env = configParser.env();
@@ -106,21 +120,47 @@ export class App {
         console.log("Configure services with", this.config);
     }
 
-    public register( id: string, Service: TServiceClass, options: Partial<TServiceOptions> = {}) {
+    // Register a service
+    public register<TServiceName extends keyof Core.Services>( 
+        id: TServiceName, 
+        Service: TServiceClass, 
+        options: Partial<TServiceOptions> = {}
+    ) {
 
         // Pas d'export default new Service pour chaque fichier de service,
         //  dissuaded'importer ms service sn'importe où, ce qui créé des références circulaires
-        console.log(`Launching service ${id} ...`, Service);
+        console.log(`[services] Registering service ${id} ...`);
         const service = options.instanciate !== false ? new Service() : Service;
-        this.services[id] = service;
-
-        // Lorsque service.load est async, une propriété loading doit etre présente 
-        //     De façon à ce que les autres services puissent savoir quand ce service est prêt
-        if ('loading' in service) {
-            service.loading = service.load();
-            this.loading.push(service.loading);
-        } else if ('load' in service)
-            service.load();
+        this.services[id as string] = service;
+
+        if ('load' in service) {
+
+            console.log(`[services] Starting service ${id} ...`);
+
+            // Lorsque service.load est async, une propriété loading doit etre présente 
+            //     De façon à ce que les autres services puissent savoir quand ce service est prêt
+            if ('loading' in service) {
+                
+                console.log(`[services] Waiting service ${id} to be fully loaded ...`);
+                service.loading = service.load().then(() => {
+                    console.info(`[service] Service ${id} successfully started.`);
+                }).catch(e => {
+                    // Bug report via email
+                    console.error(`[service] Error while starting the ${id} service:`, e);
+                    e.message = `Start ${id} service: ` + e.message;
+                    $.console.bugReport.server(e);
+                });;
+
+                this.loading.push(service.loading);
+                
+            } else
+                service.load();
+        }
+    }
+
+    // Test if a service was registered
+    public isLoaded( id: keyof Core.Services ) {
+        return id in this.services;
     }
 
     public on( name: THookName, callback: THook ) {
@@ -128,23 +168,36 @@ export class App {
         return this;
     }
 
+    public runHook( hookName: THookName ) {
+        console.info(`[hook] Run all ${hookName} hook (${this.hooks.ready.length}).`);
+        return Promise.all( 
+            this.hooks.ready.map(
+                cb => cb().catch(e => {
+                    console.error(`[hook] Error while executing hook ${hookName}:`, e);
+                })
+            ) 
+        ).then(() => {
+            console.info(`[hook] Hooks ${hookName} executed with success.`);
+        })
+    }
+
     /*----------------------------------
     - LAUNCH
     ----------------------------------*/
     public async launch() {
 
-        console.info(`Waiting for services to be ready ...`);
+        console.info(`[boot] Waiting for all services to be ready ...`);
         await Promise.all( this.loading );
 
-        console.info(`Launching application ...`);
-        await Promise.all( this.hooks.ready.map(cb => cb()) );
+        console.info(`[boot] Launching application ...`);
+        await this.runHook('ready');
 
         // NOTE: Useless ?
         /*if (this.hmr)
             this.activateHMR();*/
 
-        console.info(`Application is ready.`);
-
+        console.info(`[boot] Application is ready.`);
+        
         this.launched = true;
 
     }

package/src/server/data/Cache.ts

@@ -2,68 +2,123 @@
 - DEPENDANCES
 ----------------------------------*/
 
+// Node
+import path from 'path';
+
 // Npm
 import hInterval from 'human-interval';
+import fs from 'fs-extra';
+
+// Core
+import app from '@server/app';
 
 // Libs
-import redis from '@server/services/redis';
-import { ErreurCritique } from '@common/errors';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+type TPrimitiveValue = string | boolean | number | undefined | {[key: string]: TPrimitiveValue} | TPrimitiveValue[];
+
+type TExpirationDelay = string | number | Date | null;
+
+type CacheEntry = { 
+    // Value
+    value: TPrimitiveValue, 
+    // Expiration Timestamp
+    expiration?: number 
+};
 
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-const Cache = {
+class Cache {
+    
+    private cacheFile = path.join(app.path.data, 'cache/mem.json');
+
+    private data: {[key: string]: CacheEntry | undefined} = {};
+
+    private changes: number = 0;
+    
+    public constructor() {
+
+        setInterval(() => this.cleanMem(), 10000);
+
+        if (fs.existsSync(this.cacheFile))
+            this.data = fs.readJSONSync(this.cacheFile)
+    }
+
+    private cleanMem() {
+
+        console.log("[cache] Clean memory");
+
+        const now = Date.now();
+        for (const key in this.data) {
+            const entry = this.data[ key ];
+            if (entry?.expiration && entry.expiration < now)
+                this.del(key);
+        }
+        
+        if (this.changes > 0)
+            fs.outputJSONSync(this.cacheFile, this.data);
+    }
 
     // Expiration = Durée de vie en secondes ou date max
     // Retourne null quand pas de valeur
-    async get<TValeur>(
+    public get<TValeur extends TPrimitiveValue>(
+        cle: string, 
+        func?: (() => Promise<TValeur>),
+        expiration?: TExpirationDelay,
+        avecDetails?: true
+    ): Promise<CacheEntry>;
+
+    public get<TValeur extends TPrimitiveValue>(
+        cle: string, 
+        func: (() => Promise<TValeur>),
+        expiration?: TExpirationDelay,
+        avecDetails?: false
+    ): Promise<null | TValeur>;
+
+    public async get<TValeur extends TPrimitiveValue>(
         cle: string, 
-        func: Function | null = null,
-        expiration: number | Date | null = null,
+        func?: (() => Promise<TValeur>),
+        expiration?: TExpirationDelay,
         avecDetails?: boolean
-    ): Promise<null | TValeur> {
+    ): Promise<null | TValeur | CacheEntry> {
+
+        let retour: CacheEntry | undefined = this.data[cle];
+
+        console.log(`[cache] Get "${cle}".`);
 
-        let retour: any = await this.getVal(cle);
+        // Expired
+        if (retour?.expiration && retour.expiration < Date.now()){
+            console.log(`[cache] Key ${cle} expired.`);
+            retour = undefined;
+        }
 
         // Donnée inexistante
-        if (retour === null && func !== null) {
+        if (retour === undefined && func !== undefined) {
 
             // Rechargement
-            retour = await func();
+            retour = {
+                value: await func(),
+                expiration: expiration 
+                    ? this.delayToTimestamp(expiration) 
+                    : undefined
+            }
 
             // undefined retourné = pas d'enregistrement
-            if (retour !== undefined)
+            if (retour.value !== undefined)
                 await this.set(cle, retour, expiration);
         }
 
-        return avecDetails 
-            ? {
-                donnees: retour
-            } 
-            : retour;
-    },
-
-    getVal<TValeur>(cle: string): Promise<TValeur | null> {
-        return new Promise((resolve) => {
-
-           redis.instance.get(cle, (err, val) => {
+        if (retour === undefined)
+            return null;
 
-                if (val === null) {
-                    resolve( null );
-                } else {
-                    try {
-                        resolve( JSON.parse(val) )
-                    } catch (error) {
-
-                        console.warn(`Error while parsing JSON value from cache (id: ${cle})`, error, 'Raw value:', val);
-                        resolve(null);
-
-                    }
-                }
-
-            });
-        });
-    },
+        return avecDetails 
+            ? retour
+            : retour.value as TValeur;
+    };
 
     /**
      * Put in cache a JSON value, associated with an unique ID.
@@ -76,49 +131,44 @@ const Cache = {
      *  - null: no expiration (default)
      * @returns A void promise
      */
-    set( cle: string, val: any, expiration: string | number | Date | null = null ): Promise<void> {
-        console.log("Updating cache " + cle);
-        return new Promise((resolve) => {
-
-            //console.info('Enregistrement de ' + cle + ' avec la valeur ', val, 'expiration', expiration);
-
-            val = JSON.stringify(val);
+    public set( cle: string, val: TPrimitiveValue, expiration: TExpirationDelay = null ): void {
+        
+        console.log("[cache] Updating cache " + cle);
+        this.data[ cle ] = {
+            value: val,
+            expiration: this.delayToTimestamp(expiration)
+        }
 
-            // Conversion de l'expiration en nombre de secondes (ttl, time to live)
-            if (expiration === null)
-               redis.instance.set(cle, val, () => {
-                    resolve()
-                });
-            else {
+        this.changes++;
+    };
 
-                let secondes: number;
+    public del( cle: string ): void {
+        this.data[ cle ] = undefined;
+        this.changes++;
+    }
 
-                // H expression
-                if (typeof expiration === 'string') {
 
-                    const ms = hInterval(expiration); 
-                    if (ms === undefined) throw new Error(`Invalid period string: ` + expiration);
-                    secondes = ms / 1000;
+    /*----------------------------------
+    - UTILS
+    ----------------------------------*/
+    private delayToTimestamp( delay: TExpirationDelay ): number {
 
-                // Via durée de vie en secondes
-                } else if (typeof expiration === 'number')
-                    secondes = expiration;
-                // Date limite
-                else
-                    secondes = (expiration.getTime() - (new Date).getTime()) / 1000;
+        // H expression
+        if (typeof delay === 'string') {
 
-                redis.instance.set(cle, val, 'EX', secondes, () => {
-                    resolve()
-                });
-            }
-        });
-    },
+            const ms = hInterval(delay); 
+            if (ms === undefined) throw new Error(`Invalid period string: ` + delay);
+            return Date.now() + ms;
 
-    del( cle: string ): Promise<void> {
-        return new Promise((resolve) => {
-           redis.instance.del(cle, () => resolve());
-        });
+        // Via durée de vie en secondes
+        } else if (typeof delay === 'number')
+            return Date.now() + delay;
+        // Date limite
+        else if (delay !== null)
+            return delay.getTime();
+        else
+            return Date.now();
     }
 }
 
-export default Cache;
+export default new Cache;

package/src/server/patch.ts

@@ -4,17 +4,6 @@ moduleAlias.addAliases({
     'react-dom': "preact/compat",
 })
 
-/*----------------------------------
-- DEBUG
-----------------------------------*/
-
-// Gestion crash
-process.on('unhandledRejection', (error: any, promise: any) => {
-
-    console.error("Unhandled promise rejection:", error);
-
-});
-
 /*----------------------------------
 - DATES & TIMZEONE
 ----------------------------------*/

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

@@ -70,7 +70,7 @@ export default class BugReporter {
     public async server( error: Error, request?: ServerRequest ) {
 
         // error should be printed in the console, so they're acccessible from logs
-        console.error(error);
+        console.error(`Sending bug report for the following error:`, error);
 
         // Prevent duplicates
         if (!this.shouldSendReport('server', request?.user?.name, undefined, error.message))
@@ -79,7 +79,6 @@ export default class BugReporter {
         // Get context
         const now = new Date();
         const hash = uuid();
-        const erroTitle = "Server Bug: " + error.message;
         const { channelType, channelId } = this.console.getChannel();
 
         // On envoi l'email avant l'insertion dans bla bdd
@@ -90,31 +89,36 @@ export default class BugReporter {
         );
 
         // Send notification
-        $.email.send({
-            to: app.identity.author.email,
-            subject: "Bug serveur: " + erroTitle,
-            html: `
-                <a href="${app.env.url}/admin/activity/requests/${channelId}">
-                    View Request details & console
-                </a>
-                <br/>
-                ${logsHtml}
-            `
-        });
-        // Memorize
-        $.sql.insert('BugServer', {
-            // Context
-            hash: hash,
-            date: now,
-            channelType, 
-            channelId,
-            // User
-            user: request?.user?.name,
-            ip: request?.ip,
-            // Error
-            stacktrace: error.stack || error.message,
-            logs: logsHtml
-        });
+        if (app.isLoaded('email'))
+            $.email.send({
+                to: app.identity.author.email,
+                subject: "Server bug: " + error.message,
+                html: `
+                    <a href="${app.env.url}/admin/activity/requests/${channelId}">
+                        View Request details & console
+                    </a>
+                    <br/>
+                    ${logsHtml}
+                `
+            });
+        else
+            console.error("Unable to send bug report: email service not loaded.");
+
+        /*if (app.isLoaded('sql'))
+            // Memorize
+            $.sql.insert('BugServer', {
+                // Context
+                hash: hash,
+                date: now,
+                channelType, 
+                channelId,
+                // User
+                user: request?.user?.name,
+                ip: request?.ip,
+                // Error
+                stacktrace: error.stack || error.message,
+                logs: logsHtml
+            });*/
 
         // Update error message
         error.message = "A bug report has been sent to my personal mailbox. Sorry for the inconvenience.";

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

@@ -256,7 +256,7 @@ export class Console {
         let html = logs.map( log => logToHTML( log, this )).join('\n');
 
         if (full) {
-            const consoleCss = `background: #000; padding: 20px; font-family: 'monospace'; font-size: 12px; line-height: 20px;`
+            const consoleCss = `background: #000; padding: 20px; font-family: 'Fira Mono', 'monospace', 'Monaco'; font-size: 12px; line-height: 20px;`
             html = '<div style="' + consoleCss + '">' + html + '</div>';
         }
 

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

@@ -49,7 +49,7 @@ export class WebSocketCommander {
     public scopes: {[path: string]: SocketScope} = {}
 
     public constructor() {
-        app.on('cleanup', () => {
+        app.on('cleanup', async () => {
             this.closeAll();
         });
     }