@blocklet/sdk 1.8.1 → 1.8.4

package/README.md

@@ -303,20 +303,6 @@ For Blocklet to write business logs, provides a consistent write format.
 
 ### Usage
 
-```javascript
-const { logger } = require('@blocklet/sdk');
-
-// log
-log = logger('demo');
-log.info('this is demo', { id: 'test-id' });
-log.warn('this is demo', { id: 'test-id' });
-log.error('this is demo', { id: 'test-id' });
-log.debug('this is demo', { id: 'test-id' });
-
-// access log
-app.use(morgan('combined', { stream: logger.getAccessLogStream() }));
-```
-
 ## getWallet
 
 ### Usage

package/lib/connect/authenticator.js

@@ -0,0 +1,16 @@
+const { Authenticator } = require('@did-connect/authenticator');
+
+const getWallet = require('../wallet');
+const checkBlockletEnv = require('../util/check-blocklet-env');
+const getShared = require('./shared');
+
+module.exports = class BlockletAuthenticator extends Authenticator {
+  constructor(options = {}) {
+    checkBlockletEnv();
+
+    super({
+      wallet: getWallet(),
+      ...getShared(options),
+    });
+  }
+};

package/lib/connect/handler.js

@@ -0,0 +1,73 @@
+const get = require('lodash/get');
+const { createHandlers } = require('@did-connect/handler');
+const Notification = require('../service/notification');
+
+const noop = () => ({});
+
+// whether app web page is in mobile DID wallet
+const inMobileWallet = (didwallet) => {
+  return didwallet && ['ios', 'android'].includes(didwallet.os);
+};
+
+const consoleLogger = { info: noop, error: console.error, warn: console.warn, debug: noop };
+const getConnectedDid = (session) => {
+  if (session.autoConnect === false) {
+    return '';
+  }
+
+  if (inMobileWallet(session.didwallet)) {
+    return '';
+  }
+
+  return get(session, 'previousConnected.userDid', '');
+};
+
+module.exports = ({ authenticator, storage, logger = consoleLogger, socketPathname, sendNotificationFn }) => {
+  const handlers = createHandlers({
+    storage,
+    authenticator,
+    logger,
+    socketPathname,
+  });
+
+  const originCreateHandler = handlers.handleSessionCreate;
+  handlers.handleSessionCreate = async (context) => {
+    const session = await originCreateHandler(context);
+    const connectedDid = getConnectedDid(session);
+
+    // send notification to wallet to trigger wallet to auto connect
+    if (connectedDid) {
+      // wallet use check url to check status of the session
+      let checkUrl = '';
+      try {
+        checkUrl = new URL(session.authUrl);
+        checkUrl.pathname = checkUrl.pathname.replace(/\/auth/, '/session');
+      } catch (e) {
+        checkUrl = '';
+        console.error(e);
+      }
+
+      const deepLink = new URL('https://abtwallet.io/i/');
+      deepLink.searchParams.set('action', 'requestAuth');
+      deepLink.searchParams.set('url', encodeURIComponent(session.authUrl));
+      const message = {
+        type: 'connect',
+        url: deepLink.href,
+      };
+
+      if (checkUrl) {
+        message.checkUrl = checkUrl.href;
+      }
+
+      // sendNotificationFn maybe custom function so we need params
+      const sendFn = sendNotificationFn || Notification.sendToUser.bind(Notification);
+      sendFn(connectedDid, message, { ...context, session }).catch((err) => {
+        console.error(err);
+      });
+    }
+
+    return session;
+  };
+
+  return handlers;
+};

package/lib/connect/shared.js

@@ -0,0 +1,34 @@
+const joinUrl = require('url-join');
+const { getConnectAppUrl } = require('@blocklet/meta/lib/util');
+const { SERVICE_PREFIX } = require('../util/constants');
+
+// wraps value in closure or returns closure
+const closure = (value) => (typeof value === 'function' ? value : () => value);
+
+module.exports = (options = {}) => ({
+  chainInfo: () => {
+    const chainHost = process.env.CHAIN_HOST;
+    return chainHost ? { host: chainHost, id: 'chain' } : { host: 'none', id: 'none' };
+  },
+
+  ...options,
+
+  appInfo: async (...args) => {
+    const info = await closure(options.appInfo)(...args);
+
+    const { request, baseUrl } = args[0];
+    const groupPathPrefix = request.headers['x-group-path-prefix'] || '/';
+    const blockletDid = request.headers['x-blocklet-did'];
+
+    return {
+      name: process.env.BLOCKLET_APP_NAME,
+      description: process.env.BLOCKLET_APP_DESCRIPTION,
+      ...(info || {}),
+      link: getConnectAppUrl(args[0]),
+      icon: joinUrl(baseUrl, SERVICE_PREFIX, `/blocklet/logo/${blockletDid}`),
+      updateSubEndpoint: true,
+      subscriptionEndpoint: joinUrl(groupPathPrefix, SERVICE_PREFIX, 'websocket'),
+      nodeDid: process.env.ABT_NODE_DID,
+    };
+  },
+});

package/lib/env.js

@@ -1,3 +1,24 @@
+const { getParentComponentName } = require('@blocklet/meta/lib/util');
+
+const parsePorts = () => JSON.parse(process.env.BLOCKLET_WEB_PORTS);
+
+const getWebEndpoint = (name) => {
+  const ports = parsePorts();
+  if (ports[name]) {
+    return `http://127.0.0.1:${ports[name]}`;
+  }
+  return '';
+};
+
+const getChildWebEndpoint = (name) => {
+  const fullName = `${process.env.BLOCKLET_REAL_NAME}/${name}`;
+  return getWebEndpoint(fullName);
+};
+const getParentWebEndpoint = () => {
+  const parentName = getParentComponentName(process.env.BLOCKLET_REAL_NAME);
+  return getWebEndpoint(parentName);
+};
+
 module.exports = Object.freeze({
   appId: process.env.BLOCKLET_APP_ID,
   appName: process.env.BLOCKLET_APP_NAME,
@@ -6,4 +27,7 @@ module.exports = Object.freeze({
   isComponent: process.env.BLOCKLET_DID !== process.env.BLOCKLET_REAL_DID,
   dataDir: process.env.BLOCKLET_DATA_DIR,
   cacheDir: process.env.BLOCKLET_CACHE_DIR,
+  getWebEndpoint,
+  getChildWebEndpoint,
+  getParentWebEndpoint,
 });

package/lib/index.js

@@ -2,20 +2,22 @@ const AuthService = require('./service/auth');
 const NotificationService = require('./service/notification');
 const WalletAuthenticator = require('./wallet-authenticator');
 const WalletHandlers = require('./wallet-handler');
+const BlockletAuthenticator = require('./connect/authenticator');
+const createConnectHandlers = require('./connect/handler');
 const Database = require('./database');
 const env = require('./env');
 const middlewares = require('./middlewares');
 const getWallet = require('./wallet');
-const logger = require('./logger');
 
 module.exports = {
   AuthService,
   NotificationService,
   WalletHandlers,
   WalletAuthenticator,
+  BlockletAuthenticator,
+  createConnectHandlers,
   Database,
   getWallet,
   env,
   middlewares,
-  logger,
 };

package/lib/service/notification.js

@@ -2,25 +2,62 @@ const Jwt = require('@arcblock/jwt');
 const EventEmitter = require('events');
 
 const { WsClient } = require('@arcblock/ws');
+const { getAppPublicChannel } = require('@blocklet/meta/lib/channel');
 
 const checkBlockletEnv = require('../util/check-blocklet-env');
-const sendNotification = require('../util/send-notification');
+const { sendToUser, sendToAppChannel } = require('../util/send-notification');
 const { SERVICE_PREFIX } = require('../util/constants');
 const getWallet = require('../wallet');
+const { NOTIFICATION_TYPES } = require('../validators/notification');
 
-const sendToUser = async (receiver, notification, options) => {
+const getSender = () => ({
+  appDid: process.env.BLOCKLET_APP_ID,
+  appSk: process.env.BLOCKLET_APP_SK,
+});
+
+/**
+ *
+ * @param {Notification} notification
+ * @param {{
+ *   keepForOfflineUser: Boolean
+ * }} options
+ * @returns
+ */
+const doSendToUser = async (receiver, notification, options) => {
+  checkBlockletEnv();
+
+  return sendToUser(receiver, notification, getSender(), process.env.ABT_NODE_SERVICE_PORT, options);
+};
+
+/**
+ *
+ * @param {Notification} notification
+ * @param {{
+ *   channel: String
+ *   event: String
+ *   socketId: String
+ *   socketDid: String
+ * }} options
+ * @returns
+ */
+const broadcast = async (notification, options = {}) => {
   checkBlockletEnv();
 
-  const sender = {
-    appId: process.env.BLOCKLET_APP_ID,
-    appSk: process.env.BLOCKLET_APP_SK,
-    did: process.env.BLOCKLET_DID,
-  };
+  const sender = getSender();
 
-  return sendNotification(receiver, notification, sender, process.env.ABT_NODE_SERVICE_PORT, options);
+  const { channel = getAppPublicChannel(sender.appDid) } = options;
+  const { event = 'message' } = options;
+
+  return sendToAppChannel(channel, event, notification, sender, process.env.ABT_NODE_SERVICE_PORT, options);
 };
 
 const emitter = new EventEmitter();
+const messageEmitter = new EventEmitter();
+
+const emitError = (error) => {
+  messageEmitter.emit('error', error);
+  emitter.emit('error', error);
+};
 
 let client = null;
 
@@ -41,9 +78,38 @@ const initClient = () => {
 
     client.connect();
 
-    const channel = client.channel(wallet.address, () => ({ token: token(), pk }));
+    const messageChannel = client.channel(did, () => ({ token: token(), pk }));
+    const appPublicChannel = client.channel(getAppPublicChannel(did), () => ({ token: token(), pk }));
 
-    channel
+    messageChannel
+      .join()
+      .receive('error', (err) => {
+        const msg = `join channel error: ${err.message}`;
+        console.error(msg);
+        emitError({ message: msg });
+      })
+      .receive('timeout', () => {
+        const msg = 'join channel timeout';
+        console.error(msg);
+        emitError({ message: msg });
+      });
+
+    messageChannel.on('message', ({ status, response } = {}) => {
+      if (status === 'ok') {
+        messageEmitter.emit(response.type, response);
+        if (response.type === NOTIFICATION_TYPES.HI) {
+          emitter.emit(response.type, response);
+        }
+      } else {
+        emitError(response);
+        console.error({
+          status,
+          response,
+        });
+      }
+    });
+
+    appPublicChannel
       .join()
       .receive('error', (err) => {
         const msg = `join channel error: ${err.message}`;
@@ -56,9 +122,9 @@ const initClient = () => {
         emitter.emit('error', { message: msg });
       });
 
-    channel.on('message', ({ status, response } = {}) => {
+    appPublicChannel.on(NOTIFICATION_TYPES.HI, ({ status, response } = {}) => {
       if (status === 'ok') {
-        emitter.emit(response.type, response);
+        emitter.emit(NOTIFICATION_TYPES.HI, response);
       } else {
         emitter.emit('error', response);
         console.error({
@@ -70,14 +136,30 @@ const initClient = () => {
   }
 };
 
+const ensureClient = () => {
+  if (!client) {
+    initClient();
+  }
+};
+
 module.exports = {
-  sendToUser,
-  on: (event, cb) => {
-    if (!client) {
-      initClient();
-    }
+  sendToUser: doSendToUser,
+  broadcast,
 
+  // System notification
+  on: (event, cb) => {
+    ensureClient();
     return emitter.on(event, cb);
   },
   off: emitter.off.bind(emitter),
+
+  // Just for DID Wallet developing
+  // Any message received from any account
+  _message: {
+    on: (event, cb) => {
+      ensureClient();
+      return messageEmitter.on(event, cb);
+    },
+    off: messageEmitter.off.bind(messageEmitter),
+  },
 };

package/lib/util/send-notification.js

@@ -10,26 +10,32 @@ const { SERVICE_PREFIX } = require('./constants');
 
 const VERSION = require('../../package.json').version; // version of notification sdk
 
-const { validateNotification, validateReceiver, validateOption } = validators;
+const { validateNotification, validateReceiver, validateOption, validateChannelEvent } = validators;
 
 const SERVER_MODE = process.env.ABT_NODE_MODE;
 
+const getRequestHeaders = () => ({ 'User-Agent': `BlockletSDK/${VERSION}` });
+
 /**
  * @param {String|Array} receiver
  * @param {Object} notification
- * @param {Object} sender
+ * @param {{
+ *   appDid: String
+ *   appSk: String
+ * }} sender
  * @param {String|Number} port port of abtnode service endpoint
  * @param {Object} options
  * @returns
  */
-module.exports = async (
+const sendToUser = async (
   receiver,
   notification,
-  { appId, appSk, did } = {},
+  { appDid, appSk } = {},
   port = process.env.ABT_NODE_SERVICE_PORT,
   options = {}
 ) => {
   await validateReceiver(receiver);
+
   const opt = pick(options, ['keepForOfflineUser']);
   await validateOption(opt);
 
@@ -37,27 +43,87 @@ module.exports = async (
     await validateNotification(notification);
   }
 
-  const token = JWT.sign(appId, appSk);
-
   try {
     const { data: res } = await axios.post(
-      `http://127.0.0.1:${port}${SERVICE_PREFIX}/api/sendToUser`,
+      `http://127.0.0.1:${port}${SERVICE_PREFIX}/api/send-to-user`,
       {
         apiVersion: VERSION,
         data: {
-          sender: { did, token, appDid: appId },
+          sender: { appDid, token: JWT.sign(appDid, appSk) },
           receiver,
           notification,
           options: opt,
         },
       },
       {
-        headers: { 'User-Agent': `BlockletSDK/${VERSION}` },
+        timeout: 60 * 1000,
+        headers: getRequestHeaders(),
+      }
+    );
+
+    return res;
+  } catch (error) {
+    console.error(error);
+    throw new Error(error.response ? error.response.statusText : error.message);
+  }
+};
+
+const sendToAppChannel = async (
+  channel,
+  event,
+  notification,
+  { appDid, appSk } = {},
+  port = process.env.ABT_NODE_SERVICE_PORT,
+  options = {}
+) => {
+  if (!channel) {
+    throw new Error('channel is required');
+  }
+
+  if (!event) {
+    throw new Error('event is required');
+  }
+
+  await validateChannelEvent(event);
+
+  const opt = pick(options, ['socketId', 'userDid']);
+
+  if (opt.userDid) {
+    opt.socketDid = opt.userDid;
+    delete opt.userDid;
+  }
+
+  if (SERVER_MODE !== NODE_MODES.DEBUG) {
+    await validateNotification(notification);
+  }
+
+  try {
+    const { data: res } = await axios.post(
+      `http://127.0.0.1:${port}${SERVICE_PREFIX}/api/send-to-app-channel`,
+      {
+        apiVersion: VERSION,
+        data: {
+          sender: { appDid, token: JWT.sign(appDid, appSk) },
+          channel,
+          event,
+          notification,
+          options: opt,
+        },
+      },
+      {
+        timeout: 60 * 1000,
+        headers: getRequestHeaders(),
       }
     );
 
     return res;
   } catch (error) {
+    console.error(error);
     throw new Error(error.response ? error.response.statusText : error.message);
   }
 };
+
+module.exports = {
+  sendToUser,
+  sendToAppChannel,
+};

package/lib/validators/index.js

@@ -1,7 +1,8 @@
-const { validateNotification, validateReceiver, validateOption } = require('./notification');
+const { validateNotification, validateReceiver, validateOption, validateChannelEvent } = require('./notification');
 
 module.exports = {
   validateNotification,
   validateReceiver,
   validateOption,
+  validateChannelEvent,
 };

package/lib/validators/notification.js

@@ -89,12 +89,15 @@ const inputReceiverSchema = Joi.alternatives().try(Joi.array().items(receiverSch
 
 const optionSchema = Joi.object({
   keepForOfflineUser: Joi.boolean(),
-});
+}).unknown();
+
+const channelEventSchema = Joi.string().required();
 
 module.exports = {
   validateReceiver: inputReceiverSchema.validateAsync.bind(inputReceiverSchema),
   validateNotification: inputNotificationSchema.validateAsync.bind(inputNotificationSchema),
   validateMessage: messageSchema.validateAsync.bind(messageSchema),
+  validateChannelEvent: channelEventSchema.validateAsync.bind(channelEventSchema),
   validateOption: optionSchema.validateAsync.bind(optionSchema),
   tokenSchema,
   actionSchema,
@@ -104,4 +107,6 @@ module.exports = {
   notificationSchema,
   messageSchema,
   optionSchema,
+  channelEventSchema,
+  NOTIFICATION_TYPES: TYPES,
 };

package/lib/wallet-authenticator.js

@@ -1,14 +1,8 @@
-const joinUrl = require('url-join');
 const { WalletAuthenticator: Authenticator } = require('@arcblock/did-auth');
 
 const getWallet = require('./wallet');
 const checkBlockletEnv = require('./util/check-blocklet-env');
-const { SERVICE_PREFIX } = require('./util/constants');
-
-const env = require('./env');
-
-// wraps value in closure or returns closure
-const closure = (value) => (typeof value === 'function' ? value : () => value);
+const getShared = require('./connect/shared');
 
 class WalletAuthenticator extends Authenticator {
   constructor(options = {}) {
@@ -16,39 +10,7 @@ class WalletAuthenticator extends Authenticator {
 
     super({
       wallet: getWallet().toJSON(),
-
-      chainInfo: () => {
-        const chainHost = process.env.CHAIN_HOST;
-        return chainHost ? { host: chainHost, id: 'chain' } : { host: 'none', id: 'none' };
-      },
-
-      ...options,
-
-      appInfo: async (...args) => {
-        const info = await closure(options.appInfo)(...args);
-
-        const { request, baseUrl } = args[0];
-        const pathPrefix = request.headers['x-path-prefix'] || '/';
-        const groupPathPrefix = request.headers['x-group-path-prefix'] || '/';
-        const blockletDid = request.headers['x-blocklet-did'];
-
-        // Child blocklets should set appInfo.link to exactly the same path as the root blocklet
-        let appUrl = baseUrl;
-        if (env.isComponent && pathPrefix !== groupPathPrefix) {
-          appUrl = joinUrl(joinUrl(appUrl, '/').replace(pathPrefix, groupPathPrefix), '');
-        }
-
-        return {
-          name: process.env.BLOCKLET_APP_NAME,
-          description: process.env.BLOCKLET_APP_DESCRIPTION,
-          ...(info || {}),
-          link: appUrl,
-          icon: joinUrl(baseUrl, SERVICE_PREFIX, `/blocklet/logo/${blockletDid}`),
-          updateSubEndpoint: true,
-          subscriptionEndpoint: joinUrl(groupPathPrefix, SERVICE_PREFIX, 'websocket'),
-          nodeDid: process.env.ABT_NODE_DID,
-        };
-      },
+      ...getShared(options),
     });
   }
 }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.8.1",
+  "version": "1.8.4",
   "description": "graphql client to read/write data on abt node",
   "main": "lib/index.js",
   "files": [
@@ -19,16 +19,17 @@
   "author": "linchen1987 <linchen.1987@foxmail.com> (http://github.com/linchen1987)",
   "license": "MIT",
   "dependencies": {
-    "@abtnode/client": "1.8.1",
-    "@abtnode/constant": "1.8.1",
-    "@abtnode/logger": "1.8.1",
-    "@arcblock/did-auth": "1.17.0",
-    "@arcblock/jwt": "1.17.0",
-    "@arcblock/ws": "1.17.0",
-    "@blocklet/meta": "1.8.1",
-    "@nedb/core": "^1.3.1",
-    "@ocap/mcrypto": "1.17.0",
-    "@ocap/wallet": "1.17.0",
+    "@abtnode/client": "1.8.4",
+    "@abtnode/constant": "1.8.4",
+    "@arcblock/did-auth": "1.17.5",
+    "@arcblock/jwt": "1.17.5",
+    "@arcblock/ws": "1.17.5",
+    "@blocklet/meta": "1.8.4",
+    "@did-connect/authenticator": "^2.0.18",
+    "@did-connect/handler": "^2.0.18",
+    "@nedb/core": "^1.3.2",
+    "@ocap/mcrypto": "1.17.5",
+    "@ocap/wallet": "1.17.5",
     "axios": "^0.27.2",
     "fs-extra": "^10.0.1",
     "joi": "^17.6.0",
@@ -40,5 +41,5 @@
     "detect-port": "^1.3.0",
     "jest": "^27.4.5"
   },
-  "gitHead": "c970b8a386bebd7fe6dbc8b8eedf8bd8328b4bb5"
+  "gitHead": "c42fb1bb84c5eef0f753fd5397d8007c7a6eee19"
 }

package/lib/logger.js

@@ -1,8 +0,0 @@
-const logger = require('@abtnode/logger');
-
-if (!process.env.BLOCKLET_LOG_DIR) {
-  throw new Error('valid BLOCKLET_LOG_DIR env is required by logger');
-}
-
-module.exports = (label) => logger(label, { logDir: process.env.BLOCKLET_LOG_DIR, filename: 'info' });
-module.exports.getAccessLogStream = () => logger.getAccessLogStream(process.env.BLOCKLET_LOG_DIR);