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): resolve album URLs once per page request

Ahmet Ömer24f2e0033c23
diff --git a/apps/self-hosted/server/middleware/album-slug-redirect.ts b/apps/self-hosted/server/middleware/album-slug-redirect.ts
deleted file mode 100644
index 926983fb..00000000
--- a/apps/self-hosted/server/middleware/album-slug-redirect.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { DEFAULT_SITE } from '@chronoframe/core'
-import { resolveAlbumPath } from '@chronoframe/database/album-slugs'
-import { albumAccess } from '../utils/album-access'
-import { useDB } from '../utils/db'
-
-export default defineEventHandler(async (event) => {
- if (event.method !== 'GET' && event.method !== 'HEAD') return
- const url = getRequestURL(event)
- const match = /^\/albums\/([^/]+)\/?$/.exec(url.pathname)
- if (!match) return
- let segment: string
- try {
- segment = decodeURIComponent(match[1]!)
- } catch {
- throw createError({ statusCode: 404, statusMessage: 'Album not found' })
- }
- const resolved = resolveAlbumPath(useDB(), DEFAULT_SITE, segment)
- const access = await albumAccess(event)
- if (!resolved || (resolved.isHidden && !access.admin))
- throw createError({ statusCode: 404, statusMessage: 'Album not found' })
- if (!resolved.isCanonical || url.pathname !== `/albums/${resolved.slug}`)
- return sendRedirect(event, `/albums/${resolved.slug}${url.search}`, 301)
-})
diff --git a/packages/database/src/album-slugs.ts b/packages/database/src/album-slugs.ts
index b0d721f3..4a2d4375 100644
--- a/packages/database/src/album-slugs.ts
+++ b/packages/database/src/album-slugs.ts
@@ -5,6 +5,7 @@ import {
isValidAlbumSlug,
} from '@chronoframe/contracts/album-slug'
import { and, asc, eq } from 'drizzle-orm'
+import { alias } from 'drizzle-orm/sqlite-core'
import { type AppDatabase } from './connection.ts'
import * as tables from './schema.ts'
import {
@@ -14,6 +15,7 @@ import {
} from './album-slug.ts'
type AlbumSlugDb = Pick<AppDatabase, 'select' | 'insert' | 'update'>
+const currentAlbumSlug = alias(tables.albumSlugs, 'current_album_slug')
function currentSlug(db: AlbumSlugDb, siteId: number, albumId: number) {
return db
@@ -136,31 +138,61 @@ export function resolveAlbumPath(
segment: string,
) {
if (segment.length > ALBUM_SLUG_MAX_LENGTH) return null
- let albumId: number | null = null
- let isCurrent = false
- if (isNumericAlbumPathSegment(segment)) {
- const number = Number(segment)
- if (Number.isSafeInteger(number) && number > 0) albumId = number
- } else if (isValidAlbumSlug(segment)) {
- const entry = resolveAlbumSlug(db, site, segment)
- albumId = entry?.albumId ?? null
- isCurrent = entry?.isCurrent ?? false
- }
- if (albumId === null) return null
- const album = db
- .select({ isHidden: tables.albums.isHidden })
- .from(tables.albums)
- .where(
- and(eq(tables.albums.siteId, site.id), eq(tables.albums.id, albumId)),
- )
- .get()
+ const numeric = isNumericAlbumPathSegment(segment)
+ if (!numeric && !isValidAlbumSlug(segment)) return null
+ const numericId = Number(segment)
+ if (numeric && (!Number.isSafeInteger(numericId) || numericId < 1))
+ return null
+ const currentJoin = and(
+ eq(currentAlbumSlug.siteId, tables.albums.siteId),
+ eq(currentAlbumSlug.albumId, tables.albums.id),
+ eq(currentAlbumSlug.isCurrent, true),
+ )
+ const album = numeric
+ ? db
+ .select({
+ albumId: tables.albums.id,
+ slug: currentAlbumSlug.slug,
+ isHidden: tables.albums.isHidden,
+ })
+ .from(tables.albums)
+ .leftJoin(currentAlbumSlug, currentJoin)
+ .where(
+ and(
+ eq(tables.albums.siteId, site.id),
+ eq(tables.albums.id, numericId),
+ ),
+ )
+ .get()
+ : db
+ .select({
+ albumId: tables.albums.id,
+ slug: currentAlbumSlug.slug,
+ isHidden: tables.albums.isHidden,
+ isCurrent: tables.albumSlugs.isCurrent,
+ })
+ .from(tables.albumSlugs)
+ .innerJoin(
+ tables.albums,
+ and(
+ eq(tables.albums.id, tables.albumSlugs.albumId),
+ eq(tables.albums.siteId, tables.albumSlugs.siteId),
+ ),
+ )
+ .leftJoin(currentAlbumSlug, currentJoin)
+ .where(
+ and(
+ eq(tables.albumSlugs.siteId, site.id),
+ eq(tables.albumSlugs.slug, segment),
+ ),
+ )
+ .get()
if (!album) return null
- const slug = getCurrentAlbumSlug(db, site, albumId)
+ const isCurrent = 'isCurrent' in album && album.isCurrent === true
return {
- albumId,
- slug: slug ?? String(albumId),
- isCanonical:
- isCurrent || (slug === null && isNumericAlbumPathSegment(segment)),
+ albumId: album.albumId,
+ slug: album.slug ?? String(album.albumId),
+ isCanonical: isCurrent || (numeric && album.slug === null),
isHidden: album.isHidden,
}
}
diff --git a/packages/gallery/app/pages/albums/[albumId].vue b/packages/gallery/app/pages/albums/[albumId].vue
index 2482660d..3105b4ba 100644
--- a/packages/gallery/app/pages/albums/[albumId].vue
+++ b/packages/gallery/app/pages/albums/[albumId].vue
@@ -18,10 +18,11 @@ const { data: resolved, error: resolveError } = await useGalleryFetch<{
})
if (resolveError.value || !resolved.value)
throw createError({ statusCode: 404, statusMessage: $t('album.notFound') })
-if (!resolved.value.isCanonical)
+const canonicalAlbumRoute = computed(() => `/albums/${resolved.value?.slug}`)
+if (!resolved.value.isCanonical || route.path !== canonicalAlbumRoute.value)
await navigateTo(
{
- path: `/albums/${resolved.value.slug}`,
+ path: canonicalAlbumRoute.value,
query: route.query,
hash: route.hash,
},
@@ -30,15 +31,14 @@ if (!resolved.value.isCanonical)
replace: true,
},
)
-watch(resolved, (value) => {
- if (value && !value.isCanonical)
+watch([resolved, () => route.path], ([value]) => {
+ if (value && (!value.isCanonical || route.path !== `/albums/${value.slug}`))
void navigateTo(
{ path: `/albums/${value.slug}`, query: route.query, hash: route.hash },
{ replace: true },
)
})
const albumId = computed(() => resolved.value?.albumId ?? 0)
-const canonicalAlbumRoute = computed(() => `/albums/${resolved.value?.slug}`)
const requestUrl = useRequestURL()
useHead(() => ({
link: [
diff --git a/tests/album-slug-persistence.test.ts b/tests/album-slug-persistence.test.ts
index af79465b..7a339445 100644
--- a/tests/album-slug-persistence.test.ts
+++ b/tests/album-slug-persistence.test.ts
@@ -16,7 +16,10 @@ import { createSqliteAlbumWriteRepository } from '../packages/database/src/sqlit
const access = { authenticated: true }
test('album slugs remain unique, redirectable, and reserved after deletion', async () => {
- const sqlite = new Database(':memory:')
+ const statements: string[] = []
+ const sqlite = new Database(':memory:', {
+ verbose: (statement) => statements.push(statement),
+ })
sqlite.pragma('foreign_keys = ON')
const db = drizzle(sqlite, { schema })
migrate(db, { migrationsFolder: './packages/database/migrations' })
@@ -51,16 +54,26 @@ test('album slugs remain unique, redirectable, and reserved after deletion', asy
access,
)
assert.equal(renamed.slug, 'a-new-title')
+ statements.length = 0
assert.deepEqual(resolveAlbumPath(db, DEFAULT_SITE, String(first.id)), {
albumId: first.id,
slug: 'a-new-title',
isCanonical: false,
isHidden: false,
})
+ assert.equal(statements.length, 1)
+ statements.length = 0
assert.equal(
resolveAlbumPath(db, DEFAULT_SITE, 'a-new-title')?.isCanonical,
true,
)
+ assert.equal(statements.length, 1)
+ statements.length = 0
+ assert.equal(
+ resolveAlbumPath(db, DEFAULT_SITE, 'my-album')?.slug,
+ 'a-new-title',
+ )
+ assert.equal(statements.length, 1)
assert.equal(
resolveAlbumSlug(db, DEFAULT_SITE, 'my-album')?.albumId,
first.id,