@underpostnet/underpost 2.7.91 → 2.7.92

package/src/client/sw/default.sw.js

@@ -1,58 +1,27 @@
-import { loggerFactory } from '../components/core/Logger.js';
-
-// https://googlechrome.github.io/samples/service-worker/custom-offline-page/
-
-/*
-Copyright 2015, 2019 Google Inc. All Rights Reserved.
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
- http://www.apache.org/licenses/LICENSE-2.0
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
-*/
-
-// https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
-// https://web.dev/cache-api-quick-guide/
-// https://developer.mozilla.org/en-US/docs/Web/API
-// https://developer.mozilla.org/es/docs/Web/Progressive_web_apps/Re-engageable_Notifications_Push
-// https://developer.mozilla.org/en-US/docs/Web/API/Notification/Notification
-// https://github.com/GoogleChrome/samples/blob/9e4b3b77b091268d28e5438bb2fe8829091e9540/service-worker/basic/service-worker.js#L59
-// https://developer.mozilla.org/en-US/docs/Web/API/Geolocation_API
-
-/*
-
- 4 different ways to store data on client-side without using cookies:
-
-- Local Storage (Session and Local key/value pairs)
-- Web SQL (my favorite, it's a whole SQL Database, and it's NOT obsolete)
-- IndexedDB (another Database with different structure and acceptance)
-- Service Workers (Persistent background processing,
-even while offline, can asynchronously save files and many other things)
-
-*/
-
-const logger = loggerFactory(import.meta);
-
+const PRE_CACHED_RESOURCES = [];
+const CACHE_NAME = 'app-cache';
 const PROXY_PATH = '/';
-
 self.addEventListener('install', (event) => {
   // Activate right away
   self.skipWaiting();
 
   event.waitUntil(
     (async () => {
-      // const cache = await caches.open(CACHE_NAME);
-      // Setting {cache: 'reload'} in the new request will ensure that the response
-      // isn't fulfilled from the HTTP cache; i.e., it will be from the network.
-      // await cache.add(new Request(OFFLINE_URL, { cache: 'reload' }));
       // Open the app's cache.
-      // const cache = await caches.open(CACHE_NAME);
+      const cache = await caches.open(CACHE_NAME);
       // Cache all static resources.
-      // await cache.addAll(PRE_CACHED_RESOURCES);
+      try {
+        await cache.addAll(PRE_CACHED_RESOURCES);
+      } catch (error) {
+        console.error(error);
+      }
+      // for (const cacheKey of PRE_CACHED_RESOURCES) {
+      //   try {
+      //     await cache.add(cacheKey);
+      //   } catch (error) {
+      //     console.error(error, cacheKey);
+      //   }
+      // }
     })(),
   );
 });
@@ -67,139 +36,47 @@ self.addEventListener('activate', (event) => {
       }
     })(),
   );
-
   // Tell the active service worker to take control of the page immediately.
   self.clients.claim();
-
-  // event message
-  self.addEventListener('message', (event) => {
-    logger.info('Received event message', event.data);
-
-    switch (event.data.status) {
-      case 'skipWaiting':
-        return self.skipWaiting();
-        break;
-
-      default:
-        break;
-    }
-
-    clients.matchAll().then((clientList) => {
-      for (const client of clientList) {
-        logger.info('client', client);
-        client.postMessage({
-          title: 'Hello from SW event message',
-        });
-        // client -> document.visibilityState
-        //           client.visibilityState
-      }
-    });
-  });
-  // broadcast message
-  const channel = new BroadcastChannel('sw-messages');
-  channel.addEventListener('message', (event) => {
-    logger.info('Received broadcast message', event.data);
-    channel.postMessage({ title: 'Hello from SW broadcast message' });
-  });
 });
 
 self.addEventListener('fetch', (event) => {
-  let path;
-
-  if (event.request.url.match(location.origin)) path = event.request.url.slice(location.origin.length);
-  const preload = path && !path.match('/api');
-
-  logger.info(`On fetch`, {
-    mode: event.request.mode,
-    url: event.request.url,
-    referrer: event.request.referrer,
-    method: event.request.method,
-    path,
-    preload,
-  });
-
-  (async () => {
-    // Get the client.
-    const client = await clients.get(event.clientId);
-    if (client)
-      client.postMessage({
-        status: 'loader',
-        path,
-      });
-    else logger.warn('client not found');
-  })();
+  // Cache-First Strategy
+  event.respondWith(
+    (async () => {
+      // First, try to use the navigation preload response if it's supported.
+      try {
+        const preloadResponse = await event.preloadResponse;
+        if (preloadResponse) return preloadResponse;
+        return await fetch(event.request);
+      } catch (error) {
+        console.error('Fetch failed; returning offline page instead.', event.request.url, error);
+        // Fallback to the offline page.
+        const path = PRE_CACHED_RESOURCES.find((path) => event.request.url.match(path.replaceAll('/index.html', '')));
 
-  // We only want to call event.respondWith() if this is a navigation request
-  // for an HTML page.
-  if (path !== undefined || event.request.mode === 'navigate') {
-    event.respondWith(
-      (async () => {
         try {
-          // First, try to use the navigation preload response if it's supported.
-          const preloadResponse = await event.preloadResponse;
-          if (preloadResponse) {
-            return preloadResponse;
-          }
-
-          if (preload) {
-            const preloadCache = await caches.has(path);
-            const cache = await caches.open(path);
-            const cacheResponse = await cache.match(path);
-            if (!preloadCache || !cacheResponse || cacheResponse.status !== 200) {
-              logger.warn('install', path);
-              // await cache.add(new Request(event.request.url, { cache: 'reload' }));
-
-              // Other option:
-              // The resource wasn't found in the cache, so fetch it from the network.
-              const fetchResponse = await fetch(event.request.url);
-
-              if (fetchResponse.status === 200) {
-                // Put the response in cache.
-                await cache.put(event.request.url, fetchResponse.clone());
-                // And return the response.
-                return fetchResponse;
-              } else {
-                await caches.delete(path);
-                throw new Error(await fetchResponse.text());
-              }
-            }
-            // logger.info('cache response', path);
-            return cacheResponse;
-          }
-
-          const networkResponse = await fetch(event.request);
-          logger.warn('fetch response', event.request.url);
-          return networkResponse;
+          const cachedResponse = await caches.match(event.request);
+          if (cachedResponse) return cachedResponse;
+          const cache = await caches.open(CACHE_NAME);
+          const preCachedResponse = await cache.match(path);
+          if (!preCachedResponse) throw new Error(error.message);
+          return preCachedResponse;
         } catch (error) {
-          // catch is only triggered if an exception is thrown, which is likely
-          // due to a network error.
-          // If fetch() returns a valid HTTP response with a response code in
-          // the 4xx or 5xx range, the catch() will NOT be called.
-          if (path) {
-            const preloadCache = await caches.has(path);
-            if (preloadCache) await caches.delete(path);
-          }
-
-          logger.error('Fetch failed; returning offline page instead.', { error, path });
+          console.error('Error opening cache for pre cached page', event.request.url, error);
           try {
-            const cache = await caches.open(`${PROXY_PATH}offline.html`);
-            const cachedResponse = await cache.match(`${PROXY_PATH}offline.html`);
-            return cachedResponse;
+            const cache = await caches.open(CACHE_NAME);
+            const preCachedResponse = await cache.match(`${PROXY_PATH === '/' ? '' : PROXY_PATH}/offline/index.html`);
+            if (!preCachedResponse) throw new Error(error.message);
+            return preCachedResponse;
           } catch (error) {
-            logger.error('Error opening cache for offline page', { error, path });
-            const response = new Response(JSON.stringify({ status: 'error', message: 'offline test response' }));
+            console.error('Error opening cache for offline page', event.request.url, error);
+            const response = new Response(JSON.stringify({ status: 'error', message: error.message }));
             // response.status = 200;
             response.headers.set('Content-Type', 'application/json');
             return response;
           }
         }
-      })(),
-    );
-  }
-
-  // If our if() condition is false, then this fetch handler won't intercept the
-  // request. If there are any other fetch handlers registered, they will get a
-  // chance to call event.respondWith(). If no fetch handlers call
-  // event.respondWith(), the request will be handled by the browser as if there
-  // were no service worker involvement.
+      }
+    })(),
+  );
 });

package/src/mailer/EmailRender.js

@@ -1,5 +1,4 @@
-import { srcFormatted } from '../server/client-formatted.js';
-import fs from 'fs-extra';
+import { ssrFactory } from '../server/client-formatted.js';
 
 const EmailRender = {
   style: {
@@ -58,8 +57,7 @@ const EmailRender = {
     const templates = {};
     for (const templateKey of Object.keys(options.templates)) {
       const ssrEmailComponent = options.templates[templateKey];
-      let SrrComponent;
-      eval(await srcFormatted(fs.readFileSync(`./src/client/ssr/components/email/${ssrEmailComponent}.js`, 'utf8')));
+      const SrrComponent = await ssrFactory(`./src/client/ssr/mailer/${ssrEmailComponent}.js`);
       templates[templateKey] = SrrComponent(this, options);
     }
     return templates;

package/src/mailer/MailerProvider.js

@@ -25,7 +25,10 @@ const MailerProvider = {
       },
       host: '',
       path: '',
-      templates: ['SsrTemplate'],
+      templates: {
+        userVerifyEmail: 'DefaultVerifyEmail',
+        userRecoverEmail: 'DefaultRecoverEmail',
+      },
     },
   ) {
     try {

package/src/server/client-build.js

@@ -1,9 +1,16 @@
 'use strict';
 
 import fs from 'fs-extra';
-import { srcFormatted, componentFormatted, viewFormatted, ssrFactory } from './client-formatted.js';
+import { srcFormatted, componentFormatted, viewFormatted, ssrFactory, JSONweb } from './client-formatted.js';
 import { loggerFactory } from './logger.js';
-import { cap, newInstance, orderArrayFromAttrInt, titleFormatted } from '../client/components/core/CommonJs.js';
+import {
+  cap,
+  getCapVariableName,
+  newInstance,
+  orderArrayFromAttrInt,
+  titleFormatted,
+  uniqueArray,
+} from '../client/components/core/CommonJs.js';
 import UglifyJS from 'uglify-js';
 import { minify } from 'html-minifier-terser';
 import dotenv from 'dotenv';
@@ -131,16 +138,6 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
   const enableLiveRebuild =
     options && options.liveClientBuildPaths && options.liveClientBuildPaths.length > 0 ? true : false;
 
-  // common ssr components
-  let jsSsrCommonComponents = '';
-  {
-    const files = await fs.readdir(`./src/client/ssr/common`);
-    for (const relativePath of files)
-      jsSsrCommonComponents += await srcFormatted(
-        fs.readFileSync(`./src/client/ssr/common/${relativePath}`, 'utf8').split('export')[0],
-      );
-  }
-
   let currentPort = parseInt(process.env.PORT) + 1;
   for (const host of Object.keys(confServer)) {
     const paths = orderArrayFromAttrInt(Object.keys(confServer[host]), 'length', 'asc');
@@ -167,6 +164,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
         apiBaseHost,
         ttiLoadTimeLimit,
         singleReplica,
+        offlineBuild,
       } = confServer[host][path];
       if (singleReplica) continue;
       if (!confClient[client]) confClient[client] = {};
@@ -308,57 +306,22 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
 
       const buildId = `${client}.index`;
       const siteMapLinks = [];
-      let Render = () => '';
-      eval(await srcFormatted(fs.readFileSync(`./src/client/ssr/Render.js`, 'utf8')));
+      const ssrPath = path === '/' ? path : `${path}/`;
+      const Render = await ssrFactory();
 
       if (views) {
-        const buildJsSrcPage = async (jsSrcPath, jsPublicPath, filter) => {
-          if (!(enableLiveRebuild && !options.liveClientBuildPaths.find((p) => p.srcBuildPath === jsSrcPath))) {
-            let jsSrc = viewFormatted(await srcFormatted(fs.readFileSync(jsSrcPath, 'utf8')), dists, path, baseHost);
-            if (jsSrc.split('/*imports*/')[1]) jsSrc = jsSrc.split('/*imports*/')[1];
-            if (filter) jsSrc = await filter(jsSrc);
-            fs.writeFileSync(
-              jsPublicPath,
-              minifyBuild || process.env.NODE_ENV === 'production' ? UglifyJS.minify(jsSrc).code : jsSrc,
-              'utf8',
-            );
-          }
-        };
-
-        // service woker
-        await buildJsSrcPage(
-          fs.existsSync(`./src/client/sw/${publicClientId}.sw.js`)
-            ? `./src/client/sw/${publicClientId}.sw.js`
-            : `./src/client/sw/default.sw.js`,
-          `${rootClientPath}/sw.js`,
-          path !== '/'
-            ? (jsSrc) => jsSrc.replaceAll(`const PROXY_PATH = '/';`, `const PROXY_PATH = '${path}/';`)
-            : undefined,
-        );
+        const jsSrcPath = fs.existsSync(`./src/client/sw/${publicClientId}.sw.js`)
+          ? `./src/client/sw/${publicClientId}.sw.js`
+          : `./src/client/sw/default.sw.js`;
 
-        // ssr pages
-        for (const page of await fs.readdir('./src/client/ssr/pages')) {
-          await buildJsSrcPage(`./src/client/ssr/pages/${page}`, `${rootClientPath}/${page}`);
+        const jsPublicPath = `${rootClientPath}/sw.js`;
 
-          const htmlSrc = Render({
-            title: metadata?.title ? metadata.title : cap(client),
-            ssrPath: '/',
-            ssrHeadComponents: '',
-            ssrBodyComponents: '',
-            baseSsrLib: jsSsrCommonComponents + fs.readFileSync(`${rootClientPath}/${page}`, 'utf8'),
-          });
+        if (!(enableLiveRebuild && !options.liveClientBuildPaths.find((p) => p.srcBuildPath === jsSrcPath))) {
+          const jsSrc = viewFormatted(await srcFormatted(fs.readFileSync(jsSrcPath, 'utf8')), dists, path, baseHost);
 
           fs.writeFileSync(
-            `${rootClientPath}/${page.slice(0, -3)}.html`,
-            minifyBuild || process.env.NODE_ENV === 'production'
-              ? await minify(htmlSrc, {
-                  minifyCSS: true,
-                  minifyJS: true,
-                  collapseBooleanAttributes: true,
-                  collapseInlineTagWhitespace: true,
-                  collapseWhitespace: true,
-                })
-              : htmlSrc,
+            jsPublicPath,
+            minifyBuild || process.env.NODE_ENV === 'production' ? UglifyJS.minify(jsSrc).code : jsSrc,
             'utf8',
           );
         }
@@ -404,7 +367,6 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
             const canonicalURL = `https://${host}${path}${
               view.path === '/' ? (path === '/' ? '' : '/') : path === '/' ? `${view.path.slice(1)}/` : `${view.path}/`
             }`;
-            const ssrPath = path === '/' ? path : `${path}/`;
 
             let ssrHeadComponents = ``;
             let ssrBodyComponents = ``;
@@ -414,10 +376,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                 confSSR[view.ssr].head.unshift('Production');
 
               for (const ssrHeadComponent of confSSR[view.ssr].head) {
-                const SrrComponent = await ssrFactory(
-                  `./src/client/ssr/components/head/${ssrHeadComponent}.js`,
-                  jsSsrCommonComponents,
-                );
+                const SrrComponent = await ssrFactory(`./src/client/ssr/head/${ssrHeadComponent}.js`);
 
                 switch (ssrHeadComponent) {
                   case 'Pwa':
@@ -498,10 +457,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
               }
 
               for (const ssrBodyComponent of confSSR[view.ssr].body) {
-                const SrrComponent = await ssrFactory(
-                  `./src/client/ssr/components/body/${ssrBodyComponent}.js`,
-                  jsSsrCommonComponents,
-                );
+                const SrrComponent = await ssrFactory(`./src/client/ssr/body/${ssrBodyComponent}.js`);
                 switch (ssrBodyComponent) {
                   case 'UnderpostDefaultSplashScreen':
                   case 'CyberiaDefaultSplashScreen':
@@ -544,14 +500,6 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                 }
               }
             }
-            const htmlSrc = Render({
-              title,
-              buildId,
-              ssrPath,
-              ssrHeadComponents,
-              ssrBodyComponents,
-              baseSsrLib: jsSsrCommonComponents,
-            });
 
             /** @type {import('sitemap').SitemapItem} */
             const siteMapLink = {
@@ -561,6 +509,14 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
             };
             siteMapLinks.push(siteMapLink);
 
+            const htmlSrc = Render({
+              title,
+              buildId,
+              ssrPath,
+              ssrHeadComponents,
+              ssrBodyComponents,
+            });
+
             fs.writeFileSync(
               `${buildPath}index.html`,
               minifyBuild || process.env.NODE_ENV === 'production'
@@ -766,6 +722,76 @@ root file where the route starts, such as index.js, app.js, routes.js, etc ... *
 
         zip.writeZip(`./build/${buildId}.zip`);
       }
+      if (client) {
+        let PRE_CACHED_RESOURCES = [];
+
+        if (views && offlineBuild && fs.existsSync(`${rootClientPath}/sw.js`)) {
+          PRE_CACHED_RESOURCES = await fs.readdir(rootClientPath, { recursive: true });
+          PRE_CACHED_RESOURCES = views
+            .map((view) => `${path === '/' ? '' : path}${view.path}`)
+            .concat(
+              PRE_CACHED_RESOURCES.map((p) => `/${p}`).filter(
+                (p) => p[1] !== '.' && !fs.statSync(`${rootClientPath}${p}`).isDirectory(),
+              ),
+            );
+        }
+
+        for (const pageType of ['offline', 'pages']) {
+          if (confSSR[getCapVariableName(client)] && confSSR[getCapVariableName(client)][pageType]) {
+            for (const page of confSSR[getCapVariableName(client)][pageType]) {
+              const SsrComponent = await ssrFactory(`./src/client/ssr/${pageType}/${page.client}.js`);
+
+              const htmlSrc = Render({
+                title: page.title,
+                ssrPath,
+                ssrHeadComponents: '',
+                ssrBodyComponents: SsrComponent(),
+              });
+
+              const buildPath = `${
+                rootClientPath[rootClientPath.length - 1] === '/' ? rootClientPath.slice(0, -1) : rootClientPath
+              }${page.path === '/' ? page.path : `${page.path}/`}`;
+
+              PRE_CACHED_RESOURCES.push(`${path === '/' ? '' : path}${page.path === '/' ? '' : page.path}/index.html`);
+
+              if (!fs.existsSync(buildPath)) fs.mkdirSync(buildPath, { recursive: true });
+
+              const buildHtmlPath = `${buildPath}index.html`;
+
+              logger.info('ssr page build', buildHtmlPath);
+
+              fs.writeFileSync(
+                buildHtmlPath,
+                minifyBuild || process.env.NODE_ENV === 'production'
+                  ? await minify(htmlSrc, {
+                      minifyCSS: true,
+                      minifyJS: true,
+                      collapseBooleanAttributes: true,
+                      collapseInlineTagWhitespace: true,
+                      collapseWhitespace: true,
+                    })
+                  : htmlSrc,
+                'utf8',
+              );
+            }
+          }
+        }
+
+        {
+          const PRE_CACHED_JSON = `PRE_CACHED_RESOURCES = ${JSONweb(uniqueArray(PRE_CACHED_RESOURCES))}`;
+          const PROXY_PATH = `PROXY_PATH = '${path}'`;
+          fs.writeFileSync(
+            `${rootClientPath}/sw.js`,
+            fs
+              .readFileSync(`${rootClientPath}/sw.js`, 'utf8')
+              .replaceAll(`PRE_CACHED_RESOURCES = []`, PRE_CACHED_JSON)
+              .replaceAll(`PRE_CACHED_RESOURCES=[]`, PRE_CACHED_JSON)
+              .replaceAll(`PROXY_PATH = '/'`, PROXY_PATH)
+              .replaceAll(`PROXY_PATH='/'`, PROXY_PATH),
+            'utf8',
+          );
+        }
+      }
     }
   }
 };

package/src/server/client-formatted.js

@@ -47,11 +47,9 @@ const viewFormatted = (src, dists, proxyPath, baseHost = '') => {
   return src.replaceAll(`from './`, componentFromFormatted).replaceAll(`from '../`, componentFromFormatted);
 };
 
-const ssrFactory = async (componentPath = '', jsSsrCommonComponents) => {
+const ssrFactory = async (componentPath = `./src/client/ssr/Render.js`) => {
   let SrrComponent = () => {};
-  let render = await srcFormatted(fs.readFileSync(componentPath, 'utf8'));
-  if (render.split('/*imports*/')[1]) render = render.split('/*imports*/')[1];
-  eval(jsSsrCommonComponents + render);
+  eval(await srcFormatted(fs.readFileSync(componentPath, 'utf8')));
   return SrrComponent;
 };
 

package/src/server/conf.js

@@ -1,19 +1,20 @@
 import fs from 'fs-extra';
 import dotenv from 'dotenv';
-import { cap, capFirst, getCapVariableName, newInstance, range, timer } from '../client/components/core/CommonJs.js';
+import { capFirst, getCapVariableName, newInstance, range, timer } from '../client/components/core/CommonJs.js';
 import * as dir from 'path';
 import cliProgress from 'cli-progress';
 import cliSpinners from 'cli-spinners';
 import logUpdate from 'log-update';
 import colors from 'colors';
 import { loggerFactory } from './logger.js';
-import { shellExec, shellCd, getRootDirectory } from './process.js';
+import { shellExec } from './process.js';
 import { DefaultConf } from '../../conf.js';
 import ncp from 'copy-paste';
 import read from 'read';
 import splitFile from 'split-file';
 import axios from 'axios';
 import https from 'https';
+import { ssrFactory } from './client-formatted.js';
 
 // axios.defaults.baseURL = BASE_URL;
 
@@ -466,6 +467,16 @@ const buildProxyRouter = () => {
       }
     }
   }
+  if (process.argv.includes('maintenance'))
+    (async () => {
+      globalThis.defaultHtmlSrcMaintenance = (await ssrFactory())({
+        title: 'Site in maintenance',
+        ssrPath: '/',
+        ssrHeadComponents: '',
+        ssrBodyComponents: (await ssrFactory(`./src/client/ssr/body/Maintenance.js`))(),
+      });
+    })();
+
   return proxyRouter;
 };
 
@@ -596,14 +607,32 @@ const validateTemplatePath = (absolutePath = '') => {
     return false;
   }
   if (
-    absolutePath.match('src/client/ssr/components/body') &&
-    !confSsr.body.find((p) => absolutePath.match(`src/client/ssr/components/body/${p}.js`))
+    absolutePath.match('src/client/ssr/body') &&
+    !confSsr.body.find((p) => absolutePath.match(`src/client/ssr/body/${p}.js`))
+  ) {
+    return false;
+  }
+  if (
+    absolutePath.match('src/client/ssr/head') &&
+    !confSsr.head.find((p) => absolutePath.match(`src/client/ssr/head/${p}.js`))
+  ) {
+    return false;
+  }
+  if (
+    absolutePath.match('src/client/ssr/mailer') &&
+    !Object.keys(confSsr.mailer).find((p) => absolutePath.match(`src/client/ssr/mailer/${confSsr.mailer[p]}.js`))
+  ) {
+    return false;
+  }
+  if (
+    absolutePath.match('src/client/ssr/offline') &&
+    !confSsr.offline.find((p) => absolutePath.match(`src/client/ssr/offline/${p.client}.js`))
   ) {
     return false;
   }
   if (
-    absolutePath.match('src/client/ssr/components/head') &&
-    !confSsr.head.find((p) => absolutePath.match(`src/client/ssr/components/head/${p}.js`))
+    absolutePath.match('src/client/ssr/pages') &&
+    !confSsr.pages.find((p) => absolutePath.match(`src/client/ssr/pages/${p.client}.js`))
   ) {
     return false;
   }
@@ -891,13 +920,12 @@ const fixDependencies = async () => {
   );
 };
 
-const maintenancePath = `${getRootDirectory()}/public/${process.env.DEFAULT_DEPLOY_HOST}${
-  process.env.DEFAULT_DEPLOY_PATH
-}/maintenance.html`;
-
 const maintenanceMiddleware = (req, res, port, proxyRouter) => {
-  if (process.argv.includes('maintenance') && fs.existsSync(maintenancePath)) {
-    if (req.method.toUpperCase() === 'GET') return res.status(503).sendFile(maintenancePath);
+  if (process.argv.includes('maintenance') && globalThis.defaultHtmlSrcMaintenance) {
+    if (req.method.toUpperCase() === 'GET') {
+      res.set('Content-Type', 'text/html');
+      return res.status(503).send(globalThis.defaultHtmlSrcMaintenance);
+    }
     return res.status(503).json({
       status: 'error',
       message: 'Server is under maintenance',
@@ -941,7 +969,6 @@ export {
   mergeBackUp,
   fixDependencies,
   getDeployId,
-  maintenancePath,
   maintenanceMiddleware,
   setUpProxyMaintenanceServer,
 };

package/src/server/proxy.js

@@ -1,7 +1,6 @@
 'use strict';
 
 import express from 'express';
-import fs from 'fs-extra';
 import dotenv from 'dotenv';
 
 import { createProxyMiddleware } from 'http-proxy-middleware';
@@ -10,7 +9,6 @@ import { listenPortController, network } from './network.js';
 import { orderArrayFromAttrInt } from '../client/components/core/CommonJs.js';
 import { createSslServer, sslRedirectMiddleware } from './ssl.js';
 import { buildProxyRouter, maintenanceMiddleware } from './conf.js';
-import { getRootDirectory } from './process.js';
 
 dotenv.config();