maxibase 1.6.0 → 1.7.0

package/README.md

@@ -37,6 +37,19 @@ DELETE FROM auth.credentials WHERE user_id = (SELECT id FROM auth.users WHERE em
 DELETE FROM auth.recovery_codes WHERE user_id = (SELECT id FROM auth.users WHERE email = 'user@example.com');
 ```
 
+### Deleting inactive users
+
+Each user's `last_active_on` is set to the day they last signed in or resumed a session. Set
+`NUXT_INACTIVE_USERS_RETENTION_DAYS` and the nightly `clean` task deletes the users inactive for
+longer, with everything that cascades from them and their `u/{id}` file folders, private and
+public. It is `0` by default, which keeps everyone. A user whose files can't be deleted is kept
+and retried the next night. A deleted user stays in the backups until they age out.
+
+`NUXT_INACTIVE_USERS_WARNING_DAYS` (30 by default) emails users that many days before, with
+their deletion date. A failed warning is retried every night but never delays the deletion,
+and signing in again cancels it. When the setting is first turned on, users already past the
+limit are deleted that night without a warning.
+
 ## Deployment
 
 ### On your server

package/layers/base/nuxt.config.ts

@@ -74,6 +74,10 @@ export default defineNuxtConfig({
     logs: {
       retentionDays: 90,
     },
+    inactiveUsers: {
+      retentionDays: 0, // delete users inactive for this many days, 0 keeps them forever
+      warningDays: 30, // email users this many days before deletion, 0 deletes without warning
+    },
     rateLimit: {
       enabled: true,
       banMultiplier: 5, // banned after limit × multiplier requests in one window

package/layers/base/server/api/auth/anonymous.post.ts

@@ -16,7 +16,10 @@ export default defineEventHandler(async (event) => {
     })
   }
 
-  const insertedUsers = await db.insert(auth).values({}).returning()
+  const insertedUsers = await db
+    .insert(auth)
+    .values({ locale: useLocaleServerMiddleware(event).current })
+    .returning()
 
   if (!insertedUsers[0]) {
     throw createError({

package/layers/base/server/api/auth/otp/verify.post.ts

@@ -26,7 +26,7 @@ export default defineEventHandler(async (event) => {
 async function signUp(event: H3Event, email: string) {
   const session = await getUserSession(event)
   if (session?.user?.isAnonymous) return setAuth({ id: session.user.id, email })
-  if (useRuntimeConfig().autoSignup) return createAuth({ email })
+  if (useRuntimeConfig().autoSignup) return createAuth({ email }, event)
   throw createError({ status: 404, message: 'User not found' })
 }
 

package/layers/base/server/database/schema.ts

@@ -4,6 +4,7 @@ import {
   text,
   integer,
   timestamp,
+  date,
   uuid,
   boolean,
   primaryKey,
@@ -23,6 +24,9 @@ export const auth = authSchema.table('users', {
   createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
   totp: text(),
   role: appRoleEnum().notNull().default('user'),
+  lastActiveOn: date({ mode: 'date' }).notNull().defaultNow(),
+  deletionWarnedOn: date({ mode: 'date' }),
+  locale: text(),
 })
 
 export const refreshTokens = authSchema.table('refresh_tokens', {

package/layers/base/server/middleware/1.session.ts

@@ -10,5 +10,6 @@ export default defineEventHandler(async (event) => {
 
     const sessionData = await setSession(event, user, false)
     session.user = sessionData?.user // to update the session on SSR
+    await updateLastActive(user.id)
   } catch {}
 })

package/layers/base/server/routes/auth/microsoft.get.ts

@@ -15,7 +15,7 @@ async function onSuccess(event: H3Event, { tokens }: { tokens: any }) {
     const config = useRuntimeConfig()
 
     if (error.statusCode === 404 && config.autoSignup) {
-      return createAuth({ email: claims.email })
+      return createAuth({ email: claims.email }, event)
     }
     throw error
   })

package/layers/base/server/tasks/clean.ts

@@ -1,7 +1,7 @@
 export default defineTask({
   meta: {
     name: 'clean',
-    description: 'Clean old backups, logs and unfinished uploads',
+    description: 'Clean old backups, logs, unfinished uploads and inactive users',
   },
   async run() {
     const config = useRuntimeConfig()
@@ -9,6 +9,7 @@ export default defineTask({
     const steps: [string, () => Promise<unknown>][] = [['backups', cleanOldBackups]]
     if (config.s3.privateBucket) steps.push(['S3 backups', cleanOldS3Backups])
     steps.push(['logs', cleanLogs], ['uploads', () => cleanTempUploads()])
+    if (config.inactiveUsers.retentionDays > 0) steps.push(['inactive users', cleanInactiveUsers])
 
     const results = await Promise.allSettled(steps.map(([, step]) => step()))
 

package/layers/base/server/utils/auth.ts

@@ -1,5 +1,5 @@
 import { auth, refreshTokens } from '#server/database/schema'
-import { eq, lte } from 'drizzle-orm'
+import { and, eq, inArray, isNotNull, isNull, lt, lte, or, sql } from 'drizzle-orm'
 import { createHash, randomBytes } from 'crypto'
 import type { H3Event } from 'h3'
 
@@ -45,11 +45,12 @@ export function requireUserVerification(userVerified: boolean) {
   }
 }
 
-export async function createAuth(user: Pick<AuthUser, 'email'>) {
+export async function createAuth(user: Pick<AuthUser, 'email'>, event: H3Event) {
   const insertedUsers = await db
     .insert(auth)
     .values({
       email: user.email?.trim().toLowerCase(),
+      locale: useLocaleServerMiddleware(event).current,
     })
     .returning()
   if (!insertedUsers[0]) {
@@ -162,8 +163,99 @@ export function hashRefreshToken(token: string) {
   return createHash('sha256').update(token).digest('base64url')
 }
 
+export async function updateLastActive(userId: string) {
+  await db
+    .update(auth)
+    .set({ lastActiveOn: sql`current_date` })
+    .where(and(eq(auth.id, userId), lt(auth.lastActiveOn, sql`current_date`)))
+}
+
+export async function cleanInactiveUsers() {
+  const { retentionDays, warningDays } = useRuntimeConfig().inactiveUsers
+  const inactive = lt(auth.lastActiveOn, sql`current_date - ${retentionDays}::int`)
+
+  const users = await db.select({ id: auth.id }).from(auth).where(inactive)
+  const ids: string[] = []
+  for (const { id } of users) {
+    await deleteUserFiles(id).then(
+      () => ids.push(id),
+      () => {},
+    )
+  }
+
+  if (ids.length) {
+    const deleted = await db
+      .delete(auth)
+      .where(and(inArray(auth.id, ids), inactive))
+      .returning({ id: auth.id })
+    await log(
+      `Deleted ${deleted.length} users inactive for ${retentionDays} days`,
+      undefined,
+      'clean task',
+    )
+  }
+
+  const failedWarnings = warningDays > 0 ? await warnInactiveUsers(retentionDays, warningDays) : 0
+
+  const errors = []
+  if (users.length > ids.length) {
+    errors.push(`files of ${users.length - ids.length} users could not be deleted`)
+  }
+  if (failedWarnings) errors.push(`${failedWarnings} warnings failed to send`)
+  if (errors.length) throw new Error(`Inactive users: ${errors.join(', ')}`)
+}
+
+async function warnInactiveUsers(retentionDays: number, warningDays: number) {
+  const warnAfterDays = Math.max(retentionDays - warningDays, 0)
+
+  const users = await db
+    .select({
+      id: auth.id,
+      email: auth.email,
+      locale: auth.locale,
+      lastActiveOn: auth.lastActiveOn,
+    })
+    .from(auth)
+    .where(
+      and(
+        lt(auth.lastActiveOn, sql`current_date - ${warnAfterDays}::int`),
+        isNotNull(auth.email),
+        or(isNull(auth.deletionWarnedOn), lte(auth.deletionWarnedOn, auth.lastActiveOn)),
+      ),
+    )
+
+  let failed = 0
+  for (const user of users) {
+    // The first nightly run where lastActiveOn < current_date - retentionDays
+    const deletionOn = new Date(user.lastActiveOn.getTime() + daysToMilliseconds(retentionDays + 1))
+    const locale = user.locale ?? 'en'
+    const date = new Intl.DateTimeFormat(locale, { dateStyle: 'long', timeZone: 'UTC' }).format(
+      deletionOn,
+    )
+    try {
+      await sendEmailTemplate('inactiveDeletion', locale, { date }, user.email!)
+      await db
+        .update(auth)
+        .set({ deletionWarnedOn: sql`current_date` })
+        .where(eq(auth.id, user.id))
+    } catch {
+      failed++
+    }
+  }
+
+  if (users.length > failed) {
+    await log(
+      `Warned ${users.length - failed} inactive users of their deletion`,
+      undefined,
+      'clean task',
+    )
+  }
+  return failed
+}
+
 export async function createRefreshToken(userId: string, event: H3Event) {
   const token = generateRefreshToken()
+  await updateLastActive(userId)
 
   await db.insert(refreshTokens).values({
     userId,

package/layers/base/server/utils/files.ts

@@ -386,6 +386,20 @@ export async function getFile(
 
 export async function deletePath(event: H3Event, path: string, isPrivate = true) {
   await checkFileAccess(event, path)
+  await removePath(path, isPrivate)
+}
+
+// The u/{id} folders of the default checkFileAccess, private and public
+export async function deleteUserFiles(userId: string) {
+  const { s3 } = useRuntimeConfig()
+  for (const isPrivate of [true, false]) {
+    if (useS3() && !(isPrivate ? s3.privateBucket : s3.publicBucket)) continue
+    await removePath(`u/${userId}`, isPrivate)
+  }
+}
+
+// No access check, for server code acting on its own
+async function removePath(path: string, isPrivate: boolean) {
   path = getSecurePath(path, isPrivate)
   // An empty path resolves to the root folder, deleting it would wipe every file
   if (path === getSecurePath('', isPrivate)) throw invalidPath()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maxibase",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Nuxt layer with auth, files, logs and backups",
   "keywords": [
     "nuxt",

package/server/assets/emails/en/inactiveDeletion.html

@@ -0,0 +1,12 @@
+<title>Your {{appName}} account will be deleted</title>
+<p>
+  You haven't used {{appName}} for a long time, so your account and its data will be deleted on
+  {{date}}.
+</p>
+<p>To keep them, sign in before then.</p>
+<a
+  href="{{url}}"
+  class="button"
+>
+  Sign in
+</a>

package/server/assets/emails/fr/inactiveDeletion.html

@@ -0,0 +1,12 @@
+<title>Votre compte {{appName}} va être supprimé</title>
+<p>
+  Vous n'avez pas utilisé {{appName}} depuis longtemps, votre compte et ses données seront donc
+  supprimés le {{date}}.
+</p>
+<p>Pour les conserver, connectez-vous d'ici là.</p>
+<a
+  href="{{url}}"
+  class="button"
+>
+  Se connecter
+</a>