fixup! feat(cardano-services-client): restore KoraLabsHandleProvider

Author: iccicci

.github/workflows/continuous-integration-unit-tests.yaml

@@ -42,5 +42,6 @@ jobs:
       - name: 🔬 Test
         run: |
           yarn test --forceExit
+          yarn test:handle
         env:
           NODE_OPTIONS: '--max_old_space_size=8192'

packages/cardano-services-client/src/HandleProvider/KoraLabsHandleProvider.ts

@@ -58,27 +58,31 @@ export class KoraLabsHandleProvider implements HandleProvider {
     this.policyId = policyId;
   }
 
-  async resolveHandles(args: ResolveHandlesArgs): Promise<Array<HandleResolution | null>> {
-    try {
-      const results = await Promise.all(
-        args.handles.map((handle) => this.axiosClient.get<IHandle>(`${paths.handles}/${handle}`))
-      );
-      return results.map(({ data: apiResponse }) => toHandleResolution({ apiResponse, policyId: this.policyId }));
-    } catch (error) {
-      if (axios.isAxiosError(error)) {
-        if (error.request) {
-          throw new ProviderError(ProviderFailure.ConnectionFailure, error, error.code);
-        }
+  resolveHandles({ handles }: ResolveHandlesArgs): Promise<Array<HandleResolution | null>> {
+    // eslint-disable-next-line unicorn/consistent-function-scoping
+    const resolveHandle = async (handle: string) => {
+      try {
+        const { data } = await this.axiosClient.get<IHandle>(`${paths.handles}/${handle}`);
+
+        return toHandleResolution({ apiResponse: data, policyId: this.policyId });
+      } catch (error) {
+        if (error instanceof ProviderError) throw error;
+        if (axios.isAxiosError(error)) {
+          if (error.response?.status === 404) return null;
+          if (error.request) throw new ProviderError(ProviderFailure.ConnectionFailure, error, error.code);
 
-        if (error.response?.status === 404) {
-          return [null];
+          throw new ProviderError(
+            ProviderFailure.Unhealthy,
+            error,
+            `Failed to resolve handles due to: ${error.message}`
+          );
         }
 
-        throw new ProviderError(ProviderFailure.Unhealthy, error, `Failed to resolve handles due to: ${error.message}`);
+        throw new ProviderError(ProviderFailure.Unknown, error, 'Failed to resolve handles');
       }
-      if (error instanceof ProviderError) throw error;
-      throw new ProviderError(ProviderFailure.Unknown, error, 'Failed to resolve handles');
-    }
+    };
+
+    return Promise.all(handles.map((handle) => resolveHandle(handle)));
   }
 
   async healthCheck(): Promise<HealthCheckResponse> {

packages/cardano-services-client/test/HandleProvider/KoraLabsHandleProvider.test.ts

@@ -34,7 +34,7 @@ describe('KoraLabsHandleProvider', () => {
   });
 
   describe('resolveHandles', () => {
-    test('HandlesProvider should resolve a single handle', async () => {
+    test('HandleProvider should resolve a single handle', async () => {
       axiosMock.onGet().replyOnce(200, getAliceHandleAPIResponse);
       const args = {
         handles: ['alice']
@@ -102,8 +102,9 @@ describe('KoraLabsHandleProvider', () => {
   describe('get policy ids', () => {
     test('HandleProvider should get handle policy ids', async () => {
       const policyIds = await provider.getPolicyIds();
-      await expect(policyIds.length).toEqual(1);
-      await expect(policyIds).toEqual([config.policyId]);
+
+      expect(policyIds.length).toEqual(1);
+      expect(policyIds).toEqual([config.policyId]);
     });
   });
 });

packages/e2e/jest.config.js

@@ -27,6 +27,7 @@ module.exports = {
   projects: [
     { ...project('blockfrost'), globalSetup: './test/blockfrost/setup.ts' },
     project('blockfrost-providers'),
+    project('handle'),
     project('local-network'),
     project('long-running'),
     project('ogmios'),

packages/e2e/package.json

@@ -24,6 +24,7 @@
     "test": "echo 'test' command not implemented yet",
     "test:blockfrost": "jest -c jest.config.js --forceExit --selectProjects blockfrost --runInBand --verbose",
     "test:utils": "jest -c jest.config.js --forceExit --selectProjects utils --verbose",
+    "test:handle": "jest -c jest.config.js --forceExit --selectProjects handle --runInBand --verbose",
     "test:long-running": "jest -c jest.config.js --forceExit --selectProjects long-running --runInBand --verbose",
     "test:local-network": "jest -c jest.config.js --forceExit --selectProjects local-network --runInBand --verbose",
     "test:projection": "jest -c jest.config.js --forceExit --selectProjects projection --runInBand --verbose",

packages/e2e/test/handle/KoraLabsHandleProvider.test.ts

@@ -0,0 +1,73 @@
+/* eslint-disable no-magic-numbers */
+/* eslint-disable camelcase */
+import { Cardano, HandleResolution } from '@cardano-sdk/core';
+import { KoraLabsHandleProvider } from '@cardano-sdk/cardano-services-client';
+
+const handlePolicyId = 'f0ff48bbb7bbe9d59a40f1ce90e9e9d0ff5002ec48f232b49ca0fb9a';
+
+const config = {
+  policyId: Cardano.PolicyId(handlePolicyId),
+  serverUrl: 'https://preprod.api.handle.me/'
+};
+
+const checkHandleResolution = (source: string, result: unknown) => {
+  expect(typeof result).toBe('object');
+
+  const { backgroundImage, cardanoAddress, handle, hasDatum, image, policyId, profilePic } = result as HandleResolution;
+
+  expect(['string', 'undefined']).toContain(typeof backgroundImage);
+  expect(typeof cardanoAddress).toBe('string');
+  expect(cardanoAddress.startsWith('addr_')).toBe(true);
+  expect(handle).toBe(source);
+  expect(typeof hasDatum).toBe('boolean');
+  expect(typeof image).toBe('string');
+  expect(policyId).toBe(handlePolicyId);
+  expect(['string', 'undefined']).toContain(typeof profilePic);
+};
+
+describe('KoraLabsHandleProvider', () => {
+  let provider: KoraLabsHandleProvider;
+
+  beforeAll(() => {
+    provider = new KoraLabsHandleProvider(config);
+  });
+
+  describe('resolveHandles', () => {
+    test('HandleProvider should resolve a single handle', async () => {
+      const [result] = await provider.resolveHandles({ handles: ['test_handle_1'] });
+
+      checkHandleResolution('test_handle_1', result);
+    });
+
+    test('HandleProvider should resolve multiple handles', async () => {
+      const [result2, result3] = await provider.resolveHandles({ handles: ['test_handle_2', 'test_handle_3'] });
+
+      checkHandleResolution('test_handle_2', result2);
+      checkHandleResolution('test_handle_3', result3);
+    });
+
+    test('HandleProvider should return null for for not found handle', async () => {
+      const [resultN, result1] = await provider.resolveHandles({ handles: ['does_not_exists', 'test_handle_1'] });
+
+      expect(resultN).toBe(null);
+      checkHandleResolution('test_handle_1', result1);
+    });
+  });
+
+  describe('health checks', () => {
+    test('HandleProvider should get ok health check', async () => {
+      const result = await provider.healthCheck();
+
+      expect(result.ok).toEqual(true);
+    });
+  });
+
+  describe('get policy ids', () => {
+    test('HandleProvider should get handle policy ids', async () => {
+      const policyIds = await provider.getPolicyIds();
+
+      expect(policyIds.length).toEqual(1);
+      expect(policyIds).toEqual([config.policyId]);
+    });
+  });
+});