@did-space/core 0.2.173 → 0.3.0

package/dist/drivers/base.d.ts

@@ -2,7 +2,7 @@
 import { Stream } from 'stream';
 import { SpaceConfig } from '../configuration';
 import { Data, Object } from '../meta';
-import { AppSpaceOptions, DeleteOptions, DriverOptions, DriverProtocol, GetHashOptions, KeyStatus, ListOptions, ListsOptions, PermissionOptions, ReadOptions, SpaceConfigProtocol, SpaceOperatorProtocol, WriteOptions } from '../protocols';
+import { AppSpaceOptions, DeleteOptions, DriverOptions, DriverProtocol, ExistsAsOwnerOptions, GetHashOptions, KeyStatus, ListOptions, ListsOptions, PermissionOptions, ReadAsOwnerOptions, ReadOptions, SpaceConfigProtocol, SpaceOperatorProtocol, WriteAsOwnerOptions, WriteOptions } from '../protocols';
 export declare abstract class BaseDriver implements DriverProtocol {
     readonly options: DriverOptions;
     constructor(options: DriverOptions);
@@ -32,9 +32,9 @@ export declare abstract class BaseDriver implements DriverProtocol {
     exists(options: ReadOptions): Promise<boolean>;
     lists(options: ListsOptions): Promise<Object[]>;
     list(options: ListOptions): Promise<Object>;
-    writeAsOwner(key: string, data: Data): Promise<void>;
-    deleteAsOwner(key: string): Promise<void>;
-    readAsOwner(key: string): Promise<Stream>;
-    existsAsOwner(key: string): Promise<boolean>;
+    writeAsOwner(key: string, data: Data, options?: WriteAsOwnerOptions): Promise<void>;
+    deleteAsOwner(key: string, options?: ReadAsOwnerOptions): Promise<void>;
+    readAsOwner(key: string, options?: ReadAsOwnerOptions): Promise<Stream>;
+    existsAsOwner(key: string, options?: ExistsAsOwnerOptions): Promise<boolean>;
     getStatusAsOwner(key: string): Promise<KeyStatus>;
 }

package/dist/drivers/base.js

@@ -134,17 +134,17 @@ class BaseDriver {
     list(options) {
         return this.spaceOperator.list(options);
     }
-    writeAsOwner(key, data) {
-        return this.spaceOperator.writeAsOwner(key, data);
+    writeAsOwner(key, data, options) {
+        return this.spaceOperator.writeAsOwner(key, data, options);
     }
-    deleteAsOwner(key) {
-        return this.spaceOperator.deleteAsOwner(key);
+    deleteAsOwner(key, options) {
+        return this.spaceOperator.deleteAsOwner(key, options);
     }
-    readAsOwner(key) {
-        return this.spaceOperator.readAsOwner(key);
+    readAsOwner(key, options) {
+        return this.spaceOperator.readAsOwner(key, options);
     }
-    existsAsOwner(key) {
-        return this.spaceOperator.existsAsOwner(key);
+    existsAsOwner(key, options) {
+        return this.spaceOperator.existsAsOwner(key, options);
     }
     getStatusAsOwner(key) {
         return this.spaceOperator.getStatusAsOwner(key);

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export * from './configuration';
 export * from './constants';
 export * from './drivers';
 export * from './meta';
+export * from './model';
 export * from './protocols';
 export * from './schemas';
 export * from './space';

package/dist/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./configuration"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./drivers"), exports);
 __exportStar(require("./meta"), exports);
+__exportStar(require("./model"), exports);
 __exportStar(require("./protocols"), exports);
 __exportStar(require("./schemas"), exports);
 __exportStar(require("./space"), exports);

package/dist/meta/object.d.ts

@@ -13,6 +13,11 @@ export interface Object {
     size: number;
     lastModified: number;
     editable: boolean;
+    /**
+     * @description 如果是一个文件夹，则为 null
+     * @type {string}
+     * @memberof Object
+     */
     mimeType: string;
     [key: string]: any;
 }

package/dist/model/index.d.ts

@@ -0,0 +1,3 @@
+export * from './tree';
+export * from './object';
+export * from './object-collection';

package/dist/model/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("./tree"), exports);
+__exportStar(require("./object"), exports);
+__exportStar(require("./object-collection"), exports);

package/dist/model/object-collection.d.ts

@@ -0,0 +1,28 @@
+import { Model } from 'skypesky-sequelize';
+/**
+ * @description 存储的是对象的信息，不保存结构，创建之初就确定了，只能增加，删除
+ * @export
+ * @interface ObjectModel
+ */
+export interface ObjectCollectionModel {
+    /**
+     * @primaryKey
+     * @description 对象的唯一标识,格式是 ipfs cid v1
+     * @type {string}
+     * @column {DataTypes.CHAR(64)}
+     * @memberof ObjectCollectionModel
+     */
+    id: string;
+    /**
+     * @description 对象的创建时间
+     * @type {string}
+     * @column {DataTypes.DATE}
+     * @memberof ObjectCollectionModel
+     */
+    createdAt: string;
+}
+export declare class ObjectCollectionRepositoryClass extends Model<ObjectCollectionModel> implements ObjectCollectionModel {
+    id: string;
+    createdAt: string;
+}
+export type ObjectCollectionRepository = typeof ObjectCollectionRepositoryClass;

package/dist/model/object-collection.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectCollectionRepositoryClass = void 0;
+const skypesky_sequelize_1 = require("skypesky-sequelize");
+class ObjectCollectionRepositoryClass extends skypesky_sequelize_1.Model {
+}
+exports.ObjectCollectionRepositoryClass = ObjectCollectionRepositoryClass;

package/dist/model/object.d.ts

@@ -0,0 +1,59 @@
+import { Model } from 'skypesky-sequelize';
+/**
+ * @description 存储的是对象的信息，不保存结构，创建之初就确定了，只能增加，删除
+ * @export
+ * @interface ObjectModel
+ */
+export interface ObjectModel {
+    /**
+     * @primaryKey
+     * @description 对象的唯一标识,格式是 ipfs cid v1
+     * @type {string}
+     * @column {DataTypes.STRING(59)}
+     * @memberof ObjectModel
+     */
+    id: string;
+    /**
+     * @description 对象的大小
+     * @type {number}
+     * @column {DataTypes.BIGINT.UNSIGNED}
+     * @memberof ObjectModel
+     */
+    size: number;
+    /**
+     * @description 存储对象的元数据
+     * @type {ObjectModelMeta}
+     * @column {DataTypes.JSON}
+     * @memberof ObjectModel
+     */
+    meta: ObjectModelMeta;
+    /**
+     * @description 对象的创建时间
+     * @type {string}
+     * @column {DataTypes.DATE}
+     * @memberof ObjectModel
+     */
+    createdAt: string;
+}
+export interface ObjectModelMeta {
+    /**
+     *
+     * @description 对象的 hash,如果对象是文件夹则为 null,否则必须有值
+     * @type {string}
+     * @memberof ObjectModelMeta
+     */
+    mimeType: string;
+    /**
+     * @description 保存这个对象第一次出现的文件名
+     * @type {string}
+     * @memberof ObjectModelMeta
+     */
+    key: string;
+}
+export declare class ObjectRepositoryClass extends Model<ObjectModel> implements ObjectModel {
+    id: string;
+    size: number;
+    meta: ObjectModelMeta;
+    createdAt: string;
+}
+export type ObjectRepository = typeof ObjectRepositoryClass;

package/dist/model/object.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectRepositoryClass = void 0;
+const skypesky_sequelize_1 = require("skypesky-sequelize");
+class ObjectRepositoryClass extends skypesky_sequelize_1.Model {
+}
+exports.ObjectRepositoryClass = ObjectRepositoryClass;

package/dist/model/tree.d.ts

@@ -0,0 +1,94 @@
+import { Model } from 'skypesky-sequelize';
+import { ObjectModel } from './object';
+export interface TreeModel {
+    /**
+     * @description uuidv4
+     * @type {string}
+     * @column {DataTypes.BIGINT.UNSIGNED}
+     * @memberof Tree
+     */
+    id: string;
+    /**
+     * @description Space 的 DID
+     * @type {string}
+     * @column {DataTypes.STRING(40)}
+     * @memberof Tree
+     */
+    spaceDid: string;
+    /**
+     * @description 当且仅当，指向文件夹的时候才为空
+     * @type {string}
+     * @column {DataTypes.CHAR(64)}
+     * @memberof Tree
+     */
+    objectId: null | string;
+    /**
+     * @description 绑定对象的上一级目录的 id
+     * @example /abc/
+     * @type {string}
+     * @column {DataTypes.BIGINT.UNSIGNED}
+     * @memberof Tree
+     */
+    parentId: string;
+    /**
+     * @description 等价于文件夹和文件的路径,注意不包含 SpaceDid
+     * @example /app 或 /app/objects
+     * @type {string}
+     * @column {DataTypes.STRING(1024)}
+     * @memberof Tree
+     */
+    key: string;
+    /**
+     * @description folder or file
+     * @type {number}
+     * @column {DataTypes.TINYINT.UNSIGNED({ length: 1 })}
+     * @memberof Tree
+     */
+    type: number;
+    /**
+     *
+     * @description
+     * @default {{}}
+     * @type {TreeMeta}
+     * @column {DataTypes.JSON}
+     * @memberof Tree
+     */
+    meta: TreeModelMeta;
+    /**
+     * @description
+     * @type {string}
+     * @column {DataTypes.DATE}
+     * @memberof Tree
+     */
+    createdAt: string;
+    /**
+     * @description
+     * @type {string}
+     * @column {DataTypes.DATE}
+     * @memberof Tree
+     */
+    updatedAt: string;
+}
+export interface TreeModelMeta {
+}
+export type CreationTreeModel = Omit<TreeModel, 'id' | 'createdAt' | 'updatedAt' | 'meta'>;
+export declare class TreeRepositoryClass extends Model<TreeModel, CreationTreeModel> implements TreeModel {
+    id: string;
+    spaceDid: string;
+    objectId: string;
+    parentId: string;
+    key: string;
+    type: number;
+    meta: TreeModelMeta;
+    createdAt: string;
+    updatedAt: string;
+    Object: ObjectModel;
+    static deepCreate(data: CreationTreeModel): Promise<TreeModel>;
+    [key: string]: any;
+}
+export type TreeRepository = typeof TreeRepositoryClass;
+export declare enum TreeModelType {
+    FOLDER = 0,
+    FILE = 1
+}
+export declare const TreeModelDefaultMeta: {};

package/dist/model/tree.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeModelDefaultMeta = exports.TreeModelType = exports.TreeRepositoryClass = void 0;
+const skypesky_sequelize_1 = require("skypesky-sequelize");
+class TreeRepositoryClass extends skypesky_sequelize_1.Model {
+    // 不需要实现，只需要类型提示而已
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static deepCreate(data) {
+        throw new Error('not implemented');
+    }
+}
+exports.TreeRepositoryClass = TreeRepositoryClass;
+var TreeModelType;
+(function (TreeModelType) {
+    TreeModelType[TreeModelType["FOLDER"] = 0] = "FOLDER";
+    TreeModelType[TreeModelType["FILE"] = 1] = "FILE";
+})(TreeModelType = exports.TreeModelType || (exports.TreeModelType = {}));
+exports.TreeModelDefaultMeta = {};

package/dist/protocols/space-operator.d.ts

@@ -10,6 +10,7 @@ export interface WriteOptions extends AppSpaceOptions {
     key: string;
     data: Data;
     hash?: string;
+    size?: string;
 }
 export interface DeleteOptions extends AppSpaceOptions {
     key: string;
@@ -40,6 +41,7 @@ export interface ListsOptions {
      * @memberof ListOptions
      */
     ignoreDirectories?: boolean;
+    useGlobal?: false | true;
 }
 export interface SpaceOperatorProtocol extends SpaceOwnerOperatorProtocol {
     createSpace(spaceConfig: SpaceConfig): Promise<void>;

package/dist/protocols/space-owner-operator.d.ts

@@ -2,14 +2,40 @@
 import { Stream } from 'stream';
 import { Data } from '../meta';
 export type KeyStatus = {
+    /**
+     * @description 文件夹已存储的对象个数
+     * @type {number}
+     */
     objects: number;
+    /**
+     * @description 文件夹的最新修改时间
+     * @type {number}
+     */
     lastModified: number;
+    /**
+     * @description 文件夹的总大小
+     * @type {number}
+     */
     size: number;
 };
+export type WriteAsOwnerOptions = {
+    hash: string;
+    size: number;
+    useGlobal?: false | true;
+};
+export type ReadAsOwnerOptions = {
+    useGlobal?: false | true;
+};
+export type DeleteAsOwnerOptions = {
+    useGlobal?: false | true;
+};
+export type ExistsAsOwnerOptions = {
+    useGlobal?: false | true;
+};
 export interface SpaceOwnerOperatorProtocol {
-    writeAsOwner(key: string, data: Data): Promise<void>;
-    deleteAsOwner(key: string): Promise<void>;
-    readAsOwner(key: string): Promise<Stream>;
-    existsAsOwner(key: string): Promise<boolean>;
+    writeAsOwner(key: string, data: Data, options?: WriteAsOwnerOptions): Promise<void>;
+    deleteAsOwner(key: string, options?: DeleteAsOwnerOptions): Promise<void>;
+    readAsOwner(key: string, options?: ReadAsOwnerOptions): Promise<Stream>;
+    existsAsOwner(key: string, options?: ExistsAsOwnerOptions): Promise<boolean>;
     getStatusAsOwner(key: string): Promise<KeyStatus>;
 }

package/dist/schemas/global-space.d.ts

@@ -0,0 +1,2 @@
+export declare const GlobalSpaceOptionsSchema: import("joi").ObjectSchema<any>;
+export declare const HashSchema: import("joi").StringSchema<string>;

package/dist/schemas/global-space.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashSchema = exports.GlobalSpaceOptionsSchema = void 0;
+const validator_1 = require("@arcblock/validator");
+const utils_1 = require("../utils");
+exports.GlobalSpaceOptionsSchema = validator_1.Joi.object({
+    driver: validator_1.Joi.any().required(),
+    treeRepository: validator_1.Joi.any().required(),
+    objectRepository: validator_1.Joi.any().required(),
+    objectCollectionRepository: validator_1.Joi.any().required(),
+    gcMaxCount: validator_1.Joi.number().integer().optional().default(100),
+    gcMaxConcurrency: validator_1.Joi.number().integer().optional().default(8),
+});
+exports.HashSchema = validator_1.Joi.string()
+    .custom((value, helper) => {
+    if (!(0, utils_1.isCidV1)(value)) {
+        return helper.error(`Invalid hash(${value})`);
+    }
+    return value;
+})
+    .required();

package/dist/schemas/index.d.ts

@@ -1,2 +1,3 @@
 export * from './space-options';
 export * from './space-configuration';
+export * from './object-space';

package/dist/schemas/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./space-options"), exports);
 __exportStar(require("./space-configuration"), exports);
+__exportStar(require("./object-space"), exports);

package/dist/schemas/object-space.d.ts

@@ -0,0 +1,6 @@
+export declare const KeySchema: import("joi").StringSchema<string>;
+export declare const WriteAsOwnerOptionsSchema: import("joi").ObjectSchema<any>;
+export declare const ObjectSpaceOptionsSchema: import("joi").ObjectSchema<any>;
+export declare const DeleteAsOwnerOptionsSchema: import("joi").ObjectSchema<any>;
+export declare const WriteOptionsSchema: import("joi").ObjectSchema<any>;
+export declare const GetHashOptionsSchema: import("joi").ObjectSchema<any>;

package/dist/schemas/object-space.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetHashOptionsSchema = exports.WriteOptionsSchema = exports.DeleteAsOwnerOptionsSchema = exports.ObjectSpaceOptionsSchema = exports.WriteAsOwnerOptionsSchema = exports.KeySchema = void 0;
+const validator_1 = require("@arcblock/validator");
+exports.KeySchema = validator_1.Joi.string().regex(/^\//).required();
+const WriteAsOwnerOptionsByFolderSchema = {
+    is: validator_1.Joi.string().regex(/\/$/),
+    then: validator_1.Joi.valid(null).default(null),
+    otherwise: validator_1.Joi.required(),
+};
+exports.WriteAsOwnerOptionsSchema = validator_1.Joi.object({
+    key: exports.KeySchema,
+    data: validator_1.Joi.any().when('key', WriteAsOwnerOptionsByFolderSchema),
+    // @FIXME: 当 key 是文件夹 或者 data 不是一个 stream 的时候，hash， size 是可选的，现在的规则尝试之后没能做到这么精细化(使用 when 无法满足要求) @jianchao
+    hash: validator_1.Joi.string().optional().allow(null).default(null),
+    size: validator_1.Joi.number().integer().optional().allow(null).default(null),
+    useGlobal: validator_1.Joi.boolean().optional().default(false),
+});
+exports.ObjectSpaceOptionsSchema = validator_1.Joi.object({
+    driver: validator_1.Joi.any().required(),
+    spaceDid: validator_1.Joi.DID().required(),
+    treeRepository: validator_1.Joi.any().required(),
+    objectRepository: validator_1.Joi.any().required(),
+    objectCollectionRepository: validator_1.Joi.any().required(),
+});
+exports.DeleteAsOwnerOptionsSchema = validator_1.Joi.object({
+    key: exports.KeySchema,
+});
+exports.WriteOptionsSchema = validator_1.Joi.object({
+    appDid: validator_1.Joi.DID().required(),
+    key: validator_1.Joi.string().required(),
+    data: validator_1.Joi.any().required(),
+    hash: validator_1.Joi.string().optional().allow(null).default(null),
+    size: validator_1.Joi.number().integer().optional().allow(null).default(null),
+});
+exports.GetHashOptionsSchema = validator_1.Joi.object({
+    appDid: validator_1.Joi.DID().required(),
+    key: validator_1.Joi.string().required(),
+});

package/dist/space/global-space.d.ts

@@ -0,0 +1,43 @@
+import { Data } from '../meta';
+import { DriverProtocol, WriteAsOwnerOptions } from '../protocols';
+import { ObjectCollectionRepository, ObjectRepository, TreeRepository } from '../model';
+export type GlobalSpaceOptions = {
+    driver: DriverProtocol;
+    treeRepository: TreeRepository;
+    objectRepository: ObjectRepository;
+    objectCollectionRepository: ObjectCollectionRepository;
+    gcMaxCount?: 100 | number;
+    gcMaxConcurrency?: 8 | number;
+};
+export declare class GlobalSpace {
+    readonly driver: DriverProtocol;
+    readonly treeRepository: TreeRepository;
+    readonly objectRepository: ObjectRepository;
+    readonly objectCollectionRepository: ObjectCollectionRepository;
+    readonly gcMaxCount: number;
+    readonly gcMaxConcurrency: number;
+    constructor(options: GlobalSpaceOptions);
+    /**
+     * @description 存储新对象到全局存储区
+     * @param {string} key
+     * @param {Data} data
+     * @param {WriteAsOwnerOptions} options
+     * @return {*}  {Promise<void>}
+     * @memberof GlobalSpace
+     */
+    add(key: string, data: Data, options: WriteAsOwnerOptions): Promise<void>;
+    delete(hash: string): Promise<void>;
+    /**
+     * @description 清理未被使用的对象
+     * @return {Promise<void>}  {Promise<void>}
+     * @memberof GlobalSpace
+     */
+    gc(): Promise<void>;
+    /**
+     * @description 标记一个对象，以备之后回收
+     * @param {...string[]} hashList
+     * @return {Promise<void>}  {Promise<void>}
+     * @memberof GlobalSpace
+     */
+    mark(...hashList: string[]): Promise<void>;
+}

package/dist/space/global-space.js

@@ -0,0 +1,153 @@
+"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.GlobalSpace = void 0;
+const lodash_1 = require("lodash");
+const mime_types_1 = __importDefault(require("mime-types"));
+const debug_1 = __importDefault(require("debug"));
+const p_all_1 = __importDefault(require("p-all"));
+const utils_1 = require("../utils");
+const global_space_1 = require("../schemas/global-space");
+const schemas_1 = require("../schemas");
+const debug = (0, debug_1.default)('@did-space/core:GlobalSpace');
+class GlobalSpace {
+    constructor(options) {
+        debug('GlobalSpace.constructor', JSON.stringify({ options: (0, lodash_1.pick)(options, 'gcMaxCount', 'gcMaxConcurrency') }));
+        const { error, value } = global_space_1.GlobalSpaceOptionsSchema.validate(options);
+        if (error) {
+            throw error;
+        }
+        this.driver = value.driver;
+        this.treeRepository = value.treeRepository;
+        this.objectRepository = value.objectRepository;
+        this.objectCollectionRepository = value.objectCollectionRepository;
+        this.gcMaxCount = value.gcMaxCount;
+        this.gcMaxConcurrency = value.gcMaxConcurrency;
+        debug('GlobalSpace.constructor', JSON.stringify({ gcMaxCount: value.gcMaxCount, gcMaxConcurrency: value.gcMaxConcurrency }));
+    }
+    /**
+     * @description 存储新对象到全局存储区
+     * @param {string} key
+     * @param {Data} data
+     * @param {WriteAsOwnerOptions} options
+     * @return {*}  {Promise<void>}
+     * @memberof GlobalSpace
+     */
+    add(key, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // @note: 注意此处必须存储到全局存储区
+            // eslint-disable-next-line no-param-reassign
+            options = (0, lodash_1.merge)(options, { useGlobal: true });
+            debug('add.before', JSON.stringify({ key, options }));
+            const { error } = schemas_1.WriteAsOwnerOptionsSchema.validate(Object.assign(Object.assign({}, options), { key,
+                data }), { allowUnknown: true, stripUnknown: true });
+            if (error) {
+                throw error;
+            }
+            const where = {
+                id: options.hash,
+            };
+            debug('add.$where', JSON.stringify(where));
+            const objectRecord = yield this.objectRepository.findOne({
+                where,
+                raw: true,
+            });
+            debug('add.$objectRecord', JSON.stringify(objectRecord));
+            if (objectRecord) {
+                return;
+            }
+            // 存储新对象到全局存储区
+            const newKey = (0, utils_1.getHashPath)(options.hash);
+            yield this.driver.writeAsOwner(newKey, data, options);
+            // 添加 object 记录
+            yield this.objectRepository.create({
+                id: options.hash,
+                size: options.size,
+                meta: {
+                    mimeType: mime_types_1.default.lookup(key) || null,
+                    key,
+                },
+            });
+            debug('add.after', JSON.stringify({ objectRecord }));
+        });
+    }
+    delete(hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { error } = global_space_1.HashSchema.validate(hash);
+            if (error) {
+                throw error;
+            }
+            debug('delete.before', JSON.stringify({ hash }));
+            const where = {
+                objectId: hash,
+            };
+            debug('delete.$where', JSON.stringify(where));
+            const count = yield this.treeRepository.count({
+                where,
+            });
+            debug('delete.$count', count);
+            if (count) {
+                yield this.objectCollectionRepository.destroy({ where: { id: hash } });
+                return;
+            }
+            yield this.driver.deleteAsOwner((0, utils_1.getHashPath)(hash), { useGlobal: true });
+            yield this.objectRepository.destroy({ where: { id: hash } });
+            yield this.objectCollectionRepository.destroy({ where: { id: hash } });
+            debug('delete.after', { hash });
+        });
+    }
+    /**
+     * @description 清理未被使用的对象
+     * @return {Promise<void>}  {Promise<void>}
+     * @memberof GlobalSpace
+     */
+    gc() {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('gc.before', 'start gc...');
+            const objects = yield this.objectCollectionRepository.findAll({
+                attributes: ['id'],
+                order: [['createdAt', 'ASC']],
+                limit: this.gcMaxCount,
+            });
+            debug('gc.$objects.length', objects.length);
+            const actions = objects.map((x) => {
+                return () => this.delete(x.id);
+            });
+            // 限制并发数量
+            yield (0, p_all_1.default)(actions, { concurrency: this.gcMaxConcurrency });
+            debug('gc.after', true);
+        });
+    }
+    /**
+     * @description 标记一个对象，以备之后回收
+     * @param {...string[]} hashList
+     * @return {Promise<void>}  {Promise<void>}
+     * @memberof GlobalSpace
+     */
+    mark(...hashList) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('mark.before', true);
+            debug('mark.$hashList.length', hashList.length);
+            yield this.objectCollectionRepository.bulkCreate(hashList.map((hash) => {
+                return {
+                    id: hash,
+                };
+            }), {
+                ignoreDuplicates: true,
+            });
+            debug('mark.after', true);
+        });
+    }
+}
+exports.GlobalSpace = GlobalSpace;