5htp-core 0.2.9 → 0.3.0

package/src/server/app/index.ts

@@ -2,26 +2,20 @@
 - DEPENDANCES
 ----------------------------------*/
 
-import '../patch';
-
-// Npm
-import fs from 'fs-extra';
-
 // Core
-import ConfigParser, { TEnvConfig } from './config';
-import { default as Service, AnyService } from './service';
+import AppContainer from './container';
+import ApplicationService, { AnyService } from './service';
 import CommandsManager from './commands';
+import ServicesContainer, { TRegisteredService, TServiceMetas } from './service/container';
 
 // Built-in
 import type { default as Router, Request as ServerRequest } from '@server/services/router';
+export { default as Services } from './service/container';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-export { default as Service } from './service';
-export type { TPriority } from './service';
-
 type Config = {
 
 }
@@ -49,80 +43,62 @@ declare global {
     interface User { }
 }
 
+export const Service = ServicesContainer;
+
 /*----------------------------------
 - FUNCTIONS
 ----------------------------------*/
-export default abstract class Application extends Service<Config, Hooks, /* TODO: this ? */Application> {
+export class Application extends ApplicationService<Config, Hooks, /* TODO: this ? */Application> {
 
     /*----------------------------------
     - PROPERTIES
     ----------------------------------*/
 
     public side = 'server' as 'server';
-
-    // Context
-    public hmr: __WebpackModuleApi.Hot | undefined = module.hot;
-
-    public path = {
-        root: process.cwd(),
-        public: process.cwd() + '/public',
-
-        // TODO: move to disk
-        var: process.cwd() + '/var',
-        typings: process.cwd() + '/var/typings',
-        cache: process.cwd() + '/var/cache',
-        data: process.cwd() + '/var/data',
-        log: process.cwd() + '/var/log',
+    public metas: TServiceMetas = {
+        id: 'application',
+        name: 'Application',
+        parent: 'root',
+        dependences: [],
+        class: () => ({ 'default': Application })
     }
 
-    public pkg = fs.readJSONSync(this.path.root + '/package.json');
+    // Shortcuts to ApplicationContainer
+    public container = AppContainer;
+    public env = AppContainer.Environment;
+    public identity = AppContainer.Identity;
 
     // Status
+    public debug: boolean = false;
     public launched: boolean = false;
-    public status = {
-        services: false
-    }
 
-    private servicesList: AnyService[] = []
+    // All service instances by service id
+    public allServices: {[serviceId: string]: AnyService} = {}
 
     /*----------------------------------
     - INIT
     ----------------------------------*/
 
-    public env: TEnvConfig;
-    public identity: Config.Identity;
-
     public constructor() {
 
-        super({}, {});
+        // Application itself doesnt have configuration
+        // Configuration must be handled by application services
+        super({}, {}, {}, {});
+
+        this.app = this;
 
         // Gestion crash
         process.on('unhandledRejection', (error: any, promise: any) => {
             // We don't log the error here because it's the role of the app to decidehiw to log errors
             this.runHook('error', error);
         });
-
-        // Load config files
-        const configParser = new ConfigParser( this.path.root );
-        this.env = configParser.env();
-        this.identity = configParser.identity();
-    }
-
-    /*----------------------------------
-    - REGISTER
-    ----------------------------------*/
-
-    // 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 ];
     }
 
     /*----------------------------------
     - COMMANDS
     ----------------------------------*/
 
-    private commandsManager = new CommandsManager(this, { debug: true });
+    private commandsManager = new CommandsManager(this, { debug: true }, {}, this);
 
     public command( ...args: Parameters<CommandsManager["command"]> ) {
         return this.commandsManager.command(...args);
@@ -131,119 +107,80 @@ export default abstract class Application extends Service<Config, Hooks, /* TODO
     /*----------------------------------
     - LAUNCH
     ----------------------------------*/
-
-    public async register() {
-
-    }
     
-    public async start() {
+    protected async start() {
 
         console.log(`5HTP Core`, process.env.npm_package_version);
 
-        console.info(`[boot] Connect disk`);
-        await this.initDisk();
+        // Handle errors & crashs
+        this.on('error', this.error.bind(this))
 
-        console.info(`[boot] Start services`);
-        await this.startServices()
+        this.debug && console.info(`[boot] Start services`);
+        await this.startServices();
 
-        console.info(`[boot] App ready`);
+        this.debug && console.info(`[boot] App ready`);
+        await this.ready();
         await this.runHook('ready');
 
-        console.info(`[boot] Run application-specific boot instructions ...`);
-        await this.boot();
-
-        console.info(`[boot] Application is ready.`);
+        this.debug && console.info(`[boot] Application is ready.`);
         this.launched = true;
+    }
+
+    public async ready() {
+
 
     }
 
-    private async initDisk() {
-        console.info(`[boot] Ensure runtime dirs ...`);
-        await Promise.all([
-            fs.ensureDir( this.path.cache ),
-            fs.ensureDir( this.path.log ),
-            fs.ensureDir( this.path.data ),
-        ]);
+    // Default error handler
+    public async error( e: Error ) {
+        console.error( e );
     }
 
-    public registerService( service: AnyService ) {
-        console.log(`[app] Register service`, service.constructor?.name);
-        this.servicesList.push(service);
+    public async shutdown() {
+
     }
 
+    // TODO: move to servie class
+    // So we can do public myService = Services.use() inside service class ded
     public async startServices() {
 
-        console.log(`[app] Sorting ${this.servicesList.length} services by priority`);
-        this.servicesList.sort((s1, s2) => s2.priority - s1.priority);
+        const propsNames = Object.getOwnPropertyNames(this);
+        
+        for (const propName of propsNames) {
+
+            // Don't check services prop as it will trigger an error (it's a proxy)
+            // TODO: exclude all properties coming from the Service class itself
+            if (propName === 'services' || typeof this[ propName ] !== 'object')
+                continue;
 
-        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);
-            service.status = 'starting';
+            // Check if this property is a service registration
+            const registered = this[ propName ] as TRegisteredService;
+            if (registered?.type !== 'service')
+                continue;
 
-            if (service.register)
-                await service.register();
+            // Instanciate the service
+            const service = this.registerService( propName, registered );
+            this[ propName ] = service;
 
             // Register commands
             if (service.commands)
-                this.commandsManager.fromList(service.commands);
+                this.commandsManager.fromList( service.commands );
 
             // Start service
-            if (service.start) {
-                service.started = service.start();
-                await service.started.catch(e => {
-                    console.error("Catched error while starting service " + serviceClassName + '. Exiting process if mode production.', e);
-                    if (this.env.profile === 'prod')
-                        process.exit();
-                    else
-                        throw e;
-                })
-            }
-
-            service.status = 'running';
+            await this.startService( service );
         }
 
-        console.log(`[app] All ${this.servicesList.length} services were started.`);
+        // Check if any setup service has not been used
+        const unused: string[] = []
+        for (const serviceNS in ServicesContainer.registered)
+            if (this.allServices[ serviceNS ] === undefined)
+                unused.push(serviceNS);
+        
+        if (unused.length !== 0)
+            console.warn(`${unused.length} services were setup, but are not used anywhere:`, 
+                unused.join(', '));
     }
 
-    public abstract boot(): Promise<void>;
-
-    // TODO: make it work
-    private activateHMR() {
-
-        if (!module.hot) return;
-
-        console.info(`Activating HMR ...`);
-
-        module.hot.accept();
-        module.hot.accept( this.path.root + '/.cache/commun/routes.ts' );
-
-        module.hot.addDisposeHandler((data) => {
-
-            console.info(`Cleaning application ...`);
-
-            // Services hooks
-            /*for (const id in this.services) {
-                const service = this.services[id]
-                if (service.cleanup) {
-                    console.info(`Cleaning ${id} service ...`);
-                    service.cleanup();
-                }
-            }*/
-
-            // Application specific hooks
-            this.runHook('cleanup');
-
-            /*
-            console.log("[nettoyage] Arrêt serveur socket ...");
-            if (socket !== undefined)
-                socket.serveur.close()
-
-            console.log("[nettoyage] Reset du cache requêtes JSQL ...");
-            QueryParser.clearCache();*/
-
-        });
-    }
+}
 
-}
+export default Application

package/src/server/app/instance.ts

@@ -0,0 +1,3 @@
+import Application from '@/server';
+
+export default new Application

package/src/server/app/service/container.ts

@@ -0,0 +1,136 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Specific
+import type { 
+    AnyService, 
+    // Hooks
+    THookCallback, THooksIndex 
+} from ".";
+
+import ServicesIndex from '@/server/.generated/services';
+
+/*----------------------------------
+- TYPES: REGISTRATION
+----------------------------------*/
+
+// From service/service.json
+export type TServiceMetas<TServiceClass extends AnyService = AnyService>  = {
+    id: string,
+    name: string,
+    parent: string,
+    dependences: string[],
+    class: () => { default: ClassType<TServiceClass> }
+}
+
+export type TRegisteredService<TServiceClass extends AnyService = AnyService>  = {
+    type: 'service', // Used to recognize if an object is a registered service
+    config?: {},
+    metas: TServiceMetas<TServiceClass>,
+    hooks: THooksIndex<{}>,
+    on: (hookName: string, hookFunc: THookCallback<any>) => void,
+    subServices: TRegisteredServicesIndex
+}
+
+export type TRegisteredServicesIndex<TServiceClass extends AnyService = AnyService> = {
+    [serviceId: string]: TRegisteredService<TServiceClass>
+}
+
+/*----------------------------------
+- CONFIG
+----------------------------------*/
+
+const LogPrefix = '[service]';
+
+/*----------------------------------
+- CLASS
+----------------------------------*/
+export class ServicesContainer {
+
+    public registered: TRegisteredServicesIndex = {}
+
+    public setup( 
+        serviceId: string, 
+        serviceConfig: {} 
+    ): TRegisteredService {
+
+        // Check if the service is installed & has been indexed
+        const installedService = ServicesIndex[ serviceId ];
+        if (installedService === undefined)
+            throw new Error(`Unable to setup service "${serviceId}": This one doesn't seems to be installed.`);
+
+        // Service already registered & setup
+        const registered = this.registered[ serviceId ];
+        if (registered !== undefined)
+            throw new Error(`Service ${serviceId} has been setup multiple times. One service can only be setup one time.`);
+
+        // Create & register metas
+        const service: TRegisteredService = {
+            type: 'service',
+            config: serviceConfig,
+            metas: installedService,
+            hooks: {},
+            on: (hookName: string, hookFunc: THookCallback<any>) => {
+                const callbacks = service.hooks[ hookName ];
+                if (callbacks)
+                    callbacks.push( hookFunc );
+                else
+                    service.hooks[ hookName ] = [hookFunc]
+            },
+            subServices: {}
+        };
+
+        this.registered[ serviceId ] = service;
+
+        return service;
+    }
+
+    public use( 
+        serviceId: string, 
+        // TODO: Only subservices types supported by the parent service
+        subServices: TRegisteredServicesIndex = {}
+    ): TRegisteredService {
+
+        // Check of the service has been configurated
+        const registered = this.registered[ serviceId ];
+        if (registered === undefined)
+            throw new Error(`Unable to use service "${serviceId}": This one hasn't been setup.`);
+
+        // Bind subservices
+        registered.subServices = subServices;
+
+        // Return the service metas
+        // The parent service will take care of instanciating & starting it
+        return registered;
+    }
+
+    public callableInstance = <TInstance extends object, TCallableName extends keyof TInstance>(
+        instance: TInstance, 
+        funcName: TCallableName
+    ): TInstance[TCallableName] & TInstance => {
+
+        const callableFunc = instance[funcName];
+        if (typeof callableFunc !== 'function')
+            throw new Error(`instance[funcName] isn't callable.`);
+
+        const callable = callableFunc.bind(instance);
+
+        const methods = [
+            ...Object.getOwnPropertyNames( Object.getPrototypeOf( instance )),
+            ...Object.getOwnPropertyNames( instance ),
+            // service.launch() isn't included, maybe because parent abstract class
+            'launch'
+        ];
+
+        for (const method of methods)
+            if (method !== 'constructor')
+                callable[ method ] = typeof instance[ method ] === 'function'
+                    ? instance[ method ].bind( instance )
+                    : instance[ method ];
+
+        return callable as TInstance[TCallableName] & TInstance;
+    }
+}
+
+export default new ServicesContainer

package/src/server/app/service/index.ts

@@ -0,0 +1,219 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Specific
+import type { Application } from "..";
+import type { Command } from "../commands"; 
+import type { TServiceMetas, TRegisteredServicesIndex, TRegisteredService } from './container';
+
+/*----------------------------------
+- TYPES: OPTIONS
+----------------------------------*/
+
+export type AnyService = Service<{}, {}, Application, TStartedServicesIndex>
+
+type TServiceConfig = {
+    debug?: boolean
+}
+
+export type { TRegisteredServicesIndex, TRegisteredService } from './container';
+
+/*----------------------------------
+- TYPES: HOOKS
+----------------------------------*/
+
+export type THookCallback<THookArgs extends THookOptions> = (...args: THookArgs["args"]) => Promise<void>;
+
+type THooksList = {
+    [hookName: string]: THookOptions
+}
+
+type THookOptions = {
+    args: any[]
+}
+
+export type THooksIndex<THooks extends THooksList> = {[name in keyof THooks]?: THookCallback< THooks[name] >[]}
+
+export type StartedServicesIndex = {
+    [serviceId: string]: AnyService
+}
+
+/*----------------------------------
+- CONFIG
+----------------------------------*/
+
+const LogPrefix = '[service]';
+
+/*----------------------------------
+- CLASS
+----------------------------------*/
+export default abstract class Service<
+    TConfig extends TServiceConfig, 
+    THooks extends THooksList,
+    TApplication extends Application,
+    TServicesIndex extends StartedServicesIndex = StartedServicesIndex
+> {
+
+    public started?: Promise<void>;
+    public status: 'stopped' | 'starting' | 'running' | 'paused' = 'stopped';
+
+    public commands?: Command[];
+    public metas!: TServiceMetas;
+    public bindings: string[] = []
+
+    public static createInstance?: (
+        parent: AnyService, 
+        config: TServiceConfig,
+        services: TRegisteredServicesIndex,
+        app: Application
+    ) => Service<TServiceConfig, THooksList, Application, StartedServicesIndex>;
+
+    public constructor( 
+        public parent: AnyService, 
+        public config: TConfig,
+        services: TRegisteredServicesIndex,
+        public app: TApplication
+    ) {
+
+        // Instanciate subservices
+        for (const localName in services)
+            this.registerService( localName, services[localName] );
+        
+    }
+
+    /*----------------------------------
+    - LIFECYCLE
+    ----------------------------------*/
+
+    public async launch() {
+
+        // Instanciate subservices
+        for (const localName in this.services)
+            await this.startService( this.services[localName] );
+
+        // Start service
+        if (this.start)
+            await this.start();
+
+        // Bind app events
+        this.app.on('ready', this.ready.bind(this))
+        this.app.on('shutdown', this.shutdown.bind(this))
+
+    }
+
+    protected abstract start(): Promise<void>;
+
+    protected abstract ready(): Promise<void>;
+
+    protected abstract shutdown(): Promise<void>;
+
+    /*----------------------------------
+    - SUBSERVICES
+    ----------------------------------*/
+
+    public services: TRegisteredServicesIndex = {} as TRegisteredServicesIndex/*new Proxy({}, {
+        get: (target, prop, recever) => {
+            if (!( prop in target )) {
+                
+                throw new Error(`You made reference to the "${prop}" service, but this one hasn't been loaded yet. Loaded services: ` + Object.keys(this.services).join(', '));
+            }
+        }
+    }) as TRegisteredServicesIndex*/
+
+    protected registerService( localName: string, registered: TRegisteredService ): AnyService {
+
+        // Service already instabciates on the app scope
+        let service = this.app.allServices[ registered.metas.id ];
+
+        // Service not yet instanciated
+        if (service === undefined) {
+
+            // Instanciate
+            console.log(`[app] Load service`, registered.metas.id);
+            const ServiceClass = registered.metas.class().default;
+            // Create class instance
+            service = ServiceClass.createInstance !== undefined
+                ? ServiceClass.createInstance(this, registered.config, registered.subServices, this.app)
+                : new ServiceClass(this, registered.config, registered.subServices, this.app);
+
+            service.metas = registered.metas;
+
+        } else {
+            console.warn(`[app] Service`, registered.metas.id, 'already instanciated in this app.');
+        }
+
+        // Bind to app
+        this.services[ localName ] = service;
+        service.bindings.push(this.constructor.name + '.' + localName);
+        this.app.allServices[ registered.metas.id ] = service;
+
+        return service;
+        
+    }
+
+    protected async startService( service: AnyService ) {
+
+        // Service already started
+        if (service.started)
+            return;
+
+        // Start servuce & eventually his subservices
+        console.log(`[app] Start service`, service.metas.id);
+        service.status = 'starting';
+        service.started = service.launch();
+        await service.started.catch(e => {
+            console.error("Catched error while starting service " + service.metas.id, e);
+            if (this.app.env.profile === 'prod')
+                process.exit();
+            else
+                throw e;
+        })
+
+        console.log(`[app] Service`, service.metas.id, 'started (bound to:', service.bindings.join(', '),')');
+        service.status = 'running';
+    }
+
+    /*----------------------------------
+    - HOOKS
+    ----------------------------------*/
+    public hooks: THooksIndex<THooks> = {}
+
+    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.`);
+
+        this.config.debug && 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);
+                    if (name !== 'error')
+                        this.runHook('error', e);
+                })
+            ) 
+        ).then(() => {
+            this.config.debug && console.info(`[hook] Hooks ${name} executed with success.`);
+        })
+    }
+
+}

package/src/server/index.ts

@@ -1,5 +1,11 @@
-import Application from '@/server';
+// Load Application container
+import './app/container';
 
-const app = new Application();
+// Load services setup
+import '@/server/config/*.ts';
 
-app.start();
+// Load Application
+import application from './app/instance';
+
+// Start application
+application.start();