Chore/CI: use fs cache to save bandwidth

Build/lib/cache-filesystem.ts

@@ -0,0 +1,131 @@
+// eslint-disable-next-line import/no-unresolved -- bun built-in module
+import { Database } from 'bun:sqlite';
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+import picocolors from 'picocolors';
+
+const identity = (x: any) => x;
+
+// eslint-disable-next-line sukka-ts/no-const-enum -- bun is smart, right?
+const enum CacheStatus {
+  Hit = 'hit',
+  Stale = 'stale',
+  Miss = 'miss'
+}
+
+export interface CacheOptions {
+  cachePath?: string,
+  tbd?: number
+}
+
+interface CacheApplyNonStringOption<T> {
+  ttl?: number | null,
+  serializer: (value: T) => string,
+  deserializer: (cached: string) => T,
+  temporaryBypass?: boolean
+}
+
+interface CacheApplyStringOption {
+  ttl?: number | null,
+  temporaryBypass?: boolean
+}
+
+type CacheApplyOption<T> = T extends string ? CacheApplyStringOption : CacheApplyNonStringOption<T>;
+
+export class Cache {
+  db: Database;
+  tbd = 60 * 1000; // time before deletion
+  cachePath: string;
+
+  constructor({ cachePath = path.join(os.tmpdir() || '/tmp', 'hdc'), tbd }: CacheOptions = {}) {
+    this.cachePath = cachePath;
+    fs.mkdirSync(this.cachePath, { recursive: true });
+    if (tbd != null) this.tbd = tbd;
+
+    const db = new Database(path.join(this.cachePath, 'cache.db'));
+    db.exec('PRAGMA journal_mode = WAL');
+
+    db.prepare('CREATE TABLE IF NOT EXISTS cache (key TEXT PRIMARY KEY, value TEXT, ttl REAL NOT NULL);').run();
+    db.prepare('CREATE INDEX IF NOT EXISTS cache_ttl ON cache (ttl);').run();
+
+    // perform purge on startup
+
+    // ttl + tbd < now => ttl < now - tbd
+    const now = Date.now() - this.tbd;
+    db.prepare('DELETE FROM cache WHERE ttl < ?').run(now);
+
+    this.db = db;
+  }
+
+  set(key: string, value: string, ttl = 60 * 1000): void {
+    const insert = this.db.prepare(
+      'INSERT INTO cache (key, value, ttl) VALUES ($key, $value, $valid) ON CONFLICT(key) DO UPDATE SET value = $value, ttl = $valid'
+    );
+
+    insert.run({
+      $key: key,
+      $value: value,
+      $valid: Date.now() + ttl
+    });
+  }
+
+  get(key: string, defaultValue?: string): string | undefined {
+    const rv = this.db.prepare<{ value: string }, string>(
+      'SELECT value FROM cache WHERE key = ?'
+    ).get(key);
+
+    if (!rv) return defaultValue;
+    return rv.value;
+  }
+
+  has(key: string): CacheStatus {
+    const now = Date.now();
+    const rv = this.db.prepare<{ ttl: number }, string>('SELECT ttl FROM cache WHERE key = ?').get(key);
+
+    return !rv ? CacheStatus.Miss : (rv.ttl > now ? CacheStatus.Hit : CacheStatus.Stale);
+  }
+
+  del(key: string): void {
+    this.db.prepare('DELETE FROM cache WHERE key = ?').run(key);
+  }
+
+  async apply<T>(
+    key: string,
+    fn: () => Promise<T>,
+    opt: CacheApplyOption<T>
+  ): Promise<T> {
+    const { ttl, temporaryBypass } = opt;
+
+    if (temporaryBypass) {
+      return fn();
+    }
+    if (ttl === null) {
+      this.del(key);
+      return fn();
+    }
+
+    const cached = this.get(key);
+    let value: T;
+    if (cached == null) {
+      console.log(picocolors.yellow('[cache] miss'), picocolors.gray(key));
+      value = await fn();
+
+      const serializer = 'serializer' in opt ? opt.serializer : identity;
+      this.set(key, serializer(value), ttl);
+    } else {
+      console.log(picocolors.green('[cache] hit'), picocolors.gray(key));
+
+      const deserializer = 'deserializer' in opt ? opt.deserializer : identity;
+      value = deserializer(cached);
+    }
+    return value;
+  }
+}
+
+export const fsCache = new Cache({ cachePath: path.resolve(import.meta.dir, '../../.cache') });
+
+const separator = String.fromCharCode(0);
+
+export const serializeSet = (set: Set<string>) => Array.from(set).join(separator);
+export const deserializeSet = (str: string) => new Set(str.split(separator));