@scalekit-sdk/node 2.1.9 → 2.2.0-beta.0

package/tests/connected-accounts.test.ts

@@ -0,0 +1,434 @@
+import ScalekitClient from '../src/scalekit';
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { TestOrganizationManager } from './utils/test-data';
+import {
+  CreateConnectedAccount,
+  UpdateConnectedAccount,
+  AuthorizationDetails,
+  OauthToken,
+} from '../src/pkg/grpc/scalekit/v1/connected_accounts/connected_accounts_pb';
+
+describe('Connected Accounts', () => {
+  let client: ScalekitClient;
+  let testOrg: string;
+  let testConnectedAccountId: string | null = null;
+  let testConnector: string | null = null;
+  let testIdentifier: string | null = null;
+
+  beforeEach(async () => {
+    // Use global client
+    client = global.client;
+    
+    // Create test organization for each test
+    testOrg = await TestOrganizationManager.createTestOrganization(client);
+    
+    // Reset test state
+    testConnectedAccountId = null;
+    testConnector = null;
+    testIdentifier = null;
+  });
+
+  afterEach(async () => {
+    // Clean up test connected account if created
+    if (testConnectedAccountId && testConnector && testIdentifier) {
+      try {
+        await client.connectedAccounts.deleteConnectedAccount({
+          connector: testConnector,
+          identifier: testIdentifier,
+          connectedAccountId: testConnectedAccountId,
+        });
+      } catch (error) {
+        // Account may already be deleted or not exist
+      }
+    }
+    
+    // Reset test state
+    testConnectedAccountId = null;
+    testConnector = null;
+    testIdentifier = null;
+    
+    // Clean up test organization
+    await TestOrganizationManager.cleanupTestOrganization(client, testOrg);
+  });
+
+  describe('listConnectedAccounts', () => {
+    it('should list connected accounts', async () => {
+      const response = await client.connectedAccounts.listConnectedAccounts();
+
+      expect(response).toBeDefined();
+      expect(response.connectedAccounts).toBeDefined();
+      expect(Array.isArray(response.connectedAccounts)).toBe(true);
+      expect(response.totalSize).toBeDefined();
+      expect(typeof response.totalSize).toBe('number');
+    });
+
+    it('should list connected accounts with organization filter', async () => {
+      const response = await client.connectedAccounts.listConnectedAccounts({
+        organizationId: testOrg,
+      });
+
+      expect(response).toBeDefined();
+      expect(response.connectedAccounts).toBeDefined();
+      expect(Array.isArray(response.connectedAccounts)).toBe(true);
+    });
+
+    it('should list connected accounts with connector filter', async () => {
+      const response = await client.connectedAccounts.listConnectedAccounts({
+        connector: 'notion',
+      });
+
+      expect(response).toBeDefined();
+      expect(response.connectedAccounts).toBeDefined();
+      expect(Array.isArray(response.connectedAccounts)).toBe(true);
+    });
+
+    it('should list connected accounts with provider filter', async () => {
+      const response = await client.connectedAccounts.listConnectedAccounts({
+        provider: 'google',
+      });
+
+      expect(response).toBeDefined();
+      expect(response.connectedAccounts).toBeDefined();
+      expect(Array.isArray(response.connectedAccounts)).toBe(true);
+    });
+
+    it('should list connected accounts with pagination', async () => {
+      const firstPage = await client.connectedAccounts.listConnectedAccounts({
+        pageSize: 10,
+      });
+
+      expect(firstPage).toBeDefined();
+      expect(firstPage.connectedAccounts).toBeDefined();
+      expect(firstPage.connectedAccounts.length).toBeLessThanOrEqual(10);
+
+      if (firstPage.nextPageToken) {
+        const secondPage = await client.connectedAccounts.listConnectedAccounts({
+          pageSize: 10,
+          pageToken: firstPage.nextPageToken,
+        });
+
+        expect(secondPage).toBeDefined();
+        expect(secondPage.connectedAccounts).toBeDefined();
+      }
+    });
+
+    it('should list connected accounts with query search', async () => {
+      const response = await client.connectedAccounts.listConnectedAccounts({
+        query: 'test',
+      });
+
+      expect(response).toBeDefined();
+      expect(response.connectedAccounts).toBeDefined();
+      expect(Array.isArray(response.connectedAccounts)).toBe(true);
+    });
+  });
+
+  describe('createConnectedAccount', () => {
+    it('should handle create connected account request', async () => {
+      const connector = 'test_connector';
+      const identifier = `test_${Date.now()}`;
+      
+      const oauthToken = new OauthToken({
+        accessToken: 'test_access_token',
+        refreshToken: 'test_refresh_token',
+        scopes: ['read', 'write'],
+      });
+
+      const authorizationDetails = new AuthorizationDetails({
+        details: {
+          case: 'oauthToken',
+          value: oauthToken,
+        },
+      });
+
+      const connectedAccount = new CreateConnectedAccount({
+        authorizationDetails,
+      });
+
+      try {
+        const response = await client.connectedAccounts.createConnectedAccount({
+          connector,
+          identifier,
+          connectedAccount,
+          organizationId: testOrg,
+        });
+
+        expect(response).toBeDefined();
+        expect(response.connectedAccount).toBeDefined();
+        expect(response.connectedAccount?.id).toBeDefined();
+        
+        if (response.connectedAccount?.id) {
+          testConnectedAccountId = response.connectedAccount.id;
+          testConnector = connector;
+          testIdentifier = identifier;
+        }
+      } catch (error: any) {
+        // Expected errors: connector not found, invalid credentials, etc.
+        expect(error).toBeDefined();
+        // Verify it's a proper error response, not a request structure issue
+        expect(error.message || error.toString()).toBeDefined();
+      }
+    });
+
+    it('should handle create connected account with user ID', async () => {
+      const connector = 'test_connector';
+      const identifier = `test_user_${Date.now()}`;
+      
+      const oauthToken = new OauthToken({
+        accessToken: 'test_access_token',
+        refreshToken: 'test_refresh_token',
+        scopes: ['read'],
+      });
+
+      const authorizationDetails = new AuthorizationDetails({
+        details: {
+          case: 'oauthToken',
+          value: oauthToken,
+        },
+      });
+
+      const connectedAccount = new CreateConnectedAccount({
+        authorizationDetails,
+      });
+
+      try {
+        const response = await client.connectedAccounts.createConnectedAccount({
+          connector,
+          identifier,
+          connectedAccount,
+          userId: 'usr_test123',
+        });
+
+        expect(response).toBeDefined();
+        if (response.connectedAccount?.id) {
+          testConnectedAccountId = response.connectedAccount.id;
+          testConnector = connector;
+          testIdentifier = identifier;
+        }
+      } catch (error: any) {
+        // Expected errors: connector not found, invalid credentials, etc.
+        expect(error).toBeDefined();
+      }
+    });
+  });
+
+  describe('updateConnectedAccount', () => {
+    it('should handle update connected account request', async () => {
+      const connector = 'test_connector';
+      const identifier = 'test_identifier';
+      
+      const oauthToken = new OauthToken({
+        accessToken: 'updated_access_token',
+        refreshToken: 'updated_refresh_token',
+        scopes: ['read', 'write', 'admin'],
+      });
+
+      const authorizationDetails = new AuthorizationDetails({
+        details: {
+          case: 'oauthToken',
+          value: oauthToken,
+        },
+      });
+
+      const connectedAccount = new UpdateConnectedAccount({
+        authorizationDetails,
+      });
+
+      try {
+        const response = await client.connectedAccounts.updateConnectedAccount({
+          connector,
+          identifier,
+          connectedAccount,
+          organizationId: testOrg,
+        });
+
+        expect(response).toBeDefined();
+        expect(response.connectedAccount).toBeDefined();
+      } catch (error: any) {
+        // Expected errors: connected account not found, invalid credentials, etc.
+        expect(error).toBeDefined();
+      }
+    });
+
+    it('should handle update connected account with ID', async () => {
+      const connector = 'test_connector';
+      const identifier = 'test_identifier';
+      
+      const oauthToken = new OauthToken({
+        accessToken: 'updated_access_token',
+      });
+
+      const authorizationDetails = new AuthorizationDetails({
+        details: {
+          case: 'oauthToken',
+          value: oauthToken,
+        },
+      });
+
+      const connectedAccount = new UpdateConnectedAccount({
+        authorizationDetails,
+      });
+
+      try {
+        const response = await client.connectedAccounts.updateConnectedAccount({
+          connector,
+          identifier,
+          connectedAccount,
+          connectedAccountId: 'ca_test123',
+        });
+
+        expect(response).toBeDefined();
+      } catch (error: any) {
+        // Expected errors: connected account not found, etc.
+        expect(error).toBeDefined();
+      }
+    });
+  });
+
+  describe('deleteConnectedAccount', () => {
+    it('should handle delete connected account request', async () => {
+      const connector = 'test_connector';
+      const identifier = 'test_identifier';
+
+      try {
+        const response = await client.connectedAccounts.deleteConnectedAccount({
+          connector,
+          identifier,
+          organizationId: testOrg,
+        });
+
+        expect(response).toBeDefined();
+      } catch (error: any) {
+        // Expected errors: connected account not found, etc.
+        expect(error).toBeDefined();
+      }
+    });
+
+    it('should handle delete connected account with ID', async () => {
+      try {
+        const response = await client.connectedAccounts.deleteConnectedAccount({
+          connector: 'test_connector',
+          identifier: 'test_identifier',
+          connectedAccountId: 'ca_test123',
+        });
+
+        expect(response).toBeDefined();
+      } catch (error: any) {
+        // Expected errors: connected account not found, etc.
+        expect(error).toBeDefined();
+      }
+    });
+  });
+
+  describe('getMagicLinkForConnectedAccount', () => {
+    it('should handle get magic link request', async () => {
+      const connector = 'test_connector';
+      const identifier = 'test_identifier';
+
+      try {
+        const response = await client.connectedAccounts.getMagicLinkForConnectedAccount({
+          connector,
+          identifier,
+          organizationId: testOrg,
+        });
+
+        expect(response).toBeDefined();
+        expect(response.link).toBeDefined();
+        expect(typeof response.link).toBe('string');
+        expect(response.expiry).toBeDefined();
+      } catch (error: any) {
+        // Expected errors: connector not found, invalid parameters, etc.
+        expect(error).toBeDefined();
+      }
+    });
+
+    it('should handle get magic link with user ID', async () => {
+      try {
+        const response = await client.connectedAccounts.getMagicLinkForConnectedAccount({
+          connector: 'test_connector',
+          identifier: 'test_identifier',
+          userId: 'usr_test123',
+        });
+
+        expect(response).toBeDefined();
+        if (response.link) {
+          expect(typeof response.link).toBe('string');
+        }
+      } catch (error: any) {
+        // Expected errors: connector not found, etc.
+        expect(error).toBeDefined();
+      }
+    });
+
+    it('should handle get magic link with connected account ID', async () => {
+      try {
+        const response = await client.connectedAccounts.getMagicLinkForConnectedAccount({
+          connector: 'test_connector',
+          identifier: 'test_identifier',
+          connectedAccountId: 'ca_test123',
+        });
+
+        expect(response).toBeDefined();
+      } catch (error: any) {
+        // Expected errors: connected account not found, etc.
+        expect(error).toBeDefined();
+      }
+    });
+  });
+
+  describe('getConnectedAccountByIdentifier', () => {
+    it('should handle get connected account by identifier request', async () => {
+      const connector = 'test_connector';
+      const identifier = 'test_identifier';
+
+      try {
+        const response = await client.connectedAccounts.getConnectedAccountByIdentifier({
+          connector,
+          identifier,
+          organizationId: testOrg,
+        });
+
+        expect(response).toBeDefined();
+        expect(response.connectedAccount).toBeDefined();
+        expect(response.connectedAccount?.id).toBeDefined();
+        expect(response.connectedAccount?.authorizationDetails).toBeDefined();
+      } catch (error: any) {
+        // Expected errors: connected account not found, etc.
+        expect(error).toBeDefined();
+      }
+    });
+
+    it('should handle get connected account with user ID', async () => {
+      try {
+        const response = await client.connectedAccounts.getConnectedAccountByIdentifier({
+          connector: 'test_connector',
+          identifier: 'test_identifier',
+          userId: 'usr_test123',
+        });
+
+        expect(response).toBeDefined();
+        if (response.connectedAccount) {
+          expect(response.connectedAccount.id).toBeDefined();
+        }
+      } catch (error: any) {
+        // Expected errors: connected account not found, etc.
+        expect(error).toBeDefined();
+      }
+    });
+
+    it('should handle get connected account with connected account ID', async () => {
+      try {
+        const response = await client.connectedAccounts.getConnectedAccountByIdentifier({
+          connector: 'test_connector',
+          identifier: 'test_identifier',
+          connectedAccountId: 'ca_test123',
+        });
+
+        expect(response).toBeDefined();
+      } catch (error: any) {
+        // Expected errors: connected account not found, etc.
+        expect(error).toBeDefined();
+      }
+    });
+  });
+});

package/tests/tools.test.ts

@@ -0,0 +1,239 @@
+import ScalekitClient from '../src/scalekit';
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { TestOrganizationManager } from './utils/test-data';
+
+describe('Tools', () => {
+  let client: ScalekitClient;
+  let testOrg: string;
+
+  beforeEach(async () => {
+    // Use global client
+    client = global.client;
+    
+    // Create test organization for each test
+    testOrg = await TestOrganizationManager.createTestOrganization(client);
+  });
+
+  afterEach(async () => {
+    // Clean up test organization
+    await TestOrganizationManager.cleanupTestOrganization(client, testOrg);
+  });
+
+  describe('listTools', () => {
+    it('should list tools', async () => {
+      const response = await client.tools.listTools();
+
+      expect(response).toBeDefined();
+      expect(response.tools).toBeDefined();
+      expect(Array.isArray(response.tools)).toBe(true);
+      expect(response.totalSize).toBeDefined();
+      expect(typeof response.totalSize).toBe('number');
+    });
+
+    it('should list tools with filter', async () => {
+      const response = await client.tools.listTools({
+        filter: {
+          provider: 'GOOGLE',
+        },
+      });
+
+      expect(response).toBeDefined();
+      expect(response.tools).toBeDefined();
+      expect(Array.isArray(response.tools)).toBe(true);
+    });
+
+    it('should list tools with pagination', async () => {
+      const firstPage = await client.tools.listTools({
+        pageSize: 10,
+      });
+
+      expect(firstPage).toBeDefined();
+      expect(firstPage.tools).toBeDefined();
+      expect(firstPage.tools.length).toBeLessThanOrEqual(10);
+
+      if (firstPage.nextPageToken) {
+        const secondPage = await client.tools.listTools({
+          pageSize: 10,
+          pageToken: firstPage.nextPageToken,
+        });
+
+        expect(secondPage).toBeDefined();
+        expect(secondPage.tools).toBeDefined();
+      }
+    });
+
+    it('should list tools with summary filter', async () => {
+      const response = await client.tools.listTools({
+        filter: {
+          summary: true,
+        },
+      });
+
+      expect(response).toBeDefined();
+      expect(response.toolNames).toBeDefined();
+      expect(Array.isArray(response.toolNames)).toBe(true);
+    });
+
+    it('should list tools with tool name filter', async () => {
+      const response = await client.tools.listTools({
+        filter: {
+          toolName: ['gmail_send_email'],
+        },
+      });
+
+      expect(response).toBeDefined();
+      expect(response.tools).toBeDefined();
+      expect(Array.isArray(response.tools)).toBe(true);
+    });
+  });
+
+  describe('listScopedTools', () => {
+    it('should list scoped tools with identifier', async () => {
+      const identifier = 'test_identifier';
+      
+      // Filter is required by the API and must have at least one non-empty array
+      try {
+        const response = await client.tools.listScopedTools(identifier, {
+          filter: {
+            providers: ['GOOGLE'],
+          },
+        });
+
+        expect(response).toBeDefined();
+        expect(response.tools).toBeDefined();
+        expect(Array.isArray(response.tools)).toBe(true);
+        expect(response.totalSize).toBeDefined();
+        expect(typeof response.totalSize).toBe('number');
+      } catch (error: any) {
+        // Expected errors: connected account not found, etc.
+        expect(error).toBeDefined();
+      }
+    });
+
+    it('should list scoped tools with filter', async () => {
+      const identifier = 'test_identifier';
+      
+      try {
+        const response = await client.tools.listScopedTools(identifier, {
+          filter: {
+            providers: ['GOOGLE'],
+            toolNames: ['gmail_send_email'],
+          },
+        });
+
+        expect(response).toBeDefined();
+        expect(response.tools).toBeDefined();
+        expect(Array.isArray(response.tools)).toBe(true);
+      } catch (error: any) {
+        // Expected errors: connected account not found, etc.
+        expect(error).toBeDefined();
+      }
+    });
+
+    it('should list scoped tools with pagination', async () => {
+      const identifier = 'test_identifier';
+      
+      // Filter is required by the API and must have at least one non-empty array
+      try {
+        const firstPage = await client.tools.listScopedTools(identifier, {
+          filter: {
+            providers: ['GOOGLE'],
+          },
+          pageSize: 10,
+        });
+
+        expect(firstPage).toBeDefined();
+        expect(firstPage.tools).toBeDefined();
+        expect(firstPage.tools.length).toBeLessThanOrEqual(10);
+
+        if (firstPage.nextPageToken) {
+          const secondPage = await client.tools.listScopedTools(identifier, {
+            filter: {
+              providers: ['GOOGLE'],
+            },
+            pageSize: 10,
+            pageToken: firstPage.nextPageToken,
+          });
+
+          expect(secondPage).toBeDefined();
+          expect(secondPage.tools).toBeDefined();
+        }
+      } catch (error: any) {
+        // Expected errors: connected account not found, etc.
+        expect(error).toBeDefined();
+      }
+    });
+  });
+
+  describe('executeTool', () => {
+    it('should handle execute tool request with minimal params', async () => {
+      // This test expects an error since we don't have a real tool/connected account
+      // but it validates the request structure is correct
+      try {
+        await client.tools.executeTool({
+          toolName: 'test_tool',
+          params: {
+            test: 'value',
+          },
+        });
+        // If execution succeeds, that's fine too
+      } catch (error: any) {
+        // Expected errors: tool not found, connected account not found, etc.
+        expect(error).toBeDefined();
+        // Verify it's a proper error response, not a request structure issue
+        expect(error.message || error.toString()).toBeDefined();
+      }
+    });
+
+    it('should handle execute tool with connected account ID', async () => {
+      try {
+        await client.tools.executeTool({
+          toolName: 'test_tool',
+          connectedAccountId: 'ca_test123',
+          params: {
+            test: 'value',
+          },
+        });
+      } catch (error: any) {
+        // Expected errors: tool not found, connected account not found, etc.
+        expect(error).toBeDefined();
+      }
+    });
+
+    it('should handle execute tool with identifier and connector', async () => {
+      try {
+        await client.tools.executeTool({
+          toolName: 'test_tool',
+          identifier: 'test@example.com',
+          connector: 'google_workspace',
+          organizationId: testOrg,
+          params: {
+            test: 'value',
+          },
+        });
+      } catch (error: any) {
+        // Expected errors: tool not found, connected account not found, etc.
+        expect(error).toBeDefined();
+      }
+    });
+
+    it('should handle execute tool with complex params', async () => {
+      try {
+        await client.tools.executeTool({
+          toolName: 'gmail_send_email',
+          identifier: 'test@example.com',
+          connector: 'google_workspace',
+          params: {
+            to: 'recipient@example.com',
+            subject: 'Test Subject',
+            body: 'Test Body',
+            attachments: [],
+          },
+        });
+      } catch (error: any) {
+        // Expected errors: tool not found, connected account not found, etc.
+        expect(error).toBeDefined();
+      }
+    });
+  });
+});

package/tsconfig.json

@@ -2,6 +2,7 @@
   "compilerOptions": {
     "noImplicitAny": false,
     "target": "ES6",
+    "lib": ["ES2020"],
     "module": "commonjs",
     "declaration": true,
     "strictNullChecks": true,
@@ -11,7 +12,7 @@
     "sourceMap": true,
     "skipLibCheck": true,
     "esModuleInterop": true,
-    "typeRoots": ["src/types"],
+    "typeRoots": ["src/types", "node_modules/@types"],
     "moduleResolution": "Node"
   },
   "include": ["src"],