@freqhole/api-client 0.1.30

package/src/domains/admin.ts

@@ -0,0 +1,97 @@
+// admin domain methods for FreqholeClient
+// includes knock management endpoints
+
+import { routes } from "../codegen/routes.js";
+import type * as s from "../codegen/schema.js";
+import type { CallFn } from "./types.js";
+
+export function createAdminMethods(call: CallFn) {
+  return {
+    // knock management (admin)
+    listKnocks: () => {
+      return call(
+        "admin", "list_knocks",
+        routes.admin.list_knocks.resp,
+        routes.admin.list_knocks.req,
+        routes.admin.list_knocks.method,
+        routes.admin.list_knocks.path,
+      );
+    },
+
+    listAllKnocks: () => {
+      return call(
+        "admin", "list_all_knocks",
+        routes.admin.list_all_knocks.resp,
+        routes.admin.list_all_knocks.req,
+        routes.admin.list_all_knocks.method,
+        routes.admin.list_all_knocks.path,
+      );
+    },
+
+    getKnock: (params: { id: string }) => {
+      return call(
+        "admin", "get_knock",
+        routes.admin.get_knock.resp,
+        routes.admin.get_knock.req,
+        routes.admin.get_knock.method,
+        routes.admin.get_knock.path,
+        params,
+      );
+    },
+
+    acceptKnock: (params: { id: string } & s.ProcessKnockRequest) => {
+      return call(
+        "admin", "accept_knock",
+        routes.admin.accept_knock.resp,
+        routes.admin.accept_knock.req,
+        routes.admin.accept_knock.method,
+        routes.admin.accept_knock.path,
+        params,
+      );
+    },
+
+    rejectKnock: (params: { id: string }) => {
+      return call(
+        "admin", "reject_knock",
+        routes.admin.reject_knock.resp,
+        routes.admin.reject_knock.req,
+        routes.admin.reject_knock.method,
+        routes.admin.reject_knock.path,
+        params,
+      );
+    },
+
+    deleteKnock: (params: { id: string }) => {
+      return call(
+        "admin", "delete_knock",
+        routes.admin.delete_knock.resp,
+        routes.admin.delete_knock.req,
+        routes.admin.delete_knock.method,
+        routes.admin.delete_knock.path,
+        params,
+      );
+    },
+
+    // public knock endpoints (for P2P access requests)
+    createKnockPublic: (params: s.CreateKnockRequest) => {
+      return call(
+        "admin", "create_knock_public",
+        routes.admin.create_knock_public.resp,
+        routes.admin.create_knock_public.req,
+        routes.admin.create_knock_public.method,
+        routes.admin.create_knock_public.path,
+        params,
+      );
+    },
+
+    getKnockStatusPublic: () => {
+      return call(
+        "admin", "get_knock_status_public",
+        routes.admin.get_knock_status_public.resp,
+        routes.admin.get_knock_status_public.req,
+        routes.admin.get_knock_status_public.method,
+        routes.admin.get_knock_status_public.path,
+      );
+    },
+  };
+}

package/src/domains/app.ts

@@ -0,0 +1,98 @@
+// app domain methods for FreqholeClient
+
+import { routes } from "../codegen/routes.js";
+import type { CallFn } from "./types.js";
+
+export function createAppMethods(call: CallFn) {
+  return {
+    healthCheck: () => {
+      return call(
+        "app", "health_check",
+        routes.app.health_check.resp,
+        routes.app.health_check.req,
+        routes.app.health_check.method,
+        routes.app.health_check.path,
+      );
+    },
+
+    serverInfo: () => {
+      return call(
+        "app", "server_info",
+        routes.app.server_info.resp,
+        routes.app.server_info.req,
+        routes.app.server_info.method,
+        routes.app.server_info.path,
+      );
+    },
+
+    radioInfo: () => {
+      return call(
+        "app", "radio_info",
+        routes.app.radio_info.resp,
+        routes.app.radio_info.req,
+        routes.app.radio_info.method,
+        routes.app.radio_info.path,
+      );
+    },
+
+    radioStations: () => {
+      return call(
+        "app", "radio_stations",
+        routes.app.radio_stations.resp,
+        routes.app.radio_stations.req,
+        routes.app.radio_stations.method,
+        routes.app.radio_stations.path,
+      );
+    },
+
+    // get blob metadata for a station blob
+    radioPublicBlob: (params: { station_id: string; blob_id: string }) => {
+      return call(
+        "app", "radio_public_blob",
+        routes.app.radio_public_blob.resp,
+        routes.app.radio_public_blob.req,
+        routes.app.radio_public_blob.method,
+        routes.app.radio_public_blob.path,
+        params,
+      );
+    },
+
+    // stream the binary data for a station blob
+    radioPublicBlobData: (params: { station_id: string; blob_id: string }) => {
+      return call(
+        "app", "radio_public_blob_data",
+        routes.app.radio_public_blob_data.resp,
+        routes.app.radio_public_blob_data.req,
+        routes.app.radio_public_blob_data.method,
+        routes.app.radio_public_blob_data.path,
+        params,
+      );
+    },
+
+    // get a thumbnail for a station blob at a given size
+    radioPublicBlobThumbnail: (params: { station_id: string; blob_id: string; size: string }) => {
+      return call(
+        "app", "radio_public_blob_thumbnail",
+        routes.app.radio_public_blob_thumbnail.resp,
+        routes.app.radio_public_blob_thumbnail.req,
+        routes.app.radio_public_blob_thumbnail.method,
+        routes.app.radio_public_blob_thumbnail.path,
+        params,
+      );
+    },
+
+    // get the public timeline manifest for a station
+    radioPublicTimeline: (params: { station_id: string }) => {
+      return call(
+        "app", "radio_public_timeline",
+        routes.app.radio_public_timeline.resp,
+        routes.app.radio_public_timeline.req,
+        routes.app.radio_public_timeline.method,
+        routes.app.radio_public_timeline.path,
+        params,
+      );
+    },
+  };
+}
+
+export type AppMethods = ReturnType<typeof createAppMethods>;

package/src/domains/auth.ts

@@ -0,0 +1,191 @@
+// auth domain methods for FreqholeClient
+
+import { routes } from "../codegen/routes.js";
+import type * as s from "../codegen/schema.js";
+import type { CallFn } from "./types.js";
+
+export function createAuthMethods(call: CallFn) {
+  return {
+    registerStart: (params: s.RegisterStartRequest) => {
+      return call(
+        "auth", "register_start",
+        routes.auth.register_start.resp,
+        routes.auth.register_start.req,
+        routes.auth.register_start.method,
+        routes.auth.register_start.path,
+        params,
+      );
+    },
+
+    registerFinish: (params: any) => {
+      return call(
+        "auth", "register_finish",
+        routes.auth.register_finish.resp,
+        routes.auth.register_finish.req,
+        routes.auth.register_finish.method,
+        routes.auth.register_finish.path,
+        params,
+      );
+    },
+
+    loginStart: (params: s.StartLoginRequest) => {
+      return call(
+        "auth", "login_start",
+        routes.auth.login_start.resp,
+        routes.auth.login_start.req,
+        routes.auth.login_start.method,
+        routes.auth.login_start.path,
+        params,
+      );
+    },
+
+    loginFinish: (params: any) => {
+      return call(
+        "auth", "login_finish",
+        routes.auth.login_finish.resp,
+        routes.auth.login_finish.req,
+        routes.auth.login_finish.method,
+        routes.auth.login_finish.path,
+        params,
+      );
+    },
+
+    whoami: () => {
+      return call(
+        "auth", "whoami",
+        routes.auth.whoami.resp,
+        routes.auth.whoami.req,
+        routes.auth.whoami.method,
+        routes.auth.whoami.path,
+      );
+    },
+
+    logout: () => {
+      return call(
+        "auth", "logout",
+        routes.auth.logout.resp,
+        routes.auth.logout.req,
+        routes.auth.logout.method,
+        routes.auth.logout.path,
+      );
+    },
+
+    regenerateApiKey: () => {
+      return call(
+        "auth", "regenerate_api_key",
+        routes.auth.regenerate_api_key.resp,
+        routes.auth.regenerate_api_key.req,
+        routes.auth.regenerate_api_key.method,
+        routes.auth.regenerate_api_key.path,
+      );
+    },
+
+    apiKeyStatus: () => {
+      return call(
+        "auth", "api_key_status",
+        routes.auth.api_key_status.resp,
+        routes.auth.api_key_status.req,
+        routes.auth.api_key_status.method,
+        routes.auth.api_key_status.path,
+      );
+    },
+
+    redeemInvite: (params: s.RedeemInviteRequest) => {
+      return call(
+        "auth", "redeem_invite",
+        routes.auth.redeem_invite.resp,
+        routes.auth.redeem_invite.req,
+        routes.auth.redeem_invite.method,
+        routes.auth.redeem_invite.path,
+        params,
+      );
+    },
+
+    listPasskeys: () => {
+      return call(
+        "auth", "list_passkeys",
+        routes.auth.list_passkeys.resp,
+        routes.auth.list_passkeys.req,
+        routes.auth.list_passkeys.method,
+        routes.auth.list_passkeys.path,
+      );
+    },
+
+    deletePasskey: (params: s.DeletePasskeyRequest) => {
+      return call(
+        "auth", "delete_passkey",
+        routes.auth.delete_passkey.resp,
+        routes.auth.delete_passkey.req,
+        routes.auth.delete_passkey.method,
+        routes.auth.delete_passkey.path,
+        params,
+      );
+    },
+
+    linkNode: (params: s.LinkNodeRequest) => {
+      return call(
+        "auth", "link_node",
+        routes.auth.link_node.resp,
+        routes.auth.link_node.req,
+        routes.auth.link_node.method,
+        routes.auth.link_node.path,
+        params,
+      );
+    },
+
+    updateUsername: (params: s.UpdateUsernameRequest) => {
+      return call(
+        "auth", "update_username",
+        routes.auth.update_username.resp,
+        routes.auth.update_username.req,
+        routes.auth.update_username.method,
+        routes.auth.update_username.path,
+        params,
+      );
+    },
+
+    generateSelfAccountLink: () => {
+      return call(
+        "auth", "generate_self_account_link",
+        routes.auth.generate_self_account_link.resp,
+        routes.auth.generate_self_account_link.req,
+        routes.auth.generate_self_account_link.method,
+        routes.auth.generate_self_account_link.path,
+      );
+    },
+
+    listOwnInvites: () => {
+      return call(
+        "auth", "list_own_invites",
+        routes.auth.list_own_invites.resp,
+        routes.auth.list_own_invites.req,
+        routes.auth.list_own_invites.method,
+        routes.auth.list_own_invites.path,
+      );
+    },
+
+    revokeOwnInvite: (params: s.RevokeOwnInviteRequest) => {
+      return call(
+        "auth", "revoke_own_invite",
+        routes.auth.revoke_own_invite.resp,
+        routes.auth.revoke_own_invite.req,
+        routes.auth.revoke_own_invite.method,
+        routes.auth.revoke_own_invite.path,
+        params,
+      );
+    },
+
+    updatePasskeyName: (params: s.UpdatePasskeyNameRequest) => {
+      return call(
+        "auth", "update_passkey_name",
+        routes.auth.update_passkey_name.resp,
+        routes.auth.update_passkey_name.req,
+        routes.auth.update_passkey_name.method,
+        routes.auth.update_passkey_name.path,
+        params,
+      );
+    },
+  };
+}
+
+export type AuthMethods = ReturnType<typeof createAuthMethods>;

package/src/domains/favorites.types.ts

@@ -0,0 +1,52 @@
+// hand-rolled favorites types with proper discriminated union support
+// the codegen doesn't handle rust's #[serde(tag = "type")] properly yet
+import { z } from "zod";
+import {
+  SongQueryResultSchema,
+  AlbumQueryResultSchema,
+  ArtistQueryResultSchema,
+  PlaylistQueryResultSchema,
+} from "../codegen/schema.js";
+
+// discriminated union for favorite items
+// matches rust's FavoriteItem enum with #[serde(tag = "type", rename_all = "lowercase")]
+const FavoriteItemSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("song"),
+    favorited_at: z.number(),
+    song: SongQueryResultSchema,
+  }),
+  z.object({
+    type: z.literal("album"),
+    favorited_at: z.number(),
+    album: AlbumQueryResultSchema,
+  }),
+  z.object({
+    type: z.literal("artist"),
+    favorited_at: z.number(),
+    artist: ArtistQueryResultSchema,
+  }),
+  z.object({
+    type: z.literal("playlist"),
+    favorited_at: z.number(),
+    playlist: PlaylistQueryResultSchema,
+  }),
+]);
+
+export type FavoriteItem = z.infer<typeof FavoriteItemSchema>;
+
+// properly typed response from list_favorites endpoint
+const ListFavoritesResponseSchema = z.object({
+  favorites: z.array(FavoriteItemSchema),
+  total_count: z.number(),
+  has_more: z.boolean(),
+  offset: z.number(),
+  limit: z.number(),
+});
+
+export type ListFavoritesResponse = z.infer<
+  typeof ListFavoritesResponseSchema
+>;
+
+// export schemas for runtime validation if needed
+export { FavoriteItemSchema, ListFavoritesResponseSchema };

package/src/domains/jobs.ts

@@ -0,0 +1,48 @@
+// jobs domain methods for FreqholeClient.
+//
+// thin wrappers over the transport's `snapshotJobEvents` /
+// `subscribeJobEvents` capability. transports that don't implement
+// these fall back to the http polling iterator (see transport.ts).
+
+import type { Transport } from "../transport.js";
+import {
+  pollingJobEvents,
+  snapshotJobEventsViaRequest,
+} from "../transport.js";
+import type {
+  EventFilter,
+  JobEvent,
+  JobStateSnapshot,
+} from "../codegen/schema.js";
+
+export function createJobsMethods(transport: Transport) {
+  return {
+    events: {
+      /**
+       * one-shot snapshot of currently-active jobs the caller can see.
+       * use this to rehydrate state on mount / after a page reload.
+       */
+      snapshot: async (filter?: EventFilter): Promise<JobStateSnapshot[]> => {
+        if (transport.snapshotJobEvents) {
+          return transport.snapshotJobEvents(filter);
+        }
+        return snapshotJobEventsViaRequest(transport, filter);
+      },
+
+      /**
+       * live subscription to job events. iterates `JobEvent`s until the
+       * stream ends or the optional `signal` is aborted. transports
+       * without native streaming use the http polling fallback.
+       */
+      subscribe: (
+        filter?: EventFilter,
+        signal?: AbortSignal,
+      ): AsyncIterable<JobEvent> => {
+        if (transport.subscribeJobEvents) {
+          return transport.subscribeJobEvents(filter, signal);
+        }
+        return pollingJobEvents(transport, filter, signal);
+      },
+    },
+  };
+}