@datalayer/core 0.0.9 → 0.0.11

package/lib/api/spacer/__tests__/users.unit.test.js

@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { users } from '..';
+import * as DatalayerApi from '../../DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS } from '../../constants';
+import { MOCK_JWT_TOKEN } from '../../../__tests__/shared/test-constants';
+// Mock the DatalayerApi module
+vi.mock('../../DatalayerApi', () => ({
+    requestDatalayerAPI: vi.fn(),
+}));
+describe('Spacer Users Unit Tests', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('getMySpaces', () => {
+        const mockSpacesResponse = {
+            success: true,
+            message: 'Spaces retrieved successfully',
+            spaces: [
+                {
+                    id: 'space-1',
+                    uid: 'uid-space-1',
+                    name: 'My First Space',
+                    description: 'A test space',
+                    owner_id: 'user-123',
+                    created_at: '2024-01-01T00:00:00Z',
+                    updated_at: '2024-01-02T00:00:00Z',
+                },
+                {
+                    id: 'space-2',
+                    uid: 'uid-space-2',
+                    name: 'My Second Space',
+                    description: 'Another test space',
+                    owner_id: 'user-123',
+                    created_at: '2024-01-03T00:00:00Z',
+                    updated_at: '2024-01-04T00:00:00Z',
+                },
+            ],
+        };
+        it('should successfully get user spaces', async () => {
+            console.log('Testing getMySpaces with valid token...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockSpacesResponse);
+            const result = await users.getMySpaces(MOCK_JWT_TOKEN);
+            expect(mockedRequest).toHaveBeenCalledTimes(1);
+            expect(mockedRequest).toHaveBeenCalledWith({
+                url: `${DEFAULT_SERVICE_URLS.SPACER}${API_BASE_PATHS.SPACER}/spaces/users/me`,
+                method: 'GET',
+                token: MOCK_JWT_TOKEN,
+            });
+            expect(result).toEqual(mockSpacesResponse);
+            expect(result.spaces).toHaveLength(2);
+            console.log('Successfully retrieved user spaces');
+        });
+        it('should use custom base URL when provided', async () => {
+            console.log('Testing getMySpaces with custom base URL...');
+            const customUrl = 'https://custom.spacer.api';
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockSpacesResponse);
+            await users.getMySpaces(MOCK_JWT_TOKEN, customUrl);
+            expect(mockedRequest).toHaveBeenCalledWith({
+                url: `${customUrl}${API_BASE_PATHS.SPACER}/spaces/users/me`,
+                method: 'GET',
+                token: MOCK_JWT_TOKEN,
+            });
+            console.log('Custom base URL used correctly');
+        });
+        it('should handle empty spaces list', async () => {
+            console.log('Testing getMySpaces with empty response...');
+            const emptyResponse = {
+                success: true,
+                message: 'No spaces found for user',
+                spaces: [],
+            };
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(emptyResponse);
+            const result = await users.getMySpaces(MOCK_JWT_TOKEN);
+            expect(result).toEqual(emptyResponse);
+            expect(result.spaces).toHaveLength(0);
+            console.log('Empty spaces list handled correctly');
+        });
+        it('should fail when token is missing', async () => {
+            console.log('Testing getMySpaces with missing token...');
+            await expect(
+            // @ts-expect-error Testing undefined token
+            users.getMySpaces(undefined)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected missing token');
+        });
+        it('should fail when token is empty', async () => {
+            console.log('Testing getMySpaces with empty token...');
+            await expect(users.getMySpaces('')).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected empty token');
+        });
+        it('should fail when token is only whitespace', async () => {
+            console.log('Testing getMySpaces with whitespace token...');
+            await expect(users.getMySpaces('   ')).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected whitespace token');
+        });
+        it('should fail when token is null', async () => {
+            console.log('Testing getMySpaces with null token...');
+            await expect(
+            // @ts-expect-error Testing null token
+            users.getMySpaces(null)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected null token');
+        });
+        it('should handle API errors gracefully', async () => {
+            console.log('Testing getMySpaces with API error...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockRejectedValue(new Error('Network error'));
+            await expect(users.getMySpaces(MOCK_JWT_TOKEN)).rejects.toThrow('Network error');
+            console.log('API error handled correctly');
+        });
+        it('should handle malformed response', async () => {
+            console.log('Testing getMySpaces with malformed response...');
+            const malformedResponse = {
+                success: false,
+                message: 'Invalid response format',
+                // spaces array is missing
+            };
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(malformedResponse);
+            const result = await users.getMySpaces(MOCK_JWT_TOKEN);
+            expect(result).toEqual(malformedResponse);
+            // Should not throw, but spaces will be undefined
+            expect(result.spaces).toBeUndefined();
+            console.log('Malformed response handled gracefully');
+        });
+    });
+});

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

@@ -0,0 +1,25 @@
+/**
+ * Health check response from the Spacer service
+ */
+export interface SpacerHealthzPingResponse {
+    success: boolean;
+    message: string;
+    status?: {
+        status: string;
+    };
+    version?: string;
+}
+/**
+ * Health check ping endpoint for Spacer service
+ * @param baseUrl - Base URL for the API (defaults to production Spacer URL)
+ * @returns Health check response
+ * @throws {Error} If the health check fails
+ *
+ * @description
+ * This endpoint provides a basic health check for the Spacer service.
+ * It returns the current status of the service.
+ *
+ * Expected status codes:
+ * - 200: Service is healthy
+ */
+export declare const ping: (baseUrl?: string) => Promise<SpacerHealthzPingResponse>;

package/lib/api/spacer/healthz.js

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module api/spacer/healthz
+ * @description Health check API functions for the Datalayer Spacer service.
+ *
+ * Provides functions for checking the health status of the Spacer service.
+ */
+import { requestDatalayerAPI } from '../DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS } from '../constants';
+/**
+ * Health check ping endpoint for Spacer service
+ * @param baseUrl - Base URL for the API (defaults to production Spacer URL)
+ * @returns Health check response
+ * @throws {Error} If the health check fails
+ *
+ * @description
+ * This endpoint provides a basic health check for the Spacer service.
+ * It returns the current status of the service.
+ *
+ * Expected status codes:
+ * - 200: Service is healthy
+ */
+export const ping = async (baseUrl = DEFAULT_SERVICE_URLS.SPACER) => {
+    try {
+        const response = await requestDatalayerAPI({
+            url: `${baseUrl}${API_BASE_PATHS.SPACER}/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/spacer/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module api/spacer
+ * @description Spacer API exports.
+ *
+ * Provides organized access to spacer functionality including
+ * spaces, notebooks, cells, and lexical documents.
+ */
+export * as healthz from './healthz';
+export * as items from './items';
+export * as lexicals from './lexicals';
+export * as notebooks from './notebooks';
+export * as spaces from './spaces';
+export * as users from './users';

package/lib/api/spacer/index.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module api/spacer
+ * @description Spacer API exports.
+ *
+ * Provides organized access to spacer functionality including
+ * spaces, notebooks, cells, and lexical documents.
+ */
+export * as healthz from './healthz';
+export * as items from './items';
+export * as lexicals from './lexicals';
+export * as notebooks from './notebooks';
+export * as spaces from './spaces';
+export * as users from './users';

package/lib/api/spacer/items.d.ts

@@ -0,0 +1,17 @@
+import { DeleteSpaceItemResponse, GetSpaceItemsResponse } from '../types/spacer';
+/**
+ * Get the items of a space.
+ * @param token - Authentication token
+ * @param spaceId - The space ID
+ * @param baseUrl - Base URL for the API (defaults to production)
+ * @returns Promise resolving to the items response
+ */
+export declare const getSpaceItems: (token: string, spaceId: string, baseUrl?: string) => Promise<GetSpaceItemsResponse>;
+/**
+ * Delete an item from a space.
+ * @param token - Authentication token
+ * @param id - The item ID to delete
+ * @param baseUrl - Base URL for the API (defaults to production)
+ * @returns Promise resolving when deletion is complete
+ */
+export declare const deleteItem: (token: string, id: string, baseUrl?: string) => Promise<DeleteSpaceItemResponse>;

package/lib/api/spacer/items.js

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module api/spacer/items
+ * @description Items API functions for the Datalayer platform.
+ *
+ * Provides functions for managing items in spaces.
+ */
+import { requestDatalayerAPI } from '../DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS } from '../constants';
+/**
+ * Get the items of a space.
+ * @param token - Authentication token
+ * @param spaceId - The space ID
+ * @param baseUrl - Base URL for the API (defaults to production)
+ * @returns Promise resolving to the items response
+ */
+export const getSpaceItems = async (token, spaceId, baseUrl = DEFAULT_SERVICE_URLS.SPACER) => {
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.SPACER}/spaces/${spaceId}/items`,
+        method: 'GET',
+        token,
+    });
+};
+/**
+ * Delete an item from a space.
+ * @param token - Authentication token
+ * @param id - The item ID to delete
+ * @param baseUrl - Base URL for the API (defaults to production)
+ * @returns Promise resolving when deletion is complete
+ */
+export const deleteItem = async (token, id, baseUrl = DEFAULT_SERVICE_URLS.SPACER) => {
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.SPACER}/spaces/items/${id}`,
+        method: 'DELETE',
+        token,
+    });
+};

package/lib/api/spacer/lexicals.d.ts

@@ -0,0 +1,26 @@
+import { CreateLexicalRequest, CreateLexicalResponse, GetLexicalResponse, UpdateLexicalRequest, UpdateLexicalResponse } from '../types/spacer';
+/**
+ * Create a new lexical document.
+ * @param token - Authentication token
+ * @param data - Document creation configuration
+ * @param baseUrl - Base URL for the API (defaults to production)
+ * @returns Promise resolving to the created document response
+ */
+export declare const createLexical: (token: string, data: CreateLexicalRequest, baseUrl?: string) => Promise<CreateLexicalResponse>;
+/**
+ * Get a lexical document by ID.
+ * @param token - Authentication token
+ * @param id - The document ID
+ * @param baseUrl - Base URL for the API (defaults to production)
+ * @returns Promise resolving to the document response
+ */
+export declare const getLexical: (token: string, id: string, baseUrl?: string) => Promise<GetLexicalResponse>;
+/**
+ * Update a lexical document.
+ * @param token - Authentication token
+ * @param id - The document ID
+ * @param data - Update data containing name and/or description
+ * @param baseUrl - Base URL for the API (defaults to production)
+ * @returns Promise resolving to the updated document response
+ */
+export declare const updateLexical: (token: string, id: string, data: UpdateLexicalRequest, baseUrl?: string) => Promise<UpdateLexicalResponse>;

package/lib/api/spacer/lexicals.js

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module api/spacer/lexicals
+ * @description Lexical documents API functions for the Datalayer platform.
+ *
+ * Provides functions for creating, retrieving, and updating lexical (rich text) documents.
+ */
+import { requestDatalayerAPI } from '../DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS } from '../constants';
+/**
+ * Create a new lexical document.
+ * @param token - Authentication token
+ * @param data - Document creation configuration
+ * @param baseUrl - Base URL for the API (defaults to production)
+ * @returns Promise resolving to the created document response
+ */
+export const createLexical = async (token, data, baseUrl = DEFAULT_SERVICE_URLS.SPACER) => {
+    // Create FormData for multipart/form-data request (like the working example)
+    const formData = new FormData();
+    formData.append('spaceId', data.spaceId);
+    formData.append('name', data.name);
+    formData.append('documentType', data.documentType || 'lexical'); // Required field
+    formData.append('description', data.description || ''); // Required field - can be empty
+    // Add file if provided
+    if (data.file) {
+        if (data.file instanceof File) {
+            formData.append('file', data.file, data.file.name);
+        }
+        else {
+            // Handle Blob case
+            formData.append('file', data.file, `${data.name}.json`);
+        }
+    }
+    const url = `${baseUrl}${API_BASE_PATHS.SPACER}/lexicals`;
+    return requestDatalayerAPI({
+        url,
+        method: 'POST',
+        token,
+        body: formData,
+    });
+};
+/**
+ * Get a lexical document by ID.
+ * @param token - Authentication token
+ * @param id - The document ID
+ * @param baseUrl - Base URL for the API (defaults to production)
+ * @returns Promise resolving to the document response
+ */
+export const getLexical = async (token, id, baseUrl = DEFAULT_SERVICE_URLS.SPACER) => {
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.SPACER}/lexicals/${id}`,
+        method: 'GET',
+        token,
+    });
+};
+/**
+ * Update a lexical document.
+ * @param token - Authentication token
+ * @param id - The document ID
+ * @param data - Update data containing name and/or description
+ * @param baseUrl - Base URL for the API (defaults to production)
+ * @returns Promise resolving to the updated document response
+ */
+export const updateLexical = async (token, id, data, baseUrl = DEFAULT_SERVICE_URLS.SPACER) => {
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.SPACER}/lexicals/${id}`,
+        method: 'PUT',
+        token,
+        body: data,
+    });
+};

package/lib/api/spacer/notebooks.d.ts

@@ -0,0 +1,26 @@
+import { CreateNotebookRequest, CreateNotebookResponse, GetNotebookResponse, UpdateNotebookRequest, UpdateNotebookResponse } from '../types/spacer';
+/**
+ * Create a new Jupyter notebook.
+ * @param token - Authentication token
+ * @param data - Notebook creation configuration
+ * @param baseUrl - Base URL for the API (defaults to production)
+ * @returns Promise resolving to the created notebook response
+ */
+export declare const createNotebook: (token: string, data: CreateNotebookRequest, baseUrl?: string) => Promise<CreateNotebookResponse>;
+/**
+ * Get a notebook by ID.
+ * @param token - Authentication token
+ * @param id - The notebook ID
+ * @param baseUrl - Base URL for the API (defaults to production)
+ * @returns Promise resolving to the notebook response
+ */
+export declare const getNotebook: (token: string, id: string, baseUrl?: string) => Promise<GetNotebookResponse>;
+/**
+ * Update a notebook.
+ * @param token - Authentication token
+ * @param id - The notebook ID
+ * @param data - Update data containing name and/or description
+ * @param baseUrl - Base URL for the API (defaults to production)
+ * @returns Promise resolving to the updated notebook response
+ */
+export declare const updateNotebook: (token: string, id: string, data: UpdateNotebookRequest, baseUrl?: string) => Promise<UpdateNotebookResponse>;

package/lib/api/spacer/notebooks.js

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module api/spacer/notebooks
+ * @description Jupyter notebooks API functions for the Datalayer platform.
+ *
+ * Provides functions for creating and retrieving Jupyter notebooks within workspaces.
+ */
+import { requestDatalayerAPI } from '../DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS } from '../constants';
+/**
+ * Create a new Jupyter notebook.
+ * @param token - Authentication token
+ * @param data - Notebook creation configuration
+ * @param baseUrl - Base URL for the API (defaults to production)
+ * @returns Promise resolving to the created notebook response
+ */
+export const createNotebook = async (token, data, baseUrl = DEFAULT_SERVICE_URLS.SPACER) => {
+    // Create FormData for multipart/form-data request (like the working example)
+    const formData = new FormData();
+    formData.append('spaceId', data.spaceId);
+    formData.append('name', data.name);
+    formData.append('notebookType', data.notebookType || 'jupyter'); // Required field
+    formData.append('description', data.description || ''); // Required field - can be empty
+    // Add file if provided
+    if (data.file) {
+        if (data.file instanceof File) {
+            formData.append('file', data.file, data.file.name);
+        }
+        else {
+            // Handle Blob case
+            formData.append('file', data.file, `${data.name}.ipynb`);
+        }
+    }
+    const url = `${baseUrl}${API_BASE_PATHS.SPACER}/notebooks`;
+    return requestDatalayerAPI({
+        url,
+        method: 'POST',
+        token,
+        body: formData,
+    });
+};
+/**
+ * Get a notebook by ID.
+ * @param token - Authentication token
+ * @param id - The notebook ID
+ * @param baseUrl - Base URL for the API (defaults to production)
+ * @returns Promise resolving to the notebook response
+ */
+export const getNotebook = async (token, id, baseUrl = DEFAULT_SERVICE_URLS.SPACER) => {
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.SPACER}/notebooks/${id}`,
+        method: 'GET',
+        token,
+    });
+};
+/**
+ * Update a notebook.
+ * @param token - Authentication token
+ * @param id - The notebook ID
+ * @param data - Update data containing name and/or description
+ * @param baseUrl - Base URL for the API (defaults to production)
+ * @returns Promise resolving to the updated notebook response
+ */
+export const updateNotebook = async (token, id, data, baseUrl = DEFAULT_SERVICE_URLS.SPACER) => {
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.SPACER}/notebooks/${id}`,
+        method: 'PUT',
+        token,
+        body: data,
+    });
+};

package/lib/api/spacer/spaces.d.ts

@@ -0,0 +1,9 @@
+import { CreateSpaceRequest, CreateSpaceResponse } from '../types/spacer';
+/**
+ * Create a new workspace space.
+ * @param token - Authentication token
+ * @param data - Space creation configuration
+ * @param baseUrl - Base URL for the API
+ * @returns Promise resolving to the created space response
+ */
+export declare const createSpace: (token: string, data: CreateSpaceRequest, baseUrl?: string) => Promise<CreateSpaceResponse>;

package/lib/api/spacer/spaces.js

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module api/spacer/spaces
+ * @description Workspace spaces API functions for the Datalayer platform.
+ *
+ * Provides function for creating workspace spaces.
+ */
+import { requestDatalayerAPI } from '../DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS } from '../constants';
+import { validateToken } from '../utils/validation';
+/**
+ * Create a new workspace space.
+ * @param token - Authentication token
+ * @param data - Space creation configuration
+ * @param baseUrl - Base URL for the API
+ * @returns Promise resolving to the created space response
+ */
+export const createSpace = async (token, data, baseUrl = DEFAULT_SERVICE_URLS.SPACER) => {
+    validateToken(token);
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.SPACER}/spaces`,
+        method: 'POST',
+        token,
+        body: data,
+    });
+};

package/lib/api/spacer/users.d.ts

@@ -0,0 +1,9 @@
+import { SpacesForUserResponse } from '../types/spacer';
+/**
+ * Get all spaces for the current authenticated user.
+ * @param token - Authentication token
+ * @param baseUrl - Base URL for the API (defaults to production Spacer URL)
+ * @returns Promise resolving to the user's spaces
+ * @throws {Error} If authentication token is missing or invalid
+ */
+export declare const getMySpaces: (token: string, baseUrl?: string) => Promise<SpacesForUserResponse>;

package/lib/api/spacer/users.js

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module api/spacer/users
+ * @description User-related Spacer API functions for the Datalayer platform.
+ *
+ * Provides functions for user-specific operations in the Spacer service.
+ */
+import { requestDatalayerAPI } from '../DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS } from '../constants';
+import { validateToken } from '../utils/validation';
+/**
+ * Get all spaces for the current authenticated user.
+ * @param token - Authentication token
+ * @param baseUrl - Base URL for the API (defaults to production Spacer URL)
+ * @returns Promise resolving to the user's spaces
+ * @throws {Error} If authentication token is missing or invalid
+ */
+export const getMySpaces = async (token, baseUrl = DEFAULT_SERVICE_URLS.SPACER) => {
+    validateToken(token);
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.SPACER}/spaces/users/me`,
+        method: 'GET',
+        token,
+    });
+};