5htp-core 0.2.1 → 0.2.2

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

@@ -2,7 +2,12 @@
 - DEPENDANCES
 ----------------------------------*/
 
-import NormalizedFile from '@common/data/file';
+// Npm
+import mime from 'mime-types';
+
+// Core
+import FileToUpload from '@client/components/inputv3/file/FileToUpload';
+import { InputError } from '@common/errors';
 
 /*----------------------------------
 - TYPES
@@ -11,6 +16,34 @@ import NormalizedFile from '@common/data/file';
 import type { Request, Response, NextFunction } from 'express';
 import type { FileArray, UploadedFile } from 'express-fileupload';
 
+/*----------------------------------
+- CONFIG
+----------------------------------*/
+const reMultipart = /^multipart\/(?:form-data|related)(?:;|$)/i;
+
+/*----------------------------------
+- MIDDLEWARE
+----------------------------------*/
+export const MiddlewareFormData = (req: Request, res: Response, next: NextFunction) => {
+
+    // Verif si multipart
+    if (!isMutipart( req ))
+        return next();
+        
+    // Données body + fichiers
+    // NOTE: Les données devant obligatoirement passer par le validateur de schema, 
+    //  On peut mélanger le body et les files sans risque de sécurité
+    req.body = traiterMultipart(req.body, req['files']);
+    //req.files = traiterMultipart(req.files);
+
+    next();
+}
+
+/*----------------------------------
+- FUNCTIONS
+----------------------------------*/
+export const isMutipart = (req: Request) => req.headers['content-type'] && reMultipart.exec( req.headers['content-type'] );
+
 export const traiterMultipart = (...canaux: any[]) => {
 
     let sortie: {[nom: string]: any} = {};
@@ -20,38 +53,39 @@ export const traiterMultipart = (...canaux: any[]) => {
         if (!donnees)
             continue;
 
-        for (const chemin in donnees) {
-            let donnee = donnees[chemin];
+        for (const fieldPath in donnees) {
+            let donnee = donnees[fieldPath];
 
             let brancheA = sortie;
-            const resultats = [...chemin.matchAll(/[^\[\]]+/g)];
-            for (let iCle = 0; iCle < resultats.length; iCle++) {
+            const results = [...fieldPath.matchAll(/[^\[\]]+/g)];
+            for (let iCle = 0; iCle < results.length; iCle++) {
 
-                const [cle] = resultats[ iCle ];
+                const [cle] = results[ iCle ];
 
-                // Si ce n'est pas le dernier
-                if (iCle !== resultats.length - 1) {
+                // Need to go deeper to find data
+                if (iCle !== results.length - 1) {
 
                     if (brancheA[ cle ] === undefined) {
-                        const tableau = !isNaN( resultats[ iCle + 1 ][0] as any )
+                        const tableau = !isNaN( results[ iCle + 1 ][0] as any )
                         brancheA[ cle ] = tableau ? [] : {};
                     }
 
                     brancheA = brancheA[ cle ];
-
-                // Donnée atteinte
-                } else {
-
-                    // Fichier
-                    if (typeof donnee === 'object' && donnee.data !== undefined && donnee.data instanceof Buffer){
-                        donnee = normaliserFichier(donnee);
-                    }
-                    
-                    brancheA[ cle ] = donnee;
-                        
-
+                    continue;
                 }
 
+                // Data reached
+                if (
+                    typeof donnee === 'object' 
+                    && 
+                    donnee.data !== undefined 
+                    && 
+                    donnee.data instanceof Buffer
+                ){
+                    donnee = normalizeFile(donnee);
+                }
+                
+                brancheA[ cle ] = donnee;
             }
         }
     }
@@ -59,27 +93,22 @@ export const traiterMultipart = (...canaux: any[]) => {
     return sortie;
 }
 
-const reMultipart = /^multipart\/(?:form-data|related)(?:;|$)/i;
-export const requeteMultipart = (req: Request) => reMultipart.exec( req.headers['content-type'] );
+const normalizeFile = (file: UploadedFile) => {
 
-const normaliserFichier = (file: UploadedFile) => new NormalizedFile({
-    name: file.name,
-    type: file.mimetype,
-    size: file.size,
-    data: file.data,
-})
+    const ext = mime.extension(file.mimetype);
 
-export const MiddlewareFormData = (req: Request, res: Response, next: NextFunction) => {
+    if (ext === false)
+        throw new InputError(`We couldn't determine the type of the CV file you sent. Please encure it's not corrupted and try again.`);
 
-    // Verif si multipart
-    if (!requeteMultipart( req ))
-        return next();
-        
-    // Données body + fichiers
-    // NOTE: Les données devant obligatoirement passer par le validateur de schema, 
-    //  On peut mélanger le body et les files sans risque de sécurité
-    req.body = traiterMultipart(req.body, req.files);
-    //req.files = traiterMultipart(req.files);
+    return new FileToUpload({
 
-    next();
-}
+        name: file.name,
+        type: file.mimetype,
+        size: file.size,
+    
+        data: file.data,
+    
+        md5: file.md5,
+        ext: ext
+    })
+}

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

@@ -9,15 +9,19 @@
 - DEPENDANCES
 ----------------------------------*/
 
+// Node
+import path from 'path';
+
 // Npm
 import type express from 'express';
 import { v4 as uuid } from 'uuid';
+import fs from 'fs-extra';
 import type { GlobImportedWithMetas } from 'babel-plugin-glob-import';
 
 // Core
 import Application, { Service } from '@server/app';
 import context from '@server/context';
-import { Erreur, NotFound } from '@common/errors';
+import { CoreError, NotFound } from '@common/errors';
 import BaseRouter, {
     TRoute, TErrorRoute, TRouteModule,
     TRouteOptions, defaultOptions
@@ -42,7 +46,7 @@ import DocumentRenderer from './response/page/document';
 
 export { default as RouterService } from './service';
 export { default as RequestService } from './request/service';
-export type { default as Request } from "./request";
+export type { default as Request, UploadedFile } from "./request";
 export type { default as Response, TRouterContext } from "./response";
 export type { TRoute } from '@common/router';
 
@@ -168,6 +172,7 @@ export default class ServerRouter<
     }
 
     private registerRoutes(defModules: GlobImportedWithMetas<TRouteModule>) {
+
         for (const routeModule of defModules) {
 
             const register = routeModule.exports.__register;
@@ -181,6 +186,14 @@ export default class ServerRouter<
         this.afterRegister();
     }
 
+    // TODO: Generate TS type of the routes list
+    public url<TRoutePath extends keyof Routes = keyof Routes>( 
+        path: TRoutePath, 
+        params: Routes[TRoutePath]["params"]
+    ) {
+        return this.http.publicUrl + path;
+    }
+
     /*----------------------------------
     - REGISTER
     ----------------------------------*/
@@ -265,9 +278,12 @@ export default class ServerRouter<
         console.info("Pre-Loading request services");
         //await TrackingService.LoadCache();
 
-        console.info("Loading routes ...");
+        // Generate typescript typings
+        if (this.app.env.profile = 'dev')
+            this.genTypings();
 
         // Ordonne par ordre de priorité
+        console.info("Loading routes ...");
         this.routes.sort((r1, r2) => {
 
             const prioDelta = r2.options.priority - r1.options.priority;
@@ -329,6 +345,21 @@ export default class ServerRouter<
         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
     ----------------------------------*/
@@ -499,7 +530,7 @@ export default class ServerRouter<
         request.res.json(responseData);
     }
 
-    private async handleError(e: Erreur, request: ServerRequest<ServerRouter>) {
+    private async handleError(e: CoreError, request: ServerRequest<ServerRouter>) {
 
         const code = 'http' in e ? e.http : 500;
         const route = this.errors[code];

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

@@ -10,22 +10,24 @@ import Bowser from "bowser";
 
 // Core
 import BaseRequest from '@common/router/request';
+import type FileToUpload from '@client/components/inputv3/file/FileToUpload';
 
 // Specific
-import ServerResponse from '../response';
+import type { 
+    default as Router, Config as RouterConfig, 
+    HttpMethod, HttpHeaders
+} from '..';
 import ApiClient from './api';
+import ServerResponse from '../response';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-import type { 
-    default as Router, Config as RouterConfig, 
-    HttpMethod, HttpHeaders
-} from '@server/services/router';
-
 const localeFilter = (input: any) => typeof input === 'string' && ISO6391.validate(input) ? input : undefined;
 
+export type UploadedFile = With<FileToUpload, 'md5'|'ext'>
+
 /*----------------------------------
 - CONTEXTE
 ----------------------------------*/

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

@@ -9,7 +9,7 @@ import SchemaValidator, { TFileValidator } from '@common/validation/validators';
 
 import Validator, { EXCLUDE_VALUE,} from '@common/validation/validator';
 
-import NormalizedFile from '@common/data/file';
+import type FileToUpload from '@client/components/inputv3/file/FileToUpload';
 
 /*----------------------------------
 - TYPES
@@ -21,8 +21,8 @@ import NormalizedFile from '@common/data/file';
 ----------------------------------*/
 export default class ServerSchemaValidator extends SchemaValidator {
 
-    public file = ({ ...opts }: TFileValidator & { sharp: any }) => 
-        new Validator<NormalizedFile>('file', (val, input, output) => {
+    public file = ({ ...opts }: TFileValidator) => 
+        new Validator<FileToUpload>('file', (val, input, output) => {
 
             // Chaine = url ancien fichier = exclusion de la valeur pour conserver l'ancien fichier
             // NOTE: Si la valeur est présente mais undefined, alors on supprimera le fichier
@@ -33,14 +33,7 @@ export default class ServerSchemaValidator extends SchemaValidator {
             const file = this.validateFile(opts, val, input, output);
 
             if (file === undefined)
-                return file;
-
-            // Process Image
-            if (opts.sharp !== undefined) {
-
-
-
-            }
+                return EXCLUDE_VALUE;
 
             return file;
         }, opts)

package/src/server/services/schema/request.ts

@@ -7,14 +7,21 @@ import {
     default as Router, RequestService, Request as ServerRequest
 } from '@server/services/router';
 
-import ServerSchemaValidator from '.';
-
 import Schema, { TSchemaFields, TValidatedData } from '@common/validation/schema';
 
+// Specific
+import ServerSchemaValidator from '.';
+
 /*----------------------------------
-- TYPES
+- SERVICE CONFIG
 ----------------------------------*/
 
+const LogPrefix = `[router][validation]`;
+
+export type TConfig = {
+    debug?: boolean
+}
+
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
@@ -22,6 +29,7 @@ export default class RequestValidator extends ServerSchemaValidator implements R
 
     public constructor(
         public request: ServerRequest<Router>,
+        public config: TConfig,
         public router = request.router,
         public app = router.app
     ) {
@@ -32,7 +40,7 @@ export default class RequestValidator extends ServerSchemaValidator implements R
 
     public validate<TSchemaFieldsA extends TSchemaFields>( fields: TSchemaFieldsA ): TValidatedData<TSchemaFieldsA> {
 
-        console.log("Validate request data:", this.request.data);
+        this.config.debug && console.log(LogPrefix, "Validate request data:", this.request.data);
 
         const schema = new Schema(fields);
 
@@ -42,9 +50,10 @@ export default class RequestValidator extends ServerSchemaValidator implements R
             this.request.data, 
             {}, 
             {
-                critique: true,
-                validationComplete: true,
-                avecDependances: false
+                debug: this.config.debug,
+                throwError: true,
+                validateAll: true,
+                validateDeps: false
             },
             []
         );

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

@@ -8,7 +8,7 @@ import {
     RouterService
 } from '@server/services/router';
 
-import RequestValidator from './request';
+import RequestValidator, { TConfig } from './request';
 
 /*----------------------------------
 - TYPES
@@ -23,11 +23,15 @@ export default class AuthenticationRouterService<
     TUser extends {} = {}
 > extends RouterService {
 
+    public constructor( protected config: TConfig ) {
+        super();
+    }
+
     public async register() {
         
     }
 
     public requestService( request: ServerRequest< TRouterWithSchema<this>> ): RequestValidator {
-        return new RequestValidator( request );
+        return new RequestValidator( request, this.config );
     }
 }

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

@@ -6,38 +6,61 @@
 import crypto from 'crypto';
 
 // Core
+import Application, { Service } from '@server/app';
 import { Forbidden } from '@common/errors';
 
-const debug = true;
-
 /*----------------------------------
 - CONFIG
 ----------------------------------*/
 
-const ENC_KEY = "bf3c199c2470cb477d907b1e0917c17b"; // set random encryption key
-const IV = "5183666c72eec9e4"; // set random initialisation vector
+
+/*----------------------------------
+- SERVICE CONFIG
+----------------------------------*/
+
+export type Config = {
+    debug?: boolean,
+    iv: string,
+    keys: {[keyName: string]: string}
+}
+
+export type Hooks = {
+
+}
 
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-class AES {
+export default class AES<TConfig extends Config = Config> extends Service<TConfig, Hooks, Application> {
 
-    public encrypt( data: any ) {
+    public async register() {
+        
+    }
+
+    public async start() {
+
+    }
+
+    public encrypt( keyName: keyof TConfig["keys"], data: any ) {
+
+        const encKey = this.config.keys[ keyName as keyof typeof this.config.keys ];
 
         data = JSON.stringify(data);
 
-        let cipher = crypto.createCipheriv('aes-256-cbc', ENC_KEY, IV);
+        let cipher = crypto.createCipheriv('aes-256-cbc', encKey, this.config.iv);
         let encrypted = cipher.update(data, 'utf8', 'base64');
         encrypted += cipher.final('base64');
         return encrypted;
         
     }
 
-    public decrypt( data: string ) {
+    public decrypt( keyName: keyof TConfig["keys"], data: string ) {
+
+        const encKey = this.config.keys[ keyName as keyof typeof this.config.keys ];
 
         try {
 
-            let decipher = crypto.createDecipheriv('aes-256-cbc', ENC_KEY, IV);
+            let decipher = crypto.createDecipheriv('aes-256-cbc', encKey, this.config.iv);
             let decrypted = decipher.update(data, 'base64', 'utf8');
             return JSON.parse(decrypted + decipher.final('utf8'));
 
@@ -46,9 +69,5 @@ class AES {
             throw new Forbidden("Invalid token.");
             
         }
-        
     }
-
-}
-
-export default new AES;
+}

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

@@ -79,7 +79,7 @@ export default abstract class UsersManagementService<
     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 displayName(user?: TUser | null): string;
     protected abstract displaySessionName(session: TJwtSession): string;
 
     public async decode( req: THttpRequest, withData: true ): Promise<TUser | null>;
@@ -118,7 +118,7 @@ export default abstract class UsersManagementService<
         // 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);
+        this.config.debug && console.log(LogPrefix, `Deserialized user ${sessionName}:`, this.displayName(user));
 
         return user;    
     }
@@ -134,7 +134,7 @@ export default abstract class UsersManagementService<
         return null;
     }
 
-    protected createSession( session: TJwtSession, request: TRequest ): string {
+    public createSession( session: TJwtSession, request: TRequest ): string {
 
         this.config.debug && console.info(LogPrefix, `Creating new session:`, session);
 

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

@@ -52,8 +52,6 @@ export default class AuthenticationRouterService<
             // TODO: Typings. (context.user ?)
             const decoded = await this.users.decode( request.req, true);
 
-            console.log("DECODED", decoded);
-
             request.user = decoded || null;
         })
 

package/src/types/global/utils.d.ts

@@ -43,4 +43,14 @@ declare type TStats<T> = {
     interface IntrinsicElements {
         i: { src: TIcons } & React.HTMLAttributes<HTMLElement>;
     }
-}*/
+}*/
+
+declare type Routes = {
+    [path: string]: {
+        params: {
+            [param: string]: any
+        }
+    }
+}
+
+declare type PrimitiveValue = string | number | boolean;

package/tsconfig.common.json

@@ -9,6 +9,9 @@
         "allowJs": true,
         "strict": false,
         "downlevelIteration": true,
+        // Force case sensitive import filenames on Window and Mac
+        // https://briandesousa.net/?p=870 
+        "forceConsistentCasingInFileNames": true,
 
         // Equivalent webpack: resolve.symblinks = false
         "preserveSymlinks": true,

package/src/client/components/input/Textarea.tsx

@@ -1,57 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-import React from 'react';
-import Champ from './Base';
-
-import TextareaAutosize from 'react-textarea-autosize';
-
-/*----------------------------------
-- TYPES
-----------------------------------*/
-type TValeur = string;
-const valeurDefaut = '' as string;
-type TValeurDefaut = typeof valeurDefaut;
-type TValeurOut = string;
-
-export type Props = {
-    valeur: TValeur,
-    onPressEnter?: (valeur: TValeur) => void,
-    autoFocus?: boolean,
-}
-
-/*----------------------------------
-- COMPOSANTS
-----------------------------------*/
-export default Champ<Props, TValeurDefaut, TValeurOut>('textarea', { valeurDefaut, saisieManuelle: true }, ({
-    onPressEnter, attrsChamp
-}, { valeur, state, setState }, rendre) => {
-
-    if (onPressEnter)
-        attrsChamp.onKeyDown = (e: KeyboardEvent) => {
-            if (e.key === 'Enter') {
-
-                // Entrée seulement = envoi
-                if (!e.shiftKey) {
-                    onPressEnter( valeur );
-                }
-
-                // Nouvelle ligne si shift key + valeur ok
-                if (!(e.shiftKey && valeur)) {
-                    //e.stopPropagation();
-                    e.preventDefault();
-                    return false;
-                }
-            }
-        }
-
-    return rendre((
-        <TextareaAutosize {...attrsChamp} 
-            value={valeur} 
-            onChange={(e: any) => {
-                setState({ valeur: e.target.value });
-            }} 
-        />
-    ), {  });
-})

package/src/client/components/input/Upload.tsx

@@ -1,5 +0,0 @@
-import React from 'react';
-
-export default () => {
-    return <span>coucou</span>
-}