@abtnode/webapp 1.8.63-beta-c51e554d → 1.8.63-beta-b0b23c2b

package/api/util/find-routing-rule.js

@@ -0,0 +1,95 @@
+const {
+  DOMAIN_FOR_IP_SITE_REGEXP,
+  DOMAIN_FOR_DEFAULT_SITE,
+  ROUTING_RULE_TYPES,
+  SLOT_FOR_IP_DNS_SITE,
+} = require('@abtnode/constant');
+const checkDomainMatch = require('@abtnode/util/lib/check-domain-match');
+
+const LOCALHOST = 'localhost';
+
+const findSite = (sites, req) => {
+  const site = sites.find(x => {
+    if (x.domain === DOMAIN_FOR_IP_SITE_REGEXP || x.domain === DOMAIN_FOR_DEFAULT_SITE) {
+      return false;
+    }
+    if (checkDomainMatch(req.hostname, x.domain)) {
+      return true;
+    }
+    if ((x.domainAliases || []).some(y => checkDomainMatch(req.hostname, y.value))) {
+      return true;
+    }
+
+    const ipDomain = (x.domainAliases || []).find(y => (y.value || '').includes(SLOT_FOR_IP_DNS_SITE));
+    if (ipDomain && ipDomain.value) {
+      const [startWith, endWith] = ipDomain.value.split(SLOT_FOR_IP_DNS_SITE);
+      if (req.hostname.startsWith(startWith) && req.hostname.endsWith(endWith)) {
+        return true;
+      }
+    }
+
+    if (x.domain.includes(SLOT_FOR_IP_DNS_SITE)) {
+      const [startWith, endWith] = x.domain.split(SLOT_FOR_IP_DNS_SITE);
+      if (req.hostname.startsWith(startWith) && req.hostname.endsWith(endWith)) {
+        return true;
+      }
+    }
+    return false;
+  });
+  if (site) {
+    return site;
+  }
+
+  const dashboardSite = sites.find(x => {
+    if (x.domain === DOMAIN_FOR_IP_SITE_REGEXP) {
+      if (req.hostname === LOCALHOST) {
+        return true;
+      }
+      // eslint-disable-next-line prefer-regex-literals
+      if (new RegExp('^\\d+.\\d+.\\d+.\\d+$').test(req.hostname)) {
+        return true;
+      }
+    }
+    return (x.domainAliases || []).some(y => checkDomainMatch(req.hostname, y.value));
+  });
+  if (dashboardSite) {
+    return dashboardSite;
+  }
+
+  const defaultSite = sites.find(x => x.domain === DOMAIN_FOR_DEFAULT_SITE);
+  const mergeDashboardSite = sites.find(x => x.domain === DOMAIN_FOR_IP_SITE_REGEXP);
+  if (defaultSite) {
+    const x = Object.assign({}, defaultSite);
+    if (mergeDashboardSite) {
+      x.rules = [...x.rules, ...mergeDashboardSite.rules];
+    }
+    return x;
+  }
+
+  return null;
+};
+
+module.exports = function findRoutingRule(sites, req, urlPrefix = '') {
+  if (!req || !req.hostname || !req.headers || !req.headers.referer) {
+    return null;
+  }
+
+  const site = findSite(sites, req);
+
+  if (!site) {
+    return null;
+  }
+
+  const rules = (site.rules || [])
+    .filter(x => x.to.type === ROUTING_RULE_TYPES.BLOCKLET)
+    .sort((a, b) => (a.from.pathPrefix.length > b.from.pathPrefix.length ? -1 : 1));
+
+  const refererPath = new URL(req.headers.referer).pathname;
+
+  // return root blocklet's rule (usually last in sorted rules) for favicon
+  if (req.url.startsWith(`${urlPrefix}/favicon`)) {
+    return rules[rules.length - 1];
+  }
+
+  return rules.find(x => refererPath.startsWith(x.from.pathPrefix.replace(/\/+$/, '')));
+};

package/api/util/get-configs.js

@@ -0,0 +1,31 @@
+const { forEachBlockletSync, getSharedConfigObj, isEnvShareable } = require('@blocklet/meta/lib/util');
+
+/**
+ * Get configs of root blocklet or child blocklet
+ * @param {*} blocklet
+ * @param {*} componentId
+ * @returns
+ */
+module.exports = (blocklet, componentId) => {
+  let res = {};
+  forEachBlockletSync(blocklet, (component, { id, ancestors }) => {
+    if (id !== componentId) {
+      return;
+    }
+
+    const configs = component.configs.filter(x => isEnvShareable(x));
+    const configObj = configs.reduce((o, x) => {
+      o[x.key] = x.value;
+      return o;
+    }, {});
+
+    const sharedObj = getSharedConfigObj(component, ancestors);
+    for (const [key, value] of Object.entries(sharedObj)) {
+      configObj[key] = value;
+    }
+
+    res = configObj;
+  });
+
+  return Object.entries(res).map(([key, value]) => ({ key, value }));
+};

package/api/util/index.js

@@ -0,0 +1,5 @@
+const joinUrl = require('url-join');
+
+const getBlockletUrl = (registryUrl, did) => joinUrl(registryUrl, `/api/blocklets/${did}/blocklet.json`);
+
+module.exports = { getBlockletUrl };

package/api/util/navigation.js

@@ -0,0 +1,84 @@
+const { WELLKNOWN_SERVICE_PATH_PREFIX } = require('@abtnode/constant');
+
+const fillDashboardNavigation = navigation => {
+  if (!navigation.some(x => x.id === '/access')) {
+    navigation.push({
+      id: '/access',
+      from: 'tmpl',
+      title: {
+        en: 'Access',
+        zh: '访问控制',
+      },
+      role: ['owner', 'admin', 'member'],
+      section: ['dashboard'],
+      link: '',
+      items: [
+        {
+          id: 'member',
+          from: 'tmpl',
+          title: {
+            en: 'Members',
+            zh: '成员',
+          },
+          icon: 'ant-design:user-outlined',
+          link: `${WELLKNOWN_SERVICE_PATH_PREFIX}/admin/members`,
+        },
+        {
+          id: 'passport',
+          from: 'tmpl',
+          title: {
+            en: 'Passport',
+            zh: '通行证',
+          },
+          icon: 'icon-park-outline:passport',
+          link: `${WELLKNOWN_SERVICE_PATH_PREFIX}/admin/passports`,
+        },
+      ],
+    });
+  }
+
+  if (!navigation.some(x => x.id === '/dashboard')) {
+    navigation.push({
+      id: '/dashboard',
+      from: 'tmpl',
+      title: 'Blocklet',
+      role: ['owner', 'admin'],
+      section: ['dashboard'],
+      link: '',
+      items: [
+        {
+          id: 'dashboard',
+          from: 'tmpl',
+          title: {
+            en: 'Dashboard',
+            zh: '仪表盘',
+          },
+          icon: 'ant-design:dashboard-outlined',
+          link: `${WELLKNOWN_SERVICE_PATH_PREFIX}/admin`,
+        },
+      ],
+    });
+  }
+};
+
+const ensureSessionManagerNavigation = navigation => {
+  if (!navigation.some(x => (x.section || []).includes('sessionManager'))) {
+    navigation.push({
+      id: '/sessionManager',
+      from: 'tmpl',
+      title: {
+        en: 'Manage',
+        zh: '管理',
+      },
+      section: ['sessionManager'],
+      icon: 'ion:settings-outline',
+      link: `${WELLKNOWN_SERVICE_PATH_PREFIX}/admin`,
+      role: ['owner', 'admin'],
+    });
+  }
+};
+
+module.exports = {
+  fillDashboardNavigation,
+  ensureSessionManagerNavigation,
+};

package/api/webpack.blocklet.js

@@ -0,0 +1,43 @@
+const fs = require('fs');
+// eslint-disable-next-line import/no-extraneous-dependencies
+const { BundleAnalyzerPlugin } = require('webpack-bundle-analyzer');
+
+const env = process.env.NODE_ENV || 'development';
+
+const extraPlugins = [];
+if (process.env.ANALYZE_BUNDLE) {
+  extraPlugins.push(new BundleAnalyzerPlugin({ analyzerMode: 'static' }));
+}
+
+const extraAliases = {};
+if (process.env.NODE_ENV === 'production') {
+  const targetPath = require.resolve('express-graphql/renderGraphiQL');
+  const sourcePath = require.resolve('@abtnode/mocks/lib/graphiql');
+  fs.unlinkSync(targetPath);
+  fs.copyFileSync(sourcePath, targetPath);
+}
+
+module.exports = webpack => ({
+  optimization: {
+    nodeEnv: env, // @link https://github.com/webpack/webpack/issues/7470#issuecomment-394259698
+  },
+  resolve: {
+    alias: {
+      axios: require.resolve('axios'),
+      debug: require.resolve('debug'),
+      jspdf: require.resolve('@abtnode/mocks/lib/jspdf'),
+      isobject: require.resolve('@abtnode/mocks/lib/isobject'),
+      'vue-template-compiler': require.resolve('@abtnode/mocks/lib/vue-template-compiler'),
+      'bn.js': require.resolve('bn.js'),
+      'mime-db': require.resolve('mime-db'),
+      ...extraAliases,
+    },
+  },
+  plugins: [
+    new webpack.DefinePlugin({
+      'process.env.NODE_ENV': JSON.stringify(env),
+      'process.env.TEST_BUILD': JSON.stringify(process.env.TEST_BUILD),
+    }),
+    ...extraPlugins,
+  ],
+});

package/api/ws/index.js

@@ -0,0 +1,146 @@
+const { WsServer } = require('@arcblock/ws');
+const { types } = require('@ocap/mcrypto');
+const { fromSecretKey, WalletType } = require('@ocap/wallet');
+
+const { BlockletEvents } = require('@blocklet/constant');
+const { EVENTS } = require('@abtnode/constant');
+const { createStreamLogManager, getLogFiles } = require('@abtnode/util/lib/log');
+
+// eslint-disable-next-line global-require
+const logger = require('@abtnode/logger')(`${require('../../package.json').name}:ws`);
+
+const { authWithJwt } = require('../libs/login');
+
+logger.debug = () => null;
+
+module.exports = function createWebsocketServer(node) {
+  const wsServer = new WsServer({
+    logger,
+    pathname: '/websocket',
+    authenticate: (req, cb) => {
+      const { searchParams } = new URL(req.url, `http://${req.headers.host || 'unknown'}`);
+      const token = searchParams.get('token');
+      const timestamp = searchParams.get('timestamp');
+      if (!token) {
+        cb(new Error('token not found'), null);
+        return;
+      }
+
+      // Authentication CLI: who knows the SK of the node
+      if (token && timestamp) {
+        node.getNodeInfo().then(info => {
+          const wallet = fromSecretKey(
+            info.sk,
+            WalletType({
+              role: types.RoleType.ROLE_APPLICATION,
+              pk: types.KeyType.ED25519,
+              hash: types.HashType.SHA3,
+            })
+          );
+
+          if (wallet.verify(timestamp, token)) {
+            cb(null, { did: info.did });
+          } else {
+            cb(new Error('Signature is invalid'), null);
+          }
+        });
+      } else {
+        // Authentication web users
+        authWithJwt(token, node)
+          .then(user => {
+            cb(null, { did: user.did });
+          })
+          .catch(() => {
+            cb(new Error('token parse fail'), null);
+          });
+      }
+    },
+    hooks: {
+      receiveMessage: ({ socket, topic, event, payload }) => {
+        wsServer.emit(`${topic}/${event}`, { socket, topic, event, payload });
+        logger.info('client pushed socket message', { topic, event });
+      },
+    },
+  });
+
+  // Publish CLI generated events to web dashboard clients
+  const onCLIEvent = ({ event, payload }) => {
+    if (event) {
+      if (Object.values(BlockletEvents).includes(event) && typeof node.handleBlockletEvent === 'function') {
+        node.handleBlockletEvent(event, payload);
+        return;
+      }
+
+      if ([EVENTS.NODE_STARTED, EVENTS.NODE_STOPPED].includes(event) && typeof node.handleServerEvent === 'function') {
+        node.handleServerEvent(event, payload);
+        return;
+      }
+
+      wsServer.broadcast(event, payload);
+    }
+  };
+  wsServer.on('cli/blocklet.installed', onCLIEvent);
+  wsServer.on('cli/blocklet.upgraded', onCLIEvent);
+  wsServer.on('cli/blocklet.statusChange', onCLIEvent);
+  wsServer.on('cli/blocklet.started', onCLIEvent);
+  wsServer.on('cli/blocklet.removed', onCLIEvent);
+  wsServer.on('cli/blocklet.updated', onCLIEvent);
+  wsServer.on('cli/routing.updated', onCLIEvent);
+  wsServer.on('cli/node.stopped', onCLIEvent);
+  wsServer.on('cli/node.started', onCLIEvent);
+  wsServer.on('cli/node.upgrading', onCLIEvent);
+
+  const streamLogManager = createStreamLogManager({
+    onGetLogFiles: name => getLogFiles({ name, node }),
+    onLog: ({ topic, level, logFiles, data }) => {
+      wsServer.broadcast(topic, topic, { level, logFiles, data }, { enableLog: false });
+    },
+  });
+
+  const onChannelEvent = async (eventName, { socket, topic }) => {
+    const [type, ...names] = topic.split('.');
+    if (type === 'log') {
+      const name = names.join('.');
+      if (eventName === 'channel.join') {
+        streamLogManager.add(name, topic, (level, data, logFiles) => {
+          wsServer.send(socket, topic, topic, { level, data, logFiles }, { enableLog: false });
+        });
+      }
+
+      if (eventName === 'channel.destroy') {
+        streamLogManager.destroy(name);
+      }
+    }
+
+    if (topic === EVENTS.NODE_RUNTIME_INFO) {
+      if (eventName === 'channel.join') {
+        const info = node.getNodeRuntimeInfo();
+        wsServer.send(socket, topic, topic, info, { enableLog: false });
+      }
+    }
+  };
+
+  ['channel.join', 'channel.leave', 'channel.destroy'].forEach(name => {
+    wsServer.on(name, payload => onChannelEvent(name, payload));
+  });
+
+  node.setEventHandler(({ name, data }) => {
+    if (name === BlockletEvents.removed) {
+      // remove blocklet log stream
+      try {
+        const { did } = data.meta;
+        const logName = `blocklet-${did}`;
+        logger.info('destroy blocklet log stream', { name: logName });
+        streamLogManager.destroy(logName);
+      } catch (error) {
+        logger.error('destroy blocklet log stream error', { error });
+      }
+    }
+
+    if (name) {
+      wsServer.broadcast(name, data);
+    }
+  });
+
+  return wsServer;
+};