@rynt/sdk 0.9.53

package/src/shared/api/maps.ts

@@ -0,0 +1,385 @@
+/**
+ * API для работы с картами
+ */
+
+import { graphqlRequest, getSessionToken } from './graphql';
+import { getGraphQLUrl } from './config';
+import { safeRequest } from '../utils/safeRequest';
+
+export interface Map {
+  id: string;
+  name: string;
+  description: string;
+  image?: string;
+  minecraftVersion: string;
+  mapType: 'any' | 'build';
+  buildId?: string;
+  buildName?: string;
+  version: string;
+  sha1: string;
+  size: number;
+  filename: string;
+  mimeType: string;
+  s3Url: string;
+  s3Key: string;
+  s3Bucket: string;
+  isPublic: boolean;
+  downloads: number;
+  manifest?: Record<string, any>;
+  author: { id: string; username: string };
+  createdAt?: string;
+}
+
+export interface MapUploadResponse {
+  map: Map;
+  isNew: boolean;
+}
+
+export interface PublicMapsFilter {
+  query?: string;
+  minecraftVersion?: string;
+  mapType?: string;
+  sortBy?: string;
+  offset?: number;
+  limit?: number;
+}
+
+/**
+ * Получает карту по ID
+ */
+export async function getMap(id: string): Promise<Map | null> {
+  const query = `
+    query GetMap($id: ID!) {
+      map(where: { id: $id }) {
+        id
+        name
+        description
+        image
+        minecraftVersion
+        mapType
+        buildId
+        buildName
+        version
+        sha1
+        size
+        filename
+        mimeType
+        s3Key
+        s3Bucket
+        s3Url
+        isPublic
+        downloads
+        manifest
+        author { id username }
+        createdAt
+      }
+    }
+  `;
+
+  const result = await graphqlRequest<{ map: Map | null }>(query, { id });
+  return result.map;
+}
+
+/**
+ * Получает карты текущего пользователя
+ */
+export async function getUserMaps(): Promise<Map[]> {
+  const userQuery = `
+    query {
+      authenticatedItem {
+        ... on User { id }
+      }
+    }
+  `;
+
+  const userResult = await graphqlRequest<{
+    authenticatedItem: { id: string } | null;
+  }>(userQuery);
+
+  if (!userResult.authenticatedItem) {
+    return [];
+  }
+
+  const query = `
+    query GetUserMaps($where: MapWhereInput!) {
+      maps(where: $where) {
+        id
+        name
+        description
+        image
+        minecraftVersion
+        mapType
+        buildId
+        buildName
+        version
+        sha1
+        size
+        filename
+        mimeType
+        s3Key
+        s3Bucket
+        s3Url
+        isPublic
+        downloads
+        manifest
+        author { id username }
+        createdAt
+      }
+    }
+  `;
+
+  const result = await graphqlRequest<{ maps: Map[] }>(query, {
+    where: { author: { id: { equals: userResult.authenticatedItem.id } } },
+  });
+  return result.maps;
+}
+
+/**
+ * Получает публичные карты с фильтрацией
+ */
+export async function getPublicMaps(filter?: PublicMapsFilter): Promise<Map[]> {
+  const where: string[] = ['{ isPublic: { equals: true } }'];
+
+  if (filter?.minecraftVersion) {
+    where.push(`{ minecraftVersion: { equals: "${filter.minecraftVersion}" } }`);
+  }
+  if (filter?.mapType) {
+    where.push(`{ mapType: { equals: "${filter.mapType}" } }`);
+  }
+
+  const whereClause = where.length > 1
+    ? `{ AND: [${where.join(', ')}] }`
+    : where[0];
+
+  const orderBy = filter?.sortBy === 'downloads'
+    ? 'orderBy: { downloads: desc }'
+    : 'orderBy: { createdAt: desc }';
+
+  const take = filter?.limit ?? 20;
+  const skip = filter?.offset ?? 0;
+
+  const query = `
+    query GetPublicMaps {
+      maps(where: ${whereClause}, ${orderBy}, take: ${take}, skip: ${skip}) {
+        id
+        name
+        description
+        image
+        minecraftVersion
+        mapType
+        buildId
+        buildName
+        version
+        sha1
+        size
+        filename
+        mimeType
+        s3Key
+        s3Bucket
+        s3Url
+        isPublic
+        downloads
+        manifest
+        author { id username }
+        createdAt
+      }
+    }
+  `;
+
+  const result = await graphqlRequest<{ maps: Map[] }>(query, {});
+  return result.maps;
+}
+
+/**
+ * Получает карты по массиву SHA1 хешей
+ */
+export async function getMapsBySha1(sha1s: string[]): Promise<Map[]> {
+  const query = `
+    query GetMapsBySha1($sha1s: [String!]!) {
+      maps(where: { sha1: { in: $sha1s } }) {
+        id
+        sha1
+        size
+        name
+        filename
+        minecraftVersion
+        mapType
+        version
+        s3Url
+      }
+    }
+  `;
+
+  const result = await graphqlRequest<{ maps: Map[] }>(query, { sha1s });
+  return result.maps;
+}
+
+/**
+ * Создаёт карту
+ */
+export async function createMap(data: Partial<Map>): Promise<Map> {
+  const query = `
+    mutation CreateMap($data: MapCreateInput!) {
+      createMap(data: $data) {
+        id
+        name
+        description
+        image
+        minecraftVersion
+        mapType
+        buildId
+        buildName
+        version
+        sha1
+        size
+        filename
+        mimeType
+        s3Key
+        s3Bucket
+        s3Url
+        isPublic
+        downloads
+        author { id username }
+      }
+    }
+  `;
+
+  const result = await graphqlRequest<{ createMap: Map }>(query, { data });
+  return result.createMap;
+}
+
+/**
+ * Обновляет карту
+ */
+export async function updateMap(id: string, data: Partial<Map>): Promise<Map> {
+  const query = `
+    mutation UpdateMap($where: MapWhereUniqueInput!, $data: MapUpdateInput!) {
+      updateMap(where: $where, data: $data) {
+        id
+        name
+        description
+        image
+        minecraftVersion
+        mapType
+        buildId
+        buildName
+        version
+        sha1
+        size
+        filename
+        mimeType
+        s3Key
+        s3Bucket
+        s3Url
+        isPublic
+        downloads
+        author { id username }
+      }
+    }
+  `;
+
+  const result = await graphqlRequest<{ updateMap: Map }>(query, { where: { id }, data });
+  return result.updateMap;
+}
+
+/**
+ * Удаляет карту
+ */
+export async function deleteMap(id: string): Promise<void> {
+  const query = `
+    mutation DeleteMap($where: MapWhereUniqueInput!) {
+      deleteMap(where: $where) { id }
+    }
+  `;
+
+  await graphqlRequest(query, { where: { id } });
+}
+
+/**
+ * Загружает файл карты на сервер
+ */
+export async function uploadMap(
+  file: File | Blob,
+  filename: string,
+  mimeType: string,
+  extraFields?: Record<string, string>
+): Promise<MapUploadResponse> {
+  const apiUrl = getGraphQLUrl().replace('/graphql', '');
+  const token = getSessionToken();
+
+  const formData = new FormData();
+  formData.append('file', file);
+  formData.append('filename', filename);
+  formData.append('mimeType', mimeType);
+
+  if (extraFields) {
+    for (const [key, value] of Object.entries(extraFields)) {
+      formData.append(key, value);
+    }
+  }
+
+  const response = await fetch(`${apiUrl}/upload-map`, {
+    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 {
+      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();
+}
+
+/**
+ * Получает квоту хранилища карт текущего пользователя
+ */
+export const getUserMapsQuota = () =>
+  safeRequest<{ mapsUsedStorage: number; mapsQuota: number } | null>(
+    async () => {
+      const query = `
+      query {
+        authenticatedItem {
+          ... on User { id mapsUsedStorage mapsQuota }
+        }
+      }
+    `;
+      const result = await graphqlRequest<{
+        authenticatedItem: {
+          id: string;
+          mapsUsedStorage: number | null;
+          mapsQuota: number | null;
+        } | null;
+      }>(query);
+      if (!result.authenticatedItem) return null;
+      return {
+        mapsUsedStorage: result.authenticatedItem.mapsUsedStorage ?? 0,
+        mapsQuota: result.authenticatedItem.mapsQuota ?? 0,
+      };
+    },
+  );

package/src/shared/api/notify-websocket.ts

@@ -0,0 +1,140 @@
+/**
+ * WebSocket-клиент для @rynt/notify-service (инвайты и др.).
+ */
+
+import { getSessionToken } from './graphql';
+
+function getNotifyServiceWsUrl(): string {
+  const raw = (import.meta as unknown as { env?: Record<string, string> }).env
+    ?.VITE_NOTIFY_SERVICE_URL as string | undefined;
+  if (raw) {
+    const url = raw.endsWith('/') ? raw.slice(0, -1) : raw;
+    if (url.startsWith('ws://') || url.startsWith('wss://')) return url;
+    return url.replace(/^http/, 'ws');
+  }
+  return 'ws://localhost:3002';
+}
+
+export interface NotifyWSEvent {
+  event: string;
+  [key: string]: unknown;
+}
+
+export type NotifyWSEventHandler = (event: NotifyWSEvent) => void;
+
+export class NotifyWebSocketClient {
+  private ws: WebSocket | null = null;
+  private reconnectAttempts = 0;
+  private maxReconnectAttempts = 5;
+  private reconnectDelay = 1000;
+  private eventHandlers = new Map<string, Set<NotifyWSEventHandler>>();
+  private isConnecting = false;
+  private shouldReconnect = true;
+
+  connect(): Promise<void> {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      return Promise.resolve();
+    }
+    if (this.isConnecting) {
+      return Promise.reject(new Error('Connection already in progress'));
+    }
+    this.isConnecting = true;
+
+    return new Promise((resolve, reject) => {
+      const token = getSessionToken();
+      if (!token) {
+        this.isConnecting = false;
+        reject(new Error('No session token available'));
+        return;
+      }
+
+      const url = `${getNotifyServiceWsUrl()}/ws?token=${encodeURIComponent(token)}`;
+      this.ws = new WebSocket(url);
+
+      this.ws.onopen = () => {
+        this.isConnecting = false;
+        this.reconnectAttempts = 0;
+        resolve();
+      };
+
+      this.ws.onerror = () => {
+        this.isConnecting = false;
+        reject(new Error('Notify WebSocket error'));
+      };
+
+      this.ws.onclose = (event) => {
+        this.isConnecting = false;
+        if (this.shouldReconnect && event.code !== 1000) {
+          this.handleReconnect();
+        }
+      };
+
+      this.ws.onmessage = (ev) => {
+        try {
+          const data = JSON.parse(ev.data as string) as NotifyWSEvent;
+          this.dispatch(data);
+        } catch (e) {
+          console.error('[NotifyWebSocketClient] parse error', e);
+        }
+      };
+    });
+  }
+
+  disconnect(): void {
+    this.shouldReconnect = false;
+    if (this.ws) {
+      this.ws.close(1000, 'Client disconnect');
+      this.ws = null;
+    }
+  }
+
+  isConnected(): boolean {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+
+  on(event: string, handler: NotifyWSEventHandler): () => void {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, new Set());
+    }
+    this.eventHandlers.get(event)!.add(handler);
+    return () => this.off(event, handler);
+  }
+
+  off(event: string, handler: NotifyWSEventHandler): void {
+    const set = this.eventHandlers.get(event);
+    if (set) {
+      set.delete(handler);
+      if (set.size === 0) this.eventHandlers.delete(event);
+    }
+  }
+
+  private dispatch(event: NotifyWSEvent): void {
+    const named = this.eventHandlers.get(event.event);
+    named?.forEach((h) => {
+      try {
+        h(event);
+      } catch (e) {
+        console.error('[NotifyWebSocketClient] handler error', e);
+      }
+    });
+    const all = this.eventHandlers.get('*');
+    all?.forEach((h) => {
+      try {
+        h(event);
+      } catch (e) {
+        console.error('[NotifyWebSocketClient] * handler error', e);
+      }
+    });
+  }
+
+  private handleReconnect(): void {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) return;
+    this.reconnectAttempts++;
+    const delay = this.reconnectDelay * 2 ** (this.reconnectAttempts - 1);
+    setTimeout(() => {
+      if (this.shouldReconnect) {
+        this.connect().catch(() => {});
+      }
+    }, delay);
+  }
+}