@bedrock/vc-delivery 7.5.0 → 7.7.0

package/lib/http.js

@@ -3,6 +3,7 @@
  */
 import * as bedrock from '@bedrock/core';
 import * as exchanges from './exchanges.js';
+import * as inviteRequest from './inviteRequest/http.js';
 import * as oid4 from './oid4/http.js';
 import {createExchange, getProtocols, processExchange} from './vcapi.js';
 import {
@@ -147,6 +148,10 @@ export async function addRoutes({app, service} = {}) {
       res.json({protocols});
     }));
 
+  // create `inviteRequest` routes to be used with each individual exchange
+  await inviteRequest.createRoutes(
+    {app, exchangeRoute: routes.exchange, getConfigMiddleware, getExchange});
+
   // create OID4* routes to be used with each individual exchange
   await oid4.createRoutes(
     {app, exchangeRoute: routes.exchange, getConfigMiddleware, getExchange});

package/lib/index.js

@@ -17,8 +17,13 @@ import './config.js';
 
 const {util: {BedrockError}} = bedrock;
 
+// export programmatic access to workflow service
+export let workflowService;
+
 bedrock.events.on('bedrock.init', async () => {
-  await _initService({serviceType: 'vc-workflow', routePrefix: '/workflows'});
+  workflowService = await _initService({
+    serviceType: 'vc-workflow', routePrefix: '/workflows'
+  });
   // backwards compatibility: deprecrated `exchangers` service
   await _initService({serviceType: 'vc-exchanger', routePrefix: '/exchangers'});
 });
@@ -102,6 +107,8 @@ async function _initService({serviceType, routePrefix}) {
   bedrock.events.on(event, async () => {
     await initializeServiceAgent({serviceType});
   });
+
+  return service;
 }
 
 async function usageAggregator({meter, signal, service} = {}) {

package/lib/inviteRequest/http.js

@@ -0,0 +1,33 @@
+/*!
+ * Copyright (c) 2025 Digital Bazaar, Inc. All rights reserved.
+ */
+import * as inviteRequest from './inviteRequest.js';
+import {asyncHandler} from '@bedrock/express';
+import cors from 'cors';
+import {inviteResponseBody} from '../../schemas/bedrock-vc-workflow.js';
+import {createValidateMiddleware as validate} from '@bedrock/validation';
+
+// creates invite request endpoints for each individual exchange
+export async function createRoutes({
+  app, exchangeRoute, getConfigMiddleware, getExchange
+} = {}) {
+  const inviteRequestRoute = `${exchangeRoute}/invite-request`;
+  const routes = {
+    inviteResponse: `${inviteRequestRoute}/response`
+  };
+
+  // receives an invite response
+  app.options(routes.inviteResponse, cors());
+  app.post(
+    routes.inviteResponse,
+    cors(),
+    validate({bodySchema: inviteResponseBody()}),
+    getConfigMiddleware,
+    getExchange,
+    asyncHandler(_handleInviteResponse));
+}
+
+async function _handleInviteResponse(req, res) {
+  const result = await inviteRequest.processInviteResponse({req});
+  res.json(result);
+}

package/lib/inviteRequest/inviteRequest.js

@@ -0,0 +1,116 @@
+/*!
+ * Copyright (c) 2025 Digital Bazaar, Inc. All rights reserved.
+ */
+import * as bedrock from '@bedrock/core';
+import * as exchanges from '../exchanges.js';
+import {emitExchangeUpdated, evaluateExchangeStep} from '../helpers.js';
+import {logger} from '../logger.js';
+
+const {util: {BedrockError}} = bedrock;
+
+export async function processInviteResponse({req}) {
+  const {config: workflow} = req.serviceObject;
+  const exchangeRecord = await req.getExchange();
+  let {meta: {updated: lastUpdated}} = exchangeRecord;
+  const {exchange} = exchangeRecord;
+  let step;
+
+  try {
+    // exchange step required for `inviteRequest`
+    const currentStep = exchange.step;
+    if(!currentStep) {
+      _throwUnsupportedProtocol();
+    }
+
+    step = await evaluateExchangeStep({workflow, exchange});
+
+    // step must have `inviteRequest` to perform protocol
+    if(!step.inviteRequest) {
+      _throwUnsupportedProtocol();
+    }
+
+    // exchange must still be pending
+    if(exchange.state !== 'pending') {
+      throw new BedrockError(
+        'This exchange is already in progress.', {
+          name: 'NotAllowedError',
+          details: {httpStatusCode: 403, public: true}
+        });
+    }
+
+    // `inviteResponse` validated via HTTP body JSON schema already
+    const {body: inviteResponse} = req;
+
+    // store invite response in variables associated with current step
+    if(!exchange.variables.results) {
+      exchange.variables.results = {};
+    }
+    const stepResult = {
+      inviteRequest: {inviteResponse}
+    };
+    const prevState = exchange.state;
+    exchange.variables.results[currentStep] = stepResult;
+    try {
+      // mark exchange complete
+      exchange.state = 'complete';
+      exchange.sequence++;
+      await exchanges.complete({workflowId: workflow.id, exchange});
+      emitExchangeUpdated({workflow, exchange, step});
+      lastUpdated = Date.now();
+    } catch(e) {
+      // revert exchange changes as it couldn't be written
+      exchange.sequence--;
+      exchange.state = prevState;
+      delete exchange.variables.results[currentStep];
+      throw e;
+    }
+
+    const result = {};
+    if(inviteResponse.referenceId !== undefined) {
+      result.referenceId = inviteResponse.referenceId;
+    }
+    return result;
+  } catch(e) {
+    if(e.name === 'InvalidStateError') {
+      throw e;
+    }
+    // write last error if exchange hasn't been frequently updated
+    const {id: workflowId} = workflow;
+    const copy = {...exchange};
+    copy.sequence++;
+    copy.lastError = e;
+    exchanges.setLastError({workflowId, exchange: copy, lastUpdated})
+      .catch(error => logger.error(
+        'Could not set last exchange error: ' + error.message, {error}));
+    emitExchangeUpdated({workflow, exchange, step});
+    throw e;
+  }
+}
+
+export function getInviteRequestProtocols({workflow, exchange, step}) {
+  // no invite protocols supported
+  if(!supportsInviteRequest({workflow, exchange, step})) {
+    return {};
+  }
+
+  const exchangeId = `${workflow.id}/exchanges/${exchange.id}`;
+  return {inviteRequest: `${exchangeId}/invite-request/response`};
+}
+
+export async function initExchange({workflow, exchange, initialStep} = {}) {
+  if(!supportsInviteRequest({workflow, exchange, step: initialStep})) {
+    return;
+  }
+  // no special validation rules at this time
+}
+
+export function supportsInviteRequest({step} = {}) {
+  return !!step?.inviteRequest;
+}
+
+function _throwUnsupportedProtocol() {
+  throw new BedrockError('Invite request is not supported by this exchange.', {
+    name: 'NotSupportedError',
+    details: {httpStatusCode: 400, public: true}
+  });
+}

package/lib/oid4/authorizationRequest.js

@@ -17,7 +17,10 @@ export async function create({
   clientProfile, clientProfileId,
   verifiablePresentationRequest
 }) {
-  const authorizationRequest = oid4vp.fromVpr({verifiablePresentationRequest});
+  const authorizationRequest = verifiablePresentationRequest ?
+    oid4vp.fromVpr({verifiablePresentationRequest}) :
+    // default authz request
+    {response_type: 'vp_token'};
 
   // get params from step OID4VP client profile to apply to the AR
   const {

package/lib/vcapi.js

@@ -14,6 +14,7 @@ import {issue} from './issue.js';
 import {logger} from './logger.js';
 
 // supported protocols
+import * as inviteRequest from './inviteRequest/inviteRequest.js';
 import * as oid4vci from './oid4/oid4vci.js';
 import * as oid4vp from './oid4/oid4vp.js';
 
@@ -77,6 +78,7 @@ export async function createExchange({workflow, exchange}) {
   }
 
   // run protocol-specific initialization code
+  await inviteRequest.initExchange({workflow, exchange, initialStep});
   await oid4vci.initExchange({workflow, exchange, initialStep});
   await oid4vp.initExchange({workflow, exchange, initialStep});
 
@@ -137,6 +139,15 @@ export async function processExchange({req, res, workflow, exchangeRecord}) {
         workflow, exchange, stepName: currentStep
       });
 
+      // if step does not support VCAPI, throw
+      if(!_supportsVcApi({workflow, step})) {
+        throw new BedrockError(
+          'VC API protocol not supported by this exchange.', {
+            name: 'NotSupportedError',
+            details: {httpStatusCode: 400, public: true}
+          });
+      }
+
       // if next step is the same as the current step, throw an error
       if(step.nextStep === currentStep) {
         throw new BedrockError('Cyclical step detected.', {
@@ -376,7 +387,21 @@ async function _createProtocols({workflow, exchange, step}) {
   // dynamically construct and return `protocols` object...
   const exchangeId = `${workflow.id}/exchanges/${exchange.id}`;
 
-  // get OID4 protocols...
+  // VC API protocols...
+  let vcApiProtocols;
+  if(_supportsVcApi({workflow, step})) {
+    vcApiProtocols = {vcapi: exchangeId};
+  }
+
+  // invite request protocols
+  let inviteRequestProtocols;
+  if(inviteRequest.supportsInviteRequest({step})) {
+    inviteRequestProtocols = inviteRequest.getInviteRequestProtocols({
+      workflow, exchange, step
+    });
+  }
+
+  // OID4* protocols...
   let oid4vciProtocols;
   let oid4vpProtocols;
   if(oid4vci.supportsOID4VCI({exchange})) {
@@ -393,9 +418,15 @@ async function _createProtocols({workflow, exchange, step}) {
 
   // return merged protocols
   return {
+    ...inviteRequestProtocols,
     ...oid4vciProtocols,
     ...oid4vpProtocols,
-    // always add VC API protocol
-    vcapi: exchangeId
+    ...vcApiProtocols
   };
 }
+
+function _supportsVcApi({workflow, step}) {
+  return step?.verifiablePresentationRequest ||
+    step?.issueRequests?.length > 0 ||
+    workflow?.credentialTemplates?.length > 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrock/vc-delivery",
-  "version": "7.5.0",
+  "version": "7.7.0",
   "type": "module",
   "description": "Bedrock Verifiable Credential Delivery",
   "main": "./lib/index.js",

package/schemas/bedrock-vc-workflow.js

@@ -395,6 +395,26 @@ const issueRequestParameters = {
   }
 };
 
+export function inviteResponseBody() {
+  return {
+    title: 'Invite Response',
+    type: 'object',
+    additionalProperties: false,
+    required: ['url', 'purpose'],
+    properties: {
+      url: {
+        type: 'string'
+      },
+      purpose: {
+        type: 'string'
+      },
+      referenceId: {
+        type: 'string'
+      }
+    }
+  };
+}
+
 const oid4vpClientProfile = {
   title: 'OID4VP Client Profile',
   type: 'object',