lupine.api 1.1.50 → 1.1.52

package/admin/admin-release.tsx

@@ -284,7 +284,7 @@ export const AdminReleasePage = () => {
       isLocal,
     });
     const dataResponse = await response.json;
-    console.log('AdminRelease', dataResponse);
+    console.log('refresh-cache', dataResponse);
     if (!dataResponse || dataResponse.status !== 'ok') {
       NotificationMessage.sendMessage(dataResponse.message || 'Failed to refresh cache', NotificationColor.Error);
       return;
@@ -293,6 +293,35 @@ export const AdminReleasePage = () => {
     NotificationMessage.sendMessage('Cache refreshed successfully', NotificationColor.Success);
   };
 
+  const onRestartAppLocal = async () => {
+    return onRestartApp(true);
+  };
+  const onRestartAppRemote = async () => {
+    return onRestartApp(false);
+  };
+  const onRestartApp = async (isLocal?: boolean) => {
+    const data = getDomData();
+    if (!isLocal) {
+      if (!data.targetUrl || !data.accessToken) {
+        NotificationMessage.sendMessage('Please fill in all fields', NotificationColor.Error);
+        return;
+      }
+    }
+
+    const response = await getRenderPageProps().renderPageFunctions.fetchData('/api/admin/release/restart-app', {
+      ...data,
+      isLocal,
+    });
+    const dataResponse = await response.json;
+    console.log('restart-app', dataResponse);
+    if (!dataResponse || dataResponse.status !== 'ok') {
+      NotificationMessage.sendMessage(dataResponse.message || 'Failed to Restart App', NotificationColor.Error);
+      return;
+    }
+    domLog.value = <pre>{JSON.stringify(dataResponse, null, 2)}</pre>;
+    NotificationMessage.sendMessage('Restart App successfully', NotificationColor.Success);
+  };
+
   const ref: RefProps = {
     onLoad: async () => {
       const data = JSON.parse(localStorage.getItem('admin-release') || '{}');
@@ -321,9 +350,15 @@ export const AdminReleasePage = () => {
         <button onClick={onRefreshCacheRemote} class='button-base mr-m'>
           Refresh Cache (Remote)
         </button>
-        <button onClick={onRefreshCacheLocal} class='button-base'>
+        <button onClick={onRestartAppRemote} class='button-base mr-m color-red'>
+          Restart App (Remote)
+        </button>
+        <button onClick={onRefreshCacheLocal} class='button-base mr-m'>
           Refresh Cache (Local)
         </button>
+        <button onClick={onRestartAppLocal} class='button-base color-red'>
+          Restart App (Local)
+        </button>
       </div>
       {domUpdate.node}
       {domLog.node}

package/dev/cp-index-html.js

@@ -37,7 +37,7 @@ exports.cpIndexHtml = async (htmlFile, outputFile, appName, isMobile, defaultThe
   // if isMobile=true, then the last number is 1, or if isMobile=false, the last is 2
   const chgTime = Math.trunc(f1.mtime.getTime() / 10) * 10 + (isMobile ? 1 : 2);
 
-  // when it's isMobile, need to update env and configs
+  // when it's isMobile, need to update env and configs => no configs as mobile app fetches it from api
   if (!f2 || f2.mtime.getTime() !== chgTime || isMobile) {
     const inHtml = await fs.readFile(htmlFile, 'utf-8');
     let outStr = inHtml.replace(/{hash}/gi, new Date().getTime().toString(36));
@@ -48,7 +48,7 @@ exports.cpIndexHtml = async (htmlFile, outputFile, appName, isMobile, defaultThe
       const metaIndexStart = inHtml.indexOf(metaTextStart);
       const metaIndexEnd = inHtml.indexOf(metaTextEnd);
 
-      const webConfig = await readWebConfig(outdirData);
+      // const webConfig = await readWebConfig(outdirData);
       const webEnvData = webEnv.getWebEnv(appName);
 
       outStr =
@@ -56,9 +56,9 @@ exports.cpIndexHtml = async (htmlFile, outputFile, appName, isMobile, defaultThe
         '<script id="web-env" type="application/json">' +
         JSON.stringify(webEnvData) +
         '</script>\r\n' +
-        '<script id="web-setting" type="application/json">' +
-        JSON.stringify(webConfig) +
-        '</script>' +
+        // '<script id="web-setting" type="application/json">' +
+        // JSON.stringify(webConfig) +
+        // '</script>' +
         outStr.substring(metaIndexEnd + metaTextEnd.length);
       // outStr = webEnv.replaceWebEnv(inHtml, appName, true);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lupine.api",
-  "version": "1.1.50",
+  "version": "1.1.52",
   "license": "MIT",
   "author": "uuware.com",
   "homepage": "https://github.com/uuware/lupine.js",

package/src/admin-api/admin-api.ts

@@ -11,6 +11,7 @@ import { AdminConfig } from './admin-config';
 import { Logger } from '../lib';
 import { IApiBase, ServerRequest } from '../models';
 import { ApiRouter } from '../api';
+import { readWebConfig } from './web-config-api';
 
 const logger = new Logger('admin-api');
 
@@ -27,6 +28,8 @@ export class AdminApi implements IApiBase {
   }
 
   protected mountDashboard() {
+    this.router.use('/web-config', readWebConfig);
+
     const adminDb = new AdminDb();
     this.router.use('/db', needDevAdminSession, adminDb.getRouter());
 

package/src/admin-api/admin-auth.ts

@@ -10,6 +10,11 @@ export const needDevAdminSession = async (req: ServerRequest, res: ServerRespons
   const devAdminSession = await adminApiHelper.getDevAdminFromCookie(req, res, true);
   if (!devAdminSession) {
     // return true to skip the rest of the middleware
+    const response = {
+      status: 'error',
+      message: langHelper.getLang('shared:permission_denied'),
+    };
+    ApiHelper.sendJson(req, res, response);
     return true;
   }
   return false;
@@ -64,14 +69,15 @@ export const devAdminAuth = async (req: ServerRequest, res: ServerResponse) => {
       ApiHelper.sendJson(req, res, response);
       return true;
     }
-    // if it's dev admin, then set app admin cookie as well
-    let addLoginResponse = {};
-    const appAdminHookSetCookie = adminApiHelper.getAppAdminHookSetCookie();
-    if (appAdminHookSetCookie) {
-      addLoginResponse = await appAdminHookSetCookie(req, res, devAdminSession.u);
-    }
+    // on set app cookie when login, not every time
+    // // if it's dev admin, then set app admin cookie as well
+    // let addLoginResponse = {};
+    // const appAdminHookSetCookie = adminApiHelper.getAppAdminHookSetCookie();
+    // if (appAdminHookSetCookie) {
+    //   addLoginResponse = await appAdminHookSetCookie(req, res, devAdminSession.u);
+    // }
     const response = {
-      ...addLoginResponse,
+      // ...addLoginResponse,
       status: 'ok',
       message: langHelper.getLang('shared:login_success'),
       devLogin: CryptoUtils.encrypt(JSON.stringify(devAdminSession), cryptoKey),
@@ -104,13 +110,13 @@ export const devAdminAuth = async (req: ServerRequest, res: ServerResponse) => {
       message: langHelper.getLang('shared:login_success'),
       devLogin: tokenCookie,
     };
-    req.locals.setCookie('_token', tokenCookie, {
-      expireDays: 360,
-      path: '/',
-      httpOnly: false,
-      secure: true,
-      sameSite: 'none',
-    });
+    // req.locals.setCookie('_token', tokenCookie, {
+    //   expireDays: 360,
+    //   path: '/',
+    //   httpOnly: false,
+    //   secure: true,
+    //   sameSite: 'none',
+    // });
     ApiHelper.sendJson(req, res, response);
     return true;
   }

package/src/admin-api/admin-release.ts

@@ -11,6 +11,7 @@ import {
   adminApiHelper,
   processRefreshCache,
   apiStorage,
+  processRestartApp,
 } from 'lupine.api';
 import path from 'path';
 import { needDevAdminSession } from './admin-auth';
@@ -32,15 +33,17 @@ export class AdminRelease implements IApiBase {
   protected mountDashboard() {
     // called by FE
     this.router.use('/check', needDevAdminSession, this.check.bind(this));
-    this.router.use('/update', needDevAdminSession, this.update.bind(this));
+    this.router.use('/update', needDevAdminSession, this.callUpdate.bind(this));
     this.router.use('/view-log', needDevAdminSession, this.viewLog.bind(this));
     // called online or by clients
     this.router.use('/refresh-cache', needDevAdminSession, this.refreshCache.bind(this));
+    this.router.use('/restart-app', needDevAdminSession, this.restartApp.bind(this));
 
     // ...ByClient will verify credentials from post, so it doesn't need AdminSession
     this.router.use('/byClientCheck', this.byClientCheck.bind(this));
     this.router.use('/byClientUpdate', this.byClientUpdate.bind(this));
     this.router.use('/byClientRefreshCache', this.byClientRefreshCache.bind(this));
+    this.router.use('/byClientRestartApp', this.byClientRestartApp.bind(this));
     this.router.use('/byClientViewLog', this.byClientViewLog.bind(this));
   }
 
@@ -126,6 +129,47 @@ export class AdminRelease implements IApiBase {
     return true;
   }
 
+  async restartApp(req: ServerRequest, res: ServerResponse) {
+    // check whether it's from online admin
+    const json = await adminApiHelper.getDevAdminFromCookie(req, res, false);
+    const jsonData = req.locals.json();
+    if (json && jsonData && !Array.isArray(jsonData) && jsonData.isLocal) {
+      await processRestartApp(req);
+      const response = {
+        status: 'ok',
+        message: 'Restart app successfully.',
+      };
+      ApiHelper.sendJson(req, res, response);
+      return true;
+    }
+
+    const data = await this.chkData(jsonData, req, res, true);
+    if (!data) return true;
+
+    let targetUrl = data.targetUrl as string;
+    if (targetUrl.endsWith('/')) {
+      targetUrl = targetUrl.slice(0, -1);
+    }
+    const remoteData = await fetch(targetUrl + '/api/admin/release/byClientRestartApp', {
+      method: 'POST',
+      body: JSON.stringify(data),
+    });
+    const resultText = await remoteData.text();
+    let remoteResult: any;
+    try {
+      remoteResult = JSON.parse(resultText);
+    } catch (e: any) {
+      remoteResult = { status: 'error', message: resultText };
+    }
+    const response = {
+      status: 'ok',
+      message: 'check.',
+      ...remoteResult,
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
   public async chkData(data: any, req: ServerRequest, res: ServerResponse, chkCredential: boolean) {
     // add access token
     if (!data || Array.isArray(data) || typeof data !== 'object' || !data.accessToken || !data.targetUrl) {
@@ -569,4 +613,18 @@ export class AdminRelease implements IApiBase {
     ApiHelper.sendJson(req, res, response);
     return true;
   }
+
+  async byClientRestartApp(req: ServerRequest, res: ServerResponse) {
+    const jsonData = req.locals.json();
+    const data = await this.chkData(jsonData, req, res, true);
+    if (!data) return true;
+
+    await processRestartApp(req);
+    const response = {
+      status: 'ok',
+      message: 'Restart app successfully.',
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
 }

package/src/admin-api/web-config-api.ts

@@ -0,0 +1,19 @@
+import { ServerResponse } from 'http';
+import { Logger } from '../lib';
+import { ServerRequest } from '../models';
+import { langHelper } from '../lang';
+import { ApiHelper, apiStorage } from '../api';
+
+// only used by mobile app. For web, it's injected in the html by server-side render
+const logger = new Logger('web-cfg-api');
+export const readWebConfig = async (req: ServerRequest, res: ServerResponse) => {
+  logger.info('readWebConfig');
+
+  const response = {
+    status: 'ok',
+    result: await apiStorage.getWebAll(),
+    message: langHelper.getLang('shared:operation_success'),
+  };
+  ApiHelper.sendJson(req, res, response);
+  return true;
+};

package/src/api/server-render.ts

@@ -9,7 +9,6 @@ import { IToClientDelivery } from '../models/to-client-delivery-props';
 import { JsonObject } from '../models/json-object';
 import { getTemplateCache } from './api-cache';
 import { apiStorage } from './api-shared-storage';
-import { SimpleStorageDataProps } from '../models';
 import { RuntimeRequire } from '../lib/runtime-require';
 
 const logger = new Logger('StaticServer');
@@ -159,13 +158,13 @@ export const serverSideRenderPage = async (
   const _lupineJs = cachedHtml[nearRoot]._lupineJs;
   const currentCache = cachedHtml[nearRoot] as CachedHtmlProps;
   const webSetting = await apiStorage.getWebAll();
-  const webSettingShortKey: SimpleStorageDataProps = {};
-  for (let item of Object.keys(webSetting)) {
-    const newItem = item.substring(4);
-    webSettingShortKey[newItem] = webSetting[item];
-  }
+  // const webSettingShortKey: SimpleStorageDataProps = {};
+  // for (let item of Object.keys(webSetting)) {
+  //   const newItem = item.substring(4);
+  //   webSettingShortKey[newItem] = webSetting[item];
+  // }
   // const webSetting = AppConfig.get(AppConfig.WEB_SETTINGS_KEY) || {};
-  const clientDelivery = new ToClientDelivery(currentCache.webEnv, webSettingShortKey, req.locals.cookies());
+  const clientDelivery = new ToClientDelivery(currentCache.webEnv, webSetting, req.locals.cookies());
   const page = await _lupineJs.generatePage(props, clientDelivery);
   // console.log(`=========load lupin: `, content);
 
@@ -199,7 +198,7 @@ export const serverSideRenderPage = async (
   res.write(page.metaData);
   res.write(page.globalCss);
   res.write('<script id="web-env" type="application/json">' + JSON.stringify(currentCache.webEnv) + '</script>');
-  res.write('<script id="web-setting" type="application/json">' + JSON.stringify(webSettingShortKey) + '</script>');
+  res.write('<script id="web-setting" type="application/json">' + JSON.stringify(webSetting) + '</script>');
   res.write(
     currentCache.content.substring(
       currentCache.metaIndexEnd + metaTextEnd.length,

package/src/app/app-message.ts

@@ -2,6 +2,7 @@ import cluster from 'cluster';
 import { Logger, LogWriter, LogWriterMessageId } from '../lib';
 import { processDebugMessage } from './process-dev-requests';
 import { cleanupAndExit } from './cleanup-exit';
+import { restartApp } from './app-restart';
 
 export type AppMessageProps = {
   id: string;
@@ -78,15 +79,22 @@ export const processMessageFromWorker = (msgObject: AppMessageProps) => {
     logger.debug(
       `Message from worker ${cluster.worker?.id}, message: ${msgObject.message}, appName: ${msgObject.appName}`
     );
-    broadcast(msgObject);
-    // if it's suspend, the primary process will exit
-    if (msgObject.message === 'suspend') {
-      setTimeout(() => {
-        console.log(`[server primary] Received suspend command.`, cluster.workers);
-        cleanupAndExit();
+    if (msgObject.message === 'restartApp') {
+      restartApp();
+      return;
+    } else if (msgObject.message === 'refresh') {
+      broadcast(msgObject);
+    } else if (msgObject.message === 'shutdown') {
+      broadcast(msgObject);
+      // if it's shutdown, the primary process will exit
+      setTimeout(async () => {
+        console.log(`[server primary] Received shutdown command.`, cluster.workers);
+        await cleanupAndExit();
       }, 100);
+    } else {
+      logger.warn(`Unknown message: ${msgObject.id}`);
     }
   } else {
-    logger.warn(`Unknown message: ${msgObject.id}`);
+    logger.warn(`Unknown message id: ${msgObject.id}`);
   }
 };

package/src/app/app-restart.ts

@@ -0,0 +1,54 @@
+import cluster from 'cluster';
+import { spawn } from 'child_process';
+import { appStorage } from './app-shared-storage';
+import { AppMessageProps, processMessageFromWorker } from './app-message';
+
+export const _restartApp = {
+  isRestarting: false,
+};
+export const restartApp = async () => {
+  if (!cluster.isPrimary) {
+    console.warn(`restartApp: shouldn't come here`);
+    return;
+  }
+
+  await appStorage.save('', true);
+  console.log(`Old app ${process.pid} sends SIGTERM to all workors.`);
+  // const closeAll = () => {
+  //   _restartApp.isRestarting = true;
+
+  //   return Object.values(cluster.workers!).map(
+  //     (w) =>
+  //       new Promise((resolve) => {
+  //         console.log(`Sending SIGTERM to workor ${w!.id}.`);
+  //         w!.once('exit', resolve);
+  //         w!.kill('SIGTERM');
+  //       })
+  //   );
+  // };
+  // await Promise.all(closeAll());
+
+  console.log(`Old app ${process.pid} starts new app ${process.execPath}`, process.argv);
+  // spawn(process.execPath, process.argv.slice(1), {
+  //   stdio: 'inherit',
+  //   env: { ...process.env, RESTARTING: '1' },
+  // });
+
+  console.log(`Old app ${process.pid} exists.`);
+  // setTimeout(process.exit, 3000);
+  if (!process.send) {
+    console.log(`The primary process is not focked from loader, so cannot restart.`);
+  } else {
+    process.send({ id: 'debug', message: 'restartApp' });
+  }
+};
+
+// this is primary, and receive messages from loader
+export const receiveMessageFromLoader = () => {
+  process.on('message', async (msg: AppMessageProps) => {
+    if (msg?.id === 'debug' && msg?.message === 'shutdown') {
+      console.log(`App ${process.pid}: received shutdown message from loader.`);
+      processMessageFromWorker(msg);
+    }
+  });
+};

package/src/app/app-shared-storage.ts

@@ -1,6 +1,6 @@
 /**
  * A persistent storage to store data in primary process and share to all workers
- * 
+ *
  * You should use apiStorage in api module
  */
 import * as fs from 'fs/promises';
@@ -141,9 +141,9 @@ export class AppSharedStorage implements IAppSharedStorage {
   }
 
   // called from primary before exit, or from api to save changes
-  async save(appName?: string) {
+  async save(appName?: string, exit?: boolean) {
     if (!cluster.isPrimary) {
-      AppSharedStorageWorker.save(appName);
+      await AppSharedStorageWorker.save(appName);
       return;
     }
 
@@ -183,8 +183,16 @@ export class AppSharedStorage implements IAppSharedStorage {
   getApi(appName: string, key: string): Promise<string> {
     return this.get(appName, AppSharedStorageApiPrefix + key);
   }
-  getWebAll(appName: string): Promise<SimpleStorageDataProps> {
-    return this.getWithPrefix(appName, AppSharedStorageWebPrefix);
+  async getWebAll(appName: string): Promise<SimpleStorageDataProps> {
+    const webAll = await this.getWithPrefix(appName, AppSharedStorageWebPrefix);
+
+    const webSettingShortKey: SimpleStorageDataProps = {};
+    for (let item of Object.keys(webAll)) {
+      const newItem = item.substring(AppSharedStorageWebPrefix.length);
+      webSettingShortKey[newItem] = webAll[item];
+    }
+
+    return webSettingShortKey;
   }
   getWithPrefix(appName: string, prefixKey: string): Promise<SimpleStorageDataProps> {
     return new Promise((resolve, reject) => {
@@ -267,7 +275,7 @@ class AppSharedStorageWorker {
       workerId: cluster.worker?.id || 0,
       action: 'save',
       appName: appName || '',
-      key: '',
+      key: 'save',
     };
     process.send!(obj);
   }

package/src/app/app-start.ts

@@ -9,6 +9,7 @@ import { AppStartProps, InitStartProps, AppCacheGlobal, AppCacheKeys } from '../
 import { appStorage } from './app-shared-storage';
 import { HostToPath } from './host-to-path';
 import { cleanupAndExit } from './cleanup-exit';
+import { _restartApp, receiveMessageFromLoader } from './app-restart';
 
 // Don't use logger before set process message
 class AppStart {
@@ -16,10 +17,16 @@ class AppStart {
   webServer: WebServer | undefined;
 
   getWorkerId() {
-    return cluster.worker ? cluster.worker.id : 0;
+    return cluster.worker ? cluster.worker.id : -1;
   }
 
   async start(props: AppStartProps, webServer?: WebServer) {
+    // if it's started from spawn, wait for old master to clear ports
+    if (cluster.isPrimary && process.env.RESTARTING === '1') {
+      console.log(`New app ${process.pid} RESTARTING.`);
+      await new Promise((r) => setTimeout(r, 100));
+    }
+
     this.debug = props.debug;
     this.bindProcess();
 
@@ -58,14 +65,20 @@ class AppStart {
       const numCPUs = props.debug ? 1 : require('os').cpus().length;
       console.log(`Master Process is trying to fork ${numCPUs} processes`);
 
+      receiveMessageFromLoader();
+
       for (let i = 0; i < numCPUs; i++) {
         let worker = cluster.fork();
         worker.on('message', processMessageFromWorker);
       }
 
       cluster.on('death', (worker: any) => {
-        console.log(`Worker ${worker.pid} died; starting a new one...`);
-        cluster.fork();
+        if (!_restartApp.isRestarting) {
+          console.log(`Worker ${worker.pid} died; starting a new one...`);
+          cluster.fork();
+        } else {
+          console.log(`Worker ${worker.pid} exited during restart`);
+        }
       });
     }
   }
@@ -82,7 +95,7 @@ class AppStart {
 
     // do something when app is closing
     process.on('beforeExit', async () => {
-      cleanupAndExit();
+      await cleanupAndExit();
     });
     process.on('exit', (ret) => {
       console.log(`${process.pid} - Process on exit, code: ${ret}`);
@@ -103,14 +116,21 @@ class AppStart {
     const sslKeyPath = config.sslKeyPath || '';
     const sslCrtPath = config.sslCrtPath || '';
 
-    console.log(`Starting Web Server, httpPort: ${httpPort}, httpsPort: ${httpsPort}`);
+    console.log(`${process.pid} - Starting Web Server, httpPort: ${httpPort}, httpsPort: ${httpsPort}`);
     // for dev to refresh the FE or stop the server
     if (this.debug) {
       WebProcessor.enableDebug('/debug', processDevRequests);
     }
 
-    httpPort && this.webServer!.startHttp(httpPort, bindIp);
-    httpsPort && this.webServer!.startHttps(httpsPort, bindIp, sslKeyPath, sslCrtPath);
+    const httpServer = httpPort && this.webServer!.startHttp(httpPort, bindIp);
+    const heepsServer = httpsPort && this.webServer!.startHttps(httpsPort, bindIp, sslKeyPath, sslCrtPath);
+
+    process.on("SIGTERM", () => {
+      console.log(`${process.pid} - Worker closing servers...`);
+      httpServer && httpServer.close();
+      heepsServer && heepsServer.close();
+    });
+
   }
 }
 

package/src/app/cleanup-exit.ts

@@ -6,7 +6,7 @@ export const cleanupAndExit = async () => {
   // save shared storage first
   if (cluster.isPrimary) {
     // save only happens once
-    await appStorage.save();
+    await appStorage.save('', true);
   }
   process.exit(0);
 };

package/src/app/process-dev-requests.ts

@@ -5,6 +5,7 @@ import { appLoader } from './app-loader';
 import { DebugService } from '../api/debug-service';
 import { AppCacheGlobal, AppCacheKeys, getAppCache, ServerRequest } from '../models';
 import { cleanupAndExit } from './cleanup-exit';
+import { restartApp } from './app-restart';
 const logger = new Logger('process-dev-requests');
 
 function deleteRequireCache(moduleName: string) {
@@ -42,10 +43,10 @@ export const processDebugMessage = async (msgObject: any) => {
     // this only works in debug mode (no clusters)
     DebugService.broadcastRefresh();
   }
-  if (msgObject.id === 'debug' && msgObject.message === 'suspend') {
-    // Only when it's debug mode, it can go here, otherwise suspend should be processed in processMessageFromWorker
-    console.log(`[server] Received suspend command.`);
-    cleanupAndExit();
+  if (msgObject.id === 'debug' && msgObject.message === 'shutdown') {
+    // Only when it's debug mode, it can go here, otherwise shutdown should be processed in processMessageFromWorker
+    console.log(`[server] Received shutdown command.`);
+    await cleanupAndExit();
   }
 };
 
@@ -63,6 +64,18 @@ export async function processRefreshCache(req: ServerRequest) {
   }
 }
 
+export async function processRestartApp(req: ServerRequest) {
+  // if this is a child process, we need to notice parent process to broadcast to all clients to refresh
+  if (process.send) {
+    // send message to Primary to handle it
+    process.send({ id: 'debug', message: 'restartApp' });
+  }
+  // in case if it's only one process (primary process)
+  else {
+    await restartApp();
+  }
+}
+
 // this is only for local development
 export async function processDevRequests(req: ServerRequest, res: ServerResponse, rootUrl?: string) {
   res.end();
@@ -71,15 +84,15 @@ export async function processDevRequests(req: ServerRequest, res: ServerResponse
     console.log(`[server] Ignore request from: `, req.url, address.address);
     return true;
   }
-  if (req.url === '/debug/suspend') {
-    console.log(`[server] Received suspend command.`);
+  if (req.url === '/debug/shutdown') {
+    console.log(`[server] Received shutdown command.`);
     if (process.send) {
       // send to parent process to kill all
-      process.send({ id: 'debug', message: 'suspend' });
+      process.send({ id: 'debug', message: 'shutdown' });
     }
     // if it's debug mode (only one process)
     else if (getAppCache().get(AppCacheGlobal, AppCacheKeys.APP_DEBUG) === true) {
-      await processDebugMessage({ id: 'debug', message: 'suspend' });
+      await processDebugMessage({ id: 'debug', message: 'shutdown' });
     }
   } else if (req.url === '/debug/refresh') {
     await processRefreshCache(req);

package/src/app/web-server.ts

@@ -8,6 +8,7 @@ import { IncomingMessage, ServerResponse } from 'http';
 import { Duplex } from 'stream';
 import { WebProcessor } from './web-processor';
 import { DebugService } from '../api/debug-service';
+import cluster from 'cluster';
 const logger = new Logger('web-server');
 
 export class WebServer {
@@ -47,7 +48,7 @@ export class WebServer {
     httpServer.on('upgrade', this.handleUpgrade.bind(this));
 
     httpServer.listen(httpPort, bindIp, () => {
-      logger.info(`Http Server is started: http://localhost:${httpPort}`);
+      logger.info(`Http Server ${cluster.worker ? cluster.worker.id : -1} is started: http://localhost:${httpPort}`);
     });
     httpServer.on('error', (error: any) => {
       logger.error('Error occurred on http server', error);
@@ -88,11 +89,12 @@ export class WebServer {
       httpsServer.setTimeout(timeout);
     }
     httpsServer.listen(httpsPort, bindIp, () => {
-      logger.info(`Https Server is started: https://localhost:${httpsPort}`);
+      logger.info(`Https Server ${cluster.worker ? cluster.worker.id : -1} is started: https://localhost:${httpsPort}`);
     });
     httpsServer.on('error', (error: any) => {
       logger.error('Error occurred on https server', error);
     });
+
     return httpsServer;
   }
 }

package/src/lib/db/db.ts

@@ -2,7 +2,12 @@ import { Logger } from '../logger';
 import { DbConfig } from '../../models/db-config';
 
 // Instead, Boolean values are stored as integers 0 (false) and 1 (true).
+export type DbFieldExprssionProps = { exprssion: string; params?: (string | number)[] };
 export type DbFieldValue = { [key: string]: string | number };
+export type DbFieldExpression = { [key: string]: string | number | DbFieldExprssionProps };
+const isDbFieldExprssion = (value: any): value is DbFieldExprssionProps => {
+  return value && typeof value === 'object' && 'exprssion' in value;
+};
 
 const logger = new Logger('db');
 export class Db {
@@ -252,12 +257,28 @@ export class Db {
     return await this.execute(sql, params);
   }
 
-  public async updateObject(table: string, updateFieldValues: DbFieldValue, whereFieldValues: DbFieldValue) {
+  public async updateObject(table: string, updateFieldValues: DbFieldExpression, whereFieldValues: DbFieldValue) {
     table = this.replacePrefix(table);
     const fields = Object.keys(updateFieldValues);
-    let sql = 'UPDATE ' + table + ' SET ' + fields.map((item) => `${item}=?`).join(',');
-    const params = Object.values(updateFieldValues);
+    const setClauseParts: string[] = [];
+    const params: (string | number)[] = [];
+    // let sql = 'UPDATE ' + table + ' SET ' + fields.map((item) => `${item}=?`).join(',');
+    // const params = Object.values(updateFieldValues);
+    for (const field of fields) {
+      const value = updateFieldValues[field];
+
+      // expression
+      if (isDbFieldExprssion(value)) {
+        setClauseParts.push(`${field} = ${value.exprssion}`);
+        if (value.params) params.push(...value.params);
+      } else {
+        // static value
+        setClauseParts.push(`${field} = ?`);
+        params.push(value);
+      }
+    }
 
+    let sql = `UPDATE ${table} SET ${setClauseParts.join(', ')}`;
     if (whereFieldValues && Object.keys(whereFieldValues).length > 0) {
       sql +=
         ' WHERE ' +

package/src/models/app-shared-storage-props.ts

@@ -25,7 +25,7 @@ export interface IAppSharedStorage {
   // this is primary, msg is from a client
   messageFromSubProcess(msgObject: any): void;
   load(appName: string, rootPath: string): Promise<void>;
-  save(appName?: string): Promise<void>;
+  save(appName?: string, exit?: boolean): Promise<void>;
   get(appName: string, key: string): Promise<string>;
   getWeb(appName: string, key: string): Promise<string>;
   getApi(appName: string, key: string): Promise<string>;