@flui-cloud/cli 0.0.1

package/lib/src/modules/management/repositories/provider-configuration.repository.d.ts

@@ -0,0 +1,21 @@
+import { Repository } from 'typeorm';
+import { ProviderConfigurationEntity } from '../entities/provider-configuration.entity';
+import { CloudProvider } from '../../providers/enums/cloud-provider.enum';
+import { ProviderStatus } from '../entities/provider-status.enum';
+import { IProviderConfigurationRepository } from '../interfaces/provider-configuration.repository.interface';
+export declare class ProviderConfigurationRepository implements IProviderConfigurationRepository {
+    private readonly repository;
+    constructor(repository: Repository<ProviderConfigurationEntity>);
+    findAll(): Promise<ProviderConfigurationEntity[]>;
+    findByProvider(provider: CloudProvider): Promise<ProviderConfigurationEntity | null>;
+    findByStatus(status: ProviderStatus): Promise<ProviderConfigurationEntity[]>;
+    findActiveProviders(): Promise<ProviderConfigurationEntity[]>;
+    create(config: Partial<ProviderConfigurationEntity>): Promise<ProviderConfigurationEntity>;
+    update(id: string, updates: Partial<ProviderConfigurationEntity>): Promise<ProviderConfigurationEntity>;
+    delete(id: string): Promise<void>;
+    updateHealthCheck(id: string, healthData: {
+        lastHealthCheck: Date;
+        metadata?: Record<string, any>;
+    }): Promise<void>;
+    findById(id: string): Promise<ProviderConfigurationEntity | null>;
+}

package/lib/src/modules/management/repositories/provider-configuration.repository.js

@@ -0,0 +1,89 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderConfigurationRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const provider_configuration_entity_1 = require("../entities/provider-configuration.entity");
+const provider_status_enum_1 = require("../entities/provider-status.enum");
+let ProviderConfigurationRepository = class ProviderConfigurationRepository {
+    constructor(repository) {
+        this.repository = repository;
+    }
+    async findAll() {
+        return this.repository.find({
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByProvider(provider) {
+        return this.repository.findOne({
+            where: { provider },
+        });
+    }
+    async findByStatus(status) {
+        return this.repository.find({
+            where: { status },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findActiveProviders() {
+        return this.repository.find({
+            where: {
+                isActive: true,
+                status: provider_status_enum_1.ProviderStatus.ACTIVE,
+            },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async create(config) {
+        const newConfig = this.repository.create(config);
+        return this.repository.save(newConfig);
+    }
+    async update(id, updates) {
+        await this.repository.update(id, updates);
+        const updated = await this.repository.findOne({ where: { id } });
+        if (!updated) {
+            throw new Error(`Provider configuration with ID ${id} not found`);
+        }
+        return updated;
+    }
+    async delete(id) {
+        await this.repository.delete(id);
+    }
+    async updateHealthCheck(id, healthData) {
+        const updateData = {
+            lastHealthCheck: healthData.lastHealthCheck,
+        };
+        if (healthData.metadata) {
+            const existing = await this.repository.findOne({ where: { id } });
+            updateData.metadata = {
+                ...existing?.metadata,
+                ...healthData.metadata,
+            };
+        }
+        await this.repository.update(id, updateData);
+    }
+    async findById(id) {
+        return this.repository.findOne({
+            where: { id },
+        });
+    }
+};
+exports.ProviderConfigurationRepository = ProviderConfigurationRepository;
+exports.ProviderConfigurationRepository = ProviderConfigurationRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(provider_configuration_entity_1.ProviderConfigurationEntity)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], ProviderConfigurationRepository);

package/lib/src/modules/management/services/configuration-mode.service.d.ts

@@ -0,0 +1,20 @@
+import { ConfigService } from '@nestjs/config';
+export type ConfigurationMode = 'hosted' | 'self-hosted';
+export interface ConfigurationCapabilities {
+    mode: ConfigurationMode;
+    features: {
+        providerManagement: boolean;
+        credentialStorage: boolean;
+        multiProvider: boolean;
+        costOptimization: boolean;
+        support: 'community' | 'email' | 'priority';
+    };
+}
+export declare class ConfigurationModeService {
+    private readonly configService;
+    constructor(configService: ConfigService);
+    getCurrentMode(): ConfigurationMode;
+    getCapabilities(): ConfigurationCapabilities;
+    isHostedMode(): boolean;
+    isSelfHostedMode(): boolean;
+}

package/lib/src/modules/management/services/configuration-mode.service.js

@@ -0,0 +1,54 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationModeService = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+let ConfigurationModeService = class ConfigurationModeService {
+    constructor(configService) {
+        this.configService = configService;
+    }
+    getCurrentMode() {
+        return this.configService.get('CONFIGURATION_MODE', 'self-hosted');
+    }
+    getCapabilities() {
+        const mode = this.getCurrentMode();
+        return {
+            mode,
+            features: mode === 'hosted'
+                ? {
+                    providerManagement: false,
+                    credentialStorage: false,
+                    multiProvider: true,
+                    costOptimization: true,
+                    support: 'priority',
+                }
+                : {
+                    providerManagement: true,
+                    credentialStorage: true,
+                    multiProvider: true,
+                    costOptimization: false,
+                    support: 'community',
+                },
+        };
+    }
+    isHostedMode() {
+        return this.getCurrentMode() === 'hosted';
+    }
+    isSelfHostedMode() {
+        return this.getCurrentMode() === 'self-hosted';
+    }
+};
+exports.ConfigurationModeService = ConfigurationModeService;
+exports.ConfigurationModeService = ConfigurationModeService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_1.ConfigService])
+], ConfigurationModeService);

package/lib/src/modules/management/services/management.service.d.ts

@@ -0,0 +1,72 @@
+import { ProviderDefinitionsService } from './provider-definitions.service';
+import { ConfigurationModeService } from './configuration-mode.service';
+import { ProviderConfigurationRepository } from '../repositories/provider-configuration.repository';
+import { AccessService } from '../../access/services/access.service';
+import { CloudProvider } from '../../providers/enums/cloud-provider.enum';
+import { ProviderDefinition } from '../entities/provider-definition.entity';
+import { ProviderConfigurationDto } from '../dto/provider-configuration.dto';
+import { ConfigureProviderDto } from '../dto/configure-provider.dto';
+import { ProviderFiltersDto } from '../dto/provider-filters.dto';
+import { ValidationResultDto } from '../dto/validation-result.dto';
+import { HealthStatusDto } from '../dto/health-status.dto';
+import { ProviderCredentialsDto } from '../dto/credentials.dto';
+import { ProviderFactory } from '../../../modules/providers/services/provider.factory';
+import { CapabilitiesProviderFactory } from '../../../modules/providers/core/factories/capabilities-provider.factory';
+import { NodeSizeOptionDto } from '../dto/node-size-option.dto';
+import { PricingQueryDto } from '../dto/pricing-query.dto';
+import { PricingResponseDto } from '../dto/pricing-response.dto';
+import { CacheService } from '../../../modules/common/cache/cache.service';
+export declare class ManagementService {
+    private readonly providerDefinitions;
+    private readonly configurationMode;
+    private readonly providerConfigRepo;
+    private readonly accessService;
+    private readonly providerFactory;
+    private readonly capabilitiesFactory;
+    private readonly cacheService;
+    private readonly logger;
+    constructor(providerDefinitions: ProviderDefinitionsService, configurationMode: ConfigurationModeService, providerConfigRepo: ProviderConfigurationRepository, accessService: AccessService, providerFactory: ProviderFactory, capabilitiesFactory: CapabilitiesProviderFactory, cacheService: CacheService);
+    getAvailableProviders(): Promise<ProviderDefinition[]>;
+    getProvider(provider: CloudProvider): Promise<ProviderDefinition>;
+    getProviderLogo(provider: CloudProvider): {
+        data: Buffer;
+        contentType: string;
+    };
+    getUserProviderConfigurations(filters?: ProviderFiltersDto): Promise<ProviderConfigurationDto[]>;
+    getProviderConfiguration(provider: CloudProvider): Promise<ProviderConfigurationDto>;
+    configureProvider(configDto: ConfigureProviderDto): Promise<ProviderConfigurationDto>;
+    validateProvider(provider: CloudProvider, credentials: ProviderCredentialsDto): Promise<ValidationResultDto>;
+    enableProvider(provider: CloudProvider, enabled: boolean): Promise<ProviderConfigurationDto>;
+    getProviderHealth(provider: CloudProvider): Promise<HealthStatusDto>;
+    getProviderRegions(provider: CloudProvider): Promise<import("../entities/provider-region.entity").ProviderRegion[]>;
+    getProviderInstanceTypes(provider: CloudProvider): Promise<import("../../providers/interfaces/provider-capabilities.interface").InstanceTypeInfo[]>;
+    getConfigurationMode(): Promise<{
+        mode: import("./configuration-mode.service").ConfigurationMode;
+        capabilities: import("./configuration-mode.service").ConfigurationCapabilities;
+    }>;
+    private enrichConfigurationsWithProviderData;
+    rotateProviderCredentials(provider: CloudProvider, credentials: ProviderCredentialsDto): Promise<ProviderConfigurationDto>;
+    updateProviderCredentialsExpiry(provider: CloudProvider, expiresAt: Date | null): Promise<ProviderConfigurationDto>;
+    updateProviderRegions(provider: CloudProvider, enabledRegions: string[]): Promise<ProviderConfigurationDto>;
+    private storeProviderCredentials;
+    private validateProviderCredentials;
+    private getMaskedCredentials;
+    removeProviderConfiguration(configId: string): Promise<void>;
+    /**
+     * Get available node sizes (server types) for a provider
+     * Uses partial caching strategy:
+     * - Server type metadata (CPU, RAM, prices, etc.) is cached for 24 hours
+     * - Real-time availability is ALWAYS fetched fresh (not cached)
+     * Optionally filtered by region to show only available server types in that location
+     */
+    getNodeSizes(provider: CloudProvider, region?: string, skipCache?: boolean): Promise<NodeSizeOptionDto[]>;
+    /**
+     * Get pricing information for a provider
+     * Cached for 24 hours (CONFIGURATION category)
+     */
+    getPricing(provider: CloudProvider, query: PricingQueryDto, skipCache?: boolean): Promise<PricingResponseDto>;
+    /**
+     * Clear node sizes cache for a specific provider
+     */
+    clearNodeSizesCache(provider: CloudProvider): Promise<void>;
+}