itube-specs 0.0.805 → 0.0.807

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "itube-specs",
   "type": "module",
-  "version": "0.0.805",
+  "version": "0.0.807",
   "main": "./nuxt.config.ts",
   "types": "./types/index.d.ts",
   "scripts": {

package/server/api/age/verify.post.ts

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

package/server/api/authorization/change-email.post.ts

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

package/server/api/authorization/change-password.post.ts

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

package/server/api/authorization/confirm.get.ts

@@ -0,0 +1,13 @@
+import { getUrlWithProxiedParams } from '../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const { token } = getQuery(event);
+
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/registration/confirm?token=${token}`, event);
+
+  return await apiFetch(url, {
+    method: 'GET',
+    headers: getHeaders(event) as HeadersInit,
+  });
+});

package/server/api/authorization/delete-profile.delete.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/profile`, event);
+
+  const rawData = await apiFetch(url, {
+    method: 'DELETE',
+    headers: getRequestHeaders(event) as HeadersInit,
+  });
+
+  return rawData.data ?? rawData;
+});

package/server/api/authorization/get-profile.get.ts

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

package/server/api/authorization/login.post.ts

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

package/server/api/authorization/password.post.ts

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

package/server/api/authorization/post-profile.post.ts

@@ -0,0 +1,15 @@
+import { getUrlWithProxiedParams } from '../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/profile`, event);
+
+  const rawData = await apiFetch(url, {
+    method: 'POST',
+    headers: getRequestHeaders(event) as HeadersInit,
+    body: getRequestWebStream(event) as any,
+    duplex: 'half',
+  } as any);
+
+  return rawData.data ?? rawData;
+});

package/server/api/authorization/profile-avatar.delete.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/profile/avatar`, event);
+
+  const rawData = await apiFetch(url, {
+    method: 'DELETE',
+    headers: getRequestHeaders(event) as HeadersInit,
+  });
+
+  return rawData.data ?? rawData;
+});

package/server/api/authorization/recovery-password.post.ts

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

package/server/api/authorization/register.post.ts

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

package/server/api/channels/channels-by-model/[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-model/${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-by-name/[slug].get.ts

@@ -0,0 +1,16 @@
+import { cleanChannelInfo, 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/${slug}`, event);
+
+  const clientHeaders = event.node.req.headers as HeadersInit;
+
+  const rawData = await apiFetch(url, {
+    method: 'GET',
+    headers: clientHeaders,
+  });
+
+  return cleanChannelInfo(rawData.data);
+});

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,
+  };
+});