@atproto/api 0.0.1

package/src/client/types/com/atproto/sync/getRoot.ts

@@ -0,0 +1,32 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { Headers, XRPCError } from '@atproto/xrpc'
+
+export interface QueryParams {
+  /** The DID of the repo. */
+  did: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  root: string
+  [k: string]: unknown
+}
+
+export interface CallOptions {
+  headers?: Headers
+}
+
+export interface Response {
+  success: boolean
+  headers: Headers
+  data: OutputSchema
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+  }
+  return e
+}

package/src/client/types/com/atproto/sync/updateRepo.ts

@@ -0,0 +1,28 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { Headers, XRPCError } from '@atproto/xrpc'
+
+export interface QueryParams {
+  /** The DID of the repo. */
+  did: string
+}
+
+export type InputSchema = string | Uint8Array
+
+export interface CallOptions {
+  headers?: Headers
+  qp?: QueryParams
+  encoding: 'application/cbor'
+}
+
+export interface Response {
+  success: boolean
+  headers: Headers
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+  }
+  return e
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './client'
+export { default } from './client'
+export * from './session'
+export { default as sessionClient } from './session'

package/src/session.ts

@@ -0,0 +1,194 @@
+import {
+  CallOptions,
+  Client as XrpcClient,
+  ServiceClient as XrpcServiceClient,
+  QueryParams,
+  ResponseType,
+  XRPCError,
+  XRPCResponse,
+} from '@atproto/xrpc'
+import EventEmitter from 'events'
+import TypedEmitter from 'typed-emitter'
+import { Client, ServiceClient } from './client'
+import * as CreateSession from './client/types/com/atproto/session/create'
+import * as RefreshSession from './client/types/com/atproto/session/refresh'
+import * as CreateAccount from './client/types/com/atproto/session/create'
+
+const CREATE_SESSION = 'com.atproto.session.create'
+const REFRESH_SESSION = 'com.atproto.session.refresh'
+const DELETE_SESSION = 'com.atproto.session.delete'
+const CREATE_ACCOUNT = 'com.atproto.account.create'
+
+export class SessionClient extends Client {
+  service(serviceUri: string | URL): SessionServiceClient {
+    const xrpcService = new SessionXrpcServiceClient(this.xrpc, serviceUri)
+    return new SessionServiceClient(this, xrpcService)
+  }
+}
+
+const defaultInst = new SessionClient()
+export default defaultInst
+
+export class SessionServiceClient extends ServiceClient {
+  xrpc: SessionXrpcServiceClient
+  sessionManager: SessionManager
+  constructor(baseClient: Client, xrpcService: SessionXrpcServiceClient) {
+    super(baseClient, xrpcService)
+    this.sessionManager = this.xrpc.sessionManager
+  }
+}
+
+export class SessionXrpcServiceClient extends XrpcServiceClient {
+  sessionManager = new SessionManager()
+  refreshing?: Promise<XRPCResponse>
+
+  constructor(baseClient: XrpcClient, serviceUri: string | URL) {
+    super(baseClient, serviceUri)
+    this.sessionManager.on('session', () => {
+      // Maintain access token headers when session changes
+      const accessHeaders = this.sessionManager.accessHeaders()
+      if (accessHeaders) {
+        this.setHeader('authorization', accessHeaders.authorization)
+      } else {
+        this.unsetHeader('authorization')
+      }
+    })
+  }
+
+  async call(
+    methodNsid: string,
+    params?: QueryParams,
+    data?: unknown,
+    opts?: CallOptions,
+  ) {
+    const original = (overrideOpts?: CallOptions) =>
+      super.call(methodNsid, params, data, overrideOpts ?? opts)
+
+    // If someone is setting credentials manually, pass through as an escape hatch
+    if (opts?.headers?.authorization) {
+      return await original()
+    }
+
+    // Manage concurrent refreshes on session refresh
+    if (methodNsid === REFRESH_SESSION) {
+      return await this.refresh(opts)
+    }
+
+    // Complete any pending session refresh and then continue onto the original request with fresh credentials
+    await this.refreshing
+
+    // Setup session on session or account creation
+    if (methodNsid === CREATE_SESSION || methodNsid === CREATE_ACCOUNT) {
+      const result = await original()
+      const { accessJwt, refreshJwt } =
+        result.data as CreateSession.OutputSchema & CreateAccount.OutputSchema
+      this.sessionManager.set({ accessJwt, refreshJwt })
+      return result
+    }
+
+    // Clear session on session deletion
+    if (methodNsid === DELETE_SESSION) {
+      const result = await original({
+        ...opts,
+        headers: {
+          ...opts?.headers,
+          ...this.sessionManager.refreshHeaders(),
+        },
+      })
+      this.sessionManager.unset()
+      return result
+    }
+
+    // For all other requests, if failed due to an expired token, refresh and retry with fresh credentials
+    try {
+      return await original()
+    } catch (err) {
+      if (
+        err instanceof XRPCError &&
+        err.status === ResponseType.InvalidRequest &&
+        err.error === 'ExpiredToken' &&
+        this.sessionManager.active()
+      ) {
+        await this.refresh(opts)
+        return await original()
+      }
+      throw err
+    }
+  }
+
+  // Ensures a single refresh request at a time, deduping concurrent requests.
+  async refresh(opts?: CallOptions) {
+    this.refreshing ??= this._refresh(opts)
+    try {
+      return await this.refreshing
+    } finally {
+      this.refreshing = undefined
+    }
+  }
+
+  private async _refresh(opts?: CallOptions) {
+    try {
+      const result = await super.call(REFRESH_SESSION, undefined, undefined, {
+        ...opts,
+        headers: {
+          ...opts?.headers,
+          ...this.sessionManager.refreshHeaders(),
+        },
+      })
+      const { accessJwt, refreshJwt } =
+        result.data as RefreshSession.OutputSchema
+      this.sessionManager.set({ accessJwt, refreshJwt })
+      return result
+    } catch (err) {
+      if (
+        err instanceof XRPCError &&
+        err.status === ResponseType.InvalidRequest &&
+        (err.error === 'ExpiredToken' || err.error === 'InvalidToken')
+      ) {
+        this.sessionManager.unset()
+      }
+      throw err
+    }
+  }
+}
+
+export class SessionManager extends (EventEmitter as new () => TypedEmitter<SessionEvents>) {
+  session?: Session
+  get() {
+    return this.session
+  }
+  set(session: Session) {
+    this.session = session
+    this.emit('session', session)
+  }
+  unset() {
+    this.session = undefined
+    this.emit('session', undefined)
+  }
+  active() {
+    return !!this.session
+  }
+  accessHeaders() {
+    return (
+      this.session && {
+        authorization: `Bearer ${this.session.accessJwt}`,
+      }
+    )
+  }
+  refreshHeaders() {
+    return (
+      this.session && {
+        authorization: `Bearer ${this.session.refreshJwt}`,
+      }
+    )
+  }
+}
+
+export type Session = {
+  refreshJwt: string
+  accessJwt: string
+}
+
+type SessionEvents = {
+  session: (session?: Session) => void
+}

package/tests/errors.test.ts

@@ -0,0 +1,39 @@
+import {
+  CloseFn,
+  runTestServer,
+  TestServerInfo,
+} from '@atproto/pds/tests/_util'
+import {
+  sessionClient,
+  SessionServiceClient,
+  ComAtprotoAccountCreate,
+} from '..'
+
+describe('errors', () => {
+  let server: TestServerInfo
+  let client: SessionServiceClient
+  let close: CloseFn
+
+  beforeAll(async () => {
+    server = await runTestServer({
+      dbPostgresSchema: 'known_errors',
+    })
+    client = sessionClient.service(server.url)
+    close = server.close
+  })
+
+  afterAll(async () => {
+    await close()
+  })
+
+  it('constructs the correct error instance', async () => {
+    const res = client.com.atproto.account.create({
+      handle: 'admin',
+      email: 'admin@test.com',
+      password: 'password',
+    })
+    await expect(res).rejects.toThrow(
+      ComAtprotoAccountCreate.InvalidHandleError,
+    )
+  })
+})

package/tests/session.test.ts

@@ -0,0 +1,239 @@
+import {
+  CloseFn,
+  runTestServer,
+  TestServerInfo,
+} from '@atproto/pds/tests/_util'
+import { sessionClient, Session, SessionServiceClient } from '..'
+
+describe('session', () => {
+  let server: TestServerInfo
+  let client: SessionServiceClient
+  let close: CloseFn
+
+  beforeAll(async () => {
+    server = await runTestServer({
+      dbPostgresSchema: 'session',
+    })
+    client = sessionClient.service(server.url)
+    close = server.close
+  })
+
+  afterAll(async () => {
+    await close()
+  })
+
+  it('manages a new session on account creation.', async () => {
+    const sessions: (Session | undefined)[] = []
+    client.sessionManager.on('session', (session) => sessions.push(session))
+
+    const { data: account } = await client.com.atproto.account.create({
+      handle: 'alice.test',
+      email: 'alice@test.com',
+      password: 'password',
+    })
+
+    expect(client.sessionManager.active()).toEqual(true)
+    expect(sessions).toEqual([
+      { accessJwt: account.accessJwt, refreshJwt: account.refreshJwt },
+    ])
+
+    const { data: sessionInfo } = await client.com.atproto.session.get({})
+    expect(sessionInfo).toEqual({
+      did: account.did,
+      handle: account.handle,
+    })
+  })
+
+  it('ends a new session on session deletion.', async () => {
+    const sessions: (Session | undefined)[] = []
+    client.sessionManager.on('session', (session) => sessions.push(session))
+
+    await client.com.atproto.session.delete()
+
+    expect(sessions).toEqual([undefined])
+    expect(client.sessionManager.active()).toEqual(false)
+
+    const getSessionAfterDeletion = client.com.atproto.session.get({})
+    await expect(getSessionAfterDeletion).rejects.toThrow(
+      'Authentication Required',
+    )
+  })
+
+  it('manages a new session on session creation.', async () => {
+    const sessions: (Session | undefined)[] = []
+    client.sessionManager.on('session', (session) => sessions.push(session))
+
+    const { data: session } = await client.com.atproto.session.create({
+      handle: 'alice.test',
+      password: 'password',
+    })
+
+    expect(sessions).toEqual([
+      { accessJwt: session.accessJwt, refreshJwt: session.refreshJwt },
+    ])
+    expect(client.sessionManager.active()).toEqual(true)
+
+    const { data: sessionInfo } = await client.com.atproto.session.get({})
+    expect(sessionInfo).toEqual({
+      did: session.did,
+      handle: session.handle,
+    })
+  })
+
+  it('refreshes existing session.', async () => {
+    const sessions: (Session | undefined)[] = []
+    client.sessionManager.on('session', (session) => sessions.push(session))
+
+    const { data: session } = await client.com.atproto.session.create({
+      handle: 'alice.test',
+      password: 'password',
+    })
+
+    const { data: sessionRefresh } = await client.com.atproto.session.refresh()
+
+    expect(sessions).toEqual([
+      { accessJwt: session.accessJwt, refreshJwt: session.refreshJwt },
+      {
+        accessJwt: sessionRefresh.accessJwt,
+        refreshJwt: sessionRefresh.refreshJwt,
+      },
+    ])
+    expect(client.sessionManager.active()).toEqual(true)
+
+    const { data: sessionInfo } = await client.com.atproto.session.get({})
+    expect(sessionInfo).toEqual({
+      did: sessionRefresh.did,
+      handle: sessionRefresh.handle,
+    })
+
+    // Uses escape hatch: authorization set, so sessions are not managed by this call
+    const refreshStaleSession = client.com.atproto.session.refresh(undefined, {
+      headers: { authorization: `Bearer ${session.refreshJwt}` },
+    })
+    await expect(refreshStaleSession).rejects.toThrow('Token has been revoked')
+
+    expect(sessions.length).toEqual(2)
+    expect(client.sessionManager.active()).toEqual(true)
+  })
+
+  it('dedupes concurrent refreshes.', async () => {
+    const sessions: (Session | undefined)[] = []
+    client.sessionManager.on('session', (session) => sessions.push(session))
+
+    const { data: session } = await client.com.atproto.session.create({
+      handle: 'alice.test',
+      password: 'password',
+    })
+
+    const [{ data: sessionRefresh }] = await Promise.all(
+      [...Array(10)].map(() => client.com.atproto.session.refresh()),
+    )
+
+    expect(sessions).toEqual([
+      { accessJwt: session.accessJwt, refreshJwt: session.refreshJwt },
+      {
+        accessJwt: sessionRefresh.accessJwt,
+        refreshJwt: sessionRefresh.refreshJwt,
+      },
+    ])
+    expect(client.sessionManager.active()).toEqual(true)
+
+    const { data: sessionInfo } = await client.com.atproto.session.get({})
+    expect(sessionInfo).toEqual({
+      did: sessionRefresh.did,
+      handle: sessionRefresh.handle,
+    })
+  })
+
+  it('manually sets and unsets existing session.', async () => {
+    const sessions: (Session | undefined)[] = []
+    client.sessionManager.on('session', (session) => sessions.push(session))
+
+    const { data: session } = await client.com.atproto.session.create({
+      handle: 'alice.test',
+      password: 'password',
+    })
+    const sessionCreds = {
+      accessJwt: session.accessJwt,
+      refreshJwt: session.refreshJwt,
+    }
+    expect(client.sessionManager.active()).toEqual(true)
+
+    client.sessionManager.unset()
+    expect(client.sessionManager.active()).toEqual(false)
+
+    const getSessionAfterUnset = client.com.atproto.session.get({})
+    await expect(getSessionAfterUnset).rejects.toThrow(
+      'Authentication Required',
+    )
+
+    client.sessionManager.set(sessionCreds)
+    expect(client.sessionManager.active()).toEqual(true)
+
+    const { data: sessionInfo } = await client.com.atproto.session.get({})
+    expect(sessionInfo).toEqual({
+      did: session.did,
+      handle: session.handle,
+    })
+
+    expect(sessions).toEqual([sessionCreds, undefined, sessionCreds])
+    expect(client.sessionManager.active()).toEqual(true)
+  })
+
+  it('refreshes and retries request when access token is expired.', async () => {
+    const sessions: (Session | undefined)[] = []
+    client.sessionManager.on('session', (session) => sessions.push(session))
+    const auth = server.ctx.auth
+
+    const { data: sessionInfo } = await client.com.atproto.session.get({})
+    const accessExpired = await auth.createAccessToken(sessionInfo.did, -1)
+
+    expect(sessions.length).toEqual(0)
+    expect(client.sessionManager.active()).toEqual(true)
+
+    client.sessionManager.set({
+      refreshJwt: 'not-used-since-session-is-active',
+      ...client.sessionManager.get(),
+      accessJwt: accessExpired.jwt,
+    })
+
+    expect(sessions.length).toEqual(1)
+    expect(client.sessionManager.active()).toEqual(true)
+
+    const { data: updatedSessionInfo } = await client.com.atproto.session.get(
+      {},
+    )
+    expect(updatedSessionInfo).toEqual(sessionInfo)
+
+    expect(sessions.length).toEqual(2) // New session was created during session.get()
+    expect(client.sessionManager.active()).toEqual(true)
+  })
+
+  it('unsets session when refresh token becomes expired.', async () => {
+    const sessions: (Session | undefined)[] = []
+    client.sessionManager.on('session', (session) => sessions.push(session))
+    const auth = server.ctx.auth
+
+    const { data: sessionInfo } = await client.com.atproto.session.get({})
+    const accessExpired = await auth.createAccessToken(sessionInfo.did, -1)
+    const refreshExpired = await auth.createRefreshToken(sessionInfo.did, -1)
+
+    expect(sessions.length).toEqual(0)
+    expect(client.sessionManager.active()).toEqual(true)
+
+    client.sessionManager.set({
+      accessJwt: accessExpired.jwt,
+      refreshJwt: refreshExpired.jwt,
+    })
+
+    expect(sessions.length).toEqual(1)
+    expect(client.sessionManager.active()).toEqual(true)
+
+    const getSessionAfterExpired = client.com.atproto.session.get({})
+    await expect(getSessionAfterExpired).rejects.toThrow('Token has expired')
+
+    expect(sessions.length).toEqual(2)
+    expect(sessions[1]).toEqual(undefined)
+    expect(client.sessionManager.active()).toEqual(false)
+  })
+})

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["**/*.spec.ts", "**/*.test.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist", // Your outDir,
+    "emitDeclarationOnly": true
+  },
+  "include": ["./src"],
+  "references": [
+    { "path": "../xrpc/tsconfig.build.json" },
+    { "path": "../lex-cli/tsconfig.build.json" }
+  ]
+}