itube-specs 0.0.804 → 0.0.806

package/server/api/channels/channels-by-network-name/[slug].get.ts

@@ -0,0 +1,26 @@
+import type { IChannelCard, IRawChannelCard } from '../../../../types';
+import { cleanChannelCard, getUrlWithProxiedParams } from '../../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const slug = getRouterParam(event, 'slug');
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/channels/by-network/${slug}`, event);
+
+  const clientHeaders = event.node.req.headers as HeadersInit;
+
+  const rawData = await apiFetch(url, {
+    method: 'GET',
+    headers: clientHeaders,
+  });
+
+  const items: IRawChannelCard[] = rawData.data?.items || [];
+
+  const cleanedItems: IChannelCard[] = items.map(cleanChannelCard);
+
+  return {
+    currentPage: rawData.data?.current_page,
+    allPages: rawData.data?.all_pages,
+    total: rawData.data?.total,
+    items: cleanedItems,
+  };
+});

package/server/api/channels/channels.get.ts

@@ -0,0 +1,25 @@
+import type { IChannelCard, IRawChannelCard } from '../../../types';
+import { cleanChannelCard, getUrlWithProxiedParams } from '../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/channels`, event);
+
+  const data = await cachedApiFetch<{
+        items?: IRawChannelCard[];
+        current_page?: number;
+        all_pages?: number;
+        total?: number;
+    }>(url, event, 600);
+
+  const items: IRawChannelCard[] = data?.items || [];
+
+  const cleanedItems: IChannelCard[] = items.map(cleanChannelCard);
+
+  return {
+    currentPage: data?.current_page,
+    allPages: data?.all_pages,
+    total: data?.total,
+    items: cleanedItems,
+  };
+});

package/server/api/contacts/email.post.ts

@@ -0,0 +1,12 @@
+import { getUrlWithProxiedParams } from '../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/contacts/email`, event);
+
+  return await apiFetch(url, {
+    method: 'POST',
+    headers: getRequestHeaders(event) as HeadersInit,
+    body: JSON.stringify(await readBody(event)),
+  });
+});

package/server/api/dictionaries/countries.get.ts

@@ -0,0 +1,8 @@
+import { getUrlWithProxiedParams } from '../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/countries`, event);
+
+  return await cachedApiFetch(url, event, 3600);
+});

package/server/api/dictionaries/genders.get.ts

@@ -0,0 +1,8 @@
+import { getUrlWithProxiedParams } from '../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/genders`, event);
+
+  return await cachedApiFetch(url, event, 3600);
+});

package/server/api/models/get-info-by-name.get.ts

@@ -0,0 +1,10 @@
+import { cleanModelInfo, getUrlWithProxiedParams } from '../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v2/models/get-info-by-name`, event);
+
+  const data = await cachedApiFetch(url, event, 300);
+
+  return cleanModelInfo(data);
+});

package/server/api/models/get-models-by-phrase.get.ts

@@ -0,0 +1,25 @@
+import { cleanModelCard, getUrlWithProxiedParams } from '../../../runtime';
+import type { IRawModelCard, IModelCard } from '../../../types';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v2/models/search`, event);
+
+  const clientHeaders = event.node.req.headers as HeadersInit;
+
+  const rawData = await apiFetch(url, {
+    method: 'GET',
+    headers: clientHeaders,
+  });
+
+  const items: IRawModelCard[] = rawData.data?.items || [];
+
+  const cleanedItems: IModelCard[] = items.map(cleanModelCard);
+
+  return {
+    currentPage: rawData.data?.current_page,
+    allPages: rawData.data?.all_pages,
+    total: rawData.data?.total,
+    items: cleanedItems,
+  };
+});

package/server/api/models/get-top-chips.get.ts

@@ -0,0 +1,11 @@
+import type { IRawModelCard, PaginatedResponse } from '../../../types';
+import { convertModelCardToChips, getUrlWithProxiedParams } from '../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v2/models/top`, event);
+
+  const models = await cachedApiFetch<PaginatedResponse<IRawModelCard>>(url, event);
+
+  return convertModelCardToChips(models.items);
+});

package/server/api/models/list-by-category/[category].get.ts

@@ -0,0 +1,26 @@
+import { cleanModelCard, getUrlWithProxiedParams } from '../../../../runtime';
+import type { IRawModelCard, IModelCard } from '../../../../types';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const category = getRouterParam(event, 'category');
+  const url = getUrlWithProxiedParams(`${apiUrl}/v2/models/list-by-category/${category}`, event);
+
+  const clientHeaders = event.node.req.headers as HeadersInit;
+
+  const rawData = await apiFetch(url, {
+    method: 'GET',
+    headers: clientHeaders,
+  });
+
+  const items: IRawModelCard[] = rawData.data?.items || [];
+
+  const cleanedItems: IModelCard[] = items.map(cleanModelCard);
+
+  return {
+    currentPage: rawData.data?.current_page,
+    allPages: rawData.data?.all_pages,
+    total: rawData.data?.total,
+    items: cleanedItems,
+  };
+});

package/server/api/models/list-by-channel/[channel].get.ts

@@ -0,0 +1,26 @@
+import { cleanModelCard, getUrlWithProxiedParams } from '../../../../runtime';
+import type { IRawModelCard, IModelCard } from '../../../../types';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const channel = getRouterParam(event, 'channel');
+  const url = getUrlWithProxiedParams(`${apiUrl}/v2/models/list-by-channel/${channel}`, event);
+
+  const clientHeaders = event.node.req.headers as HeadersInit;
+
+  const rawData = await apiFetch(url, {
+    method: 'GET',
+    headers: clientHeaders,
+  });
+
+  const items: IRawModelCard[] = rawData.data?.items || [];
+
+  const cleanedItems: IModelCard[] = items.map(cleanModelCard);
+
+  return {
+    currentPage: rawData.data?.current_page,
+    allPages: rawData.data?.all_pages,
+    total: rawData.data?.total,
+    items: cleanedItems,
+  };
+});

package/server/api/models/list-by-first-letter-chips.get.ts

@@ -0,0 +1,11 @@
+import type { IRawModelCard, PaginatedResponse } from '../../../types';
+import { convertModelCardToChips, getUrlWithProxiedParams } from '../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v2/models/list-by-first-letter`, event);
+
+  const models = await cachedApiFetch<PaginatedResponse<IRawModelCard>>(url, event);
+
+  return convertModelCardToChips(models.items);
+});

package/server/api/models/list-by-first-letter.get.ts

@@ -0,0 +1,18 @@
+import { cleanModelCard, getUrlWithProxiedParams } from '../../../runtime';
+import type { IRawModelCard, IModelCard, PaginatedResponse } from '../../../types';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v2/models/list-by-first-letter`, event);
+
+  const data = await cachedApiFetch<PaginatedResponse<IRawModelCard>>(url, event);
+
+  const cleanedItems: IModelCard[] = (data.items || []).map(cleanModelCard);
+
+  return {
+    currentPage: data.current_page,
+    allPages: data.all_pages,
+    total: data.total,
+    items: cleanedItems,
+  };
+});

package/server/api/models/list-by-niche.post.ts

@@ -0,0 +1,30 @@
+import { cleanModelCard, getUrlWithProxiedParams } from '../../../runtime';
+import type { IModelFilter, IRawModelCard, IModelCard } from '../../../types';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v2/models/filter`, event);
+
+  const clientHeaders = event.node.req.headers as HeadersInit;
+
+  const body = await readBody(event);
+
+  const rawData = await apiFetch(url, {
+    method: 'POST',
+    headers: clientHeaders,
+    body: JSON.stringify(body),
+  });
+
+  const items: IRawModelCard[] = rawData?.data?.items || [];
+  const filters: IModelFilter[] = rawData?.data?.filters || [];
+
+  const cleanedItems: IModelCard[] = items && items.length > 0 ? items.map(cleanModelCard) : [];
+
+  return {
+    currentPage: rawData?.data?.current_page,
+    allPages: rawData?.data?.all_pages,
+    total: rawData?.data?.total,
+    items: cleanedItems,
+    filters: filters,
+  };
+});

package/server/api/models/list-by-tag/[tag].get.ts

@@ -0,0 +1,26 @@
+import { cleanModelCard, getUrlWithProxiedParams } from '../../../../runtime';
+import type { IRawModelCard, IModelCard } from '../../../../types';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const tag = getRouterParam(event, 'tag');
+  const url = getUrlWithProxiedParams(`${apiUrl}/v2/models/list-by-tag/${tag}`, event);
+
+  const clientHeaders = event.node.req.headers as HeadersInit;
+
+  const rawData = await apiFetch(url, {
+    method: 'GET',
+    headers: clientHeaders,
+  });
+
+  const items: IRawModelCard[] = rawData.data?.items || [];
+
+  const cleanedItems: IModelCard[] = items.map(cleanModelCard);
+
+  return {
+    currentPage: rawData.data?.current_page,
+    allPages: rawData.data?.all_pages,
+    total: rawData.data?.total,
+    items: cleanedItems,
+  };
+});

package/server/api/models/related.get.ts

@@ -0,0 +1,25 @@
+import { cleanModelCard, getUrlWithProxiedParams } from '../../../runtime';
+import type { IRawModelCard, IModelCard } from '../../../types';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v2/models/related`, event);
+
+  const clientHeaders = event.node.req.headers as HeadersInit;
+
+  const rawData = await apiFetch(url, {
+    method: 'GET',
+    headers: clientHeaders,
+  });
+
+  const items: IRawModelCard[] = rawData.data?.items || [];
+
+  const cleanedItems: IModelCard[] = items.map(cleanModelCard);
+
+  return {
+    currentPage: rawData.data?.current_page,
+    allPages: rawData.data?.all_pages,
+    total: rawData.data?.total,
+    items: cleanedItems,
+  };
+});

package/server/api/models/top.get.ts

@@ -0,0 +1,18 @@
+import { cleanModelCard, getUrlWithProxiedParams } from '../../../runtime';
+import type { IRawModelCard, IModelCard, PaginatedResponse } from '../../../types';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v2/models/top`, event);
+
+  const data = await cachedApiFetch<PaginatedResponse<IRawModelCard>>(url, event);
+
+  const cleanedItems: IModelCard[] = (data?.items || []).map(cleanModelCard);
+
+  return {
+    currentPage: data?.current_page,
+    allPages: data?.all_pages,
+    total: data?.total,
+    items: cleanedItems,
+  };
+});

package/server/api/playlist/delete-playlist/[id].delete.ts

@@ -0,0 +1,12 @@
+import { getUrlWithProxiedParams } from '../../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const id = getRouterParam(event, 'id');
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/playlist/${id}`, event);
+
+  return await apiFetch(url, {
+    method: 'DELETE',
+    headers: getRequestHeaders(event) as HeadersInit,
+  });
+});

package/server/api/playlist/delete-video/[pid]/[vid].delete.ts

@@ -0,0 +1,18 @@
+import { getUrlWithProxiedParams } from '../../../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+
+  const pid = getRouterParam(event, 'pid');
+  const vid = getRouterParam(event, 'vid');
+
+  const url = getUrlWithProxiedParams(
+    `${apiUrl}/v1/playlist/${pid}/video/${vid}`,
+    event
+  );
+
+  return await apiFetch(url, {
+    method: 'DELETE',
+    headers: getRequestHeaders(event) as HeadersInit,
+  });
+});

package/server/api/playlist/get-playlist-by-id/[id].get.ts

@@ -0,0 +1,16 @@
+import { cleanPlaylistData, getUrlWithProxiedParams } from '../../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const id = getRouterParam(event, 'id');
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/playlist/${id}`, event);
+
+  const clientHeaders = event.node.req.headers as HeadersInit;
+
+  const rawData = await apiFetch(url, {
+    method: 'GET',
+    headers: clientHeaders,
+  });
+
+  return cleanPlaylistData(rawData.data);
+});

package/server/api/playlist/get-playlist-videos-by-id/[id].get.ts

@@ -0,0 +1,27 @@
+import { cleanPlaylistVideo, getUrlWithProxiedParams } from '../../../../runtime';
+import type { IRawPlaylistVideo, IVideoCard } from '../../../../types';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const id = getRouterParam(event, 'id');
+
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/video/list-by-playlist-id/${id}`, event);
+
+  const clientHeaders = event.node.req.headers as HeadersInit;
+
+  const rawData = await apiFetch(url, {
+    method: 'GET',
+    headers: clientHeaders,
+  });
+
+  const items: IRawPlaylistVideo[] = rawData?.data?.items || [];
+
+  const cleanedItems: IVideoCard[] = items.map(cleanPlaylistVideo);
+
+  return {
+    currentPage: rawData.data?.currentPage,
+    allPages: rawData.data?.allPages,
+    total: rawData.data?.total,
+    items: cleanedItems,
+  };
+});

package/server/api/playlist/get-user-playlists.get.ts

@@ -0,0 +1,49 @@
+import {
+  cleanPlaylistCard,
+  cleanUserPlaylistCard,
+  getUrlWithProxiedParams,
+} from '../../../runtime';
+import type { IRawPlaylistsUser, IPlaylistCard, IRawPlaylistCard, PaginatedResponse } from '../../../types';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const playlistUrl = getUrlWithProxiedParams(`${apiUrl}/v1/playlist`, event);
+  const myPlaylistByNicheUrl = getUrlWithProxiedParams(`${apiUrl}/v1/playlist/my-list-by-niche`, event);
+
+  const clientHeaders = event.node.req.headers as HeadersInit;
+
+  const [playlistRaw, myPlaylistByNicheRaw] = await Promise.all([
+    apiFetch(playlistUrl, {
+      method: 'GET',
+      headers: clientHeaders,
+    }),
+    apiFetch(myPlaylistByNicheUrl, { method: 'GET', headers: clientHeaders }),
+  ]);
+
+  const playlist = playlistRaw.data as PaginatedResponse<IRawPlaylistsUser>;
+  const myPlaylistByNiche = myPlaylistByNicheRaw.data as PaginatedResponse<IRawPlaylistCard>;
+
+  const playlistItems: IPlaylistCard[] = playlist?.playlists?.map(cleanUserPlaylistCard);
+  const myPlaylistByNicheItems: IPlaylistCard[] = myPlaylistByNiche?.items?.map(cleanPlaylistCard);
+
+  const items = playlistItems?.map((item) => {
+    const myPlaylist = myPlaylistByNicheItems?.find(
+      (subItem) => subItem.id === item.id
+    );
+
+    return {
+      ...item,
+      views: myPlaylist?.views,
+      searchTags: myPlaylist?.searchTags,
+      likes: myPlaylist?.likes,
+      dislikes: myPlaylist?.dislikes,
+    };
+  });
+
+  return {
+    currentPage: playlist?.currentPage,
+    allPages: playlist?.allPages,
+    total: playlist?.total,
+    items: items,
+  };
+});

package/server/api/playlist/playlist-dislike/[md].post.ts

@@ -0,0 +1,13 @@
+import { getUrlWithProxiedParams } from '../../../../runtime';
+
+export default defineEventHandler(async (event): Promise<any> => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const md = getRouterParam(event, 'md');
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/playlist/${md}/dislike`, event);
+
+  return await apiFetch(url, {
+    method: 'POST',
+    headers: getRequestHeaders(event) as HeadersInit,
+    body: JSON.stringify(await readBody(event)),
+  });
+});

package/server/api/playlist/playlist-like/[md].post.ts

@@ -0,0 +1,13 @@
+import { getUrlWithProxiedParams } from '../../../../runtime';
+
+export default defineEventHandler(async (event): Promise<any> => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const md = getRouterParam(event, 'md');
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/playlist/${md}/like`, event);
+
+  return await apiFetch(url, {
+    method: 'POST',
+    headers: getRequestHeaders(event) as HeadersInit,
+    body: JSON.stringify(await readBody(event)),
+  });
+});

package/server/api/playlist/playlist-view/[id].post.ts

@@ -0,0 +1,13 @@
+import { getUrlWithProxiedParams } from '../../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const id = getRouterParam(event, 'id');
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/playlist/${id}/view`, event);
+
+  return await apiFetch(url, {
+    method: 'POST',
+    headers: getRequestHeaders(event) as HeadersInit,
+    body: JSON.stringify(await readBody(event)),
+  });
+});

package/server/api/playlist/playlists-list-by-niche.get.ts

@@ -0,0 +1,25 @@
+import { cleanPlaylistCard, getUrlWithProxiedParams } from '../../../runtime';
+import type { IRawPlaylistCard, IPlaylistCard } from '../../../types';
+
+export default defineEventHandler(async (event) => {
+    const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/playlist/list-by-niche`, event);
+
+    const clientHeaders = event.node.req.headers as HeadersInit;
+
+    const rawData = await apiFetch(url, {
+        method: 'GET',
+        headers: clientHeaders,
+    });
+
+    const items: IRawPlaylistCard[] = rawData.data?.items || [];
+
+    const cleanedItems: IPlaylistCard[] = items.map(cleanPlaylistCard);
+
+    return {
+        currentPage: rawData.data?.current_page,
+        allPages: rawData.data?.all_pages,
+        total: rawData.data?.total,
+        items: cleanedItems,
+    };
+});

package/server/api/playlist/post-playlist.post.ts

@@ -0,0 +1,12 @@
+import { getUrlWithProxiedParams } from '../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/playlist`, event);
+
+  return await apiFetch(url, {
+    method: 'POST',
+    headers: getRequestHeaders(event) as HeadersInit,
+    body: JSON.stringify(await readBody(event)),
+  });
+});

package/server/api/playlist/post-video.post.ts

@@ -0,0 +1,12 @@
+import { getUrlWithProxiedParams } from '../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/playlist/video`, event);
+
+  return await apiFetch(url, {
+    method: 'POST',
+    headers: getRequestHeaders(event) as HeadersInit,
+    body: JSON.stringify(await readBody(event)),
+  });
+});

package/server/api/playlist/refresh-playlist/[id].put.ts

@@ -0,0 +1,13 @@
+import { getUrlWithProxiedParams } from '../../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const id = getRouterParam(event, 'id');
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/playlist/${id}`, event);
+
+  return await apiFetch(url, {
+    method: 'PUT',
+    headers: getRequestHeaders(event) as HeadersInit,
+    body: JSON.stringify(await readBody(event)),
+  });
+});

package/server/api/search/multi-suggest.get.ts

@@ -0,0 +1,14 @@
+import { getUrlWithProxiedParams, convertSnakeKeysToCamel } from '../../../runtime';
+import type { IMultiSuggest } from '../../../types';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v2/search/multi-suggest`, event);
+
+  const rawData = await apiFetch(url, {
+    method: 'GET',
+    headers: getRequestHeaders(event) as HeadersInit,
+  });
+
+  return convertSnakeKeysToCamel<IMultiSuggest>(rawData.data);
+});

package/server/api/search/phrases.get.ts

@@ -0,0 +1,13 @@
+import { getUrlWithProxiedParams } from '../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/search/phrases`, event);
+
+  const rawData = await apiFetch(url, {
+    method: 'GET',
+    headers: getRequestHeaders(event) as HeadersInit,
+  });
+
+  return rawData.data ?? [];
+});

package/server/api/site/aabd.get.ts

@@ -0,0 +1,16 @@
+import { SiteDataService } from '../../../services/site-data.service';
+
+/* Нечитаемое имя для того, чтобы юзеры лишний раз не палили что за запрос */
+
+export default defineEventHandler(() => {
+  const domains = [...SiteDataService.getAntiAdblokDomains() || []];
+
+  if (!domains || domains.length === 0) {
+    return '';
+  }
+
+  const currentHour = new Date().getHours();
+  const index = currentHour % domains.length;
+
+  return domains[index];
+});

package/server/api/site/index.get.ts

@@ -0,0 +1,17 @@
+import type { ISiteData, ISiteLanguagesResponse, ISiteNichesResponse, ISiteResponse } from '../../../types';
+
+export default defineEventHandler(async (event): Promise<ISiteData> => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+
+  const [siteData, languagesResponse, nichesResponse] = await Promise.all([
+    cachedApiFetch<ISiteResponse>(`${apiUrl}/v1/site`, event, 3600),
+    cachedApiFetch<ISiteLanguagesResponse>(`${apiUrl}/v1/site/languages`, event, 3600),
+    cachedApiFetch<ISiteNichesResponse>(`${apiUrl}/v1/site/niches`, event, 3600),
+  ]);
+
+  return {
+    siteData,
+    languages: languagesResponse?.items || [],
+    niches: nichesResponse?.items || [],
+  };
+});