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(cloud): record API activity for account inactivity deadlines

HoshinoSuzumia361253ee1ff
diff --git a/apps/cloud/server/middleware/00-account-session.ts b/apps/cloud/server/middleware/00-account-session.ts
index 51f7eb99..bc2f8a98 100644
--- a/apps/cloud/server/middleware/00-account-session.ts
+++ b/apps/cloud/server/middleware/00-account-session.ts
@@ -1,6 +1,10 @@
import { platformDatabase } from '../../../shared/platform/runtime'
import { getCookie, getRequestHeaders } from 'h3'
import { cloudAccount } from '../utils/cloud-account'
+import {
+ recordAccountActivity,
+ ACCOUNT_ACTIVITY_INTERVAL,
+} from '../../../../packages/platform/src/account-activity'
/** Provide Cloud's account session to shared Site authorization, with numeric identity intact. */
export default defineEventHandler((event) => {
event.context.platformSessionResolver = async () => {
@@ -11,20 +15,30 @@ export default defineEventHandler((event) => {
headers: new Headers(getRequestHeaders(event) as HeadersInit),
})
const id = Number(session?.user.id)
- const control = session
- ? await platformDatabase(event)
- .prepare(
- 'SELECT suspended FROM platform_account_controls WHERE user_id=?',
- )
- .bind(id)
- .first<{ suspended: number }>()
- : null
- return !control?.suspended &&
- session &&
- session.user.emailVerified &&
- Number.isSafeInteger(id) &&
- id > 0
- ? { userId: id, expiresAt: new Date(session.session.expiresAt).getTime() }
- : null
+ if (
+ !session ||
+ !session.user.emailVerified ||
+ !Number.isSafeInteger(id) ||
+ id < 1
+ )
+ return null
+ const db = platformDatabase(event)
+ const control = await db
+ .prepare(
+ 'SELECT COALESCE(c.suspended,0) AS suspended,u.last_active_at FROM platform_users u LEFT JOIN platform_account_controls c ON c.user_id=u.id WHERE u.id=?',
+ )
+ .bind(id)
+ .first<{ suspended: number; last_active_at: number | null }>()
+ if (!control || control.suspended) return null
+ const now = Date.now()
+ if (
+ control.last_active_at === null ||
+ control.last_active_at <= now - ACCOUNT_ACTIVITY_INTERVAL
+ )
+ await recordAccountActivity(db, id, now)
+ return {
+ userId: id,
+ expiresAt: new Date(session.session.expiresAt).getTime(),
+ }
}
})
diff --git a/packages/platform/migrations/0042_account_activity.sql b/packages/platform/migrations/0042_account_activity.sql
new file mode 100644
index 00000000..5c1db00d
--- /dev/null
+++ b/packages/platform/migrations/0042_account_activity.sql
@@ -0,0 +1 @@
+ALTER TABLE platform_users ADD COLUMN last_active_at INTEGER;
diff --git a/packages/platform/src/account-activity.ts b/packages/platform/src/account-activity.ts
new file mode 100644
index 00000000..1636fbf2
--- /dev/null
+++ b/packages/platform/src/account-activity.ts
@@ -0,0 +1,19 @@
+import type { PlatformD1 } from './index.ts'
+
+export const ACCOUNT_ACTIVITY_INTERVAL = 5 * 60 * 1000
+
+/** Authenticated API activity never restores frozen accounts or changes login timestamps. */
+export async function recordAccountActivity(
+ db: PlatformD1,
+ userId: number,
+ now = Date.now(),
+) {
+ if (!Number.isSafeInteger(userId) || userId < 1) return false
+ const result = await db
+ .prepare(
+ 'UPDATE platform_users SET last_active_at=? WHERE id=? AND email_verified=1 AND (last_active_at IS NULL OR last_active_at<=?) AND NOT EXISTS(SELECT 1 FROM platform_account_controls c WHERE c.user_id=platform_users.id AND c.suspended=1) AND NOT EXISTS(SELECT 1 FROM platform_account_deletions d WHERE d.user_id=platform_users.id)',
+ )
+ .bind(now, userId, now - ACCOUNT_ACTIVITY_INTERVAL)
+ .run()
+ return result.meta.changes > 0
+}
diff --git a/packages/platform/src/account-lifecycle.ts b/packages/platform/src/account-lifecycle.ts
index d3ed1f55..5f62cfd2 100644
--- a/packages/platform/src/account-lifecycle.ts
+++ b/packages/platform/src/account-lifecycle.ts
@@ -71,7 +71,10 @@ export function deletionDeadline(
) {
const verified = !!user.email_verified,
anchor = verified
- ? (user.last_login_at ?? timeValue(user.created_at))
+ ? Math.max(
+ user.last_active_at ?? 0,
+ user.last_login_at ?? timeValue(user.created_at),
+ )
: timeValue(user.created_at)
return Math.max(
anchor + (verified ? s.inactiveDays : s.unverifiedDays) * DAY,
@@ -81,7 +84,7 @@ export function deletionDeadline(
}
export const automaticReason = (verified: boolean, days: number) =>
verified
- ? `No sign-in has been recorded for ${days} days.`
+ ? `No account activity has been recorded for ${days} days.`
: `Your email address is still unverified ${days} days after registration.`
const date = (v: number) =>
new Date(v).toISOString().replace('T', ' ').replace('.000Z', ' UTC')
@@ -94,6 +97,7 @@ export async function markAccount(
now = Date.now(),
expected?: {
login: number | null
+ activity?: number | null
verified: number
settingsRevision: number
},
@@ -124,7 +128,7 @@ export async function markAccount(
await db.batch([
db
.prepare(
- `INSERT INTO platform_account_deletions(user_id,generation,source,reason,marked_at,purge_at,previous_suspended,previous_reason) SELECT u.id,?,?,?,?,?,COALESCE(c.suspended,0),COALESCE(c.public_reason,'') FROM platform_users u LEFT JOIN platform_account_controls c ON c.user_id=u.id WHERE u.id=? AND NOT EXISTS(SELECT 1 FROM platform_account_deletions WHERE user_id=u.id) ${expected ? 'AND u.last_login_at IS ? AND u.email_verified=? AND EXISTS(SELECT 1 FROM platform_lifecycle_settings WHERE id=1 AND enabled=1 AND revision=?) AND EXISTS(SELECT 1 FROM platform_policy_epoch WHERE id=1 AND revision=?)' : ''}`,
+ `INSERT INTO platform_account_deletions(user_id,generation,source,reason,marked_at,purge_at,previous_suspended,previous_reason) SELECT u.id,?,?,?,?,?,COALESCE(c.suspended,0),COALESCE(c.public_reason,'') FROM platform_users u LEFT JOIN platform_account_controls c ON c.user_id=u.id WHERE u.id=? AND NOT EXISTS(SELECT 1 FROM platform_account_deletions WHERE user_id=u.id) ${expected ? 'AND u.last_login_at IS ? AND u.last_active_at IS ? AND u.email_verified=? AND EXISTS(SELECT 1 FROM platform_lifecycle_settings WHERE id=1 AND enabled=1 AND revision=?) AND EXISTS(SELECT 1 FROM platform_policy_epoch WHERE id=1 AND revision=?)' : ''}`,
)
.bind(
generation,
@@ -136,6 +140,7 @@ export async function markAccount(
...(expected
? [
expected.login,
+ expected.activity ?? null,
expected.verified,
expected.settingsRevision,
policyEpoch!.revision,
@@ -368,6 +373,7 @@ export async function scanAccounts(
now,
{
login: u.last_login_at,
+ activity: u.last_active_at,
verified: u.email_verified,
settingsRevision: s.revision,
},
diff --git a/tests/account-activity.test.ts b/tests/account-activity.test.ts
new file mode 100644
index 00000000..da480ccb
--- /dev/null
+++ b/tests/account-activity.test.ts
@@ -0,0 +1,123 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { DatabaseSync } from 'node:sqlite'
+import { readFileSync } from 'node:fs'
+import {
+ recordAccountActivity,
+ ACCOUNT_ACTIVITY_INTERVAL,
+} from '../packages/platform/src/account-activity.ts'
+import {
+ deletionDeadline,
+ DAY,
+} from '../packages/platform/src/account-lifecycle.ts'
+import type { PlatformD1 } from '../packages/platform/src/index.ts'
+
+test('authenticated API activity is throttled, monotonic, separate from login and unavailable to unverified, suspended or deleted users', async () => {
+ const sqlite = new DatabaseSync(':memory:')
+ try {
+ sqlite.exec(
+ 'CREATE TABLE platform_users(id INTEGER PRIMARY KEY,email_verified INTEGER,last_login_at INTEGER); CREATE TABLE platform_account_controls(user_id INTEGER,suspended INTEGER); CREATE TABLE platform_account_deletions(user_id INTEGER)',
+ )
+ sqlite.exec(
+ readFileSync(
+ new URL(
+ '../packages/platform/migrations/0042_account_activity.sql',
+ import.meta.url,
+ ),
+ 'utf8',
+ ),
+ )
+ sqlite.exec(
+ 'INSERT INTO platform_users VALUES(1,1,123,NULL),(2,0,123,NULL),(3,1,123,NULL),(4,1,123,NULL); INSERT INTO platform_account_controls VALUES(3,1); INSERT INTO platform_account_deletions VALUES(4)',
+ )
+ const db = {
+ prepare(sql: string) {
+ return {
+ bind(...values: (number | string | null)[]) {
+ return {
+ async run() {
+ return {
+ meta: {
+ changes: Number(sqlite.prepare(sql).run(...values).changes),
+ },
+ }
+ },
+ }
+ },
+ }
+ },
+ } as unknown as PlatformD1
+ const now = 100 * DAY
+ assert.equal(await recordAccountActivity(db, 1, now), true)
+ assert.equal(
+ await recordAccountActivity(db, 1, now + ACCOUNT_ACTIVITY_INTERVAL - 1),
+ false,
+ )
+ assert.equal(await recordAccountActivity(db, 1, now - DAY), false)
+ assert.equal(
+ await recordAccountActivity(db, 1, now + ACCOUNT_ACTIVITY_INTERVAL),
+ true,
+ )
+ assert.equal(
+ sqlite
+ .prepare('SELECT last_login_at FROM platform_users WHERE id=1')
+ .get()!.last_login_at,
+ 123,
+ )
+ for (const id of [2, 3, 4, 0, -1, NaN, 999])
+ assert.equal(await recordAccountActivity(db, id, now), false)
+ sqlite.exec('INSERT INTO platform_account_deletions VALUES(1)')
+ assert.equal(await recordAccountActivity(db, 1, now + DAY), false)
+ assert.equal(
+ sqlite
+ .prepare('SELECT last_active_at FROM platform_users WHERE id=1')
+ .get()!.last_active_at,
+ now + ACCOUNT_ACTIVITY_INTERVAL,
+ )
+ } finally {
+ sqlite.close()
+ }
+})
+test('verified-account deadlines follow the latest activity/login, retain legacy fallback, and leave unverified deadlines unchanged', () => {
+ const now = 200 * DAY
+ const settings = {
+ enabled: true,
+ inactiveDays: 90,
+ unverifiedDays: 14,
+ retentionDays: 15,
+ warningDays: [7, 3],
+ activatedAt: 1,
+ revision: 1,
+ }
+ const old = {
+ email_verified: 1,
+ created_at: now - 120 * DAY,
+ last_login_at: now - 100 * DAY,
+ }
+ assert.equal(
+ deletionDeadline({ ...old, last_active_at: now }, settings),
+ now + 90 * DAY,
+ )
+ assert.equal(
+ deletionDeadline(
+ { ...old, last_login_at: now, last_active_at: now - DAY },
+ settings,
+ ),
+ now + 90 * DAY,
+ )
+ assert.equal(deletionDeadline(old, settings), now - 10 * DAY)
+ assert.equal(
+ deletionDeadline(
+ { ...old, email_verified: 0, last_active_at: now },
+ settings,
+ ),
+ now - 106 * DAY,
+ )
+ assert.equal(
+ deletionDeadline(
+ { ...old, last_active_at: now, lifecycle_grace_until: now + 100 * DAY },
+ settings,
+ ),
+ now + 100 * DAY,
+ )
+})
diff --git a/tests/account-lifecycle-mail.test.ts b/tests/account-lifecycle-mail.test.ts
index badaaa89..d68b3a83 100644
--- a/tests/account-lifecycle-mail.test.ts
+++ b/tests/account-lifecycle-mail.test.ts
@@ -1498,3 +1498,71 @@ test('Retry-budget migration preserves delivery history and terminates already-e
await mf.dispose()
}
})
+
+test('authenticated API activity racing the scanner prevents automatic freezing', async () => {
+ const { mf, db } = await fixture()
+ try {
+ const now = Date.now(),
+ old = now - 100 * DAY
+ await db
+ .prepare(
+ 'UPDATE platform_lifecycle_settings SET enabled=1,activated_at=1 WHERE id=1',
+ )
+ .run()
+ await db
+ .prepare(
+ "INSERT INTO platform_users(id,email,email_verified,created_at,last_login_at,last_active_at) VALUES(1,'[email protected]',1,?,?,?)",
+ )
+ .bind(old, old, old)
+ .run()
+ const raced = {
+ prepare: db.prepare.bind(db),
+ batch: async (statements: any[]) => {
+ await db
+ .prepare('UPDATE platform_users SET last_active_at=? WHERE id=1')
+ .bind(now)
+ .run()
+ return db.batch(statements)
+ },
+ }
+ assert.equal(
+ await markAccount(
+ raced as any,
+ 1,
+ 'Inactive account',
+ 'inactive',
+ null,
+ now,
+ { login: old, activity: old, verified: 1, settingsRevision: 1 },
+ ),
+ false,
+ )
+ assert.equal(
+ await db
+ .prepare(
+ 'SELECT user_id FROM platform_account_deletions WHERE user_id=1',
+ )
+ .first(),
+ null,
+ )
+ await scanAccounts(db, now)
+ assert.equal(
+ await db
+ .prepare(
+ 'SELECT user_id FROM platform_account_deletions WHERE user_id=1',
+ )
+ .first(),
+ null,
+ )
+ assert.equal(
+ (
+ await db
+ .prepare('SELECT last_login_at FROM platform_users WHERE id=1')
+ .first()
+ ).last_login_at,
+ old,
+ )
+ } finally {
+ await mf.dispose()
+ }
+})
diff --git a/tests/cloud-session-activity.test.ts b/tests/cloud-session-activity.test.ts
new file mode 100644
index 00000000..d54f7be5
--- /dev/null
+++ b/tests/cloud-session-activity.test.ts
@@ -0,0 +1,110 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { readFile } from 'node:fs/promises'
+import { createRequire } from 'node:module'
+import { ACCOUNT_ACTIVITY_INTERVAL } from '../packages/platform/src/account-activity.ts'
+
+const require = createRequire(import.meta.url)
+const { transpileModule, ModuleKind, ScriptTarget } = require('typescript')
+const source = await readFile(
+ new URL(
+ '../apps/cloud/server/middleware/00-account-session.ts',
+ import.meta.url,
+ ),
+ 'utf8',
+)
+const code = transpileModule(
+ source.replace(/^import[\s\S]*?from ['"][^'"]+['"]\s*\n/gm, ''),
+ {
+ compilerOptions: {
+ module: ModuleKind.CommonJS,
+ target: ScriptTarget.ES2022,
+ },
+ },
+).outputText
+
+test('valid authenticated API requests record activity; fresh timestamps, anonymous/unverified/suspended identities do not write', async () => {
+ let cookie = true
+ let verified = true
+ let suspended = 0
+ let lastActive: number | null = null
+ let writes = 0
+ let reads = 0
+ const db = {
+ prepare() {
+ reads++
+ return {
+ bind() {
+ return {
+ async first() {
+ return { suspended, last_active_at: lastActive }
+ },
+ }
+ },
+ }
+ },
+ }
+ const evaluate = new Function(
+ 'exports',
+ 'defineEventHandler',
+ 'platformDatabase',
+ 'getCookie',
+ 'getRequestHeaders',
+ 'cloudAccount',
+ 'recordAccountActivity',
+ 'ACCOUNT_ACTIVITY_INTERVAL',
+ code + ';return exports.default',
+ )
+ const handler = evaluate(
+ {},
+ (v: unknown) => v,
+ () => db,
+ () => (cookie ? 'session' : undefined),
+ () => ({}),
+ async () => ({
+ api: {
+ getSession: async () => ({
+ user: { id: '1', emailVerified: verified },
+ session: { expiresAt: new Date(Date.now() + 86400000) },
+ }),
+ },
+ }),
+ async (_db: unknown, id: number, now: number) => {
+ assert.equal(id, 1)
+ writes++
+ lastActive = now
+ },
+ ACCOUNT_ACTIVITY_INTERVAL,
+ )
+ const request = async () => {
+ const event = { context: {} as any }
+ handler(event)
+ return event.context.platformSessionResolver()
+ }
+ assert.equal((await request()).userId, 1)
+ assert.equal(writes, 1)
+ await request()
+ assert.equal(
+ writes,
+ 1,
+ 'normal API reads inside the 5-minute window do not write',
+ )
+ lastActive = Date.now() - ACCOUNT_ACTIVITY_INTERVAL - 1000
+ await request()
+ assert.equal(
+ writes,
+ 2,
+ 'later API use refreshes activity without login or client events',
+ )
+ suspended = 1
+ assert.equal(await request(), null)
+ assert.equal(writes, 2)
+ suspended = 0
+ verified = false
+ assert.equal(await request(), null)
+ assert.equal(writes, 2)
+ const before = reads
+ cookie = false
+ assert.equal(await request(), null)
+ assert.equal(reads, before, 'anonymous requests do not access activity state')
+})