@blocklet/sdk 1.15.17 → 1.16.0-beta-b16cb035

package/lib/embed/generate.d.ts

@@ -0,0 +1,6 @@
+export default function generateBlockletEmbed(): {
+    name: string;
+    url: string;
+    origin: string;
+    embed: any[];
+};

package/lib/embed/generate.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function safeJsonParse(input, defaultValue) {
+    try {
+        return JSON.parse(input);
+    }
+    catch {
+        return defaultValue;
+    }
+}
+function generateBlockletEmbed() {
+    const { BLOCKLET_APP_NAME, BLOCKLET_APP_URL, BLOCKLET_REAL_NAME } = process.env;
+    const BLOCKLET_MOUNT_POINTS = safeJsonParse(process.env.BLOCKLET_MOUNT_POINTS, []);
+    let url = '/';
+    let name = BLOCKLET_APP_NAME;
+    const blockletNames = BLOCKLET_REAL_NAME.split('/');
+    const componentBlocklet = BLOCKLET_MOUNT_POINTS.find((blockletItem) => blockletItem.name === blockletNames[blockletNames.length - 1]);
+    if (componentBlocklet) {
+        // 先假设只有一层 component blocklet
+        url = componentBlocklet.mountPoint;
+        name = componentBlocklet.title;
+    }
+    return {
+        name,
+        url,
+        origin: BLOCKLET_APP_URL,
+        embed: [],
+    };
+}
+exports.default = generateBlockletEmbed;

package/lib/embed/get-embed-url.d.ts

@@ -0,0 +1 @@
+export default function getEmbedUrlFromUrl(url: string): Promise<string>;

package/lib/embed/get-embed-url.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const slim_1 = require("cheerio/lib/slim");
+const ufo_1 = require("ufo");
+const axios_1 = __importDefault(require("axios"));
+/**
+ * 判断 htmlContent 是否为开发环境
+ * @param {string} htmlContent
+ * @returns boolean
+ */
+function checkViteDev(htmlContent) {
+    const $ = (0, slim_1.load)(htmlContent);
+    const scirptList = $('script[type="module"]');
+    return !![...scirptList].find((scriptItem) => {
+        if (scriptItem.firstChild?.type === 'text') {
+            return scriptItem.firstChild?.data?.includes('window.__vite_plugin_react_preamble_installed__ = true');
+        }
+        return false;
+    });
+}
+async function getEmbedUrlFromUrl(url) {
+    try {
+        const { data: htmlContent } = await axios_1.default.get(url, {
+            headers: {
+                accept: 'text/html,application/xhtml+xml,application/xml',
+            },
+        });
+        let prefix = '/';
+        let metaUrl = url;
+        const $ = (0, slim_1.load)(htmlContent);
+        const link = $('link[rel="blocklet-open-embed"]');
+        const blockletScript = $('script[src="__blocklet__.js"]');
+        if (link && link.length > 0) {
+            metaUrl = link.attr('href') || url;
+        }
+        else {
+            return url;
+        }
+        const isViteDev = checkViteDev(htmlContent);
+        if (blockletScript && blockletScript.length > 0) {
+            const scriptUrl = new URL('__blocklet__.js?type=json', (0, ufo_1.withTrailingSlash)(url));
+            const { data: blockletMeta } = await axios_1.default.get(scriptUrl.href);
+            prefix = blockletMeta.prefix;
+        }
+        // 在 vite 开发模式下，embed-url 指向的地址会自动被增加一个前缀
+        return isViteDev ? (0, ufo_1.joinURL)(prefix, metaUrl.replace(prefix, '')) : (0, ufo_1.joinURL)(prefix, metaUrl);
+    }
+    catch {
+        return url;
+    }
+}
+exports.default = getEmbedUrlFromUrl;

package/lib/embed/get-embed.d.ts

@@ -0,0 +1 @@
+export default function getBlockletEmbedFromUrl(url: string): Promise<object | null>;

package/lib/embed/get-embed.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const lodash_1 = require("lodash");
+const axios_1 = __importDefault(require("axios"));
+const get_embed_url_1 = __importDefault(require("./get-embed-url"));
+async function getBlockletEmbedFromUrl(url) {
+    const metaUrl = await (0, get_embed_url_1.default)(url);
+    try {
+        if (metaUrl) {
+            let finalUrl = '';
+            if (metaUrl.startsWith('http://') || metaUrl.startsWith('https://')) {
+                finalUrl = metaUrl;
+            }
+            else {
+                finalUrl = `${new URL(url).origin}${(0, path_1.join)('/', metaUrl)}`;
+            }
+            const { data: metaData } = await axios_1.default.get(finalUrl);
+            if ((0, lodash_1.isObject)(metaData)) {
+                return metaData;
+            }
+        }
+    }
+    catch {
+        /* empty */
+    }
+    return null;
+}
+exports.default = getBlockletEmbedFromUrl;

package/lib/embed/index.d.ts

@@ -0,0 +1,10 @@
+import generateBlockletEmbed from './generate';
+import expressEmbed from './adapters/express';
+import getBlockletEmbedFromUrl from './get-embed';
+declare const _default: {
+    expressEmbed: typeof expressEmbed;
+    generateBlockletEmbed: typeof generateBlockletEmbed;
+    getBlockletEmbedFromUrl: typeof getBlockletEmbedFromUrl;
+};
+export default _default;
+export { expressEmbed, generateBlockletEmbed, getBlockletEmbedFromUrl };

package/lib/embed/index.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 });
+exports.getBlockletEmbedFromUrl = exports.generateBlockletEmbed = exports.expressEmbed = void 0;
+const generate_1 = __importDefault(require("./generate"));
+exports.generateBlockletEmbed = generate_1.default;
+const express_1 = __importDefault(require("./adapters/express"));
+exports.expressEmbed = express_1.default;
+const get_embed_1 = __importDefault(require("./get-embed"));
+exports.getBlockletEmbedFromUrl = get_embed_1.default;
+exports.default = { expressEmbed: express_1.default, generateBlockletEmbed: generate_1.default, getBlockletEmbedFromUrl: get_embed_1.default };

package/lib/embed/message.d.ts

@@ -0,0 +1,26 @@
+type InstanceType = 'client' | 'server';
+type MessageType = string;
+interface Callback {
+    (...args: any[]): void;
+}
+declare class Message {
+    id: string;
+    type: InstanceType;
+    private bc;
+    private eventMap;
+    init: (cb: Callback) => void;
+    onInit: (getData: () => any) => void;
+    close: () => void;
+    constructor(id: string, type?: InstanceType);
+    on(type: MessageType, cb: Callback): void;
+    off(type: MessageType, cb: Callback): void;
+    once(type: MessageType, cb: Callback): void;
+    send(type: MessageType, payload: any): void;
+}
+declare function useMessage(id?: string, type?: InstanceType): any;
+declare const _default: {
+    useMessage: typeof useMessage;
+    Message: typeof Message;
+};
+export default _default;
+export { useMessage, Message };

package/lib/embed/message.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = exports.useMessage = void 0;
+const INIT = '__init';
+const ON_INIT = '__on-init';
+function checkKey(typeKey) {
+    return !typeKey.startsWith(INIT);
+}
+function ensureType(type) {
+    if (!checkKey(type)) {
+        throw new Error(`Type can't starts with ${INIT}`);
+    }
+}
+function notExist() {
+    console.error('function not exist');
+}
+class Message {
+    constructor(id, type = 'client') {
+        this.id = id;
+        this.type = type;
+        const bc = new BroadcastChannel(this.id);
+        this.bc = bc;
+        this.eventMap = new Map();
+        const onMessage = (event) => {
+            const { data } = event;
+            const { type: messageType, payload, id: dataId } = data;
+            if (dataId === this.id) {
+                const cbList = this.eventMap.get(messageType) || [];
+                cbList.forEach((cbItem) => {
+                    cbItem(payload);
+                });
+            }
+        };
+        window.addEventListener('message', onMessage, false);
+        this.close = () => {
+            window.removeEventListener('message', onMessage, false);
+            // v1 message
+            this.bc.close();
+        };
+        // v1 message
+        bc.onmessage = ({ data }) => {
+            const { type: messageType, payload } = data;
+            const cbList = this.eventMap.get(messageType) || [];
+            cbList.forEach((cbItem) => {
+                cbItem(payload);
+            });
+        };
+        this.init = notExist;
+        this.onInit = notExist;
+        if (type === 'server') {
+            this.onInit = (getData = () => null) => {
+                this.eventMap.set(INIT, [
+                    (listenKey) => {
+                        const initData = getData();
+                        this.send(listenKey, initData);
+                    },
+                ]);
+            };
+        }
+        if (type === 'client') {
+            this.init = (cb) => {
+                const uniqueId = String(+new Date());
+                const listenKey = `${ON_INIT}_${uniqueId}`;
+                this.once(listenKey, cb);
+                this.send(INIT, listenKey);
+            };
+        }
+    }
+    on(type, cb) {
+        ensureType(type);
+        const cbList = this.eventMap.get(type) || [];
+        cbList.push(cb);
+        this.eventMap.set(type, cbList);
+    }
+    off(type, cb) {
+        ensureType(type);
+        const cbList = this.eventMap.get(type) || [];
+        if (cb) {
+            const index = cbList.indexOf(cb);
+            if (index !== -1) {
+                cbList.splice(index, 1);
+            }
+        }
+        else {
+            cbList.length = 0;
+        }
+        this.eventMap.set(type, cbList);
+    }
+    once(type, cb) {
+        ensureType(type);
+        const callback = (...args) => {
+            cb(...args);
+            this.off(type, callback);
+        };
+        this.on(type, callback);
+    }
+    send(type, payload) {
+        const data = {
+            id: this.id,
+            type,
+            payload,
+        };
+        if (this.type === 'server') {
+            const iframeList = [...document.querySelectorAll(`iframe[data-id="${this.id}"]`)];
+            iframeList.forEach((iframeItem) => {
+                iframeItem.contentWindow.postMessage(data, '*');
+            });
+        }
+        else {
+            window.parent.postMessage(data, '*');
+        }
+        // v1 message
+        this.bc.postMessage(data);
+    }
+}
+exports.Message = Message;
+const messageCache = new Map();
+function useMessage(id, type = 'client') {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const _id = id || window.frameElement?.dataset.id || window.name;
+    if (messageCache.has(_id)) {
+        return messageCache.get(_id);
+    }
+    const isInIframe = window !== window.parent;
+    const message = (type === 'server' || isInIframe) && _id ? new Message(_id, type) : null;
+    const data = { message };
+    messageCache.set(_id, data);
+    return data;
+}
+exports.useMessage = useMessage;
+exports.default = {
+    useMessage,
+    Message,
+};

package/lib/env.d.ts

@@ -0,0 +1,17 @@
+declare const _default: Readonly<{
+    appId: string;
+    appPid: string;
+    appName: string;
+    appDescription: string;
+    appUrl: string;
+    isComponent: boolean;
+    dataDir: string;
+    cacheDir: string;
+    mode: string;
+    appStorageEndpoint: string;
+    serverVersion: string;
+    preferences: {
+        [key: string]: any;
+    };
+}>;
+export = _default;

package/lib/env.js

@@ -0,0 +1,3 @@
+"use strict";
+const env_1 = require("./util/env");
+module.exports = (0, env_1.parseEnv)();

package/lib/error-handler.js

@@ -1,9 +1,9 @@
 process
-  .on('uncaughtException', (error) => {
-    console.error(error.message);
+    .on('uncaughtException', (err) => {
+    console.error(err.message);
     process.exit(1);
-  })
-  .on('unhandledRejection', (reason) => {
+})
+    .on('unhandledRejection', (reason) => {
     console.error(reason.message);
     process.exit(1);
-  });
+});

package/lib/index.d.ts

@@ -0,0 +1,53 @@
+import { TNavigation, TTheme } from '@blocklet/meta/lib/types';
+import Auth from './service/auth';
+import Notification from './service/notification';
+import WalletAuthenticator from './wallet-authenticator';
+import WalletHandlers from './wallet-handler';
+import BlockletAuthenticator from './connect/authenticator';
+import createConnectHandlers from './connect/handler';
+import Database from './database/index';
+import env from './env';
+import middlewares from './middlewares/index';
+import getWallet from './wallet';
+import Component, { MountPoint } from './component/index';
+import Security from './security/index';
+import config from './config';
+export { Auth as AuthService };
+export { Auth };
+export { Notification as NotificationService };
+export { Notification };
+export { WalletHandlers };
+export { WalletAuthenticator };
+export { BlockletAuthenticator };
+export { createConnectHandlers };
+export { Database };
+export { getWallet };
+export { env };
+export { middlewares };
+export { Component as component };
+export { Component };
+export { Security };
+export { config };
+declare global {
+    interface Window {
+        blocklet: {
+            [x: string]: any;
+            appId: string;
+            appPid: string;
+            appName: string;
+            appDescription: string;
+            appLogo: string;
+            appLogoRect: string;
+            appUrl: string;
+            isComponent: boolean;
+            prefix: string;
+            groupPrefix: string;
+            version: string;
+            theme: TTheme;
+            navigation: TNavigation[];
+            preferences: any;
+            componentMountPoints: MountPoint[];
+        };
+    }
+}
+export * from './component';

package/lib/index.js

@@ -1,13 +1,50 @@
-const AuthService = require('./service/auth');
-const NotificationService = require('./service/notification');
-const WalletAuthenticator = require('./wallet-authenticator');
-const WalletHandlers = require('./wallet-handler');
-const Database = require('./database');
-
-module.exports = {
-  AuthService,
-  NotificationService,
-  WalletHandlers,
-  WalletAuthenticator,
-  Database,
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = exports.Security = exports.Component = exports.component = exports.middlewares = exports.env = exports.getWallet = exports.Database = exports.createConnectHandlers = exports.BlockletAuthenticator = exports.WalletAuthenticator = exports.WalletHandlers = exports.Notification = exports.NotificationService = exports.Auth = exports.AuthService = void 0;
+const auth_1 = __importDefault(require("./service/auth"));
+exports.AuthService = auth_1.default;
+exports.Auth = auth_1.default;
+const notification_1 = __importDefault(require("./service/notification"));
+exports.NotificationService = notification_1.default;
+exports.Notification = notification_1.default;
+const wallet_authenticator_1 = __importDefault(require("./wallet-authenticator"));
+exports.WalletAuthenticator = wallet_authenticator_1.default;
+const wallet_handler_1 = __importDefault(require("./wallet-handler"));
+exports.WalletHandlers = wallet_handler_1.default;
+const authenticator_1 = __importDefault(require("./connect/authenticator"));
+exports.BlockletAuthenticator = authenticator_1.default;
+const handler_1 = __importDefault(require("./connect/handler"));
+exports.createConnectHandlers = handler_1.default;
+const index_1 = __importDefault(require("./database/index"));
+exports.Database = index_1.default;
+const env_1 = __importDefault(require("./env"));
+exports.env = env_1.default;
+const index_2 = __importDefault(require("./middlewares/index"));
+exports.middlewares = index_2.default;
+const wallet_1 = __importDefault(require("./wallet"));
+exports.getWallet = wallet_1.default;
+const index_3 = __importDefault(require("./component/index"));
+exports.component = index_3.default;
+exports.Component = index_3.default;
+const index_4 = __importDefault(require("./security/index"));
+exports.Security = index_4.default;
+const config_1 = __importDefault(require("./config"));
+exports.config = config_1.default;
+__exportStar(require("./component"), exports);

package/lib/middlewares/auth.d.ts

@@ -0,0 +1,8 @@
+import { NextFunction, Request, Response } from 'express';
+type MiddlewareParams = {
+    roles?: string[];
+    permissions?: string[];
+    getClient?: Function;
+};
+declare const AuthMiddleware: ({ roles, permissions, getClient }?: MiddlewareParams) => (req: Request, res: Response, next: NextFunction) => Promise<void>;
+export = AuthMiddleware;

package/lib/middlewares/auth.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const lru_cache_1 = __importDefault(require("lru-cache"));
+const auth_1 = __importDefault(require("../service/auth"));
+const cache = new lru_cache_1.default({ max: 10, maxAge: 60 * 1000 });
+const clients = {};
+const getServiceClient = () => {
+    const appId = process.env.BLOCKLET_APP_ID;
+    if (!clients[appId]) {
+        clients[appId] = new auth_1.default();
+    }
+    return clients[appId];
+};
+const getPermissionsByRole = async (getClient, role) => {
+    if (!role) {
+        return [];
+    }
+    const cached = cache.get(role);
+    if (cached) {
+        return cached;
+    }
+    const res = await getClient().getPermissionsByRole(role);
+    cache.set(role, res);
+    return res;
+};
+const AuthMiddleware = ({ roles, permissions, getClient = getServiceClient } = {}) => {
+    if (roles && !Array.isArray(roles)) {
+        throw new Error('roles must be array');
+    }
+    if (permissions && !Array.isArray(permissions)) {
+        throw new Error('permissions must be array');
+    }
+    return async (req, res, next) => {
+        if (!req.headers['x-user-did']) {
+            res.status(401).json({ code: 'forbidden', error: 'not authorized' });
+            return;
+        }
+        if (roles && !roles.includes(req.headers['x-user-role'])) {
+            res.status(403).json({ code: 'forbidden', error: 'no permission' });
+            return;
+        }
+        if (permissions) {
+            const { permissions: list } = await getPermissionsByRole(getClient, req.headers['x-user-role']);
+            if (!permissions.some((x) => (list || []).some((y) => y.name === x))) {
+                res.status(403).json({ code: 'forbidden', error: 'no permission' });
+                return;
+            }
+        }
+        next();
+    };
+};
+module.exports = AuthMiddleware;

package/lib/middlewares/component.d.ts

@@ -0,0 +1,7 @@
+import { NextFunction, Request, Response } from 'express';
+declare const verifySig: (req: Request, res: Response, next: NextFunction) => void | Response<any, Record<string, any>>;
+export { verifySig };
+declare const _default: {
+    verifySig: (req: Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: NextFunction) => void | Response<any, Record<string, any>>;
+};
+export default _default;

package/lib/middlewares/component.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySig = void 0;
+const json_stable_stringify_1 = __importDefault(require("json-stable-stringify"));
+const wallet_1 = __importDefault(require("../wallet"));
+const config_1 = require("../config");
+const verifySig = (req, res, next) => {
+    try {
+        const wallet = (0, wallet_1.default)();
+        const sig = req.get('x-component-sig');
+        if (!sig) {
+            return res.status(400).json({ error: 'Bad Request' });
+        }
+        const data = typeof req.body === 'undefined' ? {} : req.body;
+        const verified = wallet.verify((0, json_stable_stringify_1.default)(data), sig);
+        if (!verified) {
+            return res.status(401).json({ error: 'verify sig failed' });
+        }
+    }
+    catch (error) {
+        config_1.logger.error(error);
+        return res.status(401).json({ error: 'verify sig failed' });
+    }
+    return next();
+};
+exports.verifySig = verifySig;
+exports.default = {
+    verifySig,
+};

package/lib/middlewares/index.d.ts

@@ -0,0 +1,24 @@
+import user from './user';
+import auth from './auth';
+import component from './component';
+export { user };
+export { auth };
+export { component };
+declare const _default: {
+    user: () => (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>> & {
+        user?: {
+            did: string;
+            role: string;
+            fullName: string;
+        };
+    }, res: import("express").Response<any, Record<string, any>>, next: import("express").NextFunction) => Promise<void>;
+    auth: ({ roles, permissions, getClient }?: {
+        roles?: string[];
+        permissions?: string[];
+        getClient?: Function;
+    }) => (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: import("express").Response<any, Record<string, any>>, next: import("express").NextFunction) => Promise<void>;
+    component: {
+        verifySig: (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: import("express").Response<any, Record<string, any>>, next: import("express").NextFunction) => void | import("express").Response<any, Record<string, any>>;
+    };
+};
+export default _default;

package/lib/middlewares/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.component = exports.auth = exports.user = void 0;
+const user_1 = __importDefault(require("./user"));
+exports.user = user_1.default;
+const auth_1 = __importDefault(require("./auth"));
+exports.auth = auth_1.default;
+const component_1 = __importDefault(require("./component"));
+exports.component = component_1.default;
+exports.default = {
+    user: user_1.default,
+    auth: auth_1.default,
+    component: component_1.default,
+};

package/lib/middlewares/user.d.ts

@@ -0,0 +1,10 @@
+import { NextFunction, Request, Response } from 'express';
+type User = {
+    did: string;
+    role: string | undefined;
+    fullName: string;
+};
+declare const userMiddleware: () => (req: Request & {
+    user?: User;
+}, res: Response, next: NextFunction) => Promise<void>;
+export = userMiddleware;

package/lib/middlewares/user.js

@@ -0,0 +1,12 @@
+"use strict";
+const userMiddleware = () => async (req, res, next) => {
+    if (req.headers['x-user-did']) {
+        req.user = {
+            did: req.headers['x-user-did'],
+            role: req.headers['x-user-role'],
+            fullName: decodeURIComponent(req.headers['x-user-fullname']),
+        };
+    }
+    next();
+};
+module.exports = userMiddleware;

package/lib/security/index.d.ts

@@ -0,0 +1,9 @@
+declare const encrypt: (message: string) => string;
+declare const decrypt: (message: string) => string;
+export { encrypt };
+export { decrypt };
+declare const _default: {
+    encrypt: (message: string) => string;
+    decrypt: (message: string) => string;
+};
+export default _default;