oblien 1.3.0 → 2.0.1

package/src/namespaces/index.js

@@ -1,236 +0,0 @@
-/**
- * Namespaces Module
- * Manages namespaces, service configurations, and usage tracking
- */
-
-import { OblienClient } from '../client.js';
-import { Namespace } from './namespace.js';
-
-export class OblienNamespaces {
-    /**
-     * @param {import('../client.js').OblienClient|Object} clientOrConfig - Oblien client instance or { clientId, clientSecret }
-     */
-    constructor(clientOrConfig) {
-        if (!clientOrConfig) {
-            throw new Error('Either provide OblienClient instance or { clientId, clientSecret }');
-        }
-
-        // If it's already a client instance
-        if (clientOrConfig.clientId && clientOrConfig.clientSecret && typeof clientOrConfig.get === 'function') {
-            this.client = clientOrConfig;
-        }
-        // If credentials provided, create client
-        else if (clientOrConfig.clientId && clientOrConfig.clientSecret) {
-            this.client = new OblienClient(clientOrConfig);
-        }
-        else {
-            throw new Error('Either provide OblienClient instance or { clientId, clientSecret }');
-        }
-    }
-
-    /**
-     * 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

@@ -1,274 +0,0 @@
-/**
- * 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/core/api/base.js

@@ -1,89 +0,0 @@
-import * as http from '../utils/http.js';
-
-/**
- * Base API class that handles authentication and common request logic
- * Token is resolved dynamically from the parent client
- */
-export class BaseAPI {
-  /**
-   * @param {Object} client - Parent client with getToken() and getBaseURL() methods
-   */
-  constructor(client) {
-    this.client = client;
-  }
-
-  /**
-   * Get base URL from client
-   * @returns {string}
-   */
-  get baseURL() {
-    const url = this.client.getBaseURL();
-    return url ? url.replace(/\/$/, '') : '';
-  }
-
-  /**
-   * Get token from client (supports async fetching)
-   * @returns {Promise<string>}
-   */
-  async getToken() {
-    return await this.client.getToken();
-  }
-
-  /**
-   * Get headers with authentication
-   * @returns {Promise<Object>} Headers object
-   */
-  async getHeaders() {
-    const token = await this.getToken();
-    return {
-      'Authorization': `Bearer ${token}`,
-    };
-  }
-
-  /**
-   * Make a GET request
-   * @param {string} path - API path
-   * @returns {Promise<any>} Response data
-   */
-  async get(path) {
-    const url = `${this.baseURL}${path}`;
-    const headers = await this.getHeaders();
-    return http.get(url, headers);
-  }
-
-  /**
-   * Make a POST request
-   * @param {string} path - API path
-   * @param {Object} body - Request body
-   * @returns {Promise<any>} Response data
-   */
-  async post(path, body = {}) {
-    const url = `${this.baseURL}${path}`;
-    const headers = await this.getHeaders();
-    return http.post(url, body, headers);
-  }
-
-  /**
-   * Make a PUT request
-   * @param {string} path - API path
-   * @param {Object} body - Request body
-   * @returns {Promise<any>} Response data
-   */
-  async put(path, body = {}) {
-    const url = `${this.baseURL}${path}`;
-    const headers = await this.getHeaders();
-    return http.put(url, body, headers);
-  }
-
-  /**
-   * Make a DELETE request
-   * @param {string} path - API path
-   * @returns {Promise<any>} Response data
-   */
-  async delete(path) {
-    const url = `${this.baseURL}${path}`;
-    const headers = await this.getHeaders();
-    return http.del(url, headers);
-  }
-}
-