5htp-core 0.5.9 → 0.6.0-2

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>;
 

package/server/services/disks/drivers/s3/index.ts

@@ -14,7 +14,7 @@ import dayjs from 'dayjs';
 
 // Core
 import type { Application } from '@server/app';
-import type { AnyService, TRegisteredServicesIndex } from '@server/app/service';
+import type { TServiceArgs } from '@server/app/service';
 
 // Specific
 import DiskDriver, { 
@@ -50,14 +50,9 @@ export default class S3Driver<
 
     public s3: AWS.S3; 
 
-    public constructor( 
-        public parent: AnyService, 
-        public config: TConfig,
-        public services: {},
-        public app: Application
-    ) {
+    public constructor(...args: TServiceArgs) {
 
-        super( parent, config, services, app );
+        super(...args);
 
         AWS.config.update({
             accessKeyId: this.config.accessKeyId,
@@ -87,6 +82,7 @@ export default class S3Driver<
         bucketName: TBucketName, 
         filename: string
     ) {
+
         const bucket = this.config.buckets[bucketName];
         if (bucket === undefined)
             throw new Error(`Bucket "${bucketName}" not found in configuration`);

package/server/services/disks/index.ts

@@ -4,7 +4,7 @@
 
 // Core
 import type { Application } from '@server/app';
-import Service, { AnyService } from '@server/app/service';
+import Service, { AnyService, TRegisteredServicesIndex, TServiceArgs } from '@server/app/service';
 
 // Specific
 import type Driver from './driver';
@@ -17,6 +17,9 @@ export type { default as Driver } from './driver';
 type Config = {
     debug: boolean,
     default: string,//keyof MountpointList,
+    drivers: {
+        [driverId: string]: Driver
+    }
 }
 
 export type Hooks = {
@@ -34,25 +37,23 @@ export default class DisksManager<
     MountpointList extends Services = {},
     TConfig extends Config = Config,
     TApplication extends Application = Application
-> extends Service<TConfig, Hooks, TApplication, MountpointList> {
+> extends Service<TConfig, Hooks, TApplication> {
 
     public default!: Driver;
 
-    public mounted: MountpointList = this.services;
-
     /*----------------------------------
     - LIFECYCLE
     ----------------------------------*/
 
-    public async ready() {
+    public constructor( ...args: TServiceArgs<DisksManager>) {
 
-        const drivers = this.services;
+        super(...args);
+
+        const drivers = this.config.drivers;
         
         if (Object.keys( drivers ).length === 0)
             throw new Error("At least one disk driver should be mounted.");
 
-        console.log('start disks service', Object.keys( drivers ), Object.keys( this.mounted ), Object.keys( this.services ));
-
         const defaultDisk = drivers[ this.config.default ];
         if (defaultDisk === undefined)
             console.log(`Default disk "${this.config.default as string}" not mounted.`);
@@ -73,7 +74,7 @@ export default class DisksManager<
 
         const disk = diskName == 'default' || diskName === undefined
             ? this.default 
-            : this.mounted[diskName];
+            : this.config.drivers[diskName];
 
         if (disk === undefined)
             throw new Error(`Disk "${diskName as string}" not found.`);

package/server/services/email/index.ts

@@ -31,6 +31,9 @@ export type Config = {
     bugReport: {
         from: TPerson,
         to: TPerson
+    },
+    transporters: {
+        [transporterId: string]: Transporter
     }
 }
 
@@ -106,9 +109,9 @@ type TOptions = {
 /*----------------------------------
 - FONCTIONS
 ----------------------------------*/
-export default class Email extends Service<Config, Hooks, Application, Services> {
+export default class Email extends Service<Config, Hooks, Application> {
     
-    private transporters = this.services;
+    private transporters = this.config.transporters;
 
     /*----------------------------------
     - ACTIONS

package/server/services/email/transporter.ts

@@ -25,27 +25,7 @@ export type TBasicConfig = {
 - CLASS 
 ----------------------------------*/
 export abstract class Transporter<TConfig extends TBasicConfig = TBasicConfig>
-    extends Service<TConfig, {}, Application, {}> {
-
-    /*----------------------------------
-    - LIFECYCLE
-    ----------------------------------*/
-
-    protected async start() {
-        
-    }
-
-    protected async ready() {
-
-    }
-
-    protected async shutdown() {
-
-    }
-
-    /*----------------------------------
-    - ACTIONS
-    ----------------------------------*/
+    extends Service<TConfig, {}, Application> {
 
     public abstract send( emails: TCompleteEmail[] ): Promise<void>;
 }

package/server/services/fetch/index.ts

@@ -26,18 +26,16 @@ import type FsDriver from '../disks/driver';
 
 export type Config = {
     debug?: boolean,
-    disk?: string
+    disk?: string,
+
+    disks: DisksManager,
+    router?: RouterService
 }
 
 export type Hooks = {
 
 }
 
-export type Services = {
-    disks: DisksManager,
-    router?: RouterService
-}
-
 /*----------------------------------
 - TYPES
 ----------------------------------*/
@@ -60,14 +58,14 @@ const LogPrefix = `[services][fetch]`
 - SERVICE
 -  Tools that helps to consume external resources (including apis, ..)
 -----------------------------------*/
-export default class FetchService extends Service<Config, Hooks, Application, Services> {
+export default class FetchService extends Service<Config, Hooks, Application> {
 
     private disk?: FsDriver;
 
     public async ready() {
 
-        if (this.services.disks)
-            this.disk = this.services.disks.get( this.config.disk );
+        if (this.config.disks)
+            this.disk = this.config.disks.get( this.config.disk );
 
     }
 
@@ -97,10 +95,10 @@ export default class FetchService extends Service<Config, Hooks, Application, Se
     ) {
 
         // Parse url if router service is provided
-        if (this.services.router === undefined)
+        if (this.config.router === undefined)
             throw new Error(`Please bind the Router service to the Fetch service in order to contact APIs.`);
 
-        url = this.services.router.url(url);
+        url = this.config.router.url(url);
 
         // Send request
         const res = await got(url, {

package/server/services/fetch/service.json

@@ -2,5 +2,6 @@
     "id": "Core/Fetch",
     "name": "Fetch",
     "parent": "app",
-    "dependences": []
+    "dependences": [],
+    "priority": 0
 }

package/server/services/prisma/index.ts

@@ -34,22 +34,9 @@ export type Services = {
 - CLASSE
 ----------------------------------*/
 
-export default class ModelsManager extends Service<Config, Hooks, Application, Services> {
+export default class ModelsManager extends Service<Config, Hooks, Application> {
 
     public client = new PrismaClient();
-
-    /*----------------------------------
-    - LIFECICLE
-    ----------------------------------*/
-
-    protected async start() {
-
-        
-    }
-  
-    public async ready() {
-  
-    }
   
     public async shutdown() {
         await this.client.$disconnect()

package/server/services/router/index.ts

@@ -14,11 +14,13 @@
 import type express from 'express';
 import type { Request, Response, NextFunction } from 'express';
 import { v4 as uuid } from 'uuid';
+import zod from 'zod';
+export { default as schema } from 'zod';
 import type { GlobImportedWithMetas } from 'babel-plugin-glob-import';
 
 // Core
 import type { Application } from '@server/app';
-import Service, { AnyService } from '@server/app/service';
+import Service, { AnyService, TServiceArgs } from '@server/app/service';
 import type { TRegisteredServicesIndex } from '@server/app/service/container';
 import context from '@server/context';
 import type DisksManager from '@server/services/disks';
@@ -96,10 +98,10 @@ export type Config<
         request: ServerRequest<ServerRouter>, 
         app: Application
     ) => TAdditionnalSsrData,
-}
 
-export type Services = {
-    [routerServiceId: string]: RouterService
+    plugins: {
+        [routerServiceId: string]: RouterService
+    }
 }
 
 // Set it as a function, so when we instanciate the services, we can callthis.router to pass the router instance in roiuter services
@@ -113,23 +115,21 @@ export type Hooks = {
 
 export type TControllerDefinition = {
     path?: string,
-    validate?: (schema: any) => any,
+    schema?: zod.ZodSchema,
     controller: TServerController<ServerRouter>,
 }
 
 /*----------------------------------
 - CLASSE
 ----------------------------------*/
-export default class ServerRouter<
-    TSubservices extends Services = Services
-> extends Service<Config, Hooks, Application, TSubservices> implements BaseRouter {
+export default class ServerRouter 
+    extends Service<Config, Hooks, Application> implements BaseRouter {
 
     public disks = this.use<DisksManager>('Core/Disks', { optional: true });
     
     // Services
     public http: HTTP;
     public render: DocumentRenderer<this>;
-    protected routerServices: TSubservices = {} as TSubservices
 
     // Indexed
     public routes: TRoute[] = []; // API + pages front front
@@ -144,16 +144,11 @@ export default class ServerRouter<
     - SERVICE
     ----------------------------------*/
 
-    public constructor( 
-        parent: AnyService, 
-        config: Config,
-        services: TSubservices,
-        app: Application, 
-    ) {
+    public constructor( ...args: TServiceArgs<ServerRouter>) {
 
-        super(parent, config, services, app);
+        super(...args);
 
-        this.http = new HTTP(config.http, this);
+        this.http = new HTTP(this.config.http, this);
         this.render = new DocumentRenderer(this);
     }
 
@@ -164,18 +159,15 @@ export default class ServerRouter<
     public async ready() {
 
         // Detect router services
-        for (const serviceName in this.services) {
-
-            const routerService = this.services[serviceName];
-            if (routerService instanceof RouterService)
-                this.routerServices[ serviceName ] = routerService;
+        for (const serviceName in this.config.plugins) {
+            this.app.register( this.config.plugins[serviceName] )
         }
 
          // Use require to avoid circular references
          this.registerRoutes([
             ...require("metas:@/server/routes/**/*.ts"),
-            ...require("metas:@/client/pages/**/*.tsx"),
-            ...require("metas:@client/pages/**/*.tsx")
+            ...require("metas:@/client/pages/**/([a-z0-9]*).tsx"),
+            ...require("metas:@/client/pages/**/([a-z0-9]*).tsx")
         ]);
 
         // Start HTTP server
@@ -192,7 +184,6 @@ export default class ServerRouter<
     ----------------------------------*/
 
     private registerRoutes(defModules: GlobImportedWithMetas<TRouteModule>) {
-
         for (const routeModule of defModules) {
 
             const register = routeModule.exports.__register;
@@ -327,10 +318,6 @@ export default class ServerRouter<
 
     private async afterRegister() {
 
-        // Generate typescript typings
-        if (this.app.env.profile === 'dev')
-            this.genTypings();
-
         // Ordonne par ordre de priorité
         this.config.debug && console.info("Loading routes ...");
         this.routes.sort((r1, r2) => {
@@ -394,21 +381,6 @@ export default class ServerRouter<
         this.config.debug && console.info(this.routes.length + " routes where registered.");
     }
 
-    private genTypings() {
-        /*fs.outputFileSync( path.join(this.app.path.typings, 'routes.d.ts'), `
-declare type Routes = {
-        ${this.routes.map( route => `
-            '${route.path}': {
-                params: {
-                    ${route.keys.map( k => "'" + k + "': string").join(',\n')}
-                }
-            }
-        `).join(',')}
-    }
-}
-        `);*/
-    }
-
     /*----------------------------------
     - RESOLUTION
     ----------------------------------*/
@@ -438,15 +410,15 @@ declare type Routes = {
             this
         );
 
-        // Hook
-        await this.runHook('request', request);
-
         // Create request context so we can access request context across all the request-triggered libs
         context.run({ channelType: 'request', channelId: requestId }, async () => {
 
             let response: ServerResponse<this>;
             try {
 
+                // Hook
+                await this.runHook('request', request);
+
                 // Bulk API Requests
                 if (request.path === '/api' && typeof request.data.fetchers === "object") {
 
@@ -476,9 +448,15 @@ declare type Routes = {
     public createContextServices( request: ServerRequest<this> ) {
 
         const contextServices: Partial<TRouterContextServices<this>> = {}
-        for (const serviceName in this.routerServices) {
+        for (const serviceName in this.config.plugins) {
+
+            const routerService = this.config.plugins[serviceName];
+            if (!routerService)
+                throw new Error(`Could not access router service ${serviceName}. Maybe the referenced service is not started yet? Try to reduce its priority.`);
+
+            if (!routerService.requestService)
+                throw new Error(`Router service ${serviceName} is not implementing the requestService method from the RouterService interface.`);
 
-            const routerService = this.routerServices[serviceName];
             const requestService = routerService.requestService( request );
             if (requestService !== null)
                 contextServices[ serviceName ] = requestService;
@@ -509,9 +487,6 @@ declare type Routes = {
             let route = this.controllers[request.path];
             if (route !== undefined) {
 
-                // Run on resolution hooks. Ex: authentication check
-                await this.runHook('resolved', route);
-
                 // Create response
                 await this.resolvedRoute(route, response, logId, timeStart);
                 if (response.wasProvided)
@@ -564,7 +539,7 @@ declare type Routes = {
     ) {
 
         // Run on resolution hooks. Ex: authentication check
-        await this.runHook('resolved', route);
+        await this.runHook('resolved', route, response.request, response);
 
         // Create response
         await response.runController(route);

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

@@ -21,10 +21,6 @@ import ApiClientService, {
 ----------------------------------*/
 export default class ApiClientRequest extends RequestService implements ApiClientService {
 
-    protected async start() {
-
-    }
-
     /*----------------------------------
     - HIGH LEVEL
     ----------------------------------*/
@@ -66,9 +62,8 @@ export default class ApiClientRequest extends RequestService implements ApiClien
     public createFetcher<TData extends unknown = unknown>(...[method, path, data, options]: TFetcherArgs): TFetcher<TData> {
         return { 
             method, path, data, options,
-            then: () => { throw new Error("Async resolvers should not be run from server side."); },
-            run: () => { throw new Error("Async resolvers should not be run from server side."); },
-        };
+            // We don't put the then and catch methods so the api consumer on server side will know it's a fetcher and not a promize to wait
+        } as TFetcher<TData>;
     }
 
     public async fetchSync(fetchers: TFetcherList, alreadyLoadedData: {}): Promise<TObjetDonnees> {

package/server/services/router/service.ts

@@ -4,36 +4,24 @@
 
 // Core
 import type { Application } from '@server/app';
-import Service, { TRegisteredServicesIndex } from '@server/app/service';
+import Service, { TRegisteredServicesIndex, TServiceArgs } from '@server/app/service';
 
 // Specific
 import type { default as Router } from '.';
 import type ServerRequest from './request';
 import type RequestService from './request/service';
 
-export type Services = {
-    
-}
+export type TRouterServiceArgs = TServiceArgs<RouterService>;
 
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
 export default abstract class RouterService<
     TConfig extends {} = {}
-> extends Service<TConfig, {}, Application, Services> {
+> extends Service<TConfig, {}, Application> {
 
-    public constructor( 
-        // Parent is always a router in RouterService
-        // Warning: for now, it's possible that router is actually the app
-        //      It's fixed with a not very clean way in Service.bindService
-        router: Router, 
-        config: TConfig,
-        services: TRegisteredServicesIndex,
-        app: Application
-    ) {
-
-        super(router, config, services, app);
-        
+    public constructor( ...args: TRouterServiceArgs) {
+        super(...args);
     }
 
     public abstract requestService( request: ServerRequest<Router> ): RequestService | null;

package/server/services/security/encrypt/aes/index.ts

@@ -47,7 +47,7 @@ type TDecryptOptions = {
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default class AES<TConfig extends Config = Config> extends Service<TConfig, Hooks, Application, Services> {
+export default class AES<TConfig extends Config = Config> extends Service<TConfig, Hooks, Application> {
 
     public encrypt( keyName: keyof TConfig["keys"], data: any, options: TEncryptOptions = {
         encoding: 'base64url'

package/server/services/socket/index.ts

@@ -26,30 +26,27 @@ export type Config<TUser extends {}> = {
     //server: ServerOptions["server"],
     //users: UsersManagementService<TUser>,
     port: number,
+
+    users: UsersManagementService<TUser, Application>,
+    router: Router
 }
 
 export type Hooks = {
 
 }
 
-export type Services<TUser extends {}> = {
-    users: UsersManagementService<TUser, Application>,
-    router: Router
-}
-
 /*----------------------------------
 - MANAGER
 ----------------------------------*/
 export default class WebSocketCommander<
     TUser extends {},
-    TConfig extends Config<TUser>= Config<TUser>,
-    TServices extends Services<TUser> = Services<TUser>
-> extends Service<TConfig, Hooks, Application, TServices> {
+    TConfig extends Config<TUser>= Config<TUser>
+> extends Service<TConfig, Hooks, Application> {
 
     // Services
     public ws!: WebSocketServer;
-    public users!: TServices["users"];
-    public router!: Router;
+    public users!: TConfig["users"];
+    public router!: TConfig["router"];
 
     // Context
     public scopes: {[path: string]: SocketScope<TUser>} = {}
@@ -57,13 +54,12 @@ export default class WebSocketCommander<
     public constructor(
         parent: AnyService, 
         config: TConfig,
-        services: Services,
         app: TApplication, 
     ) {
-        super(parent, config, services, app);
+        super(parent, config, app);
         
-        this.users = this.services.users;
-        this.router = this.services.router;
+        this.users = this.config.users;
+        this.router = this.config.router;
         
     }
     
@@ -72,7 +68,7 @@ export default class WebSocketCommander<
     ----------------------------------*/
 
     public loading: Promise<void> | undefined = undefined;
-    protected async start() {
+    protected async ready() {
 
         this.users.on('disconnect', async (userId: string) => {
             this.disconnect(userId, 'Logout');
@@ -120,10 +116,6 @@ export default class WebSocketCommander<
         console.info(`Socket commander bound to http server.`);
     }
 
-    public async ready() {
-
-    }
-
     public async shutdown() {
         this.closeAll();
     }

package/types/global/utils.d.ts

@@ -55,6 +55,49 @@ declare type Routes = {
 
 declare type PrimitiveValue = string | number | boolean;
 
+/*----------------------------------
+- COPY FROM CLI/APP/INDEX.TS
+----------------------------------*/
+
+type TEnvConfig = {
+    name: 'local' | 'server',
+    profile: 'dev' | 'prod',
+    version: string,
+}
+
+type TServiceSetup = {
+    id: string,
+    name: string,
+    config: {},
+    subservices: TServiceSubservices
+}
+
+type TServiceRef = {
+    refTo: string
+}
+
+type TServiceSubservices = {
+    [key: string]: TServiceSetup | TServiceRef
+}
+
 declare module '@cli/app' {
-    export const app: 'test';
+    type App = {
+
+        env: TEnvConfig;
+
+        use: (referenceName: string) => TServiceRef;
+
+        setup: (...args: [
+            // { user: app.setup('Core/User') }
+            servicePath: string,
+            serviceConfig?: {}
+        ] | [
+            // app.setup('User', 'Core/User')
+            serviceName: string, 
+            servicePath: string,
+            serviceConfig?: {}
+        ]) => TServiceSetup;
+    }
+    const app: App;
+    export = app;
 }