@boldvideo/bold-js 0.1.0 → 0.3.0

package/dist/index.cjs

@@ -77,33 +77,82 @@ var import_axios = __toESM(require("axios"), 1);
 // src/lib/fetchers.ts
 function get(client, url) {
   return __async(this, null, function* () {
-    const res = yield client.get(url);
-    return res.data;
+    try {
+      const res = yield client.get(url);
+      if (res.status !== 200) {
+        throw new Error(`Unexpected response status: ${res.status}`);
+      }
+      return res.data;
+    } catch (error) {
+      console.error(`Error fetching data from URL: ${url}`, error);
+      throw error;
+    }
   });
 }
 function fetchSettings(client) {
   return (videoLimit = 12) => __async(this, null, function* () {
-    return get(client, `settings?limit=${videoLimit}`);
+    try {
+      return yield get(
+        client,
+        `settings?limit=${videoLimit}`
+      );
+    } catch (error) {
+      console.error(`Error fetching settings with limit: ${videoLimit}`, error);
+      throw error;
+    }
   });
 }
 function fetchVideos(client) {
   return (videoLimit = 12) => __async(this, null, function* () {
-    return get(client, `videos/latest?limit=${videoLimit}`);
+    try {
+      return yield get(
+        client,
+        `videos/latest?limit=${videoLimit}`
+      );
+    } catch (error) {
+      console.error(`Error fetching videos with limit: ${videoLimit}`, error);
+      throw error;
+    }
+  });
+}
+function searchVideos(client) {
+  return (term) => __async(this, null, function* () {
+    try {
+      return yield get(client, `videos?query=${term}`);
+    } catch (error) {
+      console.error(`Error searching for videos with term: ${term}`, error);
+      throw error;
+    }
   });
 }
 function fetchVideo(client) {
   return (id) => __async(this, null, function* () {
-    return get(client, `videos/${id}`);
+    try {
+      return yield get(client, `videos/${id}`);
+    } catch (error) {
+      console.error(`Error fetching video with ID: ${id}`, error);
+      throw error;
+    }
   });
 }
 function fetchPlaylists(client) {
   return () => __async(this, null, function* () {
-    return get(client, "playlists");
+    try {
+      return yield get(client, "playlists");
+    } catch (error) {
+      console.error("Error fetching playlists", error);
+      throw error;
+    }
   });
 }
 function fetchPlaylist(client) {
   return (id) => __async(this, null, function* () {
-    return get(client, `playlists/${id}`);
+    try {
+      return yield get(client, `playlists/${id}`);
+    } catch (error) {
+      console.error(`Error fetching playlist with ID: ${id}`, error);
+      throw error;
+    }
   });
 }
 
@@ -158,6 +207,7 @@ function trackEvent(client, userId, options) {
       videoId: video.id,
       title: video.title,
       videoDuration: video.duration,
+      // TODO: change to currentTime of HTMLMediaElement
       timeStamp: event.timeStamp
     });
     if (event.type == "timeupdate") {
@@ -208,6 +258,9 @@ function basicInfos() {
 // src/lib/client.ts
 function createClient(apiKey, options = { debug: false }) {
   var _a;
+  if (!apiKey || typeof apiKey !== "string") {
+    throw new Error("API key is missing or invalid");
+  }
   const { debug } = options;
   const apiClientOptions = {
     baseURL: (_a = options.baseURL) != null ? _a : "https://app.boldvideo.io/api/v1/",
@@ -215,13 +268,20 @@ function createClient(apiKey, options = { debug: false }) {
       Authorization: apiKey
     }
   };
-  const apiClient = import_axios.default.create(apiClientOptions);
+  let apiClient;
+  try {
+    apiClient = import_axios.default.create(apiClientOptions);
+  } catch (error) {
+    console.error("Error creating API client", error);
+    throw error;
+  }
   const userId = [...Array(30)].map(() => Math.random().toString(36)[2]).join("");
   return {
     settings: fetchSettings(apiClient),
     videos: {
       list: fetchVideos(apiClient),
-      get: fetchVideo(apiClient)
+      get: fetchVideo(apiClient),
+      search: searchVideos(apiClient)
     },
     playlists: {
       list: fetchPlaylists(apiClient),

package/dist/index.d.ts

@@ -59,6 +59,9 @@ declare function createClient(apiKey: string, options?: ClientOptions): {
         get: (id: string) => Promise<{
             data: Video;
         }>;
+        search: (term: string) => Promise<{
+            data: Video[];
+        }>;
     };
     playlists: {
         list: () => Promise<{

package/dist/index.js

@@ -44,33 +44,82 @@ import axios from "axios";
 // src/lib/fetchers.ts
 function get(client, url) {
   return __async(this, null, function* () {
-    const res = yield client.get(url);
-    return res.data;
+    try {
+      const res = yield client.get(url);
+      if (res.status !== 200) {
+        throw new Error(`Unexpected response status: ${res.status}`);
+      }
+      return res.data;
+    } catch (error) {
+      console.error(`Error fetching data from URL: ${url}`, error);
+      throw error;
+    }
   });
 }
 function fetchSettings(client) {
   return (videoLimit = 12) => __async(this, null, function* () {
-    return get(client, `settings?limit=${videoLimit}`);
+    try {
+      return yield get(
+        client,
+        `settings?limit=${videoLimit}`
+      );
+    } catch (error) {
+      console.error(`Error fetching settings with limit: ${videoLimit}`, error);
+      throw error;
+    }
   });
 }
 function fetchVideos(client) {
   return (videoLimit = 12) => __async(this, null, function* () {
-    return get(client, `videos/latest?limit=${videoLimit}`);
+    try {
+      return yield get(
+        client,
+        `videos/latest?limit=${videoLimit}`
+      );
+    } catch (error) {
+      console.error(`Error fetching videos with limit: ${videoLimit}`, error);
+      throw error;
+    }
+  });
+}
+function searchVideos(client) {
+  return (term) => __async(this, null, function* () {
+    try {
+      return yield get(client, `videos?query=${term}`);
+    } catch (error) {
+      console.error(`Error searching for videos with term: ${term}`, error);
+      throw error;
+    }
   });
 }
 function fetchVideo(client) {
   return (id) => __async(this, null, function* () {
-    return get(client, `videos/${id}`);
+    try {
+      return yield get(client, `videos/${id}`);
+    } catch (error) {
+      console.error(`Error fetching video with ID: ${id}`, error);
+      throw error;
+    }
   });
 }
 function fetchPlaylists(client) {
   return () => __async(this, null, function* () {
-    return get(client, "playlists");
+    try {
+      return yield get(client, "playlists");
+    } catch (error) {
+      console.error("Error fetching playlists", error);
+      throw error;
+    }
   });
 }
 function fetchPlaylist(client) {
   return (id) => __async(this, null, function* () {
-    return get(client, `playlists/${id}`);
+    try {
+      return yield get(client, `playlists/${id}`);
+    } catch (error) {
+      console.error(`Error fetching playlist with ID: ${id}`, error);
+      throw error;
+    }
   });
 }
 
@@ -125,6 +174,7 @@ function trackEvent(client, userId, options) {
       videoId: video.id,
       title: video.title,
       videoDuration: video.duration,
+      // TODO: change to currentTime of HTMLMediaElement
       timeStamp: event.timeStamp
     });
     if (event.type == "timeupdate") {
@@ -175,6 +225,9 @@ function basicInfos() {
 // src/lib/client.ts
 function createClient(apiKey, options = { debug: false }) {
   var _a;
+  if (!apiKey || typeof apiKey !== "string") {
+    throw new Error("API key is missing or invalid");
+  }
   const { debug } = options;
   const apiClientOptions = {
     baseURL: (_a = options.baseURL) != null ? _a : "https://app.boldvideo.io/api/v1/",
@@ -182,13 +235,20 @@ function createClient(apiKey, options = { debug: false }) {
       Authorization: apiKey
     }
   };
-  const apiClient = axios.create(apiClientOptions);
+  let apiClient;
+  try {
+    apiClient = axios.create(apiClientOptions);
+  } catch (error) {
+    console.error("Error creating API client", error);
+    throw error;
+  }
   const userId = [...Array(30)].map(() => Math.random().toString(36)[2]).join("");
   return {
     settings: fetchSettings(apiClient),
     videos: {
       list: fetchVideos(apiClient),
-      get: fetchVideo(apiClient)
+      get: fetchVideo(apiClient),
+      search: searchVideos(apiClient)
     },
     playlists: {
       list: fetchPlaylists(apiClient),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@boldvideo/bold-js",
   "license": "MIT",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -12,10 +12,10 @@
   },
   "devDependencies": {
     "@changesets/cli": "^2.26.0",
-    "tsup": "^6.6.3",
+    "tsup": "^6.7.0",
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "axios": "^1.3.4"
+    "axios": "^1.3.6"
   }
 }

package/src/lib/client.ts

@@ -1,6 +1,6 @@
 import axios, { AxiosInstance } from "axios";
 
-import { fetchVideo, fetchVideos, fetchSettings, fetchPlaylist, fetchPlaylists } from './fetchers'
+import { fetchVideo, fetchVideos, searchVideos, fetchSettings, fetchPlaylist, fetchPlaylists } from './fetchers'
 import { trackEvent, trackPageView } from './tracking'
 
 type ClientOptions = {
@@ -9,6 +9,10 @@ type ClientOptions = {
 }
 
 function createClient(apiKey: string, options: ClientOptions = {debug: false}) {
+  if (!apiKey || typeof apiKey !== 'string') {
+    throw new Error('API key is missing or invalid');
+  }
+
   const { debug } = options;
   const apiClientOptions = {
     baseURL: options.baseURL ?? "https://app.boldvideo.io/api/v1/",
@@ -17,7 +21,14 @@ function createClient(apiKey: string, options: ClientOptions = {debug: false}) {
     },
   };
 
-  const apiClient: AxiosInstance = axios.create(apiClientOptions);
+  let apiClient: AxiosInstance;
+
+  try {
+    apiClient = axios.create(apiClientOptions);
+  } catch (error) {
+    console.error("Error creating API client", error);
+    throw error;
+  }
 
   const userId = [...Array(30)]
     .map(() => Math.random().toString(36)[2])
@@ -28,6 +39,7 @@ function createClient(apiKey: string, options: ClientOptions = {debug: false}) {
     videos: {
       list: fetchVideos(apiClient),
       get: fetchVideo(apiClient),
+      search: searchVideos(apiClient),
     },
     playlists: {
       list: fetchPlaylists(apiClient),

package/src/lib/fetchers.ts

@@ -1,33 +1,96 @@
-import { Video, Playlist, Settings } from './types'
-import { AxiosInstance } from 'axios'
+import { Video, Playlist, Settings } from "./types";
+import { AxiosInstance } from "axios";
 
 type Response<T> = {
-  data: T
-}
+  data: T;
+};
 
 type ApiClient = AxiosInstance;
 
-async function get<TResponse>(client: ApiClient, url: string): Promise<TResponse> {
-  const res = await client.get(url);
-  return res.data as TResponse;
+async function get<TResponse>(
+  client: ApiClient,
+  url: string
+): Promise<TResponse> {
+  try {
+    const res = await client.get(url);
+    if (res.status !== 200) {
+      throw new Error(`Unexpected response status: ${res.status}`);
+    }
+    return res.data as TResponse;
+  } catch (error) {
+    console.error(`Error fetching data from URL: ${url}`, error);
+    throw error;
+  }
 }
 
 export function fetchSettings(client: ApiClient) {
-  return async (videoLimit = 12) => get<Response<Settings>>(client, `settings?limit=${videoLimit}`);
+  return async (videoLimit = 12) => {
+    try {
+      return await get<Response<Settings>>(
+        client,
+        `settings?limit=${videoLimit}`
+      );
+    } catch (error) {
+      console.error(`Error fetching settings with limit: ${videoLimit}`, error);
+      throw error;
+    }
+  };
 }
 
 export function fetchVideos(client: ApiClient) {
-  return async (videoLimit = 12) => get<Response<Video[]>>(client, `videos/latest?limit=${videoLimit}`);
+  return async (videoLimit = 12) => {
+    try {
+      return await get<Response<Video[]>>(
+        client,
+        `videos/latest?limit=${videoLimit}`
+      );
+    } catch (error) {
+      console.error(`Error fetching videos with limit: ${videoLimit}`, error);
+      throw error;
+    }
+  };
+}
+
+export function searchVideos(client: ApiClient) {
+  return async (term: string) => {
+    try {
+      return await get<Response<Video[]>>(client, `videos?query=${term}`);
+    } catch (error) {
+      console.error(`Error searching for videos with term: ${term}`, error);
+      throw error;
+    }
+  };
 }
 
 export function fetchVideo(client: ApiClient) {
-  return async (id: string) => get<Response<Video>>(client, `videos/${id}`);
+  return async (id: string) => {
+    try {
+      return await get<Response<Video>>(client, `videos/${id}`);
+    } catch (error) {
+      console.error(`Error fetching video with ID: ${id}`, error);
+      throw error;
+    }
+  };
 }
 
 export function fetchPlaylists(client: ApiClient) {
-  return async () => get<Response<Playlist[]>>(client, "playlists");
+  return async () => {
+    try {
+      return await get<Response<Playlist[]>>(client, "playlists");
+    } catch (error) {
+      console.error("Error fetching playlists", error);
+      throw error;
+    }
+  };
 }
 
 export function fetchPlaylist(client: ApiClient) {
-  return async (id: string) => get<Response<Playlist>>(client, `playlists/${id}`);
+  return async (id: string) => {
+    try {
+      return await get<Response<Playlist>>(client, `playlists/${id}`);
+    } catch (error) {
+      console.error(`Error fetching playlist with ID: ${id}`, error);
+      throw error;
+    }
+  };
 }

package/src/lib/tracking.ts

@@ -58,6 +58,7 @@ export function trackEvent(
       videoId: video.id,
       title: video.title,
       videoDuration: video.duration,
+      // TODO: change to currentTime of HTMLMediaElement
       timeStamp: event.timeStamp,
     };
     // debounce fast hitting timeupdate event