@datalayer/core 0.0.12 → 0.0.14

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

@@ -1,361 +0,0 @@
-/*
- * 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

@@ -1,88 +0,0 @@
-/**
- * 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

@@ -1,112 +0,0 @@
-/*
- * 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;
-    }
-}