@blocklet/sdk 1.8.33 → 1.8.34

package/lib/component/index.d.ts

@@ -0,0 +1,35 @@
+import { AxiosResponse } from 'axios';
+export declare 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 call: ({ name, path: _path, data }: {
+    name?: string;
+    path: string;
+    data: any;
+}) => Promise<AxiosResponse<any, any>>;
+declare const getComponentMountPoint: (keyword: string) => string;
+declare const getComponentWebEndpoint: (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

@@ -1,92 +1,95 @@
-const axios = require('axios').default;
-const get = require('lodash/get');
-const joinURL = require('url-join');
-const stableStringify = require('json-stable-stringify');
-const { getParentComponentName } = require('@blocklet/meta/lib/util');
-
-const getWallet = require('../wallet');
-const config = 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;
+"use strict";
+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());
+    });
 };
-
-const parsePorts = () => JSON.parse(process.env.BLOCKLET_WEB_PORTS);
-
-const call = async ({ name, path: _path, data }) => {
-  const baseURL = name ? getChildWebEndpoint(name) : getParentWebEndpoint();
-
-  const url = joinURL(baseURL, _path);
-
-  return doCall({ url, data });
+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 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 = ({ url, data }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const resp = yield 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 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);
+    const fullName = `${process.env.BLOCKLET_REAL_NAME}/${name}`;
+    return getWebEndpoint(fullName);
 };
-
+exports.getChildWebEndpoint = getChildWebEndpoint;
 const getParentWebEndpoint = () => {
-  const parentName = getParentComponentName(process.env.BLOCKLET_REAL_NAME);
-  return getWebEndpoint(parentName);
+    const parentName = (0, util_1.getParentComponentName)(process.env.BLOCKLET_REAL_NAME);
+    return getWebEndpoint(parentName);
 };
-
-const getComponentMountPoint = (s) => {
-  const mountPoints = parseMountPoints();
-  const item = mountPoints.find((x) => [x.title, x.name, x.did].includes(s));
-  return item ? item.mountPoint : '';
-};
-
-const getComponentWebEndpoint = (s) => {
-  const mountPoints = parseMountPoints();
-  const item = mountPoints.find((x) => [x.title, x.name, x.did].includes(s));
-  return item ? item.webEndpoint : '';
+exports.getParentWebEndpoint = getParentWebEndpoint;
+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 = getWallet();
-  const signData = typeof data === 'undefined' ? {} : data;
-
-  return { 'x-component-sig': wallet.sign(stableStringify(signData)) };
+const call = ({ name, path: _path, data }) => __awaiter(void 0, void 0, void 0, function* () {
+    const baseURL = name ? getChildWebEndpoint(name) : getParentWebEndpoint();
+    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 : '';
 };
-
-const doCall = async ({ url, data }) => {
-  try {
-    const resp = await axios.post(url, data, { headers: sign(data), timeout: 60000 });
-    config.logger.info(`call ${url} api success`);
-    return resp;
-  } catch (error) {
-    config.logger.error(`call ${url} api failed`, {
-      url,
-      responseStatus: get(error, 'response.status'),
-      responseData: get(error, 'response.data'),
-      error,
-    });
-
-    throw new Error(`call ${url} api failed`);
-  }
+exports.getComponentMountPoint = getComponentMountPoint;
+const getComponentWebEndpoint = (keyword) => {
+    const mountPoints = parseMountPoints();
+    const item = mountPoints.find((x) => [x.title, x.name, x.did].includes(keyword));
+    return item ? item.webEndpoint : '';
 };
-
-module.exports = {
-  call,
-  getComponentMountPoint,
-  getComponentWebEndpoint,
-  getChildWebEndpoint,
-  getParentWebEndpoint,
+exports.getComponentWebEndpoint = getComponentWebEndpoint;
+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

@@ -1,14 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
 /* eslint-disable no-console */
-
-module.exports = {
-  logger: {
+exports.logger = {
     info: console.log,
     debug: (...args) => {
-      if (process.env.NODE_ENV === 'development') {
-        console.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

@@ -1,16 +1,15 @@
-const { Authenticator } = require('@did-connect/authenticator');
-
-const getWallet = require('../wallet');
-const checkBlockletEnv = require('../util/check-blocklet-env');
-const getShared = require('./shared');
-
-module.exports = class BlockletAuthenticator extends Authenticator {
-  constructor(options = {}) {
-    checkBlockletEnv();
-
-    super({
-      wallet: getWallet(),
-      ...getShared(options),
-    });
-  }
+"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 = __importDefault(require("./shared"));
+class BlockletAuthenticator extends authenticator_1.Authenticator {
+    constructor(options = {}) {
+        (0, check_blocklet_env_1.default)();
+        super(Object.assign({ wallet: (0, wallet_1.default)() }, (0, shared_1.default)(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

@@ -1,73 +1,99 @@
-const get = require('lodash/get');
-const { createHandlers } = require('@did-connect/handler');
-const Notification = require('../service/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 };
+};
+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);
+    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 get(session, 'previousConnected.userDid', '');
-};
-
-module.exports = ({ authenticator, storage, logger = consoleLogger, socketPathname, sendNotificationFn }) => {
-  const handlers = 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 {
-        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.sendToUser.bind(Notification);
-      sendFn(connectedDid, message, { ...context, session }).catch((err) => {
-        console.error(err);
-      });
+    if (session.autoConnect === false) {
+        return '';
+    }
+    if (inMobileWallet(session.didwallet)) {
+        return '';
     }
-
-    return session;
-  };
-
-  return handlers;
+    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 = (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const session = yield 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, Object.assign(Object.assign({}, context), { session })).catch((err) => {
+                console.error(err);
+            });
+        }
+        return session;
+    });
+    return handlers;
 };
+module.exports = createConnectHandlers;

package/lib/connect/shared.d.ts

@@ -0,0 +1,13 @@
+declare const connectShared: (options?: {}) => {
+    appInfo: (...args: any[]) => Promise<{
+        name: string | undefined;
+        description: string | undefined;
+        link: string;
+        icon: string;
+        updateSubEndpoint: true;
+        subscriptionEndpoint: string;
+        nodeDid: string | undefined;
+    }>;
+    chainInfo: () => any;
+};
+export = connectShared;

package/lib/connect/shared.js

@@ -1,33 +1,28 @@
-const joinUrl = require('url-join');
-const { getConnectAppUrl, getChainInfo } = require('@blocklet/meta/lib/util');
-const { SERVICE_PREFIX } = require('../util/constants');
-
+"use strict";
+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 };
+};
+const url_join_1 = __importDefault(require("url-join"));
+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);
-
-module.exports = (options = {}) => ({
-  chainInfo: () => 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'] || '/';
-    const appLogo = process.env.BLOCKLET_APP_LOGO || '';
-    const appLogoSquare = process.env.BLOCKLET_APP_LOGO_SQUARE || '';
-    const appLogoStore = joinUrl(baseUrl, SERVICE_PREFIX, '/blocklet/logo');
-
-    return {
-      name: process.env.BLOCKLET_APP_NAME,
-      description: process.env.BLOCKLET_APP_DESCRIPTION,
-      ...(info || {}),
-      link: getConnectAppUrl(args[0]),
-      icon: appLogoSquare || appLogo || appLogoStore,
-      updateSubEndpoint: true,
-      subscriptionEndpoint: joinUrl(groupPathPrefix, SERVICE_PREFIX, 'websocket'),
-      nodeDid: process.env.ABT_NODE_DID,
-    };
-  },
-});
+const connectShared = (options = {}) => (Object.assign(Object.assign({ chainInfo: () => (0, util_1.getChainInfo)(process.env) }, options), { appInfo: (...args) => __awaiter(void 0, void 0, void 0, function* () {
+        const info = yield closure(options.appInfo)(...args);
+        const { request, baseUrl } = args[0];
+        const groupPathPrefix = request.headers['x-group-path-prefix'] || '/';
+        const appLogo = process.env.BLOCKLET_APP_LOGO || '';
+        const appLogoSquare = process.env.BLOCKLET_APP_LOGO_SQUARE || '';
+        const appLogoStore = (0, url_join_1.default)(baseUrl, constants_1.SERVICE_PREFIX, '/blocklet/logo');
+        return Object.assign(Object.assign({ name: process.env.BLOCKLET_APP_NAME, description: process.env.BLOCKLET_APP_DESCRIPTION }, (info || {})), { link: (0, util_1.getConnectAppUrl)(args[0]), icon: appLogoSquare || appLogo || appLogoStore, updateSubEndpoint: true, subscriptionEndpoint: (0, url_join_1.default)(groupPathPrefix, constants_1.SERVICE_PREFIX, 'websocket'), nodeDid: process.env.ABT_NODE_DID });
+    }) }));
+module.exports = connectShared;

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

@@ -1,41 +1,54 @@
-const fs = require('fs-extra');
-const path = require('path');
-const { DataStore: BaseStore } = require('@nedb/core');
-
-if (!process.env.BLOCKLET_DATA_DIR) {
-  throw new Error('Blocklet SDK must be used in blocklet runtime');
-}
-
-const DB_DIR = path.join(process.env.BLOCKLET_DATA_DIR, 'db');
-fs.ensureDirSync(DB_DIR);
-
-module.exports = class DataStore extends BaseStore {
-  constructor(name, options = {}) {
-    const filename = options.filename || path.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,
+"use strict";
+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());
     });
-  }
-
-  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();
-  }
 };
+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");
+// FIXME: 实例创建时才去校验 process.env.BLOCKLET_DATA_DIR
+// if (!process.env.BLOCKLET_DATA_DIR) {
+//  throw new Error('Blocklet SDK must be used in blocklet runtime');
+// }
+// const DB_DIR = path.join(process.env.BLOCKLET_DATA_DIR, 'db');
+// fs.ensureDirSync(DB_DIR);
+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(Object.assign({ filename, autoload: true, timestampData: true, onload: (err) => {
+                if (err) {
+                    console.error(`failed to load disk database ${filename}`, err);
+                }
+            } }, options));
+    }
+    exists(...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const doc = yield this.findOne(...args);
+            return !!doc;
+        });
+    }
+    paginate({ condition = {}, sort = {}, page = 1, size = 100, projection = {} }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.cursor(condition)
+                .sort(sort)
+                .skip(Math.max(page * size - size, 0))
+                .limit(Math.max(size, 1))
+                .projection(projection)
+                .exec();
+        });
+    }
+}
+module.exports = DataBase;