fix: added helper func to get storage client + tests (#14)

* fix: added helper func to get storage client + tests

* added jsdoc

Author: fforbeck

__tests__/clients/storage.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createStorageClient, StorageClientImpl, StorageClientInterface } from '../../src/clients/storage';
+import { createStorageClient, StorageClientInstanceImpl, StorageClientInterface } from '../../src/clients/storage';
 import * as Storage from '@web3-storage/w3up-client';
 import { StoreMemory } from '@web3-storage/w3up-client/stores/memory';
 import { defaultGatewayUrl } from '../../src/utils';
@@ -62,27 +62,31 @@ vi.mock('../../src/environments', () => ({
   })
 }));
 
+// Mock fetch for getContent tests
+global.fetch = vi.fn();
+
 // Clear mocks once before all tests
 beforeEach(() => {
   vi.clearAllMocks();
 });
 
 describe('StorageClientImpl', () => {
-  let storageClientImpl: StorageClientImpl;
+  let storageClientImpl: StorageClientInstanceImpl;
   let mockRuntime: any;
 
   beforeEach(() => {
     mockRuntime = {
       getParameter: vi.fn(),
     };
     console.log = vi.fn(); // Mock console.log to avoid cluttering test output
-    storageClientImpl = new StorageClientImpl(mockRuntime);
+    storageClientImpl = new StorageClientInstanceImpl(mockRuntime);
+    (global.fetch as any).mockReset();
   });
 
   it('should initialize correctly', async () => {
     await storageClientImpl.start();
 
-    expect(storageClientImpl.getStorageClient()).not.toBeNull();
+    expect(storageClientImpl.getStorage()).not.toBeNull();
     expect(elizaLogger.success).toHaveBeenCalledWith('✅ Storage client successfully started');
   });
 
@@ -106,12 +110,12 @@ describe('StorageClientImpl', () => {
   });
 
   it('should throw error if client is not initialized when getting storage client', () => {
-    expect(() => storageClientImpl.getStorageClient()).toThrow('Storage client not initialized');
+    expect(() => storageClientImpl.getStorage()).toThrow('Storage client not initialized');
   });
 
   it('should return the storage client when initialized', async () => {
     await storageClientImpl.start();
-    expect(storageClientImpl.getStorageClient()).not.toBeNull();
+    expect(storageClientImpl.getStorage()).not.toBeNull();
   });
 
   it('should throw error if client is not initialized when getting config', () => {
@@ -138,13 +142,48 @@ describe('StorageClientImpl', () => {
 
   it('should properly clean up resources when stopped', async () => {
     await storageClientImpl.start();
-    expect(storageClientImpl.getStorageClient()).not.toBeNull();
+    expect(storageClientImpl.getStorage()).not.toBeNull();
 
     await storageClientImpl.stop();
 
-    expect(() => storageClientImpl.getStorageClient()).toThrow('Storage client not initialized');
+    expect(() => storageClientImpl.getStorage()).toThrow('Storage client not initialized');
     expect(() => storageClientImpl.getConfig()).toThrow('Storage client not initialized');
   });
+
+  describe('getContent', () => {
+    it('should fetch content from the configured gateway URL', async () => {
+      await storageClientImpl.start();
+      const testCid = 'bafytest123';
+      const mockResponse = new Response('mock content');
+      (global.fetch as any).mockResolvedValueOnce(mockResponse);
+
+      const result = await storageClientImpl.getContent(testCid);
+
+      expect(global.fetch).toHaveBeenCalledWith('https://mock-gateway.link/ipfs/bafytest123');
+      expect(result).toBe(mockResponse);
+    });
+
+    it('should fetch content from the default gateway URL when not configured', async () => {
+      storageClientImpl.config = null; // No config set
+      const testCid = 'bafytest123';
+      const mockResponse = new Response('mock content');
+      (global.fetch as any).mockResolvedValueOnce(mockResponse);
+
+      const result = await storageClientImpl.getContent(testCid);
+
+      expect(global.fetch).toHaveBeenCalledWith(`${defaultGatewayUrl}/ipfs/bafytest123`);
+      expect(result).toBe(mockResponse);
+    });
+
+    it('should propagate fetch errors', async () => {
+      await storageClientImpl.start();
+      const testCid = 'bafytest123';
+      const mockError = new Error('Network error');
+      (global.fetch as any).mockRejectedValueOnce(mockError);
+
+      await expect(storageClientImpl.getContent(testCid)).rejects.toThrow('Network error');
+    });
+  });
 });
 
 describe('StorageClientInterface', () => {

__tests__/index.test.ts

@@ -1,9 +1,27 @@
-import { describe, it, expect } from 'vitest';
-import { storagePlugin } from '../src/index';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { storagePlugin, getStorageClient } from '../src/index';
 import { uploadAction, retrieveAction } from '../src/actions';
 import { StorageClientInterface } from '../src/clients/storage';
 import { storageClientEnvSchema } from '../src/environments';
 
+// Mock dependencies
+vi.mock('../src/clients/storage', () => {
+  const mockStorageClient = {
+    getStorage: vi.fn().mockReturnValue('mock-storage-client'),
+    stop: vi.fn()
+  };
+  
+  return {
+    StorageClientInterface: {
+      name: 'storage',
+      start: vi.fn().mockResolvedValue(mockStorageClient)
+    },
+    StorageClientInstanceImpl: class MockStorageClientImpl {
+      getStorage = vi.fn().mockReturnValue('mock-storage-client');
+    }
+  };
+});
+
 describe('storagePlugin', () => {
   it('should export the correct plugin structure', () => {
     expect(storagePlugin).toBeDefined();
@@ -35,4 +53,53 @@ describe('storagePlugin', () => {
     expect(defaultExport).toBeDefined();
     expect(defaultExport.name).toBe('storage');
   });
+});
+
+describe('getStorageClient', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return the storage client when plugin is found in runtime', async () => {
+    const mockRuntime = {
+      plugins: [
+        {
+          name: 'storage',
+          clients: [StorageClientInterface]
+        }
+      ]
+    };
+
+    const result = await getStorageClient(mockRuntime as any);
+
+    expect(result).toBeDefined();
+    expect(result).toHaveProperty('getStorage');
+    expect(StorageClientInterface.start).toHaveBeenCalledWith(mockRuntime);
+  });
+
+  it('should throw an error when plugin is not found in runtime', async () => {
+    const mockRuntime = {
+      plugins: [
+        {
+          name: 'different-plugin',
+          clients: []
+        }
+      ]
+    };
+
+    await expect(getStorageClient(mockRuntime as any)).rejects.toThrow('Storage client not found in runtime');
+  });
+
+  it('should throw an error when plugin has no clients', async () => {
+    const mockRuntime = {
+      plugins: [
+        {
+          name: 'storage',
+          clients: []
+        }
+      ]
+    };
+
+    await expect(getStorageClient(mockRuntime as any)).rejects.toThrow('Storage client not found in runtime');
+  });
 }); 

src/clients/storage.ts

@@ -5,9 +5,9 @@ import { Signer } from '@ucanto/principal/ed25519';
 import { StorageClientConfig, validateStorageClientConfig } from "../environments";
 import { defaultGatewayUrl, parseDelegation } from '../utils';
 
-export class StorageClientImpl {
+export class StorageClientInstanceImpl implements ClientInstance {
     private readonly runtime: IAgentRuntime;
-    private storageClient: Storage.Client | null = null;
+    private storage: Storage.Client | null = null;
     config: StorageClientConfig | null = null;
 
     constructor(runtime: IAgentRuntime) {
@@ -16,12 +16,12 @@ export class StorageClientImpl {
 
     async start(): Promise<void> {
         try {
-            if (this.storageClient) {
+            if (this.storage) {
                 elizaLogger.info("Storage client already initialized");
                 return;
             }
             this.config = await validateStorageClientConfig(this.runtime);
-            this.storageClient = await createStorageClient(this.config);
+            this.storage = await createStorageClient(this.config);
             elizaLogger.success(`✅ Storage client successfully started`);
         } catch (error) {
             elizaLogger.error(`❌ Storage client failed to start: ${error}`);
@@ -30,15 +30,15 @@ export class StorageClientImpl {
     }
 
     async stop(runtime?: IAgentRuntime): Promise<void> {
-        this.storageClient = null;
+        this.storage = null;
         this.config = null;
     }
 
-    getStorageClient() {
-        if (!this.storageClient) {
+    getStorage() {
+        if (!this.storage) {
             throw new Error("Storage client not initialized");
         }
-        return this.storageClient;
+        return this.storage;
     }
 
     getConfig() {
@@ -51,12 +51,16 @@ export class StorageClientImpl {
     getGatewayUrl(): string {
         return this.config?.GATEWAY_URL || defaultGatewayUrl;
     }
+
+    getContent(cid: string): Promise<Response> {
+        return fetch(`${this.getGatewayUrl()}/ipfs/${cid}`);
+    }
 }
 
 export const StorageClientInterface: Client = {
     name: 'storage',
     start: async (runtime: IAgentRuntime): Promise<ClientInstance> => {
-        const storageClient = new StorageClientImpl(runtime);
+        const storageClient = new StorageClientInstanceImpl(runtime);
         await storageClient.start();
         return storageClient;
     }

src/index.ts

@@ -1,10 +1,15 @@
-import type { Plugin } from "@elizaos/core";
+import type { ClientInstance, IAgentRuntime, Plugin } from "@elizaos/core";
 import { uploadAction, retrieveAction } from "./actions";
 import { storageClientEnvSchema } from "./environments.ts";
-import { StorageClientInterface } from "./clients/storage.ts";
+import { StorageClientInstanceImpl, StorageClientInterface } from "./clients/storage.ts";
+import * as Storage from '@web3-storage/w3up-client';
+export { StorageClientInterface, StorageClientInstanceImpl as StorageClientImpl } from "./clients/storage.ts";
+
+
+const PluginName = "storage";
 
 export const storagePlugin: Plugin = {
-    name: "storage",
+    name: PluginName,
     description: "Plugin to manage files in a decentralized storage network",
     config: storageClientEnvSchema,
     actions: [uploadAction, retrieveAction],
@@ -13,5 +18,27 @@ export const storagePlugin: Plugin = {
     evaluators: [],
     providers: [],
 };
+
+
+/**
+ * A helper function for Agent to get the storage client.
+ * It returns the first storage client from the runtime that is identified as plugin.name === storage.
+ * 
+ * @param runtime - The runtime to get the storage client from.
+ * @returns The storage client.
+ * @throws An error if no storage client is found.
+ */
+export const getStorageClient = async (runtime: IAgentRuntime): Promise<StorageClientInstanceImpl> => {
+    const storagePlugin = runtime.plugins.find((plugin) => plugin.name === PluginName);
+    if (storagePlugin && storagePlugin.clients && storagePlugin.clients.length > 0) {
+        const [storageStarter] = storagePlugin.clients;
+        if (storageStarter) {
+            const storageClient = await storageStarter.start(runtime);
+            return storageClient as StorageClientInstanceImpl;
+        }
+    }
+    throw new Error("Storage client not found in runtime");
+}
+
 export default storagePlugin;