refactor!: access-client store decoupling

packages/access-api/test/helpers/context.js

@@ -44,12 +44,12 @@ export async function context() {
 
   return {
     mf,
-    conn: await connection(
+    conn: connection({
       principal,
       // @ts-ignore
-      mf.dispatchFetch.bind(mf),
-      new URL('http://localhost:8787')
-    ),
+      fetch: mf.dispatchFetch.bind(mf),
+      url: new URL('http://localhost:8787'),
+    }),
     service: Signer.parse(bindings.PRIVATE_KEY),
     issuer: principal,
     db: new D1QB(db),

packages/access-client/package.json

@@ -28,6 +28,7 @@
   "exports": {
     ".": "./src/index.js",
     "./agent": "./src/agent.js",
+    "./drivers/*": "./src/drivers/*.js",
     "./stores/*": "./src/stores/*.js",
     "./types": "./src/types.js",
     "./encoding": "./src/encoding.js"
@@ -40,6 +41,9 @@
       "types": [
         "dist/src/types"
       ],
+      "drivers/*": [
+        "dist/src/drivers/*"
+      ],
       "stores/*": [
         "dist/src/stores/*"
       ],

packages/access-client/src/agent-data.js

@@ -0,0 +1,145 @@
+import { Signer } from '@ucanto/principal'
+import { Signer as EdSigner } from '@ucanto/principal/ed25519'
+import { importDAG } from '@ucanto/core/delegation'
+import { CID } from 'multiformats'
+
+/** @typedef {import('./types').AgentDataModel} AgentDataModel */
+
+/** @implements {AgentDataModel} */
+export class AgentData {
+  /** @type {(data: import('./types').AgentDataExport) => Promise<void> | void} */
+  #save
+
+  /**
+   * @param {import('./types').AgentDataModel} data
+   * @param {import('./types').AgentDataOptions} [options]
+   */
+  constructor(data, options = {}) {
+    this.meta = data.meta
+    this.principal = data.principal
+    this.spaces = data.spaces
+    this.delegations = data.delegations
+    this.currentSpace = data.currentSpace
+    this.#save = options.store ? options.store.save : () => {}
+  }
+
+  /**
+   * Create a new AgentData instance from the passed initialization data.
+   *
+   * @param {Partial<import('./types').AgentDataModel>} [init]
+   * @param {import('./types').AgentDataOptions} [options]
+   */
+  static async create(init = {}, options = {}) {
+    const agentData = new AgentData(
+      {
+        meta: { name: 'agent', type: 'device', ...init.meta },
+        principal: init.principal ?? (await EdSigner.generate()),
+        spaces: init.spaces ?? new Map(),
+        delegations: init.delegations ?? new Map(),
+        currentSpace: init.currentSpace,
+      },
+      options
+    )
+    if (options.store) {
+      await options.store.save(agentData.export())
+    }
+    return agentData
+  }
+
+  /**
+   * Instantiate AgentData from previously exported data.
+   *
+   * @param {import('./types').AgentDataExport} raw
+   * @param {import('./types').AgentDataOptions} [options]
+   */
+  static fromExport(raw, options) {
+    /** @type {import('./types').AgentDataModel['delegations']} */
+    const dels = new Map()
+
+    for (const [key, value] of raw.delegations) {
+      dels.set(key, {
+        delegation: importDAG(
+          value.delegation.map((d) => ({
+            cid: CID.parse(d.cid),
+            bytes: d.bytes,
+          }))
+        ),
+        meta: value.meta,
+      })
+    }
+
+    return new AgentData(
+      {
+        meta: raw.meta,
+        // @ts-expect-error
+        principal: Signer.from(raw.principal),
+        currentSpace: raw.currentSpace,
+        spaces: raw.spaces,
+        delegations: dels,
+      },
+      options
+    )
+  }
+
+  /**
+   * Export data in a format safe to pass to `structuredClone()`.
+   */
+  export() {
+    /** @type {import('./types').AgentDataExport} */
+    const raw = {
+      meta: this.meta,
+      principal: this.principal.toArchive(),
+      currentSpace: this.currentSpace,
+      spaces: this.spaces,
+      delegations: new Map(),
+    }
+    for (const [key, value] of this.delegations) {
+      raw.delegations.set(key, {
+        meta: value.meta,
+        delegation: [...value.delegation.export()].map((b) => ({
+          cid: b.cid.toString(),
+          bytes: b.bytes,
+        })),
+      })
+    }
+    return raw
+  }
+
+  /**
+   * @param {import('@ucanto/interface').DID} did
+   * @param {import('./types').SpaceMeta} meta
+   * @param {import('@ucanto/interface').Delegation} [proof]
+   */
+  async addSpace(did, meta, proof) {
+    this.spaces.set(did, meta)
+    await (proof ? this.addDelegation(proof) : this.#save(this.export()))
+  }
+
+  /**
+   * @param {import('@ucanto/interface').DID} did
+   */
+  async setCurrentSpace(did) {
+    this.currentSpace = did
+    await this.#save(this.export())
+  }
+
+  /**
+   * @param {import('@ucanto/interface').Delegation} delegation
+   * @param {import('./types').DelegationMeta} [meta]
+   */
+  async addDelegation(delegation, meta) {
+    this.delegations.set(delegation.cid.toString(), {
+      delegation,
+      meta: meta ?? {},
+    })
+    await this.#save(this.export())
+  }
+
+  /**
+   * @param {import('@ucanto/interface').UCANLink} cid
+   */
+  async removeDelegation(cid) {
+    this.delegations.delete(cid.toString())
+    await this.#save(this.export())
+  }
+}