5htp-core 0.1.1 → 0.1.2-2

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "5htp-core",
 	"description": "5-HTP, scientifically called 5-Hydroxytryptophan, is the precursor of happiness neurotransmitter.",
-	"version": "0.1.1",
+	"version": "0.1.2-2",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/5htp-core.git",
 	"license": "MIT",
@@ -58,6 +58,8 @@
 		"nodemailer": "^6.6.3",
 		"path-to-regexp": "^6.2.0",
 		"picomatch": "^2.3.1",
+		"preact": "^10.5.15",
+		"preact-render-to-string": "^5.1.19",
 		"react-scrollbars-custom": "^4.0.27",
 		"react-slider": "^2.0.1",
 		"react-textarea-autosize": "^8.3.3",
@@ -66,7 +68,6 @@
 		"request": "^2.88.2",
 		"sharp": "^0.29.1",
 		"sql-formatter": "^4.0.2",
-		"ts-alias": "^0.0.3-1",
 		"tslog": "^3.2.2",
 		"uuid": "^8.3.2",
 		"uuid-by-string": "^3.0.4",
@@ -83,9 +84,5 @@
 		"@types/universal-analytics": "^0.4.5",
 		"@types/webpack-env": "^1.16.2",
 		"@types/ws": "^7.4.7"
-	},
-    "peerDependencies": {
-        "preact": "^10.5.15",
-		"preact-render-to-string": "^5.1.19"
-    }
+	}
 }

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

@@ -1,3 +1,10 @@
+.white-card() {
+    background: white;
+    box-shadow: 0 3px 2px fade(#000, 10%);
+    border: solid 1px fade(#000, 10%);
+    border-radius: @radius;
+}
+
 .card,
 .input.text,
 .btn,
@@ -7,10 +14,7 @@ i.solid {
     .build-theme-bg( #fff, #8E8E8E);
 
     &:not(.bg) {
-        background: white;
-        box-shadow: 0 3px 2px fade(#000, 10%);
-        border: solid 1px fade(#000, 10%);
-        border-radius: @radius;
+        .white-card();
     }
 
     .bg & {

package/src/client/components/Card/index.tsx

@@ -29,7 +29,7 @@ export type Props = {
     cover?: {
         color?: string,
         title?: string,
-        logo?: string
+        logo?: ComponentChild
     },
     metas: TMeta[],
     class?: string,

package/src/client/context/index.ts

@@ -19,7 +19,6 @@ import SocketClient from './socket';
 /*----------------------------------
 - TYPES
 ----------------------------------*/
-import { User, GuestUser } from '@common/models';
 
 import type { Layout } from '@common/router';
 
@@ -63,7 +62,7 @@ export const useState = <TData extends TObjetDonnees>(initial: TData): [
 export class ClientContext {
 
     public context = this; // To access to the full nstance within a destructuration
-    public user: User | typeof GuestUser;
+    public user: User | null;
 
     public id = Date.now();
     public bridges: { [name: string]: Function } = {};
@@ -109,7 +108,7 @@ export class ClientContext {
     ) {
        
         this.request = request;
-        this.user = this.request.user || { ...GuestUser };
+        this.user = this.request.user || null;
 
     }
 
@@ -120,7 +119,7 @@ export class ClientContext {
         // Actions on the native app 
         reloadDaemon: () => { },
         reloadGui: () => {
-            this.request.response?.redirect('/');
+            this.page?.go('/');
         },
         optimize: () => {},
 

package/src/client/index.tsx

@@ -14,7 +14,6 @@ import router from '@client/router';
 import { location } from '@client/router/request/history';
 import coreRoutes from '@client/pages/**/*.tsx';
 import appRoutes from '@/client/pages/**/*.tsx';
-import { GuestUser } from '@common/models';
 
 import ClientResponse from './router/response';
 import ClientRequest from './router/request';
@@ -99,7 +98,7 @@ try {
             if (!route)
                 throw new Error(`Route ${ssrResponse.page.id} was not found in ssr routes list.`);
 
-            context.user = request.user = ssrResponse.user || { ...GuestUser };
+            context.user = request.user = ssrResponse.user || null;
 
             request.data = ssrResponse.request.data;
 

package/src/client/router/Link.tsx

@@ -0,0 +1,36 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import React from 'react';
+import type { ComponentChild } from 'preact';
+import { history } from './request/history';
+
+/*----------------------------------
+- COMPONENT
+----------------------------------*/
+// Simple link
+export const Link = ({ to, ...props }: { 
+    to: string,
+    children?: ComponentChild,
+    class?: string,
+    className?: string
+} & React.HTMLProps<HTMLAnchorElement>) => {
+
+    // External = open in new tab by default
+    if (to[0] !== '/' || to.startsWith('//'))
+        props.target = '_blank';
+    // Otherwise, propagate to the router
+    else 
+        props.onClick = (e) => {
+            history?.push(to);
+            e.preventDefault();
+            return false
+        }
+
+    return (
+        <a {...props} href={to} />
+    )
+
+}

package/src/client/router/{index.tsx → index.ts}

@@ -4,119 +4,102 @@
 
 // Npm
 import React from 'react';
-import type { ComponentChild } from 'preact';
-import type { Location } from 'history';
 
 // Core: libs
 import ClientRequest from './request';
 import ClientResponse from './response';
-import { history } from './request/history';
 
 // Core: types
-import BaseRouter, { TBaseRoute, TRouteOptions, defaultOptions, } from '@common/router'
+import BaseRouter, { defaultOptions, } from '@common/router'
 import { PageResponse } from '@common/router/response';
-import { TFetcher, TFetcherList } from '@common/router/request';
-import type { TSsrData, default as ServerResponse } from '@server/services/router/response';
+import type { TSsrData } from '@server/services/router/response';
 import type { ClientContext } from '@client/context';
 
 // Type xports
 export type { default as ClientResponse } from "./response";
+export { Link } from './Link';
+import type { 
+    TClientRoute,
+    TUnresolvedRoute,
+    TSsrUnresolvedRoute,
+    TRoutesLoaders,
+    TRouteCallback,
+    TFetchedRoute,
+    TRegisterPageArgs
+} from './route';
+
+// Temporary
+// TODO: Import these types directly from router/routes
+export type { 
+    TClientRoute,
+    TUnresolvedRoute,
+    TSsrUnresolvedRoute,
+    TRoutesLoaders,
+    TRouteCallback,
+    TFetchedRoute,
+    TRegisterPageArgs,
+    TFrontController
+} from './route';
 
 /*----------------------------------
-- TYPES: PARTIAL ROUTES
+- CONFIG
 ----------------------------------*/
 
-export type TSsrUnresolvedRoute = Pick<TClientRoute, 'type' | 'keys'> & {
-    regex: string,
-    chunk: string,
-}
-
-export type TUnresolvedRoute = Pick<TClientRoute, 'type' | 'keys'> & {
-    regex: RegExp,
-    chunk: string,
-    load: TRouteLoader,
-}
-
-type TFetchedRoute = Pick<TClientRoute, 'path' | 'options' | 'controller' | 'renderer' | 'method'>
+const debug = true;
+const LogPrefix = '[router]'
 
 /*----------------------------------
-- TYPES: REGISTER
+- TYPES
 ----------------------------------*/
 
-type TRouteLoader = () => Promise<{ default: TFetchedRoute }>;
-
-export type TRoutesLoaders = {
-    [chunkId: string]: /* Preloaded via require() */TFetchedRoute | /* Loader via import() */TRouteLoader/* | undefined*/
-}
+export type THookCallback = (request: ClientRequest) => void;
 
-type TRouteCallback = (route?: TClientRoute) => void;
-
-export type TRegisterPageArgs<TControllerData extends TFetcherList = {}> = [
-    path: string,
-    options: Partial<TRouteOptions>,
-    controller: TFrontController<TControllerData> | null,
-    renderer: TFrontRenderer<TControllerData>
-];
+type THookName = 'locationChange'
 
 /*----------------------------------
-- TYPES: COMPLETE ROUTES
+- ROUTER
 ----------------------------------*/
+class Router extends BaseRouter {
 
-export type TClientRoute = TBaseRoute & {
-    type: 'PAGE',
-    method: 'GET',
-    controller: TFrontController | null,
-    renderer: TFrontRenderer
-}
+    /*----------------------------------
+    - HOOKS
+    ----------------------------------*/
+    private hooks: {
+        [hookname in THookName]?: (THookCallback | null)[]
+    } = {}
 
-// 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 TFrontController<TControllerData extends TFetcherList = {}> = 
-    (urlParams: TObjetDonnees, context: ClientContext) => TControllerData
-
-export type TFrontRenderer<TControllerData extends TFetcherList = {}> = (
-    data: {
-        [Property in keyof TControllerData]: undefined | (extractGeneric<TControllerData[Property]> extends ((...args: any[]) => any) 
-            ? ThenArg<ReturnType< extractGeneric<TControllerData[Property]> >>
-            : extractGeneric<TControllerData[Property]>
-        )
-    },
-    context: ClientContext
-) => ComponentChild
-
-// Simple link
-export const Link = ({ to, ...props }: { 
-    to: string,
-    children?: ComponentChild,
-    class?: string,
-    className?: string
-}) => {
-
-    // External = open in new tab by default
-    if (to[0] !== '/' || to.startsWith('//'))
-        props.target = '_blank';
-    // Otherwise, propagate to the router
-    else 
-        props.onClick = (e) => {
-            history?.push(to);
-            e.preventDefault();
-            return false
-        }
+    public on( hookName: THookName, callback: THookCallback ) {
 
-    return (
-        <a {...props} href={to} />
-    )
+        debug && console.info(LogPrefix, `Register hook ${hookName}`);
 
-}
+        let cbIndex: number;
+        let callbacks = this.hooks[ hookName ];
+        if (!callbacks) {
+            cbIndex = 0;
+            callbacks = this.hooks[ hookName ] = [callback]
+        } else {
+            cbIndex = callbacks.length;
+            callbacks.push(callback);
+        }
 
-const debug = true;
+        // Listener remover
+        return () => {
+            debug && console.info(LogPrefix, `De-register hook ${hookName} (index ${cbIndex})`);
+            delete (callbacks as THookCallback[])[ cbIndex ];
+        }
 
-/*----------------------------------
-- ROUTER
-----------------------------------*/
-class Router extends BaseRouter {
+    }
+    private runHook( hookName: THookName, request: ClientRequest ) {
+        const callbacks = this.hooks[hookName];
+        if (callbacks)
+            for (const callback of callbacks)
+                // callback can be null since we use delete to unregister
+                callback && callback(request);
+    }
+
+    /*----------------------------------
+    - ROUTES MANAGEMENT
+    ----------------------------------*/
 
     public disableResolver = false;
 
@@ -171,6 +154,8 @@ class Router extends BaseRouter {
     public async resolve( request: ClientRequest, context: ClientContext ): Promise<PageResponse | undefined | null> {
         debug && console.log('Resolving request', request.path, Object.keys(request.data));
 
+        this.runHook('locationChange', request);
+
         for (let iRoute = 0; iRoute < this.routes.length; iRoute++) {
 
             let route = this.routes[iRoute];

package/src/client/router/route.ts

@@ -0,0 +1,75 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import type { ComponentChild } from 'preact';
+
+// Core
+import type { ClientContext } from '@client/context';
+import type { TBaseRoute, TRouteOptions, } from '@common/router'
+import type { TFetcher, TFetcherList } from '@common/router/request';
+
+/*----------------------------------
+- TYPES: PARTIAL ROUTES
+----------------------------------*/
+
+export type TSsrUnresolvedRoute = Pick<TClientRoute, 'type' | 'keys'> & {
+    regex: string,
+    chunk: string,
+}
+
+export type TUnresolvedRoute = Pick<TClientRoute, 'type' | 'keys'> & {
+    regex: RegExp | null,
+    chunk: string,
+    load: TRouteLoader,
+}
+
+export type TFetchedRoute = Pick<TClientRoute, 'path' | 'options' | 'controller' | 'renderer' | 'method'>
+
+/*----------------------------------
+- TYPES: REGISTER
+----------------------------------*/
+
+type TRouteLoader = () => Promise<{ default: TFetchedRoute }>;
+
+export type TRoutesLoaders = {
+    [chunkId: string]: /* Preloaded via require() */TFetchedRoute | /* Loader via import() */TRouteLoader/* | undefined*/
+}
+
+export type TRouteCallback = (route?: TClientRoute) => void;
+
+export type TRegisterPageArgs<TControllerData extends TFetcherList = {}> = [
+    path: string,
+    options: Partial<TRouteOptions>,
+    controller: TFrontController<TControllerData> | null,
+    renderer: TFrontRenderer<TControllerData>
+];
+
+/*----------------------------------
+- TYPES: COMPLETE ROUTES
+----------------------------------*/
+
+export type TClientRoute = TBaseRoute & {
+    type: 'PAGE',
+    method: 'GET',
+    controller: TFrontController | null,
+    renderer: TFrontRenderer
+}
+
+// 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 TFrontController<TControllerData extends TFetcherList = {}> = 
+    (urlParams: TObjetDonnees, context: ClientContext) => TControllerData
+
+export type TFrontRenderer<TControllerData extends TFetcherList = {}> = (
+    data: {
+        [Property in keyof TControllerData]: undefined | (extractGeneric<TControllerData[Property]> extends ((...args: any[]) => any) 
+            ? ThenArg<ReturnType< extractGeneric<TControllerData[Property]> >>
+            : extractGeneric<TControllerData[Property]>
+        )
+    },
+    context: ClientContext
+) => ComponentChild

package/src/common/router/index.ts

@@ -13,11 +13,13 @@ import type {
     TFrontRenderer 
 } from '@client/router';
 
-import type { TApiServerRoute } from '@server/services/router';
+import type { ClientContext } from '@client/context';
 
 import type { TSchema } from '@common/data/input/validate';
 
-import { TUserRole } from '@common/models';
+import type { TApiServerRoute } from '@server/services/router';
+
+import type { TUserRole } from '@server/services/auth/base';
 
 /*----------------------------------
 - TYPES: layouts
@@ -25,7 +27,7 @@ import { TUserRole } from '@common/models';
 
 import layouts from '@/client/pages/**/_layout/index.tsx';
 
-type LayoutComponent = ({ context: ClientContext }) => ComponentChild;
+type LayoutComponent = (attributes: { context: ClientContext }) => ComponentChild;
 export type Layout = { path: string, Component: LayoutComponent }
 const getLayout = (routePath: string | undefined): Layout | undefined => {
     
@@ -84,7 +86,7 @@ export type TRouteOptions = {
 
 }
 
-export const defaultOptions: TRouteOptions = {
+export const defaultOptions = {
     priority: 0,
 }
 

package/src/server/app/config.ts

@@ -30,14 +30,8 @@ declare global {
 
 export type TEnvName = TEnvConfig["name"];
 export type TEnvConfig = {
-
     name: 'local' | 'server',
     profile: 'dev' | 'prod',
-    level: 'silly' | 'info' | 'warn' | 'error',
-
-    localIP: string,
-    domain: string,
-    url: string,
 }
 
 type AppIdentityConfig = {
@@ -93,20 +87,10 @@ export default class ConfigParser {
         console.log("Using environment:", process.env.NODE_ENV);
         return process.env.NODE_ENV === 'development' ? {
             name: 'local',
-            profile: 'dev',
-            level: 'silly',
-        
-            localIP: '86.76.176.80',
-            domain: 'localhost:3010',
-            url: 'http://localhost:3010',
+            profile: 'dev'
         } : {
             name: 'server',
             profile: 'prod',
-            level: 'silly',
-        
-            localIP: '86.76.176.80',
-            domain: 'megacharger.io',
-            url: 'https://megacharger.io',
         }
     }
 

package/src/server/app/index.ts

@@ -74,7 +74,7 @@ export class App {
         get: (container, serviceId, receiver) => {
 
             if (!( serviceId in container ) && typeof serviceId === 'string')
-                throw new Error(`Service not loaded: ${serviceId}`);
+                throw new Error(`The following service is required as a dependancy: ${serviceId}`);
 
             return container[serviceId];
         }

package/src/server/libs/pages/document.tsx

@@ -34,7 +34,7 @@ export default ({ page, children: html, request, ssrData }: {
 
     const routesForClient = JSON.stringify( services.router.ssrRoutes );
 
-    const fullUrl = services.http.url + request.path;
+    const fullUrl = services.http.publicUrl + request.path;
 
     let attrsBody = {
         className: [...page.bodyClass].join(' '),

package/src/server/services/auth/base.ts

@@ -10,7 +10,7 @@ import { OAuth2Client, LoginTicket } from 'google-auth-library';
 import { Forbidden } from '@common/errors';
 
 // App Libs
-import { IP } from '@models';
+import { IP } from '@server/models';
 import app, { $ } from '@server/app';
 
 // Serbices
@@ -22,6 +22,8 @@ import '@server/services/database';
 
 import type ServerRequest from '@server/services/router/request';
 
+export type TUserRole = typeof UserRoles[number]
+
 type AuthResponse = {
     token: string,
     redirect: string,   
@@ -36,6 +38,12 @@ 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,
@@ -81,16 +89,22 @@ export default abstract class UserAuthBase {
     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;
+    private googleClient: OAuth2Client | undefined;
 
     public async load() {
 
+        // Google auth client
+        if (app.config.auth.google) {
+
+            const httpConfig = app.services.http.publicUrl;
+
+            this.googleClient = new OAuth2Client(
+                app.config.auth.google.web.clientId, // Google Client ID
+                app.config.auth.google.web.secret, // Private key
+                httpConfig + "/auth/google/response" // Redirect url
+            );
+        }
+
     }
 
     public async FromEmail(
@@ -137,7 +151,8 @@ export default abstract class UserAuthBase {
         request: ServerRequest,
     ): Promise<AuthResponse> {
 
-        if (!this.googleClient)
+        const googleConfig = app.config.auth.google;
+        if (!this.googleClient || !googleConfig)
             throw new Forbidden(`Authentication method disabled.`);
 
         if (codeOrToken === undefined)
@@ -148,15 +163,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);
+        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) {

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

@@ -32,6 +32,9 @@ type AppBugInfos = {
 }
 
 export type ServerBug = {
+
+    type: 'server',
+
     // Context
     hash: string,
     date: Date, // Timestamp
@@ -42,11 +45,15 @@ export type ServerBug = {
     ip: string | null | undefined,
     
     // Error
+    error: Error,
     stacktrace: string,
-    logs: string
+    logs: string,
 }
 
 export type ApplicationBug = {
+
+    type: 'application',
+
     // Context
     hash: string,
     date: Date,
@@ -146,6 +153,9 @@ export default class BugReporter {
         );
 
         const bugReport: ServerBug = {
+
+            type: 'server',
+
             // Context
             hash: hash,
             date: now,
@@ -155,6 +165,7 @@ export default class BugReporter {
             user: request?.user?.name,
             ip: request?.ip,
             // Error
+            error,
             stacktrace: error.stack || error.message,
             logs: logsHtml
         }
@@ -193,6 +204,8 @@ export default class BugReporter {
 
         const bugReport: ApplicationBug = {
 
+            type: 'application',
+
             // Context
             hash: hash,
             date: now,

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

@@ -19,8 +19,15 @@ import BugReporter from "./bugReporter";
 
 export type TReportTransport = keyof typeof $
 
+type TLogProfile = 'silly' | 'info' | 'warn' | 'error'
+
 export type ConsoleConfig = {
-    bugReport: TReportTransport[]
+    dev: {
+        level: TLogProfile,
+    },
+    prod: {
+        level: TLogProfile
+    }
 }
 
 declare global {
@@ -120,6 +127,8 @@ export class Console {
    ----------------------------------*/
     public load() {
 
+        const envConfig = app.config.console[ app.env.profile ];
+
         this.logger = new Logger({
             overwriteConsole: true,
             //type: app.env.profile === 'dev' ? 'pretty' : 'hidden',
@@ -138,7 +147,7 @@ export class Console {
             warn: this.log.bind(this),
             error: this.log.bind(this),
             fatal: this.log.bind(this),
-        }, app.env.level);
+        }, envConfig.level);
 
         setInterval(() => this.clean(), 60000);
 

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

@@ -11,7 +11,6 @@ import app, { $ } from '@server/app';
 //import templates from './templates';
 const templates = {} as {[template: string]: (data: any) => string}
 import { jsonToHtml } from './utils';
-import greetings from '@common/data/chaines/greetings';
 
 /*----------------------------------
 - SERVICE CONFIG
@@ -20,10 +19,14 @@ import greetings from '@common/data/chaines/greetings';
 export type EmailServiceConfig = {
     debug: boolean,
     default: {
-        transporter: TransporterName,
+        transporter: string,
         from: string
     },
-    transporters: Core.Config.EmailTransporters
+    transporters: Core.EmailTransporters,
+    bugReport: {
+        from: string,
+        to: string
+    }
 }
 
 declare global {
@@ -67,32 +70,15 @@ export type TCompleteEmail = With<THtmlEmail, {
 - TYPES: OPTIONS
 ----------------------------------*/
 
-type TransporterName = keyof Core.Config.EmailTransporters;
-
 export abstract class Transporter {
     public abstract send( emails: TCompleteEmail[] ): Promise<void>;
 }
 
 type TOptions = {
-    transporter?: TransporterName,
+    transporter?: string,
     testing?: boolean
 }
 
-// TODO: to normalize
-export const userMail = (username: string, content: string) => `
-    ${greetings(username)}<br/><br/>
-
-    ${content}
-
-    <br/><br/>
-
-    If you need any help, send me an email at <a href="mailto:contact@gaetan-legac.fr">contact@gaetan-legac.fr</a>, and I will reply to as soon as I can.
-
-    <br/><br/>
-    Peace,<br/>
-    <a href="https://www.linkedin.com/in/ga%C3%ABtanlegac/">Gaëtan Le Gac</a>
-`
-
 const config = app.config.email;
 
 /*----------------------------------
@@ -100,23 +86,31 @@ const config = app.config.email;
 ----------------------------------*/
 export default class Email {
 
-    private transporters = {} as {[name in TransporterName]: Transporter};
-    public register( name: TransporterName, transporter: (new () => Transporter) ) {
+    private transporters = {} as {[name: string]: Transporter};
+    public register( name: string, transporter: (new () => Transporter) ) {
         console.log(`[email] registering email transporter: ${name}`);
         this.transporters[ name ] = new transporter();
     }
 
     public load() {
-        $.console.bugReport.addTransporter('email', (report, error) => this.send({
-            to: app.identity.author.email,
-            subject: "Server bug: " + error.message,
+        $.console.bugReport.addTransporter('email', (report) => this.send(report.type === 'server' ? {
+            from: config.bugReport.from,
+            to: config.bugReport.to,
+            subject: "Bug on server: " + (report.error.message),
             html: `
-                <a href="${app.env.url}/admin/activity/requests/${report.channelId}">
+                <a href="${app.services.http.publicUrl}/admin/activity/requests/${report.channelId}">
                     View Request details & console
                 </a>
                 <br/>
                 ${report.logs}
             `
+        } : {
+            from: config.bugReport.from,
+            to: config.bugReport.to,
+            subject: "Bug on application " + (report.action),
+            html: {
+                ...report
+            }
         }));
         
     }

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

@@ -11,9 +11,6 @@ import path from 'path';
 import cors from 'cors';
 //var serveStatic = require('serve-static')
 
-// Npm: Autres
-import fs from 'fs-extra';
-
 // Middlewares (npm)
 import morgan from 'morgan';
 import hpp from 'hpp'; // Protection contre la pollution des reuqtees http
@@ -38,13 +35,18 @@ import { MiddlewareFormData } from './multipart';
 ----------------------------------*/
 
 export type HttpServiceConfig = {
-    port: number
-    ssl: boolean,
 
+    // Access
+    domain: string,
+    port: number,
+    ssl: number,
+
+    // Limitations / Load restriction
     upload: {
         maxSize: string // Expression package bytes
     },
 
+    // Protections against bots
     security: {
         recaptcha: {
             prv: string,
@@ -75,35 +77,19 @@ export default class HttpServer {
     public router: Router;
 
     public config: HttpServiceConfig;
-    public url: string;
+    public publicUrl: string;
 
     public constructor() {
 
         // Init
         this.config = app.config.http;
-        this.url = (this.config.ssl ? 'https' : 'http') + '://' + app.env.domain;
-        this.express = express();
+        this.publicUrl = app.env.name === 'local'
+            ? 'http://localhost:' + this.config.port
+            : ((this.config.ssl ? 'https' : 'http') + '://' + this.config.domain);
 
         // Configure HTTP server
-        if (!this.config.ssl) {
-
-            this.http = http.createServer(this.express);
-
-        } /*else if ('ssh' in app.env) {
-
-            const ssh = app.env.ssh;
-
-            console.log("Création du serveur https pour le socket:", '/home/' + ssh.login + '/ssl.*');
-            this.http = https.createServer({
-                key: fs.readFileSync('/home/' + ssh.login + '/ssl.key'),
-                cert: fs.readFileSync('/home/' + ssh.login + '/ssl.cert'),
-                ca: fs.readFileSync('/home/' + ssh.login + '/ssl.ca'),
-                requestCert: true,
-                rejectUnauthorized: false
-            }, this.express);
-            
-        }*/ else
-            throw new Error(`SSL was enabled, but no ssh config was specified in app.env (required to load ssl certificate files)`);
+        this.express = express();
+        this.http = http.createServer(this.express);
 
         // Start HTTP Server
         this.router = app.services.router;
@@ -248,7 +234,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 https://${app.env.domain}:${this.config.port}/`);
+            console.info(`Serveur web démarré sur ${this.publicUrl}`);
         });
 
     }

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

@@ -96,8 +96,6 @@ export default class ServerRequest extends BaseRequest {
         this.cookies = res.req.cookies;
 
         this.ip = res.req.ip;
-        if (this.ip === '::1' && app.env.localIP)
-            this.ip = app.env.localIP;
 
         this.data = data || {};
 

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

@@ -10,14 +10,12 @@ import jwt from 'jsonwebtoken';
 // Cre
 import app, { $ } from '@server/app';
 import { InputError, AuthRequired, Forbidden } from '@common/errors';
-import { TUserRole } from '@common/models';
+import type { TUserRole } from '@server/services/auth/base';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-import { User } from '@models';
-
 import type ServerRequest from '@server/services/router/request'
 
 type TJwtSession = { email: string }

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

@@ -80,6 +80,8 @@ export default class ProtectService {
 
         return conflict;*/
 
+        return false;
+
     }
 
     public async captcha(token?: string) {

package/src/types/aliases.d.ts

@@ -7,17 +7,6 @@ declare module "@client/pages/\*.tsx" {
     export = value;
 }
 
-// Basic Models
-declare module "@/server/models/User" {
-    const User: import("../common/models").User;
-    export = User;
-}
-
-declare module "@/server/models/IP" {
-    const IP: import("../common/models").IP;
-    export = IP;
-}
-
 declare module "@/server/services/auth" {
     const UserAuthService: import("../server/services/auth/base").default;
     export = UserAuthService;

package/src/common/models/index.ts

@@ -1,43 +0,0 @@
-
-
-export const UserRoles = ['USER', 'ADMIN', 'TEST', 'DEV'] as const
-export type TUserRole = typeof UserRoles[number]
-
-export interface User {
-    name: string,
-    email: string,
-    emailHash: string,
-    roles: TUserRole[],
-
-    balance: number,
-    banned?: Date,
-}
-
-export const GuestUser = {
-    name: "Guest",
-
-    balance: 10,
-    multiplier: 1,
-    level: 1,
-
-    isGuest: true
-}
-
-export interface IP {
-    address: string,
-
-    country: string,
-    isp?: string,
-    user_name?: string,
-
-    meet: Date,
-    activity: Date,
-    updated?: Date,
-
-    iphub?: number,
-    getipintel?: number,
-    ipinfo?: number,
-
-    banned?: Date,
-    banReason?: string,
-}