@atproto/api 0.1.3 → 0.2.1

package/dist/rich-text/detection.d.ts

@@ -0,0 +1,4 @@
+import { AppBskyRichtextFacet } from '../client';
+import { UnicodeString } from './unicode';
+export declare type Facet = AppBskyRichtextFacet.Main;
+export declare function detectFacets(text: UnicodeString): Facet[] | undefined;

package/dist/rich-text/rich-text.d.ts

@@ -0,0 +1,39 @@
+import { AtpAgent } from '../agent';
+import { AppBskyFeedPost, AppBskyRichtextFacet } from '../client';
+import { UnicodeString } from './unicode';
+export declare type Facet = AppBskyRichtextFacet.Main;
+export declare type FacetLink = AppBskyRichtextFacet.Link;
+export declare type FacetMention = AppBskyRichtextFacet.Mention;
+export declare type Entity = AppBskyFeedPost.Entity;
+export interface RichTextProps {
+    text: string;
+    facets?: Facet[];
+    entities?: Entity[];
+}
+export interface RichTextOpts {
+    cleanNewlines?: boolean;
+}
+export declare class RichTextSegment {
+    text: string;
+    facet?: AppBskyRichtextFacet.Main | undefined;
+    constructor(text: string, facet?: AppBskyRichtextFacet.Main | undefined);
+    get link(): FacetLink | undefined;
+    isLink(): boolean;
+    get mention(): FacetMention | undefined;
+    isMention(): boolean;
+}
+export declare class RichText {
+    unicodeText: UnicodeString;
+    facets?: Facet[];
+    constructor(props: RichTextProps, opts?: RichTextOpts);
+    get text(): string;
+    get length(): number;
+    get graphemeLength(): number;
+    clone(): RichText;
+    copyInto(target: RichText): void;
+    segments(): Generator<RichTextSegment, void, void>;
+    insert(insertIndex: number, insertText: string): this;
+    delete(removeStartIndex: number, removeEndIndex: number): this;
+    detectFacets(agent: AtpAgent): Promise<void>;
+    detectFacetsWithoutResolution(): void;
+}

package/dist/rich-text/sanitization.d.ts

@@ -0,0 +1,4 @@
+import { RichText } from './rich-text';
+export declare function sanitizeRichText(richText: RichText, opts: {
+    cleanNewlines?: boolean;
+}): RichText;

package/dist/rich-text/unicode.d.ts

@@ -0,0 +1,11 @@
+export declare class UnicodeString {
+    utf16: string;
+    utf8: Uint8Array;
+    private _graphemeLen?;
+    constructor(utf16: string);
+    get length(): number;
+    get graphemeLength(): number;
+    slice(start?: number, end?: number): string;
+    utf16IndexToUtf8Index(i: number): number;
+    toString(): string;
+}

package/dist/types.d.ts

@@ -26,8 +26,8 @@ export interface AtpAgentFetchHandlerResponse {
     headers: Record<string, string>;
     body: any;
 }
-export declare type AptAgentFetchHandler = (httpUri: string, httpMethod: string, httpHeaders: AtpAgentFetchHeaders, httpReqBody: any) => Promise<AtpAgentFetchHandlerResponse>;
+export declare type AtpAgentFetchHandler = (httpUri: string, httpMethod: string, httpHeaders: AtpAgentFetchHeaders, httpReqBody: any) => Promise<AtpAgentFetchHandlerResponse>;
 export interface AtpAgentGlobalOpts {
-    fetch: AptAgentFetchHandler;
+    fetch: AtpAgentFetchHandler;
 }
 export {};

package/docs/rn-fetch-handler.ts

@@ -0,0 +1,88 @@
+/**
+ * The following is the react-native fetch handler used currently in the bluesky app
+ * It's not our prettiest work, but it gets the job done
+ */
+
+import { BskyAgent, stringifyLex, jsonToLex } from '@atproto/api'
+import RNFS from 'react-native-fs'
+
+const GET_TIMEOUT = 15e3 // 15s
+const POST_TIMEOUT = 60e3 // 60s
+
+export function doPolyfill() {
+  BskyAgent.configure({ fetch: fetchHandler })
+}
+
+interface FetchHandlerResponse {
+  status: number
+  headers: Record<string, string>
+  body: ArrayBuffer | undefined
+}
+
+async function fetchHandler(
+  reqUri: string,
+  reqMethod: string,
+  reqHeaders: Record<string, string>,
+  reqBody: any,
+): Promise<FetchHandlerResponse> {
+  const reqMimeType = reqHeaders['Content-Type'] || reqHeaders['content-type']
+  if (reqMimeType && reqMimeType.startsWith('application/json')) {
+    reqBody = stringifyLex(reqBody)
+  } else if (
+    typeof reqBody === 'string' &&
+    (reqBody.startsWith('/') || reqBody.startsWith('file:'))
+  ) {
+    if (reqBody.endsWith('.jpeg') || reqBody.endsWith('.jpg')) {
+      // HACK
+      // React native has a bug that inflates the size of jpegs on upload
+      // we get around that by renaming the file ext to .bin
+      // see https://github.com/facebook/react-native/issues/27099
+      // -prf
+      const newPath = reqBody.replace(/\.jpe?g$/, '.bin')
+      await RNFS.moveFile(reqBody, newPath)
+      reqBody = newPath
+    }
+    // NOTE
+    // React native treats bodies with {uri: string} as file uploads to pull from cache
+    // -prf
+    reqBody = { uri: reqBody }
+  }
+
+  const controller = new AbortController()
+  const to = setTimeout(
+    () => controller.abort(),
+    reqMethod === 'post' ? POST_TIMEOUT : GET_TIMEOUT,
+  )
+
+  const res = await fetch(reqUri, {
+    method: reqMethod,
+    headers: reqHeaders,
+    body: reqBody,
+    signal: controller.signal,
+  })
+
+  const resStatus = res.status
+  const resHeaders: Record<string, string> = {}
+  res.headers.forEach((value: string, key: string) => {
+    resHeaders[key] = value
+  })
+  const resMimeType = resHeaders['Content-Type'] || resHeaders['content-type']
+  let resBody
+  if (resMimeType) {
+    if (resMimeType.startsWith('application/json')) {
+      resBody = jsonToLex(await res.json())
+    } else if (resMimeType.startsWith('text/')) {
+      resBody = await res.text()
+    } else {
+      throw new Error('TODO: non-textual response body')
+    }
+  }
+
+  clearTimeout(to)
+
+  return {
+    status: resStatus,
+    headers: resHeaders,
+    body: resBody,
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/api",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "main": "dist/index.js",
   "scripts": {
     "codegen": "lex gen-api ./src/client ../../lexicons/com/atproto/*/* ../../lexicons/app/bsky/*/*",
@@ -14,7 +14,10 @@
   },
   "license": "MIT",
   "dependencies": {
+    "@atproto/common-web": "*",
+    "@atproto/uri": "*",
     "@atproto/xrpc": "*",
+    "tlds": "^1.234.0",
     "typed-emitter": "^2.1.0"
   },
   "devDependencies": {

package/src/agent.ts

@@ -3,23 +3,24 @@ import { defaultFetchHandler } from '@atproto/xrpc'
 import {
   AtpBaseClient,
   AtpServiceClient,
-  ComAtprotoAccountCreate,
-  ComAtprotoSessionCreate,
-  ComAtprotoSessionGet,
-  ComAtprotoSessionRefresh,
+  ComAtprotoServerCreateAccount,
+  ComAtprotoServerCreateSession,
+  ComAtprotoServerGetSession,
+  ComAtprotoServerRefreshSession,
+  ComAtprotoRepoUploadBlob,
 } from './client'
 import {
   AtpSessionData,
   AtpAgentCreateAccountOpts,
   AtpAgentLoginOpts,
-  AptAgentFetchHandler,
+  AtpAgentFetchHandler,
   AtpAgentFetchHandlerResponse,
   AtpAgentGlobalOpts,
   AtpPersistSessionHandler,
   AtpAgentOpts,
 } from './types'
 
-const REFRESH_SESSION = 'com.atproto.session.refresh'
+const REFRESH_SESSION = 'com.atproto.server.refreshSession'
 
 /**
  * An ATP "Agent"
@@ -34,10 +35,14 @@ export class AtpAgent {
   private _persistSession?: AtpPersistSessionHandler
   private _refreshSessionPromise: Promise<void> | undefined
 
+  get com() {
+    return this.api.com
+  }
+
   /**
    * The `fetch` implementation; must be implemented for your platform.
    */
-  static fetch: AptAgentFetchHandler | undefined = defaultFetchHandler
+  static fetch: AtpAgentFetchHandler | undefined = defaultFetchHandler
 
   /**
    * Configures the API globally.
@@ -77,9 +82,9 @@ export class AtpAgent {
    */
   async createAccount(
     opts: AtpAgentCreateAccountOpts,
-  ): Promise<ComAtprotoAccountCreate.Response> {
+  ): Promise<ComAtprotoServerCreateAccount.Response> {
     try {
-      const res = await this.api.com.atproto.account.create({
+      const res = await this.api.com.atproto.server.createAccount({
         handle: opts.handle,
         password: opts.password,
         email: opts.email,
@@ -109,9 +114,9 @@ export class AtpAgent {
    */
   async login(
     opts: AtpAgentLoginOpts,
-  ): Promise<ComAtprotoSessionCreate.Response> {
+  ): Promise<ComAtprotoServerCreateSession.Response> {
     try {
-      const res = await this.api.com.atproto.session.create({
+      const res = await this.api.com.atproto.server.createSession({
         identifier: opts.identifier,
         password: opts.password,
       })
@@ -139,10 +144,10 @@ export class AtpAgent {
    */
   async resumeSession(
     session: AtpSessionData,
-  ): Promise<ComAtprotoSessionGet.Response> {
+  ): Promise<ComAtprotoServerGetSession.Response> {
     try {
       this.session = session
-      const res = await this.api.com.atproto.session.get()
+      const res = await this.api.com.atproto.server.getSession()
       if (!res.success || res.data.did !== this.session.did) {
         throw new Error('Invalid session')
       }
@@ -271,6 +276,34 @@ export class AtpAgent {
     // propagate in the _fetch() handler's second attempt to run
     // the request
   }
+
+  /**
+   * Upload a binary blob to the server
+   */
+  uploadBlob: typeof this.api.com.atproto.repo.uploadBlob = (data, opts) =>
+    this.api.com.atproto.repo.uploadBlob(data, opts)
+
+  /**
+   * Resolve a handle to a DID
+   */
+  resolveHandle: typeof this.api.com.atproto.identity.resolveHandle = (
+    params,
+    opts,
+  ) => this.api.com.atproto.identity.resolveHandle(params, opts)
+
+  /**
+   * Change the user's handle
+   */
+  updateHandle: typeof this.api.com.atproto.identity.updateHandle = (
+    data,
+    opts,
+  ) => this.api.com.atproto.identity.updateHandle(data, opts)
+
+  /**
+   * Create a moderation report
+   */
+  createModerationReport: typeof this.api.com.atproto.moderation.createReport =
+    (data, opts) => this.api.com.atproto.moderation.createReport(data, opts)
 }
 
 function isErrorObject(v: unknown): v is ErrorResponseBody {
@@ -295,9 +328,12 @@ function isErrorResponse(
 function isNewSessionObject(
   client: AtpBaseClient,
   v: unknown,
-): v is ComAtprotoSessionRefresh.OutputSchema {
+): v is ComAtprotoServerRefreshSession.OutputSchema {
   try {
-    client.xrpc.lex.assertValidXrpcOutput('com.atproto.session.refresh', v)
+    client.xrpc.lex.assertValidXrpcOutput(
+      'com.atproto.server.refreshSession',
+      v,
+    )
     return true
   } catch {
     return false

package/src/bsky-agent.ts

@@ -0,0 +1,228 @@
+import { AtUri } from '@atproto/uri'
+import { AtpAgent } from './agent'
+import {
+  AppBskyFeedPost,
+  AppBskyActorProfile,
+  ComAtprotoRepoPutRecord,
+} from './client'
+
+export class BskyAgent extends AtpAgent {
+  get app() {
+    return this.api.app
+  }
+
+  getTimeline: typeof this.api.app.bsky.feed.getTimeline = (params, opts) =>
+    this.api.app.bsky.feed.getTimeline(params, opts)
+
+  getAuthorFeed: typeof this.api.app.bsky.feed.getAuthorFeed = (params, opts) =>
+    this.api.app.bsky.feed.getAuthorFeed(params, opts)
+
+  getPostThread: typeof this.api.app.bsky.feed.getPostThread = (params, opts) =>
+    this.api.app.bsky.feed.getPostThread(params, opts)
+
+  getPost: typeof this.api.app.bsky.feed.post.get = (params) =>
+    this.api.app.bsky.feed.post.get(params)
+
+  getLikes: typeof this.api.app.bsky.feed.getLikes = (params, opts) =>
+    this.api.app.bsky.feed.getLikes(params, opts)
+
+  getRepostedBy: typeof this.api.app.bsky.feed.getRepostedBy = (params, opts) =>
+    this.api.app.bsky.feed.getRepostedBy(params, opts)
+
+  getFollows: typeof this.api.app.bsky.graph.getFollows = (params, opts) =>
+    this.api.app.bsky.graph.getFollows(params, opts)
+
+  getFollowers: typeof this.api.app.bsky.graph.getFollowers = (params, opts) =>
+    this.api.app.bsky.graph.getFollowers(params, opts)
+
+  getProfile: typeof this.api.app.bsky.actor.getProfile = (params, opts) =>
+    this.api.app.bsky.actor.getProfile(params, opts)
+
+  getProfiles: typeof this.api.app.bsky.actor.getProfiles = (params, opts) =>
+    this.api.app.bsky.actor.getProfiles(params, opts)
+
+  searchActors: typeof this.api.app.bsky.actor.searchActors = (params, opts) =>
+    this.api.app.bsky.actor.searchActors(params, opts)
+
+  searchActorsTypeahead: typeof this.api.app.bsky.actor.searchActorsTypeahead =
+    (params, opts) =>
+      this.api.app.bsky.actor.searchActorsTypeahead(params, opts)
+
+  listNotifications: typeof this.api.app.bsky.notification.listNotifications = (
+    params,
+    opts,
+  ) => this.api.app.bsky.notification.listNotifications(params, opts)
+
+  countUnreadNotifications: typeof this.api.app.bsky.notification.getUnreadCount =
+    (params, opts) =>
+      this.api.app.bsky.notification.getUnreadCount(params, opts)
+
+  async post(
+    record: Partial<AppBskyFeedPost.Record> &
+      Omit<AppBskyFeedPost.Record, 'createdAt'>,
+  ) {
+    if (!this.session) {
+      throw new Error('Not logged in')
+    }
+    record.createdAt = record.createdAt || new Date().toISOString()
+    return this.api.app.bsky.feed.post.create(
+      { repo: this.session.did },
+      record as AppBskyFeedPost.Record,
+    )
+  }
+
+  async deletePost(postUri: string) {
+    if (!this.session) {
+      throw new Error('Not logged in')
+    }
+    const postUrip = new AtUri(postUri)
+    return await this.api.app.bsky.feed.post.delete({
+      repo: postUrip.hostname,
+      rkey: postUrip.rkey,
+    })
+  }
+
+  async like(uri: string, cid: string) {
+    if (!this.session) {
+      throw new Error('Not logged in')
+    }
+    return await this.api.app.bsky.feed.like.create(
+      { repo: this.session.did },
+      {
+        subject: { uri, cid },
+        createdAt: new Date().toISOString(),
+      },
+    )
+  }
+
+  async deleteLike(likeUri: string) {
+    if (!this.session) {
+      throw new Error('Not logged in')
+    }
+    const likeUrip = new AtUri(likeUri)
+    return await this.api.app.bsky.feed.like.delete({
+      repo: likeUrip.hostname,
+      rkey: likeUrip.rkey,
+    })
+  }
+
+  async repost(uri: string, cid: string) {
+    if (!this.session) {
+      throw new Error('Not logged in')
+    }
+    return await this.api.app.bsky.feed.repost.create(
+      { repo: this.session.did },
+      {
+        subject: { uri, cid },
+        createdAt: new Date().toISOString(),
+      },
+    )
+  }
+
+  async deleteRepost(repostUri: string) {
+    if (!this.session) {
+      throw new Error('Not logged in')
+    }
+    const repostUrip = new AtUri(repostUri)
+    return await this.api.app.bsky.feed.repost.delete({
+      repo: repostUrip.hostname,
+      rkey: repostUrip.rkey,
+    })
+  }
+
+  async follow(subjectDid: string) {
+    if (!this.session) {
+      throw new Error('Not logged in')
+    }
+    return await this.api.app.bsky.graph.follow.create(
+      { repo: this.session.did },
+      {
+        subject: subjectDid,
+        createdAt: new Date().toISOString(),
+      },
+    )
+  }
+
+  async deleteFollow(followUri: string) {
+    if (!this.session) {
+      throw new Error('Not logged in')
+    }
+    const followUrip = new AtUri(followUri)
+    return await this.api.app.bsky.graph.follow.delete({
+      repo: followUrip.hostname,
+      rkey: followUrip.rkey,
+    })
+  }
+
+  async upsertProfile(
+    updateFn: (
+      existing: AppBskyActorProfile.Record | undefined,
+    ) => AppBskyActorProfile.Record | Promise<AppBskyActorProfile.Record>,
+  ) {
+    if (!this.session) {
+      throw new Error('Not logged in')
+    }
+
+    let retriesRemaining = 5
+    while (retriesRemaining >= 0) {
+      // fetch existing
+      const existing = await this.com.atproto.repo
+        .getRecord({
+          repo: this.session.did,
+          collection: 'app.bsky.actor.profile',
+          rkey: 'self',
+        })
+        .catch((_) => undefined)
+
+      // run the update
+      const updated = await updateFn(existing?.data.value)
+      if (updated) {
+        updated.$type = 'app.bsky.actor.profile'
+      }
+
+      // validate the record
+      const validation = AppBskyActorProfile.validateRecord(updated)
+      if (!validation.success) {
+        throw validation.error
+      }
+
+      try {
+        // attempt the put
+        await this.com.atproto.repo.putRecord({
+          repo: this.session.did,
+          collection: 'app.bsky.actor.profile',
+          rkey: 'self',
+          record: updated,
+          swapRecord: existing?.data.cid || null,
+        })
+      } catch (e: unknown) {
+        if (
+          retriesRemaining > 0 &&
+          e instanceof ComAtprotoRepoPutRecord.InvalidSwapError
+        ) {
+          // try again
+          retriesRemaining--
+          continue
+        } else {
+          throw e
+        }
+      }
+      break
+    }
+  }
+
+  async mute(actor: string) {
+    return this.api.app.bsky.graph.muteActor({ actor })
+  }
+
+  async unmute(actor: string) {
+    return this.api.app.bsky.graph.unmuteActor({ actor })
+  }
+
+  async updateSeenNotifications(seenAt?: string) {
+    seenAt = seenAt || new Date().toISOString()
+    return this.api.app.bsky.notification.updateSeen({
+      seenAt,
+    })
+  }
+}