Fixing identities claim to be in-line with identities discover and identities trust, by introducing a new parser parseGestaltIdentityId

package.json

@@ -109,7 +109,7 @@
     "@matrixai/errors": "^1.2.0",
     "@matrixai/logger": "^3.1.0",
     "commander": "^8.3.0",
-    "polykey": "^1.2.1-alpha.17",
+    "polykey": "^1.2.1-alpha.19",
     "threads": "^1.6.5",
     "@swc/core": "1.3.82",
     "@swc/jest": "^0.2.29",

src/identities/CommandClaim.ts

@@ -1,4 +1,5 @@
 import type PolykeyClient from 'polykey/dist/PolykeyClient';
+import type { ProviderIdentityId } from 'polykey/dist/ids';
 import CommandPolykey from '../CommandPolykey';
 import * as binUtils from '../utils';
 import * as binOptions from '../utils/options';
@@ -11,71 +12,69 @@ class CommandClaim extends CommandPolykey {
     this.name('claim');
     this.description('Claim a Digital Identity for this Keynode');
     this.argument(
-      '<providerId>',
+      '<providerIdentityId>',
       'Name of the digital identity provider',
-      binParsers.parseProviderId,
-    );
-    this.argument(
-      '<identityId>',
-      'Digital identity to claim',
-      binParsers.parseIdentityId,
+      binParsers.parseGestaltIdentityId,
     );
     this.addOption(binOptions.nodeId);
     this.addOption(binOptions.clientHost);
     this.addOption(binOptions.clientPort);
-    this.action(async (providerId, identityId, options) => {
-      const { default: PolykeyClient } = await import(
-        'polykey/dist/PolykeyClient'
-      );
-      const clientOptions = await binProcessors.processClientOptions(
-        options.nodePath,
-        options.nodeId,
-        options.clientHost,
-        options.clientPort,
-        this.fs,
-        this.logger.getChild(binProcessors.processClientOptions.name),
-      );
-      const auth = await binProcessors.processAuthentication(
-        options.passwordFile,
-        this.fs,
-      );
-      let pkClient: PolykeyClient;
-      this.exitHandlers.handlers.push(async () => {
-        if (pkClient != null) await pkClient.stop();
-      });
-      try {
-        pkClient = await PolykeyClient.createPolykeyClient({
-          nodeId: clientOptions.nodeId,
-          host: clientOptions.clientHost,
-          port: clientOptions.clientPort,
-          options: {
-            nodePath: options.nodePath,
-          },
-          logger: this.logger.getChild(PolykeyClient.name),
+    this.action(
+      async (providerIdentityId: ['identity', ProviderIdentityId], options) => {
+        const { default: PolykeyClient } = await import(
+          'polykey/dist/PolykeyClient'
+        );
+        const clientOptions = await binProcessors.processClientOptions(
+          options.nodePath,
+          options.nodeId,
+          options.clientHost,
+          options.clientPort,
+          this.fs,
+          this.logger.getChild(binProcessors.processClientOptions.name),
+        );
+        const auth = await binProcessors.processAuthentication(
+          options.passwordFile,
+          this.fs,
+        );
+        let pkClient: PolykeyClient;
+        this.exitHandlers.handlers.push(async () => {
+          if (pkClient != null) await pkClient.stop();
         });
-        const claimMessage = await binUtils.retryAuthentication(
-          (auth) =>
-            pkClient.rpcClient.methods.identitiesClaim({
-              metadata: auth,
-              providerId: providerId,
-              identityId: identityId,
+        try {
+          pkClient = await PolykeyClient.createPolykeyClient({
+            nodeId: clientOptions.nodeId,
+            host: clientOptions.clientHost,
+            port: clientOptions.clientPort,
+            options: {
+              nodePath: options.nodePath,
+            },
+            logger: this.logger.getChild(PolykeyClient.name),
+          });
+          const [providerId, identityId] = providerIdentityId[1];
+          const claimMessage = await binUtils.retryAuthentication(
+            (auth) =>
+              pkClient.rpcClient.methods.identitiesClaim({
+                metadata: auth,
+                providerId: providerId,
+                identityId: identityId,
+              }),
+            auth,
+          );
+          const output = [`Claim Id: ${claimMessage.claimId}`];
+          if (claimMessage.url) {
+            output.push(`Url: ${claimMessage.url}`);
+          }
+          process.stdout.write(
+            binUtils.outputFormatter({
+              type: options.format === 'json' ? 'json' : 'list',
+              data: output,
             }),
-          auth,
-        );
-        const output = [`Claim Id: ${claimMessage.claimId}`];
-        if (claimMessage.url) {
-          output.push(`Url: ${claimMessage.url}`);
+          );
+        } finally {
+          if (pkClient! != null) await pkClient.stop();
         }
-        process.stdout.write(
-          binUtils.outputFormatter({
-            type: options.format === 'json' ? 'json' : 'list',
-            data: output,
-          }),
-        );
-      } finally {
-        if (pkClient! != null) await pkClient.stop();
-      }
-    });
+      },
+    );
   }
 }
 

src/utils/parsers.ts

@@ -78,36 +78,52 @@ function parseSecretPath(secretPath: string): [string, string, string?] {
 const parseInteger: (data: string) => number = validateParserToArgParser(
   validationUtils.parseInteger,
 );
+
 const parseNumber: (data: string) => number = validateParserToArgParser(
   validationUtils.parseNumber,
 );
+
 const parseNodeId: (data: string) => ids.NodeId = validateParserToArgParser(
   ids.parseNodeId,
 );
+
 const parseGestaltId: (data: string) => ids.GestaltId =
   validateParserToArgParser(ids.parseGestaltId);
+
+const parseGestaltIdentityId: (data: string) => ids.GestaltId =
+  validateParserToArgParser(ids.parseGestaltIdentityId);
+
 const parseProviderId: (data: string) => ids.ProviderId =
   validateParserToArgParser(ids.parseProviderId);
+
 const parseIdentityId: (data: string) => ids.IdentityId =
   validateParserToArgParser(ids.parseIdentityId);
+
 const parseProviderIdList: (data: string) => ids.ProviderId[] =
   validateParserToArgListParser(ids.parseProviderId);
+
 const parseGestaltAction: (data: string) => 'notify' | 'scan' | 'claim' =
   validateParserToArgParser(gestaltsUtils.parseGestaltAction);
+
 const parseHost: (data: string) => Host = validateParserToArgParser(
   networkUtils.parseHost,
 );
+
 const parseHostname: (data: string) => Hostname = validateParserToArgParser(
   networkUtils.parseHostname,
 );
+
 const parseHostOrHostname: (data: string) => Host | Hostname =
   validateParserToArgParser(networkUtils.parseHostOrHostname);
+
 const parsePort: (data: string) => Port = validateParserToArgParser(
   networkUtils.parsePort,
 );
+
 const parseNetwork: (data: string) => SeedNodes = validateParserToArgParser(
   nodesUtils.parseNetwork,
 );
+
 const parseSeedNodes: (data: string) => [SeedNodes, boolean] =
   validateParserToArgParser(nodesUtils.parseSeedNodes);
 
@@ -120,6 +136,7 @@ export {
   parseNumber,
   parseNodeId,
   parseGestaltId,
+  parseGestaltIdentityId,
   parseGestaltAction,
   parseHost,
   parseHostname,

tests/identities/claim.test.ts

@@ -81,8 +81,7 @@ describe('claim', () => {
         [
           'identities',
           'claim',
-          testToken.providerId,
-          testToken.identityId,
+          `${testToken.providerId}:${testToken.identityId}`,
           '--format',
           'json',
         ],
@@ -110,7 +109,11 @@ describe('claim', () => {
     'cannot claim unauthenticated identities',
     async () => {
       const { exitCode } = await testUtils.pkStdio(
-        ['identities', 'claim', testToken.providerId, testToken.identityId],
+        [
+          'identities',
+          'claim',
+          `${testToken.providerId}:${testToken.identityId}`,
+        ],
         {
           env: {
             PK_NODE_PATH: nodePath,
@@ -128,7 +131,7 @@ describe('claim', () => {
       let exitCode;
       // Invalid provider
       ({ exitCode } = await testUtils.pkStdio(
-        ['identities', 'claim', '', testToken.identityId],
+        ['identities', 'claim', `:${testToken.identityId}`],
         {
           env: {
             PK_NODE_PATH: nodePath,
@@ -140,7 +143,7 @@ describe('claim', () => {
       expect(exitCode).toBe(sysexits.USAGE);
       // Invalid identity
       ({ exitCode } = await testUtils.pkStdio(
-        ['identities', 'claim', testToken.providerId, ''],
+        ['identities', 'claim', `${testToken.providerId}:`],
         {
           env: {
             PK_NODE_PATH: nodePath,