@aerostack/sdk-node 0.8.4 → 0.8.6

package/src/__tests__/sdk.test.ts

@@ -0,0 +1,412 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock the generated APIs and realtime
+vi.mock('../_generated/index.js', () => {
+  const createMockApi = () => ({});
+  class MockConfiguration {
+    basePath: string;
+    headers: Record<string, string>;
+    apiKey?: string;
+    constructor(opts: any = {}) {
+      this.basePath = opts.basePath || '';
+      this.headers = opts.headers || {};
+      this.apiKey = opts.apiKey;
+    }
+  }
+  return {
+    Configuration: MockConfiguration,
+    AuthenticationApi: vi.fn().mockImplementation(() => ({ auth: true })),
+    CacheApi: vi.fn().mockImplementation(() => ({
+      cacheGet: vi.fn().mockResolvedValue({ _exists: true, value: 'cached' }),
+      cacheSet: vi.fn().mockResolvedValue({}),
+      cacheDelete: vi.fn().mockResolvedValue({}),
+      cacheList: vi.fn().mockResolvedValue({ keys: [], cursor: null }),
+      cacheKeys: vi.fn().mockResolvedValue({ keys: ['k1', 'k2'] }),
+      cacheGetMany: vi.fn().mockResolvedValue({ results: [] }),
+      cacheSetMany: vi.fn().mockResolvedValue({}),
+      cacheDeleteMany: vi.fn().mockResolvedValue({}),
+      cacheFlush: vi.fn().mockResolvedValue({}),
+      cacheExpire: vi.fn().mockResolvedValue({}),
+      cacheIncrement: vi.fn().mockResolvedValue({ value: 5 }),
+    })),
+    DatabaseApi: vi.fn().mockImplementation(() => ({
+      dbQuery: vi.fn().mockResolvedValue({ results: [] }),
+    })),
+    QueueApi: vi.fn().mockImplementation(() => ({ queue: true })),
+    StorageApi: vi.fn().mockImplementation(() => ({ storage: true })),
+    AIApi: vi.fn().mockImplementation(() => ({ ai: true })),
+    ServicesApi: vi.fn().mockImplementation(() => ({ services: true })),
+    GatewayApi: vi.fn().mockImplementation(() => ({ gateway: true })),
+  };
+});
+
+vi.mock('../realtime.js', () => {
+  return {
+    NodeRealtimeClient: vi.fn().mockImplementation(() => ({
+      connect: vi.fn(),
+      disconnect: vi.fn(),
+      channel: vi.fn(),
+    })),
+  };
+});
+
+vi.mock('@aerostack/core', () => {
+  return {
+    AerostackClient: vi.fn().mockImplementation(() => ({
+      db: { query: vi.fn() },
+      cache: { get: vi.fn() },
+    })),
+  };
+});
+
+import { SDK, Aerostack, createClient } from '../sdk.js';
+
+describe('SDK', () => {
+  describe('constructor', () => {
+    it('should initialize with default options', () => {
+      const sdk = new SDK();
+      expect(sdk).toBeDefined();
+      expect(sdk.database).toBeDefined();
+      expect(sdk.auth).toBeDefined();
+      expect(sdk.cache).toBeDefined();
+      expect(sdk.queue).toBeDefined();
+      expect(sdk.storage).toBeDefined();
+      expect(sdk.ai).toBeDefined();
+      expect(sdk.services).toBeDefined();
+      expect(sdk.gateway).toBeDefined();
+      expect(sdk.realtime).toBeDefined();
+      expect(sdk.rpc).toBeDefined();
+    });
+
+    it('should accept apiKey option', () => {
+      const sdk = new SDK({ apiKey: 'my-key' });
+      expect(sdk).toBeDefined();
+    });
+
+    it('should accept apiKeyAuth alias', () => {
+      const sdk = new SDK({ apiKeyAuth: 'my-key' });
+      expect(sdk).toBeDefined();
+    });
+
+    it('should accept serverUrl option', () => {
+      const sdk = new SDK({ serverUrl: 'https://custom.com/v1' });
+      expect(sdk).toBeDefined();
+    });
+
+    it('should accept serverURL alias', () => {
+      const sdk = new SDK({ serverURL: 'https://custom.com/v1' });
+      expect(sdk).toBeDefined();
+    });
+
+    it('should accept projectId', () => {
+      const sdk = new SDK({ projectId: 'proj-1' });
+      expect(sdk).toBeDefined();
+    });
+
+    it('should accept maxReconnectAttempts', () => {
+      const sdk = new SDK({ maxReconnectAttempts: 5 });
+      expect(sdk).toBeDefined();
+    });
+  });
+
+  describe('CacheFacade', () => {
+    it('should get a cached value', async () => {
+      const sdk = new SDK({ apiKey: 'key' });
+      const result = await sdk.cache.get('test-key');
+      expect(result).toBe('cached');
+    });
+
+    it('should return null when key not found', async () => {
+      const sdk = new SDK({ apiKey: 'key' });
+      // Override the mock for this test
+      const cacheApi = (sdk.cache as any).api;
+      cacheApi.cacheGet.mockResolvedValueOnce({ _exists: false });
+      const result = await sdk.cache.get('missing');
+      expect(result).toBeNull();
+    });
+
+    it('should set a value', async () => {
+      const sdk = new SDK({ apiKey: 'key' });
+      await sdk.cache.set('key', 'value');
+      const cacheApi = (sdk.cache as any).api;
+      expect(cacheApi.cacheSet).toHaveBeenCalled();
+    });
+
+    it('should set a value with TTL', async () => {
+      const sdk = new SDK({ apiKey: 'key' });
+      await sdk.cache.set('key', 'value', 3600);
+      const cacheApi = (sdk.cache as any).api;
+      const call = cacheApi.cacheSet.mock.calls[0][0];
+      expect(call.cacheSetRequest.ttl).toBe(3600);
+    });
+
+    it('should delete a key', async () => {
+      const sdk = new SDK({ apiKey: 'key' });
+      await sdk.cache.delete('key');
+      const cacheApi = (sdk.cache as any).api;
+      expect(cacheApi.cacheDelete).toHaveBeenCalled();
+    });
+
+    it('should check if key exists', async () => {
+      const sdk = new SDK({ apiKey: 'key' });
+      const result = await sdk.cache.exists('key');
+      expect(result).toBe(true);
+    });
+
+    it('should list keys', async () => {
+      const sdk = new SDK({ apiKey: 'key' });
+      await sdk.cache.list('prefix:', 10, 'cursor');
+    });
+
+    it('should get all keys', async () => {
+      const sdk = new SDK({ apiKey: 'key' });
+      const keys = await sdk.cache.keys('prefix:');
+      expect(keys).toEqual(['k1', 'k2']);
+    });
+
+    it('should get many keys', async () => {
+      const sdk = new SDK({ apiKey: 'key' });
+      const result = await sdk.cache.getMany(['k1', 'k2']);
+      expect(result).toEqual([]);
+    });
+
+    it('should set many entries', async () => {
+      const sdk = new SDK({ apiKey: 'key' });
+      await sdk.cache.setMany([{ key: 'k1', value: 'v1' }]);
+    });
+
+    it('should delete many keys', async () => {
+      const sdk = new SDK({ apiKey: 'key' });
+      await sdk.cache.deleteMany(['k1', 'k2']);
+    });
+
+    it('should flush cache', async () => {
+      const sdk = new SDK({ apiKey: 'key' });
+      await sdk.cache.flush('prefix:');
+    });
+
+    it('should expire a key', async () => {
+      const sdk = new SDK({ apiKey: 'key' });
+      await sdk.cache.expire('key', 300);
+    });
+
+    it('should increment a counter', async () => {
+      const sdk = new SDK({ apiKey: 'key' });
+      const result = await sdk.cache.increment('counter', 1, 0, 3600);
+      expect(result).toBe(5);
+    });
+  });
+
+  describe('DatabaseFacade', () => {
+    it('should execute a query', async () => {
+      const sdk = new SDK({ apiKey: 'key' });
+      const result = await sdk.database.dbQuery({
+        dbQueryRequest: { sql: 'SELECT 1', params: [] },
+      });
+      expect(result).toEqual({ results: [] });
+    });
+
+    it('should accept requestBody alias', async () => {
+      const sdk = new SDK({ apiKey: 'key' });
+      await sdk.database.dbQuery({
+        requestBody: { sql: 'SELECT 1', params: [] },
+      });
+    });
+  });
+
+  describe('setApiKey', () => {
+    it('should update all service instances', () => {
+      const sdk = new SDK({ apiKey: 'old-key' });
+      sdk.setApiKey('new-key');
+      // After setApiKey, all services should be recreated
+      expect(sdk.database).toBeDefined();
+      expect(sdk.auth).toBeDefined();
+      expect(sdk.cache).toBeDefined();
+    });
+  });
+
+  describe('streamGateway', () => {
+    it('should make POST request to gateway endpoint', async () => {
+      const mockFetch = vi.fn().mockResolvedValue({
+        ok: true,
+        body: createMockStream('data: {"choices":[{"delta":{"content":"Hello"}}]}\n\ndata: [DONE]\n\n'),
+      });
+      vi.stubGlobal('fetch', mockFetch);
+
+      const sdk = new SDK({ apiKey: 'key', serverUrl: 'https://api.test.com/v1' });
+      const result = await sdk.streamGateway({
+        apiSlug: 'my-chatbot',
+        messages: [{ role: 'user', content: 'Hi' }],
+        consumerKey: 'ask_live_123',
+      });
+
+      expect(result.text).toBe('Hello');
+      expect(mockFetch).toHaveBeenCalledOnce();
+      const [url, opts] = mockFetch.mock.calls[0];
+      expect(url).toBe('https://api.test.com/api/gateway/my-chatbot/v1/chat/completions');
+      expect(opts.headers.Authorization).toBe('Bearer ask_live_123');
+    });
+
+    it('should use token when consumerKey not provided', async () => {
+      const mockFetch = vi.fn().mockResolvedValue({
+        ok: true,
+        body: createMockStream('data: [DONE]\n\n'),
+      });
+      vi.stubGlobal('fetch', mockFetch);
+
+      const sdk = new SDK({ serverUrl: 'https://api.test.com/v1' });
+      await sdk.streamGateway({
+        apiSlug: 'bot',
+        messages: [{ role: 'user', content: 'Hi' }],
+        token: 'jwt-token',
+      });
+
+      expect(mockFetch.mock.calls[0][1].headers.Authorization).toBe('Bearer jwt-token');
+    });
+
+    it('should prepend system prompt', async () => {
+      const mockFetch = vi.fn().mockResolvedValue({
+        ok: true,
+        body: createMockStream('data: [DONE]\n\n'),
+      });
+      vi.stubGlobal('fetch', mockFetch);
+
+      const sdk = new SDK({ serverUrl: 'https://api.test.com/v1' });
+      await sdk.streamGateway({
+        apiSlug: 'bot',
+        messages: [{ role: 'user', content: 'Hi' }],
+        systemPrompt: 'You are helpful',
+      });
+
+      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+      expect(body.messages[0]).toEqual({ role: 'system', content: 'You are helpful' });
+      expect(body.messages[1]).toEqual({ role: 'user', content: 'Hi' });
+    });
+
+    it('should call onToken callback', async () => {
+      const mockFetch = vi.fn().mockResolvedValue({
+        ok: true,
+        body: createMockStream('data: {"choices":[{"delta":{"content":"Hi"}}]}\n\ndata: {"choices":[{"delta":{"content":" there"}}]}\n\ndata: [DONE]\n\n'),
+      });
+      vi.stubGlobal('fetch', mockFetch);
+
+      const tokens: string[] = [];
+      const sdk = new SDK({ serverUrl: 'https://api.test.com/v1' });
+      await sdk.streamGateway({
+        apiSlug: 'bot',
+        messages: [{ role: 'user', content: 'Hi' }],
+        onToken: (delta: string) => tokens.push(delta),
+      });
+
+      expect(tokens).toEqual(['Hi', ' there']);
+    });
+
+    it('should call onDone callback', async () => {
+      const mockFetch = vi.fn().mockResolvedValue({
+        ok: true,
+        body: createMockStream('data: {"choices":[{"delta":{"content":"Hi"}}],"usage":{"total_tokens":10}}\n\ndata: [DONE]\n\n'),
+      });
+      vi.stubGlobal('fetch', mockFetch);
+
+      let doneResult: any;
+      const sdk = new SDK({ serverUrl: 'https://api.test.com/v1' });
+      await sdk.streamGateway({
+        apiSlug: 'bot',
+        messages: [{ role: 'user', content: 'Hi' }],
+        onDone: (result: any) => { doneResult = result; },
+      });
+
+      expect(doneResult.tokensUsed).toBe(10);
+    });
+
+    it('should throw on non-OK response', async () => {
+      const mockFetch = vi.fn().mockResolvedValue({
+        ok: false,
+        status: 500,
+        json: vi.fn().mockResolvedValue({ error: 'Server error' }),
+      });
+      vi.stubGlobal('fetch', mockFetch);
+
+      const sdk = new SDK({ serverUrl: 'https://api.test.com/v1' });
+      await expect(sdk.streamGateway({
+        apiSlug: 'bot',
+        messages: [{ role: 'user', content: 'Hi' }],
+      })).rejects.toThrow('Server error');
+    });
+
+    it('should call onError on failure', async () => {
+      const mockFetch = vi.fn().mockResolvedValue({
+        ok: false,
+        status: 500,
+        json: vi.fn().mockResolvedValue({ error: 'boom' }),
+      });
+      vi.stubGlobal('fetch', mockFetch);
+
+      let capturedError: Error | null = null;
+      const sdk = new SDK({ serverUrl: 'https://api.test.com/v1' });
+
+      try {
+        await sdk.streamGateway({
+          apiSlug: 'bot',
+          messages: [{ role: 'user', content: 'Hi' }],
+          onError: (err: Error) => { capturedError = err; },
+        });
+      } catch {
+        // Expected
+      }
+
+      expect(capturedError).not.toBeNull();
+      expect(capturedError!.message).toBe('boom');
+    });
+
+    it('should handle abort gracefully', async () => {
+      const abortController = new AbortController();
+      const mockFetch = vi.fn().mockRejectedValue(
+        Object.assign(new Error('Aborted'), { name: 'AbortError' })
+      );
+      vi.stubGlobal('fetch', mockFetch);
+
+      const sdk = new SDK({ serverUrl: 'https://api.test.com/v1' });
+      const result = await sdk.streamGateway({
+        apiSlug: 'bot',
+        messages: [{ role: 'user', content: 'Hi' }],
+        signal: abortController.signal,
+      });
+
+      expect(result.text).toBe('');
+      expect(result.tokensUsed).toBe(0);
+    });
+  });
+
+  describe('Aerostack alias', () => {
+    it('should be the same as SDK', () => {
+      expect(Aerostack).toBe(SDK);
+    });
+  });
+
+  describe('createClient', () => {
+    it('should return an SDK instance', () => {
+      const client = createClient({ apiKey: 'key' });
+      expect(client).toBeInstanceOf(SDK);
+    });
+  });
+});
+
+// Helper to create a mock ReadableStream
+function createMockStream(text: string) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(text);
+  let read = false;
+  return {
+    getReader: () => ({
+      read: async () => {
+        if (!read) {
+          read = true;
+          return { done: false, value: data };
+        }
+        return { done: true, value: undefined };
+      },
+      cancel: vi.fn(),
+    }),
+  };
+}

package/src/realtime.ts

@@ -99,6 +99,7 @@ export class RealtimeSubscription<T = any> {
         });
         this._isSubscribed = false;
         this.callbacks.clear();
+        this.client._removeSubscription(this.topic);
     }
 
     get isSubscribed() { return this._isSubscribed; }
@@ -227,8 +228,6 @@ export class NodeRealtimeClient {
     private async _doConnect(): Promise<void> {
         this._setStatus('connecting');
         const url = new URL(this.wsUrl);
-        if (this.apiKey) url.searchParams.set('apiKey', this.apiKey);
-        if (this.token) url.searchParams.set('token', this.token);
         if (this.projectId) url.searchParams.set('projectId', this.projectId);
 
         return new Promise(async (resolve, reject) => {
@@ -245,7 +244,14 @@ export class NodeRealtimeClient {
                     }
                 }
 
-                this.ws = new WsClass(url.toString());
+                // SECURITY: Pass credentials via Sec-WebSocket-Protocol header — never as URL query params
+                // (URL params appear in CDN logs, browser history, and Referer headers).
+                const protocols: string[] = [];
+                if (this.apiKey) protocols.push(`aerostack-key.${this.apiKey}`);
+                if (this.token) protocols.push(`aerostack-token.${this.token}`);
+                if (protocols.length > 0) protocols.push('aerostack-v1');
+                const protocolsArg = protocols.length > 0 ? protocols : undefined;
+                this.ws = protocolsArg ? new WsClass(url.toString(), protocolsArg) : new WsClass(url.toString());
 
                 this.ws!.onopen = () => {
                     this._setStatus('connected');
@@ -302,6 +308,9 @@ export class NodeRealtimeClient {
     }
 
     channel<T = any>(topic: string, options: RealtimeSubscriptionOptions = {}): RealtimeSubscription<T> {
+        if (!this.projectId) {
+            throw new Error('projectId is required for channel subscriptions. Set it in NodeRealtimeOptions.');
+        }
         let fullTopic: string;
         if (!topic.includes('/')) {
             fullTopic = `table/${topic}/${this.projectId}`;
@@ -328,6 +337,11 @@ export class NodeRealtimeClient {
         return Math.random().toString(36).slice(2) + Date.now().toString(36);
     }
 
+    /** @internal — Remove a subscription from the map (called on unsubscribe) */
+    _removeSubscription(topic: string): void {
+        this.subscriptions.delete(topic);
+    }
+
     /** @internal */
     _send(data: any): void {
         if (this.ws && this._status === 'connected') {