@rynt/sdk 0.9.53

package/src/shared/api/posts.ts

@@ -0,0 +1,357 @@
+/**
+ * API для работы с постами проектов
+ */
+
+import type { EntityPost } from '../types/entities';
+import { safeRequest } from '../utils/safeRequest';
+import { graphqlRequest } from './graphql';
+
+export type Post = EntityPost;
+
+export interface PostInput {
+  projectId?: string; // Опционально - пост может быть без проекта
+  serverId?: string; // Опционально - пост может быть привязан к серверу
+  title: string;
+  description: string;
+  image?: string;
+  attachments?: string[];
+}
+
+const postAuthorFragment = `
+  author {
+    id
+    username
+    avatar
+  }
+`;
+
+/**
+ * Получает все посты (для фида главной страницы)
+ */
+export const getAllPosts = (options?: {
+  take?: number;
+  skip?: number;
+  orderBy?: Array<{ date?: 'asc' | 'desc' }>;
+}) =>
+  safeRequest(async (): Promise<EntityPost[]> => {
+    const query = `
+    query GetAllPosts($orderBy: [PostOrderByInput!]!, $take: Int, $skip: Int!) {
+      posts(orderBy: $orderBy, take: $take, skip: $skip) {
+        id
+        title
+        description
+        image
+        attachments
+        ${postAuthorFragment}
+        date
+        project {
+          id
+          name
+        }
+        server {
+          id
+          name
+        }
+      }
+    }
+  `;
+
+    const orderBy = options?.orderBy || [{ date: 'desc' }];
+
+    const result = await graphqlRequest<{ posts: EntityPost[] }>(query, {
+      orderBy,
+      take: options?.take || 48,
+      skip: options?.skip || 0,
+    });
+
+    return result.posts;
+  });
+
+/**
+ * Получает пост по ID
+ */
+export const getPost = (postId: string) =>
+  safeRequest(async (): Promise<EntityPost> => {
+    const query = `
+    query GetPost($where: PostWhereUniqueInput!) {
+      post(where: $where) {
+        id
+        title
+        description
+        image
+        attachments
+        ${postAuthorFragment}
+        date
+        project {
+          id
+          name
+        }
+        server {
+          id
+          name
+        }
+      }
+    }
+  `;
+
+    const result = await graphqlRequest<{ post: EntityPost }>(query, {
+      where: { id: postId },
+    });
+
+    return result.post;
+  });
+
+/**
+ * Получает список постов проекта
+ */
+export const getProjectPosts = (
+  projectId: string,
+  options?: {
+    take?: number;
+    skip?: number;
+    orderBy?: Array<{ date?: 'asc' | 'desc' }>;
+  },
+) =>
+  safeRequest(async (): Promise<EntityPost[]> => {
+    const query = `
+    query GetProjectPosts($where: PostWhereInput!, $orderBy: [PostOrderByInput!]!, $take: Int, $skip: Int!) {
+      posts(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
+        id
+        title
+        description
+        image
+        attachments
+        ${postAuthorFragment}
+        date
+        project {
+          id
+          name
+        }
+        server {
+          id
+          name
+        }
+      }
+    }
+  `;
+
+    const orderBy = options?.orderBy || [{ date: 'desc' }];
+
+    const result = await graphqlRequest<{ posts: EntityPost[] }>(query, {
+      where: {
+        project: { id: { equals: projectId } },
+      },
+      orderBy,
+      take: options?.take || 20,
+      skip: options?.skip || 0,
+    });
+
+    return result.posts;
+  });
+
+/**
+ * Получает список постов сервера
+ */
+export const getServerPosts = (
+  serverId: string,
+  options?: {
+    take?: number;
+    skip?: number;
+    orderBy?: Array<{ date?: 'asc' | 'desc' }>;
+  },
+) =>
+  safeRequest(async (): Promise<EntityPost[]> => {
+    const query = `
+    query GetServerPosts($where: PostWhereInput!, $orderBy: [PostOrderByInput!]!, $take: Int, $skip: Int!) {
+      posts(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
+        id
+        title
+        description
+        image
+        attachments
+        ${postAuthorFragment}
+        date
+        project {
+          id
+          name
+        }
+        server {
+          id
+          name
+        }
+      }
+    }
+  `;
+
+    const orderBy = options?.orderBy || [{ date: 'desc' }];
+
+    const result = await graphqlRequest<{ posts: EntityPost[] }>(query, {
+      where: {
+        server: { id: { equals: serverId } },
+      },
+      orderBy,
+      take: options?.take || 20,
+      skip: options?.skip || 0,
+    });
+
+    return result.posts;
+  });
+
+/**
+ * Получает список постов по массиву серверов
+ */
+export const getPostsByServers = (
+  serverIds: string[],
+  options?: {
+    take?: number;
+    skip?: number;
+    orderBy?: Array<{ date?: 'asc' | 'desc' }>;
+  },
+) =>
+  safeRequest(async (): Promise<EntityPost[]> => {
+    if (serverIds.length === 0) {
+      return [];
+    }
+
+    const query = `
+    query GetPostsByServers($where: PostWhereInput!, $orderBy: [PostOrderByInput!]!, $take: Int, $skip: Int!) {
+      posts(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
+        id
+        title
+        description
+        image
+        attachments
+        ${postAuthorFragment}
+        date
+        project {
+          id
+          name
+        }
+        server {
+          id
+          name
+        }
+      }
+    }
+  `;
+
+    const orderBy = options?.orderBy || [{ date: 'desc' }];
+
+    const result = await graphqlRequest<{ posts: EntityPost[] }>(query, {
+      where: {
+        server: { id: { in: serverIds } },
+      },
+      orderBy,
+      take: options?.take || 24,
+      skip: options?.skip || 0,
+    });
+
+    return result.posts;
+  });
+
+/**
+ * Создает новый пост
+ */
+export const createPost = (data: PostInput) =>
+  safeRequest(async (): Promise<EntityPost> => {
+    const mutation = `
+    mutation CreatePost($data: PostCreateInput!) {
+      createPost(data: $data) {
+        id
+        title
+        description
+        image
+        attachments
+        author {
+          id
+          username
+          avatar
+        }
+        date
+      }
+    }
+  `;
+
+    const createData: any = {
+      title: data.title,
+      description: data.description,
+      image: data.image || '',
+      attachments: data.attachments ?? [],
+      date: new Date().toISOString(),
+    };
+
+    // Привязываем к проекту или серверу, если указаны
+    if (data.projectId) {
+      createData.project = { connect: { id: data.projectId } };
+    }
+    if (data.serverId) {
+      createData.server = { connect: { id: data.serverId } };
+    }
+
+    const result = await graphqlRequest<{ createPost: EntityPost }>(mutation, {
+      data: createData,
+    });
+
+    return result.createPost;
+  });
+
+/**
+ * Обновляет пост
+ */
+export const updatePost = (
+  postId: string,
+  data: Partial<Omit<PostInput, 'projectId'>>,
+) =>
+  safeRequest(async (): Promise<EntityPost> => {
+    const mutation = `
+    mutation UpdatePost($where: PostWhereUniqueInput!, $data: PostUpdateInput!) {
+      updatePost(where: $where, data: $data) {
+        id
+        title
+        description
+        image
+        attachments
+        author {
+          id
+          username
+          avatar
+        }
+        date
+      }
+    }
+  `;
+
+    const updateData: any = {};
+    if (data.title !== undefined) updateData.title = data.title;
+    if (data.description !== undefined)
+      updateData.description = data.description;
+    if (data.image !== undefined) updateData.image = data.image;
+    if (data.attachments !== undefined) updateData.attachments = data.attachments;
+
+    const result = await graphqlRequest<{ updatePost: EntityPost }>(mutation, {
+      where: { id: postId },
+      data: updateData,
+    });
+
+    return result.updatePost;
+  });
+
+/**
+ * Удаляет пост
+ */
+export const deletePost = (postId: string) =>
+  safeRequest(async (): Promise<EntityPost> => {
+    const mutation = `
+    mutation DeletePost($where: PostWhereUniqueInput!) {
+      deletePost(where: $where) {
+        id
+      }
+    }
+  `;
+
+    const result = await graphqlRequest<{ deletePost: EntityPost }>(mutation, {
+      where: { id: postId },
+    });
+
+    return result.deletePost;
+  });

package/src/shared/api/projectServers.ts

@@ -0,0 +1,379 @@
+/**
+ * API для работы с серверами проектов
+ */
+
+import type { EntityServer } from '../types/entities';
+import { safeRequest } from '../utils/safeRequest';
+import { graphqlRequest } from './graphql';
+
+export interface ServerInput {
+  projectId?: string; // Опционально - сервер может быть без проекта
+  name: string;
+  address: string;
+  port: number;
+  status?: 'online' | 'offline';
+  buildId?: string;
+  buildName?: string;
+  players?: number;
+  maxPlayers?: number;
+  tags?: string[];
+  allowedProviders?: string[] | null;
+  image?: string;
+  description?: string;
+  rules?: string;
+  isPublic?: boolean;
+}
+
+/**
+ * Получает список всех серверов пользователя (где он автор проекта или сервер без проекта)
+ */
+export const getUserServers = (userId: string) =>
+  safeRequest(async (): Promise<EntityServer[]> => {
+    // Получаем серверы, где пользователь является администратором через ServerMember
+    const adminServersQuery = `
+    query GetAdminServers($where: ServerMemberWhereInput!) {
+      serverMembers(where: $where) {
+        id
+        server {
+          id
+          name
+          address
+          port
+          status
+          build {
+            id
+            name
+          }
+          buildName
+          players
+          maxPlayers
+          tags
+          allowedProviders
+          image
+          description
+          rules
+          isPublic
+          project {
+            id
+            name
+            author {
+              id
+            }
+          }
+        }
+      }
+    }
+  `;
+
+    const adminServersResult = await graphqlRequest<{
+      serverMembers: Array<{ server: any }>;
+    }>(adminServersQuery, {
+      where: {
+        user: { id: { equals: userId } },
+        role: { equals: 'admin' },
+      },
+    });
+
+    // Преобразуем build в buildId для каждого сервера
+    return adminServersResult.serverMembers
+      .filter((member) => member.server) // Фильтруем только те, у которых есть сервер
+      .map((member: any) => {
+        const server = member.server;
+        if (server.build) {
+          server.buildId = server.build.id;
+          delete server.build;
+        }
+        return server as EntityServer;
+      });
+  });
+
+/**
+ * Получает сервер по ID
+ */
+export const getServer = (serverId: string) =>
+  safeRequest(async (): Promise<EntityServer> => {
+    const query = `
+    query GetProjectServer($where: ProjectServerWhereUniqueInput!) {
+      projectServer(where: $where) {
+        id
+        name
+        address
+        port
+        status
+        build {
+          id
+          name
+        }
+        buildName
+        players
+        maxPlayers
+        tags
+        allowedProviders
+        image
+        description
+        rules
+        isPublic
+        project {
+          id
+          name
+          author {
+            id
+            username
+            avatar
+          }
+          managers {
+            id
+            username
+            avatar
+          }
+        }
+      }
+    }
+  `;
+
+    const result = await graphqlRequest<{ projectServer: any }>(query, {
+      where: { id: serverId },
+    });
+
+    // Преобразуем build в buildId
+    const server = result.projectServer;
+    if (server.build) {
+      server.buildId = server.build.id;
+      delete server.build;
+    }
+
+    return server as EntityServer;
+  });
+
+/**
+ * Создает новый сервер проекта (или без проекта)
+ */
+export const createServer = (data: ServerInput) =>
+  safeRequest(async (): Promise<EntityServer> => {
+    const mutation = `
+    mutation CreateProjectServer($data: ProjectServerCreateInput!) {
+      createProjectServer(data: $data) {
+        id
+        name
+        address
+        port
+        status
+        buildName
+        players
+        maxPlayers
+        tags
+        allowedProviders
+        image
+        description
+        rules
+        isPublic
+      }
+    }
+  `;
+
+    const createData: any = {
+      name: data.name,
+      address: data.address,
+      port: data.port,
+      status: data.status || 'offline',
+      build: data.buildId ? { connect: { id: data.buildId } } : undefined,
+      buildName: data.buildName,
+      players: data.players,
+      maxPlayers: data.maxPlayers,
+      tags: data.tags || [],
+      allowedProviders: data.allowedProviders || null,
+      image: data.image || '',
+      description: data.description || '',
+      rules: data.rules || '',
+      isPublic: data.isPublic !== undefined ? data.isPublic : true,
+    };
+
+    // Привязываем к проекту только если указан
+    if (data.projectId) {
+      createData.project = { connect: { id: data.projectId } };
+    }
+
+    const result = await graphqlRequest<{ createProjectServer: EntityServer }>(
+      mutation,
+      {
+        data: createData,
+      },
+    );
+
+    return result.createProjectServer;
+  });
+
+/**
+ * Обновляет сервер проекта
+ */
+export const updateServer = (serverId: string, data: Partial<ServerInput>) =>
+  safeRequest(async (): Promise<EntityServer> => {
+    const mutation = `
+    mutation UpdateProjectServer($where: ProjectServerWhereUniqueInput!, $data: ProjectServerUpdateInput!) {
+      updateProjectServer(where: $where, data: $data) {
+        id
+        name
+        address
+        port
+        status
+        build {
+          id
+          name
+        }
+        buildName
+        players
+        maxPlayers
+        tags
+        allowedProviders
+        image
+        description
+        rules
+        isPublic
+      }
+    }
+  `;
+
+    const updateData: any = {};
+    if (data.name !== undefined) updateData.name = data.name;
+    if (data.address !== undefined) updateData.address = data.address;
+    if (data.port !== undefined) updateData.port = data.port;
+    if (data.status !== undefined) updateData.status = data.status;
+    if (data.buildId !== undefined) {
+      updateData.build = data.buildId
+        ? { connect: { id: data.buildId } }
+        : { disconnect: true };
+    }
+    if (data.buildName !== undefined) updateData.buildName = data.buildName;
+    if (data.players !== undefined) updateData.players = data.players;
+    if (data.maxPlayers !== undefined) updateData.maxPlayers = data.maxPlayers;
+    if (data.tags !== undefined) updateData.tags = data.tags;
+    if (data.allowedProviders !== undefined)
+      updateData.allowedProviders = data.allowedProviders;
+    if (data.image !== undefined) updateData.image = data.image;
+    if (data.description !== undefined)
+      updateData.description = data.description;
+    if (data.rules !== undefined) updateData.rules = data.rules;
+    if (data.isPublic !== undefined) updateData.isPublic = data.isPublic;
+
+    const result = await graphqlRequest<{ updateProjectServer: any }>(
+      mutation,
+      {
+        where: { id: serverId },
+        data: updateData,
+      },
+    );
+
+    // Преобразуем build в buildId
+    const server = result.updateProjectServer;
+    if (server.build) {
+      server.buildId = server.build.id;
+      delete server.build;
+    }
+
+    return server as EntityServer;
+  });
+
+/**
+ * Удаляет сервер проекта
+ */
+export const deleteServer = (serverId: string) =>
+  safeRequest(async (): Promise<EntityServer> => {
+    const mutation = `
+    mutation DeleteProjectServer($where: ProjectServerWhereUniqueInput!) {
+      deleteProjectServer(where: $where) {
+        id
+      }
+    }
+  `;
+
+    const result = await graphqlRequest<{ deleteProjectServer: EntityServer }>(
+      mutation,
+      {
+        where: { id: serverId },
+      },
+    );
+
+    return result.deleteProjectServer;
+  });
+
+/**
+ * Получает список серверов с поиском и фильтрацией
+ */
+export const getServers = (options?: {
+  take?: number;
+  skip?: number;
+  orderBy?: Array<{ name?: 'asc' | 'desc'; players?: 'asc' | 'desc' }>;
+  /** Только серверы с isPublic: true (библиотека, каталог). */
+  publicOnly?: boolean;
+  where?: {
+    search?: string;
+  };
+}) =>
+  safeRequest(async (): Promise<EntityServer[]> => {
+    const query = `
+    query GetServers($where: ProjectServerWhereInput!, $orderBy: [ProjectServerOrderByInput!]!, $take: Int, $skip: Int!) {
+      projectServers(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
+        id
+        name
+        address
+        port
+        status
+        build {
+          id
+          name
+        }
+        buildName
+        players
+        maxPlayers
+        tags
+        image
+        description
+        isPublic
+        project {
+          id
+          name
+          author {
+            id
+            username
+            avatar
+          }
+        }
+      }
+    }
+  `;
+
+    const where: any = {};
+
+    if (options?.publicOnly) {
+      where.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' },
+        },
+        { address: { contains: options.where.search, mode: 'insensitive' } },
+      ];
+    }
+
+    const orderBy = options?.orderBy || [{ name: 'asc' }];
+
+    const result = await graphqlRequest<{ projectServers: any[] }>(query, {
+      where,
+      orderBy,
+      take: options?.take || 20,
+      skip: options?.skip || 0,
+    });
+
+    // Преобразуем build в buildId для каждого сервера
+    return result.projectServers.map((server: any) => {
+      if (server.build) {
+        server.buildId = server.build.id;
+        delete server.build;
+      }
+      return server as EntityServer;
+    });
+  });