@blocklet/did-space-js 0.5.58

package/dist/commands/restore/restore-blocklet.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestoreBlockletCommand = void 0;
+const path_1 = require("path");
+const core_1 = require("@did-space/core");
+const base_1 = require("../base");
+const sync_1 = require("../sync");
+const post_app_restore_1 = require("./post-app-restore");
+const put_app_restore_1 = require("./put-app-restore");
+const libs_1 = require("../../libs");
+const space_1 = require("../../libs/space");
+/**
+ *
+ * FIXME: @yejianchao 优化点，需要支持 joi 校验
+ * @export
+ * @class RestoreBlockletCommand
+ * @extends {BaseCommand<RestoreBlockletCommandInput, RestoreBlockletCommandOutput>}
+ */
+class RestoreBlockletCommand extends base_1.BaseCommand {
+    getAxiosRequestConfig() {
+        return null;
+    }
+    async resolveMiddleware() {
+        let appRestore;
+        try {
+            // @note: 备份还原的时候我们希望使用 service url 来完成，不希望走 CDN
+            this.context.endpoint = await (0, space_1.getSpaceServiceEndpoint)(this.context.endpoint);
+            appRestore = (await new post_app_restore_1.PostAppRestoreCommand({
+                userDid: this.input.userDid,
+                referrer: this.input.referrer,
+                serverDid: this.input.serverDid,
+            }, this.context).request()).data;
+            const res = await new sync_1.SyncFolderPullCommand({
+                source: (0, path_1.join)('.did-objects', this.input.appDid, '/'),
+                ...this.input,
+            }, this.context).request();
+            if (res.data.errorCount !== 0) {
+                await new put_app_restore_1.PutAppRestoreCommand({
+                    id: appRestore.id,
+                    status: core_1.APP_BACKUP_STATUS.FAILED,
+                    message: res?.statusMessage,
+                }, this.context)
+                    .request()
+                    .catch(console.error);
+                return res;
+            }
+            // 仅仅是触发一下接口，更新一下 updateAt
+            await new put_app_restore_1.PutAppRestoreCommand({
+                id: appRestore.id,
+                status: core_1.APP_BACKUP_STATUS.SUCCEEDED,
+            }, this.context).request();
+            return res;
+        }
+        catch (err) {
+            console.error(err);
+            const error = err;
+            const message = (0, libs_1.getErrorMessage)(error);
+            if (appRestore) {
+                await new put_app_restore_1.PutAppRestoreCommand({
+                    id: appRestore.id,
+                    status: core_1.APP_BACKUP_STATUS.FAILED,
+                    message,
+                }, this.context)
+                    .request()
+                    .catch(console.error);
+            }
+            return {
+                statusCode: (0, libs_1.getErrorStatusCode)(error),
+                statusMessage: message,
+                stack: error.stack,
+                data: {
+                    errorCount: -1,
+                    count: -1,
+                    duration: -1,
+                },
+            };
+        }
+    }
+}
+exports.RestoreBlockletCommand = RestoreBlockletCommand;

package/dist/commands/space/head.d.ts

@@ -0,0 +1,8 @@
+import { AxiosRequestConfig } from 'axios';
+import { BaseCommand } from '../base';
+import type { HeadSpaceCommandInput, HeadSpaceCommandOutput } from '../../meta/object/head-object-command';
+export declare class HeadSpaceCommand extends BaseCommand<HeadSpaceCommandInput, HeadSpaceCommandOutput> {
+    getAxiosRequestConfig(): Promise<AxiosRequestConfig<any>>;
+    private getUrl;
+    resolveMiddleware(): Promise<HeadSpaceCommandOutput>;
+}

package/dist/commands/space/head.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeadSpaceCommand = void 0;
+const core_1 = require("@did-space/core");
+const ufo_1 = require("ufo");
+const libs_1 = require("../../libs");
+const security_1 = require("../../security");
+const base_1 = require("../base");
+class HeadSpaceCommand extends base_1.BaseCommand {
+    // eslint-disable-next-line require-await
+    async getAxiosRequestConfig() {
+        return null;
+    }
+    getUrl() {
+        const array = this.context.endpoint.split('/');
+        const lastIndexOfApp = array.lastIndexOf('app');
+        const url = array.filter((_, i) => i < lastIndexOfApp).join('/');
+        return (0, ufo_1.withQuery)(url, {
+            ...this.input,
+        });
+    }
+    async resolveMiddleware() {
+        const url = this.getUrl();
+        const method = 'HEAD';
+        const { headers } = (0, security_1.signRequest)({
+            url,
+            method,
+            data: {},
+            headers: {
+                [core_1.HEADERS.X_SIGNATURE_VERSION]: '2',
+            },
+            wallet: this.context.wallet,
+            delegation: this.context.delegation,
+        });
+        const optionsOfTextResponseBody = {
+            method,
+            headers: {
+                ...headers,
+            },
+            throwHttpErrors: false,
+        };
+        // TODO: axios 会导致严重的内存泄漏, 之后可以考虑切换到 got, @see: https://github.com/axios/axios/issues/4763#issuecomment-1334953446
+        const response = await (0, libs_1.gotApi)(url, optionsOfTextResponseBody);
+        return {
+            statusCode: response.statusCode,
+            statusMessage: response.headers['x-message'] ?? response.statusMessage,
+            data: undefined,
+            response,
+        };
+    }
+}
+exports.HeadSpaceCommand = HeadSpaceCommand;

package/dist/commands/space/index.d.ts

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

package/dist/commands/space/index.js

@@ -0,0 +1,17 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./head"), exports);

package/dist/commands/sync/index.d.ts

@@ -0,0 +1,3 @@
+export * from './sync-folder-base';
+export * from './sync-folder-pull';
+export * from './sync-folder-push';

package/dist/commands/sync/index.js

@@ -0,0 +1,19 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sync-folder-base"), exports);
+__exportStar(require("./sync-folder-pull"), exports);
+__exportStar(require("./sync-folder-push"), exports);

package/dist/commands/sync/sync-folder-base.d.ts

@@ -0,0 +1,105 @@
+import { Object } from '@did-space/core';
+import { AxiosError } from 'axios';
+import PQueue from 'p-queue';
+import { ListObjectCommandOutput, OnAfterUploadInput, OnProgressInput, SyncFolderBaseCommandInput, SyncFolderBaseCommandOutput, SyncFolderPullCommandOutput } from '../../meta';
+import { BaseCommand } from '../base';
+import type { SpaceClientOptions } from '../../protocol';
+export interface ObjectsMap {
+    [key: string]: ListObjectCommandOutput['data'];
+}
+export interface SyncObject extends Object {
+    action: 'PUT' | 'DELETE';
+}
+/**
+ * @see s3 sync https://stackoverflow.com/questions/27932345/downloading-folders-from-aws-s3-cp-or-sync
+ * @see Keep-alive 和连接重用的 NodeJS https://azureossd.github.io/2022/03/10/NodeJS-with-Keep-Alives-and-Connection-Reuse/index.html
+ * @export
+ * @class SyncFolderPushCommand
+ * @extends {BaseCommand<SyncFolderCommandInput, SyncFolderPushCommandOutput>}
+ */
+export declare abstract class SyncFolderBaseCommand<CommandInput extends SyncFolderBaseCommandInput, CommandOutput extends SyncFolderBaseCommandOutput> extends BaseCommand<CommandInput, CommandOutput> {
+    protected readonly queue: PQueue;
+    protected readonly startTime: number;
+    static readonly DEFAULT_RETRY_COUNT: number;
+    static readonly MAX_RETRY_COUNT: number;
+    static readonly DEFAULT_CONCURRENCY: number;
+    static readonly MAX_CONCURRENCY: number;
+    private retryCount;
+    constructor(input: SyncFolderBaseCommandInput, context?: SpaceClientOptions);
+    abstract getLocalObjectsMap(): Promise<ObjectsMap>;
+    abstract getRemoteObjectsMap(): Promise<ObjectsMap>;
+    /**
+     *
+     * @description 仅在开启调试模式时，输出调试信息，
+     * @protected
+     * @param {{
+     *     completedCount: number;
+     *     errorCount: number;
+     *     totalCount: number;
+     *   }} {
+     *     completedCount,
+     *     errorCount,
+     *     totalCount,
+     *   }
+     * @return {*}  {Promise<void>}
+     * @memberof SyncFolderBaseCommand
+     */
+    protected printDebugInfo({ direction, completedCount, errorCount, totalCount, }: {
+        direction: 'pull' | 'push';
+        completedCount: number;
+        errorCount: number;
+        totalCount: number;
+    }): Promise<void>;
+    /**
+     *
+     *
+     * @protected
+     * @param {(Error | AxiosError)} error
+     * @return {*}  {Promise<void>}
+     * @memberof SyncFolderBaseCommand
+     */
+    protected retryRequest(error: Error | AxiosError): Promise<SyncFolderPullCommandOutput>;
+    /**
+     *
+     * @description 比较双方的文件到底谁更新鲜，更新鲜的数据才需要被同步上去
+     * @protected
+     * @param {ObjectsMap} fromObjectsMap
+     * @param {ObjectsMap} toObjectsMap
+     * @return {*}  {Promise<string[]>}
+     * @memberof SyncFolderBaseCommand
+     */
+    protected getWaitSyncObjects(fromObjectsMap: ObjectsMap, toObjectsMap: ObjectsMap): Promise<SyncObject[]>;
+    /**
+     * @see https://github.com/ArcBlock/did-spaces/issues/955#issuecomment-1873723050
+     * @description 备份的对象随时可能在进行写入操作,所以对于需要备份的文件,最佳实践是备份它们某一个时刻的副本,否则会引发错误 Error: Unexpected end of form
+     * @param {SyncObject[]} waitSyncObjects
+     * @return {*}  {Promise<SyncObject[]>}
+     * @memberof SyncFolderBaseCommand
+     */
+    copyObjects(waitSyncObjects: SyncObject[]): Promise<SyncObject[]>;
+    /**
+     * @description 是同一个对象吗?
+     * @param {string} source
+     * @param {string} target
+     * @return {*}  {Promise<boolean>}
+     * @memberof SyncFolderBaseCommand
+     */
+    diffObject(source: string, target: string): Promise<{
+        same: boolean;
+        sourceObject: Object;
+        targetObject: Object;
+    }>;
+    getObject(absolutePath: string): Promise<Object>;
+    /**
+     * @FIXME: 重复的代码,需要重构一下接口
+     * @description 判断一个对象是否应该被备份
+     * @protected
+     * @param {string} absolutePath
+     * @return {*}  {Promise<boolean>}
+     * @memberof IncrementalSyncBaseCommand
+     */
+    protected shouldBeBackup(absolutePath: string): Promise<boolean>;
+    protected triggerOnProgressHook(params: OnProgressInput): Promise<void>;
+    protected triggerOnAfterUploadHook(params: OnAfterUploadInput): Promise<void>;
+    destroy(): Promise<void>;
+}

package/dist/commands/sync/sync-folder-base.js

@@ -0,0 +1,319 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncFolderBaseCommand = void 0;
+/* eslint-disable @typescript-eslint/indent */
+const core_1 = require("@did-space/core");
+const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
+const isUndefined_1 = __importDefault(require("lodash/isUndefined"));
+const keys_1 = __importDefault(require("lodash/keys"));
+const p_queue_1 = __importDefault(require("p-queue"));
+const debug_1 = __importDefault(require("debug"));
+const fs_extra_1 = require("fs-extra");
+const p_all_1 = __importDefault(require("p-all"));
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+const path_1 = require("path");
+const mime_types_1 = __importDefault(require("mime-types"));
+const promises_1 = require("fs/promises");
+const os_1 = require("os");
+const libs_1 = require("../../libs");
+const logger_1 = require("../../libs/logger");
+const base_1 = require("../base");
+const { name, version } = require('../../../package.json');
+const debug = (0, debug_1.default)(`${name}@${version}:SyncFolderBaseCommand`);
+/**
+ * @see s3 sync https://stackoverflow.com/questions/27932345/downloading-folders-from-aws-s3-cp-or-sync
+ * @see Keep-alive 和连接重用的 NodeJS https://azureossd.github.io/2022/03/10/NodeJS-with-Keep-Alives-and-Connection-Reuse/index.html
+ * @export
+ * @class SyncFolderPushCommand
+ * @extends {BaseCommand<SyncFolderCommandInput, SyncFolderPushCommandOutput>}
+ */
+class SyncFolderBaseCommand extends base_1.BaseCommand {
+    queue;
+    startTime = Date.now();
+    static DEFAULT_RETRY_COUNT = 3;
+    static MAX_RETRY_COUNT = 10;
+    static DEFAULT_CONCURRENCY = 4;
+    static MAX_CONCURRENCY = (0, os_1.cpus)().length;
+    retryCount = 0;
+    constructor(input, context) {
+        // @ts-expect-error why?暂时没想通报错的原因
+        super(input, context);
+        if ((0, isUndefined_1.default)(input?.concurrency)) {
+            this.input.concurrency = SyncFolderBaseCommand.DEFAULT_CONCURRENCY;
+        }
+        else if (input.concurrency > SyncFolderBaseCommand.MAX_CONCURRENCY) {
+            this.input.concurrency = SyncFolderBaseCommand.MAX_CONCURRENCY;
+        }
+        else {
+            this.input.concurrency = input.concurrency;
+        }
+        if ((0, isUndefined_1.default)(input?.retryCount)) {
+            this.input.retryCount = SyncFolderBaseCommand.DEFAULT_RETRY_COUNT;
+        }
+        else if (input.retryCount > SyncFolderBaseCommand.MAX_RETRY_COUNT) {
+            this.input.retryCount = SyncFolderBaseCommand.MAX_RETRY_COUNT;
+        }
+        else {
+            this.input.retryCount = input.retryCount;
+        }
+        if (!this.input.source.endsWith('/')) {
+            this.input.source = (0, path_1.join)(this.input.source, '/');
+        }
+        if (!this.input.target.endsWith('/')) {
+            this.input.target = (0, path_1.join)(this.input.target, '/');
+        }
+        if ((0, isEmpty_1.default)(this.input.tmpDir)) {
+            this.input.tmpDir = (0, path_1.join)(process.env.BLOCKLET_DATA_DIR || process.env.ABT_NODE_DATA_DIR, 'tmp', this.constructor.name, this.input.target);
+            (0, fs_extra_1.ensureDirSync)(this.input.tmpDir);
+        }
+        this.queue = new p_queue_1.default({ concurrency: this.input.concurrency });
+    }
+    /**
+     *
+     * @description 仅在开启调试模式时，输出调试信息，
+     * @protected
+     * @param {{
+     *     completedCount: number;
+     *     errorCount: number;
+     *     totalCount: number;
+     *   }} {
+     *     completedCount,
+     *     errorCount,
+     *     totalCount,
+     *   }
+     * @return {*}  {Promise<void>}
+     * @memberof SyncFolderBaseCommand
+     */
+    printDebugInfo({ direction, completedCount, errorCount, totalCount, }) {
+        if (!this.input.debug) {
+            return;
+        }
+        const remaining = totalCount - errorCount - completedCount;
+        const progress = ((completedCount * 100) / totalCount).toFixed(2);
+        const duration = (Date.now() - this.startTime) / 1000;
+        logger_1.logger.info(`[${direction}] pending: ${this.queue.pending}, completed: ${completedCount}, error: ${errorCount}, remaining: ${remaining}, progress: ${progress}%, total: ${totalCount}, retryCount: ${this.input.retryCount}, duration: ${duration}(s)`);
+    }
+    /**
+     *
+     *
+     * @protected
+     * @param {(Error | AxiosError)} error
+     * @return {*}  {Promise<void>}
+     * @memberof SyncFolderBaseCommand
+     */
+    async retryRequest(error) {
+        // 减少重试次数
+        --this.input.retryCount;
+        // clear queue
+        this.queue.clear();
+        // 输出错误
+        const errorMessage = (0, libs_1.getErrorMessage)(error);
+        const statusCode = (0, libs_1.getErrorStatusCode)(error);
+        logger_1.logger.error('#retryRequest()', error);
+        logger_1.logger.error('#retryRequest()', {
+            input: this.input,
+            endpoint: this.context.endpoint,
+            errorMessage,
+            statusCode,
+        });
+        // FIXME: retryCount === 0 表示，重试次数刚好用完了，后续优化 server 显示错误的进度 @yejianchao
+        // 防呆控制，retryCount < 0 说明调用基础接口始终是失败的,遇到了预料之外的事情，因此需要停止运行
+        if (this.input.retryCount <= 0 || [400, 401, 403, 404, 413].includes(statusCode)) {
+            await this.destroy();
+            return {
+                statusCode,
+                statusMessage: (0, libs_1.getErrorMessage)(error),
+                stack: error.stack,
+                data: {
+                    errorCount: -1,
+                    count: -1,
+                    duration: (Date.now() - this.startTime) / 1000,
+                },
+            };
+        }
+        // 目前我们的重试时间间隔是以 2 的指数增长的，第1次重试 1 s,第 2 次重试 2 s, 第 3 次重试间隔 4 s...
+        const retryDelayMs = 2 ** this.retryCount * 1000;
+        ++this.retryCount;
+        await (0, libs_1.sleep)(retryDelayMs);
+        return this.request();
+    }
+    /**
+     *
+     * @description 比较双方的文件到底谁更新鲜，更新鲜的数据才需要被同步上去
+     * @protected
+     * @param {ObjectsMap} fromObjectsMap
+     * @param {ObjectsMap} toObjectsMap
+     * @return {*}  {Promise<string[]>}
+     * @memberof SyncFolderBaseCommand
+     */
+    async getWaitSyncObjects(fromObjectsMap, toObjectsMap) {
+        const intersectionKeys = [...new Set((0, keys_1.default)(fromObjectsMap).concat((0, keys_1.default)(toObjectsMap)))];
+        const actions = intersectionKeys.map((key) => {
+            return async () => {
+                const fromObject = fromObjectsMap[key];
+                const toObject = toObjectsMap[key];
+                debug(`getWaitSyncObjects.$fromObjectsMap[${key}]`, fromObject);
+                debug(`getWaitSyncObjects.$toObjectsMap[${key}]`, toObject);
+                // 本地存在的文件 && 在远程不存在, 则修改远程的
+                if (fromObject && !toObject) {
+                    return {
+                        ...fromObject,
+                        action: 'PUT',
+                        key,
+                    };
+                }
+                // 本地不存在 && 远程存在, 则删除远程的
+                if (!fromObject && toObject) {
+                    return {
+                        ...toObject,
+                        action: 'DELETE',
+                        key,
+                    };
+                }
+                // 本地存在的文件 && 在远程存在 && 两者文件大小不一致, 则修改远程的
+                if (fromObject.size !== toObject.size) {
+                    return {
+                        ...fromObject,
+                        action: 'PUT',
+                        key,
+                    };
+                }
+                // 本地存在的文件 && 在远程存在 && 本地日期不新鲜,则无需修改
+                if (fromObject.lastModified <= toObject.lastModified) {
+                    return null;
+                }
+                if (!fromObject.hash) {
+                    if (!(await this.shouldBeBackup(fromObject.absolutePath))) {
+                        return null;
+                    }
+                    // 此时计算 hash
+                    fromObject.hash = await (0, core_1.getHash)((0, fs_extra_1.createReadStream)(fromObject.absolutePath));
+                }
+                // 本地存在的文件 && 在远程存在 && 两者文件内容不同, 则修改远程的
+                if (fromObject.hash !== toObject.hash) {
+                    return {
+                        ...fromObject,
+                        action: 'PUT',
+                        key,
+                    };
+                }
+                return null;
+            };
+        });
+        const syncObjects = (await (0, p_all_1.default)(actions, { concurrency: this.input.concurrency })).filter(Boolean);
+        debug('getWaitSyncObjects.$syncObjects.length', syncObjects.length);
+        debug('getWaitSyncObjects.$syncObjects.slice(0, 3)', syncObjects.slice(0, 3));
+        return syncObjects;
+    }
+    /**
+     * @see https://github.com/ArcBlock/did-spaces/issues/955#issuecomment-1873723050
+     * @description 备份的对象随时可能在进行写入操作,所以对于需要备份的文件,最佳实践是备份它们某一个时刻的副本,否则会引发错误 Error: Unexpected end of form
+     * @param {SyncObject[]} waitSyncObjects
+     * @return {*}  {Promise<SyncObject[]>}
+     * @memberof SyncFolderBaseCommand
+     */
+    async copyObjects(waitSyncObjects) {
+        const syncObjects = (0, cloneDeep_1.default)(waitSyncObjects);
+        await (0, p_all_1.default)(syncObjects.map((x) => {
+            return async () => {
+                const source = x.absolutePath;
+                const target = (0, path_1.join)(this.input.tmpDir, x.key);
+                if (x.action !== 'PUT' || !(await (0, fs_extra_1.pathExists)(source))) {
+                    return;
+                }
+                if (!(await (0, fs_extra_1.pathExists)(target))) {
+                    await (0, fs_extra_1.ensureDir)((0, path_1.dirname)(target));
+                    await (0, promises_1.copyFile)(source, target);
+                }
+                const { same, targetObject } = await this.diffObject(source, target);
+                if (!same) {
+                    x.size = targetObject.size;
+                    x.lastModified = targetObject.lastModified;
+                    x.hash = await (0, core_1.getHash)((0, fs_extra_1.createReadStream)(targetObject.absolutePath));
+                }
+                x.absolutePath = target;
+            };
+        }), {
+            concurrency: this.input.concurrency,
+        });
+        return syncObjects;
+    }
+    /**
+     * @description 是同一个对象吗?
+     * @param {string} source
+     * @param {string} target
+     * @return {*}  {Promise<boolean>}
+     * @memberof SyncFolderBaseCommand
+     */
+    async diffObject(source, target) {
+        const sourceObject = await this.getObject(source);
+        const targetObject = await this.getObject(target);
+        const same = sourceObject.lastModified <= targetObject.lastModified && sourceObject.size === targetObject.size;
+        return {
+            same,
+            sourceObject,
+            targetObject,
+        };
+    }
+    async getObject(absolutePath) {
+        const fileStat = await (0, fs_extra_1.stat)(absolutePath);
+        const objectName = (0, path_1.basename)(absolutePath);
+        const directorySuffixes = fileStat.isDirectory() ? '/' : '';
+        return {
+            key: absolutePath,
+            name: (0, path_1.join)(objectName, directorySuffixes),
+            isDir: fileStat.isDirectory(),
+            size: fileStat.size,
+            lastModified: new Date(fileStat.mtime).getTime(),
+            editable: false,
+            mimeType: mime_types_1.default.lookup(objectName) || 'unknown',
+            absolutePath,
+        };
+    }
+    /**
+     * @FIXME: 重复的代码,需要重构一下接口
+     * @description 判断一个对象是否应该被备份
+     * @protected
+     * @param {string} absolutePath
+     * @return {*}  {Promise<boolean>}
+     * @memberof IncrementalSyncBaseCommand
+     */
+    // eslint-disable-next-line require-await
+    async shouldBeBackup(absolutePath) {
+        if (typeof absolutePath !== 'string' || (0, isEmpty_1.default)(absolutePath)) {
+            return false;
+        }
+        if (absolutePath.endsWith('~')) {
+            // 临时文件不备份,因为随时可能被删除,从而引发错误
+            return false;
+        }
+        if (!(await (0, fs_extra_1.pathExists)(absolutePath))) {
+            // 不存在的文件不备份
+            return false;
+        }
+        return true;
+    }
+    // FIXME: @yejianchao 之后考虑使用事件驱动
+    async triggerOnProgressHook(params) {
+        if (typeof this.input.onProgress !== 'function') {
+            return;
+        }
+        await this.input.onProgress(params);
+    }
+    // FIXME: @yejianchao 之后考虑使用事件驱动
+    async triggerOnAfterUploadHook(params) {
+        if (typeof this.input.onAfterUpload !== 'function') {
+            return;
+        }
+        await this.input.onAfterUpload(params);
+    }
+    async destroy() {
+        if (await (0, fs_extra_1.pathExists)(this.input.tmpDir)) {
+            await (0, fs_extra_1.rm)(this.input.tmpDir, { recursive: true });
+        }
+    }
+}
+exports.SyncFolderBaseCommand = SyncFolderBaseCommand;

package/dist/commands/sync/sync-folder-pull.d.ts

@@ -0,0 +1,13 @@
+import { AxiosRequestConfig } from 'axios';
+import { SyncFolderPullCommandInput, SyncFolderPullCommandOutput } from '../../meta';
+import { ObjectsMap, SyncFolderBaseCommand, SyncObject } from './sync-folder-base';
+import type { SpaceClientOptions } from '../../protocol';
+export declare class SyncFolderPullCommand extends SyncFolderBaseCommand<SyncFolderPullCommandInput, SyncFolderPullCommandOutput> {
+    protected readonly startTime: number;
+    constructor(input: SyncFolderPullCommandInput, context?: SpaceClientOptions);
+    getAxiosRequestConfig(): Promise<AxiosRequestConfig<any>>;
+    request(): Promise<SyncFolderPullCommandOutput>;
+    getRemoteObjectsMap(): Promise<ObjectsMap>;
+    getLocalObjectsMap(): Promise<ObjectsMap>;
+    sync(syncObjects: SyncObject[]): Promise<SyncFolderPullCommandOutput>;
+}