5htp-core 0.3.2 → 0.3.3

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "5htp-core",
 	"description": "Convenient TypeScript framework designed for Performance and Productivity.",
-	"version": "0.3.2",
+	"version": "0.3.3",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/5htp-core.git",
 	"license": "MIT",
@@ -61,7 +61,6 @@
 		"mysql2": "^2.3.0",
 		"nodemailer": "^6.6.3",
 		"object-sizeof": "^1.6.3",
-		"ololog": "^1.1.175",
 		"path-to-regexp": "^6.2.0",
 		"picomatch": "^2.3.1",
 		"preact": "^10.5.15",
@@ -75,6 +74,7 @@
 		"request": "^2.88.2",
 		"sharp": "^0.29.1",
 		"sql-formatter": "^4.0.2",
+		"tslog": "^4.9.1",
 		"uuid": "^8.3.2",
 		"uuid-by-string": "^3.0.4",
 		"validator": "^13.7.0",

package/src/client/assets/css/components/button.less

@@ -65,6 +65,7 @@
         gap: @spacing / 2;
         min-width: 4em;
         font-size: 1rem;
+        z-index: 1; // Make the label on top of ::before for example
 
         li > & {
             flex: 1;
@@ -111,7 +112,7 @@
         }
 
         > i {
-            color: inherit !important;
+            color: inherit;
         }
 
     }

package/src/client/components/Dialog/Manager.tsx

@@ -185,7 +185,7 @@ export const createDialog = (app: Application, isToast: boolean): DialogActions
             </div>
         )),
 
-        loading: (title: string) => app.loading  = show({
+        loading: (title: string) => show({
             title: title,
             type: 'loading'
         }),

package/src/client/services/router/components/Page.tsx

@@ -14,45 +14,34 @@ import type Page from '../response/page';
 - PAGE STATE
 ----------------------------------*/
 
-export default ({ page, isCurrent }: { page: Page, isCurrent?: boolean }) => {
+export default ({ page }: { page: Page }) => {
 
+    /*----------------------------------
+    - CONTEXT
+    ----------------------------------*/
     const context = useContext();
 
     const [apiData, setApiData] = React.useState<{[k: string]: any} | null>( 
-        page.loading  ? null : page.data 
+        page.data || {}
     );
     page.setAllData = setApiData;
     context.data = apiData;
- 
-    React.useEffect(() => {
-
-        // Fetch the data asynchronously for the first time
-        if (/*apiData === null && */isCurrent)
-            page.fetchData().then( loadedData => {
-                page.loading  = false;
-                setApiData(loadedData);
-            })
-
-    }, [page]);
-
-    /*
-        <div 
-            class={"page" + (isCurrent ? ' current' : '')} 
-            id={page.chunkId === undefined ? undefined : 'page_' + page.chunkId}
-        >
-    */
 
+    /*----------------------------------
+    - RENDER
+    ----------------------------------*/
     //  Make request parameters and api data accessible from the page component
     return page.renderer ? (
 
         <page.renderer 
             // Services
             {...context} 
-            // URL params
-            {...context.request.data} 
-            // API data
-            data={apiData}
+            // API data & URL params
+            data={{
+                ...apiData,
+                ...context.request.data
+            }}
         />
         
-    ) : null
+    ) : 'Renderer missing'
 }

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

@@ -38,16 +38,22 @@ export default ({ service: router }: { service: Router }) => {
 
     const [pages, setPages] = React.useState<{
         current: undefined | Page,
-        //previous: undefined | Page
+        loading: boolean
     }>({
         current: context.page,
-        //previous: undefined
+        loading: false
     });
     
     const resolvePage = async (request: ClientRequest, locationUpdate?: Update) => {
 
         // WARNING: Don"t try to play with pages here, since the object will not be updated
         //  If needed to play with pages, do it in the setPages callback below
+        
+        // Set.loading  state
+        setPages( oldState => ({
+            ...oldState,
+            loading: true,
+        }));
 
         // Load the route chunks
         context.request = request;
@@ -63,9 +69,8 @@ export default ({ service: router }: { service: Router }) => {
             return;
         }
 
-        // Set.loading  state
-        newpage.isLoading = true;
-        newpage.loading  = <i src="spin" />
+        const data = context.data = await newpage.fetchData();
+
         // Add page container
         setPages( pages => {
 
@@ -74,7 +79,7 @@ export default ({ service: router }: { service: Router }) => {
             // Check if the page changed
             if (currentRoute?.path === request.path)  {
                 console.warn(LogPrefix, "Canceling navigation to the same page:", {...request});
-                return pages;
+                return { ...pages, loading: false }
             }
 
             // If if the layout changed
@@ -88,7 +93,7 @@ export default ({ service: router }: { service: Router }) => {
                 //  Find a way to unload the  previous layout / page resources before to load the new one
                 console.log(LogPrefix, `Changing layout. Before:`, curLayout, 'New layout:', newLayout);
                 window.location.replace(request.url);
-                return pages;
+                return { ...pages, loading: false }
 
                 context.app.setLayout(newLayout);
             }
@@ -98,13 +103,13 @@ export default ({ service: router }: { service: Router }) => {
             if (oldPage !== undefined) {
                 setTimeout(() => setPages({ 
                     current: newpage,
-                    //previous: undefined
+                    loading: false
                 }), 500);
             }
 
             return  {
                 current: newpage,
-                //previous: oldPage
+                loading: false
             }
         });
     }
@@ -116,7 +121,7 @@ export default ({ service: router }: { service: Router }) => {
             inline: "nearest"
         })
 
-    // First load
+    // First render
     React.useEffect(() => {
 
         // Resolve page if it wasn't done via SSR
@@ -158,9 +163,16 @@ export default ({ service: router }: { service: Router }) => {
 
         {pages.current && (
             <PageComponent page={pages.current} 
-                isCurrent 
-                key={pages.current.id === undefined ? undefined : 'page_' + pages.current.id} 
+                /* Create a new instance of the Page component every time the page change 
+                Otherwise the page will memorise the data of the previous page */
+                key={pages.current.chunkId === undefined ? undefined : 'page_' + pages.current.chunkId} 
             />
         )}
+
+        {pages.loading && (
+            <div id="loading">
+                <i src="spin" />
+            </div>
+        )}
     </>
 }

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

@@ -48,9 +48,9 @@ export default class ApiClient implements ApiClientService {
     - HIGH LEVEL
     ----------------------------------*/
 
-    public fetch<TProvidedData extends TFetcherList = TFetcherList>( 
-        fetchers: TFetcherList 
-    ): TDataReturnedByFetchers<TProvidedData> {
+    public fetch<FetchersList extends TFetcherList = TFetcherList>( 
+        fetchers: FetchersList 
+    ): TDataReturnedByFetchers<FetchersList> {
         throw new Error("api.fetch shouldn't be called here.");
     }
 

package/src/client/services/router/response/page.ts

@@ -24,8 +24,6 @@ import type ClientRouter from '..';
 
 export default class ClientPage<TRouter = ClientRouter> extends PageResponse<TRouter> {
 
-    public isLoading: boolean = false;
-    public loading: false | ComponentChild;
     public scrollToId: string;
 
     public constructor(
@@ -45,11 +43,9 @@ export default class ClientPage<TRouter = ClientRouter> extends PageResponse<TRo
 
         // Add the page to the context
         this.context.page = this;
-        this.isLoading = true;
 
         // Data succesfully loaded
         this.data = data || await this.fetchData();
-        this.isLoading = false;
 
         return this;
     }

package/src/common/router/index.ts

@@ -91,15 +91,15 @@ export type TRouteOptions = {
     // Resolving
     domain?: string,
     accept?: string,
-
-    // Access Restriction
     auth?: TUserRole | boolean,
-    //form?: TSchema,
+
+    // Rendering
+    static?: boolean,
     layout?: false | string, // The nale of the layout
 
+    // To cleanup
     TESTING?: boolean,
     logging?: boolean,
-
 }
 
 export type TRouteModule<TRegisteredRoute = any> = { 

package/src/common/router/request/api.ts

@@ -14,11 +14,7 @@ import type { FileToUpload } from '@client/components/inputv3/file';
 // By example if we want to fetch an api endpoint only if the url contains a certain url parameter
 export type TFetcherList = { [id: string]: TFetcher | undefined }
 
-export type TPostData = {[key: string]: PrimitiveValue}
-
-export type TPostDataWithFile = {[key: string]: PrimitiveValue | FileToUpload}
-
-export type TFetcher<TData extends unknown = unknown> = {
+export type TFetcher<TData extends any = unknown> = {
 
     // For async calls: api.post(...).then((data) => ...)
     then: (callback: (data: TData) => void) => Promise<TData>,
@@ -44,12 +40,16 @@ export type TApiFetchOptions = {
     encoding?: 'json' | 'multipart'
 }
 
+export type TPostData = {[key: string]: PrimitiveValue}
+
+export type TPostDataWithFile = {[key: string]: PrimitiveValue | FileToUpload}
+
 // https://stackoverflow.com/questions/44851268/typescript-how-to-extract-the-generic-parameter-from-a-type
 type TypeWithGeneric<T> = TFetcher<T>
 type extractGeneric<Type> = Type extends TypeWithGeneric<infer X> ? X : never
 
 export type TDataReturnedByFetchers<TProvidedData extends TFetcherList = {}> = {
-    [Property in keyof TProvidedData]: undefined | (extractGeneric<TProvidedData[Property]> extends ((...args: any[]) => any) 
+    [Property in keyof TProvidedData]: (extractGeneric<TProvidedData[Property]> extends ((...args: any[]) => any) 
         ? ThenArg<ReturnType< extractGeneric<TProvidedData[Property]> >>
         : extractGeneric<TProvidedData[Property]>
     )

package/src/common/router/response/page.ts

@@ -35,7 +35,7 @@ export type TFrontRenderer<
         TAdditionnalData
         &
         {
-            data: TDataReturnedByFetchers<TProvidedData>
+            data: {[key: string]: PrimitiveValue}
         }
     )
 ) => VNode<any> | null

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

@@ -106,7 +106,8 @@ export class ServicesContainer<
             ...Object.getOwnPropertyNames( Object.getPrototypeOf( instance )),
             ...Object.getOwnPropertyNames( instance ),
             // service.launch() isn't included, maybe because parent abstract class
-            'launch'
+            'launch',
+            'bindServices'
         ];
 
         for (const method of methods)

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

@@ -83,8 +83,7 @@ export default abstract class Service<
             : app
 
         // Instanciate subservices
-        for (const localName in services)
-            this.bindService( localName, services[localName] as unknown as TRegisteredService );
+        this.bindServices( services );
         
     }
 
@@ -155,7 +154,7 @@ export default abstract class Service<
         ReturnType< TServiceClass["getServiceInstance"] >
         &
         {
-            new (...args: any[]): TServiceClass & { services: TSubServices },
+            new (...args: any[]): TServiceClass["getServiceInstance"] & { services: TSubServices },
             services: TSubServices
         }
         /*Omit<TServiceClass, 'services'> & {
@@ -169,12 +168,17 @@ export default abstract class Service<
             throw new Error(`Unable to use service "${serviceId}": This one hasn't been setup.`);
 
         // Bind subservices
-        registered.subServices = subServices || {};
+        if (subServices !== undefined)
+            registered.subServices = {
+                ...registered.subServices,
+                ...subServices
+            };
 
         // Check if not already instanciated
         const existing = ServicesContainer.allServices[ serviceId ];
         if (existing !== undefined) {
             console.info("Service", serviceId, "already instanciated through another service.");
+            existing.bindServices( registered.subServices );
             return existing;
         }
 
@@ -183,14 +187,25 @@ export default abstract class Service<
         const ServiceClass = registered.metas.class().default;
 
         // Create class instance
-        const service = new ServiceClass(this, registered.config, registered.subServices, this.app || this)
-            .getServiceInstance()
+        const service = new ServiceClass(
+            this, 
+            registered.config, 
+            registered.subServices, 
+            this.app || this
+        )
+        const serviceInstance = service.getServiceInstance();
 
         // Bind his own metas
         service.metas = registered.metas;
-        ServicesContainer.allServices[ registered.metas.id ] = service;
+        ServicesContainer.allServices[ registered.metas.id ] = serviceInstance;
+
+        return serviceInstance;
+    }
 
-        return service;
+    public bindServices( services: TServicesIndex ) {
+
+        for (const localName in services)
+            this.bindService( localName, services[localName] as unknown as TRegisteredService );
     }
 
     public bindService( localName: string, service: AnyService ) {

package/src/server/app.tsconfig.json

@@ -5,7 +5,7 @@
         "baseUrl": "..",
         "paths": {
 
-            "@/server/models": ["./server/.generated/models"],
+            "@/server/models": ["./server/.generated/models.d.ts"],
 
             "@client/*": ["../node_modules/5htp-core/src/client/*"],
             "@common/*": ["../node_modules/5htp-core/src/common/*"],

package/src/server/services/console/html.ts

@@ -3,8 +3,8 @@
 ----------------------------------*/
 // Npm
 import Ansi2Html from 'ansi-to-html';
-import { Logger, ILogObject } from "tslog"
-import type { Console } from '.';;
+import { formatWithOptions } from 'util';
+import type { default as Console, TJsonLog } from '.';;
 
 var ansi2Html = new Ansi2Html({
     newline: true,
@@ -35,30 +35,31 @@ var ansi2Html = new Ansi2Html({
 /*----------------------------------
 - METHOD
 ----------------------------------*/
-export default (log: ILogObject, c: Console) => {
+export default (log: TJsonLog, c: Console) => {
 
-    if (log.logLevel === 'error') {
+    // Print metas as ANSI
+    const logMetaMarkup = c.logger._prettyFormatLogObjMeta({
+        date: log.time,
+        logLevelId: c.getLogLevelId( log.level ),
+        logLevelName: log.level,
+        // We consider that having the path is useless in this case
+        path: undefined,
+    });
 
-        // Enrichissement erreurs
-        for (const arg of log.argumentsArray) {
-
-            // Chemin complet pour pouvoir l'ouvrir dans un éditeyr via un clic
-            if (typeof arg === 'object' && arg.stack !== undefined) for (const stack of arg.stack)
-                stack.filePath = stack.fullFilePath;
-
-        }
-    }
-
-    // BUG: log.date pas pris encompte, affiche la date actuelle
-    //  https://github.com/fullstack-build/tslog/blob/master/src/LoggerWithoutCallSite.ts#L509
-
-    let ansi: string = '';
-    const myStd = { write: (message: string) => ansi += message }
-    c.logger.printPrettyLog(myStd, log);
+    // Print args as ANSI
+    const logArgsAndErrorsMarkup =  c.logger.runtime.prettyFormatLogObj( log.args, c.logger.settings);
+    const logErrors = logArgsAndErrorsMarkup.errors;
+    const logArgs = logArgsAndErrorsMarkup.args;
+    const logErrorsStr = (logErrors.length > 0 && logArgs.length > 0 ? "\n" : "") + logErrors.join("\n");
+    c.logger.settings.prettyInspectOptions.colors = c.logger.settings.stylePrettyLogs;
+    let ansi = logMetaMarkup + formatWithOptions(c.logger.settings.prettyInspectOptions, ...logArgs) + logErrorsStr;
 
+    // Use HTML spaces
     ansi = ansi.replace(/ {2}/g, ' ');
     ansi = ansi.replace(/\t/g, ' '.repeat(8));
+    ansi = ansi.replace(/\n/g, '<br/>');
 
+    // Convert ANSI to HTML
     const html = ansi2Html.toHtml(ansi)
 
     return html;

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

@@ -1,9 +1,14 @@
 /*----------------------------------
 - DEPENDANCES
 ----------------------------------*/
+
+// Node
+import { serialize } from 'v8';
+import { formatWithOptions } from 'util';
+
 // Npm
 import { v4 as uuid } from 'uuid';
-import log from 'ololog';
+import { Logger, IMeta, ILogObj, ISettings } from 'tslog';
 import { format as formatSql } from 'sql-formatter';
 import highlight from 'cli-highlight';
 
@@ -85,8 +90,14 @@ export type TDbQueryLog = ChannelInfos & {
     time: number,
 }
 
-export type TLog = ILogObject &  ChannelInfos
+export type TLogLevel = keyof typeof logLevels
 
+export type TJsonLog = {
+    time: Date,
+    level: TLogLevel,
+    args: unknown[],
+    channel: ChannelInfos
+}
 
 /*----------------------------------
 - CONST
@@ -96,21 +107,12 @@ const LogPrefix = '[console]'
 
 const errorMailInterval = (1 * 60 * 60 * 1000); // 1 hour
 
-const logFields = [
-    'date',
-    'logLevelId',
-    'logLevel',
-
-    'isConstructor',
-    'methodName',
-    'functionName',
-    'typeName',
-
-    'filePath',
-    'lineNumber',
-    'argumentsArray',
-    'stack',
-] as const
+const logLevels = {
+    'log': 0, 
+    'info': 3, 
+    'warn': 4, 
+    'error': 5
+} as const
 
 /*----------------------------------
 - LOGGER
@@ -118,21 +120,16 @@ const logFields = [
 export default class Console extends Service<Config, Hooks, Application, Services> {
 
     // Services
-    public logger!: Logger;
-
+    public logger!: Logger<ILogObj>;
     // Buffers
-    public logs: TLog[] = [];
-    public clients: TGuestLogs[] = [];
-    public requests: TRequestLogs[] = [];
-    public sqlQueries: TDbQueryLog[] = [];
+    public logs: TJsonLog[] = [];
     // Bug ID => Timestamp latest send
     private sentBugs: {[bugId: string]: number} = {};
 
-    // Adapters
-    public log = console.log;
-    public warn = console.warn;
-    public info = console.info;
-    public error = console.error;
+    // Old (still useful???)
+    /*public clients: TGuestLogs[] = [];
+    public requests: TRequestLogs[] = [];
+    public sqlQueries: TDbQueryLog[] = [];*/
 
     /*----------------------------------
     - LIFECYCLE
@@ -140,34 +137,62 @@ export default class Console extends Service<Config, Hooks, Application, Service
 
     protected async start() {
 
-        const envConfig = this.config[ this.app.env.profile ];
-
-        /*const origConsole = console;
-        console.log = (...args: unknown[]) => log(...args)*/
+        const origLog = console.log
 
-        /*this.logger = new Logger({
-            overwriteConsole: true,
-            //type: this.app.env.profile === 'dev' ? 'pretty' : 'hidden',
-            requestId: (): string => {
-                const { channelType, channelId } = this.getChannel();
-                return channelId === undefined ? channelType : channelType + ':' + channelId;
-            },
-            displayRequestId: false,
+        this.logger = new Logger({
+            // Use to improve performance in production
             hideLogPositionForProduction: this.app.env.profile === 'prod',
+            type: 'pretty',
             prettyInspectOptions: {
                 depth: 2
+            },
+            overwrite: {
+                formatMeta: (meta?: IMeta) => {
+
+                    // Shorten file paths
+                    if (meta?.path !== undefined) {
+                        meta.path.filePathWithLine = this.shortenFilePath( meta.path.filePathWithLine );
+                    }
+
+                    return this.logger._prettyFormatLogObjMeta( meta );
+                },
+                transportFormatted: (
+                    logMetaMarkup: string, 
+                    logArgs: unknown[], 
+                    logErrors: string[], 
+                    settings: ISettings<ILogObj>
+                ) => {
+                    const logErrorsStr = (logErrors.length > 0 && logArgs.length > 0 ? "\n" : "") + logErrors.join("\n");
+                    settings.prettyInspectOptions.colors = settings.stylePrettyLogs;
+                    origLog(logMetaMarkup + formatWithOptions(settings.prettyInspectOptions, ...logArgs) + logErrorsStr);
+                },
             }
         });
 
-        this.logger.attachTransport({
-            silly: this.logEntry.bind(this),
-            debug: this.logEntry.bind(this),
-            trace: this.logEntry.bind(this),
-            info: this.logEntry.bind(this),
-            warn: this.logEntry.bind(this),
-            error: this.logEntry.bind(this),
-            fatal: this.logEntry.bind(this),
-        }, envConfig.level);*/
+        if (console["_wrapped"] !== undefined)
+            return;
+
+        for (const logLevel in logLevels) {
+            console[ logLevel ] = (...args: any[]) => {
+
+                // Dev mode = no care about performance = rich logging
+                if (this.app.env.profile === 'dev')
+                    //this.logger[ logLevel ](...args);
+                    origLog(...args);
+                // Prod mode = minimal logging  
+
+                const channel = this.getChannel();
+
+                this.logs.push({
+                    time: new Date,
+                    level: logLevel,
+                    args,
+                    channel
+                });
+            }
+        }
+        
+        console["_wrapped"] = true;
 
         setInterval(() => this.clean(), 10000);
     }
@@ -180,15 +205,50 @@ export default class Console extends Service<Config, Hooks, Application, Service
 
     }
 
+    /*----------------------------------
+    - LOGS FORMATTING
+    ----------------------------------*/
+
+    public shortenFilePath( filepath?: string ) {
+
+        if (filepath === undefined)
+            return undefined;
+
+        const projectRoot = this.app.container.path.root;
+        if (filepath.startsWith( projectRoot ))
+            filepath = filepath.substring( projectRoot.length )
+
+        const frameworkRoot = '/node_modules/5htp-core/src/';
+        if (filepath.startsWith( frameworkRoot ))
+            filepath = '@' + filepath.substring( frameworkRoot.length )
+
+        return filepath;
+
+    }
+    
+
     /*----------------------------------
     - ACTIONS
     ----------------------------------*/
 
+    public getLogLevelId( logLevelName: TLogLevel ) {
+        return logLevels[ logLevelName ]
+    }
+
     private clean() {
-        /*this.config.debug && console.log(LogPrefix, `Clean logs buffer. Current size:`, this.logs.length, '/', this.config.bufferLimit);
+
+        if (this.config.debug) {
+            console.log(
+                LogPrefix, 
+                `Clean logs buffer. Current size:`, 
+                this.logs.length, '/', this.config.bufferLimit,
+                'Memory Size:', serialize(this.logs).byteLength
+            );
+        }
+
         const bufferOverflow = this.logs.length - this.config.bufferLimit;
         if (bufferOverflow > 0)
-            this.logs = this.logs.slice(bufferOverflow);*/
+            this.logs = this.logs.slice(bufferOverflow);
     }
 
     public async createBugReport( error: Error, request?: ServerRequest ) {
@@ -223,7 +283,7 @@ export default class Console extends Service<Config, Hooks, Application, Service
         // On envoi l'email avant l'insertion dans bla bdd
         // Car cette denrière a plus de chances de provoquer une erreur
         const logsHtml = this.printHtml(
-            this.logs/*.filter(e => e.channelId === channelId)*/.slice(-100), 
+            this.logs.filter( e => e.channel.channelId === channelId).slice(-100), 
             true
         );
 
@@ -252,95 +312,10 @@ export default class Console extends Service<Config, Hooks, Application, Service
         }
     }
 
-    private logEntry(entry: ILogObject) {
-
-        // Don't keep logs from the admin sashboard
-        const [channelType, channelId] = entry.requestId?.split(':') || ['master'];
-        if (entry.requestId === 'admin')
-            return;
-
-        // Only keep data required by printPrettyLog
-        // https://github.com/fullstack-build/tslog/blob/4f045d61333230bd0f9db0e0d59cb1e81fc03aa6/src/LoggerWithoutCallSite.ts#L509
-        const miniLog: TObjetDonnees = { channelType, channelId };
-        for (const k of logFields)
-            miniLog[k] = entry[k];
-
-        this.logs.push(miniLog as TLog);
-    }
-
-    public client( client: TGuestLogs ) {
-        this.clients.push(client);
-    }
-
-    public request( request: TRequestLogs ) {
-
-        if (request.id === 'admin')
-            return;
-
-        this.requests.push( request );
-    }
-
-    public database( dbQuery: TDbQueryLog ) {
-
-        this.requests.push( dbQuery );
-    }
-
     /*----------------------------------
     - READ
     ----------------------------------*/
 
-    /*public getClients() {
-        return sql`
-            SELECT * FROM logs.Clients
-            ORDER BY activity DESC
-            LIMIT 100
-        `.all();
-    }
-
-    public async getClient(clientId: string) {
-        return (
-            this.clients.find(c => c.id === clientId)
-            ||
-            await sql`
-                SELECT * FROM logs.Clients
-                WHERE id = ${clientId}
-            `.first()
-        )
-    }
-
-    public getRequests(clientId?: string) {
-        return sql`
-            SELECT * FROM logs.Requests
-            ORDER BY date DESC
-            LIMIT 100
-        `.all();
-    }
-
-    public async getRequest(requestId: string) {
-        return (
-            this.requests.find(r => r.id === requestId)
-            ||
-            await sql`
-                SELECT * FROM logs.Requests
-                WHERE id = ${requestId}
-            `.first()
-        )
-    }
-
-    public getQueries( channelType: ChannelInfos["channelType"], channelId?: string ) {
-
-        const filters: Partial<TDbQueryLog> = { channelType };
-        if (channelId !== undefined)
-            filters.channelId = channelId;
-
-        return sql`
-            SELECT * FROM logs.Queries
-            WHERE :${filters} 
-            ORDER BY date DESC
-            LIMIT 100
-        `.all();
-    }*/
-
     public async getLogs( channelType: ChannelInfos["channelType"], channelId?: string ) {
 
         const filters: Partial<TDbQueryLog> = { channelType };
@@ -373,7 +348,7 @@ export default class Console extends Service<Config, Hooks, Application, Service
         return this.printHtml( entries );
     }
  
-    public printHtml(logs: TLog[], full: boolean = false): string {
+    public printHtml( logs: TJsonLog[], full: boolean = false ): string {
 
         let html = logs.map( logEntry => logToHTML( logEntry, this )).join('\n');
 

package/src/server/services/cron/CronTask.ts

@@ -9,7 +9,7 @@ import cronParser, { CronExpression } from 'cron-parser';
 - TYPES
 ----------------------------------*/
 
-import type { CronManager } from '.';
+import type CronManager from '.';
 
 export type TFrequence = string | Date;
 export type TRunner = () => Promise<any>
@@ -22,17 +22,15 @@ export default class CronTask {
     public cron?: CronExpression
     public nextInvocation?: Date;
 
-    private debug?: boolean;
-
     public constructor(
-        manager: CronManager,
+        private manager: CronManager,
         public nom: string,
         next: TFrequence,
         public runner: TRunner,
         public autoexec?: boolean
     ) {
 
-        console.info(`[cron][${this.nom}] Enregistrement de la tâche`);
+        this.manager.config.debug && console.info(`[cron][${this.nom}] Enregistrement de la tâche`);
 
         this.schedule(next);
 
@@ -48,13 +46,15 @@ export default class CronTask {
             this.cron = cronParser.parseExpression(next);
             this.nextInvocation = this.cron.next().toDate();
 
-            console.info(`[cron][${this.nom}] Planifié pour ${this.nextInvocation.toISOString()} via cron ${next}`);
+            this.manager.config.debug && 
+                console.info(`[cron][${this.nom}] Planifié pour ${this.nextInvocation.toISOString()} via cron ${next}`);
 
             // Date
         } else {
 
             this.nextInvocation = next;
-            console.info(`[cron][${this.nom}] Planifié pour ${this.nextInvocation.toISOString()} via date`);
+            this.manager.config.debug && 
+                console.info(`[cron][${this.nom}] Planifié pour ${this.nextInvocation.toISOString()} via date`);
 
         }
     }
@@ -80,7 +80,7 @@ export default class CronTask {
 
         // Execution
         this.runner().then(() => {
-            console.info(`Tâche executée.`);
+            this.manager.config.debug && console.info(`Task runned.`);
         })
     }
 }

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

@@ -21,7 +21,7 @@ export { default as CronTask } from './CronTask';
 ----------------------------------*/
 
 export type Config = {
-   
+   debug?: boolean
 }
 
 export type Hooks = {
@@ -46,8 +46,6 @@ export default class CronManager extends Service<Config, Hooks, Application, Ser
     ----------------------------------*/
 
     protected async start() {
-        
-        this.app.on('cleanup', () => this.cleanup());
 
         clearInterval(CronManager.timer);
         CronManager.timer = setInterval(() => {

package/src/server/services/database/metas.ts

@@ -111,8 +111,6 @@ const LogPrefix = '[database][meta]';
 const sqlTypeParamsReg = /\'([^\']+)\'\,?/gi;
 const typeViaCommentReg = /\[type=([a-z]+)\]/g;
 
-const modelsTypesPath = process.cwd() + '/src/server/models.ts';
-
 /*----------------------------------
 - FUNCTIONS
 ----------------------------------*/
@@ -368,11 +366,11 @@ export default class MySQLMetasParser {
             }
         }
 
+        // Given that this file is updated during run time, 
+        // We output a typescript ambient file, so the file change doest trigger infinite app reload
         fs.outputFileSync( 
-            path.join( Container.path.server.generated, 'models.ts'), 
+            path.join( Container.path.server.generated, 'models.d.ts'), 
             types.join('\n') 
         );
-        this.debug && console.log(LogPrefix, `Wrote database types to ${modelsTypesPath}`);
-        
     }
 }

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

@@ -126,6 +126,9 @@ export default class ServerRouter<
     public errors: { [code: number]: TErrorRoute } = {};
     public ssrRoutes: TSsrUnresolvedRoute[] = [];
 
+    // Cache (ex: for static pages)
+    public cache: {[pageId: string]: string} = {}
+
     /*----------------------------------
     - SERVICE
     ----------------------------------*/

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

@@ -97,25 +97,40 @@ export default class ServerResponse<
         // Create response context for controllers
         const context = await this.createContext(route);
 
+        // Static rendering
+        const chunkId = route.options["id"];
+        if (route.options.static && 
+            chunkId !== undefined 
+            && 
+            this.router.cache[ chunkId ] !== undefined
+        ) {
+            await this.html( this.router.cache[ chunkId ] );
+            return;
+        }
+
         // Run controller
-        const response = await this.route.controller( context );
+        const content = await this.route.controller( context );
 
-        // Handle response type
-        if (response === undefined)
+        // Handle content type
+        if (content === undefined)
             return;
 
-        // No need to process the response
-        if (response instanceof ServerResponse)
+        // No need to process the content
+        if (content instanceof ServerResponse)
             return;
         // Render react page to html
-        else if (response instanceof Page)
-            await this.render(response, context, additionnalData);
+        else if (content instanceof Page)
+            await this.render(content, context, additionnalData);
         // Return HTML
-        else if (typeof response === 'string' && this.route.options.accept === 'html')
-            await this.html(response);
+        else if (typeof content === 'string' && this.route.options.accept === 'html')
+            await this.html(content);
         // Return JSON
         else
-            await this.json(response);
+            await this.json(content);
+
+        // Cache
+        if (route.options.static)
+            this.router.cache[ chunkId ] = this.data;
     }
 
     /*----------------------------------

package/src/types/global/modules.d.ts

@@ -36,7 +36,7 @@ declare module "*.svg" {
     export = value;
 }
 
-declare module "*.(png|webp)" {
+declare module "*.(png|webp|jpg|jpeg|gif|bmp)" {
     const value: string;
     export = value;
 }