itube-specs 0.0.804 → 0.0.805

package/middleware/age.global.ts

@@ -0,0 +1,25 @@
+// Возрастная верификация: СЕЙЧАС ОТКЛЮЧЕНА (middleware сразу возвращает return).
+// Логика проверки гео + статуса верификации с редиректом на форму сохранена ниже
+// в закомментированном виде — раскомментировать при включении.
+// import { isGeoMatch, getAgeValidationUrl, isAgeVerified } from '../runtime';
+// import { navigateTo } from '#app';
+
+export default defineNuxtRouteMiddleware(async (_to) => {
+  return;
+  // if (!import.meta.server) return;
+  // if (to.path.startsWith('/bff/age/verify')) return;
+  //
+  // const event = useRequestEvent();
+  //
+  // const config = useRuntimeConfig();
+  // if (!(await isGeoMatch(event, config))) return;
+  //
+  // const verified = await isAgeVerified(event, config);
+  //
+  // if (!verified) {
+  //     const { url } = await getAgeValidationUrl(event, to.path, config);
+  //     if (url) {
+  //         return navigateTo(url, { external: true });
+  //     }
+  // }
+});

package/middleware/auth.global.ts

@@ -0,0 +1,35 @@
+// Глобальный auth-middleware: при наличии jwtoken-куки подтягивает профиль в
+// useState('profileData') один раз за сессию (если ещё не загружен). На 400/401
+// считает токен невалидным и чистит куку. Работает и на SSR, и на клиенте.
+export default defineNuxtRouteMiddleware(async () => {
+  const cookie = useCookie('jwtoken', { path: '/', secure: true, httpOnly: false, sameSite: 'lax' });
+  if (!cookie.value) return;
+
+  const profileData = useState<any>('profileData', () => null);
+  if (profileData.value) return;
+
+  const headers = import.meta.server ? useRequestHeaders(['cookie']) : {};
+
+  const runtimeConfig = useRuntimeConfig();
+  const fetchProfile = () => $fetch('/bff/authorization/get-profile', {
+    headers: {
+      ...headers,
+      'x-domain': runtimeConfig.public.xDomain,
+      'Content-Type': 'application/json',
+    },
+  });
+
+  try {
+    profileData.value = await fetchProfile();
+  } catch (error: any) {
+    if (error?.statusCode === 400 || error?.statusCode === 401) {
+      cookie.value = null;
+      if (import.meta.client) {
+        // Nuxt-кука не всегда удаляется на клиенте с нужным domain — дочищаем вручную
+        document.cookie = `jwtoken=; path=/; domain=${runtimeConfig.public.xDomain}; expires=Thu, 01 Jan 1970 00:00:00 GMT; Secure`;
+      }
+    } else {
+      console.error('Error get profile:', error);
+    }
+  }
+});

package/middleware/normalize.global.ts

@@ -0,0 +1,27 @@
+// Глобальный middleware: нормализует URL (path + query) и делает 301-редирект,
+// если текущий адрес отличается от канонического. Пути из EXCLUDED_PATHS пропускаются.
+import { normalizeUrl } from '../runtime';
+
+const EXCLUDED_PATHS = [
+  '/confirm/registration',
+  '/authorization/confirm'
+];
+
+export default defineNuxtRouteMiddleware((to) => {
+  if (EXCLUDED_PATHS.some((path) => to.path.includes(path))) return;
+
+  const normalized = normalizeUrl(to);
+
+  const samePath = normalized.path === to.path;
+  const sameQuery = JSON.stringify(normalized.query) === JSON.stringify(to.query);
+
+  if (samePath && sameQuery) return;
+
+  return navigateTo(
+    {
+      path: normalized.path,
+      query: normalized.query
+    },
+    { replace: true, redirectCode: 301 }
+  );
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "itube-specs",
   "type": "module",
-  "version": "0.0.804",
+  "version": "0.0.805",
   "main": "./nuxt.config.ts",
   "types": "./types/index.d.ts",
   "scripts": {
@@ -52,6 +52,9 @@
     "utils/",
     "types/",
     "lib/",
+    "middleware/",
+    "plugins/",
+    "server/",
     "nuxt.config.ts"
   ],
   "devDependencies": {

package/plugins/countries.server.ts

@@ -0,0 +1,84 @@
+// SSR-плагин: по ISO-коду клиента резолвит имя страны в useState('clientCountryName')
+// для гео-заголовка. Полный список стран в payload не кладётся (его лениво догружает
+// селектор языка на клиенте). Результат кэшируется в куку и в память процесса.
+import type { ICountries, ISelectItem } from '../types';
+import { isoCodeMap } from '../utils/iso-code-map';
+
+const COOKIE_OPTS = { maxAge: 60 * 60 * 24 * 365, path: '/', secure: true, sameSite: 'lax' as const };
+
+type CountriesCache = {
+  items: ISelectItem[];
+  nameByIso: Map<string, string>;
+};
+
+const cache = new Map<string, Promise<CountriesCache | null>>();
+
+function buildCache(data: ICountries): CountriesCache {
+  const items: ISelectItem[] = [];
+  const nameByIso = new Map<string, string>();
+
+  for (const item of data.countries) {
+    const iso = item.isoCodes[0].toLowerCase();
+    items.push({
+      title: item.title,
+      value: item.title,
+      icon: isoCodeMap[iso] || iso,
+      key: iso,
+    });
+    for (const code of item.isoCodes) {
+      nameByIso.set(code.toLowerCase(), item.title);
+    }
+  }
+  return { items, nameByIso };
+}
+
+function getCountries(language: string, domain: string): Promise<CountriesCache | null> {
+  const key = `${language}|${domain}`;
+  let promise = cache.get(key);
+  if (!promise) {
+    promise = $fetch<ICountries>('/api/dictionaries/countries', {
+      headers: { 'x-language': language, 'x-domain': domain },
+    })
+      .then(data => (data?.countries?.length ? buildCache(data) : null))
+      .catch(() => {
+        cache.delete(key);
+        return null;
+      });
+    cache.set(key, promise);
+  }
+  return promise;
+}
+
+export default defineNuxtPlugin(async () => {
+  const event = useRequestEvent();
+  const code = (event?.context?.clientCountryCode as string | undefined) || '';
+
+  const countryName = useState<string>('clientCountryName', () => '');
+
+  // Резолвим только имя текущей страны для гео-заголовка. Полный список стран
+  // НЕ кладём в useState (не сериализуем в payload) — language.vue догружает
+  // его лениво на клиенте при открытии селектора.
+  if (!code) return;
+
+  const codeCookie = useCookie<string>('clientCountryNameCode', COOKIE_OPTS);
+  const nameCookie = useCookie<string>('clientCountryName', COOKIE_OPTS);
+
+  // Тёплая кука → имя уже известно, серверный фетч стран не нужен.
+  if (nameCookie.value && codeCookie.value === code) {
+    countryName.value = nameCookie.value;
+    return;
+  }
+
+  const language = useRequestHeaders(['x-language'])['x-language'] ?? '';
+  const domain = useRuntimeConfig().public.xDomain as string;
+
+  const result = await getCountries(language, domain);
+  if (!result) return;
+
+  const name = result.nameByIso.get(code.toLowerCase());
+  if (name) {
+    countryName.value = name;
+    nameCookie.value = name;
+    codeCookie.value = code;
+  }
+});

package/plugins/country.server.ts

@@ -0,0 +1,7 @@
+// SSR-плагин: переносит ISO-код страны клиента (определён в server/middleware/country.ts)
+// из event.context в useState('clientCountryCode'), чтобы он был доступен в приложении.
+export default defineNuxtPlugin((_nuxtApp) => {
+  const event = useRequestEvent();
+  const code = event?.context?.clientCountryCode || '';
+  useState<string>('clientCountryCode', () => code);
+});

package/plugins/mobile.server.ts

@@ -0,0 +1,8 @@
+// SSR-плагин: определяет мобильное устройство по User-Agent и кладёт результат
+// в useState('isMobile'), чтобы разметка совпадала на сервере и клиенте.
+import { isMobileDevice } from '../runtime';
+
+export default defineNuxtPlugin(() => {
+  const ua = useRequestHeaders(['user-agent'])['user-agent'] ?? '';
+  useState<boolean>('isMobile', () => isMobileDevice(ua));
+});

package/plugins/services.client.ts

@@ -0,0 +1,17 @@
+// Регистрирует app-wide статические сервисы (SiteDataService) как $services
+// через useState('global-services'), чтобы они были доступны во всём приложении.
+import { SiteDataService } from '../services/site-data.service';
+
+export default defineNuxtPlugin(() => {
+  const services = useState('global-services', () => {
+    return {
+      [SiteDataService.getServiceName()]: SiteDataService,
+    };
+  });
+
+  return {
+    provide: {
+      services
+    }
+  };
+});

package/server/api/categories/get-categories-by-name.get.ts

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

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

@@ -0,0 +1,30 @@
+import type { ICategoryCard, IMultiSuggest, IRawCategoryCard } from '../../../types';
+import { cleanCategoryCard, getUrlWithProxiedParams } from '../../../runtime';
+
+export default defineEventHandler(async (event): Promise<ICategoryCard[]> => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+
+  const suggestUrl = getUrlWithProxiedParams(`${apiUrl}/v1/search/multi-suggest`, event);
+  const categoriesUrl = getUrlWithProxiedParams(`${apiUrl}/v1/categories`, event);
+
+  const headers = getRequestHeaders(event);
+
+  const [suggestRaw, categoriesRaw] = await Promise.all([
+    apiFetch(suggestUrl, { method: 'GET', headers: headers as HeadersInit }),
+    apiFetch(categoriesUrl, { method: 'GET', headers: headers as HeadersInit }),
+  ]);
+
+  const suggestData = suggestRaw.data as IMultiSuggest;
+  const categoriesData = categoriesRaw.data as IRawCategoryCard[];
+
+  // Если нет категорий в suggestData — возвращаем пустой массив
+  if (!suggestData?.categories?.length) {
+    return [];
+  }
+
+  const categoriesResult = suggestData.categories.map(item => item?.title.replace(/<[^>]+>/g, ''));
+
+  return categoriesData
+    .filter(item => categoriesResult.includes(item.title))
+    .map(cleanCategoryCard);
+});

package/server/api/categories/get-top-random-footer.get.ts

@@ -0,0 +1,11 @@
+import type { IRawCategoryCard } from '../../../types';
+import { getUrlWithProxiedParams, convertCategoriesToFooter } from '../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/categories/top-random`, event);
+
+  const categories = await cachedApiFetch<Array<IRawCategoryCard>>(url, event);
+
+  return convertCategoriesToFooter(categories);
+});

package/server/api/categories/get-top-random-full.get.ts

@@ -0,0 +1,11 @@
+import { cleanCategoryCard, getUrlWithProxiedParams } from '../../../runtime';
+import type { IRawCategoryCard } from '../../../types';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/categories/top-random`, event);
+
+  const categories = await cachedApiFetch<Array<IRawCategoryCard>>(url, event);
+
+  return categories.map(cleanCategoryCard);
+});

package/server/api/categories/get-top-random.get.ts

@@ -0,0 +1,11 @@
+import type { IRawCategoryCard } from '../../../types';
+import { getUrlWithProxiedParams, convertCategoriesToChips } from '../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/categories/top-random`, event);
+
+  const categories = await cachedApiFetch<Array<IRawCategoryCard>>(url, event);
+
+  return convertCategoriesToChips(categories, 'categories');
+});

package/server/api/categories/group-categories.get.ts

@@ -0,0 +1,23 @@
+import { cleanCategoryCard, getUrlWithProxiedParams } from '../../../runtime';
+import type { IRawGroupCategories } from '../../../types';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/groups-categories/all`, event);
+
+  const data = await cachedApiFetch<{ items?: IRawGroupCategories[] }>(url, event, 600);
+
+  const items = data?.items;
+
+  return Array.isArray(items)
+    ? items.map((item: IRawGroupCategories) => ({
+      name: item.name,
+      title: item.title,
+      weight: item.weight,
+      icon: item.icon,
+      categories: Array.isArray(item.categories)
+        ? item.categories.map(cleanCategoryCard)
+        : []
+    }))
+    : [];
+});

package/server/api/categories/list-by-letter.post.ts

@@ -0,0 +1,22 @@
+import type { IRawCategoryCard } from '../../../types';
+import { cleanMiniCategoryCard, getUrlWithProxiedParams, groupObjectsByFirstLetter } from '../../../runtime';
+
+export default defineEventHandler(async (event) => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/categories`, event);
+
+  const categories = await cachedApiFetch<Array<IRawCategoryCard>>(url, event);
+
+  const { letter } = getQuery<{ letter?: string }>(event);
+
+  if (!letter) {
+    return [];
+  }
+
+  const lang = event.node.req.headers[ 'x-language' ] || 'en';
+  const prop = getCategoryProp(lang);
+
+  const filtered = groupObjectsByFirstLetter(categories, prop)[ letter.toUpperCase() ] ?? [];
+
+  return filtered.map(cleanMiniCategoryCard);
+});

package/server/api/categories/list-grouped-by-letter-chips.get.ts

@@ -0,0 +1,20 @@
+import type { IChipsItem, IRawCategoryCard } from '../../../types';
+import {
+  convertStringArrayToChips,
+  getUrlWithProxiedParams,
+  groupCategoriesByFirstLetter,
+} from '../../../runtime';
+
+export default defineEventHandler(async (event): Promise<IChipsItem[]> => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/categories`, event);
+
+  const categories = await cachedApiFetch<Array<IRawCategoryCard>>(url, event);
+
+  const lang = event.node.req.headers['x-language'] || 'en';
+  const prop = getCategoryProp(lang);
+
+  const items = groupCategoriesByFirstLetter(categories, prop, getCategorySortLang(lang));
+
+  return convertStringArrayToChips(Object.keys(items), 'categories/letter', 'categories/all');
+});

package/server/api/categories/list-grouped-by-letter.get.ts

@@ -0,0 +1,14 @@
+import type { ICategoryCard, IRawCategoryCard } from '../../../types';
+import { getUrlWithProxiedParams, groupCategoriesByFirstLetter } from '../../../runtime';
+
+export default defineEventHandler(async (event): Promise<Record<string, Array<ICategoryCard>>> => {
+  const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+  const url = getUrlWithProxiedParams(`${apiUrl}/v1/categories`, event);
+
+  const categories = await cachedApiFetch<Array<IRawCategoryCard>>(url, event);
+
+  const lang = event.node.req.headers['x-language'] || 'en';
+  const prop = getCategoryProp(lang);
+
+  return groupCategoriesByFirstLetter(categories, prop, getCategorySortLang(lang));
+});

package/server/api/categories/related-phrases-by-name.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/categories/related-phrases-by-name`, event);
+
+  return await cachedApiFetch(url, event, 600);
+});