@blocklet/meta 1.15.17 → 1.16.0-beta-b16cb035

package/lib/service.d.ts

@@ -0,0 +1,27 @@
+declare const setService: (meta: {
+    name: string;
+    schema: any;
+    default: any;
+}) => void;
+declare const getServiceConfig: (serviceName: string, customConfig: any, { validate }?: {
+    validate?: any;
+}) => any;
+declare const getDefaultServiceConfig: (serviceName: string) => any;
+declare const findService: (services: any[], name: string) => any;
+export { getServiceConfig };
+export { getDefaultServiceConfig };
+export { findService };
+export { setService };
+declare const _default: {
+    getServiceConfig: (serviceName: string, customConfig: any, { validate }?: {
+        validate?: any;
+    }) => any;
+    getDefaultServiceConfig: (serviceName: string) => any;
+    findService: (services: any[], name: string) => any;
+    setService: (meta: {
+        name: string;
+        schema: any;
+        default: any;
+    }) => void;
+};
+export default _default;

package/lib/service.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setService = exports.findService = exports.getDefaultServiceConfig = exports.getServiceConfig = void 0;
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+const constant_1 = __importDefault(require("@abtnode/constant"));
+const schema_1 = require("./schema");
+const { NODE_SERVICES } = constant_1.default;
+const SERVICES = {};
+const setService = (meta) => {
+    SERVICES[meta.name] = {
+        validate: meta.schema.validate.bind(meta.schema),
+        defaultConfig: meta.default,
+    };
+};
+exports.setService = setService;
+setService({
+    name: 'auth',
+    schema: schema_1.authConfigSchema,
+    default: {},
+});
+// backward compatible
+SERVICES[NODE_SERVICES.AUTH_SERVICE] = {
+    ...SERVICES[NODE_SERVICES.AUTH],
+    meta: {
+        ...SERVICES[NODE_SERVICES.AUTH].meta,
+        name: NODE_SERVICES.AUTH_SERVICE,
+    },
+};
+const getService = (serviceName) => {
+    if (!serviceName) {
+        throw new Error('service name should not be empty');
+    }
+    const service = SERVICES[serviceName];
+    if (!service) {
+        throw new Error(`service ${serviceName} does not exist`);
+    }
+    return service;
+};
+const getServiceConfig = (serviceName, customConfig, { validate } = {}) => {
+    const service = getService(serviceName);
+    const data = (0, cloneDeep_1.default)(customConfig || {});
+    const { value, error } = service.validate(data);
+    if (validate && error) {
+        throw new Error(`Invalid blocklet service config: ${error.details.map((x) => x.message).join(', ')}`);
+    }
+    return value;
+};
+exports.getServiceConfig = getServiceConfig;
+const getDefaultServiceConfig = (serviceName) => {
+    const { defaultConfig } = getService(serviceName);
+    return defaultConfig;
+};
+exports.getDefaultServiceConfig = getDefaultServiceConfig;
+const findService = (services, name) => {
+    const names = [name];
+    // backward compatible
+    if (name === NODE_SERVICES.AUTH) {
+        names.push(NODE_SERVICES.AUTH_SERVICE);
+    }
+    return (services || []).find((x) => names.includes(x.name));
+};
+exports.findService = findService;
+exports.default = {
+    getServiceConfig,
+    getDefaultServiceConfig,
+    findService,
+    setService,
+};

package/lib/types/index.d.ts

@@ -0,0 +1 @@
+export * from './schema';

package/lib/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/* eslint-disable @typescript-eslint/indent */
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./schema"), exports);

package/lib/types/schema.d.ts

@@ -0,0 +1,284 @@
+export interface TAuthConfig {
+    allowSwitchProfile?: boolean;
+    blockUnauthenticated?: boolean;
+    blockUnauthorized?: boolean;
+    ignoreUrls?: string[];
+    profileFields?: ('fullName' | 'email' | 'avatar' | 'phone')[];
+    whoCanAccess?: 'owner' | 'invited' | 'all';
+}
+export interface TBlockletMeta {
+    author?: TPerson;
+    bundleDid?: string;
+    bundleName?: string;
+    capabilities?: {
+        clusterMode?: boolean;
+        component?: boolean;
+        didSpace?: 'required' | 'optional';
+        navigation?: boolean;
+    };
+    community?: string;
+    components?: {
+        description?: TDescription;
+        mountPoint?: TMountPoint;
+        name?: TBlockletName;
+        required?: boolean;
+        source: {
+            url: string | string[];
+            version?: 'latest' | string;
+        } | {
+            name: TBlockletName;
+            store?: string | string[];
+            version?: 'latest' | string;
+        };
+        title?: TTitle;
+    }[];
+    contributors?: TPerson[];
+    copyright?: {
+        owner?: string;
+        year?: string | number;
+    };
+    description: TDescription;
+    did: string;
+    dist?: TDist;
+    documentation?: string;
+    engine?: TEngine | TEngine[];
+    environments?: TEnvironment[];
+    files?: string[];
+    gitHash?: string;
+    group: 'dapp' | 'static' | 'gateway';
+    homepage?: string;
+    htmlAst?: any;
+    interfaces?: TInterface[];
+    keywords?: string | string[];
+    lastPublishedAt?: string;
+    license?: string;
+    logo?: string;
+    logoUrl?: string;
+    main: string;
+    maintainers?: TPerson[];
+    name?: string;
+    navigation?: TNavigation;
+    nftFactory?: string;
+    path?: string;
+    payment?: {
+        componentPrice?: {
+            parentPriceRange?: number[];
+            type: 'fixed' | 'percentage';
+            value: number;
+        }[];
+        price?: {
+            address: string;
+            value: number;
+        }[];
+        share?: {
+            address: string;
+            name: string;
+            value: number;
+        }[];
+    };
+    repository?: string | {
+        directory?: string;
+        type: 'git' | 'https' | 'svn';
+        url: string;
+    };
+    requirements?: {
+        abtnode?: string;
+        cpu?: '*' | 'arm' | 'arm64' | 'ia32' | 'mips' | 'mipsel' | 'ppc' | 'ppc64' | 's390' | 's390x' | 'x32' | 'x64' | ('arm' | 'arm64' | 'ia32' | 'mips' | 'mipsel' | 'ppc' | 'ppc64' | 's390' | 's390x' | 'x32' | 'x64')[];
+        fuels?: {
+            address?: string;
+            endpoint: string;
+            reason: string;
+            value: string;
+        }[];
+        nodejs?: string;
+        os?: '*' | 'aix' | 'darwin' | 'freebsd' | 'linux' | 'openbsd' | 'sunos' | 'win32' | ('aix' | 'darwin' | 'freebsd' | 'linux' | 'openbsd' | 'sunos' | 'win32')[];
+        server?: string;
+    };
+    screenshots?: string[];
+    scripts?: TScripts;
+    signatures?: TSignature[];
+    specVersion?: string;
+    staticComponents?: {
+        description?: TDescription;
+        mountPoint: TMountPoint;
+        name: TBlockletName;
+        source: {
+            url: string | string[];
+            version?: 'latest' | string;
+        } | {
+            name: TBlockletName;
+            store?: string | string[];
+            version?: 'latest' | string;
+        };
+        title?: TTitle;
+    }[];
+    stats?: TStats;
+    storeId?: string;
+    support?: string | string;
+    tags?: string | string[];
+    theme?: TTheme;
+    timeout?: {
+        start?: number;
+    };
+    title?: TTitle | '';
+    version: string;
+}
+export type TBlockletName = string;
+export interface TComponent {
+    description?: TDescription;
+    mountPoint?: TMountPoint;
+    name?: TBlockletName;
+    required?: boolean;
+    source: {
+        url: string | string[];
+        version?: 'latest' | string;
+    } | {
+        name: TBlockletName;
+        store?: string | string[];
+        version?: 'latest' | string;
+    };
+    title?: TTitle;
+}
+export type TDescription = string;
+export interface TDist {
+    integrity: string;
+    size?: number;
+    tarball: string | string;
+}
+export interface TEndpoint {
+    meta?: {
+        params?: {
+            description: string;
+            name: string;
+        }[];
+        payable?: boolean;
+        vcType?: string;
+    };
+    path: string;
+    type: string;
+}
+export interface TEngine {
+    args?: string[];
+    interpreter?: 'binary' | 'node';
+    platform?: 'aix' | 'darwin' | 'freebsd' | 'linux' | 'openbsd' | 'sunos' | 'win32';
+    script: string;
+}
+export interface TEnvironment {
+    default?: string;
+    description: string;
+    name: TEnvironmentName;
+    required?: boolean;
+    secure?: boolean;
+    shared?: boolean;
+    validation?: string;
+}
+export type TEnvironmentName = string;
+export interface TInterface {
+    cacheable?: TPathPrefix[];
+    endpoints?: TEndpoint[];
+    name: string;
+    path?: string;
+    port?: string | {
+        external: number;
+        internal: string;
+    };
+    prefix?: string;
+    protocol?: 'tcp' | 'udp' | 'http';
+    services?: TService[];
+    type: 'web' | 'service' | 'wellknown';
+}
+export type TLogo = string;
+export type TMountPoint = string;
+export type TNavigation = TNavigationItem[];
+export interface TNavigationItem {
+    component?: string;
+    icon?: string;
+    id?: string;
+    items?: {
+        component?: string;
+        icon?: string;
+        id?: string;
+        link?: string | {
+            /**
+             * Unknown Property
+             */
+            [x: string]: string;
+        };
+        role?: string[];
+        section?: string[];
+        title: string | {
+            /**
+             * Unknown Property
+             */
+            [x: string]: string;
+        };
+        visible?: boolean;
+    }[];
+    link?: string | {
+        /**
+         * Unknown Property
+         */
+        [x: string]: string;
+    };
+    role?: string[];
+    section?: string[];
+    title: string | {
+        /**
+         * Unknown Property
+         */
+        [x: string]: string;
+    };
+    visible?: boolean;
+}
+export type TPathPrefix = string;
+export interface TPerson {
+    email?: string;
+    name: string;
+    url?: string;
+}
+export interface TScripts {
+    dev?: string;
+    e2eDev?: string;
+    postInstall?: string;
+    postStart?: string;
+    preConfig?: string;
+    preInstall?: string;
+    preStart?: string;
+    preStop?: string;
+    preUninstall?: string;
+}
+export interface TService {
+    /**
+     * Any Property
+     */
+    [x: string]: any;
+    config?: object;
+    name: string;
+}
+export interface TSignature {
+    appended?: string[];
+    created: string;
+    delegatee?: string;
+    delegateePk?: string;
+    delegation?: string;
+    excludes?: string[];
+    name: string;
+    pk: string;
+    sig: string;
+    signer: string;
+    type: string;
+}
+export interface TStats {
+    downloads?: number;
+    purchases?: number;
+    star?: number;
+}
+export interface TTheme {
+    background?: string | {
+        default?: string;
+        footer?: string;
+        header?: string;
+    };
+}
+export type TTitle = string;
+export type TUpdateMountPoint = string;

package/lib/types/schema.js

@@ -0,0 +1,3 @@
+"use strict";
+/* eslint-disable @typescript-eslint/indent */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/url-friendly.d.ts

@@ -0,0 +1,6 @@
+declare const isValidUrl: (name: string) => boolean;
+declare const urlFriendly: (name: string, { keepSlash }?: {
+    keepSlash: boolean;
+}) => string;
+export { isValidUrl };
+export default urlFriendly;

package/lib/url-friendly.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidUrl = void 0;
+const toLower_1 = __importDefault(require("lodash/toLower"));
+const slugify_1 = __importDefault(require("slugify"));
+const isValidUrl = (name) => {
+    const regex = /[\s$*_+~.()'"!:@\\]+/g;
+    return !regex.test(name);
+};
+exports.isValidUrl = isValidUrl;
+const urlFriendly = (name, { keepSlash = true } = { keepSlash: true }) => {
+    if (!keepSlash) {
+        return (0, toLower_1.default)((0, slugify_1.default)(name.replace(/^[@./-]/, '').replace(/[@./_]/g, '-')));
+    }
+    return (0, toLower_1.default)((0, slugify_1.default)(name.replace(/^[@.-]/, '').replace(/[@._]/g, '-'), { remove: /[^\w\s$*_+~.()'"!:@^/]+/g }));
+};
+exports.default = urlFriendly;

package/lib/util-meta.d.ts

@@ -0,0 +1,42 @@
+import { TBlockletMeta, TComponent } from './types';
+declare const validateUrl: (url: string, expectedHttpResTypes?: string[]) => Promise<boolean>;
+declare const getBlockletMetaByUrl: (url: string) => Promise<TBlockletMeta>;
+declare const getBlockletMetaFromUrl: (url: string, { validateFn, returnUrl, ensureTarball, logger, }?: {
+    validateFn?: Function;
+    returnUrl?: boolean;
+    ensureTarball?: boolean;
+    logger?: any;
+}) => Promise<any>;
+declare const getBlockletMetaFromUrls: (urls: string[], { validateFn, returnUrl, ensureTarball, logger, }?: {
+    validateFn?: Function;
+    returnUrl?: boolean;
+    ensureTarball?: boolean;
+    logger?: any;
+}) => Promise<any>;
+/**
+ * @param {*} config defined in componentSchema in blocklet meta schema
+ */
+declare const getSourceUrlsFromConfig: (config: TComponent & any) => string[];
+export { validateUrl };
+export { getBlockletMetaByUrl };
+export { getBlockletMetaFromUrl };
+export { getBlockletMetaFromUrls };
+export { getSourceUrlsFromConfig };
+declare const _default: {
+    validateUrl: (url: string, expectedHttpResTypes?: string[]) => Promise<boolean>;
+    getBlockletMetaByUrl: (url: string) => Promise<TBlockletMeta>;
+    getBlockletMetaFromUrl: (url: string, { validateFn, returnUrl, ensureTarball, logger, }?: {
+        validateFn?: Function;
+        returnUrl?: boolean;
+        ensureTarball?: boolean;
+        logger?: any;
+    }) => Promise<any>;
+    getBlockletMetaFromUrls: (urls: string[], { validateFn, returnUrl, ensureTarball, logger, }?: {
+        validateFn?: Function;
+        returnUrl?: boolean;
+        ensureTarball?: boolean;
+        logger?: any;
+    }) => Promise<any>;
+    getSourceUrlsFromConfig: (config: any) => string[];
+};
+export default _default;

package/lib/util-meta.js

@@ -0,0 +1,146 @@
+"use strict";
+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 = async (url, expectedHttpResTypes = ['application/json', 'text/plain']) => {
+    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;
+    }
+    // http(s)
+    if (protocol.startsWith('http')) {
+        let res;
+        try {
+            res = await (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;
+    }
+    throw new Error(`Invalid url protocol: ${protocol.replace(/:$/, '')}`);
+};
+exports.validateUrl = validateUrl;
+const validateBlockletMeta = (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((0, url_1.fileURLToPath)(url));
+        if (!fs_1.default.existsSync(decoded)) {
+            throw new Error(`File does not exist: ${decoded}`);
+        }
+        const d = await 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;
+    }
+    if (protocol.startsWith('http')) {
+        const { data: meta } = await (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;
+    }
+    throw new Error(`Invalid url protocol: ${protocol.replace(/:$/, '')}`);
+};
+exports.getBlockletMetaByUrl = getBlockletMetaByUrl;
+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;
+                }
+            }
+            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;
+};
+exports.getBlockletMetaFromUrl = getBlockletMetaFromUrl;
+const getBlockletMetaFromUrls = async (urls, { validateFn, returnUrl = false, ensureTarball = true, logger, } = {}) => {
+    try {
+        const res = await (0, promise_any_1.default)(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 (logger) {
+            logger.error('failed get blocklet meta', { urls, message });
+        }
+        throw new Error(message);
+    }
+};
+exports.getBlockletMetaFromUrls = getBlockletMetaFromUrls;
+/**
+ * @param {*} config defined in componentSchema in blocklet meta schema
+ */
+const getSourceUrlsFromConfig = (config) => {
+    if (config.source) {
+        if (config.source.url) {
+            return [config.source.url].flat();
+        }
+        const { store, version, name } = config.source;
+        // FIXME: @linchen the format or version is semverRange, blocklet store should support it
+        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];
+    }
+    throw new Error('Invalid child config');
+};
+exports.getSourceUrlsFromConfig = getSourceUrlsFromConfig;
+exports.default = {
+    validateUrl,
+    getBlockletMetaByUrl,
+    getBlockletMetaFromUrl,
+    getBlockletMetaFromUrls,
+    getSourceUrlsFromConfig,
+};