@abtnode/blocklet-services 1.16.32-beta-4d47ae7f → 1.16.32-beta-0593a408

package/api/services/auth/session.js

@@ -14,7 +14,6 @@ const { LOGIN_PROVIDER } = require('@blocklet/constant');
 const getRequestIP = require('@abtnode/util/lib/get-request-ip');
 
 const isUrl = require('is-url');
-const { PREFIXES } = require('../../util/constants');
 const { createTokenFn, getDidConnectVersion } = require('../../util');
 const checkUser = require('../../middlewares/check-user');
 
@@ -26,204 +25,219 @@ module.exports = {
     } = options;
     const createToken = createTokenFn(createSessionToken);
 
-    PREFIXES.forEach((prefix) => {
-      const handleSession = async (req, res) => {
-        const teamDid = req.getBlockletDid();
-        const { token } = req;
-        let visitorId = req.query?.visitorId;
-        if (!visitorId) {
-          visitorId = req.get('x-blocklet-visitor-id');
-        }
-        const { appPid = teamDid } = req.query;
-        await req.ensureUser({ token, visitorId, appPid });
-        if (!req.user) {
-          res.json({ user: null });
-          return;
-        }
+    const handleSession = async (req, res) => {
+      const teamDid = req.getBlockletDid();
+      const { token } = req;
+      let visitorId = req.query?.visitorId;
+      if (!visitorId) {
+        visitorId = req.get('x-blocklet-visitor-id');
+      }
+      const { appPid = teamDid } = req.query;
+      await req.ensureUser({ token, visitorId, appPid });
+      if (!req.user) {
+        res.json({ user: null });
+        return;
+      }
 
-        const blocklet = await req.getBlocklet();
-        // FIXME: this code have performance issue
-        const user = await node.getUser({ teamDid, user: { did: req.user.did } });
-        if (req.user.role) {
-          const rbac = await node.getRBAC(teamDid);
-          user.permissions = await rbac.getScope(req.user.role);
-          user.role = req.user.role;
-        }
+      const blocklet = await req.getBlocklet();
+      // FIXME: this code have performance issue
+      const user = await node.getUser({ teamDid, user: { did: req.user.did } });
+      if (req.user.role) {
+        const rbac = await node.getRBAC(teamDid);
+        user.permissions = await rbac.getScope(req.user.role);
+        user.role = req.user.role;
+      }
 
-        if (user.avatar && user.avatar.startsWith(USER_AVATAR_URL_PREFIX)) {
-          user.avatar = `${WELLKNOWN_SERVICE_PATH_PREFIX}${USER_AVATAR_PATH_PREFIX}/${
-            user.avatar.split('/').slice(-1)[0]
-          }`;
+      if (user.avatar && user.avatar.startsWith(USER_AVATAR_URL_PREFIX)) {
+        user.avatar = `${WELLKNOWN_SERVICE_PATH_PREFIX}${USER_AVATAR_PATH_PREFIX}/${
+          user.avatar.split('/').slice(-1)[0]
+        }`;
 
-          if (req.get('x-avatar-host') === '1') {
-            const appUrl = blocklet.environmentObj.BLOCKLET_APP_URL;
-            user.avatar = joinURL(appUrl, user.avatar);
-          }
+        if (req.get('x-avatar-host') === '1') {
+          const appUrl = blocklet.environmentObj.BLOCKLET_APP_URL;
+          user.avatar = joinURL(appUrl, user.avatar);
         }
+      }
 
-        user.passports = (user.passports || [])
-          .filter((x) => x.status === PASSPORT_STATUS.VALID)
-          .map((x) => pick(x, ['id', 'name', 'title', 'role']));
+      user.passports = (user.passports || [])
+        .filter((x) => x.status === PASSPORT_STATUS.VALID)
+        .map((x) => pick(x, ['id', 'name', 'title', 'role', 'scope', 'role', 'issuer']));
 
-        res.json({
-          user: omit(user, ['extra']),
-          provider: req.user.provider || LOGIN_PROVIDER.WALLET,
-          walletOS: req.user.walletOS,
-        });
-      };
+      res.json({
+        user: omit(user, ['extra']),
+        provider: req.user.provider || LOGIN_PROVIDER.WALLET,
+        walletOS: req.user.walletOS,
+      });
+    };
 
-      const sessionApi = `${prefix}/api/did/session`;
-      router.get(sessionApi, nocache(), sessionBearerToken, handleSession);
-      router.post(sessionApi, nocache(), sessionBearerToken, handleSession);
+    const sessionApi = `${WELLKNOWN_SERVICE_PATH_PREFIX}/api/did/session`;
+    router.get(sessionApi, nocache(), sessionBearerToken, handleSession);
+    router.post(sessionApi, nocache(), sessionBearerToken, handleSession);
 
-      // update user extra: settings, webhooks
-      const extraApi = `${prefix}/api/user/extra`;
-      router.get(extraApi, nocache(), sessionBearerToken, checkUser, async (req, res) => {
-        const teamDid = req.getBlockletDid();
-        const user = await node.getUser({ teamDid, user: { did: req.user.did } });
-        res.json(user.extra || {});
+    // update user extra: settings, webhooks
+    const extraApi = `${WELLKNOWN_SERVICE_PATH_PREFIX}/api/user/extra`;
+    router.get(extraApi, nocache(), sessionBearerToken, checkUser, async (req, res) => {
+      const teamDid = req.getBlockletDid();
+      const user = await node.getUser({ teamDid, user: { did: req.user.did } });
+      res.json(user.extra || {});
+    });
+    router.post(extraApi, nocache(), sessionBearerToken, checkUser, async (req, res) => {
+      const teamDid = req.getBlockletDid();
+      const exist = await node.getUser({ teamDid, user: { did: req.user.did } });
+      const preSaveData = merge({}, exist.extra || {}, req.body);
+      if (req.body.webhooks) {
+        preSaveData.webhooks = req.body.webhooks;
+      }
+      const user = await node.updateUserExtra({
+        teamDid,
+        did: req.user.did,
+        extra: JSON.stringify(preSaveData),
       });
-      router.post(extraApi, nocache(), sessionBearerToken, checkUser, async (req, res) => {
-        const teamDid = req.getBlockletDid();
-        const exist = await node.getUser({ teamDid, user: { did: req.user.did } });
-        const preSaveData = merge({}, exist.extra || {}, req.body);
-        if (req.body.webhooks) {
-          preSaveData.webhooks = req.body.webhooks;
-        }
-        const user = await node.updateUserExtra({
-          teamDid,
-          did: req.user.did,
-          extra: JSON.stringify(preSaveData),
-        });
-        res.json(user.extra);
+      res.json(user.extra);
+    });
+    router.put(extraApi, nocache(), sessionBearerToken, checkUser, async (req, res) => {
+      if (['slack', 'api'].includes(req.body.type) === false) {
+        res.status(400).send({ error: 'invalid webhook type' });
+        return;
+      }
+
+      if (isUrl(req.body.url) === false) {
+        res.status(400).send({ error: 'invalid webhook url' });
+      }
+
+      await node.sendTestMessage({
+        webhook: { type: req.body.type, params: [{ name: 'url', value: req.body.url }] },
+        message: `This is a test message from user ${req.user.did}`,
       });
-      router.put(extraApi, nocache(), sessionBearerToken, checkUser, async (req, res) => {
-        if (['slack', 'api'].includes(req.body.type) === false) {
-          res.status(400).send({ error: 'invalid webhook type' });
-          return;
-        }
 
-        if (isUrl(req.body.url) === false) {
-          res.status(400).send({ error: 'invalid webhook url' });
-        }
+      res.json({ success: true });
+    });
+
+    router.post(`${WELLKNOWN_SERVICE_PATH_PREFIX}/api/user/notification/unsubscribe`, async (req, res) => {
+      const { wallet } = await req.getBlockletInfo();
+      const { token } = req.body;
+      if (!verify(token, wallet.publicKey)) {
+        res.status(403).send('Invalid token');
+        return;
+      }
 
-        await node.sendTestMessage({
-          webhook: { type: req.body.type, params: [{ name: 'url', value: req.body.url }] },
-          message: `This is a test message from user ${req.user.did}`,
+      const verifyData = decode(token);
+
+      if (verifyData) {
+        const { userDid, channel } = verifyData;
+        const teamDid = req.getBlockletDid();
+        const exist = await node.getUser({ teamDid, user: { did: userDid } });
+        await node.updateUserExtra({
+          teamDid,
+          did: userDid,
+          extra: JSON.stringify(
+            merge({}, exist.extra || {}, {
+              notifications: {
+                [channel]: false,
+              },
+            })
+          ),
         });
+      }
 
-        res.json({ success: true });
-      });
+      res.json({ success: true });
+    });
 
-      router.post(`${prefix}/api/user/notification/unsubscribe`, async (req, res) => {
-        const { wallet } = await req.getBlockletInfo();
-        const { token } = req.body;
-        if (!verify(token, wallet.publicKey)) {
-          res.status(403).send('Invalid token');
+    router.post(`${WELLKNOWN_SERVICE_PATH_PREFIX}/api/did/refreshSession`, refreshBearerToken, async (req, res) => {
+      const token = req.refreshToken;
+      if (token) {
+        const teamDid = req.getBlockletDid();
+        let visitorId = req.query?.visitorId;
+        if (!visitorId) {
+          visitorId = req.get('x-blocklet-visitor-id');
+        }
+        const { appPid = teamDid } = req.query;
+        await req.ensureUser({ token, visitorId, appPid });
+        if (!req.user) {
+          res.status(400).send('user session is logout');
           return;
         }
 
-        const verifyData = decode(token);
+        try {
+          const { secret } = await req.getBlockletInfo();
+          /** @type {import('@abtnode/client').BlockletState} */
+          const blocklet = await req.getBlocklet();
 
-        if (verifyData) {
-          const { userDid, channel } = verifyData;
-          const teamDid = req.getBlockletDid();
-          const exist = await node.getUser({ teamDid, user: { did: userDid } });
-          await node.updateUserExtra({
-            teamDid,
+          const refreshTokenType = 'refresh';
+          const {
             did: userDid,
-            extra: JSON.stringify(
-              merge({}, exist.extra || {}, {
-                notifications: {
-                  [channel]: false,
-                },
-              })
-            ),
+            role,
+            passport,
+            provider = LOGIN_PROVIDER.WALLET,
+            walletOS,
+          } = await verifySessionToken(token, secret, {
+            checkFromDb: true,
+            teamDid,
+            checkToken: (t) => {
+              if (t.tokenType !== refreshTokenType) {
+                throw new Error(`invalid token type ${t.tokenType}`);
+              }
+            },
           });
-        }
 
-        res.json({ success: true });
-      });
+          const user = await node.getUser({ teamDid, user: { did: userDid } });
 
-      router.post(`${prefix}/api/did/refreshSession`, refreshBearerToken, async (req, res) => {
-        const token = req.refreshToken;
-        if (token) {
-          const teamDid = req.getBlockletDid();
-          let visitorId = req.query?.visitorId;
-          if (!visitorId) {
-            visitorId = req.get('x-blocklet-visitor-id');
-          }
-          const { appPid = teamDid } = req.query;
-          await req.ensureUser({ token, visitorId, appPid });
-          if (!req.user) {
-            res.status(400).send('user session is logout');
-            return;
+          if (role) {
+            const rbac = await node.getRBAC(teamDid);
+            user.permissions = await rbac.getScope(role);
+            user.role = role;
           }
 
-          try {
-            const { secret } = await req.getBlockletInfo();
-            /** @type {import('@abtnode/client').BlockletState} */
-            const blocklet = await req.getBlocklet();
-
-            const refreshTokenType = 'refresh';
-            const {
-              did: userDid,
-              role,
-              passport,
-              provider = LOGIN_PROVIDER.WALLET,
-              walletOS,
-            } = await verifySessionToken(token, secret, {
-              checkFromDb: true,
-              teamDid,
-              checkToken: (t) => {
-                if (t.tokenType !== refreshTokenType) {
-                  throw new Error(`invalid token type ${t.tokenType}`);
-                }
-              },
-            });
-
-            const user = await node.getUser({ teamDid, user: { did: userDid } });
-
-            if (role) {
-              const rbac = await node.getRBAC(teamDid);
-              user.permissions = await rbac.getScope(role);
-              user.role = role;
-            }
+          if (user.avatar && user.avatar.startsWith(USER_AVATAR_URL_PREFIX)) {
+            user.avatar = `${WELLKNOWN_SERVICE_PATH_PREFIX}${USER_AVATAR_PATH_PREFIX}/${
+              user.avatar.split('/').slice(-1)[0]
+            }`;
 
-            if (user.avatar && user.avatar.startsWith(USER_AVATAR_URL_PREFIX)) {
-              user.avatar = `${WELLKNOWN_SERVICE_PATH_PREFIX}${USER_AVATAR_PATH_PREFIX}/${
-                user.avatar.split('/').slice(-1)[0]
-              }`;
-
-              if (req.get('x-avatar-host') === '1') {
-                const appUrl = blocklet.environmentObj.BLOCKLET_APP_URL;
-                user.avatar = joinURL(appUrl, user.avatar);
-              }
+            if (req.get('x-avatar-host') === '1') {
+              const appUrl = blocklet.environmentObj.BLOCKLET_APP_URL;
+              user.avatar = joinURL(appUrl, user.avatar);
             }
+          }
 
-            const sessionConfig = blocklet.settings?.session || {};
-            const { sessionToken, refreshToken } = createToken(
-              userDid,
-              {
-                secret,
-                passport,
-                role,
-                fullName: user.fullName,
-                provider,
-                walletOS,
-              },
-              { ...sessionConfig, didConnectVersion: getDidConnectVersion(req) }
-            );
-            const ua = req.get('user-agent');
-            const lastLoginIp = getRequestIP(req);
-            const walletDeviceMessageToken = req.get('wallet-device-message-token');
-            const walletDeviceId = req.get('wallet-device-id');
-            const userSession = await node.upsertUserSession({
-              visitorId,
+          const sessionConfig = blocklet.settings?.session || {};
+          const { sessionToken, refreshToken } = createToken(
+            userDid,
+            {
+              secret,
+              passport,
+              role,
+              fullName: user.fullName,
+              provider,
+              walletOS,
+              emailVerified: !!user.emailVerified,
+              phoneVerified: !!user.phoneVerified,
+            },
+            { ...sessionConfig, didConnectVersion: getDidConnectVersion(req) }
+          );
+          const ua = req.get('user-agent');
+          const lastLoginIp = getRequestIP(req);
+          const walletDeviceMessageToken = req.get('wallet-device-message-token');
+          const walletDeviceId = req.get('wallet-device-id');
+          const userSession = await node.upsertUserSession({
+            visitorId,
+            teamDid,
+            userDid,
+            appPid: teamDid,
+            status: 'online',
+            ua,
+            lastLoginIp,
+            extra: {
+              walletOS,
+              walletDeviceMessageToken,
+              walletDeviceId,
+            },
+          });
+          if (user?.sourceAppPid) {
+            node.syncUserSession({
               teamDid,
               userDid,
-              appPid: teamDid,
-              status: 'online',
+              visitorId: userSession.visitorId,
+              targetAppPid: user.sourceAppPid,
               ua,
               lastLoginIp,
               extra: {
@@ -232,36 +246,21 @@ module.exports = {
                 walletDeviceId,
               },
             });
-            if (user?.sourceAppPid) {
-              node.syncUserSession({
-                teamDid,
-                userDid,
-                visitorId: userSession.visitorId,
-                targetAppPid: user.sourceAppPid,
-                ua,
-                lastLoginIp,
-                extra: {
-                  walletOS,
-                  walletDeviceMessageToken,
-                  walletDeviceId,
-                },
-              });
-            }
-
-            res.json({
-              user,
-              nextToken: sessionToken,
-              nextRefreshToken: refreshToken,
-              provider,
-              walletOS,
-            });
-          } catch (err) {
-            res.status(400).send(err.message);
           }
-        } else {
-          res.status(400).send('empty refreshToken');
+
+          res.json({
+            user,
+            nextToken: sessionToken,
+            nextRefreshToken: refreshToken,
+            provider,
+            walletOS,
+          });
+        } catch (err) {
+          res.status(400).send(err.message);
         }
-      });
+      } else {
+        res.status(400).send('empty refreshToken');
+      }
     });
   },
 };

package/api/services/kyc/index.js

@@ -0,0 +1,92 @@
+const { WELLKNOWN_SERVICE_PATH_PREFIX } = require('@abtnode/constant');
+const { emailSchema } = require('../../socket/channel/did');
+const { sendEmail } = require('../../libs/email');
+const { isEmailKycRequired } = require('../../libs/kyc');
+
+const logger = require('../../libs/logger')('kyc');
+
+const init = ({ node }) => {
+  const onStartEmailVerify = async (req, res) => {
+    try {
+      const [blocklet, info] = await Promise.all([req.getBlocklet(), req.getBlockletInfo()]);
+      const teamDid = blocklet.meta.did;
+
+      const { error, value: subject } = emailSchema.validate(req.body.email);
+
+      if (error) {
+        return res.status(400).send({ error: 'Email is invalid', code: 'email_invalid' });
+      }
+
+      if (await node.isEmailUsed({ teamDid, email: subject, verified: isEmailKycRequired(blocklet) })) {
+        return res.status(400).send({
+          error: 'Email is already used by another user, please use another email',
+          code: 'email_already_used',
+        });
+      }
+
+      if (await node.isSubjectVerified({ teamDid, subject })) {
+        return res.status(400).send({
+          error: 'Email is already verified, please check your DID Wallet or recover on login',
+          code: 'email_already_verified',
+        });
+      }
+
+      if (await node.isSubjectSent({ teamDid, subject })) {
+        return res.status(400).send({
+          error: 'Email is already sent, please check your inbox, or retry later',
+          code: 'email_already_sent',
+        });
+      }
+
+      const doc = await node.createVerifyCode({ teamDid, subject });
+      logger.info('create verify code', { teamDid, doc });
+
+      const result = await sendEmail(
+        subject,
+        {
+          title: `Verify Your Email on ${info.name}`,
+          body: `To ensure the security of your account and enhance your experience, you need to use following code to verify your email, and you will receive a certificate in your DID Wallet upon verification.\n\nYour verify code is ${doc.code}, please use it within 30 minutes.\n\nThank you for taking the time to enhance your account's security.`,
+        },
+        {
+          teamDid,
+          node,
+          locale: req.query.locale,
+        }
+      );
+      logger.info('send verify code', { teamDid, result });
+      await node.sendVerifyCode({ teamDid, code: doc.code });
+
+      return res.status(200).send({ message: 'Verify code successfully sent' });
+    } catch (error) {
+      logger.error('Send mail failed', { error });
+      return res.status(400).send(error.message);
+    }
+  };
+
+  const onEndEmailVerify = async (req, res) => {
+    try {
+      logger.info('onEndEmailVerify', { payload: req.body, user: req.user });
+
+      const blocklet = await req.getBlocklet();
+      const teamDid = blocklet.meta.did;
+
+      const { code } = req.body;
+      const result = await node.consumeVerifyCode({ teamDid, code });
+      logger.info('consume verify code', { teamDid, code, result });
+
+      return res.status(200).send({ message: 'Email is successfully verified' });
+    } catch (error) {
+      logger.error('Verify mail failed', { error });
+      return res.status(400).send(error.message);
+    }
+  };
+
+  return {
+    attach: (app) => {
+      app.post(`${WELLKNOWN_SERVICE_PATH_PREFIX}/api/kyc/email/send`, onStartEmailVerify);
+      app.post(`${WELLKNOWN_SERVICE_PATH_PREFIX}/api/kyc/email/verify`, onEndEmailVerify);
+    },
+  };
+};
+
+module.exports = { init };

package/api/services/notification/index.js

@@ -2,9 +2,9 @@
 const JWT = require('@arcblock/jwt');
 const Cron = require('@abtnode/cron');
 const { WsServer } = require('@arcblock/ws');
+const { WELLKNOWN_SERVICE_PATH_PREFIX } = require('@abtnode/constant');
 
 const states = require('../../state');
-const { PREFIXES } = require('../../util/constants');
 const logger = require('../../libs/logger')('notification');
 const { sendToAppChannel } = require('../../socket/channel/app');
 const { sendToAppComponents } = require('../../socket/channel/component');
@@ -157,27 +157,21 @@ const init = ({ node }) => {
   return {
     sendToUser: {
       attach: (app) => {
-        PREFIXES.forEach((prefix) => {
-          app.post(`${prefix}/api/send-to-user`, onSendToUser);
-        });
+        app.post(`${WELLKNOWN_SERVICE_PATH_PREFIX}/api/send-to-user`, onSendToUser);
       },
       exec: (data) => sendToUserDid({ ...data, node, wsServer }),
     },
 
     sendToMail: {
       attach: (app) => {
-        PREFIXES.forEach((prefix) => {
-          app.post(`${prefix}/api/send-to-mail`, onSendToMail);
-        });
+        app.post(`${WELLKNOWN_SERVICE_PATH_PREFIX}/api/send-to-mail`, onSendToMail);
       },
       exec: (data) => sendToMail({ ...data, node, wsServer }),
     },
 
     sendToPush: {
       attach: (app) => {
-        PREFIXES.forEach((prefix) => {
-          app.post(`${prefix}/api/send-to-push-kit`, onSendToPush);
-        });
+        app.post(`${WELLKNOWN_SERVICE_PATH_PREFIX}/api/send-to-push-kit`, onSendToPush);
       },
       exec: (data) => sendToMail({ ...data, node, wsServer }),
     },
@@ -193,17 +187,13 @@ const init = ({ node }) => {
 
     sendToAppChannel: {
       attach: (app) => {
-        PREFIXES.forEach((prefix) => {
-          app.post(`${prefix}/api/send-to-app-channel`, onSendToAppChannel);
-        });
+        app.post(`${WELLKNOWN_SERVICE_PATH_PREFIX}/api/send-to-app-channel`, onSendToAppChannel);
       },
       exec: (data) => sendToAppChannel({ ...data, node, wsServer }),
     },
 
     attach: (wsRouter) => {
-      PREFIXES.forEach((prefix) => {
-        wsRouter.use(`${prefix}/websocket`, wsServer.onConnect.bind(wsServer));
-      });
+      wsRouter.use(`${WELLKNOWN_SERVICE_PATH_PREFIX}/websocket`, wsServer.onConnect.bind(wsServer));
     },
   };
 };

package/api/services/relay/index.js

@@ -1,8 +1,8 @@
 const { WsServer } = require('@arcblock/ws');
 const { CHANNEL_TYPE, parseChannel } = require('@blocklet/meta/lib/channel');
+const { WELLKNOWN_SERVICE_PATH_PREFIX } = require('@abtnode/constant');
 
 const logger = require('../../libs/logger')('relay');
-const { PREFIXES } = require('../../util/constants');
 const { sendToRelay } = require('../../socket/channel/relay');
 const getHooksByChannel = require('../../socket/channel/hooks');
 
@@ -52,17 +52,13 @@ const init = ({ node }) => {
   return {
     sendToRelay: {
       attach: (app) => {
-        PREFIXES.forEach((prefix) => {
-          app.post(`${prefix}/relay/api/send-to-relay-channel`, onSendToRelay);
-        });
+        app.post(`${WELLKNOWN_SERVICE_PATH_PREFIX}/relay/api/send-to-relay-channel`, onSendToRelay);
       },
       exec: (data) => sendToRelay({ ...data, node, wsServer }),
     },
 
     attach: (wsRouter) => {
-      PREFIXES.forEach((prefix) => {
-        wsRouter.use(`${prefix}/relay/websocket`, wsServer.onConnect.bind(wsServer));
-      });
+      wsRouter.use(`${WELLKNOWN_SERVICE_PATH_PREFIX}/relay/websocket`, wsServer.onConnect.bind(wsServer));
     },
   };
 };