@datalayer/core 0.0.9 → 0.0.11

package/lib/api/runtimes/snapshots.d.ts

@@ -1,25 +1,38 @@
-import { Kernel } from '@jupyterlab/services';
-type Props = {
-    connection: Kernel.IKernelConnection;
-    metadata: {
-        filename: string;
-        [key: string]: string;
-    };
-    onUploadProgress?: (bytesUploaded: number, bytesTotal: number) => void;
-};
+import { CreateRuntimeSnapshotRequest, SnapshotsListResponse, SnapshotGetResponse, SnapshotCreateResponse } from '../types/runtimes';
 /**
- * Snapshot a runtime through the frontend and upload it to the cloud.
- *
- * Note: You should use this only for browser runtimes.
+ * Create a snapshot of a runtime instance.
+ * @param token - Authentication token
+ * @param data - Snapshot creation configuration
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving to the created snapshot response
+ * @throws {Error} If authentication token is missing or invalid
  */
-export declare function createRuntimeSnapshot(props: Props): Promise<void>;
+export declare const createSnapshot: (token: string, data: CreateRuntimeSnapshotRequest, baseUrl?: string) => Promise<SnapshotCreateResponse>;
 /**
- * Load a snapshot within a browser kernel.
- *
- * Note: You should use this only for browser kernels.
+ * List all runtime snapshots.
+ * @param token - Authentication token
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving to list of snapshots
+ * @throws {Error} If authentication token is missing or invalid
  */
-export declare function loadBrowserRuntimeSnapshot({ connection, id, }: {
-    connection: Kernel.IKernelConnection;
-    id: string;
-}): Promise<void>;
-export {};
+export declare const listSnapshots: (token: string, baseUrl?: string) => Promise<SnapshotsListResponse>;
+/**
+ * Get details for a specific runtime snapshot.
+ * @param token - Authentication token
+ * @param snapshotId - The unique identifier of the snapshot
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving to snapshot details wrapped in response
+ * @throws {Error} If authentication token is missing or invalid
+ * @throws {Error} If snapshot ID is missing or invalid
+ */
+export declare const getSnapshot: (token: string, snapshotId: string, baseUrl?: string) => Promise<SnapshotGetResponse>;
+/**
+ * Delete a runtime snapshot.
+ * @param token - Authentication token
+ * @param snapshotId - The unique identifier of the snapshot to delete
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving when deletion is complete
+ * @throws {Error} If authentication token is missing or invalid
+ * @throws {Error} If snapshot ID is missing or invalid
+ */
+export declare const deleteSnapshot: (token: string, snapshotId: string, baseUrl?: string) => Promise<void>;

package/lib/api/runtimes/snapshots.js

@@ -2,149 +2,80 @@
  * Copyright (c) 2023-2025 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-import { KernelExecutor } from '@datalayer/jupyter-react';
-import { createRuntimeSnapshotDownloadURL, uploadRuntimeSnapshot } from '.';
 /**
- * Snapshot a runtime through the frontend and upload it to the cloud.
+ * @module api/runtimes/snapshots
+ * @description Runtime snapshots API functions for the Datalayer platform.
  *
- * Note: You should use this only for browser runtimes.
+ * Provides functions for managing runtime snapshots (saved runtime states).
  */
-export async function createRuntimeSnapshot(props) {
-    const { connection, metadata, onUploadProgress } = props;
-    const dump = await new KernelExecutor({ connection }).execute(GET_RUNTIME_SNAPSHOT_SNIPPET, {
-        storeHistory: false,
+import { requestDatalayerAPI } from '../DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS } from '../constants';
+import { validateToken, validateRequiredString } from '../utils/validation';
+/**
+ * Create a snapshot of a runtime instance.
+ * @param token - Authentication token
+ * @param data - Snapshot creation configuration
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving to the created snapshot response
+ * @throws {Error} If authentication token is missing or invalid
+ */
+export const createSnapshot = async (token, data, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES) => {
+    validateToken(token);
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtime-snapshots`,
+        method: 'POST',
+        token,
+        body: data,
+    });
+};
+/**
+ * List all runtime snapshots.
+ * @param token - Authentication token
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving to list of snapshots
+ * @throws {Error} If authentication token is missing or invalid
+ */
+export const listSnapshots = async (token, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES) => {
+    validateToken(token);
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtime-snapshots`,
+        method: 'GET',
+        token,
     });
-    const serializedData = (dump.get(0)?.data['application/vnd.jupyter.stdout'] ??
-        '');
-    // Convert the data to blob.
-    const bytes = base64ToBytes(serializedData);
-    const file = new Blob([bytes.buffer]);
-    return uploadRuntimeSnapshot({
-        file,
-        metadata,
-        onProgress: onUploadProgress,
+};
+/**
+ * Get details for a specific runtime snapshot.
+ * @param token - Authentication token
+ * @param snapshotId - The unique identifier of the snapshot
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving to snapshot details wrapped in response
+ * @throws {Error} If authentication token is missing or invalid
+ * @throws {Error} If snapshot ID is missing or invalid
+ */
+export const getSnapshot = async (token, snapshotId, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES) => {
+    validateToken(token);
+    validateRequiredString(snapshotId, 'Snapshot ID');
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtime-snapshots/${snapshotId}`,
+        method: 'GET',
+        token,
     });
-}
-function base64ToBytes(base64) {
-    // Taken from https://developer.mozilla.org/en-US/docs/Web/API/Window/btoa#unicode_strings
-    const binString = atob(base64);
-    // @ts-expect-error TypeScript does not like this
-    return Uint8Array.from(binString, m => m.codePointAt(0));
-}
+};
 /**
- * Load a snapshot within a browser kernel.
- *
- * Note: You should use this only for browser kernels.
+ * Delete a runtime snapshot.
+ * @param token - Authentication token
+ * @param snapshotId - The unique identifier of the snapshot to delete
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving when deletion is complete
+ * @throws {Error} If authentication token is missing or invalid
+ * @throws {Error} If snapshot ID is missing or invalid
  */
-export async function loadBrowserRuntimeSnapshot({ connection, id, }) {
-    const downloadURL = createRuntimeSnapshotDownloadURL(id);
-    const response = await fetch(downloadURL);
-    const buffer = await response.arrayBuffer();
-    const base64 = bytesToBase64(new Uint8Array(buffer));
-    await new KernelExecutor({
-        connection,
-    }).execute(getLoadRuntimeSnapshotSnippet(base64), {
-        storeHistory: false,
-        silent: true,
+export const deleteSnapshot = async (token, snapshotId, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES) => {
+    validateToken(token);
+    validateRequiredString(snapshotId, 'Snapshot ID');
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtime-snapshots/${snapshotId}`,
+        method: 'DELETE',
+        token,
     });
-}
-function bytesToBase64(bytes) {
-    // Taken from https://developer.mozilla.org/en-US/docs/Web/API/Window/btoa#unicode_strings
-    const binString = Array.from(bytes, byte => String.fromCodePoint(byte)).join('');
-    return btoa(binString);
-}
-const GET_RUNTIME_SNAPSHOT_SNIPPET = `def _create_snapshot():
-    import logging
-    import os
-    import pickle
-    from base64 import encodebytes
-    from tempfile import TemporaryFile
-    from types import BuiltinFunctionType, BuiltinMethodType, FunctionType, MethodType, MethodWrapperType, ModuleType, TracebackType
-    
-    # print(pickle.DEFAULT_PROTOCOL)
-
-    class NotFound:
-        pass
-
-    missing = NotFound()
-
-    FORBIDDEN_TYPES = [type, BuiltinFunctionType, BuiltinMethodType, FunctionType, MethodType, MethodWrapperType, ModuleType, TracebackType, NotFound]
-    try:
-        from IPython.core.autocall import ExitAutocall
-        from IPython.core.interactiveshell import InteractiveShell
-        FORBIDDEN_TYPES.extend([ExitAutocall, InteractiveShell])
-    except ImportError:
-        pass
-    exclude = tuple(FORBIDDEN_TYPES)
-
-    all = frozenset(filter(lambda n: not n.startswith("_"), globals()))
-
-    line_separator = bytes(os.linesep, "utf-8")
-    with TemporaryFile() as dump:
-        for _n in all:
-            _v = globals().get(_n, missing)
-            
-            if not (
-                isinstance(_v, exclude) or
-                # Special IPython variables
-                (_n == "In" and isinstance(_v, list)) or
-                (_n == "Out" and isinstance(_v, dict))
-            ):
-                try:
-                    dumped_n = _n.encode("utf-8") + line_separator + pickle.dumps(_v) + line_separator + b"\\x00" + line_separator
-                    dump.write(dumped_n)
-                except BaseException as e:
-                    logging.warning("Failed to dump variable [%s ([%s])].", _n, type(_v).__qualname__, exc_info=e)
-                else:
-                    logging.debug("Variable [%s] dumped", _n)
-
-        dump.seek(0)
-        print(encodebytes(dump.read()).decode("ascii"))
-
-_create_snapshot()
-del _create_snapshot
-`;
-function getLoadRuntimeSnapshotSnippet(content) {
-    return `async def _load_snapshot():
-    import os
-    import logging
-    import platform
-    import pickle
-    from base64 import decodebytes
-    is_pyodide = platform.node() == "emscripten"
-
-    snapshot = decodebytes("${content}".encode("ascii"))
-    line_sep = bytes(os.linesep, "utf-8")
-    variable_separator = b"\\x00" + line_sep
-    name = b""
-    value = b""
-    for line in snapshot.splitlines():
-        line += line_sep
-        if line == variable_separator:
-            name_s = name.strip().decode("utf-8")
-            try:
-                try:
-                    globals()[name_s] = pickle.loads(value)
-                except ModuleNotFoundError as m:
-                    if is_pyodide:
-                        import micropip
-                        logging.info(f'Installing %s...', m.name)
-                        await micropip.install(m.name)
-                        globals()[name_s] = pickle.loads(value)
-                    else:
-                        raise m
-            except BaseException as e:
-                logging.warning("Failed to load variable [%s].", name_s, exc_info=e)
-            else:
-                logging.debug("Variable [%s] loaded", name_s)
-
-            name = b""
-            value = b""
-        else:
-            if not name:
-                name = line
-            else:
-                value += line
-await _load_snapshot()
-del _load_snapshot`;
-}
+};

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

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

package/lib/api/spacer/__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('Spacer Healthz Unit Tests', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('ping', () => {
+        it('should successfully ping the service', async () => {
+            const mockResponse = {
+                success: true,
+                message: 'Spacer 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/spacer/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/spacer/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/spacer/__tests__/items.unit.test.d.ts

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

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

@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { items } 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 Items Unit Tests', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('getSpaceItems', () => {
+        const mockGetItemsResponse = {
+            success: true,
+            message: 'Items retrieved successfully',
+            items: [
+                {
+                    id: 'item-1',
+                    type: 'notebook',
+                    space_id: 'space-123',
+                    item_id: 'notebook-456',
+                    name: 'My Notebook',
+                    created_at: '2024-01-01T00:00:00Z',
+                    updated_at: '2024-01-02T00:00:00Z',
+                },
+                {
+                    id: 'item-2',
+                    type: 'lexical',
+                    space_id: 'space-123',
+                    item_id: 'lexical-789',
+                    name: 'My Document',
+                    created_at: '2024-01-01T00:00:00Z',
+                    updated_at: '2024-01-02T00:00:00Z',
+                },
+            ],
+        };
+        it('should successfully get space items', async () => {
+            console.log('Testing get space items...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockGetItemsResponse);
+            const result = await items.getSpaceItems(MOCK_JWT_TOKEN, 'space-123', DEFAULT_SERVICE_URLS.SPACER);
+            expect(mockedRequest).toHaveBeenCalledTimes(1);
+            expect(mockedRequest).toHaveBeenCalledWith({
+                url: `${DEFAULT_SERVICE_URLS.SPACER}${API_BASE_PATHS.SPACER}/spaces/space-123/items`,
+                method: 'GET',
+                token: MOCK_JWT_TOKEN,
+            });
+            expect(result).toEqual(mockGetItemsResponse);
+            expect(result.success).toBe(true);
+            expect(result.items).toHaveLength(2);
+            expect(result.items[0].type).toBe('notebook');
+            expect(result.items[1].type).toBe('lexical');
+            console.log('Space items retrieved successfully');
+        });
+        it('should handle empty items list', async () => {
+            console.log('Testing get space items with empty response...');
+            const emptyResponse = {
+                success: true,
+                message: 'No items found in space',
+                items: [],
+            };
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(emptyResponse);
+            const result = await items.getSpaceItems(MOCK_JWT_TOKEN, 'empty-space', DEFAULT_SERVICE_URLS.SPACER);
+            expect(result).toEqual(emptyResponse);
+            expect(result.items).toHaveLength(0);
+            console.log('Empty items list handled correctly');
+        });
+        it('should use custom base URL when provided', async () => {
+            console.log('Testing get space items with custom base URL...');
+            const customUrl = 'https://custom.spacer.api';
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockGetItemsResponse);
+            await items.getSpaceItems(MOCK_JWT_TOKEN, 'space-123', customUrl);
+            expect(mockedRequest).toHaveBeenCalledWith({
+                url: `${customUrl}${API_BASE_PATHS.SPACER}/spaces/space-123/items`,
+                method: 'GET',
+                token: MOCK_JWT_TOKEN,
+            });
+            console.log('Custom base URL used correctly');
+        });
+        it('should handle API errors during get', async () => {
+            console.log('Testing get space items with API error...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockRejectedValue(new Error('Network error'));
+            await expect(items.getSpaceItems(MOCK_JWT_TOKEN, 'space-123', DEFAULT_SERVICE_URLS.SPACER)).rejects.toThrow('Network error');
+            console.log('API error handled correctly');
+        });
+    });
+    describe('deleteItem', () => {
+        const mockDeleteResponse = {
+            success: true,
+            message: 'Item deleted successfully',
+        };
+        it('should successfully delete an item', async () => {
+            console.log('Testing delete item...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockDeleteResponse);
+            const result = await items.deleteItem(MOCK_JWT_TOKEN, 'item-123', DEFAULT_SERVICE_URLS.SPACER);
+            expect(mockedRequest).toHaveBeenCalledTimes(1);
+            expect(mockedRequest).toHaveBeenCalledWith({
+                url: `${DEFAULT_SERVICE_URLS.SPACER}${API_BASE_PATHS.SPACER}/spaces/items/item-123`,
+                method: 'DELETE',
+                token: MOCK_JWT_TOKEN,
+            });
+            expect(result).toEqual(mockDeleteResponse);
+            expect(result.success).toBe(true);
+            expect(result.message).toBe('Item deleted successfully');
+            console.log('Item deleted successfully');
+        });
+        it('should handle non-existent item deletion', async () => {
+            console.log('Testing delete non-existent item...');
+            const notFoundResponse = {
+                success: false,
+                message: 'Item not found',
+            };
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(notFoundResponse);
+            const result = await items.deleteItem(MOCK_JWT_TOKEN, 'non-existent-item', DEFAULT_SERVICE_URLS.SPACER);
+            expect(result).toEqual(notFoundResponse);
+            expect(result.success).toBe(false);
+            console.log('Non-existent item handled correctly');
+        });
+        it('should use custom base URL when provided', async () => {
+            console.log('Testing delete item with custom base URL...');
+            const customUrl = 'https://custom.spacer.api';
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockDeleteResponse);
+            await items.deleteItem(MOCK_JWT_TOKEN, 'item-123', customUrl);
+            expect(mockedRequest).toHaveBeenCalledWith({
+                url: `${customUrl}${API_BASE_PATHS.SPACER}/spaces/items/item-123`,
+                method: 'DELETE',
+                token: MOCK_JWT_TOKEN,
+            });
+            console.log('Custom base URL used correctly');
+        });
+        it('should handle API errors during deletion', async () => {
+            console.log('Testing delete item with API error...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockRejectedValue(new Error('Network error'));
+            await expect(items.deleteItem(MOCK_JWT_TOKEN, 'item-123', DEFAULT_SERVICE_URLS.SPACER)).rejects.toThrow('Network error');
+            console.log('API error handled correctly');
+        });
+        it('should handle permission denied errors', async () => {
+            console.log('Testing delete item with permission denied...');
+            const permissionDeniedResponse = {
+                success: false,
+                message: 'Permission denied: You do not have permission to delete this item',
+            };
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(permissionDeniedResponse);
+            const result = await items.deleteItem(MOCK_JWT_TOKEN, 'protected-item', DEFAULT_SERVICE_URLS.SPACER);
+            expect(result).toEqual(permissionDeniedResponse);
+            expect(result.success).toBe(false);
+            expect(result.message).toContain('Permission denied');
+            console.log('Permission denied handled correctly');
+        });
+    });
+});

package/lib/api/spacer/__tests__/lexicals.unit.test.d.ts

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