@blocklet/js-sdk 1.16.22

package/dist/index.cjs

@@ -0,0 +1,242 @@
+'use strict';
+
+const constant = require('@abtnode/constant');
+const ufo = require('ufo');
+const Cookie = require('js-cookie');
+const axios = require('axios');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const Cookie__default = /*#__PURE__*/_interopDefaultCompat(Cookie);
+const axios__default = /*#__PURE__*/_interopDefaultCompat(axios);
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class AuthService {
+  constructor({ api }) {
+    __publicField$1(this, "api");
+    this.api = api;
+  }
+  async getUserPublicInfo({ did }) {
+    const { data } = await this.api.get("/api/user", {
+      params: { did }
+    });
+    return data;
+  }
+  async getUserPrivacyConfig({ did }) {
+    const { data } = await this.api.get("/api/user/privacy/config", {
+      params: { did }
+    });
+    return data;
+  }
+  async saveUserPrivacyConfig(config) {
+    const { data } = await this.api.post("/api/user/privacy/config", config);
+    return data;
+  }
+  async getUserNotificationConfig() {
+    const { data } = await this.api.get("/api/user/notification/config");
+    return data;
+  }
+  async saveUserNotificationConfig(config) {
+    const { data } = await this.api.post("/api/user/notification/config", config);
+    return data;
+  }
+  async testNotificationWebhook(webhook) {
+    const { data } = await this.api.put("/api/user/notification/webhook", webhook);
+    return data;
+  }
+  async getProfileUrl({ did, locale }) {
+    const url = `${constant.WELLKNOWN_SERVICE_PATH_PREFIX}/user`;
+    return ufo.withQuery(url, {
+      did,
+      locale
+    });
+  }
+}
+
+class TokenService {
+  getSessionToken() {
+    return Cookie__default.get(constant.SESSION_TOKEN_STORAGE_KEY);
+  }
+  setSessionToken(value) {
+    Cookie__default.set(constant.SESSION_TOKEN_STORAGE_KEY, value);
+  }
+  removeSessionToken() {
+    Cookie__default.remove(constant.SESSION_TOKEN_STORAGE_KEY);
+  }
+  getRefreshToken() {
+    return localStorage.getItem(constant.REFRESH_TOKEN_STORAGE_KEY);
+  }
+  setRefreshToken(value) {
+    localStorage.setItem(constant.REFRESH_TOKEN_STORAGE_KEY, value);
+  }
+  removeRefreshToken() {
+    localStorage.removeItem(constant.REFRESH_TOKEN_STORAGE_KEY);
+  }
+}
+
+const version = "1.16.22";
+
+const sleep = (time = 0) => {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve();
+    }, time);
+  });
+};
+
+async function sleepForLoading(config, lazyTime) {
+  config.metaData.endTime = +/* @__PURE__ */ new Date();
+  const { startTime, endTime } = config.metaData;
+  const timeDiff = endTime - startTime;
+  if (timeDiff < lazyTime)
+    await sleep(lazyTime - timeDiff);
+  delete config.metaData;
+}
+const createApi = (options = {}, { lazy = false, lazyTime = 300 } = {}) => {
+  const instance = axios__default.create({
+    ...options,
+    headers: {
+      ...options.headers,
+      "x-blocklet-client-sdk-version": version
+    }
+  });
+  if (lazy) {
+    instance.interceptors.request.use(
+      (config) => {
+        config.metaData = { startTime: +/* @__PURE__ */ new Date() };
+        return config;
+      },
+      (err) => Promise.reject(err)
+    );
+    instance.interceptors.response.use(
+      async (res) => {
+        await sleepForLoading(res.config, lazyTime);
+        return res;
+      },
+      async (err) => {
+        await sleepForLoading(err.response.config, lazyTime);
+        return Promise.reject(err);
+      }
+    );
+  }
+  return instance;
+};
+
+const baseURL = constant.WELLKNOWN_SERVICE_PATH_PREFIX;
+async function renewRefreshToken(refreshToken) {
+  if (!refreshToken) {
+    throw new Error("Refresh token not found");
+  }
+  const refreshApi = createApi({
+    baseURL,
+    timeout: 10 * 1e3,
+    headers: {
+      authorization: `Bearer ${encodeURIComponent(refreshToken)}`
+    }
+  });
+  const { data } = await refreshApi.post("api/did/refreshSession");
+  return data;
+}
+function createRequest({
+  getSessionToken,
+  setSessionToken,
+  removeSessionToken,
+  getRefreshToken,
+  setRefreshToken,
+  removeRefreshToken,
+  onRefreshTokenError,
+  onRefreshTokenSuccess
+}, options = {}) {
+  let refreshingTokenRequest = null;
+  const service = createApi({
+    baseURL,
+    timeout: 30 * 1e3,
+    ...options
+  });
+  service.interceptors.request.use(
+    async (config) => {
+      if (!Cookie__default.get(constant.SESSION_TOKEN_STORAGE_KEY)) {
+        const token = getSessionToken();
+        if (token) {
+          config.headers.authorization = `Bearer ${encodeURIComponent(token)}`;
+        }
+      }
+      if (refreshingTokenRequest) {
+        await refreshingTokenRequest;
+      }
+      return config;
+    },
+    (error) => Promise.reject(error)
+  );
+  service.interceptors.response.use(
+    (response) => response,
+    async (error) => {
+      const originalRequest = error.config;
+      originalRequest.headers = { ...originalRequest?.headers };
+      if (error?.response?.status === 401 && !originalRequest._retry) {
+        originalRequest._retry = true;
+        if (!refreshingTokenRequest) {
+          refreshingTokenRequest = renewRefreshToken(getRefreshToken());
+        }
+        try {
+          const tokenData = await refreshingTokenRequest;
+          setSessionToken(tokenData.nextToken);
+          setRefreshToken(tokenData.nextRefreshToken);
+          if (typeof onRefreshTokenSuccess === "function") {
+            onRefreshTokenSuccess(tokenData);
+          }
+          return service(originalRequest);
+        } catch (error2) {
+          removeSessionToken();
+          removeRefreshToken();
+          if (typeof onRefreshTokenError === "function") {
+            onRefreshTokenError(error2);
+          }
+          return Promise.reject(error2);
+        } finally {
+          refreshingTokenRequest = null;
+        }
+      }
+      return Promise.reject(error);
+    }
+  );
+  return service;
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class BlockletSDK {
+  constructor() {
+    __publicField(this, "api");
+    __publicField(this, "user");
+    __publicField(this, "token");
+    const tokenService = new TokenService();
+    const api = createRequest({
+      getSessionToken: tokenService.getSessionToken,
+      setSessionToken: tokenService.setSessionToken,
+      removeSessionToken: tokenService.removeSessionToken,
+      getRefreshToken: tokenService.getRefreshToken,
+      setRefreshToken: tokenService.setRefreshToken,
+      removeRefreshToken: tokenService.removeRefreshToken,
+      onRefreshTokenError: () => {
+        console.error("Failed to refresh token");
+      },
+      onRefreshTokenSuccess: () => {
+      }
+    });
+    this.user = new AuthService({ api });
+    this.api = api;
+    this.token = tokenService;
+  }
+}
+
+exports.BlockletSDK = BlockletSDK;

package/dist/index.d.cts

@@ -0,0 +1,55 @@
+import { Axios } from 'axios';
+
+type Webhook = {
+    type: 'slack' | 'api';
+    url: string;
+};
+type NotificationConfig = {
+    webhooks?: Webhook[];
+    notifications?: {
+        email?: boolean;
+        wallet?: boolean;
+        phone?: boolean;
+    };
+};
+type PrivacyConfig = {
+    [key: string]: boolean;
+};
+declare class AuthService {
+    private api;
+    constructor({ api }: {
+        api: Axios;
+    });
+    getUserPublicInfo({ did }: {
+        did: string;
+    }): Promise<any>;
+    getUserPrivacyConfig({ did }: {
+        did: string;
+    }): Promise<any>;
+    saveUserPrivacyConfig(config: PrivacyConfig): Promise<any>;
+    getUserNotificationConfig(): Promise<any>;
+    saveUserNotificationConfig(config: NotificationConfig): Promise<any>;
+    testNotificationWebhook(webhook: Webhook): Promise<any>;
+    getProfileUrl({ did, locale }: {
+        did: string;
+        locale: string;
+    }): Promise<string>;
+}
+
+declare class TokenService {
+    getSessionToken(): string;
+    setSessionToken(value: string): void;
+    removeSessionToken(): void;
+    getRefreshToken(): string;
+    setRefreshToken(value: string): void;
+    removeRefreshToken(): void;
+}
+
+declare class BlockletSDK {
+    private api;
+    user: AuthService;
+    token: TokenService;
+    constructor();
+}
+
+export { BlockletSDK };

package/dist/index.d.mts

@@ -0,0 +1,55 @@
+import { Axios } from 'axios';
+
+type Webhook = {
+    type: 'slack' | 'api';
+    url: string;
+};
+type NotificationConfig = {
+    webhooks?: Webhook[];
+    notifications?: {
+        email?: boolean;
+        wallet?: boolean;
+        phone?: boolean;
+    };
+};
+type PrivacyConfig = {
+    [key: string]: boolean;
+};
+declare class AuthService {
+    private api;
+    constructor({ api }: {
+        api: Axios;
+    });
+    getUserPublicInfo({ did }: {
+        did: string;
+    }): Promise<any>;
+    getUserPrivacyConfig({ did }: {
+        did: string;
+    }): Promise<any>;
+    saveUserPrivacyConfig(config: PrivacyConfig): Promise<any>;
+    getUserNotificationConfig(): Promise<any>;
+    saveUserNotificationConfig(config: NotificationConfig): Promise<any>;
+    testNotificationWebhook(webhook: Webhook): Promise<any>;
+    getProfileUrl({ did, locale }: {
+        did: string;
+        locale: string;
+    }): Promise<string>;
+}
+
+declare class TokenService {
+    getSessionToken(): string;
+    setSessionToken(value: string): void;
+    removeSessionToken(): void;
+    getRefreshToken(): string;
+    setRefreshToken(value: string): void;
+    removeRefreshToken(): void;
+}
+
+declare class BlockletSDK {
+    private api;
+    user: AuthService;
+    token: TokenService;
+    constructor();
+}
+
+export { BlockletSDK };

package/dist/index.d.ts

@@ -0,0 +1,55 @@
+import { Axios } from 'axios';
+
+type Webhook = {
+    type: 'slack' | 'api';
+    url: string;
+};
+type NotificationConfig = {
+    webhooks?: Webhook[];
+    notifications?: {
+        email?: boolean;
+        wallet?: boolean;
+        phone?: boolean;
+    };
+};
+type PrivacyConfig = {
+    [key: string]: boolean;
+};
+declare class AuthService {
+    private api;
+    constructor({ api }: {
+        api: Axios;
+    });
+    getUserPublicInfo({ did }: {
+        did: string;
+    }): Promise<any>;
+    getUserPrivacyConfig({ did }: {
+        did: string;
+    }): Promise<any>;
+    saveUserPrivacyConfig(config: PrivacyConfig): Promise<any>;
+    getUserNotificationConfig(): Promise<any>;
+    saveUserNotificationConfig(config: NotificationConfig): Promise<any>;
+    testNotificationWebhook(webhook: Webhook): Promise<any>;
+    getProfileUrl({ did, locale }: {
+        did: string;
+        locale: string;
+    }): Promise<string>;
+}
+
+declare class TokenService {
+    getSessionToken(): string;
+    setSessionToken(value: string): void;
+    removeSessionToken(): void;
+    getRefreshToken(): string;
+    setRefreshToken(value: string): void;
+    removeRefreshToken(): void;
+}
+
+declare class BlockletSDK {
+    private api;
+    user: AuthService;
+    token: TokenService;
+    constructor();
+}
+
+export { BlockletSDK };

package/dist/index.mjs

@@ -0,0 +1,235 @@
+import { WELLKNOWN_SERVICE_PATH_PREFIX, SESSION_TOKEN_STORAGE_KEY, REFRESH_TOKEN_STORAGE_KEY } from '@abtnode/constant';
+import { withQuery } from 'ufo';
+import Cookie from 'js-cookie';
+import axios from 'axios';
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class AuthService {
+  constructor({ api }) {
+    __publicField$1(this, "api");
+    this.api = api;
+  }
+  async getUserPublicInfo({ did }) {
+    const { data } = await this.api.get("/api/user", {
+      params: { did }
+    });
+    return data;
+  }
+  async getUserPrivacyConfig({ did }) {
+    const { data } = await this.api.get("/api/user/privacy/config", {
+      params: { did }
+    });
+    return data;
+  }
+  async saveUserPrivacyConfig(config) {
+    const { data } = await this.api.post("/api/user/privacy/config", config);
+    return data;
+  }
+  async getUserNotificationConfig() {
+    const { data } = await this.api.get("/api/user/notification/config");
+    return data;
+  }
+  async saveUserNotificationConfig(config) {
+    const { data } = await this.api.post("/api/user/notification/config", config);
+    return data;
+  }
+  async testNotificationWebhook(webhook) {
+    const { data } = await this.api.put("/api/user/notification/webhook", webhook);
+    return data;
+  }
+  async getProfileUrl({ did, locale }) {
+    const url = `${WELLKNOWN_SERVICE_PATH_PREFIX}/user`;
+    return withQuery(url, {
+      did,
+      locale
+    });
+  }
+}
+
+class TokenService {
+  getSessionToken() {
+    return Cookie.get(SESSION_TOKEN_STORAGE_KEY);
+  }
+  setSessionToken(value) {
+    Cookie.set(SESSION_TOKEN_STORAGE_KEY, value);
+  }
+  removeSessionToken() {
+    Cookie.remove(SESSION_TOKEN_STORAGE_KEY);
+  }
+  getRefreshToken() {
+    return localStorage.getItem(REFRESH_TOKEN_STORAGE_KEY);
+  }
+  setRefreshToken(value) {
+    localStorage.setItem(REFRESH_TOKEN_STORAGE_KEY, value);
+  }
+  removeRefreshToken() {
+    localStorage.removeItem(REFRESH_TOKEN_STORAGE_KEY);
+  }
+}
+
+const version = "1.16.22";
+
+const sleep = (time = 0) => {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve();
+    }, time);
+  });
+};
+
+async function sleepForLoading(config, lazyTime) {
+  config.metaData.endTime = +/* @__PURE__ */ new Date();
+  const { startTime, endTime } = config.metaData;
+  const timeDiff = endTime - startTime;
+  if (timeDiff < lazyTime)
+    await sleep(lazyTime - timeDiff);
+  delete config.metaData;
+}
+const createApi = (options = {}, { lazy = false, lazyTime = 300 } = {}) => {
+  const instance = axios.create({
+    ...options,
+    headers: {
+      ...options.headers,
+      "x-blocklet-client-sdk-version": version
+    }
+  });
+  if (lazy) {
+    instance.interceptors.request.use(
+      (config) => {
+        config.metaData = { startTime: +/* @__PURE__ */ new Date() };
+        return config;
+      },
+      (err) => Promise.reject(err)
+    );
+    instance.interceptors.response.use(
+      async (res) => {
+        await sleepForLoading(res.config, lazyTime);
+        return res;
+      },
+      async (err) => {
+        await sleepForLoading(err.response.config, lazyTime);
+        return Promise.reject(err);
+      }
+    );
+  }
+  return instance;
+};
+
+const baseURL = WELLKNOWN_SERVICE_PATH_PREFIX;
+async function renewRefreshToken(refreshToken) {
+  if (!refreshToken) {
+    throw new Error("Refresh token not found");
+  }
+  const refreshApi = createApi({
+    baseURL,
+    timeout: 10 * 1e3,
+    headers: {
+      authorization: `Bearer ${encodeURIComponent(refreshToken)}`
+    }
+  });
+  const { data } = await refreshApi.post("api/did/refreshSession");
+  return data;
+}
+function createRequest({
+  getSessionToken,
+  setSessionToken,
+  removeSessionToken,
+  getRefreshToken,
+  setRefreshToken,
+  removeRefreshToken,
+  onRefreshTokenError,
+  onRefreshTokenSuccess
+}, options = {}) {
+  let refreshingTokenRequest = null;
+  const service = createApi({
+    baseURL,
+    timeout: 30 * 1e3,
+    ...options
+  });
+  service.interceptors.request.use(
+    async (config) => {
+      if (!Cookie.get(SESSION_TOKEN_STORAGE_KEY)) {
+        const token = getSessionToken();
+        if (token) {
+          config.headers.authorization = `Bearer ${encodeURIComponent(token)}`;
+        }
+      }
+      if (refreshingTokenRequest) {
+        await refreshingTokenRequest;
+      }
+      return config;
+    },
+    (error) => Promise.reject(error)
+  );
+  service.interceptors.response.use(
+    (response) => response,
+    async (error) => {
+      const originalRequest = error.config;
+      originalRequest.headers = { ...originalRequest?.headers };
+      if (error?.response?.status === 401 && !originalRequest._retry) {
+        originalRequest._retry = true;
+        if (!refreshingTokenRequest) {
+          refreshingTokenRequest = renewRefreshToken(getRefreshToken());
+        }
+        try {
+          const tokenData = await refreshingTokenRequest;
+          setSessionToken(tokenData.nextToken);
+          setRefreshToken(tokenData.nextRefreshToken);
+          if (typeof onRefreshTokenSuccess === "function") {
+            onRefreshTokenSuccess(tokenData);
+          }
+          return service(originalRequest);
+        } catch (error2) {
+          removeSessionToken();
+          removeRefreshToken();
+          if (typeof onRefreshTokenError === "function") {
+            onRefreshTokenError(error2);
+          }
+          return Promise.reject(error2);
+        } finally {
+          refreshingTokenRequest = null;
+        }
+      }
+      return Promise.reject(error);
+    }
+  );
+  return service;
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class BlockletSDK {
+  constructor() {
+    __publicField(this, "api");
+    __publicField(this, "user");
+    __publicField(this, "token");
+    const tokenService = new TokenService();
+    const api = createRequest({
+      getSessionToken: tokenService.getSessionToken,
+      setSessionToken: tokenService.setSessionToken,
+      removeSessionToken: tokenService.removeSessionToken,
+      getRefreshToken: tokenService.getRefreshToken,
+      setRefreshToken: tokenService.setRefreshToken,
+      removeRefreshToken: tokenService.removeRefreshToken,
+      onRefreshTokenError: () => {
+        console.error("Failed to refresh token");
+      },
+      onRefreshTokenSuccess: () => {
+      }
+    });
+    this.user = new AuthService({ api });
+    this.api = api;
+    this.token = tokenService;
+  }
+}
+
+export { BlockletSDK };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@blocklet/js-sdk",
+  "version": "1.16.22",
+  "main": "dist/index.cjs",
+  "import": "dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "bugs": {
+    "url": "https://github.com/ArcBlock/blocklet-server/issues"
+  },
+  "description": "sdk for blocklet development, client only",
+  "keywords": [
+    "blocklet",
+    "client",
+    "sdk"
+  ],
+  "author": "blocklet<blocklet@arcblock.io>",
+  "homepage": "https://github.com/ArcBlock/blocklet-server#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ArcBlock/blocklet-server.git"
+  },
+  "scripts": {
+    "build": "unbuild"
+  },
+  "dependencies": {
+    "@abtnode/constant": "^1.16.22",
+    "axios": "^0.27.2",
+    "js-cookie": "^3.0.5",
+    "ufo": "^1.3.2"
+  },
+  "devDependencies": {
+    "unbuild": "^2.0.0"
+  }
+}