@blocklet/meta 1.8.34 → 1.8.35

package/lib/util-meta.js

@@ -1,174 +1,154 @@
-const { fileURLToPath } = require('url');
-const fs = require('fs');
-const axios = require('@abtnode/util/lib/axios');
-const any = require('promise.any');
-const joinUrl = require('url-join');
-
-const { BLOCKLET_STORE_API_BLOCKLET_PREFIX } = require('@abtnode/constant');
-
-const toBlockletDid = require('./did');
-const { validateMeta, fixAndValidateService } = require('./validate');
-
-const validateUrl = async (url, expectedHttpResTypes = ['application/json', 'text/plain']) => {
-  const parsed = new URL(url);
-  const { protocol } = parsed;
-
-  // file
-  if (protocol.startsWith('file')) {
-    const decoded = decodeURIComponent(fileURLToPath(url));
-    if (!fs.existsSync(decoded)) {
-      throw new Error(`File does not exist: ${decoded}`);
-    }
-    return true;
-  }
-
-  // http(s)
-  if (protocol.startsWith('http')) {
-    let res;
-
-    try {
-      res = await axios({ url, method: 'HEAD', timeout: 1000 * 10 });
-    } catch (err) {
-      throw new Error(`Cannot get content-type from ${url}: ${err.message}`);
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSourceUrlsFromConfig = exports.getBlockletMetaFromUrls = exports.getBlockletMetaFromUrl = exports.getBlockletMetaByUrl = exports.validateUrl = void 0;
+const url_1 = require("url");
+const fs_1 = __importDefault(require("fs"));
+const axios_1 = __importDefault(require("@abtnode/util/lib/axios"));
+const promise_any_1 = __importDefault(require("promise.any"));
+const url_join_1 = __importDefault(require("url-join"));
+const constant_1 = __importDefault(require("@abtnode/constant"));
+const did_1 = __importDefault(require("./did"));
+const validate_1 = require("./validate");
+const { BLOCKLET_STORE_API_BLOCKLET_PREFIX } = constant_1.default;
+const validateUrl = (url, expectedHttpResTypes = ['application/json', 'text/plain']) => __awaiter(void 0, void 0, void 0, function* () {
+    const parsed = new URL(url);
+    const { protocol } = parsed;
+    // file
+    if (protocol.startsWith('file')) {
+        const decoded = decodeURIComponent((0, url_1.fileURLToPath)(url));
+        if (!fs_1.default.existsSync(decoded)) {
+            throw new Error(`File does not exist: ${decoded}`);
+        }
+        return true;
     }
-
-    if (
-      res.headers['content-type'] &&
-      expectedHttpResTypes.some((x) => res.headers['content-type'].includes(x)) === false
-    ) {
-      throw new Error(`Unexpected content-type from ${url}: ${res.headers['content-type']}`);
+    // http(s)
+    if (protocol.startsWith('http')) {
+        let res;
+        try {
+            res = yield (0, axios_1.default)({ url, method: 'HEAD', timeout: 1000 * 10 });
+        }
+        catch (err) {
+            throw new Error(`Cannot get content-type from ${url}: ${err.message}`);
+        }
+        if (res.headers['content-type'] &&
+            expectedHttpResTypes.some((x) => res.headers['content-type'].includes(x)) === false) {
+            throw new Error(`Unexpected content-type from ${url}: ${res.headers['content-type']}`);
+        }
+        return true;
     }
-
-    return true;
-  }
-
-  throw new Error(`Invalid url protocol: ${protocol.replace(/:$/, '')}`);
-};
-
+    throw new Error(`Invalid url protocol: ${protocol.replace(/:$/, '')}`);
+});
+exports.validateUrl = validateUrl;
 const validateBlockletMeta = (meta, opts = {}) => {
-  fixAndValidateService(meta);
-  return validateMeta(meta, opts);
+    (0, validate_1.fixAndValidateService)(meta);
+    return (0, validate_1.validateMeta)(meta, opts);
 };
-
-const getBlockletMetaByUrl = async (url) => {
-  const { protocol } = new URL(url);
-
-  if (protocol.startsWith('file')) {
-    const decoded = decodeURIComponent(fileURLToPath(url));
-    if (!fs.existsSync(decoded)) {
-      throw new Error(`File does not exist: ${decoded}`);
+const getBlockletMetaByUrl = (url) => __awaiter(void 0, void 0, void 0, function* () {
+    const { protocol } = new URL(url);
+    if (protocol.startsWith('file')) {
+        const decoded = decodeURIComponent((0, url_1.fileURLToPath)(url));
+        if (!fs_1.default.existsSync(decoded)) {
+            throw new Error(`File does not exist: ${decoded}`);
+        }
+        const d = yield fs_1.default.promises.readFile(decoded);
+        // @ts-expect-error TS(2345) FIXME: Argument of type 'Buffer' is not assignable to par... Remove this comment to see the full error message
+        const meta = JSON.parse(d);
+        return meta;
     }
-    const d = await fs.promises.readFile(decoded);
-    const meta = JSON.parse(d);
-    return meta;
-  }
-
-  if (protocol.startsWith('http')) {
-    const { data: meta } = await axios({ url, method: 'GET', timeout: 1000 * 20 });
-    if (Object.prototype.toString.call(meta) !== '[object Object]') {
-      throw new Error('Url is not valid');
+    if (protocol.startsWith('http')) {
+        const { data: meta } = yield (0, axios_1.default)({ url, method: 'GET', timeout: 1000 * 20 });
+        if (Object.prototype.toString.call(meta) !== '[object Object]') {
+            throw new Error('Url is not valid');
+        }
+        return meta;
     }
-    return meta;
-  }
-
-  throw new Error(`Invalid url protocol: ${protocol.replace(/:$/, '')}`);
-};
-
-const getBlockletMetaFromUrl = async (
-  url,
-  { validateFn = validateBlockletMeta, returnUrl = false, ensureTarball = true, logger } = {}
-) => {
-  const meta = await getBlockletMetaByUrl(url);
-  delete meta.htmlAst;
-
-  const newMeta = validateFn(meta, { ensureDist: true });
-
-  if (ensureTarball) {
-    try {
-      const { href } = new URL(newMeta.dist.tarball, url);
-      const tarball = decodeURIComponent(href);
-
-      try {
-        await validateUrl(tarball, ['application/octet-stream', 'application/x-gzip']);
-      } catch (error) {
-        if (!error.message.startsWith('Cannot get content-type')) {
-          throw error;
+    throw new Error(`Invalid url protocol: ${protocol.replace(/:$/, '')}`);
+});
+exports.getBlockletMetaByUrl = getBlockletMetaByUrl;
+const getBlockletMetaFromUrl = (url, { validateFn = validateBlockletMeta, returnUrl = false, ensureTarball = true, logger, } = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    const meta = yield getBlockletMetaByUrl(url);
+    delete meta.htmlAst;
+    const newMeta = validateFn(meta, { ensureDist: true });
+    if (ensureTarball) {
+        try {
+            const { href } = new URL(newMeta.dist.tarball, url);
+            const tarball = decodeURIComponent(href);
+            try {
+                yield validateUrl(tarball, ['application/octet-stream', 'application/x-gzip']);
+            }
+            catch (error) {
+                if (!error.message.startsWith('Cannot get content-type')) {
+                    throw error;
+                }
+            }
+            newMeta.dist.tarball = tarball;
+        }
+        catch (err) {
+            const msg = `Invalid blocklet meta: dist.tarball is not a valid url ${err.message}`;
+            if (logger) {
+                logger.error(msg);
+            }
+            throw new Error(msg);
         }
-      }
-
-      newMeta.dist.tarball = tarball;
-    } catch (err) {
-      const msg = `Invalid blocklet meta: dist.tarball is not a valid url ${err.message}`;
-
-      if (logger) {
-        logger.error(msg);
-      }
-
-      throw new Error(msg);
     }
-  }
-
-  if (returnUrl) {
-    return { meta: newMeta, url };
-  }
-
-  return newMeta;
-};
-
-const getBlockletMetaFromUrls = async (urls, { validateFn, returnUrl = false, ensureTarball = true, logger } = {}) => {
-  try {
-    const res = await any(
-      urls.map((url) => getBlockletMetaFromUrl(url, { validateFn, returnUrl, ensureTarball, logger }))
-    );
-    return res;
-  } catch (err) {
-    let { message } = err;
-    if (Array.isArray(err.errors)) {
-      message = err.errors.map((x) => x.message).join(', ');
+    if (returnUrl) {
+        return { meta: newMeta, url };
     }
-
-    if (logger) {
-      logger.error('failed get blocklet meta', { urls, message });
+    return newMeta;
+});
+exports.getBlockletMetaFromUrl = getBlockletMetaFromUrl;
+const getBlockletMetaFromUrls = (urls, { validateFn, returnUrl = false, ensureTarball = true, logger, } = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield (0, promise_any_1.default)(urls.map((url) => getBlockletMetaFromUrl(url, { validateFn, returnUrl, ensureTarball, logger })));
+        return res;
     }
-
-    throw new Error(message);
-  }
-};
-
+    catch (err) {
+        let { message } = err;
+        if (Array.isArray(err.errors)) {
+            message = err.errors.map((x) => x.message).join(', ');
+        }
+        if (logger) {
+            logger.error('failed get blocklet meta', { urls, message });
+        }
+        throw new Error(message);
+    }
+});
+exports.getBlockletMetaFromUrls = getBlockletMetaFromUrls;
 /**
- * @param {*} config defined in childrenSchema in blocklet meta schema
+ * @param {*} config defined in componentSchema in blocklet meta schema
  */
 const getSourceUrlsFromConfig = (config) => {
-  if (config.source) {
-    if (config.source.url) {
-      return [config.source.url].flat();
+    if (config.source) {
+        if (config.source.url) {
+            return [config.source.url].flat();
+        }
+        const { store, version, name } = config.source;
+        return [store]
+            .flat()
+            .map((x) => (0, url_join_1.default)(x, BLOCKLET_STORE_API_BLOCKLET_PREFIX, (0, did_1.default)(name), !version || version === 'latest' ? '' : version, 'blocklet.json'));
+    }
+    if (config.resolved) {
+        return [config.resolved];
     }
-
-    const { store, version, name } = config.source;
-    return [store]
-      .flat()
-      .map((x) =>
-        joinUrl(
-          x,
-          BLOCKLET_STORE_API_BLOCKLET_PREFIX,
-          toBlockletDid(name),
-          !version || version === 'latest' ? '' : version,
-          'blocklet.json'
-        )
-      );
-  }
-
-  if (config.resolved) {
-    return [config.resolved];
-  }
-
-  throw new Error('Invalid child config');
+    throw new Error('Invalid child config');
 };
-
-module.exports = {
-  validateUrl,
-  getBlockletMetaByUrl,
-  getBlockletMetaFromUrl,
-  getBlockletMetaFromUrls,
-  getSourceUrlsFromConfig,
+exports.getSourceUrlsFromConfig = getSourceUrlsFromConfig;
+exports.default = {
+    validateUrl,
+    getBlockletMetaByUrl,
+    getBlockletMetaFromUrl,
+    getBlockletMetaFromUrls,
+    getSourceUrlsFromConfig,
 };

package/lib/util.d.ts

@@ -0,0 +1,185 @@
+import { BlockletState } from '@abtnode/client';
+import { Request } from 'express';
+import { TBlockletMeta, TEnvironment } from './types';
+declare const getComponentId: (component?: {
+    meta?: {
+        did?: string;
+    };
+}, ancestors?: Array<{
+    meta?: {
+        did?: string;
+    };
+}>) => string;
+declare const getComponentName: (component?: {
+    meta?: {
+        name?: string;
+    };
+}, ancestors?: Array<{
+    meta?: {
+        name?: string;
+    };
+}>) => string;
+declare const getComponentBundleId: (component: {
+    meta: {
+        bundleName: string;
+        version: string;
+    };
+}) => string;
+/**
+ * a => ''
+ * @a/b => ''
+ * a/b => a
+ * @a/b/c => @a/b
+ * a/@b/c => a
+ * @a/b/@c/d => @a/b
+ * @a/b/@c/d/e => @a/b/@c/d
+ * @a/b/@c/d/@e/f => @a/b/@c/d
+ */
+declare const getParentComponentName: (name?: string) => string;
+declare const forEachBlocklet: (blocklet: BlockletState, cb: Function, { parallel, sync, params: inputParams, _parent, _root, _level, _tasks: inputTasks, _ancestors, }?: {
+    parallel?: boolean;
+    sync?: boolean;
+    params?: any;
+    _parent?: any;
+    _root?: any;
+    _level?: number;
+    _tasks?: any;
+    _ancestors?: any[];
+}) => Promise<unknown>;
+declare const forEachBlockletSync: (blocklet: any, cb: Function) => Promise<unknown>;
+declare const forEachChild: (blocklet: any, cb: Function, params?: any) => Promise<any>;
+declare const forEachChildSync: (blocklet: BlockletState, cb: Function) => Promise<any>;
+declare const findComponentById: (blocklet: BlockletState, componentId: string, { _ancestors, returnAncestors, }?: {
+    _ancestors?: any[];
+    returnAncestors?: boolean;
+}) => any;
+declare const isEnvShareable: (env?: TEnvironment & {
+    key: string;
+}) => boolean;
+declare const getSharedConfigObj: (component: BlockletState, ancestors?: any[]) => any;
+declare const getAppMissingConfigs: (blocklet?: any) => any[];
+declare const getComponentMissingConfigs: (component?: any, ancestors?: any[]) => any[];
+declare const isFreeBlocklet: (meta: TBlockletMeta) => boolean;
+declare const isFreeComponent: (meta: TBlockletMeta) => boolean;
+declare const isComponentBlocklet: (meta?: TBlockletMeta) => boolean;
+declare const wipeSensitiveData: (blocklet?: BlockletState) => BlockletState;
+declare const isDeletableBlocklet: (blocklet?: BlockletState) => boolean;
+declare const hasRunnableComponent: (blocklet: BlockletState) => boolean;
+/**
+ * 获取 blocklet 的 name
+ * @param {Object} blocklet 应用数据
+ * @param {Boolean} onlyUseMeta 优先使用应用元数据的name
+ * @returns blocklet display name
+ */
+declare const getDisplayName: (blocklet: BlockletState, onlyUseMeta?: boolean) => string;
+declare const fixBlockletStatus: (blocklet?: BlockletState) => void;
+declare const findWebInterface: (blocklet?: BlockletState | TBlockletMeta) => any;
+declare const findServiceFromMeta: (meta?: TBlockletMeta, ServiceName?: string) => any;
+declare const getWhoCanAccess: (blocklet?: BlockletState) => any;
+declare const getConnectAppUrl: ({ request, baseUrl }: {
+    request: Partial<Request>;
+    baseUrl: string;
+}) => string;
+declare const replaceSlotToIp: (url?: string, ip?: string) => string;
+declare const urlFriendly: (name: string) => string;
+declare const getChainInfo: (env: Record<string, string>) => Record<string, string>;
+declare const isExternalBlocklet: (blocklet?: BlockletState) => boolean;
+export { isFreeBlocklet };
+export { isFreeComponent };
+export { isComponentBlocklet };
+export { forEachBlocklet };
+export { forEachBlockletSync };
+export { forEachChild };
+export { forEachChildSync };
+export { isDeletableBlocklet };
+export { getSharedConfigObj };
+export { getAppMissingConfigs };
+export { getComponentMissingConfigs };
+export { isEnvShareable };
+export { wipeSensitiveData };
+export { hasRunnableComponent };
+export { getDisplayName };
+export { fixBlockletStatus };
+export { findWebInterface };
+export { findServiceFromMeta };
+export { getWhoCanAccess };
+export { replaceSlotToIp };
+export { urlFriendly };
+export { getComponentId };
+export { getComponentName };
+export { getComponentBundleId };
+export { findComponentById };
+export { getParentComponentName };
+export { getConnectAppUrl };
+export { getChainInfo };
+export { isExternalBlocklet };
+declare const _default: {
+    isFreeBlocklet: (meta: TBlockletMeta) => boolean;
+    isFreeComponent: (meta: TBlockletMeta) => boolean;
+    isComponentBlocklet: (meta?: TBlockletMeta) => boolean;
+    forEachBlocklet: (blocklet: BlockletState, cb: Function, { parallel, sync, params: inputParams, _parent, _root, _level, _tasks: inputTasks, _ancestors, }?: {
+        parallel?: boolean;
+        sync?: boolean;
+        params?: any;
+        _parent?: any;
+        _root?: any;
+        _level?: number;
+        _tasks?: any;
+        _ancestors?: any[];
+    }) => Promise<unknown>;
+    forEachBlockletSync: (blocklet: any, cb: Function) => Promise<unknown>;
+    forEachChild: (blocklet: any, cb: Function, params?: any) => Promise<any>;
+    forEachChildSync: (blocklet: BlockletState, cb: Function) => Promise<any>;
+    isDeletableBlocklet: (blocklet?: BlockletState) => boolean;
+    getSharedConfigObj: (component: BlockletState, ancestors?: any[]) => any;
+    getAppMissingConfigs: (blocklet?: any) => any[];
+    getComponentMissingConfigs: (component?: any, ancestors?: any[]) => any[];
+    isEnvShareable: (env?: TEnvironment & {
+        key: string;
+    }) => boolean;
+    wipeSensitiveData: (blocklet?: BlockletState) => BlockletState;
+    hasRunnableComponent: (blocklet: BlockletState) => boolean;
+    getDisplayName: (blocklet: BlockletState, onlyUseMeta?: boolean) => string;
+    fixBlockletStatus: (blocklet?: BlockletState) => void;
+    findWebInterface: (blocklet?: TBlockletMeta | BlockletState) => any;
+    findServiceFromMeta: (meta?: TBlockletMeta, ServiceName?: string) => any;
+    getWhoCanAccess: (blocklet?: BlockletState) => any;
+    replaceSlotToIp: (url?: string, ip?: string) => string;
+    urlFriendly: (name: string) => string;
+    getComponentId: (component?: {
+        meta?: {
+            did?: string;
+        };
+    }, ancestors?: {
+        meta?: {
+            did?: string;
+        };
+    }[]) => string;
+    getComponentName: (component?: {
+        meta?: {
+            name?: string;
+        };
+    }, ancestors?: {
+        meta?: {
+            name?: string;
+        };
+    }[]) => string;
+    getComponentBundleId: (component: {
+        meta: {
+            bundleName: string;
+            version: string;
+        };
+    }) => string;
+    findComponentById: (blocklet: BlockletState, componentId: string, { _ancestors, returnAncestors, }?: {
+        _ancestors?: any[];
+        returnAncestors?: boolean;
+    }) => any;
+    getParentComponentName: (name?: string) => string;
+    getConnectAppUrl: ({ request, baseUrl }: {
+        request: Partial<Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>>;
+        baseUrl: string;
+    }) => string;
+    getChainInfo: (env: Record<string, string>) => Record<string, string>;
+    isExternalBlocklet: (blocklet?: BlockletState) => boolean;
+};
+export default _default;