@atproto/api 0.0.8 → 0.1.1

package/README.md

@@ -3,12 +3,50 @@
 ## Usage
 
 ```typescript
-import API from '@atproto/api'
+import AtpAgent from '@atproto/api'
 
-const client = API.service('http://example.com')
+const agent = new AtpAgent({service: 'https://example.com'})
 
+// provide a custom fetch implementation (shouldnt be needed in node or the browser)
+import {AtpAgentFetchHeaders, AtpAgentFetchHandlerResponse} from '@atproto/api'
+AtpAgent.configure({
+  async fetch(
+    httpUri: string,
+    httpMethod: string,
+    httpHeaders: AtpAgentFetchHeaders,
+    httpReqBody: any,
+  ): Promise<AtpAgentFetchHandlerResponse> {
+    // insert definition here...
+    return {status: 200, /*...*/}
+  }
+})
+```
+
+### Session management
+
+```typescript
+import AtpAgent, {AtpSessionEvent, AtpSessionData} from '@atproto/api'
+const agent = new AtpAgent({
+  service: 'https://example.com',
+  persistSession: (evt: AtpSessionEvent, sess?: AtpSessionData) {
+    // store the session-data for reuse 
+  }
+})
+
+await agent.login({identifier: 'alice@mail.com', password: 'hunter2'})
+await agent.resumeSession(savedSessionData)
+await agent.createAccount({
+  email: 'alice@mail.com',
+  password: 'hunter2',
+  handle: 'alice.example.com'
+})
+```
+
+### API calls
+
+```typescript
 // xrpc methods
-const res1 = await client.com.atproto.repo.createRecord(
+const res1 = await agent.api.com.atproto.repo.createRecord(
   {
     did: alice.did,
     collection: 'app.bsky.feed.post',
@@ -19,14 +57,14 @@ const res1 = await client.com.atproto.repo.createRecord(
     }
   }
 )
-const res2 = await client.com.atproto.repo.listRecords({did: alice.did, type: 'app.bsky.feed.post'})
+const res2 = await agent.api.com.atproto.repo.listRecords({did: alice.did, type: 'app.bsky.feed.post'})
 
 // repo record methods
-const res3 = await client.app.bsky.feed.post.create({did: alice.did}, {
+const res3 = await agent.api.app.bsky.feed.post.create({did: alice.did}, {
   text: 'Hello, world!',
   createdAt: (new Date()).toISOString()
 })
-const res4 = await client.app.bsky.feed.post.list({did: alice.did})
+const res4 = await agent.api.app.bsky.feed.post.list({did: alice.did})
 ```
 
 ## License

package/dist/agent.d.ts

@@ -0,0 +1,22 @@
+import { AtpServiceClient, ComAtprotoAccountCreate, ComAtprotoSessionCreate, ComAtprotoSessionGet } from './client';
+import { AtpSessionData, AtpAgentCreateAccountOpts, AtpAgentLoginOpts, AptAgentFetchHandler, AtpAgentGlobalOpts, AtpPersistSessionHandler, AtpAgentOpts } from './types';
+export declare class AtpAgent {
+    service: URL;
+    api: AtpServiceClient;
+    session?: AtpSessionData;
+    private _baseClient;
+    private _persistSession?;
+    private _refreshSessionPromise;
+    static fetch: AptAgentFetchHandler | undefined;
+    static configure(opts: AtpAgentGlobalOpts): void;
+    constructor(opts: AtpAgentOpts);
+    get hasSession(): boolean;
+    setPersistSessionHandler(handler?: AtpPersistSessionHandler): void;
+    createAccount(opts: AtpAgentCreateAccountOpts): Promise<ComAtprotoAccountCreate.Response>;
+    login(opts: AtpAgentLoginOpts): Promise<ComAtprotoSessionCreate.Response>;
+    resumeSession(session: AtpSessionData): Promise<ComAtprotoSessionGet.Response>;
+    private _addAuthHeader;
+    private _fetch;
+    private _refreshSession;
+    private _refreshSessionInner;
+}

package/dist/client/index.d.ts

@@ -37,6 +37,7 @@ import * as ComAtprotoSyncGetHead from './types/com/atproto/sync/getHead';
 import * as ComAtprotoSyncGetRecord from './types/com/atproto/sync/getRecord';
 import * as ComAtprotoSyncGetRepo from './types/com/atproto/sync/getRepo';
 import * as AppBskyActorGetProfile from './types/app/bsky/actor/getProfile';
+import * as AppBskyActorGetProfiles from './types/app/bsky/actor/getProfiles';
 import * as AppBskyActorGetSuggestions from './types/app/bsky/actor/getSuggestions';
 import * as AppBskyActorProfile from './types/app/bsky/actor/profile';
 import * as AppBskyActorSearch from './types/app/bsky/actor/search';
@@ -70,6 +71,7 @@ export * as ComAtprotoAccountGet from './types/com/atproto/account/get';
 export * as ComAtprotoAccountRequestDelete from './types/com/atproto/account/requestDelete';
 export * as ComAtprotoAccountRequestPasswordReset from './types/com/atproto/account/requestPasswordReset';
 export * as ComAtprotoAccountResetPassword from './types/com/atproto/account/resetPassword';
+export * as ComAtprotoAdminBlob from './types/com/atproto/admin/blob';
 export * as ComAtprotoAdminGetModerationAction from './types/com/atproto/admin/getModerationAction';
 export * as ComAtprotoAdminGetModerationActions from './types/com/atproto/admin/getModerationActions';
 export * as ComAtprotoAdminGetModerationReport from './types/com/atproto/admin/getModerationReport';
@@ -110,6 +112,7 @@ export * as ComAtprotoSyncGetHead from './types/com/atproto/sync/getHead';
 export * as ComAtprotoSyncGetRecord from './types/com/atproto/sync/getRecord';
 export * as ComAtprotoSyncGetRepo from './types/com/atproto/sync/getRepo';
 export * as AppBskyActorGetProfile from './types/app/bsky/actor/getProfile';
+export * as AppBskyActorGetProfiles from './types/app/bsky/actor/getProfiles';
 export * as AppBskyActorGetSuggestions from './types/app/bsky/actor/getSuggestions';
 export * as AppBskyActorProfile from './types/app/bsky/actor/profile';
 export * as AppBskyActorRef from './types/app/bsky/actor/ref';
@@ -160,28 +163,26 @@ export declare const APP_BSKY_GRAPH: {
 export declare const APP_BSKY_SYSTEM: {
     ActorUser: string;
 };
-export declare class Client {
+export declare class AtpBaseClient {
     xrpc: XrpcClient;
     constructor();
-    service(serviceUri: string | URL): ServiceClient;
+    service(serviceUri: string | URL): AtpServiceClient;
 }
-declare const defaultInst: Client;
-export default defaultInst;
-export declare class ServiceClient {
-    _baseClient: Client;
+export declare class AtpServiceClient {
+    _baseClient: AtpBaseClient;
     xrpc: XrpcServiceClient;
     com: ComNS;
     app: AppNS;
-    constructor(baseClient: Client, xrpcService: XrpcServiceClient);
+    constructor(baseClient: AtpBaseClient, xrpcService: XrpcServiceClient);
     setHeader(key: string, value: string): void;
 }
 export declare class ComNS {
-    _service: ServiceClient;
+    _service: AtpServiceClient;
     atproto: AtprotoNS;
-    constructor(service: ServiceClient);
+    constructor(service: AtpServiceClient);
 }
 export declare class AtprotoNS {
-    _service: ServiceClient;
+    _service: AtpServiceClient;
     account: AccountNS;
     admin: AdminNS;
     blob: BlobNS;
@@ -191,11 +192,11 @@ export declare class AtprotoNS {
     server: ServerNS;
     session: SessionNS;
     sync: SyncNS;
-    constructor(service: ServiceClient);
+    constructor(service: AtpServiceClient);
 }
 export declare class AccountNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     create(data?: ComAtprotoAccountCreate.InputSchema, opts?: ComAtprotoAccountCreate.CallOptions): Promise<ComAtprotoAccountCreate.Response>;
     createInviteCode(data?: ComAtprotoAccountCreateInviteCode.InputSchema, opts?: ComAtprotoAccountCreateInviteCode.CallOptions): Promise<ComAtprotoAccountCreateInviteCode.Response>;
     delete(data?: ComAtprotoAccountDelete.InputSchema, opts?: ComAtprotoAccountDelete.CallOptions): Promise<ComAtprotoAccountDelete.Response>;
@@ -205,8 +206,8 @@ export declare class AccountNS {
     resetPassword(data?: ComAtprotoAccountResetPassword.InputSchema, opts?: ComAtprotoAccountResetPassword.CallOptions): Promise<ComAtprotoAccountResetPassword.Response>;
 }
 export declare class AdminNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     getModerationAction(params?: ComAtprotoAdminGetModerationAction.QueryParams, opts?: ComAtprotoAdminGetModerationAction.CallOptions): Promise<ComAtprotoAdminGetModerationAction.Response>;
     getModerationActions(params?: ComAtprotoAdminGetModerationActions.QueryParams, opts?: ComAtprotoAdminGetModerationActions.CallOptions): Promise<ComAtprotoAdminGetModerationActions.Response>;
     getModerationReport(params?: ComAtprotoAdminGetModerationReport.QueryParams, opts?: ComAtprotoAdminGetModerationReport.CallOptions): Promise<ComAtprotoAdminGetModerationReport.Response>;
@@ -219,18 +220,18 @@ export declare class AdminNS {
     takeModerationAction(data?: ComAtprotoAdminTakeModerationAction.InputSchema, opts?: ComAtprotoAdminTakeModerationAction.CallOptions): Promise<ComAtprotoAdminTakeModerationAction.Response>;
 }
 export declare class BlobNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     upload(data?: ComAtprotoBlobUpload.InputSchema, opts?: ComAtprotoBlobUpload.CallOptions): Promise<ComAtprotoBlobUpload.Response>;
 }
 export declare class HandleNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     resolve(params?: ComAtprotoHandleResolve.QueryParams, opts?: ComAtprotoHandleResolve.CallOptions): Promise<ComAtprotoHandleResolve.Response>;
 }
 export declare class RepoNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     batchWrite(data?: ComAtprotoRepoBatchWrite.InputSchema, opts?: ComAtprotoRepoBatchWrite.CallOptions): Promise<ComAtprotoRepoBatchWrite.Response>;
     createRecord(data?: ComAtprotoRepoCreateRecord.InputSchema, opts?: ComAtprotoRepoCreateRecord.CallOptions): Promise<ComAtprotoRepoCreateRecord.Response>;
     deleteRecord(data?: ComAtprotoRepoDeleteRecord.InputSchema, opts?: ComAtprotoRepoDeleteRecord.CallOptions): Promise<ComAtprotoRepoDeleteRecord.Response>;
@@ -240,26 +241,26 @@ export declare class RepoNS {
     putRecord(data?: ComAtprotoRepoPutRecord.InputSchema, opts?: ComAtprotoRepoPutRecord.CallOptions): Promise<ComAtprotoRepoPutRecord.Response>;
 }
 export declare class ReportNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     create(data?: ComAtprotoReportCreate.InputSchema, opts?: ComAtprotoReportCreate.CallOptions): Promise<ComAtprotoReportCreate.Response>;
 }
 export declare class ServerNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     getAccountsConfig(params?: ComAtprotoServerGetAccountsConfig.QueryParams, opts?: ComAtprotoServerGetAccountsConfig.CallOptions): Promise<ComAtprotoServerGetAccountsConfig.Response>;
 }
 export declare class SessionNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     create(data?: ComAtprotoSessionCreate.InputSchema, opts?: ComAtprotoSessionCreate.CallOptions): Promise<ComAtprotoSessionCreate.Response>;
     delete(data?: ComAtprotoSessionDelete.InputSchema, opts?: ComAtprotoSessionDelete.CallOptions): Promise<ComAtprotoSessionDelete.Response>;
     get(params?: ComAtprotoSessionGet.QueryParams, opts?: ComAtprotoSessionGet.CallOptions): Promise<ComAtprotoSessionGet.Response>;
     refresh(data?: ComAtprotoSessionRefresh.InputSchema, opts?: ComAtprotoSessionRefresh.CallOptions): Promise<ComAtprotoSessionRefresh.Response>;
 }
 export declare class SyncNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     getCheckout(params?: ComAtprotoSyncGetCheckout.QueryParams, opts?: ComAtprotoSyncGetCheckout.CallOptions): Promise<ComAtprotoSyncGetCheckout.Response>;
     getCommitPath(params?: ComAtprotoSyncGetCommitPath.QueryParams, opts?: ComAtprotoSyncGetCommitPath.CallOptions): Promise<ComAtprotoSyncGetCommitPath.Response>;
     getHead(params?: ComAtprotoSyncGetHead.QueryParams, opts?: ComAtprotoSyncGetHead.CallOptions): Promise<ComAtprotoSyncGetHead.Response>;
@@ -267,33 +268,34 @@ export declare class SyncNS {
     getRepo(params?: ComAtprotoSyncGetRepo.QueryParams, opts?: ComAtprotoSyncGetRepo.CallOptions): Promise<ComAtprotoSyncGetRepo.Response>;
 }
 export declare class AppNS {
-    _service: ServiceClient;
+    _service: AtpServiceClient;
     bsky: BskyNS;
-    constructor(service: ServiceClient);
+    constructor(service: AtpServiceClient);
 }
 export declare class BskyNS {
-    _service: ServiceClient;
+    _service: AtpServiceClient;
     actor: ActorNS;
     embed: EmbedNS;
     feed: FeedNS;
     graph: GraphNS;
     notification: NotificationNS;
     system: SystemNS;
-    constructor(service: ServiceClient);
+    constructor(service: AtpServiceClient);
 }
 export declare class ActorNS {
-    _service: ServiceClient;
+    _service: AtpServiceClient;
     profile: ProfileRecord;
-    constructor(service: ServiceClient);
+    constructor(service: AtpServiceClient);
     getProfile(params?: AppBskyActorGetProfile.QueryParams, opts?: AppBskyActorGetProfile.CallOptions): Promise<AppBskyActorGetProfile.Response>;
+    getProfiles(params?: AppBskyActorGetProfiles.QueryParams, opts?: AppBskyActorGetProfiles.CallOptions): Promise<AppBskyActorGetProfiles.Response>;
     getSuggestions(params?: AppBskyActorGetSuggestions.QueryParams, opts?: AppBskyActorGetSuggestions.CallOptions): Promise<AppBskyActorGetSuggestions.Response>;
     search(params?: AppBskyActorSearch.QueryParams, opts?: AppBskyActorSearch.CallOptions): Promise<AppBskyActorSearch.Response>;
     searchTypeahead(params?: AppBskyActorSearchTypeahead.QueryParams, opts?: AppBskyActorSearchTypeahead.CallOptions): Promise<AppBskyActorSearchTypeahead.Response>;
     updateProfile(data?: AppBskyActorUpdateProfile.InputSchema, opts?: AppBskyActorUpdateProfile.CallOptions): Promise<AppBskyActorUpdateProfile.Response>;
 }
 export declare class ProfileRecord {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     list(params: Omit<ComAtprotoRepoListRecords.QueryParams, 'collection'>): Promise<{
         cursor?: string;
         records: {
@@ -313,15 +315,15 @@ export declare class ProfileRecord {
     delete(params: Omit<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>, headers?: Record<string, string>): Promise<void>;
 }
 export declare class EmbedNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
 }
 export declare class FeedNS {
-    _service: ServiceClient;
+    _service: AtpServiceClient;
     post: PostRecord;
     repost: RepostRecord;
     vote: VoteRecord;
-    constructor(service: ServiceClient);
+    constructor(service: AtpServiceClient);
     getAuthorFeed(params?: AppBskyFeedGetAuthorFeed.QueryParams, opts?: AppBskyFeedGetAuthorFeed.CallOptions): Promise<AppBskyFeedGetAuthorFeed.Response>;
     getPostThread(params?: AppBskyFeedGetPostThread.QueryParams, opts?: AppBskyFeedGetPostThread.CallOptions): Promise<AppBskyFeedGetPostThread.Response>;
     getRepostedBy(params?: AppBskyFeedGetRepostedBy.QueryParams, opts?: AppBskyFeedGetRepostedBy.CallOptions): Promise<AppBskyFeedGetRepostedBy.Response>;
@@ -330,8 +332,8 @@ export declare class FeedNS {
     setVote(data?: AppBskyFeedSetVote.InputSchema, opts?: AppBskyFeedSetVote.CallOptions): Promise<AppBskyFeedSetVote.Response>;
 }
 export declare class PostRecord {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     list(params: Omit<ComAtprotoRepoListRecords.QueryParams, 'collection'>): Promise<{
         cursor?: string;
         records: {
@@ -351,8 +353,8 @@ export declare class PostRecord {
     delete(params: Omit<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>, headers?: Record<string, string>): Promise<void>;
 }
 export declare class RepostRecord {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     list(params: Omit<ComAtprotoRepoListRecords.QueryParams, 'collection'>): Promise<{
         cursor?: string;
         records: {
@@ -372,8 +374,8 @@ export declare class RepostRecord {
     delete(params: Omit<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>, headers?: Record<string, string>): Promise<void>;
 }
 export declare class VoteRecord {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     list(params: Omit<ComAtprotoRepoListRecords.QueryParams, 'collection'>): Promise<{
         cursor?: string;
         records: {
@@ -393,11 +395,11 @@ export declare class VoteRecord {
     delete(params: Omit<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>, headers?: Record<string, string>): Promise<void>;
 }
 export declare class GraphNS {
-    _service: ServiceClient;
+    _service: AtpServiceClient;
     assertion: AssertionRecord;
     confirmation: ConfirmationRecord;
     follow: FollowRecord;
-    constructor(service: ServiceClient);
+    constructor(service: AtpServiceClient);
     getFollowers(params?: AppBskyGraphGetFollowers.QueryParams, opts?: AppBskyGraphGetFollowers.CallOptions): Promise<AppBskyGraphGetFollowers.Response>;
     getFollows(params?: AppBskyGraphGetFollows.QueryParams, opts?: AppBskyGraphGetFollows.CallOptions): Promise<AppBskyGraphGetFollows.Response>;
     getMutes(params?: AppBskyGraphGetMutes.QueryParams, opts?: AppBskyGraphGetMutes.CallOptions): Promise<AppBskyGraphGetMutes.Response>;
@@ -405,8 +407,8 @@ export declare class GraphNS {
     unmute(data?: AppBskyGraphUnmute.InputSchema, opts?: AppBskyGraphUnmute.CallOptions): Promise<AppBskyGraphUnmute.Response>;
 }
 export declare class AssertionRecord {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     list(params: Omit<ComAtprotoRepoListRecords.QueryParams, 'collection'>): Promise<{
         cursor?: string;
         records: {
@@ -426,8 +428,8 @@ export declare class AssertionRecord {
     delete(params: Omit<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>, headers?: Record<string, string>): Promise<void>;
 }
 export declare class ConfirmationRecord {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     list(params: Omit<ComAtprotoRepoListRecords.QueryParams, 'collection'>): Promise<{
         cursor?: string;
         records: {
@@ -447,8 +449,8 @@ export declare class ConfirmationRecord {
     delete(params: Omit<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>, headers?: Record<string, string>): Promise<void>;
 }
 export declare class FollowRecord {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     list(params: Omit<ComAtprotoRepoListRecords.QueryParams, 'collection'>): Promise<{
         cursor?: string;
         records: {
@@ -468,20 +470,20 @@ export declare class FollowRecord {
     delete(params: Omit<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>, headers?: Record<string, string>): Promise<void>;
 }
 export declare class NotificationNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     getCount(params?: AppBskyNotificationGetCount.QueryParams, opts?: AppBskyNotificationGetCount.CallOptions): Promise<AppBskyNotificationGetCount.Response>;
     list(params?: AppBskyNotificationList.QueryParams, opts?: AppBskyNotificationList.CallOptions): Promise<AppBskyNotificationList.Response>;
     updateSeen(data?: AppBskyNotificationUpdateSeen.InputSchema, opts?: AppBskyNotificationUpdateSeen.CallOptions): Promise<AppBskyNotificationUpdateSeen.Response>;
 }
 export declare class SystemNS {
-    _service: ServiceClient;
+    _service: AtpServiceClient;
     declaration: DeclarationRecord;
-    constructor(service: ServiceClient);
+    constructor(service: AtpServiceClient);
 }
 export declare class DeclarationRecord {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     list(params: Omit<ComAtprotoRepoListRecords.QueryParams, 'collection'>): Promise<{
         cursor?: string;
         records: {