feat: XLive 直播平台初始版本

多用户网页直播平台:OBS/FFmpeg 鉴权 RTMP 推流到 SRS,HLS 低延迟播放;
Fastify 5 + Prisma + PostgreSQL + Redis 后端,Vue 3 前端,Docker Compose 部署。
This commit is contained in:
itxiaohui committed 2026-09-14 17:57:59 +08:00
1 parent 5ef949fe07
commit 463dbb1566
73 files changed
+9593

No files matched your search

+28
View File
@@ -0,0 +1,28 @@
FROM node:22-alpine AS base
WORKDIR /app
RUN apk add --no-cache openssl libc6-compat
COPY package*.json ./
COPY apps/api/package.json apps/api/package.json
COPY apps/web/package.json apps/web/package.json
RUN npm ci
COPY apps/api apps/api
FROM base AS dev
CMD ["npm", "run", "dev", "-w", "@xlive/api"]
FROM base AS build
RUN npm run build -w @xlive/api
FROM node:22-alpine AS production
WORKDIR /app
RUN apk add --no-cache openssl wget ffmpeg su-exec && addgroup -S app && adduser -S app -G app
COPY package*.json ./
COPY apps/api/package.json apps/api/package.json
COPY apps/web/package.json apps/web/package.json
RUN npm ci --omit=dev --workspace=@xlive/api --include-workspace-root=false
COPY --from=build /app/apps/api/dist apps/api/dist
COPY --from=build /app/apps/api/prisma apps/api/prisma
COPY --from=build /app/node_modules/.prisma node_modules/.prisma
RUN mkdir -p /app/uploads /app/live && chown -R app:app /app
# 回放目录由 SRS(root)写入,启动时放开目录写权限,再以 app 用户运行服务
CMD ["sh", "-c", "mkdir -p /app/live/replays && chmod -R a+rwX /app/live/replays 2>/dev/null || true; exec su-exec app sh -c 'npx prisma migrate deploy --schema apps/api/prisma/schema.prisma && node apps/api/dist/seed.js && node apps/api/dist/server.js'"]
+50
View File
@@ -0,0 +1,50 @@
{
"name": "@xlive/api",
"version": "1.0.0",
"private": true,
"type": "module",
"scripts": {
"dev": "tsx watch src/server.ts",
"build": "prisma generate && tsc -p tsconfig.json",
"start": "node dist/server.js",
"db:migrate": "prisma migrate deploy",
"db:seed": "tsx src/seed.ts",
"test": "vitest run --coverage",
"test:watch": "vitest"
},
"dependencies": {
"@aws-sdk/client-ses": "^3.888.0",
"@fastify/cookie": "^11.0.2",
"@fastify/cors": "^11.1.0",
"@fastify/helmet": "^13.0.2",
"@fastify/jwt": "^10.0.0",
"@fastify/multipart": "^9.2.1",
"@fastify/rate-limit": "^10.3.0",
"@fastify/swagger": "^9.5.1",
"@fastify/swagger-ui": "^5.2.3",
"@fastify/websocket": "^11.2.0",
"@prisma/client": "^6.16.2",
"@scalar/fastify-api-reference": "^1.34.6",
"@types/node": "^24.3.3",
"argon2": "^0.44.0",
"fastify": "^5.6.0",
"nodemailer": "^7.0.6",
"os-utils": "^0.0.14",
"pino": "^9.9.4",
"prisma": "^6.16.2",
"prom-client": "^15.1.3",
"redis": "^5.8.2",
"systeminformation": "^5.27.7",
"uuid": "^11.1.0",
"ws": "^8.18.3",
"zod": "^4.1.8"
},
"devDependencies": {
"@types/nodemailer": "^7.0.1",
"@types/ws": "^8.18.1",
"@vitest/coverage-v8": "^3.2.4",
"tsx": "^4.20.5",
"typescript": "^5.9.2",
"vitest": "^3.2.4"
}
}
@@ -0,0 +1,353 @@
-- CreateSchema
CREATE SCHEMA IF NOT EXISTS "public";
-- CreateEnum
CREATE TYPE "UserStatus" AS ENUM ('ACTIVE', 'DISABLED', 'DELETED');
-- CreateEnum
CREATE TYPE "RoleName" AS ENUM ('USER', 'ADMIN', 'SUPER_ADMIN');
-- CreateEnum
CREATE TYPE "RoomVisibility" AS ENUM ('PUBLIC', 'PRIVATE');
-- CreateEnum
CREATE TYPE "StreamStatus" AS ENUM ('OFFLINE', 'LIVE', 'BANNED');
-- CreateEnum
CREATE TYPE "CodePurpose" AS ENUM ('REGISTER', 'LOGIN', 'RESET_PASSWORD');
-- CreateEnum
CREATE TYPE "CodeChannel" AS ENUM ('EMAIL', 'SMS');
-- CreateEnum
CREATE TYPE "BanType" AS ENUM ('LOGIN', 'CHAT', 'STREAM');
-- CreateEnum
CREATE TYPE "AdminResult" AS ENUM ('SUCCESS', 'FAILURE');
-- CreateTable
CREATE TABLE "users" (
"id" UUID NOT NULL,
"username" VARCHAR(32) NOT NULL,
"nickname" VARCHAR(64) NOT NULL,
"avatar" VARCHAR(500),
"bio" VARCHAR(500),
"email" VARCHAR(254),
"phone" VARCHAR(32),
"password_hash" TEXT NOT NULL,
"status" "UserStatus" NOT NULL DEFAULT 'ACTIVE',
"can_stream" BOOLEAN NOT NULL DEFAULT true,
"register_ip" VARCHAR(64),
"last_login_ip" VARCHAR(64),
"last_login_at" TIMESTAMP(3),
"failed_login_count" INTEGER NOT NULL DEFAULT 0,
"locked_until" TIMESTAMP(3),
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
"updated_at" TIMESTAMP(3) NOT NULL,
CONSTRAINT "users_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "roles" (
"id" SERIAL NOT NULL,
"name" "RoleName" NOT NULL,
"description" TEXT,
CONSTRAINT "roles_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "user_roles" (
"user_id" UUID NOT NULL,
"role_id" INTEGER NOT NULL,
CONSTRAINT "user_roles_pkey" PRIMARY KEY ("user_id","role_id")
);
-- CreateTable
CREATE TABLE "rooms" (
"id" UUID NOT NULL,
"owner_id" UUID NOT NULL,
"room_number" SERIAL NOT NULL,
"title" VARCHAR(120) NOT NULL,
"description" VARCHAR(1000),
"cover" VARCHAR(500),
"announcement" VARCHAR(1000),
"visibility" "RoomVisibility" NOT NULL DEFAULT 'PUBLIC',
"stream_status" "StreamStatus" NOT NULL DEFAULT 'OFFLINE',
"viewer_count" INTEGER NOT NULL DEFAULT 0,
"show_viewer_count" BOOLEAN NOT NULL DEFAULT true,
"featured" BOOLEAN NOT NULL DEFAULT false,
"live_banned" BOOLEAN NOT NULL DEFAULT false,
"last_live_at" TIMESTAMP(3),
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
"updated_at" TIMESTAMP(3) NOT NULL,
"category_id" INTEGER,
CONSTRAINT "rooms_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "stream_keys" (
"id" UUID NOT NULL,
"room_id" UUID NOT NULL,
"key_hash" VARCHAR(64) NOT NULL,
"key_cipher" TEXT NOT NULL,
"key_hint" VARCHAR(12) NOT NULL,
"version" INTEGER NOT NULL DEFAULT 1,
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
"rotated_at" TIMESTAMP(3),
CONSTRAINT "stream_keys_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "live_sessions" (
"id" UUID NOT NULL,
"room_id" UUID NOT NULL,
"stream_name" VARCHAR(128) NOT NULL,
"srs_client_id" VARCHAR(64),
"started_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
"ended_at" TIMESTAMP(3),
"duration_seconds" INTEGER,
"peak_viewers" INTEGER NOT NULL DEFAULT 0,
"viewer_seconds" BIGINT NOT NULL DEFAULT 0,
"viewer_samples" INTEGER NOT NULL DEFAULT 0,
"total_views" INTEGER NOT NULL DEFAULT 0,
CONSTRAINT "live_sessions_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "categories" (
"id" SERIAL NOT NULL,
"name" VARCHAR(64) NOT NULL,
"slug" VARCHAR(64) NOT NULL,
"icon" VARCHAR(128),
"sort" INTEGER NOT NULL DEFAULT 0,
"enabled" BOOLEAN NOT NULL DEFAULT true,
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
"updated_at" TIMESTAMP(3) NOT NULL,
CONSTRAINT "categories_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "verification_codes" (
"id" UUID NOT NULL,
"channel" "CodeChannel" NOT NULL,
"target_hash" VARCHAR(64) NOT NULL,
"code_hash" VARCHAR(64) NOT NULL,
"purpose" "CodePurpose" NOT NULL,
"attempts" INTEGER NOT NULL DEFAULT 0,
"max_attempts" INTEGER NOT NULL DEFAULT 5,
"expires_at" TIMESTAMP(3) NOT NULL,
"used_at" TIMESTAMP(3),
"ip" VARCHAR(64),
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
CONSTRAINT "verification_codes_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "system_settings" (
"key" VARCHAR(128) NOT NULL,
"value" TEXT NOT NULL,
"group" VARCHAR(64) NOT NULL,
"sensitive" BOOLEAN NOT NULL DEFAULT false,
"description" TEXT,
"updated_at" TIMESTAMP(3) NOT NULL,
"updated_by" UUID,
CONSTRAINT "system_settings_pkey" PRIMARY KEY ("key")
);
-- CreateTable
CREATE TABLE "refresh_tokens" (
"id" UUID NOT NULL,
"user_id" UUID NOT NULL,
"token_hash" VARCHAR(64) NOT NULL,
"expires_at" TIMESTAMP(3) NOT NULL,
"revoked_at" TIMESTAMP(3),
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
"ip" VARCHAR(64),
CONSTRAINT "refresh_tokens_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "admin_logs" (
"id" BIGSERIAL NOT NULL,
"admin_id" UUID NOT NULL,
"action" VARCHAR(128) NOT NULL,
"target_type" VARCHAR(64),
"target_id" VARCHAR(128),
"details" JSONB,
"result" "AdminResult" NOT NULL,
"ip" VARCHAR(64),
"request_id" VARCHAR(64),
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
CONSTRAINT "admin_logs_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "login_logs" (
"id" BIGSERIAL NOT NULL,
"user_id" UUID,
"account" VARCHAR(254) NOT NULL,
"success" BOOLEAN NOT NULL,
"reason" VARCHAR(128),
"ip" VARCHAR(64),
"user_agent" VARCHAR(500),
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
CONSTRAINT "login_logs_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "chat_messages" (
"id" UUID NOT NULL,
"room_id" UUID NOT NULL,
"user_id" UUID,
"nickname" VARCHAR(64) NOT NULL,
"avatar" VARCHAR(500),
"content" VARCHAR(500) NOT NULL,
"deleted_at" TIMESTAMP(3),
"deleted_by" UUID,
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
CONSTRAINT "chat_messages_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "bans" (
"id" UUID NOT NULL,
"user_id" UUID NOT NULL,
"type" "BanType" NOT NULL,
"reason" VARCHAR(500),
"expires_at" TIMESTAMP(3),
"created_by" UUID NOT NULL,
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
"revoked_at" TIMESTAMP(3),
CONSTRAINT "bans_pkey" PRIMARY KEY ("id")
);
-- CreateIndex
CREATE UNIQUE INDEX "users_username_key" ON "users"("username");
-- CreateIndex
CREATE UNIQUE INDEX "users_email_key" ON "users"("email");
-- CreateIndex
CREATE UNIQUE INDEX "users_phone_key" ON "users"("phone");
-- CreateIndex
CREATE INDEX "users_created_at_idx" ON "users"("created_at");
-- CreateIndex
CREATE UNIQUE INDEX "roles_name_key" ON "roles"("name");
-- CreateIndex
CREATE UNIQUE INDEX "rooms_room_number_key" ON "rooms"("room_number");
-- CreateIndex
CREATE INDEX "rooms_stream_status_visibility_idx" ON "rooms"("stream_status", "visibility");
-- CreateIndex
CREATE INDEX "rooms_owner_id_idx" ON "rooms"("owner_id");
-- CreateIndex
CREATE INDEX "rooms_category_id_idx" ON "rooms"("category_id");
-- CreateIndex
CREATE UNIQUE INDEX "stream_keys_room_id_key" ON "stream_keys"("room_id");
-- CreateIndex
CREATE UNIQUE INDEX "stream_keys_key_hash_key" ON "stream_keys"("key_hash");
-- CreateIndex
CREATE INDEX "live_sessions_room_id_started_at_idx" ON "live_sessions"("room_id", "started_at");
-- CreateIndex
CREATE INDEX "live_sessions_ended_at_idx" ON "live_sessions"("ended_at");
-- CreateIndex
CREATE UNIQUE INDEX "categories_name_key" ON "categories"("name");
-- CreateIndex
CREATE UNIQUE INDEX "categories_slug_key" ON "categories"("slug");
-- CreateIndex
CREATE INDEX "categories_enabled_sort_idx" ON "categories"("enabled", "sort");
-- CreateIndex
CREATE INDEX "verification_codes_target_hash_purpose_expires_at_idx" ON "verification_codes"("target_hash", "purpose", "expires_at");
-- CreateIndex
CREATE INDEX "system_settings_group_idx" ON "system_settings"("group");
-- CreateIndex
CREATE UNIQUE INDEX "refresh_tokens_token_hash_key" ON "refresh_tokens"("token_hash");
-- CreateIndex
CREATE INDEX "refresh_tokens_user_id_expires_at_idx" ON "refresh_tokens"("user_id", "expires_at");
-- CreateIndex
CREATE INDEX "admin_logs_admin_id_created_at_idx" ON "admin_logs"("admin_id", "created_at");
-- CreateIndex
CREATE INDEX "admin_logs_action_created_at_idx" ON "admin_logs"("action", "created_at");
-- CreateIndex
CREATE INDEX "login_logs_account_created_at_idx" ON "login_logs"("account", "created_at");
-- CreateIndex
CREATE INDEX "login_logs_ip_created_at_idx" ON "login_logs"("ip", "created_at");
-- CreateIndex
CREATE INDEX "chat_messages_room_id_created_at_idx" ON "chat_messages"("room_id", "created_at");
-- CreateIndex
CREATE INDEX "bans_user_id_type_expires_at_idx" ON "bans"("user_id", "type", "expires_at");
-- AddForeignKey
ALTER TABLE "user_roles" ADD CONSTRAINT "user_roles_user_id_fkey" FOREIGN KEY ("user_id") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "user_roles" ADD CONSTRAINT "user_roles_role_id_fkey" FOREIGN KEY ("role_id") REFERENCES "roles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "rooms" ADD CONSTRAINT "rooms_owner_id_fkey" FOREIGN KEY ("owner_id") REFERENCES "users"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "rooms" ADD CONSTRAINT "rooms_category_id_fkey" FOREIGN KEY ("category_id") REFERENCES "categories"("id") ON DELETE SET NULL ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "stream_keys" ADD CONSTRAINT "stream_keys_room_id_fkey" FOREIGN KEY ("room_id") REFERENCES "rooms"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "live_sessions" ADD CONSTRAINT "live_sessions_room_id_fkey" FOREIGN KEY ("room_id") REFERENCES "rooms"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "refresh_tokens" ADD CONSTRAINT "refresh_tokens_user_id_fkey" FOREIGN KEY ("user_id") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "admin_logs" ADD CONSTRAINT "admin_logs_admin_id_fkey" FOREIGN KEY ("admin_id") REFERENCES "users"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "login_logs" ADD CONSTRAINT "login_logs_user_id_fkey" FOREIGN KEY ("user_id") REFERENCES "users"("id") ON DELETE SET NULL ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "chat_messages" ADD CONSTRAINT "chat_messages_room_id_fkey" FOREIGN KEY ("room_id") REFERENCES "rooms"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "chat_messages" ADD CONSTRAINT "chat_messages_user_id_fkey" FOREIGN KEY ("user_id") REFERENCES "users"("id") ON DELETE SET NULL ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "bans" ADD CONSTRAINT "bans_user_id_fkey" FOREIGN KEY ("user_id") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "bans" ADD CONSTRAINT "bans_created_by_fkey" FOREIGN KEY ("created_by") REFERENCES "users"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
@@ -0,0 +1,17 @@
-- Add replay metadata to completed live sessions.
ALTER TABLE "live_sessions"
ADD COLUMN "recording_url" VARCHAR(500),
ADD COLUMN "recording_size" BIGINT;
-- Associate chat messages with their live session so they can be replayed as timed danmaku.
ALTER TABLE "chat_messages"
ADD COLUMN "session_id" UUID,
ADD COLUMN "offset_seconds" DOUBLE PRECISION;
CREATE INDEX "chat_messages_session_id_offset_seconds_idx"
ON "chat_messages"("session_id", "offset_seconds");
ALTER TABLE "chat_messages"
ADD CONSTRAINT "chat_messages_session_id_fkey"
FOREIGN KEY ("session_id") REFERENCES "live_sessions"("id")
ON DELETE SET NULL ON UPDATE CASCADE;
@@ -0,0 +1,26 @@
-- Track uploaded files (avatars, covers) so admins can manage them.
CREATE TABLE "uploads" (
"id" UUID NOT NULL,
"filename" VARCHAR(255) NOT NULL,
"original_name" VARCHAR(255),
"mime_type" VARCHAR(64) NOT NULL,
"size" INTEGER NOT NULL,
"uploader_id" UUID,
"url" VARCHAR(500) NOT NULL,
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
CONSTRAINT "uploads_pkey" PRIMARY KEY ("id")
);
CREATE INDEX "uploads_created_at_idx" ON "uploads"("created_at");
ALTER TABLE "uploads"
ADD CONSTRAINT "uploads_uploader_id_fkey"
FOREIGN KEY ("uploader_id") REFERENCES "users"("id")
ON DELETE SET NULL ON UPDATE CASCADE;
-- Per-room choice whether live sessions generate a replay, captured per session at publish time.
ALTER TABLE "rooms"
ADD COLUMN "record_replay" BOOLEAN NOT NULL DEFAULT true;
ALTER TABLE "live_sessions"
ADD COLUMN "record_enabled" BOOLEAN NOT NULL DEFAULT true;
@@ -0,0 +1,21 @@
-- 站内信 / 开播申请:用户向管理员申请开播权限,管理员审批。
CREATE TABLE "notices" (
"id" UUID NOT NULL,
"from_id" UUID NOT NULL,
"content" VARCHAR(1000) NOT NULL,
"status" VARCHAR(16) NOT NULL DEFAULT 'PENDING',
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
"handled_at" TIMESTAMP(3),
"handled_by" UUID,
CONSTRAINT "notices_pkey" PRIMARY KEY ("id")
);
CREATE INDEX "notices_status_created_at_idx" ON "notices"("status", "created_at");
ALTER TABLE "notices"
ADD CONSTRAINT "notices_from_id_fkey"
FOREIGN KEY ("from_id") REFERENCES "users"("id")
ON DELETE CASCADE ON UPDATE CASCADE;
-- 新注册用户默认无开播权限,需向管理员申请并由管理员批准。
ALTER TABLE "users" ALTER COLUMN "can_stream" SET DEFAULT false;
@@ -0,0 +1 @@
provider = "postgresql"
+332
View File
@@ -0,0 +1,332 @@
generator client {
provider = "prisma-client-js"
}
datasource db {
provider = "postgresql"
url = env("DATABASE_URL")
}
enum UserStatus {
ACTIVE
DISABLED
DELETED
}
enum RoleName {
USER
ADMIN
SUPER_ADMIN
}
enum RoomVisibility {
PUBLIC
PRIVATE
}
enum StreamStatus {
OFFLINE
LIVE
BANNED
}
enum CodePurpose {
REGISTER
LOGIN
RESET_PASSWORD
}
enum CodeChannel {
EMAIL
SMS
}
enum BanType {
LOGIN
CHAT
STREAM
}
enum AdminResult {
SUCCESS
FAILURE
}
model User {
id String @id @default(uuid()) @db.Uuid
username String @unique @db.VarChar(32)
nickname String @db.VarChar(64)
avatar String? @db.VarChar(500)
bio String? @db.VarChar(500)
email String? @unique @db.VarChar(254)
phone String? @unique @db.VarChar(32)
passwordHash String @map("password_hash")
status UserStatus @default(ACTIVE)
canStream Boolean @default(false) @map("can_stream")
registerIp String? @map("register_ip") @db.VarChar(64)
lastLoginIp String? @map("last_login_ip") @db.VarChar(64)
lastLoginAt DateTime? @map("last_login_at")
failedLoginCount Int @default(0) @map("failed_login_count")
lockedUntil DateTime? @map("locked_until")
createdAt DateTime @default(now()) @map("created_at")
updatedAt DateTime @updatedAt @map("updated_at")
roles UserRole[]
rooms Room[]
refreshTokens RefreshToken[]
chatMessages ChatMessage[]
bans Ban[] @relation("BannedUser")
bansIssued Ban[] @relation("IssuedBy")
adminLogs AdminLog[]
loginLogs LoginLog[]
uploads Upload[]
sentNotices Notice[] @relation("NoticeFrom")
@@index([createdAt])
@@map("users")
}
model Role {
id Int @id @default(autoincrement())
name RoleName @unique
description String?
users UserRole[]
@@map("roles")
}
model UserRole {
userId String @map("user_id") @db.Uuid
roleId Int @map("role_id")
user User @relation(fields: [userId], references: [id], onDelete: Cascade)
role Role @relation(fields: [roleId], references: [id], onDelete: Cascade)
@@id([userId, roleId])
@@map("user_roles")
}
model Room {
id String @id @default(uuid()) @db.Uuid
ownerId String @map("owner_id") @db.Uuid
roomNumber Int @unique @default(autoincrement()) @map("room_number")
title String @db.VarChar(120)
description String? @db.VarChar(1000)
cover String? @db.VarChar(500)
announcement String? @db.VarChar(1000)
visibility RoomVisibility @default(PUBLIC)
streamStatus StreamStatus @default(OFFLINE) @map("stream_status")
viewerCount Int @default(0) @map("viewer_count")
showViewerCount Boolean @default(true) @map("show_viewer_count")
featured Boolean @default(false)
liveBanned Boolean @default(false) @map("live_banned")
recordReplay Boolean @default(true) @map("record_replay")
lastLiveAt DateTime? @map("last_live_at")
createdAt DateTime @default(now()) @map("created_at")
updatedAt DateTime @updatedAt @map("updated_at")
owner User @relation(fields: [ownerId], references: [id], onDelete: Restrict)
categoryId Int? @map("category_id")
category Category? @relation(fields: [categoryId], references: [id], onDelete: SetNull)
streamKey StreamKey?
sessions LiveSession[]
chatMessages ChatMessage[]
@@index([streamStatus, visibility])
@@index([ownerId])
@@index([categoryId])
@@map("rooms")
}
model StreamKey {
id String @id @default(uuid()) @db.Uuid
roomId String @unique @map("room_id") @db.Uuid
keyHash String @unique @map("key_hash") @db.VarChar(64)
keyCipher String @map("key_cipher")
keyHint String @map("key_hint") @db.VarChar(12)
version Int @default(1)
createdAt DateTime @default(now()) @map("created_at")
rotatedAt DateTime? @map("rotated_at")
room Room @relation(fields: [roomId], references: [id], onDelete: Cascade)
@@map("stream_keys")
}
model LiveSession {
id String @id @default(uuid()) @db.Uuid
roomId String @map("room_id") @db.Uuid
streamName String @map("stream_name") @db.VarChar(128)
srsClientId String? @map("srs_client_id") @db.VarChar(64)
startedAt DateTime @default(now()) @map("started_at")
endedAt DateTime? @map("ended_at")
durationSeconds Int? @map("duration_seconds")
peakViewers Int @default(0) @map("peak_viewers")
viewerSeconds BigInt @default(0) @map("viewer_seconds")
viewerSamples Int @default(0) @map("viewer_samples")
totalViews Int @default(0) @map("total_views")
recordingUrl String? @map("recording_url") @db.VarChar(500)
recordingSize BigInt? @map("recording_size")
recordEnabled Boolean @default(true) @map("record_enabled")
room Room @relation(fields: [roomId], references: [id], onDelete: Cascade)
chatMessages ChatMessage[]
@@index([roomId, startedAt])
@@index([endedAt])
@@map("live_sessions")
}
model Notice {
id String @id @default(uuid()) @db.Uuid
fromId String @map("from_id") @db.Uuid
from User @relation("NoticeFrom", fields: [fromId], references: [id], onDelete: Cascade)
content String @db.VarChar(1000)
status String @default("PENDING") @db.VarChar(16)
createdAt DateTime @default(now()) @map("created_at")
handledAt DateTime? @map("handled_at")
handledBy String? @map("handled_by") @db.Uuid
@@index([status, createdAt])
@@map("notices")
}
model Upload {
id String @id @default(uuid()) @db.Uuid
filename String @db.VarChar(255)
originalName String? @map("original_name") @db.VarChar(255)
mimeType String @map("mime_type") @db.VarChar(64)
size Int
uploaderId String? @map("uploader_id") @db.Uuid
uploader User? @relation(fields: [uploaderId], references: [id], onDelete: SetNull)
url String @db.VarChar(500)
createdAt DateTime @default(now()) @map("created_at")
@@index([createdAt])
@@map("uploads")
}
model Category {
id Int @id @default(autoincrement())
name String @unique @db.VarChar(64)
slug String @unique @db.VarChar(64)
icon String? @db.VarChar(128)
sort Int @default(0)
enabled Boolean @default(true)
createdAt DateTime @default(now()) @map("created_at")
updatedAt DateTime @updatedAt @map("updated_at")
rooms Room[]
@@index([enabled, sort])
@@map("categories")
}
model VerificationCode {
id String @id @default(uuid()) @db.Uuid
channel CodeChannel
targetHash String @map("target_hash") @db.VarChar(64)
codeHash String @map("code_hash") @db.VarChar(64)
purpose CodePurpose
attempts Int @default(0)
maxAttempts Int @default(5) @map("max_attempts")
expiresAt DateTime @map("expires_at")
usedAt DateTime? @map("used_at")
ip String? @db.VarChar(64)
createdAt DateTime @default(now()) @map("created_at")
@@index([targetHash, purpose, expiresAt])
@@map("verification_codes")
}
model SystemSetting {
key String @id @db.VarChar(128)
value String
group String @db.VarChar(64)
sensitive Boolean @default(false)
description String?
updatedAt DateTime @updatedAt @map("updated_at")
updatedBy String? @map("updated_by") @db.Uuid
@@index([group])
@@map("system_settings")
}
model RefreshToken {
id String @id @default(uuid()) @db.Uuid
userId String @map("user_id") @db.Uuid
tokenHash String @unique @map("token_hash") @db.VarChar(64)
expiresAt DateTime @map("expires_at")
revokedAt DateTime? @map("revoked_at")
createdAt DateTime @default(now()) @map("created_at")
ip String? @db.VarChar(64)
user User @relation(fields: [userId], references: [id], onDelete: Cascade)
@@index([userId, expiresAt])
@@map("refresh_tokens")
}
model AdminLog {
id BigInt @id @default(autoincrement())
adminId String @map("admin_id") @db.Uuid
action String @db.VarChar(128)
targetType String? @map("target_type") @db.VarChar(64)
targetId String? @map("target_id") @db.VarChar(128)
details Json?
result AdminResult
ip String? @db.VarChar(64)
requestId String? @map("request_id") @db.VarChar(64)
createdAt DateTime @default(now()) @map("created_at")
admin User @relation(fields: [adminId], references: [id], onDelete: Restrict)
@@index([adminId, createdAt])
@@index([action, createdAt])
@@map("admin_logs")
}
model LoginLog {
id BigInt @id @default(autoincrement())
userId String? @map("user_id") @db.Uuid
account String @db.VarChar(254)
success Boolean
reason String? @db.VarChar(128)
ip String? @db.VarChar(64)
userAgent String? @map("user_agent") @db.VarChar(500)
createdAt DateTime @default(now()) @map("created_at")
user User? @relation(fields: [userId], references: [id], onDelete: SetNull)
@@index([account, createdAt])
@@index([ip, createdAt])
@@map("login_logs")
}
model ChatMessage {
id String @id @default(uuid()) @db.Uuid
roomId String @map("room_id") @db.Uuid
userId String? @map("user_id") @db.Uuid
sessionId String? @map("session_id") @db.Uuid
offsetSeconds Float? @map("offset_seconds")
nickname String @db.VarChar(64)
avatar String? @db.VarChar(500)
content String @db.VarChar(500)
deletedAt DateTime? @map("deleted_at")
deletedBy String? @map("deleted_by") @db.Uuid
createdAt DateTime @default(now()) @map("created_at")
room Room @relation(fields: [roomId], references: [id], onDelete: Cascade)
user User? @relation(fields: [userId], references: [id], onDelete: SetNull)
session LiveSession? @relation(fields: [sessionId], references: [id], onDelete: SetNull)
@@index([roomId, createdAt])
@@index([sessionId, offsetSeconds])
@@map("chat_messages")
}
model Ban {
id String @id @default(uuid()) @db.Uuid
userId String @map("user_id") @db.Uuid
type BanType
reason String? @db.VarChar(500)
expiresAt DateTime? @map("expires_at")
createdBy String @map("created_by") @db.Uuid
createdAt DateTime @default(now()) @map("created_at")
revokedAt DateTime? @map("revoked_at")
user User @relation("BannedUser", fields: [userId], references: [id], onDelete: Cascade)
issuer User @relation("IssuedBy", fields: [createdBy], references: [id], onDelete: Restrict)
@@index([userId, type, expiresAt])
@@map("bans")
}
+75
View File
@@ -0,0 +1,75 @@
import Fastify from 'fastify';
import cookie from '@fastify/cookie';
import cors from '@fastify/cors';
import helmet from '@fastify/helmet';
import jwt from '@fastify/jwt';
import rateLimit from '@fastify/rate-limit';
import swagger from '@fastify/swagger';
import swaggerUi from '@fastify/swagger-ui';
import websocket from '@fastify/websocket';
import multipart from '@fastify/multipart';
import { createClient } from 'redis';
import { ZodError } from 'zod';
import type { PrismaClient } from '@prisma/client';
import type { AppConfig } from './config.js';
import { AppError } from './lib/errors.js';
import { SettingsService } from './modules/settings.service.js';
import { MessagingService } from './modules/messaging.service.js';
import { VerificationService } from './modules/verification.service.js';
import { TranscoderService } from './modules/transcoder.service.js';
import { authRoutes } from './modules/auth.routes.js';
import { roomRoutes } from './modules/rooms.routes.js';
import { mediaRoutes } from './modules/media.routes.js';
import { adminRoutes } from './modules/admin.routes.js';
import { chatRoutes } from './modules/chat.routes.js';
import { uploadRoutes } from './modules/uploads.routes.js';
export async function buildApp(config: AppConfig, db: PrismaClient) {
const app = Fastify({
logger: { level: config.APP_ENV === 'production' ? 'info' : 'debug', redact: ['req.headers.authorization', 'req.headers.cookie', '*.password', '*.token', '*.accessKeySecret', '*.streamKey'] },
genReqId: req => String(req.headers['x-request-id'] ?? crypto.randomUUID())
});
const redis = createClient({ url: config.REDIS_URL });
redis.on('error', error => app.log.error({ err: error }, 'Redis connection error'));
await redis.connect();
const settings = new SettingsService(db, config);
const messaging = new MessagingService(settings);
const verification = new VerificationService(db, redis, messaging);
const transcoder = new TranscoderService(settings);
await app.register(cookie);
await app.register(cors, { origin: config.APP_ENV === 'development' ? true : false, credentials: true });
await app.register(helmet, { contentSecurityPolicy: false });
await app.register(jwt, { secret: config.JWT_SECRET, cookie: { cookieName: 'xlive_access', signed: false } });
await app.register(rateLimit, { max: 300, timeWindow: '1 minute', keyGenerator: request => request.ip });
await app.register(websocket);
await app.register(multipart, { limits: { fileSize: 5 * 1024 * 1024, files: 1 } });
await app.register(swagger, { openapi: { info: { title: 'XLive API', version: '1.0.0', description: 'XLive 多用户直播平台 REST API' }, tags: [{ name: 'auth' }, { name: 'rooms' }, { name: 'admin' }] } });
await app.register(swaggerUi, { routePrefix: '/api/docs' });
app.addHook('onSend', async (request, reply, payload) => { reply.header('x-request-id', request.id); return payload; });
app.setErrorHandler((error, request, reply) => {
if (error instanceof ZodError) return reply.code(422).send({ code: 'VALIDATION_ERROR', message: '请求参数不正确', details: error.issues.map(i => ({ path: i.path.join('.'), message: i.message })), requestId: request.id });
if (error instanceof AppError) return reply.code(error.status).send({ code: error.code, message: error.message, requestId: request.id });
if ((error as { code?: string }).code === 'P2002') return reply.code(409).send({ code: 'DUPLICATE_RESOURCE', message: '数据已存在', requestId: request.id });
if ((error as { statusCode?: number }).statusCode && (error as { statusCode: number }).statusCode < 500) return reply.code((error as { statusCode: number }).statusCode).send({ code: 'BAD_REQUEST', message: '请求格式不正确', requestId: request.id });
request.log.error({ err: error }, 'Unhandled request error');
return reply.code(500).send({ code: 'INTERNAL_ERROR', message: '服务器内部错误', requestId: request.id });
});
app.get('/health', async (_request, reply) => {
try { await db.$queryRaw`SELECT 1`; await redis.ping(); return { status: 'ok', components: { application: 'up', database: 'up', redis: 'up' } }; }
catch { return reply.code(503).send({ status: 'degraded' }); }
});
app.get('/api/settings/public', async () => ({ data: await settings.publicSettings() }));
await authRoutes(app, { db, config, settings, verification });
await roomRoutes(app, { db, redis, config, settings, transcoder });
await mediaRoutes(app, { db, config, settings, transcoder });
await chatRoutes(app, db);
await uploadRoutes(app, { db, config });
await adminRoutes(app, { db, redis, config, settings, messaging });
app.addHook('onClose', async () => { await redis.quit(); });
return app;
}
+24
View File
@@ -0,0 +1,24 @@
import { z } from 'zod';
const schema = z.object({
APP_ENV: z.enum(['development', 'test', 'production']).default('development'),
APP_PORT: z.coerce.number().int().min(1).max(65535).default(3000),
DATABASE_URL: z.string().min(1),
REDIS_URL: z.string().min(1),
JWT_SECRET: z.string().min(32),
CONFIG_ENCRYPTION_KEY: z.string().min(16),
COOKIE_SECURE: z.string().default('false').transform(v => v === 'true'),
ADMIN_USERNAME: z.string().min(3).default('admin'),
ADMIN_PASSWORD: z.string().min(8),
ADMIN_EMAIL: z.string().email(),
SRS_API_URL: z.string().url().default('http://srs:1985'),
SRS_HOOK_SECRET: z.string().min(12),
RTMP_PUBLIC_URL: z.string().default(''),
RTMP_PORT: z.coerce.number().int().min(1).max(65535).default(1935),
HLS_PUBLIC_URL: z.string().default('http://localhost/live'),
UPLOAD_DIR: z.string().default('./uploads'),
LIVE_DIR: z.string().default('./live')
});
export type AppConfig = z.infer<typeof schema>;
export const loadConfig = (): AppConfig => schema.parse(process.env);
+31
View File
@@ -0,0 +1,31 @@
import type { FastifyReply, FastifyRequest } from 'fastify';
import type { RoleName } from '@prisma/client';
import { AppError } from './errors.js';
type TokenPayload = { sub: string; roles: RoleName[]; type: 'access' };
export async function authenticate(request: FastifyRequest): Promise<void> {
try {
const payload = await request.jwtVerify<TokenPayload>();
if (payload.type !== 'access') throw new Error('wrong token type');
request.auth = { userId: payload.sub, roles: payload.roles };
} catch { throw new AppError('UNAUTHORIZED', '请先登录', 401); }
}
export const requireRoles = (...roles: RoleName[]) => async (request: FastifyRequest) => {
await authenticate(request);
if (!roles.some(role => request.auth!.roles.includes(role))) throw new AppError('FORBIDDEN', '没有执行此操作的权限', 403);
};
export function setAccessCookie(reply: FastifyReply, token: string, secure: boolean) {
reply.setCookie('xlive_access', token, { httpOnly: true, secure, sameSite: 'lax', path: '/', maxAge: 15 * 60 });
}
export function setRefreshCookie(reply: FastifyReply, token: string, secure: boolean) {
reply.setCookie('xlive_refresh', token, { httpOnly: true, secure, sameSite: 'strict', path: '/api/auth', maxAge: 30 * 24 * 3600 });
}
export function clearAuthCookies(reply: FastifyReply) {
reply.clearCookie('xlive_access', { path: '/' });
reply.clearCookie('xlive_refresh', { path: '/api/auth' });
}
+3
View File
@@ -0,0 +1,3 @@
import { describe, expect, it } from 'vitest';
import { decrypt, encrypt, sha256 } from './crypto.js';
describe('secret protection',()=>{it('uses authenticated encryption',()=>{const secret='unit-test-key-that-is-long-enough',plain='smtp-password';const cipher=encrypt(plain,secret);expect(cipher).not.toContain(plain);expect(decrypt(cipher,secret)).toBe(plain)});it('hashes deterministically',()=>expect(sha256('a')).toBe(sha256('a')))});
+29
View File
@@ -0,0 +1,29 @@
import { createCipheriv, createDecipheriv, createHash, createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
export const sha256 = (value: string) => createHash('sha256').update(value).digest('hex');
export const randomToken = (bytes = 32) => randomBytes(bytes).toString('base64url');
export const randomCode = () => String(Math.floor(100000 + Math.random() * 900000));
const deriveKey = (secret: string) => createHash('sha256').update(secret).digest();
export function encrypt(value: string, secret: string): string {
const iv = randomBytes(12);
const cipher = createCipheriv('aes-256-gcm', deriveKey(secret), iv);
const encrypted = Buffer.concat([cipher.update(value, 'utf8'), cipher.final()]);
return ['v1', iv.toString('base64url'), cipher.getAuthTag().toString('base64url'), encrypted.toString('base64url')].join('.');
}
export function decrypt(value: string, secret: string): string {
const [version, iv, tag, payload] = value.split('.');
if (version !== 'v1' || !iv || !tag || !payload) throw new Error('Invalid encrypted value');
const decipher = createDecipheriv('aes-256-gcm', deriveKey(secret), Buffer.from(iv, 'base64url'));
decipher.setAuthTag(Buffer.from(tag, 'base64url'));
return Buffer.concat([decipher.update(Buffer.from(payload, 'base64url')), decipher.final()]).toString('utf8');
}
export const safeEqual = (a: string, b: string) => {
const aa = Buffer.from(a); const bb = Buffer.from(b);
return aa.length === bb.length && timingSafeEqual(aa, bb);
};
export const hmacSha1Base64 = (key: string, value: string) => createHmac('sha1', key).update(value).digest('base64');
+5
View File
@@ -0,0 +1,5 @@
import { PrismaClient } from '@prisma/client';
export const prisma = new PrismaClient({
log: process.env.APP_ENV === 'development' ? ['warn', 'error'] : ['error']
});
+7
View File
@@ -0,0 +1,7 @@
export class AppError extends Error {
constructor(public code: string, message: string, public status = 400) { super(message); }
}
export function assert(condition: unknown, code: string, message: string, status = 400): asserts condition {
if (!condition) throw new AppError(code, message, status);
}
+8
View File
@@ -0,0 +1,8 @@
import { describe, expect, it } from 'vitest';
import { defaultPasswordPolicy, hashPassword, validatePassword, verifyPassword } from './password.js';
describe('password policy and hashing', () => {
it('accepts a compliant password', () => expect(() => validatePassword('ValidPass123', defaultPasswordPolicy)).not.toThrow());
it.each(['short', 'alllowercase1', 'ALLUPPERCASE1', 'NoNumbersHere'])('rejects non-compliant password %s', value => expect(() => validatePassword(value, defaultPasswordPolicy)).toThrow());
it('uses salted Argon2id hashes', async () => { const a=await hashPassword('ValidPass123'); const b=await hashPassword('ValidPass123'); expect(a).not.toBe(b); expect(a).toContain('argon2id'); expect(await verifyPassword(a,'ValidPass123')).toBe(true); });
});
+22
View File
@@ -0,0 +1,22 @@
import argon2 from 'argon2';
import { AppError } from './errors.js';
export type PasswordPolicy = {
minLength: number; maxLength: number; uppercase: boolean; lowercase: boolean; number: boolean; special: boolean;
};
export const defaultPasswordPolicy: PasswordPolicy = { minLength: 8, maxLength: 64, uppercase: true, lowercase: true, number: true, special: false };
export function validatePassword(password: string, policy: PasswordPolicy): void {
const failures: string[] = [];
if (password.length < policy.minLength) failures.push(`至少 ${policy.minLength} 位`);
if (password.length > policy.maxLength) failures.push(`最多 ${policy.maxLength} 位`);
if (policy.uppercase && !/[A-Z]/.test(password)) failures.push('包含大写字母');
if (policy.lowercase && !/[a-z]/.test(password)) failures.push('包含小写字母');
if (policy.number && !/\d/.test(password)) failures.push('包含数字');
if (policy.special && !/[^A-Za-z0-9]/.test(password)) failures.push('包含特殊字符');
if (failures.length) throw new AppError('PASSWORD_POLICY_VIOLATION', `密码必须${failures.join('、')}`);
}
export const hashPassword = (password: string) => argon2.hash(password, { type: argon2.argon2id, memoryCost: 19456, timeCost: 2, parallelism: 1 });
export const verifyPassword = (hash: string, password: string) => argon2.verify(hash, password);
+11
View File
@@ -0,0 +1,11 @@
export interface RedisLike {
ping(): Promise<string>;
info(section?: string): Promise<string>;
exists(key: string): Promise<number>;
incr(key: string): Promise<number>;
expire(key: string, seconds: number): Promise<number>;
set(key: string, value: string, options?: { EX?: number }): Promise<string | null>;
zAdd(key: string, members: { score: number; value: string }): Promise<number>;
zRemRangeByScore(key: string, min: number, max: number): Promise<number>;
zCard(key: string): Promise<number>;
}
+77
View File
@@ -0,0 +1,77 @@
import type { FastifyInstance } from 'fastify';
import type { PrismaClient } from '@prisma/client';
import { createReadStream } from 'node:fs';
import { unlink } from 'node:fs/promises';
import { join } from 'node:path';
import type { RedisLike } from '../lib/redis.js';
import { z } from 'zod';
import si from 'systeminformation';
import type { AppConfig } from '../config.js';
import type { SettingsService } from './settings.service.js';
import type { MessagingService } from './messaging.service.js';
import { requireRoles } from '../lib/auth.js';
import { assert } from '../lib/errors.js';
import { stopSrsStream } from './rooms.routes.js';
import { hashPassword, validatePassword } from '../lib/password.js';
const admin = requireRoles('ADMIN', 'SUPER_ADMIN'); const superAdmin = requireRoles('SUPER_ADMIN');
const log = (db: PrismaClient, request: { auth?: { userId: string }; ip: string; id: string }, action: string, targetType?: string, targetId?: string, details?: object) => db.adminLog.create({ data: { adminId: request.auth!.userId, action, targetType, targetId, details, result: 'SUCCESS', ip: request.ip, requestId: request.id } });
export async function adminRoutes(app: FastifyInstance, deps: { db: PrismaClient; redis: RedisLike; config: AppConfig; settings: SettingsService; messaging: MessagingService }) {
const { db, redis, config, settings, messaging } = deps;
app.get('/api/admin/dashboard', { preHandler: admin }, async () => {
const start = new Date(); start.setHours(0, 0, 0, 0);
const [users, todayUsers, live, rooms, todaySessions, viewers, cpu, memory, fs] = await Promise.all([db.user.count(), db.user.count({ where: { createdAt: { gte: start } } }), db.room.count({ where: { streamStatus: 'LIVE' } }), db.room.count(), db.liveSession.count({ where: { startedAt: { gte: start } } }), db.room.aggregate({ _sum: { viewerCount: true } }), si.currentLoad(), si.mem(), si.fsSize()]);
const dbVersion = await db.$queryRaw<Array<{ version: string }>>`SELECT version()`; const redisInfo = await redis.info('server'); const redisVersion = /redis_version:([^\r\n]+)/.exec(redisInfo)?.[1] ?? 'unknown'; let mediaVersion='unavailable'; try { const response=await fetch(`${config.SRS_API_URL}/api/v1/versions`); if(response.ok){const body=await response.json() as {data?:{major?:number;minor?:number;revision?:number}};mediaVersion=body.data?`${body.data.major}.${body.data.minor}.${body.data.revision}`:'connected';} } catch {}
return { data: { metrics: { users, todayUsers, live, rooms, todaySessions, viewers: viewers._sum.viewerCount ?? 0 }, system: { node: process.version, postgres: dbVersion[0]?.version, redis: redisVersion, mediaServer: mediaVersion, platform: `${process.platform} ${process.arch}`, uptimeSeconds: Math.floor(process.uptime()), cpuUsage: Math.round(cpu.currentLoad * 10) / 10, memory: { total: memory.total, used: memory.active, free: memory.available }, disks: fs.map(x => ({ mount: x.mount, size: x.size, used: x.used, use: x.use })) } } };
});
app.get('/api/admin/health', { preHandler: admin }, async () => {
const result: Record<string, { status: string; detail?: string }> = { application: { status: '正常' } };
try { await db.$queryRaw`SELECT 1`; result.database={status:'正常'}; } catch { result.database={status:'异常'}; }
try { await redis.ping(); result.redis={status:'正常'}; } catch { result.redis={status:'异常'}; }
try { const r=await fetch(`${config.SRS_API_URL}/api/v1/versions`); result.mediaServer={status:r.ok?'正常':'异常'}; } catch { result.mediaServer={status:'异常'}; }
const all=await settings.all(false); result.smtp={status:all['smtp.host']?'已配置':'未配置'}; result.sms={status:all['sms.accessKeyId']?'已配置':'未配置'};
return { data: result };
});
app.get('/api/admin/users', { preHandler: admin }, async request => { const q = z.object({ search: z.string().optional(), page: z.coerce.number().default(1), limit: z.coerce.number().max(100).default(20) }).parse(request.query); const where = q.search ? { OR: [{ username: { contains: q.search, mode: 'insensitive' as const } }, { nickname: { contains: q.search, mode: 'insensitive' as const } }, { email: { contains: q.search, mode: 'insensitive' as const } }] } : {}; const [items, total] = await Promise.all([db.user.findMany({ where, select: { id: true, username: true, nickname: true, avatar: true, email: true, phone: true, status: true, canStream: true, registerIp: true, createdAt: true, lastLoginIp: true, lastLoginAt: true, roles: { select: { role: { select: { name: true } } } }, bans: { where: { revokedAt: null, OR: [{ expiresAt: null }, { expiresAt: { gt: new Date() } }] }, select: { id: true, type: true, reason: true, expiresAt: true } } }, skip: (q.page - 1) * q.limit, take: q.limit, orderBy: { createdAt: 'desc' } }), db.user.count({ where })]); return { data: items.map(u => ({ ...u, phone: u.phone ? `${u.phone.slice(0, 3)}****${u.phone.slice(-4)}` : null })), meta: { total } }; });
app.delete('/api/admin/users/:id', { preHandler: superAdmin }, async request => { const { id }=z.object({id:z.string().uuid()}).parse(request.params); assert(id!==request.auth!.userId,'CANNOT_DELETE_SELF','不能删除当前登录账号',409); await db.$transaction([db.refreshToken.updateMany({where:{userId:id},data:{revokedAt:new Date()}}),db.user.update({where:{id},data:{status:'DELETED',email:null,phone:null,canStream:false}})]); await log(db,request,'DELETE_USER','USER',id); return {data:{deleted:true}}; });
app.patch('/api/admin/users/:id', { preHandler: admin }, async request => { const { id } = z.object({ id: z.string().uuid() }).parse(request.params); const input = z.object({ status: z.enum(['ACTIVE', 'DISABLED']).optional(), canStream: z.boolean().optional(), nickname: z.string().min(1).max(64).optional() }).parse(request.body); const user = await db.user.update({ where: { id }, data: input }); if (input.canStream === false) { const rooms = await db.room.findMany({ where: { ownerId: id, streamStatus: 'LIVE' } }); await Promise.all(rooms.map(r => stopSrsStream(config, `room_${r.roomNumber}`))); } await log(db, request, 'UPDATE_USER', 'USER', id, input); return { data: user }; });
app.post('/api/admin/users/:id/reset-password', { preHandler: admin }, async request => { const { id } = z.object({ id: z.string().uuid() }).parse(request.params); const { password } = z.object({ password: z.string() }).parse(request.body); validatePassword(password, await settings.passwordPolicy()); await db.$transaction([db.user.update({ where: { id }, data: { passwordHash: await hashPassword(password) } }), db.refreshToken.updateMany({ where: { userId: id }, data: { revokedAt: new Date() } })]); await log(db, request, 'RESET_USER_PASSWORD', 'USER', id); return { data: { reset: true } }; });
app.post('/api/admin/users/:id/chat-ban', { preHandler: admin }, async request => { const {id}=z.object({id:z.string().uuid()}).parse(request.params); const input=z.object({minutes:z.number().int().min(1).max(525600).default(60),reason:z.string().max(500).optional()}).parse(request.body); const ban=await db.ban.create({data:{userId:id,type:'CHAT',reason:input.reason,expiresAt:new Date(Date.now()+input.minutes*60000),createdBy:request.auth!.userId}}); await log(db,request,'MUTE_USER','USER',id,{minutes:input.minutes}); return {data:ban}; });
app.delete('/api/admin/bans/:id', { preHandler: admin }, async request => { const {id}=z.object({id:z.string().uuid()}).parse(request.params); const ban=await db.ban.update({where:{id},data:{revokedAt:new Date()}}); await log(db,request,'REVOKE_BAN','BAN',id); return {data:ban}; });
app.get('/api/admin/rooms', { preHandler: admin }, async () => ({ data: await db.room.findMany({ include: { owner: { select: { id: true, username: true, nickname: true, avatar: true } }, category: true }, orderBy: { updatedAt: 'desc' } }) }));
app.patch('/api/admin/rooms/:roomNumber', { preHandler: admin }, async request => { const {roomNumber}=z.object({roomNumber:z.coerce.number()}).parse(request.params); const input=z.object({featured:z.boolean().optional(),visibility:z.enum(['PUBLIC','PRIVATE']).optional(),title:z.string().min(1).max(120).optional()}).parse(request.body); const room=await db.room.update({where:{roomNumber},data:input}); await log(db,request,'UPDATE_ROOM','ROOM',String(roomNumber),input); return {data:room}; });
app.delete('/api/admin/rooms/:roomNumber', { preHandler: admin }, async request => { const {roomNumber}=z.object({roomNumber:z.coerce.number()}).parse(request.params); const room=await db.room.findUnique({where:{roomNumber}}); assert(room,'ROOM_NOT_FOUND','直播间不存在',404); if(room.streamStatus==='LIVE')await stopSrsStream(config,`room_${roomNumber}`); await db.room.delete({where:{id:room.id}}); await log(db,request,'DELETE_ROOM','ROOM',String(roomNumber)); return {data:{deleted:true}}; });
app.get('/api/admin/sessions', { preHandler: admin }, async () => ({ data: await db.liveSession.findMany({ take: 200, orderBy: { startedAt: 'desc' }, select: { id: true, startedAt: true, endedAt: true, durationSeconds: true, peakViewers: true, totalViews: true, recordingUrl: true, room: { select: { roomNumber: true, title: true, owner: { select: { nickname: true } } } } } }) }));
app.get('/api/admin/messages', { preHandler: admin }, async () => ({ data: await db.chatMessage.findMany({ take: 200, orderBy: { createdAt: 'desc' }, include: { room: { select: { roomNumber: true, title: true } } } }) }));
app.get('/api/admin/notices', { preHandler: admin }, async () => ({ data: await db.notice.findMany({ take: 200, orderBy: { createdAt: 'desc' }, include: { from: { select: { id: true, username: true, nickname: true } } } }) }));
app.post('/api/admin/notices/:id/approve', { preHandler: admin }, async request => { const { id } = z.object({ id: z.string().uuid() }).parse(request.params); const notice = await db.notice.findUnique({ where: { id } }); assert(notice, 'NOTICE_NOT_FOUND', '申请不存在', 404); assert(notice.status === 'PENDING', 'NOTICE_ALREADY_HANDLED', '该申请已处理'); await db.$transaction([db.notice.update({ where: { id }, data: { status: 'APPROVED', handledAt: new Date(), handledBy: request.auth!.userId } }), db.user.update({ where: { id: notice.fromId }, data: { canStream: true } })]); await log(db, request, 'APPROVE_STREAM_PERMISSION', 'NOTICE', id); return { data: { approved: true } }; });
app.post('/api/admin/notices/:id/reject', { preHandler: admin }, async request => { const { id } = z.object({ id: z.string().uuid() }).parse(request.params); const notice = await db.notice.findUnique({ where: { id } }); assert(notice, 'NOTICE_NOT_FOUND', '申请不存在', 404); assert(notice.status === 'PENDING', 'NOTICE_ALREADY_HANDLED', '该申请已处理'); await db.notice.update({ where: { id }, data: { status: 'REJECTED', handledAt: new Date(), handledBy: request.auth!.userId } }); await log(db, request, 'REJECT_STREAM_PERMISSION', 'NOTICE', id); return { data: { rejected: true } }; });
app.get('/api/admin/files', { preHandler: admin }, async request => { const q = z.object({ page: z.coerce.number().default(1), limit: z.coerce.number().max(100).default(100) }).parse(request.query); const [items, total] = await Promise.all([db.upload.findMany({ include: { uploader: { select: { id: true, nickname: true } } }, skip: (q.page - 1) * q.limit, take: q.limit, orderBy: { createdAt: 'desc' } }), db.upload.count()]); return { data: items, meta: { total } }; });
app.delete('/api/admin/files/:id', { preHandler: admin }, async request => { const { id } = z.object({ id: z.string().uuid() }).parse(request.params); const file = await db.upload.findUnique({ where: { id } }); assert(file, 'FILE_NOT_FOUND', '文件不存在', 404); await unlink(join(config.UPLOAD_DIR, file.filename)).catch(error => request.log.error({ err: error }, 'delete upload file failed')); await db.upload.delete({ where: { id } }); await log(db, request, 'DELETE_UPLOAD', 'UPLOAD', id, { filename: file.filename }); return { data: { deleted: true } }; });
app.get('/api/admin/files/:id/download', { preHandler: admin }, async (request, reply) => { const { id } = z.object({ id: z.string().uuid() }).parse(request.params); const file = await db.upload.findUnique({ where: { id } }); assert(file, 'FILE_NOT_FOUND', '文件不存在', 404); const name = (file.originalName ?? file.filename).replace(/["\\\r\n]/g, '_'); reply.header('content-disposition', `attachment; filename*=UTF-8''${encodeURIComponent(name)}`).type(file.mimeType); return reply.send(createReadStream(join(config.UPLOAD_DIR, file.filename))); });
app.get('/api/admin/replays', { preHandler: admin }, async request => { const q = z.object({ page: z.coerce.number().default(1), limit: z.coerce.number().max(100).default(100) }).parse(request.query); const [items, total] = await Promise.all([db.liveSession.findMany({ where: { recordingUrl: { not: null } }, skip: (q.page - 1) * q.limit, take: q.limit, orderBy: { startedAt: 'desc' }, select: { id: true, startedAt: true, endedAt: true, durationSeconds: true, peakViewers: true, totalViews: true, recordingUrl: true, recordingSize: true, room: { select: { roomNumber: true, title: true, owner: { select: { nickname: true } } } } } }), db.liveSession.count({ where: { recordingUrl: { not: null } } })]); return { data: items.map(s => ({ ...s, recordingSize: s.recordingSize?.toString() ?? null })), meta: { total } }; });
app.delete('/api/admin/replays/:id', { preHandler: admin }, async request => { const { id } = z.object({ id: z.string().uuid() }).parse(request.params); const session = await db.liveSession.findUnique({ where: { id } }); assert(session?.recordingUrl, 'REPLAY_NOT_FOUND', '该场次没有回放', 404); const fileName = session.recordingUrl.split(/[\\/]/).pop(); if (fileName && /^room_\d+\.\d+\.flv$/.test(fileName)) await unlink(join(config.LIVE_DIR, 'replays', fileName)).catch(error => request.log.error({ err: error }, 'delete replay file failed')); await db.liveSession.update({ where: { id }, data: { recordingUrl: null, recordingSize: null } }); await log(db, request, 'DELETE_REPLAY', 'SESSION', id, { file: fileName }); return { data: { deleted: true } }; });
app.get('/api/admin/replays/:id/download', { preHandler: admin }, async (request, reply) => { const { id } = z.object({ id: z.string().uuid() }).parse(request.params); const session = await db.liveSession.findUnique({ where: { id } }); assert(session?.recordingUrl, 'REPLAY_NOT_FOUND', '该场次没有回放', 404); const fileName = session.recordingUrl.split(/[\\/]/).pop(); assert(fileName && /^room_\d+\.\d+\.flv$/.test(fileName), 'RECORDING_PATH_INVALID', '回放文件路径无效', 422); reply.header('content-disposition', `attachment; filename="${fileName}"`).type('video/x-flv'); return reply.send(createReadStream(join(config.LIVE_DIR, 'replays', fileName))); });
app.post('/api/admin/rooms/:roomNumber/stop', { preHandler: admin }, async request => { const { roomNumber } = z.object({ roomNumber: z.coerce.number() }).parse(request.params); const room = await db.room.findUnique({ where: { roomNumber } }); assert(room, 'ROOM_NOT_FOUND', '直播间不存在', 404); const stopped = await stopSrsStream(config, `room_${roomNumber}`); await db.room.update({ where: { id: room.id }, data: { streamStatus: 'OFFLINE', viewerCount: 0 } }); await log(db, request, 'FORCE_STOP_STREAM', 'ROOM', String(roomNumber), { stopped }); return { data: { stopped } }; });
app.post('/api/admin/rooms/:roomNumber/ban', { preHandler: admin }, async request => { const { roomNumber } = z.object({ roomNumber: z.coerce.number() }).parse(request.params); const room = await db.room.update({ where: { roomNumber }, data: { liveBanned: true, streamStatus: 'BANNED' } }); await stopSrsStream(config, `room_${roomNumber}`); await log(db, request, 'BAN_ROOM_STREAM', 'ROOM', String(roomNumber)); return { data: room }; });
app.post('/api/admin/rooms/:roomNumber/unban', { preHandler: admin }, async request => { const { roomNumber } = z.object({ roomNumber: z.coerce.number() }).parse(request.params); const room = await db.room.update({ where: { roomNumber }, data: { liveBanned: false, streamStatus: 'OFFLINE' } }); await log(db, request, 'UNBAN_ROOM_STREAM', 'ROOM', String(roomNumber)); return { data: room }; });
app.get('/api/admin/categories', { preHandler: admin }, async () => ({ data: await db.category.findMany({ orderBy: [{ sort: 'asc' }, { id: 'asc' }] }) }));
app.post('/api/admin/categories', { preHandler: admin }, async (request, reply) => { const input = z.object({ name: z.string().min(1).max(64), slug: z.string().regex(/^[a-z0-9-]+$/), icon: z.string().max(128).optional(), sort: z.number().int().default(0), enabled: z.boolean().default(true) }).parse(request.body); const item = await db.category.create({ data: input }); await log(db, request, 'CREATE_CATEGORY', 'CATEGORY', String(item.id)); reply.code(201).send({ data: item }); });
app.patch('/api/admin/categories/:id', { preHandler: admin }, async request => { const { id } = z.object({ id: z.coerce.number() }).parse(request.params); const input = z.object({ name: z.string().min(1).max(64), slug: z.string().regex(/^[a-z0-9-]+$/), icon: z.string().max(128).nullable(), sort: z.number().int(), enabled: z.boolean() }).partial().parse(request.body); const item = await db.category.update({ where: { id }, data: input }); await log(db, request, 'UPDATE_CATEGORY', 'CATEGORY', String(id)); return { data: item }; });
app.delete('/api/admin/categories/:id', { preHandler: admin }, async request => { const { id } = z.object({ id: z.coerce.number() }).parse(request.params); assert(await db.room.count({ where: { categoryId: id } }) === 0, 'CATEGORY_IN_USE', '该分类下仍有直播间,不能删除', 409); await db.category.delete({ where: { id } }); await log(db, request, 'DELETE_CATEGORY', 'CATEGORY', String(id)); return { data: { deleted: true } }; });
app.get('/api/admin/settings', { preHandler: admin }, async () => ({ data: await settings.all(false) }));
app.put('/api/admin/settings', { preHandler: superAdmin }, async request => { const { values } = z.object({ values: z.record(z.string(), z.unknown()) }).parse(request.body); await settings.setMany(values, request.auth!.userId); await log(db, request, 'UPDATE_SETTINGS', 'SYSTEM', 'settings', { keys: Object.keys(values) }); return { data: await settings.all(false) }; });
app.post('/api/admin/settings/smtp/test', { preHandler: superAdmin }, async request => { const { email } = z.object({ email: z.string().email() }).parse(request.body); const info = await messaging.sendEmail(email, 'XLive SMTP 测试', '如果您收到此邮件,说明 XLive SMTP 配置有效。'); await log(db, request, 'TEST_SMTP', 'SYSTEM', 'smtp', { accepted: info.accepted }); return { data: { sent: true, accepted: info.accepted } }; });
app.post('/api/admin/settings/sms/test', { preHandler: superAdmin }, async request => { const { phone } = z.object({ phone: z.string().regex(/^\+?\d{7,15}$/) }).parse(request.body); const code = String(Math.floor(100000 + Math.random() * 900000)); const result = await messaging.sendSmsForPurpose(phone, 'REGISTER', code); await log(db, request, 'TEST_SMS', 'SYSTEM', 'sms', { requestId: result.RequestId }); return { data: { sent: true, requestId: result.RequestId } }; });
app.get('/api/admin/logs', { preHandler: admin }, async () => ({ data: (await db.adminLog.findMany({ take: 200, orderBy: { createdAt: 'desc' }, include: { admin: { select: { username: true, nickname: true } } } })).map(item => ({ ...item, id: item.id.toString() })) }));
app.get('/api/admin/admins', { preHandler: superAdmin }, async () => ({ data: await db.user.findMany({ where: { roles: { some: { role: { name: { in: ['ADMIN','SUPER_ADMIN'] } } } } }, select: { id:true,username:true,nickname:true,email:true,status:true,createdAt:true,roles:{select:{role:{select:{name:true}}}} }, orderBy:{createdAt:'asc'} }) }));
app.patch('/api/admin/admins/:id/role', { preHandler: superAdmin }, async request => { const {id}=z.object({id:z.string().uuid()}).parse(request.params); const {role}=z.object({role:z.enum(['ADMIN','SUPER_ADMIN'])}).parse(request.body); assert(id!==request.auth!.userId,'CANNOT_CHANGE_SELF_ROLE','不能修改当前登录账号的角色',409); const target=await db.user.findUnique({where:{id}}); assert(target,'USER_NOT_FOUND','用户不存在',404); await db.$transaction(async tx=>{const selectedRole=await tx.role.findUniqueOrThrow({where:{name:role}}); await tx.userRole.deleteMany({where:{userId:id,role:{name:{in:['ADMIN','SUPER_ADMIN']}}}}); await tx.userRole.create({data:{userId:id,roleId:selectedRole.id}})}); await log(db,request,'CHANGE_ADMIN_ROLE','USER',id,{role}); return {data:{updated:true}}; });
app.delete('/api/admin/messages/:id', { preHandler: admin }, async request => { const { id } = z.object({ id: z.string().uuid() }).parse(request.params); await db.chatMessage.update({ where: { id }, data: { deletedAt: new Date(), deletedBy: request.auth!.userId } }); await log(db, request, 'DELETE_CHAT_MESSAGE', 'CHAT_MESSAGE', id); return { data: { deleted: true } }; });
app.post('/api/admin/admins', { preHandler: superAdmin }, async (request, reply) => { const input = z.object({ username: z.string().min(3).max(32), nickname: z.string().min(1).max(64), email: z.string().email(), password: z.string(), role: z.enum(['ADMIN', 'SUPER_ADMIN']).default('ADMIN') }).parse(request.body); validatePassword(input.password, await settings.passwordPolicy()); const user = await db.user.create({ data: { username: input.username, nickname: input.nickname, email: input.email.toLowerCase(), passwordHash: await hashPassword(input.password), roles: { create: { role: { connect: { name: input.role } } } } } }); await log(db, request, 'CREATE_ADMIN', 'USER', user.id, { role: input.role }); reply.code(201).send({ data: { id: user.id } }); });
}
+81
View File
@@ -0,0 +1,81 @@
import type { FastifyInstance } from 'fastify';
import type { PrismaClient, RoleName } from '@prisma/client';
import { z } from 'zod';
import type { AppConfig } from '../config.js';
import type { SettingsService } from './settings.service.js';
import type { VerificationService } from './verification.service.js';
import { AppError, assert } from '../lib/errors.js';
import { hashPassword, validatePassword, verifyPassword } from '../lib/password.js';
import { clearAuthCookies, authenticate, setAccessCookie, setRefreshCookie } from '../lib/auth.js';
import { randomToken, sha256 } from '../lib/crypto.js';
const registerSchema = z.object({ username: z.string().min(3).max(32).regex(/^[a-zA-Z0-9_]+$/), nickname: z.string().min(1).max(64), email: z.string().email().optional(), phone: z.string().regex(/^\+?\d{7,15}$/).optional(), password: z.string().min(1), emailCode: z.string().length(6).optional(), smsCode: z.string().length(6).optional() });
const loginSchema = z.object({ account: z.string().min(1).max(254), password: z.string().min(1).max(128) });
function safeUser(user: { id: string; username: string; nickname: string; avatar: string | null; email: string | null; phone: string | null; status: string; canStream: boolean; createdAt: Date; roles: { role: { name: RoleName } }[] }) {
return { id: user.id, username: user.username, nickname: user.nickname, avatar: user.avatar, email: user.email, phone: user.phone ? `${user.phone.slice(0, 3)}****${user.phone.slice(-4)}` : null, status: user.status, canStream: user.canStream, createdAt: user.createdAt, roles: user.roles.map(r => r.role.name) };
}
export async function authRoutes(app: FastifyInstance, deps: { db: PrismaClient; config: AppConfig; settings: SettingsService; verification: VerificationService }) {
const { db, config, settings, verification } = deps;
app.post('/api/auth/register', async (request, reply) => {
const input = registerSchema.parse(request.body); const options = await settings.all(false);
const emailEnabled = Boolean(options['auth.register.email']); const smsEnabled = Boolean(options['auth.register.sms']);
assert(emailEnabled || smsEnabled, 'REGISTRATION_DISABLED', '网站暂未开放注册', 403);
assert(!input.email || emailEnabled, 'EMAIL_REGISTRATION_DISABLED', '未开放邮箱注册');
assert(!input.phone || smsEnabled, 'SMS_REGISTRATION_DISABLED', '未开放手机号注册');
const rule = String(options['auth.register.rule'] ?? 'ANY');
if (emailEnabled && smsEnabled && rule === 'ALL') assert(input.email && input.phone, 'CONTACT_REQUIRED', '邮箱和手机号均为必填项');
else assert((emailEnabled && input.email) || (smsEnabled && input.phone), 'CONTACT_REQUIRED', '请填写可用的邮箱或手机号');
if (options['auth.register.requireVerification']) {
if (rule === 'ALL') { assert(input.emailCode && input.smsCode, 'VERIFICATION_CODE_REQUIRED', '请输入邮箱和短信验证码'); await verification.verify('EMAIL', input.email!, 'REGISTER', input.emailCode); await verification.verify('SMS', input.phone!, 'REGISTER', input.smsCode); }
else if (input.email && input.emailCode) await verification.verify('EMAIL', input.email, 'REGISTER', input.emailCode);
else if (input.phone && input.smsCode) await verification.verify('SMS', input.phone, 'REGISTER', input.smsCode);
else throw new AppError('VERIFICATION_CODE_REQUIRED', '请至少完成一种验证码验证');
}
validatePassword(input.password, await settings.passwordPolicy());
const existing = await db.user.findFirst({ where: { OR: [{ username: input.username }, ...(input.email ? [{ email: input.email.toLowerCase() }] : []), ...(input.phone ? [{ phone: input.phone }] : [])] } });
assert(!existing, 'ACCOUNT_EXISTS', '用户名、邮箱或手机号已被使用', 409);
const canStream = await settings.get<boolean>('live.newUserCanStream', false);
const user = await db.user.create({ data: { username: input.username, nickname: input.nickname, email: input.email?.toLowerCase(), phone: input.phone, passwordHash: await hashPassword(input.password), canStream, registerIp: request.ip, roles: { create: { role: { connect: { name: 'USER' } } } } }, include: { roles: { include: { role: true } } } });
reply.code(201).send({ data: safeUser(user) });
});
app.post('/api/auth/login', async (request, reply) => {
const input = loginSchema.parse(request.body); const now = new Date();
const user = await db.user.findFirst({ where: { OR: [{ username: input.account }, { email: input.account.toLowerCase() }, { phone: input.account }] }, include: { roles: { include: { role: true } } } });
const fail = async (reason: string) => {
await db.loginLog.create({ data: { userId: user?.id, account: input.account, success: false, reason, ip: request.ip, userAgent: request.headers['user-agent'] } });
throw new AppError('INVALID_CREDENTIALS', '账号或密码错误', 401);
};
if (!user || !(await verifyPassword(user.passwordHash, input.password))) {
if (user) { const max = await settings.get<number>('security.loginMaxFailures', 5); const lockMinutes = await settings.get<number>('security.loginLockMinutes', 15); const count = user.failedLoginCount + 1; await db.user.update({ where: { id: user.id }, data: { failedLoginCount: count >= max ? 0 : count, lockedUntil: count >= max ? new Date(Date.now() + lockMinutes * 60_000) : undefined } }); }
return fail('BAD_PASSWORD');
}
if (user.status !== 'ACTIVE') throw new AppError('ACCOUNT_DISABLED', '账号已被禁用', 403);
if (user.lockedUntil && user.lockedUntil > now) throw new AppError('ACCOUNT_TEMPORARILY_LOCKED', `账号暂时锁定至 ${user.lockedUntil.toISOString()}`, 423);
const roles = user.roles.map(r => r.role.name);
const access = await reply.jwtSign({ sub: user.id, roles, type: 'access' }, { expiresIn: '15m' }); const refresh = randomToken(48);
await db.$transaction([db.refreshToken.create({ data: { userId: user.id, tokenHash: sha256(refresh), expiresAt: new Date(Date.now() + 30 * 86400_000), ip: request.ip } }), db.user.update({ where: { id: user.id }, data: { failedLoginCount: 0, lockedUntil: null, lastLoginAt: now, lastLoginIp: request.ip } }), db.loginLog.create({ data: { userId: user.id, account: input.account, success: true, ip: request.ip, userAgent: request.headers['user-agent'] } })]);
setAccessCookie(reply, access, config.COOKIE_SECURE); setRefreshCookie(reply, refresh, config.COOKIE_SECURE);
return { data: safeUser(user) };
});
app.post('/api/auth/refresh', async (request, reply) => {
const token = request.cookies.xlive_refresh; assert(token, 'REFRESH_REQUIRED', '登录状态已过期', 401);
const record = await db.refreshToken.findUnique({ where: { tokenHash: sha256(token) }, include: { user: { include: { roles: { include: { role: true } } } } } });
assert(record && !record.revokedAt && record.expiresAt > new Date() && record.user.status === 'ACTIVE', 'REFRESH_INVALID', '登录状态已过期', 401);
const roles = record.user.roles.map(r => r.role.name); const access = await reply.jwtSign({ sub: record.userId, roles, type: 'access' }, { expiresIn: '15m' });
setAccessCookie(reply, access, config.COOKIE_SECURE); return { data: { refreshed: true } };
});
app.post('/api/auth/logout', async (request, reply) => { const token = request.cookies.xlive_refresh; if (token) await db.refreshToken.updateMany({ where: { tokenHash: sha256(token) }, data: { revokedAt: new Date() } }); clearAuthCookies(reply); return { data: { loggedOut: true } }; });
app.get('/api/users/me', { preHandler: authenticate }, async request => { const user = await db.user.findUniqueOrThrow({ where: { id: request.auth!.userId }, include: { roles: { include: { role: true } } } }); return { data: safeUser(user) }; });
app.patch('/api/users/me', { preHandler: authenticate }, async request => { const input = z.object({ nickname: z.string().min(1).max(64).optional(), bio: z.string().max(500).optional(), avatar: z.string().max(500).refine(v => v === '' || /^https?:\/\/\S+$/.test(v) || v.startsWith('/uploads/'), '头像必须是有效的图片链接').optional() }).parse(request.body); const user = await db.user.update({ where: { id: request.auth!.userId }, data: { ...input, avatar: input.avatar === '' ? null : input.avatar }, include: { roles: { include: { role: true } } } }); return { data: safeUser(user) }; });
app.post('/api/auth/change-password', { preHandler: authenticate }, async request => { const input = z.object({ currentPassword: z.string(), newPassword: z.string() }).parse(request.body); const user = await db.user.findUniqueOrThrow({ where: { id: request.auth!.userId } }); assert(await verifyPassword(user.passwordHash, input.currentPassword), 'CURRENT_PASSWORD_INVALID', '当前密码不正确'); validatePassword(input.newPassword, await settings.passwordPolicy()); await db.$transaction([db.user.update({ where: { id: user.id }, data: { passwordHash: await hashPassword(input.newPassword) } }), db.refreshToken.updateMany({ where: { userId: user.id }, data: { revokedAt: new Date() } })]); return { data: { changed: true } }; });
app.get('/api/auth/captcha', async () => ({ data: await verification.createCaptcha() }));
app.post('/api/auth/email/send-code', async request => { const input = z.object({ email: z.string().email(), purpose: z.enum(['REGISTER', 'LOGIN', 'RESET_PASSWORD']).default('REGISTER'), captchaId: z.string().min(8), captchaText: z.string().min(4).max(8) }).parse(request.body); await verification.requireCaptcha(input.captchaId, input.captchaText); return { data: await verification.send('EMAIL', input.email, input.purpose, request.ip) }; });
app.post('/api/auth/sms/send-code', async request => { const input = z.object({ phone: z.string().regex(/^\+?\d{7,15}$/), purpose: z.enum(['REGISTER', 'LOGIN', 'RESET_PASSWORD']).default('REGISTER'), captchaId: z.string().min(8), captchaText: z.string().min(4).max(8) }).parse(request.body); await verification.requireCaptcha(input.captchaId, input.captchaText); return { data: await verification.send('SMS', input.phone, input.purpose, request.ip) }; });
app.post('/api/auth/reset-password', async request => { const input = z.object({ channel: z.enum(['EMAIL', 'SMS']), target: z.string(), code: z.string().length(6), newPassword: z.string() }).parse(request.body); await verification.verify(input.channel, input.target, 'RESET_PASSWORD', input.code); validatePassword(input.newPassword, await settings.passwordPolicy()); const where = input.channel === 'EMAIL' ? { email: input.target.toLowerCase() } : { phone: input.target }; const user = await db.user.findFirst({ where }); assert(user, 'ACCOUNT_NOT_FOUND', '账号不存在', 404); await db.$transaction([db.user.update({ where: { id: user.id }, data: { passwordHash: await hashPassword(input.newPassword) } }), db.refreshToken.updateMany({ where: { userId: user.id }, data: { revokedAt: new Date() } })]); return { data: { reset: true } }; });
}
@@ -0,0 +1,20 @@
import Fastify from 'fastify';
import cookie from '@fastify/cookie';
import jwt from '@fastify/jwt';
import { describe, expect, it, vi } from 'vitest';
import { hashPassword } from '../lib/password.js';
import { authRoutes } from './auth.routes.js';
import { roomRoutes } from './rooms.routes.js';
import { SettingsService } from './settings.service.js';
const config={JWT_SECRET:'test-secret-test-secret-test-secret-123',COOKIE_SECURE:false,CONFIG_ENCRYPTION_KEY:'settings-test-key',RTMP_PUBLIC_URL:'rtmp://localhost/live',HLS_PUBLIC_URL:'http://localhost/live',SRS_API_URL:'http://srs:1985'} as never;
const user=(passwordHash:string)=>({id:'1d3ba0bb-5560-4184-9267-4a7ad9012a50',username:'alice',nickname:'Alice',avatar:null,email:'alice@example.com',phone:null,status:'ACTIVE',canStream:true,createdAt:new Date(),failedLoginCount:0,lockedUntil:null,passwordHash,roles:[{role:{name:'USER'}}]});
describe('authentication routes',()=>{
it('registers a valid user',async()=>{const created=user('hash');const db={user:{findFirst:vi.fn().mockResolvedValue(null),create:vi.fn().mockResolvedValue(created)}} as never;const settings={all:vi.fn().mockResolvedValue({'auth.register.email':true,'auth.register.sms':false,'auth.register.requireVerification':false}),passwordPolicy:vi.fn().mockResolvedValue({minLength:8,maxLength:64,uppercase:true,lowercase:true,number:true,special:false}),get:vi.fn().mockResolvedValue(true)} as never;const app=Fastify();await app.register(cookie);await app.register(jwt,{secret:(config as any).JWT_SECRET,cookie:{cookieName:'xlive_access',signed:false}});await authRoutes(app,{db,config,settings,verification:{} as never});const r=await app.inject({method:'POST',url:'/api/auth/register',payload:{username:'alice',nickname:'Alice',email:'alice@example.com',password:'ValidPass123'}});expect(r.statusCode).toBe(201);expect((db as any).user.create).toHaveBeenCalled()});
it('logs in and issues HttpOnly cookies',async()=>{const u=user(await hashPassword('ValidPass123'));const db={user:{findFirst:vi.fn().mockResolvedValue(u),update:vi.fn().mockResolvedValue(u)},refreshToken:{create:vi.fn().mockResolvedValue({})},loginLog:{create:vi.fn().mockResolvedValue({})},$transaction:vi.fn(async(items:Promise<unknown>[])=>Promise.all(items))} as never;const settings={get:vi.fn()} as never;const app=Fastify();await app.register(cookie);await app.register(jwt,{secret:(config as any).JWT_SECRET,cookie:{cookieName:'xlive_access',signed:false}});await authRoutes(app,{db,config,settings,verification:{} as never});const r=await app.inject({method:'POST',url:'/api/auth/login',payload:{account:'alice',password:'ValidPass123'}});expect(r.statusCode).toBe(200);expect(String(r.headers['set-cookie'])).toContain('HttpOnly')});
});
describe('room discovery',()=>{it('always filters normal listings to public rooms',async()=>{const db={room:{findMany:vi.fn().mockResolvedValue([]),count:vi.fn().mockResolvedValue(0)},category:{findMany:vi.fn()}} as never;const app=Fastify();await app.register(cookie);await roomRoutes(app,{db,redis:{} as never,config,settings:{} as never});const r=await app.inject({method:'GET',url:'/api/rooms?search=secret'});expect(r.statusCode).toBe(200);expect((db as any).room.findMany.mock.calls[0][0].where.visibility).toBe('PUBLIC')})});
describe('system settings',()=>{it('never returns sensitive plaintext to admin lists',async()=>{const db={systemSetting:{findMany:vi.fn().mockResolvedValue([{key:'smtp.password',value:'encrypted-value',group:'smtp',sensitive:true}])}} as never;const service=new SettingsService(db,config);const all=await service.all(false);expect(all['smtp.password']).toBe('********')})});
+44
View File
@@ -0,0 +1,44 @@
import type { FastifyInstance } from 'fastify';
import type { PrismaClient, RoleName } from '@prisma/client';
import type { WebSocket } from 'ws';
import { z } from 'zod';
type Client = { socket: WebSocket; userId: string | null; nickname: string; avatar: string | null; roles: RoleName[] };
const rooms = new Map<number, Set<Client>>();
export async function chatRoutes(app: FastifyInstance, db: PrismaClient) {
app.get('/api/rooms/:roomNumber/chat', { websocket: true }, async (socket, request) => {
const roomNumber = Number((request.params as { roomNumber: string }).roomNumber);
const room = await db.room.findUnique({ where: { roomNumber } });
if (!room) { socket.send(JSON.stringify({ type: 'error', message: '直播间不存在' })); socket.close(1008); return; }
let user: { id: string; nickname: string; avatar: string | null; status: string } | null = null;
let roles: RoleName[] = [];
try {
const token = await request.jwtVerify<{ sub: string; roles: RoleName[] }>();
roles = token.roles;
const [account, ban] = await Promise.all([
db.user.findUnique({ where: { id: token.sub }, select: { id: true, nickname: true, avatar: true, status: true } }),
db.ban.findFirst({ where: { userId: token.sub, type: 'CHAT', revokedAt: null, OR: [{ expiresAt: null }, { expiresAt: { gt: new Date() } }] } })
]);
if (!account || account.status !== 'ACTIVE' || ban) { socket.send(JSON.stringify({ type: 'error', message: ban ? '您已被禁言' : '账号当前无法参与聊天' })); socket.close(1008); return; }
user = account;
} catch { /* 游客可接收聊天和弹幕,但不能发送。 */ }
const client: Client = { socket, userId: user?.id ?? null, nickname: user?.nickname ?? '游客', avatar: user?.avatar ?? null, roles };
if (!rooms.has(roomNumber)) rooms.set(roomNumber, new Set()); rooms.get(roomNumber)!.add(client);
const history = await db.chatMessage.findMany({ where: { roomId: room.id, deletedAt: null }, orderBy: { createdAt: 'desc' }, take: 50 });
socket.send(JSON.stringify({ type: 'history', messages: history.reverse() }));
socket.on('message', async raw => {
if (!user) { socket.send(JSON.stringify({ type: 'error', message: '请先登录后参与聊天' })); return; }
try {
const { content } = z.object({ content: z.string().trim().min(1).max(500) }).parse(JSON.parse(raw.toString()));
const session = await db.liveSession.findFirst({ where: { roomId: room.id, endedAt: null }, orderBy: { startedAt: 'desc' } });
const message = await db.chatMessage.create({ data: { roomId: room.id, userId: user.id, nickname: user.nickname, avatar: user.avatar, content, sessionId: session?.id, offsetSeconds: session ? Math.max(0, (Date.now() - session.startedAt.getTime()) / 1000) : null } });
const event = JSON.stringify({ type: 'message', message });
for (const peer of rooms.get(roomNumber) ?? []) if (peer.socket.readyState === peer.socket.OPEN) peer.socket.send(event);
} catch { socket.send(JSON.stringify({ type: 'error', message: '消息格式不正确或发送失败' })); }
});
socket.on('close', () => { rooms.get(roomNumber)?.delete(client); if (!rooms.get(roomNumber)?.size) rooms.delete(roomNumber); });
});
}
@@ -0,0 +1,6 @@
import Fastify from 'fastify';
import { describe, expect, it, vi } from 'vitest';
import { mediaRoutes } from './media.routes.js';
const config={SRS_HOOK_SECRET:'test-hook-secret',SRS_API_URL:'http://srs:1985'} as never;
function mockDb(){const session={id:'s1',startedAt:new Date(Date.now()-5000)};return {room:{findUnique:vi.fn().mockResolvedValue({id:'r1',roomNumber:10001,liveBanned:false,owner:{status:'ACTIVE',canStream:true},streamKey:{keyHash:'73475cb40a568e8da8a045ced110137e159f890ac4da883b6b17dc651b3a8049'}}),count:vi.fn().mockResolvedValue(0),update:vi.fn()},liveSession:{updateMany:vi.fn(),create:vi.fn(),findFirst:vi.fn().mockResolvedValue(session),update:vi.fn()},$transaction:vi.fn(async(arg:unknown)=>typeof arg==='function'?(arg as (tx:unknown)=>unknown)({room:{update:vi.fn()},liveSession:{updateMany:vi.fn(),create:vi.fn()}}):Promise.all(arg as Promise<unknown>[]))} as never}
describe('SRS webhooks',()=>{it('rejects invalid stream keys',async()=>{const app=Fastify();await mediaRoutes(app,{db:mockDb(),config});const r=await app.inject({method:'POST',url:'/api/media/hooks?secret=test-hook-secret',payload:{action:'on_publish',app:'live',stream:'room_10001',param:'?token=wrong'}});expect(r.statusCode).toBe(403)});it('records unpublish and marks a room offline',async()=>{const db=mockDb() as any,app=Fastify();await mediaRoutes(app,{db,config});const r=await app.inject({method:'POST',url:'/api/media/hooks?secret=test-hook-secret',payload:{action:'on_unpublish',app:'live',stream:'room_10001'}});expect(r.statusCode).toBe(200);expect(db.room.update).toHaveBeenCalled()})});
+51
View File
@@ -0,0 +1,51 @@
import type { FastifyInstance } from 'fastify';
import type { PrismaClient } from '@prisma/client';
import { stat, unlink } from 'node:fs/promises';
import { join } from 'node:path';
import { z } from 'zod';
import type { AppConfig } from '../config.js';
import { assert } from '../lib/errors.js';
import { sha256, safeEqual } from '../lib/crypto.js';
import type { SettingsService } from './settings.service.js';
import type { TranscoderService } from './transcoder.service.js';
const hookSchema = z.object({ action: z.string(), client_id: z.union([z.string(), z.number()]).optional(), ip: z.string().optional(), vhost: z.string().optional(), app: z.string(), stream: z.string(), param: z.string().optional(), file: z.string().optional(), duration: z.coerce.number().optional(), cwd: z.string().optional() });
export async function mediaRoutes(app: FastifyInstance, deps: { db: PrismaClient; config: AppConfig; settings?: SettingsService; transcoder?: TranscoderService }) {
const { db, config, settings, transcoder } = deps;
app.post('/api/media/hooks', async (request, reply) => {
const secret = (request.query as { secret?: string }).secret ?? ''; assert(safeEqual(secret, config.SRS_HOOK_SECRET), 'HOOK_UNAUTHORIZED', '无效的媒体服务器签名', 401);
const hook = hookSchema.parse(request.body); const match = /^room_(\d+)$/.exec(hook.stream); assert(match, 'STREAM_NAME_INVALID', '无效的流名称', 403); const roomNumber = Number(match[1]);
const room = await db.room.findUnique({ where: { roomNumber }, include: { owner: true, streamKey: true } }); assert(room && room.streamKey, 'STREAM_NOT_FOUND', '推流目标不存在', 403);
if (hook.action === 'on_publish') {
const params = new URLSearchParams((hook.param ?? '').replace(/^\?/, '')); const token = params.get('token') ?? '';
assert(token && safeEqual(sha256(token), room.streamKey.keyHash), 'STREAM_KEY_INVALID', 'Stream Key 无效', 403);
assert(room.owner.status === 'ACTIVE' && room.owner.canStream && !room.liveBanned, 'STREAM_PERMISSION_DENIED', '账号或直播间已被禁止直播', 403);
const active = await db.room.count({ where: { streamStatus: 'LIVE' } }); const maximum = settings ? await settings.get<number>('live.maxConcurrent', 100) : 100;
assert(room.streamStatus === 'LIVE' || active < maximum, 'STREAM_CAPACITY_REACHED', '平台同时直播数量已达到上限', 503);
await db.$transaction(async tx => {
await tx.liveSession.updateMany({ where: { roomId: room.id, endedAt: null }, data: { endedAt: new Date() } });
await tx.liveSession.create({ data: { roomId: room.id, streamName: hook.stream, srsClientId: hook.client_id ? String(hook.client_id) : null, recordEnabled: room.recordReplay } });
await tx.room.update({ where: { id: room.id }, data: { streamStatus: 'LIVE', lastLiveAt: new Date(), viewerCount: 0 } });
});
if (transcoder) void transcoder.onPublish(hook.stream).catch(error => request.log.error({ err: error }, 'transcoder onPublish failed'));
}
if (hook.action === 'on_unpublish') {
if (transcoder) transcoder.onUnpublish(hook.stream);
const session = await db.liveSession.findFirst({ where: { roomId: room.id, endedAt: null }, orderBy: { startedAt: 'desc' } }); const endedAt = new Date();
await db.$transaction([db.room.update({ where: { id: room.id }, data: { streamStatus: room.liveBanned ? 'BANNED' : 'OFFLINE', viewerCount: 0 } }), ...(session ? [db.liveSession.update({ where: { id: session.id }, data: { endedAt, durationSeconds: Math.max(0, Math.floor((endedAt.getTime() - session.startedAt.getTime()) / 1000)) } })] : [])]);
}
if (hook.action === 'on_dvr' && hook.file) {
const fileName = hook.file.split(/[\\/]/).pop();
assert(fileName && /^room_\d+\.\d+\.flv$/.test(fileName), 'RECORDING_PATH_INVALID', '回放文件路径无效', 422);
const session = await db.liveSession.findFirst({ where: { roomId: room.id }, orderBy: { startedAt: 'desc' } });
if (session && !session.recordEnabled) {
unlink(join(config.LIVE_DIR, 'replays', fileName)).catch(error => request.log.error({ err: error }, 'delete replay file failed'));
} else if (session) {
const size = await stat(join(config.LIVE_DIR, 'replays', fileName)).then(s => s.size).catch(() => null);
await db.liveSession.update({ where: { id: session.id }, data: { recordingUrl: `/live/replays/${fileName}`, ...(size != null ? { recordingSize: size } : {}), ...(hook.duration && !session.durationSeconds ? { durationSeconds: Math.round(hook.duration) } : {}) } });
}
}
reply.type('application/json').send(0);
});
}
+58
View File
@@ -0,0 +1,58 @@
import nodemailer from 'nodemailer';
import type { CodePurpose } from '@prisma/client';
import type { SettingsService } from './settings.service.js';
import { AppError } from '../lib/errors.js';
import { hmacSha1Base64 } from '../lib/crypto.js';
type SmtpConfig = { host: string; port: number; username: string; password: string; encryption: 'NONE' | 'SSL' | 'STARTTLS'; fromEmail: string; fromName: string };
type SmsConfig = { accessKeyId: string; accessKeySecret: string; signName: string; regionId?: string; registerTemplateId: string; loginTemplateId: string; resetTemplateId: string };
export class MessagingService {
constructor(private settings: SettingsService) {}
private async smtp(): Promise<SmtpConfig> {
const all = await this.settings.all(true);
const c = {
host: String(all['smtp.host'] ?? ''), port: Number(all['smtp.port'] ?? 587), username: String(all['smtp.username'] ?? ''),
password: String(all['smtp.password'] ?? ''), encryption: String(all['smtp.encryption'] ?? 'STARTTLS') as SmtpConfig['encryption'],
fromEmail: String(all['smtp.fromEmail'] ?? ''), fromName: String(all['smtp.fromName'] ?? all['site.name'] ?? 'XLive')
};
if (!c.host || !c.fromEmail) throw new AppError('SMTP_NOT_CONFIGURED', 'SMTP 尚未配置');
return c;
}
async sendEmail(to: string, subject: string, text: string) {
const c = await this.smtp();
const transport = nodemailer.createTransport({ host: c.host, port: c.port, secure: c.encryption === 'SSL', requireTLS: c.encryption === 'STARTTLS', auth: c.username ? { user: c.username, pass: c.password } : undefined, connectionTimeout: 10_000 });
try {
await transport.verify();
return await transport.sendMail({ from: { address: c.fromEmail, name: c.fromName }, to, subject, text });
} catch (error) {
const message = error instanceof Error ? error.message : '未知错误';
throw new AppError('SMTP_SEND_FAILED', `邮件发送失败:${message}`, 502);
}
}
async sendSms(phone: string, templateId: string, code: string) {
const all = await this.settings.all(true);
const c: SmsConfig = { accessKeyId: String(all['sms.accessKeyId'] ?? ''), accessKeySecret: String(all['sms.accessKeySecret'] ?? ''), signName: String(all['sms.signName'] ?? ''), regionId: String(all['sms.regionId'] ?? 'cn-hangzhou'), registerTemplateId: String(all['sms.registerTemplateId'] ?? ''), loginTemplateId: String(all['sms.loginTemplateId'] ?? ''), resetTemplateId: String(all['sms.resetTemplateId'] ?? '') };
if (!c.accessKeyId || !c.accessKeySecret || !c.signName || !templateId) throw new AppError('SMS_NOT_CONFIGURED', '阿里云短信尚未完整配置');
const params: Record<string, string> = {
AccessKeyId: c.accessKeyId, Action: 'SendSms', Format: 'JSON', PhoneNumbers: phone, RegionId: c.regionId ?? 'cn-hangzhou',
SignName: c.signName, SignatureMethod: 'HMAC-SHA1', SignatureNonce: crypto.randomUUID(), SignatureVersion: '1.0',
TemplateCode: templateId, TemplateParam: JSON.stringify({ code }), Timestamp: new Date().toISOString().replace(/\.\d{3}Z$/, 'Z'), Version: '2017-05-25'
};
const percent = (s: string) => encodeURIComponent(s).replace(/!/g, '%21').replace(/'/g, '%27').replace(/\(/g, '%28').replace(/\)/g, '%29').replace(/\*/g, '%2A');
const canonical = Object.keys(params).sort().map(k => `${percent(k)}=${percent(params[k]!)}`).join('&');
params.Signature = hmacSha1Base64(`${c.accessKeySecret}&`, `GET&%2F&${percent(canonical)}`);
const response = await fetch(`https://dysmsapi.aliyuncs.com/?${new URLSearchParams(params)}`);
const body = await response.json() as { Code?: string; Message?: string; RequestId?: string };
if (!response.ok || body.Code !== 'OK') throw new AppError('SMS_SEND_FAILED', `短信发送失败:${body.Message ?? body.Code ?? response.statusText}`, 502);
return body;
}
async sendSmsForPurpose(phone: string, purpose: CodePurpose, code: string) {
const key = purpose === 'REGISTER' ? 'sms.registerTemplateId' : purpose === 'LOGIN' ? 'sms.loginTemplateId' : 'sms.resetTemplateId';
return this.sendSms(phone, await this.settings.get<string>(key, ''), code);
}
}
+112
View File
@@ -0,0 +1,112 @@
import type { FastifyInstance } from 'fastify';
import type { PrismaClient } from '@prisma/client';
import type { RedisLike } from '../lib/redis.js';
import { z } from 'zod';
import type { AppConfig } from '../config.js';
import type { SettingsService } from './settings.service.js';
import { qualitySlug, type QualitySetting, type TranscoderService } from './transcoder.service.js';
import { authenticate } from '../lib/auth.js';
import { AppError, assert } from '../lib/errors.js';
import { decrypt, encrypt, randomToken, sha256 } from '../lib/crypto.js';
const roomInclude = { owner: { select: { id: true, username: true, nickname: true, avatar: true } }, category: true } as const;
const flvUrl = (path: string, flvHost: string) => flvHost ? `//${flvHost.replace(/^https?:\/\//, '').replace(/\/+$/, '')}${path}` : path;
const qualitiesFor = (n: number, configs: QualitySetting[], src: { width: number; height: number } | undefined, flvHost: string) => [{ label: '原画', flv: flvUrl(`/live/room_${n}.flv`, flvHost), hls: `/live/room_${n}.m3u8` }, ...configs.filter(q => q.enabled !== false).filter(q => !src || (q.width < src.width && q.height < src.height)).map(q => ({ label: q.label, flv: flvUrl(`/transcode/live/room_${n}_${qualitySlug(q.label)}.flv`, flvHost), hls: `/live/room_${n}_${qualitySlug(q.label)}.m3u8` }))];
const roomInput = z.object({ title: z.string().min(1).max(120), description: z.string().max(1000).optional(), cover: z.string().max(500).optional(), announcement: z.string().max(1000).optional(), categoryId: z.number().int().positive().nullable().optional(), visibility: z.enum(['PUBLIC', 'PRIVATE']).default('PUBLIC'), showViewerCount: z.boolean().default(true), recordReplay: z.boolean().optional() });
export async function roomRoutes(app: FastifyInstance, deps: { db: PrismaClient; redis: RedisLike; config: AppConfig; settings: SettingsService; transcoder: TranscoderService }) {
const { db, redis, config, settings, transcoder } = deps;
app.get('/api/rooms', async request => {
const q = z.object({ category: z.string().optional(), search: z.string().max(100).optional(), status: z.enum(['LIVE', 'OFFLINE']).optional(), page: z.coerce.number().int().min(1).default(1), limit: z.coerce.number().int().min(1).max(50).default(20) }).parse(request.query);
const where = { visibility: 'PUBLIC' as const, ...(q.status ? { streamStatus: q.status } : {}), ...(q.category ? { category: { slug: q.category, enabled: true } } : {}), ...(q.search ? { OR: [{ title: { contains: q.search, mode: 'insensitive' as const } }, { owner: { nickname: { contains: q.search, mode: 'insensitive' as const } } }] } : {}) };
const [items, total] = await Promise.all([db.room.findMany({ where, include: roomInclude, orderBy: [{ featured: 'desc' }, { streamStatus: 'desc' }, { viewerCount: 'desc' }, { lastLiveAt: 'desc' }], skip: (q.page - 1) * q.limit, take: q.limit }), db.room.count({ where })]);
return { data: items, meta: { page: q.page, limit: q.limit, total } };
});
app.get('/api/rooms/:roomNumber', async request => {
const { roomNumber } = z.object({ roomNumber: z.coerce.number().int() }).parse(request.params);
const room = await db.room.findUnique({ where: { roomNumber }, include: roomInclude }); assert(room, 'ROOM_NOT_FOUND', '直播间不存在', 404);
if (!(await settings.get<boolean>('auth.guestViewing', true)) && !request.cookies.xlive_access) throw new AppError('LOGIN_REQUIRED', '登录后才能观看直播', 401);
const [protocol, flvHost, transcodeQualities] = await Promise.all([settings.get<'FLV' | 'HLS'>('live.playback.protocol', 'FLV'), settings.get<string>('live.playback.flvHost', ''), settings.get<QualitySetting[]>('live.transcode.qualities', [])]);
const qualities = qualitiesFor(room.roomNumber, transcodeQualities, transcoder.probeOf(`room_${room.roomNumber}`), flvHost);
return { data: { ...room, playback: room.streamStatus === 'LIVE' ? { ...qualities[0]!, qualities, protocol } : null } };
});
app.get('/api/categories', async () => ({ data: await db.category.findMany({ where: { enabled: true }, orderBy: [{ sort: 'asc' }, { id: 'asc' }] }) }));
app.post('/api/rooms', { preHandler: authenticate }, async (request, reply) => {
const input = roomInput.parse(request.body); const user = await db.user.findUniqueOrThrow({ where: { id: request.auth!.userId } });
assert(user.canStream && user.status === 'ACTIVE', 'STREAM_PERMISSION_DENIED', '当前账号没有直播权限', 403); assert(await settings.get<boolean>('live.allowRegisteredUsers', true), 'STREAM_CREATION_DISABLED', '平台暂未开放创建直播间', 403);
const max = await settings.get<number>('live.maxPerUser', 1); assert(await db.room.count({ where: { ownerId: user.id } }) < max, 'ROOM_LIMIT_REACHED', `每个用户最多可创建 ${max} 个直播间`, 409);
const rawKey = randomToken(32); const room = await db.room.create({ data: { ...input, ownerId: user.id, streamKey: { create: { keyHash: sha256(rawKey), keyCipher: encrypt(rawKey, config.CONFIG_ENCRYPTION_KEY), keyHint: rawKey.slice(-6) } } }, include: roomInclude });
reply.code(201).send({ data: room });
});
app.get('/api/users/me/rooms', { preHandler: authenticate }, async request => ({ data: await db.room.findMany({ where: { ownerId: request.auth!.userId }, include: { ...roomInclude, sessions: { orderBy: { startedAt: 'desc' }, take: 20, select: { id: true, startedAt: true, endedAt: true, durationSeconds: true, peakViewers: true, totalViews: true, recordingUrl: true } } } }) }));
app.get('/api/rooms/:roomNumber/replays', async request => {
const { roomNumber } = z.object({ roomNumber: z.coerce.number().int() }).parse(request.params);
const room = await db.room.findUnique({ where: { roomNumber } }); assert(room, 'ROOM_NOT_FOUND', '直播间不存在', 404);
const sessions = await db.liveSession.findMany({ where: { roomId: room.id, endedAt: { not: null }, recordingUrl: { not: null } }, orderBy: { startedAt: 'desc' }, take: 50, select: { id: true, startedAt: true, endedAt: true, durationSeconds: true, peakViewers: true, totalViews: true, recordingUrl: true } });
return { data: sessions };
});
app.get('/api/replays', async request => {
const q = z.object({ page: z.coerce.number().int().min(1).default(1), limit: z.coerce.number().int().min(1).max(50).default(20) }).parse(request.query);
const where = { endedAt: { not: null }, recordingUrl: { not: null }, room: { visibility: 'PUBLIC' as const } };
const [items, total] = await Promise.all([db.liveSession.findMany({ where, select: { id: true, startedAt: true, endedAt: true, durationSeconds: true, peakViewers: true, totalViews: true, recordingUrl: true, room: { select: { roomNumber: true, title: true, cover: true } } }, orderBy: { startedAt: 'desc' }, skip: (q.page - 1) * q.limit, take: q.limit }), db.liveSession.count({ where })]);
return { data: items, meta: { page: q.page, limit: q.limit, total } };
});
app.post('/api/notices/stream-permission', { preHandler: authenticate }, async (request, reply) => {
const input = z.object({ content: z.string().max(1000).optional() }).parse(request.body);
const user = await db.user.findUniqueOrThrow({ where: { id: request.auth!.userId } });
assert(!user.canStream, 'STREAM_PERMISSION_GRANTED', '您已拥有开播权限');
const pending = await db.notice.findFirst({ where: { fromId: user.id, status: 'PENDING' } });
assert(!pending, 'APPLICATION_PENDING', '已有待审核的申请,请耐心等待');
const notice = await db.notice.create({ data: { fromId: user.id, content: input.content?.trim() || '申请开播权限' } });
reply.code(201).send({ data: notice });
});
app.get('/api/notices/stream-permission', { preHandler: authenticate }, async request => ({ data: await db.notice.findFirst({ where: { fromId: request.auth!.userId }, orderBy: { createdAt: 'desc' } }) }));
app.get('/api/replays/:sessionId/danmaku', async request => {
const { sessionId } = z.object({ sessionId: z.string().uuid() }).parse(request.params);
const session = await db.liveSession.findUnique({ where: { id: sessionId }, select: { id: true, recordingUrl: true } }); assert(session?.recordingUrl, 'REPLAY_NOT_FOUND', '直播回放不存在', 404);
const messages = await db.chatMessage.findMany({ where: { sessionId, deletedAt: null, offsetSeconds: { not: null } }, orderBy: { offsetSeconds: 'asc' }, select: { id: true, nickname: true, avatar: true, content: true, createdAt: true, offsetSeconds: true } });
return { data: messages };
});
app.patch('/api/rooms/:roomNumber', { preHandler: authenticate }, async request => {
const { roomNumber } = z.object({ roomNumber: z.coerce.number().int() }).parse(request.params); const room = await db.room.findUnique({ where: { roomNumber } }); assert(room, 'ROOM_NOT_FOUND', '直播间不存在', 404); assert(room.ownerId === request.auth!.userId || request.auth!.roles.some(r => r !== 'USER'), 'FORBIDDEN', '无权修改此直播间', 403);
return { data: await db.room.update({ where: { id: room.id }, data: roomInput.partial().parse(request.body), include: roomInclude }) };
});
app.get('/api/rooms/:roomNumber/stream', { preHandler: authenticate }, async request => {
const { roomNumber } = z.object({ roomNumber: z.coerce.number().int() }).parse(request.params); const room = await db.room.findUnique({ where: { roomNumber }, include: { streamKey: true } }); assert(room, 'ROOM_NOT_FOUND', '直播间不存在', 404); assert(room.ownerId === request.auth!.userId, 'FORBIDDEN', '只能查看自己的推流信息', 403); assert(room.streamKey, 'STREAM_KEY_MISSING', '推流密钥不存在', 500);
const key = decrypt(room.streamKey.keyCipher, config.CONFIG_ENCRYPTION_KEY); const [protocol, flvHost] = await Promise.all([settings.get<'FLV' | 'HLS'>('live.playback.protocol', 'FLV'), settings.get<string>('live.playback.flvHost', '')]);
const server = config.RTMP_PUBLIC_URL || `rtmp://${request.hostname}:${config.RTMP_PORT}/live`;
return { data: { server, streamKey: `room_${room.roomNumber}?token=${key}`, keyHint: room.streamKey.keyHint, playback: protocol === 'FLV' ? flvUrl(`/live/room_${room.roomNumber}.flv`, flvHost) : `/live/room_${room.roomNumber}.m3u8` } };
});
app.post('/api/rooms/:roomNumber/stream/rotate', { preHandler: authenticate }, async request => {
const { roomNumber } = z.object({ roomNumber: z.coerce.number().int() }).parse(request.params); const room = await db.room.findUnique({ where: { roomNumber }, include: { streamKey: true } }); assert(room && room.streamKey, 'ROOM_NOT_FOUND', '直播间不存在', 404); assert(room.ownerId === request.auth!.userId, 'FORBIDDEN', '只能重置自己的推流密钥', 403);
const raw = randomToken(32); await db.streamKey.update({ where: { roomId: room.id }, data: { keyHash: sha256(raw), keyCipher: encrypt(raw, config.CONFIG_ENCRYPTION_KEY), keyHint: raw.slice(-6), version: { increment: 1 }, rotatedAt: new Date() } });
if (room.streamStatus === 'LIVE') await stopSrsStream(config, `room_${roomNumber}`); return { data: { streamKey: `room_${roomNumber}?token=${raw}` } };
});
app.post('/api/rooms/:roomNumber/viewers/heartbeat', async (request, reply) => {
const { roomNumber } = z.object({ roomNumber: z.coerce.number().int() }).parse(request.params); const room = await db.room.findUnique({ where: { roomNumber } }); assert(room, 'ROOM_NOT_FOUND', '直播间不存在', 404);
let viewer = request.cookies.xlive_viewer; if (!viewer) { viewer = randomToken(18); reply.setCookie('xlive_viewer', viewer, { httpOnly: true, sameSite: 'lax', path: '/', maxAge: 86400 }); }
const key = `viewers:${room.id}`; const now = Date.now(); await redis.zAdd(key, { score: now + 45_000, value: viewer }); await redis.zRemRangeByScore(key, 0, now); await redis.expire(key, 120); const count = await redis.zCard(key);
await db.room.update({ where: { id: room.id }, data: { viewerCount: count } }); const session = await db.liveSession.findFirst({ where: { roomId: room.id, endedAt: null }, orderBy: { startedAt: 'desc' } }); if (session) await db.liveSession.update({ where: { id: session.id }, data: { peakViewers: Math.max(session.peakViewers, count), viewerSeconds: { increment: BigInt(count * 15) }, viewerSamples: { increment: 1 } } });
return { data: { viewerCount: room.showViewerCount ? count : null } };
});
}
export async function stopSrsStream(config: AppConfig, streamName: string) {
const response = await fetch(`${config.SRS_API_URL}/api/v1/streams?count=100`); if (!response.ok) return false;
const body = await response.json() as { streams?: Array<{ name: string; publish?: { cid?: number } }> }; const stream = body.streams?.find(s => s.name === streamName); const cid = stream?.publish?.cid; if (!cid) return false;
const stopped = await fetch(`${config.SRS_API_URL}/api/v1/clients/${cid}`, { method: 'DELETE' }); return stopped.ok;
}
+100
View File
@@ -0,0 +1,100 @@
import type { PrismaClient } from '@prisma/client';
import { decrypt, encrypt } from '../lib/crypto.js';
import type { AppConfig } from '../config.js';
import { defaultPasswordPolicy, type PasswordPolicy } from '../lib/password.js';
export const publicDefaults: Record<string, unknown> = {
'site.name': 'XLive', 'site.subtitle': '看见每一种热爱', 'site.description': '轻量、开放的多用户直播平台',
'site.keywords': '直播,视频,互动', 'site.logo': '', 'site.darkLogo': '', 'site.favicon': '',
'site.footer': '让连接实时发生', 'site.copyright': '© 2026 XLive', 'site.icp.text': '', 'site.icp.url': '',
'site.userAgreement': `欢迎使用 XLive 直播平台!
一、服务说明
XLive 是一个多用户直播与互动平台。您在注册和使用本平台前,请仔细阅读本协议的全部内容。注册成功即视为您已充分理解并同意本协议。
二、账号注册
1. 您需年满 18 周岁,或已获得监护人同意方可注册使用本平台。
2. 注册时请提供真实、准确的信息,并妥善保管账号密码,因保管不善造成的损失由您自行承担。
3. 不得恶意批量注册账号。
三、用户行为规范
1. 禁止发布违反法律法规的内容,包括但不限于:危害国家安全、暴力恐怖、色情低俗、赌博诈骗、侵犯他人隐私与知识产权的内容。
2. 禁止在直播、弹幕与聊天中辱骂、骚扰或人身攻击其他用户。
3. 禁止利用平台漏洞进行攻击、盗取数据、刷量作弊等行为。
四、内容与知识产权
您发布的直播与内容,授权平台在提供服务所需的范围内存储、分发与展示。您保证所发布内容不侵犯任何第三方合法权益。
五、隐私保护
平台将按照相关法律法规保护您的个人信息,未经您同意不向第三方披露,法律法规另有规定的除外。
六、责任与免责
1. 因您的行为导致的后果由您自行承担。
2. 平台有权对违规账号采取警告、禁言、封禁等措施,并配合有关部门调查。
3. 因不可抗力、网络故障等导致服务中断的,平台不承担责任。
七、协议变更
平台有权更新本协议,更新后将公布最新版本,继续使用平台即视为接受新协议。
如有疑问,请联系平台管理员。`,
'site.police.text': '', 'site.police.url': '', 'auth.guestViewing': true,
'auth.register.email': true, 'auth.register.sms': false, 'auth.register.rule': 'ANY', 'auth.register.requireVerification': false,
'password.policy': defaultPasswordPolicy,
'live.allowRegisteredUsers': true, 'live.newUserCanStream': false, 'live.maxConcurrent': 100,
'live.maxPerUser': 1, 'live.maxBitrateKbps': 8000, 'live.maxFps': 60, 'live.codecs': ['H264', 'AAC'], 'live.showPlayerLatency': false,
'live.playback.protocol': 'FLV', 'live.playback.flvHost': '',
'live.transcode.qualities': [
{ label: '2.5K', width: 2560, height: 1440, bitrate: 5000, fps: 30, enabled: true },
{ label: '4K', width: 3840, height: 2160, bitrate: 8000, fps: 30, enabled: true },
{ label: '1080P', width: 1920, height: 1080, bitrate: 3000, fps: 30, enabled: true },
{ label: '720P', width: 1280, height: 720, bitrate: 1500, fps: 30, enabled: true },
{ label: '480P', width: 854, height: 480, bitrate: 800, fps: 25, enabled: true }
],
'security.loginMaxFailures': 5, 'security.loginLockMinutes': 15
};
export class SettingsService {
private cache = new Map<string, unknown>();
private loadedAt = 0;
constructor(private db: PrismaClient, private config: AppConfig) {}
async all(includeSensitive = false) {
const rows = await this.db.systemSetting.findMany({ orderBy: [{ group: 'asc' }, { key: 'asc' }] });
const merged = new Map(Object.entries(publicDefaults));
for (const row of rows) {
if (row.sensitive && !includeSensitive) { merged.set(row.key, row.value ? '********' : ''); continue; }
const raw = row.sensitive && row.value ? decrypt(row.value, this.config.CONFIG_ENCRYPTION_KEY) : row.value;
try { merged.set(row.key, JSON.parse(raw)); } catch { merged.set(row.key, raw); }
}
return Object.fromEntries(merged);
}
async publicSettings() {
const all = await this.all(false);
return Object.fromEntries(Object.entries(all).filter(([key]) => key.startsWith('site.') || ['auth.guestViewing', 'auth.register.email', 'auth.register.sms', 'auth.register.rule', 'password.policy', 'live.showPlayerLatency'].includes(key)));
}
async get<T>(key: string, fallback?: T): Promise<T> {
if (Date.now() - this.loadedAt > 30_000) { this.cache.clear(); this.loadedAt = Date.now(); }
if (this.cache.has(key)) return this.cache.get(key) as T;
const row = await this.db.systemSetting.findUnique({ where: { key } });
let value: unknown = publicDefaults[key] ?? fallback;
if (row) {
const raw = row.sensitive && row.value ? decrypt(row.value, this.config.CONFIG_ENCRYPTION_KEY) : row.value;
try { value = JSON.parse(raw); } catch { value = raw; }
}
this.cache.set(key, value); return value as T;
}
passwordPolicy() { return this.get<PasswordPolicy>('password.policy', defaultPasswordPolicy); }
async setMany(values: Record<string, unknown>, updatedBy: string, sensitiveKeys: string[] = []) {
for (const [key, value] of Object.entries(values)) {
const sensitive = sensitiveKeys.includes(key) || ['smtp.password', 'sms.accessKeySecret'].includes(key);
if (sensitive && (value === '' || value === '********')) continue;
const raw = typeof value === 'string' ? value : JSON.stringify(value);
await this.db.systemSetting.upsert({ where: { key }, update: { value: sensitive ? encrypt(raw, this.config.CONFIG_ENCRYPTION_KEY) : raw, sensitive, updatedBy }, create: { key, value: sensitive ? encrypt(raw, this.config.CONFIG_ENCRYPTION_KEY) : raw, group: key.split('.')[0]!, sensitive, updatedBy } });
}
this.cache.clear();
}
}
@@ -0,0 +1,50 @@
import { spawn, type ChildProcess } from 'node:child_process';
import type { SettingsService } from './settings.service.js';
export type QualitySetting = { label: string; width: number; height: number; bitrate: number; fps: number; enabled?: boolean };
export const qualitySlug = (label: string) => label.replace(/[^A-Za-z0-9]/g, '');
export class TranscoderService {
private procs = new Map<string, ChildProcess[]>();
private probes = new Map<string, { width: number; height: number }>();
constructor(private settings: SettingsService) {}
probeOf(stream: string) { return this.probes.get(stream); }
async onPublish(stream: string) {
this.onUnpublish(stream);
const qualities = (await this.settings.get<QualitySetting[]>('live.transcode.qualities', [])).filter(q => q.enabled !== false && q.width > 0 && q.height > 0 && q.bitrate > 0 && q.fps > 0);
if (!qualities.length) return;
const src = await this.probe(stream);
if (!src) return;
const targets = qualities.filter(q => q.width < src.width && q.height < src.height);
if (!targets.length) return;
const procs = targets.map(q => {
const proc = spawn('ffmpeg', ['-hide_banner', '-loglevel', 'error', '-i', `rtmp://srs:1935/live/${stream}`, '-c:v', 'libx264', '-preset', 'ultrafast', '-tune', 'zerolatency', '-b:v', `${q.bitrate}k`, '-maxrate', `${Math.round(q.bitrate * 1.2)}k`, '-bufsize', `${q.bitrate * 2}k`, '-vf', `scale=${q.width}:${q.height}`, '-r', String(q.fps), '-g', String(q.fps * 2), '-sc_threshold', '0', '-c:a', 'aac', '-b:a', '128k', '-ar', '48000', '-ac', '2', '-f', 'flv', `rtmp://srs2:1936/live/${stream}_${qualitySlug(q.label)}`], { stdio: 'ignore' });
proc.on('error', () => {}); proc.on('exit', () => { this.procs.set(stream, (this.procs.get(stream) ?? []).filter(p => p !== proc)); });
return proc;
});
this.procs.set(stream, procs);
}
onUnpublish(stream: string) {
const procs = this.procs.get(stream) ?? []; this.procs.delete(stream);
for (const proc of procs) proc.kill('SIGKILL');
}
private probe(stream: string): Promise<{ width: number; height: number } | null> {
return new Promise(resolve => {
const proc = spawn('ffprobe', ['-v', 'error', '-analyzeduration', '3M', '-probesize', '3M', '-select_streams', 'v:0', '-show_entries', 'stream=width,height', '-of', 'csv=p=0', `rtmp://srs:1935/live/${stream}`], { stdio: ['ignore', 'pipe', 'ignore'] });
let out = ''; const timer = setTimeout(() => proc.kill('SIGKILL'), 10_000);
proc.stdout.on('data', (chunk: Buffer) => { out += chunk.toString(); });
proc.on('error', () => { clearTimeout(timer); resolve(null); });
proc.on('exit', () => {
clearTimeout(timer);
const match = /(\d+),(\d+)/.exec(out);
const info = match ? { width: Number(match[1]), height: Number(match[2]) } : null;
if (info) this.probes.set(stream, info);
resolve(info);
});
});
}
}
+28
View File
@@ -0,0 +1,28 @@
import type { FastifyInstance } from 'fastify';
import type { PrismaClient } from '@prisma/client';
import { mkdir, writeFile } from 'node:fs/promises';
import { join } from 'node:path';
import type { AppConfig } from '../config.js';
import { authenticate } from '../lib/auth.js';
import { AppError } from '../lib/errors.js';
import { randomToken } from '../lib/crypto.js';
function detectedExtension(buffer: Buffer): 'jpg' | 'png' | 'webp' | null {
if (buffer.length > 3 && buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) return 'jpg';
if (buffer.length > 8 && buffer.subarray(0, 8).equals(Buffer.from([137,80,78,71,13,10,26,10]))) return 'png';
if (buffer.length > 12 && buffer.toString('ascii',0,4)==='RIFF' && buffer.toString('ascii',8,12)==='WEBP') return 'webp';
return null;
}
export async function uploadRoutes(app: FastifyInstance, deps: { db: PrismaClient; config: AppConfig }) {
const { db, config } = deps;
app.post('/api/uploads/images', { preHandler: authenticate }, async request => {
const file = await request.file({ limits: { fileSize: 5 * 1024 * 1024, files: 1 } });
if (!file) throw new AppError('FILE_REQUIRED', '请选择图片文件');
const buffer = await file.toBuffer(); const extension = detectedExtension(buffer);
if (!extension || !['image/jpeg','image/png','image/webp'].includes(file.mimetype)) throw new AppError('INVALID_IMAGE', '仅支持 JPG、PNG、WebP 图片');
await mkdir(config.UPLOAD_DIR, { recursive: true }); const name = `${randomToken(20)}.${extension}`; await writeFile(join(config.UPLOAD_DIR, name), buffer, { flag: 'wx' });
const upload = await db.upload.create({ data: { filename: name, originalName: file.filename?.slice(0, 255), mimeType: file.mimetype, size: buffer.length, uploaderId: request.auth!.userId, url: `/uploads/${name}` } });
return { data: { id: upload.id, url: upload.url } };
});
}
@@ -0,0 +1,58 @@
import type { PrismaClient, CodeChannel, CodePurpose } from '@prisma/client';
import type { RedisLike } from '../lib/redis.js';
import { randomCode, randomToken, sha256, safeEqual } from '../lib/crypto.js';
import { AppError, assert } from '../lib/errors.js';
import type { MessagingService } from './messaging.service.js';
// 图形验证码:本地生成 SVG 图片(英文字母),答案哈希后存入 Redis,一次性使用
const CAPTCHA_LETTERS = 'ABCDEFGHJKLMNPQRSTUVWXYZ';
const captchaKey = (id: string, text: string) => `captcha:${sha256(`${id}:${text}`)}`;
function renderCaptchaSvg(text: string) {
const colors = ['#c0392b', '#1f618d', '#1e8449', '#6c3483', '#b9770e', '#21618c'];
const chars = text.split('').map((ch, i) => {
const x = 16 + i * 24, y = 28 + Math.floor(Math.random() * 6 - 3), rotate = Math.floor(Math.random() * 36 - 18), size = 24 + Math.floor(Math.random() * 8);
return `<text x="${x}" y="${y}" font-size="${size}" font-weight="bold" font-family="Arial,Helvetica,sans-serif" fill="${colors[Math.floor(Math.random() * colors.length)]}" transform="rotate(${rotate} ${x} ${y})">${ch}</text>`;
}).join('');
const noise = Array.from({ length: 5 }, () => `<line x1="${Math.floor(Math.random() * 120)}" y1="${Math.floor(Math.random() * 44)}" x2="${Math.floor(Math.random() * 120)}" y2="${Math.floor(Math.random() * 44)}" stroke="#9aa5b1" stroke-width="1"/>`).join('');
const dots = Array.from({ length: 40 }, () => `<circle cx="${Math.floor(Math.random() * 120)}" cy="${Math.floor(Math.random() * 44)}" r="1" fill="#9aa5b1"/>`).join('');
return `<svg xmlns="http://www.w3.org/2000/svg" width="120" height="44" viewBox="0 0 120 44"><rect width="120" height="44" fill="#eef1f5"/>${noise}${dots}${chars}</svg>`;
}
export class VerificationService {
constructor(private db: PrismaClient, private redis: RedisLike, private messaging: MessagingService) {}
async send(channel: CodeChannel, target: string, purpose: CodePurpose, ip: string) {
const normalized = target.trim().toLowerCase(); const targetHash = sha256(normalized);
const cooldown = `verify:cooldown:${channel}:${targetHash}`; const ipRate = `verify:ip:${ip}`;
assert(!(await this.redis.exists(cooldown)), 'CODE_TOO_FREQUENT', '请在 60 秒后重试', 429);
const count = await this.redis.incr(ipRate); if (count === 1) await this.redis.expire(ipRate, 3600);
assert(count <= 20, 'IP_RATE_LIMITED', '此 IP 发送过于频繁,请稍后重试', 429);
const code = randomCode();
await this.db.verificationCode.create({ data: { channel, targetHash, codeHash: sha256(`${targetHash}:${code}`), purpose, expiresAt: new Date(Date.now() + 5 * 60_000), ip } });
if (channel === 'EMAIL') await this.messaging.sendEmail(normalized, 'XLive 验证码', `您的验证码为 ${code},5 分钟内有效。请勿将验证码告知他人。`);
else await this.messaging.sendSmsForPurpose(normalized, purpose, code);
await this.redis.set(cooldown, '1', { EX: 60 });
return { expiresIn: 300, retryAfter: 60 };
}
async createCaptcha() {
const id = randomToken(12);
const text = Array.from({ length: 4 }, () => CAPTCHA_LETTERS[Math.floor(Math.random() * CAPTCHA_LETTERS.length)]).join('');
await this.redis.set(captchaKey(id, text), '1', { EX: 300 });
return { captchaId: id, image: `data:image/svg+xml;base64,${Buffer.from(renderCaptchaSvg(text)).toString('base64')}` };
}
async requireCaptcha(captchaId: string, captchaText: string) {
const key = captchaKey(captchaId, captchaText.trim().toUpperCase());
assert(await this.redis.exists(key), 'CAPTCHA_INVALID', '图形验证码不正确或已过期,请重新输入');
await this.redis.expire(key, 1); // 一次性使用,立即失效
}
async verify(channel: CodeChannel, target: string, purpose: CodePurpose, code: string) {
const targetHash = sha256(target.trim().toLowerCase());
const record = await this.db.verificationCode.findFirst({ where: { channel, targetHash, purpose, usedAt: null, expiresAt: { gt: new Date() }, attempts: { lt: 5 } }, orderBy: { createdAt: 'desc' } });
if (!record) throw new AppError('CODE_INVALID_OR_EXPIRED', '验证码无效或已过期');
const valid = safeEqual(record.codeHash, sha256(`${targetHash}:${code}`));
await this.db.verificationCode.update({ where: { id: record.id }, data: valid ? { usedAt: new Date() } : { attempts: { increment: 1 } } });
if (!valid) throw new AppError('CODE_INVALID', '验证码不正确');
}
}
+12
View File
@@ -0,0 +1,12 @@
import { PrismaClient } from '@prisma/client';
import { hashPassword } from './lib/password.js';
const db = new PrismaClient();
for (const role of ['USER', 'ADMIN', 'SUPER_ADMIN'] as const) await db.role.upsert({ where: { name: role }, update: {}, create: { name: role, description: role } });
const categories = [['游戏', 'games', 'game-controller'], ['聊天', 'chat', 'chatbubbles'], ['音乐', 'music', 'musical-notes'], ['学习', 'study', 'book'], ['户外', 'outdoors', 'bicycle'], ['体育', 'sports', 'football'], ['其他', 'other', 'apps']] as const;
for (const [name, slug, icon] of categories) await db.category.upsert({ where: { slug }, update: {}, create: { name, slug, icon } });
const username = process.env.ADMIN_USERNAME ?? 'admin'; const email = process.env.ADMIN_EMAIL ?? 'admin@example.com'; const password = process.env.ADMIN_PASSWORD;
if (!password) throw new Error('ADMIN_PASSWORD is required for first startup');
const existing = await db.user.findFirst({ where: { OR: [{ username }, { email }] } });
if (!existing) await db.user.create({ data: { username, nickname: '超级管理员', email, passwordHash: await hashPassword(password), roles: { create: { role: { connect: { name: 'SUPER_ADMIN' } } } } } });
await db.$disconnect();
+9
View File
@@ -0,0 +1,9 @@
import { loadConfig } from './config.js';
import { prisma } from './lib/db.js';
import { buildApp } from './app.js';
const config = loadConfig();
const app = await buildApp(config, prisma);
const stop = async () => { await app.close(); await prisma.$disconnect(); process.exit(0); };
process.on('SIGINT', stop); process.on('SIGTERM', stop);
await app.listen({ host: '0.0.0.0', port: config.APP_PORT });
+7
View File
@@ -0,0 +1,7 @@
import type { RoleName } from '@prisma/client';
declare module 'fastify' {
interface FastifyRequest {
auth?: { userId: string; roles: RoleName[] };
}
}
+16
View File
@@ -0,0 +1,16 @@
{
"compilerOptions": {
"target": "ES2023",
"module": "NodeNext",
"moduleResolution": "NodeNext",
"outDir": "dist",
"rootDir": "src",
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"noUncheckedIndexedAccess": true,
"resolveJsonModule": true
},
"include": ["src/**/*.ts"],
"exclude": ["src/**/*.test.ts"]
}