@datalayer/core 0.0.9 → 0.0.11

package/lib/sdk/client/__tests__/sdk.spacer.integration.test.js

@@ -0,0 +1,361 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { DatalayerSDK } from '..';
+import { Space } from '../models/Space';
+import { Notebook } from '../models/Notebook';
+import { Lexical } from '../models/Lexical';
+import { testConfig } from '../../../__tests__/shared/test-config';
+import { DEFAULT_SERVICE_URLS } from '../../../api/constants';
+import { performCleanup } from '../../../__tests__/shared/cleanup-shared';
+/**
+ * SDK Spacer Integration Tests
+ *
+ * Tests workspace, notebook, and lexical document lifecycle
+ * using the SDK client and model classes.
+ */
+describe('SDK Spacer Integration Tests', () => {
+    let sdk;
+    let testSpace = null;
+    let createdNotebook = null;
+    let createdLexical = null;
+    beforeAll(async () => {
+        if (!testConfig.hasToken()) {
+            return;
+        }
+        await performCleanup('setup');
+        sdk = new DatalayerSDK({
+            token: testConfig.getToken(),
+            iamRunUrl: DEFAULT_SERVICE_URLS.IAM,
+            runtimesRunUrl: DEFAULT_SERVICE_URLS.RUNTIMES,
+            spacerRunUrl: DEFAULT_SERVICE_URLS.SPACER,
+        });
+    });
+    afterAll(async () => {
+        if (!testConfig.hasToken()) {
+            return;
+        }
+        await performCleanup('teardown');
+    }, 30000);
+    describe.skipIf(!testConfig.hasToken())('Space management', () => {
+        it('should get user spaces', async () => {
+            console.log('Getting user spaces...');
+            const spaces = await sdk.getMySpaces();
+            expect(spaces).toBeDefined();
+            expect(Array.isArray(spaces)).toBe(true);
+            expect(spaces.length).toBeGreaterThan(0);
+            const firstSpace = spaces[0];
+            expect(firstSpace).toBeInstanceOf(Space);
+            expect(firstSpace.id || firstSpace.uid).toBeDefined();
+            testSpace = firstSpace;
+            console.log(`Found ${spaces.length} space(s)`);
+            const spaceName = await firstSpace.getName();
+            console.log(`Using space: ${spaceName || firstSpace.id || firstSpace.uid}`);
+        });
+        it('should test space model methods', async () => {
+            if (!testSpace) {
+                throw new Error('Test dependency failed: testSpace should be available from previous test');
+            }
+            console.log('Testing space model methods...');
+            // Test getName method (lazy loading)
+            const name = await testSpace.getName();
+            expect(name).toBeDefined();
+            console.log(`Space name: ${name}`);
+            // Test getDescription method
+            const description = await testSpace.getDescription();
+            console.log(`Space description: ${description || 'None'}`);
+            // Test getUpdatedAt method
+            const updatedAt = await testSpace.getUpdatedAt();
+            if (updatedAt) {
+                expect(updatedAt).toBeInstanceOf(Date);
+                console.log(`Space updated at: ${updatedAt.toISOString()}`);
+            }
+            else {
+                console.log('Space has no update timestamp');
+            }
+            // Test getItems method
+            const items = await testSpace.getItems();
+            expect(Array.isArray(items)).toBe(true);
+            console.log(`Space has ${items.length} item(s)`);
+            // Test toJSON method
+            const json = await testSpace.toJSON();
+            expect(json).toBeDefined();
+            expect(json.id || json.uid).toBeDefined();
+            // Test toString
+            const str = testSpace.toString();
+            expect(str).toContain('Space');
+            console.log(`Space string: ${str}`);
+        });
+        // Space creation is not implemented - removed this test
+    });
+    describe.skipIf(!testConfig.hasToken())('Notebook lifecycle', () => {
+        it('should create a notebook', async () => {
+            if (!testSpace) {
+                throw new Error('Test dependency failed: testSpace should be available from previous test');
+            }
+            console.log('Creating notebook...');
+            const notebook = await sdk.createNotebook({
+                spaceId: testSpace.uid,
+                notebookType: 'jupyter',
+                name: 'sdk-test-notebook-' + Date.now(),
+                description: 'Test notebook from SDK',
+            });
+            expect(notebook).toBeInstanceOf(Notebook);
+            expect(notebook.id).toBeDefined();
+            expect(notebook.spaceId).toBe(testSpace.uid);
+            createdNotebook = notebook;
+            console.log(`Created notebook: ${notebook.id}`);
+            console.log(`  Name: ${await notebook.getName()}`);
+            console.log(`  Space: ${notebook.spaceId}`);
+        });
+        it('should get notebook details', async () => {
+            if (!createdNotebook) {
+                throw new Error('Test dependency failed: notebook should be created in previous test');
+            }
+            console.log('Getting notebook details...');
+            const notebook = await sdk.getNotebook(createdNotebook.uid);
+            expect(notebook).toBeInstanceOf(Notebook);
+            expect(notebook.id).toBe(createdNotebook.id);
+            expect(notebook.spaceId).toBe(createdNotebook.spaceId);
+            console.log(`Retrieved notebook: ${notebook.id}`);
+            const notebookName = await notebook.getName();
+            console.log(`  Name: ${notebookName}`);
+        });
+        it('should update notebook', async () => {
+            if (!createdNotebook) {
+                throw new Error('Test dependency failed: notebook should be created in previous test');
+            }
+            console.log('Updating notebook...');
+            const updatedNotebook = await sdk.updateNotebook(createdNotebook, {
+                name: 'sdk-test-notebook-updated',
+                description: 'Updated description from SDK test',
+            });
+            expect(updatedNotebook).toBeInstanceOf(Notebook);
+            expect(updatedNotebook.id).toBe(createdNotebook.id);
+            console.log(`Updated notebook: ${updatedNotebook.id}`);
+            const updatedNotebookName = await updatedNotebook.getName();
+            console.log(`  New name: ${updatedNotebookName}`);
+        });
+        it('should test notebook model methods', async () => {
+            if (!createdNotebook) {
+                throw new Error('Test dependency failed: notebook should be created in previous test');
+            }
+            console.log('Testing notebook model methods...');
+            // Check the raw data structure (debugging removed)
+            const rawData = await createdNotebook.toJSON();
+            expect(rawData).toBeDefined();
+            // Test getName method (lazy loading)
+            const name = await createdNotebook.getName();
+            expect(name).toBeDefined();
+            console.log(`Notebook name: ${name}`);
+            // Test getContent method
+            const content = await createdNotebook.getContent();
+            console.log(`Notebook has content: ${content !== null}`);
+            // Test getKernelSpec method
+            const kernelSpec = await createdNotebook.getKernelSpec();
+            console.log(`Kernel spec: ${kernelSpec ? JSON.stringify(kernelSpec).substring(0, 50) : 'None'}`);
+            // Test getUpdatedAt method
+            const updatedAt = await createdNotebook.getUpdatedAt();
+            expect(updatedAt).toBeInstanceOf(Date);
+            console.log(`Notebook updated at: ${updatedAt.toISOString()}`);
+            // Skip the update test as the notebook was already updated in the previous test
+            // The API doesn't like rapid successive updates
+            console.log('Skipping model update test (notebook already updated)');
+            // Test toJSON method
+            const json = await createdNotebook.toJSON();
+            expect(json).toBeDefined();
+            expect(json.id).toBe(createdNotebook.id);
+            // Test toString
+            const str = createdNotebook.toString();
+            expect(str).toContain('Notebook');
+            expect(str).toContain(createdNotebook.id);
+            console.log(`Notebook string: ${str}`);
+        });
+        it('should delete notebook', async () => {
+            if (!createdNotebook) {
+                throw new Error('Test dependency failed: notebook should be created in previous test');
+            }
+            console.log('Deleting notebook...');
+            await createdNotebook.delete();
+            console.log(`Notebook deleted successfully`);
+            // Verify deletion
+            expect(createdNotebook.isDeleted).toBe(true);
+            try {
+                await createdNotebook.getName();
+                expect(true).toBe(false); // Should not reach here
+            }
+            catch (error) {
+                expect(error.message).toContain('deleted');
+                console.log('Notebook correctly marked as deleted');
+            }
+        });
+    });
+    describe.skipIf(!testConfig.hasToken())('Lexical document lifecycle', () => {
+        it('should create a lexical document', async () => {
+            if (!testSpace) {
+                throw new Error('Test dependency failed: testSpace should be available from previous test');
+            }
+            console.log('Creating lexical document...');
+            const lexical = await sdk.createLexical({
+                spaceId: testSpace.uid,
+                name: 'sdk-test-lexical-' + Date.now(),
+                description: 'Test lexical from SDK',
+                documentType: 'document',
+            });
+            expect(lexical).toBeInstanceOf(Lexical);
+            expect(lexical.id).toBeDefined();
+            expect(lexical.spaceId).toBe(testSpace.uid);
+            createdLexical = lexical;
+            console.log(`Created lexical: ${lexical.id}`);
+            const lexicalName = await lexical.getName();
+            console.log(`  Name: ${lexicalName}`);
+        });
+        it('should get lexical details', async () => {
+            if (!createdLexical) {
+                throw new Error('Test dependency failed: lexical should be created in previous test');
+            }
+            console.log('Getting lexical details...');
+            const lexical = await sdk.getLexical(createdLexical.uid);
+            expect(lexical).toBeInstanceOf(Lexical);
+            expect(lexical.id).toBe(createdLexical.id);
+            expect(lexical.spaceId).toBe(createdLexical.spaceId);
+            console.log(`Retrieved lexical: ${lexical.id}`);
+            const retrievedLexicalName = await lexical.getName();
+            console.log(`  Name: ${retrievedLexicalName}`);
+        });
+        it('should update lexical', async () => {
+            if (!createdLexical) {
+                throw new Error('Test dependency failed: lexical should be created in previous test');
+            }
+            console.log('Updating lexical...');
+            const updatedLexical = await sdk.updateLexical(createdLexical, {
+                name: 'sdk-test-lexical-updated',
+                description: 'Updated description from SDK test',
+            });
+            expect(updatedLexical).toBeInstanceOf(Lexical);
+            expect(updatedLexical.id).toBe(createdLexical.id);
+            console.log(`Updated lexical: ${updatedLexical.id}`);
+            const updatedLexicalName = await updatedLexical.getName();
+            console.log(`  New name: ${updatedLexicalName}`);
+        });
+        it('should test lexical model methods', async () => {
+            if (!createdLexical) {
+                throw new Error('Test dependency failed: lexical should be created in previous test');
+            }
+            console.log('Testing lexical model methods...');
+            // Check the raw data structure (debugging removed)
+            const rawData = await createdLexical.toJSON();
+            expect(rawData).toBeDefined();
+            // Test getName method (lazy loading)
+            const name = await createdLexical.getName();
+            expect(name).toBeDefined();
+            console.log(`Lexical name: ${name}`);
+            // Test getContent method
+            const content = await createdLexical.getContent();
+            console.log(`Lexical has content: ${content !== null}`);
+            // Test getUpdatedAt method
+            const updatedAt = await createdLexical.getUpdatedAt();
+            expect(updatedAt).toBeInstanceOf(Date);
+            console.log(`Lexical updated at: ${updatedAt.toISOString()}`);
+            // Skip the update test as the lexical was already updated in the previous test
+            // The API doesn't like rapid successive updates
+            console.log('Skipping model update test (lexical already updated)');
+            // Test toJSON method
+            const json = await createdLexical.toJSON();
+            expect(json).toBeDefined();
+            expect(json.id).toBe(createdLexical.id);
+            // Test toString
+            const str = createdLexical.toString();
+            expect(str).toContain('Lexical');
+            expect(str).toContain(createdLexical.id);
+            console.log(`Lexical string: ${str}`);
+        });
+        it('should delete lexical document', async () => {
+            if (!createdLexical) {
+                throw new Error('Test dependency failed: lexical should be created in previous test');
+            }
+            console.log('Deleting lexical...');
+            await createdLexical.delete();
+            console.log(`Lexical deleted successfully`);
+            // Verify deletion
+            expect(createdLexical.isDeleted).toBe(true);
+            try {
+                await createdLexical.getName();
+                expect(true).toBe(false); // Should not reach here
+            }
+            catch (error) {
+                expect(error.message).toContain('deleted');
+                console.log('Lexical correctly marked as deleted');
+            }
+        });
+    });
+    describe.skipIf(!testConfig.hasToken())('Space items management', () => {
+        it('should get space items', async () => {
+            if (!testSpace) {
+                throw new Error('Test dependency failed: testSpace should be available from previous test');
+            }
+            console.log('Getting space items...');
+            const response = await sdk.getSpaceItems(testSpace.uid);
+            expect(response).toBeDefined();
+            expect(response.items).toBeDefined();
+            expect(Array.isArray(response.items)).toBe(true);
+            console.log(`Space has ${response.items.length} item(s)`);
+            if (response.items.length > 0) {
+                const firstItem = response.items[0];
+                console.log(`First item: ${firstItem.name} (${firstItem.type})`);
+            }
+        });
+        it('should delete space item', async () => {
+            // Note: We don't actually delete items here as they might be important
+            // This just tests the method exists and can be called
+            console.log('Testing space item deletion (dry run)...');
+            // We would normally create a test item and delete it
+            // For now, just verify the method exists
+            expect(sdk.deleteSpaceItem).toBeDefined();
+            console.log('Space item deletion method verified');
+        });
+    });
+    describe.skipIf(!testConfig.hasToken())('Error handling', () => {
+        it('should handle non-existent notebook gracefully', async () => {
+            console.log('Testing non-existent notebook...');
+            try {
+                await sdk.getNotebook('non-existent-notebook-id');
+                expect(true).toBe(false); // Should not reach here
+            }
+            catch (error) {
+                expect(error).toBeDefined();
+                console.log('Non-existent notebook error handled correctly');
+            }
+        });
+        it('should handle non-existent lexical gracefully', async () => {
+            console.log('Testing non-existent lexical...');
+            try {
+                await sdk.getLexical('non-existent-lexical-id');
+                expect(true).toBe(false); // Should not reach here
+            }
+            catch (error) {
+                expect(error).toBeDefined();
+                console.log('Non-existent lexical error handled correctly');
+            }
+        });
+        it('should validate notebook creation parameters', async () => {
+            console.log('Testing invalid notebook creation...');
+            try {
+                // Missing required fields
+                await sdk.createNotebook({
+                    spaceId: '', // Invalid empty spaceId
+                    notebookType: 'jupyter',
+                    name: 'test',
+                    description: 'test description',
+                });
+                expect(true).toBe(false); // Should not reach here
+            }
+            catch (error) {
+                expect(error).toBeDefined();
+                console.log('Invalid notebook parameters rejected');
+            }
+        });
+    });
+});

package/lib/sdk/client/base.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Configuration options for the Datalayer SDK.
+ */
+export interface DatalayerSDKConfig {
+    /** Authentication token for API requests. */
+    token?: string;
+    /** URL for the IAM (Identity and Access Management) service. */
+    iamRunUrl?: string;
+    /** URL for the Runtimes service. */
+    runtimesRunUrl?: string;
+    /** URL for the Spacer (workspaces and collaboration) service. */
+    spacerRunUrl?: string;
+}
+/**
+ * Base SDK class that provides core configuration and token management.
+ *
+ * This class serves as the foundation for the DatalayerSDK, handling
+ * authentication tokens, service URL configuration, and other common
+ * SDK functionality that all mixins can access.
+ */
+export declare class DatalayerSDKBase {
+    /** URL for IAM service */
+    readonly iamRunUrl: string;
+    /** URL for Runtimes service */
+    readonly runtimesRunUrl: string;
+    /** URL for Spacer service */
+    readonly spacerRunUrl: string;
+    /** Authentication token */
+    token?: string;
+    /**
+     * Create a DatalayerSDK base instance.
+     *
+     * @param config - SDK configuration options
+     */
+    constructor(config: DatalayerSDKConfig);
+    /**
+     * Update the authentication token for all API requests.
+     *
+     * This method updates the token that will be used for all subsequent
+     * API calls made through the SDK.
+     *
+     * @param token - New authentication token
+     *
+     * @example
+     * ```typescript
+     * // After login, update the SDK with the new token
+     * const loginResponse = await sdk.login(credentials);
+     * sdk.updateToken(loginResponse.access_token);
+     * ```
+     */
+    updateToken(token: string): void;
+    /**
+     * Get the current configuration including service URLs and token.
+     *
+     * @returns The current configuration
+     */
+    getConfig(): DatalayerSDKConfig;
+    /**
+     * Update the configuration for API requests.
+     *
+     * @param config - Configuration updates
+     */
+    updateConfig(config: Partial<DatalayerSDKConfig>): void;
+    /**
+     * Get the IAM service URL for API requests.
+     *
+     * @returns The IAM service URL
+     */
+    getIamRunUrl(): string;
+    /**
+     * Get the Runtimes service URL for API requests.
+     *
+     * @returns The Runtimes service URL
+     */
+    getRuntimesRunUrl(): string;
+    /**
+     * Get the Spacer service URL for API requests.
+     *
+     * @returns The Spacer service URL
+     */
+    getSpacerRunUrl(): string;
+    /**
+     * Get the current authentication token.
+     *
+     * @returns The authentication token
+     */
+    getToken(): string | undefined;
+}

package/lib/sdk/client/base.js

@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module sdk/client/base
+ * @description Base SDK class providing core configuration and token management.
+ */
+import { DEFAULT_SERVICE_URLS } from '../../api/constants';
+/**
+ * Base SDK class that provides core configuration and token management.
+ *
+ * This class serves as the foundation for the DatalayerSDK, handling
+ * authentication tokens, service URL configuration, and other common
+ * SDK functionality that all mixins can access.
+ */
+export class DatalayerSDKBase {
+    /** URL for IAM service */
+    iamRunUrl;
+    /** URL for Runtimes service */
+    runtimesRunUrl;
+    /** URL for Spacer service */
+    spacerRunUrl;
+    /** Authentication token */
+    token;
+    /**
+     * Create a DatalayerSDK base instance.
+     *
+     * @param config - SDK configuration options
+     */
+    constructor(config) {
+        this.iamRunUrl = config.iamRunUrl || DEFAULT_SERVICE_URLS.IAM;
+        this.runtimesRunUrl =
+            config.runtimesRunUrl || DEFAULT_SERVICE_URLS.RUNTIMES;
+        this.spacerRunUrl = config.spacerRunUrl || DEFAULT_SERVICE_URLS.SPACER;
+        this.token = config.token;
+    }
+    /**
+     * Update the authentication token for all API requests.
+     *
+     * This method updates the token that will be used for all subsequent
+     * API calls made through the SDK.
+     *
+     * @param token - New authentication token
+     *
+     * @example
+     * ```typescript
+     * // After login, update the SDK with the new token
+     * const loginResponse = await sdk.login(credentials);
+     * sdk.updateToken(loginResponse.access_token);
+     * ```
+     */
+    updateToken(token) {
+        this.token = token;
+    }
+    /**
+     * Get the current configuration including service URLs and token.
+     *
+     * @returns The current configuration
+     */
+    getConfig() {
+        return {
+            iamRunUrl: this.iamRunUrl,
+            runtimesRunUrl: this.runtimesRunUrl,
+            spacerRunUrl: this.spacerRunUrl,
+            token: this.token,
+        };
+    }
+    /**
+     * Update the configuration for API requests.
+     *
+     * @param config - Configuration updates
+     */
+    updateConfig(config) {
+        if (config.token !== undefined) {
+            this.updateToken(config.token);
+        }
+        // Note: service URLs cannot be changed after initialization
+    }
+    /**
+     * Get the IAM service URL for API requests.
+     *
+     * @returns The IAM service URL
+     */
+    getIamRunUrl() {
+        return this.iamRunUrl;
+    }
+    /**
+     * Get the Runtimes service URL for API requests.
+     *
+     * @returns The Runtimes service URL
+     */
+    getRuntimesRunUrl() {
+        return this.runtimesRunUrl;
+    }
+    /**
+     * Get the Spacer service URL for API requests.
+     *
+     * @returns The Spacer service URL
+     */
+    getSpacerRunUrl() {
+        return this.spacerRunUrl;
+    }
+    /**
+     * Get the current authentication token.
+     *
+     * @returns The authentication token
+     */
+    getToken() {
+        return this.token;
+    }
+}