5htp-core 0.2.9 → 0.3.0

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

@@ -7,7 +7,8 @@
 */
 
 // Core
-import Application, { Service } from '@server/app';
+import type { Application } from '@server/app';
+import Service from '@server/app/service';
 import markdown from '@common/data/markdown';
 
 // Speciic
@@ -108,14 +109,25 @@ export default class Email extends Service<Config, Hooks, Application> {
     
     private transporters = this.config.transporters;
 
-    public async register() {
-
-    }
+    /*----------------------------------
+    - LIFECYCLE
+    ----------------------------------*/
 
     public async start() {
         
     }
 
+    public async ready() {
+
+    }
+
+    public async shutdown() {
+
+    }
+
+    /*----------------------------------
+    - ACTIONS
+    ----------------------------------*/
 
     public async send( to: string, subject: string, markdown: string, options?: TOptions );
     public async send( emails: TEmail | TEmail[], options?: TOptions ): Promise<void>;

package/src/server/services/email/service.json

@@ -0,0 +1,6 @@
+{
+    "id": "Core/Email",
+    "name": "Email",
+    "parent": "app",
+    "dependences": []
+}

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

@@ -10,21 +10,28 @@ import fs from 'fs-extra';
 import request from 'request';
 
 // Core: general
-import type Application from '@server/app';
-import Service from '@server/app/service';
+import type { Application } from '@server/app';
+import Service, { AnyService } from '@server/app/service';
+import type DisksManager from '../disks';
+import type FsDriver from '../disks/driver';
 
 /*----------------------------------
 - SERVICE TYPES
 ----------------------------------*/
 
 export type Config = {
-
+    debug?: boolean,
+    disk?: string
 }
 
 export type Hooks = {
 
 }
 
+export type Services = {
+    disks: DisksManager
+}
+
 /*----------------------------------
 - TYPES
 ----------------------------------*/
@@ -46,16 +53,47 @@ const LogPrefix = `[services][fetch]`
 - SERVICE
 -  Tools that helps to consume external resources (including apis, ..)
 -----------------------------------*/
-export default class FetchService extends Service<Config, Hooks, Application> {
+export default class FetchService extends Service<Config, Hooks, Application, Services> {
+
+    private disk?: FsDriver;
+
+    public constructor(
+        parent: AnyService, 
+        config: Config,
+        services: Services,
+        app: Application
+    ) {
 
-    public async register() {
+        super(parent, config, services, app);
+
+        if (this.services.disks)
+            this.disk = this.services.disks.get( config.disk );
         
     }
 
+    /*----------------------------------
+    - LIFECYCLE
+    ----------------------------------*/
+
     public async start() {
+
+        
+        
         
     }
 
+    public async ready() {
+
+    }
+
+    public async shutdown() {
+
+    }
+
+    /*----------------------------------
+    - ACTIONS
+    ----------------------------------*/
+
     public toBuffer( uri: string ): Promise<Buffer> {
         return new Promise<Buffer>((resolve, reject) => {
             request(uri, { encoding: null }, (err, res, body) => {
@@ -74,9 +112,15 @@ export default class FetchService extends Service<Config, Hooks, Application> {
     public async image( 
         imageFileUrl: string, 
         { width, height, fit, quality }: TImageConfig, 
-        saveToPath?: string
+        saveToBucket: string,
+        saveToPath?: string,
+        disk?: FsDriver
     ): Promise<Buffer | null> {
 
+        // Define target disk
+        if (this.disk === undefined)
+            throw new Error(`Please provide a Disks service in order to download files.`);
+
         // Download
         let imageBuffer: Buffer;
         try {
@@ -89,7 +133,7 @@ export default class FetchService extends Service<Config, Hooks, Application> {
         // Resize
         const processing = sharp( imageBuffer )
             // Max dimensions (save space)
-            .resize(width, height, { fit })
+            .resize(width, height, { fit }) 
 
         // Convert to webp and finalize
         const processedBuffer = await processing.webp({ quality }).toBuffer().catch(e => {
@@ -100,7 +144,7 @@ export default class FetchService extends Service<Config, Hooks, Application> {
         // Save file
         if (saveToPath !== undefined && processedBuffer !== null) {
             console.log(LogPrefix, `Saving ${imageFileUrl} logo to ${saveToPath}`);
-            fs.outputFileSync(saveToPath, processedBuffer);
+            await this.disk.outputFile(saveToBucket, saveToPath, processedBuffer);
         }
 
         // We return the original, because Vibrant.js doesn't support webp

package/src/server/services/fetch/service.json

@@ -0,0 +1,6 @@
+{
+    "id": "Core/Fetch",
+    "name": "Fetch",
+    "parent": "app",
+    "dependences": []
+}

package/src/server/services/router/http/index.ts

@@ -22,7 +22,9 @@ import cookieParser from 'cookie-parser';
 import * as csp from 'express-csp-header';
 
 // Core
-import Application, { Service } from '@server/app';
+import type { Application } from '@server/app';
+import Container from '@server/app/container';
+import Service from '@server/app/service';
 import type Router from '..';
 
 // Middlewaees (core)
@@ -34,6 +36,8 @@ import { MiddlewareFormData } from './multipart';
 
 export type Config = {
 
+    debug?: boolean,
+
     // Access
     domain: string,
     port: number,
@@ -58,16 +62,18 @@ export type Hooks = {
 /*----------------------------------
 - FUNCTION
 ----------------------------------*/
-export default class HttpServer extends Service<Config, Hooks, Application> {
+export default class HttpServer {
 
     public http: http.Server | https.Server;
     public express: express.Express;
 
     public publicUrl: string;
 
-    public constructor( config: Config, public router: Router ) {
-
-        super( router.app, config );
+    public constructor( 
+        public config: Config, 
+        public router: Router,
+        public app = router.app
+    ) {
 
         // Init
         this.publicUrl = this.app.env.name === 'local'
@@ -85,9 +91,6 @@ export default class HttpServer extends Service<Config, Hooks, Application> {
     /*----------------------------------
     - HOOKS
     ----------------------------------*/
-    public async register() {
-
-    }
 
     public async start() {
 
@@ -113,7 +116,7 @@ export default class HttpServer extends Service<Config, Hooks, Application> {
         routes.use('/public', cors());
         routes.use(
             '/public',
-            expressStaticGzip( this.app.path.root + '/bin/public', {
+            expressStaticGzip( Container.path.root + '/bin/public', {
                 enableBrotli: true,
                 serveStatic: {
                     setHeaders: function setCustomCacheControl(res, path) {

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

@@ -10,18 +10,17 @@
 ----------------------------------*/
 
 // Node
-import path from 'path';
-
 // Npm
 import type express from 'express';
 import { v4 as uuid } from 'uuid';
-import fs from 'fs-extra';
 import type { GlobImportedWithMetas } from 'babel-plugin-glob-import';
 
 // Core
-import Application, { Service } from '@server/app';
+import type { Application } from '@server/app';
+import Service, { AnyService } from '@server/app/service';
+import type { TRegisteredServicesIndex } from '@server/app/service/container';
 import context from '@server/context';
-import type DiskDriver from '@server/services/disks/driver';
+import type DisksManager from '@server/services/disks';
 import { CoreError, NotFound } from '@common/errors';
 import BaseRouter, {
     TRoute, TErrorRoute, TRouteModule,
@@ -29,14 +28,14 @@ import BaseRouter, {
 } from '@common/router';
 import { buildRegex, getRegisterPageArgs } from '@common/router/register';
 import { layoutsList, getLayout } from '@common/router/layouts';
-import { TFetcherList, TFetcher } from '@common/router/request/api';
+import { TFetcherList } from '@common/router/request/api';
 import type { TFrontRenderer } from '@common/router/response/page';
 import type { TSsrUnresolvedRoute, TRegisterPageArgs } from '@client/services/router';
 
 // Specific
 import RouterService from './service';
 import ServerRequest from "./request";
-import ServerResponse, { TRouterContext } from './response';
+import ServerResponse, { TRouterContext, TRouterContextServices } from './response';
 import Page from './response/page';
 import HTTP, { Config as HttpServiceConfig } from './http';
 import DocumentRenderer from './response/page/document';
@@ -49,7 +48,7 @@ export { default as RouterService } from './service';
 export { default as RequestService } from './request/service';
 export type { default as Request, UploadedFile } from "./request";
 export type { default as Response, TRouterContext } from "./response";
-export type { TRoute } from '@common/router';
+export type { TRoute, TAnyRoute } from '@common/router';
 
 export type TApiRegisterArgs<TRouter extends ServerRouter> = ([
     path: string,
@@ -78,10 +77,6 @@ export type HttpHeaders = { [cle: string]: string }
 
 const LogPrefix = '[router]';
 
-export type TRouterServicesList = {
-    [serviceName: string]: RouterService<ServerRouter>
-}
-
 export type Config<
     TServiceList extends TRouterServicesList = TRouterServicesList,
     TAdditionnalSsrData extends {} = {}
@@ -89,24 +84,23 @@ export type Config<
 
     debug: boolean,
 
-    disk: DiskDriver,
+    disk?: string, // Disk driver ID
 
     http: HttpServiceConfig
 
-    // Set it as a function, so when we instanciate the services, we can callthis.router to pass the router instance in roiuter services
-    services: TServiceList,
+    context: (
+        request: ServerRequest<ServerRouter>, 
+        app: Application
+    ) => TAdditionnalSsrData,
+}
 
-    context: (request: ServerRequest<ServerRouter>) => TAdditionnalSsrData,
+export type Services = {
+    disks?: DisksManager
+} & TRegisteredServicesIndex< RouterService<ServerRouter> >
 
-    // Protections against bots
-    // TODO: move to Protection service
-    /*security: {
-        recaptcha: {
-            prv: string,
-            pub: string
-        },
-        iphub: string
-    },*/
+// Set it as a function, so when we instanciate the services, we can callthis.router to pass the router instance in roiuter services
+type TRouterServicesList = {
+    [serviceName: string]: RouterService<ServerRouter>
 }
 
 export type Hooks = {
@@ -119,12 +113,12 @@ export type Hooks = {
 export default class ServerRouter<
     TConfig extends Config = Config,
     TApplication extends Application = Application
-> extends Service<TConfig, Hooks, TApplication> implements BaseRouter {
+> extends Service<TConfig, Hooks, TApplication, Services> implements BaseRouter {
 
     // Services
     public http: HTTP;
-    public services: TConfig["services"];
-    public render: DocumentRenderer;
+    public render: DocumentRenderer<this>;
+    protected routerServices: {[serviceId: string]: RouterService} = {}
 
     // Indexed
     public routes: TRoute[] = []; // API + pages front front
@@ -135,44 +129,59 @@ export default class ServerRouter<
     - SERVICE
     ----------------------------------*/
 
-    public constructor(app: TApplication, config: TConfig) {
+    public constructor( 
+        parent: AnyService, 
+        config: TConfig,
+        services: TRegisteredServicesIndex<RouterService>,
+        app: TApplication, 
+    ) {
 
-        super(app, config);
+        super(parent, config, services, app);
 
         this.http = new HTTP(config.http, this);
         this.render = new DocumentRenderer(this);
-        this.services = config.services;
 
     }
 
-    public async register() {
-
-        // Since route registering requires all services to be ready,
-        // We load routes only when all services are ready
-        this.app.on('ready', async () => {
-            // Use require to avoid circular references
-            this.registerRoutes([
-                ...require("metas:@/server/routes/**/*.ts"),
-                ...require("metas:@/client/pages/**/*.tsx"),
-                ...require("metas:@client/pages/**/*.tsx")
-            ]);
-        })
+    /*----------------------------------
+    - LIFECYCLE
+    ----------------------------------*/
+
+    protected async start() { 
+
+        // Detect router services
+        for (const serviceName in this.services) {
+
+            const routerService = this.services[serviceName];
+            if (routerService instanceof RouterService)
+                this.routerServices[ serviceName ] = routerService;
+        }
+
+        console.log("this.routerServices", Object.keys( this.routerServices ));
     }
 
-    public async start() {
-        this.startServices();
+    public async ready() {
+
+         // Use require to avoid circular references
+         this.registerRoutes([
+            ...require("metas:@/server/routes/**/*.ts"),
+            ...require("metas:@/client/pages/**/*.tsx"),
+            ...require("metas:@client/pages/**/*.tsx")
+        ]);
+
+        // Start HTTP server
+        await this.http.start();
+
     }
 
-    private async startServices() {
-        console.log(LogPrefix, `Starting router services`);
+    public async shutdown() {
 
-        for (const serviceId in this.services) {
-            const service = this.services[serviceId];
-            service.attach(this);
-            await service.register();
-        }
     }
 
+    /*----------------------------------
+    - ACTIONS
+    ----------------------------------*/
+
     private registerRoutes(defModules: GlobImportedWithMetas<TRouteModule>) {
 
         for (const routeModule of defModules) {
@@ -181,8 +190,14 @@ export default class ServerRouter<
             if (!register)
                 continue;
 
-            console.log(LogPrefix, `Register file:`, routeModule.matches.join('/'));
-            register(this.app);
+            this.config.debug && console.log(LogPrefix, `Register file:`, routeModule.matches.join('/'));
+            try {
+                register(this.app.services);
+            } catch (error) {
+                console.error("Failed to register route file:", routeModule);
+                console.error('Register function:', register.toString());
+                throw error;
+            }
         }
 
         this.afterRegister();
@@ -281,15 +296,12 @@ export default class ServerRouter<
 
     private async afterRegister() {
 
-        console.info("Pre-Loading request services");
-        //await TrackingService.LoadCache();
-
         // Generate typescript typings
         if (this.app.env.profile === 'dev')
             this.genTypings();
 
         // Ordonne par ordre de priorité
-        console.info("Loading routes ...");
+        this.config.debug && console.info("Loading routes ...");
         this.routes.sort((r1, r2) => {
 
             const prioDelta = r2.options.priority - r1.options.priority;
@@ -304,12 +316,12 @@ export default class ServerRouter<
             return 0;
         })
         // - Génère les définitions de route pour le client
-        console.info(`Registered routes:`);
+        this.config.debug && console.info(`Registered routes:`);
         for (const route of this.routes) {
 
             const chunkId = route.options["id"];
 
-            console.info('-',
+            this.config.debug && console.info('-',
                 route.method,
                 route.path,
                 ' :: ', JSON.stringify(route.options)
@@ -324,13 +336,13 @@ export default class ServerRouter<
 
         }
 
-        console.info(`Registered error pages:`);
+        this.config.debug && console.info(`Registered error pages:`);
         for (const code in this.errors) {
 
             const route = this.errors[code];
             const chunkId = route.options["id"];
 
-            console.info('-', code,
+            this.config.debug && console.info('-', code,
                 ' :: ', JSON.stringify(route.options)
             );
 
@@ -340,19 +352,19 @@ export default class ServerRouter<
             });
         }
 
-        console.info(`Registered layouts:`);
+        this.config.debug && console.info(`Registered layouts:`);
         for (const layoutId in layoutsList) {
 
             const layout = layoutsList[layoutId];
 
-            console.info('-', layoutId, layout);
+            this.config.debug && console.info('-', layoutId, layout);
         }
 
-        console.info(this.routes.length + " routes where registered.");
+        this.config.debug && console.info(this.routes.length + " routes where registered.");
     }
 
     private genTypings() {
-        fs.outputFileSync( path.join(this.app.path.typings, 'routes.d.ts'), `
+        /*fs.outputFileSync( path.join(this.app.path.typings, 'routes.d.ts'), `
 declare type Routes = {
         ${this.routes.map( route => `
             '${route.path}': {
@@ -363,7 +375,7 @@ declare type Routes = {
         `).join(',')}
     }
 }
-        `);
+        `);*/
     }
 
     /*----------------------------------
@@ -469,6 +481,21 @@ declare type Routes = {
         });
     }
 
+    public createContextServices( request: ServerRequest<this> ) {
+
+        const contextServices: Partial<TRouterContextServices<this>> = {}
+        for (const serviceName in this.routerServices) {
+
+            const routerService = this.routerServices[serviceName];
+            const requestService = routerService.requestService( request );
+            if (requestService !== null)
+                contextServices[ serviceName ] = requestService;
+
+        }
+
+        return contextServices;
+    }
+
     public async resolve(request: ServerRequest<this>): Promise<ServerResponse<this>> {
 
         console.info(LogPrefix, request.ip, request.method, request.domain, request.path);
@@ -541,7 +568,7 @@ declare type Routes = {
         request.res.json(responseData);
     }
 
-    private async handleError(e: CoreError, request: ServerRequest<ServerRouter>) {
+    private async handleError( e: CoreError, request: ServerRequest<ServerRouter> ) {
 
         const code = 'http' in e ? e.http : 500;
         const route = this.errors[code];

package/src/server/services/router/request/api.ts

@@ -20,7 +20,7 @@ import ApiClientService, {
 ----------------------------------*/
 export default class ApiClientRequest extends RequestService implements ApiClientService {
 
-    public async start() {
+    protected async start() {
 
     }
 

package/src/server/services/router/response/index.ts

@@ -11,11 +11,11 @@
 import express from 'express';
 
 // Core
-import Application from '@server/app';
+import { Application } from '@server/app';
 import type ServerRouter from '@server/services/router';
 import ServerRequest from '@server/services/router/request';
-import { TRoute } from '@common/router';
-import { NotFound, Forbidden } from '@common/errors';
+import { TRoute, TAnyRoute } from '@common/router';
+import { NotFound, Forbidden, Anomaly } from '@common/errors';
 import BaseResponse, { TResponseData } from '@common/router/response';
 import Page from './page';
 
@@ -50,8 +50,6 @@ export type TRouterContext<TRouter extends ServerRouter = ServerRouter> = (
     TRouterContextServices<TRouter>
 )
 
-type TRouterContextWithPage = With<TRouterContext, 'page'>
-
 export type TRouterContextServices<TRouter extends ServerRouter> = (
     // Custom context via servuces
     // For each roiuter service, return the request service (returned by roiuterService.requestService() )
@@ -92,7 +90,7 @@ export default class ServerResponse<
         this.app = this.router.app;
     }
 
-    public async runController( route: TRoute, additionnalData: {} = {} ) {
+    public async runController( route: TAnyRoute, additionnalData: {} = {} ) {
 
         this.route = route;
 
@@ -128,17 +126,9 @@ export default class ServerResponse<
     private async createContext( route: TRoute ): Promise<TRequestContext> {
 
 
-        const contextServices: Partial<TRouterContextServices<TRouter>> = {}
-        for (const serviceName in this.router.services) {
-
-            const routerService = this.router.services[serviceName];
-            const requestService = routerService.requestService( this.request );
-            if (requestService !== null)
-                contextServices[ serviceName ] = requestService;
-
-        }
+        const contextServices = this.router.createContextServices(this.request);
 
-        const customSsrData = this.router.config.context(this.request);
+        const customSsrData = this.router.config.context(this.request, this.app);
 
         const context: TRequestContext = {
             // Router context
@@ -160,7 +150,7 @@ export default class ServerResponse<
 
     public forSsr( page: Page<TRouter> ): TBasicSSrData {
 
-        const customSsrData = this.router.config.context(this.request);
+        const customSsrData = this.router.config.context(this.request, this.app);
 
         return {
             request: {
@@ -251,8 +241,12 @@ export default class ServerResponse<
         //     fichier = fichier[0] === '/'
         //         ? this.app.path.root + '/bin' + fichier
         //         : this.app.path.data + '/' + fichier;
+        // Disk not provided = file response disabled
+        if (this.router.services.disks === undefined)
+            throw new Anomaly("Router: Unable to return file response in router, because no disk has been given in the router config.");
 
-        const disk = this.router.config.disk;
+        // Retirve disk driver
+        const disk = this.router.services.disks.get('default');
 
         // Verif existance
         const fileExists = await disk.exists('data', fichier);
@@ -262,7 +256,7 @@ export default class ServerResponse<
         }
 
         // envoi fichier
-        this.data = await disk.readFile('data', fichier);
+        this.data = await disk.readFile('data', fichier, {});
         return this.end();
     }
 

package/src/server/services/router/service.json

@@ -0,0 +1,6 @@
+{
+    "id": "Core/Router",
+    "name": "Router",
+    "parent": "app",
+    "dependences": []
+}