5htp-core 0.0.6 → 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.6",
+	"version": "0.0.8",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/5htp-core.git",
 	"license": "MIT",
@@ -37,6 +37,7 @@
 		"fast-safe-stringify": "^2.1.1",
 		"fs-extra": "^10.1.0",
 		"google-auth-library": "^7.11.0",
+		"got": "^11.8.3",
 		"handlebars": "^4.7.7",
 		"helmet": "^4.6.0",
 		"history": "^5.0.1",
@@ -57,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",
@@ -72,8 +72,10 @@
 		"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",
 		"@types/express": "^4.17.13",

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/config.ts

@@ -35,23 +35,9 @@ export type TEnvConfig = {
     profile: 'dev' | 'prod',
     level: 'silly' | 'info' | 'warn' | 'error',
 
+    localIP: string,
     domain: string,
-    protocol: 'http' | 'https',
-    url: string, // protocol + domain
-    localIP?: string
-
-    http: {
-        port: number,
-        ssl: boolean
-    },
-
-    database: {
-        host: string,
-        port: number,
-        login: string,
-        password: string,
-        list: string[]
-    },
+    url: string,
 }
 
 type AppIdentityConfig = {
@@ -101,9 +87,27 @@ export default class ConfigParser {
         return yaml.parse(rawConfig);
     }
 
-    public env() {
-        const envFile = this.appDir + '/env' + (this.envName === undefined ? '' : '.' + this.envName) + '.yaml';
-        return this.loadYaml( envFile );
+    public env(): TEnvConfig {
+        // We assume that when we run 5htp dev, we're in local
+        // Otherwise, we're in production environment (docker)
+        console.log("Using environment:", process.env.NODE_ENV);
+        return process.env.NODE_ENV === 'development' ? {
+            name: 'local',
+            profile: 'dev',
+            level: 'silly',
+        
+            localIP: '86.76.176.80',
+            domain: 'localhost:3010',
+            url: 'http://localhost:3010',
+        } : {
+            name: 'server',
+            profile: 'prod',
+            level: 'silly',
+        
+            localIP: '86.76.176.80',
+            domain: 'megacharger.io',
+            url: 'https://megacharger.io',
+        }
     }
 
     public identity() {

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/services/database/connection.ts

@@ -62,13 +62,15 @@ export default class FastDatabase {
 
         console.info(`Connecting to databases ...`);
 
+        const creds = this.config[ app.env.profile ];
+
         return await mysql.createPool({
 
             // Identification
-            host: this.config.host,
-            port: this.config.port,
-            user: this.config.login,
-            password: this.config.password,
+            host: creds.host,
+            port: creds.port,
+            user: creds.login,
+            password: creds.password,
             database: this.config.list[0],
 
             // Pool
@@ -106,7 +108,7 @@ export default class FastDatabase {
         let type = field.type;
         if (field.db) {
 
-            // A revoir, car les infos passées peuvent être des alias
+            // TODO: A revoir, car les infos passées peuvent être des alias
 
             const db = this.tables[ field.db ];
             if (db === undefined) {

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

@@ -41,11 +41,19 @@ export type TInsertQueryOptions<TData extends TObjetDonnees = TObjetDonnees> = T
 ----------------------------------*/
 
 export type DatabaseServiceConfig = {
-    host: string,
     list: string[],
-    login: string,
-    password: string,
-    port: number
+    dev: {
+        host: string,
+        port: number,
+        login: string,
+        password: string,
+    },
+    prod: {
+        host: string,
+        port: number,
+        login: string,
+        password: string,
+    }
 }
 
 declare global {

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

@@ -89,7 +89,7 @@ export default class HttpServer {
 
             this.http = http.createServer(this.express);
 
-        } else if ('ssh' in app.env) {
+        } /*else if ('ssh' in app.env) {
 
             const ssh = app.env.ssh;
 
@@ -102,7 +102,7 @@ export default class HttpServer {
                 rejectUnauthorized: false
             }, this.express);
             
-        } else
+        }*/ else
             throw new Error(`SSL was enabled, but no ssh config was specified in app.env (required to load ssl certificate files)`);
 
         // Start HTTP Server

package/tsconfig.common.json

@@ -34,9 +34,9 @@
             "@errors": ["./common/errors"],
             "@models": ["./common/models"],
 
-            "react": ["../node_modules/preact/compat"],
-            "react-dom": ["../node_modules/preact/compat"],
-            "react/jsx-runtime": ["../node_modules/preact/jsx-runtime"]
+            "react": ["preact/compat"],
+            "react-dom": ["preact/compat"],
+            "react/jsx-runtime": ["preact/jsx-runtime"]
         },
     },
     "include": ["src"]