hfs 0.46.1 → 0.47.0-alpha6

package/src/serveFile.js

@@ -68,9 +68,10 @@ async function serveFile(ctx, source, mime, content) {
             return ctx.body = content;
         const { size } = stats;
         const range = getRange(ctx, size);
-        ctx.body = (0, fs_1.createReadStream)(source, range);
+        ctx.body = (0, fs_1.createReadStream)(source, range).on('end', () => (0, connections_1.updateConnection)(ctx.state.connection, { opProgress: 1 }));
         if (ctx.vfsNode)
             (0, connections_1.updateConnection)(ctx.state.connection, {
+                ctx,
                 op: 'download',
                 opTotal: stats.size,
                 opOffset: range && (range.start / size),
@@ -106,6 +107,7 @@ function getRange(ctx, totalSize) {
         ctx.body = 'Requested Range Not Satisfiable';
         return;
     }
+    ctx.state.includesLastByte = end === max;
     ctx.status = const_1.HTTP_PARTIAL_CONTENT;
     ctx.set('Content-Range', `bytes ${start}-${isNaN(end) ? '' : end}/${isNaN(totalSize) ? '*' : totalSize}`);
     ctx.response.length = end - start + 1;

package/src/throttler.js

@@ -44,7 +44,7 @@ const throttler = async (ctx, next) => {
         (0, connections_1.updateConnection)(conn, {
             outSpeed,
             sent: conn.socket.bytesWritten,
-            opProgress: (conn.opOffset || 0) + ts.getBytesSent() / conn.opTotal,
+            opProgress: conn.opTotal && ((conn.opOffset || 0) + (ts.getBytesSent() - offset) / conn.opTotal),
         });
         /* in case this stream stands still for a while (before the end), we'll have neither 'sent' or 'close' events,
         * so who will take care to updateConnection? This artificial next-call will ensure just that */
@@ -67,6 +67,7 @@ const throttler = async (ctx, next) => {
         delete ip2group[ctx.ip];
     });
     const downloadTotal = ctx.response.length;
+    ctx.state.originalStream = ctx.body;
     ctx.body = ctx.body.pipe(ts);
     if (downloadTotal) // preserve this info
         ctx.response.length = downloadTotal;

package/src/update.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.update = exports.updateSupported = exports.localUpdateAvailable = exports.getUpdate = void 0;
+exports.update = exports.updateSupported = exports.localUpdateAvailable = exports.getUpdates = void 0;
 const github_1 = require("./github");
 const const_1 = require("./const");
 const path_1 = require("path");
@@ -14,10 +14,45 @@ const fs_1 = require("fs");
 const plugins_1 = require("./plugins");
 const promises_1 = require("fs/promises");
 const open_1 = __importDefault(require("open"));
-async function getUpdate() {
-    return (await (0, github_1.getRepoInfo)(const_1.HFS_REPO + '/releases?per_page=1'))[0];
+const config_1 = require("./config");
+const updateToBeta = (0, config_1.defineConfig)('update_to_beta', false);
+async function getUpdates() {
+    const stable = await (0, github_1.getRepoInfo)(const_1.HFS_REPO + '/releases/latest');
+    const verStable = ver(stable);
+    const ret = await getBetas();
+    if (stable && (config_1.currentVersion.olderThan(stable.tag_name) || const_1.RUNNING_BETA)) // if we are running a beta, also offer the latest stable
+        ret.push(stable);
+    return ret;
+    function ver(x) {
+        return (0, config_1.versionToScalar)(x.name);
+    }
+    async function getBetas() {
+        if (!updateToBeta.get() && !const_1.RUNNING_BETA)
+            return [];
+        let page = 1;
+        const ret = [];
+        while (1) {
+            const per = 100;
+            const res = await (0, github_1.getRepoInfo)(const_1.HFS_REPO + `/releases?per_page=${per}&page=${page++}`);
+            if (!res.length)
+                break;
+            const curV = config_1.currentVersion.getScalar();
+            for (const x of res) {
+                if (!x.prerelease)
+                    continue; // prerelease are all the end
+                const v = ver(x);
+                if (v <= verStable) // prerelease-s are locally ordered, so as soon as we reach verStable we are done
+                    return ret;
+                if (v === curV)
+                    continue; // skip current
+                x.isNewer = v > curV; // make easy to know what's newer
+                ret.push(x);
+            }
+        }
+        return ret;
+    }
 }
-exports.getUpdate = getUpdate;
+exports.getUpdates = getUpdates;
 const LOCAL_UPDATE = 'hfs-update.zip'; // update from file takes precedence over net
 function localUpdateAvailable() {
     return (0, promises_1.access)(LOCAL_UPDATE).then(() => true, () => false);
@@ -27,12 +62,15 @@ function updateSupported() {
     return const_1.IS_BINARY;
 }
 exports.updateSupported = updateSupported;
-async function update() {
+async function update(tag) {
     if (!updateSupported())
         throw "only binary versions are supported for now";
     let updateSource = await localUpdateAvailable() && (0, fs_1.createReadStream)(LOCAL_UPDATE);
     if (!updateSource) {
-        const update = await getUpdate();
+        const update = !tag ? (await getUpdates())[0]
+            : await (0, github_1.getRepoInfo)(const_1.HFS_REPO + '/releases/tags/' + tag);
+        if (!update)
+            throw "no update found";
         const assetSearch = { win32: 'windows', darwin: 'mac', linux: 'linux' }[process.platform];
         if (!assetSearch)
             throw "this feature doesn't support your platform: " + process.platform;
@@ -45,7 +83,7 @@ async function update() {
     }
     const bin = process.execPath;
     const binPath = (0, path_1.dirname)(bin);
-    const binFile = (0, path_1.basename)(bin);
+    const binFile = 'hfs' + (const_1.IS_WINDOWS ? '.exe' : ''); // currently running bin could have been renamed
     const newBinFile = 'new-' + binFile;
     plugins_1.pluginsWatcher.pause();
     try {

package/src/util-http.js

@@ -7,7 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.httpsStream = exports.httpsString = void 0;
 const node_https_1 = __importDefault(require("node:https"));
 const const_1 = require("./const");
-function httpsString(url, options = {}) {
+function httpsString(url, options) {
     return httpsStream(url, options).then(res => new Promise(resolve => {
         let buf = '';
         res.on('data', chunk => buf += chunk.toString());
@@ -18,8 +18,10 @@ function httpsString(url, options = {}) {
     }));
 }
 exports.httpsString = httpsString;
-function httpsStream(url, options = {}) {
+function httpsStream(url, { body, ...options } = {}) {
     return new Promise((resolve, reject) => {
+        if (body)
+            options.method || (options.method = 'POST');
         const req = node_https_1.default.request(url, options, res => {
             if (!res.statusCode || res.statusCode >= 400)
                 return reject(new Error(String(res.statusCode), { cause: res }));
@@ -28,7 +30,10 @@ function httpsStream(url, options = {}) {
             resolve(res);
         }).on('error', e => {
             reject(req.res || e);
-        }).end();
+        });
+        if (body)
+            req.write(body);
+        req.end();
     });
 }
 exports.httpsStream = httpsStream;

package/src/vfs.js

@@ -26,22 +26,33 @@ exports.defaultPerms = {
 exports.PERM_KEYS = (0, misc_1.typedKeys)(exports.defaultPerms);
 exports.MIME_AUTO = 'auto';
 function inheritFromParent(parent, child) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c;
     for (const k of (0, misc_1.typedKeys)(exports.defaultPerms)) {
-        let dueParent = parent;
-        while (((_a = dueParent === null || dueParent === void 0 ? void 0 : dueParent.propagate) === null || _a === void 0 ? void 0 : _a[k]) === false)
-            dueParent = dueParent.parent;
-        const v = dueParent === null || dueParent === void 0 ? void 0 : dueParent[k];
-        if (v !== undefined) // small optimization: don't expand the object
-            (_b = child[k]) !== null && _b !== void 0 ? _b : (child[k] = v);
+        let p = parent;
+        let inheritedPerm;
+        while (p) {
+            inheritedPerm = p[k];
+            // // in case of object without children, parent is skipped in favor of the parent's parent
+            if (!isWhoObject(inheritedPerm))
+                break;
+            inheritedPerm = inheritedPerm.children;
+            if (inheritedPerm !== undefined)
+                break;
+            p = p.parent;
+        }
+        if (inheritedPerm !== undefined) // small optimization: don't expand the object
+            (_a = child[k]) !== null && _a !== void 0 ? _a : (child[k] = inheritedPerm);
     }
     if (typeof parent.mime === 'object' && typeof child.mime === 'object')
         lodash_1.default.defaults(child.mime, parent.mime);
     else
-        (_c = child.mime) !== null && _c !== void 0 ? _c : (child.mime = parent.mime);
-    (_d = child.accept) !== null && _d !== void 0 ? _d : (child.accept = parent.accept);
+        (_b = child.mime) !== null && _b !== void 0 ? _b : (child.mime = parent.mime);
+    (_c = child.accept) !== null && _c !== void 0 ? _c : (child.accept = parent.accept);
     return child;
 }
+function isWhoObject(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
 function isSameFilenameAs(name) {
     const lc = name.toLowerCase();
     return (other) => lc === (typeof other === 'string' ? other : getNodeName(other)).toLowerCase();
@@ -114,7 +125,18 @@ async function urlToNode(url, ctx, parent = exports.vfs, getRest) {
 }
 exports.urlToNode = urlToNode;
 exports.vfs = {};
-(0, config_1.defineConfig)('vfs', {}).sub(data => exports.vfs = data);
+(0, config_1.defineConfig)('vfs', {}).sub(data => exports.vfs = (function recur(node) {
+    if (node.propagate) { // legacy pre-0.47
+        for (const [k, v] of (0, misc_1.typedEntries)(node.propagate))
+            if (v === false)
+                node[k] = { this: node[k] };
+        delete node.propagate;
+    }
+    if (node.children)
+        for (const c of node.children)
+            recur(c);
+    return node;
+})(data));
 function saveVfs() {
     return (0, config_1.setConfig)({ vfs: lodash_1.default.cloneDeep(exports.vfs) }, true);
 }
@@ -157,14 +179,16 @@ function statusCodeForMissingPerm(node, perm, ctx, assign = true) {
         ctx.status = ret;
     return ret;
     function getCode() {
-        var _a;
         if (!node.source && perm === 'can_upload') // Upload possible only if we know where to store. First check node.source because is supposedly faster.
             return const_1.HTTP_FORBIDDEN;
         // calculate value of permission resolving references to other permissions, avoiding infinite loop
         let who;
         let max = exports.PERM_KEYS.length;
         do {
-            who = (_a = node[perm]) !== null && _a !== void 0 ? _a : exports.defaultPerms[perm];
+            who = node[perm];
+            if (isWhoObject(who))
+                who = who.this;
+            who !== null && who !== void 0 ? who : (who = exports.defaultPerms[perm]);
             if (!max-- || typeof who !== 'string' || who === exports.WHO_ANY_ACCOUNT)
                 break;
             perm = who;