proteum 1.0.0-1

package/server/services/prisma/index.ts

@@ -0,0 +1,201 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import { PrismaClient } from '@/var/prisma';
+import mysql from 'mysql2/promise';
+import type PrismaClientType from '@prisma/client';
+const safeStringify = require('fast-safe-stringify'); // remplace les références circulairs par un [Circular]
+
+// Core
+import type { Application } from '@server/app';
+import Service from '@server/app/service';
+
+// Specific
+import Facet, { TDelegate, TSubset, Transform } from './Facet';
+import { NotFound } from '@common/errors';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+export type SqlQuery = ReturnType<ModelsManager["SQL"]>
+
+/*----------------------------------
+- SERVICE CONFIG
+----------------------------------*/
+
+export type Config = {
+   debug?: boolean
+}
+
+export type Hooks = {
+
+}
+
+export type Services = {
+
+}
+
+/*----------------------------------
+- CLASSE
+----------------------------------*/
+
+export default class ModelsManager extends Service<Config, Hooks, Application, Application> {
+
+    public client = new PrismaClient() as PrismaClientType.PrismaClient;
+
+    public async ready() {
+
+        await this.client.$executeRaw`SET time_zone = '+00:00'`;
+
+    }
+  
+    public async shutdown() {
+        await this.client.$disconnect()
+    }
+
+    public Facet<
+        D extends TDelegate<R>,
+        S extends TSubset,
+        R,
+        RT
+    >(...args: [D, S, Transform<S, R, RT>]) {
+
+        return new Facet(
+            this.client,
+            ...args
+        );
+    }
+
+    /*----------------------------------
+    - OPERATIONS: PARSING
+    ----------------------------------*/
+    public SQL<TRowData extends {}|number|string>( strings: TemplateStringsArray, ...data: any[] ) {
+
+        const string = this.string(strings, ...data);
+
+        const query = () => {
+            return this.client.$queryRawUnsafe(string) as Promise<TRowData[]>;
+        }
+
+        query.all = query;
+        query.value = <TValue extends any = number>() => query().then((resultatRequetes: any) => {
+
+            const resultat = resultatRequetes[0];
+
+            if (!resultat)
+                return null;
+
+            return Object.values(resultat)[0] as TValue;
+        });
+
+        query.first = () => query().then((resultatRequetes: any) => {
+            return resultatRequetes[0] || null;
+        });
+        
+        query.firstOrFail = (message: string) => query().then((resultatRequetes: any) => {
+            
+            if (resultatRequetes.length === 0)
+                throw new NotFound(message);
+    
+            return resultatRequetes[0];
+        });
+
+        query.string = string;
+
+        return query;
+    }
+
+    public esc( data: any, forStorage: boolean = false ) {
+
+        // JSON object
+        // TODO: do it via datatypes.ts
+        if (typeof data === 'object' && data !== null) {
+
+            // Object: stringify in JSON
+            if (data.constructor.name === "Object")
+                data = safeStringify(data);
+            // Array: if for storage, reparate items with a comma
+            else if (forStorage && Array.isArray( data )) {
+                data = data.join(',')
+            } 
+        }
+    
+        return mysql.escape(data);
+    }
+
+    public string = (strings: TemplateStringsArray, ...data: any[]) => {
+        const iMax = data.length - 1;
+
+        if (typeof data === 'function') 
+            throw new Error(`A function has been passed into the sql string template: ` + data);
+
+        return strings.map((stringBefore, i) => {
+
+            if (i <= iMax) {
+
+                let value = data[i];
+                stringBefore = stringBefore.trim();
+                const prefix = stringBefore[stringBefore.length - 1];
+
+                // Null
+                if (value === undefined || value === null) {
+
+                    value = 'NULL';
+
+                    // Replace ""= NULL" by "IS NULL"
+                    if (prefix === '=')
+                        stringBefore = stringBefore.substring(0, stringBefore.length - 1) + 'IS ';
+
+                // Prefix = special parse
+                } else if (prefix === ':' || prefix === '&') {
+
+                    // Remove the prefix
+                    stringBefore = stringBefore.substring(0, stringBefore.length - 1);
+
+                    // Object: `WHERE :${filters}` => `SET requestId = "" AND col = 3`
+                    if (typeof value === 'object') {
+
+                        const keyword = prefix === '&' ? ' AND ' : ', '
+
+                        value = Object.keys(value).length === 0 ? '1' : this.equalities(value).join( keyword );
+                        
+                    // String: `SET :${column} = ${data}` => `SET balance = 10`
+                    } else {
+
+
+                    }
+
+                // SQL query
+                } else if (typeof value === 'function' && value.string !== undefined)
+                    value = ' ' + value.string;
+                // Escape value
+                else {
+
+                    const lastKeyword = stringBefore.trim().split(' ').pop();
+
+                    // Escape table name
+                    if (lastKeyword === 'FROM')
+                        value = '`' + value + '`';
+                    else
+                        value = mysql.escape(value);
+
+                    value = ' ' + value;
+                }
+                stringBefore += value;
+
+            }
+
+            return stringBefore;
+
+        }).join(' ').trim();
+    }
+
+    public equalities = (data: TObjetDonnees, forStorage: boolean = false) => {
+        return Object.keys(data).map(k => '' + k + ' = ' + this.esc( data[k], forStorage ))
+    }
+
+   
+}

package/server/services/prisma/service.json

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

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

@@ -0,0 +1,217 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm: Serveurs
+import bytes from 'bytes';
+import express from 'express';
+import http from 'http';
+import https from 'https';
+import path from 'path';
+import cors, { CorsOptions } from 'cors';
+
+// Middlewares (npm)
+import morgan from 'morgan';
+import hpp from 'hpp'; // Protection contre la pollution des reuqtees http
+import helmet from 'helmet'; // Diverses protections
+import compression from 'compression';
+import fileUpload from 'express-fileupload';
+import cookieParser from 'cookie-parser';
+import * as csp from 'express-csp-header';
+
+// Core
+import Container from '@server/app/container';
+import type Router from '..';
+
+// Middlewaees (core)
+import { MiddlewareFormData } from './multipart';
+
+/*----------------------------------
+- CONFIG
+----------------------------------*/
+
+export type Config = {
+
+    debug?: boolean,
+
+    // Access
+    domain: string,
+    port: number,
+    ssl: boolean,
+
+    // Limitations / Load restriction
+    upload: {
+        maxSize: string // Expression package bytes
+    },
+    csp: {
+        default?: string[],
+        styles?: string[],
+        images?: string[],
+        scripts: string[],
+    },
+    cors?: CorsOptions,
+    helmet?: Parameters<typeof helmet>[0]
+}
+
+export type Hooks = {
+
+}
+
+/*----------------------------------
+- FUNCTION
+----------------------------------*/
+export default class HttpServer {
+
+    public http: http.Server | https.Server;
+    public express: express.Express;
+
+    public publicUrl: string;
+
+    public constructor( 
+        public config: Config, 
+        public router: Router,
+        public app = router.app
+    ) {
+
+        // Init
+        this.publicUrl = this.app.env.name === 'local'
+            ? 'http://localhost:' + this.config.port
+            : ((this.config.ssl ? 'https' : 'http') + '://' + this.config.domain);
+
+        // Configure HTTP server
+        this.express = express();
+        this.http = http.createServer(this.express);
+
+        // Start HTTP Server
+        this.app.on('cleanup', () => this.cleanup());
+    }
+
+    /*----------------------------------
+    - HOOKS
+    ----------------------------------*/
+
+    public async start() {
+
+        const routes = this.express
+
+        /*----------------------------------
+        - SECURITÉ DE BASE
+        ----------------------------------*/
+
+        // Config
+        routes.set('trust proxy', 1); // Indique qu'on est sous le proxy apache
+        // Diverses protections (dont le disable x-powered-by)
+        routes.use( helmet(this.config.helmet) );
+
+        /*----------------------------------
+        - FICHIERS STATIQUES
+        ----------------------------------*/
+
+        // Fichiers statiques: Eviter un maximum de middlewares inutiles
+        // Normalement, seulement utile pour le mode production, 
+        // Quand mode debug, les ressources client semblent servies par le dev middlewae
+        // Sauf que les ressources serveur ne semblent pas trouvées par le dev-middleware
+        routes.use(compression());
+        routes.use('/public', cors());
+        routes.use(
+            '/public',
+            express.static( Container.path.root + '/bin/public', {
+                dotfiles: 'deny',
+                setHeaders: function setCustomCacheControl(res, path) {
+
+                    const dontCache = [
+                        '/public/icons',
+                        '/public/client'
+                    ]
+
+                    res.setHeader('Cache-Control', 'public, max-age=0');
+
+                    // Set long term cache, except for non-hashed filenames
+                    /*if (dontCache.some( p => path.startsWith( p ))) {
+                        res.setHeader('Cache-Control', 'public, max-age=0');
+                    } else {
+                        res.setHeader('Cache-Control', 'public, max-age=604800000'); // 7 Days
+                    }*/
+                    
+                }
+            }),
+            (req, res) => {
+                res.status(404).send();
+            }
+        );
+ 
+        routes.use('/robots.txt', express.static( path.resolve(__dirname, 'public/robots.txt')) );
+
+        routes.get("/ping", (req, res) => res.send("pong"));
+
+        /*----------------------------------
+        - SESSION & SECURITE
+        ----------------------------------*/
+        // https://expressjs.com/fr/advanced/best-practice-security.html
+        // Protection contre la pollution des reuqtees http
+        routes.use(hpp());
+
+        // Init de req.cookies
+        routes.use(cookieParser())
+
+        /*----------------------------------
+        - DÉCODEURS
+        ----------------------------------*/
+        routes.use(
+
+            // Décodage des données post
+            express.json({
+                // TODO: prendre en considération les upload de fichiers
+                limit: bytes(this.config.upload.maxSize),
+                verify: (req, res, buf, encoding) => {
+                    // Store the raw request body so we can access it later
+                    req.rawBody = buf;
+                }
+            }),
+
+            // Permet de receptionner les données multipart (req.body + req.files)
+            // A mettre avant les services, car l'assignement de req.socket fait planter les uploads
+            fileUpload({
+                debug: false,
+                limits: {
+                    fileSize: bytes(this.config.upload.maxSize),
+                    abortOnLimit: true
+                },
+            }),
+
+            // Décodage des requetes multipart
+            // Peut-être requis par le résolver api
+            MiddlewareFormData
+        );
+
+        /*----------------------------------
+        - PAGES / API
+        ----------------------------------*/
+
+        if (this.config.cors !== undefined)
+            routes.use( cors( this.config.cors ));
+
+        routes.use( csp.expressCspHeader({
+            directives: {
+                'script-src': [csp.INLINE, csp.SELF, 
+                   ...this.config.csp.scripts
+                ]
+            }
+        }));
+        
+        routes.use( this.router.middleware.bind( this.router ) );
+
+        /*----------------------------------
+        - BOOT SERVICES
+        ----------------------------------*/
+        console.info("Lancement du serveur web");
+        this.http.listen(this.config.port, () => {
+            console.info(`Web server ready on ${this.publicUrl}`);
+        });
+
+    }
+
+    public async cleanup() {
+        this.http.close();
+    }
+}

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

@@ -0,0 +1,102 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import mime from 'mime-types';
+
+// Core
+import { InputError } from '@common/errors';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+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} = {};
+
+    for (const donnees of canaux) {
+
+        if (!donnees)
+            continue;
+
+        for (const fieldPath in donnees) {
+            let donnee = donnees[fieldPath];
+
+            let brancheA = sortie;
+            const results = [...fieldPath.matchAll(/[^\[\]]+/g)];
+            for (let iCle = 0; iCle < results.length; iCle++) {
+
+                const [cle] = results[ iCle ];
+
+                // Need to go deeper to find data
+                if (iCle !== results.length - 1) {
+
+                    if (brancheA[ cle ] === undefined) {
+                        const tableau = !isNaN( results[ iCle + 1 ][0] as any )
+                        brancheA[ cle ] = tableau ? [] : {};
+                    }
+
+                    brancheA = brancheA[ cle ];
+                    continue;
+                }
+
+                // Data reached
+                if (
+                    typeof donnee === 'object' 
+                    && 
+                    donnee.data !== undefined 
+                    && 
+                    donnee.data instanceof Buffer
+                ){
+                    const md5 = donnee.md5;
+                    const data = donnee.data;
+                    donnee = new File(donnee.data, donnee.name, { 
+                        type: donnee.mimetype,
+                        lastModified: Date.now(),
+                        //size: donnee.size,
+                    });
+
+                    donnee.md5 = md5;
+                    donnee.data = data;
+                }
+                
+                brancheA[ cle ] = donnee;
+            }
+        }
+    }
+
+    return sortie;
+}

package/server/services/router/http/session.ts.old

@@ -0,0 +1,40 @@
+// Npm
+import session from 'express-session';
+import { v4 as uuidv4 } from 'uuid';
+import redisConnector from 'connect-redis';
+const RedisStore = redisConnector(session);
+
+// Services
+import type { THttpConfig } from '@server/services/http';
+import Redis from '@server/services/redis';
+
+// Middleware
+export const createSessionMiddleware = (httpConfig: THttpConfig) => {
+    return session({
+
+        genid: (req) => {
+            return /*req.id;*/uuidv4(); // ID session via UUID
+        },
+
+        name: httpConfig.session.name,
+        store: new RedisStore({
+            client: Redis.instance,
+            ttl: httpConfig.session.duration // secondes
+        }),
+        secret: httpConfig.session.secret,
+
+        // Ces deux valeurs sont recommandes avec session filestore
+        // https://github.com/valery-barysok/session-file-store/blob/master/examples/express-example/app.js
+        resave: true, // Quand false, /admin/console réinitialise la session
+        saveUninitialized: true,
+
+        cookie: {
+            maxAge: httpConfig.session.duration * 1000, // millisecondes
+            //sameSite: true,
+            httpOnly: true,
+            // Les variables d'environnement sont des chaines
+            secure: httpConfig.ssl,
+            path: '/',
+        }
+    })
+}