5htp-core 0.3.1 → 0.3.2

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "5htp-core",
 	"description": "Convenient TypeScript framework designed for Performance and Productivity.",
-	"version": "0.3.1",
+	"version": "0.3.2",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/5htp-core.git",
 	"license": "MIT",

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

@@ -19,7 +19,7 @@ export const Link = ({ to, ...props }: {
 } & React.HTMLProps<HTMLAnchorElement>) => {
 
     // External = open in new tab by default
-    if (to[0] !== '/' || to.startsWith('//'))
+    if (to && (to[0] !== '/' || to.startsWith('//')))
         props.target = '_blank';
     // Otherwise, propagate to the router
     else 

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

@@ -22,6 +22,7 @@ export default ({ page, isCurrent }: { page: Page, isCurrent?: boolean }) => {
         page.loading  ? null : page.data 
     );
     page.setAllData = setApiData;
+    context.data = apiData;
  
     React.useEffect(() => {
 
@@ -50,7 +51,7 @@ export default ({ page, isCurrent }: { page: Page, isCurrent?: boolean }) => {
             // URL params
             {...context.request.data} 
             // API data
-            {...apiData} 
+            data={apiData}
         />
         
     ) : null

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

@@ -20,7 +20,7 @@ import BaseRouter, {
 import { getLayout } from '@common/router/layouts';
 import { getRegisterPageArgs, buildRegex } from '@common/router/register';
 import { TFetcherList } from '@common/router/request/api';
-import type { TFrontRenderer, TDataProvider } from '@common/router/response/page';
+import type { TFrontRenderer } from '@common/router/response/page';
 
 import App from '@client/app/component';
 import type ClientApplication from '@client/app';
@@ -61,21 +61,18 @@ export type Response = ClientResponse<ClientRouter> | ServerResponse<ServerRoute
 - TYPES: ROUTES LOADING
 ----------------------------------*/
 
-// WARN: To be updated with the mplemenations list of Router.page
+// WARN: To be updated with the mplemenations list of Router.page AND the routes babel plugin
 //      (both server and client side)
-export type TRegisterPageArgs<TProvidedData extends TFetcherList = {}, TRouter extends Router = Router> = ([
+export type TRegisterPageArgs<
+    TProvidedData extends TFetcherList = TFetcherList, 
+    TRouter extends Router = Router
+> = ([
     path: string,
-    controller: TDataProvider<TProvidedData> | null,
     renderer: TFrontRenderer<TProvidedData>
 ] | [
     path: string,
     options: Partial<TRoute["options"]>,
     renderer: TFrontRenderer<TProvidedData>
-] | [
-    path: string,
-    options: Partial<TRoute["options"]>,
-    controller: TDataProvider<TProvidedData> | null,
-    renderer: TFrontRenderer<TProvidedData>
 ])
 
 // Route definition passed by the server
@@ -221,28 +218,20 @@ export default class ClientRouter<
         return currentRoute;
     }
 
-    public page(
+    public page<TProvidedData extends TFetcherList = TFetcherList>(
         path: string,
-        controller: TDataProvider<{}> | null,
-        renderer: TFrontRenderer<{}>
+        renderer: TFrontRenderer<TProvidedData>
     ): TRoute;
 
-    public page(
+    public page<TProvidedData extends TFetcherList = TFetcherList>(
         path: string,
         options: Partial<TRoute["options"]>,
-        renderer: TFrontRenderer<{}>
-    ): TRoute;
-
-    public page(
-        path: string,
-        options: Partial<TRoute["options"]>,
-        controller: TDataProvider<{}> | null,
-        renderer: TFrontRenderer<{}>
+        renderer: TFrontRenderer<TProvidedData>
     ): TRoute;
 
     public page(...args: TRegisterPageArgs): TRoute {
 
-        const { path, options, controller, renderer, layout } = getRegisterPageArgs(...args);
+        const { path, options, renderer, layout } = getRegisterPageArgs(...args);
 
         // S'il s'agit d'une page, son id doit avoir été injecté via le plugin babel
         const id = options["id"];
@@ -260,7 +249,7 @@ export default class ClientRouter<
                 ...defaultOptions,
                 ...options
             },
-            controller: (context: TClientOrServerContext) => new ClientPage(controller, renderer, context, layout)
+            controller: (context: TClientOrServerContext) => new ClientPage(route, renderer, context, layout)
         };
 
         this.routes.push(route);
@@ -275,7 +264,7 @@ export default class ClientRouter<
 
         const route: TErrorRoute = {
             code,
-            controller: (context: TClientOrServerContext) => new ClientPage(null, renderer, context, layout),
+            controller: (context: TClientOrServerContext) => new ClientPage(route, renderer, context, layout),
             options
         };
 
@@ -391,7 +380,9 @@ export default class ClientRouter<
 
         const response = await this.createResponse(route, request, apiData)
 
-        ReactDOM.hydrate( <App context={response.context} />, document.body, () => {
+        ReactDOM.hydrate((
+            <App context={response.context} />
+        ), document.body, () => {
 
             console.log(`Render complete`);
 
@@ -404,7 +395,7 @@ export default class ClientRouter<
         pageData: {} = {}
     ): Promise<ClientPage> {
 
-        // Load if not done before
+        // Load the route if not done before
         if ('load' in route)
             route = this.routes[route.index] = await this.load(route);
 

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

@@ -9,7 +9,8 @@ import axios, { AxiosResponse, AxiosError, AxiosRequestConfig } from 'axios';
 import type { TApiResponseData } from '@server/services/router';
 import ApiClientService, { 
     TPostData,
-    TApiFetchOptions, TFetcherList, TFetcherArgs, TFetcher 
+    TApiFetchOptions, TFetcherList, TFetcherArgs, TFetcher,
+    TDataReturnedByFetchers
 } from '@common/router/request/api';
 import { instancierViaCode, NetworkError } from '@common/errors';
 import type ClientApplication from '@client/app';
@@ -46,6 +47,13 @@ export default class ApiClient implements ApiClientService {
     /*----------------------------------
     - HIGH LEVEL
     ----------------------------------*/
+
+    public fetch<TProvidedData extends TFetcherList = TFetcherList>( 
+        fetchers: TFetcherList 
+    ): TDataReturnedByFetchers<TProvidedData> {
+        throw new Error("api.fetch shouldn't be called here.");
+    }
+
     public get = <TData extends unknown = unknown>(path: string, data?: TPostData, opts?: TApiFetchOptions) => 
         this.createFetcher<TData>('GET', path, data, opts);
 
@@ -120,7 +128,7 @@ export default class ApiClient implements ApiClientService {
         /*if (options?.captcha !== undefined)
             await this.gui.captcha.check(options?.captcha);*/
 
-        return await this.fetch<TData>(method, path, data, options).catch((e) => {
+        return await this.execute<TData>(method, path, data, options).catch((e) => {
             this.app.handleError(e);
             throw e; // Throw to break the loop
         })
@@ -141,7 +149,7 @@ export default class ApiClient implements ApiClientService {
         // Fetch all the api data thanks to one http request
         const fetchedData = fetchersCount === 0
             ? 0
-            : await this.fetch("POST", "/api", { 
+            : await this.execute("POST", "/api", { 
                 fetchers: fetchersToRun 
             }).then((res) => {
 
@@ -201,7 +209,7 @@ export default class ApiClient implements ApiClientService {
         return config;
     }
     
-    public fetch<TData = unknown>(...args: TFetcherArgs): Promise<TData> {
+    public execute<TData = unknown>(...args: TFetcherArgs): Promise<TData> {
     
         const config = this.configure(...args);
         

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

@@ -6,8 +6,8 @@
 import type { ComponentChild } from 'preact';
 
 // Core
-import type { TClientOrServerContext, Layout } from '@common/router';
-import PageResponse, { TDataProvider, TFrontRenderer } from "@common/router/response/page";
+import type { TClientOrServerContext, Layout, TRoute, TErrorRoute } from '@common/router';
+import PageResponse, { TFrontRenderer } from "@common/router/response/page";
 
 // Specific
 import type ClientRouter from '..';
@@ -29,15 +29,13 @@ export default class ClientPage<TRouter = ClientRouter> extends PageResponse<TRo
     public scrollToId: string;
 
     public constructor(
-        public dataProvider: TDataProvider | null,
+        public route: TRoute | TErrorRoute,
         public component: TFrontRenderer,
         public context: TClientOrServerContext,
-        public layout?: Layout,
-
-        public route = context.route
+        public layout?: Layout
     ) {
 
-        super(dataProvider, component, context);
+        super(route, component, context);
 
         this.bodyId = context.route.options.bodyId;
         this.scrollToId = context.request.hash;

package/src/common/router/index.ts

@@ -20,7 +20,7 @@ import type { TUserRole } from '@server/services/users';
 import type { TAppArrowFunction } from '@common/app';
 
 // Specfic
-import type { default as Page, TFrontRenderer } from './response/page';
+import type { default as Page, TFrontRenderer, TDataProvider } from './response/page';
 
 /*----------------------------------
 - TYPES: ROUTES
@@ -81,6 +81,7 @@ export type TRouteOptions = {
 
     // Injected by the page plugin
     filepath?: string,
+    data?: TDataProvider
 
     // Indexing
     bodyId?: string,

package/src/common/router/register.ts

@@ -10,7 +10,7 @@ import { getLayout } from './layouts';
 
 // types
 import type { TRouteOptions } from '.';
-import type { TDataProvider, TFrontRenderer } from './response/page';
+import type { TFrontRenderer } from './response/page';
 import type { TRegisterPageArgs } from '@client/services/router';
 
 /*----------------------------------
@@ -21,20 +21,17 @@ export const getRegisterPageArgs = (...args: TRegisterPageArgs) => {
 
     let path: string;
     let options: Partial<TRouteOptions> = {};
-    let controller: TDataProvider|null;
     let renderer: TFrontRenderer;
 
-    if (args.length === 4)
-        ([path, options, controller, renderer] = args)
-    else if (typeof args[1] === 'object')
-        ([path, options, renderer] = args)
+    if (args.length === 2)
+        ([path, renderer] = args)
     else
-        ([path, controller, renderer] = args)
+        ([path, options, renderer] = args)
 
     // Automatic layout form the nearest _layout folder
     const layout = getLayout(path, options);
 
-    return { path, options, controller, renderer, layout }
+    return { path, options, renderer, layout }
 
 }
 

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

@@ -2,10 +2,11 @@
 - DEPENDANCES
 ----------------------------------*/
 
-import type { ComponentChild, FunctionComponent } from 'preact';
+// Npm
+import type { VNode } from 'preact';
 
 // Core libs
-import { ClientOrServerRouter, TClientOrServerContext } from '@common/router';
+import { ClientOrServerRouter, TClientOrServerContext, TRoute, TErrorRoute } from '@common/router';
 import { TFetcherList, TDataReturnedByFetchers } from '@common/router/request/api';
 import { history } from '@client/services/router/request/history';
 
@@ -14,21 +15,30 @@ import { history } from '@client/services/router/request/history';
 ----------------------------------*/
 
 // The function that fetch data from the api before to pass them as context to the renderer
-export type TDataProvider<TProvidedData extends TFetcherList = {}> = 
-    (context: TClientOrServerContext/* & TUrlData */) => TProvidedData
+export type TDataProvider<TProvidedData extends TFetcherList = TFetcherList> = (
+    context: TClientOrServerContext & {
+        // URL query parameters
+        // TODO: typings
+        data: {[key: string]: string | number}
+    }
+) => TProvidedData
 
 // The function that renders routes
 export type TFrontRenderer<
-    TProvidedData extends TFetcherList = {}, 
-    TAdditionnalData = {},
+    TProvidedData extends TFetcherList = TFetcherList, 
+    TAdditionnalData extends {} = {},
     TRouter = ClientOrServerRouter,
-> = FunctionComponent<(
-    TClientOrServerContext 
-    & 
-    TDataReturnedByFetchers<TProvidedData>
-    &
-    TAdditionnalData
-)>;
+> = ( 
+    context: (
+        TClientOrServerContext 
+        &
+        TAdditionnalData
+        &
+        {
+            data: TDataReturnedByFetchers<TProvidedData>
+        }
+    )
+) => VNode<any> | null
 
 // Script or CSS resource
 export type TPageResource = {
@@ -46,7 +56,7 @@ const debug = false;
 /*----------------------------------
 - CLASS
 ----------------------------------*/
-export default class PageResponse<TRouter extends ClientOrServerRouter = ClientOrServerRouter> {
+export default abstract class PageResponse<TRouter extends ClientOrServerRouter = ClientOrServerRouter> {
 
     // Metadata
     public chunkId: string;
@@ -65,7 +75,7 @@ export default class PageResponse<TRouter extends ClientOrServerRouter = ClientO
     public data: TObjetDonnees = {};
 
     public constructor(
-        public dataProvider: TDataProvider | null,
+        public route: TRoute | TErrorRoute,
         public renderer: TFrontRenderer,
         public context: TClientOrServerContext
     ) {
@@ -77,8 +87,12 @@ export default class PageResponse<TRouter extends ClientOrServerRouter = ClientO
     public async fetchData() {
 
         // Load the fetchers list to load data if needed
-        if (this.dataProvider)
-            this.fetchers = this.dataProvider({ ...this.context, ...this.context.request.data });
+        const dataFetcher = this.route.options.data;
+        if (dataFetcher)
+            this.fetchers = dataFetcher({
+                ...this.context,
+                data: this.context.request.data
+            });
 
         // Execute the fetchers for missing data
         debug && console.log(`[router][page] Fetching api data:` + Object.keys(this.fetchers));

package/src/server/app/index.ts

@@ -4,9 +4,13 @@
 
 // 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
@@ -49,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

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

@@ -53,7 +53,7 @@ export class ServicesContainer<
     public registered: TRegisteredServicesIndex = {}
 
     // All service instances by service id
-    public allServices: {[serviceId: string]: AnyService} = {}
+    public allServices: TServicesIndex = {} as TServicesIndex
 
     public setup<TServiceId extends keyof TServicesIndex>( 
         serviceId: keyof TServicesIndex, 

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

@@ -12,7 +12,8 @@ import ServicesContainer from './container';
 - TYPES: OPTIONS
 ----------------------------------*/
 
-export type AnyService = Service<{}, {}, Application, {}>
+export type AnyService<TSubServices extends StartedServicesIndex = StartedServicesIndex> = 
+    Service<{}, {}, Application, TSubServices>
 
 type TServiceConfig = {
     debug?: boolean
@@ -140,10 +141,26 @@ export default abstract class Service<
     // 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<TServiceId extends keyof TServicesIndex>( 
+    public use<
+        TInstalledServices extends this["app"]["servicesContainer"]["allServices"],
+        TServiceId extends keyof TInstalledServices,
+        TServiceClass extends TInstalledServices[TServiceId],
+        TSubServices extends TServiceClass["services"],
+    >( 
         serviceId: TServiceId, 
-        // TODO: Only subservices types supported by the parent service
-        subServices: TServicesIndex[TServiceId]["services"] = {}
+        subServices?: TSubServices
+    ): (
+        // We can't pass the services types as a generic to TServiceClass
+        // So we overwrite the services property
+        ReturnType< TServiceClass["getServiceInstance"] >
+        &
+        {
+            new (...args: any[]): TServiceClass & { services: TSubServices },
+            services: TSubServices
+        }
+        /*Omit<TServiceClass, 'services'> & {
+            services: TSubServices
+        }*/
     ) {
 
         // Check of the service has been configurated
@@ -152,7 +169,7 @@ export default abstract class Service<
             throw new Error(`Unable to use service "${serviceId}": This one hasn't been setup.`);
 
         // Bind subservices
-        registered.subServices = subServices;
+        registered.subServices = subServices || {};
 
         // Check if not already instanciated
         const existing = ServicesContainer.allServices[ serviceId ];
@@ -176,7 +193,7 @@ export default abstract class Service<
         return service;
     }
 
-    protected bindService( localName: string, service: AnyService ) {
+    public bindService( localName: string, service: AnyService ) {
 
         const serviceScope = this.constructor.name + '.' + localName;
 
@@ -196,7 +213,7 @@ export default abstract class Service<
         
     }
 
-    protected async startService( localName: string, service: AnyService ) {
+    public async startService( localName: string, service: AnyService ) {
         // Service already started
         if (!service.started) {
 

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

@@ -107,13 +107,16 @@ export const mysqlToJs = {
     'POINT': 'float',
         
     // Integres
-    'INT': 'int',
-    'BIGINT': 'int',
+    'BIT': 'int',
     'LONG': 'int',
     'LONGLONG': 'int',
+
     'TINYINT': 'int',
     'SMALLINT': 'int',
     'MEDIUMINT': 'int',
+    'INT': 'int',
+    'INTEGER': 'int',
+    'BIGINT': 'int',
 
     // Dates
     'DATE': 'date',
@@ -121,9 +124,18 @@ export const mysqlToJs = {
 
     // Strings
     'VARCHAR': 'string',
+    'BINARY': 'string',
+    'VARBINARY': 'string',
+    'TINYBLOB': 'string',
+    'TINY_BLOB': 'string',
+    'MEDIUM_BLOB': 'string',
+    'BLOB': 'string',
+    'LONG_BLOB': 'string',
     'CHAR': 'string',
     'VAR_STRING': 'string',
     'LONGTEXT': 'string',
+    'TINYTEXT': 'string',
+    'MEDIUMTEXT': 'string',
     'TEXT': 'string',
     'ENUM': 'enum',
 

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

@@ -5,7 +5,6 @@
 // Core
 import type { Application } from '@server/app';
 import Service, { AnyService } from '@server/app/service';
-import type { TRegisteredServicesIndex } from '@server/app/service/container';
 
 // Specific
 import type Driver from './driver';
@@ -25,7 +24,7 @@ export type Hooks = {
 }
 
 export type Services = {
-
+    [diskId: string]: Driver
 }
 
 /*----------------------------------

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

@@ -28,9 +28,6 @@ export type Config = {
         transporter: string,
         from: TPerson
     },
-    transporters: {
-        [transporterName: string]: Transporter
-    },
     bugReport: {
         from: TPerson,
         to: TPerson
@@ -111,14 +108,14 @@ type TOptions = {
 ----------------------------------*/
 export default class Email extends Service<Config, Hooks, Application, Services> {
     
-    private transporters = this.config.transporters;
+    private transporters = this.services;
 
     /*----------------------------------
     - LIFECYCLE
     ----------------------------------*/
 
     public async start() {
-        
+
     }
 
     public async ready() {

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

@@ -6,6 +6,7 @@
 
 // Core
 import type Application from "@server/app";
+import Service from '@server/app/service';
 import type EmailService from '@server/services/email';
 
 // Specific
@@ -23,16 +24,28 @@ export type TBasicConfig = {
 /*----------------------------------
 - CLASS 
 ----------------------------------*/
-export abstract class Transporter<TConfig extends {} = {}> {
+export abstract class Transporter<TConfig extends TBasicConfig = TBasicConfig>
+    extends Service<TConfig, {}, Application, {}> {
 
-    public constructor( 
-        protected app: Application & { email: EmailService },
-        protected config: TBasicConfig & TConfig,
+    /*----------------------------------
+    - LIFECYCLE
+    ----------------------------------*/
 
-        protected email = app.email
-    ) {
+    protected async start() {
+        
+    }
+
+    protected async ready() {
+
+    }
+
+    protected async shutdown() {
 
     }
 
+    /*----------------------------------
+    - ACTIONS
+    ----------------------------------*/
+
     public abstract send( emails: TCompleteEmail[] ): Promise<void>;
 }

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

@@ -194,7 +194,7 @@ export default class HttpServer {
         ----------------------------------*/
 
         // TODO: Migrer dans app
-        routes.use('/chrome', cors());
+        //routes.use('/chrome', cors());
         // TODO: Trouver une solution pour n'autoriser les requetes que depuis l'application & dopamyn.io
         //      https://www.google.com/search?q=http+cors+from+android%7Cwindows%7Cdesktop%7Cmodile+app
         //routes.use('/auth', cors());
@@ -225,7 +225,7 @@ export default class HttpServer {
         // Impossible donc de créer un serveur http ici, on le fera dans start.js
         console.info("Lancement du serveur web");
         this.http.listen(this.config.port, () => {
-            console.info(`Serveur web démarré sur ${this.publicUrl}`);
+            console.info(`Web server ready on ${this.publicUrl}`);
         });
 
     }

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

@@ -95,8 +95,6 @@ export type Config<
 }
 
 export type Services = {
-    disks?: DisksManager
-} & {
     [routerServiceId: string]: RouterService
 }
 
@@ -113,14 +111,15 @@ export type Hooks = {
 - CLASSE
 ----------------------------------*/
 export default class ServerRouter<
-    TConfig extends Config = Config,
-    TApplication extends Application = Application
-> extends Service<TConfig, Hooks, TApplication, Services> implements BaseRouter {
+    TSubservices extends Services = Services
+> extends Service<Config, Hooks, Application, TSubservices> implements BaseRouter {
 
+    public disks = this.use('Core/Disks') as unknown as DisksManager;
+    
     // Services
     public http: HTTP;
     public render: DocumentRenderer<this>;
-    protected routerServices: {[serviceId: string]: RouterService} = {}
+    protected routerServices: TSubservices = {} as TSubservices
 
     // Indexed
     public routes: TRoute[] = []; // API + pages front front
@@ -133,9 +132,9 @@ export default class ServerRouter<
 
     public constructor( 
         parent: AnyService, 
-        config: TConfig,
-        services: Services,
-        app: TApplication, 
+        config: Config,
+        services: TSubservices,
+        app: Application, 
     ) {
 
         super(parent, config, services, app);
@@ -217,7 +216,7 @@ export default class ServerRouter<
 
     public page(...args: TRegisterPageArgs) {
 
-        const { path, options, controller, renderer, layout } = getRegisterPageArgs(...args);
+        const { path, options, renderer, layout } = getRegisterPageArgs(...args);
 
         const { regex, keys } = buildRegex(path);
 
@@ -226,7 +225,7 @@ export default class ServerRouter<
             path,
             regex,
             keys,
-            controller: (context: TRouterContext<this>) => new Page(controller, renderer, context, layout),
+            controller: (context: TRouterContext<this>) => new Page(route, renderer, context, layout),
             options: {
                 ...defaultOptions,
                 accept: 'html', // Les pages retournent forcémment du html
@@ -249,11 +248,13 @@ export default class ServerRouter<
         // Automatic layout form the nearest _layout folder
         const layout = getLayout('Error ' + code, options);
 
-        this.errors[code] = {
+        const route = {
             code,
-            controller: (context: TRouterContext<this>) => new Page(null, renderer, context, layout),
+            controller: (context: TRouterContext<this>) => new Page(route, renderer, context, layout),
             options
         };
+
+        this.errors[code] = route;
     }
 
     public all = (...args: TApiRegisterArgs<this>) => this.registerApi('*', ...args);

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

@@ -7,7 +7,8 @@
 import RequestService from './service';
 
 import ApiClientService, { 
-    TApiFetchOptions, TFetcherList, TFetcherArgs, TFetcher 
+    TApiFetchOptions, TFetcherList, TFetcherArgs, TFetcher,
+    TDataReturnedByFetchers
 } from '@common/router/request/api';
 
 /*----------------------------------
@@ -28,6 +29,12 @@ export default class ApiClientRequest extends RequestService implements ApiClien
     - HIGH LEVEL
     ----------------------------------*/
 
+    public fetch<TProvidedData extends TFetcherList = TFetcherList>( 
+        fetchers: TFetcherList 
+    ): TDataReturnedByFetchers<TProvidedData> {
+        throw new Error("api.fetch shouldn't be called here.");
+    }
+
     public get = <TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions) => 
         this.createFetcher<TData>('GET', path, data, opts);
 

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

@@ -242,11 +242,11 @@ export default class ServerResponse<
         //         ? this.app.path.root + '/bin' + fichier
         //         : this.app.path.data + '/' + fichier;
         // Disk not provided = file response disabled
-        if (this.router.services.disks === undefined)
+        if (this.router.disks === undefined)
             throw new Anomaly("Router: Unable to return file response in router, because no disk has been given in the router config.");
 
         // Retirve disk driver
-        const disk = this.router.services.disks.get('default');
+        const disk = this.router.disks.get('default');
 
         // Verif existance
         const fileExists = await disk.exists('data', fichier);

package/src/server/services/router/response/page/index.tsx

@@ -9,8 +9,8 @@ const safeStringify = require('fast-safe-stringify'); // remplace les référenc
 
 // Core
 import { default as Router, TRouterContext } from "@server/services/router";
-import type { Layout } from '@common/router';
-import PageResponse, { TDataProvider, TFrontRenderer } from "@common/router/response/page";
+import type { Layout, TRoute, TErrorRoute } from '@common/router';
+import PageResponse, { TFrontRenderer } from "@common/router/response/page";
 
 // Composants UI
 import App from '@client/app/component';
@@ -34,18 +34,17 @@ const seoLimits = {
 export default class Page<TRouter extends Router = Router> extends PageResponse<TRouter> {
 
     public constructor(
-        public dataProvider: TDataProvider | null,
+        public route: TRoute | TErrorRoute,
         public renderer: TFrontRenderer,
         public context: TRouterContext,
         public layout?: Layout,
 
-        public route = context.route,
         public app = context.app,
         public router = context.request.router,
         
     ) {
 
-        super(dataProvider, renderer, context)
+        super(route, renderer, context)
         
     }
 

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

@@ -14,7 +14,6 @@ import RequestValidator, { TConfig } from '../request';
 - TYPES
 ----------------------------------*/
 
-type TRouterWithSchema<TAuthService extends SchemaRouterService> = Router<RouterConfig<{ auth: TAuthService }>>
 
 /*----------------------------------
 - SERVICE
@@ -43,7 +42,7 @@ export default class SchemaRouterService<
     - ROUTER SERVICE LIFECYCLE
     ----------------------------------*/
 
-    public requestService( request: ServerRequest< TRouterWithSchema<this>> ): RequestValidator {
+    public requestService( request: ServerRequest ): RequestValidator {
         return new RequestValidator( request, this.config );
     }
 }