5htp-core 0.6.0 → 0.6.1-1

package/server/services/router/index.ts

@@ -11,20 +11,21 @@
 
 // Node
 // Npm
+import got from 'got';
+import hInterval from 'human-interval';
 import type express from 'express';
 import type { Request, Response, NextFunction } from 'express';
 import { v4 as uuid } from 'uuid';
-import zod from 'zod';
+import zod, { ZodError } from 'zod';
 export { default as schema } from 'zod';
 import type { GlobImportedWithMetas } from 'babel-plugin-glob-import';
 
 // Core
 import type { Application } from '@server/app';
 import Service, { AnyService, TServiceArgs } from '@server/app/service';
-import type { TRegisteredServicesIndex } from '@server/app/service/container';
 import context from '@server/context';
 import type DisksManager from '@server/services/disks';
-import { CoreError, NotFound, toJson as errorToJson } from '@common/errors';
+import { CoreError, InputError, NotFound, toJson as errorToJson } from '@common/errors';
 import BaseRouter, {
     TRoute, TErrorRoute, TRouteModule,
     TRouteOptions, defaultOptions,
@@ -138,7 +139,13 @@ export default class ServerRouter
     public ssrRoutes: TSsrUnresolvedRoute[] = [];
 
     // Cache (ex: for static pages)
-    public cache: {[pageId: string]: string} = {}
+    public cache: {
+        [pageId: string]: {
+            rendered: any,
+            expire: number | undefined,
+            options: TRouteOptions["static"]
+        }
+    } = {}
 
     /*----------------------------------
     - SERVICE
@@ -158,6 +165,11 @@ export default class ServerRouter
 
     public async ready() {
 
+        // Every hours
+        setInterval(() => {
+            this.refreshStaticPages();
+        }, 1000 * 60 * 60);
+
         // Detect router services
         for (const serviceName in this.config.plugins) {
             this.app.register( this.config.plugins[serviceName] )
@@ -173,6 +185,32 @@ export default class ServerRouter
         // Start HTTP server
         await this.http.start();
 
+        // override
+        const originalLog = console.log;
+        console.log = (...args: any[]) => {
+
+            // parse stack trace: skip this function and the console.log call
+            /*const stackLine = (new Error()).stack?.split('\n')[2] || '';
+            const match = stackLine.match(/at (\w+)\.(\w+) /);
+            const className = match ? match[1] : '<global>';
+            const methodName = match ? match[2] : '<anonymous>';*/
+
+            const contextData = context.getStore() || {
+                channelType: 'master',
+            }
+
+            const requestPrefix = contextData.channelType === 'request' 
+                ? `[${contextData.user ? contextData.user : 'guest'}] ${contextData.method} ${contextData.path} |` 
+                : 'master';
+
+            // prefix and forward
+            originalLog.call(
+                console, 
+                `${requestPrefix}`, // ${className}.${methodName}
+                ...args
+            );
+        };
+
     }
 
     public async shutdown() {
@@ -183,6 +221,65 @@ export default class ServerRouter
     - ACTIONS
     ----------------------------------*/
 
+    public async renderStatic( 
+        path: string, 
+        options: TRouteOptions["static"],
+        rendered?: any
+    ) {
+
+        // Wildcard: tell that the newly rendered pages should be cached
+        if (path === '*' || !path)
+            return;
+
+        if (!rendered) {
+
+            const fullUrl = this.url(path, {}, true);
+            console.log('[router] renderStatic', fullUrl);
+
+            const response = await got( fullUrl, {
+                method: 'GET',
+                headers: {
+                    'Accept': 'text/html'
+                },
+                throwHttpErrors: false,
+            });
+
+            if (response.statusCode !== 200) {
+                console.error('renderStatic', response.statusCode, response.body);
+                return;
+            }
+
+            rendered = response.body;
+        }
+
+        this.cache[path] = {
+            rendered: rendered,
+            options: options,
+            expire: typeof options === 'object' 
+                ? Date.now() + (hInterval(options.refresh) || 3600) 
+                : undefined
+        };
+        
+    }
+
+    private refreshStaticPages() {
+
+        console.log('[router] refreshStaticPages');
+        
+        for (const pageId in this.cache) {
+            const page = this.cache[pageId];
+            if (page.path && page.expire && page.expire < Date.now()) {
+
+                this.renderStatic(page.path, page.options);
+
+            }
+        }
+    }
+
+
+
+
+
     private registerRoutes(defModules: GlobImportedWithMetas<TRouteModule>) {
         for (const routeModule of defModules) {
 
@@ -231,6 +328,14 @@ export default class ServerRouter
 
         this.routes.push(route);
 
+        // Add to static pages
+        // Should be a GET oage that don't take any parameter
+        if (options.static) {
+            for (const url of options.static.urls) {
+                this.renderStatic(url, options.static);
+            }
+        }
+
         return this;
 
     }
@@ -393,7 +498,13 @@ export default class ServerRouter
             "Cache-Control",
             "no-store, no-cache, must-revalidate, proxy-revalidate"
         );
-        res.setHeader("Pragma", "no-cache");
+
+        // Static pages
+        if (this.cache[req.path]) {
+            console.log('[router] Get static page from cache', req.path);
+            res.send( this.cache[req.path].rendered );
+            return;
+        }
 
         // Create request
         let requestId = uuid();
@@ -410,39 +521,34 @@ export default class ServerRouter
             this
         );
 
-        // Create request context so we can access request context across all the request-triggered libs
-        context.run({ channelType: 'request', channelId: requestId }, async () => {
-
-            let response: ServerResponse<this>;
-            try {
-
-                // Hook
-                await this.runHook('request', request);
+        let response: ServerResponse<this>;
+        try {
 
-                // Bulk API Requests
-                if (request.path === '/api' && typeof request.data.fetchers === "object") {
+            // Hook
+            await this.runHook('request', request);
 
-                    return await this.resolveApiBatch(request.data.fetchers, request);
+            // Bulk API Requests
+            if (request.path === '/api' && typeof request.data.fetchers === "object") {
 
-                } else {
-                    response = await this.resolve(request);
-                }
-            } catch (e) {
-                response = await this.handleError(e, request);
-            }
+                return await this.resolveApiBatch(request.data.fetchers, request);
 
-            if (!res.headersSent) {
-                // Status
-                res.status(response.statusCode);
-                // Headers
-                res.header(response.headers);
-                // Data
-                res.send(response.data);
-            } else if (response.data !== 'true') {
-                throw new Error("Can't return data from the controller since response has already been sent via express.");
+            } else {
+                response = await this.resolve(request);
             }
+        } catch (e) {
+            response = await this.handleError(e, request);
+        }
 
-        });
+        if (!res.headersSent) {
+            // Status
+            res.status(response.statusCode);
+            // Headers
+            res.header(response.headers);
+            // Data
+            res.send(response.data);
+        } else if (response.data !== 'true') {
+            throw new Error("Can't return data from the controller since response has already been sent via express.");
+        }
     }
 
     public createContextServices( request: ServerRequest<this> ) {
@@ -466,75 +572,86 @@ export default class ServerRouter
         return contextServices;
     }
 
-    public async resolve(request: ServerRequest<this>): Promise<ServerResponse<this>> {
+    public resolve = (request: ServerRequest<this>) => new Promise<ServerResponse<this>>((resolve, reject) => {
+
+        // Create request context so we can access request context across all the request-triggered libs
+        context.run({ 
+            // This is for debugging
+            channelType: 'request', 
+            channelId: request.id,
+            method: request.method,
+            path: request.path,
+        }, async () => {
+
+            const timeStart = Date.now();
+
+            if (this.status === 'starting') {
+                console.log(LogPrefix, `Waiting for servert to be resdy before resolving request`);
+                await this.started;
+            }
 
-        const logId = LogPrefix + ' ' + (request.isVirtual ? ' ---- ' : '') + request.ip + ' ' + request.method + ' ' + request.domain + ' ' + request.path;
-        console.info(logId);
-        const timeStart = Date.now();
+            try {
 
-        if (this.status === 'starting') {
-            console.log(LogPrefix, `Waiting for servert to be resdy before resolving request`);
-            await this.started;
-        }
+                const response = new ServerResponse<this>(request);
 
-        try {
+                await this.runHook('resolve', request);
 
-            const response = new ServerResponse<this>(request);
+                // Controller route
+                let route = this.controllers[request.path];
+                if (route !== undefined) {
 
-            await this.runHook('resolve', request);
+                    // Create response
+                    await this.resolvedRoute(route, response, timeStart);
+                    if (response.wasProvided)
+                        return resolve(response);
+                }
 
-            // Controller route
-            let route = this.controllers[request.path];
-            if (route !== undefined) {
+                const contextStore = context.getStore();
+                if (contextStore)
+                    contextStore.user = request.user?.email;
 
-                // Create response
-                await this.resolvedRoute(route, response, logId, timeStart);
-                if (response.wasProvided)
-                    return response;
-            }
+                // Classic routes
+                for (route of this.routes) {
 
-            // Classic routes
-            for (route of this.routes) {
+                    // Match Method
+                    if (request.method !== route.method && route.method !== '*')
+                        continue;
 
-                // Match Method
-                if (request.method !== route.method && route.method !== '*')
-                    continue;
+                    // Match Response format
+                    if (!request.accepts(route.options.accept))
+                        continue;
 
-                // Match Response format
-                if (!request.accepts(route.options.accept))
-                    continue;
+                    const isMatching = matchRoute(route, request);
+                    if (!isMatching)
+                        continue;
 
-                const isMatching = matchRoute(route, request);
-                if (!isMatching)
-                    continue;
+                    await this.resolvedRoute(route, response, timeStart);
+                    if (response.wasProvided)
+                        return resolve(response);
+                }
 
-                await this.resolvedRoute(route, response, logId, timeStart);
-                if (response.wasProvided)
-                    return response;
-            }
+                reject( new NotFound() );
 
-            throw new NotFound();
+            } catch (error) {
 
-        } catch (error) {
+                if (this.app.env.profile === 'dev') {
+                    console.log('API batch error:', request.method, request.path, error);
+                    const errOrigin = request.method + ' ' + request.path;
+                    if (error.details === undefined)
+                        error.details = { origin: errOrigin }
+                    else
+                        error.details.origin = errOrigin;
+                }
 
-            if (this.app.env.profile === 'dev') {
-                console.log('API batch error:', request.method, request.path, error);
-                const errOrigin = request.method + ' ' + request.path;
-                if (error.details === undefined)
-                    error.details = { origin: errOrigin }
-                else
-                    error.details.origin = errOrigin;
+                this.printTakenTime(timeStart);
+                reject( error );
             }
-
-            this.printTakenTime(logId, timeStart);
-            throw error;
-        }
-    }
+        });
+    });
 
     private async resolvedRoute( 
         route: TRoute, 
         response: ServerResponse<this>,
-        logId: string,
         timeStart: number
     ) {
 
@@ -546,15 +663,25 @@ export default class ServerRouter
         if (!response.wasProvided)
             return;
 
+        // Set in cache
+        if (
+            response.request.path
+            && route.options.static 
+            && route.options.static.urls.includes('*')
+        ) {
+            console.log('[router] Set in cache', response.request.path);
+            this.renderStatic(response.request.path, route.options.static, response.data);
+        }
+
         const timeEndResolving = Date.now();
-        this.printTakenTime(logId, timeStart, timeEndResolving);
+        this.printTakenTime(timeStart, timeEndResolving);
     }
 
-    private printTakenTime = (logId: string, timeStart: number, timeEndResolving?: number) => {
+    private printTakenTime = (timeStart: number, timeEndResolving?: number) => {
 
         if (this.app.env.name === 'server') return;
 
-        console.log(logId + ' ' + Math.round(Date.now() - timeStart) + 'ms' + 
+        console.log( Math.round(Date.now() - timeStart) + 'ms' + 
             (timeEndResolving === undefined ? '' : ' | Routing: ' + Math.round(timeEndResolving - timeStart))
         );
     }
@@ -583,7 +710,12 @@ export default class ServerRouter
         request.res.json(responseData);
     }
 
-    private async handleError( e: CoreError, request: ServerRequest<ServerRouter> ) {
+    private async handleError( e: Error |CoreError | ZodError, request: ServerRequest<ServerRouter> ) {
+
+        if (e instanceof ZodError)
+            e = new InputError( 
+                e.errors.map(e => e.path.join('.') + ': ' + e.message).join(', ') 
+            );
 
         const code = 'http' in e ? e.http : 500;
 
@@ -600,7 +732,9 @@ export default class ServerRouter
 
             // Don't exose technical errors to users
             if (this.app.env.profile === 'prod')
-                e.message = "We encountered an internal error, and our team has just been notified. Sorry for the inconvenience.";
+                e = new Error(
+                    "We encountered an internal error, and our team has just been notified. Sorry for the inconvenience."
+                );
 
         } else {
 

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

@@ -111,17 +111,6 @@ export default class ServerResponse<
         // Create response context for controllers
         const context = await this.createContext(route);
 
-        // Static rendering
-        const chunkId = route.options["id"];
-        if (route.options.static && 
-            chunkId !== undefined 
-            && 
-            this.router.cache[ chunkId ] !== undefined
-        ) {
-            await this.html( this.router.cache[ chunkId ] );
-            return;
-        }
-
         // Run controller
         const content = await this.route.controller( context );
         if (content === undefined)
@@ -139,10 +128,6 @@ export default class ServerResponse<
         // Return JSON
         else
             await this.json(content);
-
-        // Cache
-        if (route.options.static)
-            this.router.cache[ chunkId ] = this.data;
     }
 
     private updateCanonicalUrl( route: TAnyRoute ) {

package/server/utils/rte.ts

@@ -9,131 +9,39 @@ import path from 'path';
 import md5 from 'md5';
 import { fromBuffer } from 'file-type';
 import { JSDOM } from 'jsdom';
-// Lexical
-import { $getRoot } from 'lexical';
-import { createHeadlessEditor } from '@lexical/headless';
-import { $generateNodesFromDOM, $generateHtmlFromNodes } from '@lexical/html';
 
 // Core
-import { Anomaly } from '@common/errors';
 import editorNodes from '@common/data/rte/nodes';
 import ExampleTheme from '@client/components/Rte/themes/PlaygroundEditorTheme';
-import type Driver from '@server/services/disks/driver';
 import Slug from '@server/utils/slug';
 
+// Lexical
+import { $getRoot, SerializedEditorState, SerializedLexicalNode } from 'lexical';
+import { createHeadlessEditor } from '@lexical/headless';
+import { $generateNodesFromDOM, $generateHtmlFromNodes } from '@lexical/html';
+
+// Specifc
+import { 
+    default as BaseRteUtils, 
+    LexicalNode, 
+    LexicalState, 
+    TRenderOptions,
+    TContentAssets,
+    TSkeleton
+} from '@common/utils/rte';
+
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-type LexicalState = {
-    root: LexicalNode
-}
-
-export type LexicalNode = {
-    version: number,
-    type: string,
-    children?: LexicalNode[],
-    // Attachement
-    src?: string;
-    // Headhing
-    text?: string;
-    anchor?: string;
-    tag?: string;
-}
-
-type TRenderOptions = {
-
-    transform?: RteUtils["transformNode"],
-
-    render?: (
-        node: LexicalNode, 
-        parent: LexicalNode | null, 
-        options: TRenderOptions
-    ) => Promise<LexicalNode>,
-
-    attachements?: {
-        disk: Driver,
-        directory: string,
-        prevVersion?: string | LexicalState | null,
-    }
-}
-
-type TSkeleton = { 
-    id: string,
-    title: string, 
-    level: number, 
-    childrens: TSkeleton 
-}[];
-
-type TContentAssets = {
-    attachements: string[],
-    skeleton: TSkeleton
-}
 
 /*----------------------------------
 - FUNCTIONS
 ----------------------------------*/
 
-export class RteUtils {
-
-    public async render( 
-        content: string | LexicalState, 
-        options: TRenderOptions = {}
-    ): Promise<TContentAssets & {
-        html: string,
-        json: string | LexicalState,
-    }> {
+export class RteUtils extends BaseRteUtils {
 
-        // Transform content
-        const assets: TContentAssets = {
-            attachements: [],
-            skeleton: []
-        }
-
-        // Parse content if string
-        let json: LexicalState;
-        if (typeof content === 'string' && content.trim().startsWith('{')) {
-            try {
-                json = JSON.parse(content) as LexicalState;
-            } catch (error) { 
-                throw new Anomaly("Invalid JSON format for the given JSON RTE content.");
-            }
-        } else if (content && typeof content === 'object' && content.root)
-            json = content;
-        else
-            return { html: '', json: content, ...assets };
-
-        // Parse prev version if string
-        if (typeof options?.attachements?.prevVersion === 'string') {
-            try {
-                options.attachements.prevVersion = JSON.parse(options.attachements.prevVersion) as LexicalState;
-            } catch (error) {
-                throw new Anomaly("Invalid JSON format for the given JSON RTE prev version.");
-            }
-        }
-
-        const root = await this.processContent(json.root, null, async (node, parent) => {
-            return await this.transformNode(node, parent, assets, options);
-        });
-
-        json = { ...json, root };
-
-        // Delete unused attachements
-        const attachementOptions = options?.attachements;
-        if (attachementOptions && attachementOptions.prevVersion !== undefined) {
-
-            await this.processContent(root, null, async (node) => {
-                return await this.deleteUnusedFile(node, assets, attachementOptions);
-            });
-        }
-
-        // Convert json to HTML
-        const html = await this.jsonToHtml( json, options );
-
-        return { html, json: content, ...assets };
-    }
-
-    private async processContent( 
+    protected async processContent( 
         node: LexicalNode, 
         parent: LexicalNode | null,
         callback: (node: LexicalNode, parent: LexicalNode | null) => Promise<LexicalNode>
@@ -153,7 +61,7 @@ export class RteUtils {
         return node;
     }
 
-    private async transformNode(
+    protected async transformNode(
         node: LexicalNode, 
         parent: LexicalNode | null, 
         assets: TContentAssets, 
@@ -254,7 +162,7 @@ export class RteUtils {
         });
     }
 
-    private async deleteUnusedFile( 
+    protected async deleteUnusedFile( 
         node: LexicalNode, 
         assets: TContentAssets,
         options: NonNullable<TRenderOptions["attachements"]>
@@ -282,7 +190,7 @@ export class RteUtils {
         return node;
     }
 
-    public async jsonToHtml( json: LexicalState, options: TRenderOptions = {} ) {
+    public async jsonToHtml( json: LexicalState, options: TRenderOptions = {} ): Promise<string | null> {
 
         // Transform before rendering
         const renderTransform = options.render;
@@ -310,7 +218,7 @@ export class RteUtils {
         });
 
         // Set the editor state from JSON
-        const state = editor.parseEditorState(json);
+        const state = editor.parseEditorState(json as SerializedEditorState<SerializedLexicalNode>);
         if (state.isEmpty())
             return '';
 
@@ -334,25 +242,6 @@ export class RteUtils {
         return html;
     }
 
-    private jsonToText( node: LexicalNode ) {
-
-        let text = '';
-
-        // Check if the node has text content
-        if (node.type === 'text' && node.text) {
-            text += node.text;
-        }
-
-        // Recursively process children nodes
-        if (node.children && Array.isArray(node.children)) {
-            node.children.forEach(childNode => {
-                text += this.jsonToText(childNode);
-            });
-        }
-
-        return text;
-    }
-
     public async htmlToJson(htmlString: string): Promise<LexicalState> {
 
         const editor = createHeadlessEditor({