@rynt/sdk 0.9.53

package/src/shared/api/serverMembers.ts

@@ -0,0 +1,173 @@
+/**
+ * API для работы с участниками серверов
+ */
+
+import type { EntityServerMember } from '../types/entities';
+import type { ServerMemberRole } from '../types/serverMember';
+import { safeRequest } from '../utils/safeRequest';
+import { graphqlRequest } from './graphql';
+
+export interface ServerMemberInput {
+  serverId: string;
+  userId: string;
+  role: ServerMemberRole;
+  invitedBy?: string;
+}
+
+const memberFragment = `
+  id
+  user {
+    id
+    username
+    avatar
+  }
+  role
+  joinedAt
+  invitedBy {
+    id
+    username
+  }
+`;
+
+/**
+ * Получает список участников сервера
+ */
+export const getServerMembers = (serverId: string) =>
+  safeRequest(async (): Promise<EntityServerMember[]> => {
+    const query = `
+      query GetServerMembers($where: ServerMemberWhereInput!) {
+        serverMembers(where: $where) {
+          ${memberFragment}
+        }
+      }
+    `;
+
+    const result = await graphqlRequest<{ serverMembers: EntityServerMember[] }>(query, {
+      where: {
+        server: { id: { equals: serverId } },
+      },
+    });
+
+    return result.serverMembers;
+  });
+
+/**
+ * Приглашает участника на сервер
+ */
+export const inviteServerMember = (data: ServerMemberInput) =>
+  safeRequest(async (): Promise<EntityServerMember> => {
+    const mutation = `
+      mutation CreateServerMember($data: ServerMemberCreateInput!) {
+        createServerMember(data: $data) {
+          ${memberFragment}
+        }
+      }
+    `;
+
+    const result = await graphqlRequest<{ createServerMember: EntityServerMember }>(mutation, {
+      data: {
+        server: { connect: { id: data.serverId } },
+        user: { connect: { id: data.userId } },
+        role: data.role,
+        invitedBy: data.invitedBy ? { connect: { id: data.invitedBy } } : undefined,
+      },
+    });
+
+    return result.createServerMember;
+  });
+
+/**
+ * Обновляет роль участника
+ */
+export const updateServerMemberRole = (memberId: string, role: ServerMemberRole) =>
+  safeRequest(async (): Promise<EntityServerMember> => {
+    const mutation = `
+      mutation UpdateServerMember($where: ServerMemberWhereUniqueInput!, $data: ServerMemberUpdateInput!) {
+        updateServerMember(where: $where, data: $data) {
+          id
+          role
+        }
+      }
+    `;
+
+    const result = await graphqlRequest<{ updateServerMember: EntityServerMember }>(mutation, {
+      where: { id: memberId },
+      data: { role },
+    });
+
+    return result.updateServerMember;
+  });
+
+/**
+ * Удаляет участника с сервера
+ */
+export const removeServerMember = (memberId: string) =>
+  safeRequest(async (): Promise<{ id: string }> => {
+    const mutation = `
+      mutation DeleteServerMember($where: ServerMemberWhereUniqueInput!) {
+        deleteServerMember(where: $where) {
+          id
+        }
+      }
+    `;
+
+    const result = await graphqlRequest<{ deleteServerMember: { id: string } }>(mutation, {
+      where: { id: memberId },
+    });
+
+    return result.deleteServerMember;
+  });
+
+/**
+ * Присоединяет текущего пользователя к серверу
+ */
+export const joinServer = (serverId: string) =>
+  safeRequest(async (): Promise<EntityServerMember> => {
+    const mutation = `
+      mutation CreateServerMember($data: ServerMemberCreateInput!) {
+        createServerMember(data: $data) {
+          ${memberFragment}
+        }
+      }
+    `;
+
+    const result = await graphqlRequest<{ createServerMember: EntityServerMember }>(mutation, {
+      data: {
+        server: { connect: { id: serverId } },
+      },
+    });
+
+    return result.createServerMember;
+  });
+
+/**
+ * Получает роль текущего пользователя на сервере
+ */
+export const getCurrentUserServerRole = (serverId: string) =>
+  safeRequest(async (): Promise<ServerMemberRole | null> => {
+    const query = `
+      query GetCurrentUserServerRole($serverId: ID!) {
+        authenticatedItem {
+          ... on User {
+            id
+            serverMemberships(where: { server: { id: { equals: $serverId } } }) {
+              role
+            }
+          }
+        }
+      }
+    `;
+
+    const result = await graphqlRequest<{
+      authenticatedItem: {
+        id: string;
+        serverMemberships: Array<{ role: ServerMemberRole }>;
+      } | null;
+    }>(query, { serverId });
+
+    if (!result.authenticatedItem || result.authenticatedItem.serverMemberships.length === 0) {
+      return null;
+    }
+
+    return result.authenticatedItem.serverMemberships[0].role;
+  });

package/src/shared/api/users.ts

@@ -0,0 +1,294 @@
+/**
+ * API профиля пользователя и публичного контента автора
+ */
+
+import type { EntityPost, EntityServer, EntityUser } from '../types/entities';
+import type { Build } from './builds';
+import type { Map } from './maps';
+import { getUserServers } from './projectServers';
+import { safeRequest } from '../utils/safeRequest';
+import { graphqlRequest } from './graphql';
+
+export type UserProfile = Pick<
+  EntityUser,
+  'id' | 'username' | 'avatar' | 'bio' | 'status' | 'statusDetail' | 'level' | 'lastSeenAt'
+>;
+
+const postListFragment = `
+  id
+  title
+  description
+  image
+  date
+  author {
+    id
+    username
+    avatar
+  }
+  project {
+    id
+    name
+  }
+  server {
+    id
+    name
+  }
+`;
+
+const publicServerFragment = `
+  id
+  name
+  address
+  port
+  status
+  build {
+    id
+    name
+  }
+  buildName
+  players
+  maxPlayers
+  tags
+  image
+  description
+  isPublic
+`;
+
+/**
+ * Публичный профиль пользователя (без email)
+ */
+export const getUserProfile = (userId: string) =>
+  safeRequest(async (): Promise<UserProfile | null> => {
+    const query = `
+      query GetUserProfile($where: UserWhereUniqueInput!) {
+        user(where: $where) {
+          id
+          username
+          avatar
+          bio
+          status
+          statusDetail
+          level
+          lastSeenAt
+        }
+      }
+    `;
+
+    const result = await graphqlRequest<{ user: UserProfile | null }>(query, {
+      where: { id: userId },
+    });
+
+    return result.user;
+  });
+
+/**
+ * Посты пользователя (с учётом filter.query на Post — приватные серверы скрыты)
+ */
+export const getUserPosts = (
+  userId: string,
+  options?: {
+    take?: number;
+    skip?: number;
+    orderBy?: Array<{ date?: 'asc' | 'desc' }>;
+  },
+) =>
+  safeRequest(async (): Promise<EntityPost[]> => {
+    const query = `
+      query GetUserPosts($where: PostWhereInput!, $orderBy: [PostOrderByInput!]!, $take: Int, $skip: Int!) {
+        posts(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
+          ${postListFragment}
+        }
+      }
+    `;
+
+    const orderBy = options?.orderBy || [{ date: 'desc' }];
+
+    const result = await graphqlRequest<{ posts: EntityPost[] }>(query, {
+      where: {
+        author: { id: { equals: userId } },
+      },
+      orderBy,
+      take: options?.take ?? 24,
+      skip: options?.skip ?? 0,
+    });
+
+    return result.posts;
+  });
+
+/**
+ * Публичные серверы, на которых пользователь состоит (любая роль)
+ */
+export const getUserPublicServerMemberships = (userId: string) =>
+  safeRequest(async (): Promise<EntityServer[]> => {
+    const query = `
+      query GetUserPublicMemberships($where: ServerMemberWhereInput!) {
+        serverMembers(where: $where) {
+          server {
+            ${publicServerFragment}
+          }
+        }
+      }
+    `;
+
+    const result = await graphqlRequest<{
+      serverMembers: Array<{ server: EntityServer | null }>;
+    }>(query, {
+      where: {
+        user: { id: { equals: userId } },
+        server: { isPublic: { equals: true } },
+      },
+    });
+
+    return result.serverMembers
+      .map((m) => {
+        const server = m.server;
+        if (!server) return null;
+        if (server.build) {
+          server.buildId = server.build.id;
+          delete (server as { build?: unknown }).build;
+        }
+        return server;
+      })
+      .filter((s): s is EntityServer => !!s);
+  });
+
+/**
+ * Публичные сборки автора
+ */
+export const getUserPublicBuilds = (
+  userId: string,
+  options?: { take?: number; skip?: number },
+) =>
+  safeRequest(async (): Promise<Build[]> => {
+    const query = `
+      query GetUserPublicBuilds($where: BuildWhereInput!, $take: Int, $skip: Int!) {
+        builds(where: $where, orderBy: [{ downloads: desc }], take: $take, skip: $skip) {
+          id
+          name
+          description
+          image
+          isPublic
+          downloads
+          rating
+          minecraftVersion
+          loader
+          author {
+            id
+            username
+          }
+        }
+      }
+    `;
+
+    const result = await graphqlRequest<{ builds: Build[] }>(query, {
+      where: {
+        AND: [
+          { author: { id: { equals: userId } } },
+          { isPublic: { equals: true } },
+        ],
+      },
+      take: options?.take ?? 48,
+      skip: options?.skip ?? 0,
+    });
+
+    return result.builds;
+  });
+
+/**
+ * Публичные карты автора
+ */
+export const getUserPublicMaps = (
+  userId: string,
+  options?: { take?: number; skip?: number },
+) =>
+  safeRequest(async (): Promise<Map[]> => {
+    const query = `
+      query GetUserPublicMaps($where: MapWhereInput!, $take: Int, $skip: Int!) {
+        maps(where: $where, orderBy: [{ downloads: desc }], take: $take, skip: $skip) {
+          id
+          name
+          description
+          image
+          minecraftVersion
+          mapType
+          buildId
+          buildName
+          version
+          sha1
+          size
+          isPublic
+          downloads
+          author { id username }
+          createdAt
+        }
+      }
+    `;
+
+    const result = await graphqlRequest<{ maps: Map[] }>(query, {
+      where: {
+        AND: [
+          { author: { id: { equals: userId } } },
+          { isPublic: { equals: true } },
+        ],
+      },
+      take: options?.take ?? 48,
+      skip: options?.skip ?? 0,
+    });
+
+    return result.maps;
+  });
+
+/**
+ * Публичные серверы, где пользователь автор проекта или администратор
+ */
+export const getUserPublicAuthoredServers = (userId: string) =>
+  safeRequest(async (): Promise<EntityServer[]> => {
+    const projectAuthorQuery = `
+      query GetProjectAuthorServers($where: ProjectServerWhereInput!) {
+        projectServers(where: $where) {
+          ${publicServerFragment}
+          project {
+            id
+            name
+          }
+        }
+      }
+    `;
+
+    const [projectResult, adminRes] = await Promise.all([
+      graphqlRequest<{ projectServers: EntityServer[] }>(projectAuthorQuery, {
+        where: {
+          AND: [
+            { isPublic: { equals: true } },
+            { project: { author: { id: { equals: userId } } } },
+          ],
+        },
+      }),
+      getUserServers(userId),
+    ]);
+
+    const byId = new Map<string, EntityServer>();
+
+    for (const server of projectResult.projectServers) {
+      if (!server?.id) continue;
+      const normalized = { ...server };
+      if (normalized.build) {
+        normalized.buildId = normalized.build.id;
+        delete (normalized as { build?: unknown }).build;
+      }
+      if (normalized.isPublic !== false) {
+        byId.set(normalized.id, normalized);
+      }
+    }
+
+    if (adminRes.ok) {
+      for (const server of adminRes.result) {
+        if (!server?.id || server.isPublic === false) continue;
+        if (!byId.has(server.id)) {
+          byId.set(server.id, server);
+        }
+      }
+    }
+
+    return Array.from(byId.values());
+  });

package/src/shared/composables/buildEditor/useBuildEditor.ts

@@ -0,0 +1,66 @@
+import { ref, computed } from 'vue';
+import { defineStore } from '../../definitions/defineStore';
+import { useBuildManifestModel } from '../buildManifest/buildManifest';
+
+/**
+ * Глобальное состояние редактора сборки.
+ * Редактор не привязан к роуту: открытие/закрытие только через startEditing/stopEditing.
+ */
+export const useBuildEditor = defineStore(() => {
+  const editingBuildUuid = ref<string | null>(null);
+  const isEditorVisible = ref(true);
+
+  const buildManifest = useBuildManifestModel();
+
+  const isEditorActive = computed(() => editingBuildUuid.value !== null);
+
+  /** Показывать ли слой редактора (активен и не свёрнут) */
+  const isEditorShown = computed(
+    () => editingBuildUuid.value !== null && isEditorVisible.value,
+  );
+
+  /** Название открытой сборки для сайдбара и т.п. */
+  const openBuildDisplayName = computed(() => {
+    const name = buildManifest.manifest.value?._meta?.name;
+    if (name?.trim()) return name.trim();
+    const uuid = editingBuildUuid.value;
+    if (uuid === '_new') return 'Новая сборка';
+    return uuid ? 'Сборка' : '';
+  });
+
+  /** Открыть сборку для редактирования (показывает редактор) */
+  const startEditing = (uuid: string) => {
+    editingBuildUuid.value = uuid;
+    isEditorVisible.value = true;
+  };
+
+  const stopEditing = () => {
+    editingBuildUuid.value = null;
+    isEditorVisible.value = false;
+  };
+
+  /** Показать уже открытый редактор (например, по клику в сайдбаре) */
+  const showEditor = () => {
+    if (editingBuildUuid.value !== null) {
+      isEditorVisible.value = true;
+    }
+  };
+
+  /** Свернуть редактор (оставить сборку «открытой», скрыть слой) */
+  const hideEditor = () => {
+    isEditorVisible.value = false;
+  };
+
+  return {
+    editingBuildUuid,
+    isEditorActive,
+    isEditorVisible,
+    isEditorShown,
+    openBuildDisplayName,
+    startEditing,
+    stopEditing,
+    showEditor,
+    hideEditor,
+    buildManifest,
+  };
+});