infrahub-sdk 0.0.8 → 0.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infrahub-sdk",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "A client SDK for the Infrahub API.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -83,11 +83,12 @@ export class InfrahubClient {
     this.branch = new InfrahubBranchManager(this);
 
     // Create custom fetch with TLS options if provided
-    let customFetch: typeof fetch = fetch;
+    // Also handle Request objects properly for node-fetch v2 compatibility
+    let httpsAgent: https.Agent | undefined;
     if (options.tls) {
       // Build agent options, ensuring rejectUnauthorized is explicitly set if provided
       const agentOptions: https.AgentOptions = {};
-      
+
       if (options.tls.rejectUnauthorized !== undefined) {
         agentOptions.rejectUnauthorized = options.tls.rejectUnauthorized;
       }
@@ -101,19 +102,42 @@ export class InfrahubClient {
         agentOptions.key = options.tls.key;
       }
 
-      const httpsAgent = new https.Agent(agentOptions);
-      
-      customFetch = ((
-        url: Parameters<typeof fetch>[0],
-        opts: Parameters<typeof fetch>[1] = {}
-      ) => {
-        // Ensure agent is passed for HTTPS URLs
-        // node-fetch v2 requires the agent to be explicitly set
-        const fetchOptions = { ...opts, agent: httpsAgent };
-        return fetch(url, fetchOptions);
-      }) as typeof fetch;
+      httpsAgent = new https.Agent(agentOptions);
     }
 
+    // Wrap fetch to handle Request objects from openapi-fetch
+    // node-fetch v2 doesn't properly extract URL from Request objects
+    const customFetch = ((
+      input: Parameters<typeof fetch>[0],
+      init?: Parameters<typeof fetch>[1]
+    ) => {
+      let url: string;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      let options: any = init || {};
+
+      // Handle Request objects by extracting URL and merging options
+      if (input && typeof input === 'object' && 'url' in input) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const req = input as any;
+        url = req.url;
+        options = {
+          method: req.method,
+          headers: req.headers,
+          body: req.body,
+          ...init
+        };
+      } else {
+        url = input as string;
+      }
+
+      // Add HTTPS agent if configured
+      if (httpsAgent) {
+        options = { ...options, agent: httpsAgent };
+      }
+
+      return fetch(url, options);
+    }) as typeof fetch;
+
     // Initialize the openapi-fetch client with TLS configuration
     this.rest = createClient<paths>({
       baseUrl: this.baseUrl,

package/src/integration.test.ts

@@ -0,0 +1,63 @@
+/**
+ * Integration tests for the Infrahub SDK
+ *
+ * These tests require a running Infrahub server at http://localhost:8000
+ *
+ * Run with: npx jest --testPathPattern=integration --resetModules
+ * Or run directly: npx ts-node src/integration.test.ts
+ */
+
+import { InfrahubClient, InfrahubClientOptions } from './index';
+import { describe, expect, it, beforeAll } from '@jest/globals';
+
+const INFRAHUB_URL = process.env.INFRAHUB_URL || 'http://localhost:8000';
+const INFRAHUB_TOKEN = process.env.INFRAHUB_TOKEN || '';
+
+describe('Integration Tests - Schema Loading', () => {
+  let client: InfrahubClient;
+
+  beforeAll(() => {
+    const options: InfrahubClientOptions = {
+      address: INFRAHUB_URL,
+      token: INFRAHUB_TOKEN
+    };
+    client = new InfrahubClient(options);
+  });
+
+  it('should load schema from the server', async () => {
+    const result = await client.rest.GET('/api/schema');
+
+    expect(result.error).toBeUndefined();
+    expect(result.response?.status).toBe(200);
+    expect(result.data).toBeDefined();
+
+    // Schema should have nodes and/or generics arrays
+    if (result.data) {
+      expect(typeof result.data).toBe('object');
+    }
+  });
+
+  it('should load schema summary from the server', async () => {
+    const result = await client.rest.GET('/api/schema/summary');
+
+    expect(result.error).toBeUndefined();
+    expect(result.response?.status).toBe(200);
+    expect(result.data).toBeDefined();
+  });
+
+  it('should get server info', async () => {
+    const result = await client.rest.GET('/api/info');
+
+    expect(result.error).toBeUndefined();
+    expect(result.response?.status).toBe(200);
+    expect(result.data).toBeDefined();
+  });
+
+  it('should get server config', async () => {
+    const result = await client.rest.GET('/api/config');
+
+    expect(result.error).toBeUndefined();
+    expect(result.response?.status).toBe(200);
+    expect(result.data).toBeDefined();
+  });
+});