devsyncwrld/backspace
1
0
Fork 0
Code Issues Pull Requests Actions 26 Packages Projects Releases Wiki Activity

refactor: rename Server → Space across entire codebase

Browse Source 
Renames all domain terminology from "Server" to "Space" throughout the
application — database schema, API routes, shared types, stores, components,
and UI strings. Files renamed: ServerSidebar → SpaceSidebar, CreateServer →
CreateSpace, JoinServer → JoinSpace, ServerSettings → SpaceSettings,
serverStore → spaceStore, routes/servers → routes/spaces.
This commit is contained in:
Jannis Braun
2026-03-08 20:08:24 +01:00
parent d18d9c51f7
commit fc06e25731
62 changed files with 1342 additions and 1342 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/server/src/routes/channels.ts
+43 -43
View File
@@ -3,7 +3,7 @@ import { eq, and } from 'drizzle-orm';
import { getDb, schema } from '../db/index.js';
import { authenticate } from '../utils/auth.js';
import { generateSnowflake } from '../utils/snowflake.js';
import { isMember, hasPermission, getChannelServerId, PermissionBits, computePermissions } from '../utils/permissions.js';
import { isMember, hasPermission, getChannelSpaceId, PermissionBits, computePermissions } from '../utils/permissions.js';
import { permissionsToString } from '@backspace/shared/src/permissions.js';
import { connectionManager } from '../ws/handler.js';
import type {
@@ -15,7 +15,7 @@ import type {
function rowToChannel(row: typeof schema.channels.$inferSelect): Channel {
return {
id: row.id,
serverId: row.serverId,
spaceId: row.spaceId,
name: row.name,
type: row.type as Channel['type'],
topic: row.topic,
@@ -25,57 +25,57 @@ function rowToChannel(row: typeof schema.channels.$inferSelect): Channel {
}
/**
* After a channel override changes, notify each server member:
* After a channel override changes, notify each space member:
* - VIEW_CHANNEL holders receive channel_updated (with their myPermissions)
* - Non-viewers receive channel_deleted to remove the channel from their UI
*/
function broadcastOverrideChange(serverId: string, channelId: string): void {
function broadcastOverrideChange(spaceId: string, channelId: string): void {
const db = getDb();
const channel = db.select().from(schema.channels).where(eq(schema.channels.id, channelId)).get();
if (!channel) return;
const channelData = rowToChannel(channel);
for (const [userId, serverIds] of connectionManager.getUserServerEntries()) {
if (!serverIds.has(serverId)) continue;
for (const [userId, spaceIds] of connectionManager.getUserSpaceEntries()) {
if (!spaceIds.has(spaceId)) continue;
const perms = computePermissions(userId, serverId, channelId);
const perms = computePermissions(userId, spaceId, channelId);
if ((perms & PermissionBits.VIEW_CHANNEL) !== 0n) {
connectionManager.sendToUser(userId, {
type: 'channel_updated',
channel: { ...channelData, myPermissions: permissionsToString(perms) },
serverId,
spaceId,
});
} else {
connectionManager.sendToUser(userId, {
type: 'channel_deleted',
channelId,
serverId,
spaceId,
});
}
}
}
export async function channelRoutes(app: FastifyInstance): Promise<void> {
// GET /api/servers/:id/channels - List channels in a server
app.get<{ Params: { id: string } }>('/api/servers/:id/channels', {
// GET /api/spaces/:id/channels - List channels in a space
app.get<{ Params: { id: string } }>('/api/spaces/:id/channels', {
preHandler: authenticate,
}, async (request, reply) => {
const { id } = request.params;
const db = getDb();
const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
if (!server) {
return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
const space = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
if (!space) {
return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
}
if (!isMember(id, request.userId)) {
return reply.code(403).send({ error: 'You are not a member of this server', statusCode: 403 });
return reply.code(403).send({ error: 'You are not a member of this space', statusCode: 403 });
}
const allChannels = db.select()
.from(schema.channels)
.where(eq(schema.channels.serverId, id))
.where(eq(schema.channels.spaceId, id))
.all();
// Filter by VIEW_CHANNEL permission per channel
@@ -90,17 +90,17 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
return reply.code(200).send(visibleChannels.map(rowToChannel));
});
// POST /api/servers/:id/channels - Create a channel (admin+)
app.post<{ Params: { id: string }; Body: CreateChannelRequest }>('/api/servers/:id/channels', {
// POST /api/spaces/:id/channels - Create a channel (admin+)
app.post<{ Params: { id: string }; Body: CreateChannelRequest }>('/api/spaces/:id/channels', {
preHandler: authenticate,
}, async (request, reply) => {
const { id } = request.params;
const { name, type, topic } = request.body;
const db = getDb();
const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
if (!server) {
return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
const space = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
if (!space) {
return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
}
if (!hasPermission(request.userId, id, PermissionBits.MANAGE_CHANNELS)) {
@@ -123,7 +123,7 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
// Get max position for ordering
const existingChannels = db.select()
.from(schema.channels)
.where(eq(schema.channels.serverId, id))
.where(eq(schema.channels.spaceId, id))
.all();
const maxPosition = existingChannels.reduce((max, ch) => Math.max(max, ch.position ?? 0), -1);
@@ -133,7 +133,7 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
db.insert(schema.channels).values({
id: channelId,
serverId: id,
spaceId: id,
name: trimmedName,
type,
topic: topic?.trim() || null,
@@ -148,11 +148,11 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
const channelData = rowToChannel(channel);
// Broadcast channel_created to all server members
connectionManager.sendToServer(id, {
// Broadcast channel_created to all space members
connectionManager.sendToSpace(id, {
type: 'channel_created',
channel: channelData,
serverId: id,
spaceId: id,
});
return reply.code(201).send(channelData);
@@ -171,8 +171,8 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
return reply.code(404).send({ error: 'Channel not found', statusCode: 404 });
}
const serverId = channel.serverId;
if (!hasPermission(request.userId, serverId, PermissionBits.MANAGE_CHANNELS, id)) {
const spaceId = channel.spaceId;
if (!hasPermission(request.userId, spaceId, PermissionBits.MANAGE_CHANNELS, id)) {
return reply.code(403).send({ error: 'Missing MANAGE_CHANNELS permission', statusCode: 403 });
}
@@ -211,10 +211,10 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
const channelData = rowToChannel(updated);
// Broadcast channel_updated to members with VIEW_CHANNEL
connectionManager.sendToChannel(serverId, id, {
connectionManager.sendToChannel(spaceId, id, {
type: 'channel_updated',
channel: channelData,
serverId,
spaceId,
});
return reply.code(200).send(channelData);
@@ -232,16 +232,16 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
return reply.code(404).send({ error: 'Channel not found', statusCode: 404 });
}
const serverId = channel.serverId;
if (!hasPermission(request.userId, serverId, PermissionBits.MANAGE_CHANNELS, id)) {
const spaceId = channel.spaceId;
if (!hasPermission(request.userId, spaceId, PermissionBits.MANAGE_CHANNELS, id)) {
return reply.code(403).send({ error: 'Missing MANAGE_CHANNELS permission', statusCode: 403 });
}
// Collect viewers BEFORE deleting (overrides CASCADE-delete with the channel)
const viewerIds: string[] = [];
for (const [uid, serverIds] of connectionManager.getUserServerEntries()) {
if (serverIds.has(serverId)) {
const perms = computePermissions(uid, serverId, id);
for (const [uid, spaceIds] of connectionManager.getUserSpaceEntries()) {
if (spaceIds.has(spaceId)) {
const perms = computePermissions(uid, spaceId, id);
if ((perms & PermissionBits.VIEW_CHANNEL) !== 0n) {
viewerIds.push(uid);
}
@@ -253,7 +253,7 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
db.delete(schema.channels).where(eq(schema.channels.id, id)).run();
// Broadcast channel_deleted only to users who could see the channel
const deleteEvent = { type: 'channel_deleted' as const, channelId: id, serverId };
const deleteEvent = { type: 'channel_deleted' as const, channelId: id, spaceId };
for (const uid of viewerIds) {
connectionManager.sendToUser(uid, deleteEvent);
}
@@ -275,7 +275,7 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
return reply.code(404).send({ error: 'Channel not found', statusCode: 404 });
}
if (!hasPermission(request.userId, channel.serverId, PermissionBits.MANAGE_ROLES)) {
if (!hasPermission(request.userId, channel.spaceId, PermissionBits.MANAGE_ROLES)) {
return reply.code(403).send({ error: 'Missing MANAGE_ROLES permission', statusCode: 403 });
}
@@ -315,7 +315,7 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
return reply.code(404).send({ error: 'Channel not found', statusCode: 404 });
}
if (!hasPermission(request.userId, channel.serverId, PermissionBits.MANAGE_ROLES)) {
if (!hasPermission(request.userId, channel.spaceId, PermissionBits.MANAGE_ROLES)) {
return reply.code(403).send({ error: 'Missing MANAGE_ROLES permission', statusCode: 403 });
}
@@ -346,8 +346,8 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
}).run();
});
// Notify all server members of the permission change
broadcastOverrideChange(channel.serverId, id);
// Notify all space members of the permission change
broadcastOverrideChange(channel.spaceId, id);
return reply.code(200).send({ success: true });
});
@@ -365,7 +365,7 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
return reply.code(404).send({ error: 'Channel not found', statusCode: 404 });
}
if (!hasPermission(request.userId, channel.serverId, PermissionBits.MANAGE_ROLES)) {
if (!hasPermission(request.userId, channel.spaceId, PermissionBits.MANAGE_ROLES)) {
return reply.code(403).send({ error: 'Missing MANAGE_ROLES permission', statusCode: 403 });
}
@@ -377,8 +377,8 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
)
).run();
// Notify all server members of the permission change
broadcastOverrideChange(channel.serverId, id);
// Notify all space members of the permission change
broadcastOverrideChange(channel.spaceId, id);
return reply.code(200).send({ success: true });
},
packages/server/src/routes/explore.ts
+113 -113
View File
@@ -3,14 +3,14 @@ import { eq, and, sql, inArray } from 'drizzle-orm';
import { getDb, getRawDb, schema } from '../db/index.js';
import { authenticate } from '../utils/auth.js';
import { generateSnowflake } from '../utils/snowflake.js';
import { isMember, isServerOwner, hasPermission, computePermissions, PermissionBits, permissionsToString } from '../utils/permissions.js';
import { isMember, isSpaceOwner, hasPermission, computePermissions, PermissionBits, permissionsToString } from '../utils/permissions.js';
import { connectionManager } from '../ws/handler.js';
import { sanitizeUser } from '../utils/sanitize.js';
import type {
ExploreServer,
ExploreSpace,
JoinRequest,
MemberWithUser,
ServerWithChannelsAndMembers,
SpaceWithChannelsAndMembers,
Channel,
} from '@backspace/shared';
@@ -20,7 +20,7 @@ function rowToJoinRequest(
): JoinRequest {
return {
id: row.id,
serverId: row.serverId,
spaceId: row.spaceId,
userId: row.userId,
message: row.message,
status: row.status as JoinRequest['status'],
@@ -32,22 +32,22 @@ function rowToJoinRequest(
}
/**
* Find all online users for a server who have MANAGE_SERVER or are the owner.
* Find all online users for a space who have MANAGE_SPACE or are the owner.
* Used to route join_request_received events.
*/
function getServerManagers(serverId: string): string[] {
function getSpaceManagers(spaceId: string): string[] {
const db = getDb();
const server = db.select().from(schema.servers).where(eq(schema.servers.id, serverId)).get();
if (!server) return [];
const space = db.select().from(schema.spaces).where(eq(schema.spaces.id, spaceId)).get();
if (!space) return [];
const memberRows = db.select()
.from(schema.serverMembers)
.where(eq(schema.serverMembers.serverId, serverId))
.from(schema.spaceMembers)
.where(eq(schema.spaceMembers.spaceId, spaceId))
.all();
const managers: string[] = [];
for (const member of memberRows) {
if (member.userId === server.ownerId || hasPermission(member.userId, serverId, PermissionBits.MANAGE_SERVER)) {
if (member.userId === space.ownerId || hasPermission(member.userId, spaceId, PermissionBits.MANAGE_SPACE)) {
managers.push(member.userId);
}
}
@@ -55,28 +55,28 @@ function getServerManagers(serverId: string): string[] {
}
/**
* Build a full ServerWithChannelsAndMembers for a newly joined user.
* Build a full SpaceWithChannelsAndMembers for a newly joined user.
* Used after accepting a join request or public join.
*/
function buildFullServer(serverId: string, forUserId: string): ServerWithChannelsAndMembers | null {
function buildFullSpace(spaceId: string, forUserId: string): SpaceWithChannelsAndMembers | null {
const db = getDb();
const server = db.select().from(schema.servers).where(eq(schema.servers.id, serverId)).get();
if (!server) return null;
const space = db.select().from(schema.spaces).where(eq(schema.spaces.id, spaceId)).get();
if (!space) return null;
const channels = db.select()
.from(schema.channels)
.where(eq(schema.channels.serverId, serverId))
.where(eq(schema.channels.spaceId, spaceId))
.all();
const roles = db.select()
.from(schema.roles)
.where(eq(schema.roles.serverId, serverId))
.where(eq(schema.roles.spaceId, spaceId))
.orderBy(schema.roles.position)
.all();
const memberRows = db.select()
.from(schema.serverMembers)
.where(eq(schema.serverMembers.serverId, serverId))
.from(schema.spaceMembers)
.where(eq(schema.spaceMembers.spaceId, spaceId))
.all();
const memberUserIds = memberRows.map(m => m.userId);
@@ -87,7 +87,7 @@ function buildFullServer(serverId: string, forUserId: string): ServerWithChannel
const memberRoleRows = db.select()
.from(schema.memberRoles)
.where(eq(schema.memberRoles.serverId, serverId))
.where(eq(schema.memberRoles.spaceId, spaceId))
.all();
const members: MemberWithUser[] = memberRows
@@ -103,7 +103,7 @@ function buildFullServer(serverId: string, forUserId: string): ServerWithChannel
.filter(r => assignedRoleIds.includes(r.id))
.map(r => ({
id: r.id,
serverId: r.serverId,
spaceId: r.spaceId,
name: r.name,
color: r.color ?? '#b9bbbe',
position: r.position ?? 0,
@@ -111,7 +111,7 @@ function buildFullServer(serverId: string, forUserId: string): ServerWithChannel
}));
return {
serverId: m.serverId,
spaceId: m.spaceId,
userId: m.userId,
nickname: m.nickname,
joinedAt: m.joinedAt,
@@ -121,16 +121,16 @@ function buildFullServer(serverId: string, forUserId: string): ServerWithChannel
})
.filter((m): m is MemberWithUser => m !== null);
const serverPerms = computePermissions(forUserId, serverId);
const spacePerms = computePermissions(forUserId, spaceId);
const visibleChannels: Channel[] = [];
for (const ch of channels) {
const chPerms = computePermissions(forUserId, serverId, ch.id);
const chPerms = computePermissions(forUserId, spaceId, ch.id);
const hasView = (chPerms & PermissionBits.VIEW_CHANNEL) !== 0n || (chPerms & PermissionBits.ADMINISTRATOR) !== 0n;
if (hasView) {
visibleChannels.push({
id: ch.id,
serverId: ch.serverId,
spaceId: ch.spaceId,
name: ch.name,
type: ch.type as Channel['type'],
topic: ch.topic,
@@ -142,34 +142,34 @@ function buildFullServer(serverId: string, forUserId: string): ServerWithChannel
}
return {
id: server.id,
name: server.name,
icon: server.icon,
ownerId: server.ownerId,
inviteCode: server.inviteCode,
visibility: (server.visibility ?? 'private') as ServerWithChannelsAndMembers['visibility'],
description: server.description ?? null,
createdAt: server.createdAt,
id: space.id,
name: space.name,
icon: space.icon,
ownerId: space.ownerId,
inviteCode: space.inviteCode,
visibility: (space.visibility ?? 'private') as SpaceWithChannelsAndMembers['visibility'],
description: space.description ?? null,
createdAt: space.createdAt,
channels: visibleChannels,
members,
roles: roles.map(r => ({
id: r.id,
serverId: r.serverId,
spaceId: r.spaceId,
name: r.name,
color: r.color ?? '#b9bbbe',
position: r.position ?? 0,
permissions: r.permissions ?? undefined,
isEveryone: r.id === serverId,
isEveryone: r.id === spaceId,
createdAt: r.createdAt,
})),
myPermissions: permissionsToString(serverPerms),
myPermissions: permissionsToString(spacePerms),
};
}
export async function exploreRoutes(app: FastifyInstance): Promise<void> {
// GET /api/servers/explore — list discoverable servers
app.get<{ Querystring: { q?: string; limit?: string; offset?: string } }>('/api/servers/explore', {
// GET /api/spaces/explore — list discoverable spaces
app.get<{ Querystring: { q?: string; limit?: string; offset?: string } }>('/api/spaces/explore', {
preHandler: authenticate,
}, async (request, reply) => {
const db = getDb();
@@ -177,35 +177,35 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
// Check instance-level discovery toggle
const settings = db.select().from(schema.instanceSettings).where(eq(schema.instanceSettings.id, 1)).get();
if (!settings || settings.discoveryEnabled === 0) {
return reply.code(200).send({ servers: [], total: 0, discoveryEnabled: false });
return reply.code(200).send({ spaces: [], total: 0, discoveryEnabled: false });
}
const q = request.query.q?.trim() ?? '';
const limit = Math.min(Math.max(parseInt(request.query.limit ?? '50', 10) || 50, 1), 100);
const offset = Math.max(parseInt(request.query.offset ?? '0', 10) || 0, 0);
// Get user's current server memberships to exclude
const myMemberships = db.select({ serverId: schema.serverMembers.serverId })
.from(schema.serverMembers)
.where(eq(schema.serverMembers.userId, request.userId))
// Get user's current space memberships to exclude
const myMemberships = db.select({ spaceId: schema.spaceMembers.spaceId })
.from(schema.spaceMembers)
.where(eq(schema.spaceMembers.userId, request.userId))
.all();
const myServerIds = new Set(myMemberships.map(m => m.serverId));
const mySpaceIds = new Set(myMemberships.map(m => m.spaceId));
// Build raw SQL query for explore — we need a LEFT JOIN for member count
// which is more efficient to do with raw SQL
const rawDb = getRawDb();
// Count ALL discoverable servers (including ones the user has joined) for context
// Count ALL discoverable spaces (including ones the user has joined) for context
const totalAllRow = rawDb.prepare(
`SELECT COUNT(DISTINCT s.id) as total FROM servers s WHERE s.visibility IN ('public', 'request')`
`SELECT COUNT(DISTINCT s.id) as total FROM spaces s WHERE s.visibility IN ('public', 'request')`
).get() as { total: number };
let countSql = `SELECT COUNT(DISTINCT s.id) as total FROM servers s WHERE s.visibility IN ('public', 'request')`;
let countSql = `SELECT COUNT(DISTINCT s.id) as total FROM spaces s WHERE s.visibility IN ('public', 'request')`;
let querySql = `
SELECT s.id, s.name, s.icon, s.description, s.visibility, s.created_at,
COUNT(sm.user_id) as member_count
FROM servers s
LEFT JOIN server_members sm ON sm.server_id = s.id
FROM spaces s
LEFT JOIN space_members sm ON sm.space_id = s.id
WHERE s.visibility IN ('public', 'request')
`;
@@ -231,79 +231,79 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
member_count: number;
}[];
const servers: ExploreServer[] = rows.map(r => ({
const spaces: ExploreSpace[] = rows.map(r => ({
id: r.id,
name: r.name,
icon: r.icon,
description: r.description,
visibility: r.visibility as ExploreServer['visibility'],
visibility: r.visibility as ExploreSpace['visibility'],
memberCount: r.member_count,
createdAt: r.created_at,
joined: myServerIds.has(r.id),
joined: mySpaceIds.has(r.id),
}));
return reply.code(200).send({ servers, total: totalRow.total, totalAll: totalAllRow.total, discoveryEnabled: true });
return reply.code(200).send({ spaces, total: totalRow.total, totalAll: totalAllRow.total, discoveryEnabled: true });
});
// POST /api/servers/:id/public-join — join a public server without invite
app.post<{ Params: { id: string } }>('/api/servers/:id/public-join', {
// POST /api/spaces/:id/public-join — join a public space without invite
app.post<{ Params: { id: string } }>('/api/spaces/:id/public-join', {
preHandler: authenticate,
}, async (request, reply) => {
const { id } = request.params;
const db = getDb();
const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
if (!server) {
return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
const space = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
if (!space) {
return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
}
if (server.visibility !== 'public') {
return reply.code(403).send({ error: 'This server does not allow public joins', statusCode: 403 });
if (space.visibility !== 'public') {
return reply.code(403).send({ error: 'This space does not allow public joins', statusCode: 403 });
}
if (isMember(id, request.userId)) {
return reply.code(409).send({ error: 'You are already a member of this server', statusCode: 409 });
return reply.code(409).send({ error: 'You are already a member of this space', statusCode: 409 });
}
const now = Date.now();
db.insert(schema.serverMembers).values({
serverId: id,
db.insert(schema.spaceMembers).values({
spaceId: id,
userId: request.userId,
joinedAt: now,
}).run();
// Register in connectionManager for WS broadcasts
connectionManager.addUserServer(request.userId, id);
connectionManager.addUserSpace(request.userId, id);
// Broadcast member_joined to existing server members
// Broadcast member_joined to existing space members
const joiningUser = db.select().from(schema.users).where(eq(schema.users.id, request.userId)).get();
if (joiningUser) {
const memberPayload: MemberWithUser = {
serverId: id,
spaceId: id,
userId: request.userId,
nickname: null,
joinedAt: now,
user: sanitizeUser(joiningUser),
roles: [],
};
connectionManager.sendToServer(id, {
connectionManager.sendToSpace(id, {
type: 'member_joined',
serverId: id,
spaceId: id,
member: memberPayload,
});
}
// Return full server data
const fullServer = buildFullServer(id, request.userId);
if (!fullServer) {
return reply.code(500).send({ error: 'Failed to load server', statusCode: 500 });
// Return full space data
const fullSpace = buildFullSpace(id, request.userId);
if (!fullSpace) {
return reply.code(500).send({ error: 'Failed to load space', statusCode: 500 });
}
return reply.code(200).send(fullServer);
return reply.code(200).send(fullSpace);
});
// POST /api/servers/:id/request-join — request to join a request-only server
app.post<{ Params: { id: string }; Body: { message?: string } }>('/api/servers/:id/request-join', {
// POST /api/spaces/:id/request-join — request to join a request-only space
app.post<{ Params: { id: string }; Body: { message?: string } }>('/api/spaces/:id/request-join', {
preHandler: authenticate,
config: {
rateLimit: {
@@ -315,30 +315,30 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
const { id } = request.params;
const db = getDb();
const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
if (!server) {
return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
const space = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
if (!space) {
return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
}
if (server.visibility !== 'request') {
return reply.code(403).send({ error: 'This server does not accept join requests', statusCode: 403 });
if (space.visibility !== 'request') {
return reply.code(403).send({ error: 'This space does not accept join requests', statusCode: 403 });
}
if (isMember(id, request.userId)) {
return reply.code(409).send({ error: 'You are already a member of this server', statusCode: 409 });
return reply.code(409).send({ error: 'You are already a member of this space', statusCode: 409 });
}
// Check for existing pending request
const existingRequest = db.select().from(schema.joinRequests)
.where(and(
eq(schema.joinRequests.serverId, id),
eq(schema.joinRequests.spaceId, id),
eq(schema.joinRequests.userId, request.userId),
eq(schema.joinRequests.status, 'pending'),
))
.get();
if (existingRequest) {
return reply.code(409).send({ error: 'You already have a pending request for this server', statusCode: 409 });
return reply.code(409).send({ error: 'You already have a pending request for this space', statusCode: 409 });
}
const requestId = generateSnowflake();
@@ -347,7 +347,7 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
db.insert(schema.joinRequests).values({
id: requestId,
serverId: id,
spaceId: id,
userId: request.userId,
message: msgText,
status: 'pending',
@@ -360,8 +360,8 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
joiningUser ? sanitizeUser(joiningUser) : undefined,
);
// Send WS event to server managers (owner + MANAGE_SERVER users)
const managers = getServerManagers(id);
// Send WS event to space managers (owner + MANAGE_SPACE users)
const managers = getSpaceManagers(id);
for (const managerId of managers) {
connectionManager.sendToUser(managerId, {
type: 'join_request_received',
@@ -372,26 +372,26 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
return reply.code(201).send(joinRequest);
});
// GET /api/servers/:id/join-requests — list join requests for a server
app.get<{ Params: { id: string }; Querystring: { status?: string } }>('/api/servers/:id/join-requests', {
// GET /api/spaces/:id/join-requests — list join requests for a space
app.get<{ Params: { id: string }; Querystring: { status?: string } }>('/api/spaces/:id/join-requests', {
preHandler: authenticate,
}, async (request, reply) => {
const { id } = request.params;
const db = getDb();
const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
if (!server) {
return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
const space = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
if (!space) {
return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
}
if (!isServerOwner(id, request.userId) && !hasPermission(request.userId, id, PermissionBits.MANAGE_SERVER)) {
return reply.code(403).send({ error: 'Missing MANAGE_SERVER permission', statusCode: 403 });
if (!isSpaceOwner(id, request.userId) && !hasPermission(request.userId, id, PermissionBits.MANAGE_SPACE)) {
return reply.code(403).send({ error: 'Missing MANAGE_SPACE permission', statusCode: 403 });
}
const statusFilter = request.query.status ?? 'pending';
const rows = db.select().from(schema.joinRequests)
.where(and(
eq(schema.joinRequests.serverId, id),
eq(schema.joinRequests.spaceId, id),
eq(schema.joinRequests.status, statusFilter),
))
.all();
@@ -408,8 +408,8 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
return reply.code(200).send({ requests });
});
// PATCH /api/servers/:id/join-requests/:requestId — accept or decline
app.patch<{ Params: { id: string; requestId: string }; Body: { action: 'accept' | 'decline' } }>('/api/servers/:id/join-requests/:requestId', {
// PATCH /api/spaces/:id/join-requests/:requestId — accept or decline
app.patch<{ Params: { id: string; requestId: string }; Body: { action: 'accept' | 'decline' } }>('/api/spaces/:id/join-requests/:requestId', {
preHandler: authenticate,
}, async (request, reply) => {
const { id, requestId } = request.params;
@@ -420,17 +420,17 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
return reply.code(400).send({ error: 'Action must be "accept" or "decline"', statusCode: 400 });
}
const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
if (!server) {
return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
const space = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
if (!space) {
return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
}
if (!isServerOwner(id, request.userId) && !hasPermission(request.userId, id, PermissionBits.MANAGE_SERVER)) {
return reply.code(403).send({ error: 'Missing MANAGE_SERVER permission', statusCode: 403 });
if (!isSpaceOwner(id, request.userId) && !hasPermission(request.userId, id, PermissionBits.MANAGE_SPACE)) {
return reply.code(403).send({ error: 'Missing MANAGE_SPACE permission', statusCode: 403 });
}
const joinReq = db.select().from(schema.joinRequests).where(eq(schema.joinRequests.id, requestId)).get();
if (!joinReq || joinReq.serverId !== id) {
if (!joinReq || joinReq.spaceId !== id) {
return reply.code(404).send({ error: 'Join request not found', statusCode: 404 });
}
@@ -443,8 +443,8 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
if (action === 'accept') {
// Insert member and update request atomically
db.transaction((tx) => {
tx.insert(schema.serverMembers).values({
serverId: id,
tx.insert(schema.spaceMembers).values({
spaceId: id,
userId: joinReq.userId,
joinedAt: now,
}).run();
@@ -457,38 +457,38 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
});
// Register in connectionManager
connectionManager.addUserServer(joinReq.userId, id);
connectionManager.addUserSpace(joinReq.userId, id);
// Broadcast member_joined to server
// Broadcast member_joined to space
const joiningUser = db.select().from(schema.users).where(eq(schema.users.id, joinReq.userId)).get();
if (joiningUser) {
const memberPayload: MemberWithUser = {
serverId: id,
spaceId: id,
userId: joinReq.userId,
nickname: null,
joinedAt: now,
user: sanitizeUser(joiningUser),
roles: [],
};
connectionManager.sendToServer(id, {
connectionManager.sendToSpace(id, {
type: 'member_joined',
serverId: id,
spaceId: id,
member: memberPayload,
});
}
// Build full server for the accepted user
const fullServer = buildFullServer(id, joinReq.userId);
// Build full space for the accepted user
const fullSpace = buildFullSpace(id, joinReq.userId);
const updatedRow = db.select().from(schema.joinRequests).where(eq(schema.joinRequests.id, requestId)).get()!;
const updatedRequest = rowToJoinRequest(updatedRow, joiningUser ? sanitizeUser(joiningUser) : undefined);
// Send join_request_accepted to the requesting user
if (fullServer) {
if (fullSpace) {
connectionManager.sendToUser(joinReq.userId, {
type: 'join_request_accepted',
request: updatedRequest,
server: fullServer,
space: fullSpace,
});
}
packages/server/src/routes/livekit.ts
+5 -5
View File
@@ -2,7 +2,7 @@ import type { FastifyInstance } from 'fastify';
import { AccessToken } from 'livekit-server-sdk';
import { authenticate } from '../utils/auth.js';
import { config } from '../config.js';
import { getChannelServerId, hasPermission, isDmMember, PermissionBits } from '../utils/permissions.js';
import { getChannelSpaceId, hasPermission, isDmMember, PermissionBits } from '../utils/permissions.js';
import type { LiveKitTokenRequest, LiveKitTokenResponse } from '@backspace/shared';
export async function livekitRoutes(app: FastifyInstance): Promise<void> {
@@ -25,12 +25,12 @@ export async function livekitRoutes(app: FastifyInstance): Promise<void> {
}
roomName = `dm-${dmChannelId}`;
} else if (channelId && typeof channelId === 'string') {
// Server voice channel token
const serverId = getChannelServerId(channelId);
if (!serverId) {
// Space voice channel token
const spaceId = getChannelSpaceId(channelId);
if (!spaceId) {
return reply.code(404).send({ error: 'Channel not found', statusCode: 404 });
}
if (!hasPermission(request.userId, serverId, PermissionBits.CONNECT, channelId)) {
if (!hasPermission(request.userId, spaceId, PermissionBits.CONNECT, channelId)) {
return reply.code(403).send({ error: 'Missing CONNECT permission', statusCode: 403 });
}
roomName = channelId;
packages/server/src/routes/messages.ts
+15 -15
View File
@@ -3,7 +3,7 @@ import { eq, and, desc, lt, inArray } from 'drizzle-orm';
import { getDb, schema } from '../db/index.js';
import { authenticate } from '../utils/auth.js';
import { generateSnowflake } from '../utils/snowflake.js';
import { hasPermission, getChannelServerId, PermissionBits } from '../utils/permissions.js';
import { hasPermission, getChannelSpaceId, PermissionBits } from '../utils/permissions.js';
import { connectionManager } from '../ws/handler.js';
import type {
CreateMessageRequest,
@@ -158,12 +158,12 @@ export async function messageRoutes(app: FastifyInstance): Promise<void> {
const before = request.query.before;
const limit = Math.min(Math.max(Number(request.query.limit) || 50, 1), 100);
const serverId = getChannelServerId(id);
if (!serverId) {
const spaceId = getChannelSpaceId(id);
if (!spaceId) {
return reply.code(404).send({ error: 'Channel not found', statusCode: 404 });
}
if (!hasPermission(request.userId, serverId, PermissionBits.VIEW_CHANNEL | PermissionBits.READ_MESSAGE_HISTORY, id)) {
if (!hasPermission(request.userId, spaceId, PermissionBits.VIEW_CHANNEL | PermissionBits.READ_MESSAGE_HISTORY, id)) {
return reply.code(403).send({ error: 'Missing VIEW_CHANNEL or READ_MESSAGE_HISTORY permission', statusCode: 403 });
}
@@ -251,12 +251,12 @@ export async function messageRoutes(app: FastifyInstance): Promise<void> {
const { id } = request.params;
const { content, attachments: attachmentIds, replyToId } = request.body;
const serverId = getChannelServerId(id);
if (!serverId) {
const spaceId = getChannelSpaceId(id);
if (!spaceId) {
return reply.code(404).send({ error: 'Channel not found', statusCode: 404 });
}
if (!hasPermission(request.userId, serverId, PermissionBits.SEND_MESSAGES, id)) {
if (!hasPermission(request.userId, spaceId, PermissionBits.SEND_MESSAGES, id)) {
return reply.code(403).send({ error: 'Missing SEND_MESSAGES permission', statusCode: 403 });
}
@@ -315,7 +315,7 @@ export async function messageRoutes(app: FastifyInstance): Promise<void> {
const messageWithUser = buildMessageWithUser(message, user, attachmentRows, [], replyTo);
// Broadcast via WebSocket
connectionManager.sendToServer(serverId, {
connectionManager.sendToSpace(spaceId, {
type: 'message_created',
message: messageWithUser,
});
@@ -377,9 +377,9 @@ export async function messageRoutes(app: FastifyInstance): Promise<void> {
const messageWithUser = buildMessageWithUser(updatedMessage, user, attachmentRows, reactions, replyTo);
// Broadcast edit
const serverId = getChannelServerId(message.channelId);
if (serverId) {
connectionManager.sendToServer(serverId, {
const spaceId = getChannelSpaceId(message.channelId);
if (spaceId) {
connectionManager.sendToSpace(spaceId, {
type: 'message_updated',
message: messageWithUser,
});
@@ -400,13 +400,13 @@ export async function messageRoutes(app: FastifyInstance): Promise<void> {
return reply.code(404).send({ error: 'Message not found', statusCode: 404 });
}
const serverId = getChannelServerId(message.channelId);
if (!serverId) {
const spaceId = getChannelSpaceId(message.channelId);
if (!spaceId) {
return reply.code(404).send({ error: 'Channel not found', statusCode: 404 });
}
const isAuthor = message.userId === request.userId;
const canManageMessages = hasPermission(request.userId, serverId, PermissionBits.MANAGE_MESSAGES, message.channelId);
const canManageMessages = hasPermission(request.userId, spaceId, PermissionBits.MANAGE_MESSAGES, message.channelId);
if (!isAuthor && !canManageMessages) {
return reply.code(403).send({ error: 'You cannot delete this message', statusCode: 403 });
@@ -419,7 +419,7 @@ export async function messageRoutes(app: FastifyInstance): Promise<void> {
});
// Broadcast deletion
connectionManager.sendToServer(serverId, {
connectionManager.sendToSpace(spaceId, {
type: 'message_deleted',
messageId: id,
channelId: message.channelId,
packages/server/src/routes/servers.ts → packages/server/src/routes/spaces.ts
+168 -168
View File
@@ -3,31 +3,31 @@ import { eq, and, inArray } from 'drizzle-orm';
import { getDb, schema } from '../db/index.js';
import { authenticate } from '../utils/auth.js';
import { generateSnowflake } from '../utils/snowflake.js';
import { isMember, isServerOwner, hasPermission, computePermissions, PermissionBits } from '../utils/permissions.js';
import { isMember, isSpaceOwner, hasPermission, computePermissions, PermissionBits } from '../utils/permissions.js';
import { DEFAULT_EVERYONE_PERMISSIONS, ALL_PERMISSIONS, permissionsToString } from '@backspace/shared/src/permissions.js';
import crypto from 'crypto';
import { connectionManager } from '../ws/handler.js';
import type {
CreateServerRequest,
UpdateServerRequest,
JoinServerRequest,
CreateSpaceRequest,
UpdateSpaceRequest,
JoinSpaceRequest,
UpdateMemberRequest,
Server,
Space,
Channel,
MemberWithUser,
ServerWithChannelsAndMembers,
SpaceWithChannelsAndMembers,
Role,
} from '@backspace/shared';
import { sanitizeUser } from '../utils/sanitize.js';
function rowToServer(row: typeof schema.servers.$inferSelect): Server {
function rowToSpace(row: typeof schema.spaces.$inferSelect): Space {
return {
id: row.id,
name: row.name,
icon: row.icon,
ownerId: row.ownerId,
inviteCode: row.inviteCode,
visibility: (row.visibility ?? 'private') as Server['visibility'],
visibility: (row.visibility ?? 'private') as Space['visibility'],
description: row.description ?? null,
createdAt: row.createdAt,
};
@@ -36,7 +36,7 @@ function rowToServer(row: typeof schema.servers.$inferSelect): Server {
function rowToChannel(row: typeof schema.channels.$inferSelect): Channel {
return {
id: row.id,
serverId: row.serverId,
spaceId: row.spaceId,
name: row.name,
type: row.type as Channel['type'],
topic: row.topic,
@@ -49,32 +49,32 @@ function generateInviteCode(): string {
return crypto.randomBytes(4).toString('hex');
}
export async function serverRoutes(app: FastifyInstance): Promise<void> {
// POST /api/servers - Create a new server
app.post<{ Body: CreateServerRequest }>('/api/servers', {
export async function spaceRoutes(app: FastifyInstance): Promise<void> {
// POST /api/spaces - Create a new server
app.post<{ Body: CreateSpaceRequest }>('/api/spaces', {
preHandler: authenticate,
}, async (request, reply) => {
const { name, icon } = request.body;
if (!name || typeof name !== 'string') {
return reply.code(400).send({ error: 'Server name is required', statusCode: 400 });
return reply.code(400).send({ error: 'Space name is required', statusCode: 400 });
}
const trimmedName = name.trim();
if (trimmedName.length < 1 || trimmedName.length > 100) {
return reply.code(400).send({ error: 'Server name must be between 1 and 100 characters', statusCode: 400 });
return reply.code(400).send({ error: 'Space name must be between 1 and 100 characters', statusCode: 400 });
}
const db = getDb();
const serverId = generateSnowflake();
const spaceId = generateSnowflake();
const channelId = generateSnowflake();
const now = Date.now();
const inviteCode = generateInviteCode();
// Create server, owner membership, default channel, and @everyone role atomically
db.transaction((tx) => {
tx.insert(schema.servers).values({
id: serverId,
tx.insert(schema.spaces).values({
id: spaceId,
name: trimmedName,
icon: icon ?? null,
ownerId: request.userId,
@@ -82,25 +82,25 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
createdAt: now,
}).run();
tx.insert(schema.serverMembers).values({
serverId,
tx.insert(schema.spaceMembers).values({
spaceId,
userId: request.userId,
joinedAt: now,
}).run();
tx.insert(schema.channels).values({
id: channelId,
serverId,
spaceId,
name: 'general',
type: 'text',
position: 0,
createdAt: now,
}).run();
// Auto-create @everyone role (id = serverId)
// Auto-create @everyone role (id = spaceId)
tx.insert(schema.roles).values({
id: serverId,
serverId,
id: spaceId,
spaceId,
name: '@everyone',
color: '#b9bbbe',
position: 0,
@@ -109,68 +109,68 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
}).run();
});
const server = db.select().from(schema.servers).where(eq(schema.servers.id, serverId)).get();
const server = db.select().from(schema.spaces).where(eq(schema.spaces.id, spaceId)).get();
if (!server) {
return reply.code(500).send({ error: 'Failed to create server', statusCode: 500 });
return reply.code(500).send({ error: 'Failed to create space', statusCode: 500 });
}
return reply.code(201).send(rowToServer(server));
return reply.code(201).send(rowToSpace(server));
});
// GET /api/servers - List user's servers
app.get('/api/servers', {
// GET /api/spaces - List user's servers
app.get('/api/spaces', {
preHandler: authenticate,
}, async (request, reply) => {
const db = getDb();
const memberships = db.select()
.from(schema.serverMembers)
.where(eq(schema.serverMembers.userId, request.userId))
.from(schema.spaceMembers)
.where(eq(schema.spaceMembers.userId, request.userId))
.all();
if (memberships.length === 0) {
return reply.code(200).send([]);
}
const serverIds = memberships.map(m => m.serverId);
const spaceIds = memberships.map(m => m.spaceId);
const servers = db.select()
.from(schema.servers)
.where(inArray(schema.servers.id, serverIds))
.from(schema.spaces)
.where(inArray(schema.spaces.id, spaceIds))
.all();
return reply.code(200).send(servers.map(rowToServer));
return reply.code(200).send(servers.map(rowToSpace));
});
// GET /api/servers/:id - Get server detail with channels and members
app.get<{ Params: { id: string } }>('/api/servers/:id', {
// GET /api/spaces/:id - Get server detail with channels and members
app.get<{ Params: { id: string } }>('/api/spaces/:id', {
preHandler: authenticate,
}, async (request, reply) => {
const { id } = request.params;
const db = getDb();
const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
const server = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
if (!server) {
return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
}
if (!isMember(id, request.userId)) {
return reply.code(403).send({ error: 'You are not a member of this server', statusCode: 403 });
return reply.code(403).send({ error: 'You are not a member of this space', statusCode: 403 });
}
const channels = db.select()
.from(schema.channels)
.where(eq(schema.channels.serverId, id))
.where(eq(schema.channels.spaceId, id))
.all();
const roles = db.select()
.from(schema.roles)
.where(eq(schema.roles.serverId, id))
.where(eq(schema.roles.spaceId, id))
.orderBy(schema.roles.position)
.all();
const memberRows = db.select()
.from(schema.serverMembers)
.where(eq(schema.serverMembers.serverId, id))
.from(schema.spaceMembers)
.where(eq(schema.spaceMembers.spaceId, id))
.all();
const memberUserIds = memberRows.map(m => m.userId);
@@ -182,7 +182,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
const memberRoleRows = db.select()
.from(schema.memberRoles)
.where(eq(schema.memberRoles.serverId, id))
.where(eq(schema.memberRoles.spaceId, id))
.all();
const members: MemberWithUser[] = memberRows
@@ -198,7 +198,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
.filter(r => assignedRoleIds.includes(r.id))
.map(r => ({
id: r.id,
serverId: r.serverId,
spaceId: r.spaceId,
name: r.name,
color: r.color ?? '#b9bbbe',
position: r.position ?? 0,
@@ -206,7 +206,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
}));
return {
serverId: m.serverId,
spaceId: m.spaceId,
userId: m.userId,
nickname: m.nickname,
joinedAt: m.joinedAt,
@@ -222,13 +222,13 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
return (perms & PermissionBits.VIEW_CHANNEL) !== 0n;
});
const result: ServerWithChannelsAndMembers = {
...rowToServer(server),
const result: SpaceWithChannelsAndMembers = {
...rowToSpace(server),
channels: visibleChannels.map(rowToChannel),
members,
roles: roles.map(r => ({
id: r.id,
serverId: r.serverId,
spaceId: r.spaceId,
name: r.name,
color: r.color ?? '#b9bbbe',
position: r.position ?? 0,
@@ -239,29 +239,29 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
return reply.code(200).send(result);
});
// PATCH /api/servers/:id - Update server (owner only)
app.patch<{ Params: { id: string }; Body: UpdateServerRequest }>('/api/servers/:id', {
// PATCH /api/spaces/:id - Update server (owner only)
app.patch<{ Params: { id: string }; Body: UpdateSpaceRequest }>('/api/spaces/:id', {
preHandler: authenticate,
}, async (request, reply) => {
const { id } = request.params;
const { name, icon, visibility, description } = request.body;
const db = getDb();
const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
const server = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
if (!server) {
return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
}
if (!hasPermission(request.userId, id, PermissionBits.MANAGE_SERVER)) {
return reply.code(403).send({ error: 'Missing MANAGE_SERVER permission', statusCode: 403 });
if (!hasPermission(request.userId, id, PermissionBits.MANAGE_SPACE)) {
return reply.code(403).send({ error: 'Missing MANAGE_SPACE permission', statusCode: 403 });
}
const updates: Partial<typeof schema.servers.$inferInsert> = {};
const updates: Partial<typeof schema.spaces.$inferInsert> = {};
if (name !== undefined) {
const trimmedName = name.trim();
if (trimmedName.length < 1 || trimmedName.length > 100) {
return reply.code(400).send({ error: 'Server name must be between 1 and 100 characters', statusCode: 400 });
return reply.code(400).send({ error: 'Space name must be between 1 and 100 characters', statusCode: 400 });
}
updates.name = trimmedName;
}
@@ -287,60 +287,60 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
return reply.code(400).send({ error: 'No fields to update', statusCode: 400 });
}
db.update(schema.servers).set(updates).where(eq(schema.servers.id, id)).run();
db.update(schema.spaces).set(updates).where(eq(schema.spaces.id, id)).run();
const updated = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
const updated = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
if (!updated) {
return reply.code(500).send({ error: 'Failed to update server', statusCode: 500 });
return reply.code(500).send({ error: 'Failed to update space', statusCode: 500 });
}
const serverData = rowToServer(updated);
const spaceData = rowToSpace(updated);
// Broadcast server_updated to all server members
connectionManager.sendToServer(id, {
type: 'server_updated',
server: serverData,
// Broadcast space_updated to all space members
connectionManager.sendToSpace(id, {
type: 'space_updated',
space: spaceData,
});
return reply.code(200).send(serverData);
return reply.code(200).send(spaceData);
});
// DELETE /api/servers/:id - Delete server (owner only)
app.delete<{ Params: { id: string } }>('/api/servers/:id', {
// DELETE /api/spaces/:id - Delete server (owner only)
app.delete<{ Params: { id: string } }>('/api/spaces/:id', {
preHandler: authenticate,
}, async (request, reply) => {
const { id } = request.params;
const db = getDb();
const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
const server = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
if (!server) {
return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
}
if (!isServerOwner(id, request.userId)) {
return reply.code(403).send({ error: 'Only the server owner can delete the server', statusCode: 403 });
if (!isSpaceOwner(id, request.userId)) {
return reply.code(403).send({ error: 'Only the space owner can delete the space', statusCode: 403 });
}
// Delete all channels (messages cascade), members, then server atomically
db.transaction((tx) => {
tx.delete(schema.channels).where(eq(schema.channels.serverId, id)).run();
tx.delete(schema.serverMembers).where(eq(schema.serverMembers.serverId, id)).run();
tx.delete(schema.servers).where(eq(schema.servers.id, id)).run();
tx.delete(schema.channels).where(eq(schema.channels.spaceId, id)).run();
tx.delete(schema.spaceMembers).where(eq(schema.spaceMembers.spaceId, id)).run();
tx.delete(schema.spaces).where(eq(schema.spaces.id, id)).run();
});
return reply.code(200).send({ success: true });
});
// POST /api/servers/:id/invite - Generate invite code (admin+)
app.post<{ Params: { id: string } }>('/api/servers/:id/invite', {
// POST /api/spaces/:id/invite - Generate invite code (admin+)
app.post<{ Params: { id: string } }>('/api/spaces/:id/invite', {
preHandler: authenticate,
}, async (request, reply) => {
const { id } = request.params;
const db = getDb();
const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
const server = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
if (!server) {
return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
}
if (!hasPermission(request.userId, id, PermissionBits.CREATE_INVITE)) {
@@ -353,13 +353,13 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
}
const inviteCode = generateInviteCode();
db.update(schema.servers).set({ inviteCode }).where(eq(schema.servers.id, id)).run();
db.update(schema.spaces).set({ inviteCode }).where(eq(schema.spaces.id, id)).run();
return reply.code(200).send({ inviteCode });
});
// POST /api/servers/:id/join - Join server by invite code
app.post<{ Params: { id: string }; Body: JoinServerRequest }>('/api/servers/:id/join', {
// POST /api/spaces/:id/join - Join server by invite code
app.post<{ Params: { id: string }; Body: JoinSpaceRequest }>('/api/spaces/:id/join', {
preHandler: authenticate,
}, async (request, reply) => {
const { id } = request.params;
@@ -371,9 +371,9 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
const db = getDb();
const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
const server = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
if (!server) {
return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
}
if (server.inviteCode !== inviteCode) {
@@ -381,42 +381,42 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
}
if (isMember(id, request.userId)) {
return reply.code(409).send({ error: 'You are already a member of this server', statusCode: 409 });
return reply.code(409).send({ error: 'You are already a member of this space', statusCode: 409 });
}
const now = Date.now();
db.insert(schema.serverMembers).values({
serverId: id,
db.insert(schema.spaceMembers).values({
spaceId: id,
userId: request.userId,
joinedAt: now,
}).run();
// Register the user in connectionManager so they receive WS broadcasts for this server
connectionManager.addUserServer(request.userId, id);
connectionManager.addUserSpace(request.userId, id);
// Broadcast member_joined to existing server members
const joiningUser = db.select().from(schema.users).where(eq(schema.users.id, request.userId)).get();
if (joiningUser) {
const memberPayload: MemberWithUser = {
serverId: id,
spaceId: id,
userId: request.userId,
nickname: null,
joinedAt: now,
user: sanitizeUser(joiningUser),
roles: [],
};
connectionManager.sendToServer(id, {
connectionManager.sendToSpace(id, {
type: 'member_joined',
serverId: id,
spaceId: id,
member: memberPayload,
});
}
return reply.code(200).send(rowToServer(server));
return reply.code(200).send(rowToSpace(server));
});
// POST /api/servers/join - Join server by invite code (no server ID needed)
app.post<{ Body: JoinServerRequest }>('/api/servers/join', {
// POST /api/spaces/join - Join server by invite code (no server ID needed)
app.post<{ Body: JoinSpaceRequest }>('/api/spaces/join', {
preHandler: authenticate,
}, async (request, reply) => {
const { inviteCode } = request.body;
@@ -427,65 +427,65 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
const db = getDb();
const server = db.select().from(schema.servers).where(eq(schema.servers.inviteCode, inviteCode)).get();
const server = db.select().from(schema.spaces).where(eq(schema.spaces.inviteCode, inviteCode)).get();
if (!server) {
return reply.code(404).send({ error: 'Invalid invite code', statusCode: 404 });
}
if (isMember(server.id, request.userId)) {
return reply.code(409).send({ error: 'You are already a member of this server', statusCode: 409 });
return reply.code(409).send({ error: 'You are already a member of this space', statusCode: 409 });
}
const now = Date.now();
db.insert(schema.serverMembers).values({
serverId: server.id,
db.insert(schema.spaceMembers).values({
spaceId: server.id,
userId: request.userId,
joinedAt: now,
}).run();
// Register the user in connectionManager so they receive WS broadcasts for this server
connectionManager.addUserServer(request.userId, server.id);
connectionManager.addUserSpace(request.userId, server.id);
// Broadcast member_joined to existing server members
const joiningUser = db.select().from(schema.users).where(eq(schema.users.id, request.userId)).get();
if (joiningUser) {
const memberPayload: MemberWithUser = {
serverId: server.id,
spaceId: server.id,
userId: request.userId,
nickname: null,
joinedAt: now,
user: sanitizeUser(joiningUser),
roles: [],
};
connectionManager.sendToServer(server.id, {
connectionManager.sendToSpace(server.id, {
type: 'member_joined',
serverId: server.id,
spaceId: server.id,
member: memberPayload,
});
}
return reply.code(200).send(rowToServer(server));
return reply.code(200).send(rowToSpace(server));
});
// GET /api/servers/:id/members - List server members
app.get<{ Params: { id: string } }>('/api/servers/:id/members', {
// GET /api/spaces/:id/members - List server members
app.get<{ Params: { id: string } }>('/api/spaces/:id/members', {
preHandler: authenticate,
}, async (request, reply) => {
const { id } = request.params;
const db = getDb();
const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
const server = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
if (!server) {
return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
}
if (!isMember(id, request.userId)) {
return reply.code(403).send({ error: 'You are not a member of this server', statusCode: 403 });
return reply.code(403).send({ error: 'You are not a member of this space', statusCode: 403 });
}
const memberRows = db.select()
.from(schema.serverMembers)
.where(eq(schema.serverMembers.serverId, id))
.from(schema.spaceMembers)
.where(eq(schema.spaceMembers.spaceId, id))
.all();
const memberUserIds = memberRows.map(m => m.userId);
@@ -497,13 +497,13 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
const roles = db.select()
.from(schema.roles)
.where(eq(schema.roles.serverId, id))
.where(eq(schema.roles.spaceId, id))
.orderBy(schema.roles.position)
.all();
const memberRoleRows = db.select()
.from(schema.memberRoles)
.where(eq(schema.memberRoles.serverId, id))
.where(eq(schema.memberRoles.spaceId, id))
.all();
const members: MemberWithUser[] = memberRows
@@ -519,7 +519,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
.filter(r => assignedRoleIds.includes(r.id))
.map(r => ({
id: r.id,
serverId: r.serverId,
spaceId: r.spaceId,
name: r.name,
color: r.color ?? '#b9bbbe',
position: r.position ?? 0,
@@ -527,7 +527,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
}));
return {
serverId: m.serverId,
spaceId: m.spaceId,
userId: m.userId,
nickname: m.nickname,
joinedAt: m.joinedAt,
@@ -540,17 +540,17 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
return reply.code(200).send(members);
});
// PATCH /api/servers/:id/members/:uid - Update member roles
app.patch<{ Params: { id: string; uid: string }; Body: UpdateMemberRequest }>('/api/servers/:id/members/:uid', {
// PATCH /api/spaces/:id/members/:uid - Update member roles
app.patch<{ Params: { id: string; uid: string }; Body: UpdateMemberRequest }>('/api/spaces/:id/members/:uid', {
preHandler: authenticate,
}, async (request, reply) => {
const { id, uid } = request.params;
const { roleIds } = request.body;
const db = getDb();
const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
const server = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
if (!server) {
return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
}
if (!hasPermission(request.userId, id, PermissionBits.MANAGE_ROLES)) {
@@ -566,15 +566,15 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
}
// Cannot modify the server owner's roles unless you are the owner
if (isServerOwner(id, uid) && !isServerOwner(id, request.userId)) {
return reply.code(403).send({ error: 'Only the server owner can modify their own roles', statusCode: 403 });
if (isSpaceOwner(id, uid) && !isSpaceOwner(id, request.userId)) {
return reply.code(403).send({ error: 'Only the space owner can modify their own roles', statusCode: 403 });
}
const member = db.select()
.from(schema.serverMembers)
.from(schema.spaceMembers)
.where(and(
eq(schema.serverMembers.serverId, id),
eq(schema.serverMembers.userId, uid),
eq(schema.spaceMembers.spaceId, id),
eq(schema.spaceMembers.userId, uid),
))
.get();
@@ -584,16 +584,16 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
// Validate all roleIds belong to this server and are not @everyone
if (roleIds.length > 0) {
const serverRoles = db.select()
const spaceRoles = db.select()
.from(schema.roles)
.where(eq(schema.roles.serverId, id))
.where(eq(schema.roles.spaceId, id))
.all();
const serverRoleIds = new Set(serverRoles.map(r => r.id));
const spaceRoleIds = new Set(spaceRoles.map(r => r.id));
for (const roleId of roleIds) {
if (!serverRoleIds.has(roleId)) {
return reply.code(400).send({ error: `Role ${roleId} does not belong to this server`, statusCode: 400 });
if (!spaceRoleIds.has(roleId)) {
return reply.code(400).send({ error: `Role ${roleId} does not belong to this space`, statusCode: 400 });
}
if (roleId === id) {
return reply.code(400).send({ error: '@everyone role is implicit and cannot be assigned', statusCode: 400 });
@@ -606,7 +606,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
// Remove all existing role assignments for this member in this server
tx.delete(schema.memberRoles)
.where(and(
eq(schema.memberRoles.serverId, id),
eq(schema.memberRoles.spaceId, id),
eq(schema.memberRoles.userId, uid),
))
.run();
@@ -614,7 +614,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
// Insert new role assignments
for (const roleId of roleIds) {
tx.insert(schema.memberRoles).values({
serverId: id,
spaceId: id,
userId: uid,
roleId,
}).run();
@@ -626,10 +626,10 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
// Build response with populated roles
const updatedMember = db.select()
.from(schema.serverMembers)
.from(schema.spaceMembers)
.where(and(
eq(schema.serverMembers.serverId, id),
eq(schema.serverMembers.userId, uid),
eq(schema.spaceMembers.spaceId, id),
eq(schema.spaceMembers.userId, uid),
))
.get();
@@ -645,7 +645,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
const updatedRoleRows = db.select()
.from(schema.memberRoles)
.where(and(
eq(schema.memberRoles.serverId, id),
eq(schema.memberRoles.spaceId, id),
eq(schema.memberRoles.userId, uid),
))
.all();
@@ -653,7 +653,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
const updatedRoleIds = updatedRoleRows.map(r => r.roleId);
const allRoles = db.select()
.from(schema.roles)
.where(eq(schema.roles.serverId, id))
.where(eq(schema.roles.spaceId, id))
.orderBy(schema.roles.position)
.all();
@@ -661,7 +661,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
.filter(r => updatedRoleIds.includes(r.id))
.map(r => ({
id: r.id,
serverId: r.serverId,
spaceId: r.spaceId,
name: r.name,
color: r.color ?? '#b9bbbe',
position: r.position ?? 0,
@@ -669,7 +669,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
}));
const result: MemberWithUser = {
serverId: updatedMember.serverId,
spaceId: updatedMember.spaceId,
userId: updatedMember.userId,
nickname: updatedMember.nickname,
joinedAt: updatedMember.joinedAt,
@@ -680,20 +680,20 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
return reply.code(200).send(result);
});
// DELETE /api/servers/:id/members/:uid - Kick member (owner) or leave (self)
app.delete<{ Params: { id: string; uid: string } }>('/api/servers/:id/members/:uid', {
// DELETE /api/spaces/:id/members/:uid - Kick member (owner) or leave (self)
app.delete<{ Params: { id: string; uid: string } }>('/api/spaces/:id/members/:uid', {
preHandler: authenticate,
}, async (request, reply) => {
const { id, uid } = request.params;
const db = getDb();
const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
const server = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
if (!server) {
return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
}
const isSelf = uid === request.userId;
const isOwnerUser = isServerOwner(id, request.userId);
const isOwnerUser = isSpaceOwner(id, request.userId);
const canKick = hasPermission(request.userId, id, PermissionBits.KICK_MEMBERS);
if (!isSelf && !canKick) {
@@ -702,14 +702,14 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
// Owner cannot leave their own server - they must delete it
if (isSelf && isOwnerUser) {
return reply.code(400).send({ error: 'Server owner cannot leave. Transfer ownership or delete the server.', statusCode: 400 });
return reply.code(400).send({ error: 'Space owner cannot leave. Transfer ownership or delete the space.', statusCode: 400 });
}
const member = db.select()
.from(schema.serverMembers)
.from(schema.spaceMembers)
.where(and(
eq(schema.serverMembers.serverId, id),
eq(schema.serverMembers.userId, uid),
eq(schema.spaceMembers.spaceId, id),
eq(schema.spaceMembers.userId, uid),
))
.get();
@@ -718,21 +718,21 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
}
// Cannot kick the owner
if (isServerOwner(id, uid)) {
return reply.code(400).send({ error: 'Cannot remove the server owner', statusCode: 400 });
if (isSpaceOwner(id, uid)) {
return reply.code(400).send({ error: 'Cannot remove the space owner', statusCode: 400 });
}
db.delete(schema.serverMembers)
db.delete(schema.spaceMembers)
.where(and(
eq(schema.serverMembers.serverId, id),
eq(schema.serverMembers.userId, uid),
eq(schema.spaceMembers.spaceId, id),
eq(schema.spaceMembers.userId, uid),
))
.run();
// Broadcast member_left event
connectionManager.sendToServer(id, {
connectionManager.sendToSpace(id, {
type: 'member_left',
serverId: id,
spaceId: id,
userId: uid,
});
@@ -741,8 +741,8 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
// Role Management
// POST /api/servers/:id/roles - Create a new role
app.post<{ Params: { id: string }; Body: { name: string; color?: string } }>('/api/servers/:id/roles', {
// POST /api/spaces/:id/roles - Create a new role
app.post<{ Params: { id: string }; Body: { name: string; color?: string } }>('/api/spaces/:id/roles', {
preHandler: authenticate,
}, async (request, reply) => {
const { id } = request.params;
@@ -756,7 +756,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
const roleId = generateSnowflake();
db.insert(schema.roles).values({
id: roleId,
serverId: id,
spaceId: id,
name: name || 'new role',
color: color || '#b9bbbe',
position: 0,
@@ -767,8 +767,8 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
return reply.code(201).send(role);
});
// PATCH /api/servers/:id/roles/:roleId - Update a role
app.patch<{ Params: { id: string; roleId: string }; Body: { name?: string; color?: string; position?: number } }>('/api/servers/:id/roles/:roleId', {
// PATCH /api/spaces/:id/roles/:roleId - Update a role
app.patch<{ Params: { id: string; roleId: string }; Body: { name?: string; color?: string; position?: number } }>('/api/spaces/:id/roles/:roleId', {
preHandler: authenticate,
}, async (request, reply) => {
const { id, roleId } = request.params;
@@ -779,13 +779,13 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
return reply.code(403).send({ error: 'Missing MANAGE_ROLES permission', statusCode: 403 });
}
db.update(schema.roles).set(updates).where(and(eq(schema.roles.id, roleId), eq(schema.roles.serverId, id))).run();
db.update(schema.roles).set(updates).where(and(eq(schema.roles.id, roleId), eq(schema.roles.spaceId, id))).run();
const updated = db.select().from(schema.roles).where(eq(schema.roles.id, roleId)).get();
return reply.code(200).send(updated);
});
// DELETE /api/servers/:id/roles/:roleId - Delete a role
app.delete<{ Params: { id: string; roleId: string } }>('/api/servers/:id/roles/:roleId', {
// DELETE /api/spaces/:id/roles/:roleId - Delete a role
app.delete<{ Params: { id: string; roleId: string } }>('/api/spaces/:id/roles/:roleId', {
preHandler: authenticate,
}, async (request, reply) => {
const { id, roleId } = request.params;
@@ -805,12 +805,12 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
and(eq(schema.channelOverrides.targetType, 'role'), eq(schema.channelOverrides.targetId, roleId))
).run();
db.delete(schema.roles).where(and(eq(schema.roles.id, roleId), eq(schema.roles.serverId, id))).run();
db.delete(schema.roles).where(and(eq(schema.roles.id, roleId), eq(schema.roles.spaceId, id))).run();
return reply.code(200).send({ success: true });
});
// POST /api/servers/:id/members/:uid/roles - Add role to member
app.post<{ Params: { id: string; uid: string }; Body: { roleId: string } }>('/api/servers/:id/members/:uid/roles', {
// POST /api/spaces/:id/members/:uid/roles - Add role to member
app.post<{ Params: { id: string; uid: string }; Body: { roleId: string } }>('/api/spaces/:id/members/:uid/roles', {
preHandler: authenticate,
}, async (request, reply) => {
const { id, uid } = request.params;
@@ -822,7 +822,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
}
db.insert(schema.memberRoles).values({
serverId: id,
spaceId: id,
userId: uid,
roleId,
}).run();
@@ -830,8 +830,8 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
return reply.code(200).send({ success: true });
});
// DELETE /api/servers/:id/members/:uid/roles/:roleId - Remove role from member
app.delete<{ Params: { id: string; uid: string; roleId: string } }>('/api/servers/:id/members/:uid/roles/:roleId', {
// DELETE /api/spaces/:id/members/:uid/roles/:roleId - Remove role from member
app.delete<{ Params: { id: string; uid: string; roleId: string } }>('/api/spaces/:id/members/:uid/roles/:roleId', {
preHandler: authenticate,
}, async (request, reply) => {
const { id, uid, roleId } = request.params;
@@ -842,7 +842,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
}
db.delete(schema.memberRoles).where(and(
eq(schema.memberRoles.serverId, id),
eq(schema.memberRoles.spaceId, id),
eq(schema.memberRoles.userId, uid),
eq(schema.memberRoles.roleId, roleId)
)).run();
packages/server/src/routes/users.ts
+3 -3
View File
@@ -120,9 +120,9 @@ export async function userRoutes(app: FastifyInstance): Promise<void> {
// Broadcast presence update if status changed
if (status !== undefined) {
const userServers = connectionManager.getUserServers(sanitized.id);
for (const serverId of userServers) {
connectionManager.sendToServer(serverId, {
const userSpaces = connectionManager.getUserSpaces(sanitized.id);
for (const spaceId of userSpaces) {
connectionManager.sendToSpace(spaceId, {
type: 'presence_update',
userId: sanitized.id,
status: status,