feat: change plan/update to plan/set and use existing PlansStorage#set to implement an invocation handler

packages/capabilities/src/plan.js

@@ -16,8 +16,8 @@ export const get = capability({
 /**
  * Capability can be invoked by an account to change its billing plan.
  */
-export const update = capability({
-  can: 'plan/update',
+export const set = capability({
+  can: 'plan/set',
   with: AccountDID,
   nb: struct({
     product: DID,

packages/capabilities/src/types.ts

@@ -630,9 +630,9 @@ export interface PlanNotFound extends Ucanto.Failure {
 
 export type PlanGetFailure = PlanNotFound
 
-export type PlanUpdate = InferInvokedCapability<typeof PlanCaps.update>
+export type PlanSet = InferInvokedCapability<typeof PlanCaps.set>
 
-export type PlanUpdateSuccess = Unit
+export type PlanSetSuccess = Unit
 
 export interface AccountNotFound extends Ucanto.Failure {
   name: 'AccountNotFound'
@@ -642,7 +642,7 @@ export interface InvalidPlanName extends Ucanto.Failure {
   name: 'InvalidPlanName'
 }
 
-export type PlanUpdateFailure = AccountNotFound
+export type PlanSetFailure = AccountNotFound
 
 // Top
 export type Top = InferInvokedCapability<typeof top>

packages/capabilities/test/capabilities/plan.test.js

@@ -95,11 +95,11 @@ describe('plan/get', function () {
   })
 })
 
-describe('plan/update', function () {
+describe('plan/set', function () {
   const agent = alice
   const account = 'did:mailto:mallory.com:mallory'
   it('can invoke as an account', async function () {
-    const auth = Plan.update.invoke({
+    const auth = Plan.set.invoke({
       issuer: agent,
       audience: service,
       with: account,
@@ -109,7 +109,7 @@ describe('plan/update', function () {
       proofs: await createAuthorization({ agent, service, account }),
     })
     const result = await access(await auth.delegate(), {
-      capability: Plan.update,
+      capability: Plan.set,
       principal: Verifier,
       authority: service,
       validateAuthorization,
@@ -118,14 +118,14 @@ describe('plan/update', function () {
       assert.fail(`error in self issue: ${result.error.message}`)
     } else {
       assert.deepEqual(result.ok.audience.did(), service.did())
-      assert.equal(result.ok.capability.can, 'plan/update')
+      assert.equal(result.ok.capability.can, 'plan/set')
       assert.deepEqual(result.ok.capability.with, account)
     }
   })
 
   it('fails without account delegation', async function () {
     const agent = alice
-    const auth = Plan.update.invoke({
+    const auth = Plan.set.invoke({
       issuer: agent,
       audience: service,
       with: account,
@@ -135,7 +135,7 @@ describe('plan/update', function () {
     })
 
     const result = await access(await auth.delegate(), {
-      capability: Plan.update,
+      capability: Plan.set,
       principal: Verifier,
       authority: service,
       validateAuthorization,
@@ -145,7 +145,7 @@ describe('plan/update', function () {
   })
 
   it('fails when invoked by a different agent', async function () {
-    const auth = Plan.update.invoke({
+    const auth = Plan.set.invoke({
       issuer: bob,
       audience: service,
       with: account,
@@ -156,24 +156,24 @@ describe('plan/update', function () {
     })
 
     const result = await access(await auth.delegate(), {
-      capability: Plan.update,
+      capability: Plan.set,
       principal: Verifier,
       authority: service,
       validateAuthorization,
     })
     assert.equal(result.error?.message.includes('not authorized'), true)
   })
 
-  it('can delegate plan/update', async function () {
-    const invocation = Plan.update.invoke({
+  it('can delegate plan/set', async function () {
+    const invocation = Plan.set.invoke({
       issuer: bob,
       audience: service,
       with: account,
       nb: {
         product: 'did:web:lite.web3.storage',
       },
       proofs: [
-        await Plan.update.delegate({
+        await Plan.set.delegate({
           issuer: agent,
           audience: bob,
           with: account,
@@ -182,7 +182,7 @@ describe('plan/update', function () {
       ],
     })
     const result = await access(await invocation.delegate(), {
-      capability: Plan.update,
+      capability: Plan.set,
       principal: Verifier,
       authority: service,
       validateAuthorization,
@@ -191,21 +191,21 @@ describe('plan/update', function () {
       assert.fail(`error in self issue: ${result.error.message}`)
     } else {
       assert.deepEqual(result.ok.audience.did(), service.did())
-      assert.equal(result.ok.capability.can, 'plan/update')
+      assert.equal(result.ok.capability.can, 'plan/set')
       assert.deepEqual(result.ok.capability.with, account)
     }
   })
 
-  it('can invoke plan/update with the product that its delegation specifies', async function () {
-    const invocation = Plan.update.invoke({
+  it('can invoke plan/set with the product that its delegation specifies', async function () {
+    const invocation = Plan.set.invoke({
       issuer: bob,
       audience: service,
       with: account,
       nb: {
         product: 'did:web:lite.web3.storage',
       },
       proofs: [
-        await Plan.update.delegate({
+        await Plan.set.delegate({
           issuer: agent,
           audience: bob,
           with: account,
@@ -217,7 +217,7 @@ describe('plan/update', function () {
       ],
     })
     const result = await access(await invocation.delegate(), {
-      capability: Plan.update,
+      capability: Plan.set,
       principal: Verifier,
       authority: service,
       validateAuthorization,
@@ -226,21 +226,21 @@ describe('plan/update', function () {
       assert.fail(`error in self issue: ${result.error.message}`)
     } else {
       assert.deepEqual(result.ok.audience.did(), service.did())
-      assert.equal(result.ok.capability.can, 'plan/update')
+      assert.equal(result.ok.capability.can, 'plan/set')
       assert.deepEqual(result.ok.capability.with, account)
     }
   })
 
-  it('cannot invoke plan/update with a different product than its delegation specifies', async function () {
-    const invocation = Plan.update.invoke({
+  it('cannot invoke plan/set with a different product than its delegation specifies', async function () {
+    const invocation = Plan.set.invoke({
       issuer: bob,
       audience: service,
       with: account,
       nb: {
         product: 'did:web:lite.web3.storage',
       },
       proofs: [
-        await Plan.update.delegate({
+        await Plan.set.delegate({
           issuer: agent,
           audience: bob,
           with: account,
@@ -252,7 +252,7 @@ describe('plan/update', function () {
       ],
     })
     const result = await access(await invocation.delegate(), {
-      capability: Plan.update,
+      capability: Plan.set,
       principal: Verifier,
       authority: service,
       validateAuthorization,

packages/upload-api/src/plan/set.js

@@ -0,0 +1,18 @@
+import * as API from '../types.js'
+import * as Provider from '@ucanto/server'
+import { Plan } from '@web3-storage/capabilities'
+
+/**
+ * @param {API.PlanServiceContext} context
+ */
+export const provide = (context) =>
+  Provider.provide(Plan.set, (input) => set(input, context))
+
+/**
+ * @param {API.Input<Plan.set>} input
+ * @param {API.PlanServiceContext} context
+ * @returns {Promise<API.Result<API.PlanSetSuccess, API.PlanSetFailure>>}
+ */
+const set = async ({ capability }, context) => {
+  return context.plansStorage.set(capability.with, capability.nb.product)
+}

packages/upload-api/src/types/plans.ts

@@ -1,5 +1,5 @@
 import * as Ucanto from '@ucanto/interface'
-import { AccountDID, DID, PlanGetFailure, PlanGetSuccess } from '../types.js'
+import { AccountDID, DID, PlanGetFailure, PlanGetSuccess, PlanSetFailure, PlanSetSuccess } from '../types.js'
 
 export type PlanID = DID
 
@@ -17,12 +17,13 @@ export interface PlansStorage {
   ) => Promise<Ucanto.Result<PlanGetSuccess, PlanGetFailure>>
 
   /**
-   * Set an account's plan
+   * Set an account's plan. Update our systems and any third party billing systems.
    *
    * @param account account DID
+   * @param plan the DID of the new plan
    */
   set: (
     account: AccountDID,
     plan: DID
-  ) => Promise<Ucanto.Result<Ucanto.Unit, Ucanto.Failure>>
+  ) => Promise<Ucanto.Result<PlanSetSuccess, PlanSetFailure>>
 }