feat(profile): add account reset and delete (#60)

* feat(profile): add wipeSifaData helper for profile reset/delete

* fix(profile): add pagination and batching to wipeSifaData

* feat(profile): add reset and delete account endpoints

* fix(profile): improve error handling in reset/delete endpoints

* style: fix prettier formatting

src/routes/profile-write.ts

···
 } from '../services/pds-writer.js';
 import { createAuthMiddleware, getAuthContext } from '../middleware/auth.js';
 import { sanitize, sanitizeOptional } from '../lib/sanitize.js';
+import { wipeSifaData } from '../services/profile-wipe.js';
+import {
+  sessions as sessionsTable,
+  oauthSessions as oauthSessionsTable,
+} from '../db/schema/index.js';
 
 const overrideSchema = z.object({
   headline: z.string().max(300).nullish(),
···
 
     return reply.status(200).send({ ok: true });
   });
+
+  // DELETE /api/profile/reset -- wipe all Sifa data from PDS and local DB (keep account)
+  app.delete(
+    '/api/profile/reset',
+    { preHandler: requireAuth, config: { rateLimit: { max: 3, timeWindow: '1 hour' } } },
+    async (request, reply) => {
+      const { did, session } = getAuthContext(request);
+
+      try {
+        await wipeSifaData(session, did, db);
+      } catch (err) {
+        app.log.error({ err, did }, 'Profile reset failed');
+        return reply
+          .status(500)
+          .send({ error: 'ResetFailed', message: 'Failed to reset profile data' });
+      }
+
+      app.log.info({ did }, 'Profile reset completed');
+      return reply.status(200).send({ ok: true });
+    },
+  );
+
+  // DELETE /api/profile/account -- wipe all Sifa data, then logout and destroy session
+  app.delete(
+    '/api/profile/account',
+    { preHandler: requireAuth, config: { rateLimit: { max: 3, timeWindow: '1 hour' } } },
+    async (request, reply) => {
+      const { did, session } = getAuthContext(request);
+      let handle: string | undefined;
+
+      try {
+        // Read handle before wiping so we can return it for redirect
+        const [profileRow] = await db
+          .select({ handle: profilesTable.handle })
+          .from(profilesTable)
+          .where(eq(profilesTable.did, did))
+          .limit(1);
+        handle = profileRow?.handle ?? undefined;
+
+        await wipeSifaData(session, did, db);
+      } catch (err) {
+        app.log.error({ err, did }, 'Account deletion failed');
+        return reply
+          .status(500)
+          .send({ error: 'DeleteFailed', message: 'Failed to delete account' });
+      }
+
+      // Logout: destroy session and revoke OAuth tokens
+      const sessionId = request.cookies?.session;
+      if (sessionId) {
+        await db.delete(sessionsTable).where(eq(sessionsTable.id, sessionId));
+      }
+      await db
+        .delete(oauthSessionsTable)
+        .where(eq(oauthSessionsTable.did, did))
+        .catch((err: unknown) => {
+          app.log.error({ err, did }, 'Failed to delete OAuth sessions during account deletion');
+        });
+      if (oauthClient) {
+        await oauthClient.revoke(did).catch((err: unknown) => {
+          app.log.warn({ err, did }, 'Failed to revoke OAuth token during account deletion');
+        });
+      }
+      reply.clearCookie('session', { path: '/' });
+
+      app.log.info({ did }, 'Account deletion completed');
+      return reply.status(200).send({ ok: true, handle });
+    },
+  );
 }

src/services/profile-wipe.ts

···
+import { Agent } from '@atproto/api';
+import type { OAuthSession } from '@atproto/oauth-client';
+import { eq } from 'drizzle-orm';
+import { buildApplyWritesOp, writeToUserPds } from './pds-writer.js';
+import type { ApplyWritesOp } from './pds-writer.js';
+import type { Database } from '../db/index.js';
+import { profiles, externalAccountVerifications } from '../db/schema/index.js';
+
+const SIFA_COLLECTIONS = [
+  'id.sifa.profile.self',
+  'id.sifa.profile.position',
+  'id.sifa.profile.education',
+  'id.sifa.profile.skill',
+  'id.sifa.profile.certification',
+  'id.sifa.profile.project',
+  'id.sifa.profile.volunteering',
+  'id.sifa.profile.publication',
+  'id.sifa.profile.course',
+  'id.sifa.profile.honor',
+  'id.sifa.profile.language',
+  'id.sifa.profile.externalAccount',
+] as const;
+
+export { SIFA_COLLECTIONS };
+
+export async function buildPdsDeleteOps(
+  agent: Agent,
+  did: string,
+  collections: readonly string[],
+): Promise<ApplyWritesOp[]> {
+  const ops: ApplyWritesOp[] = [];
+  for (const collection of collections) {
+    let cursor: string | undefined;
+    do {
+      const existing = await agent.com.atproto.repo.listRecords({
+        repo: did,
+        collection,
+        limit: 100,
+        cursor,
+      });
+      for (const rec of existing.data.records) {
+        const rkey = rec.uri.split('/').pop() ?? '';
+        if (rkey) ops.push(buildApplyWritesOp('delete', collection, rkey));
+      }
+      cursor = existing.data.cursor;
+    } while (cursor);
+  }
+  return ops;
+}
+
+export async function wipeSifaData(
+  session: OAuthSession,
+  did: string,
+  db: Database,
+): Promise<void> {
+  const agent = new Agent(session);
+  const ops = await buildPdsDeleteOps(agent, did, SIFA_COLLECTIONS);
+
+  // applyWrites has a 200-op limit per call
+  const BATCH_SIZE = 200;
+  for (let i = 0; i < ops.length; i += BATCH_SIZE) {
+    const batch = ops.slice(i, i + BATCH_SIZE);
+    await writeToUserPds(session, did, batch);
+  }
+
+  await db.delete(profiles).where(eq(profiles.did, did));
+  await db.delete(externalAccountVerifications).where(eq(externalAccountVerifications.did, did));
+}

tests/routes/profile-reset.test.ts

···
+import { describe, it, expect } from 'vitest';
+import {
+  wipeSifaData,
+  buildPdsDeleteOps,
+  SIFA_COLLECTIONS,
+} from '../../src/services/profile-wipe.js';
+
+describe('profile-wipe module', () => {
+  it('exports wipeSifaData as a function', () => {
+    expect(typeof wipeSifaData).toBe('function');
+  });
+
+  it('exports buildPdsDeleteOps as a function', () => {
+    expect(typeof buildPdsDeleteOps).toBe('function');
+  });
+
+  it('exports SIFA_COLLECTIONS with all 12 lexicon collections', () => {
+    expect(SIFA_COLLECTIONS).toHaveLength(12);
+    expect(SIFA_COLLECTIONS).toContain('id.sifa.profile.self');
+    expect(SIFA_COLLECTIONS).toContain('id.sifa.profile.position');
+    expect(SIFA_COLLECTIONS).toContain('id.sifa.profile.skill');
+    expect(SIFA_COLLECTIONS).toContain('id.sifa.profile.externalAccount');
+  });
+});
+
+describe('reset and delete endpoint signatures', () => {
+  it('wipeSifaData expects three parameters (session, did, db)', () => {
+    // wipeSifaData(session, did, db) -> 3 params
+    expect(wipeSifaData.length).toBe(3);
+  });
+});

tests/services/profile-wipe.test.ts

···
+import { describe, it, expect, vi } from 'vitest';
+import { buildPdsDeleteOps } from '../../src/services/profile-wipe.js';
+import type { Agent } from '@atproto/api';
+
+function createMockAgent(recordsByCollection: Record<string, Array<{ uri: string }>>): Agent {
+  return {
+    com: {
+      atproto: {
+        repo: {
+          listRecords: vi.fn(async ({ collection }: { collection: string }) => ({
+            data: {
+              records: recordsByCollection[collection] ?? [],
+            },
+          })),
+        },
+      },
+    },
+  } as unknown as Agent;
+}
+
+describe('buildPdsDeleteOps', () => {
+  it('returns delete ops for records returned by listRecords', async () => {
+    const agent = createMockAgent({
+      'id.sifa.profile.position': [
+        { uri: 'at://did:plc:abc/id.sifa.profile.position/3abc' },
+        { uri: 'at://did:plc:abc/id.sifa.profile.position/3def' },
+      ],
+    });
+
+    const ops = await buildPdsDeleteOps(agent, 'did:plc:abc', ['id.sifa.profile.position']);
+
+    expect(ops).toHaveLength(2);
+    expect(ops[0]).toEqual({
+      $type: 'com.atproto.repo.applyWrites#delete',
+      collection: 'id.sifa.profile.position',
+      rkey: '3abc',
+    });
+    expect(ops[1]).toEqual({
+      $type: 'com.atproto.repo.applyWrites#delete',
+      collection: 'id.sifa.profile.position',
+      rkey: '3def',
+    });
+  });
+
+  it('returns empty array when no records exist', async () => {
+    const agent = createMockAgent({});
+
+    const ops = await buildPdsDeleteOps(agent, 'did:plc:abc', [
+      'id.sifa.profile.self',
+      'id.sifa.profile.skill',
+    ]);
+
+    expect(ops).toEqual([]);
+  });
+
+  it('iterates all provided collections', async () => {
+    const agent = createMockAgent({
+      'id.sifa.profile.self': [{ uri: 'at://did:plc:abc/id.sifa.profile.self/self' }],
+      'id.sifa.profile.skill': [{ uri: 'at://did:plc:abc/id.sifa.profile.skill/ts' }],
+      'id.sifa.profile.education': [{ uri: 'at://did:plc:abc/id.sifa.profile.education/uni1' }],
+    });
+
+    const collections = [
+      'id.sifa.profile.self',
+      'id.sifa.profile.skill',
+      'id.sifa.profile.education',
+    ];
+
+    const ops = await buildPdsDeleteOps(agent, 'did:plc:abc', collections);
+
+    expect(ops).toHaveLength(3);
+
+    const collectionsInOps = ops.map((op) => op.collection);
+    expect(collectionsInOps).toContain('id.sifa.profile.self');
+    expect(collectionsInOps).toContain('id.sifa.profile.skill');
+    expect(collectionsInOps).toContain('id.sifa.profile.education');
+
+    const listRecords = agent.com.atproto.repo.listRecords as ReturnType<typeof vi.fn>;
+    expect(listRecords).toHaveBeenCalledTimes(3);
+    for (const col of collections) {
+      expect(listRecords).toHaveBeenCalledWith({
+        repo: 'did:plc:abc',
+        collection: col,
+        limit: 100,
+      });
+    }
+  });
+});