5htp-core 0.0.7 → 0.0.8

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",
 	"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/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;