5htp-core 0.2.9 → 0.3.0

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

@@ -2,8 +2,11 @@
 - DEPENDANCES
 ----------------------------------*/
 
+// Core
+import type { Application } from '@server/app';
+import Service, { TRegisteredServicesIndex } from '@server/app/service';
+
 // Specific
-import type Application from '@server/app';
 import type { default as Router } from '.';
 import type ServerRequest from './request';
 import type RequestService from './request/service';
@@ -11,38 +14,22 @@ import type RequestService from './request/service';
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default abstract class RouterService<TRouter extends Router = Router> {
-
-    protected router!: TRouter;
-    protected app!: Application;
-
-    public constructor(
-        
+export default abstract class RouterService<
+    TConfig extends {} = {}
+> extends Service<TConfig, {}, Application> {
+
+    public constructor( 
+        // Parent is always a router in RouterService
+        public router: Router, 
+        config: TConfig,
+        services: TRegisteredServicesIndex,
+        app: Application
     ) {
 
+        super(router, config, services, app);
+        
     }
 
-    /*
-        We can't pass the router instance in the routerservice constructor
-        Because we instanciate the routerservice in the router instanciation itself
-        So if we do:
-        public router = new Router(this, {
-            ...,
-            services: () => ({
-
-                auth: new AuthService(this.router, this.users),
-
-            }),
-        )
-        We would have a cicular reference in typings, which will make router typed as any
-    */
-    public attach( router: TRouter ) {
-        this.router = router;
-        this.app = router.app;
-    }
-    
-    public abstract register(): Promise<void>;
-
     public abstract requestService( request: ServerRequest<TRouter> ): RequestService | null;
 
 }

package/src/server/services/schema/{router.ts → router/index.ts}

@@ -8,29 +8,41 @@ import {
     RouterService
 } from '@server/services/router';
 
-import RequestValidator, { TConfig } from './request';
+import RequestValidator, { TConfig } from '../request';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-type TRouterWithSchema<TAuthService extends AuthenticationRouterService> = Router<RouterConfig<{ auth: TAuthService }>>
+type TRouterWithSchema<TAuthService extends SchemaRouterService> = Router<RouterConfig<{ auth: TAuthService }>>
 
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default class AuthenticationRouterService<
+export default class SchemaRouterService<
     TUser extends {} = {}
 > extends RouterService {
 
-    public constructor( protected config: TConfig ) {
-        super();
-    }
+    /*----------------------------------
+    - LIFECYCLE
+    ----------------------------------*/
 
-    public async register() {
+    public async start() {
         
     }
 
+    public async ready() {
+
+    }
+
+    public async shutdown() {
+
+    }
+
+    /*----------------------------------
+    - ROUTER SERVICE LIFECYCLE
+    ----------------------------------*/
+
     public requestService( request: ServerRequest< TRouterWithSchema<this>> ): RequestValidator {
         return new RequestValidator( request, this.config );
     }

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

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

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

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

package/src/server/services/security/encrypt/{aes.ts → aes/index.ts}

@@ -6,7 +6,8 @@
 import crypto, { Encoding } from 'crypto';
 
 // Core
-import Application, { Service } from '@server/app';
+import type { Application } from '@server/app';
+import Service from '@server/app/service';
 import { Forbidden } from '@common/errors';
 
 /*----------------------------------
@@ -45,14 +46,26 @@ type TDecryptOptions = {
 ----------------------------------*/
 export default class AES<TConfig extends Config = Config> extends Service<TConfig, Hooks, Application> {
 
-    public async register() {
+    /*----------------------------------
+    - LIFECYCLE
+    ----------------------------------*/
+
+    public async start() {
         
     }
 
-    public async start() {
+    public async ready() {
 
     }
 
+    public async shutdown() {
+
+    }
+
+	/*----------------------------------
+    - ACTIONS
+    ----------------------------------*/
+
     public encrypt( keyName: keyof TConfig["keys"], data: any, options: TEncryptOptions = {
         encoding: 'base64url'
     }) {

package/src/server/services/security/encrypt/aes/service.json

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

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

@@ -9,8 +9,10 @@ import { IncomingMessage } from 'http';
 import cookie from 'cookie';
 
 // Core
-import Application, { Service } from '@server/app';
+import type { Application } from '@server/app';
+import Service, { AnyService, TRegisteredService } from '@server/app/service';
 import SocketScope, { WebSocket } from './scope';
+import type Router from '@server/services/router';
 export type { WebSocket, default as SocketScope } from './scope';
 import type UsersManagementService from '../users';
 
@@ -20,8 +22,9 @@ import type UsersManagementService from '../users';
 
 
 export type Config<TUser extends {}> = {
-    server: ServerOptions["server"],
-    users: UsersManagementService<TUser>,
+    debug?: boolean,
+    //server: ServerOptions["server"],
+    //users: UsersManagementService<TUser>,
     port: number,
 }
 
@@ -40,33 +43,44 @@ export default class WebSocketCommander<
     // Services
     public ws!: WebSocketServer;
     public users: UsersManagementService<TUser>;
+    public router: Router;
 
     // Context
     public scopes: {[path: string]: SocketScope<TUser>} = {}
 
-    public constructor( app: Application, config: TConfig ) {
-        super(app, config);
+    public constructor( 
+        parent: AnyService, 
+        config: TConfig,
+        services: {
+            users: TRegisteredService< UsersManagementService<TUser> >,
+            router: Router
+        },
+        app: Application, 
+    ) {
 
-        this.users = config.users;
+        super(parent, config, services, app);
+
+        this.users = this.services.users;
+        this.router = this.services.router;
     }
+    
+    /*----------------------------------
+    - LIFECYCLE
+    ----------------------------------*/
 
-    public async register() {
+    public loading: Promise<void> | undefined = undefined;
+    protected async start() {
 
         this.app.on('cleanup', async () => {
             this.closeAll();
         });
 
-
         this.users.on('disconnect', async (userId: string) => {
             this.disconnect(userId, 'Logout');
         });
-    }
-
-    public loading: Promise<void> | undefined = undefined;
-    public async start() {
 
         console.info(`Loading socket commander`);
-        this.ws = new WebSocketServer({ server: this.config.server })
+        this.ws = new WebSocketServer({ server: this.router.http.http })
             .on('connection', (socket: WebSocket, req: IncomingMessage) => {
 
                 // Resolve scope
@@ -107,6 +121,18 @@ export default class WebSocketCommander<
         console.info(`Socket commander bound to http server.`);
     }
 
+    public async ready() {
+
+    }
+
+    public async shutdown() {
+
+    }
+
+	/*----------------------------------
+    - ACTIONS
+    ----------------------------------*/
+
     public open(path: string) {
 
         if (!(path in this.scopes)) {

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

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

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

@@ -8,7 +8,7 @@ import type express from 'express';
 import type http from 'http';
 
 // Core
-import Application from '@server/app';
+import { Application } from '@server/app';
 import Service from '@server/app/service';
 import { 
     default as Router, Request as ServerRequest,
@@ -68,14 +68,26 @@ export default abstract class UsersManagementService<
     TRequest extends ServerRequest<Router> = ServerRequest<Router>,
 > extends Service<TConfig, THooks, TApplication> {
 
-    public async register() {
-       
-    }
+    /*----------------------------------
+    - LIFECYCLE
+    ----------------------------------*/
 
     public async start() {
+        
+    }
+
+    public async ready() {
 
     }
 
+    public async shutdown() {
+
+    }
+
+	/*----------------------------------
+    - ACTIONS
+    ----------------------------------*/
+
     public abstract login( ...args: any[] ): Promise<{ user: TUser, token: string }>;
     public abstract decodeSession( jwt: TJwtSession, req: THttpRequest ): Promise<TUser>;
 

package/src/server/services/users/old.ts

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

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

@@ -5,10 +5,8 @@
 // Npm
 
 // Core
-import type Application from '@server/app';
-
 import { 
-    default as Router, Request as ServerRequest, TRoute,
+    default as Router, Request as ServerRequest, TAnyRoute,
     RouterService
 } from '@server/services/router';
 
@@ -35,35 +33,44 @@ export default class AuthenticationRouterService<
     TRequest extends ServerRequest<Router> = ServerRequest<Router>,
 > extends RouterService {
 
-    public constructor( 
-        public users: UsersService<TUser, Application>,
-        public config = users.config
-    ) {
-
-        super();
+    /*----------------------------------
+    - LIFECYCLE
+    ----------------------------------*/
 
-    }
+    public users = this.services.users;
 
-    public async register() {
+    protected async start() {
 
         // Decode current user
         this.router.on('request', async (request: TRequest) => {
 
             // TODO: Typings. (context.user ?)
-            const decoded = await this.users.decode( request.req, true);
+            const decoded = await this.services.users.decode( request.req, true);
 
             request.user = decoded || null;
         })
 
         // Check route permissions
-        this.router.on('resolved', async (route: TRoute, request: TRequest) => {
+        this.router.on('resolved', async (route: TAnyRoute, request: TRequest) => {
 
             if (route.options.auth !== undefined)
                 // TODO: How to pas the router type to router config ? Circular rfeerence ?
-                this.users.check(request, route.options.auth);
+                this.services.users.check(request, route.options.auth);
         })
     }
 
+    protected async ready() {
+
+    }
+
+    protected async shutdown() {
+
+    }
+
+    /*----------------------------------
+    - ROUTER SERVICE LIFECYCLE
+    ----------------------------------*/
+
     public requestService( request: TRequest ): UsersRequestService<TUser> {
         return new UsersRequestService( request, this );
     }   

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

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

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

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

package/src/types/aliases.d.ts

@@ -51,4 +51,9 @@ declare module "@/client/context" {
     const useContext: () => ClientContext;
 
     export = useContext;
+}
+
+declare module "@app" {
+    const ServerApplicationClass: import("../server/app").default;
+    export = ServerApplicationClass;
 }

package/tsconfig.common.json

@@ -18,6 +18,8 @@
         // Décorateurs
         "experimentalDecorators": true,
 
+        "inlineSourceMap": true,
+
         // React
         "jsx": "react-jsx",
         "jsxImportSource": "preact",

package/src/server/app/service.ts

@@ -1,109 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Specific
-import Application from ".";
-import type { Command } from "./commands"; 
-
-/*----------------------------------
-- TYPES: OPTIONS
-----------------------------------*/
-
-export type AnyService = Service<{}, {}, Application>
-
-type THookCallback<THookArgs extends THookOptions> = (...args: THookArgs["args"]) => Promise<void>;
-
-type THooksList = {
-    [hookName: string]: THookOptions
-}
-
-type THookOptions = {
-    args: any[]
-}
-
-export type TPriority = -2 | -1 | 0 | 1 | 2
-
-type TServiceConfig = {
-    debug?: boolean
-}
-
-/*----------------------------------
-- CONFIG
-----------------------------------*/
-
-const LogPrefix = '[service]';
-
-/*----------------------------------
-- CLASS
-----------------------------------*/
-export default abstract class Service<
-    TConfig extends TServiceConfig, 
-    THooks extends THooksList,
-    TApplication extends Application
-> {
-
-    public priority: TPriority = 0;
-    public started?: Promise<void>;
-    public status: 'stopped' | 'starting' | 'running' | 'paused' = 'stopped';
-
-    public commands?: Command[];
-
-    public constructor( 
-        public app: TApplication, 
-        public config: TConfig,
-    ) {
-
-        if (!( this instanceof Application ))
-            // Make the app aware of his services
-            app.registerService(this);
-        
-    }
-
-    public abstract register?(): Promise<void>;
-
-    public abstract start?(): Promise<void>;
-
-    /*----------------------------------
-    - HOOKS
-    ----------------------------------*/
-    public hooks: {[name in keyof THooks]?: THookCallback< THooks[name] >[]} = {}
-
-    public on<THookName extends keyof THooksList>( 
-        name: THookName, 
-        callback: THookCallback<THooksList[THookName]> 
-    ) {
-
-        const callbacks = this.hooks[ name ];
-        if (callbacks)
-            callbacks.push( callback );
-        else
-            this.hooks[ name ] = [callback]
-
-        return this;
-    }
-
-    public runHook<THookName extends keyof THooksList>( 
-        name: THookName, 
-        ...args: THooksList[THookName]["args"]
-    ) {
-
-        const callbacks = this.hooks[name];
-        if (!callbacks)
-            return console.info(LogPrefix, `No ${name} hook defined in the current service instance.`);
-
-        this.config.debug && console.info(`[hook] Run all ${name} hook (${callbacks.length}).`);
-        return Promise.all( 
-            callbacks.map(
-                cb => cb(...args).catch(e => {
-                    console.error(`[hook] Error while executing hook ${name}:`, e);
-                    if (name !== 'error')
-                        this.runHook('error', e);
-                })
-            ) 
-        ).then(() => {
-            this.config.debug && console.info(`[hook] Hooks ${name} executed with success.`);
-        })
-    }
-
-}