firebase-tools 10.2.1 → 10.3.1

package/lib/emulator/storage/files.js

@@ -7,19 +7,18 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Persistence = exports.StorageLayer = exports.UploadStatus = exports.ResumableUpload = exports.StoredFile = void 0;
+exports.StorageLayer = exports.StoredFile = void 0;
 const fs_1 = require("fs");
-const os_1 = require("os");
-const uuid_1 = require("uuid");
 const list_1 = require("./list");
 const metadata_1 = require("./metadata");
+const errors_1 = require("./errors");
 const path = require("path");
-const fs = require("fs");
 const fse = require("fs-extra");
-const rimraf = require("rimraf");
 const cloudFunctions_1 = require("./cloudFunctions");
 const logger_1 = require("../../logger");
 const adminSdkConfig_1 = require("../adminSdkConfig");
+const types_1 = require("./rules/types");
+const upload_1 = require("./upload");
 class StoredFile {
     constructor(metadata, path) {
         this.metadata = metadata;
@@ -39,69 +38,17 @@ class StoredFile {
     }
 }
 exports.StoredFile = StoredFile;
-class ResumableUpload {
-    constructor(bucketId, objectId, uploadId, contentType, metadata) {
-        this._currentBytesUploaded = 0;
-        this._status = UploadStatus.ACTIVE;
-        this._bucketId = bucketId;
-        this._objectId = objectId;
-        this._uploadId = uploadId;
-        this._contentType = contentType;
-        this._metadata = metadata;
-        this._fileLocation = encodeURIComponent(`${uploadId}_b_${bucketId}_o_${objectId}`);
-        this._currentBytesUploaded = 0;
-    }
-    get uploadId() {
-        return this._uploadId;
-    }
-    get metadata() {
-        return this._metadata;
-    }
-    get bucketId() {
-        return this._bucketId;
-    }
-    get objectId() {
-        return this._objectId;
-    }
-    get contentType() {
-        return this._contentType;
-    }
-    set contentType(contentType) {
-        this._contentType = contentType;
-    }
-    get currentBytesUploaded() {
-        return this._currentBytesUploaded;
-    }
-    set currentBytesUploaded(value) {
-        this._currentBytesUploaded = value;
-    }
-    set status(status) {
-        this._status = status;
-    }
-    get status() {
-        return this._status;
-    }
-    get fileLocation() {
-        return this._fileLocation;
-    }
-}
-exports.ResumableUpload = ResumableUpload;
-var UploadStatus;
-(function (UploadStatus) {
-    UploadStatus[UploadStatus["ACTIVE"] = 0] = "ACTIVE";
-    UploadStatus[UploadStatus["CANCELLED"] = 1] = "CANCELLED";
-    UploadStatus[UploadStatus["FINISHED"] = 2] = "FINISHED";
-})(UploadStatus = exports.UploadStatus || (exports.UploadStatus = {}));
 class StorageLayer {
-    constructor(_projectId) {
+    constructor(_projectId, _rulesValidator, _adminCredsValidator, _persistence) {
         this._projectId = _projectId;
+        this._rulesValidator = _rulesValidator;
+        this._adminCredsValidator = _adminCredsValidator;
+        this._persistence = _persistence;
         this.reset();
         this._cloudFunctions = new cloudFunctions_1.StorageCloudFunctions(this._projectId);
     }
     reset() {
         this._files = new Map();
-        this._persistence = new Persistence(`${(0, os_1.tmpdir)()}/firebase/storage/blobs`);
-        this._uploads = new Map();
         this._buckets = new Map();
     }
     createBucket(id) {
@@ -110,7 +57,7 @@ class StorageLayer {
         }
     }
     async listBuckets() {
-        if (this._buckets.size == 0) {
+        if (this._buckets.size === 0) {
             let adminSdkConfig = await (0, adminSdkConfig_1.getProjectAdminSdkConfigOrCached)(this._projectId);
             if (!adminSdkConfig) {
                 adminSdkConfig = (0, adminSdkConfig_1.constructDefaultAdminSdkConfig)(this._projectId);
@@ -119,6 +66,22 @@ class StorageLayer {
         }
         return [...this._buckets.values()];
     }
+    async handleGetObject(request, skipAuth = false) {
+        var _a;
+        const metadata = this.getMetadata(request.bucketId, request.decodedObjectId);
+        const hasValidDownloadToken = ((metadata === null || metadata === void 0 ? void 0 : metadata.downloadTokens) || []).includes((_a = request.downloadToken) !== null && _a !== void 0 ? _a : "");
+        let authorized = skipAuth || hasValidDownloadToken;
+        if (!authorized) {
+            authorized = await this._rulesValidator.validate(["b", request.bucketId, "o", request.decodedObjectId].join("/"), types_1.RulesetOperationMethod.GET, { before: metadata === null || metadata === void 0 ? void 0 : metadata.asRulesResource() }, request.authorization);
+        }
+        if (!authorized) {
+            throw new errors_1.ForbiddenError("Failed auth");
+        }
+        if (!metadata) {
+            throw new errors_1.NotFoundError("File not found");
+        }
+        return { metadata: metadata, data: this.getBytes(request.bucketId, request.decodedObjectId) };
+    }
     getMetadata(bucket, object) {
         const key = this.path(bucket, object);
         const val = this._files.get(key);
@@ -136,34 +99,17 @@ class StorageLayer {
         }
         return undefined;
     }
-    public(value) {
-        this._files = value;
-    }
-    startUpload(bucket, object, contentType, metadata) {
-        const uploadId = (0, uuid_1.v4)();
-        const upload = new ResumableUpload(bucket, object, uploadId, contentType, metadata);
-        this._uploads.set(uploadId, upload);
-        return upload;
-    }
-    queryUpload(uploadId) {
-        return this._uploads.get(uploadId);
-    }
-    cancelUpload(uploadId) {
-        const upload = this._uploads.get(uploadId);
-        if (!upload) {
-            return undefined;
+    async handleDeleteObject(request, skipAuth = false) {
+        const storedMetadata = this.getMetadata(request.bucketId, request.decodedObjectId);
+        const authorized = skipAuth ||
+            (await this._rulesValidator.validate(["b", request.bucketId, "o", request.decodedObjectId].join("/"), types_1.RulesetOperationMethod.DELETE, { before: storedMetadata === null || storedMetadata === void 0 ? void 0 : storedMetadata.asRulesResource() }, request.authorization));
+        if (!authorized) {
+            throw new errors_1.ForbiddenError();
         }
-        upload.status = UploadStatus.CANCELLED;
-        this._persistence.deleteFile(upload.fileLocation);
-    }
-    uploadBytes(uploadId, bytes) {
-        const upload = this._uploads.get(uploadId);
-        if (!upload) {
-            return undefined;
-        }
-        this._persistence.appendBytes(upload.fileLocation, bytes, upload.currentBytesUploaded);
-        upload.currentBytesUploaded += bytes.byteLength;
-        return upload;
+        if (!storedMetadata) {
+            throw new errors_1.NotFoundError();
+        }
+        this.deleteFile(request.bucketId, request.decodedObjectId);
     }
     deleteFile(bucketId, objectId) {
         const isFolder = objectId.toLowerCase().endsWith("%2f");
@@ -175,7 +121,7 @@ class StorageLayer {
             filePath += "%2F";
         }
         const file = this._files.get(filePath);
-        if (file == undefined) {
+        if (file === undefined) {
             return false;
         }
         else {
@@ -185,89 +131,130 @@ class StorageLayer {
             return true;
         }
     }
-    async deleteAll() {
-        return this._persistence.deleteAll();
+    async handleUpdateObjectMetadata(request, skipAuth = false) {
+        const storedMetadata = this.getMetadata(request.bucketId, request.decodedObjectId);
+        const authorized = skipAuth ||
+            (await this._rulesValidator.validate(["b", request.bucketId, "o", request.decodedObjectId].join("/"), types_1.RulesetOperationMethod.UPDATE, {
+                before: storedMetadata === null || storedMetadata === void 0 ? void 0 : storedMetadata.asRulesResource(),
+                after: storedMetadata === null || storedMetadata === void 0 ? void 0 : storedMetadata.asRulesResource(request.metadata),
+            }, request.authorization));
+        if (!authorized) {
+            throw new errors_1.ForbiddenError();
+        }
+        if (!storedMetadata) {
+            throw new errors_1.NotFoundError();
+        }
+        storedMetadata.update(request.metadata);
+        return storedMetadata;
     }
-    finalizeUpload(uploadId) {
-        const upload = this._uploads.get(uploadId);
-        if (!upload) {
-            return undefined;
+    async handleUploadObject(upload, skipAuth = false) {
+        if (upload.status !== upload_1.UploadStatus.FINISHED) {
+            throw new Error(`Unexpected upload status encountered: ${upload.status}.`);
         }
-        upload.status = UploadStatus.FINISHED;
         const filePath = this.path(upload.bucketId, upload.objectId);
-        const bytes = this._persistence.readBytes(upload.fileLocation, upload.currentBytesUploaded);
-        const finalMetadata = new metadata_1.StoredFileMetadata({
+        const metadata = new metadata_1.StoredFileMetadata({
             name: upload.objectId,
             bucket: upload.bucketId,
-            contentType: "",
+            contentType: upload.metadata.contentType || "application/octet-stream",
+            contentDisposition: upload.metadata.contentDisposition,
             contentEncoding: upload.metadata.contentEncoding,
+            contentLanguage: upload.metadata.contentLanguage,
+            cacheControl: upload.metadata.cacheControl,
             customMetadata: upload.metadata.metadata,
-        }, this._cloudFunctions, bytes, upload.metadata);
-        const file = new StoredFile(finalMetadata, filePath);
-        this._files.set(filePath, file);
+        }, this._cloudFunctions, this._persistence.readBytes(upload.path, upload.size));
+        const authorized = skipAuth ||
+            (await this._rulesValidator.validate(["b", upload.bucketId, "o", upload.objectId].join("/"), types_1.RulesetOperationMethod.CREATE, { after: metadata === null || metadata === void 0 ? void 0 : metadata.asRulesResource() }, upload.authorization));
+        if (!authorized) {
+            this._persistence.deleteFile(upload.path);
+            throw new errors_1.ForbiddenError();
+        }
         this._persistence.deleteFile(filePath, true);
-        this._persistence.renameFile(upload.fileLocation, filePath);
-        this._cloudFunctions.dispatch("finalize", new metadata_1.CloudStorageObjectMetadata(file.metadata));
-        return { upload: upload, file: file };
+        this._persistence.renameFile(upload.path, filePath);
+        this._files.set(filePath, new StoredFile(metadata, this._persistence.getDiskPath(filePath)));
+        this._cloudFunctions.dispatch("finalize", new metadata_1.CloudStorageObjectMetadata(metadata));
+        return metadata;
     }
-    oneShotUpload(bucket, object, contentType, incomingMetadata, bytes) {
-        const filePath = this.path(bucket, object);
+    copyFile(sourceFile, destinationBucket, destinationObject, incomingMetadata) {
+        const filePath = this.path(destinationBucket, destinationObject);
         this._persistence.deleteFile(filePath, true);
+        const bytes = this.getBytes(sourceFile.bucket, sourceFile.name);
         this._persistence.appendBytes(filePath, bytes);
-        const md = new metadata_1.StoredFileMetadata({
-            name: object,
-            bucket: bucket,
-            contentType: incomingMetadata.contentType || "application/octet-stream",
-            contentEncoding: incomingMetadata.contentEncoding,
-            customMetadata: incomingMetadata.metadata,
+        const newMetadata = Object.assign(Object.assign(Object.assign({}, sourceFile), { metadata: sourceFile.customMetadata }), incomingMetadata);
+        if (sourceFile.downloadTokens.length &&
+            !((incomingMetadata === null || incomingMetadata === void 0 ? void 0 : incomingMetadata.metadata) && Object.keys(incomingMetadata === null || incomingMetadata === void 0 ? void 0 : incomingMetadata.metadata).length)) {
+            if (!newMetadata.metadata)
+                newMetadata.metadata = {};
+            newMetadata.metadata.firebaseStorageDownloadTokens = sourceFile.downloadTokens.join(",");
+        }
+        if (newMetadata.metadata) {
+            for (const [k, v] of Object.entries(newMetadata.metadata)) {
+                if (v === null)
+                    newMetadata.metadata[k] = "";
+            }
+        }
+        const copiedFileMetadata = new metadata_1.StoredFileMetadata({
+            name: destinationObject,
+            bucket: destinationBucket,
+            contentType: newMetadata.contentType || "application/octet-stream",
+            contentDisposition: newMetadata.contentDisposition,
+            contentEncoding: newMetadata.contentEncoding,
+            contentLanguage: newMetadata.contentLanguage,
+            cacheControl: newMetadata.cacheControl,
+            customMetadata: newMetadata.metadata,
         }, this._cloudFunctions, bytes, incomingMetadata);
-        const file = new StoredFile(md, this._persistence.getDiskPath(filePath));
+        const file = new StoredFile(copiedFileMetadata, this._persistence.getDiskPath(filePath));
         this._files.set(filePath, file);
         this._cloudFunctions.dispatch("finalize", new metadata_1.CloudStorageObjectMetadata(file.metadata));
         return file.metadata;
     }
-    listItemsAndPrefixes(bucket, prefix, delimiter, pageToken, maxResults) {
-        if (!delimiter) {
-            delimiter = "/";
-        }
-        if (!prefix) {
-            prefix = "";
-        }
-        if (!prefix.endsWith(delimiter)) {
-            prefix += delimiter;
-        }
-        if (!prefix.startsWith(delimiter)) {
-            prefix = delimiter + prefix;
+    async handleListObjects(request, skipAuth = false) {
+        var _a, _b, _c;
+        const authorized = skipAuth ||
+            (await this._rulesValidator.validate(["b", request.bucketId, "o", request.prefix].join("/"), types_1.RulesetOperationMethod.LIST, {}, request.authorization));
+        if (!authorized) {
+            throw new errors_1.ForbiddenError();
         }
+        const itemsResults = this.listItems(request.bucketId, request.prefix, request.delimiter, request.pageToken, request.maxResults);
+        return new list_1.ListResponse((_a = itemsResults.prefixes) !== null && _a !== void 0 ? _a : [], (_c = (_b = itemsResults.items) === null || _b === void 0 ? void 0 : _b.map((i) => new list_1.ListItem(i.name, i.bucket))) !== null && _c !== void 0 ? _c : [], itemsResults.nextPageToken);
+    }
+    listItems(bucket, prefix, delimiter, pageToken, maxResults) {
         let items = [];
         const prefixes = new Set();
         for (const [, file] of this._files) {
-            if (file.metadata.bucket != bucket) {
+            if (file.metadata.bucket !== bucket) {
                 continue;
             }
-            let name = `${delimiter}${file.metadata.name}`;
+            const name = file.metadata.name;
             if (!name.startsWith(prefix)) {
                 continue;
             }
-            name = name.substring(prefix.length);
-            if (name.startsWith(delimiter)) {
-                name = name.substring(prefix.length);
-            }
-            const startAtIndex = name.indexOf(delimiter);
-            if (startAtIndex == -1) {
-                if (!file.metadata.name.endsWith("/")) {
-                    items.push(file.metadata.name);
+            let includeMetadata = true;
+            if (delimiter) {
+                const delimiterIdx = name.indexOf(delimiter);
+                const delimiterAfterPrefixIdx = name.indexOf(delimiter, prefix.length);
+                includeMetadata = delimiterIdx === -1 || delimiterAfterPrefixIdx === -1;
+                if (delimiterAfterPrefixIdx !== -1) {
+                    prefixes.add(name.slice(0, delimiterAfterPrefixIdx + delimiter.length));
                 }
             }
-            else {
-                const prefixPath = prefix + name.substring(0, startAtIndex + 1);
-                prefixes.add(prefixPath);
+            if (includeMetadata) {
+                items.push(file.metadata);
             }
         }
-        items.sort();
+        items.sort((a, b) => {
+            if (a.name === b.name) {
+                return 0;
+            }
+            else if (a.name < b.name) {
+                return -1;
+            }
+            else {
+                return 1;
+            }
+        });
         if (pageToken) {
-            const idx = items.findIndex((v) => v == pageToken);
-            if (idx != -1) {
+            const idx = items.findIndex((v) => v.name === pageToken);
+            if (idx !== -1) {
                 items = items.slice(idx);
             }
         }
@@ -276,81 +263,39 @@ class StorageLayer {
         }
         let nextPageToken = undefined;
         if (items.length > maxResults) {
-            nextPageToken = items[maxResults];
+            nextPageToken = items[maxResults].name;
             items = items.slice(0, maxResults);
         }
-        return new list_1.ListResponse([...prefixes].sort(), items.map((i) => new list_1.ListItem(i, bucket)), nextPageToken);
-    }
-    listItems(bucket, prefix, delimiter, pageToken, maxResults) {
-        if (!delimiter) {
-            delimiter = "/";
-        }
-        if (!prefix) {
-            prefix = "";
-        }
-        if (!prefix.endsWith(delimiter)) {
-            prefix += delimiter;
-        }
-        let items = [];
-        for (const [, file] of this._files) {
-            if (file.metadata.bucket != bucket) {
-                continue;
-            }
-            let name = file.metadata.name;
-            if (!name.startsWith(prefix)) {
-                continue;
-            }
-            name = name.substring(prefix.length);
-            if (name.startsWith(delimiter)) {
-                name = name.substring(prefix.length);
-            }
-            items.push(this.path(file.metadata.bucket, file.metadata.name));
-        }
-        items.sort();
-        if (pageToken) {
-            const idx = items.findIndex((v) => v == pageToken);
-            if (idx != -1) {
-                items = items.slice(idx);
-            }
-        }
-        if (!maxResults) {
-            maxResults = 1000;
-        }
         return {
-            kind: "#storage/objects",
-            items: items.map((item) => {
-                const storedFile = this._files.get(item);
-                if (!storedFile) {
-                    return console.warn(`No file ${item}`);
-                }
-                return new metadata_1.CloudStorageObjectMetadata(storedFile.metadata);
-            }),
+            nextPageToken,
+            prefixes: prefixes.size > 0 ? [...prefixes].sort() : undefined,
+            items: items.length > 0 ? items.map((item) => new metadata_1.CloudStorageObjectMetadata(item)) : undefined,
         };
     }
-    addDownloadToken(bucket, object) {
-        const key = this.path(bucket, object);
-        const val = this._files.get(key);
-        if (!val) {
-            return undefined;
+    handleCreateDownloadToken(request) {
+        if (!this._adminCredsValidator.validate(request.authorization)) {
+            throw new errors_1.ForbiddenError();
+        }
+        const metadata = this.getMetadata(request.bucketId, request.decodedObjectId);
+        if (!metadata) {
+            throw new errors_1.NotFoundError();
         }
-        const md = val.metadata;
-        md.addDownloadToken();
-        return md;
+        metadata.addDownloadToken();
+        return metadata;
     }
-    deleteDownloadToken(bucket, object, token) {
-        const key = this.path(bucket, object);
-        const val = this._files.get(key);
-        if (!val) {
-            return undefined;
+    handleDeleteDownloadToken(request) {
+        if (!this._adminCredsValidator.validate(request.authorization)) {
+            throw new errors_1.ForbiddenError();
+        }
+        const metadata = this.getMetadata(request.bucketId, request.decodedObjectId);
+        if (!metadata) {
+            throw new errors_1.NotFoundError();
         }
-        const md = val.metadata;
-        md.deleteDownloadToken(token);
-        return md;
+        metadata.deleteDownloadToken(request.token);
+        return metadata;
     }
     path(bucket, object) {
-        const directory = path.dirname(object);
-        const filename = path.basename(object) + (object.endsWith("/") ? "/" : "");
-        return path.join(bucket, directory, encodeURIComponent(filename));
+        return path.join(bucket, object);
     }
     get dirPath() {
         return this._persistence.dirPath;
@@ -373,9 +318,7 @@ class StorageLayer {
         try {
             for (var _b = __asyncValues(this._files.entries()), _c; _c = await _b.next(), !_c.done;) {
                 const [p, file] = _c.value;
-                const metadataExportPath = path.join(metadataDirPath, p) + ".json";
-                const metadataExportDirPath = path.dirname(metadataExportPath);
-                await fse.ensureDir(metadataExportDirPath);
+                const metadataExportPath = path.join(metadataDirPath, encodeURIComponent(p)) + ".json";
                 await fse.writeFile(metadataExportPath, metadata_1.StoredFileMetadata.toJSON(file.metadata));
             }
         }
@@ -389,7 +332,7 @@ class StorageLayer {
     }
     import(storageExportPath) {
         const bucketsFile = path.join(storageExportPath, "buckets.json");
-        const bucketsList = JSON.parse(fs.readFileSync(bucketsFile, "utf-8"));
+        const bucketsList = JSON.parse((0, fs_1.readFileSync)(bucketsFile, "utf-8"));
         for (const b of bucketsList.buckets) {
             const bucketMetadata = new metadata_1.CloudStorageBucketMetadata(b.id);
             this._buckets.set(b.id, bucketMetadata);
@@ -403,11 +346,11 @@ class StorageLayer {
                 logger_1.logger.debug(`Skipping unexpected storage metadata file: ${f}`);
                 continue;
             }
-            const metadata = metadata_1.StoredFileMetadata.fromJSON(fs.readFileSync(f, "utf-8"), this._cloudFunctions);
+            const metadata = metadata_1.StoredFileMetadata.fromJSON((0, fs_1.readFileSync)(f, "utf-8"), this._cloudFunctions);
             const metadataRelPath = path.relative(metadataDir, f);
             const blobPath = metadataRelPath.substring(0, metadataRelPath.length - dotJson.length);
             const blobAbsPath = path.join(blobsDir, blobPath);
-            if (!fs.existsSync(blobAbsPath)) {
+            if (!(0, fs_1.existsSync)(blobAbsPath)) {
                 logger_1.logger.warn(`Could not find file "${blobPath}" in storage export.`);
                 continue;
             }
@@ -417,10 +360,10 @@ class StorageLayer {
         fse.copySync(blobsDir, this.dirPath);
     }
     *walkDirSync(dir) {
-        const files = fs.readdirSync(dir);
+        const files = (0, fs_1.readdirSync)(dir);
         for (const file of files) {
             const p = path.join(dir, file);
-            if (fs.statSync(p).isDirectory()) {
+            if ((0, fs_1.statSync)(p).isDirectory()) {
                 yield* this.walkDirSync(p);
             }
             else {
@@ -430,87 +373,3 @@ class StorageLayer {
     }
 }
 exports.StorageLayer = StorageLayer;
-class Persistence {
-    constructor(dirPath) {
-        this._dirPath = dirPath;
-        if (!(0, fs_1.existsSync)(dirPath)) {
-            (0, fs_1.mkdirSync)(dirPath, {
-                recursive: true,
-            });
-        }
-    }
-    get dirPath() {
-        return this._dirPath;
-    }
-    appendBytes(fileName, bytes, fileOffset) {
-        const filepath = this.getDiskPath(fileName);
-        const encodedSlashIndex = filepath.toLowerCase().lastIndexOf("%2f");
-        const dirPath = encodedSlashIndex >= 0 ? filepath.substring(0, encodedSlashIndex) : path.dirname(filepath);
-        if (!(0, fs_1.existsSync)(dirPath)) {
-            (0, fs_1.mkdirSync)(dirPath, {
-                recursive: true,
-            });
-        }
-        let fd;
-        try {
-            fs.appendFileSync(filepath, bytes);
-            return filepath;
-        }
-        finally {
-            if (fd) {
-                (0, fs_1.closeSync)(fd);
-            }
-        }
-    }
-    readBytes(fileName, size, fileOffset) {
-        const path = this.getDiskPath(fileName);
-        let fd;
-        try {
-            fd = (0, fs_1.openSync)(path, "r");
-            const buf = Buffer.alloc(size);
-            const offset = fileOffset && fileOffset > 0 ? fileOffset : 0;
-            (0, fs_1.readSync)(fd, buf, 0, size, offset);
-            return buf;
-        }
-        finally {
-            if (fd) {
-                (0, fs_1.closeSync)(fd);
-            }
-        }
-    }
-    deleteFile(fileName, failSilently = false) {
-        try {
-            (0, fs_1.unlinkSync)(this.getDiskPath(fileName));
-        }
-        catch (err) {
-            if (!failSilently) {
-                throw err;
-            }
-        }
-    }
-    deleteAll() {
-        return new Promise((resolve, reject) => {
-            rimraf(this._dirPath, (err) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
-    }
-    renameFile(oldName, newName) {
-        const dirPath = this.getDiskPath(path.dirname(newName));
-        if (!(0, fs_1.existsSync)(dirPath)) {
-            (0, fs_1.mkdirSync)(dirPath, {
-                recursive: true,
-            });
-        }
-        (0, fs_1.renameSync)(this.getDiskPath(oldName), this.getDiskPath(newName));
-    }
-    getDiskPath(fileName) {
-        return path.join(this._dirPath, fileName);
-    }
-}
-exports.Persistence = Persistence;