@blocklet/sdk 1.8.32 → 1.8.34

package/lib/service/notification.js

@@ -1,20 +1,55 @@
-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 { sendToUser, sendToAppChannel } = require('../util/send-notification');
-const { SERVICE_PREFIX } = require('../util/constants');
-const getWallet = require('../wallet');
-const { NOTIFICATION_TYPES } = require('../validators/notification');
-
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.broadcast = exports.sendToUser = exports._message = exports.off = exports.on = void 0;
+/* eslint-disable @typescript-eslint/naming-convention */
+const Jwt = __importStar(require("@arcblock/jwt"));
+const events_1 = __importDefault(require("events"));
+const ws_1 = require("@arcblock/ws");
+const channel_1 = require("@blocklet/meta/lib/channel");
+const check_blocklet_env_1 = __importDefault(require("../util/check-blocklet-env"));
+const send_notification_1 = require("../util/send-notification");
+const constants_1 = require("../util/constants");
+const wallet_1 = __importDefault(require("../wallet"));
+const notification_1 = require("../validators/notification");
 const getSender = () => ({
-  appDid: process.env.BLOCKLET_APP_ID,
-  appSk: process.env.BLOCKLET_APP_SK,
+    appDid: process.env.BLOCKLET_APP_ID,
+    appSk: process.env.BLOCKLET_APP_SK,
 });
-
 /**
  *
  * @param {Notification} notification
@@ -23,12 +58,11 @@ const getSender = () => ({
  * }} options
  * @returns
  */
-const doSendToUser = async (receiver, notification, options) => {
-  checkBlockletEnv();
-
-  return sendToUser(receiver, notification, getSender(), process.env.ABT_NODE_SERVICE_PORT, options);
-};
-
+const doSendToUser = (receiver, notification, options) => __awaiter(void 0, void 0, void 0, function* () {
+    (0, check_blocklet_env_1.default)();
+    return (0, send_notification_1.sendToUser)(receiver, notification, getSender(), process.env.ABT_NODE_SERVICE_PORT, options);
+});
+exports.sendToUser = doSendToUser;
 /**
  *
  * @param {Notification} notification
@@ -40,126 +74,112 @@ const doSendToUser = async (receiver, notification, options) => {
  * }} options
  * @returns
  */
-const broadcast = async (notification, options = {}) => {
-  checkBlockletEnv();
-
-  const sender = getSender();
-
-  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 broadcast = (notification, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    (0, check_blocklet_env_1.default)();
+    const sender = getSender();
+    const { channel = (0, channel_1.getAppPublicChannel)(sender.appDid) } = options;
+    const { event = 'message' } = options;
+    return (0, send_notification_1.sendToAppChannel)(channel, event, notification, sender, process.env.ABT_NODE_SERVICE_PORT, options);
+});
+exports.broadcast = broadcast;
+const emitter = new events_1.default();
+const messageEmitter = new events_1.default();
 const emitError = (error) => {
-  messageEmitter.emit('error', error);
-  emitter.emit('error', error);
+    messageEmitter.emit('error', error);
+    emitter.emit('error', error);
 };
-
 let client = null;
-
 const initClient = () => {
-  if (!client) {
-    const wallet = getWallet();
-    const { address: did, publicKey: pk, secretKey: sk } = wallet;
-    const url = `ws://127.0.0.1:${process.env.ABT_NODE_SERVICE_PORT}${SERVICE_PREFIX}`;
-    const token = () => Jwt.sign(did, sk, {});
-
-    client = new WsClient(url, {
-      heartbeatIntervalMs: 10 * 1000,
-      params: () => ({
-        token: token(),
-        pk,
-      }),
-    });
-
-    client.connect();
-
-    const messageChannel = client.channel(did, () => ({ token: token(), pk }));
-    const appPublicChannel = client.channel(getAppPublicChannel(did), () => ({ token: token(), pk }));
-
-    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,
+    if (!client) {
+        const wallet = (0, wallet_1.default)();
+        const { address: did, publicKey: pk, secretKey: sk } = wallet;
+        const url = `ws://127.0.0.1:${process.env.ABT_NODE_SERVICE_PORT}${constants_1.SERVICE_PREFIX}`;
+        const token = () => Jwt.sign(did, sk, {});
+        client = new ws_1.WsClient(url, {
+            heartbeatIntervalMs: 10 * 1000,
+            params: () => ({
+                token: token(),
+                pk,
+            }),
         });
-      }
-    });
-
-    appPublicChannel
-      .join()
-      .receive('error', (err) => {
-        const msg = `join channel error: ${err.message}`;
-        console.error(msg);
-        emitter.emit('error', { message: msg });
-      })
-      .receive('timeout', () => {
-        const msg = 'join channel timeout';
-        console.error(msg);
-        emitter.emit('error', { message: msg });
-      });
-
-    appPublicChannel.on(NOTIFICATION_TYPES.HI, ({ status, response } = {}) => {
-      if (status === 'ok') {
-        emitter.emit(NOTIFICATION_TYPES.HI, response);
-      } else {
-        emitter.emit('error', response);
-        console.error({
-          status,
-          response,
+        client.connect();
+        const messageChannel = client.channel(did, () => ({ token: token(), pk }));
+        const appPublicChannel = client.channel((0, channel_1.getAppPublicChannel)(did), () => ({ token: token(), pk }));
+        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_1.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}`;
+            console.error(msg);
+            emitter.emit('error', { message: msg });
+        })
+            .receive('timeout', () => {
+            const msg = 'join channel timeout';
+            console.error(msg);
+            emitter.emit('error', { message: msg });
+        });
+        appPublicChannel.on(notification_1.NOTIFICATION_TYPES.HI, ({ status, response } = {}) => {
+            if (status === 'ok') {
+                emitter.emit(notification_1.NOTIFICATION_TYPES.HI, response);
+            }
+            else {
+                emitter.emit('error', response);
+                console.error({
+                    status,
+                    response,
+                });
+            }
+        });
+    }
 };
-
 const ensureClient = () => {
-  if (!client) {
-    initClient();
-  }
+    if (!client) {
+        initClient();
+    }
 };
-
-module.exports = {
-  sendToUser: doSendToUser,
-  broadcast,
-
-  // System notification
-  on: (event, cb) => {
+const 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: {
+};
+exports.on = on;
+exports.off = emitter.off.bind(emitter);
+exports._message = {
     on: (event, cb) => {
-      ensureClient();
-      return messageEmitter.on(event, cb);
+        ensureClient();
+        return messageEmitter.on(event, cb);
     },
     off: messageEmitter.off.bind(messageEmitter),
-  },
+};
+exports.default = {
+    sendToUser: doSendToUser,
+    broadcast,
+    on: exports.on,
+    off: exports.off,
+    _message: exports._message,
 };

package/lib/types/notification.d.ts

@@ -0,0 +1,71 @@
+export declare type TChannelEvent = string;
+export interface TDataAsset {
+    chainHost: string;
+    did: unknown;
+}
+export interface TDataToken {
+    address?: unknown;
+    amount: string;
+    chainHost: string;
+    decimal: number;
+    senderDid: unknown;
+    symbol: string;
+}
+export interface TDataVC {
+    credential: {
+        /**
+         * Unknown Property
+         */
+        [x: string]: unknown;
+    };
+    tag?: string;
+}
+export interface TMessage {
+    /**
+     * Any Property
+     */
+    [x: string]: any;
+    createdAt: Date;
+    id: string;
+    receiver: {
+        did: unknown;
+    };
+    type: string;
+}
+export declare type TNotification = TNotificationItem | TNotificationConnect | TNotificationFeed;
+export interface TNotificationAction {
+    bgColor?: string;
+    color?: string;
+    link?: string;
+    name: string;
+    title?: string;
+}
+export interface TNotificationAttachment {
+    data?: object;
+    type: 'asset' | 'vc' | 'token';
+}
+export interface TNotificationConnect {
+    checkUrl?: string;
+    type?: 'connect';
+    url: string;
+}
+export interface TNotificationFeed {
+    data: object;
+    feedType: string;
+    type?: 'feed';
+}
+export declare type TNotificationInput = TNotification[] | TNotification;
+export interface TNotificationItem {
+    actions?: TNotificationAction[];
+    attachments?: TNotificationAttachment[];
+    body?: string;
+    title?: string;
+    type?: 'notification';
+}
+export interface TSendOptions {
+    /**
+     * Any Property
+     */
+    [x: string]: any;
+    keepForOfflineUser?: boolean;
+}

package/lib/types/notification.js

@@ -0,0 +1,3 @@
+"use strict";
+/* eslint-disable @typescript-eslint/indent */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/util/check-blocklet-env.d.ts

@@ -0,0 +1,2 @@
+declare const checkBlockletEnvironment: () => void;
+export = checkBlockletEnvironment;

package/lib/util/check-blocklet-env.js

@@ -1,20 +1,21 @@
-module.exports = () => {
-  const props = [
-    'BLOCKLET_APP_ID',
-    'BLOCKLET_APP_NAME',
-    'BLOCKLET_APP_DESCRIPTION',
-    'BLOCKLET_APP_SK',
-    'BLOCKLET_DID',
-    'ABT_NODE', // abtnode version
-    'ABT_NODE_DID',
-    'ABT_NODE_PK',
-    'ABT_NODE_PORT', // abtnode daemon port
-    'ABT_NODE_SERVICE_PORT',
-  ];
-
-  props.forEach((prop) => {
-    if (!process.env[prop]) {
-      throw new Error(`${prop} does not exist in environments`);
-    }
-  });
+"use strict";
+const checkBlockletEnvironment = () => {
+    const envNames = [
+        'BLOCKLET_APP_ID',
+        'BLOCKLET_APP_NAME',
+        'BLOCKLET_APP_DESCRIPTION',
+        'BLOCKLET_APP_SK',
+        'BLOCKLET_DID',
+        'ABT_NODE',
+        'ABT_NODE_DID',
+        'ABT_NODE_PK',
+        'ABT_NODE_PORT',
+        'ABT_NODE_SERVICE_PORT',
+    ];
+    envNames.forEach((envName) => {
+        if (!process.env[envName]) {
+            throw new Error(`${envName} does not exist in environments`);
+        }
+    });
 };
+module.exports = checkBlockletEnvironment;

package/lib/util/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const SERVICE_PREFIX = "/.well-known/service";
+declare const _default: {
+    SERVICE_PREFIX: string;
+};
+export default _default;

package/lib/util/constants.js

@@ -1,3 +1,7 @@
-module.exports = {
-  SERVICE_PREFIX: '/.well-known/service',
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SERVICE_PREFIX = void 0;
+exports.SERVICE_PREFIX = '/.well-known/service';
+exports.default = {
+    SERVICE_PREFIX: exports.SERVICE_PREFIX,
 };

package/lib/util/send-notification.d.ts

@@ -0,0 +1,25 @@
+import { TNotificationInput, TSendOptions } from '../types/notification';
+export declare type TNotificationSender = {
+    appDid: string;
+    appSk: string;
+};
+/**
+ * @param {String|Array} receiver
+ * @param {Object} notification
+ * @param {{
+ *   appDid: String
+ *   appSk: String
+ * }} sender
+ * @param {String|Number} port port of abtnode service endpoint
+ * @param {Object} options
+ * @returns
+ */
+declare const sendToUser: (receiver: string | string[], notification: TNotificationInput, { appDid, appSk }: TNotificationSender, port?: string, options?: {}) => Promise<any>;
+declare const sendToAppChannel: (channel: string, event: string, notification: TNotificationInput, { appDid, appSk }: TNotificationSender, port?: string, options?: TSendOptions) => Promise<any>;
+export { sendToUser };
+export { sendToAppChannel };
+declare const _default: {
+    sendToUser: (receiver: string | string[], notification: TNotificationInput, { appDid, appSk }: TNotificationSender, port?: string, options?: {}) => Promise<any>;
+    sendToAppChannel: (channel: string, event: string, notification: TNotificationInput, { appDid, appSk }: TNotificationSender, port?: string, options?: TSendOptions) => Promise<any>;
+};
+export default _default;