@rynt/sdk 0.9.53

package/src/shared/api/friends.ts

@@ -0,0 +1,140 @@
+import type { EntityUser } from '../types/entities';
+import { safeRequest } from '../utils/safeRequest';
+import { graphqlRequest } from './graphql';
+
+/** Алиас для совместимости с кодом, который ожидал экспорт типа `Friend`. */
+export type Friend = EntityUser;
+
+/**
+ * Получает список друзей текущего пользователя
+ */
+export const getFriends = () =>
+  safeRequest(async (): Promise<EntityUser[]> => {
+    const query = `
+      query GetFriends {
+        authenticatedItem {
+          ... on User {
+            friends {
+              id
+              username
+              email
+              avatar
+              status
+              statusDetail
+              lastSeenAt
+            }
+          }
+        }
+      }
+    `;
+
+    const result = await graphqlRequest<{
+      authenticatedItem: { friends: EntityUser[] } | null;
+    }>(query);
+
+    return result.authenticatedItem?.friends ?? [];
+  });
+
+/**
+ * Удаляет друга (временно с двух сторон на фронте)
+ */
+export const removeFriend = (friendId: string) =>
+  safeRequest(async (): Promise<boolean> => {
+    const currentUserQuery = `
+      query GetCurrentUser {
+        authenticatedItem {
+          ... on User {
+            id
+          }
+        }
+      }
+    `;
+
+    const currentUserResult = await graphqlRequest<{
+      authenticatedItem: { id: string } | null;
+    }>(currentUserQuery);
+
+    const currentUserId = currentUserResult.authenticatedItem?.id;
+
+    if (!currentUserId) {
+      throw new Error('User not authenticated');
+    }
+
+    const mutation = `
+      mutation RemoveFriend($where: UserWhereUniqueInput!, $data: UserUpdateInput!) {
+        updateUser(where: $where, data: $data) {
+          id
+        }
+      }
+    `;
+
+    await graphqlRequest(mutation, {
+      where: { id: currentUserId },
+      data: {
+        friends: {
+          disconnect: [{ id: friendId }],
+        },
+      },
+    });
+
+    // TODO: перенести на backend
+    await graphqlRequest(mutation, {
+      where: { id: friendId },
+      data: {
+        friends: {
+          disconnect: [{ id: currentUserId }],
+        },
+      },
+    });
+
+    return true;
+  });
+
+/**
+ * Ищет пользователей по имени или email
+ */
+export const searchUsers = (
+  query: string,
+  options?: {
+    excludeFriendIds?: string[];
+    currentUserId?: string;
+  },
+) =>
+  safeRequest(async (): Promise<EntityUser[]> => {
+    const searchQuery = `
+      query SearchUsers($where: UserWhereInput!) {
+        users(where: $where, take: 20) {
+          id
+          username
+          email
+          avatar
+          status
+          statusDetail
+          lastSeenAt
+        }
+      }
+    `;
+
+    const excludeIds = [
+      ...(options?.excludeFriendIds ?? []),
+      ...(options?.currentUserId ? [options.currentUserId] : []),
+    ];
+
+    const where: Record<string, unknown> = {
+      OR: [
+        { username: { contains: query, mode: 'insensitive' } },
+        { email: { contains: query, mode: 'insensitive' } },
+      ],
+      ...(excludeIds.length && {
+        id: {
+          not: { in: excludeIds },
+        },
+      }),
+    };
+
+    const result = await graphqlRequest<{ users: EntityUser[] }>(searchQuery, {
+      where,
+    });
+
+    return result.users;
+  });

package/src/shared/api/graphql.ts

@@ -0,0 +1,87 @@
+/**
+ * GraphQL клиент для работы с Keystone API
+ */
+
+import { getGraphQLUrl as getGraphQLUrlFromConfig } from './config';
+
+export interface GraphQLResponse<T = any> {
+  data?: T;
+  errors?: Array<{
+    message: string;
+    locations?: Array<{ line: number; column: number }>;
+    path?: Array<string | number>;
+  }>;
+}
+
+export interface GraphQLRequestOptions {
+  headers?: Record<string, string>;
+}
+
+/**
+ * Выполняет GraphQL запрос
+ */
+export async function graphqlRequest<T = any>(
+  query: string,
+  variables?: Record<string, any>,
+  options?: GraphQLRequestOptions
+): Promise<T> {
+  const token = getSessionToken();
+  
+  const response = await fetch(getGraphQLUrlFromConfig(), {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      ...(token && { Authorization: `Bearer ${token}` }),
+      ...options?.headers,
+    },
+    credentials: 'include', // Важно для работы с cookies (если Keystone использует cookie-based auth)
+    body: JSON.stringify({
+      query,
+      variables,
+    }),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => 'Unknown error');
+    throw new Error(`HTTP ${response.status}: ${errorText}`);
+  }
+
+  const result: GraphQLResponse<T> = await response.json();
+
+  if (result.errors && result.errors.length > 0) {
+    // Берем первое сообщение об ошибке (обычно это основная ошибка)
+    const errorMessage = result.errors[0].message;
+    throw new Error(errorMessage);
+  }
+
+  if (!result.data) {
+    throw new Error('No data returned from GraphQL query');
+  }
+
+  return result.data;
+}
+
+/**
+ * Получает токен сессии из localStorage
+ */
+export function getSessionToken(): string | null {
+  if (typeof window === 'undefined') return null;
+  return localStorage.getItem('session_token');
+}
+
+/**
+ * Сохраняет токен сессии в localStorage
+ */
+export function setSessionToken(token: string): void {
+  if (typeof window === 'undefined') return;
+  localStorage.setItem('session_token', token);
+}
+
+/**
+ * Удаляет токен сессии из localStorage
+ */
+export function removeSessionToken(): void {
+  if (typeof window === 'undefined') return;
+  localStorage.removeItem('session_token');
+}
+

package/src/shared/api/index.ts

@@ -0,0 +1,23 @@
+/**
+ * Экспорт всех API модулей
+ */
+
+export * from './config';
+export * from './graphql';
+export * from './auth';
+export * from './users';
+export * from './assets';
+export * from './maps';
+export * from './builds';
+export * from './projectServers';
+export * from './posts';
+export * from './events';
+export * from './serverMembers';
+export * from './invites';
+export * from './friends';
+export * from './library';
+export * from './downloads';
+export * from './download-stats';
+export * from './entity-authorship';
+export * from './notify-websocket';
+

package/src/shared/api/invites.ts

@@ -0,0 +1,262 @@
+/**
+ * API для работы с инвайтами
+ */
+
+import type { EntityInvite } from '../types/entities';
+import { safeRequest } from '../utils/safeRequest';
+import { graphqlRequest } from './graphql';
+
+export interface CreateInviteInput {
+  targetId: string;
+  type: EntityInvite['type'];
+  config?: Record<string, any>;
+}
+
+/**
+ * Получает список входящих инвайтов (где текущий пользователь - цель)
+ */
+export const getIncomingInvites = (
+  currentUserId: string,
+  options?: {
+    type?: EntityInvite['type'];
+    status?: EntityInvite['status'];
+  },
+) =>
+  safeRequest(async (): Promise<EntityInvite[]> => {
+    const query = `
+    query GetIncomingInvites($where: InviteWhereInput!, $orderBy: [InviteOrderByInput!]!) {
+      invites(where: $where, orderBy: $orderBy) {
+        id
+        type
+        status
+        config
+        createdAt
+        updatedAt
+        author {
+          id
+          username
+          email
+          avatar
+        }
+        target {
+          id
+          username
+          email
+          avatar
+        }
+      }
+    }
+  `;
+
+    const where: any = {
+      target: { id: { equals: currentUserId } },
+    };
+
+    if (options?.type) {
+      where.type = { equals: options.type };
+    }
+
+    if (options?.status) {
+      where.status = { equals: options.status };
+    }
+
+    const orderBy = [{ createdAt: 'desc' as const }];
+
+    const result = await graphqlRequest<{ invites: EntityInvite[] }>(query, {
+      where,
+      orderBy,
+    });
+
+    return result.invites;
+  });
+
+/**
+ * Получает список исходящих инвайтов (где текущий пользователь - автор)
+ */
+export const getOutgoingInvites = (
+  currentUserId: string,
+  options?: {
+    type?: EntityInvite['type'];
+    status?: EntityInvite['status'];
+  },
+) =>
+  safeRequest(async (): Promise<EntityInvite[]> => {
+    const query = `
+    query GetOutgoingInvites($where: InviteWhereInput!, $orderBy: [InviteOrderByInput!]!) {
+      invites(where: $where, orderBy: $orderBy) {
+        id
+        type
+        status
+        config
+        createdAt
+        updatedAt
+        author {
+          id
+          username
+          email
+          avatar
+        }
+        target {
+          id
+          username
+          email
+          avatar
+        }
+      }
+    }
+  `;
+
+    const where: any = {
+      author: { id: { equals: currentUserId } },
+    };
+
+    if (options?.type) {
+      where.type = { equals: options.type };
+    }
+
+    if (options?.status) {
+      where.status = { equals: options.status };
+    }
+
+    const orderBy = [{ createdAt: 'desc' as const }];
+
+    const result = await graphqlRequest<{ invites: EntityInvite[] }>(query, {
+      where,
+      orderBy,
+    });
+
+    return result.invites;
+  });
+
+/**
+ * Создает новый инвайт
+ */
+export const createInvite = (input: CreateInviteInput) =>
+  safeRequest(async (): Promise<EntityInvite> => {
+    const mutation = `
+    mutation CreateInvite($data: InviteCreateInput!) {
+      createInvite(data: $data) {
+        id
+        type
+        status
+        config
+        createdAt
+        updatedAt
+        author {
+          id
+          username
+          email
+          avatar
+        }
+        target {
+          id
+          username
+          email
+          avatar
+        }
+      }
+    }
+  `;
+
+    const result = await graphqlRequest<{ createInvite: EntityInvite }>(
+      mutation,
+      {
+        data: {
+          target: { connect: { id: input.targetId } },
+          type: input.type,
+          config: input.config || {},
+        },
+      },
+    );
+
+    return result.createInvite;
+  });
+/**
+ * Принимает инвайт (обновляет статус на accepted)
+ */
+export const acceptInvite = (inviteId: string) =>
+  safeRequest(async (): Promise<EntityInvite> => {
+    const mutation = `
+    mutation AcceptInvite($where: InviteWhereUniqueInput!, $data: InviteUpdateInput!) {
+      updateInvite(where: $where, data: $data) {
+        id
+        type
+        status
+        config
+        createdAt
+        updatedAt
+        author {
+          id
+          username
+          email
+          avatar
+        }
+        target {
+          id
+          username
+          email
+          avatar
+        }
+      }
+    }
+  `;
+
+    const result = await graphqlRequest<{ updateInvite: EntityInvite }>(
+      mutation,
+      {
+        where: { id: inviteId },
+        data: {
+          status: 'accepted',
+        },
+      },
+    );
+
+    return result.updateInvite;
+  });
+
+/**
+ * Отклоняет инвайт (удаляет его)
+ */
+export const rejectInvite = (inviteId: string) =>
+  safeRequest(async (): Promise<boolean> => {
+    const mutation = `
+    mutation RejectInvite($where: InviteWhereUniqueInput!) {
+      deleteInvite(where: $where) {
+        id
+      }
+    }
+  `;
+
+    await graphqlRequest<{ deleteInvite: { id: string } }>(mutation, {
+      where: { id: inviteId },
+    });
+
+    return true;
+  });
+
+/**
+ * Проверяет, отправлен ли уже инвайт в друзья указанному пользователю
+ */
+export const checkFriendInviteExists = (targetId: string) =>
+  safeRequest(async (): Promise<boolean> => {
+    const query = `
+    query CheckFriendInviteExists($where: InviteWhereInput!) {
+      invites(where: $where, take: 1) {
+        id
+      }
+    }
+  `;
+
+    const result = await graphqlRequest<{ invites: Array<{ id: string }> }>(
+      query,
+      {
+        where: {
+          type: { equals: 'friend' },
+          target: { id: { equals: targetId } },
+          status: { equals: 'pending' },
+        },
+      },
+    );
+
+    return result.invites.length > 0;
+  });

package/src/shared/api/library.ts

@@ -0,0 +1,44 @@
+/**
+ * API для страницы библиотеки (статистика через стандартные count-запросы)
+ */
+
+import { graphqlRequest } from './graphql';
+
+export interface LibraryStats {
+  usersOnline: number;
+  usersTotal: number;
+  serversCount: number;
+  buildsCount: number;
+  mapsCount: number;
+}
+
+/**
+ * Получает сводную статистику для страницы библиотеки —
+ * один запрос с фильтрацией по каждой сущности (usersCount, buildsCount, projectServersCount).
+ */
+export async function getLibraryStats(): Promise<LibraryStats> {
+  const query = `
+    query LibraryStatsCounts {
+      usersOnline: usersCount(where: { status: { equals: "online" } })
+      usersTotal: usersCount(where: {})
+      serversCount: projectServersCount(where: {})
+      buildsCount: buildsCount(where: { isPublic: { equals: true } })
+    }
+  `;
+
+  const result = await graphqlRequest<{
+    usersOnline: number;
+    usersTotal: number;
+    serversCount: number;
+    buildsCount: number;
+    mapsCount: number;
+  }>(query);
+
+  return {
+    usersOnline: result.usersOnline,
+    usersTotal: result.usersTotal,
+    serversCount: result.serversCount,
+    buildsCount: result.buildsCount,
+    mapsCount: result.mapsCount,
+  };
+}