oppi.li
atproto pastebin service: https://plonk.li
fmt
+78
-73
+48
-41
src/auth/storage.ts
+48
-41
src/auth/storage.ts
···
1
1
import type {
2
-
NodeSavedSession,
3
-
NodeSavedSessionStore,
4
-
NodeSavedState,
5
-
NodeSavedStateStore,
6
-
} from '@atproto/oauth-client-node'
7
-
import type { Database } from '#/db'
2
+
NodeSavedSession,
3
+
NodeSavedSessionStore,
4
+
NodeSavedState,
5
+
NodeSavedStateStore,
6
+
} from "@atproto/oauth-client-node";
7
+
import type { Database } from "#/db";
8
8
9
9
export class StateStore implements NodeSavedStateStore {
10
-
constructor(private db: Database) {}
11
-
async get(key: string): Promise<NodeSavedState | undefined> {
12
-
const result = await this.db.selectFrom('auth_state').selectAll().where('key', '=', key).executeTakeFirst()
13
-
if (!result) return
14
-
return JSON.parse(result.state) as NodeSavedState
15
-
}
16
-
async set(key: string, val: NodeSavedState) {
17
-
const state = JSON.stringify(val)
18
-
await this.db
19
-
.insertInto('auth_state')
20
-
.values({ key, state })
21
-
.onConflict((oc) => oc.doUpdateSet({ state }))
22
-
.execute()
23
-
}
24
-
async del(key: string) {
25
-
await this.db.deleteFrom('auth_state').where('key', '=', key).execute()
26
-
}
10
+
constructor(private db: Database) {}
11
+
async get(key: string): Promise<NodeSavedState | undefined> {
12
+
const result = await this.db
13
+
.selectFrom("auth_state")
14
+
.selectAll()
15
+
.where("key", "=", key)
16
+
.executeTakeFirst();
17
+
if (!result) return;
18
+
return JSON.parse(result.state) as NodeSavedState;
19
+
}
20
+
async set(key: string, val: NodeSavedState) {
21
+
const state = JSON.stringify(val);
22
+
await this.db
23
+
.insertInto("auth_state")
24
+
.values({ key, state })
25
+
.onConflict((oc) => oc.doUpdateSet({ state }))
26
+
.execute();
27
+
}
28
+
async del(key: string) {
29
+
await this.db.deleteFrom("auth_state").where("key", "=", key).execute();
30
+
}
27
31
}
28
32
29
33
export class SessionStore implements NodeSavedSessionStore {
30
-
constructor(private db: Database) {}
31
-
async get(key: string): Promise<NodeSavedSession | undefined> {
32
-
const result = await this.db.selectFrom('auth_session').selectAll().where('key', '=', key).executeTakeFirst()
33
-
if (!result) return
34
-
return JSON.parse(result.session) as NodeSavedSession
35
-
}
36
-
async set(key: string, val: NodeSavedSession) {
37
-
const session = JSON.stringify(val)
38
-
await this.db
39
-
.insertInto('auth_session')
40
-
.values({ key, session })
41
-
.onConflict((oc) => oc.doUpdateSet({ session }))
42
-
.execute()
43
-
}
44
-
async del(key: string) {
45
-
await this.db.deleteFrom('auth_session').where('key', '=', key).execute()
46
-
}
34
+
constructor(private db: Database) {}
35
+
async get(key: string): Promise<NodeSavedSession | undefined> {
36
+
const result = await this.db
37
+
.selectFrom("auth_session")
38
+
.selectAll()
39
+
.where("key", "=", key)
40
+
.executeTakeFirst();
41
+
if (!result) return;
42
+
return JSON.parse(result.session) as NodeSavedSession;
43
+
}
44
+
async set(key: string, val: NodeSavedSession) {
45
+
const session = JSON.stringify(val);
46
+
await this.db
47
+
.insertInto("auth_session")
48
+
.values({ key, session })
49
+
.onConflict((oc) => oc.doUpdateSet({ session }))
50
+
.execute();
51
+
}
52
+
async del(key: string) {
53
+
await this.db.deleteFrom("auth_session").where("key", "=", key).execute();
54
+
}
47
55
}
48
-
+30
-32
src/id-resolver.ts
+30
-32
src/id-resolver.ts
···
1
-
import { IdResolver, MemoryCache } from '@atproto/identity'
2
-
3
-
const HOUR = 60e3 * 60
4
-
const DAY = HOUR * 24
1
+
import { IdResolver, MemoryCache } from "@atproto/identity";
5
2
3
+
const HOUR = 60e3 * 60;
4
+
const DAY = HOUR * 24;
6
5
7
6
export function createIdResolver() {
8
-
return new IdResolver({
9
-
didCache: new MemoryCache(HOUR, DAY),
10
-
})
7
+
return new IdResolver({
8
+
didCache: new MemoryCache(HOUR, DAY),
9
+
});
11
10
}
12
11
13
12
export interface BidirectionalResolver {
14
-
resolveDidToHandle(did: string): Promise<string>
15
-
resolveDidsToHandles(dids: string[]): Promise<Record<string, string>>
13
+
resolveDidToHandle(did: string): Promise<string>;
14
+
resolveDidsToHandles(dids: string[]): Promise<Record<string, string>>;
16
15
}
17
16
18
17
export function createBidirectionalResolver(resolver: IdResolver) {
19
-
return {
20
-
async resolveDidToHandle(did: string): Promise<string> {
21
-
const didDoc = await resolver.did.resolveAtprotoData(did)
22
-
const resolvedHandle = await resolver.handle.resolve(didDoc.handle)
23
-
if (resolvedHandle === did) {
24
-
return didDoc.handle
25
-
}
26
-
return did
27
-
},
18
+
return {
19
+
async resolveDidToHandle(did: string): Promise<string> {
20
+
const didDoc = await resolver.did.resolveAtprotoData(did);
21
+
const resolvedHandle = await resolver.handle.resolve(didDoc.handle);
22
+
if (resolvedHandle === did) {
23
+
return didDoc.handle;
24
+
}
25
+
return did;
26
+
},
28
27
29
-
async resolveDidsToHandles(
30
-
dids: string[]
31
-
): Promise<Record<string, string>> {
32
-
const didHandleMap: Record<string, string> = {}
33
-
const resolves = await Promise.all(
34
-
dids.map((did) => this.resolveDidToHandle(did).catch((_) => did))
35
-
)
36
-
for (let i = 0; i < dids.length; i++) {
37
-
didHandleMap[dids[i]] = resolves[i]
38
-
}
39
-
return didHandleMap
40
-
},
41
-
}
28
+
async resolveDidsToHandles(
29
+
dids: string[],
30
+
): Promise<Record<string, string>> {
31
+
const didHandleMap: Record<string, string> = {};
32
+
const resolves = await Promise.all(
33
+
dids.map((did) => this.resolveDidToHandle(did).catch((_) => did)),
34
+
);
35
+
for (let i = 0; i < dids.length; i++) {
36
+
didHandleMap[dids[i]] = resolves[i];
37
+
}
38
+
return didHandleMap;
39
+
},
40
+
};
42
41
}
43
-