@e-mc/file-manager 0.6.0 → 0.7.0

package/index.js

@@ -126,6 +126,76 @@ function resetAssets() {
     this.reset();
     FileManager.sanitizeAssets(this.assets);
 }
+function recurseDir(output, subDirs, options) {
+    const { ignore, sortBy, recursive } = options;
+    const items = fs.readdirSync(path.join(...subDirs), { withFileTypes: true })
+        .filter(item => item.name)
+        .sort((a, b) => {
+        if (sortBy > 0) {
+            if (a.isDirectory() && !b.isDirectory()) {
+                return sortBy & 1 /* READDIR_SORT.DIRECTORY */ ? -1 : 1;
+            }
+            if (!a.isDirectory() && b.isDirectory()) {
+                return sortBy & 1 /* READDIR_SORT.DIRECTORY */ ? 1 : -1;
+            }
+        }
+        return (a.name < b.name ? -1 : 1) * (2 /* READDIR_SORT.DESCENDING */ & 2 ? -1 : 1);
+    });
+    for (const item of items) {
+        if (!item.isDirectory()) {
+            const pathname = path.join(item.path, item.name);
+            if (!ignore.includes(pathname)) {
+                output.push(pathname);
+            }
+        }
+        else if (recursive) {
+            recurseDir(output, subDirs.concat(item.name), options);
+        }
+    }
+    return output;
+}
+function checkHash(data, fromBuffer, options) {
+    if (options) {
+        let algorithm, digest, value;
+        if ((0, types_1.isObject)(options)) {
+            ({ algorithm, digest, value } = options);
+        }
+        else {
+            value = options;
+        }
+        if ((0, types_1.isString)(value)) {
+            if (!fromBuffer) {
+                try {
+                    data = fs.readFileSync(data);
+                }
+                catch {
+                    return false;
+                }
+            }
+            return value === core_1.Host.asHash(data, { algorithm, digest });
+        }
+    }
+    return true;
+}
+function filterPaths(values, include, exclude) {
+    if (include) {
+        if ((0, types_1.isString)(include)) {
+            include = [include];
+        }
+        if ((0, types_1.isArray)(include)) {
+            return values.filter(value => core_1.Permission.match(value, include));
+        }
+    }
+    if (exclude) {
+        if ((0, types_1.isString)(exclude)) {
+            exclude = [exclude];
+        }
+        if ((0, types_1.isArray)(exclude)) {
+            return values.filter(value => !core_1.Permission.match(value, exclude));
+        }
+    }
+    return values;
+}
 function abortedHost() {
     if (this.finalizeState === 6 /* FINALIZE_STATE.ABORTED */) {
         this.restarting = false;
@@ -195,6 +265,8 @@ function collectErrors() {
 function rejectModule(err, type, hint) {
     this.writeFail(["Handled rejection" /* ERR_MESSAGE.HANDLED_REJECTION */, this.moduleName + (hint ? ': ' + hint : '')], err, type);
 }
+const checksumFile = (algorithm) => "checksum" /* HASH_OUTPUT.FILENAME */ + '.' + ((0, types_1.isString)(algorithm) ? algorithm.toLowerCase() : "sha256" /* HASH_OUTPUT.ALGORITHM */);
+const checksumError = (algorithm) => new Error("Invalid parameters" /* ERR_MESSAGE.PARAMETERS */ + ` (${algorithm || "sha256" /* HASH_OUTPUT.ALGORITHM */})`);
 const isFunction = (value) => typeof value === 'function';
 const ignoreAsset = (item, exists) => item.invalid || (0, types_1.hasBit)(item.flags, 1 /* ASSET_FLAG.IGNORE */ | (!exists ? 128 /* ASSET_FLAG.EXISTS */ : 0));
 class HttpDiskCache {
@@ -557,6 +629,146 @@ class FileManager extends core_1.Host {
         });
         return assets;
     }
+    static async writeChecksum(root, to, options) {
+        if ((0, types_1.isObject)(to)) {
+            options = to;
+            to = undefined;
+        }
+        else {
+            options || (options = {});
+        }
+        const { algorithm, digest, sortBy = 0, recursive = false, ignore = [], include, exclude, verbose = false, joinRoot } = options;
+        to || (to = checksumFile(algorithm));
+        let result = [];
+        try {
+            const filename = path.basename(to);
+            to = joinRoot ? path.join(root, to) : path.resolve(to);
+            recurseDir(result, [root], { ignore: [...ignore, to], sortBy, recursive });
+            const output = [];
+            for (const pathname of result = filterPaths(result, include, exclude)) {
+                if (recursive === 1 && path.basename(pathname) === filename) {
+                    continue;
+                }
+                const current = await this.readHash(pathname, { algorithm, digest }) + ' ' + (path.sep === '\\' ? pathname.replace(/\\/g, '/') : pathname).substring(root.length).replace(/^\//, '');
+                if (verbose) {
+                    process.stdout.write(current + '\n');
+                }
+                output.push(current);
+            }
+            if (output.length) {
+                fs.writeFileSync(to, output.join('\n'), 'utf-8');
+                options.outPath = to;
+            }
+            else {
+                if (this.isPath(to)) {
+                    fs.unlinkSync(to);
+                }
+                if (options.throwsEmpty) {
+                    throw checksumError(algorithm);
+                }
+            }
+        }
+        catch (err) {
+            if (options.throwsEmpty) {
+                throw err;
+            }
+            this.writeFail(["Unable to read directory" /* ERR_MESSAGE.READ_DIRECTORY */, root], err, 32 /* LOG_TYPE.FILE */);
+            return null;
+        }
+        return result;
+    }
+    static async verifyChecksum(root, from, options) {
+        if ((0, types_1.isObject)(from)) {
+            options = from;
+            from = undefined;
+        }
+        else {
+            options || (options = {});
+        }
+        const { algorithm, digest, sortBy = 0, recursive = false, ignore = [], include, exclude, verbose = true, joinRoot } = options;
+        const parent = recursive === 1 && typeof verbose !== 'number';
+        from || (from = checksumFile(algorithm));
+        let fail = [], missing = [];
+        try {
+            const filename = path.basename(from);
+            const files = [];
+            from = joinRoot ? path.join(root, filename) : path.resolve(from);
+            recurseDir(files, [root], { ignore: [...ignore, from], sortBy, recursive });
+            const items = fs.readFileSync(from, 'utf-8').split('\n').map(item => {
+                const index = item.indexOf(' ');
+                return [item.substring(0, index), path.join(root, item.substring(index + 1))];
+            });
+            const checked = include || exclude ? filterPaths(items.map(item => item[1]), include, exclude) : null;
+            let valid;
+            for (const [previous, pathname] of items) {
+                if (checked !== null && !checked.includes(pathname) || recursive === 1 && path.basename(pathname) === filename) {
+                    continue;
+                }
+                if (files.includes(pathname)) {
+                    const hash = await this.readHash(pathname, { algorithm, digest });
+                    if (hash !== previous) {
+                        fail.push(pathname);
+                    }
+                    else if (verbose) {
+                        process.stdout.write("+" /* SUMDIR_STATUS.PASS */ + ' ' + pathname + '\n');
+                    }
+                    valid = true;
+                }
+                else if (!ignore.includes(pathname)) {
+                    missing.push(pathname);
+                }
+            }
+            if (parent) {
+                const nested = files.filter(value => path.basename(value) === filename);
+                if (nested.length) {
+                    const current = items.map(item => item[1]);
+                    const tasks = nested.map(pathname => this.verifyChecksum(path.dirname(pathname), filename, { ...options, ignore: current, joinRoot: true, verbose: (verbose ? 1 : 0) }));
+                    await Promise.all(tasks).then(group => {
+                        for (const item of group) {
+                            if (item) {
+                                const [f, m] = item;
+                                if (f.length) {
+                                    fail.push(...f);
+                                }
+                                if (m.length) {
+                                    missing.push(...m);
+                                }
+                                valid = true;
+                            }
+                        }
+                    });
+                }
+            }
+            if (valid) {
+                options.outPath = from;
+            }
+            else if (options.throwsEmpty) {
+                throw checksumError(algorithm);
+            }
+        }
+        catch (err) {
+            if (options.throwsEmpty) {
+                throw err;
+            }
+            this.writeFail(["Unable to read directory" /* ERR_MESSAGE.READ_DIRECTORY */, root], err, 32 /* LOG_TYPE.FILE */);
+            return null;
+        }
+        if (parent) {
+            if (fail.length) {
+                fail = Array.from(new Set(fail));
+            }
+            if (missing.length) {
+                missing = Array.from(new Set(missing));
+            }
+        }
+        if (verbose === true) {
+            const max = Math.max(...fail.concat(missing).map(item => item.length));
+            const writeLog = (items, symbol) => items.forEach((value, index) => process.stdout.write(`${symbol} ${value.padEnd(max)} (${(index + 1).toString()})\n`));
+            writeLog(fail, "-" /* SUMDIR_STATUS.FAIL */);
+            writeLog(missing, "?" /* SUMDIR_STATUS.MISSING */);
+        }
+        return [fail, missing];
+    }
     static createFileThread(host, file) {
         return new FileThread(host, file, 0);
     }
@@ -2582,6 +2794,10 @@ class FileManager extends core_1.Host {
             return true;
         };
         const fileReceived = (item, localUri, err, fetched, binary) => {
+            if (item.checksum && !err && !checkHash(item.buffer || localUri, !!item.buffer, item.checksum)) {
+                err = (0, types_1.errorValue)("Checksum did not match" /* ERR_MESSAGE.FAILED_CHECKSUM */, item.uri);
+                this.filesToRemove.add(localUri);
+            }
             if (err) {
                 item.invalid = true;
                 this.completeAsyncTask(err, localUri);
@@ -2690,7 +2906,7 @@ class FileManager extends core_1.Host {
                         if (!cached) {
                             setBuffer(item);
                         }
-                        if (core_1.Host.isPath(localUri)) {
+                        if (core_1.Host.isPath(localUri) && (!item.checksumOutput || checkHash(localUri, false, item.checksumOutput))) {
                             item.flags |= 128 /* ASSET_FLAG.EXISTS */;
                             if (!etag || item.fetchType !== 1 /* FETCH_TYPE.HTTP */) {
                                 if (!(0, types_1.isEmpty)(bundleId) && bundleIndex === 0) {
@@ -2708,13 +2924,15 @@ class FileManager extends core_1.Host {
                         else if (cached) {
                             try {
                                 const buffer = cached[1];
-                                fs.writeFileSync(localUri, buffer);
-                                if (item.willChange && Buffer.isBuffer(buffer)) {
-                                    item.buffer = buffer;
+                                if (!item.checksum || checkHash(buffer, true, item.checksum)) {
+                                    fs.writeFileSync(localUri, buffer);
+                                    if (item.willChange && Buffer.isBuffer(buffer)) {
+                                        item.buffer = buffer;
+                                    }
+                                    this.performAsyncTask();
+                                    fileReceived(item, localUri, null, true);
+                                    continue;
                                 }
-                                this.performAsyncTask();
-                                fileReceived(item, localUri, null, true);
-                                continue;
                             }
                             catch {
                             }
@@ -3157,13 +3375,6 @@ class FileManager extends core_1.Host {
         return cloud ? cloud_1.default.finalize.call(this, cloud).catch(err => rejectModule.call(cloud, err, 64 /* LOG_TYPE.CLOUD */)) : Promise.resolve();
     }
     async finalizeCleanup() {
-        if (this.Compress) {
-            const tasks = [];
-            this.assets.forEach(item => item.compress && !ignoreAsset(item, true) && tasks.push(this.compressFile(item, false)));
-            if (tasks.length) {
-                await Promise.allSettled(tasks);
-            }
-        }
         if (this.emptyDir.size) {
             for (const value of Array.from(this.emptyDir).reverse()) {
                 try {
@@ -3237,11 +3448,54 @@ class FileManager extends core_1.Host {
             return Promise.reject((0, types_1.createAbortError)());
         }
         removeFiles();
+        for (const item of this.assets) {
+            if (item.checksumOutput && !ignoreAsset(item)) {
+                const localUri = item.localUri;
+                if (!checkHash(localUri, false, item.checksumOutput)) {
+                    item.invalid = true;
+                    filesToRemove.add(localUri);
+                    this.writeFail(["Invalid checksum" /* ERR_MESSAGE.CHECKSUM */, path.basename(localUri)], (0, types_1.errorValue)("Checksum did not match" /* ERR_MESSAGE.FAILED_CHECKSUM */, localUri), { type: 32 /* LOG_TYPE.FILE */, startTime });
+                }
+            }
+        }
+        removeFiles();
         await this.finalizeCloud().catch(err => rejectModule.call(this, err, 64 /* LOG_TYPE.CLOUD */));
         if (this.aborted) {
             return Promise.reject((0, types_1.createAbortError)());
         }
         removeFiles();
+        if (this.Compress) {
+            const tasks = [];
+            this.assets.forEach(item => item.compress && !ignoreAsset(item, true) && tasks.push(this.compressFile(item, false)));
+            if (tasks.length) {
+                await Promise.allSettled(tasks);
+            }
+        }
+        let checksum = this.config.checksum;
+        if (checksum) {
+            if (typeof checksum === 'boolean' || checksum === 1) {
+                checksum = { recursive: checksum };
+            }
+            else if ((0, types_1.isString)(checksum)) {
+                const items = checksum.split('.');
+                checksum = items.length > 1 ? { algorithm: items[items.length - 1], filename: checksum } : { algorithm: checksum };
+            }
+            if ((0, types_1.isPlainObject)(checksum)) {
+                const baseDirectory = this.baseDirectory;
+                checksum.joinRoot = true;
+                checksum.throwsEmpty = true;
+                const sumTime = LOG_TIMEELAPSED ? process.hrtime() : 0;
+                try {
+                    const files = (await FileManager.writeChecksum(baseDirectory, checksum.filename, checksum));
+                    if (sumTime) {
+                        this.writeTimeElapsed(checksum.algorithm || "sha256" /* HASH_OUTPUT.ALGORITHM */, [baseDirectory, files.length + (files.length === 1 ? ' file' : ' files')], sumTime, { ...core_1.Host.LOG_STYLE_WARN });
+                    }
+                }
+                catch (err) {
+                    this.writeFail(["Unable to read directory" /* ERR_MESSAGE.READ_DIRECTORY */, path.basename(baseDirectory)], err, { type: 32 /* LOG_TYPE.FILE */, startTime });
+                }
+            }
+        }
         await this.finalizeCleanup().catch(err => rejectModule.call(this, err, 1 /* LOG_TYPE.SYSTEM */));
         removeFiles();
         if (LOG_TIMEELAPSED) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e-mc/file-manager",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "FileManager constructor for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -20,14 +20,14 @@
   "license": "BSD 3-Clause",
   "homepage": "https://github.com/anpham6/e-mc#readme",
   "dependencies": {
-    "@e-mc/cloud": "0.6.0",
-    "@e-mc/compress": "0.6.0",
-    "@e-mc/core": "0.6.0",
-    "@e-mc/document": "0.6.0",
-    "@e-mc/image": "0.6.0",
-    "@e-mc/request": "0.6.0",
-    "@e-mc/task": "0.6.0",
-    "@e-mc/types": "0.6.0",
-    "@e-mc/watch": "0.6.0"
+    "@e-mc/cloud": "0.7.0",
+    "@e-mc/compress": "0.7.0",
+    "@e-mc/core": "0.7.0",
+    "@e-mc/document": "0.7.0",
+    "@e-mc/image": "0.7.0",
+    "@e-mc/request": "0.7.0",
+    "@e-mc/task": "0.7.0",
+    "@e-mc/types": "0.7.0",
+    "@e-mc/watch": "0.7.0"
   }
 }