Self-hosted personal gallery application with online photo management and albums, supporting Live/Motion Photos, EXIF parsing, geolocation recognition, and an explore map.
TypeScript albumsexif-extractiongeocodinglive-photomotion-photophoto-galleryphoto-sharingwebgl-viewer
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.tsindex 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.sqlnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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 | nullverified: numbersettingsRevision: 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.tsnew file mode 100644index 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.tsindex 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-eawait 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.tsnew file mode 100644index 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')+})