itube-specs 0.0.780 → 0.0.781

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "itube-specs",
   "type": "module",
-  "version": "0.0.780",
+  "version": "0.0.781",
   "main": "./nuxt.config.ts",
   "types": "./types/index.d.ts",
   "scripts": {
@@ -39,12 +39,17 @@
       "import": "./lib/index.ts",
       "default": "./lib/index.ts"
     },
+    "./services/*": "./services/*.ts",
+    "./composables/*": "./composables/*.ts",
+    "./utils/*": "./utils/*.ts",
     "./*": "./*"
   },
   "files": [
     "runtime/",
     "components/",
     "composables/",
+    "services/",
+    "utils/",
     "types/",
     "lib/",
     "nuxt.config.ts"

package/services/__tests__/site-data.service.test.ts

@@ -0,0 +1,61 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { SiteDataService } from '../site-data.service';
+
+describe('SiteDataService', () => {
+  it('возвращает имя сервиса', () => {
+    expect(SiteDataService.getServiceName()).toBe('SiteDataService');
+  });
+
+  it('пустые геттеры коллекций отдают [] до загрузки данных', () => {
+    expect(SiteDataService.getAntiAdblokDomains()).toEqual([]);
+    expect(SiteDataService.getSiteLanguages()).toEqual([]);
+    expect(SiteDataService.getSiteNiches()).toEqual([]);
+  });
+
+  describe('fetchSiteData', () => {
+    const fetchMock = vi.fn();
+
+    beforeEach(() => {
+      vi.stubGlobal('$fetch', fetchMock);
+      fetchMock.mockReset();
+    });
+
+    afterEach(() => {
+      vi.unstubAllGlobals();
+    });
+
+    it('раскладывает ответы трёх эндпоинтов по геттерам', async () => {
+      fetchMock.mockImplementation((url: string) => {
+        if (url.endsWith('/v1/site')) {
+          return Promise.resolve({
+            data: { antiAdblockDomains: ['ads.example'], debugMode: false, enabled: true, recaptchaPublicKey: 'key' },
+          });
+        }
+        if (url.endsWith('/v1/site/languages')) {
+          return Promise.resolve({ data: { items: [{ guid: 'l1', title: 'English' }] } });
+        }
+        if (url.endsWith('/v1/site/niches')) {
+          return Promise.resolve({ data: { items: [{ guid: 'n1', title: 'Gay' }] } });
+        }
+        return Promise.resolve({ data: {} });
+      });
+
+      await SiteDataService.fetchSiteData();
+
+      expect(SiteDataService.getAntiAdblokDomains()).toEqual(['ads.example']);
+      expect(SiteDataService.isSiteEnabled()).toBe(true);
+      expect(SiteDataService.getSiteLanguages()).toEqual([{ guid: 'l1', title: 'English' }]);
+      expect(SiteDataService.getSiteNiches()).toEqual([{ guid: 'n1', title: 'Gay' }]);
+    });
+
+    it('ошибка запроса не пробрасывается наружу', async () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      fetchMock.mockRejectedValue(new Error('network'));
+
+      await expect(SiteDataService.fetchSiteData()).resolves.toBeUndefined();
+      expect(consoleSpy).toHaveBeenCalled();
+
+      consoleSpy.mockRestore();
+    });
+  });
+});

package/services/api/authorization.service.ts

@@ -0,0 +1,172 @@
+import type {
+  IRecoveryPasswordForm,
+  IProfileData,
+  IChangePasswordForm,
+  ILoginForm,
+  IPasswordForm,
+  IRegistrateForm,
+  IChangeEmail
+} from '../../types';
+import { ApiHelper } from '../../runtime';
+
+/** Сервис для работы с API авторизации */
+export class AuthorizationApiService {
+  static async recoveryPassword(data: IRecoveryPasswordForm): Promise<any> {
+    return await ApiHelper.fetch('/authorization/recovery-password', {
+      method: 'POST',
+      headers: {
+        'X-Cache-Time': 259200,
+        'Content-Type': 'application/json',
+      },
+      body: data,
+    },
+    useRuntimeConfig(),
+    );
+  }
+  static async changePassword(data: IChangePasswordForm): Promise<any> {
+    return await ApiHelper.fetch('/authorization/change-password', {
+      method: 'POST',
+      headers: {
+        'X-Cache-Time': 259200,
+        'Content-Type': 'application/json',
+      },
+      body: data,
+    },
+    useRuntimeConfig(),
+    );
+  }
+  static async changeEmail(data: IChangeEmail): Promise<any> {
+    return await ApiHelper.fetch('/authorization/change-email', {
+      method: 'POST',
+      headers: {
+        'X-Cache-Time': 259200,
+        'Content-Type': 'application/json',
+      },
+      body: data,
+    },
+    useRuntimeConfig(),
+    );
+  }
+  static async postProfile(data: FormData): Promise<any> {
+    return await ApiHelper.fetch('/authorization/post-profile', {
+      method: 'POST',
+      headers: {
+        'X-Cache-Time': 259200,
+      },
+      body: data,
+    },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async getProfile(): Promise<IProfileData | null> {
+    return await ApiHelper.fetch(
+      '/authorization/get-profile',
+      {
+        method: 'GET',
+        headers: {
+          'X-Cache-Time': 259200,
+          'Content-Type': 'application/json',
+        },
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async password(
+    data: IPasswordForm,
+  ): Promise<any> {
+    return await ApiHelper.fetch(
+      '/authorization/password',
+      {
+        method: 'POST',
+        headers: {
+          'X-Cache-Time': 259200,
+          'Content-Type': 'application/json',
+        },
+        body: data,
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async deleteProfile(): Promise<any> {
+    return await ApiHelper.fetch(
+      '/authorization/delete-profile',
+      {
+        method: 'DELETE',
+        headers: {
+          'X-Cache-Time': 259200,
+          'Content-Type': 'application/json',
+        },
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async deleteAvatar(): Promise<any> {
+    return await ApiHelper.fetch(
+      '/authorization/profile-avatar',
+      {
+        method: 'DELETE',
+        headers: {
+          'X-Cache-Time': 259200,
+          'Content-Type': 'application/json',
+        },
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async login(
+    data: ILoginForm,
+  ): Promise<any> {
+    return await ApiHelper.fetch(
+      '/authorization/login',
+      {
+        method: 'POST',
+        headers: {
+          'X-Cache-Time': 259200,
+          'Content-Type': 'application/json',
+        },
+        body: data,
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async register(
+    data: IRegistrateForm,
+  ): Promise<any> {
+    return await ApiHelper.fetch(
+      '/authorization/register',
+      {
+        method: 'POST',
+        headers: {
+          'X-Cache-Time': 259200,
+          'Content-Type': 'application/json',
+        },
+        body: data
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async confirmRegistration(token: string): Promise<any> {
+    return await ApiHelper.fetch(
+      '/authorization/confirm',
+      {
+        method: 'GET',
+        headers: {
+          'X-Cache-Time': 259200,
+          'X-Domain': useRuntimeConfig()?.public?.xDomain || useAppConfig().xDomain,
+          'Content-Type': 'application/json',
+        },
+        params: {
+          token,
+        }
+      },
+    useRuntimeConfig(),
+    );
+  }
+}

package/services/api/categories.service.ts

@@ -0,0 +1,239 @@
+import type { Language } from '../../runtime';
+import { ApiHelper, toHeaderLanguage } from '../../runtime';
+import type {
+    IRelatedPhrases,
+    ICategoryCard,
+    IGroupCategories,
+    ICardInfo, IChipsItem,
+} from '../../types';
+
+/** Сервис для работы с API категорий */
+export class CategoriesApiService {
+    static async getCategoriesByName(
+        lang: Language,
+        name: string,
+        niche? = NicheHelper.getSiteDefaultNiche(),
+    ): Promise<ICardInfo> {
+        return await ApiHelper.fetch(
+            '/categories/get-categories-by-name',
+            {
+                method: 'GET',
+                headers: {
+                    'X-Niche': niche,
+                    'X-Language': toHeaderLanguage(lang),
+                    'X-Cache-Time': 259200,
+                    'Content-Type': 'application/json',
+                },
+                params: {
+                    name: name,
+                },
+            },
+        useRuntimeConfig(),
+        );
+    }
+
+    static async getCategoriesByPhrase(
+        lang: Language,
+        phrase: string,
+        phrasesLimit: number,
+        modelsLimit: number,
+        categoriesLimit: number,
+        niche? = NicheHelper.getSiteDefaultNiche(),
+    ): Promise<Array<ICategoryCard>> {
+        return await ApiHelper.fetch(
+            '/categories/get-categories-by-phrase',
+            {
+                method: 'GET',
+                headers: {
+                    'X-Niche': niche,
+                    'X-Language': toHeaderLanguage(lang),
+                    'X-Cache-Time': 259200,
+                    'Content-Type': 'application/json',
+                },
+                params: {
+                    query: phrase,
+                    'phrases-limit': phrasesLimit,
+                    'models-limit': modelsLimit,
+                    'categories-limit': categoriesLimit,
+                },
+            },
+        useRuntimeConfig(),
+        );
+    }
+
+    static async getTopRandomFooter(
+        lang: Language,
+        niche? = NicheHelper.getSiteDefaultNiche(),
+        limit? = 29, // выводим максимально возможное колличество, из расчета 6 колонок по 5 рядов, и минус 1 это All categories
+    ): Promise<Array<IChipsItem>> {
+        return await ApiHelper.fetch(
+            '/categories/get-top-random-footer',
+            {
+                method: 'GET',
+                headers: {
+                    'X-Niche': niche,
+                    'X-Language': toHeaderLanguage(lang),
+                    'X-Cache-Time': 259200,
+                    'Content-Type': 'application/json',
+                },
+                params: {
+                    limit: limit,
+                },
+            },
+        useRuntimeConfig(),
+        );
+    }
+
+    static async getTopRandomFull(
+        lang: Language,
+        niche? = NicheHelper.getSiteDefaultNiche(),
+        limit? = 128,
+    ): Promise<Array<ICategoryCard>> {
+        return await ApiHelper.fetch(
+            '/categories/get-top-random-full',
+            {
+                method: 'GET',
+                headers: {
+                    'X-Niche': niche,
+                    'X-Language': toHeaderLanguage(lang),
+                    'X-Cache-Time': 259200,
+                    'Content-Type': 'application/json',
+                },
+                params: {
+                    limit: limit,
+                },
+            },
+        useRuntimeConfig(),
+        );
+    }
+
+    static async getRelatedCategories(
+        lang: Language,
+        name: string,
+        niche? = NicheHelper.getSiteDefaultNiche(),
+        limit? = 50,
+    ): Promise<IRelatedPhrases> {
+        return await ApiHelper.fetch(
+            '/categories/related-phrases-by-name',
+            {
+                method: 'GET',
+                headers: {
+                    'X-Niche': niche,
+                    'X-Language': toHeaderLanguage(lang),
+                    'X-Cache-Time': 259200,
+                    'Content-Type': 'application/json',
+                },
+                params: {
+                    limit: limit,
+                    name: name,
+                },
+            },
+        useRuntimeConfig(),
+        );
+    }
+
+    static async getTopRandom(
+        lang: Language,
+        cacheId = 'default',
+        niche? = NicheHelper.getSiteDefaultNiche(),
+        limit? = 20,
+    ): Promise<Array<IChipsItem>> {
+        return await ApiHelper.fetch(
+            '/categories/get-top-random',
+            {
+                method: 'GET',
+                headers: {
+                    'X-Niche': niche,
+                    'X-Cache-Extra': cacheId,
+                    'X-Language': toHeaderLanguage(lang),
+                    'X-Cache-Time': 604800,
+                    'Content-Type': 'application/json',
+                },
+                params: {
+                    limit: limit,
+                },
+            },
+        useRuntimeConfig(),
+        );
+    }
+
+    static async getListGroupedByLetter(
+        lang: Language,
+        niche? = NicheHelper.getSiteDefaultNiche(),
+    ): Promise<Record<string, Array<ICategoryCard>>> {
+        return await ApiHelper.fetch(
+            '/categories/list-grouped-by-letter',
+            {
+                method: 'GET',
+                headers: {
+                    'X-Niche': niche,
+                    'X-Language': toHeaderLanguage(lang),
+                    'X-Cache-Time': 259200,
+                    'Content-Type': 'application/json',
+                },
+            },
+        useRuntimeConfig(),
+        );
+    }
+
+    static async getListGroupedByLetterChips(
+        lang: Language,
+        niche? = NicheHelper.getSiteDefaultNiche(),
+    ): Promise<Record<string, Array<ICategoryCard>>> {
+        return await ApiHelper.fetch(
+            '/categories/list-grouped-by-letter-chips',
+            {
+                method: 'GET',
+                headers: {
+                    'X-Niche': niche,
+                    'X-Language': toHeaderLanguage(lang),
+                    'X-Cache-Time': 259200,
+                    'Content-Type': 'application/json',
+                },
+            },
+        useRuntimeConfig(),
+        );
+    }
+
+    static async getCategoriesByLetter(
+        lang: Language,
+        letter: string,
+        niche? = NicheHelper.getSiteDefaultNiche(),
+    ): Promise<Array<ICategoryCard>> {
+        return await ApiHelper.fetch(
+            '/categories/list-by-letter',
+            {
+                method: 'POST',
+                headers: {
+                    'X-Niche': niche,
+                    'X-Language': toHeaderLanguage(lang),
+                    'X-Cache-Time': 259200,
+                    'Content-Type': 'application/json',
+                },
+                params: {
+                    letter,
+                },
+            },
+        useRuntimeConfig(),
+        );
+    }
+
+    static async getGroupsCategories(
+        lang: Language,
+        niche? = NicheHelper.getSiteDefaultNiche(),
+    ): Promise<IGroupCategories[]> {
+        return await ApiHelper.fetch(
+            '/categories/group-categories',
+            {
+                method: 'GET',
+                headers: {
+                    'X-Niche': niche,
+                    'X-Language': toHeaderLanguage(lang),
+                    'X-Cache-Time': 259200,
+                    'Content-Type': 'application/json',
+                },
+            },
+        useRuntimeConfig(),
+        );
+    }
+}

package/services/api/channels.service.ts

@@ -0,0 +1,101 @@
+import type { RequestPagination, PaginatedResponse, IChannelCard, ICardInfo } from '../../types';
+import type { Language } from '../../runtime';
+import { ApiHelper, toHeaderLanguage } from '../../runtime';
+
+/** Сервис для работы с API каналов */
+export class ChannelsApiService {
+  static async getChannelsByNetworkName(
+    lang: Language,
+    pagination: RequestPagination,
+    slug: string,
+    niche? = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<PaginatedResponse<IChannelCard>> {
+    return await ApiHelper.fetch(
+      `/channels/channels-by-network-name/${slug}`,
+      {
+        method: 'GET',
+        headers: {
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': 259200,
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*',
+        },
+        params: {
+          ...pagination,
+        },
+      },
+    useRuntimeConfig(),
+    );
+  }
+  static async getChannelsByModel(
+    lang: Language,
+    pagination: RequestPagination,
+    slug: string,
+    niche? = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<PaginatedResponse<IChannelCard>> {
+    return await ApiHelper.fetch(
+      `/channels/channels-by-model/${slug}`,
+      {
+        method: 'GET',
+        headers: {
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': 259200,
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*',
+        },
+        params: {
+          ...pagination,
+        },
+      },
+    useRuntimeConfig(),
+    );
+  }
+  static async getChannelsByName(
+    lang: Language,
+    slug: string,
+    niche? = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<ICardInfo> {
+    return await ApiHelper.fetch(
+      `/channels/channels-by-name/${slug}`,
+      {
+        method: 'GET',
+        headers: {
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': 259200,
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*',
+        },
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async getChannels(
+    lang: Language,
+    pagination: RequestPagination,
+    order: string,
+    niche? = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<PaginatedResponse<IChannelCard>> {
+    return await ApiHelper.fetch(
+      '/channels/channels',
+      {
+        method: 'GET',
+        headers: {
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': 259200,
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*',
+        },
+        params: {
+          ...pagination,
+          order,
+        },
+      },
+    useRuntimeConfig(),
+    );
+  }
+}

package/services/api/contacts.service.ts

@@ -0,0 +1,22 @@
+import type { IContactsForm } from '../../types';
+import { ApiHelper } from '../../runtime';
+
+/** Сервис для работы с API контакты */
+export class ContactsApiService {
+  static async email(
+    data: IContactsForm,
+  ): Promise<any> {
+    return await ApiHelper.fetch(
+      '/contacts/email',
+      {
+        method: 'POST',
+        headers: {
+          'X-Cache-Time': 259200,
+          'Content-Type': 'application/json',
+        },
+        body: data
+      },
+      useRuntimeConfig(),
+    );
+  }
+}

package/services/api/dictionaries.service.ts

@@ -0,0 +1,34 @@
+import type { ICountries, IGenders } from '../../types';
+import { ApiHelper } from '../../runtime';
+
+/** Сервис для работы с API справочников (страны, гендеры) */
+export class DictionariesApiService {
+    static async getCountries(): Promise<ICountries> {
+        return await ApiHelper.fetch(
+            '/dictionaries/countries',
+            {
+                method: 'GET',
+                headers: {
+                    'X-Cache-Time': 259200,
+                    'Content-Type': 'application/json',
+                    'Access-Control-Allow-Origin': '*',
+                },
+            },
+        useRuntimeConfig(),
+        );
+    }
+    static async getGenders(): Promise<IGenders> {
+        return await ApiHelper.fetch(
+            '/dictionaries/genders',
+            {
+                method: 'GET',
+                headers: {
+                    'X-Cache-Time': 259200,
+                    'Content-Type': 'application/json',
+                    'Access-Control-Allow-Origin': '*',
+                },
+            },
+        useRuntimeConfig(),
+        );
+    }
+}