@rynt/sdk 0.9.53

package/src/shared/api/builds.ts

@@ -0,0 +1,647 @@
+/**
+ * API для работы со сборками и версиями
+ */
+
+import { graphqlRequest } from './graphql';
+import type { BuildVersionManifest } from '../minecraft-types/build-manifest';
+
+export interface Build {
+  id: string;
+  name: string;
+  description: string;
+  image?: string;
+  isPublic: boolean;
+  downloads?: number;
+  rating?: number | null;
+  minecraftVersion?: string;
+  loader?: string;
+  author: {
+    id: string;
+    username: string;
+  };
+}
+
+export interface Version {
+  id: string;
+  version: string;
+  name: string;
+  description: string;
+  image?: string;
+  minecraftVersion?: string;
+  loader?: string;
+  releaseTime?: string;
+  build: {
+    id: string;
+  };
+}
+
+/**
+ * Проверяет, существует ли сборка с указанным ID
+ */
+export async function checkBuildExists(buildId: string): Promise<boolean> {
+  const query = `
+    query CheckBuildExists($id: ID!) {
+      build(where: { id: $id }) {
+        id
+      }
+    }
+  `;
+
+  try {
+    const result = await graphqlRequest<{ build: { id: string } | null }>(
+      query,
+      { id: buildId },
+    );
+    return result.build !== null;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Получает сборку по ID с последней версией и манифестом
+ */
+export async function getBuildWithLatestVersion(buildId: string): Promise<{
+  id: string;
+  name: string;
+  latestVersion: {
+    id: string;
+    version: string;
+    manifest: BuildVersionManifest;
+  } | null;
+} | null> {
+  const query = `
+    query GetBuildWithLatestVersion($where: BuildWhereUniqueInput!) {
+      build(where: $where) {
+        id
+        name
+        versions(
+          orderBy: { releaseTime: desc }
+          take: 1
+        ) {
+          id
+          version
+          manifest
+        }
+      }
+    }
+  `;
+
+  try {
+    const result = await graphqlRequest<{
+      build: {
+        id: string;
+        name: string;
+        versions: Array<{
+          id: string;
+          version: string;
+          manifest: BuildVersionManifest;
+        }>;
+      } | null;
+    }>(query, { where: { id: buildId } });
+
+    if (!result.build) {
+      return null;
+    }
+
+    return {
+      id: result.build.id,
+      name: result.build.name,
+      latestVersion:
+        result.build.versions.length > 0
+          ? {
+              id: result.build.versions[0].id,
+              version: result.build.versions[0].version,
+              manifest: result.build.versions[0].manifest,
+            }
+          : null,
+    };
+  } catch (error) {
+    console.error('Error getting build with latest version:', error);
+    return null;
+  }
+}
+
+/**
+ * Получает версию сборки по ID сборки и номеру версии
+ */
+export async function getBuildVersion(
+  buildId: string,
+  version: string,
+): Promise<{
+  id: string;
+  version: string;
+  manifest: BuildVersionManifest;
+} | null> {
+  const query = `
+    query GetBuildVersion($where: BuildWhereUniqueInput!, $versionWhere: VersionWhereInput!) {
+      build(where: $where) {
+        id
+        versions(
+          where: $versionWhere
+          take: 1
+        ) {
+          id
+          version
+          manifest
+        }
+      }
+    }
+  `;
+
+  try {
+    const result = await graphqlRequest<{
+      build: {
+        id: string;
+        versions: Array<{
+          id: string;
+          version: string;
+          manifest: BuildVersionManifest;
+        }>;
+      } | null;
+    }>(query, {
+      where: { id: buildId },
+      versionWhere: { version: { equals: version } },
+    });
+
+    if (!result.build || result.build.versions.length === 0) {
+      return null;
+    }
+
+    return {
+      id: result.build.versions[0].id,
+      version: result.build.versions[0].version,
+      manifest: result.build.versions[0].manifest,
+    };
+  } catch (error) {
+    console.error('Error getting build version:', error);
+    return null;
+  }
+}
+
+/**
+ * Создает новую сборку
+ */
+export async function createBuild(data: {
+  name: string;
+  description: string;
+  image?: string;
+  isPublic?: boolean;
+  minecraftVersion?: string;
+  loader?: string;
+}): Promise<Build> {
+  const mutation = `
+    mutation CreateBuild($data: BuildCreateInput!) {
+      createBuild(data: $data) {
+        id
+        name
+        description
+        image
+        isPublic
+        minecraftVersion
+        loader
+        author {
+          id
+          username
+        }
+      }
+    }
+  `;
+
+  const result = await graphqlRequest<{ createBuild: Build }>(mutation, {
+    data: {
+      name: data.name,
+      description: data.description,
+      image: data.image || '',
+      isPublic: data.isPublic || false,
+      minecraftVersion: data.minecraftVersion || '',
+      loader: data.loader || '',
+    },
+  });
+
+  return result.createBuild;
+}
+
+/**
+ * Обновляет информацию о сборке
+ */
+export async function updateBuild(
+  buildId: string,
+  data: {
+    name?: string;
+    description?: string;
+    image?: string;
+    minecraftVersion?: string;
+    loader?: string;
+    isPublic?: boolean;
+  },
+): Promise<Build> {
+  const mutation = `
+    mutation UpdateBuild($where: BuildWhereUniqueInput!, $data: BuildUpdateInput!) {
+      updateBuild(where: $where, data: $data) {
+        id
+        name
+        description
+        image
+        isPublic
+        minecraftVersion
+        loader
+        author {
+          id
+          username
+        }
+      }
+    }
+  `;
+
+  const updateData: any = {};
+  if (data.name !== undefined) updateData.name = data.name;
+  if (data.description !== undefined) updateData.description = data.description;
+  if (data.image !== undefined) updateData.image = data.image;
+  if (data.minecraftVersion !== undefined)
+    updateData.minecraftVersion = data.minecraftVersion;
+  if (data.loader !== undefined) updateData.loader = data.loader;
+  if (data.isPublic !== undefined) updateData.isPublic = data.isPublic;
+
+  const result = await graphqlRequest<{ updateBuild: Build }>(mutation, {
+    where: { id: buildId },
+    data: updateData,
+  });
+
+  return result.updateBuild;
+}
+
+/**
+ * Получает сборки текущего пользователя (опубликованные)
+ */
+export async function getMyBuilds(): Promise<Build[]> {
+  // Сначала получаем текущего пользователя
+  const userQuery = `
+    query {
+      authenticatedItem {
+        ... on User {
+          id
+        }
+      }
+    }
+  `;
+
+  const userResult = await graphqlRequest<{
+    authenticatedItem: { id: string } | null;
+  }>(userQuery);
+
+  if (!userResult.authenticatedItem) {
+    return [];
+  }
+
+  const query = `
+    query GetMyBuilds($where: BuildWhereInput!, $orderBy: [BuildOrderByInput!]!) {
+      builds(where: $where, orderBy: $orderBy) {
+        id
+        name
+        description
+        image
+        downloads
+        minecraftVersion
+        loader
+        author {
+          id
+          username
+        }
+      }
+    }
+  `;
+
+  const result = await graphqlRequest<{ builds: Build[] }>(query, {
+    where: {
+      author: { id: { equals: userResult.authenticatedItem.id } },
+    },
+    orderBy: [{ name: 'asc' }],
+  });
+
+  return result.builds;
+}
+
+/**
+ * Получает все версии сборки, отсортированные по дате релиза (последняя первая)
+ */
+export async function getBuildVersions(buildId: string): Promise<Version[]> {
+  const query = `
+    query GetBuildVersions($where: BuildWhereUniqueInput!) {
+      build(where: $where) {
+        id
+        versions(
+          orderBy: { releaseTime: desc }
+        ) {
+          id
+          version
+          name
+          description
+          image
+          minecraftVersion
+          loader
+          releaseTime
+          build {
+            id
+          }
+        }
+      }
+    }
+  `;
+
+  try {
+    const result = await graphqlRequest<{
+      build: {
+        id: string;
+        versions: Version[];
+      } | null;
+    }>(query, { where: { id: buildId } });
+
+    if (!result.build) {
+      return [];
+    }
+
+    return result.build.versions;
+  } catch (error) {
+    console.error('Error getting build versions:', error);
+    return [];
+  }
+}
+
+/**
+ * Получает все сборки текущего пользователя (включая приватные)
+ */
+export async function getAllUserBuilds(): Promise<Build[]> {
+  // Сначала получаем текущего пользователя
+  const userQuery = `
+    query {
+      authenticatedItem {
+        ... on User {
+          id
+        }
+      }
+    }
+  `;
+
+  const userResult = await graphqlRequest<{
+    authenticatedItem: { id: string } | null;
+  }>(userQuery);
+
+  if (!userResult.authenticatedItem) {
+    return [];
+  }
+
+  const query = `
+    query GetAllUserBuilds($where: BuildWhereInput!, $orderBy: [BuildOrderByInput!]!) {
+      builds(where: $where, orderBy: $orderBy) {
+        id
+        name
+        description
+        image
+        downloads
+        minecraftVersion
+        loader
+        isPublic
+        author {
+          id
+          username
+        }
+      }
+    }
+  `;
+
+  const result = await graphqlRequest<{ builds: Build[] }>(query, {
+    where: {
+      author: { id: { equals: userResult.authenticatedItem.id } },
+    },
+    orderBy: [{ name: 'asc' }],
+  });
+
+  return result.builds;
+}
+
+/**
+ * Создает версию сборки
+ */
+export async function createVersion(data: {
+  buildId: string;
+  version: string;
+  name: string;
+  description: string;
+  image?: string;
+  manifest: BuildVersionManifest;
+  assetIds: string[];
+  versionAssets: Array<{
+    path: string;
+    sha1: string;
+    url: string;
+    name: string;
+    skipHashCheck?: boolean;
+  }>;
+}): Promise<Version> {
+  const mutation = `
+    mutation CreateVersion($data: VersionCreateInput!) {
+      createVersion(data: $data) {
+        id
+        version
+        name
+        description
+        build {
+          id
+        }
+      }
+    }
+  `;
+
+  // Получаем текущее время для releaseTime
+  const releaseTime = new Date().toISOString();
+
+  // Очищаем манифест от локальных полей и обновляем метаданные
+  const cleanedManifest = cleanManifestForPublish(
+    data.manifest,
+    data.buildId,
+    data.version,
+    releaseTime,
+  );
+
+  // Обновляем versionAssets с реальными данными об ассетах
+  cleanedManifest.versionAssets = data.versionAssets.map((asset) => {
+    const result: any = {
+      name: asset.name,
+      path: asset.path,
+      sha1: asset.sha1,
+      url: asset.url,
+    };
+    if (asset.skipHashCheck) {
+      result.skipHashCheck = asset.skipHashCheck;
+    }
+    return result;
+  });
+
+  const result = await graphqlRequest<{ createVersion: Version }>(mutation, {
+    data: {
+      build: { connect: { id: data.buildId } },
+      version: data.version,
+      name: data.name,
+      description: data.description,
+      image: data.image || '',
+      manifest: cleanedManifest,
+      minecraftVersion: cleanedManifest._meta?.manifest?.minecraftVersion || '',
+      loader: cleanedManifest._meta?.manifest?.loader || '',
+      loaderVersion: cleanedManifest._meta?.manifest?.loaderVersion || '',
+      releaseTime: releaseTime,
+      assets: {
+        connect: data.assetIds.map((id) => ({ id })),
+      },
+    },
+  });
+
+  return result.createVersion;
+}
+
+/**
+ * Добавляет автора к существующему ассету
+ */
+export async function addAuthorToAsset(assetId: string): Promise<void> {
+  const mutation = `
+    mutation UpdateAsset($where: AssetWhereUniqueInput!, $data: AssetUpdateInput!) {
+      updateAsset(where: $where, data: $data) {
+        id
+      }
+    }
+  `;
+
+  // Получаем текущего пользователя через authenticatedItem
+  const userQuery = `
+    query {
+      authenticatedItem {
+        ... on User {
+          id
+        }
+      }
+    }
+  `;
+
+  const userResult = await graphqlRequest<{
+    authenticatedItem: { id: string } | null;
+  }>(userQuery);
+
+  if (!userResult.authenticatedItem) {
+    throw new Error('User not authenticated');
+  }
+
+  await graphqlRequest(mutation, {
+    where: { id: assetId },
+    data: {
+      authors: {
+        connect: [{ id: userResult.authenticatedItem.id }],
+      },
+    },
+  });
+}
+
+/**
+ * Очищает манифест от локальных полей перед публикацией
+ */
+function cleanManifestForPublish(
+  manifest: BuildVersionManifest,
+  buildId: string,
+  versionNumber: string,
+  releaseTime: string,
+): BuildVersionManifest {
+  const cleaned = JSON.parse(JSON.stringify(manifest)); // Глубокое копирование
+
+  // Устанавливаем id манифеста равным ID сборки (только на бэкенде, локальный не меняем)
+  cleaned.id = buildId;
+
+  // Обновляем _meta
+  if (cleaned._meta) {
+    // Обновляем UUID на ID сборки (всегда)
+    cleaned._meta.uuid = buildId;
+
+    // Обновляем версию на новую
+    cleaned._meta.version = versionNumber;
+
+    // Обновляем releaseTime на серверное время
+    cleaned._meta.releaseTime = releaseTime;
+
+    // Удаляем локальные настройки (settings)
+    if (cleaned._meta.settings) {
+      delete cleaned._meta.settings;
+    }
+
+    // Удаляем статистику (stats, playTime и т.д.)
+    if (cleaned._meta.stats) {
+      delete cleaned._meta.stats;
+    }
+
+    // Удаляем локальные пути и другие локальные данные
+    // Но сохраняем важные метаданные: name, description, image, manifest
+  }
+
+  return cleaned;
+}
+
+/**
+ * Получает список публичных сборок
+ */
+export async function getPublicBuilds(options?: {
+  take?: number;
+  skip?: number;
+  orderBy?: Array<{ downloads?: 'asc' | 'desc'; rating?: 'asc' | 'desc' }>;
+  where?: {
+    minecraftVersion?: string;
+    search?: string;
+  };
+}): Promise<Build[]> {
+  const query = `
+    query GetPublicBuilds($where: BuildWhereInput!, $orderBy: [BuildOrderByInput!]!, $take: Int, $skip: Int!) {
+      builds(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
+        id
+        name
+        description
+        image
+        isPublic
+        downloads
+        rating
+        minecraftVersion
+        loader
+        author {
+          id
+          username
+        }
+      }
+    }
+  `;
+
+  const where: any = {
+    isPublic: { equals: true },
+  };
+
+  // Поиск по названию или описанию (case-insensitive)
+  if (options?.where?.search) {
+    where.OR = [
+      { name: { contains: options.where.search, mode: 'insensitive' } },
+      { description: { contains: options.where.search, mode: 'insensitive' } },
+    ];
+  }
+
+  // Фильтр по версии Minecraft (прямо из поля Build)
+  if (options?.where?.minecraftVersion) {
+    where.minecraftVersion = {
+      equals: options.where.minecraftVersion,
+      mode: 'insensitive',
+    };
+  }
+
+  const orderBy = options?.orderBy || [{ downloads: 'desc' }];
+
+  const result = await graphqlRequest<{ builds: Build[] }>(query, {
+    where,
+    orderBy,
+    take: options?.take || 20,
+    skip: options?.skip || 0,
+  });
+
+  return result.builds;
+}

package/src/shared/api/config.ts

@@ -0,0 +1,19 @@
+/**
+ * Конфигурация API
+ */
+
+/**
+ * Получает полный URL GraphQL endpoint из переменных окружения
+ * VITE_API_URL должен содержать полный URL до GraphQL (например: http://localhost:3000/api/graphql)
+ */
+export function getGraphQLUrl(): string {
+  const apiUrl = (import.meta as any).env?.VITE_API_URL as string | undefined;
+  if (apiUrl) {
+    // Убираем trailing slash если есть
+    return apiUrl.endsWith('/') ? apiUrl.slice(0, -1) : apiUrl;
+  }
+  
+  // Fallback: используем localhost:3000/api/graphql
+  return 'http://localhost:3000/api/graphql';
+}
+