sliftutils 0.65.0 → 0.67.0

package/index.d.ts

@@ -938,9 +938,6 @@ declare module "sliftutils/storage/StorageObservable" {
         synced: {
             keySeqNum: number;
         };
-        resynced: {
-            seqNum: number;
-        };
         constructor(storage: IStorage<T>);
         get(key: string): T | undefined;
         set(key: string, value: T): void;
@@ -989,6 +986,7 @@ declare module "sliftutils/storage/TransactionStorage" {
         watchResync(callback: () => void): void;
         private init;
         private getCurrentChunk;
+        private updateDiskFileTimestamp;
         private onAddToChunk;
         get(key: string): Promise<Buffer | undefined>;
         set(key: string, value: Buffer): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "0.65.0",
+    "version": "0.67.0",
     "main": "index.js",
     "license": "MIT",
     "files": [

package/storage/StorageObservable.d.ts

@@ -10,9 +10,6 @@ export declare class StorageSync<T> implements IStorageSync<T> {
     synced: {
         keySeqNum: number;
     };
-    resynced: {
-        seqNum: number;
-    };
     constructor(storage: IStorage<T>);
     get(key: string): T | undefined;
     set(key: string, value: T): void;

package/storage/StorageObservable.ts

@@ -11,16 +11,17 @@ export class StorageSync<T> implements IStorageSync<T> {
         keySeqNum: 0,
     }, undefined, { deep: false });
 
-    resynced = observable({ seqNum: 0 });
-
     constructor(public storage: IStorage<T>) {
         storage.watchResync?.(() => {
-            this.resynced.seqNum++;
+            this.cached.clear();
+            this.infoCached.clear();
+            this.keys.clear();
+            this.loadedKeys = false;
+            this.synced.keySeqNum++;
         });
     }
 
     public get(key: string): T | undefined {
-        this.resynced.seqNum;
         if (!this.cached.has(key)) {
             this.cached.set(key, undefined);
             void this.getPromise(key);
@@ -48,14 +49,12 @@ export class StorageSync<T> implements IStorageSync<T> {
     }
     private loadedKeys = false;
     public getKeys(): string[] {
-        this.resynced.seqNum;
         void this.getKeysPromise();
         this.synced.keySeqNum;
         return Array.from(this.keys);
     }
 
     public getInfo(key: string): { size: number; lastModified: number } | undefined {
-        this.resynced.seqNum;
         if (!this.infoCached.has(key)) {
             this.infoCached.set(key, { size: 0, lastModified: 0 });
             void this.storage.getInfo(key).then(info => {

package/storage/TransactionStorage.d.ts

@@ -22,6 +22,7 @@ export declare class TransactionStorage implements IStorage<Buffer> {
     watchResync(callback: () => void): void;
     private init;
     private getCurrentChunk;
+    private updateDiskFileTimestamp;
     private onAddToChunk;
     get(key: string): Promise<Buffer | undefined>;
     set(key: string, value: Buffer): Promise<void>;

package/storage/TransactionStorage.ts

@@ -78,7 +78,8 @@ function getNextChunkPath(): string {
 
 export class TransactionStorage implements IStorage<Buffer> {
     public cache: Map<string, TransactionEntry> = new Map();
-    private diskFiles: Set<string> = new Set();
+    // Maps file name to our last known write timestamp
+    private diskFiles: Map<string, number> = new Map();
     private currentChunk: {
         path: string;
         size: number;
@@ -123,10 +124,14 @@ export class TransactionStorage implements IStorage<Buffer> {
                 size: 0,
                 timeCreated: Date.now()
             };
-            this.diskFiles.add(this.currentChunk.path);
+            // Timestamp will be updated after actual write
+            this.diskFiles.set(this.currentChunk.path, 0);
         }
         return this.currentChunk.path;
     }
+    private updateDiskFileTimestamp(file: string): void {
+        this.diskFiles.set(file, Date.now());
+    }
     private onAddToChunk(size: number): void {
         if (!this.currentChunk) return;
         this.currentChunk.size += size;
@@ -222,6 +227,7 @@ export class TransactionStorage implements IStorage<Buffer> {
                     }
                     let content = chunk.buffer;
                     await this.rawStorage.append(file, content);
+                    this.updateDiskFileTimestamp(file);
                     this.onAddToChunk(content.length);
                 }
 
@@ -255,8 +261,18 @@ export class TransactionStorage implements IStorage<Buffer> {
         const anyChanges = async () => {
             let keys = await this.rawStorage.getKeys();
             let diskFiles = keys.filter(key => key.endsWith(CHUNK_EXT));
-            let hasNew = diskFiles.some(file => !this.diskFiles.has(file));
-            return hasNew;
+            // Check if any known files have been modified externally (disk timestamp newer than ours)
+            for (let file of diskFiles) {
+                let ourTimestamp = this.diskFiles.get(file);
+                if (ourTimestamp === undefined) {
+                    return true;
+                }
+                let info = await this.rawStorage.getInfo(file);
+                if (info && info.lastModified > ourTimestamp) {
+                    return true;
+                }
+            }
+            return false;
         };
         if (!await anyChanges()) return;
 
@@ -278,7 +294,12 @@ export class TransactionStorage implements IStorage<Buffer> {
         let time = Date.now();
         const keys = await this.rawStorage.getKeys();
         const transactionFiles = keys.filter(key => key.endsWith(CHUNK_EXT));
-        this.diskFiles = new Set(transactionFiles);
+        // Populate diskFiles with actual timestamps from disk
+        this.diskFiles = new Map();
+        for (let file of transactionFiles) {
+            let info = await this.rawStorage.getInfo(file);
+            this.diskFiles.set(file, info?.lastModified ?? Date.now());
+        }
 
         let entryList: TransactionEntry[][] = [];
         for (let file of transactionFiles) {
@@ -568,6 +589,7 @@ export class TransactionStorage implements IStorage<Buffer> {
                 }
                 let buffer = Buffer.concat([headerBuffer, content]);
                 await this.rawStorage.set(file, buffer);
+                this.updateDiskFileTimestamp(file);
                 let verified = await this.rawStorage.get(file);
                 if (!verified?.equals(buffer)) {
                     console.error(`Failed to verify transaction file ${file} in ${this.debugName}`);