5htp-core 0.5.9 → 0.6.0

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

@@ -206,11 +206,6 @@ export default class Console {
         this.enableLogging(origLog);
     }
 
-    // Avoid to use lifecycle functions
-    protected async start() {}
-    public async ready() {}
-    public async shutdown() {}
-
     private enableLogging( origLog: typeof console.log ) {
 
         const minLogLevel = logLevels[this.config.level];
@@ -381,7 +376,7 @@ export default class Console {
             logs
         }
 
-        await application.reportBug( bugReport );
+        await application.runHook('bug', bugReport);
     }
 
     public getChannel() {

package/server/app/container/index.ts

@@ -2,8 +2,6 @@
 - DEPENDANCES
 ----------------------------------*/
 
-import './patch';
-
 // Npm
 import path from 'path';
 

package/server/app/index.ts

@@ -7,16 +7,16 @@ import type express from 'express';
 
 // Core
 import AppContainer from './container';
-import ApplicationService, { StartedServicesIndex } from './service';
+import ApplicationService, { AnyService, StartedServicesIndex } from './service';
 import CommandsManager from './commands';
 import ServicesContainer, { 
     ServicesContainer as ServicesContainerClass, 
     TServiceMetas 
 } from './service/container';
-import type { ServerBug } from './container/console';
 
 // Built-in
-import type { default as Router, Request as ServerRequest } from '@server/services/router';
+import type { default as Router, Request as ServerRequest, TRoute } from '@server/services/router';
+import { Anomaly } from '@common/errors';
 
 export { default as Services } from './service/container';
 export type { TEnvConfig as Environment } from './container/config';
@@ -55,7 +55,7 @@ export type ApplicationProperties = Prettify<keyof Application>;
 ----------------------------------*/
 export abstract class Application<
     TServicesContainer extends ServicesContainerClass = ServicesContainerClass
-> extends ApplicationService<Config, Hooks, /* TODO: this ? */Application, {}> {
+> extends ApplicationService<Config, Hooks, Application> {
 
     public app!: this;
     public servicesContainer!: TServicesContainer;
@@ -81,9 +81,13 @@ export abstract class Application<
     // Status
     public debug: boolean = false;
     public launched: boolean = false;
-
-    protected abstract serviceNames: string[];
-    protected abstract servicesIdToName: { [serviceId: string]: string };
+    
+    protected abstract registered: { 
+        [serviceId: string]: {
+            name: string,
+            start: () => AnyService
+        }
+    };
 
     /*----------------------------------
     - INIT
@@ -95,7 +99,7 @@ export abstract class Application<
 
         // Application itself doesnt have configuration
         // Configuration must be handled by application services
-        super(self, {}, () => ({}), self);
+        super(self, {}, self);
         
         // Handle unhandled crash
         this.on('error', (e, request) => this.container.handleBug(e, "An error occured in the application", request));
@@ -109,7 +113,13 @@ export abstract class Application<
         // We can't pass this in super so we assign here
         this.parent = this;
         this.app = this;
-        
+
+    }
+
+    public report(...anomalyArgs: ConstructorParameters<typeof Anomaly>) {
+        return this.container.Console.createBugReport(
+            new Anomaly(...anomalyArgs)
+        );
     }
 
     /*----------------------------------
@@ -132,6 +142,11 @@ export abstract class Application<
         console.log("Core version", CORE_VERSION);
         const startTime = Date.now();
 
+        this.startServices();
+
+        console.log('----------------------------------');
+        console.log('- SERVICES');
+        console.log('----------------------------------');
         await this.ready();
         await this.runHook('ready');
 
@@ -144,33 +159,54 @@ export abstract class Application<
     - ERROR HANDLING
     ----------------------------------*/
 
-    // Default error handler
-    public async reportBug( bug: ServerBug ) {
+    private startServices() {
+        
+        // Satrt services
+        for (const serviceId in this.registered) {
+            try {
+                const service = this.registered[serviceId];
+                const instance = service.start();
+                this[service.name] = instance.getServiceInstance();
+            } catch (error) {
+                console.error("Error while starting service", serviceId, error);
+                throw error;
+            }
+        }
+    }
+
+    public register( service: AnyService ) {
 
-        console.error( bug.error );
+        service.ready();
 
     }
 
     protected async ready() {
 
-        console.info(`[boot] Prepare services`);
-        for (const serviceName of this.serviceNames) {
+        // Print services
+        const processService = async (propKey: string, service: AnyService, level: number = 0) => {
 
-            const service = this[serviceName];
+            if (service.status !== 'starting')
+                return;
 
-            if (typeof service.getServices === 'function')
-                service.services = service.getServices();
+            // Services start shouldn't block app boot
+            // use await ServiceName.started to make services depends on each other
+            this.starting = service.ready();
+            service.status = 'running';
+            console.log('-' + '-'.repeat(level * 1), propKey + ': ' + service.constructor.name);
 
-            const routes = service.__routes;
+            // Routes
+            const routes = service.__routes as TRoute[];
             if (routes) for (const route of routes) { 
 
+                console.log('Attached service', service.constructor.name, 'to route', route.path);
+
                 const origController = route.controller;
                 route.controller = (context: RouterContext) => {
 
                     // Filter data
-                    const data = route.options.validate 
-                        ? route.options.validate( context.schema )
-                        : context.request.data;
+                    const data = route.schema 
+                        ? route.schema.parse( context.request.data )
+                        : {};
 
                     // Run controller
                     return origController.bind( service )(
@@ -181,8 +217,38 @@ export abstract class Application<
 
                 this.Router.controllers[ route.path ] = route;
             }
+            
+            // Subservices
+            for (const propKey in service) {
+
+                if (propKey === 'app')
+                    continue;
+                const propValue = service[propKey];
+
+                // Check if service
+                const isService = 
+                    typeof propValue === 'object' && 
+                    !(propValue instanceof Application) &&
+                    propValue !== null && 
+                    propValue.status !== undefined;
+                if (!isService)
+                    continue;
+
+                // Services start shouldn't block app boot
+                processService(propKey, propValue, level + 1);
+            }
+        }
+
+        for (const serviceId in this.registered) {
+
+            const registeredService = this.registered[serviceId];
+            const service = this[registeredService.name];
 
-            service.ready();
+            // TODO: move to router
+            //  Application.on('service.ready')
+            
+            // Services start shouldn't block app boot
+            processService(serviceId, service);
         }
     }
 

package/server/app/service/index.ts

@@ -7,17 +7,16 @@ import type { Application } from "..";
 import type { Command } from "../commands"; 
 import type { TServiceMetas } from './container';
 import type { TControllerDefinition, TRoute } from '../../services/router';
+import { Anomaly } from "@common/errors";
+
+export { default as schema } from 'zod';
 
 /*----------------------------------
 - TYPES: OPTIONS
 ----------------------------------*/
 
 export type AnyService<TSubServices extends StartedServicesIndex = StartedServicesIndex> = 
-    Service<{}, {}, Application, TSubServices>
-
-type TServiceConfig = {
-    priority?: number
-}
+    Service<{}, {}, Application>
 
 export type { TRegisteredServicesIndex, TRegisteredService } from './container';
 
@@ -41,9 +40,11 @@ export type StartedServicesIndex = {
     [serviceId: string]: AnyService
 }
 
-type TServiceUseOptions = {
-    optional?: boolean
-}
+export type TServiceArgs<TService extends AnyService> = [
+    parent: AnyService | 'self',
+    getConfig: (instance: TService) => {},
+    app: TService['app'] | 'self'
+]
 
 /*----------------------------------
 - CONFIG
@@ -51,7 +52,7 @@ type TServiceUseOptions = {
 
 const LogPrefix = '[service]';
 
-export function Route(options: TControllerDefinition = {}) {
+export function Route(options: Omit<TControllerDefinition, 'controller'> = {}) {
     return function (
         target: any,
         propertyKey: string,
@@ -73,6 +74,7 @@ export function Route(options: TControllerDefinition = {}) {
             method: 'POST',
             path: '/api/' + options.path,
             controller: originalMethod,
+            schema: options.schema,
             options: {
                 priority: options.priority || 0
             }
@@ -90,36 +92,33 @@ export function Route(options: TControllerDefinition = {}) {
 - CLASS
 ----------------------------------*/
 export default abstract class Service<
-    TConfig extends TServiceConfig, 
+    TConfig extends {}, 
     THooks extends THooksList,
-    TApplication extends Application,
-    TServicesIndex extends StartedServicesIndex = {}
+    TApplication extends Application
 > {
 
     public started?: Promise<void>;
-    public status: 'stopped' | 'starting' | 'running' | 'paused' = 'stopped';
+    public status: 'stopped' | 'starting' | 'running' | 'paused' = 'starting';
 
     public commands?: Command[];
     public metas!: TServiceMetas;
     public bindings: string[] = []
 
     public app: TApplication;
+    public config: TConfig = {} as TConfig;
 
-    public constructor( 
-        public parent: AnyService | 'self', 
-        public config: TConfig,
-        // Make this argument appear as instanciated sercices index
-        // But actually, Setup.use returns a registered service, not yet launched
-        public getServices: TServicesIndex,
-        app: TApplication | 'self'
-    ) {
+    public constructor(...[parent, getConfig, app]: TServiceArgs<AnyService>) {
 
+        this.parent = parent;
         if (this.parent === 'self') 
             this.parent = this;
 
         this.app = app === 'self'
             ? this as unknown as TApplication
             : app
+
+        if (typeof getConfig === 'function')
+            this.config = getConfig(this);
         
     }
 
@@ -127,8 +126,6 @@ export default abstract class Service<
         return this;
     }
 
-    public services: TServicesIndex = {} as TServicesIndex;
-
     /*----------------------------------
     - LIFECYCLE
     ----------------------------------*/
@@ -141,13 +138,17 @@ export default abstract class Service<
     - SUBSERVICES
     ----------------------------------*/
 
-    public use( serviceId: string ) {
+    // TODO:; babel plugin: transform Service references to app.use('Service')
+    public use<TService extends AnyService = AnyService>( 
+        serviceId: string,
+        useOptions: { optional?: boolean } = {}
+    ): TService {
 
-        const serviceName = this.app.servicesIdToName[serviceId];
-        if (serviceName === undefined)
-            throw new Error(`Service ${serviceName} not found.`);
+        const registeredService = this.app.registered[serviceId];
+        if (registeredService === undefined && useOptions.optional === false)
+            throw new Error(`Service ${registeredService} not registered.`);
 
-        return this.app[ serviceName ];
+        return this.app[ registeredService.name ];
     }
 
     /*----------------------------------
@@ -182,13 +183,7 @@ export default abstract class Service<
         //this.config.debug && console.info(`[hook] Run all ${name} hook (${callbacks.length}).`);
         return Promise.all( 
             callbacks.map(
-                cb => cb(...args).catch(e => {
-
-                    if (name !== 'error')
-                        this.runHook('error', e);
-                    else 
-                        console.error(`[hook] Error while executing hook ${name}:`, e);
-                })
+                cb => cb(...args)
             ) 
         ).then(() => {
             //this.config.debug && console.info(`[hook] Hooks ${name} executed with success.`);

package/server/services/auth/index.ts

@@ -49,10 +49,6 @@ export type THooks = {
     
 }
 
-export type TServices = {
-
-}
-
 export type TBasicUser = {
     type: string,
     name: string,
@@ -73,13 +69,11 @@ export default abstract class AuthService<
     TApplication extends Application,
     TJwtSession extends TBasicJwtSession = TBasicJwtSession,
     TRequest extends ServerRequest<Router> = ServerRequest<Router>,
-> extends Service<TConfig, THooks, TApplication, TServices> {
+> extends Service<TConfig, THooks, TApplication> {
 
-    public abstract login( ...args: any[] ): Promise<{ user: TUser, token: string }>;
+    //public abstract login( ...args: any[] ): Promise<{ user: TUser, token: string }>;
     public abstract decodeSession( jwt: TJwtSession, req: THttpRequest ): Promise<TUser | null>;
 
-    protected abstract displaySessionName(session: TJwtSession): string;
-
     // https://beeceptor.com/docs/concepts/authorization-header/#examples
     public async decode( req: THttpRequest, withData: true ): Promise<TUser | null>;
     public async decode( req: THttpRequest, withData?: false ): Promise<TJwtSession | null>;
@@ -95,6 +89,8 @@ export default abstract class AuthService<
 
         // Get auth session
         const session = this.getAuthSession(tokenType, token);
+        if (session === null)
+            return null;
 
         // Return email only
         if (!withData) {
@@ -138,7 +134,7 @@ export default abstract class AuthService<
         return { tokenType, token };
     }
 
-    private getAuthSession( tokenType: string | undefined, token: string ): TJwtSession {
+    private getAuthSession( tokenType: string | undefined, token: string ): TJwtSession | null {
 
         let session: TJwtSession;
 
@@ -159,10 +155,12 @@ export default abstract class AuthService<
                 });
             } catch (error) {
                 console.warn(LogPrefix, "Failed to decode jwt token:", token);
-                throw new Forbidden(`The JWT token provided in the Authorization header is invalid`);
+                return null;
+                //throw new Forbidden(`The JWT token provided in the Authorization header is invalid`);
             }
         } else 
-            throw new InputError(`The authorization scheme provided in the Authorization header is unsupported.`);
+            return null;
+            //throw new InputError(`The authorization scheme provided in the Authorization header is unsupported.`);
 
         return session;
     }
@@ -189,9 +187,9 @@ export default abstract class AuthService<
         request.res.clearCookie('authorization');
     }
 
-    public check( request: TRequest, entity: string, role: TUserRole, motivation?: string): TUser;
-    public check( request: TRequest, entity: string, role: false, motivation?: string): null;
-    public check( request: TRequest, entity: string, role: TUserRole | false = 'USER', motivation?: string): TUser | null {
+    public check( request: TRequest, entity: string, role: TUserRole): TUser;
+    public check( request: TRequest, entity: string, role: false): null;
+    public check( request: TRequest, entity: string, role: TUserRole | false = 'USER'): TUser | null {
 
         const user = request.user;
 
@@ -201,7 +199,7 @@ export default abstract class AuthService<
 
             throw new Error(`request.user has not been decoded.`);
 
-        // No auth needed
+        // Shoudln't be logged
         } else if (role === false) {
 
             return user;
@@ -220,13 +218,13 @@ export default abstract class AuthService<
         // Insufficient permissions
         } else if (!user.roles.includes(role)) {
 
-            console.warn(LogPrefix, "Refusé: " + role + " pour " + user.name + " (" + (user.roles ? user.roles.join(', ') : 'role inconnu') + ")");
+            console.warn(LogPrefix, "Refusé: " + role + " pour " + user.name + " (" + (user.roles || 'role inconnu') + ")");
 
             throw new Forbidden("You do not have sufficient permissions to access this resource.");
 
         } else {
 
-            console.warn(LogPrefix, "Autorisé " + role + " pour " + user.name + " (" + user.roles.join(', ') + ")");
+            console.warn(LogPrefix, "Autorisé " + role + " pour " + user.name + " (" + user.roles + ")");
 
         }
 

package/server/services/auth/old.ts

@@ -13,7 +13,7 @@ type AuthResponse = {
 export default class {
 
 
-    protected async start() {
+    protected async ready() {
 
         // Google auth client
         if (this.config.google) {

package/server/services/auth/router/index.ts

@@ -6,8 +6,8 @@
 
 // Core
 import { 
-    default as Router, Request as ServerRequest, TAnyRoute,
-    RouterService
+    default as Router, Request as ServerRequest, Response as ServerResponse, TAnyRoute,
+    RouterService, TRouterServiceArgs
 } from '@server/services/router';
 
 // Specific
@@ -37,30 +37,42 @@ export default class AuthenticationRouterService<
     - LIFECYCLE
     ----------------------------------*/
 
-    public users = this.services.users;
+    public users: UsersService;
 
-    protected async start() {
+    public constructor(...args: TRouterServiceArgs) {
+        super(...args);
+
+        this.users = this.config.users;
+    }
+
+    protected async ready() {
 
         // Decode current user
         this.parent.on('request', async (request: TRequest) => {
 
             // TODO: Typings. (context.user ?)
-            const decoded = await this.services.users.decode( request.req, true);
+            const decoded = await this.users.decode( request.req, true);
 
             request.user = decoded || null;
         })
 
         // Check route permissions
-        this.parent.on('resolved', async (route: TAnyRoute, request: TRequest) => {
+        this.parent.on('resolved', async (
+            route: TAnyRoute, 
+            request: TRequest, 
+            response: ServerResponse<Router>
+        ) => {
 
-            if (route.options.auth !== undefined)
-                // TODO: How to pas the router type to router config ? Circular rfeerence ?
-                this.services.users.check(request, route.options.auth);
-        })
-    }
+            if (route.options.auth !== undefined) {
 
-    protected async ready() {
+                // Basic auth check
+                this.users.check(request, 'User', route.options.auth);
 
+                // Redirect to logged page
+                if (route.options.auth === false && request.user && route.options.redirectLogged)
+                    response.redirect(route.options.redirectLogged);
+            }
+        })
     }
 
     protected async shutdown() {

package/server/services/cache/index.ts

@@ -59,20 +59,17 @@ type TCacheGetOnlyArgs = [
 export type Config = {
     debug: boolean,
     disk: string, // TODO: keyof disks
+    disks: DisksManager
 }
 
 export type Hooks = {
 
 }
 
-export type Services = {
-    disks: DisksManager,
-}
-
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default class Cache extends Service<Config, Hooks, Application, Services> {
+export default class Cache extends Service<Config, Hooks, Application> {
 
     public commands = registerCommands(this);
 
@@ -83,29 +80,21 @@ export default class Cache extends Service<Config, Hooks, Application, Services>
     public constructor( 
         parent: AnyService, 
         config: Config,
-        services: Services,
         app: Application, 
     ) {
 
-        super(parent, config, services, app);
+        super(parent, config, app);
 
-        this.disk = this.services.disks.get(config.disk)
+        this.disk = this.config.disks.get(config.disk)
     }
 
     /*----------------------------------
     - LIFECYCLE
     ----------------------------------*/
 
-    protected async start() {
-
-        setInterval(() => this.cleanMem(), 10000);
-
-        // Restore persisted data
-        //await this.restore();
-    }
-
     public async ready() {
 
+        setInterval(() => this.cleanMem(), 10000);
     }
 
     public async shutdown() {

package/server/services/cron/index.ts

@@ -36,7 +36,7 @@ export type Services = {
 - CLASSE
 ----------------------------------*/
 
-export default class CronManager extends Service<Config, Hooks, Application, Services> {
+export default class CronManager extends Service<Config, Hooks, Application> {
 
     public static taches: { [nom: string]: CronTask } = {}
     public static timer: NodeJS.Timeout;
@@ -45,7 +45,7 @@ export default class CronManager extends Service<Config, Hooks, Application, Ser
     - LIFECICLE
     ----------------------------------*/
 
-    protected async start() {
+    public async ready() {
 
         clearInterval(CronManager.timer);
         CronManager.timer = setInterval(() => {
@@ -54,13 +54,6 @@ export default class CronManager extends Service<Config, Hooks, Application, Ser
                 CronManager.taches[id].run();
 
         }, 10000);
-    }
-  
-    public async ready() {
-  
-    }
-  
-    public async shutdown() {
   
     }
 

package/server/services/database/index.ts

@@ -10,7 +10,7 @@ const safeStringify = require('fast-safe-stringify'); // remplace les référenc
 
 // Core: general
 import { Application, Services } from '@server/app';
-import Service, { AnyService, TRegisteredServicesIndex } from '@server/app/service';
+import Service, { AnyService, TRegisteredServicesIndex, TServiceArgs } from '@server/app/service';
 import { NotFound } from '@common/errors';
 
 // Services
@@ -91,20 +91,15 @@ const emptyOkPacket = {
 
 // TODO: build callable instance sithut instanciating the service
 
-export default class SQL extends Service<Config, Hooks, Application, Services> {
+export default class SQL extends Service<Config, Hooks, Application> {
 
     public database: Database;
 
-    public constructor( 
-        parent: AnyService, 
-        config: Config,
-        drivers: TRegisteredServicesIndex,
-        app: Application, 
-    ) {
+    public constructor( ...args: TServiceArgs<SQL>) {
 
-        super(parent, config, drivers, app);
+        super(...args);
 
-        this.database = new Database(this, config);
+        this.database = new Database(this, this.config);
     }
 
     public getServiceInstance() {

package/server/services/database/stats.ts

@@ -77,8 +77,6 @@ export default class StatsService extends Service<TStatsServiceConfig> {
 
     }
 
-    protected async start() {}
-
     public async fetchStats<TDonnees extends TObjDonneesStats>(
         
         table: string, columns: (string | [string, string])[], {

package/server/services/disks/driver.ts

@@ -56,7 +56,7 @@ export type TReadFileOptions = {
 export default abstract class FsDriver<
     Config extends TDrivercnfig = TDrivercnfig,
     TBucketName = keyof Config["buckets"]
-> extends Service<Config, {}, Application, Services> {
+> extends Service<Config, {}, Application> {
 
     public abstract mount(): Promise<void>;