fmt

src/auth/storage.ts

···
 import type {
-  NodeSavedSession,
-  NodeSavedSessionStore,
-  NodeSavedState,
-  NodeSavedStateStore,
-} from '@atproto/oauth-client-node'
-import type { Database } from '#/db'
+	NodeSavedSession,
+	NodeSavedSessionStore,
+	NodeSavedState,
+	NodeSavedStateStore,
+} from "@atproto/oauth-client-node";
+import type { Database } from "#/db";
 
 export class StateStore implements NodeSavedStateStore {
-  constructor(private db: Database) {}
-  async get(key: string): Promise<NodeSavedState | undefined> {
-    const result = await this.db.selectFrom('auth_state').selectAll().where('key', '=', key).executeTakeFirst()
-    if (!result) return
-    return JSON.parse(result.state) as NodeSavedState
-  }
-  async set(key: string, val: NodeSavedState) {
-    const state = JSON.stringify(val)
-    await this.db
-      .insertInto('auth_state')
-      .values({ key, state })
-      .onConflict((oc) => oc.doUpdateSet({ state }))
-      .execute()
-  }
-  async del(key: string) {
-    await this.db.deleteFrom('auth_state').where('key', '=', key).execute()
-  }
+	constructor(private db: Database) {}
+	async get(key: string): Promise<NodeSavedState | undefined> {
+		const result = await this.db
+			.selectFrom("auth_state")
+			.selectAll()
+			.where("key", "=", key)
+			.executeTakeFirst();
+		if (!result) return;
+		return JSON.parse(result.state) as NodeSavedState;
+	}
+	async set(key: string, val: NodeSavedState) {
+		const state = JSON.stringify(val);
+		await this.db
+			.insertInto("auth_state")
+			.values({ key, state })
+			.onConflict((oc) => oc.doUpdateSet({ state }))
+			.execute();
+	}
+	async del(key: string) {
+		await this.db.deleteFrom("auth_state").where("key", "=", key).execute();
+	}
 }
 
 export class SessionStore implements NodeSavedSessionStore {
-  constructor(private db: Database) {}
-  async get(key: string): Promise<NodeSavedSession | undefined> {
-    const result = await this.db.selectFrom('auth_session').selectAll().where('key', '=', key).executeTakeFirst()
-    if (!result) return
-    return JSON.parse(result.session) as NodeSavedSession
-  }
-  async set(key: string, val: NodeSavedSession) {
-    const session = JSON.stringify(val)
-    await this.db
-      .insertInto('auth_session')
-      .values({ key, session })
-      .onConflict((oc) => oc.doUpdateSet({ session }))
-      .execute()
-  }
-  async del(key: string) {
-    await this.db.deleteFrom('auth_session').where('key', '=', key).execute()
-  }
+	constructor(private db: Database) {}
+	async get(key: string): Promise<NodeSavedSession | undefined> {
+		const result = await this.db
+			.selectFrom("auth_session")
+			.selectAll()
+			.where("key", "=", key)
+			.executeTakeFirst();
+		if (!result) return;
+		return JSON.parse(result.session) as NodeSavedSession;
+	}
+	async set(key: string, val: NodeSavedSession) {
+		const session = JSON.stringify(val);
+		await this.db
+			.insertInto("auth_session")
+			.values({ key, session })
+			.onConflict((oc) => oc.doUpdateSet({ session }))
+			.execute();
+	}
+	async del(key: string) {
+		await this.db.deleteFrom("auth_session").where("key", "=", key).execute();
+	}
 }
-

src/id-resolver.ts

···
-import { IdResolver, MemoryCache } from '@atproto/identity'
-
-const HOUR = 60e3 * 60
-const DAY = HOUR * 24
+import { IdResolver, MemoryCache } from "@atproto/identity";
 
+const HOUR = 60e3 * 60;
+const DAY = HOUR * 24;
 
 export function createIdResolver() {
-  return new IdResolver({
-    didCache: new MemoryCache(HOUR, DAY),
-  })
+	return new IdResolver({
+		didCache: new MemoryCache(HOUR, DAY),
+	});
 }
 
 export interface BidirectionalResolver {
-  resolveDidToHandle(did: string): Promise<string>
-  resolveDidsToHandles(dids: string[]): Promise<Record<string, string>>
+	resolveDidToHandle(did: string): Promise<string>;
+	resolveDidsToHandles(dids: string[]): Promise<Record<string, string>>;
 }
 
 export function createBidirectionalResolver(resolver: IdResolver) {
-  return {
-    async resolveDidToHandle(did: string): Promise<string> {
-      const didDoc = await resolver.did.resolveAtprotoData(did)
-      const resolvedHandle = await resolver.handle.resolve(didDoc.handle)
-      if (resolvedHandle === did) {
-        return didDoc.handle
-      }
-      return did
-    },
+	return {
+		async resolveDidToHandle(did: string): Promise<string> {
+			const didDoc = await resolver.did.resolveAtprotoData(did);
+			const resolvedHandle = await resolver.handle.resolve(didDoc.handle);
+			if (resolvedHandle === did) {
+				return didDoc.handle;
+			}
+			return did;
+		},
 
-    async resolveDidsToHandles(
-      dids: string[]
-    ): Promise<Record<string, string>> {
-      const didHandleMap: Record<string, string> = {}
-      const resolves = await Promise.all(
-        dids.map((did) => this.resolveDidToHandle(did).catch((_) => did))
-      )
-      for (let i = 0; i < dids.length; i++) {
-        didHandleMap[dids[i]] = resolves[i]
-      }
-      return didHandleMap
-    },
-  }
+		async resolveDidsToHandles(
+			dids: string[],
+		): Promise<Record<string, string>> {
+			const didHandleMap: Record<string, string> = {};
+			const resolves = await Promise.all(
+				dids.map((did) => this.resolveDidToHandle(did).catch((_) => did)),
+			);
+			for (let i = 0; i < dids.length; i++) {
+				didHandleMap[dids[i]] = resolves[i];
+			}
+			return didHandleMap;
+		},
+	};
 }
-