5htp-core 0.3.0 → 0.3.1-2

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "5htp-core",
 	"description": "Convenient TypeScript framework designed for Performance and Productivity.",
-	"version": "0.3.0",
+	"version": "0.3.1-2",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/5htp-core.git",
 	"license": "MIT",
@@ -97,6 +97,6 @@
 		"babel-plugin-glob-import": "^0.0.7"
 	},
 	"peerDependencies": {
-		"5htp": "0.3.0"
+		"5htp": "0.3.1"
 	}
 }

package/src/client/components/Select/index.tsx

@@ -6,11 +6,11 @@
 import React from 'react';
 
 // Core
-import Dropdown, { TDropdownControl, Props as DropdownProps } from '@client/components/dropdown';
+import { Props as DropdownProps } from '@client/components/dropdown';
 import Input from '@client/components/inputv3';
 
 // Specific
-import ChoiceSelector, { 
+import { 
     Props as SelectorProps, 
     Choice,
 } from './ChoiceSelector';
@@ -24,6 +24,8 @@ export type Props = DropdownProps & SelectorProps & {
     errors?: string[],
 }
 
+export type { Choice } from './ChoiceSelector';
+
 const ChoiceElement = ({ choice, currentList, onChange, multiple, includeCurrent }: {
     choice: Choice,
     currentList: Choice[],

package/src/client/services/router/index.tsx

@@ -40,7 +40,7 @@ import * as appRoutes from '@/client/pages/**/*.tsx';
 - CONFIG
 ----------------------------------*/
 
-const debug = true;
+const debug = false;
 const LogPrefix = '[router]'
 
 /*----------------------------------
@@ -61,6 +61,8 @@ export type Response = ClientResponse<ClientRouter> | ServerResponse<ServerRoute
 - TYPES: ROUTES LOADING
 ----------------------------------*/
 
+// WARN: To be updated with the mplemenations list of Router.page
+//      (both server and client side)
 export type TRegisterPageArgs<TProvidedData extends TFetcherList = {}, TRouter extends Router = Router> = ([
     path: string,
     controller: TDataProvider<TProvidedData> | null,
@@ -219,6 +221,25 @@ export default class ClientRouter<
         return currentRoute;
     }
 
+    public page(
+        path: string,
+        controller: TDataProvider<{}> | null,
+        renderer: TFrontRenderer<{}>
+    ): TRoute;
+
+    public page(
+        path: string,
+        options: Partial<TRoute["options"]>,
+        renderer: TFrontRenderer<{}>
+    ): TRoute;
+
+    public page(
+        path: string,
+        options: Partial<TRoute["options"]>,
+        controller: TDataProvider<{}> | null,
+        renderer: TFrontRenderer<{}>
+    ): TRoute;
+
     public page(...args: TRegisterPageArgs): TRoute {
 
         const { path, options, controller, renderer, layout } = getRegisterPageArgs(...args);

package/src/client/services/router/response/index.tsx

@@ -86,7 +86,7 @@ export default class ClientPageResponse<
             route: this.route,
             api: this.request.api,
 
-            ...this.request.router.config.context()
+            ...this.request.router.config.context( this.request.router )
         }
 
         context.context = context;

package/src/common/errors/index.ts

@@ -16,6 +16,26 @@ type TDetailsErreur = {
     urlRequete?: string,
 }
 
+/*----------------------------------
+- TYPES: BUG REPORT
+----------------------------------*/
+
+export type ServerBug = {
+    // Context
+    hash: string,
+    date: Date, // Timestamp
+    channelType?: string, 
+    channelId?: string,
+
+    user: string | null | undefined,
+    ip: string | null | undefined,
+    
+    // Error
+    error: Error,
+    stacktrace: string,
+    logs: string,
+}
+
 /*----------------------------------
 - ERREURS
 ----------------------------------*/

package/src/common/validation/validators.ts

@@ -10,6 +10,8 @@ import {
     isURL
 } from 'validator';
 
+import normalizeUrl, { Options as NormalizeUrlOptions } from 'normalize-url';
+
 // Core
 import { InputError } from '@common/errors';
 import FileToUpload from '@client/components/inputv3/file/FileToUpload';
@@ -157,16 +159,25 @@ export default class SchemaValidators {
             
         }, opts)
 
-    public url = (opts: TValidator<string> & {} = {}) => 
+    public url = (opts: TValidator<string> & {
+        normalize?: NormalizeUrlOptions
+    } = {}) => 
         new Validator<string>('url', (inputVal, input, output, corriger?) => {
 
             let val = this.string(opts).validate(inputVal, input, output, corriger);
 
+            // Check if URL
             if (!isURL(val, {
                 // https://www.npmjs.com/package/validator
             }))
                 throw new InputError(`Please provide a valid URL.`);
 
+            // Normalize
+            if (opts.normalize !== undefined)
+                val = normalizeUrl(val, opts.normalize);
+
+            console.log("@@@@@@@@@@@@@NORMALISZE URL", opts.normalize, val);
+
             return val;
         }, opts)
 

package/src/server/app/commands.ts

@@ -41,15 +41,35 @@ export type Hooks = {
 
 }
 
+export type Services = {
+
+}
+
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default class CommandsManager extends Service<Config, Hooks, Application> {
+export default class CommandsManager extends Service<Config, Hooks, Application, Services> {
 
     public priority = 2 as 2;
 
     public commandsIndex: CommandsList = {}
 
+    /*----------------------------------
+    - LIFECYCLE
+    ----------------------------------*/
+
+    protected async start() {
+        
+    }
+
+    protected async ready() {
+
+    }
+
+    protected async shutdown() {
+
+    }
+
     /*----------------------------------
     - DEFINITIONS
     ----------------------------------*/

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

@@ -35,6 +35,7 @@ export type TEnvConfig = {
 type AppIdentityConfig = {
 
     name: string,
+    identifier: string,
     description: string,
     author: {
         name: string,

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

@@ -8,19 +8,22 @@ import './patch';
 import path from 'path';
 
 // Core
-import Services from '../service/container';
+import type { StartedServicesIndex } from '../service';
+import Services, { ServicesContainer } from '../service/container';
 import ConfigParser, { TEnvConfig } from './config';
 
 /*----------------------------------
 - CLASS
 ----------------------------------*/
-export class ApplicationContainer {
+export class ApplicationContainer<
+    TServicesIndex extends StartedServicesIndex = StartedServicesIndex
+> {
 
     /*----------------------------------
     - INIT
     ----------------------------------*/
 
-    public Services = Services;
+    public Services = Services as ServicesContainer<TServicesIndex>;
     public Environment: TEnvConfig;
     public Identity: Config.Identity;
 

package/src/server/app/index.ts

@@ -4,9 +4,14 @@
 
 // Core
 import AppContainer from './container';
-import ApplicationService, { AnyService } from './service';
+import ApplicationService, { StartedServicesIndex } from './service';
 import CommandsManager from './commands';
-import ServicesContainer, { TRegisteredService, TServiceMetas } from './service/container';
+import ServicesContainer, { 
+    ServicesContainer as ServicesContainerClass, 
+    TRegisteredService, 
+    TServiceMetas 
+} from './service/container';
+import type { ServerBug } from '../services/console';
 
 // Built-in
 import type { default as Router, Request as ServerRequest } from '@server/services/router';
@@ -48,7 +53,12 @@ export const Service = ServicesContainer;
 /*----------------------------------
 - FUNCTIONS
 ----------------------------------*/
-export class Application extends ApplicationService<Config, Hooks, /* TODO: this ? */Application> {
+export class Application<
+    TServicesContainer extends ServicesContainerClass = ServicesContainerClass
+> extends ApplicationService<Config, Hooks, /* TODO: this ? */Application, {}> {
+
+    public app!: this;
+    public servicesContainer!: TServicesContainer;
 
     /*----------------------------------
     - PROPERTIES
@@ -72,8 +82,8 @@ export class Application extends ApplicationService<Config, Hooks, /* TODO: this
     public debug: boolean = false;
     public launched: boolean = false;
 
-    // All service instances by service id
-    public allServices: {[serviceId: string]: AnyService} = {}
+    // Mandatory services
+    public Console = this.use('Core/Console');
 
     /*----------------------------------
     - INIT
@@ -81,10 +91,14 @@ export class Application extends ApplicationService<Config, Hooks, /* TODO: this
 
     public constructor() {
 
+        const self = 'self' as unknown as Application;
+
         // Application itself doesnt have configuration
         // Configuration must be handled by application services
-        super({}, {}, {}, {});
+        super(self, {}, {}, self);
 
+        // We can't pass this in super so we assign here
+        this.parent = this;
         this.app = this;
 
         // Gestion crash
@@ -113,9 +127,9 @@ export class Application extends ApplicationService<Config, Hooks, /* TODO: this
         console.log(`5HTP Core`, process.env.npm_package_version);
 
         // Handle errors & crashs
-        this.on('error', this.error.bind(this))
+        this.on('error', e => this.Console.createBugReport(e))
 
-        this.debug && console.info(`[boot] Start services`);
+        console.info(`[boot] Start services`);
         await this.startServices();
 
         this.debug && console.info(`[boot] App ready`);
@@ -132,8 +146,10 @@ export class Application extends ApplicationService<Config, Hooks, /* TODO: this
     }
 
     // Default error handler
-    public async error( e: Error ) {
-        console.error( e );
+    public async reportBug( bug: ServerBug ) {
+
+        console.error( bug.error );
+
     }
 
     public async shutdown() {
@@ -150,30 +166,38 @@ export class Application extends ApplicationService<Config, Hooks, /* TODO: this
 
             // 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')
+            if (propName === 'services' || this[ propName ] === undefined)
                 continue;
 
             // Check if this property is a service registration
-            const registered = this[ propName ] as TRegisteredService;
-            if (registered?.type !== 'service')
+            const service = this[ propName ] as TRegisteredService;
+            const isService = (
+                service instanceof ApplicationService
+                ||
+                (
+                    typeof service === 'function'
+                    &&
+                    service.serviceInstance instanceof ApplicationService
+                )
+            )
+            if (!isService)
                 continue;
 
             // Instanciate the service
-            const service = this.registerService( propName, registered );
-            this[ propName ] = service;
+            this.bindService( propName, service );
 
             // Register commands
             if (service.commands)
                 this.commandsManager.fromList( service.commands );
 
             // Start service
-            await this.startService( service );
+            await this.startService( propName, service );
         }
 
         // Check if any setup service has not been used
         const unused: string[] = []
         for (const serviceNS in ServicesContainer.registered)
-            if (this.allServices[ serviceNS ] === undefined)
+            if (ServicesContainer.allServices[ serviceNS ] === undefined)
                 unused.push(serviceNS);
         
         if (unused.length !== 0)

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

@@ -4,7 +4,7 @@
 
 // Specific
 import type { 
-    AnyService, 
+    AnyService, StartedServicesIndex,
     // Hooks
     THookCallback, THooksIndex 
 } from ".";
@@ -46,13 +46,18 @@ const LogPrefix = '[service]';
 /*----------------------------------
 - CLASS
 ----------------------------------*/
-export class ServicesContainer {
+export class ServicesContainer<
+    TServicesIndex extends StartedServicesIndex = StartedServicesIndex
+> {
 
     public registered: TRegisteredServicesIndex = {}
 
-    public setup( 
-        serviceId: string, 
-        serviceConfig: {} 
+    // All service instances by service id
+    public allServices: TServicesIndex = {} as TServicesIndex
+
+    public setup<TServiceId extends keyof TServicesIndex>( 
+        serviceId: keyof TServicesIndex, 
+        serviceConfig: TServicesIndex[TServiceId]["config"]
     ): TRegisteredService {
 
         // Check if the service is installed & has been indexed
@@ -86,25 +91,6 @@ export class ServicesContainer {
         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
@@ -129,6 +115,9 @@ export class ServicesContainer {
                     ? instance[ method ].bind( instance )
                     : instance[ method ];
 
+        // Allow us to recognize a callable as a service 
+        callable.serviceInstance = instance;
+
         return callable as TInstance[TCallableName] & TInstance;
     }
 }

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

@@ -6,12 +6,14 @@
 import type { Application } from "..";
 import type { Command } from "../commands"; 
 import type { TServiceMetas, TRegisteredServicesIndex, TRegisteredService } from './container';
+import ServicesContainer from './container';
 
 /*----------------------------------
 - TYPES: OPTIONS
 ----------------------------------*/
 
-export type AnyService = Service<{}, {}, Application, TStartedServicesIndex>
+export type AnyService<TSubServices extends StartedServicesIndex = StartedServicesIndex> = 
+    Service<{}, {}, Application, TSubServices>
 
 type TServiceConfig = {
     debug?: boolean
@@ -39,6 +41,12 @@ export type StartedServicesIndex = {
     [serviceId: string]: AnyService
 }
 
+type ClassType<T = {}> = new (...args: any[]) => T;
+
+type ServiceWithSubservices<TService extends ClassType<AnyService>, TSubservices extends StartedServicesIndex> = {
+    new (...args: any[]): TService & { services: TSubservices }
+  };
+
 /*----------------------------------
 - CONFIG
 ----------------------------------*/
@@ -52,7 +60,7 @@ export default abstract class Service<
     TConfig extends TServiceConfig, 
     THooks extends THooksList,
     TApplication extends Application,
-    TServicesIndex extends StartedServicesIndex = StartedServicesIndex
+    TServicesIndex extends StartedServicesIndex
 > {
 
     public started?: Promise<void>;
@@ -62,26 +70,34 @@ export default abstract class Service<
     public metas!: TServiceMetas;
     public bindings: string[] = []
 
-    public static createInstance?: (
-        parent: AnyService, 
-        config: TServiceConfig,
-        services: TRegisteredServicesIndex,
-        app: Application
-    ) => Service<TServiceConfig, THooksList, Application, StartedServicesIndex>;
+    public app: TApplication;
 
     public constructor( 
-        public parent: AnyService, 
+        public parent: AnyService | 'self', 
         public config: TConfig,
-        services: TRegisteredServicesIndex,
-        public app: TApplication
+        // Make this argument appear as instanciated sercices index
+        // But actually, Setup.use returns a registered service, not yet launched
+        services: TServicesIndex,
+        app: TApplication | 'self'
     ) {
 
+        if (this.parent === 'self') 
+            this.parent = this;
+
+        this.app = app === 'self'
+            ? this as unknown as TApplication
+            : app
+
         // Instanciate subservices
         for (const localName in services)
-            this.registerService( localName, services[localName] );
+            this.bindService( localName, services[localName] as unknown as TRegisteredService );
         
     }
 
+    public getServiceInstance() {
+        return this;
+    }
+
     /*----------------------------------
     - LIFECYCLE
     ----------------------------------*/
@@ -90,7 +106,7 @@ export default abstract class Service<
 
         // Instanciate subservices
         for (const localName in this.services)
-            await this.startService( this.services[localName] );
+            await this.startService( localName, this.services[localName] );
 
         // Start service
         if (this.start)
@@ -112,66 +128,114 @@ export default abstract class Service<
     - SUBSERVICES
     ----------------------------------*/
 
-    public services: TRegisteredServicesIndex = {} as TRegisteredServicesIndex/*new Proxy({}, {
+    public registered: TRegisteredServicesIndex = {} as TRegisteredServicesIndex;
+
+    public services: TServicesIndex = {} as TServicesIndex;
+    
+    /*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(', '));
+                throw new Error(`You made reference to the "${prop}" service, but this one hasn't been loaded or started yet. 
+                    Registered services: ${Object.keys(this.services).join(', ')} ; 
+                    Loaded services: ${Object.keys(this.services).join(', ')}
+                `);
             }
         }
     }) as TRegisteredServicesIndex*/
 
-    protected registerService( localName: string, registered: TRegisteredService ): AnyService {
+    // this.use immediatly instanciate the subservice for few reasons:
+    // - The subservice instance can be accesses from another service in the constructor, no matter the order of loading of the services
+    // - Consistency: the subserviuce proprties shouldn't be assogned to two different values according depending on the app lifecycle
+    public use<
+        TInstalledServices extends this["app"]["servicesContainer"]["allServices"],
+        TServiceId extends keyof TInstalledServices,
+        TServiceClass extends TInstalledServices[TServiceId],
+        TSubServices extends TServiceClass["services"],
+    >( 
+        serviceId: TServiceId, 
+        subServices?: TSubServices
+    ): (
+        {
+            new (...args: any[]): TServiceClass & { services: TSubServices }
+        }
+        /*Omit<TServiceClass, 'services'> & {
+            services: TSubServices
+        }*/
+    ) {
 
-        // Service already instabciates on the app scope
-        let service = this.app.allServices[ registered.metas.id ];
+        // Check of the service has been configurated
+        const registered = ServicesContainer.registered[ serviceId ];
+        if (registered === undefined)
+            throw new Error(`Unable to use service "${serviceId}": This one hasn't been setup.`);
 
-        // Service not yet instanciated
-        if (service === undefined) {
+        // Bind subservices
+        registered.subServices = subServices || {};
 
-            // 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);
+        // Check if not already instanciated
+        const existing = ServicesContainer.allServices[ serviceId ];
+        if (existing !== undefined) {
+            console.info("Service", serviceId, "already instanciated through another service.");
+            return existing;
+        }
 
-            service.metas = registered.metas;
+        // Instanciate
+        console.log(`[app] Load service`, registered.metas.id);
+        const ServiceClass = registered.metas.class().default;
 
-        } else {
-            console.warn(`[app] Service`, registered.metas.id, 'already instanciated in this app.');
-        }
+        // Create class instance
+        const service = new ServiceClass(this, registered.config, registered.subServices, this.app || this)
+            .getServiceInstance()
 
-        // Bind to app
-        this.services[ localName ] = service;
-        service.bindings.push(this.constructor.name + '.' + localName);
-        this.app.allServices[ registered.metas.id ] = service;
+        // Bind his own metas
+        service.metas = registered.metas;
+        ServicesContainer.allServices[ registered.metas.id ] = service;
 
         return service;
-        
     }
 
-    protected async startService( service: AnyService ) {
+    public bindService( localName: string, 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;
-        })
+        const serviceScope = this.constructor.name + '.' + localName;
+
+        // Fix the parent service (the app could be provided as parent because the dev called this.use() in the app class definition)
+        service.parent = this;
+
+        // Bind subservice to service
+        //console.log(`Binding service ${serviceScope}`);
+        service.bindings.push(serviceScope);
+
+        // Since now we have the localname, we can bind the service in this.service too
+        this.services[localName] = service;
 
-        console.log(`[app] Service`, service.metas.id, 'started (bound to:', service.bindings.join(', '),')');
-        service.status = 'running';
+        // For serices that have been passed through this.use
+        if ((localName in this) && this[localName] === undefined)
+            this[ localName ] = service;
+        
+    }
+
+    public async startService( localName: string, service: AnyService ) {
+        // Service already started
+        if (!service.started) {
+
+            const serviceScope = this.constructor.name + '.' + localName;
+
+            // Start servuce & eventually his subservices
+            console.log(`[app] Start service`, serviceScope);
+            service.status = 'starting';
+            service.started = service.launch();
+            await service.started.catch(e => {
+                console.error("Catched error while starting service " + serviceScope, e);
+                if (this.app.env.profile === 'prod')
+                    process.exit();
+                else
+                    throw e;
+            })
+
+            // Bind to app
+            console.log(`[app] Service`, serviceScope, 'started (bound to:', service.bindings.join(', '),')');
+            service.status = 'running';
+        }
     }
 
     /*----------------------------------