@did-space/core 0.2.172 → 0.3.0

package/dist/space/object-space.js

@@ -0,0 +1,652 @@
+"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.ObjectSpace = void 0;
+const debug_1 = __importDefault(require("debug"));
+const skypesky_sequelize_1 = require("skypesky-sequelize");
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const path_1 = require("path");
+const lodash_1 = require("lodash");
+const configuration_1 = require("../configuration");
+const model_1 = require("../model");
+const utils_1 = require("../utils");
+const schemas_1 = require("../schemas");
+const constants_1 = require("../constants");
+const stream_1 = require("../utils/stream");
+const global_space_1 = require("./global-space");
+const debug = (0, debug_1.default)('@did-space/core:ObjectSpace');
+class ObjectSpace {
+    constructor(options) {
+        const { error } = schemas_1.ObjectSpaceOptionsSchema.validate(options, {
+            allowUnknown: true,
+            stripUnknown: true,
+        });
+        if (error) {
+            throw error;
+        }
+        this.driver = options.driver;
+        this.spaceDid = options.spaceDid;
+        this.treeRepository = options.treeRepository;
+        this.objectRepository = options.objectRepository;
+        this.objectCollectionRepository = options.objectCollectionRepository;
+        this.globalSpace = new global_space_1.GlobalSpace({
+            driver: options.driver,
+            treeRepository: options.treeRepository,
+            objectRepository: options.objectRepository,
+            objectCollectionRepository: options.objectCollectionRepository,
+        });
+    }
+    createSpace(spaceConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('createSpace.before', JSON.stringify(spaceConfig));
+            yield this.writeAsOwner('/', null, null);
+            yield this.createConfig(spaceConfig);
+            debug('createSpace.after', JSON.stringify(spaceConfig));
+        });
+    }
+    isSpaceCreated() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const where = {
+                spaceDid: this.spaceDid,
+                key: '/config.yml',
+            };
+            debug('isSpaceCreated.before', JSON.stringify(where));
+            const created = Boolean(yield this.treeRepository.count({
+                where,
+            }));
+            debug('isSpaceCreated.after', JSON.stringify({ created }));
+            return created;
+        });
+    }
+    /**
+     *
+     * @description
+     * @return {*}  {Promise<void>}
+     * @memberof ObjectSpace
+     */
+    destroySpace() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.deleteAsOwner('/');
+        });
+    }
+    getSpaceSize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { size } = yield this.getStatusAsOwner('/');
+            return size;
+        });
+    }
+    createAppSpace(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('createAppSpace.before', JSON.stringify({ options }));
+            yield this.writeAsOwner(yield this.getAppSpacePath(options), null);
+            debug('createAppSpace.after', JSON.stringify({ options }));
+        });
+    }
+    /**
+     * @description
+     * @param {AppSpaceOptions} options
+     * @return {Promise<void>}  {Promise<void>}
+     * @memberof ObjectSpace
+     */
+    destroyAppSpace(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('destroyAppSpace.before', JSON.stringify({ options }));
+            yield this.deleteAsOwner(yield this.getAppSpacePath(options));
+            debug('destroyAppSpace.after', JSON.stringify({ options }));
+        });
+    }
+    getAppSpacePath(options) {
+        // @ts-expect-error
+        return (0, path_1.join)(`/${constants_1.APPS}`, `${options.appDid}/`);
+    }
+    write(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('write.before', JSON.stringify((0, lodash_1.omit)(options, 'data')));
+            const { error } = schemas_1.WriteOptionsSchema.validate(options, {
+                allowUnknown: true,
+                stripUnknown: true,
+            });
+            if (error) {
+                throw error;
+            }
+            const { data } = options;
+            const key = (0, path_1.join)(yield this.getAppSpacePath(options), options.key);
+            // @ts-expect-error
+            yield this.writeAsOwner(key, data, options);
+            debug('write.after', JSON.stringify({ key }));
+        });
+    }
+    delete(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('delete.before', JSON.stringify({ options }));
+            const key = (0, path_1.join)(yield this.getAppSpacePath(options), options.key);
+            yield this.deleteAsOwner(key);
+            debug('delete.after', JSON.stringify({ key }));
+        });
+    }
+    read(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('read.before', JSON.stringify({ options }));
+            const key = (0, path_1.join)(yield this.getAppSpacePath(options), options.key);
+            debug('read.$key', key);
+            return this.readAsOwner(key);
+        });
+    }
+    getHash(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('getHash.before', JSON.stringify({ options }));
+            const key = (0, path_1.join)(yield this.getAppSpacePath(options), options.key);
+            const where = {
+                spaceDid: this.spaceDid,
+                key,
+            };
+            debug('getHash.$key', key);
+            debug('getHash.$where', JSON.stringify({ where }));
+            if (!(yield this.exists(options))) {
+                throw new Error(`Object(${key}) not exists`);
+            }
+            const tree = yield this.treeRepository.findOne({ where });
+            return tree.objectId;
+        });
+    }
+    exists(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('exists.before', JSON.stringify({ options }));
+            const key = (0, path_1.join)(yield this.getAppSpacePath(options), options.key);
+            return this.existsAsOwner(key);
+        });
+    }
+    listsOneLevelAsOwner(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const where = {
+                spaceDid: this.spaceDid,
+                key: options.key,
+            };
+            debug('listsOneLevel.before', JSON.stringify(options));
+            const parentTree = yield this.treeRepository.findOne({
+                where,
+                raw: true,
+            });
+            debug('listsOneLevel.$parentTree', JSON.stringify(parentTree, null, 2));
+            const trees = yield this.treeRepository.findAll({
+                where: {
+                    spaceDid: this.spaceDid,
+                    parentId: parentTree.id,
+                },
+                include: this.objectRepository,
+            });
+            return Promise.all(trees.map((x) => __awaiter(this, void 0, void 0, function* () {
+                if (x.type === model_1.TreeModelType.FOLDER) {
+                    const { size, lastModified } = yield this.getStatusAsOwner(x.key);
+                    return {
+                        key: x.key,
+                        name: (0, path_1.basename)(x.key),
+                        isDir: true,
+                        size,
+                        lastModified: lastModified || new Date(x.updatedAt).getTime(),
+                        editable: true,
+                        mimeType: null,
+                    };
+                }
+                return {
+                    key: x.key,
+                    name: (0, path_1.basename)(x.key),
+                    isDir: x.type === model_1.TreeModelType.FOLDER,
+                    size: x.Object.size,
+                    lastModified: new Date(x.updatedAt).getTime(),
+                    editable: true,
+                    mimeType: x.Object.meta.mimeType,
+                };
+            })));
+        });
+    }
+    listsRecursiveAsOwner(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('listsRecursiveAsOwner.before', JSON.stringify(options));
+            const where = {
+                spaceDid: this.spaceDid,
+                key: {
+                    [skypesky_sequelize_1.Op.like]: `${options.key}%`,
+                },
+                type: model_1.TreeModelType.FILE,
+            };
+            const trees = yield this.treeRepository.findAll({
+                where,
+                include: this.objectRepository,
+            });
+            return trees.map((x) => {
+                return {
+                    key: x.key,
+                    name: (0, path_1.basename)(x.key),
+                    isDir: x.type === model_1.TreeModelType.FOLDER,
+                    size: x.Object.size,
+                    lastModified: new Date(x.updatedAt).getTime(),
+                    editable: true,
+                    mimeType: x.Object.meta.mimeType,
+                };
+            });
+        });
+    }
+    /**
+     * @description 后续改名为 listsAsOwner 更合适
+     * @param {ListsOptions} options
+     * @return {*}  {Promise<Object[]>}
+     * @memberof ObjectSpace
+     */
+    lists(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('lists.before', JSON.stringify(options));
+            if (!(yield this.existsAsOwner(options.key))) {
+                return [];
+            }
+            // 以 非递归的方式 && 显示文件夹 的方式列出当前文件
+            if (!options.recursive) {
+                return this.listsOneLevelAsOwner(options);
+            }
+            if (options.recursive && options.ignoreDirectories) {
+                const objects = yield this.listsRecursiveAsOwner(options);
+                return objects.map((x) => {
+                    return Object.assign(Object.assign({}, x), { key: x.key.replace(options.key, '/') });
+                });
+            }
+            debug('lists.after', JSON.stringify(options));
+            throw new Error(`Filter methods not yet supported:\n ${JSON.stringify(options, null, 2)}`);
+        });
+    }
+    /**
+     * @FIXME: 接口的功能实际应该是 listAsOwner 实现的，属于技术债 @jianchao
+     * @description
+     * @param {ListOptions} options
+     * @return {*}  {Promise<Object>}
+     * @memberof ObjectSpace
+     */
+    list(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('list.before', JSON.stringify(options));
+            const where = {
+                spaceDid: this.spaceDid,
+                key: options.key,
+            };
+            const x = yield this.treeRepository.findOne({
+                where,
+                include: this.objectRepository,
+            });
+            return {
+                key: x.key,
+                name: (0, path_1.basename)(x.key),
+                isDir: x.type === model_1.TreeModelType.FOLDER,
+                size: x.type === model_1.TreeModelType.FOLDER ? 0 : x.Object.size,
+                lastModified: new Date(x.updatedAt).getTime(),
+                // FIXME: 需要后续处理一下
+                editable: true,
+                mimeType: x.type === model_1.TreeModelType.FOLDER ? null : x.Object.meta.mimeType,
+            };
+        });
+    }
+    // private async _addToGlobalStorage(key: string, data: Data, options: WriteAsOwnerOptions): Promise<void> {
+    //   // @note: 注意此处必须存储到全局存储区
+    //   // eslint-disable-next-line no-param-reassign
+    //   options = merge(options, { useGlobal: true });
+    //   const where: WhereOptions<ObjectModel> = {
+    //     id: options.hash,
+    //   };
+    //   debug('_addToGlobalStorage.before', JSON.stringify({ key, options, where }));
+    //   const objectRecord: ObjectModel = await this.objectRepository.findOne({
+    //     where,
+    //     raw: true,
+    //   });
+    //   debug('_addToGlobalStorage.$objectRecord', JSON.stringify(objectRecord));
+    //   if (objectRecord) {
+    //     return;
+    //   }
+    //   // 存储新对象到全局存储区
+    //   const newKey = getHashPath(options.hash);
+    //   await this.driver.writeAsOwner(newKey, data, options);
+    //   // 添加 object 记录
+    //   await this.objectRepository.create({
+    //     id: options.hash,
+    //     size: options.size,
+    //     meta: {
+    //       mimeType: <string>mimeTypes.lookup(key) || 'unknown',
+    //       key,
+    //     },
+    //   });
+    //   debug('_addToGlobalStorage.after', JSON.stringify({ objectRecord }));
+    // }
+    _updateAsOwner(key, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('_updateAsOwner.before', JSON.stringify({ key, options }));
+            if ((0, utils_1.isDirectory)(key)) {
+                return;
+            }
+            const where = {
+                spaceDid: this.spaceDid,
+                key,
+            };
+            debug('_updateAsOwner.before', JSON.stringify({ key, options, where }));
+            const oldTree = yield this.treeRepository.findOne({
+                where,
+                raw: true,
+            });
+            debug('_updateAsOwner.$oldTree', JSON.stringify(oldTree));
+            if (oldTree.objectId === options.hash) {
+                // 内容不变，不需要再次存储对象，只需要更新对象的事件即可
+                yield this.treeRepository.update({
+                    updatedAt: new Date().toISOString(),
+                }, {
+                    where: {
+                        id: oldTree.id,
+                    },
+                });
+                return;
+            }
+            yield this.globalSpace.add(key, data, options);
+            // 更新 tree 记录
+            yield this.treeRepository.update({
+                updatedAt: new Date().toISOString(),
+                objectId: options.hash,
+            }, {
+                where: {
+                    id: oldTree.id,
+                },
+            });
+            // 标记清除
+            yield this.globalSpace.mark(oldTree.objectId);
+        });
+    }
+    _createAsOwner(key, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('_createAsOwner.before', JSON.stringify({ key, options }));
+            const isDir = key.endsWith('/');
+            if (isDir) {
+                // 添加 tree 记录
+                yield this.treeRepository.deepCreate({
+                    spaceDid: this.spaceDid,
+                    objectId: null,
+                    parentId: null,
+                    key,
+                    type: model_1.TreeModelType.FOLDER,
+                });
+                return;
+            }
+            // 存储新对象到全局存储区
+            yield this.globalSpace.add(key, data, options);
+            // 添加 tree 记录
+            yield this.treeRepository.deepCreate({
+                spaceDid: this.spaceDid,
+                objectId: options.hash,
+                parentId: null,
+                key,
+                type: key.endsWith('/') ? model_1.TreeModelType.FOLDER : model_1.TreeModelType.FILE,
+            });
+        });
+    }
+    /**
+     * @refactor: @jianchao 后续让 write 的接口参数保持一致，即 key, data 都在 options 里面，目前改动收益比较小
+     * @description
+     * @param {string} key
+     * @param {Data} data
+     * @param {WriteAsOwnerOptions} options
+     * @return {*}  {Promise<void>}
+     * @memberof ObjectSpace
+     */
+    writeAsOwner(key, data, options = { hash: null, size: null }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('writeAsOwner.before', JSON.stringify({ key, options: (0, lodash_1.omit)(options, 'data') }));
+            const { error } = schemas_1.WriteAsOwnerOptionsSchema.validate(Object.assign(Object.assign({}, options), { key,
+                data }), {
+                allowUnknown: true,
+                stripUnknown: true,
+            });
+            if (error) {
+                throw error;
+            }
+            if (!(0, utils_1.isDirectory)(key) && !(0, stream_1.isStream)(data)) {
+                options.hash = options.hash || (yield (0, utils_1.getHash)(data));
+                options.size = options.size || (0, utils_1.getSize)(data);
+                if (!options.hash || !options.size) {
+                    throw new Error('Hash and size cannot be empty');
+                }
+            }
+            const exists = yield this.existsAsOwner(key);
+            debug('writeAsOwner.$exists', exists);
+            if (exists) {
+                // 更新对象
+                yield this._updateAsOwner(key, data, options);
+            }
+            else {
+                // 添加新对象
+                yield this._createAsOwner(key, data, options);
+            }
+        });
+    }
+    deleteAsOwner(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('deleteAsOwner.before', JSON.stringify({ key }));
+            const { error } = schemas_1.DeleteAsOwnerOptionsSchema.validate({
+                key,
+            });
+            if (error) {
+                throw error;
+            }
+            const isDir = key.endsWith('/');
+            if (isDir) {
+                // 删除文件夹
+                const whereForDeleteFolder = {
+                    spaceDid: this.spaceDid,
+                    // 删除以 key 开头的记录
+                    key: {
+                        [skypesky_sequelize_1.Op.like]: `${key}%`,
+                    },
+                };
+                debug('deleteAsOwner.$whereForDeleteFolder', JSON.stringify(whereForDeleteFolder));
+                const trees = yield this.treeRepository.findAll({
+                    where: whereForDeleteFolder,
+                    attributes: ['objectId'],
+                    raw: true,
+                });
+                yield this.treeRepository.destroy({
+                    where: whereForDeleteFolder,
+                });
+                yield this.globalSpace.mark(...trees.map((x) => x.objectId));
+                return;
+            }
+            const where = {
+                spaceDid: this.spaceDid,
+                key,
+            };
+            const tree = yield this.treeRepository.findOne({
+                where,
+                attributes: ['objectId'],
+                raw: true,
+            });
+            yield this.treeRepository.destroy({
+                where,
+            });
+            yield this.globalSpace.mark(tree.objectId);
+        });
+    }
+    readAsOwner(key, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('readAsOwner.before', JSON.stringify({ key, options }));
+            const where = {
+                spaceDid: this.spaceDid,
+                key,
+            };
+            debug('readAsOwner.$where', JSON.stringify(where));
+            const tree = yield this.treeRepository.findOne({
+                where,
+            });
+            if (!tree) {
+                throw new Error(`Object(${key}) not exists`);
+            }
+            return this.driver.readAsOwner((0, utils_1.getHashPath)(tree.objectId), { useGlobal: true });
+        });
+    }
+    existsAsOwner(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const where = {
+                spaceDid: this.spaceDid,
+                key,
+            };
+            debug('existsAsOwner.before', JSON.stringify({ where }));
+            const exists = Boolean(yield this.treeRepository.count({
+                where,
+            }));
+            debug('existsAsOwner.after', JSON.stringify({ exists }));
+            return exists;
+        });
+    }
+    getStatusAsOwner(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('getStatusAsOwner.before', JSON.stringify({
+                spaceDid: this.spaceDid,
+                key,
+            }));
+            const { error } = schemas_1.KeySchema.validate(key);
+            if (error) {
+                throw error;
+            }
+            const where = {
+                spaceDid: this.spaceDid,
+                key: {
+                    [skypesky_sequelize_1.Op.like]: `${key}%`,
+                },
+                type: model_1.TreeModelType.FILE,
+            };
+            const objects = yield this.treeRepository.count({ where });
+            const lastModified = yield this.treeRepository.max('updatedAt', {
+                where,
+            });
+            // @FIXME: 没有正确关联
+            const objectRecords = yield this.objectRepository.sequelize.query(`SELECT SUM(Object.size) as totalSize FROM Object JOIN Tree ON Object.id = Tree.objectId WHERE Tree.key LIKE '${key}%' AND Tree.spaceDid = '${this.spaceDid}'`, { type: skypesky_sequelize_1.QueryTypes.SELECT });
+            // @ts-expect-error
+            const size = objectRecords[0].totalSize;
+            debug('getStatusAsOwner.after', JSON.stringify({
+                spaceDid: this.spaceDid,
+                key,
+                objects,
+                size,
+                lastModified,
+            }));
+            return {
+                objects,
+                size,
+                lastModified,
+            };
+        });
+    }
+    createConfig(spaceConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = js_yaml_1.default.dump(spaceConfig);
+            const hash = yield (0, utils_1.getHash)(data);
+            const size = (0, utils_1.getSize)(data);
+            debug('createSpace.$data', data);
+            debug('createSpace.$hash', hash);
+            debug('createSpace.$size', size);
+            yield this.writeAsOwner('/config.yml', data, {
+                hash,
+                size,
+                useGlobal: true,
+            });
+        });
+    }
+    destroyConfig() {
+        return this.deleteAsOwner('/config.yml');
+    }
+    set(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('set.before', JSON.stringify({ key, value }));
+            const configData = yield this.readAsOwner('/config.yml');
+            const data = js_yaml_1.default.load(yield (0, stream_1.streamToString)(configData));
+            data[key] = value;
+            yield this.createConfig(data);
+        });
+    }
+    get(key, defaultValue = undefined) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('get.before', JSON.stringify({ key }));
+            const configData = yield this.readAsOwner('/config.yml');
+            const data = js_yaml_1.default.load(yield (0, stream_1.streamToString)(configData));
+            return (_a = data[key]) !== null && _a !== void 0 ? _a : defaultValue;
+        });
+    }
+    getPermission({ fromAppDid, toAppDid }) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const permissions = yield this.get('permissions');
+            return ((_a = permissions === null || permissions === void 0 ? void 0 : permissions[fromAppDid]) === null || _a === void 0 ? void 0 : _a[toAppDid]) || 0;
+        });
+    }
+    /**
+     *
+     * @see https://blog.csdn.net/a1173537204/article/details/89765932
+     * @private
+     * @param {PermissionOptions} { fromAppDid, toAppDid }
+     * @param {number} permission
+     * @param {boolean} status
+     * @return {*}  {Promise<void>}
+     * @memberof S3SpaceConfig
+     */
+    setPermission({ fromAppDid, toAppDid }, permission, status) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const permissions = yield this.get('permissions', {});
+            // 我想知道原来的权限是啥样的？
+            const oldPermission = ((_a = permissions === null || permissions === void 0 ? void 0 : permissions[fromAppDid]) === null || _a === void 0 ? void 0 : _a[toAppDid]) || 0;
+            permissions[fromAppDid] = Object.assign((_b = permissions === null || permissions === void 0 ? void 0 : permissions[fromAppDid]) !== null && _b !== void 0 ? _b : {}, Object.assign(Object.assign({}, permissions === null || permissions === void 0 ? void 0 : permissions[fromAppDid]), { 
+                // eslint-disable-next-line no-bitwise
+                [toAppDid]: status ? oldPermission | permission : oldPermission & ~permission }));
+            yield this.set('permissions', permissions);
+        });
+    }
+    /**
+     *
+     * @refactor 这部分的实现大同小异，之后可以抽象到上层实现，这样可以减少代码量 @jianchao
+     * @description
+     * @param {PermissionOptions} options
+     * @param {boolean} value
+     * @return {*}  {Promise<void>}
+     * @memberof ObjectSpace
+     */
+    setListable(options, value) {
+        return this.setPermission(options, configuration_1.Scopes['list:object'], value);
+    }
+    setReadable(options, value) {
+        return this.setPermission(options, configuration_1.Scopes['read:object'], value);
+    }
+    setWritable(options, value) {
+        return this.setPermission(options, configuration_1.Scopes['write:object'], value);
+    }
+    isListable(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const permission = yield this.getPermission(options);
+            return Boolean((permission & configuration_1.Scopes['list:object']) === configuration_1.Scopes['list:object']);
+        });
+    }
+    isReadable(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const permission = yield this.getPermission(options);
+            return Boolean((permission & configuration_1.Scopes['read:object']) === configuration_1.Scopes['read:object']);
+        });
+    }
+    isWritable(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const permission = yield this.getPermission(options);
+            return Boolean((permission & configuration_1.Scopes['write:object']) === configuration_1.Scopes['write:object']);
+        });
+    }
+}
+exports.ObjectSpace = ObjectSpace;

package/dist/space/space.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+import { Stream } from 'stream';
+import { SpaceConfig } from '../configuration';
+import { Data, Object } from '../meta';
+import { WriteOptions, ReadOptions, SpaceProtocol, DriverProtocol, AppSpaceOptions, PermissionOptions, DeleteOptions, ListOptions, ListsOptions, GetHashOptions, KeyStatus, ReadAsOwnerOptions, ExistsAsOwnerOptions } from '../protocols';
+export declare class Space implements SpaceProtocol {
+    readonly driver: DriverProtocol;
+    static readonly READONLY_OBJECT_KEYS: string[];
+    constructor(driver: DriverProtocol);
+    createSpace(spaceConfiguration: SpaceConfig): Promise<void>;
+    destroySpace(): Promise<void>;
+    isSpaceCreated(): Promise<boolean>;
+    getSpaceSize(): Promise<number>;
+    createAppSpace(options: AppSpaceOptions): Promise<void>;
+    destroyAppSpace(options: AppSpaceOptions): Promise<void>;
+    getAppSpacePath(options: AppSpaceOptions): Promise<string>;
+    createConfig(spaceConfig: SpaceConfig): Promise<void>;
+    destroyConfig(): Promise<void>;
+    set<T = any>(key: string, value: T): Promise<void>;
+    get<T = any>(key: string): Promise<T>;
+    setListable(options: PermissionOptions, value: boolean): Promise<void>;
+    setReadable(options: PermissionOptions, value: boolean): Promise<void>;
+    setWritable(options: PermissionOptions, value: boolean): Promise<void>;
+    isListable(options: PermissionOptions): Promise<boolean>;
+    isReadable(options: PermissionOptions): Promise<boolean>;
+    isWritable(options: PermissionOptions): Promise<boolean>;
+    getSpaceStatus(): Promise<{
+        totalCapacity: number;
+        usedCapacity: number;
+        isFull: boolean;
+    }>;
+    write(options: WriteOptions): Promise<void>;
+    delete(options: DeleteOptions): Promise<void>;
+    read(options: ReadOptions): Promise<Stream>;
+    getHash(options: GetHashOptions): Promise<string>;
+    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, options?: ReadAsOwnerOptions): Promise<Stream>;
+    existsAsOwner(key: string, options?: ExistsAsOwnerOptions): Promise<boolean>;
+    getStatusAsOwner(key: string): Promise<KeyStatus>;
+    static editable(key: string): boolean;
+}