lupine.api 1.0.41

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

@@ -0,0 +1,81 @@
+import { ServerResponse } from 'http';
+import { Logger } from 'lupine.api';
+import { Db } from '../lib/db';
+
+const logger = new Logger('admin-csv');
+export const exportCSVData = async (db: Db, tableName: string, res: ServerResponse) => {
+  res.write(`@TABLE,${tableName}\r\n`);
+
+  const result = await db.selectObject(tableName);
+  if (result && result.length > 0) {
+    const fields = Object.keys(result[0]).join(',').toLowerCase();
+    res.write(`@FIELD,${fields}\r\n`);
+    result.forEach((row: any) => {
+      res.write(`${JSON.stringify(Object.values(row))}\r\n`);
+    });
+  } else {
+    res.write('#no data\r\n');
+  }
+};
+
+export const exportCSVHead = (fileName: string, res: ServerResponse) => {
+  res.writeHead(200, {
+    'Content-Type': 'text/csv',
+    // 'Expires': '0',
+    // 'Cache-Control': 'no-cache, no-store, must-revalidate',
+    'Content-Disposition': 'attachment; filename=' + fileName + '.ljcsv',
+    // 'Content-Description': 'File Transfer',
+  });
+};
+
+export const exportCSV = async (db: Db, tableName: string, res: ServerResponse) => {
+  if (tableName) {
+    exportCSVHead(tableName + '-' + new Date().toJSON().replace(/:/g, '-'), res);
+    await exportCSVData(db, tableName, res);
+  } else {
+    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.write('Need a table name.');
+  }
+  res.end();
+  return true;
+};
+
+export const exportCSVTables = async (db: Db, tables: string[], res: ServerResponse) => {
+  exportCSVHead('all-tables-' + new Date().toJSON().replace(/:/g, '-'), res);
+  for (const i in tables) {
+    await exportCSVData(db, tables[i], res);
+    res.write('\r\n');
+  }
+  res.end();
+  return true;
+};
+
+export const loadCSV = async (db: Db, lines: string[]) => {
+  let table = '';
+  let insSql = '';
+  const result: any = {};
+  for (const i in lines) {
+    if (!lines[i] || lines[i].startsWith('#')) {
+      continue;
+    }
+    if (lines[i].startsWith('@TABLE,')) {
+      table = lines[i].substring(7);
+      result[table] = { succeeded: 0, failed: 0, errorMessage: [] };
+    } else if (lines[i].startsWith('@FIELD,')) {
+      const fields = lines[i].substring(7); //.split(',');
+      const values = Array(fields.split(',').length).fill('?').join(',');
+      insSql = `INSERT INTO ${table} (${fields} ) VALUES (${values})`;
+    } else {
+      try {
+        const row = JSON.parse(lines[i]);
+        const r = await db.execute(insSql, row);
+        result[table].succeeded++;
+      } catch (error: any) {
+        result[table].failed++;
+        result[table].errorMessage.push(error.message);
+      }
+    }
+  }
+
+  return result;
+};

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

@@ -0,0 +1,269 @@
+import { ServerResponse } from 'http';
+import { IApiBase, FsUtils, Logger, apiCache, ServerRequest, ApiRouter, ApiHelper } from 'lupine.api';
+import { exportCSV, exportCSVTables, loadCSV } from './admin-csv';
+
+const logger = new Logger('admin-db');
+export class AdminDb implements IApiBase {
+  protected router = new ApiRouter();
+  adminUser: any;
+
+  constructor() {
+    this.mountDashboard();
+  }
+
+  public getRouter(): ApiRouter {
+    return this.router;
+  }
+
+  protected mountDashboard() {
+    this.router.use('/install', this.install.bind(this));
+    this.router.use('/run-sql', this.runSql.bind(this));
+    // this.router.use('/table-info', this.tableInfo.bind(this));
+
+    this.router.use('/tables/list', this.tableList.bind(this));
+    this.router.use('/tables/download', this.tableDownloadAll.bind(this));
+    this.router.use('/tables/upload', this.tableUpload.bind(this));
+    this.router.use('/tables/truncate', this.tableTruncateAll.bind(this));
+    this.router.use('/tables/drop', this.tableDropAll.bind(this));
+    this.router.use('/table/data/:tableName/?offset/?limit', this.tableData.bind(this));
+    this.router.use('/table/delete/:tableName/:id', this.tableDelete.bind(this));
+    this.router.use('/table/drop/:tableName', this.tableDrop.bind(this));
+    this.router.use('/table/truncate/:tableName', this.tableTruncate.bind(this));
+    this.router.use('/table/download/:tableName', this.tableDownload.bind(this));
+  }
+
+  async tableList(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const result = await db.getAllTables(true);
+    const response = {
+      status: Array.isArray(result) ? 'ok' : 'error',
+      message: 'Table List.',
+      result: result,
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async tableDownloadAll(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const tables = await db.getAllTableNames();
+    exportCSVTables(db, tables, res);
+    return true;
+  }
+
+  async tableUpload(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const lines = Buffer.from(req.locals.body!)
+      .toString()
+      .split(/(?:\r\n|\r|\n)/g);
+    const result = await loadCSV(db, lines);
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.write(JSON.stringify({ status: 'ok', result }));
+    res.end();
+    return true;
+  }
+
+  async tableTruncateAll(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const tables = await db.getAllTableNames();
+    if (tables && tables.length > 0) {
+      for (const i in tables) {
+        await db.truncateTable(tables[i]);
+      }
+    }
+
+    const response = {
+      status: 'ok',
+      message: 'Truncate all Tables: ' + tables.length,
+      result: '',
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async tableDropAll(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const tables = await db.getAllTableNames();
+    if (tables && tables.length > 0) {
+      for (const i in tables) {
+        await db.execute(`DROP TABLE ${tables[i]}`);
+      }
+    }
+
+    const response = {
+      status: 'ok',
+      message: 'Truncate all Tables: ' + tables.length,
+      result: '',
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async tableData(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const tableName = req.locals.urlParameters.get('tableName', '');
+    let pageIndex = req.locals.urlParameters.getInt('offset', 0); // Number.parseInt(post.pg_i as string);
+    const pageLimit = req.locals.urlParameters.getInt('limit', 30); //Number.parseInt(post.pg_l as string) || 50;
+
+    const response = {
+      status: 'error',
+      message: tableName ? 'Table Data.' : 'Need a table name.',
+      result: null,
+    };
+    if (tableName) {
+      const itemsCount = await db.selectOneResult(tableName, 'count(*)');
+      let maxPages = Math.floor(itemsCount / pageLimit);
+      if (itemsCount % pageLimit !== 0) {
+        maxPages++;
+      }
+      if (pageIndex > maxPages) {
+        pageIndex = maxPages - 1;
+      }
+
+      const offset = pageIndex * pageLimit;
+      response.result = await db.selectObject(tableName, undefined, undefined, undefined, pageLimit, offset);
+      response.status = 'ok';
+      (response as any).itemsCount = itemsCount;
+      (response as any).pageIndex = pageIndex;
+    }
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async tableDelete(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const tableName = req.locals.urlParameters.get('tableName', '');
+    const id = req.locals.urlParameters.getInt('id', -1);
+
+    const response = {
+      status: 'error',
+      message: tableName ? 'Table delete.' : 'Need a table name.',
+      result: null,
+    };
+    if (tableName && id > 0) {
+      const result = await db.deleteObject(tableName, { id: id });
+      response.result = result;
+      response.status = 'ok';
+      ApiHelper.sendJson(req, res, response);
+      return true;
+    }
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async tableDownload(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const tableName = req.locals.urlParameters.get('tableName', '');
+    if (!tableName) {
+      const response = {
+        status: 'error',
+        message: 'Need a table name.',
+      };
+      ApiHelper.sendJson(req, res, response);
+      return true;
+    }
+    exportCSV(db, tableName, res);
+    return true;
+  }
+
+  async tableDrop(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const tableName = req.locals.urlParameters.get('tableName', '');
+    const response = {
+      status: 'error',
+      message: tableName ? 'Delete Table.' : 'Need a table name.',
+      result: '',
+    };
+    if (tableName) {
+      const result = await db.execute(`DROP TABLE ${tableName}`);
+      response.result = result;
+      response.status = 'ok';
+    }
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async tableTruncate(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const tableName = req.locals.urlParameters.get('tableName', '');
+    const response = {
+      status: 'error',
+      message: tableName ? 'Truncate Table.' : 'Need a table name.',
+      result: '',
+    };
+    if (tableName) {
+      const result = await db.truncateTable(tableName);
+      response.result = result;
+      response.status = 'ok';
+    }
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async runSql(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const data = req.locals.json();
+    const response = {
+      status: 'error',
+      message: '',
+      result: '',
+    };
+    if (data && !Array.isArray(data) && data.sql) {
+      const sql = ((data.sql as string) || '').trim();
+      const result = sql.toUpperCase().startsWith('SELECT') ? await db.select(sql) : await db.execute(sql);
+      response.status = 'ok';
+      response.message = 'Executed sql.';
+      response.result = result;
+    }
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async install(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const appData = apiCache.getAppData();
+    const installDir = appData.dataPath + '/resources';
+    const dbType = appData.dbType;
+    const sqlFile = `${installDir}/install.${dbType}.sql`;
+    const sql = await FsUtils.readFile(sqlFile);
+    if (!sql) {
+      const response = { errorMessage: `Can't read file: ${sqlFile}` };
+      ApiHelper.sendJson(req, res, response);
+      return true;
+    }
+
+    const sqlArr = sql.replace(/^#.*/gm, '').replace(/\r/g, ' ').replace(/\n/g, ' ').split(';');
+    const result = [];
+    for (let one in sqlArr) {
+      const oneSql = sqlArr[one].trim();
+      if (oneSql) {
+        try {
+          const one = await db.execute(oneSql);
+          result.push(one);
+        } catch (error: any) {
+          result.push({ error: error.message });
+        }
+      }
+    }
+    const response = { status: 'ok', message: 'Installed', result };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async tableInfo(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const tableName = req.locals.query.get('table');
+    const response = {
+      status: 'error',
+      message: tableName ? 'Get Table.' : 'Need a table name.',
+      result: '',
+    };
+    if (tableName) {
+      const result = await db.getTableInfo(tableName);
+      response.result = result;
+      response.status = 'ok';
+    }
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+}

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

@@ -0,0 +1,111 @@
+import { ServerResponse } from 'http';
+import { ApiHelper } from '../api';
+import { CryptoUtils, Logger } from '../lib';
+import { ServerRequest } from '../models';
+
+/*
+dev-admin uses different authentication method from frontend.
+dev-admin only provides fixed username and password authentication, no user maintenance.
+saved cookie name: _token_dev
+*/
+
+// DEFAULT_ADMIN_PASS is DEFAULT_ADMIN_NAME + ':' + login password hash.
+// Use below command to generate hash:
+// node -e "console.log(require('crypto').createHash('md5').update('admin:F4AZ5O@2fPUjw%f$LmhZpJTQ^DoXnWPkH#hqE', 'utf8').digest('hex'))"
+export type DevAdminSessionProps = {
+  u: string; // username
+  t: string; // type: admin, user
+  ip: string;
+  h: string; // md5 of name+pass
+};
+
+export const DEV_ADMIN_TYPE = 'dev-admin';
+export const DEV_ADMIN_CRYPTO_KEY_NAME = 'DEV_CRYPTO_KEY';
+export const DEV_ADMIN_SESSION_NAME = '_token_dev';
+export class AdminHelper {
+  private static instance: AdminHelper;
+  private logger = new Logger('admin-api');
+
+  private constructor() {}
+
+  public static getInstance(): AdminHelper {
+    if (!AdminHelper.instance) {
+      AdminHelper.instance = new AdminHelper();
+    }
+    return AdminHelper.instance;
+  }
+
+  decryptJson(text: string) {
+    const cryptoKey = process.env[DEV_ADMIN_CRYPTO_KEY_NAME];
+    if (cryptoKey && text) {
+      try {
+        const deCrypto = CryptoUtils.decrypt(text, cryptoKey);
+        const json = JSON.parse(deCrypto);
+        return json;
+      } catch (error: any) {
+        this.logger.error(error.message);
+      }
+    }
+    return false;
+  }
+
+  encryptJson(jsonOrText: string | object) {
+    const cryptoKey = process.env[DEV_ADMIN_CRYPTO_KEY_NAME];
+    if (cryptoKey && jsonOrText) {
+      try {
+        const text = typeof jsonOrText === 'string' ? jsonOrText : JSON.stringify(jsonOrText);
+        const encryptText = CryptoUtils.encrypt(text, cryptoKey);
+        return encryptText;
+      } catch (error: any) {
+        this.logger.error(error.message);
+      }
+    }
+    return false;
+  }
+
+  async getDevAdminFromCookie(
+    req: ServerRequest,
+    res: ServerResponse,
+    sendResponseWhenError = true
+  ): Promise<DevAdminSessionProps | false> {
+    try {
+      const cookies = req.locals.cookies();
+      const token = cookies.get(DEV_ADMIN_SESSION_NAME, '');
+      if (token) {
+        const json = this.decryptJson(token) as DevAdminSessionProps;
+        if (!json || json.t !== DEV_ADMIN_TYPE) {
+          if (sendResponseWhenError) {
+            const response = {
+              status: 'error',
+              message: 'Wrong session data, contact site admin please.',
+            };
+            ApiHelper.sendJson(req, res, response);
+          }
+          return false;
+        }
+
+        // if it's special admin
+        if (json.h && json.u === process.env['DEV_ADMIN_USER']) {
+          const hash = CryptoUtils.hash(process.env['DEV_ADMIN_USER'] + ':' + process.env['DEV_ADMIN_PASS']);
+          if (json.h === hash) {
+            return json;
+          }
+        }
+        return false;
+      }
+    } catch (error: any) {
+      this.logger.error(error.message);
+    }
+    if (sendResponseWhenError) {
+      const response = {
+        status: 'error',
+        message: 'Please login to use this system.',
+      };
+      ApiHelper.sendJson(req, res, response);
+    }
+    return false;
+  }
+}
+
+// add comment for tree shaking
+export const adminHelper = /* @__PURE__ */ AdminHelper.getInstance();

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

@@ -0,0 +1,135 @@
+import { ServerResponse } from 'http';
+import { IApiBase, Logger, apiCache, ServerRequest, ApiRouter, ApiHelper } from 'lupine.api';
+
+const logger = new Logger('admin-menu');
+export class AdminMenu implements IApiBase {
+  protected router = new ApiRouter();
+  adminUser: any;
+
+  constructor() {
+    this.mountDashboard();
+  }
+
+  public getRouter(): ApiRouter {
+    return this.router;
+  }
+
+  protected mountDashboard() {
+    this.router.use('/list', this.list.bind(this));
+    this.router.use('/add', this.add.bind(this));
+    this.router.use('/save', this.save.bind(this));
+    this.router.use('/get/:id', this.getRecord.bind(this));
+    this.router.use('/delete/:id', this.delete.bind(this));
+  }
+
+  async list(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const result = await db.selectObject('$__s_menu');
+    const response = {
+      status: Array.isArray(result) ? 'ok' : 'error',
+      message: 'Menu List.',
+      result: result,
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async add(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const data = req.locals.json() as any;
+    delete data['id'];
+    const result = await db.insertObject('$__st_user', data);
+    const response = {
+      status: Array.isArray(result) ? 'ok' : 'error',
+      message: 'User List.',
+      result: result,
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async save(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const data = req.locals.json() as any;
+
+    const id = data['id'];
+    if (!data['idReadonly']) {
+      // save as
+      const result = await db.selectObject('$__s_menu', ['menuid'], {
+        menuid: id,
+      });
+      if (result && result.length > 0) {
+        const response = {
+          status: 'ID_EXISTS',
+          message: `Menu id: ${id} exists`,
+        };
+        ApiHelper.sendJson(req, res, response);
+        return true;
+      }
+    }
+
+    await db.deleteObject('$__s_menu', { menuid: id });
+    const result = await db.insertObject('$__s_menu', {
+      menuid: id,
+      title: data['title'],
+      note: data['note'],
+      package: data['package'],
+      items: JSON.stringify(data['items']),
+      updateduserid: 1,
+      updatedstamp: new Date().toISOString(),
+    });
+    const response = {
+      status: 'ok',
+      result: result,
+      message: 'Menu Saved.',
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async getRecord(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const id = req.locals.urlParameters.get('id', '');
+
+    const response = {
+      status: 'error',
+      message: 'Get a menu item.',
+      result: {},
+    };
+    if (id) {
+      const result = await db.selectObject('$__s_menu', undefined, {
+        menuid: id,
+      });
+      if (result && result.length > 0) {
+        response.result = {
+          menuid: result[0]['menuid'],
+          title: result[0]['title'],
+          note: result[0]['note'],
+          package: result[0]['package'],
+          items: JSON.parse(result[0]['items']),
+        };
+      }
+      response.status = 'ok';
+    }
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async delete(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const id = req.locals.urlParameters.get('id', '');
+
+    const response = {
+      status: 'ok',
+      message: 'Delete a menu.',
+      result: null,
+    };
+    if (id) {
+      const result = await db.deleteObject('$__s_menu', { menuid: id });
+      response.result = result;
+      response.status = 'ok';
+    }
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+}