@rocksky/sdk 0.1.0 → 0.2.1

package/src/http.ts

@@ -2,16 +2,16 @@ import {
   RockskyAuthError,
   RockskyHttpError,
   RockskyTimeoutError,
-} from "./errors";
+} from "./errors.js";
 import {
   type AuthProvider,
   DEFAULT_BASE_URL,
   type FetchLike,
   type RequestOptions,
-} from "./types";
+} from "./types.js";
 
 export type XrpcCallOptions = RequestOptions & {
-  params?: Record<string, unknown>;
+  params?: object;
   body?: unknown;
   requireAuth?: boolean;
 };
@@ -65,11 +65,11 @@ async function resolveAuth(
 }
 
 export function serializeParams(
-  params: Record<string, unknown> | undefined,
+  params: object | undefined,
 ): string {
   if (!params) return "";
   const usp = new URLSearchParams();
-  for (const [k, v] of Object.entries(params)) {
+  for (const [k, v] of Object.entries(params as Record<string, unknown>)) {
     if (v == null) continue;
     if (Array.isArray(v)) {
       for (const item of v) {

package/src/index.ts

@@ -2,13 +2,13 @@ export {
   RockskyClient,
   RockskyClientBuilder,
   createClient,
-} from "./client";
+} from "./client.js";
 export {
   RockskyError,
   RockskyHttpError,
   RockskyTimeoutError,
   RockskyAuthError,
-} from "./errors";
+} from "./errors.js";
 export {
   pipe,
   map,
@@ -18,7 +18,7 @@ export {
   withFallback,
   catchError,
   type Op,
-} from "./pipe";
+} from "./pipe.js";
 export {
   DEFAULT_BASE_URL,
   type AuthProvider,
@@ -27,13 +27,13 @@ export {
   type Json,
   type Pagination,
   type RequestOptions,
-} from "./types";
+} from "./types.js";
 export {
   paginate,
   type PageOpts,
   type PageResult,
   type PaginateArgs,
-} from "./paginate";
+} from "./paginate.js";
 export {
   RealtimeClient,
   RealtimeClientBuilder,
@@ -44,42 +44,42 @@ export {
   type ReconnectOptions,
   type WebSocketCtor,
   type WebSocketLike,
-} from "./realtime";
+} from "./realtime.js";
 
 export type {
   GetProfileParams,
   ActorPagedParams,
   ActorRangeParams,
-} from "./namespaces/actor";
+} from "./namespaces/actor.js";
 export type {
   CreateScrobbleInput,
   GetScrobblesParams,
-} from "./namespaces/scrobble";
+} from "./namespaces/scrobble.js";
 export type {
   GetSongParams,
   GetSongsParams,
   MatchSongParams,
   CreateSongInput,
-} from "./namespaces/song";
-export type { GetAlbumsParams } from "./namespaces/album";
+} from "./namespaces/song.js";
+export type { GetAlbumsParams } from "./namespaces/album.js";
 export type {
   GetArtistsParams,
   ArtistListenersParams,
   GetArtistTracksParams,
-} from "./namespaces/artist";
+} from "./namespaces/artist.js";
 export type {
   ListApikeysParams,
   CreateApikeyInput,
   UpdateApikeyInput,
-} from "./namespaces/apikey";
+} from "./namespaces/apikey.js";
 export type {
   ScrobblesChartParams,
   TopChartParams,
-} from "./namespaces/charts";
+} from "./namespaces/charts.js";
 export type {
   FollowListParams,
   KnownFollowersParams,
-} from "./namespaces/graph";
-export type { RecommendParams } from "./namespaces/feed";
-export type { LikeInput } from "./namespaces/like";
-export type { PutMirrorSourceInput } from "./namespaces/mirror";
+} from "./namespaces/graph.js";
+export type { RecommendParams } from "./namespaces/feed.js";
+export type { LikeInput } from "./namespaces/like.js";
+export type { PutMirrorSourceInput } from "./namespaces/mirror.js";

package/src/namespaces/_helpers.ts

@@ -1,17 +1,27 @@
-import { type HttpClientConfig, xrpcCall } from "../http";
-import type { RequestOptions } from "../types";
+import { type HttpClientConfig, xrpcCall } from "../http.js";
+import type { RequestOptions } from "../types.js";
+import type { Endpoints } from "../generated/types.js";
 
-export type Call = <T>(
-  nsid: string,
-  method: "GET" | "POST",
-  opts?: {
-    params?: Record<string, unknown>;
-    body?: unknown;
-    requireAuth?: boolean;
-  } & RequestOptions,
-) => Promise<T>;
+type CallOpts = {
+  params?: object;
+  body?: unknown;
+  requireAuth?: boolean;
+} & RequestOptions;
+
+export interface Call {
+  <K extends keyof Endpoints>(
+    nsid: K,
+    method: "GET" | "POST",
+    opts?: CallOpts,
+  ): Promise<Endpoints[K]>;
+  <T = unknown>(
+    nsid: string,
+    method: "GET" | "POST",
+    opts?: CallOpts,
+  ): Promise<T>;
+}
 
 export function makeCall(config: HttpClientConfig): Call {
-  return (nsid, method, opts) =>
-    xrpcCall(config, nsid, method, opts ?? {});
+  return ((nsid: string, method: "GET" | "POST", opts?: CallOpts) =>
+    xrpcCall(config, nsid, method, opts ?? {})) as Call;
 }

package/src/namespaces/actor.ts

@@ -1,87 +1,91 @@
-import type { Call } from "./_helpers";
-import type { RequestOptions } from "../types";
+import type {
+  GetActorAlbumsParams,
+  GetActorArtistsParams,
+  GetActorCompatibilityParams,
+  GetActorLovedSongsParams,
+  GetActorNeighboursParams,
+  GetActorPlaylistsParams,
+  GetActorScrobblesParams,
+  GetActorSongsParams,
+  GetProfileParams,
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
-export type GetProfileParams = { did?: string };
-export type DidParam = { did: string };
-export type ActorPagedParams = DidParam & {
-  limit?: number;
-  offset?: number;
-};
-export type ActorRangeParams = ActorPagedParams & {
-  startDate?: string;
-  endDate?: string;
-};
+export type { GetProfileParams };
+export type ActorPagedParams = GetActorScrobblesParams;
+export type ActorRangeParams = GetActorAlbumsParams;
 
 export class ActorNamespace {
   constructor(private readonly call: Call) {}
 
-  getProfile<T = unknown>(params: GetProfileParams = {}, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.actor.getProfile", "GET", {
+  getProfile(params: GetProfileParams = {}, opts?: RequestOptions) {
+    return this.call("app.rocksky.actor.getProfile", "GET", {
       params,
       ...opts,
     });
   }
 
-  getActorAlbums<T = unknown>(params: ActorRangeParams, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.actor.getActorAlbums", "GET", {
+  getActorAlbums(params: GetActorAlbumsParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.actor.getActorAlbums", "GET", {
       params,
       ...opts,
     });
   }
 
-  getActorArtists<T = unknown>(params: ActorRangeParams, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.actor.getActorArtists", "GET", {
+  getActorArtists(params: GetActorArtistsParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.actor.getActorArtists", "GET", {
       params,
       ...opts,
     });
   }
 
-  getActorSongs<T = unknown>(params: ActorRangeParams, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.actor.getActorSongs", "GET", {
+  getActorSongs(params: GetActorSongsParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.actor.getActorSongs", "GET", {
       params,
       ...opts,
     });
   }
 
-  getActorScrobbles<T = unknown>(
-    params: ActorPagedParams,
+  getActorScrobbles(
+    params: GetActorScrobblesParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.actor.getActorScrobbles", "GET", {
+    return this.call("app.rocksky.actor.getActorScrobbles", "GET", {
       params,
       ...opts,
     });
   }
 
-  getActorLovedSongs<T = unknown>(
-    params: ActorPagedParams,
+  getActorLovedSongs(
+    params: GetActorLovedSongsParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.actor.getActorLovedSongs", "GET", {
+    return this.call("app.rocksky.actor.getActorLovedSongs", "GET", {
       params,
       ...opts,
     });
   }
 
-  getActorPlaylists<T = unknown>(
-    params: ActorPagedParams,
+  getActorPlaylists(
+    params: GetActorPlaylistsParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.actor.getActorPlaylists", "GET", {
+    return this.call("app.rocksky.actor.getActorPlaylists", "GET", {
       params,
       ...opts,
     });
   }
 
-  getActorNeighbours<T = unknown>(params: DidParam, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.actor.getActorNeighbours", "GET", {
+  getActorNeighbours(params: GetActorNeighboursParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.actor.getActorNeighbours", "GET", {
       params,
       ...opts,
     });
   }
 
-  getActorCompatibility<T = unknown>(params: DidParam, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.actor.getActorCompatibility", "GET", {
+  getActorCompatibility(params: GetActorCompatibilityParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.actor.getActorCompatibility", "GET", {
       params,
       ...opts,
     });

package/src/namespaces/album.ts

@@ -1,32 +1,32 @@
-import type { Call } from "./_helpers";
-import type { RequestOptions } from "../types";
+import type {
+  GetAlbumParams,
+  GetAlbumsParams,
+  GetAlbumTracksParams,
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
-export type UriParam = { uri: string };
-export type GetAlbumsParams = {
-  limit?: number;
-  offset?: number;
-  genre?: string;
-};
+export type { GetAlbumsParams };
 
 export class AlbumNamespace {
   constructor(private readonly call: Call) {}
 
-  getAlbum<T = unknown>(params: UriParam, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.album.getAlbum", "GET", {
+  getAlbum(params: GetAlbumParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.album.getAlbum", "GET", {
       params,
       ...opts,
     });
   }
 
-  getAlbums<T = unknown>(params: GetAlbumsParams = {}, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.album.getAlbums", "GET", {
+  getAlbums(params: GetAlbumsParams = {}, opts?: RequestOptions) {
+    return this.call("app.rocksky.album.getAlbums", "GET", {
       params,
       ...opts,
     });
   }
 
-  getAlbumTracks<T = unknown>(params: UriParam, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.album.getAlbumTracks", "GET", {
+  getAlbumTracks(params: GetAlbumTracksParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.album.getAlbumTracks", "GET", {
       params,
       ...opts,
     });

package/src/namespaces/apikey.ts

@@ -1,47 +1,47 @@
-import type { Call } from "./_helpers";
-import type { RequestOptions } from "../types";
+import type {
+  CreateApikeyInput,
+  GetApikeysParams,
+  RemoveApikeyParams,
+  UpdateApikeyInput,
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
-export type ListApikeysParams = { limit?: number; offset?: number };
-export type CreateApikeyInput = { name: string; description?: string };
-export type UpdateApikeyInput = {
-  id: string;
-  name: string;
-  description?: string;
-};
-export type RemoveApikeyParams = { id: string };
+export type { CreateApikeyInput, UpdateApikeyInput };
+export type ListApikeysParams = GetApikeysParams;
 
 export class ApikeyNamespace {
   constructor(private readonly call: Call) {}
 
-  getApikeys<T = unknown>(
+  getApikeys(
     params: ListApikeysParams = {},
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.apikey.getApikeys", "GET", {
+    return this.call("app.rocksky.apikey.getApikeys", "GET", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  createApikey<T = unknown>(input: CreateApikeyInput, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.apikey.createApikey", "POST", {
+  createApikey(input: CreateApikeyInput, opts?: RequestOptions) {
+    return this.call("app.rocksky.apikey.createApikey", "POST", {
       body: input,
       requireAuth: true,
       ...opts,
     });
   }
 
-  updateApikey<T = unknown>(input: UpdateApikeyInput, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.apikey.updateApikey", "POST", {
+  updateApikey(input: UpdateApikeyInput, opts?: RequestOptions) {
+    return this.call("app.rocksky.apikey.updateApikey", "POST", {
       body: input,
       requireAuth: true,
       ...opts,
     });
   }
 
-  removeApikey<T = unknown>(params: RemoveApikeyParams, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.apikey.removeApikey", "POST", {
+  removeApikey(params: RemoveApikeyParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.apikey.removeApikey", "POST", {
       params,
       requireAuth: true,
       ...opts,

package/src/namespaces/artist.ts

@@ -1,72 +1,66 @@
-import type { Call } from "./_helpers";
-import type { RequestOptions } from "../types";
+import type {
+  GetArtistAlbumsParams,
+  GetArtistListenersParams,
+  GetArtistParams,
+  GetArtistRecentListenersParams,
+  GetArtistsParams,
+  GetArtistTracksParams,
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
-export type UriParam = { uri: string };
-export type ArtistListenersParams = UriParam & {
-  limit?: number;
-  offset?: number;
-};
-export type GetArtistsParams = {
-  limit?: number;
-  offset?: number;
-  names?: string;
-  genre?: string;
-};
-export type GetArtistTracksParams = {
-  uri?: string;
-  limit?: number;
-  offset?: number;
-};
+export type { GetArtistsParams, GetArtistTracksParams };
+export type ArtistListenersParams = GetArtistListenersParams;
 
 export class ArtistNamespace {
   constructor(private readonly call: Call) {}
 
-  getArtist<T = unknown>(params: UriParam, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.artist.getArtist", "GET", {
+  getArtist(params: GetArtistParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.artist.getArtist", "GET", {
       params,
       ...opts,
     });
   }
 
-  getArtists<T = unknown>(params: GetArtistsParams = {}, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.artist.getArtists", "GET", {
+  getArtists(params: GetArtistsParams = {}, opts?: RequestOptions) {
+    return this.call("app.rocksky.artist.getArtists", "GET", {
       params,
       ...opts,
     });
   }
 
-  getArtistAlbums<T = unknown>(params: UriParam, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.artist.getArtistAlbums", "GET", {
+  getArtistAlbums(params: GetArtistAlbumsParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.artist.getArtistAlbums", "GET", {
       params,
       ...opts,
     });
   }
 
-  getArtistTracks<T = unknown>(
+  getArtistTracks(
     params: GetArtistTracksParams = {},
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.artist.getArtistTracks", "GET", {
+    return this.call("app.rocksky.artist.getArtistTracks", "GET", {
       params,
       ...opts,
     });
   }
 
-  getArtistListeners<T = unknown>(
-    params: ArtistListenersParams,
+  getArtistListeners(
+    params: GetArtistListenersParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.artist.getArtistListeners", "GET", {
+    return this.call("app.rocksky.artist.getArtistListeners", "GET", {
       params,
       ...opts,
     });
   }
 
-  getArtistRecentListeners<T = unknown>(
-    params: ArtistListenersParams,
+  getArtistRecentListeners(
+    params: GetArtistRecentListenersParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.artist.getArtistRecentListeners", "GET", {
+    return this.call("app.rocksky.artist.getArtistRecentListeners", "GET", {
       params,
       ...opts,
     });

package/src/namespaces/charts.ts

@@ -1,45 +1,36 @@
-import type { Call } from "./_helpers";
-import type { RequestOptions } from "../types";
+import type {
+  GetScrobblesChartParams,
+  GetTopArtistsParams,
+  GetTopTracksParams,
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
-export type ScrobblesChartParams = {
-  did?: string;
-  artisturi?: string;
-  albumuri?: string;
-  songuri?: string;
-  genre?: string;
-  from?: string;
-  to?: string;
-};
-
-export type TopChartParams = {
-  limit?: number;
-  offset?: number;
-  startDate?: string;
-  endDate?: string;
-};
+export type ScrobblesChartParams = GetScrobblesChartParams;
+export type TopChartParams = GetTopArtistsParams;
 
 export class ChartsNamespace {
   constructor(private readonly call: Call) {}
 
-  getScrobblesChart<T = unknown>(
+  getScrobblesChart(
     params: ScrobblesChartParams = {},
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.charts.getScrobblesChart", "GET", {
+    return this.call("app.rocksky.charts.getScrobblesChart", "GET", {
       params,
       ...opts,
     });
   }
 
-  getTopArtists<T = unknown>(params: TopChartParams = {}, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.charts.getTopArtists", "GET", {
+  getTopArtists(params: GetTopArtistsParams = {}, opts?: RequestOptions) {
+    return this.call("app.rocksky.charts.getTopArtists", "GET", {
       params,
       ...opts,
     });
   }
 
-  getTopTracks<T = unknown>(params: TopChartParams = {}, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.charts.getTopTracks", "GET", {
+  getTopTracks(params: GetTopTracksParams = {}, opts?: RequestOptions) {
+    return this.call("app.rocksky.charts.getTopTracks", "GET", {
       params,
       ...opts,
     });

package/src/namespaces/dropbox.ts

@@ -1,44 +1,50 @@
-import type { Call } from "./_helpers";
-import type { RequestOptions } from "../types";
+import type {
+  DownloadFileParams,
+  GetFilesParams,
+  GetMetadataParams,
+  GetTemporaryLinkParams,
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
 export class DropboxNamespace {
   constructor(private readonly call: Call) {}
 
-  getFiles<T = unknown>(
-    params: { at?: string } = {},
+  getFiles(
+    params: GetFilesParams = {},
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.dropbox.getFiles", "GET", {
+    return this.call("app.rocksky.dropbox.getFiles", "GET", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  getMetadata<T = unknown>(params: { path: string }, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.dropbox.getMetadata", "GET", {
+  getMetadata(params: GetMetadataParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.dropbox.getMetadata", "GET", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  getTemporaryLink<T = unknown>(
-    params: { path: string },
+  getTemporaryLink(
+    params: GetTemporaryLinkParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.dropbox.getTemporaryLink", "GET", {
+    return this.call("app.rocksky.dropbox.getTemporaryLink", "GET", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  downloadFile<T = unknown>(
-    params: { fileId: string },
+  downloadFile(
+    params: DownloadFileParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.dropbox.downloadFile", "GET", {
+    return this.call("app.rocksky.dropbox.downloadFile", "GET", {
       params,
       requireAuth: true,
       ...opts,