keyv-dir-store 0.0.1 → 0.0.3

package/README.md

@@ -1,24 +1,34 @@
-
-# KeyvDIR
+# Keyv Directory Store
 
 Store key into a file per value
 
-## Store each value with CSV
+## Usages
 
 ```ts
+// Default: Store each value with JSON in format "{value: ..., expires: ...}"
 new Keyv({
-  store: new KeyvDirStore("cache/kv", { ext: "csv" }),
-  serialize: ({ value }) => csvFormat(value),
-  deserialize: (str) => ({ value: csvParse(str), expires: undefined }),
+  store: new KeyvDirStore(".cache/kv")
 });
-```
 
-## Store each value with YAML
+// Store each value with CSV
+new Keyv({
+  store: new KeyvDirStore(".cache/kv", { ext: ".csv" }),
+  serialize: ({ value }) => d3.csvFormat(value),
+  deserialize: (str) => ({ value: d3.csvParse(str), expires: undefined }),
+});
 
-```ts
+// Store each value with YAML
 new Keyv({
-  store: new KeyvDirStore("cache/kv", { ext: "yaml" }),
+  store: new KeyvDirStore(".cache/kv", { ext: ".json" }),
   serialize: ({ value }) => yaml.stringify(value),
   deserialize: (str) => ({ value: yaml.parse(str), expires: undefined }),
 });
-```
+
+// Store each value with JSON
+new Keyv({
+  store: new KeyvDirStore(".cache/kv", { ext: ".json" }),
+  serialize: ({ value }) => JSON.stringify(value, null, 2),
+  deserialize: (str) => ({ value: JSON.parse(str), expires: undefined }),
+});
+
+```

package/dist/index.js

@@ -0,0 +1,408 @@
+// @bun
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// node_modules/crypt/crypt.js
+var require_crypt = __commonJS((exports, module) => {
+  (function() {
+    var base64map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", crypt = {
+      rotl: function(n, b) {
+        return n << b | n >>> 32 - b;
+      },
+      rotr: function(n, b) {
+        return n << 32 - b | n >>> b;
+      },
+      endian: function(n) {
+        if (n.constructor == Number) {
+          return crypt.rotl(n, 8) & 16711935 | crypt.rotl(n, 24) & 4278255360;
+        }
+        for (var i = 0;i < n.length; i++)
+          n[i] = crypt.endian(n[i]);
+        return n;
+      },
+      randomBytes: function(n) {
+        for (var bytes = [];n > 0; n--)
+          bytes.push(Math.floor(Math.random() * 256));
+        return bytes;
+      },
+      bytesToWords: function(bytes) {
+        for (var words = [], i = 0, b = 0;i < bytes.length; i++, b += 8)
+          words[b >>> 5] |= bytes[i] << 24 - b % 32;
+        return words;
+      },
+      wordsToBytes: function(words) {
+        for (var bytes = [], b = 0;b < words.length * 32; b += 8)
+          bytes.push(words[b >>> 5] >>> 24 - b % 32 & 255);
+        return bytes;
+      },
+      bytesToHex: function(bytes) {
+        for (var hex = [], i = 0;i < bytes.length; i++) {
+          hex.push((bytes[i] >>> 4).toString(16));
+          hex.push((bytes[i] & 15).toString(16));
+        }
+        return hex.join("");
+      },
+      hexToBytes: function(hex) {
+        for (var bytes = [], c = 0;c < hex.length; c += 2)
+          bytes.push(parseInt(hex.substr(c, 2), 16));
+        return bytes;
+      },
+      bytesToBase64: function(bytes) {
+        for (var base64 = [], i = 0;i < bytes.length; i += 3) {
+          var triplet = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+          for (var j = 0;j < 4; j++)
+            if (i * 8 + j * 6 <= bytes.length * 8)
+              base64.push(base64map.charAt(triplet >>> 6 * (3 - j) & 63));
+            else
+              base64.push("=");
+        }
+        return base64.join("");
+      },
+      base64ToBytes: function(base64) {
+        base64 = base64.replace(/[^A-Z0-9+\/]/ig, "");
+        for (var bytes = [], i = 0, imod4 = 0;i < base64.length; imod4 = ++i % 4) {
+          if (imod4 == 0)
+            continue;
+          bytes.push((base64map.indexOf(base64.charAt(i - 1)) & Math.pow(2, -2 * imod4 + 8) - 1) << imod4 * 2 | base64map.indexOf(base64.charAt(i)) >>> 6 - imod4 * 2);
+        }
+        return bytes;
+      }
+    };
+    module.exports = crypt;
+  })();
+});
+
+// node_modules/charenc/charenc.js
+var require_charenc = __commonJS((exports, module) => {
+  var charenc = {
+    utf8: {
+      stringToBytes: function(str) {
+        return charenc.bin.stringToBytes(unescape(encodeURIComponent(str)));
+      },
+      bytesToString: function(bytes) {
+        return decodeURIComponent(escape(charenc.bin.bytesToString(bytes)));
+      }
+    },
+    bin: {
+      stringToBytes: function(str) {
+        for (var bytes = [], i = 0;i < str.length; i++)
+          bytes.push(str.charCodeAt(i) & 255);
+        return bytes;
+      },
+      bytesToString: function(bytes) {
+        for (var str = [], i = 0;i < bytes.length; i++)
+          str.push(String.fromCharCode(bytes[i]));
+        return str.join("");
+      }
+    }
+  };
+  module.exports = charenc;
+});
+
+// node_modules/is-buffer/index.js
+var require_is_buffer = __commonJS((exports, module) => {
+  var isBuffer = function(obj) {
+    return !!obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+  };
+  var isSlowBuffer = function(obj) {
+    return typeof obj.readFloatLE === "function" && typeof obj.slice === "function" && isBuffer(obj.slice(0, 0));
+  };
+  /*!
+   * Determine if an object is a Buffer
+   *
+   * @author   Feross Aboukhadijeh <https://feross.org>
+   * @license  MIT
+   */
+  module.exports = function(obj) {
+    return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer);
+  };
+});
+
+// node_modules/md5/md5.js
+var require_md5 = __commonJS((exports, module) => {
+  (function() {
+    var crypt = require_crypt(), utf8 = require_charenc().utf8, isBuffer = require_is_buffer(), bin = require_charenc().bin, md5 = function(message, options) {
+      if (message.constructor == String)
+        if (options && options.encoding === "binary")
+          message = bin.stringToBytes(message);
+        else
+          message = utf8.stringToBytes(message);
+      else if (isBuffer(message))
+        message = Array.prototype.slice.call(message, 0);
+      else if (!Array.isArray(message) && message.constructor !== Uint8Array)
+        message = message.toString();
+      var m = crypt.bytesToWords(message), l = message.length * 8, a = 1732584193, b = -271733879, c = -1732584194, d = 271733878;
+      for (var i = 0;i < m.length; i++) {
+        m[i] = (m[i] << 8 | m[i] >>> 24) & 16711935 | (m[i] << 24 | m[i] >>> 8) & 4278255360;
+      }
+      m[l >>> 5] |= 128 << l % 32;
+      m[(l + 64 >>> 9 << 4) + 14] = l;
+      var { _ff: FF, _gg: GG, _hh: HH, _ii: II } = md5;
+      for (var i = 0;i < m.length; i += 16) {
+        var aa = a, bb = b, cc = c, dd = d;
+        a = FF(a, b, c, d, m[i + 0], 7, -680876936);
+        d = FF(d, a, b, c, m[i + 1], 12, -389564586);
+        c = FF(c, d, a, b, m[i + 2], 17, 606105819);
+        b = FF(b, c, d, a, m[i + 3], 22, -1044525330);
+        a = FF(a, b, c, d, m[i + 4], 7, -176418897);
+        d = FF(d, a, b, c, m[i + 5], 12, 1200080426);
+        c = FF(c, d, a, b, m[i + 6], 17, -1473231341);
+        b = FF(b, c, d, a, m[i + 7], 22, -45705983);
+        a = FF(a, b, c, d, m[i + 8], 7, 1770035416);
+        d = FF(d, a, b, c, m[i + 9], 12, -1958414417);
+        c = FF(c, d, a, b, m[i + 10], 17, -42063);
+        b = FF(b, c, d, a, m[i + 11], 22, -1990404162);
+        a = FF(a, b, c, d, m[i + 12], 7, 1804603682);
+        d = FF(d, a, b, c, m[i + 13], 12, -40341101);
+        c = FF(c, d, a, b, m[i + 14], 17, -1502002290);
+        b = FF(b, c, d, a, m[i + 15], 22, 1236535329);
+        a = GG(a, b, c, d, m[i + 1], 5, -165796510);
+        d = GG(d, a, b, c, m[i + 6], 9, -1069501632);
+        c = GG(c, d, a, b, m[i + 11], 14, 643717713);
+        b = GG(b, c, d, a, m[i + 0], 20, -373897302);
+        a = GG(a, b, c, d, m[i + 5], 5, -701558691);
+        d = GG(d, a, b, c, m[i + 10], 9, 38016083);
+        c = GG(c, d, a, b, m[i + 15], 14, -660478335);
+        b = GG(b, c, d, a, m[i + 4], 20, -405537848);
+        a = GG(a, b, c, d, m[i + 9], 5, 568446438);
+        d = GG(d, a, b, c, m[i + 14], 9, -1019803690);
+        c = GG(c, d, a, b, m[i + 3], 14, -187363961);
+        b = GG(b, c, d, a, m[i + 8], 20, 1163531501);
+        a = GG(a, b, c, d, m[i + 13], 5, -1444681467);
+        d = GG(d, a, b, c, m[i + 2], 9, -51403784);
+        c = GG(c, d, a, b, m[i + 7], 14, 1735328473);
+        b = GG(b, c, d, a, m[i + 12], 20, -1926607734);
+        a = HH(a, b, c, d, m[i + 5], 4, -378558);
+        d = HH(d, a, b, c, m[i + 8], 11, -2022574463);
+        c = HH(c, d, a, b, m[i + 11], 16, 1839030562);
+        b = HH(b, c, d, a, m[i + 14], 23, -35309556);
+        a = HH(a, b, c, d, m[i + 1], 4, -1530992060);
+        d = HH(d, a, b, c, m[i + 4], 11, 1272893353);
+        c = HH(c, d, a, b, m[i + 7], 16, -155497632);
+        b = HH(b, c, d, a, m[i + 10], 23, -1094730640);
+        a = HH(a, b, c, d, m[i + 13], 4, 681279174);
+        d = HH(d, a, b, c, m[i + 0], 11, -358537222);
+        c = HH(c, d, a, b, m[i + 3], 16, -722521979);
+        b = HH(b, c, d, a, m[i + 6], 23, 76029189);
+        a = HH(a, b, c, d, m[i + 9], 4, -640364487);
+        d = HH(d, a, b, c, m[i + 12], 11, -421815835);
+        c = HH(c, d, a, b, m[i + 15], 16, 530742520);
+        b = HH(b, c, d, a, m[i + 2], 23, -995338651);
+        a = II(a, b, c, d, m[i + 0], 6, -198630844);
+        d = II(d, a, b, c, m[i + 7], 10, 1126891415);
+        c = II(c, d, a, b, m[i + 14], 15, -1416354905);
+        b = II(b, c, d, a, m[i + 5], 21, -57434055);
+        a = II(a, b, c, d, m[i + 12], 6, 1700485571);
+        d = II(d, a, b, c, m[i + 3], 10, -1894986606);
+        c = II(c, d, a, b, m[i + 10], 15, -1051523);
+        b = II(b, c, d, a, m[i + 1], 21, -2054922799);
+        a = II(a, b, c, d, m[i + 8], 6, 1873313359);
+        d = II(d, a, b, c, m[i + 15], 10, -30611744);
+        c = II(c, d, a, b, m[i + 6], 15, -1560198380);
+        b = II(b, c, d, a, m[i + 13], 21, 1309151649);
+        a = II(a, b, c, d, m[i + 4], 6, -145523070);
+        d = II(d, a, b, c, m[i + 11], 10, -1120210379);
+        c = II(c, d, a, b, m[i + 2], 15, 718787259);
+        b = II(b, c, d, a, m[i + 9], 21, -343485551);
+        a = a + aa >>> 0;
+        b = b + bb >>> 0;
+        c = c + cc >>> 0;
+        d = d + dd >>> 0;
+      }
+      return crypt.endian([a, b, c, d]);
+    };
+    md5._ff = function(a, b, c, d, x, s, t) {
+      var n = a + (b & c | ~b & d) + (x >>> 0) + t;
+      return (n << s | n >>> 32 - s) + b;
+    };
+    md5._gg = function(a, b, c, d, x, s, t) {
+      var n = a + (b & d | c & ~d) + (x >>> 0) + t;
+      return (n << s | n >>> 32 - s) + b;
+    };
+    md5._hh = function(a, b, c, d, x, s, t) {
+      var n = a + (b ^ c ^ d) + (x >>> 0) + t;
+      return (n << s | n >>> 32 - s) + b;
+    };
+    md5._ii = function(a, b, c, d, x, s, t) {
+      var n = a + (c ^ (b | ~d)) + (x >>> 0) + t;
+      return (n << s | n >>> 32 - s) + b;
+    };
+    md5._blocksize = 16;
+    md5._digestsize = 16;
+    module.exports = function(message, options) {
+      if (message === undefined || message === null)
+        throw new Error("Illegal argument " + message);
+      var digestbytes = crypt.wordsToBytes(md5(message, options));
+      return options && options.asBytes ? digestbytes : options && options.asString ? bin.bytesToString(digestbytes) : crypt.bytesToHex(digestbytes);
+    };
+  })();
+});
+
+// node_modules/truncate-utf8-bytes/lib/truncate.js
+var require_truncate = __commonJS((exports, module) => {
+  var isHighSurrogate = function(codePoint) {
+    return codePoint >= 55296 && codePoint <= 56319;
+  };
+  var isLowSurrogate = function(codePoint) {
+    return codePoint >= 56320 && codePoint <= 57343;
+  };
+  module.exports = function truncate(getLength, string, byteLength) {
+    if (typeof string !== "string") {
+      throw new Error("Input must be string");
+    }
+    var charLength = string.length;
+    var curByteLength = 0;
+    var codePoint;
+    var segment;
+    for (var i = 0;i < charLength; i += 1) {
+      codePoint = string.charCodeAt(i);
+      segment = string[i];
+      if (isHighSurrogate(codePoint) && isLowSurrogate(string.charCodeAt(i + 1))) {
+        i += 1;
+        segment += string[i];
+      }
+      curByteLength += getLength(segment);
+      if (curByteLength === byteLength) {
+        return string.slice(0, i + 1);
+      } else if (curByteLength > byteLength) {
+        return string.slice(0, i - segment.length + 1);
+      }
+    }
+    return string;
+  };
+});
+
+// node_modules/truncate-utf8-bytes/index.js
+var require_truncate_utf8_bytes = __commonJS((exports, module) => {
+  var truncate = require_truncate();
+  var getLength = Buffer.byteLength.bind(Buffer);
+  module.exports = truncate.bind(null, getLength);
+});
+
+// node_modules/sanitize-filename/index.js
+var require_sanitize_filename = __commonJS((exports, module) => {
+  var sanitize = function(input, replacement) {
+    if (typeof input !== "string") {
+      throw new Error("Input must be string");
+    }
+    var sanitized = input.replace(illegalRe, replacement).replace(controlRe, replacement).replace(reservedRe, replacement).replace(windowsReservedRe, replacement).replace(windowsTrailingRe, replacement);
+    return truncate(sanitized, 255);
+  };
+  var truncate = require_truncate_utf8_bytes();
+  var illegalRe = /[\/\?<>\\:\*\|"]/g;
+  var controlRe = /[\x00-\x1f\x80-\x9f]/g;
+  var reservedRe = /^\.+$/;
+  var windowsReservedRe = /^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\..*)?$/i;
+  var windowsTrailingRe = /[\. ]+$/;
+  module.exports = function(input, options) {
+    var replacement = options && options.replacement || "";
+    var output = sanitize(input, replacement);
+    if (replacement === "") {
+      return output;
+    }
+    return sanitize(output, "");
+  };
+});
+
+// index.ts
+var import_md5 = __toESM(require_md5(), 1);
+var import_sanitize_filename = __toESM(require_sanitize_filename(), 1);
+import {mkdir, readFile, rm, stat, utimes, writeFile} from "fs/promises";
+import path from "path";
+
+class KeyvDirStore {
+  #dir;
+  #cache;
+  #ready;
+  #path;
+  ext = ".json";
+  constructor(dir, {
+    cache = new Map,
+    path: path2,
+    ext
+  } = {}) {
+    this.#ready = mkdir(dir, { recursive: true });
+    this.#cache = cache;
+    this.#dir = dir;
+    this.#path = path2 ?? this.#defaultPath;
+    this.ext = ext ?? this.ext;
+  }
+  #defaultPath(key) {
+    const readableName = import_sanitize_filename.default(key).slice(4, 16);
+    const hashName = import_md5.default(this.#dir + key).slice(0, 16);
+    const name = readableName + "-" + hashName + this.ext;
+    return path.join(this.#dir, name);
+  }
+  async get(key) {
+    const cached = this.#cache.get(key);
+    if (cached) {
+      if (cached.expires && cached.expires < Date.now()) {
+        await this.delete(key);
+      } else {
+        return cached.value;
+      }
+    }
+    const stats = await stat(this.#path(key)).catch(() => null);
+    if (!stats)
+      return;
+    const expires = +stats.mtime;
+    if (expires !== 0) {
+      const expired = +stats.mtime < +Date.now();
+      if (expired) {
+        await this.delete(key);
+        return;
+      }
+    }
+    return await readFile(this.#path(key), "utf8").catch(() => {
+      return;
+    });
+  }
+  async set(key, value, ttl) {
+    if (!value)
+      return await this.delete(key);
+    const expires = ttl ? Date.now() + ttl : 0;
+    this.#cache.set(key, { value, expires });
+    await this.#ready;
+    await writeFile(this.#path(key), value);
+    await utimes(this.#path(key), +new Date, new Date(expires ?? 0));
+    return true;
+  }
+  async delete(key) {
+    this.#cache.delete(key);
+    await rm(this.#path(key), { force: true });
+    return true;
+  }
+  async clear() {
+    await rm(this.#dir, { recursive: true }).catch(() => {
+      return;
+    });
+    await mkdir(this.#dir, { recursive: true });
+  }
+  async has(key) {
+    return await this.get(key) !== undefined;
+  }
+  static serialize({ value }) {
+    return JSON.stringify(value, null, 2);
+  }
+  static deserialize(str) {
+    return { value: JSON.parse(str), expires: undefined };
+  }
+}
+export {
+  KeyvDirStore
+};

package/index.test.ts

@@ -4,7 +4,7 @@ import { KeyvDirStore } from ".";
 it("KeyvDirStore works", async () => {
   // store test
   const kv = new Keyv<number | string | { obj: boolean }>({
-    store: new KeyvDirStore("cache/test1"),
+    store: new KeyvDirStore(".cache/test1"),
     deserialize: KeyvDirStore.deserialize,
     serialize: KeyvDirStore.serialize,
   });
@@ -20,7 +20,7 @@ it("KeyvDirStore works", async () => {
 
   // new instance with no cache Obj, to test file cache
   const kv2 = new Keyv<number | string | { obj: boolean }>({
-    store: new KeyvDirStore("cache/test1"),
+    store: new KeyvDirStore(".cache/test1"),
     deserialize: KeyvDirStore.deserialize,
     serialize: KeyvDirStore.serialize,
   });
@@ -32,7 +32,7 @@ it("KeyvDirStore works", async () => {
 it("KeyvDirStore works with only store", async () => {
   // store test
   const kv = new Keyv<number | string | { obj: boolean }>({
-    store: new KeyvDirStore("cache/test2"),
+    store: new KeyvDirStore(".cache/test2"),
   });
   await kv.clear();
   await kv.set("a", 1234, -86400e3); // already expired
@@ -46,7 +46,7 @@ it("KeyvDirStore works with only store", async () => {
 
   // new instance with no cache Obj, to test file cache
   const kv2 = new Keyv<number | string | { obj: boolean }>({
-    store: new KeyvDirStore("cache/test2"),
+    store: new KeyvDirStore(".cache/test2"),
   });
   expect(await kv2.get("a")).toEqual(undefined); // will delete file before get
   expect(await kv2.get("b")).toEqual(1234);

package/index.ts

@@ -1,12 +1,8 @@
-import { stat } from "fs/promises";
-import { writeFile } from "fs/promises";
-import { rm } from "fs/promises";
-import { readFile, mkdir } from "fs/promises";
-import { type default as Keyv, type DeserializedData } from "keyv";
+import { mkdir, readFile, rm, stat, utimes, writeFile } from "node:fs/promises";
+import type { DeserializedData, default as Keyv } from "keyv";
 import md5 from "md5";
-import sanitizeFilename from "sanitize-filename";
 import path from "path";
-import { utimes } from "fs/promises";
+import sanitizeFilename from "sanitize-filename";
 type Value = any;
 type CacheMap<Value> = Map<string, DeserializedData<Value>>;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "keyv-dir-store",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "author": "snomiao <snomiao@gmail.com>",
   "type": "module",
   "exports": {
@@ -13,10 +13,16 @@
     "dist"
   ],
   "scripts": {
-    "build": "bun build index.ts --outdir=dist",
+    "build": "bun build index.ts --outdir=dist --target=bun",
+    "prerelease": "bun run build && bun run test",
     "release": "bunx standard-version && git push --follow-tags && npm publish",
     "test": "bun test"
   },
+  "dependencies": {
+    "@types/node": "^20.14.2",
+    "md5": "^2.3.0",
+    "sanitize-filename": "^1.6.3"
+  },
   "devDependencies": {
     "@types/bun": "^1.1.3",
     "@types/jest": "^29.5.12",
@@ -25,9 +31,5 @@
   },
   "peerDependencies": {
     "keyv": "^4.5.4"
-  },
-  "dependencies": {
-    "md5": "^2.3.0",
-    "sanitize-filename": "^1.6.3"
   }
 }