Skip to content

Self-hosted personal gallery application with online photo management and albums, supporting Live/Motion Photos, EXIF parsing, geolocation recognition, and an explore map.

refactor(albums): centralize slug URL contracts and cover redirects

Ahmet Ömera07221ee267b
diff --git a/.github/workflows/workspace-checks.yml b/.github/workflows/workspace-checks.yml
index 1c52fa11..89da2366 100644
--- a/.github/workflows/workspace-checks.yml
+++ b/.github/workflows/workspace-checks.yml
@@ -35,6 +35,7 @@ jobs:
- run: pnpm test
- run: pnpm build:deps
- run: pnpm build
+ - run: pnpm test:album-http
edge:
env:
diff --git a/apps/self-hosted/server/api/albums/[albumId]/index.put.ts b/apps/self-hosted/server/api/albums/[albumId]/index.put.ts
index 4ccc7c88..39de4841 100644
--- a/apps/self-hosted/server/api/albums/[albumId]/index.put.ts
+++ b/apps/self-hosted/server/api/albums/[albumId]/index.put.ts
@@ -1,4 +1,5 @@
import { requireAdminSession } from '../../../utils/require-admin.ts'
+import { ALBUM_SLUG_MAX_LENGTH } from '@chronoframe/contracts/album-slug'
import { z } from 'zod'
import {
ALBUM_PASSWORD_MAX_LENGTH,
@@ -25,7 +26,7 @@ export default eventHandler(async (event) => {
event,
z.object({
title: z.string().min(1).max(255).optional(),
- slug: z.string().max(80).optional(),
+ slug: z.string().trim().max(ALBUM_SLUG_MAX_LENGTH).optional(),
description: z.string().max(1000).optional(),
coverPhotoId: z.string().optional(),
photoIds: z.array(z.string()).optional(),
diff --git a/apps/self-hosted/server/api/albums/index.post.ts b/apps/self-hosted/server/api/albums/index.post.ts
index 49819ad9..b3272065 100644
--- a/apps/self-hosted/server/api/albums/index.post.ts
+++ b/apps/self-hosted/server/api/albums/index.post.ts
@@ -1,4 +1,5 @@
import { requireAdminSession } from '../../utils/require-admin.ts'
+import { ALBUM_SLUG_MAX_LENGTH } from '@chronoframe/contracts/album-slug'
import z from 'zod'
import {
ALBUM_PASSWORD_MAX_LENGTH,
@@ -12,7 +13,7 @@ export default eventHandler(async (event) => {
event,
z.object({
title: z.string().min(1).max(255),
- slug: z.string().max(80).optional(),
+ slug: z.string().trim().max(ALBUM_SLUG_MAX_LENGTH).optional(),
description: z.string().max(1000).optional(),
coverPhotoId: z.string().optional(),
photoIds: z.array(z.string()).optional(),
diff --git a/apps/self-hosted/server/api/albums/resolve/[slug].get.ts b/apps/self-hosted/server/api/albums/resolve/[slug].get.ts
index 2a1a819e..05a82816 100644
--- a/apps/self-hosted/server/api/albums/resolve/[slug].get.ts
+++ b/apps/self-hosted/server/api/albums/resolve/[slug].get.ts
@@ -1,4 +1,5 @@
import { DEFAULT_SITE } from '@chronoframe/core'
+import type { AlbumPathResolution } from '@chronoframe/contracts/album-slug'
import { resolveAlbumPath } from '@chronoframe/database/album-slugs'
import { albumAccess } from '../../../utils/album-access'
import { useDB } from '../../../utils/db'
@@ -9,5 +10,6 @@ export default eventHandler(async (event) => {
const access = await albumAccess(event)
if (!resolved || (resolved.isHidden && !access.admin))
throw createError({ statusCode: 404, statusMessage: 'Album not found' })
- return resolved
+ const response: AlbumPathResolution = resolved
+ return response
})
diff --git a/package.json b/package.json
index ffdf95f7..c3664d6a 100644
--- a/package.json
+++ b/package.json
@@ -35,6 +35,7 @@
"docs:preview": "vitepress preview docs",
"check:packages": "node scripts/check-ui-boundaries.mjs && node scripts/check-package-boundaries.mjs && pnpm --filter @chronoframe/worker --filter @chronoframe/jobs --filter @chronoframe/processing --filter @chronoframe/database --filter @chronoframe/platform --filter @chronoframe/core --filter @chronoframe/contracts --filter @chronoframe/storage --filter @chronoframe/media --filter @chronoframe/geocoding type-check",
"test": "node --experimental-strip-types --test tests/*.test.ts packages/gallery/app/utils/*.test.ts",
+ "test:album-http": "node --experimental-strip-types --test tests/integration/album-slug-http.test.ts",
"check:ui": "node scripts/check-ui-boundaries.mjs",
"prepare": "node scripts/self-hosted.mjs prepare",
"dev:cloud": "node scripts/saas-entry.mjs cloud dev",
diff --git a/packages/contracts/src/album-slug.ts b/packages/contracts/src/album-slug.ts
index f19bdcc6..d69fe0d0 100644
--- a/packages/contracts/src/album-slug.ts
+++ b/packages/contracts/src/album-slug.ts
@@ -1,5 +1,12 @@
export const ALBUM_SLUG_MAX_LENGTH = 80
+export interface AlbumPathResolution {
+ albumId: number
+ slug: string
+ isCanonical: boolean
+ isHidden: boolean
+}
+
const albumSlugPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
const numericAlbumPathPattern = /^\d+$/
diff --git a/packages/core/src/mutations.ts b/packages/core/src/mutations.ts
index 89360cc5..5bca1cf0 100644
--- a/packages/core/src/mutations.ts
+++ b/packages/core/src/mutations.ts
@@ -20,7 +20,6 @@ export interface AlbumInput {
}
export interface AlbumWriteData {
title?: string
- slug?: string
description?: string | null
coverPhotoId?: string | null
isHidden?: boolean
@@ -34,11 +33,13 @@ export interface AlbumWriteRepository {
createFirst(
data: AlbumWriteData & { title: string },
photoIds: string[],
+ requestedSlug?: string,
): Promise<Album>
update(
id: number,
data: AlbumWriteData,
photoIds?: string[],
+ requestedSlug?: string,
): Promise<Album | null>
delete(id: number): Promise<boolean>
reorder(ids: number[]): Promise<void>
@@ -70,7 +71,6 @@ export function createAlbumWriter(deps: {
return deps.repository.createFirst(
{
title: input.title,
- slug: input.slug ?? '',
description: input.description || null,
coverPhotoId: input.coverPhotoId || null,
isHidden: input.isHidden || false,
@@ -79,6 +79,7 @@ export function createAlbumWriter(deps: {
: null,
},
albumPhotoIds(input),
+ input.slug ?? '',
)
},
async update(id: number, input: AlbumInput, access: MutationAccess) {
@@ -87,7 +88,6 @@ export function createAlbumWriter(deps: {
throw new CoreError(404, 'Album not found')
const data: AlbumWriteData = { updatedAt: deps.clock.now() }
if (input.title !== undefined) data.title = input.title
- if (input.slug !== undefined) data.slug = input.slug
if (input.description !== undefined)
data.description = input.description || null
if (input.coverPhotoId !== undefined)
@@ -101,6 +101,7 @@ export function createAlbumWriter(deps: {
id,
data,
input.photoIds === undefined ? undefined : albumPhotoIds(input),
+ input.slug,
)
if (!album) throw new CoreError(404, 'Album not found')
return album
diff --git a/packages/database/src/album-slugs.ts b/packages/database/src/album-slugs.ts
index 588fe929..8d9cf261 100644
--- a/packages/database/src/album-slugs.ts
+++ b/packages/database/src/album-slugs.ts
@@ -4,6 +4,7 @@ import {
isNumericAlbumPathSegment,
isValidAlbumSlug,
} from '@chronoframe/contracts/album-slug'
+import type { AlbumPathResolution } from '@chronoframe/contracts/album-slug'
import { and, asc, eq, isNull } from 'drizzle-orm'
import { alias } from 'drizzle-orm/sqlite-core'
import { type AppDatabase } from './connection.ts'
@@ -151,7 +152,7 @@ export function resolveAlbumPath(
db: AppDatabase,
site: SiteContext,
segment: string,
-) {
+): AlbumPathResolution | null {
if (segment.length > ALBUM_SLUG_MAX_LENGTH) return null
const numeric = isNumericAlbumPathSegment(segment)
if (!numeric && !isValidAlbumSlug(segment)) return null
diff --git a/packages/database/src/sqlite-mutations.ts b/packages/database/src/sqlite-mutations.ts
index 73080ecd..f23bf023 100644
--- a/packages/database/src/sqlite-mutations.ts
+++ b/packages/database/src/sqlite-mutations.ts
@@ -33,10 +33,9 @@ export function createSqliteAlbumWriteRepository(
.get(),
)
},
- async createFirst(data, photoIds) {
+ async createFirst(data, photoIds, requestedSlug = '') {
return db.transaction(
(tx) => {
- const { slug: requestedSlug = '', ...albumData } = data
const row = tx
.select({ min: min(tables.albums.position) })
.from(tables.albums)
@@ -45,7 +44,7 @@ export function createSqliteAlbumWriteRepository(
const album = tx
.insert(tables.albums)
.values({
- ...albumData,
+ ...data,
siteId: site.id,
position: (row?.min ?? 1000) - 1000,
})
@@ -64,7 +63,7 @@ export function createSqliteAlbumWriteRepository(
{ behavior: 'immediate' },
)
},
- async update(id, data, photoIds) {
+ async update(id, data, photoIds, requestedSlug) {
return db.transaction(
(tx) => {
const exists = tx
@@ -78,10 +77,9 @@ export function createSqliteAlbumWriteRepository(
)
.get()
if (!exists) return null
- const { slug: requestedSlug, ...albumData } = data
- if (Object.keys(albumData).length) {
+ if (Object.keys(data).length) {
tx.update(tables.albums)
- .set(albumData)
+ .set(data)
.where(
siteAnd(
eq(tables.albums.id, id),
diff --git a/packages/gallery/app/components/album/Listing.vue b/packages/gallery/app/components/album/Listing.vue
index e22ad965..6c96a6e4 100644
--- a/packages/gallery/app/components/album/Listing.vue
+++ b/packages/gallery/app/components/album/Listing.vue
@@ -13,6 +13,7 @@ const appSlogan = useSettingRef('app:slogan')
const { homeView, photoWallPath } = useHomeView()
const { photos } = usePhotos()
const { loggedIn } = useUserSession()
+
const {
data: albums,
status,
diff --git a/packages/gallery/app/components/photo/InfoPanel.vue b/packages/gallery/app/components/photo/InfoPanel.vue
index 4f6c7ca1..dbdbfd1c 100644
--- a/packages/gallery/app/components/photo/InfoPanel.vue
+++ b/packages/gallery/app/components/photo/InfoPanel.vue
@@ -27,6 +27,7 @@ const dayjs = useDayjs()
const router = useRouter()
const { localizeExif } = useExifLocalization()
+
const props = defineProps<Props>()
// 获取照片所属的相册
diff --git a/packages/gallery/app/pages/albums/[albumId].vue b/packages/gallery/app/pages/albums/[albumId].vue
index 3105b4ba..4f7fa96a 100644
--- a/packages/gallery/app/pages/albums/[albumId].vue
+++ b/packages/gallery/app/pages/albums/[albumId].vue
@@ -2,6 +2,7 @@
const galleryApi = useGalleryApi()
import { motion } from 'motion-v'
+import type { AlbumPathResolution } from '@chronoframe/contracts/album-slug'
const route = useRoute()
const router = useRouter()
@@ -9,13 +10,13 @@ const dayjs = useDayjs()
const { user } = useUserSession()
const { albumListPath } = useHomeView()
const albumSegment = computed(() => String(route.params.albumId))
-const { data: resolved, error: resolveError } = await useGalleryFetch<{
- albumId: number
- slug: string
- isCanonical: boolean
-}>(() => `/api/albums/resolve/${encodeURIComponent(albumSegment.value)}`, {
- watch: [albumSegment],
-})
+const { data: resolved, error: resolveError } =
+ await useGalleryFetch<AlbumPathResolution>(
+ () => `/api/albums/resolve/${encodeURIComponent(albumSegment.value)}`,
+ {
+ watch: [albumSegment],
+ },
+ )
if (resolveError.value || !resolved.value)
throw createError({ statusCode: 404, statusMessage: $t('album.notFound') })
const canonicalAlbumRoute = computed(() => `/albums/${resolved.value?.slug}`)
@@ -27,7 +28,7 @@ if (!resolved.value.isCanonical || route.path !== canonicalAlbumRoute.value)
hash: route.hash,
},
{
- redirectCode: 301,
+ redirectCode: resolved.value.redirectCode ?? 301,
replace: true,
},
)
diff --git a/tests/album-slug-persistence.test.ts b/tests/album-slug-persistence.test.ts
index 27d29091..d4e84bf2 100644
--- a/tests/album-slug-persistence.test.ts
+++ b/tests/album-slug-persistence.test.ts
@@ -3,6 +3,7 @@ import test from 'node:test'
import Database from 'better-sqlite3'
import { drizzle } from 'drizzle-orm/better-sqlite3'
import { migrate } from 'drizzle-orm/better-sqlite3/migrator'
+import { asc } from 'drizzle-orm'
import { DEFAULT_SITE, CoreError, createAlbumWriter } from '@chronoframe/core'
import * as schema from '../packages/database/src/schema.ts'
import {
@@ -173,6 +174,7 @@ test('backfill assigns deterministic slugs once for existing rows', () => {
db
.select()
.from(schema.albumSlugs)
+ .orderBy(asc(schema.albumSlugs.slug))
.all()
.map((row) => row.slug),
['ni-hao', 'ni-hao-1'],
diff --git a/tests/integration/album-slug-http.test.ts b/tests/integration/album-slug-http.test.ts
new file mode 100644
index 00000000..91cb6f80
--- /dev/null
+++ b/tests/integration/album-slug-http.test.ts
@@ -0,0 +1,184 @@
+import assert from 'node:assert/strict'
+import { spawn } from 'node:child_process'
+import { once } from 'node:events'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { createServer } from 'node:net'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { setTimeout as delay } from 'node:timers/promises'
+import test from 'node:test'
+import { openDatabase, tables } from '../../packages/database/src/connection.ts'
+
+const root = process.cwd()
+
+async function unusedPort(): Promise<number> {
+ const server = createServer()
+ server.listen(0, '127.0.0.1')
+ await once(server, 'listening')
+ const address = server.address()
+ assert.ok(address && typeof address !== 'string')
+ server.close()
+ await once(server, 'close')
+ return address.port
+}
+
+test(
+ 'self-hosted album URLs redirect and enforce visibility without reusing history',
+ { timeout: 45_000 },
+ async () => {
+ const temporary = await mkdtemp(join(tmpdir(), 'chronoframe-album-http-'))
+ const filename = join(temporary, 'albums.sqlite3')
+ const migrationsFolder = join(root, 'packages/database/migrations')
+ const connection = openDatabase({ filename, migrationsFolder })
+ try {
+ const visible = connection.db
+ .insert(tables.albums)
+ .values({ title: 'Visible Album' })
+ .returning({ id: tables.albums.id })
+ .get()
+ connection.db
+ .insert(tables.albumSlugs)
+ .values([
+ {
+ siteId: 1,
+ albumId: visible.id,
+ slug: 'old-visible',
+ isCurrent: false,
+ },
+ {
+ siteId: 1,
+ albumId: visible.id,
+ slug: 'visible-album',
+ isCurrent: true,
+ },
+ ])
+ .run()
+ const hidden = connection.db
+ .insert(tables.albums)
+ .values({ title: 'Hidden Album', isHidden: true })
+ .returning({ id: tables.albums.id })
+ .get()
+ connection.db
+ .insert(tables.albumSlugs)
+ .values({
+ siteId: 1,
+ albumId: hidden.id,
+ slug: 'hidden-album',
+ isCurrent: true,
+ })
+ .run()
+ connection.close()
+
+ const port = await unusedPort()
+ const base = `http://127.0.0.1:${port}`
+ const server = spawn(
+ process.execPath,
+ [join(root, 'apps/self-hosted/.output/server/index.mjs')],
+ {
+ cwd: root,
+ env: {
+ ...process.env,
+ DATABASE_URL: filename,
+ DATABASE_MIGRATIONS: migrationsFolder,
+ NUXT_SESSION_PASSWORD: '0123456789abcdef0123456789abcdef',
+ NITRO_PORT: String(port),
+ },
+ stdio: ['ignore', 'pipe', 'pipe'],
+ },
+ )
+ let output = ''
+ for (const stream of [server.stdout, server.stderr])
+ stream.on('data', (chunk) => {
+ output = (output + chunk.toString()).slice(-4000)
+ })
+ try {
+ let ready = false
+ for (let attempt = 0; attempt < 200; attempt++) {
+ try {
+ await fetch(`${base}/api/wizard/schema`, {
+ signal: AbortSignal.timeout(500),
+ })
+ ready = true
+ break
+ } catch {
+ if (server.exitCode !== null) break
+ await delay(100)
+ }
+ }
+ assert.ok(ready, `Built server did not start: ${output}`)
+
+ const request = (path: string, options?: RequestInit) =>
+ fetch(`${base}${path}`, {
+ redirect: 'manual',
+ signal: AbortSignal.timeout(5000),
+ ...options,
+ })
+ const jsonPost = (path: string, body: object) =>
+ request(path, {
+ method: 'POST',
+ headers: { 'content-type': 'application/json' },
+ body: JSON.stringify(body),
+ })
+ assert.equal(
+ (
+ await jsonPost('/api/wizard/admin', {
+ email: '[email protected]',
+ username: 'admin',
+ password: 'test-password-123',
+ })
+ ).status,
+ 200,
+ )
+ assert.equal((await jsonPost('/api/wizard/complete', {})).status, 200)
+
+ const canonical = await request('/albums/visible-album')
+ assert.equal(canonical.status, 200)
+ const numeric = await request(`/albums/${visible.id}`)
+ assert.equal(numeric.status, 301)
+ assert.equal(numeric.headers.get('location'), '/albums/visible-album')
+ const historical = await request('/albums/old-visible?photo=x')
+ assert.equal(historical.status, 301)
+ assert.equal(
+ historical.headers.get('location'),
+ '/albums/visible-album?photo=x',
+ )
+ const trailing = await request('/albums/visible-album/')
+ assert.equal(trailing.status, 301)
+ assert.equal(trailing.headers.get('location'), '/albums/visible-album')
+ assert.equal((await request('/albums/hidden-album')).status, 404)
+
+ const login = await jsonPost('/api/login', {
+ email: '[email protected]',
+ password: 'test-password-123',
+ })
+ assert.equal(login.status, 201)
+ const cookie = login.headers
+ .getSetCookie()
+ .map((value) => value.split(';')[0])
+ .join('; ')
+ assert.ok(cookie)
+ assert.equal(
+ (await request('/albums/hidden-album', { headers: { cookie } }))
+ .status,
+ 200,
+ )
+ const reuse = await request(`/api/albums/${visible.id}`, {
+ method: 'PUT',
+ headers: { cookie, 'content-type': 'application/json' },
+ body: JSON.stringify({ slug: 'old-visible' }),
+ })
+ assert.equal(reuse.status, 409)
+ assert.equal((await request('/albums/old-visible')).status, 301)
+ assert.equal((await request('/albums/visible-album')).status, 200)
+ } finally {
+ if (server.exitCode === null) {
+ server.kill('SIGINT')
+ await once(server, 'exit')
+ }
+ }
+ } finally {
+ connection.close()
+ await rm(temporary, { recursive: true, force: true })
+ }
+ },
+)