@blocklet/sdk 1.15.17 → 1.16.0-beta-b16cb035

package/lib/types/notification.d.ts

@@ -0,0 +1,113 @@
+export type TChannelEvent = string;
+export interface TDataAsset {
+    chainHost: string;
+    did: unknown;
+}
+export interface TDataDapp {
+    appDID: unknown;
+    desc?: string;
+    logo: string;
+    title: string;
+    url: string;
+}
+export interface TDataImage {
+    alt?: string;
+    url: string;
+}
+export interface TDataLink {
+    description?: string;
+    image?: string;
+    title?: string;
+    url: string;
+}
+export interface TDataText {
+    color?: string;
+    size?: 'small' | 'normal' | 'big';
+    text: string;
+    type: string;
+}
+export interface TDataToken {
+    address?: unknown;
+    amount: string;
+    chainHost: string;
+    decimal: number;
+    senderDid: unknown;
+    symbol: string;
+}
+export interface TDataTransaction {
+    chainId: string;
+    hash: 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 interface TNotification {
+    actions?: TNotificationAction[];
+    attachments?: TNotificationAttachment[];
+    blocks?: TNotificationAttachment[];
+    body?: string;
+    checkUrl?: string;
+    data?: object;
+    feedType?: string;
+    severity?: 'normal' | 'success' | 'error' | 'warning';
+    title?: string;
+    type?: 'notification' | 'connect' | 'feed' | 'hi';
+    url?: string;
+}
+export interface TNotificationAction {
+    bgColor?: string;
+    color?: string;
+    link?: string;
+    name: string;
+    title?: string;
+}
+export interface TNotificationAttachment {
+    data?: any;
+    fields?: any;
+    type: 'asset' | 'vc' | 'token' | 'text' | 'image' | 'divider' | 'transaction' | 'dapp' | 'link' | 'section';
+}
+export interface TNotificationConnect {
+    checkUrl?: string;
+    type?: 'connect';
+    url: string;
+}
+export interface TNotificationFeed {
+    data: object;
+    feedType: string;
+    type?: 'feed';
+}
+export type TNotificationInput = TNotification[];
+export interface TNotificationItem {
+    actions?: TNotificationAction[];
+    attachments?: TNotificationAttachment[];
+    blocks?: TNotificationAttachment[];
+    body?: string;
+    severity?: 'normal' | 'success' | 'error' | 'warning';
+    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,18 +1,21 @@
-module.exports = () => {
-  const props = [
-    'BLOCKLET_APP_ID',
-    '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 = {
-  AUTH_SERVICE_PREFIX: '/.service/@abtnode/auth-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/env.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+type BlockletPreferences = {
+    [key: string]: any;
+};
+export declare function parseEnv(env?: NodeJS.ProcessEnv): Readonly<{
+    appId: string;
+    appPid: string;
+    appName: string;
+    appDescription: string;
+    appUrl: string;
+    isComponent: boolean;
+    dataDir: string;
+    cacheDir: string;
+    mode: string;
+    appStorageEndpoint: string;
+    serverVersion: string;
+    preferences: BlockletPreferences;
+}>;
+export {};

package/lib/util/env.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEnv = void 0;
+const constant_1 = require("@blocklet/constant");
+function parseEnv(env = process.env) {
+    const preferences = Object.keys(env)
+        .filter((x) => x.startsWith(constant_1.BLOCKLET_PREFERENCE_PREFIX))
+        .reduce((acc, x) => {
+        const key = x.replace(constant_1.BLOCKLET_PREFERENCE_PREFIX, '');
+        try {
+            acc[key] = JSON.parse(env[x]);
+        }
+        catch {
+            acc[key] = env[x];
+        }
+        return acc;
+    }, {});
+    return Object.freeze({
+        appId: env.BLOCKLET_APP_ID,
+        appPid: env.BLOCKLET_APP_PID,
+        appName: env.BLOCKLET_APP_NAME,
+        appDescription: env.BLOCKLET_APP_DESCRIPTION,
+        appUrl: env.BLOCKLET_APP_URL,
+        isComponent: env.BLOCKLET_DID !== env.BLOCKLET_REAL_DID,
+        dataDir: env.BLOCKLET_DATA_DIR,
+        cacheDir: env.BLOCKLET_CACHE_DIR,
+        mode: env.BLOCKLET_MODE,
+        appStorageEndpoint: env.BLOCKLET_APP_SPACE_ENDPOINT,
+        serverVersion: env.ABT_NODE,
+        preferences,
+    });
+}
+exports.parseEnv = parseEnv;

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

@@ -0,0 +1,26 @@
+import { TNotificationInput, TSendOptions } from '../types/notification';
+export 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>;
+declare const sendToRelay: (topic: string, event: string, data: any, { appDid, appSk }: TNotificationSender, port?: string) => Promise<any>;
+export { sendToUser, sendToAppChannel, sendToRelay };
+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>;
+    sendToRelay: (topic: string, event: string, data: any, { appDid, appSk }: TNotificationSender, port?: string) => Promise<any>;
+};
+export default _default;

package/lib/util/send-notification.js

@@ -1,45 +1,156 @@
-/* eslint-disable global-require */
-const axios = require('axios').create({ proxy: false });
-
-const JWT = require('@arcblock/jwt');
-
-const validators = require('../validators');
-const { AUTH_SERVICE_PREFIX } = require('./constants');
-
-const VERSION = require('../../package.json').version; // version of notification sdk
-
-const { validateNotification, validateReceiver } = validators;
-
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendToRelay = exports.sendToAppChannel = exports.sendToUser = void 0;
+const axios_1 = __importDefault(require("axios"));
+const pick_1 = __importDefault(require("lodash/pick"));
+const JWT = __importStar(require("@arcblock/jwt"));
+const constant_1 = __importDefault(require("@abtnode/constant"));
+const channel_1 = require("@blocklet/meta/lib/channel");
+const index_1 = require("../validators/index");
+const constants_1 = require("./constants");
+const version_1 = require("../version");
+const axios = axios_1.default.create({ proxy: false });
+const { NODE_MODES } = constant_1.default;
+const VERSION = version_1.version; // version of notification sdk
+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 (
-  receiver,
-  notification,
-  { appId, appSk, did } = {},
-  port = process.env.ABT_NODE_SERVICE_PORT
-) => {
-  await validateReceiver(receiver);
-  await validateNotification(notification);
-
-  const token = JWT.sign(appId, appSk);
-
-  try {
-    const { data: res } = await axios.post(`http://127.0.0.1:${port}${AUTH_SERVICE_PREFIX}/api/sendToUser`, {
-      apiVersion: VERSION,
-      data: {
-        sender: { did, token, appDid: appId },
-        receiver,
-        notification,
-      },
-    });
-
-    return res;
-  } catch (error) {
-    throw new Error(error.response ? error.response.statusText : error.message);
-  }
+const sendToUser = async (receiver, notification, { appDid, appSk }, port = process.env.ABT_NODE_SERVICE_PORT, options = {}) => {
+    await (0, index_1.validateReceiver)(receiver);
+    const opt = (0, pick_1.default)(options, ['keepForOfflineUser']);
+    await (0, index_1.validateOption)(opt);
+    if (SERVER_MODE !== NODE_MODES.DEBUG) {
+        await (0, index_1.validateNotification)(notification);
+    }
+    try {
+        const { data: res } = await axios.post(`http://127.0.0.1:${port}${constants_1.SERVICE_PREFIX}/api/send-to-user`, {
+            apiVersion: VERSION,
+            data: {
+                sender: { appDid, token: JWT.sign(appDid, appSk) },
+                receiver,
+                notification,
+                options: opt,
+            },
+        }, {
+            timeout: 60 * 1000,
+            headers: getRequestHeaders(),
+        });
+        return res;
+    }
+    catch (err) {
+        console.error(err.response ? err.response.data : err);
+        throw new Error(err.response ? err.response.data : err.message);
+    }
+};
+exports.sendToUser = sendToUser;
+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 (0, index_1.validateChannelEvent)(event);
+    const opt = (0, pick_1.default)(options, ['socketId', 'userDid']);
+    if (opt.userDid) {
+        // @ts-expect-error TS(2551) FIXME: Property 'socketDid' does not exist on type 'Pick<... Remove this comment to see the full error message
+        opt.socketDid = opt.userDid;
+        delete opt.userDid;
+    }
+    if (SERVER_MODE !== NODE_MODES.DEBUG) {
+        await (0, index_1.validateNotification)(notification);
+    }
+    try {
+        const { data: res } = await axios.post(`http://127.0.0.1:${port}${constants_1.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 (err) {
+        console.error(err.response ? err.response.data : err);
+        throw new Error(err.response ? err.response.data : err.message);
+    }
+};
+exports.sendToAppChannel = sendToAppChannel;
+const sendToRelay = async (topic, event, data, { appDid, appSk }, port = process.env.ABT_NODE_SERVICE_PORT) => {
+    if (!topic) {
+        throw new Error('topic is required');
+    }
+    if (!event) {
+        throw new Error('event is required');
+    }
+    if (!data) {
+        throw new Error('data is required');
+    }
+    try {
+        const { data: res } = await axios.post(`http://127.0.0.1:${port}${constants_1.SERVICE_PREFIX}/relay/api/send-to-relay-channel`, {
+            apiVersion: VERSION,
+            data: {
+                sender: { appDid, token: JWT.sign(appDid, appSk) },
+                channel: (0, channel_1.getRelayChannel)(appDid, topic),
+                event,
+                data,
+            },
+        }, {
+            timeout: 60 * 1000,
+            headers: getRequestHeaders(),
+        });
+        return res;
+    }
+    catch (err) {
+        console.error(err.response ? err.response.data : err);
+        throw new Error(err.response ? err.response.data : err.message);
+    }
+};
+exports.sendToRelay = sendToRelay;
+exports.default = {
+    sendToUser,
+    sendToAppChannel,
+    sendToRelay,
 };

package/lib/validators/index.d.ts

@@ -0,0 +1,12 @@
+import { validateNotification, validateReceiver, validateOption, validateChannelEvent } from './notification';
+export { validateNotification };
+export { validateReceiver };
+export { validateOption };
+export { validateChannelEvent };
+declare const _default: {
+    validateNotification: any;
+    validateReceiver: any;
+    validateOption: any;
+    validateChannelEvent: any;
+};
+export default _default;

package/lib/validators/index.js

@@ -1,6 +1,14 @@
-const { validateNotification, validateReceiver } = require('./notification');
-
-module.exports = {
-  validateNotification,
-  validateReceiver,
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateChannelEvent = exports.validateOption = exports.validateReceiver = exports.validateNotification = void 0;
+const notification_1 = require("./notification");
+Object.defineProperty(exports, "validateNotification", { enumerable: true, get: function () { return notification_1.validateNotification; } });
+Object.defineProperty(exports, "validateReceiver", { enumerable: true, get: function () { return notification_1.validateReceiver; } });
+Object.defineProperty(exports, "validateOption", { enumerable: true, get: function () { return notification_1.validateOption; } });
+Object.defineProperty(exports, "validateChannelEvent", { enumerable: true, get: function () { return notification_1.validateChannelEvent; } });
+exports.default = {
+    validateNotification: notification_1.validateNotification,
+    validateReceiver: notification_1.validateReceiver,
+    validateOption: notification_1.validateOption,
+    validateChannelEvent: notification_1.validateChannelEvent,
 };

package/lib/validators/notification.d.ts

@@ -0,0 +1,74 @@
+import JOI from 'joi';
+declare const TYPES: {
+    NOTIFICATION: string;
+    CONNECT: string;
+    FEED: string;
+    HI: string;
+};
+declare const assetSchema: JOI.ObjectSchema<any>;
+declare const vcSchema: JOI.ObjectSchema<any>;
+declare const tokenSchema: JOI.ObjectSchema<any>;
+declare const textSchema: JOI.ObjectSchema<any>;
+declare const imageSchema: JOI.ObjectSchema<any>;
+declare const transactionSchema: JOI.ObjectSchema<any>;
+declare const dappSchema: JOI.ObjectSchema<any>;
+declare const linkSchema: JOI.ObjectSchema<any>;
+declare const actionSchema: JOI.ObjectSchema<any>;
+declare const attachmentSchema: JOI.ObjectSchema<any>;
+declare const notificationTypeSchema: JOI.ObjectSchema<any>;
+declare const connectTypeSchema: JOI.ObjectSchema<any>;
+declare const feedTypeSchema: JOI.ObjectSchema<any>;
+declare const notificationSchema: JOI.ObjectSchema<any>;
+declare const messageSchema: JOI.ObjectSchema<any>;
+declare const inputNotificationSchema: JOI.ArraySchema<any[]>;
+declare const optionSchema: JOI.ObjectSchema<any>;
+declare const channelEventSchema: JOI.StringSchema<string>;
+export declare const validateReceiver: any;
+export declare const validateNotification: any;
+export declare const validateMessage: any;
+export declare const validateChannelEvent: any;
+export declare const validateOption: any;
+export { tokenSchema };
+export { actionSchema };
+export { assetSchema };
+export { vcSchema };
+export { transactionSchema };
+export { textSchema };
+export { linkSchema };
+export { imageSchema };
+export { dappSchema };
+export { attachmentSchema };
+export { notificationSchema };
+export { messageSchema };
+export { optionSchema };
+export { channelEventSchema };
+export { TYPES as NOTIFICATION_TYPES };
+export { inputNotificationSchema, notificationTypeSchema, connectTypeSchema, feedTypeSchema };
+declare const _default: {
+    validateReceiver: any;
+    validateNotification: any;
+    validateMessage: any;
+    validateChannelEvent: any;
+    validateOption: any;
+    tokenSchema: JOI.ObjectSchema<any>;
+    actionSchema: JOI.ObjectSchema<any>;
+    assetSchema: JOI.ObjectSchema<any>;
+    vcSchema: JOI.ObjectSchema<any>;
+    transactionSchema: JOI.ObjectSchema<any>;
+    textSchema: JOI.ObjectSchema<any>;
+    linkSchema: JOI.ObjectSchema<any>;
+    imageSchema: JOI.ObjectSchema<any>;
+    dappSchema: JOI.ObjectSchema<any>;
+    attachmentSchema: JOI.ObjectSchema<any>;
+    notificationSchema: JOI.ObjectSchema<any>;
+    messageSchema: JOI.ObjectSchema<any>;
+    optionSchema: JOI.ObjectSchema<any>;
+    channelEventSchema: JOI.StringSchema<string>;
+    NOTIFICATION_TYPES: {
+        NOTIFICATION: string;
+        CONNECT: string;
+        FEED: string;
+        HI: string;
+    };
+};
+export default _default;