dotrino-content 0.2.0

package/src/blobstore-s3.js

@@ -0,0 +1,177 @@
+/**
+ * El almacén con BUCKET detrás (DISENO.md §15).
+ *
+ * Misma interfaz que `BlobStore` —`put`, `read`, `sizeOf`, `remove`— para que ni la API
+ * local, ni el plano de control, ni el puerto de vistas previas se enteren de dónde
+ * salen los bytes. Lo que cambia es de dónde salen:
+ *
+ *     disco (caché)  →  si está, sale de aquí, y así es como se sirve casi siempre
+ *     bucket         →  si no, se jala mientras se sirve y se deja la copia
+ *
+ * Tres cosas que no son detalles:
+ *
+ *  · **Se escribe primero en local y se responde.** La subida al bucket va detrás, y
+ *    hasta que el bucket confirma, ese blob NO es desalojable (`remote`, §15.11). Un
+ *    pendiente que no logra subir se reintenta y se reporta; no se olvida.
+ *  · **Público y privado son buckets distintos** y con credenciales distintas (§15.1).
+ *    Cuál toca lo dice el ACL del blob, y quien lo sabe es el índice — por eso `put` y
+ *    `upload` reciben `isPublic` en vez de adivinarlo.
+ *  · **Una lectura parcial NO puebla la caché.** Cachear trozos sueltos dejaría
+ *    agujeros que luego parecen un blob completo.
+ */
+import { createWriteStream } from 'node:fs'
+import { mkdir, rename, rm } from 'node:fs/promises'
+import path from 'node:path'
+import { Readable } from 'node:stream'
+import { pipeline } from 'node:stream/promises'
+import { PassThrough } from 'node:stream'
+import { BlobStore, isValidCid } from './blobstore.js'
+import { S3Bucket, S3Error } from './s3.js'
+
+/** Lo que se le pone a un objeto público: es inmutable por construcción (§15.2). */
+const IMMUTABLE = 'public, max-age=31536000, immutable'
+
+/** Del `cid` a la clave del objeto. Sin prefijos: el bucket ya separa público de privado. */
+const keyOf = (cid) => {
+  if (!isValidCid(cid)) throw new Error(`cid inválido: ${cid}`)
+  return cid
+}
+
+export class S3BlobStore {
+  /**
+   * @param {object} o
+   * @param {string} o.root directorio de la CACHÉ (el mismo árbol `blobs/` de siempre)
+   * @param {S3Bucket} o.priv bucket privado (obligatorio: es donde va todo lo cifrado)
+   * @param {S3Bucket|null} [o.pub] bucket público; sin él, lo público viaja por la red (§15.3)
+   * @param {(m:string)=>void} [o.log]
+   */
+  constructor ({ root, priv, pub = null, log = () => {} }) {
+    if (!priv) throw new Error('S3BlobStore: falta el bucket privado')
+    this.cache = new BlobStore(root)
+    this.priv = priv
+    this.pub = pub
+    this.log = log
+    /** Hay una segunda copia detrás: el GC puede desalojar en vez de destruir (§15.11). */
+    this.backed = true
+  }
+
+  async init () {
+    await this.cache.init()
+    return this
+  }
+
+  /** El bucket que le toca a un blob según su ACL. */
+  bucketFor (isPublic) {
+    if (!isPublic) return this.priv
+    if (!this.pub) throw new Error('este node no tiene bucket público (CONTENT_S3_BUCKET_PUBLIC)')
+    return this.pub
+  }
+
+  /** La URL pública de un blob, o `null` si este node no publica por bucket. */
+  urlFor (cid, baseUrl) {
+    return baseUrl ? `${String(baseUrl).replace(/\/+$/, '')}/${keyOf(cid)}` : null
+  }
+
+  pathFor (cid) { return this.cache.pathFor(cid) }
+
+  /** Guarda en la caché. La subida al bucket la lanza el node después (`upload`). */
+  async put (readable, opts) {
+    return this.cache.put(readable, opts)
+  }
+
+  /**
+   * Sube al bucket que le toca y **confirma**. Quien llama es el único que puede marcar
+   * `remote`, y solo con lo que devuelve esto: marcar al lanzar la subida es
+   * exactamente el error que deja perder contenido.
+   *
+   * @param {string} cid
+   * @param {{ size: number, mime?: string, public?: boolean }} meta
+   */
+  async upload (cid, { size, mime, public: isPublic = false }) {
+    const bucket = this.bucketFor(isPublic)
+    const body = this.cache.read(cid)
+    await bucket.put(keyOf(cid), Readable.toWeb(body), {
+      sha256: cid.slice('sha256-'.length),
+      size,
+      contentType: mime || 'application/octet-stream',
+      // Solo lo público lleva cabecera de caché: es lo único que sirve un CDN.
+      ...(isPublic ? { cacheControl: IMMUTABLE } : {})
+    })
+    return { cid, remote: true }
+  }
+
+  /** ¿Está en la caché de esta máquina? (no pregunta al bucket: eso cuesta una petición) */
+  async sizeOf (cid) {
+    return this.cache.sizeOf(cid)
+  }
+
+  /**
+   * Lee. Si está en la caché sale de ahí; si no, se jala del bucket **mientras se
+   * sirve** y se deja la copia — salvo que sea una lectura parcial.
+   *
+   * Devuelve un stream, como el de disco, para que quien llama no cambie.
+   *
+   * @param {string} cid
+   * @param {{ start: number, end: number }} [range] inclusivo
+   * @param {{ public?: boolean }} [opts] de qué bucket, si hay que ir a buscarlo
+   */
+  read (cid, range, { public: isPublic = false } = {}) {
+    const out = new PassThrough()
+    this.cache.sizeOf(cid).then(async (size) => {
+      if (size !== null) return pipeline(this.cache.read(cid, range), out)
+
+      const bucket = this.bucketFor(isPublic)
+      const { body } = await bucket.get(keyOf(cid), range || null)
+      const src = Readable.fromWeb(/** @type {any} */ (body))
+
+      // Parcial: se sirve y se olvida. Guardar un trozo dejaría en la caché algo que
+      // parece el blob entero y no lo es.
+      if (range) { src.pipe(out); return }
+
+      // Entero: el mismo stream va a DOS destinos —quien pidió y el disco—, y solo al
+      // terminar bien se pone en su sitio. Si la descarga se corta, no queda medio blob
+      // con el nombre bueno, que luego se serviría como si estuviera completo.
+      const dest = this.cache.pathFor(cid)
+      const tmp = dest + '.dl'
+      await mkdir(path.dirname(dest), { recursive: true })
+      const disk = createWriteStream(tmp)
+      src.pipe(out)
+      src.pipe(disk)
+      disk.on('finish', () => { rename(tmp, dest).catch(() => rm(tmp, { force: true })) })
+      src.on('error', () => { disk.destroy(); rm(tmp, { force: true }).catch(() => {}) })
+    }).catch((e) => out.destroy(e))
+    return out
+  }
+
+  /**
+   * Los primeros `n` bytes. Es lo que necesita el puerto público para comprobar el tipo
+   * REAL de una imagen por sus bytes mágicos (§7.2) — y existe en la interfaz porque
+   * con bucket detrás no hay ninguna ruta de disco que abrir.
+   */
+  async readHead (cid, n, { public: isPublic = false } = {}) {
+    const local = await this.cache.sizeOf(cid)
+    if (local !== null) return this.cache.readHead(cid, n)
+    return this.bucketFor(isPublic).head(keyOf(cid), n)
+  }
+
+  /** Suelta la copia local y deja la del bucket (desalojar, §15.11). */
+  async evict (cid) {
+    await this.cache.remove(cid)
+  }
+
+  /** Borra de verdad: de la caché y del bucket. Caducar y despublicar pasan por aquí. */
+  async remove (cid, { public: isPublic = null } = {}) {
+    await this.cache.remove(cid)
+    // Sin saber su ACL se borra de los dos: es idempotente y borrar lo que no está no
+    // es un error. Más vale una petición de más que dejar un objeto huérfano pagando.
+    const buckets = isPublic === null ? [this.priv, this.pub] : [this.bucketFor(isPublic)]
+    for (const b of buckets) {
+      if (!b) continue
+      try { await b.remove(keyOf(cid)) } catch (e) {
+        if (!(e instanceof S3Error) || e.status !== 404) throw e
+      }
+    }
+  }
+}
+
+export default { S3BlobStore }

package/src/blobstore.js

@@ -0,0 +1,139 @@
+/**
+ * Almacén de blobs direccionado por contenido (Fase 1, DISENO.md §3).
+ *
+ * - `cid = sha256-<hex>` (prefijo de algoritmo → extensible a blake3 después).
+ *   Se usa SHA-256 de `node:crypto` porque no requiere dependencias nativas
+ *   (el `.npmrc` del ecosistema bloquea los build scripts de npm).
+ * - Disco: `blobs/<aa>/<bb>/<cid>` (sharding por los 4 primeros hex del hash).
+ * - Escritura por streaming: se hashea MIENTRAS se escribe a un tmp y al final
+ *   se renombra al path definitivo (dedup gratis: si ya existe, se descarta).
+ */
+import { createHash, randomBytes } from 'node:crypto'
+import { createWriteStream, createReadStream } from 'node:fs'
+import { mkdir, open, rename, rm, stat } from 'node:fs/promises'
+import { pipeline } from 'node:stream/promises'
+import { Transform } from 'node:stream'
+import path from 'node:path'
+
+const CID_RE = /^sha256-[0-9a-f]{64}$/
+
+export function isValidCid (cid) {
+  return typeof cid === 'string' && CID_RE.test(cid)
+}
+
+export class BlobStore {
+  /** @param {string} root directorio raíz de datos (contiene blobs/ y tmp/) */
+  constructor (root) {
+    this.root = root
+    this.blobsDir = path.join(root, 'blobs')
+    this.tmpDir = path.join(root, 'tmp')
+    /**
+     * ¿Hay una segunda copia detrás (un bucket)? Aquí no: el disco es la única
+     * copia, así que soltar un blob es destruirlo y el GC se comporta como
+     * siempre (DISENO.md §15.11).
+     */
+    this.backed = false
+  }
+
+  /** Prepara los directorios. Devuelve `this` para poder encadenar, como el resto. */
+  async init () {
+    await mkdir(this.blobsDir, { recursive: true })
+    await mkdir(this.tmpDir, { recursive: true })
+    return this
+  }
+
+  /** Path en disco de un cid (no comprueba existencia). */
+  pathFor (cid) {
+    if (!isValidCid(cid)) throw new Error(`cid inválido: ${cid}`)
+    const hex = cid.slice('sha256-'.length)
+    return path.join(this.blobsDir, hex.slice(0, 2), hex.slice(2, 4), cid)
+  }
+
+  /** ¿Existe el blob en disco? → size o null. */
+  async sizeOf (cid) {
+    try {
+      const st = await stat(this.pathFor(cid))
+      return st.size
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Guarda un stream hasheando al vuelo.
+   * @param {import('node:stream').Readable} readable
+   * @param {{ maxBytes?: number }} [opts] límite duro de tamaño (corta el stream)
+   * @returns {Promise<{ cid: string, size: number, existed: boolean }>}
+   */
+  async put (readable, opts = {}) {
+    const tmp = path.join(this.tmpDir, `up-${randomBytes(8).toString('hex')}`)
+    const hash = createHash('sha256')
+    let size = 0
+    const meter = new Transform({
+      transform (chunk, _enc, cb) {
+        size += chunk.length
+        if (opts.maxBytes && size > opts.maxBytes) {
+          cb(Object.assign(new Error('blob demasiado grande'), { code: 'ETOOBIG' }))
+          return
+        }
+        hash.update(chunk)
+        cb(null, chunk)
+      }
+    })
+    try {
+      await pipeline(readable, meter, createWriteStream(tmp))
+      const cid = `sha256-${hash.digest('hex')}`
+      const dest = this.pathFor(cid)
+      if (await this.sizeOf(cid) !== null) {
+        // dedup: ya lo teníamos, descartar el tmp
+        await rm(tmp, { force: true })
+        return { cid, size, existed: true }
+      }
+      await mkdir(path.dirname(dest), { recursive: true })
+      await rename(tmp, dest)
+      return { cid, size, existed: false }
+    } catch (err) {
+      await rm(tmp, { force: true })
+      throw err
+    }
+  }
+
+  /**
+   * Stream de lectura, con rango opcional [start, end] inclusivo.
+   * @returns {import('node:fs').ReadStream}
+   */
+  read (cid, range) {
+    const p = this.pathFor(cid)
+    return range
+      ? createReadStream(p, { start: range.start, end: range.end })
+      : createReadStream(p)
+  }
+
+  /**
+   * Los primeros `n` bytes de un blob. Existe para que el puerto público compruebe el
+   * tipo REAL de una imagen por sus bytes mágicos (§7.2) **sin abrir el archivo por su
+   * ruta**: con un bucket detrás no hay ruta que abrir, así que olfatear tiene que ser
+   * una operación del almacén y no de quien lo usa.
+   */
+  async readHead (cid, n) {
+    const fh = await open(this.pathFor(cid), 'r')
+    try {
+      const buf = Buffer.alloc(n)
+      const { bytesRead } = await fh.read(buf, 0, n, 0)
+      return buf.subarray(0, bytesRead)
+    } finally { await fh.close() }
+  }
+
+  async remove (cid) {
+    await rm(this.pathFor(cid), { force: true })
+  }
+
+  /**
+   * Suelta la copia LOCAL y deja la de atrás. Sin bucket detrás no hay copia de
+   * atrás, así que esto es exactamente `remove` — y por eso el node comprueba
+   * `backed` antes de llamarlo: con este backend, desalojar es destruir.
+   */
+  async evict (cid) {
+    return this.remove(cid)
+  }
+}

package/src/db.js

@@ -0,0 +1,237 @@
+/**
+ * Índice de metadatos (Fase 1, DISENO.md §3): SQLite embebido de Node
+ * (`node:sqlite`, sin dependencias). Los bytes viven en el BlobStore;
+ * aquí solo `cid, size, mime, createdAt, owner, enc, acl, ttl, pinned…`.
+ */
+import { DatabaseSync } from 'node:sqlite'
+import path from 'node:path'
+
+export class Index {
+  /** @param {string} root directorio raíz de datos */
+  constructor (root) {
+    this.db = new DatabaseSync(path.join(root, 'index.db'))
+    this.db.exec(`
+      PRAGMA journal_mode = WAL;
+      CREATE TABLE IF NOT EXISTS blobs (
+        cid          TEXT PRIMARY KEY,
+        size         INTEGER NOT NULL,
+        mime         TEXT NOT NULL DEFAULT 'application/octet-stream',
+        createdAt    INTEGER NOT NULL,
+        owner        TEXT,
+        enc          INTEGER NOT NULL DEFAULT 0,
+        acl          TEXT,
+        ttl          INTEGER,            -- epoch ms de expiración (NULL = no expira)
+        pinned       INTEGER NOT NULL DEFAULT 0,
+        thumbnailCid TEXT,
+        meta         TEXT               -- JSON de presentación: { name, title, description }
+      );
+      CREATE TABLE IF NOT EXISTS egress (
+        day   TEXT PRIMARY KEY,         -- YYYY-MM-DD (UTC)
+        bytes INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE INDEX IF NOT EXISTS idx_blobs_ttl ON blobs (ttl) WHERE ttl IS NOT NULL;
+      CREATE INDEX IF NOT EXISTS idx_blobs_gc  ON blobs (pinned, createdAt);
+      CREATE INDEX IF NOT EXISTS idx_blobs_acl ON blobs (acl, createdAt);
+    `)
+    // Migración de un índice creado antes de que existiera `meta`: añadir la
+    // columna a una base ya escrita en disco. `ADD COLUMN` con default NULL es
+    // barato y no reescribe la tabla; si ya está, SQLite tira y se ignora.
+    try { this.db.exec('ALTER TABLE blobs ADD COLUMN meta TEXT') } catch (_) { /* ya existía */ }
+
+    // Columnas de la CACHÉ (DISENO.md §15.11). Existen aunque no haya bucket: sin
+    // él, `remote` se queda en 0 y `cached` en 1 para siempre, y nada cambia.
+    //
+    //  · `remote`   — el bucket YA CONFIRMÓ estos bytes. Se pone a 1 con la
+    //                 confirmación, nunca al lanzar la subida: es el cerrojo que
+    //                 impide desalojar algo cuya única copia sigue siendo esta.
+    //  · `cached`   — los bytes están en el disco de esta máquina. Al desalojar se
+    //                 pone a 0 y la FILA SE QUEDA: si se fuera con los bytes, el
+    //                 blob quedaría en el bucket sin dueño, sin ACL y sin tipo.
+    //  · `lastRead` — para desalojar por último acceso y no por antigüedad. Un
+    //                 almacén ordena por edad; una caché, por uso.
+    for (const col of [
+      'remote INTEGER NOT NULL DEFAULT 0',
+      'cached INTEGER NOT NULL DEFAULT 1',
+      'lastRead INTEGER'
+    ]) {
+      try { this.db.exec(`ALTER TABLE blobs ADD COLUMN ${col}`) } catch (_) { /* ya existía */ }
+    }
+    this.db.exec('CREATE INDEX IF NOT EXISTS idx_blobs_evict ON blobs (pinned, cached, remote, lastRead)')
+  }
+
+  upsert ({ cid, size, mime, owner = null, enc = 0, acl = null, ttl = null, meta = null }) {
+    this.db.prepare(`
+      INSERT INTO blobs (cid, size, mime, createdAt, owner, enc, acl, ttl, meta)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT (cid) DO UPDATE SET
+        mime = excluded.mime,
+        ttl  = excluded.ttl,
+        -- Volver a subir los mismos bytes NO borra la presentación que ya tenían.
+        meta = COALESCE(excluded.meta, blobs.meta)
+    `).run(cid, size, mime, Date.now(), owner, enc ? 1 : 0, acl, ttl, meta ? JSON.stringify(meta) : null)
+  }
+
+  get (cid) {
+    return this.db.prepare('SELECT * FROM blobs WHERE cid = ?').get(cid) ?? null
+  }
+
+  list () {
+    return this.db.prepare(
+      'SELECT cid, size, mime, createdAt, owner, enc, acl, ttl, pinned, meta FROM blobs ORDER BY createdAt DESC'
+    ).all()
+  }
+
+  /**
+   * Cambia el `acl` de un blob (`public` | `private`). Devuelve false si no existe.
+   * Se cambia aparte del `upsert` a propósito: volver a subir los mismos bytes NO
+   * debe reabrir ni cerrar un blob por accidente.
+   */
+  setAcl (cid, acl) {
+    const { changes } = this.db.prepare('UPDATE blobs SET acl = ? WHERE cid = ?').run(acl, cid)
+    return changes > 0
+  }
+
+  remove (cid) {
+    this.db.prepare('DELETE FROM blobs WHERE cid = ?').run(cid)
+  }
+
+  setPinned (cid, pinned) {
+    const { changes } = this.db.prepare('UPDATE blobs SET pinned = ? WHERE cid = ?')
+      .run(pinned ? 1 : 0, cid)
+    return changes > 0
+  }
+
+  /** Suma de bytes indexados. @returns {number} */
+  totalBytes () {
+    return Number(this.db.prepare('SELECT COALESCE(SUM(size), 0) AS n FROM blobs').get().n)
+  }
+
+  /** @returns {number} */
+  count () {
+    return Number(this.db.prepare('SELECT COUNT(*) AS n FROM blobs').get().n)
+  }
+
+  /**
+   * Blobs con ttl vencido (candidatos a GC incondicional, aunque estén sin pin).
+   * @returns {{ cid: string, size: number }[]}
+   */
+  expired (now = Date.now()) {
+    return /** @type {{ cid: string, size: number }[]} */ (this.db.prepare(
+      'SELECT cid, size FROM blobs WHERE ttl IS NOT NULL AND ttl <= ? AND pinned = 0'
+    ).all(now))
+  }
+
+  /**
+   * Candidatos a liberar espacio por cuota: no pineados, con bytes en disco, y
+   * **el menos usado primero** (DISENO.md §15.11). `COALESCE(lastRead, createdAt)`
+   * porque lo que nunca se ha leído cuenta por su fecha de subida.
+   *
+   * @param {{ requireRemote?: boolean }} [opts] `requireRemote` lo pone el backend
+   *   con bucket: entonces solo se desaloja lo que el bucket YA confirmó, porque
+   *   desalojar es tirar una copia caliente y sin la otra copia sería destruir.
+   * @returns {{ cid: string, size: number }[]}
+   */
+  evictable ({ requireRemote = false } = {}) {
+    return /** @type {{ cid: string, size: number }[]} */ (this.db.prepare(`
+      SELECT cid, size FROM blobs
+      WHERE pinned = 0 AND cached = 1 ${requireRemote ? 'AND remote = 1' : ''}
+      ORDER BY COALESCE(lastRead, createdAt) ASC
+    `).all())
+  }
+
+  /** Marca que estos bytes ya están confirmados en el bucket. */
+  setRemote (cid, remote = true) {
+    const { changes } = this.db.prepare('UPDATE blobs SET remote = ? WHERE cid = ?')
+      .run(remote ? 1 : 0, cid)
+    return changes > 0
+  }
+
+  /** Marca si los bytes están (o ya no) en el disco de esta máquina. */
+  setCached (cid, cached = true) {
+    const { changes } = this.db.prepare('UPDATE blobs SET cached = ? WHERE cid = ?')
+      .run(cached ? 1 : 0, cid)
+    return changes > 0
+  }
+
+  /** Anota que este blob se acaba de leer (es lo que ordena el desalojo). */
+  touch (cid, now = Date.now()) {
+    this.db.prepare('UPDATE blobs SET lastRead = ? WHERE cid = ?').run(now, cid)
+  }
+
+  /**
+   * Lo que aún NO está confirmado en el bucket: la cola de subida pendiente. Que
+   * esto sea una consulta y no una lista en memoria es a propósito — un reinicio
+   * a media subida no debe perder el pendiente.
+   */
+  pendingUpload (limit = 100) {
+    return /** @type {{ cid: string, size: number }[]} */ (this.db.prepare(
+      'SELECT cid, size FROM blobs WHERE remote = 0 AND cached = 1 ORDER BY createdAt ASC LIMIT ?'
+    ).all(limit))
+  }
+
+  /** Bytes que ocupan disco AQUÍ (la cuota es de la caché, no del inventario). */
+  cachedBytes () {
+    return Number(this.db.prepare('SELECT COALESCE(SUM(size), 0) AS n FROM blobs WHERE cached = 1').get().n)
+  }
+
+  /**
+   * Metadatos de PRESENTACIÓN de un blob (nombre, título, descripción): lo único
+   * que la vista previa pública (§7.3) tiene para armar la tarjeta. Se guarda
+   * aparte de los bytes porque no forma parte del `cid` — dos nombres distintos
+   * para el mismo archivo son el mismo blob.
+   * @param {string} cid
+   * @param {{name?:string,title?:string,description?:string}|null} meta
+   */
+  setMeta (cid, meta) {
+    const { changes } = this.db.prepare('UPDATE blobs SET meta = ? WHERE cid = ?')
+      .run(meta ? JSON.stringify(meta) : null, cid)
+    return changes > 0
+  }
+
+  /**
+   * Enlaza la MINIATURA de un blob (otro blob, con su propio `cid`). El node no
+   * genera miniaturas: las hace la app al subir —el aparato pone el trabajo, que
+   * es el patrón del ecosistema— y aquí solo se anota cuál es.
+   */
+  setThumbnail (cid, thumbnailCid) {
+    const { changes } = this.db.prepare('UPDATE blobs SET thumbnailCid = ? WHERE cid = ?')
+      .run(thumbnailCid, cid)
+    return changes > 0
+  }
+
+  /**
+   * Blobs servibles al mundo: `acl = public` y EN CLARO. Un blob cifrado no sale
+   * por aquí ni marcado público (ops.js ya lo impide al marcarlo, esto es el
+   * segundo cerrojo, en el sitio donde los bytes de verdad salen).
+   */
+  listPublic ({ limit = 100, offset = 0 } = {}) {
+    return this.db.prepare(`
+      SELECT cid, size, mime, createdAt, meta FROM blobs
+      WHERE acl = 'public' AND enc = 0
+      ORDER BY createdAt DESC LIMIT ? OFFSET ?
+    `).all(limit, offset)
+  }
+
+  /**
+   * Contabilidad de EGRESS del modo público (§7.2), por día UTC y persistida: un
+   * techo que se reinicia con el proceso no es un techo — el reinicio es
+   * exactamente lo que pasa cuando algo se descontrola.
+   * @param {number} bytes @param {string} day YYYY-MM-DD
+   */
+  addEgress (bytes, day) {
+    if (!(bytes > 0)) return
+    this.db.prepare(`
+      INSERT INTO egress (day, bytes) VALUES (?, ?)
+      ON CONFLICT (day) DO UPDATE SET bytes = bytes + excluded.bytes
+    `).run(day, Math.round(bytes))
+  }
+
+  /** Bytes servidos ese día. @returns {number} */
+  egressOn (day) {
+    return Number(this.db.prepare('SELECT COALESCE(bytes, 0) AS n FROM egress WHERE day = ?').get(day)?.n || 0)
+  }
+
+  close () {
+    this.db.close()
+  }
+}

package/src/index.js

@@ -0,0 +1,3 @@
+export { ContentNode, isValidCid } from './node.js'
+export { BlobStore } from './blobstore.js'
+export { createServer, parseRange } from './server.js'