@saavn-labs/sdk 0.1.0

package/dist/saavn/operations/search-results/index.js

@@ -0,0 +1,29 @@
+import { SaavnSearchResultsMapper } from './mapper.ops';
+import { SaavnSearchResultsSchema } from './schema.ops';
+export const SaavnSearchResults = {
+    all: {
+        call: 'autocomplete.get',
+        schema: SaavnSearchResultsSchema.all,
+        mapper: SaavnSearchResultsMapper.all,
+    },
+    albums: {
+        call: 'search.getAlbumResults',
+        schema: SaavnSearchResultsSchema.albums,
+        mapper: SaavnSearchResultsMapper.albums,
+    },
+    artists: {
+        call: 'search.getArtistResults',
+        schema: SaavnSearchResultsSchema.artists,
+        mapper: SaavnSearchResultsMapper.artists,
+    },
+    playlists: {
+        call: 'search.getPlaylistResults',
+        schema: SaavnSearchResultsSchema.playlists,
+        mapper: SaavnSearchResultsMapper.playlists,
+    },
+    songs: {
+        call: 'search.getResults',
+        schema: SaavnSearchResultsSchema.songs,
+        mapper: SaavnSearchResultsMapper.songs,
+    },
+};

package/dist/saavn/operations/search-results/mapper.ops.d.ts

@@ -0,0 +1,413 @@
+import { z } from 'zod';
+import { SaavnSearchResultsSchema } from './schema.ops';
+export declare const SaavnSearchResultsMapper: {
+    all: (data: z.infer<typeof SaavnSearchResultsSchema.all.response>) => {
+        albums: {
+            position: number;
+            data: ({
+                id: any;
+                type: "song";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isExplicit: boolean;
+                    isRadioPresent?: undefined;
+                };
+                name?: undefined;
+            } | {
+                id: any;
+                type: "album";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isExplicit: boolean;
+                    isRadioPresent?: undefined;
+                };
+                name?: undefined;
+            } | {
+                id: any;
+                type: "artist";
+                name: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isRadioPresent: any;
+                    isExplicit?: undefined;
+                };
+                title?: undefined;
+                subtitle?: undefined;
+                description?: undefined;
+            } | {
+                id: any;
+                type: "playlist";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isExplicit: boolean;
+                    isRadioPresent?: undefined;
+                };
+                name?: undefined;
+            } | {
+                id: any;
+                type: "show";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags?: undefined;
+                name?: undefined;
+            } | null)[];
+        };
+        artists: {
+            position: number;
+            data: ({
+                id: any;
+                type: "song";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isExplicit: boolean;
+                    isRadioPresent?: undefined;
+                };
+                name?: undefined;
+            } | {
+                id: any;
+                type: "album";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isExplicit: boolean;
+                    isRadioPresent?: undefined;
+                };
+                name?: undefined;
+            } | {
+                id: any;
+                type: "artist";
+                name: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isRadioPresent: any;
+                    isExplicit?: undefined;
+                };
+                title?: undefined;
+                subtitle?: undefined;
+                description?: undefined;
+            } | {
+                id: any;
+                type: "playlist";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isExplicit: boolean;
+                    isRadioPresent?: undefined;
+                };
+                name?: undefined;
+            } | {
+                id: any;
+                type: "show";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags?: undefined;
+                name?: undefined;
+            } | null)[];
+        };
+        playlists: {
+            position: number;
+            data: ({
+                id: any;
+                type: "song";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isExplicit: boolean;
+                    isRadioPresent?: undefined;
+                };
+                name?: undefined;
+            } | {
+                id: any;
+                type: "album";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isExplicit: boolean;
+                    isRadioPresent?: undefined;
+                };
+                name?: undefined;
+            } | {
+                id: any;
+                type: "artist";
+                name: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isRadioPresent: any;
+                    isExplicit?: undefined;
+                };
+                title?: undefined;
+                subtitle?: undefined;
+                description?: undefined;
+            } | {
+                id: any;
+                type: "playlist";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isExplicit: boolean;
+                    isRadioPresent?: undefined;
+                };
+                name?: undefined;
+            } | {
+                id: any;
+                type: "show";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags?: undefined;
+                name?: undefined;
+            } | null)[];
+        };
+        shows: {
+            position: number;
+            data: ({
+                id: any;
+                type: "song";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isExplicit: boolean;
+                    isRadioPresent?: undefined;
+                };
+                name?: undefined;
+            } | {
+                id: any;
+                type: "album";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isExplicit: boolean;
+                    isRadioPresent?: undefined;
+                };
+                name?: undefined;
+            } | {
+                id: any;
+                type: "artist";
+                name: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isRadioPresent: any;
+                    isExplicit?: undefined;
+                };
+                title?: undefined;
+                subtitle?: undefined;
+                description?: undefined;
+            } | {
+                id: any;
+                type: "playlist";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isExplicit: boolean;
+                    isRadioPresent?: undefined;
+                };
+                name?: undefined;
+            } | {
+                id: any;
+                type: "show";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags?: undefined;
+                name?: undefined;
+            } | null)[];
+        };
+        songs: {
+            position: number;
+            data: ({
+                id: any;
+                type: "song";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isExplicit: boolean;
+                    isRadioPresent?: undefined;
+                };
+                name?: undefined;
+            } | {
+                id: any;
+                type: "album";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isExplicit: boolean;
+                    isRadioPresent?: undefined;
+                };
+                name?: undefined;
+            } | {
+                id: any;
+                type: "artist";
+                name: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isRadioPresent: any;
+                    isExplicit?: undefined;
+                };
+                title?: undefined;
+                subtitle?: undefined;
+                description?: undefined;
+            } | {
+                id: any;
+                type: "playlist";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags: {
+                    isExplicit: boolean;
+                    isRadioPresent?: undefined;
+                };
+                name?: undefined;
+            } | {
+                id: any;
+                type: "show";
+                title: any;
+                subtitle: any;
+                description: any;
+                url: any;
+                images: import("../../..").Image[];
+                flags?: undefined;
+                name?: undefined;
+            } | null)[];
+        };
+        topquery: {
+            position: any;
+            data: any;
+        };
+    };
+    albums: (data: z.infer<typeof SaavnSearchResultsSchema.albums.response>) => {
+        total: number;
+        start: number;
+        results: import("../../../core/models").Album[];
+    };
+    artists: (data: z.infer<typeof SaavnSearchResultsSchema.artists.response>) => {
+        total: number;
+        start: number;
+        results: {
+            flags: {
+                isRadioPresent: boolean;
+                isFollowed: boolean;
+            };
+            id: string;
+            type: "artist";
+            name: string;
+            subtitle?: string;
+            url: string;
+            images: import("../../..").Image[];
+            stats?: {
+                followerCount?: number;
+                fanCount?: number;
+            };
+            language?: {
+                primary?: string;
+                available?: string[];
+            };
+            profile?: {
+                bio?: import("../../..").BioSection[];
+                dob?: string;
+            };
+            links?: {
+                saavn?: {
+                    overview?: string;
+                    albums?: string;
+                    songs?: string;
+                    bio?: string;
+                    comments?: string;
+                };
+                social?: {
+                    wiki?: string;
+                    facebook?: string;
+                    twitter?: string;
+                };
+            };
+            songs?: {
+                top?: import("../../../core/models").Song[];
+                latest?: import("../../../core/models").Song[];
+            };
+            albums?: {
+                top?: import("../../../core/models").Album[];
+                singles?: import("../../../core/models").Album[];
+                latest?: import("../../../core/models").Album[];
+            };
+            playlists?: {
+                dedicated?: import("../../../core/models").Playlist[];
+                featured?: import("../../../core/models").Playlist[];
+            };
+            related?: {
+                similar?: import("../../../core/models").Artist[];
+            };
+        }[];
+    };
+    playlists: (data: z.infer<typeof SaavnSearchResultsSchema.playlists.response>) => {
+        total: number;
+        start: number;
+        results: import("../../../core/models").Playlist[];
+    };
+    songs: (data: z.infer<typeof SaavnSearchResultsSchema.songs.response>) => {
+        total: number;
+        start: number;
+        results: import("../../../core/models").Song[];
+    };
+};

package/dist/saavn/operations/search-results/mapper.ops.js

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import { mapAlbumEdgeCase, mapPlaylistEdgeCase, mapSong, mapArtistBase, mapSearchAllBase, } from '../../common-mapper';
+import { SaavnSearchResultsSchema } from './schema.ops';
+function normalizeSection(section) {
+    return {
+        position: section?.position ?? 0,
+        data: section?.data ?? [],
+    };
+}
+function normalizeTopQuery(topquery) {
+    if (!topquery || Array.isArray(topquery)) {
+        return { position: 0, data: [] };
+    }
+    return {
+        position: topquery.position ?? 0,
+        data: topquery.data ?? [],
+    };
+}
+export const SaavnSearchResultsMapper = {
+    all: (data) => {
+        const albums = normalizeSection(data.albums);
+        const artists = normalizeSection(data.artists);
+        const playlists = normalizeSection(data.playlists);
+        const songs = normalizeSection(data.songs);
+        const shows = normalizeSection(data.shows);
+        const topquery = normalizeTopQuery(data.topquery);
+        return {
+            albums: {
+                position: albums.position,
+                data: albums.data.map(mapSearchAllBase).filter(Boolean),
+            },
+            artists: {
+                position: artists.position,
+                data: artists.data.map(mapSearchAllBase).filter(Boolean),
+            },
+            playlists: {
+                position: playlists.position,
+                data: playlists.data.map(mapSearchAllBase).filter(Boolean),
+            },
+            shows: {
+                position: shows.position,
+                data: shows.data.map(mapSearchAllBase).filter(Boolean),
+            },
+            songs: {
+                position: songs.position,
+                data: songs.data.map(mapSearchAllBase).filter(Boolean),
+            },
+            topquery: {
+                position: topquery.position,
+                data: topquery.data.map(mapSearchAllBase).filter(Boolean),
+            },
+        };
+    },
+    albums: (data) => ({
+        total: data.total,
+        start: data.start,
+        results: data.results.map(mapAlbumEdgeCase),
+    }),
+    artists: (data) => ({
+        total: data.total,
+        start: data.start,
+        results: data.results.map((artist) => ({
+            ...mapArtistBase(artist),
+            flags: {
+                isRadioPresent: artist.isRadioPresent,
+                isFollowed: artist.is_followed,
+            },
+        })),
+    }),
+    playlists: (data) => ({
+        total: data.total,
+        start: data.start,
+        results: data.results.map(mapPlaylistEdgeCase),
+    }),
+    songs: (data) => ({
+        total: data.total,
+        start: data.start,
+        results: data.results.map(mapSong),
+    }),
+};