@saavn-labs/sdk 0.1.0

package/dist/saavn/operations/web-radio/index.d.ts

@@ -0,0 +1,181 @@
+import { SaavnWebRadioSchema } from './schema.ops';
+export declare const SaavnWebRadio: {
+    createEntityStation: {
+        call: string;
+        schema: {
+            readonly params: import("zod").ZodObject<{
+                ctx: import("zod").ZodLiteral<"android">;
+                entity_type: import("zod").ZodLiteral<"queue">;
+                entity_id: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            readonly response: import("zod").ZodObject<{
+                stationid: import("zod").ZodString;
+            }, import("zod/v4/core").$loose>;
+        };
+        mapper: (data: import("zod").infer<typeof SaavnWebRadioSchema.createEntityStation.response>) => {
+            stationId: string;
+        };
+    };
+    createFeaturedStation: {
+        call: string;
+        schema: {
+            readonly params: import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                language: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            readonly response: import("zod").ZodObject<{
+                stationid: import("zod").ZodString;
+            }, import("zod/v4/core").$loose>;
+        };
+        mapper: (data: import("zod").infer<typeof SaavnWebRadioSchema.createFeaturedStation.response>) => {
+            stationId: string;
+        };
+    };
+    songs: {
+        call: string;
+        schema: {
+            readonly params: import("zod").ZodObject<{
+                ctx: import("zod").ZodLiteral<"android">;
+                stationid: import("zod").ZodString;
+                k: import("zod").ZodOptional<import("zod").ZodString>;
+                next: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    0: "0";
+                    1: "1";
+                }>>;
+            }, import("zod/v4/core").$strict>;
+            readonly response: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                song: import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    title: import("zod").ZodString;
+                    subtitle: import("zod").ZodString;
+                    type: import("zod").ZodLiteral<"song">;
+                    perma_url: import("zod").ZodString;
+                    image: import("zod").ZodString;
+                    explicit_content: import("zod").ZodString;
+                    header_desc: import("zod").ZodString;
+                    language: import("zod").ZodString;
+                    year: import("zod").ZodString;
+                    play_count: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>;
+                    more_info: import("zod").ZodObject<{
+                        music: import("zod").ZodString;
+                        album_id: import("zod").ZodString;
+                        album: import("zod").ZodString;
+                        label: import("zod").ZodString;
+                        label_id: import("zod").ZodNullable<import("zod").ZodString>;
+                        origin: import("zod").ZodString;
+                        is_dolby_content: import("zod").ZodBoolean;
+                        encrypted_media_url: import("zod").ZodString;
+                        encrypted_drm_media_url: import("zod").ZodString;
+                        album_url: import("zod").ZodString;
+                        duration: import("zod").ZodString;
+                        has_lyrics: import("zod").ZodString;
+                        lyrics_snippet: import("zod").ZodString;
+                        lyrics_id: import("zod").ZodOptional<import("zod").ZodString>;
+                        copyright_text: import("zod").ZodString;
+                        release_date: import("zod").ZodNullable<import("zod").ZodString>;
+                        label_url: import("zod").ZodOptional<import("zod").ZodString>;
+                        vcode: import("zod").ZodOptional<import("zod").ZodString>;
+                        vlink: import("zod").ZodOptional<import("zod").ZodString>;
+                        artistMap: import("zod").ZodLazy<import("zod").ZodObject<{
+                            primary_artists: import("zod").ZodArray<import("zod").ZodObject<{
+                                id: import("zod").ZodString;
+                                name: import("zod").ZodString;
+                                role: import("zod").ZodString;
+                                image: import("zod").ZodString;
+                                type: import("zod").ZodLiteral<"artist">;
+                                perma_url: import("zod").ZodString;
+                            }, import("zod/v4/core").$loose>>;
+                            featured_artists: import("zod").ZodArray<import("zod").ZodObject<{
+                                id: import("zod").ZodString;
+                                name: import("zod").ZodString;
+                                role: import("zod").ZodString;
+                                image: import("zod").ZodString;
+                                type: import("zod").ZodLiteral<"artist">;
+                                perma_url: import("zod").ZodString;
+                            }, import("zod/v4/core").$loose>>;
+                            artists: import("zod").ZodArray<import("zod").ZodObject<{
+                                id: import("zod").ZodString;
+                                name: import("zod").ZodString;
+                                role: import("zod").ZodString;
+                                image: import("zod").ZodString;
+                                type: import("zod").ZodLiteral<"artist">;
+                                perma_url: import("zod").ZodString;
+                            }, import("zod/v4/core").$loose>>;
+                        }, import("zod/v4/core").$loose>>;
+                    }, import("zod/v4/core").$loose>;
+                }, import("zod/v4/core").$loose>;
+                stationid: import("zod").ZodString;
+            }, import("zod/v4/core").$loose>, import("zod").ZodObject<{
+                stationid: import("zod").ZodString;
+            }, import("zod/v4/core").$catchall<import("zod").ZodObject<{
+                song: import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    title: import("zod").ZodString;
+                    subtitle: import("zod").ZodString;
+                    type: import("zod").ZodLiteral<"song">;
+                    perma_url: import("zod").ZodString;
+                    image: import("zod").ZodString;
+                    explicit_content: import("zod").ZodString;
+                    header_desc: import("zod").ZodString;
+                    language: import("zod").ZodString;
+                    year: import("zod").ZodString;
+                    play_count: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>;
+                    more_info: import("zod").ZodObject<{
+                        music: import("zod").ZodString;
+                        album_id: import("zod").ZodString;
+                        album: import("zod").ZodString;
+                        label: import("zod").ZodString;
+                        label_id: import("zod").ZodNullable<import("zod").ZodString>;
+                        origin: import("zod").ZodString;
+                        is_dolby_content: import("zod").ZodBoolean;
+                        encrypted_media_url: import("zod").ZodString;
+                        encrypted_drm_media_url: import("zod").ZodString;
+                        album_url: import("zod").ZodString;
+                        duration: import("zod").ZodString;
+                        has_lyrics: import("zod").ZodString;
+                        lyrics_snippet: import("zod").ZodString;
+                        lyrics_id: import("zod").ZodOptional<import("zod").ZodString>;
+                        copyright_text: import("zod").ZodString;
+                        release_date: import("zod").ZodNullable<import("zod").ZodString>;
+                        label_url: import("zod").ZodOptional<import("zod").ZodString>;
+                        vcode: import("zod").ZodOptional<import("zod").ZodString>;
+                        vlink: import("zod").ZodOptional<import("zod").ZodString>;
+                        artistMap: import("zod").ZodLazy<import("zod").ZodObject<{
+                            primary_artists: import("zod").ZodArray<import("zod").ZodObject<{
+                                id: import("zod").ZodString;
+                                name: import("zod").ZodString;
+                                role: import("zod").ZodString;
+                                image: import("zod").ZodString;
+                                type: import("zod").ZodLiteral<"artist">;
+                                perma_url: import("zod").ZodString;
+                            }, import("zod/v4/core").$loose>>;
+                            featured_artists: import("zod").ZodArray<import("zod").ZodObject<{
+                                id: import("zod").ZodString;
+                                name: import("zod").ZodString;
+                                role: import("zod").ZodString;
+                                image: import("zod").ZodString;
+                                type: import("zod").ZodLiteral<"artist">;
+                                perma_url: import("zod").ZodString;
+                            }, import("zod/v4/core").$loose>>;
+                            artists: import("zod").ZodArray<import("zod").ZodObject<{
+                                id: import("zod").ZodString;
+                                name: import("zod").ZodString;
+                                role: import("zod").ZodString;
+                                image: import("zod").ZodString;
+                                type: import("zod").ZodLiteral<"artist">;
+                                perma_url: import("zod").ZodString;
+                            }, import("zod/v4/core").$loose>>;
+                        }, import("zod/v4/core").$loose>>;
+                    }, import("zod/v4/core").$loose>;
+                }, import("zod/v4/core").$loose>;
+            }, import("zod/v4/core").$loose>>>, import("zod").ZodObject<{
+                stationid: import("zod").ZodOptional<import("zod").ZodString>;
+                error: import("zod").ZodString;
+            }, import("zod/v4/core").$loose>]>;
+        };
+        mapper: (data: import("zod").infer<typeof SaavnWebRadioSchema.songs.response>) => {
+            stationId: string | undefined;
+            songs: import("../../../core/models").Song[];
+        };
+    };
+};

package/dist/saavn/operations/web-radio/index.js

@@ -0,0 +1,19 @@
+import { SaavnWebRadioMapper } from './mapper.ops';
+import { SaavnWebRadioSchema } from './schema.ops';
+export const SaavnWebRadio = {
+    createEntityStation: {
+        call: 'webradio.createEntityStation',
+        schema: SaavnWebRadioSchema.createEntityStation,
+        mapper: SaavnWebRadioMapper.createEntityStation,
+    },
+    createFeaturedStation: {
+        call: 'webradio.createFeaturedStation',
+        schema: SaavnWebRadioSchema.createFeaturedStation,
+        mapper: SaavnWebRadioMapper.createFeaturedStation,
+    },
+    songs: {
+        call: 'webradio.getSong',
+        schema: SaavnWebRadioSchema.songs,
+        mapper: SaavnWebRadioMapper.songs,
+    },
+};

package/dist/saavn/operations/web-radio/mapper.ops.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { SaavnWebRadioSchema } from './schema.ops';
+export declare const SaavnWebRadioMapper: {
+    createEntityStation: (data: z.infer<typeof SaavnWebRadioSchema.createEntityStation.response>) => {
+        stationId: string;
+    };
+    createFeaturedStation: (data: z.infer<typeof SaavnWebRadioSchema.createFeaturedStation.response>) => {
+        stationId: string;
+    };
+    songs: (data: z.infer<typeof SaavnWebRadioSchema.songs.response>) => {
+        stationId: string | undefined;
+        songs: import("../../../core/models").Song[];
+    };
+};

package/dist/saavn/operations/web-radio/mapper.ops.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { mapSong } from '../../common-mapper';
+import { SaavnWebRadioSchema } from './schema.ops';
+export const SaavnWebRadioMapper = {
+    createEntityStation: (data) => {
+        return {
+            stationId: data.stationid,
+        };
+    },
+    createFeaturedStation: (data) => {
+        return {
+            stationId: data.stationid,
+        };
+    },
+    songs: (data) => {
+        if ('song' in data && data.song) {
+            return {
+                stationId: data.stationid,
+                songs: [mapSong(data.song)],
+            };
+        }
+        const songs = Object.entries(data)
+            .filter(([key, value]) => key !== 'stationid' &&
+            !Number.isNaN(Number(key)) &&
+            typeof value === 'object' &&
+            value !== null &&
+            'song' in value)
+            .sort(([a], [b]) => Number(a) - Number(b))
+            .map(([, value]) => mapSong(value.song));
+        return {
+            stationId: data.stationid,
+            songs,
+        };
+    },
+};

package/dist/saavn/operations/web-radio/schema.ops.d.ts

@@ -0,0 +1,162 @@
+import { z } from 'zod';
+export declare const SaavnWebRadioSchema: {
+    readonly createEntityStation: {
+        readonly params: z.ZodObject<{
+            ctx: z.ZodLiteral<"android">;
+            entity_type: z.ZodLiteral<"queue">;
+            entity_id: z.ZodString;
+        }, z.core.$strict>;
+        readonly response: z.ZodObject<{
+            stationid: z.ZodString;
+        }, z.core.$loose>;
+    };
+    readonly createFeaturedStation: {
+        readonly params: z.ZodObject<{
+            name: z.ZodString;
+            language: z.ZodString;
+        }, z.core.$strict>;
+        readonly response: z.ZodObject<{
+            stationid: z.ZodString;
+        }, z.core.$loose>;
+    };
+    readonly songs: {
+        readonly params: z.ZodObject<{
+            ctx: z.ZodLiteral<"android">;
+            stationid: z.ZodString;
+            k: z.ZodOptional<z.ZodString>;
+            next: z.ZodOptional<z.ZodEnum<{
+                0: "0";
+                1: "1";
+            }>>;
+        }, z.core.$strict>;
+        readonly response: z.ZodUnion<readonly [z.ZodObject<{
+            song: z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+                subtitle: z.ZodString;
+                type: z.ZodLiteral<"song">;
+                perma_url: z.ZodString;
+                image: z.ZodString;
+                explicit_content: z.ZodString;
+                header_desc: z.ZodString;
+                language: z.ZodString;
+                year: z.ZodString;
+                play_count: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+                more_info: z.ZodObject<{
+                    music: z.ZodString;
+                    album_id: z.ZodString;
+                    album: z.ZodString;
+                    label: z.ZodString;
+                    label_id: z.ZodNullable<z.ZodString>;
+                    origin: z.ZodString;
+                    is_dolby_content: z.ZodBoolean;
+                    encrypted_media_url: z.ZodString;
+                    encrypted_drm_media_url: z.ZodString;
+                    album_url: z.ZodString;
+                    duration: z.ZodString;
+                    has_lyrics: z.ZodString;
+                    lyrics_snippet: z.ZodString;
+                    lyrics_id: z.ZodOptional<z.ZodString>;
+                    copyright_text: z.ZodString;
+                    release_date: z.ZodNullable<z.ZodString>;
+                    label_url: z.ZodOptional<z.ZodString>;
+                    vcode: z.ZodOptional<z.ZodString>;
+                    vlink: z.ZodOptional<z.ZodString>;
+                    artistMap: z.ZodLazy<z.ZodObject<{
+                        primary_artists: z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            name: z.ZodString;
+                            role: z.ZodString;
+                            image: z.ZodString;
+                            type: z.ZodLiteral<"artist">;
+                            perma_url: z.ZodString;
+                        }, z.core.$loose>>;
+                        featured_artists: z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            name: z.ZodString;
+                            role: z.ZodString;
+                            image: z.ZodString;
+                            type: z.ZodLiteral<"artist">;
+                            perma_url: z.ZodString;
+                        }, z.core.$loose>>;
+                        artists: z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            name: z.ZodString;
+                            role: z.ZodString;
+                            image: z.ZodString;
+                            type: z.ZodLiteral<"artist">;
+                            perma_url: z.ZodString;
+                        }, z.core.$loose>>;
+                    }, z.core.$loose>>;
+                }, z.core.$loose>;
+            }, z.core.$loose>;
+            stationid: z.ZodString;
+        }, z.core.$loose>, z.ZodObject<{
+            stationid: z.ZodString;
+        }, z.core.$catchall<z.ZodObject<{
+            song: z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+                subtitle: z.ZodString;
+                type: z.ZodLiteral<"song">;
+                perma_url: z.ZodString;
+                image: z.ZodString;
+                explicit_content: z.ZodString;
+                header_desc: z.ZodString;
+                language: z.ZodString;
+                year: z.ZodString;
+                play_count: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+                more_info: z.ZodObject<{
+                    music: z.ZodString;
+                    album_id: z.ZodString;
+                    album: z.ZodString;
+                    label: z.ZodString;
+                    label_id: z.ZodNullable<z.ZodString>;
+                    origin: z.ZodString;
+                    is_dolby_content: z.ZodBoolean;
+                    encrypted_media_url: z.ZodString;
+                    encrypted_drm_media_url: z.ZodString;
+                    album_url: z.ZodString;
+                    duration: z.ZodString;
+                    has_lyrics: z.ZodString;
+                    lyrics_snippet: z.ZodString;
+                    lyrics_id: z.ZodOptional<z.ZodString>;
+                    copyright_text: z.ZodString;
+                    release_date: z.ZodNullable<z.ZodString>;
+                    label_url: z.ZodOptional<z.ZodString>;
+                    vcode: z.ZodOptional<z.ZodString>;
+                    vlink: z.ZodOptional<z.ZodString>;
+                    artistMap: z.ZodLazy<z.ZodObject<{
+                        primary_artists: z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            name: z.ZodString;
+                            role: z.ZodString;
+                            image: z.ZodString;
+                            type: z.ZodLiteral<"artist">;
+                            perma_url: z.ZodString;
+                        }, z.core.$loose>>;
+                        featured_artists: z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            name: z.ZodString;
+                            role: z.ZodString;
+                            image: z.ZodString;
+                            type: z.ZodLiteral<"artist">;
+                            perma_url: z.ZodString;
+                        }, z.core.$loose>>;
+                        artists: z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            name: z.ZodString;
+                            role: z.ZodString;
+                            image: z.ZodString;
+                            type: z.ZodLiteral<"artist">;
+                            perma_url: z.ZodString;
+                        }, z.core.$loose>>;
+                    }, z.core.$loose>>;
+                }, z.core.$loose>;
+            }, z.core.$loose>;
+        }, z.core.$loose>>>, z.ZodObject<{
+            stationid: z.ZodOptional<z.ZodString>;
+            error: z.ZodString;
+        }, z.core.$loose>]>;
+    };
+};

package/dist/saavn/operations/web-radio/schema.ops.js

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { JSONStringArray, NonEmptyString, PositiveString, } from '../../primitives/string';
+import { SaavnExplicitFlagSchema } from '../../primitives/enums';
+import { SaavnSongEntity } from '../../entities';
+const WebRadioSingleSong = z.looseObject({
+    song: SaavnSongEntity,
+    stationid: z.string(),
+});
+const WebRadioMultipleSongs = z
+    .looseObject({
+    stationid: z.string(),
+})
+    .catchall(z.looseObject({
+    song: SaavnSongEntity,
+}))
+    .refine((obj) => Object.keys(obj).some((key) => key !== 'stationid' && !Number.isNaN(Number(key))), {
+    message: 'Expected numeric song keys (0,1,2,...)',
+});
+const WebRadioError = z.looseObject({
+    stationid: z.string().optional(),
+    error: z.string(),
+});
+export const SaavnWebRadioSchema = {
+    createEntityStation: {
+        params: z.strictObject({
+            ctx: z.literal('android'),
+            entity_type: z.literal('queue'),
+            entity_id: JSONStringArray,
+        }),
+        response: z.looseObject({
+            stationid: z.string(),
+        }),
+    },
+    createFeaturedStation: {
+        params: z.strictObject({
+            name: NonEmptyString,
+            language: NonEmptyString,
+        }),
+        response: z.looseObject({
+            stationid: z.string(),
+        }),
+    },
+    songs: {
+        params: z.strictObject({
+            ctx: z.literal('android'),
+            stationid: NonEmptyString,
+            k: PositiveString.optional(),
+            next: SaavnExplicitFlagSchema.optional(),
+        }),
+        response: z.union([
+            WebRadioSingleSong,
+            WebRadioMultipleSongs,
+            WebRadioError,
+        ]),
+    },
+};

package/dist/saavn/primitives/enums.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export type SaavnSortOrder = z.infer<typeof SaavnSortOrderSchema>;
+export type SaavnSortBy = z.infer<typeof SaavnSortBySchema>;
+export type SaavnExplicitFlag = z.infer<typeof SaavnExplicitFlagSchema>;
+export declare const SaavnSortOrderSchema: z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+}>;
+export declare const SaavnSortBySchema: z.ZodEnum<{
+    "": "";
+    alphabetical: "alphabetical";
+    latest: "latest";
+}>;
+export declare const SaavnExplicitFlagSchema: z.ZodEnum<{
+    0: "0";
+    1: "1";
+}>;

package/dist/saavn/primitives/enums.js

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export const SaavnSortOrderSchema = z.enum(['asc', 'desc']);
+export const SaavnSortBySchema = z.enum(['alphabetical', 'latest', '']);
+export const SaavnExplicitFlagSchema = z.enum(['0', '1']);

package/dist/saavn/primitives/string.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export declare const NonEmptyString: z.ZodString;
+export declare const PositiveString: z.ZodString;
+export declare const CSVString: z.ZodString;
+export declare const JSONStringArray: z.ZodString;

package/dist/saavn/primitives/string.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export const NonEmptyString = z.string().min(1);
+export const PositiveString = z
+    .string()
+    .regex(/^[1-9]\d*$/, 'Expected a positive numeric string');
+export const CSVString = z
+    .string()
+    .min(1)
+    .refine((v) => v.split(',').every((part) => part.trim().length > 0), 'Expected comma-separated non-empty values');
+export const JSONStringArray = z.string().refine((value) => {
+    try {
+        const parsed = JSON.parse(value);
+        return (Array.isArray(parsed) &&
+            parsed.length > 0 &&
+            parsed.every((item) => typeof item === 'string' && item.length > 0));
+    }
+    catch {
+        return false;
+    }
+}, {
+    message: 'Expected a JSON-stringified array of non-empty strings',
+});

package/dist/saavn/run-operation.d.ts

@@ -0,0 +1,12 @@
+import { z, type ZodType } from 'zod';
+type AnyZodSchema = ZodType<unknown, any, any>;
+type OperationLike<P extends AnyZodSchema, R extends AnyZodSchema, O> = {
+    call: string;
+    schema: {
+        params: P;
+        response: R;
+    };
+    mapper: (data: z.infer<R>) => O;
+};
+export declare function runOperation<P extends AnyZodSchema, R extends AnyZodSchema, O>(op: OperationLike<P, R, O>, input: z.input<P>): Promise<O>;
+export {};

package/dist/saavn/run-operation.js

@@ -0,0 +1,39 @@
+import { z, ZodError } from 'zod';
+import { fetchFromSaavn } from '../helpers/fetch';
+import { fromZodError, networkError, internalError, SDKError, detectSaavnApiError, } from '../helpers/errors';
+export async function runOperation(op, input) {
+    let parsedParams;
+    try {
+        parsedParams = op.schema.params.parse(input);
+    }
+    catch (e) {
+        if (e instanceof ZodError) {
+            throw fromZodError(e, 'params', op.call);
+        }
+        throw internalError('Failed to validate parameters.', e);
+    }
+    const params = Object.fromEntries(Object.entries(parsedParams).map(([k, v]) => [k, String(v)]));
+    const res = await fetchFromSaavn({ call: op.call, params });
+    if (!res.ok) {
+        throw networkError(op.call, res.status);
+    }
+    const apiErrorMessage = detectSaavnApiError(res.data);
+    if (apiErrorMessage) {
+        throw new SDKError('API_ERROR', apiErrorMessage, {
+            details: {
+                call: op.call,
+                response: res.data,
+            },
+        });
+    }
+    try {
+        const parsed = op.schema.response.parse(res.data);
+        return op.mapper(parsed);
+    }
+    catch (e) {
+        if (e instanceof ZodError) {
+            throw fromZodError(e, 'response', op.call);
+        }
+        throw internalError('Failed to parse or map response.', e);
+    }
+}