@rocksky/sdk 0.12.0 → 0.14.0

package/dist/index.js

@@ -19,11 +19,13 @@ var RockskyError;
 var init_errors = __esm(() => {
   RockskyError = class RockskyError extends Error {
     kind;
-    constructor(payload) {
+    status;
+    constructor(payload, status) {
       const p = payload;
       super(p?.message || p?.error || "rocksky request failed");
       this.name = "RockskyError";
       this.kind = p?.error;
+      this.status = status;
     }
   };
 });
@@ -42,7 +44,7 @@ class RockskyLibrary {
     }
     const res = await this.rpc.get(nsid, { params: clean });
     if (!res.ok)
-      throw new RockskyError(res.data);
+      throw new RockskyError(res.data, res.status);
     return res.data;
   }
   async procedure(nsid, input) {
@@ -53,7 +55,7 @@ class RockskyLibrary {
     }
     const res = await this.rpc.post(nsid, { input: clean });
     if (!res.ok)
-      throw new RockskyError(res.data);
+      throw new RockskyError(res.data, res.status);
     return res.data;
   }
   ping() {
@@ -230,7 +232,7 @@ class RockskyClient {
     }
     const res = await this.rpc.get(nsid, { params: clean });
     if (!res.ok)
-      throw new RockskyError(res.data);
+      throw new RockskyError(res.data, res.status);
     return res.data;
   }
   profile(actor) {
@@ -247,6 +249,20 @@ class RockskyClient {
   get(nsid, params = {}) {
     return this.query(nsid, params);
   }
+  async post(nsid, opts = {}) {
+    const clean = {};
+    for (const [k, v] of Object.entries(opts.params ?? {})) {
+      if (v !== undefined && v !== "")
+        clean[k] = v;
+    }
+    const call = { params: clean };
+    if (opts.body !== undefined)
+      call.input = opts.body;
+    const res = await this.rpc.post(nsid, call);
+    if (!res.ok)
+      throw new RockskyError(res.data, res.status);
+    return res.data;
+  }
   async songs(actor, limit = 50, offset = 0) {
     const out = await this.query("app.rocksky.actor.getActorSongs", {
       did: actor,
@@ -297,27 +313,30 @@ class RockskyClient {
     });
     return out.artists ?? [];
   }
-  async catalogAlbums(limit = 50, offset = 0, genre) {
+  async catalogAlbums(limit = 50, offset = 0, genre, filter) {
     const out = await this.query("app.rocksky.album.getAlbums", {
       limit,
       offset,
-      genre
+      genre,
+      filter: filter?.toString()
     });
     return out.albums ?? [];
   }
-  async catalogArtists(limit = 50, offset = 0, genre) {
+  async catalogArtists(limit = 50, offset = 0, genre, filter) {
     const out = await this.query("app.rocksky.artist.getArtists", {
       limit,
       offset,
-      genre
+      genre,
+      filter: filter?.toString()
     });
     return out.artists ?? [];
   }
-  async catalogSongs(limit = 50, offset = 0, genre) {
+  async catalogSongs(limit = 50, offset = 0, genre, filter) {
     const out = await this.query("app.rocksky.song.getSongs", {
       limit,
       offset,
-      genre
+      genre,
+      filter: filter?.toString()
     });
     return out.tracks ?? [];
   }
@@ -337,12 +356,13 @@ class RockskyClient {
     });
     return out.tracks ?? [];
   }
-  async scrobbleFeed(did, following = false, limit = 50, offset = 0) {
+  async scrobbleFeed(did, following = false, limit = 50, offset = 0, filter) {
     const out = await this.query("app.rocksky.scrobble.getScrobbles", {
       did,
       following,
       limit,
-      offset
+      offset,
+      filter: filter?.toString()
     });
     return out.scrobbles ?? [];
   }
@@ -485,9 +505,24 @@ class RockskyClient {
       input: ids && ids.length ? { ids } : {}
     });
     if (!res.ok)
-      throw new RockskyError(res.data);
+      throw new RockskyError(res.data, res.status);
     return res.data;
   }
+  followAccount(account) {
+    return this.post("app.rocksky.graph.followAccount", { params: { account } });
+  }
+  unfollowAccount(account) {
+    return this.post("app.rocksky.graph.unfollowAccount", { params: { account } });
+  }
+  createScrobble(input) {
+    return this.post("app.rocksky.scrobble.createScrobble", { body: input });
+  }
+  putMirrorSource(input) {
+    return this.post("app.rocksky.mirror.putMirrorSource", { body: input });
+  }
+  putAudioSettings(input) {
+    return this.post("app.rocksky.rockbox.putAudioSettings", { body: input });
+  }
 }
 var Interval, DEFAULT_APPVIEW = "https://api.rocksky.app";
 var init_client = __esm(() => {
@@ -741,7 +776,7 @@ class Agent {
       input: { repo: this.did, collection, record: { ...record, $type: collection } }
     });
     if (!res.ok)
-      throw new RockskyError(res.data);
+      throw new RockskyError(res.data, res.status);
     return res.data.uri;
   }
   async putRecord(collection, rkey, record) {
@@ -750,7 +785,7 @@ class Agent {
       input: { repo: this.did, collection, rkey, record: { ...record, $type: collection } }
     });
     if (!res.ok)
-      throw new RockskyError(res.data);
+      throw new RockskyError(res.data, res.status);
     return res.data.uri;
   }
   async delete(collection, rkey) {
@@ -759,7 +794,7 @@ class Agent {
       input: { repo: this.did, collection, rkey }
     });
     if (!res.ok)
-      throw new RockskyError(res.data);
+      throw new RockskyError(res.data, res.status);
   }
   async scrobble(rec) {
     const record = { ...rec, createdAt: rec.createdAt || nowISO() };
@@ -900,200 +935,6 @@ class Agent {
     return this.delete(C_STATUS, "self");
   }
 }
-// src/dedup.ts
-import { fromUint8Array } from "@atcute/car";
-import { decode as cborDecode, fromBytes, isBytes, isCidLink } from "@atcute/cbor";
-import { toString as cidToString } from "@atcute/cid";
-import { ClassicLevel } from "classic-level";
-
-// src/hash.ts
-import { createHash } from "node:crypto";
-function sha256Lower(s) {
-  return createHash("sha256").update(s.toLowerCase()).digest("hex");
-}
-function songHash(title, artist, album) {
-  return sha256Lower(`${title} - ${artist} - ${album}`);
-}
-function albumHash(album, albumArtist) {
-  return sha256Lower(`${album} - ${albumArtist}`);
-}
-function artistHash(albumArtist) {
-  return sha256Lower(albumArtist);
-}
-
-// src/dedup.ts
-var C_ARTIST2 = "app.rocksky.artist";
-var C_ALBUM2 = "app.rocksky.album";
-var C_SONG2 = "app.rocksky.song";
-var C_SCROBBLE2 = "app.rocksky.scrobble";
-var SEP = "\x00";
-function totalIndexed(s) {
-  return s.artists + s.albums + s.songs + s.scrobbles;
-}
-function identKey(did, col, hash) {
-  return `${did}${SEP}${col}${SEP}${hash}`;
-}
-function scrobbleKey(did, songH, secs) {
-  return `${did}${SEP}${C_SCROBBLE2}${SEP}${songH}${SEP}${secs}`;
-}
-function primaryFor(did, col, rec) {
-  const s = (k) => typeof rec[k] === "string" ? rec[k] : "";
-  switch (col) {
-    case C_ARTIST2:
-      return s("name") ? identKey(did, C_ARTIST2, artistHash(s("name"))) : undefined;
-    case C_ALBUM2:
-      return s("title") && s("artist") ? identKey(did, C_ALBUM2, albumHash(s("title"), s("artist"))) : undefined;
-    case C_SONG2:
-      return s("title") && s("artist") && s("album") ? identKey(did, C_SONG2, songHash(s("title"), s("artist"), s("album"))) : undefined;
-    case C_SCROBBLE2: {
-      if (s("title") && s("artist") && s("album") && s("createdAt")) {
-        const secs = Math.floor(Date.parse(s("createdAt")) / 1000);
-        if (!Number.isNaN(secs))
-          return scrobbleKey(did, songHash(s("title"), s("artist"), s("album")), secs);
-      }
-      return;
-    }
-  }
-  return;
-}
-
-class RockskyIndex {
-  db;
-  constructor(path) {
-    this.db = new ClassicLevel(path, { keyEncoding: "utf8", valueEncoding: "utf8" });
-  }
-  open() {
-    return this.db.open();
-  }
-  close() {
-    return this.db.close();
-  }
-  async get(key) {
-    try {
-      return await this.db.get(key);
-    } catch {
-      return;
-    }
-  }
-  songUri(did, title, artist, album) {
-    return this.get(identKey(did, C_SONG2, songHash(title, artist, album)));
-  }
-  albumUri(did, album, albumArtist) {
-    return this.get(identKey(did, C_ALBUM2, albumHash(album, albumArtist)));
-  }
-  artistUri(did, albumArtist) {
-    return this.get(identKey(did, C_ARTIST2, artistHash(albumArtist)));
-  }
-  scrobbleUri(did, title, artist, album, secs) {
-    return this.get(scrobbleKey(did, songHash(title, artist, album), secs));
-  }
-  async putPrimary(did, col, primary, uri) {
-    const rkey = uri.slice(uri.lastIndexOf("/") + 1);
-    await this.db.batch([
-      { type: "put", key: primary, value: uri },
-      { type: "put", key: `${SEP}rk${SEP}${did}${SEP}${col}${SEP}${rkey}`, value: primary }
-    ]);
-  }
-  recordSong(did, title, artist, album, uri) {
-    return this.putPrimary(did, C_SONG2, identKey(did, C_SONG2, songHash(title, artist, album)), uri);
-  }
-  recordAlbum(did, album, albumArtist, uri) {
-    return this.putPrimary(did, C_ALBUM2, identKey(did, C_ALBUM2, albumHash(album, albumArtist)), uri);
-  }
-  recordArtist(did, albumArtist, uri) {
-    return this.putPrimary(did, C_ARTIST2, identKey(did, C_ARTIST2, artistHash(albumArtist)), uri);
-  }
-  recordScrobble(did, title, artist, album, secs, uri) {
-    return this.putPrimary(did, C_SCROBBLE2, scrobbleKey(did, songHash(title, artist, album), secs), uri);
-  }
-  cursor(did) {
-    return this.get(`${SEP}meta${SEP}cursor${SEP}${did}`).then((v) => v ? Number(v) : 0);
-  }
-  async setCursor(did, timeUS) {
-    await this.db.put(`${SEP}meta${SEP}cursor${SEP}${did}`, String(timeUS));
-  }
-  async indexCar(did, car) {
-    const reader = fromUint8Array(car);
-    const blocks = new Map;
-    for (const entry of reader)
-      blocks.set(cidToString(entry.cid), entry.bytes);
-    const root = reader.roots[0];
-    if (!root)
-      throw new Error("CAR has no root");
-    const commit = cborDecode(blocks.get(root.$link));
-    const stats = { artists: 0, albums: 0, songs: 0, scrobbles: 0 };
-    const ops = [];
-    for (const [path, valueLink] of walkMst(blocks, commit.data.$link)) {
-      const slash = path.indexOf("/");
-      if (slash < 0)
-        continue;
-      const col = path.slice(0, slash);
-      const rkey = path.slice(slash + 1);
-      if (col !== C_ARTIST2 && col !== C_ALBUM2 && col !== C_SONG2 && col !== C_SCROBBLE2)
-        continue;
-      const recBytes = blocks.get(valueLink);
-      if (!recBytes)
-        continue;
-      const rec = cborDecode(recBytes);
-      const primary = primaryFor(did, col, rec);
-      if (!primary)
-        continue;
-      const uri = `at://${did}/${col}/${rkey}`;
-      ops.push({ type: "put", key: primary, value: uri });
-      ops.push({ type: "put", key: `${SEP}rk${SEP}${did}${SEP}${col}${SEP}${rkey}`, value: primary });
-      if (col === C_ARTIST2)
-        stats.artists++;
-      else if (col === C_ALBUM2)
-        stats.albums++;
-      else if (col === C_SONG2)
-        stats.songs++;
-      else
-        stats.scrobbles++;
-    }
-    if (commit.rev)
-      ops.push({ type: "put", key: `${SEP}meta${SEP}rev${SEP}${did}`, value: commit.rev });
-    await this.db.batch(ops);
-    return stats;
-  }
-  async applyCommit(did, col, operation, rkey, record) {
-    if (operation === "create" || operation === "update") {
-      if (!record)
-        return;
-      const primary = primaryFor(did, col, record);
-      if (!primary)
-        return;
-      await this.putPrimary(did, col, primary, `at://${did}/${col}/${rkey}`);
-    } else if (operation === "delete") {
-      const rk = `${SEP}rk${SEP}${did}${SEP}${col}${SEP}${rkey}`;
-      const primary = await this.get(rk);
-      if (primary) {
-        await this.db.batch([
-          { type: "del", key: primary },
-          { type: "del", key: rk }
-        ]);
-      }
-    }
-  }
-}
-function* walkMst(blocks, cid) {
-  const raw = blocks.get(cid);
-  if (!raw)
-    return;
-  const node = cborDecode(raw);
-  if (node.l && isCidLink(node.l))
-    yield* walkMst(blocks, node.l.$link);
-  let last = new Uint8Array(0);
-  for (const e of node.e) {
-    const suffix = isBytes(e.k) ? fromBytes(e.k) : e.k;
-    const key = new Uint8Array(e.p + suffix.length);
-    key.set(last.subarray(0, e.p), 0);
-    key.set(suffix, e.p);
-    yield [new TextDecoder().decode(key), e.v.$link];
-    last = key;
-    if (e.t && isCidLink(e.t))
-      yield* walkMst(blocks, e.t.$link);
-  }
-}
 // src/remote-player.ts
 var DEFAULT_REMOTE_WS = "wss://api.rocksky.app/ws";
 
@@ -1606,26 +1447,176 @@ function deviceFromJson(d) {
     queue: (d.queue?.queue ?? []).map(queueItemFromJson)
   };
 }
+// src/filter.ts
+var SAFE_VALUE = /^[A-Za-z0-9_.:@*+-]+$/;
+var renderValue = (value) => {
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (value.length > 0 && SAFE_VALUE.test(value))
+    return value;
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+};
+
+class Filter {
+  expr;
+  kind;
+  constructor(expr, kind) {
+    this.expr = expr;
+    this.kind = kind;
+  }
+  static comparison(field, op, value) {
+    return new Filter(`${field}${op}${renderValue(value)}`, "comparison");
+  }
+  static list(field, op, values) {
+    if (values.length === 0) {
+      throw new Error(`Filter.${op === "=in=" ? "in" : "out"}("${field}", ...) needs at least one value`);
+    }
+    return new Filter(`${field}${op}(${values.map(renderValue).join(",")})`, "comparison");
+  }
+  static eq(field, value) {
+    return Filter.comparison(field, "==", value);
+  }
+  static ne(field, value) {
+    return Filter.comparison(field, "!=", value);
+  }
+  static gt(field, value) {
+    return Filter.comparison(field, "=gt=", value);
+  }
+  static ge(field, value) {
+    return Filter.comparison(field, "=ge=", value);
+  }
+  static lt(field, value) {
+    return Filter.comparison(field, "=lt=", value);
+  }
+  static le(field, value) {
+    return Filter.comparison(field, "=le=", value);
+  }
+  static in(field, values) {
+    return Filter.list(field, "=in=", values);
+  }
+  static out(field, values) {
+    return Filter.list(field, "=out=", values);
+  }
+  static isNull(field) {
+    return new Filter(`${field}==null`, "comparison");
+  }
+  static isNotNull(field) {
+    return new Filter(`${field}!=null`, "comparison");
+  }
+  and(other) {
+    return new Filter(`${this.renderIn("and")};${other.renderIn("and")}`, "and");
+  }
+  or(other) {
+    return new Filter(`${this.expr},${other.expr}`, "or");
+  }
+  renderIn(parent) {
+    return this.kind === "or" ? `(${this.expr})` : this.expr;
+  }
+  build() {
+    return this.expr;
+  }
+  toString() {
+    return this.expr;
+  }
+}
+var SongFields = {
+  title: "title",
+  artist: "artist",
+  album: "album",
+  albumArtist: "albumArtist",
+  genre: "genre",
+  composer: "composer",
+  label: "label",
+  duration: "duration",
+  trackNumber: "trackNumber",
+  discNumber: "discNumber",
+  mbId: "mbId",
+  isrc: "isrc",
+  sha256: "sha256",
+  uri: "uri",
+  albumUri: "albumUri",
+  artistUri: "artistUri",
+  createdAt: "createdAt"
+};
+var AlbumFields = {
+  title: "title",
+  artist: "artist",
+  year: "year",
+  releaseDate: "releaseDate",
+  sha256: "sha256",
+  uri: "uri",
+  artistUri: "artistUri",
+  createdAt: "createdAt"
+};
+var ArtistFields = {
+  name: "name",
+  genres: "genres",
+  bornIn: "bornIn",
+  born: "born",
+  died: "died",
+  sha256: "sha256",
+  uri: "uri",
+  createdAt: "createdAt"
+};
+var ScrobbleFields = {
+  uri: "uri",
+  date: "date",
+  timestamp: "timestamp",
+  title: "title",
+  artist: "artist",
+  album: "album",
+  trackTitle: "track.title",
+  trackArtist: "track.artist",
+  trackAlbum: "track.album",
+  trackAlbumArtist: "track.albumArtist",
+  trackGenre: "track.genre",
+  trackDuration: "track.duration",
+  trackIsrc: "track.isrc",
+  trackMbId: "track.mbId",
+  userDid: "user.did",
+  userHandle: "user.handle",
+  userDisplayName: "user.displayName",
+  artistName: "artist.name",
+  artistGenres: "artist.genres"
+};
+// src/hash.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
+function sha256Lower(s) {
+  return bytesToHex(sha256(new TextEncoder().encode(s.toLowerCase())));
+}
+function songHash(title, artist, album) {
+  return sha256Lower(`${title} - ${artist} - ${album}`);
+}
+function albumHash(album, albumArtist) {
+  return sha256Lower(`${album} - ${albumArtist}`);
+}
+function artistHash(albumArtist) {
+  return sha256Lower(albumArtist);
+}
 
 // src/index.ts
 init_errors();
 export {
   Agent,
+  AlbumFields,
+  ArtistFields,
   DEFAULT_APPVIEW,
   DEFAULT_JETSTREAM_SERVERS,
   DEFAULT_MATCH_SONG_PER_HOUR,
   DEFAULT_REMOTE_WS,
+  Filter,
   Interval,
   MAX_SAFE_WRITES_PER_HOUR,
   RemoteController,
   RemotePlayer,
   RockskyClient,
   RockskyError,
-  RockskyIndex,
   RockskyLibrary,
+  ScrobbleFields,
+  SongFields,
   albumHash,
   artistHash,
   runJetstream,
-  songHash,
-  totalIndexed
+  songHash
 };

package/dist/remote.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote.d.ts","sourceRoot":"","sources":["../src/remote.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,cAAc,GACpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,gBAAgB,EAChB,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,YAAY,EACjB,KAAK,YAAY,GAClB,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"remote.d.ts","sourceRoot":"","sources":["../src/remote.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,cAAc,GACpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,gBAAgB,EAChB,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,YAAY,EACjB,KAAK,YAAY,GAClB,MAAM,wBAAwB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rocksky/sdk",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "TypeScript SDK for Rocksky — built on atcute: AppView reads, AT Protocol PDS writes (scrobble, like, follow, shout), a local dedup index, and Jetstream real-time sync.",
   "license": "MIT",
   "repository": {
@@ -26,6 +26,11 @@
       "types": "./dist/remote.d.ts",
       "import": "./dist/remote.js",
       "default": "./dist/remote.js"
+    },
+    "./dedup": {
+      "types": "./dist/dedup.d.ts",
+      "import": "./dist/dedup.js",
+      "default": "./dist/dedup.js"
     }
   },
   "files": [
@@ -34,7 +39,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "bun build ./src/index.ts ./src/remote.ts --outdir ./dist --target node --format esm --packages external && bun run build:types",
+    "build": "bun build ./src/index.ts ./src/remote.ts ./src/dedup.ts --outdir ./dist --target node --format esm --packages external && bun run build:types",
     "build:types": "tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
     "test": "bun test",
@@ -69,6 +74,7 @@
     "@atcute/identity": "^2.0.2",
     "@atcute/identity-resolver": "^2.0.1",
     "@atcute/password-session": "^1.0.2",
+    "@noble/hashes": "^2.3.0",
     "classic-level": "^3.0.0"
   }
 }

package/src/agent.ts

@@ -325,7 +325,7 @@ export class Agent {
     const res = await this.rpc.post("com.atproto.repo.createRecord" as never, {
       input: { repo: this.did, collection, record: { ...record, $type: collection } },
     } as never);
-    if (!res.ok) throw new RockskyError(res.data);
+    if (!res.ok) throw new RockskyError(res.data, res.status);
     return (res.data as { uri: string }).uri;
   }
 
@@ -334,7 +334,7 @@ export class Agent {
     const res = await this.rpc.post("com.atproto.repo.putRecord" as never, {
       input: { repo: this.did, collection, rkey, record: { ...record, $type: collection } },
     } as never);
-    if (!res.ok) throw new RockskyError(res.data);
+    if (!res.ok) throw new RockskyError(res.data, res.status);
     return (res.data as { uri: string }).uri;
   }
 
@@ -344,7 +344,7 @@ export class Agent {
     const res = await this.rpc.post("com.atproto.repo.deleteRecord" as never, {
       input: { repo: this.did, collection, rkey },
     } as never);
-    if (!res.ok) throw new RockskyError(res.data);
+    if (!res.ok) throw new RockskyError(res.data, res.status);
   }
 
   /**