oblien 1.0.7 → 1.1.1

package/src/namespaces/index.js

@@ -0,0 +1,225 @@
+/**
+ * Namespaces Module
+ * Manages namespaces, service configurations, and usage tracking
+ */
+
+import { Namespace } from './namespace.js';
+
+export class OblienNamespaces {
+    /**
+     * @param {import('../client.js').OblienClient} client - Oblien client instance
+     */
+    constructor(client) {
+        if (!client) {
+            throw new Error('Oblien client is required');
+        }
+
+        this.client = client;
+    }
+
+    /**
+     * Create a new namespace
+     * @param {Object} options - Namespace options
+     * @param {string} options.name - Namespace name (required)
+     * @param {string} [options.slug] - URL-friendly slug
+     * @param {string} [options.description] - Description
+     * @param {string} [options.type] - Type: 'default', 'production', 'testing', 'development'
+     * @param {boolean} [options.isDefault] - Is default namespace
+     * @param {Object} [options.metadata] - Custom metadata
+     * @param {Array<string>} [options.tags] - Tags
+     * @param {string} [options.endUserId] - End user ID
+     * @returns {Promise<Object>} Created namespace data
+     */
+    async create(options) {
+        const namespace = new Namespace({ client: this.client });
+        return await namespace.create(options);
+    }
+
+    /**
+     * Get namespace by ID or slug
+     * @param {string} identifier - Namespace ID or slug
+     * @returns {Promise<Object>} Namespace data
+     */
+    async get(identifier) {
+        const namespace = new Namespace({ client: this.client });
+        return await namespace.get(identifier);
+    }
+
+    /**
+     * List all namespaces with filtering and pagination
+     * @param {Object} [options] - Query options
+     * @param {number} [options.limit] - Max results (default: 50, max: 100)
+     * @param {number} [options.offset] - Offset for pagination
+     * @param {string} [options.status] - Filter by status: 'active', 'inactive', 'suspended', 'archived'
+     * @param {string} [options.type] - Filter by type: 'default', 'production', 'testing', 'development'
+     * @param {string} [options.search] - Search in name, slug, description
+     * @param {string} [options.sortBy] - Sort by: 'name', 'created_at', 'updated_at', 'last_active_at'
+     * @param {string} [options.sortOrder] - Sort order: 'ASC', 'DESC'
+     * @returns {Promise<Object>} Namespaces data with pagination info
+     */
+    async list(options = {}) {
+        const response = await this.client.get('namespaces', options);
+        return response;
+    }
+
+    /**
+     * Update namespace
+     * @param {string} namespaceId - Namespace ID
+     * @param {Object} updates - Fields to update
+     * @returns {Promise<Object>} Updated namespace data
+     */
+    async update(namespaceId, updates) {
+        const namespace = new Namespace({ client: this.client, namespaceId });
+        return await namespace.update(updates);
+    }
+
+    /**
+     * Delete (archive) namespace
+     * @param {string} namespaceId - Namespace ID
+     * @returns {Promise<Object>} Deletion result
+     */
+    async delete(namespaceId) {
+        const namespace = new Namespace({ client: this.client, namespaceId });
+        return await namespace.delete();
+    }
+
+    /**
+     * Get namespace activity log
+     * @param {string} namespaceId - Namespace ID
+     * @param {Object} [options] - Query options
+     * @param {number} [options.limit] - Number of activities (default: 50)
+     * @param {number} [options.offset] - Offset for pagination
+     * @returns {Promise<Array>} Array of activity logs
+     */
+    async getActivity(namespaceId, options = {}) {
+        const namespace = new Namespace({ client: this.client, namespaceId });
+        return await namespace.getActivity(options);
+    }
+
+    /**
+     * Get namespace usage statistics
+     * @param {string} namespaceId - Namespace ID
+     * @param {Object} [options] - Query options
+     * @param {string} [options.service] - Filter by service
+     * @param {number} [options.days] - Number of days (default: 30)
+     * @returns {Promise<Object>} Usage statistics
+     */
+    async getUsage(namespaceId, options = {}) {
+        const namespace = new Namespace({ client: this.client, namespaceId });
+        return await namespace.getUsage(options);
+    }
+
+    /**
+     * Get available services
+     * @returns {Promise<Array>} Array of available services
+     */
+    async getAvailableServices() {
+        const response = await this.client.get('namespaces/services/available');
+        return response.data || response;
+    }
+
+    /**
+     * Configure a service for a namespace
+     * @param {string} namespaceId - Namespace ID
+     * @param {Object} options - Service configuration
+     * @param {string} options.service - Service name (required)
+     * @param {boolean} [options.enabled] - Enable/disable service
+     * @param {Object} [options.config] - Service-specific configuration
+     * @param {number} [options.rateLimitRequests] - Rate limit requests
+     * @param {string} [options.rateLimitPeriod] - Rate limit period
+     * @param {Array<string>} [options.features] - Enabled features
+     * @returns {Promise<Object>} Service configuration
+     */
+    async configureService(namespaceId, options) {
+        const namespace = new Namespace({ client: this.client, namespaceId });
+        return await namespace.configureService(options);
+    }
+
+    /**
+     * List all services for a namespace
+     * @param {string} namespaceId - Namespace ID
+     * @returns {Promise<Array>} Array of service configurations
+     */
+    async listServices(namespaceId) {
+        const namespace = new Namespace({ client: this.client, namespaceId });
+        return await namespace.listServices();
+    }
+
+    /**
+     * Get specific service configuration
+     * @param {string} namespaceId - Namespace ID
+     * @param {string} service - Service name
+     * @returns {Promise<Object>} Service configuration
+     */
+    async getServiceConfig(namespaceId, service) {
+        const namespace = new Namespace({ client: this.client, namespaceId });
+        return await namespace.getServiceConfig(service);
+    }
+
+    /**
+     * Toggle service enabled/disabled
+     * @param {string} namespaceId - Namespace ID
+     * @param {string} service - Service name
+     * @param {boolean} enabled - Enable or disable
+     * @returns {Promise<Object>} Updated service configuration
+     */
+    async toggleService(namespaceId, service, enabled) {
+        const namespace = new Namespace({ client: this.client, namespaceId });
+        return await namespace.toggleService(service, enabled);
+    }
+
+    /**
+     * Enable a service for a namespace
+     * @param {string} namespaceId - Namespace ID
+     * @param {string} service - Service name
+     * @returns {Promise<Object>} Updated service configuration
+     */
+    async enableService(namespaceId, service) {
+        return await this.toggleService(namespaceId, service, true);
+    }
+
+    /**
+     * Disable a service for a namespace
+     * @param {string} namespaceId - Namespace ID
+     * @param {string} service - Service name
+     * @returns {Promise<Object>} Updated service configuration
+     */
+    async disableService(namespaceId, service) {
+        return await this.toggleService(namespaceId, service, false);
+    }
+
+    /**
+     * Delete service configuration
+     * @param {string} namespaceId - Namespace ID
+     * @param {string} service - Service name
+     * @returns {Promise<Object>} Deletion result
+     */
+    async deleteService(namespaceId, service) {
+        const namespace = new Namespace({ client: this.client, namespaceId });
+        return await namespace.deleteService(service);
+    }
+
+    /**
+     * Bulk configure multiple services
+     * @param {string} namespaceId - Namespace ID
+     * @param {Array<Object>} services - Array of service configurations
+     * @returns {Promise<Array>} Array of configured services
+     */
+    async bulkConfigureServices(namespaceId, services) {
+        const namespace = new Namespace({ client: this.client, namespaceId });
+        return await namespace.bulkConfigureServices(services);
+    }
+
+    /**
+     * Create a Namespace instance for chaining operations
+     * @param {string} [namespaceId] - Namespace ID
+     * @returns {Namespace} Namespace instance
+     */
+    namespace(namespaceId) {
+        return new Namespace({ client: this.client, namespaceId });
+    }
+}
+
+export { Namespace };
+export default OblienNamespaces;
+

package/src/namespaces/namespace.js

@@ -0,0 +1,274 @@
+/**
+ * Namespace Entity Manager
+ * Manages individual namespace operations
+ */
+
+export class Namespace {
+    /**
+     * @param {Object} options - Namespace options
+     * @param {import('../client.js').OblienClient} options.client - Oblien client instance
+     * @param {string} [options.namespaceId] - Existing namespace ID
+     * @param {Object} [options.data] - Namespace data
+     */
+    constructor(options) {
+        if (!options.client) {
+            throw new Error('Oblien client is required');
+        }
+
+        this.client = options.client;
+        this.namespaceId = options.namespaceId || null;
+        this.data = options.data || null;
+    }
+
+    /**
+     * Create a new namespace
+     * @param {Object} options - Namespace options
+     * @param {string} options.name - Namespace name (required)
+     * @param {string} [options.slug] - URL-friendly slug (auto-generated from name if not provided)
+     * @param {string} [options.description] - Namespace description
+     * @param {string} [options.type] - Type: 'default', 'production', 'testing', 'development'
+     * @param {boolean} [options.isDefault] - Is this the default namespace
+     * @param {Object} [options.metadata] - Custom metadata object
+     * @param {Array<string>} [options.tags] - Array of tags
+     * @param {string} [options.endUserId] - End user ID (creator)
+     * @returns {Promise<Object>} Created namespace data
+     */
+    async create(options) {
+        if (!options.name) {
+            throw new Error('Namespace name is required');
+        }
+
+        const payload = {
+            name: options.name,
+            slug: options.slug,
+            description: options.description,
+            type: options.type || 'default',
+            isDefault: options.isDefault || false,
+            metadata: options.metadata || {},
+            tags: options.tags || [],
+            endUserId: options.endUserId,
+        };
+
+        const response = await this.client.post('namespaces', payload);
+        this.data = response.data;
+        this.namespaceId = this.data.id;
+
+        return this.data;
+    }
+
+    /**
+     * Get namespace details
+     * @param {string} [identifier] - Namespace ID or slug (uses instance namespaceId if not provided)
+     * @returns {Promise<Object>} Namespace data
+     */
+    async get(identifier) {
+        const id = identifier || this.namespaceId;
+        if (!id) {
+            throw new Error('Namespace ID or slug is required');
+        }
+
+        const response = await this.client.get(`namespaces/${id}`);
+        this.data = response.data;
+        this.namespaceId = this.data.id;
+
+        return this.data;
+    }
+
+    /**
+     * Update namespace
+     * @param {Object} updates - Fields to update
+     * @param {string} [updates.name] - New name
+     * @param {string} [updates.description] - New description
+     * @param {string} [updates.status] - New status: 'active', 'inactive', 'suspended', 'archived'
+     * @param {string} [updates.type] - New type
+     * @param {Object} [updates.metadata] - New metadata
+     * @param {Array<string>} [updates.tags] - New tags
+     * @param {string} [namespaceId] - Namespace ID (uses instance namespaceId if not provided)
+     * @returns {Promise<Object>} Updated namespace data
+     */
+    async update(updates, namespaceId) {
+        const id = namespaceId || this.namespaceId;
+        if (!id) {
+            throw new Error('Namespace ID is required');
+        }
+
+        const response = await this.client.put(`namespaces/${id}`, updates);
+        this.data = response.data;
+
+        return this.data;
+    }
+
+    /**
+     * Delete (archive) namespace
+     * @param {string} [namespaceId] - Namespace ID (uses instance namespaceId if not provided)
+     * @returns {Promise<Object>} Deletion result
+     */
+    async delete(namespaceId) {
+        const id = namespaceId || this.namespaceId;
+        if (!id) {
+            throw new Error('Namespace ID is required');
+        }
+
+        return await this.client.delete(`namespaces/${id}`);
+    }
+
+    /**
+     * Get namespace activity log
+     * @param {Object} [options] - Query options
+     * @param {number} [options.limit] - Number of activities to return (default: 50)
+     * @param {number} [options.offset] - Offset for pagination
+     * @param {string} [namespaceId] - Namespace ID (uses instance namespaceId if not provided)
+     * @returns {Promise<Array>} Array of activity logs
+     */
+    async getActivity(options = {}, namespaceId) {
+        const id = namespaceId || this.namespaceId;
+        if (!id) {
+            throw new Error('Namespace ID is required');
+        }
+
+        const response = await this.client.get(`namespaces/${id}/activity`, options);
+        return response.data || response;
+    }
+
+    /**
+     * Get namespace usage statistics
+     * @param {Object} [options] - Query options
+     * @param {string} [options.service] - Filter by specific service
+     * @param {number} [options.days] - Number of days to include (default: 30)
+     * @param {string} [namespaceId] - Namespace ID (uses instance namespaceId if not provided)
+     * @returns {Promise<Object>} Usage statistics
+     */
+    async getUsage(options = {}, namespaceId) {
+        const id = namespaceId || this.namespaceId;
+        if (!id) {
+            throw new Error('Namespace ID is required');
+        }
+
+        const response = await this.client.get(`namespaces/${id}/usage`, options);
+        return response.data || response;
+    }
+
+    /**
+     * Configure a service for this namespace
+     * @param {Object} options - Service configuration
+     * @param {string} options.service - Service name (required)
+     * @param {boolean} [options.enabled] - Enable/disable service
+     * @param {Object} [options.config] - Service-specific configuration
+     * @param {number} [options.rateLimitRequests] - Rate limit requests per period
+     * @param {string} [options.rateLimitPeriod] - Rate limit period: 'minute', 'hour', 'day'
+     * @param {Array<string>} [options.features] - Enabled features
+     * @param {string} [namespaceId] - Namespace ID (uses instance namespaceId if not provided)
+     * @returns {Promise<Object>} Service configuration
+     */
+    async configureService(options, namespaceId) {
+        const id = namespaceId || this.namespaceId;
+        if (!id) {
+            throw new Error('Namespace ID is required');
+        }
+
+        if (!options.service) {
+            throw new Error('Service name is required');
+        }
+
+        const response = await this.client.post(`namespaces/${id}/services`, options);
+        return response.data || response;
+    }
+
+    /**
+     * List all services for this namespace
+     * @param {string} [namespaceId] - Namespace ID (uses instance namespaceId if not provided)
+     * @returns {Promise<Array>} Array of service configurations
+     */
+    async listServices(namespaceId) {
+        const id = namespaceId || this.namespaceId;
+        if (!id) {
+            throw new Error('Namespace ID is required');
+        }
+
+        const response = await this.client.get(`namespaces/${id}/services`);
+        return response.data || response;
+    }
+
+    /**
+     * Get specific service configuration
+     * @param {string} service - Service name
+     * @param {string} [namespaceId] - Namespace ID (uses instance namespaceId if not provided)
+     * @returns {Promise<Object>} Service configuration
+     */
+    async getServiceConfig(service, namespaceId) {
+        const id = namespaceId || this.namespaceId;
+        if (!id) {
+            throw new Error('Namespace ID is required');
+        }
+
+        if (!service) {
+            throw new Error('Service name is required');
+        }
+
+        const response = await this.client.get(`namespaces/${id}/services/${service}`);
+        return response.data || response;
+    }
+
+    /**
+     * Toggle service enabled/disabled
+     * @param {string} service - Service name
+     * @param {boolean} enabled - Enable or disable
+     * @param {string} [namespaceId] - Namespace ID (uses instance namespaceId if not provided)
+     * @returns {Promise<Object>} Updated service configuration
+     */
+    async toggleService(service, enabled, namespaceId) {
+        const id = namespaceId || this.namespaceId;
+        if (!id) {
+            throw new Error('Namespace ID is required');
+        }
+
+        if (!service) {
+            throw new Error('Service name is required');
+        }
+
+        const response = await this.client.patch(`namespaces/${id}/services/${service}/toggle`, { enabled });
+        return response.data || response;
+    }
+
+    /**
+     * Delete service configuration
+     * @param {string} service - Service name
+     * @param {string} [namespaceId] - Namespace ID (uses instance namespaceId if not provided)
+     * @returns {Promise<Object>} Deletion result
+     */
+    async deleteService(service, namespaceId) {
+        const id = namespaceId || this.namespaceId;
+        if (!id) {
+            throw new Error('Namespace ID is required');
+        }
+
+        if (!service) {
+            throw new Error('Service name is required');
+        }
+
+        return await this.client.delete(`namespaces/${id}/services/${service}`);
+    }
+
+    /**
+     * Bulk configure multiple services
+     * @param {Array<Object>} services - Array of service configurations
+     * @param {string} [namespaceId] - Namespace ID (uses instance namespaceId if not provided)
+     * @returns {Promise<Array>} Array of service configurations
+     */
+    async bulkConfigureServices(services, namespaceId) {
+        const id = namespaceId || this.namespaceId;
+        if (!id) {
+            throw new Error('Namespace ID is required');
+        }
+
+        if (!Array.isArray(services)) {
+            throw new Error('Services must be an array');
+        }
+
+        const response = await this.client.post(`namespaces/${id}/services/bulk`, { services });
+        return response.data || response;
+    }
+}
+
+export default Namespace;
+

package/src/sandbox/index.js

@@ -0,0 +1,185 @@
+/**
+ * Sandboxes Module
+ * Manages cloud sandboxes - create, control, monitor
+ */
+
+import { Sandbox } from './sandbox.js';
+
+export class OblienSandboxes {
+    /**
+     * @param {import('../client.js').OblienClient} client - Oblien client instance
+     */
+    constructor(client) {
+        if (!client) {
+            throw new Error('Oblien client is required');
+        }
+
+        this.client = client;
+    }
+
+    /**
+     * Create a new sandbox
+     * @param {Object} options - Sandbox options
+     * @param {string} [options.name] - Sandbox name
+     * @param {string} [options.region='us-east-1'] - Region: 'us-east-1' | 'us-west-1' | 'eu-west-1'
+     * @param {string} [options.template='node-20'] - Template: 'node-20' | 'python-3' | 'blank' | custom
+     * @param {Object} [options.config] - Custom configuration
+     * @param {boolean} [options.autoStart=true] - Auto-start sandbox after creation
+     * @returns {Promise<Object>} Created sandbox data with token
+     */
+    async create(options = {}) {
+        const {
+            name,
+            region = 'us-east-1',
+            template = 'node-20',
+            config,
+            autoStart = true
+        } = options;
+
+        const response = await this.client.post('sandbox', {
+            name,
+            region,
+            template,
+            config,
+            autoStart
+        });
+
+        return response;
+    }
+
+    /**
+     * List all sandboxes with pagination and filtering
+     * @param {Object} [options] - Query options
+     * @param {number} [options.page=1] - Page number
+     * @param {number} [options.limit=20] - Results per page
+     * @param {string} [options.status] - Filter by status: 'active' | 'stopped' | 'suspended' | 'deleted'
+     * @returns {Promise<Object>} Sandboxes data with pagination info
+     */
+    async list(options = {}) {
+        const params = {
+            page: options.page || 1,
+            limit: options.limit || 20
+        };
+
+        if (options.status) {
+            params.status = options.status;
+        }
+
+        const response = await this.client.get('sandbox', params);
+        return response;
+    }
+
+    /**
+     * Get sandbox by ID
+     * @param {string} sandboxId - Sandbox ID
+     * @returns {Promise<Object>} Sandbox data
+     */
+    async get(sandboxId) {
+        if (!sandboxId) {
+            throw new Error('Sandbox ID is required');
+        }
+
+        const sandbox = new Sandbox({ client: this.client, sandboxId });
+        return await sandbox.get();
+    }
+
+    /**
+     * Update sandbox
+     * @param {string} sandboxId - Sandbox ID
+     * @param {Object} updates - Fields to update
+     * @returns {Promise<Object>} Update result
+     */
+    async update(sandboxId, updates) {
+        const sandbox = new Sandbox({ client: this.client, sandboxId });
+        return await sandbox.update(updates);
+    }
+
+    /**
+     * Delete sandbox
+     * @param {string} sandboxId - Sandbox ID
+     * @returns {Promise<Object>} Delete result
+     */
+    async delete(sandboxId) {
+        const sandbox = new Sandbox({ client: this.client, sandboxId });
+        return await sandbox.delete();
+    }
+
+    /**
+     * Start sandbox
+     * @param {string} sandboxId - Sandbox ID
+     * @returns {Promise<Object>} Start result with new token
+     */
+    async start(sandboxId) {
+        const sandbox = new Sandbox({ client: this.client, sandboxId });
+        return await sandbox.start();
+    }
+
+    /**
+     * Stop sandbox
+     * @param {string} sandboxId - Sandbox ID
+     * @returns {Promise<Object>} Stop result
+     */
+    async stop(sandboxId) {
+        const sandbox = new Sandbox({ client: this.client, sandboxId });
+        return await sandbox.stop();
+    }
+
+    /**
+     * Restart sandbox
+     * @param {string} sandboxId - Sandbox ID
+     * @returns {Promise<Object>} Restart result with new token
+     */
+    async restart(sandboxId) {
+        const sandbox = new Sandbox({ client: this.client, sandboxId });
+        return await sandbox.restart();
+    }
+
+    /**
+     * Regenerate sandbox token
+     * @param {string} sandboxId - Sandbox ID
+     * @returns {Promise<Object>} New token (1h expiry)
+     */
+    async regenerateToken(sandboxId) {
+        const sandbox = new Sandbox({ client: this.client, sandboxId });
+        return await sandbox.regenerateToken();
+    }
+
+    /**
+     * Get sandbox metrics
+     * @param {string} sandboxId - Sandbox ID
+     * @returns {Promise<Object>} Sandbox metrics
+     */
+    async getMetrics(sandboxId) {
+        const sandbox = new Sandbox({ client: this.client, sandboxId });
+        return await sandbox.getMetrics();
+    }
+
+    /**
+     * Get sandbox stats (overall statistics)
+     * @returns {Promise<Object>} Sandbox statistics
+     */
+    async getStats() {
+        return await this.client.get('sandbox/stats');
+    }
+
+    /**
+     * Get sandbox activity
+     * @returns {Promise<Object>} Sandbox activity logs
+     */
+    async getActivity() {
+        return await this.client.get('sandbox/activity');
+    }
+
+    /**
+     * Create a Sandbox instance for chaining operations
+     * @param {string} sandboxId - Sandbox ID
+     * @returns {Sandbox} Sandbox instance
+     */
+    sandbox(sandboxId) {
+        return new Sandbox({ client: this.client, sandboxId });
+    }
+}
+
+export { Sandbox };
+export default OblienSandboxes;
+