@datalayer/core 0.0.10 → 0.0.11

package/lib/api/iam/__tests__/healthz.unit.test.js

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ping } from '../healthz';
+import { requestDatalayerAPI } from '../../DatalayerApi';
+// Mock the DatalayerAPI module
+vi.mock('../../DatalayerApi');
+describe('IAM Healthz Unit Tests', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('ping', () => {
+        it('should return health status on successful health check', async () => {
+            const mockResponse = {
+                success: true,
+                message: 'datalayer_iam is up and running.',
+                status: { status: 'OK' },
+                version: '1.0.7',
+            };
+            vi.mocked(requestDatalayerAPI).mockResolvedValueOnce(mockResponse);
+            const result = await ping();
+            expect(result).toEqual(mockResponse);
+            expect(requestDatalayerAPI).toHaveBeenCalledWith({
+                url: 'https://prod1.datalayer.run/api/iam/v1/ping',
+                method: 'GET',
+            });
+        });
+        it('should use custom base URL when provided', async () => {
+            const mockResponse = {
+                success: true,
+                message: 'Service is healthy',
+                status: { status: 'OK' },
+                version: '2.0.0',
+            };
+            const customUrl = 'https://custom.example.com';
+            vi.mocked(requestDatalayerAPI).mockResolvedValueOnce(mockResponse);
+            const result = await ping(customUrl);
+            expect(result).toEqual(mockResponse);
+            expect(requestDatalayerAPI).toHaveBeenCalledWith({
+                url: `${customUrl}/api/iam/v1/ping`,
+                method: 'GET',
+            });
+        });
+        it('should throw error with status code on failure', async () => {
+            const mockError = {
+                response: { status: 500 },
+                message: 'Internal Server Error',
+            };
+            vi.mocked(requestDatalayerAPI).mockRejectedValueOnce(mockError);
+            await expect(ping()).rejects.toThrow('Health check failed: Service unhealthy (status 500) - Internal Server Error');
+        });
+        it('should throw generic error on network failure', async () => {
+            const mockError = new Error('Network error');
+            vi.mocked(requestDatalayerAPI).mockRejectedValueOnce(mockError);
+            await expect(ping()).rejects.toThrow('Health check failed: Network error');
+        });
+    });
+});

package/lib/api/iam/__tests__/profile.unit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/api/iam/__tests__/profile.unit.test.js

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { describe, it, expect } from 'vitest';
+import { profile } from '..';
+describe('IAM Profile Unit Tests', () => {
+    describe('parameter validation', () => {
+        it('should handle undefined token parameter at runtime', async () => {
+            console.log('Testing that undefined token is caught by validation...');
+            // In JavaScript/TypeScript at runtime, calling a function without
+            // required parameters just passes undefined for those parameters.
+            // Our validation code inside the function should catch this.
+            // Test me() with undefined token
+            await expect(profile.me(undefined)).rejects.toThrow('Authentication token is required');
+            // Test whoami() with undefined token
+            await expect(profile.whoami(undefined)).rejects.toThrow('Authentication token is required');
+            console.log('Validation correctly rejects undefined token');
+        });
+        it('should handle null token parameter at runtime', async () => {
+            console.log('Testing that null token is caught by validation...');
+            // Test me() with null token
+            await expect(profile.me(null)).rejects.toThrow('Authentication token is required');
+            // Test whoami() with null token
+            await expect(profile.whoami(null)).rejects.toThrow('Authentication token is required');
+            console.log('Validation correctly rejects null token');
+        });
+        it('should handle empty string token', async () => {
+            console.log('Testing that empty string token is caught by validation...');
+            // Test me() with empty string
+            await expect(profile.me('')).rejects.toThrow('Authentication token is required');
+            // Test whoami() with empty string
+            await expect(profile.whoami('')).rejects.toThrow('Authentication token is required');
+            console.log('Validation correctly rejects empty string token');
+        });
+        it('should handle whitespace-only token', async () => {
+            console.log('Testing that whitespace-only token is caught by validation...');
+            // Test me() with whitespace
+            await expect(profile.me('   ')).rejects.toThrow('Authentication token is required');
+            // Test whoami() with whitespace
+            await expect(profile.whoami('   ')).rejects.toThrow('Authentication token is required');
+            console.log('Validation correctly rejects whitespace-only token');
+        });
+        it('demonstrates JavaScript runtime behavior with missing parameters', () => {
+            console.log('Demonstrating JS runtime behavior...');
+            // This demonstrates that JavaScript doesn't throw errors for missing parameters
+            // The function receives undefined for missing parameters
+            function testFunction(required) {
+                return required === undefined;
+            }
+            // @ts-expect-error TypeScript knows this is wrong, but JS allows it
+            const result = testFunction();
+            expect(result).toBe(true); // The parameter is undefined
+            console.log('JavaScript passes undefined for missing parameters');
+        });
+    });
+});

package/lib/api/iam/authentication.d.ts

@@ -0,0 +1,40 @@
+import { LoginRequest, LoginResponse } from '../types/iam';
+/**
+ * Authenticate a user with credentials or token
+ * @param data - Login credentials (either handle+password or token)
+ * @param baseUrl - Base URL for the API (defaults to production IAM URL)
+ * @returns Login response with tokens
+ * @throws {Error} If both credential and token authentication are provided
+ * @throws {Error} If neither authentication method is provided
+ * @throws {Error} If handle is provided without password or vice versa
+ * @throws {Error} If server returns unexpected status code (expects 201 for success, 401 for failure)
+ *
+ * @description
+ * Expected status codes:
+ * - 201: Login succeeded
+ * - 401: Login failed (invalid credentials)
+ */
+export declare const login: (data: LoginRequest, baseUrl?: string) => Promise<LoginResponse>;
+/**
+ * Log out the current user
+ * @param token - Authentication token
+ * @param baseUrl - Base URL for the API (defaults to production IAM URL)
+ * @returns Void response
+ */
+export declare const logout: (token: string, baseUrl?: string) => Promise<void>;
+/**
+ * Validate authentication through proxy
+ * @param token - Authentication token (required)
+ * @param baseUrl - Base URL for the API (defaults to production IAM URL)
+ * @returns Promise that resolves if authenticated (200), rejects if unauthorized (401) or forbidden (403)
+ * @throws {Error} If authentication token is missing or invalid
+ *
+ * @description
+ * This endpoint validates authentication status through a proxy.
+ *
+ * Expected status codes:
+ * - 200: Authenticated successfully
+ * - 401: Unauthorized - invalid or missing credentials
+ * - 403: Forbidden - valid credentials but access denied
+ */
+export declare const proxyAuth: (token: string, baseUrl?: string) => Promise<void>;

package/lib/api/iam/authentication.js

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module api/iam/authentication
+ * @description Authentication API functions for the Datalayer platform.
+ *
+ * Provides functions for user login, logout, and authentication management.
+ */
+import { requestDatalayerAPI } from '../DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS } from '../constants';
+import { validateToken } from '../utils/validation';
+/**
+ * Authenticate a user with credentials or token
+ * @param data - Login credentials (either handle+password or token)
+ * @param baseUrl - Base URL for the API (defaults to production IAM URL)
+ * @returns Login response with tokens
+ * @throws {Error} If both credential and token authentication are provided
+ * @throws {Error} If neither authentication method is provided
+ * @throws {Error} If handle is provided without password or vice versa
+ * @throws {Error} If server returns unexpected status code (expects 201 for success, 401 for failure)
+ *
+ * @description
+ * Expected status codes:
+ * - 201: Login succeeded
+ * - 401: Login failed (invalid credentials)
+ */
+export const login = async (data, baseUrl = DEFAULT_SERVICE_URLS.IAM) => {
+    // Validate that we have either handle+password OR token, but not both
+    const hasCredentials = Boolean(data.handle || data.password);
+    const hasToken = Boolean(data.token);
+    if (hasCredentials && hasToken) {
+        throw new Error('Cannot provide both credentials (handle/password) and token. Use either handle+password or token.');
+    }
+    if (!hasCredentials && !hasToken) {
+        throw new Error('Must provide either credentials (handle+password) or token for authentication.');
+    }
+    // If using credentials, ensure both handle and password are provided
+    if (hasCredentials) {
+        if (!data.handle || !data.password) {
+            throw new Error('Both handle and password are required for credential-based authentication.');
+        }
+    }
+    try {
+        const response = await requestDatalayerAPI({
+            url: `${baseUrl}${API_BASE_PATHS.IAM}/login`,
+            method: 'POST',
+            body: data,
+        });
+        // Note: requestDatalayerAPI already handles successful responses (2xx status codes)
+        // If we get here, the login was successful
+        return response;
+    }
+    catch (error) {
+        // Check if it's a response error with status code information
+        if (error.response) {
+            const status = error.response.status;
+            // Expected error: 401 for invalid credentials
+            if (status === 401) {
+                throw new Error(`Login failed: Invalid credentials (${status})`);
+            }
+            // Unexpected status codes
+            throw new Error(`Login failed: Unexpected status code ${status} - ${error.message}`);
+        }
+        // Re-throw other errors (network errors, etc.)
+        throw error;
+    }
+};
+/**
+ * Log out the current user
+ * @param token - Authentication token
+ * @param baseUrl - Base URL for the API (defaults to production IAM URL)
+ * @returns Void response
+ */
+export const logout = async (token, baseUrl = DEFAULT_SERVICE_URLS.IAM) => {
+    validateToken(token);
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.IAM}/logout`,
+        method: 'GET',
+        token,
+    });
+};
+/**
+ * Validate authentication through proxy
+ * @param token - Authentication token (required)
+ * @param baseUrl - Base URL for the API (defaults to production IAM URL)
+ * @returns Promise that resolves if authenticated (200), rejects if unauthorized (401) or forbidden (403)
+ * @throws {Error} If authentication token is missing or invalid
+ *
+ * @description
+ * This endpoint validates authentication status through a proxy.
+ *
+ * Expected status codes:
+ * - 200: Authenticated successfully
+ * - 401: Unauthorized - invalid or missing credentials
+ * - 403: Forbidden - valid credentials but access denied
+ */
+export const proxyAuth = async (token, baseUrl = DEFAULT_SERVICE_URLS.IAM) => {
+    validateToken(token);
+    try {
+        const response = await requestDatalayerAPI({
+            url: `${baseUrl}${API_BASE_PATHS.IAM}/proxy-auth`,
+            method: 'GET',
+            token,
+        });
+        // Note: requestDatalayerAPI already handles successful responses (2xx status codes)
+        // If we get here, authentication was successful (200)
+        return response;
+    }
+    catch (error) {
+        // Check if it's a response error with status code information
+        if (error.response) {
+            const status = error.response.status;
+            // Expected errors
+            if (status === 401) {
+                throw new Error(`Proxy authentication failed: Unauthorized (${status})`);
+            }
+            if (status === 403) {
+                throw new Error(`Proxy authentication failed: Forbidden (${status})`);
+            }
+            // Unexpected status codes
+            throw new Error(`Proxy authentication failed: Unexpected status code ${status} - ${error.message}`);
+        }
+        // Re-throw other errors (network errors, etc.)
+        throw error;
+    }
+};

package/lib/api/iam/healthz.d.ts

@@ -0,0 +1,15 @@
+import { HealthzPingResponse } from '../types/iam';
+/**
+ * Health check ping endpoint
+ * @param baseUrl - Base URL for the API (defaults to production IAM URL)
+ * @returns Health check response with user count
+ * @throws {Error} If the health check fails
+ *
+ * @description
+ * This endpoint provides a basic health check for the IAM service.
+ * It returns the current user count in the system.
+ *
+ * Expected status codes:
+ * - 200: Service is healthy
+ */
+export declare const ping: (baseUrl?: string) => Promise<HealthzPingResponse>;

package/lib/api/iam/healthz.js

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module api/iam/healthz
+ * @description Health check API functions for the Datalayer IAM service.
+ *
+ * Provides functions for checking the health status of the IAM service.
+ */
+import { requestDatalayerAPI } from '../DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS } from '../constants';
+/**
+ * Health check ping endpoint
+ * @param baseUrl - Base URL for the API (defaults to production IAM URL)
+ * @returns Health check response with user count
+ * @throws {Error} If the health check fails
+ *
+ * @description
+ * This endpoint provides a basic health check for the IAM service.
+ * It returns the current user count in the system.
+ *
+ * Expected status codes:
+ * - 200: Service is healthy
+ */
+export const ping = async (baseUrl = DEFAULT_SERVICE_URLS.IAM) => {
+    try {
+        const response = await requestDatalayerAPI({
+            url: `${baseUrl}${API_BASE_PATHS.IAM}/ping`,
+            method: 'GET',
+        });
+        return response;
+    }
+    catch (error) {
+        // Check if it's a response error with status code information
+        if (error.response) {
+            const status = error.response.status;
+            throw new Error(`Health check failed: Service unhealthy (status ${status}) - ${error.message}`);
+        }
+        // Re-throw other errors (network errors, etc.)
+        throw new Error(`Health check failed: ${error.message}`);
+    }
+};

package/lib/api/iam/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module api/iam
+ * @description IAM (Identity and Access Management) API exports.
+ *
+ * Provides organized access to authentication and user profile functionality.
+ */
+export * as authentication from './authentication';
+export * as profile from './profile';
+export * as healthz from './healthz';
+export { login, logout, proxyAuth } from './authentication';
+export { me, whoami } from './profile';
+export { ping } from './healthz';

package/lib/api/iam/index.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module api/iam
+ * @description IAM (Identity and Access Management) API exports.
+ *
+ * Provides organized access to authentication and user profile functionality.
+ */
+export * as authentication from './authentication';
+export * as profile from './profile';
+export * as healthz from './healthz';
+// For backward compatibility, export the old API structure
+export { login, logout, proxyAuth } from './authentication';
+export { me, whoami } from './profile';
+export { ping } from './healthz';

package/lib/api/iam/profile.d.ts

@@ -0,0 +1,15 @@
+import { UserMeResponse, WhoAmIResponse } from '../types/iam';
+/**
+ * Get current authenticated user profile
+ * @param token - Authentication token (required)
+ * @param baseUrl - Base URL for the API (defaults to production IAM URL)
+ * @returns Current user profile information
+ */
+export declare const me: (token: string, baseUrl?: string) => Promise<UserMeResponse>;
+/**
+ * Get current user identity information
+ * @param token - Authentication token (required)
+ * @param baseUrl - Base URL for the API (defaults to production IAM URL)
+ * @returns Current user identity and profile information
+ */
+export declare const whoami: (token: string, baseUrl?: string) => Promise<WhoAmIResponse>;

package/lib/api/iam/profile.js

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module api/iam/profile
+ * @description User profile management API functions for the Datalayer platform.
+ *
+ * Provides functions for retrieving and managing user profile information.
+ */
+import { requestDatalayerAPI } from '../DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS } from '../constants';
+import { validateToken } from '../utils/validation';
+/**
+ * Get current authenticated user profile
+ * @param token - Authentication token (required)
+ * @param baseUrl - Base URL for the API (defaults to production IAM URL)
+ * @returns Current user profile information
+ */
+export const me = async (token, baseUrl = DEFAULT_SERVICE_URLS.IAM) => {
+    validateToken(token);
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.IAM}/me`,
+        method: 'GET',
+        token,
+    });
+};
+/**
+ * Get current user identity information
+ * @param token - Authentication token (required)
+ * @param baseUrl - Base URL for the API (defaults to production IAM URL)
+ * @returns Current user identity and profile information
+ */
+export const whoami = async (token, baseUrl = DEFAULT_SERVICE_URLS.IAM) => {
+    validateToken(token);
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.IAM}/whoami`,
+        method: 'GET',
+        token,
+    });
+};

package/lib/api/index.d.ts

@@ -1,3 +1,20 @@
-export * from './jupyter';
-export * from './runtimes';
-export * from './DatalayerApi';
+/**
+ * @module @datalayer/core/api
+ * @description Minimal API layer for the Datalayer platform providing base HTTP client and functional API methods.
+ *
+ * This module contains the low-level API functionality. For high-level object-oriented
+ * SDK classes, use @datalayer/core/sdk instead.
+ */
+export { requestDatalayerAPI, RunResponseError, NetworkError, } from './DatalayerApi';
+export type { IRequestDatalayerAPIOptions } from './DatalayerApi';
+export * from './types';
+export * as iam from './iam';
+export * as runtimes from './runtimes';
+export * as spacer from './spacer';
+/**
+ * @deprecated Please import directly from '@datalayer/core/sdk/stateful' instead.
+ * This module provides backward compatibility for the moved apiv1 modules.
+ */
+export * from '../sdk/stateful/jupyter';
+export * from '../sdk/stateful/runtimes';
+export * from '../api/DatalayerApi';

package/lib/api/index.js

@@ -2,6 +2,25 @@
  * Copyright (c) 2023-2025 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-export * from './jupyter';
-export * from './runtimes';
-export * from './DatalayerApi';
+/**
+ * @module @datalayer/core/api
+ * @description Minimal API layer for the Datalayer platform providing base HTTP client and functional API methods.
+ *
+ * This module contains the low-level API functionality. For high-level object-oriented
+ * SDK classes, use @datalayer/core/sdk instead.
+ */
+// Base client exports
+export { requestDatalayerAPI, RunResponseError, NetworkError, } from './DatalayerApi';
+// Type exports
+export * from './types';
+// Domain-organized API exports
+export * as iam from './iam';
+export * as runtimes from './runtimes';
+export * as spacer from './spacer';
+/**
+ * @deprecated Please import directly from '@datalayer/core/sdk/stateful' instead.
+ * This module provides backward compatibility for the moved apiv1 modules.
+ */
+export * from '../sdk/stateful/jupyter';
+export * from '../sdk/stateful/runtimes';
+export * from '../api/DatalayerApi';

package/lib/api/runtimes/__tests__/environments.unit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/api/runtimes/__tests__/environments.unit.test.js

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { environments } from '..';
+import { requestDatalayerAPI } from '../../DatalayerApi';
+import { MOCK_JWT_TOKEN, MOCK_ENVIRONMENTS_RESPONSE, } from '../../../__tests__/shared/test-constants';
+// Mock the DatalayerAPI module
+vi.mock('../../DatalayerApi');
+describe('Runtimes Environments Unit Tests', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('listEnvironments', () => {
+        it('should list environments with valid token', async () => {
+            vi.mocked(requestDatalayerAPI).mockResolvedValueOnce(MOCK_ENVIRONMENTS_RESPONSE);
+            const result = await environments.listEnvironments(MOCK_JWT_TOKEN);
+            expect(result).toEqual(MOCK_ENVIRONMENTS_RESPONSE);
+            expect(requestDatalayerAPI).toHaveBeenCalledWith({
+                url: 'https://prod1.datalayer.run/api/runtimes/v1/environments',
+                method: 'GET',
+                token: MOCK_JWT_TOKEN,
+            });
+        });
+        it('should use custom base URL when provided', async () => {
+            const mockResponse = {
+                success: true,
+                message: 'Environments retrieved',
+                environments: [],
+            };
+            const customUrl = 'https://staging.datalayer.run';
+            vi.mocked(requestDatalayerAPI).mockResolvedValueOnce(mockResponse);
+            const result = await environments.listEnvironments(MOCK_JWT_TOKEN, customUrl);
+            expect(result).toEqual(mockResponse);
+            expect(requestDatalayerAPI).toHaveBeenCalledWith({
+                url: `${customUrl}/api/runtimes/v1/environments`,
+                method: 'GET',
+                token: MOCK_JWT_TOKEN,
+            });
+        });
+        it('should throw error when token is missing', async () => {
+            await expect(environments.listEnvironments('')).rejects.toThrow('Authentication token is required');
+            expect(requestDatalayerAPI).not.toHaveBeenCalled();
+        });
+        it('should throw error when token is null', async () => {
+            // @ts-expect-error Testing null token
+            await expect(environments.listEnvironments(null)).rejects.toThrow('Authentication token is required');
+            expect(requestDatalayerAPI).not.toHaveBeenCalled();
+        });
+        it('should throw error when token is undefined', async () => {
+            // @ts-expect-error Testing undefined token
+            await expect(environments.listEnvironments(undefined)).rejects.toThrow('Authentication token is required');
+            expect(requestDatalayerAPI).not.toHaveBeenCalled();
+        });
+        it('should throw error when token is only whitespace', async () => {
+            await expect(environments.listEnvironments('   ')).rejects.toThrow('Authentication token is required');
+            expect(requestDatalayerAPI).not.toHaveBeenCalled();
+        });
+        it('should handle API errors properly', async () => {
+            const mockError = new Error('Network error');
+            vi.mocked(requestDatalayerAPI).mockRejectedValueOnce(mockError);
+            await expect(environments.listEnvironments(MOCK_JWT_TOKEN)).rejects.toThrow('Network error');
+        });
+        it('should handle empty environments list', async () => {
+            const mockResponse = {
+                success: true,
+                message: 'No environments available',
+                environments: [],
+            };
+            vi.mocked(requestDatalayerAPI).mockResolvedValueOnce(mockResponse);
+            const result = await environments.listEnvironments(MOCK_JWT_TOKEN);
+            expect(result).toEqual(mockResponse);
+            expect(result.environments).toHaveLength(0);
+        });
+    });
+});

package/lib/api/runtimes/__tests__/healthz.unit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/api/runtimes/__tests__/healthz.unit.test.js

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { healthz } from '..';
+import { requestDatalayerAPI } from '../../DatalayerApi';
+// Mock the DatalayerAPI module
+vi.mock('../../DatalayerApi');
+describe('Runtimes Healthz Unit Tests', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('ping', () => {
+        it('should successfully ping the service', async () => {
+            const mockResponse = {
+                success: true,
+                message: 'Runtimes service is healthy',
+                status: {
+                    status: 'OK',
+                },
+                version: '1.0.0',
+            };
+            vi.mocked(requestDatalayerAPI).mockResolvedValueOnce(mockResponse);
+            const result = await healthz.ping('https://test.datalayer.run');
+            expect(result).toEqual(mockResponse);
+            expect(requestDatalayerAPI).toHaveBeenCalledWith({
+                url: 'https://test.datalayer.run/api/runtimes/v1/ping',
+                method: 'GET',
+            });
+        });
+        it('should use default URL when not provided', async () => {
+            const mockResponse = {
+                success: true,
+                message: 'Service is healthy',
+            };
+            vi.mocked(requestDatalayerAPI).mockResolvedValueOnce(mockResponse);
+            const result = await healthz.ping();
+            expect(result).toEqual(mockResponse);
+            expect(requestDatalayerAPI).toHaveBeenCalledWith({
+                url: 'https://prod1.datalayer.run/api/runtimes/v1/ping',
+                method: 'GET',
+            });
+        });
+        it('should handle service unhealthy errors', async () => {
+            const mockError = new Error('Service error');
+            mockError.response = { status: 500 };
+            vi.mocked(requestDatalayerAPI).mockRejectedValueOnce(mockError);
+            await expect(healthz.ping()).rejects.toThrow('Health check failed: Service unhealthy (status 500)');
+        });
+        it('should handle network errors', async () => {
+            const mockError = new Error('Network error');
+            vi.mocked(requestDatalayerAPI).mockRejectedValueOnce(mockError);
+            await expect(healthz.ping()).rejects.toThrow('Health check failed: Network error');
+        });
+    });
+});

package/lib/api/runtimes/__tests__/runtimes.unit.test.d.ts

@@ -0,0 +1 @@
+export {};