udate response with id field and add match to query

0xPolygonID · Dec 16, 2024 · 5e16710 · 5e16710
1 parent cda7ec7
commit 5e16710
Show file tree

Hide file tree

Showing 3 changed files with 255 additions and 63 deletions.
diff --git a/src/iden3comm/handlers/discovery-protocol.ts b/src/iden3comm/handlers/discovery-protocol.ts
@@ -1,12 +1,13 @@
 import { PROTOCOL_MESSAGE_TYPE } from '../constants';
 
-import { BasicMessage, IPackageManager } from '../types';
+import { BasicMessage, IPackageManager, ProtocolMessage } from '../types';
 
 import * as uuid from 'uuid';
 import {
   DiscoverFeatureDiscloseMessage,
   DiscoverFeatureDisclosure,
   DiscoverFeatureQueriesMessage,
+  DiscoverFeatureQuery,
   DiscoverFeatureQueryType,
   DiscoveryProtocolFeatureType
 } from '../types/protocol/discovery-protocol';
@@ -17,6 +18,7 @@ import {
 } from './message-handler';
 import { getUnixTimestamp } from '@iden3/js-iden3-core';
 import { verifyExpiresTime } from './common';
+import def from 'ajv/dist/vocabularies/discriminator';
 
 /**
  * @beta
@@ -26,6 +28,7 @@ import { verifyExpiresTime } from './common';
  */
 export interface DiscoveryProtocolOptions {
   packageManager: IPackageManager;
+  supportedProtocols?: Array<ProtocolMessage>;
 }
 
 /**
@@ -46,27 +49,21 @@ export type DiscoveryProtocolHandlerOptions = BasicHandlerOptions & {
  * @param opts - discovery-feature query options
  * @returns `DiscoverFeatureQueriesMessage`
  */
-export function createDiscoveryFeatureQueryMessage(opts?: {
-  featureTypes?: DiscoveryProtocolFeatureType[];
-  from?: string;
-  to?: string;
-  expires_time?: number;
-}): DiscoverFeatureQueriesMessage {
+export function createDiscoveryFeatureQueryMessage(
+  queries: DiscoverFeatureQuery[],
+  opts?: {
+    from?: string;
+    to?: string;
+    expires_time?: number;
+  }
+): DiscoverFeatureQueriesMessage {
   const uuidv4 = uuid.v4();
   return {
     id: uuidv4,
     thid: uuidv4,
     type: PROTOCOL_MESSAGE_TYPE.DISCOVERY_PROTOCOL_QUERIES_MESSAGE_TYPE,
     body: {
-      queries: opts?.featureTypes?.length
-        ? opts.featureTypes.map((featureType) => ({
-            [DiscoverFeatureQueryType.FeatureType]: featureType
-          }))
-        : [
-            {
-              [DiscoverFeatureQueryType.FeatureType]: DiscoveryProtocolFeatureType.Accept
-            }
-          ]
+      queries
     },
     from: opts?.from,
     to: opts?.to,
@@ -173,24 +170,11 @@ export class DiscoveryProtocolHandler
       verifyExpiresTime(message);
     }
 
-    if (message.body.queries.length !== 1) {
-      throw new Error('Invalid number of queries. Only one query is supported');
+    const disclosures: DiscoverFeatureDisclosure[] = [];
+    for (const query of message.body.queries) {
+      disclosures.push(...this.handleQuery(query));
     }
 
-    if (
-      message.body.queries[0][DiscoverFeatureQueryType.FeatureType] !==
-      DiscoveryProtocolFeatureType.Accept
-    ) {
-      throw new Error('Invalid feature-type. Only "accept" is supported');
-    }
-
-    const disclosures = [
-      {
-        [DiscoverFeatureQueryType.FeatureType]: DiscoveryProtocolFeatureType.Accept,
-        accept: this._options.packageManager.getSupportedProfiles()
-      }
-    ];
-
     return Promise.resolve(
       createDiscoveryFeatureDiscloseMessage(disclosures, {
         to: message.from,
@@ -201,4 +185,52 @@ export class DiscoveryProtocolHandler
       })
     );
   }
+
+  private handleQuery(query: DiscoverFeatureQuery): DiscoverFeatureDisclosure[] {
+    let result: DiscoverFeatureDisclosure[] = [];
+    switch (query[DiscoverFeatureQueryType.FeatureType]) {
+      case DiscoveryProtocolFeatureType.Accept:
+        result = this.handleAcceptQuery();
+        break;
+      case DiscoveryProtocolFeatureType.Protocol:
+        result = this.handleProtocolQuery();
+        break;
+    }
+
+    return this.handleMatch(result, query.match);
+  }
+
+  private handleAcceptQuery(): DiscoverFeatureDisclosure[] {
+    const acceptProfiles = this._options.packageManager.getSupportedProfiles();
+    return acceptProfiles.map((profile) => ({
+      [DiscoverFeatureQueryType.FeatureType]: DiscoveryProtocolFeatureType.Accept,
+      id: profile
+    }));
+  }
+
+  private handleProtocolQuery(): DiscoverFeatureDisclosure[] {
+    return (
+      this._options.supportedProtocols?.map((protocol) => ({
+        [DiscoverFeatureQueryType.FeatureType]: DiscoveryProtocolFeatureType.Protocol,
+        id: protocol
+      })) ?? []
+    );
+  }
+
+  private handleMatch(
+    disclosures: DiscoverFeatureDisclosure[],
+    match?: string
+  ): DiscoverFeatureDisclosure[] {
+    if (!match || match === '*') {
+      return disclosures;
+    }
+    const regExp = this.wildcardToRegExp(match);
+    return disclosures.filter((disclosure) => regExp.test(disclosure.id));
+  }
+
+  private wildcardToRegExp(match: string): RegExp {
+    // Escape special regex characters, then replace `*` with `.*`
+    const regexPattern = match.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
+    return new RegExp(`^${regexPattern}$`);
+  }
 }
diff --git a/src/iden3comm/types/protocol/discovery-protocol.ts b/src/iden3comm/types/protocol/discovery-protocol.ts
@@ -8,7 +8,10 @@ export enum DiscoverFeatureQueryType {
 
 /** @beta DiscoveryProtocolFeatureType is enum for supported feature-types */
 export enum DiscoveryProtocolFeatureType {
-  Accept = 'accept'
+  Accept = 'accept',
+  Protocol = 'protocol',
+  GoalCode = 'goal-code',
+  Header = 'header'
 }
 
 /** @beta DiscoverFeatureQueriesMessage is struct the represents discover feature queries message */
@@ -19,9 +22,13 @@ export type DiscoverFeatureQueriesMessage = BasicMessage & {
 
 /** @beta DiscoverFeatureQueriesBody is struct the represents discover feature queries body */
 export type DiscoverFeatureQueriesBody = {
-  queries: {
-    [DiscoverFeatureQueryType.FeatureType]: DiscoveryProtocolFeatureType;
-  }[];
+  queries: DiscoverFeatureQuery[];
+};
+
+/** @beta DiscoverFeatureQuery is struct the represents discover feature query */
+export type DiscoverFeatureQuery = {
+  [DiscoverFeatureQueryType.FeatureType]: DiscoveryProtocolFeatureType;
+  match?: string;
 };
 
 /** @beta DiscoverFeatureDiscloseMessage is struct the represents discover feature disclose message */
@@ -38,5 +45,5 @@ export type DiscoverFeatureDiscloseBody = {
 /** @beta DiscoverFeatureDisclosure is struct the represents discover feature disclosure */
 export type DiscoverFeatureDisclosure = {
   [DiscoverFeatureQueryType.FeatureType]: DiscoveryProtocolFeatureType;
-  accept: Array<string>;
+  id: string;
 };