lupine.api 1.0.41

package/dev/cp-index-html.js

@@ -0,0 +1,69 @@
+const path = require('path');
+const fs = require('fs/promises');
+const webEnv = require('../src/common-js/web-env.js');
+const fileUtils = require('./file-utils.js');
+
+const fileSizeAndTime = async (filename) => {
+  try {
+    var stats = await fs.stat(filename);
+    return { size: stats.size, mtime: stats.mtime };
+  } catch (e) {
+    return false;
+  }
+};
+const fileUpdateTime = async (filename, time) => {
+  fs.utimes(filename, time, time);
+};
+
+const readWebConfig = async (outdirData) => {
+  let tempPath = path.join(outdirData, 'config.json');
+  if (!(await fileUtils.pathExists(tempPath))) {
+    tempPath = path.join(outdirData, 'resources', 'config_default.json');
+  }
+
+  // file should exist
+  const data = await fs.readFile(tempPath, 'utf-8');
+  const json = JSON.parse(data || {});
+  return webEnv.getWebConfig(json);
+};
+
+const metaTextStart = '<!--META-ENV-START-->';
+const metaTextEnd = '<!--META-ENV-END-->';
+exports.cpIndexHtml = async (htmlFile, outputFile, appName, isMobile, defaultThemeName, outdirData) => {
+  const f1 = await fileSizeAndTime(htmlFile);
+  const f2 = await fileSizeAndTime(outputFile);
+
+  // once isMobile is changed, then index.html file needs to be rebuilt
+  // 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
+  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));
+    if (isMobile) {
+      // const outStr = inHtml.replace(/{hash}/gi, new Date().getTime().toString(36)).replace('\<\!--META-ENV--\>', JSON.stringify(envWeb));
+      // env is replaced here for the mobile app. And the env is replaced again for the web app at each startup
+
+      const metaIndexStart = inHtml.indexOf(metaTextStart);
+      const metaIndexEnd = inHtml.indexOf(metaTextEnd);
+
+      const webConfig = await readWebConfig(outdirData);
+      const webEnvData = webEnv.getWebEnv(appName);
+
+      outStr =
+        outStr.substring(0, metaIndexStart).replace('<!--META-THEME-->', defaultThemeName) +
+        '<script id="web-env" type="application/json">' +
+        JSON.stringify(webEnvData) +
+        '</script>\r\n' +
+        '<script id="web-setting" type="application/json">' +
+        JSON.stringify(webConfig) +
+        '</script>' +
+        outStr.substring(metaIndexEnd + metaTextEnd.length);
+      // outStr = webEnv.replaceWebEnv(inHtml, appName, true);
+    }
+    await fs.mkdir(path.dirname(outputFile), { recursive: true });
+    await fs.writeFile(outputFile, outStr);
+    await fileUpdateTime(outputFile, new Date(chgTime));
+  }
+};

package/dev/file-utils.js

@@ -0,0 +1,12 @@
+const fs = require('fs/promises');
+
+exports.readJson = async (filename) => {
+  return JSON.parse((await fs.readFile(filename)).toString());
+};
+
+exports.pathExists = async (path) => {
+  return await fs
+    .access(path)
+    .then(() => true)
+    .catch(() => false);
+};

package/dev/index.js

@@ -0,0 +1,19 @@
+const { copyFolder } = require('./copy-folder.js');
+const { cpIndexHtml } = require('./cp-index-html.js');
+const fileUtils = require('./file-utils.js');
+const webEnv = require('../src/common-js/web-env.js');
+const { runCmd } = require('./run-cmd.js');
+const { sendRequest } = require('./send-request.js');
+module.exports = {
+  copyFolder,
+  cpIndexHtml,
+  runCmd,
+  sendRequest,
+  readJson: fileUtils.readJson,
+  pathExists: fileUtils.pathExists,
+  parseEnv: webEnv.parseEnv,
+  loadEnv: webEnv.loadEnv,
+  getWebConfig: webEnv.getWebConfig,
+  pluginIfelse: require('./plugin-ifelse.js'),
+  genVersions: require('./plugin-gen-versions.js'),
+};

package/dev/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "lupine.api-dev",
+  "version": "1.0.0",
+  "private": true,
+  "description": "dev tools for lupine.api",
+  "main": "index.js",
+  "module": "index.js",
+  "umd:main": "index.js",
+  "source": "index.js",
+  "types": "index.js",
+  "license": "MIT"
+}

package/dev/plugin-gen-versions.js

@@ -0,0 +1,20 @@
+const fs = require('fs/promises');
+
+module.exports = (
+  packageDependencies,
+  outputFilename,
+) => {
+  return {
+    name: 'gen-versions',
+    setup(build) {
+      build.onStart(async () => {
+        const content = `export const LUPINE_WEB_VERSION = "${packageDependencies['lupine.web']}";
+export const LUPINE_COMPONENTS_VERSION = "${packageDependencies['lupine.components']}";
+export const LUPINE_API_VERSION = "${packageDependencies['lupine.api']}";
+`;
+        await fs.writeFile(outputFilename, content);
+        console.log(`Generated ${outputFilename}`);
+      });
+    },
+  };
+};

package/dev/plugin-ifelse.js

@@ -0,0 +1,155 @@
+const fs = require('fs/promises');
+const path = require('path');
+
+const _saved = {
+  vars: [],
+  baseDir: '',
+  exclude: [],
+};
+
+const LINE_FLAG = {
+  code: 0,
+  if: 1,
+  else: 2,
+  endif: 3,
+};
+
+const ifRegExp = /^\/\/\s*#if\s*(.*)$/;
+const elseifRegExp = /^\/\/\s*#elseif\s*(.*)$/;
+const elseRegExp = /^\/\/\s*#else\s*(.*)$/;
+const endifRegExp = /^\/\/\s*#endif$/;
+const ifdefRegExpMultiLine = new RegExp(`^${ifRegExp.source}`, 'gm');
+
+// if a variable is not defined, exception will be thrown
+// if a variable is '', 0, false, undefined, null, NaN, or any other value, it will be considered as false
+/*
+var vars = {
+    TEST1: '', // false
+    TEST2: '2',
+}
+evalExpression(vars, 'TEST1'); // false
+evalExpression(vars, 'TEST2'); // true
+try {
+    evalExpression(vars, 'TEST3'); // exception
+} catch {}
+evalExpression(vars, "TEST2===`2` && TEST2==='2'"); // true, can't use ["] in the exception
+evalExpression(vars, "TEST1 || TEST2"); // true
+
+TODO: define variables if it's not defined?
+function extractVariables(expression) {
+  // Match words that are not numbers or keywords
+  const variableRegex = /\b([a-zA-Z_][a-zA-Z0-9_]*)\b/g;
+  return [...new Set(expression.match(variableRegex) || [])];
+}
+*/
+const evalExpression = (vars, expression) => {
+  const variables = Object.freeze({ ...vars });
+  const fn = new Function(...Object.keys(variables), 'return eval("' + expression + '")');
+  const result = !!fn(...Object.values(variables));
+  console.log(`Expression [${expression}], result: ${result}`);
+  return result;
+};
+
+const processOneFile = async (vars, fpath) => {
+  let text = await fs.readFile(fpath, 'utf8');
+  if (!ifdefRegExpMultiLine.test(text)) {
+    return null;
+  }
+
+  let lines = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
+  let line = '';
+  let expression = '';
+  let keepLine = true;
+  let lineType = LINE_FLAG.code;
+  const saveLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    line = lines[i];
+
+    let matchIf = line.match(ifRegExp);
+    let matchElseIf = line.match(elseifRegExp);
+    if (matchIf) {
+      lineType = LINE_FLAG.if;
+      expression = matchIf[1].trim();
+    } else if (matchElseIf) {
+      lineType = LINE_FLAG.if;
+      expression = matchElseIf[1].trim();
+    } else if (line.match(elseRegExp)) {
+      lineType = LINE_FLAG.else;
+    } else if (line.match(endifRegExp)) {
+      lineType = LINE_FLAG.endif;
+    } else {
+      lineType = LINE_FLAG.code;
+    }
+
+    if (lineType === LINE_FLAG.if) {
+      keepLine = true;
+      const result = evalExpression(vars, expression);
+      if (!result) {
+        keepLine = false;
+      }
+    }
+    if (lineType === LINE_FLAG.else) {
+      console.log(`Expression else`);
+      keepLine = !keepLine;
+    }
+    if (lineType === LINE_FLAG.code) {
+      if (keepLine) {
+        saveLines.push(line);
+      }
+    }
+    if (lineType === LINE_FLAG.endif) {
+      keepLine = true;
+    }
+  }
+
+  text = saveLines.join('\n');
+  return text;
+};
+
+async function pluginOnLoad(args) {
+  let fPath = path.relative(_saved.baseDir, args.path);
+  let skip = false;
+
+  for (let filter of _saved.exclude) {
+    if (fPath.startsWith(filter)) {
+      skip = true;
+      break;
+    }
+  }
+
+  if (skip) {
+    return null;
+  }
+
+  const text = await processOneFile(_saved.vars, args.path);
+  if (text) {
+    return {
+      contents: text,
+      loader: path.extname(args.path).substring(1),
+    };
+  } else {
+    return null;
+  }
+}
+
+const DEFAULT_EXCLUDE_LIST = ['dist', 'node_modules'];
+const DEFAULT_EXTENSION_LIST = ['.js', '.jsx', '.ts', '.tsx'];
+module.exports = (
+  vars,
+  baseDir = process.cwd(),
+  exclude = DEFAULT_EXCLUDE_LIST,
+  extension = DEFAULT_EXTENSION_LIST
+) => {
+  _saved.vars = vars;
+  _saved.baseDir = baseDir;
+  _saved.exclude = exclude;
+  const filter = {
+    filter: new RegExp(`(${extension.join('|')})$`),
+  };
+  return {
+    name: 'plugin-ifdef',
+    setup(build) {
+      build.onLoad(filter, pluginOnLoad);
+    },
+  };
+};

package/dev/plugin-ifelse.test.js

@@ -0,0 +1,37 @@
+/*
+(async () => {
+    var vars = {
+        TEST: undefined,
+        TEST1: '', // false
+        TEST2: '2',
+        PROD: false,
+    }
+      const x = await processOneFile(vars, 'test.js');
+  console.log(x);
+  process.exit(0);
+})();
+*/
+console.log('test start');
+console.log('test start');
+// #if TEST
+console.log('test');
+// #elseif PROD
+console.log('prod');
+// #else
+console.log('not test');
+// #endif
+console.log('test end');
+console.log('test end');
+// #if TEST1 && TEST2
+console.log('test1 and test2');
+// #endif
+
+// #if TEST1 || TEST2
+console.log('test1 or test2');
+// #endif
+
+// #if TEST2
+console.log('test2');
+// #endif
+console.log('test end');
+console.log('test end');

package/dev/run-cmd.js

@@ -0,0 +1,14 @@
+const cp = require('child_process');
+
+exports.runCmd = (cmd) => {
+  const child = cp.spawn(`npm run ${cmd}`, { shell: true });
+  console.log(`[dev-server] Run: ${cmd}`);
+  // child.stdout.on('data', (data) => {
+  //   process.stdout.write(`${data}`);
+  // });
+  // child.stderr.on('data', (data) => {
+  //   process.stdout.write(`${data}`);
+  // });
+  child.stdout.pipe(process.stdout);
+  child.stderr.pipe(process.stderr);
+};

package/dev/send-request.js

@@ -0,0 +1,12 @@
+exports.sendRequest = async (url, waitSeconds) => {
+  try {
+    // need node 18
+    const ret = await fetch(url, {
+      signal: AbortSignal.timeout(waitSeconds * 1000),
+    });
+    waitSeconds > 0 && (await new Promise((r) => setTimeout(r, waitSeconds * 1000)));
+    return ret;
+  } catch (err) {
+    console.error('sendRequest error: ', err);
+  }
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "lupine.api",
+  "version": "1.0.41",
+  "license": "MIT",
+  "author": "uuware.com",
+  "homepage": "https://github.com/uuware/lupine.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/uuware/lupine.js.git",
+    "directory": "packages/lupine.api"
+  },
+  "description": "lupine.api is a fast, lightweight, and flexible node.js based server, working with lupine.web to provide SSR and modern JavaScript features for web applications and APIs.",
+  "main": "src/index.ts",
+  "source": "src/index.ts",
+  "types": "src/index.ts",
+  "engines": {
+    "node": ">= 20"
+  },
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "umd": "./src/index.ts",
+      "import": "./src/index.ts",
+      "require": "./src/index.ts"
+    },
+    "./admin": {
+      "types": "./admin/index.ts",
+      "import": "./admin/index.ts",
+      "require": "./admin/index.ts"
+    },
+    "./dev": {
+      "require": "./dev/index.js"
+    }
+  },
+  "keywords": [
+    "backend-end",
+    "lightweight"
+  ],
+  "scripts": {
+    "note": "echo 'build is not needed as the typescript code is supposed to be referred directly from other projects'",
+    "npm-publish": "npm publish --access public",
+    "build": "tsc"
+  },
+  "dependencies": {
+    "better-sqlite3": "^11.9.1",
+    "lupine.web": "^1.0.0",
+    "lupine.components": "^1.0.0"
+  },
+  "optionalDependencies": {
+    "mysql2": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12"
+  }
+}

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

@@ -0,0 +1,59 @@
+import { ServerResponse } from 'http';
+// import { AdminUser } from './admin-user';
+import { AdminDb } from './admin-db';
+import { AdminMenu } from './admin-menu';
+import { devAdminAuth, needDevAdminSession } from './admin-auth';
+import { AdminPerformance } from './admin-performance';
+import { AdminRelease } from './admin-release';
+import { AdminResources } from './admin-resources';
+import { AdminTokens } from './admin-tokens';
+import { AdminConfig } from './admin-config';
+import { Logger } from '../lib';
+import { IApiBase, ServerRequest } from '../models';
+import {ApiRouter } from '../api';
+
+const logger = new Logger('admin-api');
+
+export class AdminApi implements IApiBase {
+  protected router = new ApiRouter();
+  adminUser: any;
+
+  constructor() {
+    this.mountDashboard();
+  }
+
+  public getRouter(): ApiRouter {
+    return this.router;
+  }
+
+  protected mountDashboard() {
+    const adminDb = new AdminDb();
+    this.router.use('/db', needDevAdminSession, adminDb.getRouter());
+
+    // const adminUsers = new AdminUser();
+    // this.router.use('/user', needDevAdminSession, adminUsers.getRouter());
+
+    const adminMenus = new AdminMenu();
+    this.router.use('/menu', needDevAdminSession, adminMenus.getRouter());
+
+    const adminPerformance = new AdminPerformance();
+    this.router.use('/performance', needDevAdminSession, adminPerformance.getRouter());
+
+    const adminRelease = new AdminRelease();
+    // as some endpoints check the token, so add needDevAdminSession inside
+    this.router.use('/release', adminRelease.getRouter());
+
+    const adminResources = new AdminResources();
+    this.router.use('/resources', needDevAdminSession, adminResources.getRouter());
+
+    const adminConfig = new AdminConfig();
+    this.router.use('/config', needDevAdminSession, adminConfig.getRouter());
+
+    const adminTokens = new AdminTokens();
+    this.router.use('/tokens', needDevAdminSession, adminTokens.getRouter());
+
+    this.router.use('/auth', async (req: ServerRequest, res: ServerResponse) => {
+      return devAdminAuth(req, res);
+    });
+  }
+}

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

@@ -0,0 +1,87 @@
+import { ServerResponse } from 'http';
+import { Logger, ServerRequest, ApiHelper } from 'lupine.api';
+import { CryptoUtils } from '../lib/utils/crypto';
+import { adminHelper, DEV_ADMIN_CRYPTO_KEY_NAME, DEV_ADMIN_TYPE, DevAdminSessionProps } from './admin-helper';
+import { langHelper } from '../lang';
+
+const logger = new Logger('admin-auth');
+export const needDevAdminSession = async (req: ServerRequest, res: ServerResponse) => {
+  const devAdminSession = await adminHelper.getDevAdminFromCookie(req, res, true);
+  if (!devAdminSession) {
+    // return true to skip the rest of the middleware
+    return true;
+  }
+  return false;
+};
+
+// dev admin, for development only
+export const devAdminAuth = async (req: ServerRequest, res: ServerResponse) => {
+  const cryptoKey = process.env[DEV_ADMIN_CRYPTO_KEY_NAME];
+  if (!cryptoKey) {
+    const msg = langHelper.getLang('shared:crypto_key_not_set', {
+      cryptoKey: DEV_ADMIN_CRYPTO_KEY_NAME,
+    });
+    logger.error(msg);
+    const response = {
+      status: 'error',
+      message: msg,
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+  if (!process.env['DEV_ADMIN_PASS']) {
+    const msg = langHelper.getLang('shared:name_not_set', {
+      name: 'DEV_ADMIN_PASS',
+    });
+    logger.error(msg);
+    const response = {
+      status: 'error',
+      message: msg,
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  // TODO: secure and httpOnly cookies
+  const data = req.locals.json();
+  if (!data || Array.isArray(data) || !data.u || !data.p) {
+    // if session already exists, use session data login
+    const devAdminSession = await adminHelper.getDevAdminFromCookie(req, res, true);
+    if (!devAdminSession) {
+      return true;
+    }
+    const response = {
+      status: 'ok',
+      message: langHelper.getLang('shared:login_success'),
+      result: CryptoUtils.encrypt(JSON.stringify(devAdminSession), cryptoKey),
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  if (data.u === process.env['DEV_ADMIN_USER'] && data.p === process.env['DEV_ADMIN_PASS']) {
+    logger.info('dev admin logged in');
+    const devSession: DevAdminSessionProps = {
+      u: data.u,
+      t: DEV_ADMIN_TYPE,
+      ip: req.socket.remoteAddress as string,
+      h: CryptoUtils.hash(data.u + ':' + data.p),
+    };
+    const token = JSON.stringify(devSession);
+    const response = {
+      status: 'ok',
+      message: langHelper.getLang('shared:login_success'),
+      result: CryptoUtils.encrypt(token, cryptoKey),
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  logger.info(`dev admin login failed: ${((data.u as string) || '').substring(0, 30)}`);
+  const response = {
+    status: 'error',
+    message: langHelper.getLang('shared:login_failed'),
+  };
+  ApiHelper.sendJson(req, res, response);
+  return true;
+};

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

@@ -0,0 +1,93 @@
+import { ServerResponse } from 'http';
+import * as fs from 'fs/promises';
+import {
+  IApiBase,
+  Logger,
+  apiCache,
+  ServerRequest,
+  ApiRouter,
+  ApiHelper,
+  langHelper,
+  FsUtils,
+  adminHelper,
+} from 'lupine.api';
+import path from 'path';
+import { needDevAdminSession } from './admin-auth';
+
+export class AdminConfig implements IApiBase {
+  private logger = new Logger('config-api');
+  protected router = new ApiRouter();
+
+  constructor() {
+    this.mountDashboard();
+  }
+
+  public getRouter(): ApiRouter {
+    return this.router;
+  }
+
+  protected mountDashboard() {
+    // called by FE
+    this.router.use('/load', this.load.bind(this));
+    this.router.use('/save', this.save.bind(this));
+  }
+
+  async load(req: ServerRequest, res: ServerResponse) {
+    const appData = apiCache.getAppData();
+    let cfgPath = path.join(appData.dataPath, 'config.json');
+    if (!(await FsUtils.pathExist(cfgPath))) {
+      cfgPath = path.join(appData.dataPath, 'resources', 'config_default.json');
+    }
+    if (!(await FsUtils.pathExist(cfgPath))) {
+      const response = {
+        status: 'error',
+        message: langHelper.getLang('shared:not_found_file', { fileName: 'config.json' }),
+      };
+      ApiHelper.sendJson(req, res, response);
+      return true;
+    }
+
+    let jsonCfg: any;
+    try {
+      jsonCfg = JSON.parse(await fs.readFile(cfgPath, 'utf8'));
+    } catch (e) {
+      const response = {
+        status: 'error',
+        message: langHelper.getLang('shared:not_found_file', { fileName: 'config.json' }),
+      };
+      ApiHelper.sendJson(req, res, response);
+      return true;
+    }
+    const response = {
+      status: 'ok',
+      message: langHelper.getLang('shared:operation_success'),
+      result: jsonCfg,
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  // called by clients
+  async save(req: ServerRequest, res: ServerResponse) {
+    const data = req.locals.json();
+    if (!data || Array.isArray(data) || !data.json) {
+      const response = {
+        status: 'error',
+        message: langHelper.getLang('shared:wrong_data'),
+      };
+      ApiHelper.sendJson(req, res, response);
+      return true;
+    }
+
+    const appData = apiCache.getAppData();
+    const cfgPath = path.join(appData.dataPath, 'config.json');
+    await fs.writeFile(cfgPath, JSON.stringify(data.json));
+
+    const response = {
+      status: 'ok',
+      message: langHelper.getLang('shared:operation_success'),
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+}