5htp-core 0.1.2 → 0.2.0

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

@@ -7,7 +7,7 @@ import ws from 'ws';
 import type { IncomingMessage } from 'http';
 
 // Core
-import AuthService from '@server/services/router/request/services/auth';
+import type SocketService from '.';
 import context from '@server/context';
 
 /*----------------------------------
@@ -33,7 +33,7 @@ const activityDelay = 10 * 1000; // Clearn broken connections veery 10s
 /*----------------------------------
 - SCOPE
 ----------------------------------*/
-export default class SocketScope {
+export default class SocketScope<TUser extends {}> {
 
     private connectEvent?: TConnectCallback;
     private disconnectEvent?: TConnectCallback;
@@ -41,7 +41,9 @@ export default class SocketScope {
     public users: { [username: string]: WebSocket[] } = {}
 
     public constructor(
-        public path: string
+        public path: string,
+        private socket: SocketService<TUser>,
+        private app = socket.app
     ) {
 
     }
@@ -74,7 +76,7 @@ export default class SocketScope {
         context.run({ channelType: 'socket', channelId: this.path }, async () => {
 
         // Auth
-        const username = await AuthService.decode(req);
+        const username = await this.socket.config.users.decode(req);
         if (!username) {
             console.log(`Rejecting connection on ${this.path} for client ${socket.ip} (${socket.id})}: Not authenticated`);
             socket.close(4004, "auth");

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

@@ -0,0 +1,203 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import jwt from 'jsonwebtoken';
+import type express from 'express';
+import type http from 'http';
+
+// Core
+import Application from '@server/app';
+import Service from '@server/app/service';
+import { 
+    default as Router, Request as ServerRequest,
+} from '@server/services/router';
+import { InputError, AuthRequired, Forbidden } from '@common/errors';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+export type TUserRole = typeof UserRoles[number]
+
+export type THttpRequest = express.Request | http.IncomingMessage;
+
+/*----------------------------------
+- CONFIG
+----------------------------------*/
+
+const LogPrefix = '[auth]'
+
+export const UserRoles = ['USER', 'ADMIN', 'TEST', 'DEV'] as const
+
+/*----------------------------------
+- SERVICE CONVIG
+----------------------------------*/
+
+export type TConfig = {
+    debug: boolean,
+    logoutUrl: string,
+    jwt: {
+        // 2048 bits
+        key: string,
+        expiration: string,
+    },
+    google?: {
+        web: {
+            clientId: string,
+            secret: string,
+        },
+        android: {
+            clientId: string
+        }
+    }
+}
+
+export type THooks = {
+    
+}
+
+/*----------------------------------
+- SERVICE
+----------------------------------*/
+export default abstract class UsersManagementService<
+    TUser extends {},
+    TApplication extends Application,
+    TJwtSession extends {} = {},
+    TRequest extends ServerRequest<Router> = ServerRequest<Router>,
+> extends Service<TConfig, THooks, TApplication> {
+
+    public async register() {
+       
+    }
+
+    public async start() {
+
+    }
+
+    public abstract login( ...args: any[] ): Promise<{ user: TUser, token: string }>;
+    public abstract decodeSession( jwt: TJwtSession, req: THttpRequest ): Promise<TUser>;
+
+    protected abstract displayName(user: TUser): string;
+    protected abstract displaySessionName(session: TJwtSession): string;
+
+    public async decode( req: THttpRequest, withData: true ): Promise<TUser | null>;
+    public async decode( req: THttpRequest, withData?: false ): Promise<TJwtSession | null>;
+    public async decode( req: THttpRequest, withData: boolean = false ): Promise<TJwtSession | TUser | null> {
+
+        this.config.debug && console.log(LogPrefix, 'Decode:', { cookie: req.cookies['authorization'] });
+        
+        let token: string | undefined;
+        if (('cookies' in req) && typeof req.cookies['authorization'] === 'string')
+            token = req.cookies['authorization'];
+        // Desktop app webview do not support cookie config, so wwe retrieve it from headers
+        else if (typeof req.headers['authorization'] === 'string')
+            token = req.headers['authorization'];
+
+        if (token === undefined)
+            return this.unauthorized(req);
+
+        let session: TJwtSession;
+        try {
+            session = jwt.verify(token, this.config.jwt.key, { 
+                maxAge: this.config.jwt.expiration 
+            });
+        } catch (error) {
+            console.warn(LogPrefix, "Failed to decode jwt token:", token);
+            return this.unauthorized(req);
+        }
+
+        // Return email only
+        const sessionName = this.displaySessionName(session);
+        if (!withData) {
+            this.config.debug && console.log(LogPrefix, `Auth user ${sessionName} successfull. Return email only`);
+            return session;
+        }
+
+        // Deserialize full user data
+        this.config.debug && console.log(LogPrefix, `Deserialize user ${sessionName}`);
+        const user = await this.decodeSession(session, req);
+        this.config.debug && console.log(LogPrefix, `Deserialized user ${sessionName}:`, user);
+
+        return user;    
+    }
+
+    public unauthorized( req: THttpRequest ) {
+
+        if ('res' in req) {
+            // If use auth failed, we remove the jwt token so we avoid to trigger the same auth error in the next request
+            console.warn(LogPrefix, "Auth failed: remove authorization cookie");
+            req.res?.clearCookie('authorization');
+        }
+
+        return null;
+    }
+
+    protected createSession( session: TJwtSession, request: TRequest ): string {
+
+        this.config.debug && console.info(LogPrefix, `Creating new session:`, session);
+
+        const token = jwt.sign(session, this.config.jwt.key);
+
+        this.config.debug && console.info(LogPrefix, `Generated JWT token for session:` + token);
+
+        request.res.cookie('authorization', token);
+
+        return token;
+    }
+
+    public logout( request: TRequest ) {
+
+        const user = request.user;
+        if (!user) return;
+
+        this.config.debug && console.info(LogPrefix, `Logout ${this.displayName(user)}`);
+        request.res.clearCookie('authorization');
+    }
+
+    public check( request: TRequest, role: TUserRole, motivation?: string): TUser;
+    public check( request: TRequest, role: false, motivation?: string): null;
+    public check( request: TRequest, role: TUserRole | boolean = 'USER', motivation?: string): TUser | null {
+
+        const user = request.user;
+
+        this.config.debug && console.warn(LogPrefix, `Check auth, role = ${role}. Current user =`, user);
+
+        if (user === undefined) {
+
+            throw new Error(`request.user has not been decoded.`);
+
+        // Shortcut: { auth: true } <=> { auth: 'USER' }
+        } else if (role === true) {
+
+            role = 'USER';
+
+        // No auth needed
+        } else if (role === false) {
+
+            return user;
+
+        // Not connected
+        } else if (user === null) {
+
+            this.config.debug && console.warn(LogPrefix, "Refusé pour anonyme (" + request.ip + ")");
+            throw new AuthRequired(motivation);
+            
+        // Insufficient permissions
+        } else if (!user.roles.includes(role)) {
+
+            console.warn(LogPrefix, "Refusé: " + role + " pour " + this.displayName(user) + " (" + (user.roles ? user.roles.join(', ') : 'role inconnu') + ")");
+
+            throw new Forbidden("You do not have sufficient permissions to access this resource.");
+
+        } else {
+
+            console.warn(LogPrefix, "Autorisé " + role + " pour " + this.displayName(user) + " (" + user.roles.join(', ') + ")");
+
+        }
+
+        return user;
+    }
+
+}

package/src/server/services/{auth/base.ts → users/old.ts}

@@ -1,28 +1,8 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
 
-// Npm
 import md5 from 'md5';
 import { OAuth2Client, LoginTicket } from 'google-auth-library';
 
-// Core libs
-import { Forbidden } from '@common/errors';
 
-// App Libs
-import { IP } from '@server/models';
-import app, { $ } from '@server/app';
-
-// Serbices
-import '@server/services/database';
-
-/*----------------------------------
-- TYPES
-----------------------------------*/
-
-import type ServerRequest from '@server/services/router/request';
-
-export type TUserRole = typeof UserRoles[number]
 
 type AuthResponse = {
     token: string,
@@ -30,90 +10,26 @@ type AuthResponse = {
     user: User
 }
 
-/*----------------------------------
-- CONFIG
-----------------------------------*/
-
-const config = app.config.auth;
-
-const LogPrefix = '[auth]'
-
-export const UserRoles = ['USER', 'ADMIN', 'TEST', 'DEV'] as const
-
-/*----------------------------------
-- SERVICE CONVIG
-----------------------------------*/
-
-export type AuthConfig = {
-    debug: boolean,
-    logoutUrl: string,
-    jwt: {
-        // 2048 bits
-        key: string,
-        expiration: string,
-    },
-    google?: {
-        web: {
-            clientId: string,
-            secret: string,
-        },
-        android: {
-            clientId: string
-        }
-    }
-}
-
-declare global {
-    namespace Core {
-
-        interface Services {
-            auth: UserAuthBase
-        }
-
-        namespace Config {
-            interface Services {
-                auth: AuthConfig
-            }
-        }
-    }
-}
+export default class {
 
-/*----------------------------------
-- SERVICE
-----------------------------------*/
-export default abstract class UserAuthBase {
 
-    public abstract getData( where: string ): Promise<User> ;
-    public abstract SsrMask: string;
+    public async start() {
 
-    public abstract beforeSignup(user: User): Promise< void >;
-    public abstract afterSignup(user: User): Promise<{ redirect: string }>;
-    
-    private googleClient = app.config.auth.google
-        ? new OAuth2Client(
-            app.config.auth.google.web.clientId, // Google Client ID
-            app.config.auth.google.web.secret, // Private key
-            "https://" + app.env.domain + "/auth/google/response" // Redirect url
-        )
-        : undefined;
+        // Google auth client
+        if (this.config.google) {
 
-    public async load() {
+            const httpConfig = this.app.http.publicUrl;
 
+            this.googleClient = new OAuth2Client(
+                this.config.google.web.clientId, // Google Client ID
+                this.config.google.web.secret, // Private key
+                httpConfig + "/auth/google/response" // Redirect url
+            );
+        }
     }
 
-    public async FromEmail(
-        email: string, 
-        request: ServerRequest, 
-        userInfo: Partial<User> = {} 
-    ) {
-
-        const { token, user } = await this.Auth(email, request, false, userInfo);
-
-        return await request.response.json(
-            { token, user },
-            `token user( ` + this.SsrMask + ` )`
-        )
-    }
+    
+    private googleClient: OAuth2Client | undefined;
 
     public async FromGoogle(request: ServerRequest): Promise<string> {
 
@@ -145,7 +61,8 @@ export default abstract class UserAuthBase {
         request: ServerRequest,
     ): Promise<AuthResponse> {
 
-        if (!this.googleClient)
+        const googleConfig = this.config.google;
+        if (!this.googleClient || !googleConfig)
             throw new Forbidden(`Authentication method disabled.`);
 
         if (codeOrToken === undefined)
@@ -156,15 +73,15 @@ export default abstract class UserAuthBase {
             return this.GoogleResponse('token', r.tokens.id_token, request);
         }
 
-        config.debug && console.log(LogPrefix, "Auth via google", app.config.auth.google);
+        this.config.debug && console.log(LogPrefix, "Auth via google", googleConfig);
 
         let ticket: LoginTicket;
         try {
             ticket = await this.googleClient.verifyIdToken({
                 idToken: codeOrToken,
                 audience: [
-                    app.config.auth.google.web.clientId,
-                    app.config.auth.google.android.clientId,
+                    googleConfig.web.clientId,
+                    googleConfig.android.clientId,
                 ]
             });
         } catch (error) {
@@ -198,7 +115,7 @@ export default abstract class UserAuthBase {
         userInfo: Partial<User> = {} 
     ): Promise<AuthResponse> {
 
-        let user = await this.getData('email = ' + $.sql.esc(email));
+        let user = await this.getData('email = ' + this.sql.esc(email));
         let ip: IP;
         let redirect: string;
         if (!user) { // Signup
@@ -225,7 +142,7 @@ export default abstract class UserAuthBase {
             
         }
 
-        /*await $.sql`
+        /*await this.sql`
             INSERT INTO UserLogin SET
                 user = ${user.email},
                 date = NOW(),
@@ -244,7 +161,7 @@ export default abstract class UserAuthBase {
         let username = email.split('@')[0];
 
         // Prefix username if alreasy existing
-        const duplicates = await $.sql`
+        const duplicates = await this.sql`
             FROM User 
             WHERE name REGEXP CONCAT('^', ${username}, '[0-9]*$');
         `.count();
@@ -268,12 +185,12 @@ export default abstract class UserAuthBase {
         // Referrer
         if (user.referrer !== undefined) {
 
-            const refExists = await $.sql`FROM User WHERE name = ${user.referrer}`.exists();
+            const refExists = await this.sql`FROM User WHERE name = ${user.referrer}`.exists();
             if (!refExists)
                 user.referrer = undefined;
             else {
                 
-                await $.sql.upsert('UserStats', { 
+                await this.sql.upsert('UserStats', { 
                     user: user.referrer,
                     date: new Date,
                     refSignups: 1 
@@ -284,8 +201,8 @@ export default abstract class UserAuthBase {
         }
             
         // Create user
-        await $.sql.insert('User', user);
-        await $.sql.update('logs.IP', { user_name: username }, { address: request.ip });
+        await this.sql.insert('User', user);
+        await this.sql.update('logs.IP', { user_name: username }, { address: request.ip });
 
         // Hook
         let redirect: string = '/';
@@ -296,7 +213,7 @@ export default abstract class UserAuthBase {
         // remove user.emailHash
 
         // Notif email
-        await $.email.send({
+        await this.email.send({
             to: app.identity.author.email,
             subject: app.identity.name + ": New User",
             html: JSON.stringify(user)
@@ -335,7 +252,7 @@ export default abstract class UserAuthBase {
                 return;
 
             // Check if user exists
-            const referrerExists = await $.sql`FROM User WHERE name = ${referrer}`.count();
+            const referrerExists = await this.sql`FROM User WHERE name = ${referrer}`.count();
             if (referrerExists === 0)
                 return;
 
@@ -347,7 +264,7 @@ export default abstract class UserAuthBase {
             response.cookie('r', referrer);
 
             // Count the clic 
-            await $.sql.upsert('UserStats', { 
+            await this.sql.upsert('UserStats', { 
                 user: referrer,
                 date: new Date,
                 refClics: 1 
@@ -357,5 +274,4 @@ export default abstract class UserAuthBase {
         }
 
     }
-
 }

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

@@ -0,0 +1,72 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+
+// Core
+import type Application from '@server/app';
+
+import { 
+    default as Router, Request as ServerRequest, TRoute,
+    RouterService
+} from '@server/services/router';
+
+// Specific
+import type { default as UsersService, TUserRole } from '..';
+import UsersRequestService from './request';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+
+/*----------------------------------
+- CONFIG
+----------------------------------*/
+
+const LogPrefix = '[router][auth]';
+
+/*----------------------------------
+- SERVICE
+----------------------------------*/
+export default class AuthenticationRouterService<
+    TUser extends {} = {},
+    TRequest extends ServerRequest<Router> = ServerRequest<Router>,
+> extends RouterService {
+
+    public constructor( 
+        public users: UsersService<TUser, Application>,
+        public config = users.config
+    ) {
+
+        super();
+
+    }
+
+    public async register() {
+
+        // Decode current user
+        this.router.on('request', async (request: TRequest) => {
+
+            // TODO: Typings. (context.user ?)
+            const decoded = await this.users.decode( request.req, true);
+
+            console.log("DECODED", decoded);
+
+            request.user = decoded || null;
+        })
+
+        // Check route permissions
+        this.router.on('resolved', async (route: TRoute, 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);
+        })
+    }
+
+    public requestService( request: TRequest ): UsersRequestService<TUser> {
+        return new UsersRequestService( request, this );
+    }   
+}

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

@@ -0,0 +1,49 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import jwt from 'jsonwebtoken';
+
+// Core
+import type { default as Router, Request as ServerRequest } from '@server/services/router';
+import RequestService from '@server/services/router/request/service';
+import { InputError, AuthRequired, Forbidden } from '@common/errors';
+
+// Specific
+import type AuthenticationRouterService from '.';
+import type { default as UsersManagementService, TUserRole } from '..';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+/*----------------------------------
+- MODULE
+----------------------------------*/
+export default class UsersRequestService<
+    TUser extends {}
+> extends RequestService {
+
+    public constructor( 
+        request: ServerRequest<Router>,
+        public auth: AuthenticationRouterService,
+        public users = auth.users,
+    ) {
+        super(request);
+    }
+
+    public login( email: string ) {
+        return this.users.login( this.request, email );
+    }
+
+    public logout() {
+        return this.users.logout( this.request );
+    }
+
+    public check( role: TUserRole, motivation?: string): TUser;
+    public check( role: false, motivation?: string): null;
+    public check( role: TUserRole | boolean = 'USER', motivation?: string): TUser | null {
+        return this.users.check( this.request, role, motivation );
+    }
+}

package/src/types/aliases.d.ts

@@ -1,13 +1,54 @@
+declare module "@/client/pages/\*\*/_layout/index.tsx" {
+    const Layout: import("../common/router/layouts").ImportedLayouts;
+    export = LayoutsList
+}
+
 declare module "@/client/pages/\*.tsx" {
-    const value: import("../client/router").TRoutesLoaders;
+    const value: import("../client/services/router").TRoutesLoaders;
     export = value;
 }
+
 declare module "@client/pages/\*.tsx" {
-    const value: import("../client/router").TRoutesLoaders;
+    const value: import("../client/services/router").TRoutesLoaders;
     export = value;
 }
 
 declare module "@/server/services/auth" {
     const UserAuthService: import("../server/services/auth/base").default;
     export = UserAuthService;
+}
+
+declare module "@/server" {
+    const ServerApplicationClass: import("../server/app").default;
+    export = InstanceType<ServerApplicationClass>;
+}
+
+declare module "@/client" {
+    const ClientApplicationClass: import("../client/app").default;
+    export = InstanceType<ClientApplicationClass>;
+}
+
+declare module "@/client/context" {
+
+    const Test: true;
+
+    const ClientRouter: import('../client/services/router').default;
+    const ServerRouter: import('../server/services/router').default;
+
+    const TServerRouterRequestContext: import('../server/services/router/response').TRouterContext;
+    const TClientRouterRequestContext: import('../client/services/router/response').TRouterContext;
+
+    export const ClientContext = (
+        // TO Fix: TClientRouterRequestContext is unable to get the right type of CrossPathClient["router"]
+        //    (it gets ClientApplication instead of CrossPathClient)
+        TClientRouterRequestContext<ClientRouter, ClientRouter["app"]>
+        | 
+        TServerRouterRequestContext<ServerRouter>
+    )
+
+    export const ReactClientContext: preact.Context<ClientContext>;
+
+    const useContext: () => ClientContext;
+
+    export = useContext;
 }

package/templates/composant.tsx

@@ -8,7 +8,7 @@
 import React from 'react';
 
 // Core libs
-import useContext from '@client/context';
+import useContext from '@/client/context';
 
 // Core components
 import Button from '@client/components/button';

package/templates/modal.tsx

@@ -8,7 +8,7 @@
 import React from 'react';
 
 // Cre libs
-import useContext from '@client/context';
+import useContext from '@/client/context';
 
 // Core components
 import Card, { Props as CardProps } from '@client/components/Dialog/card';

package/templates/page.tsx

@@ -9,7 +9,7 @@ import React from 'react';
 
 // Core
 import route from '@router';
-import { useState } from '@client/context';
+import { useState } from '@/client/context';
 
 // Core components
 import Button from '@client/components/button';