publish: fix (FileCache)

Author: tenbits

.gitignore

@@ -1,2 +1,3 @@
 node_modules/
-ts-temp/
+ts-temp/
+test/tmp/

authorized_keys

@@ -112,6 +112,7 @@ declare module 'memd/Cache' {
         clear(key?: string): void;
         clearAsync(key?: string): Promise<void>;
         destroy(): void;
+        flushAsync(): Promise<void>;
     }
 }
 
@@ -126,7 +127,7 @@ declare module 'memd/persistance/FsTransport' {
         isAsync: boolean;
         constructor(opts: IFsTransportOpts);
         restoreAsync(): Promise<any>;
-        flushAsync(coll: ICacheEntryCollection): any;
+        flushAsync(coll: ICacheEntryCollection): Promise<any>;
     }
 }
 

lib/memd.d.ts

@@ -213,9 +213,24 @@ var TransportWorker = /** @class */ (function () {
     TransportWorker.prototype.flushAsync = function (key, entry) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                this.isReady = true;
-                this.lastModified = new Date();
-                this.coll[key] = entry;
+                switch (_a.label) {
+                    case 0:
+                        if (!(this.isReady === false)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.restoreAsync()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        this.lastModified = new Date();
+                        this.coll[key] = entry;
+                        return [2 /*return*/, this.flushRunner.run()];
+                }
+            });
+        });
+    };
+    TransportWorker.prototype.flushAsyncAll = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
                 return [2 /*return*/, this.flushRunner.run()];
             });
         });
@@ -255,20 +270,30 @@ var AsyncRunner = /** @class */ (function () {
         this.shouldRunNext = false;
     }
     AsyncRunner.prototype.run = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                if (this.isWaiting && !this.isBusy) {
+                    this.defer();
+                    return [2 /*return*/, this.dfr.promise];
+                }
+                if (this.isBusy) {
+                    this.shouldRunNext = true;
+                    return [2 /*return*/, this.dfr.promise];
+                }
+                this.isWaiting = true;
+                this.isBusy = false;
+                this.dfr = new Deferred;
+                this.defer();
+                return [2 /*return*/, this.dfr.promise];
+            });
+        });
+    };
+    AsyncRunner.prototype.defer = function () {
         var _this = this;
-        if (this.isWaiting && !this.isBusy) {
-            this.reset();
-            return this.run();
+        if (this.isWaiting) {
+            clearTimeout(this.timeout);
         }
-        if (this.isBusy) {
-            this.shouldRunNext = true;
-            return this.dfr.promise;
-        }
-        this.isWaiting = true;
-        this.isBusy = false;
-        this.dfr = new Deferred;
         this.timeout = setTimeout(function () { return _this.runInner(); }, this.debounce);
-        return this.dfr.promise;
     };
     AsyncRunner.prototype.reset = function () {
         clearTimeout(this.timeout);
@@ -286,24 +311,23 @@ var AsyncRunner = /** @class */ (function () {
                         this.isBusy = true;
                         _a.label = 1;
                     case 1:
-                        _a.trys.push([1, 3, 4, 5]);
+                        _a.trys.push([1, 3, , 4]);
                         return [4 /*yield*/, this.fn()];
                     case 2:
                         _a.sent();
-                        return [3 /*break*/, 5];
+                        return [3 /*break*/, 4];
                     case 3:
                         error_1 = _a.sent();
                         console.error('Transport error', error_1);
-                        return [3 /*break*/, 5];
+                        return [3 /*break*/, 4];
                     case 4:
                         runNext = this.shouldRunNext;
-                        this.dfr.resolve();
+                        this.dfr.resolve(null);
                         this.reset();
                         if (runNext) {
                             this.run();
                         }
-                        return [7 /*endfinally*/];
-                    case 5: return [2 /*return*/];
+                        return [2 /*return*/];
                 }
             });
         });
@@ -320,6 +344,11 @@ var Deferred = /** @class */ (function () {
     }
     return Deferred;
 }());
+function wait(ms) {
+    return new Promise(function (resolve) {
+        setTimeout(resolve, ms);
+    });
+}
 ;
 
 	function isObject(x) {
@@ -666,6 +695,19 @@ var Cache = /** @class */ (function () {
     Cache.prototype.onChanged = function (key) {
         this.clear(key);
     };
+    Cache.prototype.flushAsync = function () {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, ((_a = this._transport) === null || _a === void 0 ? void 0 : _a.flushAsyncAll())];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     return Cache;
 }());
 exports.Cache = Cache;
@@ -1407,31 +1449,47 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var FsTransport = /** @class */ (function () {
     function FsTransport(opts) {
         this.opts = opts;
-        this.File = null;
+        this._file = null;
         this.isAsync = true;
         if (typeof process === 'undefined' || typeof process.exit !== 'function') {
             throw new Error('NodeJS expected');
         }
         var r = require;
         var module = 'atma-io';
-        this.File = r(module).File;
+        var FileSafe = r(module).FileSafe;
+        this._file = new FileSafe(this.opts.path, { threadSafe: true });
     }
     FsTransport.prototype.restoreAsync = function () {
         return __awaiter(this, void 0, void 0, function () {
+            var str, error_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.File.existsAsync(this.opts.path)];
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this._file.readAsync()];
                     case 1:
-                        if ((_a.sent()) === false) {
-                            return [2 /*return*/, {}];
-                        }
-                        return [2 /*return*/, this.File.readAsync(this.opts.path)];
+                        str = _a.sent();
+                        return [2 /*return*/, JSON.parse(str)];
+                    case 2:
+                        error_1 = _a.sent();
+                        return [2 /*return*/, {}];
+                    case 3: return [2 /*return*/];
                 }
             });
         });
     };
     FsTransport.prototype.flushAsync = function (coll) {
-        return this.File.writeAsync(this.opts.path, coll);
+        return __awaiter(this, void 0, void 0, function () {
+            var json;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        json = JSON.stringify(coll);
+                        return [4 /*yield*/, this._file.writeAsync(json)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
     };
     return FsTransport;
 }());