@abtnode/webapp 1.8.63-beta-a36b5e1a → 1.8.63

package/api/routes/blocklet-preference.js

@@ -1,161 +0,0 @@
-const fs = require('fs-extra');
-const qs = require('querystring');
-const get = require('lodash/get');
-const joinUrl = require('url-join');
-const express = require('express');
-const multer = require('multer');
-const serveStatic = require('serve-static');
-const path = require('path');
-const { BLOCKLET_PREFERENCE_FILE, BLOCKLET_PREFERENCE_PREFIX, BLOCKLET_UPLOADS_DIR } = require('@blocklet/constant');
-const { WELLKNOWN_SERVICE_PATH_PREFIX } = require('@abtnode/constant');
-
-const mutateBlockletPermission = require('../middlewares/mutate-blocklet-permission');
-const DiskStorage = require('../libs/storage');
-
-// For reading and updating blocklet preferences
-module.exports = {
-  init(app, node) {
-    // find a component from the dependency tree
-    const findComponent = (parent, id) => {
-      if (parent.env.id === id) {
-        return parent;
-      }
-
-      const possible = parent.children.find(x => id.startsWith(x.env.id));
-      return possible ? findComponent(possible, id) : null;
-    };
-
-    const mergeConfigToSchema = (properties, configs, uploadAction) => {
-      Object.keys(properties).forEach(key => {
-        const prop = properties[key];
-        if (prop.properties) {
-          mergeConfigToSchema(prop.properties, configs, uploadAction);
-        }
-        if (prop['x-decorator'] === 'FormItem') {
-          const prefixedKey = `${BLOCKLET_PREFERENCE_PREFIX}${key}`;
-          if (typeof configs[prefixedKey] !== 'undefined') {
-            prop.default = configs[prefixedKey];
-          }
-          if (prop['x-component'].startsWith('Upload') && !prop['x-component-props'].action) {
-            prop['x-component-props'].action = uploadAction;
-          }
-        }
-      });
-    };
-
-    const ensurePermission = mutateBlockletPermission(node);
-
-    const ensureBlocklet = async (req, res, next) => {
-      if (!req.query.id) {
-        return res.status(400).json({ code: 'bad_request', error: 'no blocklet did' });
-      }
-
-      const [did] = req.query.id.split('/');
-      req.blocklet = await node.getBlocklet({ did, attachRuntimeInfo: false });
-      if (!req.blocklet) {
-        return res.status(400).json({ code: 'bad_request', error: 'blocklet not found' });
-      }
-
-      return next();
-    };
-
-    const ensureComponent = (req, res, next) => {
-      req.component = findComponent(req.blocklet, req.query.id);
-      if (!req.component) {
-        return res.status(400).json({ code: 'bad_request', error: 'component not found' });
-      }
-
-      return next();
-    };
-
-    const uploadApi = '/api/uploads';
-
-    // load preferences schema
-    app.get('/api/preferences', ensurePermission, ensureBlocklet, ensureComponent, async (req, res) => {
-      const schemaFile = path.join(req.component.env.appDir, BLOCKLET_PREFERENCE_FILE);
-      if (fs.existsSync(schemaFile)) {
-        try {
-          const info = await node.getNodeInfo();
-          const isFromService = req.get('source') === 'blocklet-service';
-          const uploadAction = joinUrl(
-            // eslint-disable-next-line no-nested-ternary
-            isFromService
-              ? joinUrl(WELLKNOWN_SERVICE_PATH_PREFIX, uploadApi)
-              : process.env.NODE_ENV === 'production'
-              ? joinUrl(info.routing.adminPath, uploadApi)
-              : uploadApi,
-            `?${qs.stringify(req.query)}`
-          );
-
-          const schema = JSON.parse(fs.readFileSync(schemaFile, 'utf8'));
-          mergeConfigToSchema(get(schema, 'schema.properties', {}), req.component.configObj, uploadAction);
-          return res.json(schema);
-        } catch (err) {
-          console.error(err);
-          return res.json({});
-        }
-      }
-
-      return res.json({});
-    });
-
-    // save preferences data
-    app.post('/api/preferences', ensurePermission, ensureBlocklet, ensureComponent, async (req, res) => {
-      const configs = Object.keys(req.body).reduce((acc, key) => {
-        const value = req.body[key];
-        acc.push({ key: `${BLOCKLET_PREFERENCE_PREFIX}${key}`, value });
-        return acc;
-      }, []);
-      await node.configBlocklet({ did: req.query.id.split('/'), configs }, { user: req.user });
-      res.json(req.body);
-    });
-
-    // download dataDir
-    // FIXME: we should limit this feature when dataDir is too large
-    app.get('/api/export', ensurePermission, ensureBlocklet, async (req, res) => {
-      const timestamp = new Date().toISOString().split('.')[0].split(':').join('-').replaceAll('-', '');
-      const fileName = `blocklet-${req.blocklet.env.appId}-${timestamp}.zip`;
-      const filePath = await node.createBlockletDataArchive(req.blocklet.env.dataDir, fileName);
-      res.download(filePath, err => err && console.error(err));
-    });
-
-    const upload = multer({
-      storage: new DiskStorage({
-        destination: (req, file, cb) => {
-          const uploadDir = path.join(req.blocklet.env.dataDir, BLOCKLET_UPLOADS_DIR);
-          if (fs.existsSync(uploadDir) === false) {
-            fs.mkdirSync(uploadDir, { recursive: true });
-          }
-          cb(null, uploadDir);
-        },
-      }),
-    });
-
-    // handle upload for blocklet prefs
-    // FIXME: should also ensurePermission here
-    app.post(uploadApi, ensureBlocklet, ensureComponent, upload.single('file'), async (req, res) => {
-      res.json({
-        url: joinUrl(
-          req.blocklet.environmentObj.BLOCKLET_APP_URL,
-          WELLKNOWN_SERVICE_PATH_PREFIX,
-          BLOCKLET_UPLOADS_DIR,
-          req.file.filename
-        ),
-      });
-    });
-
-    const staticOptions = {
-      maxAge: '30d',
-      extensions: ['html', 'htm'],
-      index: ['index.html', 'index.htm'],
-      setHeaders: (res, file) => {
-        if (serveStatic.mime.lookup(file) === 'text/html') {
-          res.setHeader('Cache-Control', 'public, max-age=0');
-        }
-      },
-    };
-
-    // serve hosted version
-    app.use('/hosted/form-collector', express.static(node.collectorPath, staticOptions));
-  },
-};

package/api/routes/blocklet-proxy.js

@@ -1,220 +0,0 @@
-/* eslint-disable no-underscore-dangle, global-require */
-/* eslint-disable no-console */
-const httpProxy = require('http-proxy');
-const LRU = require('lru-cache');
-const { isValid } = require('@arcblock/did');
-const { BlockletEvents } = require('@blocklet/constant');
-const md5 = require('@abtnode/util/lib/md5');
-const { BLOCKLET_PROXY_PATH_PREFIX, WELLKNOWN_SERVICE_PATH_PREFIX, EVENTS } = require('@abtnode/constant');
-const { forEachBlocklet } = require('@blocklet/meta/lib/util');
-
-const get = require('lodash/get');
-
-const logger = require('@abtnode/logger')(`${require('../../package.json').name}:blockletProxy`);
-
-const findRoutingRule = require('../util/find-routing-rule');
-
-const createLRU = opts => new LRU(opts);
-
-const GENERIC_GROUP = 'GENERIC';
-
-const createProxyCache = opts => {
-  const groups = {};
-
-  const resetGroup = did => {
-    logger.info('Reset cache group', { did });
-    groups[did] = createLRU(opts);
-  };
-
-  resetGroup(GENERIC_GROUP);
-
-  return {
-    set(did, key, value) {
-      if (!groups[did]) {
-        resetGroup(did);
-      }
-      groups[did].set(key, value);
-    },
-    get(did, key) {
-      return groups[did] ? groups[did].get(key) : undefined;
-    },
-    resetGroup,
-    deleteGroup(did) {
-      logger.info('Delete cache group', { did });
-      delete groups[did];
-    },
-  };
-};
-
-const ensureUrl = (req, urlPrefix) => {
-  req.url = req.url.slice(urlPrefix.length);
-
-  // convert all faviconXXX to favicon to ensure file exists in root blocklet
-  if (req.url.startsWith('/favicon')) {
-    req.url = '/favicon.ico';
-  }
-};
-
-module.exports = {
-  createProxyCache,
-  init(app, node, proxy, proxyCache) {
-    if (process.env.NODE_ENV !== 'test' && (proxy || proxyCache)) {
-      throw new Error('proxy or proxyCache should only be invoked in test environment');
-    }
-
-    if (!proxy) {
-      // eslint-disable-next-line no-param-reassign
-      proxy = httpProxy.createProxyServer({
-        timeout: 3600 * 1000,
-        proxyTimeout: 3600 * 1000,
-      });
-    }
-
-    if (!proxyCache) {
-      // eslint-disable-next-line no-param-reassign
-      proxyCache = createProxyCache({
-        // FIXME: 如果 css 文件加载后, css文件中的 font 文件没有被立即加载, 期间加载了超过 50 个其他的文件, 再加载 css 文件中的 font 文件, 则 font 文件会无法加载. 这种情况可能会在 abt web wallet 中出现
-        max: 50, // cache at most 50
-        maxAge: 1 * 60 * 1000, // cache for 1 minute
-      });
-    }
-
-    const refreshSites = async () => {
-      try {
-        const sites = await node.getSitesFromSnapshot();
-        proxyCache.set(GENERIC_GROUP, 'SITES', sites);
-        return sites;
-      } catch (err) {
-        logger.error('refreshSites failed', { error: err });
-        return [];
-      }
-    };
-
-    [BlockletEvents.started, BlockletEvents.reloaded].forEach(event => {
-      node.on(event, blocklet => {
-        forEachBlocklet(
-          blocklet,
-          b => {
-            proxyCache.resetGroup(get(b, 'meta.did'));
-          },
-          { sync: true }
-        );
-      });
-    });
-
-    node.on(BlockletEvents.removed, blocklet => {
-      forEachBlocklet(
-        blocklet,
-        b => {
-          proxyCache.deleteGroup(get(b, 'meta.did'));
-        },
-        { sync: true }
-      );
-    });
-
-    node.on(EVENTS.ROUTING_UPDATED, refreshSites);
-
-    /**
-     * match request
-     * e.g.
-     *   /.blocklet/proxy/<did>/a.css
-     *   /.blocklet/proxy/path/a.css
-     */
-    app.get(`${BLOCKLET_PROXY_PATH_PREFIX}/:did/**`, async (req, res, next) => {
-      const { did } = req.params;
-
-      // proxy to blocklet service
-      if (did === 'blocklet-service') {
-        req.url = req.url.replace(`${BLOCKLET_PROXY_PATH_PREFIX}/${did}`, `${WELLKNOWN_SERVICE_PATH_PREFIX}/static`);
-        const target = `http://127.0.0.1:${process.env.ABT_NODE_SERVICE_PORT}`;
-        proxy.web(req, res, { target }, error => {
-          if (error) {
-            logger.error('http proxy error', { error });
-            res.status(502).send(`Can not proxy to blocklet service: ${target}`);
-          }
-        });
-        return;
-      }
-
-      if (isValid(did)) {
-        req.PROXY_PATH_PREFIX_DID = did;
-        req.PROXY_PATH_PREFIX = `${BLOCKLET_PROXY_PATH_PREFIX}/${did}`;
-      }
-      next();
-    });
-
-    /**
-     * match request
-     * e.g.
-     *   /.blocklet/proxy/<did>/a.css
-     *   /.blocklet/proxy/path/a.css
-     *   /.blocklet/proxy/a.css
-     */
-    app.get(`${BLOCKLET_PROXY_PATH_PREFIX}/**`, async (req, res) => {
-      if (!req.headers.referer) {
-        res.status(400).send('Referer was not found in headers');
-        return;
-      }
-
-      const urlPrefix = req.PROXY_PATH_PREFIX || BLOCKLET_PROXY_PATH_PREFIX;
-
-      const group = req.PROXY_PATH_PREFIX_DID || GENERIC_GROUP;
-
-      // get origin by referer because the origin of referer of css resource and font resource are same
-      // e.g. https://a.b.c:8080/.blocklet/proxy/style.css | referer: https://a.b.c:8080/ | origin: https://a.b.c:8080
-      //      https://a.b.c:8080/.blocklet/proxy/font.woff | referer: https://a.b.c:8080/.blocklet/proxy/style.css | origin: https://a.b.c:8080
-      const cacheUrl = md5(`${new URL(req.headers.referer).origin}${req.url}${req.search || ''}`);
-
-      const cacheKey = md5(`${cacheUrl}${req.headers.referer}`);
-      const cacheReferer = md5(req.headers.referer);
-
-      // use cache target if exist
-      const cachedTarget = proxyCache.get(group, cacheKey) || proxyCache.get(group, cacheReferer);
-      if (cachedTarget) {
-        ensureUrl(req, urlPrefix);
-
-        proxy.web(req, res, { target: cachedTarget }, error => {
-          if (error) {
-            logger.error('http proxy error', { error });
-            res.status(502).send(`Can not proxy to upstream blocklet: ${cachedTarget}`);
-          }
-        });
-        return;
-      }
-
-      // get sites
-      let sites = proxyCache.get(GENERIC_GROUP, 'SITES');
-      if (!sites) {
-        sites = await refreshSites();
-      }
-
-      // find routing rule
-      const rule = findRoutingRule(sites, req, urlPrefix);
-
-      // proxy to target is matched rule was founded
-      if (rule) {
-        const target = `http://127.0.0.1:${rule.to.port}`;
-
-        // cache the target for subsequent requests with the same url and referer
-        proxyCache.set(group, cacheKey, target);
-
-        // cache the target for subsequent requests request which referer is this url
-        // e.g. current request: http://a.com/.blocklet/proxy/a.css
-        //      follow-up request: http://a.com/.blocklet/proxy/font.woff (referer is http://a.com/.blocklet/proxy/a.css)
-        proxyCache.set(group, cacheUrl, target);
-
-        ensureUrl(req, urlPrefix);
-
-        proxy.web(req, res, { target }, error => {
-          if (error) {
-            logger.error('http proxy error', { error });
-            res.status(502).send(`Can not proxy to upstream blocklet: ${target}`);
-          }
-        });
-        return;
-      }
-
-      res.status(400).send(`Cannot find blocklet served at ${req.hostname}`);
-    });
-  },
-};

package/api/routes/did-resolver.js

@@ -1,38 +0,0 @@
-const { WELLKNOWN_DID_RESOLVER_PREFIX } = require('@abtnode/constant');
-
-const getDidDocumentMiddleware = node => async (req, res) => {
-  const blockletDid = req.get('x-blocklet-did');
-  if (!blockletDid) {
-    return res.status(404).json({ message: 'Service can not be found' });
-  }
-
-  const { did: serverDid } = await node.getNodeInfo();
-  let appId = serverDid;
-  let did = serverDid;
-
-  if (blockletDid !== serverDid) {
-    const blocklet = await node.getBlocklet({ did: blockletDid, attachRuntimeInfo: false });
-    if (!blocklet) {
-      return res.status(404).json({ message: 'Service can not be found' });
-    }
-
-    appId = blocklet.appDid;
-    did = blockletDid;
-  }
-
-  const document = {
-    id: `did:abt:${appId}`,
-    alsoKnownAs: [`did:abt:${did}`],
-    controller: `did:abt:${serverDid}`,
-    services: [],
-  };
-
-  return res.json(document);
-};
-
-module.exports = {
-  init(app, node) {
-    app.get(WELLKNOWN_DID_RESOLVER_PREFIX, getDidDocumentMiddleware(node));
-  },
-  getDidDocumentMiddleware,
-};

package/api/routes/dns-resolver.js

@@ -1,73 +0,0 @@
-const dns = require('dns');
-const LRU = require('lru-cache');
-const joinUrl = require('url-join');
-const axios = require('@abtnode/util/lib/axios');
-const { DEFAULT_IP_DOMAIN, DEFAULT_ADMIN_PATH } = require('@abtnode/constant');
-
-const getNodeDomain = ip => (ip ? DEFAULT_IP_DOMAIN.replace(/^\*/, ip.replace(/\./g, '-')) : '');
-
-const timeout = process.env.NODE_ENV === 'test' ? 500 : 2000;
-
-// check if node dashboard https endpoint return 2xx
-const checkConnected = async ({ ip, nodeInfo }) => {
-  const { adminPath = DEFAULT_ADMIN_PATH } = nodeInfo.routing || {};
-  const origin = `https://${getNodeDomain(ip)}`;
-  const endpoint = joinUrl(origin, adminPath);
-  await axios.get(endpoint, { timeout });
-};
-
-module.exports = {
-  init(router, node) {
-    const cache = new LRU({
-      max: 50, // cache at most 50
-      maxAge: 5 * 60 * 1000, // cache for 5 minute
-    });
-
-    const accessibleCache = new LRU({
-      max: 50, // cache at most 50
-      maxAge: 5 * 60 * 1000, // cache for 5 minute
-    });
-
-    router.get('/api/dns-resolve/', async (req, res) => {
-      const hostname = req.query.hostname || req.hostname;
-      const accessible = !!req.query.accessible;
-
-      const _cache = accessible ? accessibleCache : cache;
-
-      const cachedAddress = _cache.get(hostname);
-
-      if (cachedAddress) {
-        res.json({ address: cachedAddress });
-        return;
-      }
-
-      dns.lookup(hostname, async (err, address, family) => {
-        if (err) {
-          _cache.del(hostname);
-          res.json({ address: null, error: err.message });
-          return;
-        }
-
-        if (family !== 4) {
-          _cache.del(hostname);
-          res.json({ address: null, error: 'address is not IPv4 format' });
-        }
-
-        if (accessible) {
-          const nodeInfo = await node.getNodeInfo();
-          try {
-            await checkConnected({ ip: address, nodeInfo });
-            _cache.set(hostname, address);
-            res.json({ address });
-          } catch {
-            _cache.del(hostname);
-            res.json({ address: null, error: 'address is not accessible' });
-          }
-        } else {
-          _cache.set(hostname, address);
-          res.json({ address });
-        }
-      });
-    });
-  },
-};

package/api/routes/log.js

@@ -1,31 +0,0 @@
-const dayjs = require('dayjs');
-const { createDownloadLogStream } = require('@abtnode/util/lib/log');
-
-const mutateBlockletPermission = require('../middlewares/mutate-blocklet-permission');
-
-module.exports = {
-  init(app, node) {
-    const ensurePermission = mutateBlockletPermission(node);
-
-    app.get('/api/download/log/:did', ensurePermission, async (req, res) => {
-      const { did } = req.params;
-      const { days } = req.query;
-
-      if (days > 7) {
-        res.status(400).send('Interval should not > 1 week');
-        return;
-      }
-
-      try {
-        const stream = await createDownloadLogStream({ node, did, days });
-
-        res.setHeader('Content-Type', 'application/octet-stream');
-        res.setHeader('Content-Disposition', `attachment;filename=${did}.${dayjs().format('YYYYMMDDHHmmss')}.log.zip`);
-
-        stream.pipe(res);
-      } catch (error) {
-        res.status(500).send(error.message);
-      }
-    });
-  },
-};

package/api/routes/passport.js

@@ -1,19 +0,0 @@
-const { getPassportStatus } = require('@abtnode/auth/lib/auth');
-
-module.exports = {
-  init(router, node) {
-    router.get('/api/passport/status', async (req, res) => {
-      const { vcId, userDid, locale } = req.query;
-      const nodeInfo = await node.getNodeInfo();
-      const teamDid = nodeInfo.did;
-
-      if (teamDid !== req.query.teamDid) {
-        throw new Error('teamDid is invalid');
-      }
-
-      const status = await getPassportStatus({ node, teamDid, userDid, vcId, locale });
-
-      res.json(status);
-    });
-  },
-};

package/api/routes/session.js

@@ -1,61 +0,0 @@
-const url = require('url');
-const SealedBox = require('tweetnacl-sealedbox-js');
-const { getBaseUrl } = require('@abtnode/router-adapter');
-const { decodeEncryptionKey } = require('@abtnode/util/lib/security');
-
-const env = require('../libs/env');
-const { createSessionToken } = require('../libs/login');
-
-module.exports = {
-  init(app, node) {
-    // eslint-disable-next-line consistent-return
-    app.get('/api/did/session', async (req, res) => {
-      // Must be some one try to trick daemon with a blocklet token
-      if (req.user && req.user.bid) {
-        return res.status(403).send('Forbidden');
-      }
-
-      if (!req.user) {
-        return res.json({});
-      }
-
-      // Authentication request from dashboard
-      const user = { ...req.user };
-      const rbac = await node.getRBAC();
-      user.permissions = await rbac.getScope(user.role);
-
-      const encKey = '_ek_';
-      let nextToken = '';
-      if (req.query[encKey]) {
-        try {
-          const encryptionKey = decodeEncryptionKey(req.query[encKey]);
-          nextToken = JSON.stringify(await createSessionToken(user.did, { passport: user.passport, role: user.role }));
-          nextToken = Buffer.from(SealedBox.seal(Buffer.from(nextToken), encryptionKey)).toString('base64');
-        } catch {
-          // Do nothing
-        }
-      }
-
-      res.json({ user, nextToken });
-    });
-
-    app.get('/api/env', async (req, res) => {
-      res.type('js');
-
-      const info = await node.getNodeInfo();
-      const baseUrl = url.format({
-        protocol: req.protocol,
-        host: req.get('host'),
-        pathname: '',
-      });
-
-      res.send(`window.env = {
-  appId: "${info.did}",
-  appName: "${info.name}",
-  appDescription: "${info.description}",
-  apiPrefix: "${getBaseUrl(req)}",
-  baseUrl: "${env.baseUrl || baseUrl}",
-}`);
-    });
-  },
-};

package/api/routes/user.js

@@ -1,38 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-const { NODE_DATA_DIR_NAME, USER_AVATAR_PATH_PREFIX } = require('@abtnode/constant');
-const { getAvatarFile } = require('@abtnode/util/lib/user-avatar');
-
-module.exports = {
-  init(app, node) {
-    // eslint-disable-next-line consistent-return
-    app.get(`${USER_AVATAR_PATH_PREFIX}/:did/:fileName`, async (req, res) => {
-      const sendOptions = { maxAge: '1y' };
-      const info = await node.getNodeInfo();
-      const { did, fileName } = req.params;
-
-      let dataDir;
-      if (did === info.did) {
-        dataDir = path.join(node.dataDirs.data, NODE_DATA_DIR_NAME);
-      } else {
-        const blocklet = await node.getBlocklet({ did, attachConfig: false });
-        if (!blocklet) {
-          res.status(404).send('Blocklet Not Found');
-          return;
-        }
-
-        dataDir = path.join(node.dataDirs.data, blocklet.meta.name);
-      }
-
-      const avatarFile = getAvatarFile(dataDir, fileName);
-
-      if (!fs.existsSync(avatarFile)) {
-        res.status(404).send('Avatar Not Found');
-        return;
-      }
-
-      res.sendFile(avatarFile, sendOptions);
-    });
-  },
-};