5htp-core 0.1.2 → 0.2.0

package/src/server/app/index.ts

@@ -9,48 +9,53 @@ import fs from 'fs-extra';
 
 // Core
 import ConfigParser, { TEnvConfig } from './config';
+import { default as Service, AnyService } from './service';
+import type { default as Router, Request as ServerRequest } from '@server/services/router';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-type THookName = 'ready' | 'cleanup' | 'error'
-type THook = () => Promise<void>;
+export { default as Service, TPriority } from './service';
 
-type TServiceOptions = {
-    instanciate: boolean
-}
+type Config = {
 
-abstract class AsyncService {
-    public abstract loading: Promise<void> | undefined;
-    public abstract load: () => Promise<void>;
-}
-abstract class Service {
-    public abstract load: () => void;
 }
 
-interface TServiceClass {
-    new(): AsyncService | Service;
+type Hooks = {
+    ready: {
+        args: [],
+    },
+    cleanup: {
+        args: [],
+    },
+    error: {
+        args: [error: Error, request?: ServerRequest<Router>],
+    }
 }
 
 declare global {
-    namespace Core {
-        interface Services { }
+
+    //interface Services { }    
+
+    interface AppHooks {
+       
     }
+
     interface User { }
 }
 
-const servicesObj = {}
-
 /*----------------------------------
 - FUNCTIONS
 ----------------------------------*/
-export class App {
+export default abstract class Application extends Service<Config, Hooks, /* TODO: this ? */Application> {
 
     /*----------------------------------
     - PROPERTIES
     ----------------------------------*/
 
+    public side = 'server' as 'server';
+
     // Context
     public hmr: __WebpackModuleApi.Hot | undefined = module.hot;
 
@@ -65,143 +70,101 @@ export class App {
 
     // Status
     public launched: boolean = false;
-    public loading: Promise<void>[] = [];
     public status = {
         services: false
     }
 
-    public services: Core.Services = new Proxy( servicesObj, {
-        get: (container, serviceId, receiver) => {
-
-            if (!( serviceId in container ) && typeof serviceId === 'string')
-                throw new Error(`Service not loaded: ${serviceId}`);
-
-            return container[serviceId];
-        }
-    }) as Core.Services;
-
-    public hooks: {[name in THookName]: THook[]} = {
-        ready: [],
-        cleanup: [],
-        error: []
-    }
+    private servicesList: AnyService[] = []
 
     /*----------------------------------
     - INIT
     ----------------------------------*/
 
+    public env: TEnvConfig;
+    public abstract identity: Config.Identity;
+
     public constructor() {
 
+        // @ts-ignore: can't pass this to super
+        super();
+
         // 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.`);
+            this.runHook('error', error);
 
         });
 
         // Load config files
         const configParser = new ConfigParser( this.path.root );
         this.env = configParser.env();
-        this.identity = configParser.identity();
-    }
-
-    // Configs
-    public config!: Core.Config.Services;
-    public identity: Core.Config.Identity;
-    public env: TEnvConfig;
-    public configure( config: Core.Config.Services) {
-        this.config = config;
-        console.log("Configure services with", this.config);
-    }
-
-    // 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(`[services] Registering service ${id} ...`);
-        const service = options.instanciate !== false ? new Service() : Service;
-        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 ) {
-        this.hooks[ name ].push( callback );
-        return this;
-    }
+    /*----------------------------------
+    - REGISTER
+    ----------------------------------*/
 
-    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.`);
-        })
+    // Require a service at file scope
+    //  Only use in files where a service is strictly required 
+    public use<ServiceType extends Service<{}, {}, this>>( serviceName: string ): ServiceType | undefined {
+        return this[ serviceName ];
     }
 
     /*----------------------------------
     - LAUNCH
     ----------------------------------*/
-    public async launch() {
+
+    public async register() {
+
+    }
+    
+    public async start() {
 
         console.info(`[boot] Waiting for all services to be ready ...`);
-        await Promise.all( this.loading );
+        await this.startServices()
 
         console.info(`[boot] Launching application ...`);
         await this.runHook('ready');
 
-        // NOTE: Useless ?
-        /*if (this.hmr)
-            this.activateHMR();*/
+        console.info(`[boot] Run application-specific boot instructions ...`);
+        await this.boot();
 
         console.info(`[boot] Application is ready.`);
-        
         this.launched = true;
 
     }
 
+    public registerService( service: AnyService ) {
+        console.log(`[app] Register service`, service.constructor?.name);
+        this.servicesList.push(service);
+    }
+
+    public async startServices() {
+
+        console.log(`[app] Sorting ${this.servicesList.length} services by priority`);
+        this.servicesList.sort((s1, s2) => s2.priority - s1.priority);
+
+        console.log(`[app] Starting ${this.servicesList.length} services.`);
+        for (const service of this.servicesList) {
+            const serviceClassName = service.constructor?.name;
+            console.log(`[app] Start service`, serviceClassName);
+
+            if (service.register)
+                service.register();
+
+            if (service.start) {
+                service.started = service.start();
+                await service.started;
+            }
+        }
+
+        console.log(`[app] All ${this.servicesList.length} services were started.`);
+    }
+
+    public abstract boot(): Promise<void>;
+
+    // TODO: make it work
     private activateHMR() {
 
         if (!module.hot) return;
@@ -216,17 +179,16 @@ export class App {
             console.info(`Cleaning application ...`);
 
             // Services hooks
-            for (const id in this.services) {
+            /*for (const id in this.services) {
                 const service = this.services[id]
                 if (service.cleanup) {
                     console.info(`Cleaning ${id} service ...`);
                     service.cleanup();
                 }
-            }
+            }*/
 
             // Application specific hooks
-            for (const callback of this.hooks.cleanup)
-                callback();
+            this.runHook('cleanup');
 
             /*
             console.log("[nettoyage] Arrêt serveur socket ...");
@@ -239,9 +201,4 @@ export class App {
         });
     }
 
-}
-
-const app = new App;
-export const services = app.services;
-export const $ = app.services;
-export default app;
+}

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/error/index.ts

@@ -0,0 +1,13 @@
+export class SqlError extends Error {
+
+    public constructor( 
+        public original: Error, 
+        public query: string 
+    ) {
+        super(original.message);
+
+        this.name = original.name;
+        this.message = original.message;
+        this.stack = original.stack;
+    }
+}

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;