advances for accounts edit

lexicons/app/wafrn/actor/cacheAccount.json

···
+{
+  "lexicon": 1,
+  "id": "app.wafrn.actor.cacheAccount",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Cache account in the appview for indexing. Requires authentication.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "did": { "type": "string", "format": "did" },
+            "handle": { "type": "string", "format": "handle" },
+            "active": { "type": "boolean" },
+            "status": {
+              "type": "string",
+              "knownValues": ["deactivated", "suspended", "takendown"]
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "updated_at": { "type": "string", "format": "datetime" }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/app/wafrn/actor/defs.json

···
         "status": { "type": "string" },
         "wafrn": { "type": "ref", "ref": "#profileView" }
       }
+    },
+    "customField": {
+      "type": "object",
+      "required": ["key", "value"],
+      "properties": {
+        "key": {
+          "type": "string",
+          "description": "Field name",
+          "maxLength": 64
+        },
+        "value": {
+          "type": "string",
+          "description": "Field value",
+          "maxLength": 256
+        }
+      }
     }
   }
 }

packages/client/app/components/UserMenu.tsx

···
             <Link to={`/profile/${handle}`}>Your profile</Link>
           </li>
           <li>
+            <Link to="/settings/account">Account settings</Link>
+          </li>
+          <li>
             <Link to="/settings/delegation">Private posts setup</Link>
           </li>
           <li>

packages/client/app/lib/oauthClient.server.ts

···
   keys.map((k) => JoseKey.fromImportable(JSON.stringify(k), k.kid))
 )
 
-const createOAuthClient = (baseUrl?: string) => {
-  const scope = 'atproto transition:generic' as const
+const AUTH_SCOPES = [
+  'atproto',
+  'transition:generic',
+  'repo:*',
+  'blob:*/*',
+  'account:email',
+  'identity:handle'
+].join(' ')
 
+const createOAuthClient = (baseUrl?: string) => {
   if (env.IS_PROD && !baseUrl) {
     throw new Error('baseUrl for OAuth is required in production')
   }
···
   const url = baseUrl || `http://127.0.0.1:${env.PORT}`
   const localParams = new URLSearchParams({
     redirect_uri: `${url}/oauth/callback`,
-    scope
+    scope: AUTH_SCOPES
   })
+  console.log('localParams: ', localParams.toString())
 
   return new NodeOAuthClient({
     clientMetadata: {
···
         : `http://localhost?${localParams.toString()}`,
       client_uri: url,
       redirect_uris: [`${url}/oauth/callback`],
-      scope,
+      scope: AUTH_SCOPES,
       grant_types: ['authorization_code', 'refresh_token'],
       response_types: ['code'],
       application_type: 'web',

packages/client/app/lib/profile.server.ts

···
-import type { Handle } from '@atcute/lexicons'
+import type { Did, Handle } from '@atcute/lexicons'
 import {
   getPublicAgent,
   getPublicServiceAgent,
···
 import { getRelationship } from './follow.server'
 import asyncWrap from './asyncWrap'
 import { handleToDid } from './idResolver.server'
+import type { OAuthSession } from '@atproto/oauth-client-node'
+import type { AppBskyActorProfile } from '@atcute/bluesky'
 
 export async function getProfileData(request: Request, handle: Handle) {
   const [session] = await asyncWrap(() => getOAuthSession(request))
-  const sessionAgent = session ? getSessionAgent(session) : getPublicAgent()
   const serviceDid =
     `did:web:${encodeURIComponent(new URL(env.API_URL).host)}` as const
   const serverClient = session
···
   // Fetch all data in parallel
   const [feed, profile, wafrnProfiles, relationship] = await Promise.all([
     getFeed(session, handle),
-    ok(
-      sessionAgent.get('app.bsky.actor.getProfile', {
-        params: { actor: profileDid }
-      })
-    ),
+    getProfile(session, profileDid),
     ok(
       serverClient.get('app.wafrn.actor.getProfiles', {
         params: { actors: [profileDid], includeCounts: true }
···
     feed: feed ?? []
   }
 }
+
+export async function getProfile(session?: OAuthSession | null, did?: Did) {
+  const profileDid = did ?? session?.did
+  if (!profileDid) {
+    throw new Error('No DID provided for getProfile')
+  }
+
+  const agent = session
+    ? getSessionAgent(session)
+    : getPublicServiceAgent(env.DEFAULT_PDS_URL as HTTPURL)
+  const profileReq = await agent.get('com.atproto.repo.getRecord', {
+    params: {
+      collection: 'app.bsky.actor.profile',
+      rkey: 'self',
+      repo: profileDid
+    }
+  })
+  if (!profileReq.ok) {
+    console.error(profileReq.data)
+    return null
+  }
+  return profileReq.data.value as AppBskyActorProfile.Main
+}

packages/client/app/lib/user.server.ts

···
 import { StatusError } from './https'
-import { getSessionAgent, type XRPCLient } from '@www/lib/xrpcClient'
-import type { Did } from '@atcute/lexicons'
+import { getSessionAgent } from '@www/lib/xrpcClient'
 import { getOAuthSession } from './oauth.server'
-import { didDocResolver } from './idResolver.server'
-import { getAtprotoHandle } from '@atcute/identity'
+import { ok } from '@atcute/client'
+import { getProfile } from './profile.server'
 
 export async function getCurrentUser(request: Request) {
   try {
     const session = await getOAuthSession(request)
-    const client = getSessionAgent(session)
-    const didDoc = await didDocResolver.resolve(session.did)
-    const identity = {
-      did: session.did,
-      didDoc,
-      handle: getAtprotoHandle(didDoc)
-    }
-    const profile = await getProfile(client, session.did)
+    const agent = getSessionAgent(session)
+    const identity = await ok(agent.get('com.atproto.server.getSession'))
+    const profile = await getProfile(session)
     return { profile, identity }
   } catch (error) {
     const isStatusError =
···
     return null
   }
 }
-
-export async function getProfile(agent: XRPCLient, did: Did) {
-  // if no 'app.bsky.actor.profile' record is found on the user's PDS, this method will not return an error
-  // instead it will return an empty skeleton of a profile record with "handle" set to "handle.invalid"
-  // const profile = await agent.getProfile(
-  //   didOrHandle ? { actor: didOrHandle } : undefined
-  // )
-  const profile = await agent.get('app.bsky.actor.getProfile', {
-    params: { actor: did }
-  })
-  if (!profile.ok) {
-    throw new Error('Failed to fetch profile')
-  }
-
-  const data = profile.data.handle === 'handle.invalid' ? null : profile.data
-  return data
-}

packages/client/app/lib/xrpcClient.ts

···
   Client,
   ok,
   simpleFetchHandler,
+  CredentialManager,
   type FetchHandler
 } from '@atcute/client'
 
···
 import type {} from '@atcute/atproto'
 import type {} from '@watproto/lexicon'
 
-import type { Did, Nsid } from '@atcute/lexicons'
+import type { Did, Handle, Nsid } from '@atcute/lexicons'
 import { didWebToUrl, type OAuthSession } from '@atproto/oauth-client-node'
 import { KeyserverClient } from '@atpkeyserver/client'
 import { env } from './env.server'
 
 export type XRPCLient = Awaited<ReturnType<typeof getSessionAgent>>
+
+/**
+ * This agent is what you need to use to edit your account settings like email, password, handle, etc.
+ * This has elevated privileges greater than the session agent, so use it with caution.
+ */
+export async function getLoginAgent(
+  serviceUrl: string,
+  handle: Handle,
+  password: string
+) {
+  const loginManager = new CredentialManager({
+    service: serviceUrl
+  })
+  await loginManager.login({
+    identifier: handle,
+    password
+  })
+  return new Client({ handler: loginManager })
+}
 
 export function getSessionAgent(session: OAuthSession) {
   const client = new Client({ handler: session.fetchHandler.bind(session) })

packages/client/app/routes/oauth.$.tsx

···
 import keys from '@www/jwks.json'
 import { commitSession, getSession } from '@www/lib/session.server'
 import { redirect } from 'react-router'
+import { getServiceAgent, getSessionAgent } from '@www/lib/xrpcClient'
+import { env } from '@www/lib/env.server'
+import { ok } from '@atcute/client'
 
 const publicKeys = keys.map((k) => {
   const { kty, alg, kid, crv, x, y } = k
   return { kty, alg, kid, crv, x, y }
 })
+
+const serviceDid =
+  `did:web:${encodeURIComponent(new URL(env.API_URL).host)}` as const
 
 export async function loader({ params, request }: Route.LoaderArgs) {
   const path = params['*']
···
         type: 'success',
         message: 'You are now logged in'
       })
+      const { did, handle, status, active } = await ok(
+        getSessionAgent(session).get('com.atproto.server.getSession')
+      )
+      const agent = getServiceAgent(session, serviceDid)
+      await agent.post('app.wafrn.actor.cacheAccount', {
+        input: { did, handle, status, active }
+      })
+
+      // call app.wafrn.actor.updateProfile with { last_login_at: Date.now() }
       const redirectUrl = new URL(state ?? '/', request.url).toString()
       return redirect(redirectUrl, {
         headers: {

packages/client/app/routes/profile.$handle.tsx

···
 import type { Route } from './+types/profile.$handle'
-import type { Handle, Did, ResourceUri } from '@atcute/lexicons'
+import type { Handle, Did, ResourceUri, Blob } from '@atcute/lexicons'
 import { Form, useLoaderData, useNavigation } from 'react-router'
 import PostFeed from '@www/components/PostFeed'
 import asyncWrap from '@www/lib/asyncWrap'
···
     buttonVariant = 'btn-primary'
   }
 
+  function formatAvatarBlob(blob: Blob) {
+    const blobId = blob.ref?.$link
+    return blobId
+      ? `https://cdn.bsky.app/img/avatar/plain/${did}/${blobId}@jpeg`
+      : ''
+  }
+
   return (
     <div className="px-2 py-4 max-w-4xl mx-auto">
       {/* Profile Header */}
···
           {/* Avatar */}
           {profile?.avatar && (
             <img
-              src={profile.avatar}
+              src={formatAvatarBlob(profile.avatar as Blob<'image/png'>)}
               alt={profile.displayName || handle}
               className="w-20 h-20 rounded-full object-cover"
             />

packages/client/app/routes/settings.account.tsx

···
+import { Form, data } from 'react-router'
+import type { Route } from './+types/settings.account'
+import { getOAuthSession } from '@www/lib/oauth.server'
+import { useRootData } from '@www/lib/useRootData'
+import { getLoginAgent, getSessionAgent } from '@www/lib/xrpcClient'
+import { ok } from '@atcute/client'
+import type { Handle } from '@atcute/lexicons'
+
+export async function action({ request }: Route.ActionArgs) {
+  const session = await getOAuthSession(request)
+  const formData = await request.formData()
+  const action = formData.get('action')
+
+  try {
+    if (action === 'update-email') {
+      const handle = String(formData.get('handle')) as Handle
+      const newEmail = String(formData.get('email') ?? '')
+      if (!newEmail) {
+        throw new Error('"email" is required in body')
+      }
+      const password = String(formData.get('password') ?? '')
+      if (!password) {
+        throw new Error('"password" is required in body')
+      }
+      const agent = await getLoginAgent(session.server.issuer, handle, password)
+      await ok(
+        agent.post('com.atproto.server.updateEmail', {
+          as: 'bytes',
+          input: {
+            email: newEmail
+          }
+        })
+      )
+
+      return data({
+        success: true,
+        message:
+          'Email update initiated. Please check your inbox for verification.'
+      })
+    } else if (action === 'update-handle') {
+      const newHandle = String(formData.get('handle') ?? '') as Handle
+      if (!newHandle) {
+        throw new Error('"handle" is required in body')
+      }
+      const agent = getSessionAgent(session)
+      await ok(
+        agent.post('com.atproto.identity.updateHandle', {
+          as: 'bytes',
+          input: {
+            handle: newHandle
+          }
+        })
+      )
+
+      return data({
+        success: true,
+        message: 'Handle updated successfully.'
+      })
+    } else if (action === 'update-password') {
+      // // TODO: Implement password update via XRPC
+      // const handle = String(formData.get('handle') ?? '') as Handle
+      // const currentPassword = String(formData.get('current_password') ?? '')
+      // const newPassword = String(formData.get('new_password') ?? '')
+      // const confirmPassword = String(formData.get('confirm_password') ?? '')
+      // if (newPassword !== confirmPassword) {
+      //   return data(
+      //     {
+      //       success: false,
+      //       message: 'New passwords do not match.'
+      //     },
+      //     { status: 400 }
+      //   )
+      // }
+      // return data({
+      //   success: true,
+      //   message: 'Password updated successfully.'
+      // })
+    }
+  } catch (error) {
+    return data(
+      {
+        success: false,
+        message: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`
+      },
+      { status: 500 }
+    )
+  }
+}
+
+export default function AccountSettings({ actionData }: Route.ComponentProps) {
+  const { user } = useRootData()
+
+  if (!user) {
+    return (
+      <div className="px-4 py-6 max-w-3xl mx-auto">
+        <div className="alert alert-error">
+          Please log in to access account settings.
+        </div>
+      </div>
+    )
+  }
+
+  const handle = user.identity.handle
+  const email = user.identity.email
+  const emailConfirmed = user.identity.emailConfirmed
+
+  return (
+    <div className="px-4 py-6 max-w-3xl mx-auto">
+      <h1 className="text-2xl font-bold mb-6">Account Settings</h1>
+
+      {actionData?.message && (
+        <div
+          className={`alert alert-soft ${actionData.success ? 'alert-success' : 'alert-error'} mb-4`}
+        >
+          {actionData.message}
+        </div>
+      )}
+
+      {/* Email Section */}
+      <div className="card bg-base-200 shadow-xl mb-6">
+        <div className="card-body">
+          <h2 className="card-title">Email Address</h2>
+          <p className="text-sm opacity-70 mb-4">
+            Update your email address for account notifications and recovery.
+          </p>
+
+          <div className="mb-4">
+            <p className="text-sm font-semibold mb-1">Current Email:</p>
+            <p className="text-sm opacity-70">{email}</p>
+          </div>
+
+          <Form method="POST">
+            <input type="hidden" name="handle" value={handle ?? ''} />
+            <fieldset className="fieldset">
+              <legend className="fieldset-legend">New Email</legend>
+              <input
+                type="email"
+                name="email"
+                placeholder="[e-mail]"
+                className="input"
+                required
+              />
+            </fieldset>
+            <fieldset className="fieldset">
+              <legend className="fieldset-legend">Your current password</legend>
+              <input
+                type="password"
+                name="password"
+                placeholder="******"
+                className="input"
+                required
+              />
+            </fieldset>
+            <button
+              type="submit"
+              name="action"
+              value="update-email"
+              className="btn btn-primary mt-3"
+            >
+              {emailConfirmed ? 'Request Email Change' : 'Update Email'}
+            </button>
+          </Form>
+        </div>
+      </div>
+
+      {/* Handle Section */}
+      <div className="card bg-base-200 shadow-xl mb-6">
+        <div className="card-body">
+          <h2 className="card-title">Handle</h2>
+          <p className="text-sm opacity-70 mb-4">
+            Your handle is your unique identifier on ATProto. Changing it will
+            update how others find and mention you.
+          </p>
+
+          <div className="mb-4">
+            <p className="text-sm font-semibold mb-1">Current Handle:</p>
+            <p className="text-sm opacity-70 font-mono">@{handle}</p>
+          </div>
+
+          <Form
+            method="POST"
+            className="flex flex-wrap gap-1 items-center mb-4"
+          >
+            <fieldset className="fieldset min-w-1/2">
+              <legend className="fieldset-legend">New Handle</legend>
+              <label className="input w-full">
+                <span className="label mr-0">@</span>
+                <input
+                  type="text"
+                  name="handle"
+                  placeholder="your.new.handle"
+                  pattern="[a-zA-Z0-9.-]+"
+                  required
+                />
+              </label>
+              <p className="label opacity-70">
+                Only letters, numbers, dots, and hyphens allowed
+              </p>
+            </fieldset>
+            <button
+              type="submit"
+              name="action"
+              value="update-handle"
+              className="btn btn-primary mt-2"
+            >
+              Update Handle
+            </button>
+          </Form>
+        </div>
+      </div>
+
+      <p className="mb-4">Coming Soon</p>
+
+      {/* Password Section */}
+      <div className="card bg-base-200 shadow-xl mb-6 opacity-50 pointer-events-none">
+        <div className="card-body">
+          <h2 className="card-title">Password</h2>
+          <p className="text-sm opacity-70 mb-4">
+            Change your account password. Make sure to use a strong, unique
+            password.
+          </p>
+
+          <Form method="POST">
+            <fieldset className="fieldset mb-4">
+              <legend className="fieldset-legend">Current Password</legend>
+              <input
+                type="password"
+                name="current_password"
+                placeholder="Enter your current password"
+                className="input input-bordered"
+                required
+              />
+            </fieldset>
+
+            <fieldset className="fieldset mb-4">
+              <legend className="fieldset-legend">New Password</legend>
+              <input
+                type="password"
+                name="new_password"
+                placeholder="Enter your new password"
+                className="input input-bordered"
+                minLength={8}
+                required
+              />
+              <p className="label opacity-70">Minimum 8 characters</p>
+            </fieldset>
+
+            <fieldset className="fieldset mb-4">
+              <legend className="fieldset-legend">Confirm New Password</legend>
+              <input
+                type="password"
+                name="confirm_password"
+                placeholder="Confirm your new password"
+                className="input input-bordered"
+                minLength={8}
+                required
+              />
+            </fieldset>
+
+            <div className="card-actions">
+              <button
+                type="submit"
+                name="action"
+                disabled
+                value="update-password"
+                className="btn btn-warning"
+              >
+                Change Password
+              </button>
+            </div>
+          </Form>
+        </div>
+      </div>
+    </div>
+  )
+}

packages/client/tsconfig.json

···
     "**/.client/**/*",
     ".react-router/types/**/*"
   ],
+  "exclude": ["./build/**/*"],
   "compilerOptions": {
     "lib": ["DOM", "DOM.Iterable", "ES2022"],
     "types": ["node", "vite/client", "@types/bun"],

packages/lexicon/index.ts

···
+export * as AppWafrnActorCacheAccount from "./types/app/wafrn/actor/cacheAccount.js";
 export * as AppWafrnActorDefs from "./types/app/wafrn/actor/defs.js";
 export * as AppWafrnActorGetProfiles from "./types/app/wafrn/actor/getProfiles.js";
 export * as AppWafrnActorProfile from "./types/app/wafrn/actor/profile.js";

packages/lexicon/types/app/wafrn/actor/cacheAccount.ts

···
+import type {} from "@atcute/lexicons";
+import * as v from "@atcute/lexicons/validations";
+import type {} from "@atcute/lexicons/ambient";
+
+const _mainSchema = /*#__PURE__*/ v.procedure("app.wafrn.actor.cacheAccount", {
+  params: null,
+  input: {
+    type: "lex",
+    schema: /*#__PURE__*/ v.object({
+      active: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.boolean()),
+      did: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.didString()),
+      handle: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.handleString()),
+      status: /*#__PURE__*/ v.optional(
+        /*#__PURE__*/ v.string<
+          "deactivated" | "suspended" | "takendown" | (string & {})
+        >(),
+      ),
+    }),
+  },
+  output: {
+    type: "lex",
+    schema: /*#__PURE__*/ v.object({
+      updated_at: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.datetimeString()),
+    }),
+  },
+});
+
+type main$schematype = typeof _mainSchema;
+
+export interface mainSchema extends main$schematype {}
+
+export const mainSchema = _mainSchema as mainSchema;
+
+export interface $params {}
+export interface $input extends v.InferXRPCBodyInput<mainSchema["input"]> {}
+export interface $output extends v.InferXRPCBodyInput<mainSchema["output"]> {}
+
+declare module "@atcute/lexicons/ambient" {
+  interface XRPCProcedures {
+    "app.wafrn.actor.cacheAccount": mainSchema;
+  }
+}

packages/lexicon/types/app/wafrn/actor/defs.ts

···
 import * as v from "@atcute/lexicons/validations";
 import * as AppWafrnActorProfile from "./profile.js";
 
+const _customFieldSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("app.wafrn.actor.defs#customField"),
+  ),
+  /**
+   * Field name
+   * @maxLength 64
+   */
+  key: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [
+    /*#__PURE__*/ v.stringLength(0, 64),
+  ]),
+  /**
+   * Field value
+   * @maxLength 256
+   */
+  value: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [
+    /*#__PURE__*/ v.stringLength(0, 256),
+  ]),
+});
 const _profileViewSchema = /*#__PURE__*/ v.object({
   $type: /*#__PURE__*/ v.optional(
     /*#__PURE__*/ v.literal("app.wafrn.actor.defs#profileView"),
···
   },
 });
 
+type customField$schematype = typeof _customFieldSchema;
 type profileView$schematype = typeof _profileViewSchema;
 type profileViewDetailed$schematype = typeof _profileViewDetailedSchema;
 
+export interface customFieldSchema extends customField$schematype {}
 export interface profileViewSchema extends profileView$schematype {}
 export interface profileViewDetailedSchema
   extends profileViewDetailed$schematype {}
 
+export const customFieldSchema = _customFieldSchema as customFieldSchema;
 export const profileViewSchema = _profileViewSchema as profileViewSchema;
 export const profileViewDetailedSchema =
   _profileViewDetailedSchema as profileViewDetailedSchema;
 
+export interface CustomField extends v.InferInput<typeof customFieldSchema> {}
 export interface ProfileView extends v.InferInput<typeof profileViewSchema> {}
 export interface ProfileViewDetailed
   extends v.InferInput<typeof profileViewDetailedSchema> {}

packages/server/src/db/migrations/1762527898283_social_graph.ts

···
     .createTable('follow_counts')
     .addColumn('did', 'text', (col) => col.primaryKey().notNull())
     .addColumn('follower_count', 'integer', (col) => col.notNull().defaultTo(0))
-    .addColumn('following_count', 'integer', (col) => col.notNull().defaultTo(0))
+    .addColumn('following_count', 'integer', (col) =>
+      col.notNull().defaultTo(0)
+    )
     .addColumn('updated_at', 'integer', (col) =>
       col.notNull().defaultTo(sql`(unixepoch() * 1000)`)
     )
···
     .addColumn('description', 'text')
     .addColumn('banner_url', 'text')
     // Timestamps
-    .addColumn('profile_cached_at', 'integer')
-    .addColumn('wafrn_updated_at', 'integer', (col) =>
+    .addColumn('indexed_at', 'integer', (col) =>
+      col.notNull().defaultTo(sql`(unixepoch() * 1000)`)
+    )
+    .addColumn('updated_at', 'integer', (col) =>
       col.notNull().defaultTo(sql`(unixepoch() * 1000)`)
     )
     .addForeignKeyConstraint(

packages/server/src/db/schema.d.ts

···
   did: string;
   display_name: string | null;
   html_bio: string | null;
-  profile_cached_at: number | null;
+  indexed_at: Generated<number>;
   server_origin: string | null;
-  wafrn_updated_at: Generated<number>;
+  updated_at: Generated<number>;
 }
 
 export interface PublicPosts {

packages/server/src/lib/account.ts

···
 import type { Accounts } from '@api/db/schema'
 import type { Insertable } from 'kysely'
 
-export function createOrUpdateAccount(account: Insertable<Accounts>) {
+export function cacheAccount(account: Insertable<Accounts>) {
   return db
     .insertInto('accounts')
     .values([

packages/server/src/lib/profile.ts

···
  * Creates the account if it doesn't exist, updates last_login_at if it does.
  * This should be called on first interaction with any DID.
  */
-export async function ensureAccount(did: string, handle: string): Promise<void> {
+export async function ensureAccount(
+  did: string,
+  handle: string
+): Promise<void> {
   await db
     .insertInto('accounts')
     .values({
···
       server_origin: profile.server_origin ?? null,
       custom_fields: profile.custom_fields
         ? JSON.stringify(profile.custom_fields)
-        : null,
-      wafrn_updated_at: Date.now()
+        : null
     })
     .onConflict((oc) =>
       oc.column('did').doUpdateSet({
···
         custom_fields: profile.custom_fields
           ? JSON.stringify(profile.custom_fields)
           : null,
-        wafrn_updated_at: Date.now()
+        updated_at: Date.now()
       })
     )
     .execute()