rasler 0.1.0 → 0.2.0

package/src/storage/local-blobs.js

@@ -0,0 +1,19 @@
+import {
+  writeContent, readContent, readContentFromPath,
+  readContentStream, readContentStreamFromPath, deleteContent,
+} from './files.js';
+
+export function makeLocalBlobs(dataDir) {
+  return {
+    put: (cid, bytes) => { writeContent(dataDir, cid, bytes); },
+    get: (cid, meta) => {
+      if (meta?.source_path) return readContentFromPath(meta.source_path);
+      return readContent(dataDir, cid);
+    },
+    getStream: (cid, meta) => {
+      if (meta?.source_path) return readContentStreamFromPath(meta.source_path);
+      return readContentStream(dataDir, cid);
+    },
+    delete: (cid) => { deleteContent(dataDir, cid); },
+  };
+}

package/src/storage/local-db.js

@@ -0,0 +1,39 @@
+import {
+  dbPutContent, dbGetContent, dbHasContent, dbListContent, dbDeleteContent,
+  dbRecordRequest, dbSetPinned, dbGetTotalPoolSize, dbGetTotalPinnedSize,
+  dbCountPinned, dbCountContent, dbListContentPage,
+  dbSetMountPoint, dbDeleteMountPoint, dbListMountPoints,
+  dbPutStaticContent, dbGetContentBySourcePath, dbListStaticContent,
+} from './db.js';
+
+export function makeLocalDb(db) {
+  return {
+    putContent: (cid, opts) => { dbPutContent(db, cid, opts); },
+    getContent: (cid) => dbGetContent(db, cid),
+    hasContent: (cid) => dbHasContent(db, cid),
+    listContent: () => dbListContent(db),
+    countContent: () => dbCountContent(db),
+    listContentPage: (limit, cursor) => dbListContentPage(db, limit, cursor),
+    deleteContent: (cid) => { dbDeleteContent(db, cid); },
+    recordRequest: (cid) => { dbRecordRequest(db, cid); },
+    setPinned: (cid, pinned) => { dbSetPinned(db, cid, pinned); },
+    getTotalPoolSize: () => dbGetTotalPoolSize(db),
+    getTotalPinnedSize: () => dbGetTotalPinnedSize(db),
+    countPinned: () => dbCountPinned(db),
+    findEvictionCandidate: () => {
+      const row = db.prepare(`
+        SELECT cid FROM content
+        WHERE pinned = 0
+        ORDER BY last_requested ASC NULLS FIRST
+        LIMIT 1
+      `).get();
+      return row?.cid ?? null;
+    },
+    putStaticContent: (cid, opts) => { dbPutStaticContent(db, cid, opts); },
+    getContentBySourcePath: (sourcePath) => dbGetContentBySourcePath(db, sourcePath),
+    listStaticContent: () => dbListStaticContent(db),
+    setMountPoint: (hostname, mountPath, maslCid) => { dbSetMountPoint(db, hostname, mountPath, maslCid); },
+    deleteMountPoint: (hostname, mountPath) => { dbDeleteMountPoint(db, hostname, mountPath); },
+    listMountPoints: () => dbListMountPoints(db),
+  };
+}

package/src/storage/store.js

@@ -1,36 +1,14 @@
-import {
-  dbPutContent, dbGetContent, dbHasContent, dbListContent, dbDeleteContent,
-  dbRecordRequest, dbSetPinned, dbGetTotalPoolSize, dbGetTotalPinnedSize,
-  dbCountPinned, dbCountContent, dbListContentPage,
-  dbSetMountPoint, dbDeleteMountPoint, dbListMountPoints,
-} from './db.js';
 import { sortMountPoints } from '../util/parseJsonConfig.js';
-import {
-  writeContent, readContent, readContentFromPath,
-  readContentStream, readContentStreamFromPath, deleteContent,
-} from './files.js';
 import { realpathSync } from 'fs';
 import { sep } from 'path';
 
-// Default eviction policy: oldest unpinned by last_requested (LRU).
-// An overlay can supply a network-aware policy that considers
-// replica counts and primary-holder status.
-function defaultFindEvictionCandidate(store) {
-  const row = store.db.prepare(`
-    SELECT cid FROM content
-    WHERE pinned = 0
-    ORDER BY last_requested ASC NULLS FIRST
-    LIMIT 1
-  `).get();
-  return row?.cid ?? null;
-}
-
 export class Store {
-  constructor(db, dataDir, totalCapacity, { findEvictionCandidate, staticRoots = [] } = {}) {
+  // db: DbAdapter (see local-db.js for the interface)
+  // blobs: BlobBackend (see local-blobs.js for the interface)
+  constructor(db, blobs, totalCapacity, { staticRoots = [] } = {}) {
     this.db = db;
-    this.dataDir = dataDir;
+    this.blobs = blobs;
     this.totalCapacity = totalCapacity;
-    this._findEvictionCandidate = findEvictionCandidate ?? defaultFindEvictionCandidate;
     // Pre-resolve static roots once so symlink checks at serve time are fast.
     this._realStaticRoots = staticRoots.map(r => {
       const dir = typeof r === 'string' ? r : r.directory;
@@ -38,41 +16,43 @@ export class Store {
     });
     // Populated by indexStaticRoot after each root is indexed. Maps realpath → maslCid.
     this.staticRootMasls = new Map();
-    // Runtime mount point mappings set via operator API. Persisted in SQLite.
+    // Runtime mount point mappings set via operator API. Persisted in the db adapter.
     // Array of {hostname, prefix, maslCid} — hostname='' means any host.
-    // Sorted: longer prefix first; equal prefix: specific hostname before wildcard.
-    // Takes priority over staticRootMasls in mount-point routing.
-    const runtimeRows = dbListMountPoints(db)
-      .map(row => ({ hostname: row.hostname, prefix: row.mount_path, maslCid: row.masl_cid }));
-    sortMountPoints(runtimeRows);
-    this.runtimeMountPoints = runtimeRows;
-  }
-
-  putContent(cid, bytes, { maslCid = null, pinned = false } = {}) {
-    writeContent(this.dataDir, cid, bytes);
-    dbPutContent(this.db, cid, {
-      maslCid,
-      size: bytes.length,
-      pinned,
-      lastRequested: null,
-    });
+    // Callers that use an async db adapter must call store.loadMountPoints() after construction.
+    const mpResult = db.listMountPoints();
+    const rows = Array.isArray(mpResult)
+      ? mpResult
+      : []; // async adapters return a Promise; callers must await loadMountPoints()
+    this.runtimeMountPoints = rows.map(
+      row => ({ hostname: row.hostname, prefix: row.mount_path, maslCid: row.masl_cid })
+    );
+    sortMountPoints(this.runtimeMountPoints);
+  }
+
+  // Must be called after construction when using an async db adapter (e.g. D1).
+  async loadMountPoints() {
+    const rows = await this.db.listMountPoints();
+    this.runtimeMountPoints = rows.map(
+      row => ({ hostname: row.hostname, prefix: row.mount_path, maslCid: row.masl_cid })
+    );
+    sortMountPoints(this.runtimeMountPoints);
   }
 
-  getContent(cid) {
-    const meta = dbGetContent(this.db, cid);
+  async putContent(cid, bytes, { maslCid = null, pinned = false } = {}) {
+    await this.blobs.put(cid, bytes);
+    await this.db.putContent(cid, { maslCid, size: bytes.length, pinned, lastRequested: null });
+  }
+
+  async getContent(cid) {
+    const meta = await this.db.getContent(cid);
     if (!meta) return null;
-    const bytes = meta.source_path
-      ? readContentFromPath(meta.source_path)
-      : readContent(this.dataDir, cid);
+    const bytes = await this.blobs.get(cid, meta);
     if (!bytes) return null;
     return { bytes, meta };
   }
 
-  // Returns { stream: ReadStream, meta } for efficient large-file serving,
-  // or null if the content is unavailable. For static entries, verifies
-  // that source_path still resolves to a path under a configured static root.
-  getContentStream(cid) {
-    const meta = dbGetContent(this.db, cid);
+  async getContentStream(cid) {
+    const meta = await this.db.getContent(cid);
     if (!meta) return null;
     if (meta.source_path) {
       let realFile;
@@ -81,72 +61,66 @@ export class Store {
         root => realFile === root || realFile.startsWith(root + sep)
       );
       if (!allowed) return null;
-      const stream = readContentStreamFromPath(meta.source_path);
-      if (!stream) return null;
-      return { stream, meta };
     }
-    const stream = readContentStream(this.dataDir, cid);
+    const stream = await this.blobs.getStream(cid, meta);
     if (!stream) return null;
     return { stream, meta };
   }
 
-  getContentMeta(cid) {
-    return dbGetContent(this.db, cid);
+  async getContentMeta(cid) {
+    return this.db.getContent(cid);
   }
 
-  hasContent(cid) {
-    return dbHasContent(this.db, cid);
+  async hasContent(cid) {
+    return this.db.hasContent(cid);
   }
 
-  listContent() {
-    return dbListContent(this.db);
+  async listContent() {
+    return this.db.listContent();
   }
 
-  countContent() {
-    return dbCountContent(this.db);
+  async countContent() {
+    return this.db.countContent();
   }
 
-  listContentPage(limit, cursor) {
-    return dbListContentPage(this.db, limit, cursor);
+  async listContentPage(limit, cursor) {
+    return this.db.listContentPage(limit, cursor);
   }
 
-  deleteContent(cid) {
-    const meta = dbGetContent(this.db, cid);
-    // Static content: bytes live on operator's filesystem; only remove the DB record.
-    if (!meta?.source_path) deleteContent(this.dataDir, cid);
-    dbDeleteContent(this.db, cid);
+  async deleteContent(cid) {
+    const meta = await this.db.getContent(cid);
+    if (!meta?.source_path) await this.blobs.delete(cid);
+    await this.db.deleteContent(cid);
   }
 
-  recordRequest(cid) {
-    dbRecordRequest(this.db, cid);
+  async recordRequest(cid) {
+    await this.db.recordRequest(cid);
   }
 
-  setPinned(cid, pinned) {
-    dbSetPinned(this.db, cid, pinned);
+  async setPinned(cid, pinned) {
+    await this.db.setPinned(cid, pinned);
   }
 
-  getPoolUsed() {
-    return dbGetTotalPoolSize(this.db);
+  async getPoolUsed() {
+    return this.db.getTotalPoolSize();
   }
 
-  getPinnedUsed() {
-    return dbGetTotalPinnedSize(this.db);
+  async getPinnedUsed() {
+    return this.db.getTotalPinnedSize();
   }
 
-  getPoolAvailable() {
-    return Math.max(0, this.totalCapacity - this.getPoolUsed() - this.getPinnedUsed());
+  async getPoolAvailable() {
+    const pool = await this.db.getTotalPoolSize();
+    const pinned = await this.db.getTotalPinnedSize();
+    return Math.max(0, this.totalCapacity - pool - pinned);
   }
 
-  countPinned() {
-    return dbCountPinned(this.db);
+  async countPinned() {
+    return this.db.countPinned();
   }
 
-  // Evicts one CID if needed to free requiredBytes. Returns true if eviction
-  // was performed or not needed, false if impossible. The eviction policy is
-  // injected via the constructor; replica-row cleanup happens automatically
-  // via FK cascade on the replicas table.
-  setMountPoint(hostname, prefix, maslCid) {
-    dbSetMountPoint(this.db, hostname, prefix, maslCid);
+  async setMountPoint(hostname, prefix, maslCid) {
+    await this.db.setMountPoint(hostname, prefix, maslCid);
     this.runtimeMountPoints = this.runtimeMountPoints.filter(
       mp => !(mp.hostname === hostname && mp.prefix === prefix)
     );
@@ -154,18 +128,31 @@ export class Store {
     sortMountPoints(this.runtimeMountPoints);
   }
 
-  deleteMountPoint(hostname, prefix) {
-    dbDeleteMountPoint(this.db, hostname, prefix);
+  async deleteMountPoint(hostname, prefix) {
+    await this.db.deleteMountPoint(hostname, prefix);
     this.runtimeMountPoints = this.runtimeMountPoints.filter(
       mp => !(mp.hostname === hostname && mp.prefix === prefix)
     );
   }
 
-  evictIfNeeded(requiredBytes) {
-    if (this.getPoolAvailable() >= requiredBytes) return true;
-    const cid = this._findEvictionCandidate(this);
+  async evictIfNeeded(requiredBytes) {
+    if (await this.getPoolAvailable() >= requiredBytes) return true;
+    const cid = await this.db.findEvictionCandidate();
     if (!cid) return false;
-    this.deleteContent(cid);
+    await this.deleteContent(cid);
     return true;
   }
+
+  // Static-content methods (local Node.js deployment only).
+  async putStaticContent(cid, opts) {
+    await this.db.putStaticContent(cid, opts);
+  }
+
+  async getContentBySourcePath(sourcePath) {
+    return this.db.getContentBySourcePath(sourcePath);
+  }
+
+  async listStaticContent() {
+    return this.db.listStaticContent();
+  }
 }