- {favorites.map((item) => (
+ {renderableFavorites.map((item) => (
- {history.length === 0 ? (
+ {renderableHistory.length === 0 ? (
) : (
- {history.map((item) => (
+ {renderableHistory.map((item) => (
0) {
- historyStore.getState().importHistory(result.data.history);
+ const history = keepRenderableHistory(result.data.history);
+ const favorites = keepRenderableFavorites(result.data.favorites);
+
+ if (history.length > 0) {
+ historyStore.getState().importHistory(history);
}
- if (result.data.favorites?.length > 0) {
- favoritesStore.getState().importFavorites(result.data.favorites);
+ if (favorites.length > 0) {
+ favoritesStore.getState().importFavorites(favorites);
}
}
} catch (error) {
diff --git a/lib/server/auth.ts b/lib/server/auth.ts
index 375af6a..d2611da 100644
--- a/lib/server/auth.ts
+++ b/lib/server/auth.ts
@@ -1,6 +1,6 @@
-import { Redis } from '@upstash/redis/cloudflare';
-import { getOptionalRequestContext } from '@cloudflare/next-on-pages';
import { NextRequest, NextResponse } from 'next/server';
+import { getRedisClient } from '@/lib/server/redis';
+import { getRuntimeEnvValue } from '@/lib/server/runtime-env';
import { getRuntimeFeatures } from '@/lib/server/runtime-features';
import {
createStoredAccount,
@@ -87,25 +87,11 @@ const DANMAKU_API_URL = process.env.DANMAKU_API_URL || process.env.NEXT_PUBLIC_D
const SESSION_MAX_AGE_SECONDS = 60 * 60 * 24 * 30;
const MANAGED_AUTH_FORCED = process.env.MANAGED_AUTH_ENABLED === 'true';
-function getRuntimeEnvValue(name: string, fallback = ''): string {
- try {
- const runtimeEnv = getOptionalRequestContext()?.env as unknown as Record | undefined;
- const value = runtimeEnv?.[name];
- if (typeof value === 'string') return value;
- } catch {
- // Outside Cloudflare's request runtime, fall back to process.env.
- }
-
- return process.env[name] || fallback;
-}
-
function getEffectiveAdminPassword(): string {
return getRuntimeEnvValue('ADMIN_PASSWORD', ADMIN_PASSWORD) ||
getRuntimeEnvValue('ACCESS_PASSWORD', ACCESS_PASSWORD);
}
-let cachedRedis: Redis | null | undefined;
-
export class ManagedAuthStorageError extends Error {
constructor(operation: 'read' | 'write', cause?: unknown) {
super(`Managed auth storage ${operation} failed`, { cause });
@@ -113,25 +99,6 @@ export class ManagedAuthStorageError extends Error {
}
}
-function getRedisClient(): Redis | null {
- if (cachedRedis !== undefined) {
- return cachedRedis;
- }
-
- const url = getRuntimeEnvValue('UPSTASH_REDIS_REST_URL');
- const token = getRuntimeEnvValue('UPSTASH_REDIS_REST_TOKEN');
- if (!url || !token) {
- cachedRedis = null;
- return cachedRedis;
- }
-
- cachedRedis = new Redis({
- url,
- token,
- });
- return cachedRedis;
-}
-
function isManagedAuthEnabled(): boolean {
return !!getRuntimeEnvValue('AUTH_SECRET', AUTH_SECRET) && !!getRedisClient();
}
diff --git a/lib/server/douban-image.ts b/lib/server/douban-image.ts
new file mode 100644
index 0000000..8367ac5
--- /dev/null
+++ b/lib/server/douban-image.ts
@@ -0,0 +1,30 @@
+// Douban's imgN.doubanio.com hosts mirror the same paths but use different
+// network routes. Some routes are unreachable from overseas deployments, so a
+// failed request can retry the same path through known reachable mirrors.
+const DOUBAN_IMAGE_HOSTS = [
+ 'img9.doubanio.com',
+ 'img3.doubanio.com',
+ 'img2.doubanio.com',
+];
+
+export function buildDoubanImageCandidates(rawUrl: string): string[] {
+ const candidates = [rawUrl];
+
+ try {
+ const parsed = new URL(rawUrl);
+ if (!/^img\d+\.doubanio\.com$/.test(parsed.hostname)) {
+ return candidates;
+ }
+
+ for (const host of DOUBAN_IMAGE_HOSTS) {
+ if (host === parsed.hostname) continue;
+ const alternate = new URL(parsed.toString());
+ alternate.hostname = host;
+ candidates.push(alternate.toString());
+ }
+ } catch {
+ // Leave malformed URLs to fetch so the route returns its normal proxy error.
+ }
+
+ return candidates;
+}
diff --git a/lib/server/redis.ts b/lib/server/redis.ts
new file mode 100644
index 0000000..3379610
--- /dev/null
+++ b/lib/server/redis.ts
@@ -0,0 +1,35 @@
+import { Redis } from '@upstash/redis/cloudflare';
+
+import { getRuntimeEnvValue } from '@/lib/server/runtime-env';
+
+let cachedRedis: Redis | undefined;
+
+/**
+ * Build the shared Upstash client from whichever environment source is available.
+ *
+ * `Redis.fromEnv()` is deliberately not used here: the `@upstash/redis/cloudflare`
+ * implementation only reads Cloudflare's global bindings and never falls back to
+ * `process.env`, so it always resolves to `undefined` on Docker / Node
+ * self-hosted deployments. The client is also created lazily because Cloudflare's
+ * per-request bindings are not reachable while a module is being evaluated.
+ *
+ * Returns `null` when Upstash is not configured, which callers should treat as
+ * "server-side sync unavailable" rather than as a request failure.
+ */
+export function getRedisClient(): Redis | null {
+ if (cachedRedis) {
+ return cachedRedis;
+ }
+
+ const url = getRuntimeEnvValue('UPSTASH_REDIS_REST_URL');
+ const token = getRuntimeEnvValue('UPSTASH_REDIS_REST_TOKEN');
+ if (!url || !token) {
+ return null;
+ }
+
+ cachedRedis = new Redis({
+ url,
+ token,
+ });
+ return cachedRedis;
+}
diff --git a/lib/server/runtime-env.ts b/lib/server/runtime-env.ts
new file mode 100644
index 0000000..84da27c
--- /dev/null
+++ b/lib/server/runtime-env.ts
@@ -0,0 +1,20 @@
+import { getOptionalRequestContext } from '@cloudflare/next-on-pages';
+
+/**
+ * Read an environment value that may live in either runtime environment.
+ *
+ * On Cloudflare, bindings and secrets are only reachable through the
+ * per-request context. On Docker / Node self-hosting there is no such context,
+ * so the value comes from `process.env`.
+ */
+export function getRuntimeEnvValue(name: string, fallback = ''): string {
+ try {
+ const runtimeEnv = getOptionalRequestContext()?.env as unknown as Record | undefined;
+ const value = runtimeEnv?.[name];
+ if (typeof value === 'string') return value;
+ } catch {
+ // Outside Cloudflare's request runtime, fall back to process.env.
+ }
+
+ return typeof process !== 'undefined' ? process.env[name] || fallback : fallback;
+}
diff --git a/lib/utils/sync-records.ts b/lib/utils/sync-records.ts
new file mode 100644
index 0000000..c260a9f
--- /dev/null
+++ b/lib/utils/sync-records.ts
@@ -0,0 +1,38 @@
+import type { FavoriteItem, VideoHistoryItem } from '@/lib/types';
+
+function hasIdentity(value: unknown): boolean {
+ if (!value || typeof value !== 'object') return false;
+ const record = value as { videoId?: unknown; source?: unknown; title?: unknown };
+ const videoId = record.videoId;
+ const hasVideoId = typeof videoId === 'string'
+ ? videoId.trim().length > 0
+ : typeof videoId === 'number' && Number.isFinite(videoId);
+
+ return hasVideoId &&
+ typeof record.source === 'string' && record.source.trim().length > 0 &&
+ typeof record.title === 'string' && record.title.trim().length > 0;
+}
+
+/**
+ * Records restored from server-side sync are not guaranteed to be well formed —
+ * they may come from an older schema or a partial write. Rendering one without
+ * `videoId` or `episodeIndex` throws while building the player URL, which takes
+ * down the whole page, so anything lacking the required URL fields is dropped.
+ */
+export function isRenderableHistoryItem(value: unknown): value is VideoHistoryItem {
+ if (!hasIdentity(value)) return false;
+ const episodeIndex = (value as { episodeIndex?: unknown }).episodeIndex;
+ return typeof episodeIndex === 'number' && Number.isInteger(episodeIndex) && episodeIndex >= 0;
+}
+
+export function isRenderableFavoriteItem(value: unknown): value is FavoriteItem {
+ return hasIdentity(value);
+}
+
+export function keepRenderableHistory(items: unknown): VideoHistoryItem[] {
+ return Array.isArray(items) ? items.filter(isRenderableHistoryItem) : [];
+}
+
+export function keepRenderableFavorites(items: unknown): FavoriteItem[] {
+ return Array.isArray(items) ? items.filter(isRenderableFavoriteItem) : [];
+}
diff --git a/package-lock.json b/package-lock.json
index 174dc86..0d3f2fb 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "kvideo",
- "version": "4.9.18",
+ "version": "4.9.19",
"lockfileVersion": 2,
"requires": true,
"packages": {
"": {
"name": "kvideo",
- "version": "4.9.18",
+ "version": "4.9.19",
"dependencies": {
"@dnd-kit/core": "^6.3.1",
"@dnd-kit/sortable": "^10.0.0",
diff --git a/package.json b/package.json
index 6f7b193..be2e709 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
{
"name": "kvideo",
- "version": "4.9.18",
+ "version": "4.9.19",
"private": true,
"scripts": {
"dev": "node scripts/next-with-lan-access.mjs dev",
diff --git a/tests/douban-image-fallback.test.ts b/tests/douban-image-fallback.test.ts
new file mode 100644
index 0000000..c15f121
--- /dev/null
+++ b/tests/douban-image-fallback.test.ts
@@ -0,0 +1,54 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { GET } from '@/app/api/douban/image/route';
+import { buildDoubanImageCandidates } from '@/lib/server/douban-image';
+
+test('Douban image candidates preserve the path and try reachable mirrors', () => {
+ const candidates = buildDoubanImageCandidates(
+ 'https://img1.doubanio.com/view/photo/s_ratio_poster/public/p123.webp?x=1',
+ );
+
+ assert.deepEqual(candidates, [
+ 'https://img1.doubanio.com/view/photo/s_ratio_poster/public/p123.webp?x=1',
+ 'https://img9.doubanio.com/view/photo/s_ratio_poster/public/p123.webp?x=1',
+ 'https://img3.doubanio.com/view/photo/s_ratio_poster/public/p123.webp?x=1',
+ 'https://img2.doubanio.com/view/photo/s_ratio_poster/public/p123.webp?x=1',
+ ]);
+});
+
+test('non-Douban and malformed URLs are attempted only once', () => {
+ assert.deepEqual(buildDoubanImageCandidates('https://example.com/poster.jpg'), [
+ 'https://example.com/poster.jpg',
+ ]);
+ assert.deepEqual(buildDoubanImageCandidates('not a url'), ['not a url']);
+});
+
+test('image proxy falls back after a mirror network failure', async (context) => {
+ const requested: string[] = [];
+
+ context.mock.method(globalThis, 'fetch', async (input: string | URL | Request) => {
+ const url = input.toString();
+ requested.push(url);
+
+ if (url.includes('img1.doubanio.com')) {
+ throw new TypeError('fetch failed');
+ }
+
+ return new Response('image-bytes', {
+ status: 200,
+ headers: { 'content-type': 'image/webp' },
+ });
+ });
+
+ const target = encodeURIComponent('https://img1.doubanio.com/poster.webp');
+ const response = await GET(new Request(`https://kvideo.test/api/douban/image?url=${target}`));
+
+ assert.equal(response.status, 200);
+ assert.equal(response.headers.get('content-type'), 'image/webp');
+ assert.equal(await response.text(), 'image-bytes');
+ assert.deepEqual(requested, [
+ 'https://img1.doubanio.com/poster.webp',
+ 'https://img9.doubanio.com/poster.webp',
+ ]);
+});
diff --git a/tests/sync-records.test.ts b/tests/sync-records.test.ts
new file mode 100644
index 0000000..963f7ec
--- /dev/null
+++ b/tests/sync-records.test.ts
@@ -0,0 +1,41 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+ keepRenderableFavorites,
+ keepRenderableHistory,
+} from '@/lib/utils/sync-records';
+
+const validIdentity = {
+ videoId: 'video-1',
+ source: 'source-a',
+ title: 'Example',
+};
+
+test('sync record filters reject malformed identities', () => {
+ assert.deepEqual(keepRenderableFavorites([
+ validIdentity,
+ { ...validIdentity, videoId: undefined },
+ { ...validIdentity, videoId: Number.NaN },
+ { ...validIdentity, source: '' },
+ { ...validIdentity, title: ' ' },
+ null,
+ ]), [validIdentity]);
+});
+
+test('history records require a usable episode index', () => {
+ const validHistory = { ...validIdentity, episodeIndex: 0 };
+
+ assert.deepEqual(keepRenderableHistory([
+ validHistory,
+ { ...validIdentity },
+ { ...validIdentity, episodeIndex: -1 },
+ { ...validIdentity, episodeIndex: 1.5 },
+ { ...validIdentity, episodeIndex: '0' },
+ ]), [validHistory]);
+});
+
+test('sync record filters tolerate non-array payloads', () => {
+ assert.deepEqual(keepRenderableHistory({ history: [] }), []);
+ assert.deepEqual(keepRenderableFavorites(undefined), []);
+});