@blocklet/did-space-js 0.5.58

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

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

package/dist/commands/incremental-sync/index.js

@@ -0,0 +1,18 @@
+"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-base"), exports);
+__exportStar(require("./sync-push"), exports);

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

@@ -0,0 +1,76 @@
+import { AxiosError } from 'axios';
+import PQueue from 'p-queue';
+import { IncrementalSyncBaseCommandInput, IncrementalSyncBaseCommandOutput, SyncFolderPullCommandOutput } from '../../meta';
+import { BaseCommand } from '../base';
+import { ObjectsMap, SyncObject } from '../sync';
+import type { SpaceClientOptions } from '../../protocol';
+/**
+ * @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 IncrementalSyncBaseCommand<CommandInput extends IncrementalSyncBaseCommandInput, CommandOutput extends IncrementalSyncBaseCommandOutput> 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: IncrementalSyncBaseCommandInput, context?: SpaceClientOptions);
+    private initialize;
+    abstract getLocalObjectsMap(): Promise<ObjectsMap>;
+    abstract getRemoteObjectsMap(): Promise<ObjectsMap>;
+    /**
+     *
+     * @description 仅在开启调试模式时，输出调试信息，
+     * @protected
+     * @param {{
+     *     completedCount: number;
+     *     errorCount: number;
+     *     totalCount: number;
+     *   }} {
+     *     completedCount,
+     *     errorCount,
+     *     totalCount,
+     *   }
+     * @return {*}  {Promise<void>}
+     * @memberof IncrementalSyncBaseCommand
+     */
+    protected printDebugInfo({ direction, completedCount, errorCount, totalCount, }: {
+        direction: 'pull' | 'push';
+        completedCount: number;
+        errorCount: number;
+        totalCount: number;
+    }): void;
+    /**
+     *
+     *
+     * @protected
+     * @param {(Error | AxiosError)} error
+     * @return {*}  {Promise<void>}
+     * @memberof IncrementalSyncBaseCommand
+     */
+    protected retryRequest(error: Error | AxiosError): Promise<SyncFolderPullCommandOutput>;
+    /**
+     *
+     * @description 比较双方的文件到底谁更新鲜，更新鲜的数据才需要被同步上去
+     * @protected
+     * @param {ObjectsMap} fromObjectsMap
+     * @param {ObjectsMap} toObjectsMap
+     * @return {*}  {Promise<string[]>}
+     * @memberof IncrementalSyncBaseCommand
+     */
+    protected getWaitSyncObjects(fromObjectsMap: ObjectsMap, toObjectsMap: ObjectsMap): Promise<SyncObject[]>;
+    /**
+     * @description 判断一个对象是否应该被备份
+     * @protected
+     * @param {string} absolutePath
+     * @return {*}  {Promise<boolean>}
+     * @memberof IncrementalSyncBaseCommand
+     */
+    protected shouldBeBackup(absolutePath: string): Promise<boolean>;
+    destroy(): Promise<void>;
+}

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

@@ -0,0 +1,236 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncrementalSyncBaseCommand = 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 path_1 = require("path");
+const os_1 = require("os");
+const libs_1 = require("../../libs");
+const logger_1 = require("../../libs/logger");
+const base_1 = require("../base");
+const sleep_1 = require("../../libs/sleep");
+const { name, version } = require('../../../package.json');
+const debug = (0, debug_1.default)(`${name}@${version}:IncrementalSyncBaseCommand`);
+/**
+ * @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 IncrementalSyncBaseCommand 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
+        super(input, context);
+        this.initialize(input);
+        this.queue = new p_queue_1.default({ concurrency: this.input.concurrency });
+    }
+    initialize(input) {
+        if ((0, isUndefined_1.default)(input?.concurrency)) {
+            this.input.concurrency = IncrementalSyncBaseCommand.DEFAULT_CONCURRENCY;
+        }
+        else if (input.concurrency > IncrementalSyncBaseCommand.MAX_CONCURRENCY) {
+            this.input.concurrency = IncrementalSyncBaseCommand.MAX_CONCURRENCY;
+        }
+        else {
+            this.input.concurrency = input.concurrency;
+        }
+        if ((0, isUndefined_1.default)(input?.retryCount)) {
+            this.input.retryCount = IncrementalSyncBaseCommand.DEFAULT_RETRY_COUNT;
+        }
+        else if (input.retryCount > IncrementalSyncBaseCommand.MAX_RETRY_COUNT) {
+            this.input.retryCount = IncrementalSyncBaseCommand.MAX_RETRY_COUNT;
+        }
+        else {
+            this.input.retryCount = input.retryCount;
+        }
+        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.ABT_NODE_DATA_DIR, 'tmp', this.constructor.name, this.input.target);
+            (0, fs_extra_1.ensureDirSync)(this.input.tmpDir);
+        }
+    }
+    /**
+     *
+     * @description 仅在开启调试模式时，输出调试信息，
+     * @protected
+     * @param {{
+     *     completedCount: number;
+     *     errorCount: number;
+     *     totalCount: number;
+     *   }} {
+     *     completedCount,
+     *     errorCount,
+     *     totalCount,
+     *   }
+     * @return {*}  {Promise<void>}
+     * @memberof IncrementalSyncBaseCommand
+     */
+    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 IncrementalSyncBaseCommand
+     */
+    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)) {
+            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, sleep_1.sleep)(retryDelayMs);
+        return this.request();
+    }
+    /**
+     *
+     * @description 比较双方的文件到底谁更新鲜，更新鲜的数据才需要被同步上去
+     * @protected
+     * @param {ObjectsMap} fromObjectsMap
+     * @param {ObjectsMap} toObjectsMap
+     * @return {*}  {Promise<string[]>}
+     * @memberof IncrementalSyncBaseCommand
+     */
+    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;
+    }
+    /**
+     * @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;
+    }
+    async destroy() {
+        if (await (0, fs_extra_1.pathExists)(this.input.tmpDir)) {
+            await (0, fs_extra_1.remove)(this.input.tmpDir);
+        }
+    }
+}
+exports.IncrementalSyncBaseCommand = IncrementalSyncBaseCommand;

package/dist/commands/incremental-sync/sync-push.d.ts

@@ -0,0 +1,30 @@
+import { Object } from '@did-space/core';
+import { AxiosRequestConfig } from 'axios';
+import { IncrementalSyncPushCommandInput, IncrementalSyncPushCommandOutput } from '../../meta';
+import { ObjectsMap, SyncObject } from '../sync';
+import { IncrementalSyncBaseCommand } from './sync-base';
+/**
+ * @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, IncrementalSyncPushCommandOutput>}
+ */
+export declare class IncrementalSyncPushCommand extends IncrementalSyncBaseCommand<IncrementalSyncPushCommandInput, IncrementalSyncPushCommandOutput> {
+    protected readonly startTime: number;
+    getAxiosRequestConfig(): Promise<AxiosRequestConfig<any>>;
+    request(): Promise<IncrementalSyncPushCommandOutput>;
+    getLocalObjectsMap(): Promise<ObjectsMap>;
+    getRemoteObjectsMap(): Promise<ObjectsMap>;
+    /**
+     * @see https://github.com/ArcBlock/did-spaces/issues/955#issuecomment-1873723050
+     * @description 备份的对象随时可能在进行写入操作,所以对于需要备份的文件,最佳实践是备份它们某一个时刻的副本,否则会引发错误 Error: Unexpected end of form
+     * @param {SyncObject[]} waitSyncObjects
+     * @return {*}  {Promise<SyncObject[]>}
+     * @memberof IncrementalSyncPushCommand
+     */
+    copyObjects(waitSyncObjects: SyncObject[]): Promise<SyncObject[]>;
+    getObject(absolutePath: string): Promise<Object>;
+    registerEvents(): void;
+    private sync;
+}

package/dist/commands/incremental-sync/sync-push.js

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncrementalSyncPushCommand = void 0;
+/* eslint-disable @typescript-eslint/indent */
+const core_1 = require("@did-space/core");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const isFunction_1 = __importDefault(require("lodash/isFunction"));
+const keyBy_1 = __importDefault(require("lodash/keyBy"));
+const debug_1 = __importDefault(require("debug"));
+const xbytes_1 = __importDefault(require("xbytes"));
+const pick_1 = __importDefault(require("lodash/pick"));
+const p_all_1 = __importDefault(require("p-all"));
+const fs_extra_1 = require("fs-extra");
+const mime_types_1 = __importDefault(require("mime-types"));
+const promises_1 = require("stream/promises");
+const object_1 = require("../object");
+const logger_1 = require("../../libs/logger");
+const delete_object_1 = require("../object/delete-object");
+const sync_base_1 = require("./sync-base");
+const { name, version } = require('../../../package.json');
+const debug = (0, debug_1.default)(`${name}@${version}:sync-folder-push`);
+/**
+ * @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, IncrementalSyncPushCommandOutput>}
+ */
+class IncrementalSyncPushCommand extends sync_base_1.IncrementalSyncBaseCommand {
+    startTime = Date.now();
+    getAxiosRequestConfig() {
+        return null;
+    }
+    async request() {
+        try {
+            const localObjectsMap = await this.getLocalObjectsMap();
+            const remoteObjectsMap = await this.getRemoteObjectsMap();
+            const waitSyncObjects = await this.getWaitSyncObjects(localObjectsMap, remoteObjectsMap);
+            const syncObjects = await this.copyObjects(waitSyncObjects);
+            debug(`[${(0, logger_1.now)()}] [waitUpload] waitUploadCount=${syncObjects.length}`);
+            debug(`[${(0, logger_1.now)()}] [context]`, { input: this.input, context: (0, pick_1.default)(this.context, ['endpoint']) });
+            return await this.sync(syncObjects);
+        }
+        catch (error) {
+            return this.retryRequest(error);
+        }
+    }
+    // eslint-disable-next-line require-await
+    async getLocalObjectsMap() {
+        // @note: 注意,此处不要先计算文件 hash
+        let objects = this.input.source;
+        if ((0, isFunction_1.default)(this.input.filter)) {
+            objects = objects.filter(this.input.filter);
+        }
+        const map = (0, keyBy_1.default)(objects, (object) => object.key);
+        return map;
+    }
+    async getRemoteObjectsMap() {
+        const { data: objects } = await new object_1.ListObjectsCommand({
+            key: this.input.target,
+        }, this.context).request();
+        const map = (0, keyBy_1.default)(objects, (object) => object.key);
+        return map;
+    }
+    /**
+     * @see https://github.com/ArcBlock/did-spaces/issues/955#issuecomment-1873723050
+     * @description 备份的对象随时可能在进行写入操作,所以对于需要备份的文件,最佳实践是备份它们某一个时刻的副本,否则会引发错误 Error: Unexpected end of form
+     * @param {SyncObject[]} waitSyncObjects
+     * @return {*}  {Promise<SyncObject[]>}
+     * @memberof IncrementalSyncPushCommand
+     */
+    async copyObjects(waitSyncObjects) {
+        await (0, p_all_1.default)(waitSyncObjects.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.pipeline)((0, fs_1.createReadStream)(source), (0, fs_1.createWriteStream)(target));
+                }
+                const targetObject = await this.getObject(target);
+                x.size = targetObject.size;
+                x.lastModified = targetObject.lastModified;
+                x.hash = await (0, core_1.getHash)((0, fs_1.createReadStream)(targetObject.absolutePath));
+                x.absolutePath = targetObject.absolutePath;
+            };
+        }), {
+            concurrency: this.input.concurrency,
+        });
+        return waitSyncObjects;
+    }
+    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,
+        };
+    }
+    registerEvents() {
+        this.removeAllListeners();
+        this.on('sync.before', (input) => {
+            this.input?.onProgress?.(input);
+        });
+        this.on('sync.after', (input) => {
+            this.input?.onAfterUpload?.(input);
+        });
+    }
+    async sync(syncObjects) {
+        this.queue.removeAllListeners();
+        this.registerEvents();
+        let errorCount = 0;
+        let completedCount = 0;
+        const totalCount = syncObjects.length;
+        // @ts-expect-error
+        this.queue.on('error', async () => {
+            errorCount += 1;
+            await this.printDebugInfo({
+                direction: 'push',
+                completedCount,
+                errorCount,
+                totalCount,
+            });
+        });
+        const actions = syncObjects.map((x) => {
+            return async () => {
+                const sourceKey = x.absolutePath;
+                const targetKey = (0, path_1.join)(this.input.target, x.key);
+                if (x.action === 'PUT' && !(await this.shouldBeBackup(sourceKey))) {
+                    debug('sync.return', {
+                        sourceKey,
+                        [`$pathExists(${sourceKey})`]: false,
+                    });
+                    return;
+                }
+                this.emit('sync.before', {
+                    completed: completedCount,
+                    total: totalCount,
+                    key: sourceKey,
+                });
+                // 开始上传
+                debug(`[${(0, logger_1.now)()}] [sync:${x.action}.before] ${sourceKey} => ${targetKey} size=${(0, xbytes_1.default)(x.size, {
+                    iec: true,
+                })} completed=${completedCount} total=${totalCount}`);
+                if (x.action === 'PUT') {
+                    await new object_1.PutObjectCommand({
+                        key: targetKey,
+                        data: (0, fs_1.createReadStream)(sourceKey),
+                        hash: x.hash,
+                    }, this.context).request();
+                }
+                else {
+                    await new delete_object_1.DeleteObjectCommand({
+                        key: targetKey,
+                    }, this.context).request();
+                }
+                // progress
+                ++completedCount;
+                this.printDebugInfo({
+                    direction: 'push',
+                    completedCount,
+                    errorCount,
+                    totalCount,
+                });
+                this.emit('sync.after', {
+                    completed: completedCount,
+                    total: totalCount,
+                    key: sourceKey,
+                });
+                // 结束上传
+                debug(`[${(0, logger_1.now)()}] [sync:${x.action}.after] ${sourceKey}=>${targetKey} size=${(0, xbytes_1.default)(x.size, {
+                    iec: true,
+                })} completed=${completedCount} total=${totalCount}`);
+            };
+        });
+        await this.queue.addAll(actions);
+        await this.queue.onIdle();
+        return {
+            statusCode: 200,
+            data: {
+                count: actions.length,
+                errorCount,
+                duration: (Date.now() - this.startTime) / 1000,
+            },
+        };
+    }
+}
+exports.IncrementalSyncPushCommand = IncrementalSyncPushCommand;

package/dist/commands/index.d.ts

@@ -0,0 +1,9 @@
+export * from './backup';
+export * from './incremental-backup';
+export * from './incremental-sync';
+export * from './nft';
+export * from './object';
+export * from './restore';
+export * from './space';
+export * from './sync';
+export * from './base';

package/dist/commands/index.js

@@ -0,0 +1,25 @@
+"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("./backup"), exports);
+__exportStar(require("./incremental-backup"), exports);
+__exportStar(require("./incremental-sync"), exports);
+__exportStar(require("./nft"), exports);
+__exportStar(require("./object"), exports);
+__exportStar(require("./restore"), exports);
+__exportStar(require("./space"), exports);
+__exportStar(require("./sync"), exports);
+__exportStar(require("./base"), exports);

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

@@ -0,0 +1 @@
+export * from './put-nft-object';

package/dist/commands/nft/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("./put-nft-object"), exports);

package/dist/commands/nft/put-nft-object.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { AxiosRequestConfig } from 'axios';
+import { DidDocument } from '../../did-document';
+import { BaseCommand } from '../base';
+import { PutNftObjectCommandInput, type PutNftObjectCommandOutput } from '../../meta';
+export declare class PutNftObjectCommand extends BaseCommand<PutNftObjectCommandInput, PutNftObjectCommandOutput> {
+    private readonly tempCacheObjectKey;
+    private tempCacheObjectHash;
+    constructor(input: PutNftObjectCommandInput);
+    getUrl(): Promise<string>;
+    getDisplayUrl(): Promise<string>;
+    getStreams(): Promise<{
+        streamForUpload: Readable;
+        streamForHash: Readable;
+    }>;
+    getDidDocument(streamForHash: Readable): Promise<DidDocument>;
+    getAxiosRequestConfig(): Promise<AxiosRequestConfig<any>>;
+    destroy(): Promise<void>;
+}