@atproto/pds 0.5.12 → 0.5.15

package/src/account-manager/db/schema/index.ts

@@ -1,43 +0,0 @@
-import * as accountDevice from './account-device.js'
-import * as account from './account.js'
-import * as actor from './actor.js'
-import * as appPassword from './app-password.js'
-import * as oauthRequest from './authorization-request.js'
-import * as authorizedClient from './authorized-client.js'
-import * as device from './device.js'
-import * as emailToken from './email-token.js'
-import * as inviteCode from './invite-code.js'
-import * as lexicon from './lexicon.js'
-import * as refreshToken from './refresh-token.js'
-import * as repoRoot from './repo-root.js'
-import * as token from './token.js'
-import * as usedRefreshToken from './used-refresh-token.js'
-
-export type DatabaseSchema = actor.PartialDB &
-  account.PartialDB &
-  accountDevice.PartialDB &
-  authorizedClient.PartialDB &
-  device.PartialDB &
-  oauthRequest.PartialDB &
-  token.PartialDB &
-  usedRefreshToken.PartialDB &
-  refreshToken.PartialDB &
-  appPassword.PartialDB &
-  repoRoot.PartialDB &
-  inviteCode.PartialDB &
-  lexicon.PartialDB &
-  emailToken.PartialDB
-
-export type { Actor, ActorEntry } from './actor.js'
-export type { Account, AccountEntry } from './account.js'
-export type { AccountDevice } from './account-device.js'
-export type { Device } from './device.js'
-export type { AuthorizationRequest } from './authorization-request.js'
-export type { Token } from './token.js'
-export type { Lexicon } from './lexicon.js'
-export type { UsedRefreshToken } from './used-refresh-token.js'
-export type { RepoRoot } from './repo-root.js'
-export type { RefreshToken } from './refresh-token.js'
-export type { AppPassword } from './app-password.js'
-export type { InviteCode, InviteCodeUse } from './invite-code.js'
-export type { EmailToken, EmailTokenPurpose } from './email-token.js'

package/src/account-manager/db/schema/invite-code.ts

@@ -1,24 +0,0 @@
-import { DatetimeString, DidString } from '@atproto/lex'
-
-export interface InviteCode {
-  code: string
-  availableUses: number
-  disabled: 0 | 1
-  forAccount: string
-  createdBy: string
-  createdAt: DatetimeString
-}
-
-export interface InviteCodeUse {
-  code: string
-  usedBy: DidString
-  usedAt: DatetimeString
-}
-
-export const tableName = 'invite_code'
-export const supportingTableName = 'invite_code_use'
-
-export type PartialDB = {
-  [tableName]: InviteCode
-  [supportingTableName]: InviteCodeUse
-}

package/src/account-manager/db/schema/lexicon.ts

@@ -1,15 +0,0 @@
-import type { LexiconDocument } from '@atproto/oauth-provider'
-import { DateISO, JsonEncoded } from '../../../db/cast.js'
-
-export interface Lexicon {
-  nsid: string
-  createdAt: DateISO
-  updatedAt: DateISO
-  lastSucceededAt: null | DateISO
-  uri: null | string
-  lexicon: null | JsonEncoded<LexiconDocument>
-}
-
-export const tableName = 'lexicon'
-
-export type PartialDB = { [tableName]: Lexicon }

package/src/account-manager/db/schema/refresh-token.ts

@@ -1,11 +0,0 @@
-export interface RefreshToken {
-  id: string
-  did: string
-  expiresAt: string
-  appPasswordName: string | null
-  nextId: string | null
-}
-
-export const tableName = 'refresh_token'
-
-export type PartialDB = { [tableName]: RefreshToken }

package/src/account-manager/db/schema/repo-root.ts

@@ -1,12 +0,0 @@
-import { DatetimeString } from '@atproto/lex'
-
-export interface RepoRoot {
-  did: string
-  cid: string
-  rev: string
-  indexedAt: DatetimeString
-}
-
-export const tableName = 'repo_root'
-
-export type PartialDB = { [tableName]: RepoRoot }

package/src/account-manager/db/schema/token.ts

@@ -1,38 +0,0 @@
-import { Generated, Selectable } from 'kysely'
-import {
-  ClientAuth,
-  ClientAuthLegacy,
-  Code,
-  DeviceId,
-  Did,
-  OAuthAuthorizationDetails,
-  OAuthAuthorizationRequestParameters,
-  OAuthClientId,
-  RefreshToken,
-  TokenId,
-} from '@atproto/oauth-provider'
-import { DateISO, JsonEncoded } from '../../../db/cast.js'
-
-export interface Token {
-  id: Generated<number>
-  did: Did
-
-  tokenId: TokenId
-  createdAt: DateISO
-  updatedAt: DateISO
-  expiresAt: DateISO
-  clientId: OAuthClientId
-  clientAuth: JsonEncoded<ClientAuth | ClientAuthLegacy>
-  deviceId: DeviceId | null
-  parameters: JsonEncoded<OAuthAuthorizationRequestParameters>
-  details: JsonEncoded<OAuthAuthorizationDetails> | null
-  code: Code | null
-  currentRefreshToken: RefreshToken | null
-  scope: string | null
-}
-
-export type TokenEntry = Selectable<Token>
-
-export const tableName = 'token'
-
-export type PartialDB = { [tableName]: Token }

package/src/account-manager/db/schema/used-refresh-token.ts

@@ -1,13 +0,0 @@
-import { Selectable } from 'kysely'
-import { RefreshToken } from '@atproto/oauth-provider'
-
-export interface UsedRefreshToken {
-  tokenId: number
-  refreshToken: RefreshToken
-}
-
-export type UsedRefreshTokenEntry = Selectable<UsedRefreshToken>
-
-export const tableName = 'used_refresh_token'
-
-export type PartialDB = { [tableName]: UsedRefreshToken }

package/src/account-manager/helpers/account-device.ts

@@ -1,63 +0,0 @@
-import assert from 'node:assert'
-import { DeviceId, Did } from '@atproto/oauth-provider'
-import { toDateISO } from '../../db/index.js'
-import { AccountDb } from '../db/index.js'
-import { selectAccountQB } from './account.js'
-
-export function upsertQB(db: AccountDb, deviceId: DeviceId, did: string) {
-  const now = new Date()
-
-  return db.db
-    .insertInto('account_device')
-    .values({
-      did,
-      deviceId,
-      createdAt: toDateISO(now),
-      updatedAt: toDateISO(now),
-    })
-    .onConflict((oc) =>
-      // uses pk
-      oc.columns(['deviceId', 'did']).doUpdateSet({
-        updatedAt: toDateISO(now),
-      }),
-    )
-}
-
-export function selectQB(
-  db: AccountDb,
-  filter: { did?: Did; deviceId?: DeviceId },
-) {
-  assert(
-    filter.did != null || filter.deviceId != null,
-    'Either sub or deviceId must be provided',
-  )
-
-  return (
-    selectAccountQB(db, { includeDeactivated: true })
-      // note: query planner should use "account_device_pk" index
-      .innerJoin('account_device', 'account_device.did', 'actor.did')
-      .select([
-        'account_device.deviceId',
-        'account_device.createdAt as adCreatedAt',
-        'account_device.updatedAt as adUpdatedAt',
-      ])
-      .innerJoin('device', 'device.id', 'account_device.deviceId')
-      .select([
-        'device.sessionId',
-        'device.userAgent',
-        'device.ipAddress',
-        'device.lastSeenAt',
-      ])
-      .$if(filter.did != null, (qb) => qb.where('actor.did', '=', filter.did!))
-      .$if(filter.deviceId != null, (qb) =>
-        qb.where('account_device.deviceId', '=', filter.deviceId!),
-      )
-  )
-}
-
-export function removeQB(db: AccountDb, deviceId: DeviceId, did: string) {
-  return db.db
-    .deleteFrom('account_device')
-    .where('deviceId', '=', deviceId)
-    .where('did', '=', did)
-}

package/src/account-manager/helpers/account.ts

@@ -1,355 +0,0 @@
-import { DAY } from '@atproto/common'
-import {
-  AtIdentifierString,
-  DatetimeString,
-  DidString,
-  HandleString,
-  currentDatetimeString,
-  isDidIdentifier,
-} from '@atproto/lex'
-import { isErrUniqueViolation, notSoftDeletedClause } from '../../db/index.js'
-import { com } from '../../lexicons/index.js'
-import { AccountDb, ActorEntry } from '../db/index.js'
-
-export class UserAlreadyExistsError extends Error {
-  name = 'UserAlreadyExistsError'
-  constructor(
-    message = 'This email address is already in use, please use a different email.',
-    options?: ErrorOptions,
-  ) {
-    super(message, options)
-  }
-}
-
-export type ActorAccount = ActorEntry & {
-  email: string | null
-  emailConfirmedAt: string | null
-  invitesDisabled: 0 | 1 | null
-}
-
-export type AvailabilityFlags = {
-  includeTakenDown?: boolean
-  includeDeactivated?: boolean
-}
-
-export enum AccountStatus {
-  Active = 'active',
-  Takendown = 'takendown',
-  Suspended = 'suspended',
-  Deleted = 'deleted',
-  Deactivated = 'deactivated',
-}
-
-export const selectAccountQB = (db: AccountDb, flags?: AvailabilityFlags) => {
-  const { includeTakenDown = false, includeDeactivated = false } = flags ?? {}
-  const { ref } = db.db.dynamic
-  return db.db
-    .selectFrom('actor')
-    .leftJoin('account', 'actor.did', 'account.did')
-    .$if(!includeTakenDown, (qb) =>
-      qb.where(notSoftDeletedClause(ref('actor'))),
-    )
-    .$if(!includeDeactivated, (qb) =>
-      qb.where('actor.deactivatedAt', 'is', null),
-    )
-    .select([
-      'actor.did',
-      'actor.handle',
-      'actor.createdAt',
-      'actor.takedownRef',
-      'actor.deactivatedAt',
-      'actor.deleteAfter',
-      'account.email',
-      'account.emailConfirmedAt',
-      'account.invitesDisabled',
-    ])
-}
-
-export const getAccount = async (
-  db: AccountDb,
-  handleOrDid: AtIdentifierString,
-  flags?: AvailabilityFlags,
-): Promise<ActorAccount | null> => {
-  const found = await selectAccountQB(db, flags)
-    .where((eb) => {
-      if (isDidIdentifier(handleOrDid)) {
-        return eb('actor.did', '=', handleOrDid)
-      } else {
-        return eb('actor.handle', '=', handleOrDid)
-      }
-    })
-    .executeTakeFirst()
-  return found || null
-}
-
-export const getAccounts = async (
-  db: AccountDb,
-  dids: DidString[],
-  flags?: AvailabilityFlags,
-): Promise<Map<string, ActorAccount>> => {
-  const results = new Map<string, ActorAccount>()
-
-  if (!dids.length) {
-    return results
-  }
-
-  const accounts = await selectAccountQB(db, flags)
-    .where('actor.did', 'in', dids)
-    .execute()
-
-  accounts.forEach((account) => {
-    results.set(account.did, account)
-  })
-
-  return results
-}
-
-export const getAccountByEmail = async (
-  db: AccountDb,
-  email: string,
-  flags?: AvailabilityFlags,
-): Promise<ActorAccount | null> => {
-  const found = await selectAccountQB(db, flags)
-    .where('email', '=', email.toLowerCase())
-    .executeTakeFirst()
-  return found || null
-}
-
-export const registerActor = async (
-  db: AccountDb,
-  opts: {
-    did: DidString
-    handle: HandleString
-    deactivated?: boolean
-  },
-) => {
-  const { did, handle, deactivated } = opts
-  const now = Date.now()
-  const createdAt = new Date(now).toISOString()
-  const [registered] = await db.executeWithRetry(
-    db.db
-      .insertInto('actor')
-      .values({
-        did,
-        handle,
-        createdAt,
-        deactivatedAt: deactivated ? createdAt : null,
-        deleteAfter: deactivated ? new Date(now + 3 * DAY).toISOString() : null,
-      })
-      .onConflict((oc) => oc.doNothing())
-      .returning('did'),
-  )
-  if (!registered) {
-    throw new UserAlreadyExistsError()
-  }
-}
-
-export const registerAccount = async (
-  db: AccountDb,
-  opts: {
-    did: string
-    email: string
-    passwordScrypt: string
-  },
-) => {
-  const { did, email, passwordScrypt } = opts
-  const [registered] = await db.executeWithRetry(
-    db.db
-      .insertInto('account')
-      .values({
-        did,
-        email: email.toLowerCase(),
-        passwordScrypt,
-      })
-      .onConflict((oc) => oc.doNothing())
-      .returning('did'),
-  )
-  if (!registered) {
-    throw new UserAlreadyExistsError()
-  }
-}
-
-export const deleteAccount = async (
-  db: AccountDb,
-  did: DidString,
-): Promise<void> => {
-  // Not done in transaction because it would be too long, prone to contention.
-  // Also, this can safely be run multiple times if it fails.
-  await db.executeWithRetry(
-    db.db.deleteFrom('repo_root').where('did', '=', did),
-  )
-  await db.executeWithRetry(
-    db.db.deleteFrom('email_token').where('did', '=', did),
-  )
-  await db.executeWithRetry(
-    db.db.deleteFrom('refresh_token').where('did', '=', did),
-  )
-  await db.executeWithRetry(
-    db.db.deleteFrom('account').where('account.did', '=', did),
-  )
-  await db.executeWithRetry(
-    db.db.deleteFrom('actor').where('actor.did', '=', did),
-  )
-}
-
-export const updateHandle = async (
-  db: AccountDb,
-  did: DidString,
-  handle: HandleString,
-) => {
-  // No-op if the handle is the same, but still returns 1 row affected, so that
-  // it can be used to check for existence of the account.
-  const [res] = await db.executeWithRetry(
-    db.db
-      .updateTable('actor')
-      .set({ handle })
-      .where('did', '=', did)
-      .where(({ not, exists }) =>
-        not(
-          exists(
-            db.db
-              .selectFrom('actor')
-              .where('handle', '=', handle)
-              .where('did', '!=', did)
-              .selectAll(),
-          ),
-        ),
-      ),
-  )
-  if (res.numUpdatedRows < 1) {
-    throw new UserAlreadyExistsError(
-      'Handle is already in use, please choose a different handle.',
-    )
-  }
-}
-
-export const updateEmail = async (
-  db: AccountDb,
-  did: DidString,
-  email: string,
-) => {
-  try {
-    await db.executeWithRetry(
-      db.db
-        .updateTable('account')
-        .set({
-          email: email.toLowerCase(),
-          emailConfirmedAt: null,
-        })
-        .where('did', '=', did),
-    )
-  } catch (err) {
-    if (isErrUniqueViolation(err)) {
-      throw new UserAlreadyExistsError()
-    }
-    throw err
-  }
-}
-
-export const setEmailConfirmedAt = async (
-  db: AccountDb,
-  did: DidString,
-  emailConfirmedAt: DatetimeString,
-) => {
-  await db.executeWithRetry(
-    db.db
-      .updateTable('account')
-      .set({ emailConfirmedAt })
-      .where('did', '=', did),
-  )
-}
-
-export const getAccountAdminStatus = async (
-  db: AccountDb,
-  did: DidString,
-): Promise<{
-  takedown: com.atproto.admin.defs.StatusAttr
-  deactivated: com.atproto.admin.defs.StatusAttr
-} | null> => {
-  const res = await db.db
-    .selectFrom('actor')
-    .select(['takedownRef', 'deactivatedAt'])
-    .where('did', '=', did)
-    .executeTakeFirst()
-  if (!res) return null
-  const takedown = res.takedownRef
-    ? { applied: true, ref: res.takedownRef }
-    : { applied: false }
-  const deactivated = res.deactivatedAt ? { applied: true } : { applied: false }
-  return { takedown, deactivated }
-}
-
-export const updateAccountTakedownStatus = async (
-  db: AccountDb,
-  did: DidString,
-  takedown: com.atproto.admin.defs.StatusAttr,
-) => {
-  const takedownRef = takedown.applied
-    ? takedown.ref ?? currentDatetimeString()
-    : null
-  await db.executeWithRetry(
-    db.db.updateTable('actor').set({ takedownRef }).where('did', '=', did),
-  )
-}
-
-export const deactivateAccount = async (
-  db: AccountDb,
-  did: DidString,
-  deleteAfter: string | null,
-): Promise<boolean> => {
-  const [res] = await db.executeWithRetry(
-    db.db
-      .updateTable('actor')
-      .set({
-        deactivatedAt: currentDatetimeString(),
-        deleteAfter,
-      })
-      .where('did', '=', did),
-  )
-
-  return res.numUpdatedRows > 0
-}
-
-export const activateAccount = async (
-  db: AccountDb,
-  did: DidString,
-  flags?: AvailabilityFlags,
-): Promise<boolean> => {
-  const { includeTakenDown = false, includeDeactivated = true } = flags ?? {}
-  const { ref } = db.db.dynamic
-
-  const [res] = await db.executeWithRetry(
-    db.db
-      .updateTable('actor')
-      .set({
-        deactivatedAt: null,
-        deleteAfter: null,
-      })
-      .where('did', '=', did)
-      .$if(!includeTakenDown, (q) =>
-        q.where(notSoftDeletedClause(ref('actor'))),
-      )
-      .$if(!includeDeactivated, (q) =>
-        q.where('actor.deactivatedAt', 'is not', null),
-      ),
-  )
-
-  return res.numUpdatedRows > 0
-}
-
-export const formatAccountStatus = (
-  account: null | {
-    takedownRef: string | null
-    deactivatedAt: string | null
-  },
-) => {
-  if (!account) {
-    return { active: false, status: AccountStatus.Deleted } as const
-  } else if (account.takedownRef) {
-    return { active: false, status: AccountStatus.Takendown } as const
-  } else if (account.deactivatedAt) {
-    return { active: false, status: AccountStatus.Deactivated } as const
-  } else {
-    return { active: true, status: undefined } as const
-  }
-}