@rynt/sdk 0.9.53

package/src/shared/api/assets.ts

@@ -0,0 +1,112 @@
+/**
+ * API для работы с ассетами
+ */
+
+import { graphqlRequest } from './graphql';
+import { getGraphQLUrl } from './config';
+import { getSessionToken } from './graphql';
+
+export interface Asset {
+  id: string;
+  sha1: string;
+  size: number;
+  filename: string;
+  mimeType: string;
+  s3Url: string;
+  s3Key: string;
+  s3Bucket: string;
+  authors?: Array<{ id: string; username: string }>;
+}
+
+export interface AssetUploadResponse {
+  asset: Asset;
+  isNew: boolean;
+}
+
+/**
+ * Запрашивает ассеты по массиву SHA1 хешей
+ */
+export async function getAssetsBySha1(sha1s: string[]): Promise<Asset[]> {
+  const query = `
+    query GetAssetsBySha1($sha1s: [String!]!) {
+      assets(where: { sha1: { in: $sha1s } }) {
+        id
+        sha1
+        size
+        filename
+        mimeType
+        s3Key
+        s3Bucket
+        s3Url
+        authors {
+          id
+          username
+        }
+      }
+    }
+  `;
+
+  const result = await graphqlRequest<{
+    assets: Asset[];
+  }>(query, { sha1s });
+
+  return result.assets;
+}
+
+/**
+ * Загружает файл на сервер
+ */
+export async function uploadAsset(
+  file: File | Blob,
+  filename: string,
+  mimeType: string
+): Promise<AssetUploadResponse> {
+  const apiUrl = getGraphQLUrl().replace('/graphql', '');
+  const token = getSessionToken();
+
+  const formData = new FormData();
+  formData.append('file', file);
+  formData.append('filename', filename);
+  formData.append('mimeType', mimeType);
+
+  const response = await fetch(`${apiUrl}/upload-asset`, {
+    method: 'POST',
+    headers: {
+      ...(token && { Authorization: `Bearer ${token}` }),
+    },
+    body: formData,
+  });
+
+  if (!response.ok) {
+    let errorMessage = 'Unknown error';
+    let errorData: any = {};
+    
+    try {
+      errorData = await response.json();
+      // Если есть сообщение об ошибке от сервера, используем его
+      if (errorData.message) {
+        errorMessage = errorData.message;
+      } else if (errorData.error) {
+        errorMessage = errorData.error;
+      } else {
+        errorMessage = `HTTP ${response.status}: ${JSON.stringify(errorData)}`;
+      }
+    } catch {
+      // Если не удалось распарсить JSON, используем текст ответа
+      try {
+        const errorText = await response.text();
+        errorMessage = `HTTP ${response.status}: ${errorText}`;
+      } catch {
+        errorMessage = `HTTP ${response.status}: Unknown error`;
+      }
+    }
+    
+    const error: any = new Error(errorMessage);
+    error.response = { status: response.status, data: errorData };
+    throw error;
+  }
+
+  return response.json();
+}
+
+

package/src/shared/api/auth.ts

@@ -0,0 +1,283 @@
+/**
+ * API для работы с авторизацией через Keystone (GraphQL)
+ */
+
+import type { EntityUser } from '../types/entities';
+import {
+  graphqlRequest,
+  setSessionToken,
+  removeSessionToken,
+  getSessionToken,
+} from './graphql';
+import { safeRequest } from '../utils/safeRequest';
+
+export interface LoginCredentials {
+  username: string;
+  password: string;
+}
+
+export interface RegisterData {
+  username: string;
+  email: string;
+  password: string;
+}
+
+export interface AuthResponse {
+  success: boolean;
+  token?: string;
+  error?: string;
+  user?: {
+    id: string;
+    username: string;
+    email: string;
+  };
+}
+
+// --- LOGIN ---
+export const login = (credentials: LoginCredentials) =>
+  safeRequest<AuthResponse>(async () => {
+    const mutation = `
+      mutation AuthenticateUser($username: String!, $password: String!) {
+        authenticateUserWithPassword(username: $username, password: $password) {
+          __typename
+          ... on UserAuthenticationWithPasswordSuccess {
+            sessionToken
+            item { id username email }
+          }
+          ... on UserAuthenticationWithPasswordFailure {
+            message
+          }
+        }
+      }
+    `;
+
+    const result = await graphqlRequest<{
+      authenticateUserWithPassword:
+        | {
+            __typename: 'UserAuthenticationWithPasswordSuccess';
+            sessionToken: string;
+            item: { id: string; username: string; email: string };
+          }
+        | {
+            __typename: 'UserAuthenticationWithPasswordFailure';
+            message: string;
+          };
+    }>(mutation, credentials);
+
+    const auth = result.authenticateUserWithPassword;
+
+    // Если ошибка — выбрасываем её, safeRequest её подхватит и положит в error
+    if (auth.__typename === 'UserAuthenticationWithPasswordFailure') {
+      throw new Error(auth.message);
+    }
+
+    // Успешная авторизация
+    setSessionToken(auth.sessionToken);
+
+    return { success: true, token: auth.sessionToken, user: auth.item };
+  });
+
+// --- REGISTER ---
+export const registerWithEmail = (data: RegisterData) =>
+  safeRequest<{ success: boolean; error?: string }>(async () => {
+    const mutation = `
+      mutation RegisterWithEmail($username: String!, $email: String!, $password: String!) {
+        registerWithEmail(username: $username, email: $email, password: $password)
+      }
+    `;
+    const result = await graphqlRequest<{ registerWithEmail: boolean }>(
+      mutation,
+      data,
+    );
+
+    if (result.registerWithEmail) return { success: true };
+
+    return { success: false, error: 'Не удалось отправить код подтверждения' };
+  });
+
+export const verifyRegistration = (
+  email: string,
+  code: string,
+  username: string,
+  password: string,
+) =>
+  safeRequest<AuthResponse>(async () => {
+    const mutation = `
+      mutation VerifyRegistration($email: String!, $code: String!, $username: String!, $password: String!) {
+        verifyRegistration(email: $email, code: $code, username: $username, password: $password) {
+          sessionToken
+          user { id username email }
+        }
+      }
+    `;
+
+    const result = await graphqlRequest<{
+      verifyRegistration: {
+        sessionToken: string;
+        user: { id: string; username: string; email: string };
+      };
+    }>(mutation, { email, code, username, password });
+
+    const { sessionToken, user } = result.verifyRegistration;
+    setSessionToken(sessionToken);
+
+    return { success: true, token: sessionToken, user };
+  });
+
+// --- PASSWORD RESET ---
+export const requestPasswordReset = (email: string) =>
+  safeRequest<{ success: boolean; error?: string }>(async () => {
+    const mutation = `
+      mutation RequestPasswordReset($email: String!) {
+        requestPasswordReset(email: $email)
+      }
+    `;
+    await graphqlRequest<{ requestPasswordReset: boolean }>(mutation, {
+      email,
+    });
+    return { success: true };
+  });
+
+export const verifyPasswordReset = (
+  email: string,
+  code: string,
+  newPassword: string,
+) =>
+  safeRequest<{ success: boolean; error?: string }>(async () => {
+    const mutation = `
+      mutation VerifyPasswordReset($email: String!, $code: String!, $newPassword: String!) {
+        verifyPasswordReset(email: $email, code: $code, newPassword: $newPassword)
+      }
+    `;
+    await graphqlRequest<{ verifyPasswordReset: boolean }>(mutation, {
+      email,
+      code,
+      newPassword,
+    });
+    return { success: true };
+  });
+
+// --- OLD REGISTER (deprecated) ---
+export const register = (data: RegisterData) =>
+  safeRequest<AuthResponse>(async () => {
+    const { result: registerResult } = await registerWithEmail(data);
+    if (!registerResult?.success)
+      return { success: false, error: registerResult?.error };
+    return { success: true };
+  });
+
+// --- LOGOUT ---
+export const logout = () =>
+  safeRequest<void>(async () => {
+    const mutation = `mutation { endSession }`;
+    await graphqlRequest<{ endSession: boolean }>(mutation).catch(() => {});
+    removeSessionToken();
+  });
+
+// --- CURRENT USER ---
+export const getCurrentUser = () =>
+  safeRequest<EntityUser | null>(async () => {
+    const query = `
+      query {
+        authenticatedItem {
+          ... on User {
+            id username email avatar bio status statusDetail
+            serverMemberships {
+              id role
+              server { id name address port status image tags players maxPlayers description build { id name } }
+            }
+          }
+        }
+      }
+    `;
+    const result = await graphqlRequest<{
+      authenticatedItem: EntityUser | null;
+    }>(query);
+    return result.authenticatedItem ?? null;
+  });
+
+// --- SESSION CHECK ---
+export const isAuthenticated = () =>
+  safeRequest<boolean>(async () => {
+    const token = getSessionToken();
+    if (!token) return false;
+    const { result: user } = await getCurrentUser();
+    return !!user;
+  });
+
+// --- USER STORAGE QUOTA ---
+export const getUserStorageQuota = () =>
+  safeRequest<{ usedStorage: number; storageQuota: number } | null>(
+    async () => {
+      const query = `
+      query {
+        authenticatedItem {
+          ... on User { id usedStorage storageQuota }
+        }
+      }
+    `;
+      const result = await graphqlRequest<{
+        authenticatedItem: {
+          id: string;
+          usedStorage: number | null;
+          storageQuota: number | null;
+        } | null;
+      }>(query);
+      if (!result.authenticatedItem) return null;
+      return {
+        usedStorage: result.authenticatedItem.usedStorage ?? 0,
+        storageQuota: result.authenticatedItem.storageQuota ?? 0,
+      };
+    },
+  );
+
+// --- UPDATE PROFILE ---
+export const updateUserProfile = (data: {
+  username?: string;
+  email?: string;
+  avatar?: string;
+  bio?: string;
+}) =>
+  safeRequest<EntityUser>(async () => {
+    const { result: currentUser } = await getCurrentUser();
+    if (!currentUser) throw new Error('User is not authenticated');
+
+    const mutation = `
+      mutation UpdateUser($where: UserWhereUniqueInput!, $data: UserUpdateInput!) {
+        updateUser(where: $where, data: $data) {
+          id username email avatar bio
+        }
+      }
+    `;
+    const updateData: any = { ...data };
+    const result = await graphqlRequest<{ updateUser: EntityUser }>(mutation, {
+      where: { id: currentUser.id },
+      data: updateData,
+    });
+    return result.updateUser;
+  });
+
+// --- UPDATE STATUS ---
+export const updateUserStatus = (data: {
+  status?: 'online' | 'offline';
+  statusDetail?: object | null;
+}) =>
+  safeRequest<void>(async () => {
+    const { result: currentUser } = await getCurrentUser();
+    if (!currentUser) throw new Error('User is not authenticated');
+
+    const mutation = `
+      mutation UpdateUserStatus($where: UserWhereUniqueInput!, $data: UserUpdateInput!) {
+        updateUser(where: $where, data: $data) { id }
+      }
+    `;
+    const updateData: { status?: string; statusDetail?: object | null } = {};
+    if (data.status !== undefined) updateData.status = data.status;
+    if (data.statusDetail !== undefined)
+      updateData.statusDetail = data.statusDetail;
+
+    await graphqlRequest(mutation, {
+      where: { id: currentUser.id },
+      data: updateData,
+    });
+  });