5htp-core 0.1.2 → 0.2.1

package/src/server/app/service.ts

@@ -0,0 +1,98 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+import Application from ".";
+
+/*----------------------------------
+- TYPES: OPTIONS
+----------------------------------*/
+
+export type AnyService = Service<{}, {}, Application>
+
+type THookCallback<THookArgs extends THookOptions> = (...args: THookArgs["args"]) => Promise<void>;
+
+type THooksList = {
+    [hookName: string]: THookOptions
+}
+
+type THookOptions = {
+    args: any[]
+}
+
+export type TPriority = -2 | -1 | 0 | 1 | 2
+
+/*----------------------------------
+- CONFIG
+----------------------------------*/
+
+const LogPrefix = '[service]';
+
+/*----------------------------------
+- CLASS
+----------------------------------*/
+export default abstract class Service<
+    TConfig extends {}, 
+    THooks extends THooksList,
+    TApplication extends Application
+> {
+
+    public priority: TPriority = 0;
+    public started?: Promise<void>;
+
+    public constructor( 
+        public app: TApplication, 
+        public config: TConfig,
+    ) {
+
+        if (!( this instanceof Application ))
+            // Make the app aware of his services
+            app.registerService(this);
+        
+    }
+
+    public abstract register?(): Promise<void>;
+
+    public abstract start?(): Promise<void>;
+
+    /*----------------------------------
+    - HOOKS
+    ----------------------------------*/
+    public hooks: {[name in keyof THooks]?: THookCallback< THooks[name] >[]} = {}
+
+    public on<THookName extends keyof THooksList>( 
+        name: THookName, 
+        callback: THookCallback<THooksList[THookName]> 
+    ) {
+
+        const callbacks = this.hooks[ name ];
+        if (callbacks)
+            callbacks.push( callback );
+        else
+            this.hooks[ name ] = [callback]
+
+        return this;
+    }
+
+    public runHook<THookName extends keyof THooksList>( 
+        name: THookName, 
+        ...args: THooksList[THookName]["args"]
+    ) {
+
+        const callbacks = this.hooks[name];
+        if (!callbacks)
+            return console.info(LogPrefix, `No ${name} hook defined in the current service instance.`);
+
+        console.info(`[hook] Run all ${name} hook (${callbacks.length}).`);
+        return Promise.all( 
+            callbacks.map(
+                cb => cb(...args).catch(e => {
+                    console.error(`[hook] Error while executing hook ${name}:`, e);
+                })
+            ) 
+        ).then(() => {
+            console.info(`[hook] Hooks ${name} executed with success.`);
+        })
+    }
+
+}

package/src/server/app.tsconfig.json

@@ -5,18 +5,10 @@
         "baseUrl": "..",
         "paths": {
 
-            // RAPPEL: Mettre à jour webpack externals
-
             "@client/*": ["../node_modules/5htp-core/src/client/*"],
             "@common/*": ["../node_modules/5htp-core/src/common/*"],
             "@server/*": ["../node_modules/5htp-core/src/server/*"],
 
-            "@validator": ["../node_modules/5htp-core/src/server/data/input"],
-            "@router": ["../node_modules/5htp-core/src/server/services/router"],
-            "@errors": ["../node_modules/5htp-core/src/common/errors"],
-
-            "@models": ["../server/models"],
-
             "@/*": ["./*"],
 
             // ATTENTION: Les références à preact doivent toujours pointer vers la même instance

package/src/server/index.ts

@@ -0,0 +1,5 @@
+import Application from '@/server';
+
+const app = new Application();
+
+app.start();

package/src/server/patch.ts

@@ -1,9 +1,3 @@
-const moduleAlias = require('module-alias')
-moduleAlias.addAliases({
-    'react': "preact/compat",
-    'react-dom': "preact/compat",
-})
-
 /*----------------------------------
 - DATES & TIMZEONE
 ----------------------------------*/

package/src/server/{data/Cache.ts → services/cache/index.ts}

@@ -10,7 +10,7 @@ import hInterval from 'human-interval';
 import fs from 'fs-extra';
 
 // Core
-import app from '@server/app';
+import Application, { Service } from '@server/app';
 
 // Libs
 
@@ -18,15 +18,17 @@ import app from '@server/app';
 - CONFIG
 ----------------------------------*/
 
-const debug = false;
+const LogPrefix = '[cache]';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-type TPrimitiveValue = string | boolean | number | undefined | {[key: string]: TPrimitiveValue} | TPrimitiveValue[];
+type TPrimitiveValue = string | boolean | number | undefined | TPrimitiveValue[] | {
+    [key: string]: TPrimitiveValue
+}
 
-type TExpirationDelay = string | number | Date | null;
+type TExpirationDelay = 'never' | string | number | Date;
 
 type CacheEntry = { 
     // Value
@@ -35,47 +37,70 @@ type CacheEntry = {
     expiration?: number 
 };
 
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+export type Config = {
+    debug: boolean
+}
+
+export type Hooks = {
+
+}
+
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-class Cache {
+export default class Cache extends Service<Config, Hooks, Application> {
     
-    private cacheFile = path.join(app.path.data, 'cache/mem.json');
+    private cacheFile = path.join(this.app.path.data, 'cache/mem.json');
 
     private data: {[key: string]: CacheEntry | undefined} = {};
 
     private changes: number = 0;
     
-    public constructor() {
+    public async register() {
+
+
+    }
+
+    public async start() {
 
         setInterval(() => this.cleanMem(), 10000);
 
+        // Restore persisted data
         if (fs.existsSync(this.cacheFile))
             this.data = fs.readJSONSync(this.cacheFile)
     }
 
     private cleanMem() {
 
-        debug && console.log("[cache] Clean memory");
-
+        // Remove expired data
         const now = Date.now();
         for (const key in this.data) {
             const entry = this.data[ key ];
-            if (entry?.expiration && entry.expiration < now)
+            if (entry?.expiration && entry.expiration < now) {
+                this.config.debug && console.log(LogPrefix, `Delete expired data: ${key}`);
                 this.del(key);
+            }
         }
         
-        if (this.changes > 0)
+        // 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;
+        }
     }
 
     // Expiration = Durée de vie en secondes ou date max
     // Retourne null quand pas de valeur
     public get<TValeur extends TPrimitiveValue>(
         cle: string, 
-        func?: (() => Promise<TValeur>),
-        expiration?: TExpirationDelay,
-        avecDetails?: true
+        func: (() => Promise<TValeur>),
+        expiration: TExpirationDelay,
+        avecDetails: true
     ): Promise<CacheEntry>;
 
     public get<TValeur extends TPrimitiveValue>(
@@ -83,47 +108,44 @@ class Cache {
         func: (() => Promise<TValeur>),
         expiration?: TExpirationDelay,
         avecDetails?: false
-    ): Promise<null | TValeur>;
+    ): Promise<TValeur>;
 
     public async get<TValeur extends TPrimitiveValue>(
         cle: string, 
-        func?: (() => Promise<TValeur>),
-        expiration?: TExpirationDelay,
+        func: (() => Promise<TValeur>),
+        expiration: TExpirationDelay = 'never',
         avecDetails?: boolean
-    ): Promise<null | TValeur | CacheEntry> {
+    ): Promise<TValeur | CacheEntry> {
 
-        let retour: CacheEntry | undefined = this.data[cle];
-
-        debug && console.log(`[cache] Get "${cle}".`);
+        let entry: CacheEntry | undefined = this.data[cle];
 
         // Expired
-        if (retour?.expiration && retour.expiration < Date.now()){
-            debug && console.log(`[cache] Key ${cle} expired.`);
-            retour = undefined;
+        if (entry?.expiration && entry.expiration < Date.now()){
+            this.config.debug && console.log(LogPrefix, `Key ${cle} expired.`);
+            entry = undefined;
         }
 
         // Donnée inexistante
-        if (retour === undefined && func !== undefined) {
+        if (entry === undefined) {
+
+            this.config.debug && console.log(LogPrefix, `Get "${cle}": refresh value`);
 
             // Rechargement
-            retour = {
+            entry = {
                 value: await func(),
-                expiration: expiration 
-                    ? this.delayToTimestamp(expiration) 
-                    : undefined
+                expiration: this.delayToTimestamp(expiration)
             }
 
             // undefined retourné = pas d'enregistrement
-            if (retour.value !== undefined)
-                await this.set(cle, retour, expiration);
-        }
+            //if (entry.value !== undefined)
+                await this.set(cle, entry.value, expiration);
 
-        if (retour === undefined)
-            return null;
+        } else
+            this.config.debug && console.log(LogPrefix, `Get "${cle}": restored via cache`);
 
         return avecDetails 
-            ? retour
-            : retour.value as TValeur;
+            ? entry
+            : entry.value as TValeur;
     };
 
     /**
@@ -137,9 +159,9 @@ class Cache {
      *  - null: no expiration (default)
      * @returns A void promise
      */
-    public set( cle: string, val: TPrimitiveValue, expiration: TExpirationDelay = null ): void {
+    public set( cle: string, val: TPrimitiveValue, expiration: TExpirationDelay = 'never' ): void {
         
-        debug && console.log("[cache] Updating cache " + cle);
+        this.config.debug && console.log(LogPrefix, "Updating cache " + cle);
         this.data[ cle ] = {
             value: val,
             expiration: this.delayToTimestamp(expiration)
@@ -157,24 +179,34 @@ class Cache {
     /*----------------------------------
     - UTILS
     ----------------------------------*/
-    private delayToTimestamp( delay: TExpirationDelay ): number {
+    /**
+     * 
+     * @param delay 
+     * @returns number (timestamp when the data expired) or undefined (never expires)
+     */
+    private delayToTimestamp( delay: TExpirationDelay ): number | undefined {
+
+        if (delay === 'now') {
+
+            return Date.now();
+
+        } else if (delay === 'never') {
+
+            return undefined;
 
         // H expression
-        if (typeof delay === 'string') {
+        } else if (typeof delay === 'string') {
 
             const ms = hInterval(delay); 
             if (ms === undefined) throw new Error(`Invalid period string: ` + delay);
             return Date.now() + ms;
 
-        // Via durée de vie en secondes
+        // Lifetime in seconds
         } else if (typeof delay === 'number')
             return Date.now() + delay;
-        // Date limite
-        else if (delay !== null)
-            return delay.getTime();
+
+        // Date limit
         else
-            return Date.now();
+            return delay.getTime();
     }
 }
-
-export default new Cache;

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

@@ -6,8 +6,8 @@
 import { v4 as uuid } from 'uuid';
 
 // Core
-import app, { $ } from '@server/app';
-import type { Console } from '.';
+import { SqlError } from '@server/services/database/debug';
+import type Console from '.';
 
 // Types
 import type ServerRequest from '@server/services/router/request';
@@ -72,8 +72,6 @@ export type ApplicationBug = {
     stacktrace: string
 }
 
-const config = app.config.console;
-
 /*----------------------------------
 - CONFIG
 ----------------------------------*/
@@ -110,7 +108,8 @@ export default class BugReporter {
     private sentBugs: {[bugId: string]: number} = {};
 
     public constructor(
-        private console: Console
+        private console: Console,
+        public app = console.app,
     ) {
 
     }
@@ -133,7 +132,16 @@ export default class BugReporter {
 
     public async server( error: Error, request?: ServerRequest ) {
 
-        // error should be printed in the console, so they're acccessible from logs
+        // Print the error so it's accessible via logs
+        if (error instanceof SqlError)  {
+            let printedQuery: string;
+            try {
+                printedQuery = this.console.printSql( error.query );
+            } catch (error) {
+                printedQuery = 'Failed to print query:' + (error || 'unknown error');
+            }
+            console.error(`Error caused by this query:`, printedQuery);
+        }
         console.error(LogPrefix, `Sending bug report for the following error:`, error);
 
         // Prevent duplicates
@@ -172,6 +180,7 @@ export default class BugReporter {
 
         await this.sendToTransporters(bugReport);
 
+        // TODO: Move on App side
         /*if (app.isLoaded('sql'))
             // Memorize
             $.sql.insert('BugServer', {
@@ -192,7 +201,7 @@ export default class BugReporter {
         error.message = "A bug report has been sent to my personal mailbox. Sorry for the inconvenience.";
     }
 
-    public async app( report: AppBugInfos ) {
+    public async application( report: AppBugInfos ) {
 
         // Prevent duplicates
         if (!this.shouldSendReport(report.side, report.user, report.action, report.message))
@@ -224,17 +233,12 @@ export default class BugReporter {
             stacktrace: report.stacktrace,
         }
 
-        await this.sendToTransporters(bugReport);
-
-        /* // Send notification
-        $.email.send({
-            to: app.identity.author.email,
-            subject: "Bug app: " + report.message,
-            html: report
-        });
 
+        // TODO: 
         // Memorize
-        $.sql.insert('BugApp', );*/
+        //$.sql.insert('BugApp', );
+
+        await this.sendToTransporters(bugReport);
     }
 
     private async sendToTransporters( bugReport: Bug, error?: Error ) {
@@ -245,6 +249,12 @@ export default class BugReporter {
             return false;
         }
 
+        // Don't send if we're in local (avoid to use credits: ex: email, sms)
+        if (this.app.env.name === 'local'){
+            console.warn(LogPrefix, `Error report sending aborted since we're local.`);
+            return false;
+        }
+
         // Send report to trabporters
         await Promise.all( 
             this.transporters.map( transport => {

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

@@ -8,30 +8,31 @@ import { format as formatSql } from 'sql-formatter';
 import highlight from 'cli-highlight';
 
 // Core libs
-import app, { $ } from '@server/app';
-import logToHTML from './html';
+import Application, { Service, TPriority } from '@server/app';
 import context from '@server/context';
+import type ServerRequest from '@server/services/router/request';
+
+// Specific
+import logToHTML from './html';
 import BugReporter from "./bugReporter";
 
 /*----------------------------------
 - SERVICE CONFIG
 ----------------------------------*/
 
-export type TReportTransport = keyof typeof $
+type TLogProfile = 'silly' | 'info' | 'warn' | 'error'
 
-export type ConsoleConfig = {
-    bugReport: TReportTransport[]
+export type Config = {
+    dev: {
+        level: TLogProfile,
+    },
+    prod: {
+        level: TLogProfile
+    }
 }
 
-declare global {
-    namespace Core {
-        interface EmailTransporters { }
-        namespace Config {
-            interface Services {
-                console: ConsoleConfig
-            }
-        }
-    }
+export type Hooks = {
+
 }
 
 /*----------------------------------
@@ -103,7 +104,10 @@ const logFields = [
 /*----------------------------------
 - LOGGER
 ----------------------------------*/
-export class Console {
+export default class Console extends Service<Config, Hooks, Application> {
+
+    // Load before all
+    public priority: TPriority = 2;
 
     // Services
     public logger!: Logger;
@@ -115,34 +119,50 @@ export class Console {
     public requests: TRequestLogs[] = [];
     public sqlQueries: TQueryLogs[] = [];
 
+    // Adapters
+    public log = console.log;
+    public warn = console.warn;
+    public info = console.info;
+    public error = console.error;
+
     /*----------------------------------
-   - INSTANCE
-   ----------------------------------*/
-    public load() {
+    - INSTANCE
+    ----------------------------------*/
+    public async register() {
+
+    }
+
+    public async start() {
+
+        const envConfig = this.config[ this.app.env.profile ];
 
         this.logger = new Logger({
             overwriteConsole: true,
-            //type: app.env.profile === 'dev' ? 'pretty' : 'hidden',
+            //type: this.app.env.profile === 'dev' ? 'pretty' : 'hidden',
             requestId: (): string => {
                 const { channelType, channelId } = this.getChannel();
                 return channelId === undefined ? channelType : channelType + ':' + channelId;
             },
             displayRequestId: false,
+            prettyInspectOptions: {
+                depth: 2
+            }
         });
 
         this.logger.attachTransport({
-            silly: this.log.bind(this),
-            debug: this.log.bind(this),
-            trace: this.log.bind(this),
-            info: this.log.bind(this),
-            warn: this.log.bind(this),
-            error: this.log.bind(this),
-            fatal: this.log.bind(this),
-        }, app.env.level);
+            silly: this.logEntry.bind(this),
+            debug: this.logEntry.bind(this),
+            trace: this.logEntry.bind(this),
+            info: this.logEntry.bind(this),
+            warn: this.logEntry.bind(this),
+            error: this.logEntry.bind(this),
+            fatal: this.logEntry.bind(this),
+        }, envConfig.level);
 
         setInterval(() => this.clean(), 60000);
 
-        return this.logger;
+        // Send email report
+        this.app.on('error', (error: Error, request?: ServerRequest) => this.bugReport.server(error, request));
     }
 
     private clean() {
@@ -160,7 +180,7 @@ export class Console {
         }
     }
 
-    private log(entry: ILogObject) {
+    private logEntry(entry: ILogObject) {
 
         const [channelType, channelId] = entry.requestId?.split(':') || ['master'];
         if (entry.requestId === 'admin')
@@ -175,10 +195,10 @@ export class Console {
         // remove webpack path
         if (miniLog.filePath !== undefined) {
 
-            const appPrefix = '/webpack:/' + app.pkg.name + '/src/';
+            const appPrefix = '/webpack:/' + this.app.pkg.name + '/src/';
             const appPrefixIndex = miniLog.filePath.indexOf(appPrefix);
 
-            const corePrefix = '/webpack:/' + app.pkg.name + '/node_modules/5htp-core/src/';
+            const corePrefix = '/webpack:/' + this.app.pkg.name + '/node_modules/5htp-core/src/';
             const corePrefixIndex = miniLog.filePath.indexOf(corePrefix);
 
             if (appPrefixIndex !== -1)
@@ -207,8 +227,8 @@ export class Console {
     - READ
     ----------------------------------*/
 
-    public getClients() {
-        return $.sql`
+    /*public getClients() {
+        return sql`
             SELECT * FROM logs.Clients
             ORDER BY activity DESC
             LIMIT 100
@@ -219,7 +239,7 @@ export class Console {
         return (
             this.clients.find(c => c.id === clientId)
             ||
-            await $.sql`
+            await sql`
                 SELECT * FROM logs.Clients
                 WHERE id = ${clientId}
             `.first()
@@ -227,7 +247,7 @@ export class Console {
     }
 
     public getRequests(clientId?: string) {
-        return $.sql`
+        return sql`
             SELECT * FROM logs.Requests
             ORDER BY date DESC
             LIMIT 100
@@ -238,7 +258,7 @@ export class Console {
         return (
             this.requests.find(r => r.id === requestId)
             ||
-            await $.sql`
+            await sql`
                 SELECT * FROM logs.Requests
                 WHERE id = ${requestId}
             `.first()
@@ -251,13 +271,13 @@ export class Console {
         if (channelId !== undefined)
             filters.channelId = channelId;
 
-        return $.sql`
+        return sql`
             SELECT * FROM logs.Queries
             WHERE :${filters} 
             ORDER BY date DESC
             LIMIT 100
         `.all();
-    }
+    }*/
 
     public async getLogs( channelType: ChannelInfos["channelType"], channelId?: string ) {
 
@@ -274,7 +294,7 @@ export class Console {
  
     public printHtml(logs: TLog[], full: boolean = false): string {
 
-        let html = logs.map( log => logToHTML( log, this )).join('\n');
+        let html = logs.map( logEntry => logToHTML( logEntry, this )).join('\n');
 
         if (full) {
             const consoleCss = `background: #000; padding: 20px; font-family: 'Fira Mono', 'monospace', 'Monaco'; font-size: 12px; line-height: 20px;`
@@ -289,16 +309,4 @@ export class Console {
         { language: 'sql', ignoreIllegals: true }
     )
 
-}
-
-/*----------------------------------
-- REGISTER SERVICE
-----------------------------------*/
-app.register('console', Console);
-declare global {
-    namespace Core {
-        interface Services {
-            console: Console;
-        }
-    }
 }