proteum 1.0.0-1

package/server/services/router/response/mask/index.ts

@@ -0,0 +1,60 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Libs
+import compilerSelecteurs, { TObjetSelecteurs } from './selecteurs';
+import Filter from './Filter';
+
+// Filtres spécifiques métier
+//import filtresProps from '@/general/serveur/filtresApi';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+/*----------------------------------
+- CONFIG
+----------------------------------*/
+
+const debug = false;
+
+/*----------------------------------
+- MODULE
+----------------------------------*/
+
+// proprieteModele = Si l'objet actuellement traité fait partie des valeurs d'un modèle
+export default (
+    donnee: any,
+    selecteurs?: string | TObjetSelecteurs
+) => {
+
+    // Pas besoin de filtrer
+    if (donnee === null || typeof donnee !== 'object'/*  || donnee._filtered === true */) {
+        return donnee;
+    }
+
+    // Correction sélecteurs
+    let selecteursCompiles: TObjetSelecteurs | undefined;
+    if (selecteurs === undefined)
+        selecteursCompiles = undefined;
+    else if (typeof selecteurs === 'string')
+        selecteursCompiles = compilerSelecteurs(selecteurs);
+    else // Déjà un objet, pas besoin de compiler
+        selecteursCompiles = selecteurs;
+
+    debug && console.log('Avant filtrage', donnee);
+
+    const filtre = new Filter();
+    const retour = filtre.filtrer(donnee, selecteursCompiles);
+
+    // Empêche un nouveau filtrage
+    // OBSOLETE: éviter d emodifier le retour des api, car cela peut poser probleme lors du traitement de ces données (ex: itération clés objet)
+    /*if (typeof retour === 'object' && retour !== null)
+        retour._filtered = true;*/
+
+    debug && console.log('Apres filtrage', retour);
+
+    return retour;
+
+}

package/server/services/router/response/mask/selecteurs.ts

@@ -0,0 +1,92 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+export type TSelecteur = true | "*" | TObjetSelecteurs
+// Wildcard en clé = selectionner toutes les clés
+// Wildcard en valeur = sélectionner absolument toutes les valeur descendantes
+export type TObjetSelecteurs = {[cle: string]: TSelecteur}
+
+/*----------------------------------
+- CONSTANTES
+----------------------------------*/
+const reSelecteurs = /((([a-z0-9\*\@\.\_\#]+)|(\{[^\}]+\}))\s*(\(?))|\)/gi; // <branche>( <elem1> <elem2> )
+
+const cache: TObjetSelecteurs = {};
+
+/*----------------------------------
+- FONCTION
+----------------------------------*/
+export default (selecteurs: string) => {
+
+    if (cache[selecteurs] === undefined)
+        cache[selecteurs] = compiler(selecteurs);
+
+    return cache[selecteurs];
+
+}
+
+const compiler = (selecteurs: string): TObjetSelecteurs => {
+
+    let chemins: TObjetSelecteurs = {};
+    let cheminA: string[] = []; // Chemin en construction
+
+    let branche;
+    while (branche = reSelecteurs.exec(selecteurs)) {
+
+        if (branche[0] === ')') { // fermeture
+
+            // Niveau précédent: docs.titre => docs
+            cheminA.pop();
+
+        } else {
+
+            const nomBranche = branche[2];
+            const ouverture = branche[5] === '(';
+
+            // Ligne débutant par un # = commentaire
+            if (nomBranche.startsWith("#"))
+                continue;
+
+            if (ouverture)
+                // Ouverture de la branche: docs => docs.titre
+                cheminA.push(nomBranche);
+            else {
+
+                const chemin = [...cheminA, nomBranche];
+
+                // Construction du chemin
+                let brancheA = chemins;
+                const nbBranches = chemin.length;
+                for (let iBranche = 0; iBranche < nbBranches; iBranche++) {
+
+                    const nomBranche = chemin[iBranche];
+
+                    const extremite = iBranche === nbBranches - 1
+                    if (extremite) {
+
+                        // Dernière branche = extremité = true
+                        brancheA[nomBranche] = true;
+
+                    } else {
+
+                        // Pas encore définie
+                        if (brancheA[nomBranche] === undefined)
+                            // Sinon, initialisation
+                            brancheA[nomBranche] = {};
+
+                        // Rférnce pour la prochaine itération
+                        brancheA = brancheA[nomBranche];
+
+                    }
+                }
+            }
+        }
+    }
+
+    return chemins;
+
+}

package/server/services/router/response/page/document.tsx

@@ -0,0 +1,160 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import React from 'react';
+import renderToString from "preact-render-to-string";
+const safeStringify = require('fast-safe-stringify'); // remplace les références circulairs par un [Circular]
+
+// Core
+import type { default as Router, Response as ServerResponse } from "@server/services/router";
+import type Page from '.';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+
+/*----------------------------------
+- SERVICE
+----------------------------------*/
+export default class DocumentRenderer<TRouter extends Router> {
+
+    public constructor(
+        public router: TRouter,
+        public app = router.app
+    ) {
+
+    }
+
+    public staticDocument() {
+        const routesForClient = JSON.stringify( this.router.ssrRoutes );
+        return '<!doctype html>' + renderToString(
+            <html lang="en">
+                <head>
+                    {/* Format */}
+                    <meta charSet="utf-8" />
+                    <meta name="viewport" content="width=device-width,minimum-scale=1,initial-scale=1" />
+
+                    {/* CSS */}
+                    <link rel="preload" href="/public/client.css" as="style" />
+                    <link rel="preload" as="font" href={"/public/icons.woff2?v=" + BUILD_ID} type="font/woff2" />
+                    <link rel="stylesheet" type="text/css" href="/public/icons.css" />
+                    <link rel="stylesheet" type="text/css" href="/public/client.css" />
+
+                    {/* JS */}
+                    <script type="text/javascript" dangerouslySetInnerHTML={{
+                        __html: `window.routes=${routesForClient};` + (this.app.env.profile === 'dev' ? 'window.dev = true;' : '')
+                    }} />
+                    <link rel="preload" href="/public/client.js" as="script" />
+                    <script defer type="text/javascript" src="/public/client.js" />
+
+                </head>
+                <body></body>
+            </html>
+        );
+    }
+
+    public async page( html: string, page: Page, response: ServerResponse<TRouter> ) {
+
+        let attrsBody = {
+            className: [...page.bodyClass].join(' '),
+        };
+
+        return '<!doctype html>' + renderToString(
+            <html lang="en">
+                <head>
+                    {/* Format */}
+                    <meta charSet="utf-8" />
+                    <meta content="IE=edge" httpEquiv="X-UA-Compatible" />
+                    <meta name="viewport" content="width=device-width,minimum-scale=1,initial-scale=1" />
+
+                    {/* Mobile */}
+                    <meta name="application-name" content={this.app.identity.web.title} />
+                    <meta name="apple-mobile-web-app-title" content={this.app.identity.web.title} />
+                    <meta name="apple-mobile-web-app-title" content={this.app.identity.web.title} />
+                    <meta content={this.app.identity.author.name} name="author" />
+                    <meta name="theme-color" content={this.app.identity.maincolor} />
+                    <meta name="msapplication-TileColor" content={this.app.identity.maincolor} />
+                    <meta name="apple-mobile-web-app-capable" content="yes" />
+                    <meta name="mobile-web-app-capable" content="yes" />
+                    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0" />
+
+                    {/* https://stackoverflow.com/questions/48956465/favicon-standard-2019-svg-ico-png-and-dimensions */}
+                    {/*<link rel="manifest" href={RES['manifest.json']} />*/}
+                    <link rel="shortcut icon" href="/public/app/favicon.ico" />
+                    <link rel="icon" type="image/png" sizes="16x16" href="/public/app/favicon-16x16.png" />
+                    <link rel="icon" type="image/png" sizes="32x32" href="/public/app/favicon-32x32.png" />
+                    <link rel="apple-touch-icon" sizes="180x180" href="/public/app/apple-touch-icon-180x180.png" />
+                    <meta name="msapplication-config" content="/public/app/browserconfig.xml" />
+
+                    {/* Page */}
+                    <title>{page.title}</title>
+                    <meta content={page.description} name="description" />
+                    <link rel="canonical" href={response.canonicalUrl} />
+
+                    {/* SEO, social medias, OG tags, ...  */}
+                    {page.head.map(({ $, ...attrs }) => (
+                        React.createElement($, attrs)
+                    ))}
+
+                    {this.styles( page )}
+
+                    {await this.scripts( response, page )}
+
+                    {/* Rich Snippets: https://schema.org/docs/full.html + https://jsonld.com/ */}
+                    <script type="application/ld+json" dangerouslySetInnerHTML={{
+                        __html: JSON.stringify({
+                            '@context': 'http://schema.org',
+                            '@graph': page.jsonld
+                        })
+                    }}/>
+
+                </head>
+                <body {...attrsBody} dangerouslySetInnerHTML={{ __html: html }}></body>
+            </html>
+        )
+    }
+
+    private styles( page: Page ) {
+        return <>
+            <link rel="preload" href="/public/client.css" as="style" />
+            <link rel="stylesheet" type="text/css" href="/public/client.css" />
+
+            {page.style.map( style => 'url' in style ? <>
+                <link rel="preload" href={style.url} as="style" />
+                <link rel="stylesheet" type="text/css" href={style.url} />
+            </> : <>
+                <style id={style.id} dangerouslySetInnerHTML={{ __html: style.inline }} />
+            </>)}
+        </>
+    }
+
+    private async scripts( response: ServerResponse<TRouter>, page: Page ) {
+
+        const ssrData = response.forSsr(page);
+        const context = safeStringify( ssrData );
+        const routesForClient = JSON.stringify( this.router.ssrRoutes );
+
+        return <>
+            {/* JS */}
+            <script type="text/javascript" dangerouslySetInnerHTML={{ 
+                __html: `window.ssr=${context}; window.routes=${routesForClient};` + (
+                    this.app.env.profile === 'dev' ? 'window.dev = true;' : ''
+                )
+            }} />
+
+            <link rel="preload" href={"/public/client.js?v=" + BUILD_ID} as="script" />
+            <script defer type="text/javascript" src={"/public/client.js?v=" + BUILD_ID} />
+
+            {page.scripts.map( script => 'url' in script ? <>
+                <link rel="preload" href={script.url} as="script" />
+                <script type="text/javascript" src={script.url} {...script.attrs || {}} />
+            </> : <>
+                <script type="text/javascript" {...script.attrs || {}} id={script.id} 
+                    dangerouslySetInnerHTML={{ __html: script.inline }} />
+            </>)}
+        </>
+    }
+}

package/server/services/router/response/page/index.tsx

@@ -0,0 +1,196 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import React from 'react';
+import renderToString from "preact-render-to-string"; 
+
+// Core
+import { default as Router, TRouterContext } from "@server/services/router";
+import type { Layout, TRoute, TErrorRoute, TClientOrServerContext } from '@common/router';
+import PageResponse, { TFrontRenderer } from "@common/router/response/page";
+
+// Composants UI
+import App from '@client/app/component';
+
+// Caches
+const chunks = require('./chunk-manifest.json');
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+const seoLimits = {
+    title: 70,
+    description: 255
+}
+
+/*----------------------------------
+- FONCTION
+----------------------------------*/
+
+export default class ServerPage<TRouter extends Router = Router> extends PageResponse<TRouter> {
+
+    public constructor(
+        public route: TRoute | TErrorRoute,
+        public renderer: TFrontRenderer,
+        public context: TRouterContext,
+        public layout?: Layout,
+
+        public app = context.app,
+        public router = context.request.router,
+        
+    ) {
+
+        super(route, renderer, context)
+        
+    }
+
+    public render(): Promise<string> {
+
+        // Complete SEO metadatas
+        const titleSuffix = ' | ' + this.app.identity.web.titleSuffix
+        if (this.title === undefined)
+            this.title = this.app.identity.web.fullTitle;
+        else if (this.title.length < seoLimits.title - titleSuffix.length)
+            this.title += titleSuffix;
+
+        if (this.description === undefined)
+            this.description = this.app.identity.web.description;
+
+        // We render page & document separatly,
+        // because document needs to access to runtime assigned values
+        // Ex: runtime added scripts, title, metas, ....
+        
+        const html = renderToString(
+            <App {...this.context} />
+        );
+
+        if (html === undefined)
+            throw new Error(`Page HTML is empty (undefined)`);
+
+        // Metas
+        this.buildMetas();
+        this.buildJsonLd();
+
+        // Un chunk peut regrouper plusieurs fihciers css / js
+        // L'id du chunk est injecté depuis le plugin babel
+        this.addChunks();
+
+        /*if (page.classeBody)
+            attrsBody.className += ' ' + page.classeBody.join(' ');
+
+        if (page.theme)
+            attrsBody.className += ' ' + page.theme;*/
+
+        return this.router.render.page(html, this, this.context.response);
+    }
+
+    // Define which chunks (script / style) to load
+    private addChunks() {
+        const pageChunks = [this.route.options["id"]];
+        for (const chunk of pageChunks) {
+
+            if (!chunk) continue;
+
+            const assets = chunks[chunk];
+            if (!assets) {
+                console.warn(`Chunk ${chunk} was not found. Indexed chunks: ${Object.keys(chunks).join(', ')}`);
+                continue;
+            }
+
+            for (let i = 0; i < assets.length; i++) {
+                const asset = assets[i];
+
+                if (asset.endsWith('.css'))
+                    this.style.push({
+                        id: chunk,
+                        url: '/public/' + asset
+                    })
+                else
+                    this.scripts.push({
+                        id: chunk,
+                        url: '/public/' + asset
+                    });
+            }
+
+        }
+    }
+
+    private buildMetas() {
+
+        const shouldIndex = this.context.response.statusCode < 300;
+
+        const metas = {
+
+            robots: shouldIndex ? 'index' : 'noindex',
+
+            'og:type': 'website',
+            'og:locale': this.app.identity.locale,
+            'og:site_name': this.app.identity.web.title,
+            'og:url': this.url,
+
+            'og:title': this.title,
+            'og:description': this.description,
+
+            'twitter:url': this.url,
+            'twitter:card': 'summary_large_image',
+            'twitter:title': this.title,
+            'twitter:description': this.description,
+
+            ...(this.app.identity.web.metas || {}),
+
+            ...this.metas
+        };
+
+        for (const key in metas) {
+            const value = metas[key];
+            if (value === "") continue;
+            this.head.push({ $: 'meta', property: key, content: value });
+        }
+    }
+
+    private buildJsonLd() {
+        this.jsonld.push({
+            '@type': 'Organization',
+            '@id': this.router.url('/#organization'),
+            name: this.app.identity.author.name,
+            url: this.app.identity.author.url,
+            logo: {
+                '@type': 'ImageObject',
+                '@id': this.router.url('/#logo'),
+                url: this.router.url('/public/brand/1024.png'),
+                width: "1024px",
+                height: "1024px",
+                caption: this.app.identity.name
+            },
+            sameAs: []
+        }, {
+            '@type': 'WebSite',
+            '@id': this.router.url('/#website'),
+            url: this.router.url('/'),
+            name: this.app.identity.name,
+            description: this.app.identity.description,
+            "publisher": {
+                "@id": this.router.url('/#organization'),
+            },
+            inLanguage: this.app.identity.locale,
+            potentialAction: [],
+
+            ...(this.app.identity.web.jsonld || {}),
+        }, {
+            '@type': "WebPage",
+            '@id': this.url,
+            url: this.url,
+
+            "isPartOf": {
+                "@id": this.router.url('/#website'),
+            },
+
+            name: this.title,
+            description: this.description,
+            inLanguage: this.app.identity.locale,
+        });
+    }
+}

package/server/services/router/service.json

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

package/server/services/router/service.ts

@@ -0,0 +1,36 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Core
+import type { Application } from '@server/app';
+import Service, { TRegisteredServicesIndex, TServiceArgs } from '@server/app/service';
+
+// Specific
+import type { default as Router } from '.';
+import type ServerRequest from './request';
+import type RequestService from './request/service';
+import type { TAnyRouter } from '.';
+
+export type AnyRouterService = RouterService<any, TAnyRouter>;
+
+export type TRouterServiceArgs = [
+    getConfig: TServiceArgs<AnyRouterService>[1],
+    app: Application,
+];
+
+/*----------------------------------
+- SERVICE
+----------------------------------*/
+export default abstract class RouterService<
+    TConfig extends {},
+    TRouter extends TAnyRouter
+> extends Service<TConfig, {}, Application, TRouter> {
+
+    public constructor( ...[config, app]: TRouterServiceArgs) {
+        super(app, config, app);
+    }
+
+    public abstract requestService( request: ServerRequest<TRouter> ): RequestService | {} | null;
+
+}

package/server/services/schema/index.ts

@@ -0,0 +1,44 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Core
+import type { Application } from '@server/app';
+
+// Specific
+import { SchemaValidators, TFileValidator } from '@server/services/router/request/validation/validators';
+import Validator, { TValidatorOptions } from '@server/services/router/request/validation/validator';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+
+/*----------------------------------
+- SERVICE
+----------------------------------*/
+export default class ServerSchemaValidator extends SchemaValidators {
+
+    public constructor( public app: Application ) {
+        super();
+    }
+
+    public richText = (opts: TValidatorOptions<string> & {
+        attachements?: TFileValidator
+    } = {}) => new Validator<string>('richText', (val, options, path) => {
+
+        // Default validation
+        val = super.richText(opts).validate(val, options, path);
+
+        // Uploads are done in the business code since the process is specific to every case:
+        // - ID in the destination directory
+        // - Cleanup before upload
+
+        return val;
+
+    }, {
+        //defaut: new Date,
+        ...opts,
+    })
+
+}

package/server/services/schema/request.ts

@@ -0,0 +1,49 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import zod from 'zod';
+import { SomeType } from 'zod/v4/core';
+ 
+// Core
+import { 
+    default as Router, TServerRouter, Request as ServerRequest
+} from '@server/services/router';
+
+// Ap
+import { preprocessSchema, schema } from '@server/services/router/request/validation/zod';
+
+/*----------------------------------
+- SERVICE CONFIG
+----------------------------------*/
+
+const LogPrefix = `[router][validation]`;
+
+export type TConfig = {
+    debug?: boolean
+}
+
+/*----------------------------------
+- SERVICE
+----------------------------------*/
+export default(
+    request: ServerRequest< TServerRouter >,
+    config: TConfig,
+    router = request.router,
+    app = router.app
+) => ({
+
+    ...schema,
+
+    validate( fields: zod.ZodSchema | { [key: string]: zod.ZodSchema } ) {
+
+        config.debug && console.log(LogPrefix, "Validate request data:", request.data);
+
+        const schema = typeof fields === 'object' ? zod.object(fields) : fields;
+
+        const preprocessedSchema = preprocessSchema(schema);
+
+        return preprocessedSchema.parse(request.data);
+    },
+})

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

@@ -0,0 +1,28 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Core
+import { 
+    default as Router, Request as ServerRequest, Config as RouterConfig,
+    RouterService, TAnyRouter
+} from '@server/services/router';
+
+import makeRequestValidators from '../request';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+
+/*----------------------------------
+- SERVICE
+----------------------------------*/
+export default class SchemaRouterService<
+    TUser extends {} = {}
+> extends RouterService<{}, TAnyRouter> {
+
+    public requestService( request: ServerRequest ) {
+        return makeRequestValidators( request, this.config );
+    }
+}

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

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