@blocklet/sdk 1.15.17 → 1.16.0-beta-b16cb035

package/README.md

@@ -2,201 +2,4 @@
 
 Blocklet SDK for blocklet developer
 
-## Install
-
-```shell
-yarn add @blocklet/sdk
-```
-
-or
-
-```shell
-npm install @blocklet/sdk
-```
-
-## Auth SDK
-
-### Usage
-
-```javascript
-const Auth = require('@blocklet/sdk/service/auth');
-
-const client = new Auth();
-
-const userDid = 'xxxxxxxx';
-
-const { user } = await client.getUser(userDid);
-```
-
-### Api
-
-#### client.getUser(did)
-
-Get user by user did
-
-- **did** `string`
-
-#### client.getUsers()
-
-Get all users of the team
-
-#### client.updateUserRole(did, role)
-
-- **did** `string`
-- **role** `string`
-
-#### client.getPermissionsByRole(role)
-
-Get all permissions of a role
-
-- **role** `string`
-
-#### client.getRoles()
-
-Get all roles of the team
-
-#### client.getPermissions()
-
-Get all permissions of the team
-
-## Notification SDK
-
-### Usage
-
-```javascript
-const Notification = require('@blocklet/sdk/service/notification');
-
-const userDid = 'xxxxxxxx';
-
-const notification = {
-  title: 'xxx',
-  body: 'xxx',
-  attachments: [
-    {
-      type: 'asset',
-      data: {
-        did: 'xxx',
-        chainHost: 'https://chainhost',
-      },
-    },
-  ],
-  actions: [
-    {
-      name: 'xxx',
-      title: 'Go To Website',
-      link: 'https://arcblock.io',
-    },
-  ],
-};
-
-const content = { message: 'this is a message' };
-const actions = [];
-
-await Notification.sendToUser(userDid, notification);
-
-await Notification.sendToUser(userDid, [notification, anotherNotification]);
-await Notification.sendToUser([userDid, anotherUserDid], notification);
-await Notification.sendToUser([userDid, anotherUserDid], [notification, anotherNotification]);
-```
-
-### Api
-
-#### notification.sendToUser(receiver, notification)
-
-Send notification to an account
-
-- **receiver** `string | array<string>` required
-- **notification** `object | array<object>` required
-  - **notification.title** `string`
-  - **notification.body** `string`
-  - **notification.attachments** `array<object>`
-    - **attachment.type** `enum` 'asset', 'vc', 'token' required
-    - **attachment.data** `object`
-      - _type: text_
-        - **type** `string`
-        - **message** `string`
-      - _type: asset_
-        - **did** `string` did
-        - **chainHost** `string` uri
-      - _type: vc_
-        - **credential** `object`
-        - **tag** `string`
-      - _type: token_
-        - **address** `string` did
-        - **amount** `string`
-        - **symbol** `string`
-        - **senderDid** `string` did
-        - **chainHost** `string`
-        - **decimal** `integer`
-  - **notification.actions** `array<object>`
-    - **name** `string` required
-    - **title** `string`
-    - **color** `string`
-    - **bgColor** `string`
-    - **link** `string` uri
-
-## WalletAuthenticator SDK
-
-### Usage
-
-```javascript
-const { WalletAuthenticator } = require('@blocklet/sdk');
-
-const authenticator = new WalletAuthenticator();
-```
-
-## WalletHandler SDK
-
-### Usage
-
-```javascript
-const AuthStorage = require('@arcblock/did-auth-storage-nedb');
-const { WalletAuthenticator, WalletHandlers } = require('@blocklet/sdk');
-
-const authenticator = new WalletAuthenticator();
-
-const handlers = new WalletHandlers({
-  authenticator,
-  tokenGenerator: () => Date.now().toString(),
-  tokenStorage: new AuthStorage({
-    dbPath: path.join(process.env.BLOCKLET_DATA_DIR, 'auth.db'),
-    onload: (err) => {
-      if (err) {
-        // eslint-disable-next-line no-console
-        console.error(`Failed to load database from ${path.join(process.env.BLOCKLET_DATA_DIR, 'auth.db')}`, err);
-      }
-    },
-  }),
-});
-```
-
-## Database SDK
-
-A database library for develop blocklet, it's a wrapper of [nedb](https://www.github.com/Arcblock/nedb).
-Supply a simpler way to use nedb. Just use `new Database([dbName])`, or you can pass a object option as second parameter to create a database as origin nedb way `new Database([dbName], [options])`
-
-Supply full-promise support.
-
-### Usage
-
-```javascript
-const { Database } = require('@blocklet/sdk');
-
-(async () => {
-  const db1 = new Database('db1');
-  const data1 = await db1.find().skip(1).limit(10);
-
-  class MyDatabase extends Database {
-    constructor(name) {
-      super(name);
-    }
-
-    async extraFn() {
-      return 'extra';
-    }
-  }
-  const db2 = new MyDatabase('db2');
-  const data2 = await db2.find().paginate(1, 10);
-  const data2Extra = await db2.extraFn();
-})();
-```
+See [https://developer.blocklet.io/docs/](https://developer.blocklet.io/docs/)

package/lib/component/index.d.ts

@@ -0,0 +1,35 @@
+import { AxiosResponse } from 'axios';
+export type MountPoint = {
+    did: string;
+    name: string;
+    title: string;
+    port: number;
+    webEndpoint: string;
+    mountPoint: string;
+};
+declare const getChildWebEndpoint: (name: string) => string;
+declare const getParentWebEndpoint: () => string;
+declare const getComponentWebEndpoint: (keyword: string) => string;
+declare const call: ({ name, path: _path, data }: {
+    name?: string;
+    path: string;
+    data: any;
+}) => Promise<AxiosResponse<any, any>>;
+declare const getComponentMountPoint: (keyword: string) => string;
+export { call };
+export { getComponentMountPoint };
+export { getComponentWebEndpoint };
+export { getChildWebEndpoint };
+export { getParentWebEndpoint };
+declare const _default: {
+    call: ({ name, path: _path, data }: {
+        name?: string;
+        path: string;
+        data: any;
+    }) => Promise<AxiosResponse<any, any>>;
+    getComponentMountPoint: (keyword: string) => string;
+    getComponentWebEndpoint: (keyword: string) => string;
+    getChildWebEndpoint: (name: string) => string;
+    getParentWebEndpoint: () => string;
+};
+export default _default;

package/lib/component/index.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParentWebEndpoint = exports.getChildWebEndpoint = exports.getComponentWebEndpoint = exports.getComponentMountPoint = exports.call = void 0;
+const axios_1 = __importDefault(require("axios"));
+const get_1 = __importDefault(require("lodash/get"));
+const url_join_1 = __importDefault(require("url-join"));
+const json_stable_stringify_1 = __importDefault(require("json-stable-stringify"));
+const util_1 = require("@blocklet/meta/lib/util");
+const wallet_1 = __importDefault(require("../wallet"));
+const config_1 = require("../config");
+const parseMountPoints = () => {
+    const mountPoints = JSON.parse(process.env.BLOCKLET_MOUNT_POINTS) || [];
+    mountPoints.forEach((x) => {
+        if (x.port) {
+            x.webEndpoint = `http://127.0.0.1:${x.port}`;
+        }
+    });
+    return mountPoints;
+};
+const sign = (data) => {
+    const wallet = (0, wallet_1.default)();
+    const signData = typeof data === 'undefined' ? {} : data;
+    return { 'x-component-sig': wallet.sign((0, json_stable_stringify_1.default)(signData)) };
+};
+const doCall = async ({ url, data }) => {
+    try {
+        const resp = await axios_1.default.post(url, data, { headers: sign(data), timeout: 60000 });
+        config_1.logger.info(`call ${url} api success`);
+        return resp;
+    }
+    catch (error) {
+        config_1.logger.error(`call ${url} api failed`, {
+            url,
+            responseStatus: (0, get_1.default)(error, 'response.status'),
+            responseData: (0, get_1.default)(error, 'response.data'),
+            error,
+        });
+        throw new Error(`call ${url} api failed`);
+    }
+};
+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);
+};
+exports.getChildWebEndpoint = getChildWebEndpoint;
+const getParentWebEndpoint = () => {
+    const parentName = (0, util_1.getParentComponentName)(process.env.BLOCKLET_REAL_NAME);
+    return getWebEndpoint(parentName);
+};
+exports.getParentWebEndpoint = getParentWebEndpoint;
+const getComponentWebEndpoint = (keyword) => {
+    const mountPoints = parseMountPoints();
+    const item = mountPoints.find((x) => [x.title, x.name, x.did].includes(keyword));
+    return item ? item.webEndpoint : '';
+};
+exports.getComponentWebEndpoint = getComponentWebEndpoint;
+const call = async ({ name, path: _path, data }) => {
+    let baseURL;
+    if (name) {
+        baseURL = getComponentWebEndpoint(name) || getChildWebEndpoint(name);
+    }
+    else {
+        baseURL = getParentWebEndpoint();
+    }
+    if (!baseURL) {
+        throw new Error(`can not find web endpoint for ${name}`);
+    }
+    const url = (0, url_join_1.default)(baseURL, _path);
+    return doCall({ url, data });
+};
+exports.call = call;
+const getComponentMountPoint = (keyword) => {
+    const mountPoints = parseMountPoints();
+    const item = mountPoints.find((x) => [x.title, x.name, x.did].includes(keyword));
+    return item ? item.mountPoint : '';
+};
+exports.getComponentMountPoint = getComponentMountPoint;
+exports.default = {
+    call,
+    getComponentMountPoint,
+    getComponentWebEndpoint,
+    getChildWebEndpoint,
+    getParentWebEndpoint,
+};

package/lib/config.d.ts

@@ -0,0 +1,33 @@
+export declare const logger: {
+    info: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    debug: (...args: any[]) => void;
+    warn: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    error: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+};
+declare const _default: {
+    logger: {
+        info: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+        debug: (...args: any[]) => void;
+        warn: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+        error: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+    };
+};
+export default _default;

package/lib/config.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+/* eslint-disable no-console */
+exports.logger = {
+    info: console.log,
+    debug: (...args) => {
+        if (process.env.NODE_ENV === 'development') {
+            console.debug(...args);
+        }
+    },
+    warn: console.warn,
+    error: console.error,
+};
+exports.default = {
+    logger: exports.logger,
+};

package/lib/connect/authenticator.d.ts

@@ -0,0 +1,5 @@
+import { Authenticator } from '@did-connect/authenticator';
+declare class BlockletAuthenticator extends Authenticator {
+    constructor(options?: {});
+}
+export = BlockletAuthenticator;

package/lib/connect/authenticator.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const authenticator_1 = require("@did-connect/authenticator");
+const wallet_1 = __importDefault(require("../wallet"));
+const check_blocklet_env_1 = __importDefault(require("../util/check-blocklet-env"));
+const shared_1 = require("./shared");
+class BlockletAuthenticator extends authenticator_1.Authenticator {
+    constructor(options = {}) {
+        (0, check_blocklet_env_1.default)();
+        super({
+            wallet: (0, wallet_1.default)(),
+            ...(0, shared_1.getAuthenticatorProps)(options),
+        });
+    }
+}
+module.exports = BlockletAuthenticator;

package/lib/connect/handler.d.ts

@@ -0,0 +1,2 @@
+declare const createConnectHandlers: ({ authenticator, storage, logger, socketPathname, sendNotificationFn, }: $TSFixMe) => import("@did-connect/handler").THandlers;
+export = createConnectHandlers;

package/lib/connect/handler.js

@@ -0,0 +1,90 @@
+"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 };
+};
+const get_1 = __importDefault(require("lodash/get"));
+const handler_1 = require("@did-connect/handler");
+const notification_1 = __importStar(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 (0, get_1.default)(session, 'previousConnected.userDid', '');
+};
+const createConnectHandlers = ({ authenticator, storage, logger = consoleLogger, socketPathname, sendNotificationFn, }) => {
+    const handlers = (0, handler_1.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 {
+                // @ts-expect-error TS(2322) FIXME: Type 'URL' is not assignable to type 'string'.
+                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_1.sendToUser.bind(notification_1.default);
+            sendFn(connectedDid, message, { ...context, session }).catch((err) => {
+                console.error(err);
+            });
+        }
+        return session;
+    };
+    return handlers;
+};
+module.exports = createConnectHandlers;

package/lib/connect/shared.d.ts

@@ -0,0 +1,19 @@
+import { WalletObject } from '@ocap/wallet';
+declare const getDelegator: () => WalletObject<string>;
+declare const getDelegatee: () => WalletObject<string>;
+declare const getDelegation: (delegator: WalletObject, delegatee: WalletObject) => string;
+declare const getAuthenticatorProps: (options?: {}) => {
+    appInfo: (...args: any[]) => Promise<{
+        name: string | undefined;
+        description: string | undefined;
+        link: string;
+        icon: string;
+        updateSubEndpoint: true;
+        subscriptionEndpoint: string;
+        nodeDid: string | undefined;
+    }>;
+    delegator: () => WalletObject<string>;
+    delegation: () => string;
+    chainInfo: () => Record<string, string>;
+};
+export { getDelegation, getDelegator, getDelegatee, getAuthenticatorProps };

package/lib/connect/shared.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuthenticatorProps = exports.getDelegatee = exports.getDelegator = exports.getDelegation = void 0;
+const url_join_1 = __importDefault(require("url-join"));
+const wallet_1 = __importDefault(require("@blocklet/meta/lib/wallet"));
+const jwt_1 = require("@arcblock/jwt");
+const util_1 = require("@blocklet/meta/lib/util");
+const constants_1 = require("../util/constants");
+// wraps value in closure or returns closure
+const closure = (value) => (typeof value === 'function' ? value : () => value);
+const getDelegator = () => {
+    const { BLOCKLET_APP_SK, BLOCKLET_APP_PSK, BLOCKLET_WALLET_TYPE } = process.env;
+    if (BLOCKLET_APP_SK && BLOCKLET_APP_PSK && BLOCKLET_APP_SK !== BLOCKLET_APP_PSK) {
+        return (0, wallet_1.default)(BLOCKLET_APP_PSK, undefined, BLOCKLET_WALLET_TYPE);
+    }
+    return null;
+};
+exports.getDelegator = getDelegator;
+const getDelegatee = () => {
+    const { BLOCKLET_APP_SK, BLOCKLET_WALLET_TYPE } = process.env;
+    return (0, wallet_1.default)(BLOCKLET_APP_SK, undefined, BLOCKLET_WALLET_TYPE);
+};
+exports.getDelegatee = getDelegatee;
+const getDelegation = (delegator, delegatee) => {
+    return (0, jwt_1.signV2)(delegator.address, delegator.secretKey, {
+        agentDid: `did:abt:${delegatee.address}`,
+        permissions: [
+            {
+                role: 'DIDConnectAgent',
+                claims: [
+                    'authPrincipal',
+                    'profile',
+                    'signature',
+                    'prepareTx',
+                    'agreement',
+                    'verifiableCredential',
+                    'asset',
+                    'keyPair',
+                    'encryptionKey',
+                ],
+            },
+        ],
+        exp: Math.floor(new Date().getTime() / 1000) + 60 * 60, // valid for 1 hour
+    });
+};
+exports.getDelegation = getDelegation;
+const getAuthenticatorProps = (options = {}) => ({
+    chainInfo: () => (0, util_1.getChainInfo)(process.env),
+    ...options,
+    appInfo: async (...args) => {
+        const info = await closure(options.appInfo)(...args);
+        const { request, baseUrl } = args[0];
+        const groupPathPrefix = request.headers['x-group-path-prefix'] || '/';
+        return {
+            name: process.env.BLOCKLET_APP_NAME,
+            description: process.env.BLOCKLET_APP_DESCRIPTION,
+            ...(info || {}),
+            link: (0, util_1.getConnectAppUrl)(args[0]),
+            icon: (0, url_join_1.default)(baseUrl, constants_1.SERVICE_PREFIX, `/blocklet/logo?v=${process.env.BLOCKLET_APP_VERSION || ''}`),
+            updateSubEndpoint: true,
+            subscriptionEndpoint: (0, url_join_1.default)(groupPathPrefix, constants_1.SERVICE_PREFIX, 'websocket'),
+            nodeDid: process.env.ABT_NODE_DID,
+        };
+    },
+    delegator: () => {
+        const delegator = getDelegator();
+        return delegator;
+    },
+    delegation: () => {
+        const delegator = getDelegator();
+        if (delegator) {
+            const delegatee = getDelegatee();
+            return getDelegation(delegator, delegatee);
+        }
+        return null;
+    },
+});
+exports.getAuthenticatorProps = getAuthenticatorProps;

package/lib/database/index.d.ts

@@ -0,0 +1,13 @@
+import { DataStore as BaseStore, DataStoreOptions } from '@nedb/core';
+declare class DataBase extends BaseStore {
+    constructor(name: string, options?: DataStoreOptions);
+    exists(...args: any[]): Promise<boolean>;
+    paginate({ condition, sort, page, size, projection }: {
+        condition?: {};
+        sort?: {};
+        page?: number;
+        size?: number;
+        projection?: {};
+    }): Promise<import("@nedb/core").Row<import("@nedb/core").AnyObject>[]>;
+}
+export = DataBase;

package/lib/database/index.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const core_1 = require("@nedb/core");
+class DataBase extends core_1.DataStore {
+    constructor(name, options = {}) {
+        if (!process.env.BLOCKLET_DATA_DIR) {
+            throw new Error('Blocklet SDK must be used in blocklet runtime');
+        }
+        const DB_DIR = path_1.default.join(process.env.BLOCKLET_DATA_DIR, 'db');
+        fs_extra_1.default.ensureDirSync(DB_DIR);
+        const filename = options.filename || path_1.default.join(DB_DIR, `${name}.db`);
+        super({
+            filename,
+            autoload: true,
+            timestampData: true,
+            onload: (err) => {
+                if (err) {
+                    console.error(`failed to load disk database ${filename}`, err);
+                }
+            },
+            ...options,
+        });
+        // @ts-ignore
+        const compactInterval = typeof options.compactInterval === 'undefined' ? 60 * 60 * 1000 : +options.compactInterval;
+        if (compactInterval > 0) {
+            this.persistence.setAutoCompactionInterval(compactInterval, console.warn);
+        }
+    }
+    async exists(...args) {
+        const doc = await this.findOne(...args);
+        return !!doc;
+    }
+    async paginate({ condition = {}, sort = {}, page = 1, size = 100, projection = {} }) {
+        return this.cursor(condition)
+            .sort(sort)
+            .skip(Math.max(page * size - size, 0))
+            .limit(Math.max(size, 1))
+            .projection(projection)
+            .exec();
+    }
+}
+module.exports = DataBase;

package/lib/embed/adapters/express.d.ts

@@ -0,0 +1,3 @@
+import type { Request, Response } from 'express';
+declare function expressEmbed(req: Request, res: Response): Promise<void>;
+export default expressEmbed;

package/lib/embed/adapters/express.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_embed_1 = __importDefault(require("../get-embed"));
+async function expressEmbed(req, res) {
+    const { query = {} } = req;
+    const { url = '' } = query;
+    const data = await (0, get_embed_1.default)(url);
+    res.json(data);
+}
+exports.default = expressEmbed;