proteum 1.0.3 → 2.0.0

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

@@ -4,78 +4,76 @@
 
 // Npm
 import React from 'react';
-import renderToString from "preact-render-to-string"; 
+import renderToString from 'preact-render-to-string';
 
 // Core
-import { default as Router, TRouterContext } from "@server/services/router";
+import { type TServerRouter, TRouterContext } from '@server/services/router';
 import type { Layout, TRoute, TErrorRoute, TClientOrServerContext } from '@common/router';
-import PageResponse, { TFrontRenderer } from "@common/router/response/page";
+import PageResponse, { TFrontRenderer, TPageRenderContext } from '@common/router/response/page';
+import { getClientBuildManifest } from './clientManifest';
 
 // Composants UI
 import App from '@client/app/component';
 
-// Caches
-const chunks = require('./chunk-manifest.json');
-
 /*----------------------------------
-- TYPES
+- CONSTANTS
 ----------------------------------*/
 
-const seoLimits = {
-    title: 70,
-    description: 255
-}
+const seoLimits = { title: 70, description: 255 };
 
 /*----------------------------------
-- FONCTION
+- CLASS
 ----------------------------------*/
 
-export default class ServerPage<TRouter extends Router = Router> extends PageResponse<TRouter> {
+export default class ServerPage<TRouter extends TServerRouter = TServerRouter> extends PageResponse<
+    TRouter,
+    TRoute | TErrorRoute,
+    TRouterContext<TRouter>
+> {
+    public app: TRouter['app'];
+    public router: TRouter;
+
+    /*----------------------------------
+    - PUBLIC API
+    ----------------------------------*/
 
     public constructor(
         public route: TRoute | TErrorRoute,
         public renderer: TFrontRenderer,
-        public context: TRouterContext,
+        context: TRouterContext<TRouter>,
         public layout?: Layout,
-
-        public app = context.app,
-        public router = context.request.router,
-        
     ) {
+        super(route, renderer, context);
 
-        super(route, renderer, context)
-        
+        this.app = context.app;
+        this.router = context.request.router;
     }
 
     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;
+        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;
+        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 context = this.context as TPageRenderContext & TRouterContext<TRouter>;
         const html = renderToString(
-            <App {...this.context} />
+            <App context={context as Parameters<typeof App>[0]['context'] & TRouterContext<TRouter>} />,
         );
 
-        if (html === undefined)
-            throw new Error(`Page HTML is empty (undefined)`);
+        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
+        // A page chunk can group multiple CSS and JS assets.
+        // Route ids come from the generated route wrapper modules.
         this.addChunks();
 
         /*if (page.classeBody)
@@ -84,46 +82,43 @@ export default class ServerPage<TRouter extends Router = Router> extends PageRes
         if (page.theme)
             attrsBody.className += ' ' + page.theme;*/
 
-        return this.router.render.page(html, this, this.context.response);
+        return this.router.render.page(html, this, context.response);
     }
 
+    /*----------------------------------
+    - HELPERS
+    ----------------------------------*/
+
     // Define which chunks (script / style) to load
     private addChunks() {
-        const pageChunks = [this.route.options["id"]];
+        const manifest = getClientBuildManifest();
+        const pageChunks = [this.route.options['id']];
         for (const chunk of pageChunks) {
-
             if (!chunk) continue;
 
-            const assets = chunks[chunk];
+            const assets = manifest.chunks?.[chunk];
             if (!assets) {
-                console.warn(`Chunk ${chunk} was not found. Indexed chunks: ${Object.keys(chunks).join(', ')}`);
+                console.warn(
+                    `Chunk ${chunk} was not found. Indexed chunks: ${Object.keys(manifest.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
-                    });
+            for (const asset of assets.css || []) {
+                this.style.push({ id: chunk, url: '/public/' + asset });
             }
 
+            for (const asset of assets.js || []) {
+                this.scripts.push({ id: chunk, url: '/public/' + asset });
+            }
         }
     }
 
     private buildMetas() {
+        const context = this.context as TPageRenderContext & TRouterContext<TRouter>;
+        const shouldIndex = context.response.statusCode < 300;
 
-        const shouldIndex = this.context.response.statusCode < 300;
-
-        const metas = {
-
+        const metas: Record<string, string | undefined> = {
             robots: shouldIndex ? 'index' : 'noindex',
 
             'og:type': 'website',
@@ -141,56 +136,56 @@ export default class ServerPage<TRouter extends Router = Router> extends PageRes
 
             ...(this.app.identity.web.metas || {}),
 
-            ...this.metas
+            ...this.metas,
         };
 
         for (const key in metas) {
             const value = metas[key];
-            if (value === "") continue;
+            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
+        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: [],
             },
-            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'),
+            {
+                '@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 || {}),
             },
-            inLanguage: this.app.identity.locale,
-            potentialAction: [],
+            {
+                '@type': 'WebPage',
+                '@id': this.url,
+                url: this.url,
 
-            ...(this.app.identity.web.jsonld || {}),
-        }, {
-            '@type': "WebPage",
-            '@id': this.url,
-            url: this.url,
+                isPartOf: { '@id': this.router.url('/#website') },
 
-            "isPartOf": {
-                "@id": this.router.url('/#website'),
+                name: this.title,
+                description: this.description,
+                inLanguage: this.app.identity.locale,
             },
-
-            name: this.title,
-            description: this.description,
-            inLanguage: this.app.identity.locale,
-        });
+        );
     }
-}
+}

package/server/services/router/service.ts

@@ -3,20 +3,19 @@
 ----------------------------------*/
 
 // Core
-import type { Application } from '@server/app';
-import Service, { TRegisteredServicesIndex, TServiceArgs } from '@server/app/service';
+import type { Application } from '@server/app/index';
+import Service, { TSetupConfig } 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 AnyRouterService = RouterService<any, TAnyRouter, object | null>;
 
-export type TRouterServiceArgs = [
-    getConfig: TServiceArgs<AnyRouterService>[1],
-    app: Application,
+export type TRouterServiceArgs<TConfig extends {} = {}, TRouter extends TAnyRouter = TAnyRouter> = [
+    getConfig: TSetupConfig<TConfig> | null | undefined,
+    app: TRouter['app'],
 ];
 
 /*----------------------------------
@@ -24,13 +23,12 @@ export type TRouterServiceArgs = [
 ----------------------------------*/
 export default abstract class RouterService<
     TConfig extends {},
-    TRouter extends TAnyRouter
-> extends Service<TConfig, {}, Application, TRouter> {
-
-    public constructor( ...[config, app]: TRouterServiceArgs) {
-        super(app, config, app);
+    TRouter extends TAnyRouter = TAnyRouter,
+    TRequestService extends object | null = object | null,
+> extends Service<TConfig, {}, TRouter['app'], TRouter> {
+    public constructor(...[config, app]: TRouterServiceArgs<TConfig, TRouter>) {
+        super(app as TRouter['app'] & TRouter, config, app);
     }
 
-    public abstract requestService( request: ServerRequest<TRouter> ): RequestService | {} | null;
-
-}
+    public abstract requestService(request: ServerRequest<TRouter>): TRequestService;
+}

package/server/services/schema/index.ts

@@ -3,42 +3,33 @@
 ----------------------------------*/
 
 // Core
-import type { Application } from '@server/app';
+import type { Application } from '@server/app/index';
 
 // Specific
-import { SchemaValidators, TFileValidator } from '@server/services/router/request/validation/validators';
-import Validator, { TValidatorOptions } from '@server/services/router/request/validation/validator';
+import { schema, type TRichTextValidatorOptions } from '@server/services/router/request/validation/zod';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
+export type TFileValidator = boolean;
+export type TValidatorOptions<TValue> = { default?: TValue; optional?: boolean };
+
+type TCompatValidator<TValue> = {
+    validate: (value: unknown, options?: unknown, path?: string[]) => TValue;
+};
 
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default class ServerSchemaValidator extends SchemaValidators {
-
-    public constructor( public app: Application ) {
-        super();
+export default class ServerSchemaValidator {
+    public constructor(public app: Application) {
+        void app;
     }
 
-    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,
-    })
-
-}
+    public richText = (
+        opts: TValidatorOptions<string> & { attachements?: TFileValidator } = {},
+    ): TCompatValidator<string> => ({
+        validate: (value: unknown) => schema.richText(opts as TRichTextValidatorOptions).parse(value) as string,
+    });
+}

package/server/services/schema/request.ts

@@ -4,14 +4,17 @@
 
 // Npm
 import zod from 'zod';
- 
+
 // Core
-import { 
-    default as Router, TServerRouter, Request as ServerRequest
-} from '@server/services/router';
+import { TServerRouter, Request as ServerRequest } from '@server/services/router';
 
 // Ap
-import { preprocessSchema, schema } from '@server/services/router/request/validation/zod';
+import {
+    schema,
+    toValidationSchema,
+    type TValidationSchema,
+    type TValidationShape,
+} from '@server/services/router/request/validation/zod';
 
 /*----------------------------------
 - SERVICE CONFIG
@@ -19,39 +22,23 @@ import { preprocessSchema, schema } from '@server/services/router/request/valida
 
 const LogPrefix = `[router][validation]`;
 
-export type TConfig = {
-    debug?: boolean
-}
-
-type TValidationSchema = zod.ZodTypeAny;
-type TValidationShape = zod.ZodRawShape;
-
-const isZodSchema = (fields: unknown): fields is TValidationSchema => {
-    return (
-        typeof fields === 'object'
-        && fields !== null
-        && 'safeParse' in fields
-        && typeof (fields as TValidationSchema).safeParse === 'function'
-    );
-}
+export type TConfig = { debug?: boolean };
 
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default(
-    request: ServerRequest< TServerRouter >,
+export default (
+    request: ServerRequest<TServerRouter>,
     config: TConfig,
     router = request.router,
-    app = router.app
+    _app = router.app,
 ) => {
+    function validate<TSchema extends TValidationSchema>(fields: TSchema): zod.output<TSchema>;
+    function validate<TShape extends TValidationShape>(fields: TShape): zod.output<zod.ZodObject<TShape>>;
+    function validate(fields: TValidationSchema | TValidationShape) {
+        config.debug && console.log(LogPrefix, 'Validate request data:', request.data);
 
-    function validate<TSchema extends TValidationSchema>( fields: TSchema ): zod.output<TSchema>;
-    function validate<TShape extends TValidationShape>( fields: TShape ): zod.output<zod.ZodObject<TShape>>;
-    function validate( fields: TValidationSchema | TValidationShape ) {
-
-        config.debug && console.log(LogPrefix, "Validate request data:", request.data);
-
-        const validationSchema = isZodSchema(fields) ? fields : zod.object(fields);
+        const validationSchema = toValidationSchema(fields);
 
         //const preprocessedSchema = preprocessSchema(validationSchema);
 
@@ -59,9 +46,8 @@ export default(
     }
 
     return {
-
         ...schema,
 
         validate,
-    }
-}
+    };
+};

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

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

package/server/services/security/encrypt/aes/index.ts

@@ -6,7 +6,7 @@
 import crypto, { Encoding } from 'crypto';
 
 // Core
-import type { Application } from '@server/app';
+import type { Application } from '@server/app/index';
 import Service from '@server/app/service';
 import { Forbidden } from '@common/errors';
 
@@ -15,45 +15,33 @@ import { Forbidden } from '@common/errors';
 ----------------------------------*/
 
 export type Config = {
-    debug?: boolean,
+    debug?: boolean;
     // Initialisation vector
     // Generate one here: https://www.allkeysgenerator.com/Random/Security-Encryption-Key-Generator.aspx
-    iv: string,
+    iv: string;
     // Define usage-specific keys
     // You can also generate one via the link upper
-    keys: {[keyName: string]: string}
-}
-
-export type Hooks = {
+    keys: { [keyName: string]: string };
+};
 
-}
+export type Hooks = {};
 
-export type Services = {
-    
-}
+export type Services = {};
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-type TEncryptOptions = {
-    encoding: Encoding
-}
+type TEncryptOptions = { encoding: Encoding };
 
-type TDecryptOptions = {
-    encoding: Encoding
-}
+type TDecryptOptions = { encoding: Encoding };
 
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
 export default class AES<TConfig extends Config = Config> extends Service<TConfig, Hooks, Application, Application> {
-
-    public encrypt( keyName: keyof TConfig["keys"], data: any, options: TEncryptOptions = {
-        encoding: 'base64url'
-    }) {
-
-        const encKey = this.config.keys[ keyName as keyof typeof this.config.keys ];
+    public encrypt(keyName: keyof TConfig['keys'], data: any, options: TEncryptOptions = { encoding: 'base64url' }) {
+        const encKey = this.config.keys[keyName as keyof typeof this.config.keys];
 
         data = JSON.stringify(data);
 
@@ -61,25 +49,17 @@ export default class AES<TConfig extends Config = Config> extends Service<TConfi
         let encrypted = cipher.update(data, 'utf8', options.encoding);
         encrypted += cipher.final(options.encoding);
         return encrypted;
-        
     }
 
-    public decrypt( keyName: keyof TConfig["keys"], data: string, options: TDecryptOptions = {
-        encoding: 'base64url'
-    }) {
-
-        const encKey = this.config.keys[ keyName as keyof typeof this.config.keys ];
+    public decrypt(keyName: keyof TConfig['keys'], data: string, options: TDecryptOptions = { encoding: 'base64url' }) {
+        const encKey = this.config.keys[keyName as keyof typeof this.config.keys];
 
         try {
-
             let decipher = crypto.createDecipheriv('aes-256-cbc', encKey, this.config.iv);
             let decrypted = decipher.update(data, options.encoding, 'utf8');
             return JSON.parse(decrypted + decipher.final('utf8'));
-
         } catch (error) {
-
-            throw new Forbidden("Invalid token.");
-            
+            throw new Forbidden('Invalid token.');
         }
     }
-}
+}