@milaboratories/pl-drivers 1.11.59 → 1.11.60

package/dist/drivers/download_blob/sparse_cache/cache.js

@@ -1,203 +1,174 @@
-import { ensureDirExists, fileExists, mapEntries } from '@milaboratories/ts-helpers';
-import { promises } from 'node:fs';
-import path__default from 'node:path';
-import { rangesFileName, readRangesFile, writeRangesFile, rangesSize, doesRangeExist, addRange } from './ranges.js';
-import { writeToSparseFile } from './file.js';
-import { functions } from '@milaboratories/helpers';
+import { addRange, doesRangeExist, rangesFileName, rangesSize, readRangesFile, writeRangesFile } from "./ranges.js";
+import { writeToSparseFile } from "./file.js";
+import { ensureDirExists, fileExists, mapEntries } from "@milaboratories/ts-helpers";
+import { functions } from "@milaboratories/helpers";
+import { promises } from "node:fs";
+import path from "node:path";
 
+//#region src/drivers/download_blob/sparse_cache/cache.ts
 /** The implementer of SparseCacheRanges could throw it if ranges were corrupted. */
-class CorruptedRangesError extends Error {
-    name = "CorruptedRangesError";
-}
+var CorruptedRangesError = class extends Error {
+	name = "CorruptedRangesError";
+};
 /** Stores ranges in a directory as JSON files (the default implementation). */
-class SparseCacheFsRanges {
-    logger;
-    cacheDir;
-    constructor(logger, cacheDir) {
-        this.logger = logger;
-        this.cacheDir = cacheDir;
-    }
-    fPath(key) {
-        return path__default.join(this.cacheDir, rangesFileName(key));
-    }
-    async get(key) {
-        return await readRangesFile(this.logger, this.fPath(key));
-    }
-    async set(key, ranges) {
-        return await writeRangesFile(this.logger, this.fPath(key), ranges);
-    }
-    async delete(key) {
-        await promises.rm(this.fPath(key));
-    }
-}
+var SparseCacheFsRanges = class {
+	constructor(logger, cacheDir) {
+		this.logger = logger;
+		this.cacheDir = cacheDir;
+	}
+	fPath(key) {
+		return path.join(this.cacheDir, rangesFileName(key));
+	}
+	async get(key) {
+		return await readRangesFile(this.logger, this.fPath(key));
+	}
+	async set(key, ranges) {
+		return await writeRangesFile(this.logger, this.fPath(key), ranges);
+	}
+	async delete(key) {
+		await promises.rm(this.fPath(key));
+	}
+};
 /** Stores sparse files in a directory (the default implementation). */
-class SparseCacheFsFile {
-    logger;
-    cacheDir;
-    suffix = ".sparse.bin";
-    constructor(logger, cacheDir) {
-        this.logger = logger;
-        this.cacheDir = cacheDir;
-    }
-    async all() {
-        await ensureDirExists(this.cacheDir);
-        const files = await promises.readdir(this.cacheDir);
-        return files.filter((f) => f.endsWith(this.suffix));
-    }
-    async exists(key) {
-        return await fileExists(this.path(key));
-    }
-    path(key) {
-        return path__default.join(this.cacheDir, key + this.suffix);
-    }
-    async write(key, data, from) {
-        await ensureDirExists(this.cacheDir);
-        await writeToSparseFile(this.logger, process.platform, this.path(key), data, from);
-    }
-    async delete(key) {
-        await promises.rm(this.path(key));
-    }
-}
+var SparseCacheFsFile = class {
+	suffix = ".sparse.bin";
+	constructor(logger, cacheDir) {
+		this.logger = logger;
+		this.cacheDir = cacheDir;
+	}
+	async all() {
+		await ensureDirExists(this.cacheDir);
+		return (await promises.readdir(this.cacheDir)).filter((f) => f.endsWith(this.suffix));
+	}
+	async exists(key) {
+		return await fileExists(this.path(key));
+	}
+	path(key) {
+		return path.join(this.cacheDir, key + this.suffix);
+	}
+	async write(key, data, from) {
+		await ensureDirExists(this.cacheDir);
+		await writeToSparseFile(this.logger, process.platform, this.path(key), data, from);
+	}
+	async delete(key) {
+		await promises.rm(this.path(key));
+	}
+};
 /** LRU cache for ranges of sparse files. */
-class SparseCache {
-    logger;
-    maxSize;
-    ranges;
-    storage;
-    /** Fields are public for tests. */
-    /** The lock to make sure cache requests are done one by one. */
-    lock = new functions.AwaitLock();
-    keyToLastAccessTime = new Map();
-    size = 0;
-    constructor(logger, 
-    /** The hard limit in bytes. */
-    maxSize, ranges, storage) {
-        this.logger = logger;
-        this.maxSize = maxSize;
-        this.ranges = ranges;
-        this.storage = storage;
-    }
-    /** Resets a cache's size by rereading everything we already store.
-     * Safe for concurrent use. */
-    async reset() {
-        await withLock(this.lock, async () => {
-            await this.resetUnsafe();
-        });
-    }
-    /** Returns a path to the key if the range exists in a cache, otherwise returns undefined.
-     * Safe for concurrent use. */
-    async get(key, range) {
-        return await withLock(this.lock, async () => {
-            return await this.getUnsafe(key, range);
-        });
-    }
-    /** Sets data to the cache's file and clear the cache if it's needed.
-     * Safe for concurrent use. */
-    async set(key, range, data) {
-        await withLock(this.lock, async () => {
-            await this.setUnsafe(key, range, data);
-        });
-    }
-    async resetUnsafe() {
-        this.size = 0;
-        this.keyToLastAccessTime = new Map();
-        const now = new Date();
-        // In rmKey method we first deletes the key from a storage and only then from ranges,
-        // so if something goes wrong between 2 operations,
-        // on reset the logic will be correct.
-        for (const key of await this.storage.all()) {
-            const ranges = await this.ranges.get(key);
-            this.size += rangesSize(ranges);
-            this.keyToLastAccessTime.set(key, now);
-        }
-    }
-    async getUnsafe(key, range) {
-        // It first checks the storage, and then the ranges.
-        // In another method, when we remove a key, it first deletes a key from a storage and then from ranges,
-        // so if we don't have a key in storage but have it in ranges, the logic here is correct.
-        // We probably could reverse the operations here and there, and everywhere we work with both storage and ranges.
-        if (await this.storage.exists(key)) {
-            this.keyToLastAccessTime.set(key, new Date());
-            const ranges = await this.getRanges(key);
-            if (doesRangeExist(ranges, range)) {
-                return this.storage.path(key);
-            }
-            return undefined;
-        }
-        return undefined;
-    }
-    async setUnsafe(key, range, data) {
-        await this.setWithoutEviction(key, range, data);
-        await this.ensureEvicted();
-    }
-    /** Sets a key and recalculates a size, but doesn't ensures that the size is less than the hard limit. */
-    async setWithoutEviction(key, range, data) {
-        if (range.to - range.from !== data.length) {
-            throw new Error(`SparseCache.set: trying to set ${key} with wrong range length: ` +
-                `range: ${JSON.stringify(range)}, data: ${data.length}`);
-        }
-        this.keyToLastAccessTime.set(key, new Date());
-        const ranges = await this.getRanges(key);
-        this.size -= rangesSize(ranges);
-        await this.storage.write(key, data, range.from);
-        const newRanges = addRange(ranges, range);
-        this.size += rangesSize(newRanges);
-        await this.ranges.set(key, newRanges);
-    }
-    /** Ensures the size is less than hard limit by deleting the oldest keys. */
-    async ensureEvicted() {
-        const byTime = mapEntries(this.keyToLastAccessTime);
-        byTime.sort(([_, aDate], [__, bDate]) => bDate.getTime() - aDate.getTime());
-        while (this.size > this.maxSize) {
-            const keyAndDate = byTime.pop(); // removes the oldest
-            if (!keyAndDate) {
-                break;
-            }
-            const [key, _] = keyAndDate;
-            const ranges = await this.getRanges(key);
-            this.size -= rangesSize(ranges);
-            this.rmKey(key);
-        }
-    }
-    /** Gets ranges and if they were corrupted, then remove the file from the cache and reset the cache's size. */
-    async getRanges(key) {
-        try {
-            return await this.ranges.get(key);
-        }
-        catch (e) {
-            if (e instanceof CorruptedRangesError) {
-                // We need to reset a state of the cache and update current size,
-                // it's the only way to calculate the real size when one of the ranges were corrupted.
-                await this.rmKey(key);
-                await this.resetUnsafe();
-                return await this.ranges.get(key);
-            }
-            throw e;
-        }
-    }
-    /** Removes a key the state of the cache. The size should be updated. */
-    async rmKey(key) {
-        await this.storage.delete(key);
-        await this.ranges.delete(key);
-        this.keyToLastAccessTime.delete(key);
-    }
-    async dispose() {
-        await this.lock.acquireAsync();
-    }
-    async [Symbol.asyncDispose]() {
-        await this.dispose();
-    }
-}
+var SparseCache = class {
+	/** Fields are public for tests. */
+	/** The lock to make sure cache requests are done one by one. */
+	lock = new functions.AwaitLock();
+	keyToLastAccessTime = /* @__PURE__ */ new Map();
+	size = 0;
+	constructor(logger, maxSize, ranges, storage) {
+		this.logger = logger;
+		this.maxSize = maxSize;
+		this.ranges = ranges;
+		this.storage = storage;
+	}
+	/** Resets a cache's size by rereading everything we already store.
+	* Safe for concurrent use. */
+	async reset() {
+		await withLock(this.lock, async () => {
+			await this.resetUnsafe();
+		});
+	}
+	/** Returns a path to the key if the range exists in a cache, otherwise returns undefined.
+	* Safe for concurrent use. */
+	async get(key, range) {
+		return await withLock(this.lock, async () => {
+			return await this.getUnsafe(key, range);
+		});
+	}
+	/** Sets data to the cache's file and clear the cache if it's needed.
+	* Safe for concurrent use. */
+	async set(key, range, data) {
+		await withLock(this.lock, async () => {
+			await this.setUnsafe(key, range, data);
+		});
+	}
+	async resetUnsafe() {
+		this.size = 0;
+		this.keyToLastAccessTime = /* @__PURE__ */ new Map();
+		const now = /* @__PURE__ */ new Date();
+		for (const key of await this.storage.all()) {
+			const ranges = await this.ranges.get(key);
+			this.size += rangesSize(ranges);
+			this.keyToLastAccessTime.set(key, now);
+		}
+	}
+	async getUnsafe(key, range) {
+		if (await this.storage.exists(key)) {
+			this.keyToLastAccessTime.set(key, /* @__PURE__ */ new Date());
+			if (doesRangeExist(await this.getRanges(key), range)) return this.storage.path(key);
+			return;
+		}
+	}
+	async setUnsafe(key, range, data) {
+		await this.setWithoutEviction(key, range, data);
+		await this.ensureEvicted();
+	}
+	/** Sets a key and recalculates a size, but doesn't ensures that the size is less than the hard limit. */
+	async setWithoutEviction(key, range, data) {
+		if (range.to - range.from !== data.length) throw new Error(`SparseCache.set: trying to set ${key} with wrong range length: range: ${JSON.stringify(range)}, data: ${data.length}`);
+		this.keyToLastAccessTime.set(key, /* @__PURE__ */ new Date());
+		const ranges = await this.getRanges(key);
+		this.size -= rangesSize(ranges);
+		await this.storage.write(key, data, range.from);
+		const newRanges = addRange(ranges, range);
+		this.size += rangesSize(newRanges);
+		await this.ranges.set(key, newRanges);
+	}
+	/** Ensures the size is less than hard limit by deleting the oldest keys. */
+	async ensureEvicted() {
+		const byTime = mapEntries(this.keyToLastAccessTime);
+		byTime.sort(([_, aDate], [__, bDate]) => bDate.getTime() - aDate.getTime());
+		while (this.size > this.maxSize) {
+			const keyAndDate = byTime.pop();
+			if (!keyAndDate) break;
+			const [key, _] = keyAndDate;
+			const ranges = await this.getRanges(key);
+			this.size -= rangesSize(ranges);
+			this.rmKey(key);
+		}
+	}
+	/** Gets ranges and if they were corrupted, then remove the file from the cache and reset the cache's size. */
+	async getRanges(key) {
+		try {
+			return await this.ranges.get(key);
+		} catch (e) {
+			if (e instanceof CorruptedRangesError) {
+				await this.rmKey(key);
+				await this.resetUnsafe();
+				return await this.ranges.get(key);
+			}
+			throw e;
+		}
+	}
+	/** Removes a key the state of the cache. The size should be updated. */
+	async rmKey(key) {
+		await this.storage.delete(key);
+		await this.ranges.delete(key);
+		this.keyToLastAccessTime.delete(key);
+	}
+	async dispose() {
+		await this.lock.acquireAsync();
+	}
+	async [Symbol.asyncDispose]() {
+		await this.dispose();
+	}
+};
 /** Acquires the lock and executes a callback. */
 async function withLock(lock, cb) {
-    try {
-        await lock.acquireAsync();
-        return await cb();
-    }
-    finally {
-        lock.release();
-    }
+	try {
+		await lock.acquireAsync();
+		return await cb();
+	} finally {
+		lock.release();
+	}
 }
 
+//#endregion
 export { CorruptedRangesError, SparseCache, SparseCacheFsFile, SparseCacheFsRanges };
-//# sourceMappingURL=cache.js.map
+//# sourceMappingURL=cache.js.map

package/dist/drivers/download_blob/sparse_cache/cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"cache.js","sources":["../../../../src/drivers/download_blob/sparse_cache/cache.ts"],"sourcesContent":["import { RangeBytes } from \"@milaboratories/pl-model-common\";\nimport { ensureDirExists, fileExists, mapEntries, MiLogger } from \"@milaboratories/ts-helpers\";\nimport { promises as fs } from \"node:fs\";\nimport path from \"node:path\";\nimport {\n  addRange,\n  doesRangeExist,\n  Ranges,\n  rangesFileName,\n  rangesSize,\n  readRangesFile,\n  writeRangesFile,\n} from \"./ranges\";\nimport { writeToSparseFile } from \"./file\";\nimport { functions } from \"@milaboratories/helpers\";\n\n/** The implementer of SparseCacheRanges could throw it if ranges were corrupted. */\nexport class CorruptedRangesError extends Error {\n  name = \"CorruptedRangesError\";\n}\n\n/** Extracted ranges methods to be able to store ranges somewhere else (e.g. in memory for tests). */\nexport interface SparseCacheRanges {\n  get(key: string): Promise<Ranges>;\n  set(key: string, ranges: Ranges): Promise<void>;\n  delete(key: string): Promise<void>;\n}\n\n/** Stores ranges in a directory as JSON files (the default implementation). */\nexport class SparseCacheFsRanges implements SparseCacheRanges {\n  constructor(\n    private readonly logger: MiLogger,\n    private readonly cacheDir: string,\n  ) {}\n\n  private fPath(key: string): string {\n    return path.join(this.cacheDir, rangesFileName(key));\n  }\n\n  async get(key: string): Promise<Ranges> {\n    return await readRangesFile(this.logger, this.fPath(key));\n  }\n\n  async set(key: string, ranges: Ranges) {\n    return await writeRangesFile(this.logger, this.fPath(key), ranges);\n  }\n\n  async delete(key: string) {\n    await fs.rm(this.fPath(key));\n  }\n}\n\n/** Extracted interface for storing sparse files. */\nexport interface SparseFileStorage {\n  all(): Promise<string[]>;\n  exists(key: string): Promise<boolean>;\n  path(key: string): string;\n  write(key: string, data: Uint8Array, from: number): Promise<void>;\n  delete(key: string): Promise<void>;\n}\n\n/** Stores sparse files in a directory (the default implementation). */\nexport class SparseCacheFsFile implements SparseFileStorage {\n  private readonly suffix = \".sparse.bin\";\n\n  constructor(\n    private readonly logger: MiLogger,\n    private readonly cacheDir: string,\n  ) {}\n\n  async all(): Promise<string[]> {\n    await ensureDirExists(this.cacheDir);\n    const files = await fs.readdir(this.cacheDir);\n    return files.filter((f) => f.endsWith(this.suffix));\n  }\n\n  async exists(key: string): Promise<boolean> {\n    return await fileExists(this.path(key));\n  }\n\n  path(key: string): string {\n    return path.join(this.cacheDir, key + this.suffix);\n  }\n\n  async write(key: string, data: Uint8Array, from: number): Promise<void> {\n    await ensureDirExists(this.cacheDir);\n    await writeToSparseFile(this.logger, process.platform, this.path(key), data, from);\n  }\n\n  async delete(key: string): Promise<void> {\n    await fs.rm(this.path(key));\n  }\n}\n\n/** LRU cache for ranges of sparse files. */\nexport class SparseCache implements AsyncDisposable {\n  /** Fields are public for tests. */\n\n  /** The lock to make sure cache requests are done one by one. */\n  private lock = new functions.AwaitLock();\n\n  public keyToLastAccessTime = new Map<string, Date>();\n  public size = 0;\n\n  constructor(\n    public readonly logger: MiLogger,\n    /** The hard limit in bytes. */\n    public readonly maxSize: number,\n    public readonly ranges: SparseCacheRanges,\n    public readonly storage: SparseFileStorage,\n  ) {}\n\n  /** Resets a cache's size by rereading everything we already store.\n   * Safe for concurrent use. */\n  async reset() {\n    await withLock(this.lock, async () => {\n      await this.resetUnsafe();\n    });\n  }\n\n  /** Returns a path to the key if the range exists in a cache, otherwise returns undefined.\n   * Safe for concurrent use. */\n  async get(key: string, range: RangeBytes): Promise<string | undefined> {\n    return await withLock(this.lock, async () => {\n      return await this.getUnsafe(key, range);\n    });\n  }\n\n  /** Sets data to the cache's file and clear the cache if it's needed.\n   * Safe for concurrent use. */\n  async set(key: string, range: RangeBytes, data: Uint8Array): Promise<void> {\n    await withLock(this.lock, async () => {\n      await this.setUnsafe(key, range, data);\n    });\n  }\n\n  private async resetUnsafe() {\n    this.size = 0;\n    this.keyToLastAccessTime = new Map<string, Date>();\n\n    const now = new Date();\n    // In rmKey method we first deletes the key from a storage and only then from ranges,\n    // so if something goes wrong between 2 operations,\n    // on reset the logic will be correct.\n    for (const key of await this.storage.all()) {\n      const ranges = await this.ranges.get(key);\n      this.size += rangesSize(ranges);\n      this.keyToLastAccessTime.set(key, now);\n    }\n  }\n\n  private async getUnsafe(key: string, range: RangeBytes): Promise<string | undefined> {\n    // It first checks the storage, and then the ranges.\n    // In another method, when we remove a key, it first deletes a key from a storage and then from ranges,\n    // so if we don't have a key in storage but have it in ranges, the logic here is correct.\n    // We probably could reverse the operations here and there, and everywhere we work with both storage and ranges.\n    if (await this.storage.exists(key)) {\n      this.keyToLastAccessTime.set(key, new Date());\n\n      const ranges = await this.getRanges(key);\n      if (doesRangeExist(ranges, range)) {\n        return this.storage.path(key);\n      }\n\n      return undefined;\n    }\n\n    return undefined;\n  }\n\n  private async setUnsafe(key: string, range: { from: number; to: number }, data: Uint8Array) {\n    await this.setWithoutEviction(key, range, data);\n    await this.ensureEvicted();\n  }\n\n  /** Sets a key and recalculates a size, but doesn't ensures that the size is less than the hard limit. */\n  async setWithoutEviction(key: string, range: RangeBytes, data: Uint8Array): Promise<void> {\n    if (range.to - range.from !== data.length) {\n      throw new Error(\n        `SparseCache.set: trying to set ${key} with wrong range length: ` +\n          `range: ${JSON.stringify(range)}, data: ${data.length}`,\n      );\n    }\n\n    this.keyToLastAccessTime.set(key, new Date());\n\n    const ranges = await this.getRanges(key);\n    this.size -= rangesSize(ranges);\n\n    await this.storage.write(key, data, range.from);\n\n    const newRanges = addRange(ranges, range);\n    this.size += rangesSize(newRanges);\n\n    await this.ranges.set(key, newRanges);\n  }\n\n  /** Ensures the size is less than hard limit by deleting the oldest keys. */\n  async ensureEvicted(): Promise<void> {\n    const byTime = mapEntries(this.keyToLastAccessTime);\n    byTime.sort(([_, aDate], [__, bDate]) => bDate.getTime() - aDate.getTime());\n\n    while (this.size > this.maxSize) {\n      const keyAndDate = byTime.pop(); // removes the oldest\n      if (!keyAndDate) {\n        break;\n      }\n      const [key, _] = keyAndDate;\n\n      const ranges = await this.getRanges(key);\n      this.size -= rangesSize(ranges);\n      this.rmKey(key);\n    }\n  }\n\n  /** Gets ranges and if they were corrupted, then remove the file from the cache and reset the cache's size. */\n  private async getRanges(key: string) {\n    try {\n      return await this.ranges.get(key);\n    } catch (e: unknown) {\n      if (e instanceof CorruptedRangesError) {\n        // We need to reset a state of the cache and update current size,\n        // it's the only way to calculate the real size when one of the ranges were corrupted.\n        await this.rmKey(key);\n        await this.resetUnsafe();\n\n        return await this.ranges.get(key);\n      }\n\n      throw e;\n    }\n  }\n\n  /** Removes a key the state of the cache. The size should be updated. */\n  private async rmKey(key: string) {\n    await this.storage.delete(key);\n    await this.ranges.delete(key);\n    this.keyToLastAccessTime.delete(key);\n  }\n\n  async dispose(): Promise<void> {\n    await this.lock.acquireAsync();\n  }\n\n  async [Symbol.asyncDispose](): Promise<void> {\n    await this.dispose();\n  }\n}\n\n/** Acquires the lock and executes a callback. */\nasync function withLock<T>(lock: functions.AwaitLock, cb: () => Promise<T>): Promise<T> {\n  try {\n    await lock.acquireAsync();\n    return await cb();\n  } finally {\n    lock.release();\n  }\n}\n"],"names":["path","fs"],"mappings":"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"}
+{"version":3,"file":"cache.js","names":["fs"],"sources":["../../../../src/drivers/download_blob/sparse_cache/cache.ts"],"sourcesContent":["import { RangeBytes } from \"@milaboratories/pl-model-common\";\nimport { ensureDirExists, fileExists, mapEntries, MiLogger } from \"@milaboratories/ts-helpers\";\nimport { promises as fs } from \"node:fs\";\nimport path from \"node:path\";\nimport {\n  addRange,\n  doesRangeExist,\n  Ranges,\n  rangesFileName,\n  rangesSize,\n  readRangesFile,\n  writeRangesFile,\n} from \"./ranges\";\nimport { writeToSparseFile } from \"./file\";\nimport { functions } from \"@milaboratories/helpers\";\n\n/** The implementer of SparseCacheRanges could throw it if ranges were corrupted. */\nexport class CorruptedRangesError extends Error {\n  name = \"CorruptedRangesError\";\n}\n\n/** Extracted ranges methods to be able to store ranges somewhere else (e.g. in memory for tests). */\nexport interface SparseCacheRanges {\n  get(key: string): Promise<Ranges>;\n  set(key: string, ranges: Ranges): Promise<void>;\n  delete(key: string): Promise<void>;\n}\n\n/** Stores ranges in a directory as JSON files (the default implementation). */\nexport class SparseCacheFsRanges implements SparseCacheRanges {\n  constructor(\n    private readonly logger: MiLogger,\n    private readonly cacheDir: string,\n  ) {}\n\n  private fPath(key: string): string {\n    return path.join(this.cacheDir, rangesFileName(key));\n  }\n\n  async get(key: string): Promise<Ranges> {\n    return await readRangesFile(this.logger, this.fPath(key));\n  }\n\n  async set(key: string, ranges: Ranges) {\n    return await writeRangesFile(this.logger, this.fPath(key), ranges);\n  }\n\n  async delete(key: string) {\n    await fs.rm(this.fPath(key));\n  }\n}\n\n/** Extracted interface for storing sparse files. */\nexport interface SparseFileStorage {\n  all(): Promise<string[]>;\n  exists(key: string): Promise<boolean>;\n  path(key: string): string;\n  write(key: string, data: Uint8Array, from: number): Promise<void>;\n  delete(key: string): Promise<void>;\n}\n\n/** Stores sparse files in a directory (the default implementation). */\nexport class SparseCacheFsFile implements SparseFileStorage {\n  private readonly suffix = \".sparse.bin\";\n\n  constructor(\n    private readonly logger: MiLogger,\n    private readonly cacheDir: string,\n  ) {}\n\n  async all(): Promise<string[]> {\n    await ensureDirExists(this.cacheDir);\n    const files = await fs.readdir(this.cacheDir);\n    return files.filter((f) => f.endsWith(this.suffix));\n  }\n\n  async exists(key: string): Promise<boolean> {\n    return await fileExists(this.path(key));\n  }\n\n  path(key: string): string {\n    return path.join(this.cacheDir, key + this.suffix);\n  }\n\n  async write(key: string, data: Uint8Array, from: number): Promise<void> {\n    await ensureDirExists(this.cacheDir);\n    await writeToSparseFile(this.logger, process.platform, this.path(key), data, from);\n  }\n\n  async delete(key: string): Promise<void> {\n    await fs.rm(this.path(key));\n  }\n}\n\n/** LRU cache for ranges of sparse files. */\nexport class SparseCache implements AsyncDisposable {\n  /** Fields are public for tests. */\n\n  /** The lock to make sure cache requests are done one by one. */\n  private lock = new functions.AwaitLock();\n\n  public keyToLastAccessTime = new Map<string, Date>();\n  public size = 0;\n\n  constructor(\n    public readonly logger: MiLogger,\n    /** The hard limit in bytes. */\n    public readonly maxSize: number,\n    public readonly ranges: SparseCacheRanges,\n    public readonly storage: SparseFileStorage,\n  ) {}\n\n  /** Resets a cache's size by rereading everything we already store.\n   * Safe for concurrent use. */\n  async reset() {\n    await withLock(this.lock, async () => {\n      await this.resetUnsafe();\n    });\n  }\n\n  /** Returns a path to the key if the range exists in a cache, otherwise returns undefined.\n   * Safe for concurrent use. */\n  async get(key: string, range: RangeBytes): Promise<string | undefined> {\n    return await withLock(this.lock, async () => {\n      return await this.getUnsafe(key, range);\n    });\n  }\n\n  /** Sets data to the cache's file and clear the cache if it's needed.\n   * Safe for concurrent use. */\n  async set(key: string, range: RangeBytes, data: Uint8Array): Promise<void> {\n    await withLock(this.lock, async () => {\n      await this.setUnsafe(key, range, data);\n    });\n  }\n\n  private async resetUnsafe() {\n    this.size = 0;\n    this.keyToLastAccessTime = new Map<string, Date>();\n\n    const now = new Date();\n    // In rmKey method we first deletes the key from a storage and only then from ranges,\n    // so if something goes wrong between 2 operations,\n    // on reset the logic will be correct.\n    for (const key of await this.storage.all()) {\n      const ranges = await this.ranges.get(key);\n      this.size += rangesSize(ranges);\n      this.keyToLastAccessTime.set(key, now);\n    }\n  }\n\n  private async getUnsafe(key: string, range: RangeBytes): Promise<string | undefined> {\n    // It first checks the storage, and then the ranges.\n    // In another method, when we remove a key, it first deletes a key from a storage and then from ranges,\n    // so if we don't have a key in storage but have it in ranges, the logic here is correct.\n    // We probably could reverse the operations here and there, and everywhere we work with both storage and ranges.\n    if (await this.storage.exists(key)) {\n      this.keyToLastAccessTime.set(key, new Date());\n\n      const ranges = await this.getRanges(key);\n      if (doesRangeExist(ranges, range)) {\n        return this.storage.path(key);\n      }\n\n      return undefined;\n    }\n\n    return undefined;\n  }\n\n  private async setUnsafe(key: string, range: { from: number; to: number }, data: Uint8Array) {\n    await this.setWithoutEviction(key, range, data);\n    await this.ensureEvicted();\n  }\n\n  /** Sets a key and recalculates a size, but doesn't ensures that the size is less than the hard limit. */\n  async setWithoutEviction(key: string, range: RangeBytes, data: Uint8Array): Promise<void> {\n    if (range.to - range.from !== data.length) {\n      throw new Error(\n        `SparseCache.set: trying to set ${key} with wrong range length: ` +\n          `range: ${JSON.stringify(range)}, data: ${data.length}`,\n      );\n    }\n\n    this.keyToLastAccessTime.set(key, new Date());\n\n    const ranges = await this.getRanges(key);\n    this.size -= rangesSize(ranges);\n\n    await this.storage.write(key, data, range.from);\n\n    const newRanges = addRange(ranges, range);\n    this.size += rangesSize(newRanges);\n\n    await this.ranges.set(key, newRanges);\n  }\n\n  /** Ensures the size is less than hard limit by deleting the oldest keys. */\n  async ensureEvicted(): Promise<void> {\n    const byTime = mapEntries(this.keyToLastAccessTime);\n    byTime.sort(([_, aDate], [__, bDate]) => bDate.getTime() - aDate.getTime());\n\n    while (this.size > this.maxSize) {\n      const keyAndDate = byTime.pop(); // removes the oldest\n      if (!keyAndDate) {\n        break;\n      }\n      const [key, _] = keyAndDate;\n\n      const ranges = await this.getRanges(key);\n      this.size -= rangesSize(ranges);\n      this.rmKey(key);\n    }\n  }\n\n  /** Gets ranges and if they were corrupted, then remove the file from the cache and reset the cache's size. */\n  private async getRanges(key: string) {\n    try {\n      return await this.ranges.get(key);\n    } catch (e: unknown) {\n      if (e instanceof CorruptedRangesError) {\n        // We need to reset a state of the cache and update current size,\n        // it's the only way to calculate the real size when one of the ranges were corrupted.\n        await this.rmKey(key);\n        await this.resetUnsafe();\n\n        return await this.ranges.get(key);\n      }\n\n      throw e;\n    }\n  }\n\n  /** Removes a key the state of the cache. The size should be updated. */\n  private async rmKey(key: string) {\n    await this.storage.delete(key);\n    await this.ranges.delete(key);\n    this.keyToLastAccessTime.delete(key);\n  }\n\n  async dispose(): Promise<void> {\n    await this.lock.acquireAsync();\n  }\n\n  async [Symbol.asyncDispose](): Promise<void> {\n    await this.dispose();\n  }\n}\n\n/** Acquires the lock and executes a callback. */\nasync function withLock<T>(lock: functions.AwaitLock, cb: () => Promise<T>): Promise<T> {\n  try {\n    await lock.acquireAsync();\n    return await cb();\n  } finally {\n    lock.release();\n  }\n}\n"],"mappings":"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"}

package/dist/drivers/download_blob/sparse_cache/file.cjs

@@ -1,62 +1,41 @@
-'use strict';
-
-var tsHelpers = require('@milaboratories/ts-helpers');
-var fsp = require('node:fs/promises');
-
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-var fsp__namespace = /*#__PURE__*/_interopNamespaceDefault(fsp);
+const require_runtime = require('../../../_virtual/_rolldown/runtime.cjs');
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_runtime.__toESM(node_fs_promises);
+let _milaboratories_ts_helpers = require("@milaboratories/ts-helpers");
 
+//#region src/drivers/download_blob/sparse_cache/file.ts
 /** Creates a sparse file for all systems
- * Table of what supports sparse files:
- * https://en.wikipedia.org/wiki/Comparison_of_file_systems#Allocation_and_layout_policies */
+* Table of what supports sparse files:
+* https://en.wikipedia.org/wiki/Comparison_of_file_systems#Allocation_and_layout_policies */
 async function createSparseFile(logger, path, platform) {
-    try {
-        const ensureCreated = await fsp__namespace.open(path, "w");
-        await ensureCreated.close();
-        await ensureSparseOnWindows(path, platform);
-    }
-    catch (error) {
-        logger.error(`Error creating file ${path} on platform ${platform}: ${error}`);
-    }
+	try {
+		await (await node_fs_promises.open(path, "w")).close();
+		await ensureSparseOnWindows(path, platform);
+	} catch (error) {
+		logger.error(`Error creating file ${path} on platform ${platform}: ${error}`);
+	}
 }
 /** Sets a sparse flag on Windows.
- * We could check the file is sparse by running:
- * `fsutil sparse queryflag <path>`
- * and
- * `fsutil sparse queryrange <path>`
- */
+* We could check the file is sparse by running:
+* `fsutil sparse queryflag <path>`
+* and
+* `fsutil sparse queryrange <path>`
+*/
 async function ensureSparseOnWindows(path, platform) {
-    if (platform === "win32") {
-        // https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/fsutil-sparse
-        await tsHelpers.spawnAsync("fsutil", ["sparse", "setflag", path], { stdio: "pipe" });
-    }
+	if (platform === "win32") await (0, _milaboratories_ts_helpers.spawnAsync)("fsutil", [
+		"sparse",
+		"setflag",
+		path
+	], { stdio: "pipe" });
 }
 /** Ensures the file is created and writes to it. */
 async function writeToSparseFile(logger, platform, path, data, from) {
-    if (!(await tsHelpers.fileExists(path))) {
-        await createSparseFile(logger, path, platform);
-    }
-    const fileHandle = await fsp__namespace.open(path, "r+");
-    await fileHandle.write(data, 0, data.length, from);
-    await fileHandle.close();
+	if (!await (0, _milaboratories_ts_helpers.fileExists)(path)) await createSparseFile(logger, path, platform);
+	const fileHandle = await node_fs_promises.open(path, "r+");
+	await fileHandle.write(data, 0, data.length, from);
+	await fileHandle.close();
 }
 
-exports.createSparseFile = createSparseFile;
+//#endregion
 exports.writeToSparseFile = writeToSparseFile;
-//# sourceMappingURL=file.cjs.map
+//# sourceMappingURL=file.cjs.map

package/dist/drivers/download_blob/sparse_cache/file.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"file.cjs","sources":["../../../../src/drivers/download_blob/sparse_cache/file.ts"],"sourcesContent":["import { fileExists, MiLogger, spawnAsync } from \"@milaboratories/ts-helpers\";\nimport * as fs from \"node:fs/promises\";\n\n/** Creates a sparse file for all systems\n * Table of what supports sparse files:\n * https://en.wikipedia.org/wiki/Comparison_of_file_systems#Allocation_and_layout_policies */\nexport async function createSparseFile(logger: MiLogger, path: string, platform: NodeJS.Platform) {\n  try {\n    const ensureCreated = await fs.open(path, \"w\");\n    await ensureCreated.close();\n\n    await ensureSparseOnWindows(path, platform);\n  } catch (error: unknown) {\n    logger.error(`Error creating file ${path} on platform ${platform}: ${error}`);\n  }\n}\n\n/** Sets a sparse flag on Windows.\n * We could check the file is sparse by running:\n * `fsutil sparse queryflag <path>`\n * and\n * `fsutil sparse queryrange <path>`\n */\nasync function ensureSparseOnWindows(path: string, platform: NodeJS.Platform) {\n  if (platform === \"win32\") {\n    // https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/fsutil-sparse\n    await spawnAsync(\"fsutil\", [\"sparse\", \"setflag\", path], { stdio: \"pipe\" });\n  }\n}\n\n/** Ensures the file is created and writes to it. */\nexport async function writeToSparseFile(\n  logger: MiLogger,\n  platform: NodeJS.Platform,\n  path: string,\n  data: Uint8Array,\n  from: number,\n) {\n  if (!(await fileExists(path))) {\n    await createSparseFile(logger, path, platform);\n  }\n\n  const fileHandle = await fs.open(path, \"r+\");\n  await fileHandle.write(data, 0, data.length, from);\n  await fileHandle.close();\n}\n"],"names":["fs","spawnAsync","fileExists"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAGA;;AAE6F;AACtF,eAAe,gBAAgB,CAAC,MAAgB,EAAE,IAAY,EAAE,QAAyB,EAAA;AAC9F,IAAA,IAAI;QACF,MAAM,aAAa,GAAG,MAAMA,cAAE,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC;AAC9C,QAAA,MAAM,aAAa,CAAC,KAAK,EAAE;AAE3B,QAAA,MAAM,qBAAqB,CAAC,IAAI,EAAE,QAAQ,CAAC;IAC7C;IAAE,OAAO,KAAc,EAAE;QACvB,MAAM,CAAC,KAAK,CAAC,CAAA,oBAAA,EAAuB,IAAI,CAAA,aAAA,EAAgB,QAAQ,CAAA,EAAA,EAAK,KAAK,CAAA,CAAE,CAAC;IAC/E;AACF;AAEA;;;;;AAKG;AACH,eAAe,qBAAqB,CAAC,IAAY,EAAE,QAAyB,EAAA;AAC1E,IAAA,IAAI,QAAQ,KAAK,OAAO,EAAE;;AAExB,QAAA,MAAMC,oBAAU,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAC5E;AACF;AAEA;AACO,eAAe,iBAAiB,CACrC,MAAgB,EAChB,QAAyB,EACzB,IAAY,EACZ,IAAgB,EAChB,IAAY,EAAA;IAEZ,IAAI,EAAE,MAAMC,oBAAU,CAAC,IAAI,CAAC,CAAC,EAAE;QAC7B,MAAM,gBAAgB,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC;IAChD;IAEA,MAAM,UAAU,GAAG,MAAMF,cAAE,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC;AAC5C,IAAA,MAAM,UAAU,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC;AAClD,IAAA,MAAM,UAAU,CAAC,KAAK,EAAE;AAC1B;;;;;"}
+{"version":3,"file":"file.cjs","names":["fs"],"sources":["../../../../src/drivers/download_blob/sparse_cache/file.ts"],"sourcesContent":["import { fileExists, MiLogger, spawnAsync } from \"@milaboratories/ts-helpers\";\nimport * as fs from \"node:fs/promises\";\n\n/** Creates a sparse file for all systems\n * Table of what supports sparse files:\n * https://en.wikipedia.org/wiki/Comparison_of_file_systems#Allocation_and_layout_policies */\nexport async function createSparseFile(logger: MiLogger, path: string, platform: NodeJS.Platform) {\n  try {\n    const ensureCreated = await fs.open(path, \"w\");\n    await ensureCreated.close();\n\n    await ensureSparseOnWindows(path, platform);\n  } catch (error: unknown) {\n    logger.error(`Error creating file ${path} on platform ${platform}: ${error}`);\n  }\n}\n\n/** Sets a sparse flag on Windows.\n * We could check the file is sparse by running:\n * `fsutil sparse queryflag <path>`\n * and\n * `fsutil sparse queryrange <path>`\n */\nasync function ensureSparseOnWindows(path: string, platform: NodeJS.Platform) {\n  if (platform === \"win32\") {\n    // https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/fsutil-sparse\n    await spawnAsync(\"fsutil\", [\"sparse\", \"setflag\", path], { stdio: \"pipe\" });\n  }\n}\n\n/** Ensures the file is created and writes to it. */\nexport async function writeToSparseFile(\n  logger: MiLogger,\n  platform: NodeJS.Platform,\n  path: string,\n  data: Uint8Array,\n  from: number,\n) {\n  if (!(await fileExists(path))) {\n    await createSparseFile(logger, path, platform);\n  }\n\n  const fileHandle = await fs.open(path, \"r+\");\n  await fileHandle.write(data, 0, data.length, from);\n  await fileHandle.close();\n}\n"],"mappings":";;;;;;;;;AAMA,eAAsB,iBAAiB,QAAkB,MAAc,UAA2B;AAChG,KAAI;AAEF,SADsB,MAAMA,iBAAG,KAAK,MAAM,IAAI,EAC1B,OAAO;AAE3B,QAAM,sBAAsB,MAAM,SAAS;UACpC,OAAgB;AACvB,SAAO,MAAM,uBAAuB,KAAK,eAAe,SAAS,IAAI,QAAQ;;;;;;;;;AAUjF,eAAe,sBAAsB,MAAc,UAA2B;AAC5E,KAAI,aAAa,QAEf,kDAAiB,UAAU;EAAC;EAAU;EAAW;EAAK,EAAE,EAAE,OAAO,QAAQ,CAAC;;;AAK9E,eAAsB,kBACpB,QACA,UACA,MACA,MACA,MACA;AACA,KAAI,CAAE,iDAAiB,KAAK,CAC1B,OAAM,iBAAiB,QAAQ,MAAM,SAAS;CAGhD,MAAM,aAAa,MAAMA,iBAAG,KAAK,MAAM,KAAK;AAC5C,OAAM,WAAW,MAAM,MAAM,GAAG,KAAK,QAAQ,KAAK;AAClD,OAAM,WAAW,OAAO"}

package/dist/drivers/download_blob/sparse_cache/file.js

@@ -1,40 +1,39 @@
-import { fileExists, spawnAsync } from '@milaboratories/ts-helpers';
-import * as fsp from 'node:fs/promises';
+import * as fs from "node:fs/promises";
+import { fileExists, spawnAsync } from "@milaboratories/ts-helpers";
 
+//#region src/drivers/download_blob/sparse_cache/file.ts
 /** Creates a sparse file for all systems
- * Table of what supports sparse files:
- * https://en.wikipedia.org/wiki/Comparison_of_file_systems#Allocation_and_layout_policies */
+* Table of what supports sparse files:
+* https://en.wikipedia.org/wiki/Comparison_of_file_systems#Allocation_and_layout_policies */
 async function createSparseFile(logger, path, platform) {
-    try {
-        const ensureCreated = await fsp.open(path, "w");
-        await ensureCreated.close();
-        await ensureSparseOnWindows(path, platform);
-    }
-    catch (error) {
-        logger.error(`Error creating file ${path} on platform ${platform}: ${error}`);
-    }
+	try {
+		await (await fs.open(path, "w")).close();
+		await ensureSparseOnWindows(path, platform);
+	} catch (error) {
+		logger.error(`Error creating file ${path} on platform ${platform}: ${error}`);
+	}
 }
 /** Sets a sparse flag on Windows.
- * We could check the file is sparse by running:
- * `fsutil sparse queryflag <path>`
- * and
- * `fsutil sparse queryrange <path>`
- */
+* We could check the file is sparse by running:
+* `fsutil sparse queryflag <path>`
+* and
+* `fsutil sparse queryrange <path>`
+*/
 async function ensureSparseOnWindows(path, platform) {
-    if (platform === "win32") {
-        // https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/fsutil-sparse
-        await spawnAsync("fsutil", ["sparse", "setflag", path], { stdio: "pipe" });
-    }
+	if (platform === "win32") await spawnAsync("fsutil", [
+		"sparse",
+		"setflag",
+		path
+	], { stdio: "pipe" });
 }
 /** Ensures the file is created and writes to it. */
 async function writeToSparseFile(logger, platform, path, data, from) {
-    if (!(await fileExists(path))) {
-        await createSparseFile(logger, path, platform);
-    }
-    const fileHandle = await fsp.open(path, "r+");
-    await fileHandle.write(data, 0, data.length, from);
-    await fileHandle.close();
+	if (!await fileExists(path)) await createSparseFile(logger, path, platform);
+	const fileHandle = await fs.open(path, "r+");
+	await fileHandle.write(data, 0, data.length, from);
+	await fileHandle.close();
 }
 
-export { createSparseFile, writeToSparseFile };
-//# sourceMappingURL=file.js.map
+//#endregion
+export { writeToSparseFile };
+//# sourceMappingURL=file.js.map