Gozala
commented
11 months ago This is roughly the interface I had in mind when talking about it
interface ConnecionModel {
/**
* Local keypair use to sign messages send over the connection.
*/
readonly issuer: Ucanto.Signer
/**
* DID of the destination.
*/
readonly audience: Ucanto.Principal
/**
* Wire transport encoding.
*/
readonly codec: Ucanto.Transport.OutboundCodec
/**
* Ucanto Transport channel.
*/
readonly channel: Ucanto.Transport.Channel
}
interface Model {
/**
* Connection to the (remote) agent a.k.a service.
*/
connection: ConnecionModel
/**
* Set of delegations that can be used to invoke capabilities over `connection`.
*/
authorization: Store<Ucanto.Delegation>
}
interface AgentView {
model: Model
accounts: AgentAccounts
login(email: string): Promise<AccountView>
}
interface AgentAccounts extends Iterable<AccountView> {
get(email: string): AccountView
add(account: AccountView): Promise<AccountView>
remove(account: AccountView): Promise<void>
}
interface AccountView {
spaces: Spaces
plan: AccountPlan
}
interface AccountPlan {
get(): PlanView
}
interface PlanView {
subscriptions: Subscriptions
}
interface Subscriptions extends Iterable<Subscription> {
get(id: string): Subscription
add(subscription: Subscription): Promise<Subscription>
remove(subscription: Subscription): Promise<void>
}
interface Subscription {
consumer: SpaceDID
}
interface Spaces extends Iterable<SpaceView> {
get(name: string): SpaceView
add(space: SpaceView): Promise<SpaceView>
remove(space: SpaceView): Promise<void>
}
interface SpaceView {
upload: UploadView
store: StoreView
createFileUploader(): FileUploader
createDirectoryUploader(): DirectoryUploader
createArchiveUploader(): ArchiveUploader
}
export interface Uploader {
/**
* Writes contents of the upload to the space without adding it to the upload
* list.
*/
store(space?: SpaceView): Promise<Upload>
/**
* Writes content of the upload to the space and adds it to the upload list.
*/
upload(space?: SpaceView): Promise<Upload>
}
interface FileUploader extends Uploader {
}
interface DirectoryUploader extends Uploader {
}
interface ArchiveUploader extends Uploader {
}
interface Upload {
root: Link
shards: CARLink[]
}
interface UploadView {
add(upload: Upload): Promise<Upload>
remove(upload: Upload): Promise<Unit>
list(): Promise<Upload[]>
}
interface StoreView {
add(shard: Archive): Promise<ArchiveWriter>
remove(shard: Archive): Promise<Unit>
list(): Promise<Archive[]>
}
interface Archive {
link: Link
size: number
}
interface ArchiveWriter {
write(bytes: Uint8Array): Promise<void>
}
alanshaw
hannahhoward
Me @alanshaw, @vasco-santos and @travis had been talking about revisiting API for the client at the labweek and have got some feedback from the workshop which was validating of the one we were entertaining, I thought I'd sketch it here so we can discuss it further. Before I proceed let me call out some high level goals I have in my mind.
AgentView- Convenience wrapper of what I have access to on this agent.AccountView- Agent may have access to arbitrary number of accounts represented viaAccountViewwhich should simply be another view over the "proofs store". When you login you get a newAccountView(holding account to agent delegation) if you do want to persist reference to the account across the agent sessions you doagent.add(account).SpaceView- Agent may have access to arbitrary number of spaces represented viaSpaceViewwhich should also be views over "proofs store". When you create a space you get a newOwnedSpaceView. If you want to retain access to space across devices and sessions you'd callaccount.add(space). If you do not want to add space to the account you can add it it e.g.agent.local.add(space)or something like that so we emphasize the fact that space is detached from any account.account.remove(space)which simply revokes delegation from space to account.UploadViewandStoreViewwill be just be views that expose correspondingupload/*andstore/*capabilities of the space. I don't mean subclasses here, simply views over the same model. And space could probably have.uploadand and.storefields with the corresponding views.