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.

fix: address upload and job lifecycle review findings

HoshinoSuzumiBot1c0f2a2f0672
diff --git a/packages/core/src/upload-preparation.ts b/packages/core/src/upload-preparation.ts
index cfec99dd..435121bd 100644
--- a/packages/core/src/upload-preparation.ts
+++ b/packages/core/src/upload-preparation.ts
@@ -80,30 +80,26 @@ export function createUploadPreparer(deps: {
'upload.error.required.title',
)
const { fileName, fileSize, chunked, contentType } = input
- if (chunked || fileSize !== undefined) {
- if (!Number.isSafeInteger(fileSize) || fileSize! <= 0)
- throw new CoreError(400, 'Invalid file size')
- if (fileSize! > policy.maxBytes)
- throw new CoreError(
- 413,
- 'File is too large',
- 'upload.error.tooLarge.title',
- )
- if (
- policy.mimeWhitelistEnabled &&
- policy.mimeWhitelist.length &&
- !policy.mimeWhitelist.includes(
- contentType || 'application/octet-stream',
- )
+ if (!Number.isSafeInteger(fileSize) || fileSize! <= 0)
+ throw new CoreError(400, 'Invalid file size')
+ if (fileSize! > policy.maxBytes)
+ throw new CoreError(
+ 413,
+ 'File is too large',
+ 'upload.error.tooLarge.title',
)
- throw new CoreError(
- 415,
- 'Invalid content type',
- 'upload.error.invalidType.title',
- )
- if (/[\\/]/.test(fileName) || fileName === '.' || fileName === '..')
- throw new CoreError(400, 'Invalid file name')
- }
+ if (
+ policy.mimeWhitelistEnabled &&
+ policy.mimeWhitelist.length &&
+ !policy.mimeWhitelist.includes(contentType || 'application/octet-stream')
+ )
+ throw new CoreError(
+ 415,
+ 'Invalid content type',
+ 'upload.error.invalidType.title',
+ )
+ if (/[\\/]/.test(fileName) || fileName === '.' || fileName === '..')
+ throw new CoreError(400, 'Invalid file name')
await deps.quota.assertAllowed(owner, fileSize)
const fileKey = buildUploadObjectKey(policy.prefix, fileName)
let existingPhoto: DuplicatePhoto | null = null
diff --git a/packages/jobs/src/index.ts b/packages/jobs/src/index.ts
index a0fd653a..11184bc9 100644
--- a/packages/jobs/src/index.ts
+++ b/packages/jobs/src/index.ts
@@ -51,7 +51,8 @@ export async function runOneJob(deps: {
if (lease.siteId !== deps.site.id)
throw new PermanentJobError('Claimed job belongs to a different Site')
const controller = new AbortController()
- let heartbeatRunning = false
+ let heartbeatRunning = false,
+ leaseLost = false
const timer = setInterval(
() => {
if (heartbeatRunning) return
@@ -59,8 +60,10 @@ export async function runOneJob(deps: {
void deps.repository
.heartbeat(lease, now(), leaseMs)
.then((valid) => {
- if (!valid)
+ if (!valid) {
+ leaseLost = true
controller.abort(new LostLeaseError('Lease or source changed'))
+ }
})
.catch((error) => {
controller.abort(error)
@@ -86,7 +89,7 @@ export async function runOneJob(deps: {
!(
error instanceof PermanentJobError ||
error instanceof LostLeaseError ||
- controller.signal.aborted
+ leaseLost
),
now(),
)
diff --git a/server/api/photos/index.post.ts b/server/api/photos/index.post.ts
index c15a61b7..f4fb6f76 100644
--- a/server/api/photos/index.post.ts
+++ b/server/api/photos/index.post.ts
@@ -32,15 +32,17 @@ export default eventHandler(
identifiers: { fromStorageKey: generateSafePhotoId },
// Self-hosted has no account-wide quota; the per-file policy still applies.
quota: { assertAllowed: async () => {} },
- prepare: (owner, key, size, contentType, chunked) =>
- prepareUpload(
+ prepare: (owner, key, size, contentType, chunked) => {
+ reserveUploadSource(key, storageProvider)
+ return prepareUpload(
owner,
key,
size,
contentType,
sourceAwareUploadStorage(storageProvider),
chunked,
- ),
+ )
+ },
})
try {
const result = await preparer(String(session.user.id), body, {
@@ -71,7 +73,6 @@ export default eventHandler(
'upload.duplicateCheck.mode',
)) ?? 'skip',
})
- if (!result.skipped) reserveUploadSource(result.fileKey, storageProvider)
const fileName = body.fileName
if (result.skipped) {
return {
diff --git a/server/api/photos/livephoto/manage.post.ts b/server/api/photos/livephoto/manage.post.ts
index d48539de..af1fa628 100644
--- a/server/api/photos/livephoto/manage.post.ts
+++ b/server/api/photos/livephoto/manage.post.ts
@@ -1,6 +1,6 @@
import { createSiteRepository } from '@chronoframe/database'
import { storageForPhoto } from '../../../utils/object-storage'
-import { DEFAULT_SITE } from '@chronoframe/core'
+import { CoreError, DEFAULT_SITE } from '@chronoframe/core'
import {
processSpecificLivePhotoVideo,
scanAndProcessExistingLivePhotos,
@@ -114,6 +114,12 @@ export default eventHandler(async (event) => {
})
}
} catch (error) {
+ if (error instanceof CoreError)
+ throw createError({
+ statusCode: error.statusCode,
+ statusMessage: error.message,
+ })
+ if (error && typeof error === 'object' && 'statusCode' in error) throw error
logger.chrono.error('LivePhoto management error:', error)
throw createError({
statusCode: 500,
diff --git a/server/api/queue/task/retry-batch.post.ts b/server/api/queue/task/retry-batch.post.ts
index db8092e5..d628267b 100644
--- a/server/api/queue/task/retry-batch.post.ts
+++ b/server/api/queue/task/retry-batch.post.ts
@@ -77,6 +77,11 @@ export default defineEventHandler(async (event) => {
.update(tables.pipelineQueue)
.set({
status: 'pending',
+ resourceId: null,
+ sourceHash: null,
+ attemptId: null,
+ workerId: null,
+ leaseExpiresAt: null,
statusStage: null,
errorMessage: null,
warningCode: null,
diff --git a/server/api/queue/task/retry.post.ts b/server/api/queue/task/retry.post.ts
index 01d44c5d..803e2a37 100644
--- a/server/api/queue/task/retry.post.ts
+++ b/server/api/queue/task/retry.post.ts
@@ -57,6 +57,11 @@ export default defineEventHandler(async (event) => {
.update(tables.pipelineQueue)
.set({
status: 'pending',
+ resourceId: null,
+ sourceHash: null,
+ attemptId: null,
+ workerId: null,
+ leaseExpiresAt: null,
statusStage: null,
errorMessage: null,
warningCode: null,
diff --git a/server/routes/thumb/[...thumbnailUrl].get.ts b/server/routes/thumb/[...thumbnailUrl].get.ts
index aefd4062..b6c88d5a 100644
--- a/server/routes/thumb/[...thumbnailUrl].get.ts
+++ b/server/routes/thumb/[...thumbnailUrl].get.ts
@@ -81,6 +81,14 @@ export default eventHandler(async (event) => {
photo = await readFile(
await resolveLocalMediaPath(storageProvider.config, localKey),
)
+ } else if (isAppPath) {
+ const key = decodeURIComponent(url.replace(/^\/(?:storage|image)\//, ''))
+ if (await assertPhotoAccess(event, key))
+ setHeader(event, 'Cache-Control', 'private, no-store')
+ const buffer = await storageProvider.get(key)
+ if (!buffer)
+ throw createError({ statusCode: 404, statusMessage: 'Photo not found' })
+ photo = buffer
} else {
const response = await fetch(url)
if (!response.ok)
diff --git a/server/utils/upload-source.ts b/server/utils/upload-source.ts
index 230e4b08..9515fa5c 100644
--- a/server/utils/upload-source.ts
+++ b/server/utils/upload-source.ts
@@ -83,6 +83,8 @@ function idForKey(key: string) {
}
/** Invalidate the prior generation before a managed upload can replace its source. */
export function reserveUploadSource(key: string, provider: StorageProvider) {
+ // Companion videos share the image identifier but must not replace its generation.
+ if (/\.(?:mov|mp4)$/i.test(key)) return
return reserveResource(useDB(), DEFAULT_SITE, idForKey(key), {
...referenceForProvider(provider),
storageKey: key,
diff --git a/tests/core-upload-preparation.test.ts b/tests/core-upload-preparation.test.ts
index ffe97f4a..4d8f052c 100644
--- a/tests/core-upload-preparation.test.ts
+++ b/tests/core-upload-preparation.test.ts
@@ -38,9 +38,16 @@ test('upload preparation rejects invalid size, MIME, names and quota before crea
},
})
for (const input of [
- { fileName: 'p.jpg', fileSize: 0 },
- { fileName: 'p.jpg', fileSize: 11 },
- { fileName: 'p.jpg', fileSize: 2, contentType: 'text/plain' },
+ { fileName: '../escape.jpg' },
+ { fileName: 'p.jpg' },
+ { fileName: '..\\escape.jpg', fileSize: 2, contentType: 'image/jpeg' },
+ { contentType: 'image/jpeg', fileName: 'p.jpg', fileSize: 0 },
+ { contentType: 'image/jpeg', fileName: 'p.jpg', fileSize: 11 },
+ {
+ fileName: 'p.jpg',
+ fileSize: 2,
+ contentType: 'text/plain',
+ },
{ fileName: '../p.jpg', fileSize: 2, contentType: 'image/jpeg' },
]) {
await assert.rejects(
@@ -62,7 +69,11 @@ test('upload preparation rejects invalid size, MIME, names and quota before crea
},
})
await assert.rejects(
- blocked('owner', { fileName: 'p.jpg' }, policy),
+ blocked(
+ 'owner',
+ { fileSize: 2, contentType: 'image/jpeg', fileName: 'p.jpg' },
+ policy,
+ ),
/Quota exhausted/,
)
})
@@ -78,14 +89,18 @@ test('duplicate skip, block and warning preserve keys and avoid unwanted provide
return { mode: 'single', url: '/upload' }
},
})
- const skipped = await prepare('owner', { fileName: 'p.jpg' }, policy)
+ const skipped = await prepare(
+ 'owner',
+ { fileSize: 2, contentType: 'image/jpeg', fileName: 'p.jpg' },
+ policy,
+ )
assert.equal(skipped.skipped, true)
assert.equal(skipped.fileKey, 'photos/p.jpg')
assert.deepEqual(prepared, [])
await assert.rejects(
prepare(
'owner',
- { fileName: 'p.jpg' },
+ { fileSize: 2, contentType: 'image/jpeg', fileName: 'p.jpg' },
{ ...policy, duplicateMode: 'block' },
),
(error: unknown) =>
@@ -94,18 +109,27 @@ test('duplicate skip, block and warning preserve keys and avoid unwanted provide
)
const warning = await prepare(
'owner',
- { fileName: 'p.jpg' },
+ { fileSize: 2, contentType: 'image/jpeg', fileName: 'p.jpg' },
{ ...policy, duplicateMode: 'warn' },
)
assert.equal(warning.skipped, false)
assert.equal(warning.existingPhoto!.id, 'photo')
const ignored = await prepare(
'owner',
- { fileName: 'p.jpg', skipDuplicateCheck: true },
+ {
+ fileSize: 2,
+ contentType: 'image/jpeg',
+ fileName: 'p.jpg',
+ skipDuplicateCheck: true,
+ },
policy,
)
assert.equal(ignored.existingPhoto, null)
- const video = await prepare('owner', { fileName: 'p.mov' }, policy)
+ const video = await prepare(
+ 'owner',
+ { fileName: 'p.mov', fileSize: 2, contentType: 'image/jpeg' },
+ policy,
+ )
assert.equal(video.skipped, false)
assert.equal(video.existingPhoto, null)
})
diff --git a/tests/job-leases.test.ts b/tests/job-leases.test.ts
index 8a800d7d..1493a09b 100644
--- a/tests/job-leases.test.ts
+++ b/tests/job-leases.test.ts
@@ -344,7 +344,8 @@ test('heartbeat loss aborts cooperatively and keeps the native slot until proces
complete: async () => {
throw new Error('lost lease completed')
},
- fail: async () => {
+ fail: async (_lease, _error, retryable) => {
+ assert.equal(retryable, false)
failed = true
return true
},
@@ -447,3 +448,40 @@ test('maintenance snapshots reject stale writes and preserve published derived o
connection.close()
}
})
+
+test('temporary heartbeat failures abort processing but remain retryable', async () => {
+ const connection = openDatabase({ filename: ':memory:', migrationsFolder })
+ try {
+ const repository = createSqliteJobRepository(
+ connection.db,
+ DEFAULT_SITE,
+ resolveId,
+ )
+ repository.enqueue({ type: 'photo', storageKey: 'source.jpg' })
+ const result = await runOneJob({
+ site: DEFAULT_SITE,
+ workerId: 'worker',
+ now: () => clock,
+ heartbeatMs: 10,
+ repository: {
+ ...repository,
+ heartbeat: async () => {
+ throw new Error('SQLITE_BUSY')
+ },
+ },
+ process: async (_lease, signal) => {
+ await new Promise<void>((resolve) =>
+ signal.addEventListener('abort', () => resolve(), { once: true }),
+ )
+ signal.throwIfAborted()
+ },
+ })
+ assert.equal(result, 'failed')
+ const row = connection.db.select().from(tables.pipelineQueue).get()!
+ assert.equal(row.status, 'pending')
+ assert.equal(row.errorMessage, 'SQLITE_BUSY')
+ assert.equal(row.attempts, 1)
+ } finally {
+ connection.close()
+ }
+})
diff --git a/tests/review-runtime.test.ts b/tests/review-runtime.test.ts
new file mode 100644
index 00000000..468ebd4a
--- /dev/null
+++ b/tests/review-runtime.test.ts
@@ -0,0 +1,282 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import vm from 'node:vm'
+import ts from 'typescript'
+import sharp from 'sharp'
+import { DEFAULT_SITE } from '@chronoframe/core'
+import { openDatabase, tables, reserveResource } from '@chronoframe/database'
+
+const require = createRequire(import.meta.url)
+function load(
+ file: string,
+ modules: Record<string, unknown>,
+ globals: Record<string, unknown> = {},
+) {
+ const code = ts.transpileModule(readFileSync(file, 'utf8'), {
+ compilerOptions: {
+ module: ts.ModuleKind.CommonJS,
+ target: ts.ScriptTarget.ES2022,
+ esModuleInterop: true,
+ },
+ }).outputText
+ const exports = {}
+ vm.runInNewContext(
+ code,
+ {
+ exports,
+ require: (name: string) =>
+ name in modules ? modules[name] : require(name),
+ Buffer,
+ ...globals,
+ },
+ { filename: file },
+ )
+ return exports as Record<string, any>
+}
+
+test('Live Photo companion reservation leaves the image generation unchanged', async () => {
+ const connection = openDatabase({
+ filename: ':memory:',
+ migrationsFolder: 'packages/database/migrations',
+ })
+ try {
+ reserveResource(connection.db, DEFAULT_SITE, 'IMG', {
+ storageKey: 'IMG.HEIC',
+ storageConnectionId: null,
+ storageRevision: 1,
+ })
+ const source = load('server/utils/upload-source.ts', {
+ './db': { useDB: () => connection.db, tables },
+ './file-utils': { generateSafePhotoId: () => 'IMG' },
+ './object-storage': {
+ storageForReference: () => {
+ throw new Error('unexpected provider lookup')
+ },
+ },
+ })
+ const before = connection.db.select().from(tables.resourceVersions).all()
+ source.reserveUploadSource('IMG.MOV', {})
+ source.reserveUploadSource('IMG.mp4', {})
+ assert.deepEqual(
+ connection.db.select().from(tables.resourceVersions).all(),
+ before,
+ )
+ } finally {
+ connection.close()
+ }
+})
+
+test('non-local thumbnails read app-relative keys through the provider after authorization', async () => {
+ const jpeg = await sharp({
+ create: { width: 2, height: 3, channels: 3, background: 'red' },
+ })
+ .jpeg()
+ .toBuffer()
+ const calls: string[] = []
+ const route = load(
+ 'server/routes/thumb/[...thumbnailUrl].get.ts',
+ {
+ '../../utils/object-storage': {},
+ '../../utils/local-media': {},
+ '../../utils/db': {},
+ '../../utils/album-access': {
+ assertPhotoAccess: async (_event: unknown, key: string) => {
+ calls.push('authorize:' + key)
+ return true
+ },
+ },
+ },
+ {
+ eventHandler: (handler: unknown) => handler,
+ useStorageProvider: () => ({
+ storageProvider: {
+ config: { provider: 's3' },
+ get: async (key: string) => {
+ calls.push('get:' + key)
+ return jpeg
+ },
+ },
+ }),
+ getRouterParam: () => encodeURIComponent('/image/photos/test.jpg'),
+ setHeader: () => {},
+ fetch: () => {
+ throw new Error('must not fetch relative URL')
+ },
+ },
+ ).default
+ const output = await route({})
+ assert.equal((await sharp(output).metadata()).width, 2)
+ assert.ok(
+ calls.indexOf('authorize:photos/test.jpg') <
+ calls.indexOf('get:photos/test.jpg'),
+ )
+})
+
+test('single and batch manual retries discard stale bindings and adopt the current source', async () => {
+ const { createSqliteJobRepository } = await import('@chronoframe/database')
+ for (const path of ['retry.post.ts', 'retry-batch.post.ts']) {
+ const connection = openDatabase({
+ filename: ':memory:',
+ migrationsFolder: 'packages/database/migrations',
+ })
+ try {
+ const db = connection.db
+ const repository = createSqliteJobRepository(
+ db,
+ DEFAULT_SITE,
+ () => 'photo',
+ )
+ repository.enqueue({ type: 'photo', storageKey: 'source.jpg' })
+ const now = new Date()
+ const lease = (await repository.claim('old', now, 60000))!
+ repository.bindSourceHash(lease, 'a'.repeat(64), now)
+ await repository.fail(lease, 'failed', false, now)
+ reserveResource(db, DEFAULT_SITE, 'photo', {
+ storageKey: 'source.jpg',
+ storageConnectionId: null,
+ storageRevision: 1,
+ })
+ const route = load(
+ 'server/api/queue/task/' + path,
+ {},
+ {
+ defineEventHandler: (handler: unknown) => handler,
+ requireUserSession: async () => ({ user: { isAdmin: true } }),
+ readValidatedBody: async () => ({
+ taskId: lease.id,
+ taskIds: [lease.id],
+ }),
+ useDB: () => db,
+ tables,
+ console,
+ createError: (options: object) =>
+ Object.assign(new Error('HTTP error'), options),
+ },
+ ).default
+ await route({})
+ const reset = db.select().from(tables.pipelineQueue).get()!
+ for (const key of [
+ 'resourceId',
+ 'sourceHash',
+ 'attemptId',
+ 'workerId',
+ 'leaseExpiresAt',
+ ] as const)
+ assert.equal(reset[key], null)
+ const retry = (await repository.claim(
+ 'new',
+ new Date(Date.now() + 1000),
+ 60000,
+ ))!
+ assert.ok(retry)
+ assert.ok(retry.sourceVersion > lease.sourceVersion)
+ assert.equal(retry.attempts, 1)
+ repository.bindSourceHash(
+ retry,
+ 'b'.repeat(64),
+ new Date(Date.now() + 1000),
+ )
+ } finally {
+ connection.close()
+ }
+ }
+})
+
+test('upload reservation failure creates no provider plan and duplicate skip never reserves', async () => {
+ let plans = 0,
+ reservations = 0,
+ duplicate = false
+ const route = load(
+ 'server/api/photos/index.post.ts',
+ {
+ '../../utils/upload-source': {
+ reserveUploadSource: () => {
+ reservations++
+ throw new Error('unregistered')
+ },
+ sourceAwareUploadStorage: (provider: unknown) => provider,
+ },
+ '../../utils/useStorageProvider': {
+ useStorageProvider: () => ({
+ storageProvider: { config: { provider: 's3' } },
+ }),
+ },
+ '../../utils/file-utils': { generateSafePhotoId: () => 'photo' },
+ '../../services/settings/settingsManager': {
+ settingsManager: { get: async () => undefined },
+ },
+ '../../utils/direct-upload': {
+ prepareUpload: async () => {
+ plans++
+ return { mode: 'single', url: '/upload' }
+ },
+ },
+ '../../utils/db': { useDB: () => ({}) },
+ '../../repositories/sqlite-uploads': {
+ createSqliteUploadRepository: () => ({
+ findDuplicate: async () =>
+ duplicate ? { id: 'photo', storageKey: 'p.jpg' } : null,
+ }),
+ },
+ },
+ {
+ eventHandler: (handler: unknown) => handler,
+ requireUserSession: async () => ({ user: { id: 1 } }),
+ useTranslation: async () => (key: string) => key,
+ readBody: async () => ({
+ fileName: 'p.jpg',
+ fileSize: 2,
+ contentType: 'image/jpeg',
+ }),
+ useRuntimeConfig: () => ({
+ upload: { mime: { whitelistEnabled: false, whitelist: '' } },
+ }),
+ logger: { chrono: { error: () => {} } },
+ createError: (options: object) =>
+ Object.assign(new Error('HTTP error'), options),
+ },
+ ).default
+ await assert.rejects(route({}), { statusCode: 500 })
+ assert.equal(plans, 0)
+ assert.equal(reservations, 1)
+ duplicate = true
+ assert.equal((await route({})).skipped, true)
+ assert.equal(reservations, 1)
+})
+
+test('Live Photo management preserves missing photo and source conflict responses', async () => {
+ const { CoreError } = await import('@chronoframe/core')
+ for (const status of [404, 409]) {
+ const route = load(
+ 'server/api/photos/livephoto/manage.post.ts',
+ {
+ '@chronoframe/database': {
+ createSiteRepository: () => ({
+ capturePhoto: async () => {
+ if (status === 409)
+ throw new CoreError(409, 'Photo source changed')
+ return null
+ },
+ }),
+ },
+ '../../../utils/object-storage': {},
+ '~~/server/services/video/scanner': {},
+ '~~/server/services/video/livephoto': {},
+ '~~/server/plugins/3.storage': {},
+ '~~/server/services/video/test-utils': {},
+ },
+ {
+ eventHandler: (handler: unknown) => handler,
+ requireUserSession: async () => ({}),
+ readBody: async () => ({ action: 'update-photo', photoId: 'photo' }),
+ useDB: () => ({}),
+ logger: { chrono: { error: () => {} } },
+ createError: (options: object) =>
+ Object.assign(new Error('HTTP error'), options),
+ },
+ ).default
+ await assert.rejects(route({}), { statusCode: status })
+ }
+})