Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@atproto/xrpc

Package Overview
Dependencies
Maintainers
4
Versions
23
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@atproto/xrpc - npm Package Compare versions

Comparing version 0.6.0-rc.0 to 0.6.0

576

CHANGELOG.md
# @atproto/xrpc
## 0.6.0-rc.0
## 0.6.0
### Minor Changes
- [#2483](https://github.com/bluesky-social/atproto/pull/2483) [`2ded0156b`](https://github.com/bluesky-social/atproto/commit/2ded0156b9adf33b9cce66583a375bff922d383b) Thanks [@matthieusieben](https://github.com/matthieusieben)! - **New Features**:
- [#2483](https://github.com/bluesky-social/atproto/pull/2483) [`b934b396b`](https://github.com/bluesky-social/atproto/commit/b934b396b13ba32bf2bf7e75ecdf6871e5f310dd) Thanks [@matthieusieben](https://github.com/matthieusieben)!
1. Improved Separation of Concerns: We've restructured the XRPC HTTP call
dispatcher into a distinct class. This means cleaner code organization and
better clarity on responsibilities.
2. Enhanced Evolutivity: With this refactor, the XRPC client is now more
adaptable to various use cases. You can easily extend and customize the
dispatcher perform session management, retries, and more.
#### Motivation
**Compatibility**:
The motivation for these changes is the need to make the `@atproto/api` package
compatible with OAuth session management. We don't have OAuth client support
"launched" and documented quite yet, so you can keep using the current app
password authentication system. When we do "launch" OAuth support and begin
encouraging its usage in the near future (see the [OAuth
Roadmap](https://github.com/bluesky-social/atproto/discussions/2656)), these
changes will make it easier to migrate.
In addition, the redesigned session management system fixes a bug that could
cause the session data to become invalid when Agent clones are created (e.g.
using `agent.withProxy()`).
#### New Features
We've restructured the `XrpcClient` HTTP fetch handler to be specified during
the instantiation of the XRPC client, through the constructor, instead of using
a default implementation (which was statically defined).
With this refactor, the XRPC client is now more modular and reusable. Session
management, retries, cryptographic signing, and other request-specific logic can
be implemented in the fetch handler itself rather than by the calling code.
A new abstract class named `Agent`, has been added to `@atproto/api`. This class
will be the base class for all Bluesky agents classes in the `@atproto`
ecosystem. It is meant to be extended by implementations that provide session
management and fetch handling.
As you adapt your code to these changes, make sure to use the `Agent` type
wherever you expect to receive an agent, and use the `AtpAgent` type (class)
only to instantiate your client. The reason for this is to be forward compatible
with the OAuth agent implementation that will also extend `Agent`, and not
`AtpAgent`.
```ts
import { Agent, AtpAgent } from '@atproto/api'
async function setupAgent(
service: string,
username: string,
password: string,
): Promise<Agent> {
const agent = new AtpAgent({
service,
persistSession: (evt, session) => {
// handle session update
},
})
await agent.login(username, password)
return agent
}
```
```ts
import { Agent } from '@atproto/api'
async function doStuffWithAgent(agent: Agent, arg: string) {
return agent.resolveHandle(arg)
}
```
```ts
import { Agent, AtpAgent } from '@atproto/api'
class MyClass {
agent: Agent
constructor() {
this.agent = new AtpAgent()
}
}
```
#### Breaking changes
Most of the changes introduced in this version are backward-compatible. However,
there are a couple of breaking changes you should be aware of:
- Customizing `fetchHandler`: The ability to customize the fetchHandler on the
XRPC Client and AtpAgent classes has been modified. Please review your code if
you rely on custom fetch handlers.
- Managing Sessions: Previously, you had the ability to manage sessions directly
through AtpAgent instances. Now, session management must be handled through a
dedicated `SessionManager` instance. If you were making authenticated
requests, you'll need to update your code to use explicit session management.
- Customizing `fetch`: The ability to customize the `fetch: FetchHandler`
property of `@atproto/xrpc`'s `Client` and `@atproto/api`'s `AtpAgent` classes
has been removed. Previously, the `fetch` property could be set to a function
that would be used as the fetch handler for that instance, and was initialized
to a default fetch handler. That property is still accessible in a read-only
fashion through the `fetchHandler` property and can only be set during the
instance creation. Attempting to set/get the `fetch` property will now result
in an error.
- The `fetch()` method, as well as WhatWG compliant `Request` and `Headers`
constructors, must be globally available in your environment.
constructors, must be globally available in your environment. Use a polyfill
if necessary.
- The `AtpBaseClient` has been removed. The `AtpServiceClient` has been renamed
`AtpBaseClient`. Any code using either of these classes will need to be
updated.
- Instead of _wrapping_ an `XrpcClient` in its `xrpc` property, the
`AtpBaseClient` (formerly `AtpServiceClient`) class - created through
`lex-cli` - now _extends_ the `XrpcClient` class. This means that a client
instance now passes the `instanceof XrpcClient` check. The `xrpc` property now
returns the instance itself and has been deprecated.
- `setSessionPersistHandler` is no longer available on the `AtpAgent` or
`BskyAgent` classes. The session handler can only be set though the
`persistSession` options of the `AtpAgent` constructor.
- The new class hierarchy is as follows:
- `BskyAgent` extends `AtpAgent`: but add no functionality (hence its
deprecation).
- `AtpAgent` extends `Agent`: adds password based session management.
- `Agent` extends `AtpBaseClient`: this abstract class that adds syntactic sugar
methods `app.bsky` lexicons. It also adds abstract session management
methods and adds atproto specific utilities
(`labelers` & `proxy` headers, cloning capability)
- `AtpBaseClient` extends `XrpcClient`: automatically code that adds fully
typed lexicon defined namespaces (`instance.app.bsky.feed.getPosts()`) to
the `XrpcClient`.
- `XrpcClient` is the base class.
- [#2483](https://github.com/bluesky-social/atproto/pull/2483) [`2ded0156b`](https://github.com/bluesky-social/atproto/commit/2ded0156b9adf33b9cce66583a375bff922d383b) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Add the ability to use `fetch()` compatible `BodyInit` body when making XRPC calls.
#### Non-breaking changes
- The `com.*` and `app.*` namespaces have been made directly available to every
`Agent` instances.
#### Deprecations
- The default export of the `@atproto/xrpc` package has been deprecated. Use
named exports instead.
- The `Client` and `ServiceClient` classes are now deprecated. They are replaced by a single `XrpcClient` class.
- The default export of the `@atproto/api` package has been deprecated. Use
named exports instead.
- The `BskyAgent` has been deprecated. Use the `AtpAgent` class instead.
- The `xrpc` property of the `AtpClient` instances has been deprecated. The
instance itself should be used as the XRPC client.
- The `api` property of the `AtpAgent` and `BskyAgent` instances has been
deprecated. Use the instance itself instead.
#### Migration
##### The `@atproto/api` package
If you were relying on the `AtpBaseClient` solely to perform validation, use
this:
<table>
<tr>
<td><center>Before</center></td> <td><center>After</center></td>
</tr>
<tr>
<td>
```ts
import { AtpBaseClient, ComAtprotoSyncSubscribeRepos } from '@atproto/api'
const baseClient = new AtpBaseClient()
baseClient.xrpc.lex.assertValidXrpcMessage('io.example.doStuff', {
// ...
})
```
</td>
<td>
```ts
import { lexicons } from '@atproto/api'
lexicons.assertValidXrpcMessage('io.example.doStuff', {
// ...
})
```
</td>
</tr>
</table>
If you are extending the `BskyAgent` to perform custom `session` manipulation, define your own `Agent` subclass instead:
<table>
<tr>
<td><center>Before</center></td> <td><center>After</center></td>
</tr>
<tr>
<td>
```ts
import { BskyAgent } from '@atproto/api'
class MyAgent extends BskyAgent {
private accessToken?: string
async createOrRefreshSession(identifier: string, password: string) {
// custom logic here
this.accessToken = 'my-access-jwt'
}
async doStuff() {
return this.call('io.example.doStuff', {
headers: {
Authorization: this.accessToken && `Bearer ${this.accessToken}`,
},
})
}
}
```
</td>
<td>
```ts
import { Agent } from '@atproto/api'
class MyAgent extends Agent {
private accessToken?: string
public did?: string
constructor(private readonly service: string | URL) {
super({
service,
headers: {
Authorization: () =>
this.accessToken ? `Bearer ${this.accessToken}` : null,
},
})
}
clone(): MyAgent {
const agent = new MyAgent(this.service)
agent.accessToken = this.accessToken
agent.did = this.did
return this.copyInto(agent)
}
async createOrRefreshSession(identifier: string, password: string) {
// custom logic here
this.did = 'did:example:123'
this.accessToken = 'my-access-jwt'
}
}
```
</td>
</tr>
</table>
If you are monkey patching the `xrpc` service client to perform client-side rate limiting, you can now do this in the `FetchHandler` function:
<table>
<tr>
<td><center>Before</center></td> <td><center>After</center></td>
</tr>
<tr>
<td>
```ts
import { BskyAgent } from '@atproto/api'
import { RateLimitThreshold } from 'rate-limit-threshold'
const agent = new BskyAgent()
const limiter = new RateLimitThreshold(3000, 300_000)
const origCall = agent.api.xrpc.call
agent.api.xrpc.call = async function (...args) {
await limiter.wait()
return origCall.call(this, ...args)
}
```
</td>
<td>
```ts
import { AtpAgent } from '@atproto/api'
import { RateLimitThreshold } from 'rate-limit-threshold'
class LimitedAtpAgent extends AtpAgent {
constructor(options: AtpAgentOptions) {
const fetch: typeof globalThis.fetch = options.fetch ?? globalThis.fetch
const limiter = new RateLimitThreshold(3000, 300_000)
super({
...options,
fetch: async (...args) => {
await limiter.wait()
return fetch(...args)
},
})
}
}
```
</td>
</tr>
</table>
If you configure a static `fetch` handler on the `BskyAgent` class - for example
to modify the headers of every request - you can now do this by providing your
own `fetch` function:
<table>
<tr>
<td><center>Before</center></td> <td><center>After</center></td>
</tr>
<tr>
<td>
```ts
import { BskyAgent, defaultFetchHandler } from '@atproto/api'
BskyAgent.configure({
fetch: async (httpUri, httpMethod, httpHeaders, httpReqBody) => {
const ua = httpHeaders['User-Agent']
httpHeaders['User-Agent'] = ua ? `${ua} ${userAgent}` : userAgent
return defaultFetchHandler(httpUri, httpMethod, httpHeaders, httpReqBody)
},
})
```
</td>
<td>
```ts
import { AtpAgent } from '@atproto/api'
class MyAtpAgent extends AtpAgent {
constructor(options: AtpAgentOptions) {
const fetch = options.fetch ?? globalThis.fetch
super({
...options,
fetch: async (url, init) => {
const headers = new Headers(init.headers)
const ua = headersList.get('User-Agent')
headersList.set('User-Agent', ua ? `${ua} ${userAgent}` : userAgent)
return fetch(url, { ...init, headers })
},
})
}
}
```
</td>
</tr>
</table>
<!-- <table>
<tr>
<td><center>Before</center></td> <td><center>After</center></td>
</tr>
<tr>
<td>
```ts
// before
```
</td>
<td>
```ts
// after
```
</td>
</tr>
</table> -->
##### The `@atproto/xrpc` package
The `Client` and `ServiceClient` classes are now **deprecated**. If you need a
lexicon based client, you should update the code to use the `XrpcClient` class
instead.
The deprecated `ServiceClient` class now extends the new `XrpcClient` class.
Because of this, the `fetch` `FetchHandler` can no longer be configured on the
`Client` instances (including the default export of the package). If you are not
relying on the `fetch` `FetchHandler`, the new changes should have no impact on
your code. Beware that the deprecated classes will eventually be removed in a
future version.
Since its use has completely changed, the `FetchHandler` type has also
completely changed. The new `FetchHandler` type is now a function that receives
a `url` pathname and a `RequestInit` object and returns a `Promise<Response>`.
This function is responsible for making the actual request to the server.
```ts
export type FetchHandler = (
this: void,
/**
* The URL (pathname + query parameters) to make the request to, without the
* origin. The origin (protocol, hostname, and port) must be added by this
* {@link FetchHandler}, typically based on authentication or other factors.
*/
url: string,
init: RequestInit,
) => Promise<Response>
```
A noticeable change that has been introduced is that the `uri` field of the
`ServiceClient` class has _not_ been ported to the new `XrpcClient` class. It is
now the responsibility of the `FetchHandler` to determine the full URL to make
the request to. The same goes for the `headers`, which should now be set through
the `FetchHandler` function.
If you _do_ rely on the legacy `Client.fetch` property to perform custom logic
upon request, you will need to migrate your code to use the new `XrpcClient`
class. The `XrpcClient` class has a similar API to the old `ServiceClient`
class, but with a few differences:
- The `Client` + `ServiceClient` duality was removed in favor of a single
`XrpcClient` class. This means that:
- There no longer exists a centralized lexicon registry. If you need a global
lexicon registry, you can maintain one yourself using a `new Lexicons` (from
`@atproto/lexicon`).
- The `FetchHandler` is no longer a statically defined property of the
`Client` class. Instead, it is passed as an argument to the `XrpcClient`
constructor.
- The `XrpcClient` constructor now requires a `FetchHandler` function as the
first argument, and an optional `Lexicon` instance as the second argument.
- The `setHeader` and `unsetHeader` methods were not ported to the new
`XrpcClient` class. If you need to set or unset headers, you should do so in
the `FetchHandler` function provided in the constructor arg.
<table>
<tr>
<td><center>Before</center></td> <td><center>After</center></td>
</tr>
<tr>
<td>
```ts
import client, { defaultFetchHandler } from '@atproto/xrpc'
client.fetch = function (
httpUri: string,
httpMethod: string,
httpHeaders: Headers,
httpReqBody: unknown,
) {
// Custom logic here
return defaultFetchHandler(httpUri, httpMethod, httpHeaders, httpReqBody)
}
client.addLexicon({
lexicon: 1,
id: 'io.example.doStuff',
defs: {},
})
const instance = client.service('http://my-service.com')
instance.setHeader('my-header', 'my-value')
await instance.call('io.example.doStuff')
```
</td>
<td>
```ts
import { XrpcClient } from '@atproto/xrpc'
const instance = new XrpcClient(
async (url, init) => {
const headers = new Headers(init.headers)
headers.set('my-header', 'my-value')
// Custom logic here
const fullUrl = new URL(url, 'http://my-service.com')
return fetch(fullUrl, { ...init, headers })
},
[
{
lexicon: 1,
id: 'io.example.doStuff',
defs: {},
},
],
)
await instance.call('io.example.doStuff')
```
</td>
</tr>
</table>
If your fetch handler does not require any "custom logic", and all you need is
an `XrpcClient` that makes its HTTP requests towards a static service URL, the
previous example can be simplified to:
```ts
import { XrpcClient } from '@atproto/xrpc'
const instance = new XrpcClient('http://my-service.com', [
{
lexicon: 1,
id: 'io.example.doStuff',
defs: {},
},
])
```
If you need to add static headers to all requests, you can instead instantiate
the `XrpcClient` as follows:
```ts
import { XrpcClient } from '@atproto/xrpc'
const instance = new XrpcClient(
{
service: 'http://my-service.com',
headers: {
'my-header': 'my-value',
},
},
[
{
lexicon: 1,
id: 'io.example.doStuff',
defs: {},
},
],
)
```
If you need the headers or service url to be dynamic, you can define them using
functions:
```ts
import { XrpcClient } from '@atproto/xrpc'
const instance = new XrpcClient(
{
service: () => 'http://my-service.com',
headers: {
'my-header': () => 'my-value',
'my-ignored-header': () => null, // ignored
},
},
[
{
lexicon: 1,
id: 'io.example.doStuff',
defs: {},
},
],
)
```
- [#2483](https://github.com/bluesky-social/atproto/pull/2483) [`b934b396b`](https://github.com/bluesky-social/atproto/commit/b934b396b13ba32bf2bf7e75ecdf6871e5f310dd) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Add the ability to use `fetch()` compatible `BodyInit` body when making XRPC calls.
### Patch Changes
- Updated dependencies [[`2ded0156b`](https://github.com/bluesky-social/atproto/commit/2ded0156b9adf33b9cce66583a375bff922d383b), [`2ded0156b`](https://github.com/bluesky-social/atproto/commit/2ded0156b9adf33b9cce66583a375bff922d383b)]:
- @atproto/lexicon@0.4.1-rc.0
- Updated dependencies [[`b934b396b`](https://github.com/bluesky-social/atproto/commit/b934b396b13ba32bf2bf7e75ecdf6871e5f310dd), [`2bdf75d7a`](https://github.com/bluesky-social/atproto/commit/2bdf75d7a63924c10e7a311f16cb447d595b933e)]:
- @atproto/lexicon@0.4.1

@@ -38,0 +574,0 @@ ## 0.5.0

6

dist/client.d.ts
import { LexiconDoc, Lexicons } from '@atproto/lexicon';
import { CallOptions, Gettable, QueryParams } from './types';
import { CallOptions, QueryParams } from './types';
import { XrpcClient } from './xrpc-client';

@@ -21,7 +21,7 @@ /** @deprecated Use {@link XrpcClient} instead */

uri: URL;
protected headers: Map<string, Gettable<string | null>>;
headers: Record<string, string>;
constructor(baseClient: Client, serviceUri: string | URL);
setHeader(key: string, value: Gettable<null | string>): void;
setHeader(key: string, value: string): void;
unsetHeader(key: string): void;
}
//# sourceMappingURL=client.d.ts.map

8

dist/client.js

@@ -52,3 +52,3 @@ "use strict";

super(async (input, init) => {
const headers = (0, util_1.combineHeaders)(init.headers, this.headers);
const headers = (0, util_1.combineHeaders)(init.headers, Object.entries(this.headers));
return fetch(new URL(input, this.uri), { ...init, headers });

@@ -72,3 +72,3 @@ }, baseClient.lex);

writable: true,
value: new Map()
value: {}
});

@@ -78,6 +78,6 @@ this.uri = typeof serviceUri === 'string' ? new URL(serviceUri) : serviceUri;

setHeader(key, value) {
this.headers.set(key.toLowerCase(), value);
this.headers[key] = value;
}
unsetHeader(key) {
this.headers.delete(key.toLowerCase());
delete this.headers[key];
}

@@ -84,0 +84,0 @@ }

2

dist/fetch-handler.d.ts

@@ -32,3 +32,3 @@ import { Gettable } from './types';

};
export declare function buildFetchHandler(options: FetchHandlerOptions): FetchHandler;
export declare function buildFetchHandler(options: FetchHandler | FetchHandlerOptions): FetchHandler;
//# sourceMappingURL=fetch-handler.d.ts.map

3

dist/fetch-handler.js

@@ -6,2 +6,5 @@ "use strict";

function buildFetchHandler(options) {
// Already a fetch handler (allowed for convenience)
if (typeof options === 'function')
return options;
const { service, headers: defaultHeaders = undefined, fetch = globalThis.fetch, } = typeof options === 'string' || options instanceof URL

@@ -8,0 +11,0 @@ ? { service: options }

91

dist/util.js

@@ -150,18 +150,18 @@ "use strict";

let headers = undefined;
for (const [key, getter] of defaultHeaders) {
for (const [name, definition] of defaultHeaders) {
// Ignore undefined values (allowed for convenience when using
// Object.entries).
if (getter === undefined)
if (definition === undefined)
continue;
// Lazy initialization of the headers object
headers ?? (headers = new Headers(headersInit));
if (headers.has(key))
if (headers.has(name))
continue;
const value = typeof getter === 'function' ? getter() : getter;
const value = typeof definition === 'function' ? definition() : definition;
if (typeof value === 'string')
headers.set(key, value);
headers.set(name, value);
else if (value === null)
headers.delete(key);
headers.delete(name);
else
throw new TypeError(`Invalid "${key}" header value: ${typeof value}`);
throw new TypeError(`Invalid "${name}" header value: ${typeof value}`);
}

@@ -270,74 +270,9 @@ return headers ?? headersInit;

}
// Note, in environments where ReadableStream is not available either, we
// *could* load the iterable into memory and create an Arraybuffer from it.
// However, this would be a bad idea for large iterables. In order to keep
// things simple, we'll just allow the anonymous ReadableStream constructor
// to throw an error in those environments, hinting the user of the lib to find
// an alternate solution in that case (e.g. use a Blob if available).
let generator;
return new ReadableStream({
type: 'bytes',
start() {
// Wrap the iterable in an async generator to handle both sync and async
// iterables, and make sure that the return() method exists.
generator = (async function* () {
yield* iterable;
})();
},
async pull(controller) {
const { done, value } = await generator.next();
if (done) {
controller.close();
}
else {
try {
const buf = toUint8Array(value);
if (buf)
controller.enqueue(buf);
}
catch (cause) {
// ReadableStream won't call cancel() if the stream is errored.
await generator.return();
controller.error(new TypeError('Converting iterable body to ReadableStream requires Buffer, ArrayBuffer or string values', { cause }));
}
}
},
async cancel() {
await generator.return();
},
});
// If you see this error, consider using a polyfill for ReadableStream. For
// example, the "web-streams-polyfill" package:
// https://github.com/MattiasBuelens/web-streams-polyfill
throw new TypeError('ReadableStream.from() is not supported in this environment. ' +
'It is required to support using iterables as the request body. ' +
'Consider using a polyfill or re-write your code to use a different body type.');
}
// Browsers don't have Buffer. This syntax is to avoid bundlers from including
// a Buffer polyfill in the bundle if it's not used elsewhere.
const globalName = `${{ toString: () => 'Buf' }}fer`;
const Buffer = typeof globalThis[globalName] === 'function'
? globalThis[globalName]
: undefined;
const toUint8Array = Buffer
? (value) => {
// @ts-expect-error Buffer.from will throw if value is not a valid input
const buf = Buffer.isBuffer(value) ? value : Buffer.from(value);
return buf.byteLength ? new Uint8Array(buf) : undefined;
}
: (value) => {
if (value instanceof ArrayBuffer) {
const buf = new Uint8Array(value);
return buf.byteLength ? buf : undefined;
}
// Simulate Buffer.from() behavior for strings and and coercion
if (typeof value === 'string') {
return value.length ? new TextEncoder().encode(value) : undefined;
}
else if (typeof value?.valueOf === 'function') {
const coerced = value.valueOf();
if (coerced instanceof ArrayBuffer) {
const buf = new Uint8Array(coerced);
return buf.byteLength ? buf : undefined;
}
else if (typeof coerced === 'string') {
return coerced.length ? new TextEncoder().encode(coerced) : undefined;
}
}
throw new TypeError(`Unable to convert "${typeof value}" to Uint8Array`);
};
function httpResponseBodyParse(mimeType, data) {

@@ -344,0 +279,0 @@ try {

2

dist/xrpc-client.d.ts

@@ -7,5 +7,5 @@ import { LexiconDoc, Lexicons } from '@atproto/lexicon';

readonly lex: Lexicons;
constructor(fetchHandler: FetchHandler | FetchHandlerOptions, lex: Lexicons | Iterable<LexiconDoc>);
constructor(fetchHandlerOpts: FetchHandler | FetchHandlerOptions, lex: Lexicons | Iterable<LexiconDoc>);
call(methodNsid: string, params?: QueryParams, data?: unknown, opts?: CallOptions): Promise<XRPCResponse>;
}
//# sourceMappingURL=xrpc-client.d.ts.map

12

dist/xrpc-client.js

@@ -9,3 +9,6 @@ "use strict";

class XrpcClient {
constructor(fetchHandler, lex) {
constructor(fetchHandlerOpts,
// "Lexicons" is redundant here (because that class implements
// "Iterable<LexiconDoc>") but we keep it for explicitness:
lex) {
Object.defineProperty(this, "fetchHandler", {

@@ -23,6 +26,3 @@ enumerable: true,

});
this.fetchHandler =
typeof fetchHandler === 'function'
? fetchHandler
: (0, fetch_handler_1.buildFetchHandler)(fetchHandler);
this.fetchHandler = (0, fetch_handler_1.buildFetchHandler)(fetchHandlerOpts);
this.lex = lex instanceof lexicon_1.Lexicons ? lex : new lexicon_1.Lexicons(lex);

@@ -35,3 +35,3 @@ }

}
//@TODO: should we validate the params and data here?
// @TODO: should we validate the params and data here?
// this.lex.assertValidXrpcParams(methodNsid, params)

@@ -38,0 +38,0 @@ // if (data !== undefined) {

4

package.json
{
"name": "@atproto/xrpc",
"version": "0.6.0-rc.0",
"version": "0.6.0",
"license": "MIT",

@@ -20,3 +20,3 @@ "description": "atproto HTTP API (XRPC) client library",

"zod": "^3.23.8",
"@atproto/lexicon": "^0.4.1-rc.0"
"@atproto/lexicon": "^0.4.1"
},

@@ -23,0 +23,0 @@ "devDependencies": {

12

src/client.ts
import { LexiconDoc, Lexicons } from '@atproto/lexicon'
import { CallOptions, Gettable, QueryParams } from './types'
import { CallOptions, QueryParams } from './types'
import { XrpcClient } from './xrpc-client'

@@ -62,3 +62,3 @@ import { combineHeaders } from './util'

uri: URL
protected headers = new Map<string, Gettable<null | string>>()
headers: Record<string, string> = {}

@@ -70,3 +70,3 @@ constructor(

super(async (input, init) => {
const headers = combineHeaders(init.headers, this.headers)
const headers = combineHeaders(init.headers, Object.entries(this.headers))
return fetch(new URL(input, this.uri), { ...init, headers })

@@ -77,9 +77,9 @@ }, baseClient.lex)

setHeader(key: string, value: Gettable<null | string>): void {
this.headers.set(key.toLowerCase(), value)
setHeader(key: string, value: string): void {
this.headers[key] = value
}
unsetHeader(key: string): void {
this.headers.delete(key.toLowerCase())
delete this.headers[key]
}
}

7

src/fetch-handler.ts

@@ -42,3 +42,8 @@ import { Gettable } from './types'

export function buildFetchHandler(options: FetchHandlerOptions): FetchHandler {
export function buildFetchHandler(
options: FetchHandler | FetchHandlerOptions,
): FetchHandler {
// Already a fetch handler (allowed for convenience)
if (typeof options === 'function') return options
const {

@@ -45,0 +50,0 @@ service,

99

src/util.ts

@@ -196,6 +196,6 @@ import {

for (const [key, getter] of defaultHeaders) {
for (const [name, definition] of defaultHeaders) {
// Ignore undefined values (allowed for convenience when using
// Object.entries).
if (getter === undefined) continue
if (definition === undefined) continue

@@ -205,9 +205,9 @@ // Lazy initialization of the headers object

if (headers.has(key)) continue
if (headers.has(name)) continue
const value = typeof getter === 'function' ? getter() : getter
const value = typeof definition === 'function' ? definition() : definition
if (typeof value === 'string') headers.set(key, value)
else if (value === null) headers.delete(key)
else throw new TypeError(`Invalid "${key}" header value: ${typeof value}`)
if (typeof value === 'string') headers.set(name, value)
else if (value === null) headers.delete(name)
else throw new TypeError(`Invalid "${name}" header value: ${typeof value}`)
}

@@ -348,82 +348,13 @@

// Note, in environments where ReadableStream is not available either, we
// *could* load the iterable into memory and create an Arraybuffer from it.
// However, this would be a bad idea for large iterables. In order to keep
// things simple, we'll just allow the anonymous ReadableStream constructor
// to throw an error in those environments, hinting the user of the lib to find
// an alternate solution in that case (e.g. use a Blob if available).
// If you see this error, consider using a polyfill for ReadableStream. For
// example, the "web-streams-polyfill" package:
// https://github.com/MattiasBuelens/web-streams-polyfill
let generator: AsyncGenerator<unknown, void, undefined>
return new ReadableStream<Uint8Array>({
type: 'bytes',
start() {
// Wrap the iterable in an async generator to handle both sync and async
// iterables, and make sure that the return() method exists.
generator = (async function* () {
yield* iterable
})()
},
async pull(controller: ReadableStreamDefaultController) {
const { done, value } = await generator.next()
if (done) {
controller.close()
} else {
try {
const buf = toUint8Array(value)
if (buf) controller.enqueue(buf)
} catch (cause) {
// ReadableStream won't call cancel() if the stream is errored.
await generator.return()
controller.error(
new TypeError(
'Converting iterable body to ReadableStream requires Buffer, ArrayBuffer or string values',
{ cause },
),
)
}
}
},
async cancel() {
await generator.return()
},
})
throw new TypeError(
'ReadableStream.from() is not supported in this environment. ' +
'It is required to support using iterables as the request body. ' +
'Consider using a polyfill or re-write your code to use a different body type.',
)
}
// Browsers don't have Buffer. This syntax is to avoid bundlers from including
// a Buffer polyfill in the bundle if it's not used elsewhere.
const globalName = `${{ toString: () => 'Buf' }}fer` as 'Buffer'
const Buffer =
typeof globalThis[globalName] === 'function'
? globalThis[globalName]
: undefined
const toUint8Array: (value: unknown) => Uint8Array | undefined = Buffer
? (value) => {
// @ts-expect-error Buffer.from will throw if value is not a valid input
const buf = Buffer.isBuffer(value) ? value : Buffer.from(value)
return buf.byteLength ? new Uint8Array(buf) : undefined
}
: (value) => {
if (value instanceof ArrayBuffer) {
const buf = new Uint8Array(value)
return buf.byteLength ? buf : undefined
}
// Simulate Buffer.from() behavior for strings and and coercion
if (typeof value === 'string') {
return value.length ? new TextEncoder().encode(value) : undefined
} else if (typeof value?.valueOf === 'function') {
const coerced = value.valueOf()
if (coerced instanceof ArrayBuffer) {
const buf = new Uint8Array(coerced)
return buf.byteLength ? buf : undefined
} else if (typeof coerced === 'string') {
return coerced.length ? new TextEncoder().encode(coerced) : undefined
}
}
throw new TypeError(`Unable to convert "${typeof value}" to Uint8Array`)
}
export function httpResponseBodyParse(

@@ -430,0 +361,0 @@ mimeType: string | null,

11

src/xrpc-client.ts

@@ -30,9 +30,8 @@ import { LexiconDoc, Lexicons, ValidationError } from '@atproto/lexicon'

constructor(
fetchHandler: FetchHandler | FetchHandlerOptions,
fetchHandlerOpts: FetchHandler | FetchHandlerOptions,
// "Lexicons" is redundant here (because that class implements
// "Iterable<LexiconDoc>") but we keep it for explicitness:
lex: Lexicons | Iterable<LexiconDoc>,
) {
this.fetchHandler =
typeof fetchHandler === 'function'
? fetchHandler
: buildFetchHandler(fetchHandler)
this.fetchHandler = buildFetchHandler(fetchHandlerOpts)

@@ -55,3 +54,3 @@ this.lex = lex instanceof Lexicons ? lex : new Lexicons(lex)

//@TODO: should we validate the params and data here?
// @TODO: should we validate the params and data here?
// this.lex.assertValidXrpcParams(methodNsid, params)

@@ -58,0 +57,0 @@ // if (data !== undefined) {

dist/client.d.ts.map

Sorry, the diff of this file is not supported yet

dist/client.js.map

Sorry, the diff of this file is not supported yet

dist/fetch-handler.d.ts.map

Sorry, the diff of this file is not supported yet

dist/fetch-handler.js.map

Sorry, the diff of this file is not supported yet

dist/util.d.ts.map

Sorry, the diff of this file is not supported yet

dist/util.js.map

Sorry, the diff of this file is not supported yet

dist/xrpc-client.d.ts.map

Sorry, the diff of this file is not supported yet

dist/xrpc-client.js.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc