lupine.api 1.0.41

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

@@ -0,0 +1,318 @@
+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';
+
+export class AdminResources implements IApiBase {
+  private logger = new Logger('resources-api');
+  protected router = new ApiRouter();
+
+  constructor() {
+    this.mountDashboard();
+  }
+
+  public getRouter(): ApiRouter {
+    return this.router;
+  }
+
+  protected mountDashboard() {
+    // called by FE
+    this.router.use('/data', this.data.bind(this));
+    this.router.use('/download', this.download.bind(this));
+    this.router.use('/upload', this.upload.bind(this));
+    this.router.use('/rename', this.rename.bind(this));
+    this.router.use('/newFolder', this.newFolder.bind(this));
+    this.router.use('/remove', this.remove.bind(this));
+    this.router.use('/removeDir', this.removeDir.bind(this));
+  }
+
+  async upload(req: ServerRequest, res: ServerResponse) {
+    const fPath = req.locals.query.get('p');
+    const fName = req.locals.query.get('n');
+    const data = req.locals.body;
+    if (!data || data.length < 1 || !fPath || !fName) {
+      const response = {
+        status: 'error',
+        message: langHelper.getLang('shared:wrong_data'),
+      };
+      ApiHelper.sendJson(req, res, response);
+      return true;
+    }
+
+    const appData = apiCache.getAppData();
+    const locPath = this.pathJoin(fPath, appData.webPath);
+    if (!(await FsUtils.pathExist(locPath))) {
+      const response = {
+        status: 'error',
+        message: langHelper.getLang('shared:wrong_data'),
+      };
+      ApiHelper.sendJson(req, res, response);
+      return true;
+    }
+
+    const key = req.locals.query.get('key') as string;
+    const chunkNumberStr = req.locals.query.get('chunkNumber') as string;
+    const chunkNumber = parseInt(chunkNumberStr);
+    const totalChunks = parseInt(req.locals.query.get('totalChunks') as string);
+    const decryptedKey = key && adminHelper.decryptJson(key.replace(/ /g, '+'));
+    const keyNG =
+      !chunkNumberStr ||
+      !totalChunks ||
+      (chunkNumber !== 0 && (!decryptedKey || decryptedKey.ind !== chunkNumber || decryptedKey.cnt !== totalChunks));
+    if (keyNG) {
+      const response = {
+        status: 'error',
+        message: langHelper.getLang('shared:permission_denied'),
+      };
+      ApiHelper.sendJson(req, res, response);
+      return true;
+    }
+    const MAX_FILE_SIZE = 1024 * 1024 * 800; // MB
+    if (totalChunks * data.length > MAX_FILE_SIZE) {
+      const response = {
+        status: 'error',
+        message: langHelper.getLang('shared:file_too_large'),
+      };
+      ApiHelper.sendJson(req, res, response);
+      return true;
+    }
+
+    const filename = path.join(fPath, fName);
+    // write data to a file
+    if (chunkNumber === 0) {
+      await fs.writeFile(filename, data, 'binary');
+    } else {
+      await fs.appendFile(filename, data, 'binary');
+    }
+
+    const response = {
+      status: 'ok',
+      chunkNumber,
+      totalChunks,
+      message: langHelper.getLang('shared:file_part_updated'),
+      key: adminHelper.encryptJson({ ind: chunkNumber + 1, cnt: totalChunks, t: new Date().getTime() }),
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  private chkData(data: any, req: ServerRequest, res: ServerResponse, chkCredential: boolean) {
+    if (!data || Array.isArray(data) || typeof data !== 'object') {
+      this.logger.error(`chkData, missing parameters`, data);
+      const response = {
+        status: 'error',
+        message: 'Wrong data [missing parameters].', //langHelper.getLang('shared:wrong_data'),
+      };
+      ApiHelper.sendJson(req, res, response);
+      return false;
+    }
+    return data;
+  }
+
+  private async getFolders(locPath: string) {
+    const results: any[] = [];
+    const folders = await FsUtils.getDirAndFiles(locPath);
+
+    results.push({
+      fullPath: locPath,
+    });
+    for (let i = 0; i < folders.length; i++) {
+      const oneFolder = folders[i];
+      const fileInfo = await FsUtils.fileInfo(path.join(locPath, oneFolder));
+      if (fileInfo?.isFile) {
+        results.push({
+          name: oneFolder,
+          time: new Date(fileInfo!.mtime).toLocaleString(),
+          size: fileInfo?.size,
+        });
+      } else {
+        const subFolders = await FsUtils.getDirAndFiles(path.join(locPath, oneFolder));
+        const subFoldersWithTime = [];
+        for (let j = 0; j < subFolders.length; j++) {
+          const subFile = subFolders[j];
+          const fileInfo2 = await FsUtils.fileInfo(path.join(locPath, oneFolder, subFile));
+
+          if (fileInfo2?.isFile) {
+            subFoldersWithTime.push({
+              name: subFile,
+              time: new Date(fileInfo2.mtime).toLocaleString(),
+              size: fileInfo2?.size,
+            });
+          } else {
+            subFoldersWithTime.push({
+              name: subFile,
+              time: fileInfo2?.mtime && new Date(fileInfo2.mtime).toLocaleString(),
+            });
+          }
+        }
+        results.push({
+          name: oneFolder,
+          time: fileInfo?.mtime && new Date(fileInfo.mtime).toLocaleString(),
+          items: subFoldersWithTime,
+        });
+      }
+    }
+    return results;
+  }
+
+  private pathJoin(folder: string, apiPath: string) {
+    return folder !== '/' && folder !== '' && (folder.startsWith('/') || folder.startsWith('\\') || folder[1] === ':')
+      ? path.join(folder)
+      : path.join(apiPath, folder);
+  }
+
+  async data(req: ServerRequest, res: ServerResponse) {
+    const data = this.chkData(req.locals.json(), req, res, false);
+    if (!data) return true;
+    let results: any[] = [];
+    if (typeof data.folder === 'string') {
+      const appData = apiCache.getAppData();
+      const locPath = this.pathJoin(data.folder, appData.webPath);
+      results = await this.getFolders(locPath);
+    }
+    const response = {
+      status: 'ok',
+      message: 'OK',
+      results,
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  // called by clients
+  async download(req: ServerRequest, res: ServerResponse) {
+    const data = this.chkData(req.locals.json(), req, res, true);
+    if (!data) return true;
+
+    if (typeof data.resource === 'string') {
+      const resPath = path.join(data.resource);
+      if (await FsUtils.pathExist(resPath)) {
+        ApiHelper.sendFile(req, res, resPath);
+        return true;
+      }
+    }
+    const response = {
+      status: 'error',
+      message: 'Resource not found',
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async rename(req: ServerRequest, res: ServerResponse) {
+    const data = this.chkData(req.locals.json(), req, res, true);
+    if (!data) return true;
+
+    if (typeof data.resource === 'string' && data.oldName && data.newName) {
+      const resPath = path.join(data.resource);
+      const basePath = path.dirname(resPath);
+      const oldPath = path.join(basePath, data.oldName);
+      if (await FsUtils.pathExist(oldPath)) {
+        const newPath = path.join(basePath, data.newName);
+        await FsUtils.rename(oldPath, newPath);
+        if (await FsUtils.pathExist(newPath)) {
+          const response = {
+            status: 'ok',
+            message: 'Resource renamed to ' + newPath,
+          };
+          ApiHelper.sendJson(req, res, response);
+        } else {
+          const response = {
+            status: 'error',
+            message: 'Resource not renamed',
+          };
+          ApiHelper.sendJson(req, res, response);
+        }
+        return true;
+      }
+    }
+    const response = {
+      status: 'error',
+      message: 'Resource not found',
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async remove(req: ServerRequest, res: ServerResponse) {
+    const data = this.chkData(req.locals.json(), req, res, true);
+    if (!data) return true;
+
+    if (typeof data.resource === 'string') {
+      const resPath = path.join(data.resource);
+      if (await FsUtils.pathExist(resPath)) {
+        await FsUtils.unlinkFile(resPath);
+        const response = {
+          status: 'ok',
+          message: 'Resource removed',
+        };
+        ApiHelper.sendJson(req, res, response);
+        return true;
+      }
+    }
+    const response = {
+      status: 'error',
+      message: 'Resource not found',
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async removeDir(req: ServerRequest, res: ServerResponse) {
+    const data = this.chkData(req.locals.json(), req, res, true);
+    if (!data) return true;
+
+    if (typeof data.resource === 'string') {
+      const resPath = path.join(data.resource);
+      if (await FsUtils.pathExist(resPath)) {
+        await FsUtils.unlinkFolderEmpty(resPath);
+        const response = {
+          status: 'ok',
+          message: 'Directory removed',
+        };
+        ApiHelper.sendJson(req, res, response);
+        return true;
+      }
+    }
+    const response = {
+      status: 'error',
+      message: 'Directory not found or has files',
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async newFolder(req: ServerRequest, res: ServerResponse) {
+    const data = this.chkData(req.locals.json(), req, res, true);
+    if (!data) return true;
+
+    if (typeof data.resource === 'string' && data.newName) {
+      const resPath = path.join(data.resource, data.newName);
+      if (!await FsUtils.pathExist(resPath)) {
+        await FsUtils.mkdir(resPath);
+        const response = {
+          status: 'ok',
+          message: 'Folder created',
+        };
+        ApiHelper.sendJson(req, res, response);
+        return true;
+      }
+    }
+    const response = {
+      status: 'error',
+      message: 'Folder not created',
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+}

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

@@ -0,0 +1,79 @@
+import { apiStorage } from '../api';
+import { CryptoUtils, Logger } from '../lib';
+import { adminHelper } from './admin-helper';
+
+export type TokenProps = {
+  token: string;
+  description: string;
+  timestamp?: number;
+};
+export class AdminTokenHelper {
+  private static instance: AdminTokenHelper;
+  private logger = new Logger('admin-token-api');
+
+  private constructor() {}
+
+  public static getInstance(): AdminTokenHelper {
+    if (!AdminTokenHelper.instance) {
+      AdminTokenHelper.instance = new AdminTokenHelper();
+    }
+    return AdminTokenHelper.instance;
+  }
+
+  async list(search?: string): Promise<TokenProps[]> {
+    const tokens = await apiStorage.getApi('access-tokens');
+    const tokenJson = JSON.parse(tokens || '[]');
+
+    const searchTexts = (search || '').trim().split(' ').filter(item => !!item);
+    const results = tokenJson.filter((item: TokenProps) =>
+      searchTexts.every((text) => item.description.toLowerCase().includes(text.toLowerCase()))
+    );
+
+    return results;
+  }
+  async add(tokenData: TokenProps) {
+    const tokens = await apiStorage.getApi('access-tokens');
+    const tokensJson = JSON.parse(tokens || '[]');
+    tokenData.timestamp = new Date().getTime();
+    tokensJson.push(tokenData);
+    apiStorage.setApi('access-tokens', JSON.stringify(tokensJson));
+    await apiStorage.save();
+  }
+
+  async update(tokenData: TokenProps) {
+    const tokens = await apiStorage.getApi('access-tokens');
+    const tokensJson = JSON.parse(tokens || '{}');
+    const idx = tokensJson.findIndex((item: TokenProps) => item.token === tokenData.token);
+    if (idx !== -1) {
+      tokensJson[idx].description = tokenData.description;
+    }
+    apiStorage.setApi('access-tokens', JSON.stringify(tokensJson));
+    apiStorage.save();
+  }
+
+  async remove(token: string) {
+    const tokens = await apiStorage.getApi('access-tokens');
+    const tokensJson = JSON.parse(tokens || '[]');
+    const idx = tokensJson.findIndex((item: TokenProps) => item.token === token);
+    if (idx !== -1) {
+      tokensJson.splice(idx, 1);
+    }
+    apiStorage.setApi('access-tokens', JSON.stringify(tokensJson));
+    apiStorage.save();
+  }
+
+  generate() {
+    const salt = 'Lupine:' + CryptoUtils.uuid() + ':' + new Date().getTime().toString();
+    return adminHelper.encryptJson(salt) as string;
+  }
+
+  async validateToken(token: string) {
+    const tokens = await apiStorage.getApi('access-tokens');
+    const tokensJson = JSON.parse(tokens || '[]');
+    const idx = tokensJson.findIndex((item: TokenProps) => item.token === token);
+    return idx !== -1;
+  }
+}
+
+// add comment for tree shaking
+export const adminTokenHelper = /* @__PURE__ */ AdminTokenHelper.getInstance();

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

@@ -0,0 +1,90 @@
+import { ServerResponse } from 'http';
+import { IApiBase, Logger, ServerRequest, ApiRouter, ApiHelper, apiStorage } from 'lupine.api';
+import { adminTokenHelper } from './admin-token-helper';
+
+export class AdminTokens implements IApiBase {
+  logger = new Logger('admin-page');
+  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('/generate', this.generateToken.bind(this));
+    this.router.use('/update', this.update.bind(this));
+    this.router.use('/remove', this.remove.bind(this));
+  }
+
+  async list(req: ServerRequest, res: ServerResponse) {
+    const pageLimit = await apiStorage.getWeb('pageLimit') || '15';
+    const data = req.locals.json() as any;
+    const search = data['q'];
+    const list = await adminTokenHelper.list(search);
+    const response = {
+      status: 'ok',
+      message: 'Token List.',
+      result: list,
+      pageLimit,
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async add(req: ServerRequest, res: ServerResponse) {
+    const data = req.locals.json() as any;
+    const token = data['token'];
+    const description = data['description'];
+    token && (await adminTokenHelper.add({token, description}));
+    const response = {
+      status: 'ok',
+      message: 'Added token.',
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async generateToken(req: ServerRequest, res: ServerResponse) {
+    const newToken = adminTokenHelper.generate();
+    const response = {
+      status: 'ok',
+      message: 'Generated new token.',
+      result: newToken,
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async update(req: ServerRequest, res: ServerResponse) {
+    const data = req.locals.json() as any;
+    const token = data['token'];
+    const description = data['description'];
+    token && (await adminTokenHelper.update({token, description}));
+    const response = {
+      status: 'ok',
+      message: 'Updated token.',
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async remove(req: ServerRequest, res: ServerResponse) {
+    const data = req.locals.json() as any;
+    const token = data['token'];
+    token && (await adminTokenHelper.remove(token));
+
+    const response = {
+      status: 'ok',
+      message: 'Removed token.',
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+}

package/src/admin-api/index.ts

@@ -0,0 +1,2 @@
+export * from './admin-api';
+export * from './admin-helper';

package/src/api/api-cache.ts

@@ -0,0 +1,103 @@
+/**
+ * A simple settings/config class for storing key/value pairs in memory
+ */
+import { Db } from '../lib';
+import { asyncLocalStorage } from './async-storage';
+import { AsyncStorageProps, HostToPathProps } from '../models';
+
+// This data doesn't need to be shared to other workers
+export const getTemplateCache = () => {
+  let cachedHtml = apiCache.get(apiCache.KEYS.TEMPLATE);
+  if (!cachedHtml) {
+    cachedHtml = {};
+    apiCache.set(apiCache.KEYS.TEMPLATE, cachedHtml);
+  }
+  return cachedHtml;
+};
+
+enum ApiCacheKeys {
+  TEMPLATE = 'TEMPLATE',
+  DB = 'DB',
+  APP_DATA = 'APP_DATA',
+  // APP_CACHE = 'APP_CACHE',
+}
+
+// For cross clusters sharing, use AppSharedStorage
+// ApiCache doesn't share cross clusters
+// Since apis and app are independent, so ApiCache in apis and app are different instances.
+// ApiCache is not shared cross app and apis, so `set` is only supposed to be called when app starts, or
+// `set/get` is only used inside one api only
+export class ApiCache {
+  private static instance: ApiCache;
+  KEYS = ApiCacheKeys;
+
+  private cacheMap: { [key: string]: any } = {};
+
+  private constructor() {}
+
+  public static getInstance(): ApiCache {
+    if (!ApiCache.instance) {
+      ApiCache.instance = new ApiCache();
+    }
+    return ApiCache.instance;
+  }
+
+  clear() {
+    Object.keys(this.cacheMap).forEach((key) => {
+      delete this.cacheMap[key];
+    });
+  }
+
+  get(key: string) {
+    return this.cacheMap[key];
+  }
+
+  set(key: string, value: any) {
+    if (typeof value === 'undefined') {
+      delete this.cacheMap[key];
+    } else {
+      this.cacheMap[key] = value;
+    }
+  }
+
+  // get scope variables inside of asyncLocalStorage.run
+  getAsyncStore(): AsyncStorageProps {
+    const store = asyncLocalStorage.getStore();
+    if (!store) {
+      throw new Error('This function should be called inside of asyncLocalStorage.run');
+    }
+
+    return store;
+  }
+
+  // get scope variables inside of asyncLocalStorage.run
+  getAppData() {
+    return this.get(ApiCacheKeys.APP_DATA) as HostToPathProps;
+  }
+
+  // get scope variables inside of asyncLocalStorage.run
+  getAppName() {
+    return this.getAsyncStore().appName;
+  }
+
+  // get scope variables inside of asyncLocalStorage.run
+  getDb() {
+    return this.get(ApiCacheKeys.DB) as Db;
+  }
+
+  // get scope variables inside of asyncLocalStorage.run
+  getUuid() {
+    return this.getAsyncStore().uuid;
+  }
+
+  // get scope variables inside of asyncLocalStorage.run
+  getLang() {
+    return this.getAsyncStore().lang;
+  }
+
+  clearTemplateCache() {
+    this.set(ApiCacheKeys.TEMPLATE, undefined);
+  }
+}
+
+export const apiCache = /* @__PURE__ */ ApiCache.getInstance();

package/src/api/api-helper.ts

@@ -0,0 +1,44 @@
+import { ServerResponse } from 'http';
+import { ServerRequest } from '../models/locals-props';
+import { JsonObject } from '../models/json-object';
+import fs from 'fs';
+
+export class ApiHelper {
+  static sendJson(
+    req: ServerRequest,
+    res: ServerResponse,
+    json: JsonObject,
+    statusCode = 200,
+    headers?: { [key: string]: string }
+  ) {
+    res.writeHead(statusCode, Object.assign({ 'Content-Type': 'application/json' }, headers));
+    res.write(JSON.stringify(json));
+    res.end();
+    return true;
+  }
+
+  static sendHtml(
+    req: ServerRequest,
+    res: ServerResponse,
+    html: string,
+    statusCode = 200,
+    headers?: { [key: string]: string }
+  ) {
+    res.writeHead(statusCode, Object.assign({ 'Content-Type': 'text/html' }, headers));
+    res.write(html);
+    res.end();
+    return true;
+  }
+
+  static sendFile(
+    req: ServerRequest,
+    res: ServerResponse,
+    filepath: string,
+    statusCode = 200,
+    headers?: { [key: string]: string }
+  ) {
+    res.writeHead(statusCode, Object.assign({ 'Content-Type': 'application/octet-stream' }, headers));
+    fs.createReadStream(filepath).pipe(res);
+    return true;
+  }
+}

package/src/api/api-module.ts

@@ -0,0 +1,60 @@
+import { DbConfig, DbHelper, HostToPathProps, IApiBase, loadEnv, ServerRequest } from 'lupine.api';
+import { ServerResponse } from 'http';
+import path from 'path';
+import { apiCache, asyncLocalStorage, bindRenderPageFunctions } from '.';
+import { AppCacheGlobal, AppCacheKeys, AsyncStorageProps, IApiModule, IAppCache, IAppSharedStorage, setAppCache } from '../models';
+import { apiStorage } from './api-shared-storage';
+
+export class ApiModule implements IApiModule {
+  rootApi: IApiBase;
+  constructor(api: IApiBase) {
+    this.rootApi = api;
+  }
+
+  public async processApi(store: AsyncStorageProps, url: string, req: ServerRequest, res: ServerResponse) {
+    let result = false;
+    await asyncLocalStorage.run(store, async () => {
+      if (await this.rootApi.getRouter().findRoute(url, req, res, true)) {
+        result = true;
+        return true;
+      }
+    });
+    return result;
+  }
+
+  // appCache is from app-loader (parent scope), not the same in current scope
+  public async initApi(appConfig: HostToPathProps, appCacheFromApp: IAppCache, appStorageFromApp: IAppSharedStorage) {
+
+    // const evnFile = appCacheFromApp.get(AppCacheGlobal, AppCacheKeys.APP_ENV_FILE);
+    // if (evnFile) {
+    //   await loadEnv(evnFile);
+    // }
+
+    // set app's instances to api
+    setAppCache(appCacheFromApp);
+    // setAppStorage(appStorageFromApp);
+    apiStorage.setAppSharedStorage(appStorageFromApp);
+    // set RENDER_PAGE_FUNCTIONS to API module
+    bindRenderPageFunctions(appCacheFromApp.get(AppCacheGlobal, AppCacheKeys.RENDER_PAGE_FUNCTIONS));
+
+    console.log(`appConfig: `, appConfig);
+    apiCache.set(apiCache.KEYS.APP_DATA, appConfig);
+    // apiCache.set(apiCache.KEYS.APP_CACHE, appCache);
+
+    // await this.initConfig(appConfig);
+    apiCache.clearTemplateCache();
+
+    appConfig.dbConfig.filename = path.join(appConfig.dataPath, 'sqlite3.db');
+    await this.initDb(appConfig.dbConfig);
+  }
+
+  private async initDb(config: DbConfig) {
+    const db = await DbHelper.createInstance(config);
+    apiCache.set(apiCache.KEYS.DB, db);
+    return db;
+  }
+
+  // private async initConfig(appConfig: HostToPathProps) {
+  //   await AppConfig.load(appConfig.dataPath);
+  // }
+}