@blocklet/sdk 1.7.27 → 1.8.2

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/index.js

@@ -6,7 +6,6 @@ const Database = require('./database');
 const env = require('./env');
 const middlewares = require('./middlewares');
 const getWallet = require('./wallet');
-const logger = require('./logger');
 
 module.exports = {
   AuthService,
@@ -17,5 +16,4 @@ module.exports = {
   getWallet,
   env,
   middlewares,
-  logger,
 };

package/lib/service/auth.js

@@ -123,6 +123,7 @@ class AuthService extends Client {
       this[api] = apiFnMap[api] ? apiFnMap[api](fn) : apiFallback(fn);
     });
 
+    // eslint-disable-next-line no-constructor-return
     return new Proxy(this, {
       get(target, propKey) {
         if (!apiList.includes(propKey)) {

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/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.7.27",
+  "version": "1.8.2",
   "description": "graphql client to read/write data on abt node",
   "main": "lib/index.js",
   "files": [
@@ -19,16 +19,15 @@
   "author": "linchen1987 <linchen.1987@foxmail.com> (http://github.com/linchen1987)",
   "license": "MIT",
   "dependencies": {
-    "@abtnode/client": "1.7.27",
-    "@abtnode/constant": "1.7.27",
-    "@abtnode/logger": "1.7.27",
-    "@arcblock/did-auth": "1.17.0",
-    "@arcblock/jwt": "1.17.0",
-    "@arcblock/ws": "1.17.0",
-    "@blocklet/meta": "1.7.27",
-    "@nedb/core": "^1.2.2",
-    "@ocap/mcrypto": "1.17.0",
-    "@ocap/wallet": "1.17.0",
+    "@abtnode/client": "1.8.2",
+    "@abtnode/constant": "1.8.2",
+    "@arcblock/did-auth": "1.17.2",
+    "@arcblock/jwt": "1.17.2",
+    "@arcblock/ws": "1.17.2",
+    "@blocklet/meta": "1.8.2",
+    "@nedb/core": "^1.3.1",
+    "@ocap/mcrypto": "1.17.2",
+    "@ocap/wallet": "1.17.2",
     "axios": "^0.27.2",
     "fs-extra": "^10.0.1",
     "joi": "^17.6.0",
@@ -40,5 +39,5 @@
     "detect-port": "^1.3.0",
     "jest": "^27.4.5"
   },
-  "gitHead": "81a5492df66389b0aede13f033d1e493450833bc"
+  "gitHead": "fcbe3c97f3825c507ee16714f49bbf8f58c5b59f"
 }

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);