@gracile/engine 0.1.1 → 0.2.0-next.1

package/dist/server/request.js

@@ -2,73 +2,116 @@ import { Readable, Writable } from 'node:stream';
 import { logger } from '@gracile/internal-utils/logger';
 import { createServerAdapter } from '@whatwg-node/server';
 import c from 'picocolors';
-import { /*  errorInline, */ errorPage } from '../errors/templates.js';
-import { renderRouteTemplate, } from '../render/route-template.js';
+import { isUnknownObject } from '../assertions.js';
+import { errorPage } from '../errors/templates.js';
+import { renderRouteTemplate } from '../render/route-template.js';
 import { renderSsrTemplate } from '../render/utils.js';
 import { getRoute } from '../routes/match.js';
 // NOTE: Find a more canonical way to ponyfill the Node HTTP request to standard Request
 // @ts-expect-error Abusing this feature!
 const adapter = createServerAdapter((request) => request);
 export function createGracileMiddleware({ vite, routes, routeImports, routeAssets, root, serverMode, }) {
-    const middleware = async (req, res, next) => {
-        // Typing workaround
+    const middleware = async (req, res, next, locals) => {
+        // HACK: Typing workaround
         if (!req.url)
             throw Error('Incorrect url');
         if (!req.method)
             throw Error('Incorrect method');
-        logger.info(`[${c.yellow(req.method)}] ${c.yellow(req.url)}`, {
-            timestamp: true,
-        });
-        // MARK: Skip unwanted requests
-        if (
-        //
-        req.url.endsWith('favicon.ico') ||
-            req.url.endsWith('favicon.svg'))
-            return next();
-        const requestPonyfilled = (await Promise.resolve(adapter.handleNodeRequest(req)));
-        async function renderPageFn(handlerInfos, routeInfos) {
-            const { output } = await renderRouteTemplate({
-                request: requestPonyfilled,
-                vite,
-                mode: 'dev',
-                routeInfos,
-                handlerInfos,
-                routeAssets,
-                root,
-                serverMode,
-            });
-            return output || undefined;
+        const { url: urlPath, method } = req;
+        // if (urlPath === '/favicon.ico') return next();
+        async function createErrorPage(e) {
+            logger.error(e.message);
+            let errorPageHtml = await renderSsrTemplate(errorPage(e));
+            if (vite)
+                errorPageHtml = await vite.transformIndexHtml(urlPath, errorPageHtml);
+            return errorPageHtml;
         }
         try {
+            const requestPonyfilled = (await Promise.resolve(adapter.handleNodeRequest(
+            // HACK: Incorrect typings
+            req)));
+            // NOTE: Maybe it should be constructed from `req`
+            const fullUrl = requestPonyfilled.url;
             // MARK: Get route infos
-            const moduleInfos = await getRoute({
-                url: requestPonyfilled.url,
+            const routeOptions = {
+                url: fullUrl,
                 vite,
                 routes,
                 routeImports,
+            };
+            const routeInfos = await getRoute(routeOptions).catch(async (error) => {
+                // MARK: User defined Gracile 404
+                logger.error(String(error));
+                const url = new URL('/404/', fullUrl).href;
+                const options = { ...routeOptions, url };
+                const notFound = await getRoute(options).catch(() => null);
+                return notFound;
+            });
+            if (routeInfos === null) {
+                // MARK: Default, fallback 404
+                const message = `404 not found!\n\n---\n\nCreate a /src/routes/404.{js,ts} to get a custom page.\n${method} - ${urlPath}`;
+                res.statusCode = 404;
+                res.statusMessage = '404 not found!';
+                const errorPage404 = await createErrorPage(new Error(message));
+                return res.end(errorPage404);
+            }
+            const routeTemplateOptions = {
+                request: requestPonyfilled,
+                vite,
+                mode: 'dev', // vite && vite.config.mode === 'dev' ? 'dev' : 'build',
+                routeAssets,
+                root,
+                serverMode,
+                routeInfos,
+            };
+            logger.info(`[${c.yellow(method)}] ${c.yellow(urlPath)}`, {
+                timestamp: true,
             });
             let output;
             // TODO: should move this to `special-file` so we don't recalculate on each request
             // + we would be able to do some route codegen.
             const response = {};
             // NOTE: Only for Express for now.
-            let locals = null;
-            if ('locals' in res)
-                locals = moduleInfos.routeModule.locals?.(res.locals);
+            // console.log({ locals });
+            let providedLocals = {};
+            // if ('locals' in res && isUnknownObject(res.locals)) locals = res.locals;
+            if (locals && isUnknownObject(locals))
+                providedLocals = locals;
             // MARK: Server handler
-            const handler = moduleInfos.routeModule.handler;
-            if ('handler' in moduleInfos.routeModule &&
+            const handler = routeInfos.routeModule.handler;
+            if ('handler' in routeInfos.routeModule &&
                 typeof handler !== 'undefined') {
-                const options = {
+                const routeContext = Object.freeze({
                     request: requestPonyfilled,
-                    url: new URL(requestPonyfilled.url),
+                    url: new URL(fullUrl),
                     response,
-                    params: moduleInfos.params,
-                    locals,
-                };
+                    params: routeInfos.params,
+                    locals: providedLocals,
+                });
+                // MARK: Run user middleware
+                // NOTE: Experimental
+                // eslint-disable-next-line no-inner-declarations
+                // async function useHandler() {}
+                // if (vite) {
+                // 	const middleware = await vite
+                // 		.ssrLoadModule('/src/middleware.ts')
+                // 		.catch(() => null)
+                // 		.then((m) => m.default);
+                // 	if (middleware)
+                // 		await middleware(
+                // 			routeContext,
+                // 			async () => {
+                // 				await useHandler();
+                // 			},
+                // 		);
+                // 	else await useHandler();
+                // } else {
+                // 	await useHandler();
+                // }
+                //
                 // MARK: Top level handler
                 if (typeof handler === 'function') {
-                    const handlerOutput = (await Promise.resolve(handler(options)));
+                    const handlerOutput = (await Promise.resolve(handler(routeContext)));
                     if (handlerOutput instanceof Response)
                         output = handlerOutput;
                     else
@@ -79,26 +122,38 @@ export function createGracileMiddleware({ vite, routes, routeImports, routeAsset
                     const handlerWithMethod = handler[requestPonyfilled.method];
                     if (typeof handlerWithMethod !== 'function')
                         throw TypeError('Handler must be a function.');
-                    const handlerOutput = await Promise.resolve(handlerWithMethod(options));
+                    const handlerOutput = await Promise.resolve(handlerWithMethod(routeContext));
                     if (handlerOutput instanceof Response)
                         output = handlerOutput;
                     else {
-                        output = await renderPageFn({
-                            data: handlerOutput,
-                            method: requestPonyfilled.method,
-                        }, moduleInfos);
+                        output = await renderRouteTemplate({
+                            ...routeTemplateOptions,
+                            handlerInfos: { data: handlerOutput, method },
+                        }).then((r) => r.output);
                     }
                     // MARK: No GET, render page
                 }
                 else if (handler &&
                     'GET' in handler === false &&
                     requestPonyfilled.method === 'GET') {
-                    output = await renderPageFn({ data: null, method: 'GET' }, moduleInfos);
+                    output = await renderRouteTemplate({
+                        ...routeTemplateOptions,
+                        handlerInfos: { data: null, method: 'GET' },
+                        routeInfos,
+                    }).then((r) => r.output);
+                }
+                else {
+                    const message = `This route doesn't handle the \`${method}\` method!`;
+                    res.statusCode = 404;
+                    res.statusMessage = message;
+                    return res.end(await createErrorPage(new Error(message)));
                 }
-                // MARK: No handler, render page
             }
             else {
-                output = await renderPageFn({ data: null, method: 'GET' }, moduleInfos);
+                output = await renderRouteTemplate({
+                    ...routeTemplateOptions,
+                    handlerInfos: { data: null, method: 'GET' },
+                }).then((r) => r.output);
             }
             // MARK: Return response
             // NOTE: try directly with the requestPonyfill. This might not be necessary
@@ -120,69 +175,56 @@ export function createGracileMiddleware({ vite, routes, routeImports, routeAsset
                 // TODO: use this with page only?
                 // if (output.bodyUsed === false)
                 //   throw new Error('Missing body.');
-                if (output.body)
-                    output.body
+                if (output.body) {
+                    const piped = await output.body
                         .pipeTo(Writable.toWeb(res))
                         .catch((e) => logger.error(String(e)));
+                    return piped;
+                }
                 // else throw new Error('Missing body.');
-                else
-                    return res.end(output);
+                // NOTE: Other shapes
+                return res.end(output);
                 // MARK: Stream page render
             }
-            else {
-                new Headers(response.headers)?.forEach((content, header) => res.setHeader(header, content));
-                if (response.status)
-                    res.statusCode = response.status;
-                if (response.statusText)
-                    res.statusMessage = response.statusText;
-                res.setHeader('Content-Type', 'text/html');
-                // MARK: Page stream error
-                output
-                    ?.on('error', (error) => {
-                    const errorMessage = `There was an error while rendering a template chunk on server-side.\n` +
-                        `It was omitted from the resulting HTML.`;
-                    logger.error(errorMessage);
-                    logger.error(error.message);
-                    res.statusCode = 500;
-                    res.statusMessage = errorMessage;
-                    /* NOTE: Safety closing tags, maybe add more */
-                    // Maybe just returning nothing is better to not break the page?
-                    // Should send a overlay message anyway via WebSocket
-                    // vite.ws.send()
-                    if (vite)
-                        setTimeout(() => {
-                            vite.hot.send('gracile:ssr-error', {
-                                message: errorMessage,
-                            });
-                        }, 500);
-                    res.end('' /* errorInline(error) */);
-                })
-                    .pipe(res);
-            }
+            new Headers(response.headers)?.forEach((content, header) => res.setHeader(header, content));
+            if (response.status)
+                res.statusCode = response.status;
+            if (response.statusText)
+                res.statusMessage = response.statusText;
+            res.setHeader('Content-Type', 'text/html');
+            // MARK: Page stream error
+            return output
+                ?.on('error', (error) => {
+                const errorMessage = `There was an error while rendering a template chunk on server-side.\n` +
+                    `It was omitted from the resulting HTML.`;
+                logger.error(errorMessage);
+                logger.error(error.message);
+                res.statusCode = 500;
+                res.statusMessage = errorMessage;
+                /* NOTE: Safety closing tags, maybe add more */
+                // Maybe just returning nothing is better to not break the page?
+                // Should send a overlay message anyway via WebSocket
+                // vite.ws.send()
+                if (vite)
+                    setTimeout(() => {
+                        vite.hot.send('gracile:ssr-error', {
+                            message: errorMessage,
+                        });
+                    }, 500);
+                return res.end('' /* errorInline(error) */);
+            })
+                .pipe(res);
             // MARK: Errors
         }
         catch (e) {
             const error = e;
             if (vite)
                 vite.ssrFixStacktrace(error);
-            // else
-            logger.error(error.message);
-            if (error.cause === 404) {
-                // TODO: Handle 404 with dedicated page
-                if (!vite)
-                    return next();
-                res.statusCode = 404;
-                return res.end('404');
-                // TODO: use a nice framework service page
-                // .redirect(new URL('/__404/', requestPonyfilled.url).href)
-            }
-            let errorTemplate = await renderSsrTemplate(errorPage(error));
-            if (vite)
-                errorTemplate = await vite.transformIndexHtml(req.url, errorTemplate);
+            const ultimateErrorPage = await createErrorPage(error);
             res.statusCode = 500;
-            return res.end(errorTemplate);
+            res.statusMessage = 'Gracile middleware error';
+            return res.end(ultimateErrorPage);
         }
-        return next();
     };
     return middleware;
 }

package/dist/server/utils.d.ts

@@ -1,4 +1,22 @@
-import type { Server } from 'http';
-import type { AddressInfo } from 'net';
-export declare function printNodeHttpServerAddressInfos(instance: Server): AddressInfo;
+import type { IncomingMessage, Server, ServerResponse } from 'node:http';
+export declare function printAddressInfos(options: {
+    instance?: Server;
+    address: string;
+}): void;
+export declare function notFoundHandler(req: IncomingMessage, res: ServerResponse): void;
+export type LocalMiddlewareContext = {
+    request: Request;
+    response: ResponseInit;
+};
+export type BasicAuthUser = {
+    userName: string | null;
+};
+/**
+ * @param context
+ * @returns
+ */
+export declare const authenticateBasic: (context: LocalMiddlewareContext, validate: (user: {
+    name: string;
+    pass: string;
+}) => boolean) => BasicAuthUser;
 //# sourceMappingURL=utils.d.ts.map

package/dist/server/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/server/utils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACnC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,KAAK,CAAC;AAKvC,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CAsB7E"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/server/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AASzE,wBAAgB,iBAAiB,CAAC,OAAO,EAAE;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CAChB,QA2BA;AASD,wBAAgB,eAAe,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,QAaxE;AAED,MAAM,MAAM,sBAAsB,GAAG;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,YAAY,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,YACpB,sBAAsB,YACrB,CAAC,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,KAAK,OAAO,KACzD,aAwBF,CAAC"}

package/dist/server/utils.js

@@ -1,21 +1,72 @@
 // NOTE: Util. to pretty print for user provided server.
+// import type { AddressInfo } from 'node:net';
 import { logger } from '@gracile/internal-utils/logger';
 import { DEV } from 'esm-env';
 import c from 'picocolors';
 import { IP_EXPOSED } from './env.js';
-export function printNodeHttpServerAddressInfos(instance) {
-    const infos = instance.address();
+export function printAddressInfos(options) {
+    let address = null;
+    if (options.instance) {
+        const infos = options.instance.address();
+        if (typeof infos === 'object' && infos && infos.port && infos.address) {
+            address = `http://${infos.address}:${infos.port}/`;
+        }
+    }
+    else if (options.address) {
+        address = options.address;
+    }
+    else
+        throw new Error('Incorrect options');
     logger.info(c.green(`${DEV ? 'development' : 'production'} server started`), {
         timestamp: true,
     });
-    if (typeof infos === 'object' && infos && infos.port && infos.address) {
-        logger.info(`
-${c.dim('┃')} Local    ${c.cyan(`http://localhost:${infos.port}/`)}` +
-            `${infos.address === IP_EXPOSED
-                ? `${c.dim('┃')} Network  ${c.cyan(`http://${infos.address}:${infos.port}/`)}`
-                : ''}
+    logger.info(`
+${c.dim('┃')} Local    ${c.cyan(address)}` +
+        `${address?.includes(IP_EXPOSED)
+            ? `${c.dim('┃')} Network  ${c.cyan(address)}`
+            : ''}
 `);
-        return infos;
+}
+function sendHtml(res, payload) {
+    res.setHeader('content/type', 'text/html');
+    res.end(payload);
+}
+function fallback404(res) {
+    return sendHtml(res, '404 — Not found!');
+}
+export function notFoundHandler(req, res) {
+    const host = req.headers.host;
+    if (!host) {
+        fallback404(res);
+        return;
     }
-    throw Error('Invalid address/port.');
+    const url = new URL('/404/', `http://${host}`);
+    fetch(url)
+        .then((t) => t.text())
+        .then((r) => sendHtml(res, r))
+        .catch(() => fallback404(res));
 }
+/**
+ * @param context
+ * @returns
+ */
+export const authenticateBasic = (context, validate) => {
+    const b64 = context.request.headers.get('authorization')?.split(' ')?.[1];
+    if (b64) {
+        const [name, pass] = Buffer.from(b64, 'base64').toString().split(':');
+        if (name && pass) {
+            validate({ name, pass });
+            return { userName: name };
+        }
+    }
+    /**
+     * Authentication failed
+     */
+    context.response.headers = new Headers({
+        ...context.response.headers,
+        'WWW-Authenticate': 'Basic',
+    });
+    context.response.status = 401;
+    context.response.statusText = 'You are not authenticated!';
+    return { userName: null };
+};