typekro 0.14.0 → 0.15.0

package/dist/core/deployment/strategies/alchemy-strategy.d.ts

@@ -1,109 +0,0 @@
-/**
- * Alchemy Deployment Strategy
- *
- * This module provides the alchemy deployment strategy that wraps deployments
- * in alchemy resources with individual resource registration.
- */
-import type { DeploymentResult, FactoryOptions } from '../../types/deployment.js';
-import type { KubernetesResource } from '../../types/kubernetes.js';
-import type { KroCompatibleType, SchemaDefinition, Scope, StatusBuilder } from '../../types/serialization.js';
-import { BaseDeploymentStrategy, type DeploymentStrategy } from './base-strategy.js';
-/**
- * Alchemy deployment strategy - wraps deployments in alchemy resources with individual resource registration
- *
- * This strategy implements individual resource registration for Direct mode Alchemy integration.
- * Unlike Kro mode which registers RGDs and instances, Direct mode registers each individual
- * Kubernetes resource (Deployment, Service, ConfigMap, etc.) as separate Alchemy resource types.
- *
- * ## Resource Registration Pattern
- *
- * **Direct Mode (this strategy):**
- * - Each individual Kubernetes resource gets its own Alchemy resource type registration
- * - Resource types are named using the pattern `kubernetes::{Kind}` (e.g., `kubernetes::Deployment`)
- * - Each instance of each resource gets a separate Alchemy resource registered
- * - Example: A webapp with Deployment + Service creates 2 Alchemy resource types and 2 resource instances
- *
- * **Kro Mode (for comparison):**
- * - Each RGD gets one Alchemy resource type registered (`kro::ResourceGraphDefinition`)
- * - Each instance of each RGD gets a separate Alchemy resource registered (`kro::{Kind}`)
- * - Example: A webapp RGD creates 1 RGD type + 1 instance type = 2 Alchemy resources total
- *
- * ## Error Handling
- *
- * The strategy implements robust error handling for individual resource failures:
- * - Continues processing remaining resources when individual resources fail
- * - Collects all errors and includes them in the final DeploymentResult
- * - Sets deployment status to 'partial' when some resources succeed and others fail
- * - Provides resource-specific error context including kind, name, namespace, and Alchemy resource type
- *
- * ## Integration with DirectTypeKroDeployer
- *
- * This strategy integrates with DirectTypeKroDeployer for actual resource deployment:
- * - Extracts DirectDeploymentEngine from the base DirectDeploymentStrategy
- * - Creates DirectTypeKroDeployer instance for individual resource deployments
- * - Passes deployer to each Alchemy resource provider for deployment execution
- *
- * @template TSpec - The specification type for the resource
- * @template TStatus - The status type for the resource
- */
-export declare class AlchemyDeploymentStrategy<TSpec extends KroCompatibleType, TStatus extends KroCompatibleType> extends BaseDeploymentStrategy<TSpec, TStatus> {
-    private alchemyScope;
-    private baseStrategy;
-    protected readonly alchemyLogger: import("../../logging/types.js").TypeKroLogger;
-    constructor(factoryName: string, namespace: string, schemaDefinition: SchemaDefinition<TSpec, TStatus>, statusBuilder: StatusBuilder<TSpec, TStatus, any> | undefined, resourceKeys: Record<string, KubernetesResource> | undefined, factoryOptions: FactoryOptions, alchemyScope: Scope, baseStrategy: DeploymentStrategy<TSpec, TStatus>);
-    /**
-     * Execute deployment with individual resource registration for Alchemy integration
-     *
-     * This method implements the core logic for Direct mode Alchemy integration:
-     *
-     * ## Process Overview
-     * 1. **Validation**: Validates the Alchemy scope is available and properly configured
-     * 2. **Resource Graph Creation**: Gets the resource graph from the base strategy using createResourceGraphForInstance
-     * 3. **Deployer Setup**: Creates DirectTypeKroDeployer instance using DirectDeploymentEngine from base strategy
-     * 4. **Individual Registration**: Processes each resource in the resource graph individually for Alchemy registration
-     * 5. **Error Collection**: Continues processing remaining resources when individual resources fail
-     * 6. **Result Creation**: Creates comprehensive DeploymentResult with individual resource tracking
-     *
-     * ## Individual Resource Processing
-     *
-     * For each resource in the resource graph:
-     * - **Type Inference**: Infers Alchemy resource type from Kubernetes kind (e.g., `kubernetes::Deployment`)
-     * - **Type Registration**: Calls ensureResourceTypeRegistered to register the resource type (shared across instances)
-     * - **ID Generation**: Creates unique resource ID using createAlchemyResourceId with namespace and resource info
-     * - **Deployment**: Deploys the resource through Alchemy using the resource provider and DirectTypeKroDeployer
-     * - **Tracking**: Tracks deployed resource with Alchemy metadata (resource ID, type, etc.)
-     *
-     * ## Error Handling Strategy
-     *
-     * The method implements robust error handling:
-     * - **Continue on Failure**: Individual resource failures don't stop processing of remaining resources
-     * - **Error Collection**: All errors are collected with detailed context about which resource failed
-     * - **Resource Context**: Error messages include resource kind, name, namespace, and Alchemy resource type
-     * - **Partial Status**: Deployment status is set to 'partial' when some resources succeed and others fail
-     *
-     * ## Resource Type Naming
-     *
-     * Resource types follow consistent naming patterns:
-     * - **Kubernetes Resources**: `kubernetes::{Kind}` (e.g., `kubernetes::Deployment`, `kubernetes::Service`)
-     * - **Shared Types**: Multiple instances of the same resource type share the same Alchemy resource type registration
-     * - **Unique IDs**: Each resource instance gets a unique Alchemy resource ID for individual tracking
-     *
-     * @param spec - The resource specification to deploy
-     * @param instanceName - The name of this specific instance
-     * @returns Promise<DeploymentResult> - Comprehensive deployment result with individual resource tracking
-     * @throws Error - If Alchemy scope validation fails or critical deployment errors occur
-     */
-    protected executeDeployment(spec: TSpec, instanceName: string, opts?: import('./base-strategy.js').DeployStrategyOptions): Promise<DeploymentResult>;
-    private executeBaseDirectDeployment;
-    private rollbackBaseDirectDeployment;
-    protected getStrategyMode(): 'direct' | 'kro';
-    /**
-     * Create resource graph for instance using base strategy logic
-     */
-    private createResourceGraphForInstance;
-    /**
-     * Extract serializable kubeConfig options from factory options
-     */
-    private extractKubeConfigOptions;
-}
-//# sourceMappingURL=alchemy-strategy.d.ts.map

package/dist/core/deployment/strategies/alchemy-strategy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"alchemy-strategy.d.ts","sourceRoot":"","sources":["../../../../src/core/deployment/strategies/alchemy-strategy.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,OAAO,KAAK,EAGV,gBAAgB,EAChB,cAAc,EACf,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,EACL,aAAa,EACd,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAAE,sBAAsB,EAAE,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAGrF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBAAa,yBAAyB,CACpC,KAAK,SAAS,iBAAiB,EAC/B,OAAO,SAAS,iBAAiB,CACjC,SAAQ,sBAAsB,CAAC,KAAK,EAAE,OAAO,CAAC;IAW5C,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,YAAY;IAXtB,SAAS,CAAC,QAAQ,CAAC,aAAa,iDAAqD;gBAGnF,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,gBAAgB,EAAE,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,EAElD,aAAa,EAAE,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,GAAG,SAAS,EAC7D,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,GAAG,SAAS,EAC5D,cAAc,EAAE,cAAc,EACtB,YAAY,EAAE,KAAK,EACnB,YAAY,EAAE,kBAAkB,CAAC,KAAK,EAAE,OAAO,CAAC;IAK1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;cACa,iBAAiB,CAC/B,IAAI,EAAE,KAAK,EACX,YAAY,EAAE,MAAM,EACpB,IAAI,CAAC,EAAE,OAAO,oBAAoB,EAAE,qBAAqB,GACxD,OAAO,CAAC,gBAAgB,CAAC;YA0Pd,2BAA2B;YAoB3B,4BAA4B;IA+B1C,SAAS,CAAC,eAAe,IAAI,QAAQ,GAAG,KAAK;IAI7C;;OAEG;IACH,OAAO,CAAC,8BAA8B;IAuDtC;;OAEG;IACH,OAAO,CAAC,wBAAwB;CAwKjC"}

package/dist/core/deployment/strategies/alchemy-strategy.js

@@ -1,556 +0,0 @@
-/**
- * Alchemy Deployment Strategy
- *
- * This module provides the alchemy deployment strategy that wraps deployments
- * in alchemy resources with individual resource registration.
- */
-import { DEFAULT_READINESS_TIMEOUT } from '../../config/defaults.js';
-import { DependencyGraph } from '../../dependencies/graph.js';
-import { ensureError } from '../../errors.js';
-import { getComponentLogger } from '../../logging/index.js';
-import { hasResourceMetadata } from '../../metadata/index.js';
-import { ensureReadinessEvaluator } from '../../readiness/index.js';
-import { getEffectiveScopes } from '../resource-tagging.js';
-import { validateAlchemyScope } from '../shared-utilities.js';
-import { BaseDeploymentStrategy } from './base-strategy.js';
-import { DirectDeploymentStrategy } from './direct-strategy.js';
-/**
- * Alchemy deployment strategy - wraps deployments in alchemy resources with individual resource registration
- *
- * This strategy implements individual resource registration for Direct mode Alchemy integration.
- * Unlike Kro mode which registers RGDs and instances, Direct mode registers each individual
- * Kubernetes resource (Deployment, Service, ConfigMap, etc.) as separate Alchemy resource types.
- *
- * ## Resource Registration Pattern
- *
- * **Direct Mode (this strategy):**
- * - Each individual Kubernetes resource gets its own Alchemy resource type registration
- * - Resource types are named using the pattern `kubernetes::{Kind}` (e.g., `kubernetes::Deployment`)
- * - Each instance of each resource gets a separate Alchemy resource registered
- * - Example: A webapp with Deployment + Service creates 2 Alchemy resource types and 2 resource instances
- *
- * **Kro Mode (for comparison):**
- * - Each RGD gets one Alchemy resource type registered (`kro::ResourceGraphDefinition`)
- * - Each instance of each RGD gets a separate Alchemy resource registered (`kro::{Kind}`)
- * - Example: A webapp RGD creates 1 RGD type + 1 instance type = 2 Alchemy resources total
- *
- * ## Error Handling
- *
- * The strategy implements robust error handling for individual resource failures:
- * - Continues processing remaining resources when individual resources fail
- * - Collects all errors and includes them in the final DeploymentResult
- * - Sets deployment status to 'partial' when some resources succeed and others fail
- * - Provides resource-specific error context including kind, name, namespace, and Alchemy resource type
- *
- * ## Integration with DirectTypeKroDeployer
- *
- * This strategy integrates with DirectTypeKroDeployer for actual resource deployment:
- * - Extracts DirectDeploymentEngine from the base DirectDeploymentStrategy
- * - Creates DirectTypeKroDeployer instance for individual resource deployments
- * - Passes deployer to each Alchemy resource provider for deployment execution
- *
- * @template TSpec - The specification type for the resource
- * @template TStatus - The status type for the resource
- */
-export class AlchemyDeploymentStrategy extends BaseDeploymentStrategy {
-    alchemyScope;
-    baseStrategy;
-    alchemyLogger = getComponentLogger('alchemy-deployment-strategy');
-    constructor(factoryName, namespace, schemaDefinition, 
-    // biome-ignore lint/suspicious/noExplicitAny: alchemy strategy must preserve the generic status-builder resource map contract.
-    statusBuilder, resourceKeys, factoryOptions, alchemyScope, baseStrategy) {
-        super(factoryName, namespace, schemaDefinition, statusBuilder, resourceKeys, factoryOptions);
-        this.alchemyScope = alchemyScope;
-        this.baseStrategy = baseStrategy;
-    }
-    /**
-     * Execute deployment with individual resource registration for Alchemy integration
-     *
-     * This method implements the core logic for Direct mode Alchemy integration:
-     *
-     * ## Process Overview
-     * 1. **Validation**: Validates the Alchemy scope is available and properly configured
-     * 2. **Resource Graph Creation**: Gets the resource graph from the base strategy using createResourceGraphForInstance
-     * 3. **Deployer Setup**: Creates DirectTypeKroDeployer instance using DirectDeploymentEngine from base strategy
-     * 4. **Individual Registration**: Processes each resource in the resource graph individually for Alchemy registration
-     * 5. **Error Collection**: Continues processing remaining resources when individual resources fail
-     * 6. **Result Creation**: Creates comprehensive DeploymentResult with individual resource tracking
-     *
-     * ## Individual Resource Processing
-     *
-     * For each resource in the resource graph:
-     * - **Type Inference**: Infers Alchemy resource type from Kubernetes kind (e.g., `kubernetes::Deployment`)
-     * - **Type Registration**: Calls ensureResourceTypeRegistered to register the resource type (shared across instances)
-     * - **ID Generation**: Creates unique resource ID using createAlchemyResourceId with namespace and resource info
-     * - **Deployment**: Deploys the resource through Alchemy using the resource provider and DirectTypeKroDeployer
-     * - **Tracking**: Tracks deployed resource with Alchemy metadata (resource ID, type, etc.)
-     *
-     * ## Error Handling Strategy
-     *
-     * The method implements robust error handling:
-     * - **Continue on Failure**: Individual resource failures don't stop processing of remaining resources
-     * - **Error Collection**: All errors are collected with detailed context about which resource failed
-     * - **Resource Context**: Error messages include resource kind, name, namespace, and Alchemy resource type
-     * - **Partial Status**: Deployment status is set to 'partial' when some resources succeed and others fail
-     *
-     * ## Resource Type Naming
-     *
-     * Resource types follow consistent naming patterns:
-     * - **Kubernetes Resources**: `kubernetes::{Kind}` (e.g., `kubernetes::Deployment`, `kubernetes::Service`)
-     * - **Shared Types**: Multiple instances of the same resource type share the same Alchemy resource type registration
-     * - **Unique IDs**: Each resource instance gets a unique Alchemy resource ID for individual tracking
-     *
-     * @param spec - The resource specification to deploy
-     * @param instanceName - The name of this specific instance
-     * @returns Promise<DeploymentResult> - Comprehensive deployment result with individual resource tracking
-     * @throws Error - If Alchemy scope validation fails or critical deployment errors occur
-     */
-    async executeDeployment(spec, instanceName, opts) {
-        try {
-            // Validate alchemy scope is available and properly configured
-            validateAlchemyScope(this.alchemyScope, 'Alchemy deployment');
-            // Use static imports for registration functions
-            const { ensureResourceTypeRegistered, createAlchemyResourceId } = await import('../../../alchemy/deployment.js');
-            // Get resource graph from base strategy using createResourceGraphForInstance
-            // This provides the individual Kubernetes resources that need to be registered with Alchemy
-            this.logger.info('About to create resource graph for instance', {
-                instanceName,
-                hasBaseStrategy: !!this.baseStrategy,
-                baseStrategyType: this.baseStrategy?.constructor?.name,
-            });
-            const resourceGraph = this.createResourceGraphForInstance(spec, instanceName);
-            this.logger.info('Resource graph created', {
-                resourceCount: resourceGraph.resources.length,
-                graphName: resourceGraph.name,
-            });
-            let directResult;
-            try {
-                directResult = await this.executeBaseDirectDeployment(spec, instanceName, opts);
-            }
-            catch (directDeploymentError) {
-                const error = ensureError(directDeploymentError);
-                this.logger.warn('Base direct deployment failed; preserving failure in Alchemy result', {
-                    error: error.message,
-                    resourceCount: resourceGraph.resources.length,
-                });
-                directResult = {
-                    status: 'failed',
-                    deploymentId: `alchemy-direct-failed-${instanceName}-${Date.now()}`,
-                    resources: [],
-                    dependencyGraph: resourceGraph.dependencyGraph,
-                    duration: 0,
-                    errors: resourceGraph.resources.map((resource) => ({
-                        resourceId: resource.id,
-                        phase: 'deployment',
-                        error: new Error(`Direct deployment failed for ${resource.manifest.kind || 'Unknown'}/${resource.manifest.metadata?.name || 'unnamed'}: ${error.message}`),
-                        timestamp: new Date(),
-                    })),
-                };
-            }
-            const directResourcesById = new Map(directResult.resources.map((resource) => [resource.id, resource]));
-            const trackingDeployer = {
-                deploy: async (resource) => resource,
-                delete: async () => {
-                    // Alchemy direct mode is only registering state here; the base direct
-                    // deployment already performed Kubernetes mutations.
-                },
-            };
-            // Process each actually deployed resource in the graph for Alchemy state registration.
-            const deployedResources = [];
-            const errors = [];
-            const startTime = Date.now();
-            this.logger.info('Processing resource graph for alchemy deployment', {
-                resourceCount: resourceGraph.resources.length,
-                resourceIds: resourceGraph.resources.map((r) => r.id),
-                resourceKinds: resourceGraph.resources.map((r) => r.manifest.kind),
-            });
-            // Continue processing remaining resources when individual resources fail
-            for (const resource of resourceGraph.resources) {
-                const directDeployedResource = directResourcesById.get(resource.id);
-                if (!directDeployedResource) {
-                    this.logger.debug('Skipping Alchemy state registration for undeployed resource', {
-                        resourceId: resource.id,
-                        resourceScopes: getEffectiveScopes(resource.manifest),
-                        targetScopes: opts?.targetScopes,
-                    });
-                    continue;
-                }
-                try {
-                    this.logger.info('Processing resource for alchemy deployment', {
-                        resourceId: resource.id,
-                        resourceKind: resource.manifest.kind,
-                        resourceName: resource.manifest.metadata?.name,
-                        hasReadinessEvaluator: hasResourceMetadata(resource.manifest),
-                    });
-                    const resourceWithEvaluator = ensureReadinessEvaluator(resource.manifest);
-                    // Register resource type dynamically (shared across instances)
-                    const ResourceProvider = ensureResourceTypeRegistered(resourceWithEvaluator);
-                    // Create unique resource ID for this instance
-                    const resourceId = createAlchemyResourceId(resourceWithEvaluator, this.namespace);
-                    // Deploy individual resource through Alchemy within the scope
-                    await this.alchemyScope.run(async () => {
-                        try {
-                            // Extract serializable kubeConfig options
-                            const kubeConfigOptions = this.extractKubeConfigOptions();
-                            // Create the resource through Alchemy
-                            const _alchemyResource = await ResourceProvider(resourceId, {
-                                resource: resourceWithEvaluator,
-                                namespace: this.namespace,
-                                deploymentStrategy: 'direct',
-                                kubeConfigOptions,
-                                deployer: trackingDeployer,
-                                options: {
-                                    waitForReady: this.factoryOptions.waitForReady ?? false, // Default to false for faster tests
-                                    timeout: this.factoryOptions.timeout ?? DEFAULT_READINESS_TIMEOUT,
-                                    factoryName: this.factoryName,
-                                    instanceName,
-                                    ...(opts?.singletonSpecFingerprint && { singletonSpecFingerprint: opts.singletonSpecFingerprint }),
-                                },
-                            });
-                            // Track the deployed resource
-                            deployedResources.push({
-                                ...directDeployedResource,
-                                alchemyResourceId: resourceId,
-                                alchemyResourceType: ResourceProvider.name || 'unknown',
-                            });
-                            this.logger.debug('Successfully deployed resource through Alchemy', {
-                                resourceKind: resource.manifest.kind,
-                                resourceName: resource.manifest.metadata?.name,
-                                alchemyResourceId: resourceId,
-                                alchemyResourceType: ResourceProvider.name,
-                            });
-                        }
-                        catch (deployError) {
-                            const error = ensureError(deployError);
-                            this.logger.error('Failed to deploy individual resource through Alchemy', error, {
-                                resourceKind: resource.manifest.kind,
-                                resourceName: resource.manifest.metadata?.name,
-                                resourceId: resource.id,
-                                namespace: this.namespace,
-                            });
-                            // Collect error but continue processing other resources
-                            errors.push({
-                                resourceId: resource.id,
-                                error,
-                                phase: 'deployment',
-                                timestamp: new Date(),
-                                resourceKind: resource.manifest.kind || 'Unknown',
-                                resourceName: resource.manifest.metadata?.name || 'unnamed',
-                                alchemyResourceType: ResourceProvider.name || 'unknown',
-                                namespace: this.namespace,
-                            });
-                        }
-                    });
-                }
-                catch (registrationError) {
-                    const error = ensureError(registrationError);
-                    this.logger.error('Failed to register resource type with Alchemy', error, {
-                        resourceKind: resource.manifest.kind,
-                        resourceName: resource.manifest.metadata?.name,
-                        resourceId: resource.id,
-                    });
-                    // Collect error but continue processing other resources
-                    errors.push({
-                        resourceId: resource.id,
-                        error,
-                        phase: 'deployment',
-                        timestamp: new Date(),
-                        resourceKind: resource.manifest.kind || 'Unknown',
-                        resourceName: resource.manifest.metadata?.name || 'unnamed',
-                        alchemyResourceType: 'registration-failed',
-                        namespace: this.namespace,
-                    });
-                }
-            }
-            // Create comprehensive deployment result
-            const duration = Date.now() - startTime;
-            const allErrors = [
-                ...(directResult.errors ?? []).map((error) => ({
-                    ...error,
-                    resourceKind: 'Unknown',
-                    resourceName: error.resourceId,
-                    alchemyResourceType: 'direct-deployment',
-                    namespace: this.namespace,
-                })),
-                ...errors,
-            ];
-            const hasErrors = allErrors.length > 0;
-            let hasSuccesses = deployedResources.length > 0;
-            let rolledBackAfterAlchemyFailure = false;
-            if (hasErrors && directResult.resources.length > 0) {
-                await this.rollbackBaseDirectDeployment(directResult);
-                deployedResources.length = 0;
-                hasSuccesses = false;
-                rolledBackAfterAlchemyFailure = true;
-            }
-            let status;
-            if (rolledBackAfterAlchemyFailure) {
-                status = 'failed';
-            }
-            else if (hasSuccesses && !hasErrors) {
-                status = 'success';
-            }
-            else if (!hasSuccesses && hasErrors) {
-                status = 'failed';
-            }
-            else if (!hasSuccesses && !hasErrors) {
-                status = directResult.status;
-            }
-            else {
-                status = 'partial';
-            }
-            this.logger.info('Alchemy deployment completed', {
-                status,
-                successfulResources: deployedResources.length,
-                failedResources: allErrors.length,
-                totalResources: resourceGraph.resources.length,
-                duration,
-            });
-            return {
-                status,
-                deploymentId: directResult.deploymentId,
-                resources: deployedResources,
-                dependencyGraph: resourceGraph.dependencyGraph,
-                duration,
-                errors: allErrors.map((e) => ({
-                    resourceId: e.resourceId,
-                    error: e.error,
-                    phase: e.phase,
-                    timestamp: e.timestamp,
-                })),
-            };
-        }
-        catch (error) {
-            this.logger.error('Alchemy deployment strategy failed', ensureError(error));
-            throw error;
-        }
-    }
-    async executeBaseDirectDeployment(spec, instanceName, opts) {
-        const strategy = this.baseStrategy;
-        if (typeof strategy.executeDeployment !== 'function') {
-            throw new Error('Alchemy direct deployment requires a direct base strategy');
-        }
-        return strategy.executeDeployment(spec, instanceName, opts);
-    }
-    async rollbackBaseDirectDeployment(directResult) {
-        const strategy = this.baseStrategy;
-        if (typeof strategy.rollbackDeployment !== 'function') {
-            this.logger.warn('Alchemy registration failed after direct deployment, but base strategy cannot rollback', {
-                deploymentId: directResult.deploymentId,
-                resourceCount: directResult.resources.length,
-            });
-            return;
-        }
-        try {
-            const scopes = [...new Set(directResult.resources.flatMap((resource) => getEffectiveScopes(resource.manifest)))];
-            await strategy.rollbackDeployment(directResult.deploymentId, scopes.length > 0 ? { scopes } : undefined);
-            this.logger.info('Rolled back direct resources after Alchemy registration failure', {
-                deploymentId: directResult.deploymentId,
-                resourceCount: directResult.resources.length,
-            });
-        }
-        catch (rollbackError) {
-            this.logger.error('Failed to rollback direct resources after Alchemy registration failure', ensureError(rollbackError), {
-                deploymentId: directResult.deploymentId,
-            });
-            throw rollbackError;
-        }
-    }
-    getStrategyMode() {
-        return 'direct'; // Alchemy strategy uses direct mode for individual resource registration
-    }
-    /**
-     * Create resource graph for instance using base strategy logic
-     */
-    createResourceGraphForInstance(spec, instanceName) {
-        // Delegate to the base strategy's resource resolution logic
-        if (this.baseStrategy instanceof DirectDeploymentStrategy) {
-            const baseStrategy = this.baseStrategy;
-            if (baseStrategy.resourceResolver &&
-                typeof baseStrategy.resourceResolver.createResourceGraphForInstance === 'function') {
-                this.logger.info('Calling createResourceGraphForInstance on resource resolver', {
-                    hasResourceResolver: !!baseStrategy.resourceResolver,
-                    resolverType: baseStrategy.resourceResolver.constructor?.name,
-                });
-                const resourceGraph = baseStrategy.resourceResolver.createResourceGraphForInstance(spec, instanceName);
-                this.logger.info('Created resource graph from base strategy', {
-                    resourceCount: resourceGraph.resources.length,
-                    resourceIds: resourceGraph.resources.map((r) => r.id),
-                    resourceKinds: resourceGraph.resources.map((r) => r.manifest?.kind),
-                });
-                return { ...resourceGraph, name: instanceName };
-            }
-            else {
-                this.logger.warn('Base strategy does not have resourceResolver or createResourceGraphForInstance method', {
-                    hasResourceResolver: !!baseStrategy.resourceResolver,
-                    resolverType: baseStrategy.resourceResolver?.constructor?.name,
-                    hasMethod: baseStrategy.resourceResolver
-                        ? typeof baseStrategy.resourceResolver.createResourceGraphForInstance
-                        : 'no resolver',
-                });
-            }
-        }
-        else {
-            this.logger.warn('Base strategy is not DirectDeploymentStrategy', {
-                baseStrategyType: this.baseStrategy?.constructor?.name,
-            });
-        }
-        // Fallback implementation - this should not happen in normal operation
-        this.logger.error('Falling back to empty resource graph - this indicates a configuration issue');
-        return {
-            name: instanceName,
-            resources: [],
-            dependencyGraph: new DependencyGraph(),
-        };
-    }
-    /**
-     * Extract serializable kubeConfig options from factory options
-     */
-    extractKubeConfigOptions() {
-        let kubeConfigOptions = {};
-        if (this.factoryOptions.kubeConfig) {
-            const kc = this.factoryOptions.kubeConfig;
-            const cluster = kc.getCurrentCluster();
-            const user = kc.getCurrentUser();
-            const context = kc.getCurrentContext();
-            this.logger.debug('Extracting kubeconfig options for alchemy', {
-                hasCluster: !!cluster,
-                clusterSkipTLS: cluster?.skipTLSVerify,
-                clusterServer: cluster?.server,
-                hasUser: !!user,
-                context,
-            });
-            // SECURITY: Prioritize user's explicit skipTLSVerify choice over cluster config
-            const userSkipTLS = this.factoryOptions.skipTLSVerify;
-            const clusterSkipTLS = cluster?.skipTLSVerify;
-            const finalSkipTLS = userSkipTLS === true ? true : (clusterSkipTLS ?? false);
-            // Log security warning when TLS is disabled
-            if (finalSkipTLS) {
-                this.logger.warn('TLS verification disabled - this is insecure and should only be used in development', {
-                    component: 'alchemy-deployment-strategy',
-                    security: 'tls-disabled',
-                    userExplicit: userSkipTLS === true,
-                    fromClusterConfig: clusterSkipTLS === true,
-                    server: cluster?.server,
-                    recommendation: userSkipTLS === true
-                        ? 'Remove skipTLSVerify: true from factory options for production'
-                        : 'Update cluster configuration to enable TLS verification',
-                });
-            }
-            kubeConfigOptions = {
-                skipTLSVerify: finalSkipTLS,
-                ...(cluster?.server && { server: cluster.server }),
-                ...(context && { context }),
-                // Include complete cluster configuration
-                ...(cluster && {
-                    cluster: {
-                        name: cluster.name,
-                        server: cluster.server,
-                        skipTLSVerify: finalSkipTLS,
-                        ...(cluster.caData && { caData: cluster.caData }),
-                        ...(cluster.caFile && { caFile: cluster.caFile }),
-                    },
-                }),
-                // Include complete user configuration
-                ...(user && {
-                    user: {
-                        name: user.name,
-                        ...(user.token && { token: user.token }),
-                        ...(user.certData && { certData: user.certData }),
-                        ...(user.certFile && { certFile: user.certFile }),
-                        ...(user.keyData && { keyData: user.keyData }),
-                        ...(user.keyFile && { keyFile: user.keyFile }),
-                        ...(user.exec ? { exec: user.exec } : {}),
-                        ...(user.authProvider
-                            ? { authProvider: user.authProvider }
-                            : {}),
-                    },
-                }),
-            };
-            this.logger.debug('Extracted kubeconfig options', {
-                server: cluster?.server ?? '(default)',
-                hasToken: !!user?.token,
-                hasCertData: !!user?.certData,
-                hasKeyData: !!user?.keyData,
-            });
-        }
-        else {
-            // Try extracting from the base strategy's factory options (common in tests)
-            try {
-                if (this.baseStrategy instanceof DirectDeploymentStrategy) {
-                    const bs = this.baseStrategy;
-                    const baseFactoryOptions = bs?.factoryOptions;
-                    const baseKc = baseFactoryOptions?.kubeConfig;
-                    const cluster = baseKc?.getCurrentCluster();
-                    const user = baseKc?.getCurrentUser();
-                    const context = baseKc?.getCurrentContext();
-                    this.logger.debug('Extracting kubeconfig options from base strategy for alchemy', {
-                        hasBaseFactoryOptions: !!baseFactoryOptions,
-                        hasBaseKubeConfig: !!baseKc,
-                        hasCluster: !!cluster,
-                        clusterSkipTLS: cluster?.skipTLSVerify,
-                        clusterServer: cluster?.server,
-                        hasUser: !!user,
-                        context,
-                    });
-                    if (baseKc && cluster) {
-                        // SECURITY: Prioritize user's explicit skipTLSVerify choice over cluster config
-                        const userSkipTLS = this.factoryOptions.skipTLSVerify;
-                        const clusterSkipTLS = cluster.skipTLSVerify;
-                        const finalSkipTLS = userSkipTLS === true ? true : (clusterSkipTLS ?? false);
-                        // Log security warning when TLS is disabled
-                        if (finalSkipTLS) {
-                            this.logger.warn('TLS verification disabled - this is insecure and should only be used in development', {
-                                component: 'alchemy-deployment-strategy',
-                                security: 'tls-disabled',
-                                userExplicit: userSkipTLS === true,
-                                fromClusterConfig: clusterSkipTLS === true,
-                                server: cluster?.server,
-                                recommendation: userSkipTLS === true
-                                    ? 'Remove skipTLSVerify: true from factory options for production'
-                                    : 'Update cluster configuration to enable TLS verification',
-                            });
-                        }
-                        kubeConfigOptions = {
-                            skipTLSVerify: finalSkipTLS,
-                            ...(cluster.server && { server: cluster.server }),
-                            ...(context && { context }),
-                            cluster: {
-                                name: cluster.name,
-                                server: cluster.server,
-                                skipTLSVerify: finalSkipTLS,
-                                ...(cluster.caData && { caData: cluster.caData }),
-                                ...(cluster.caFile && { caFile: cluster.caFile }),
-                            },
-                            ...(user && {
-                                user: {
-                                    name: user.name,
-                                    ...(user.token && { token: user.token }),
-                                    ...(user.certData && { certData: user.certData }),
-                                    ...(user.certFile && { certFile: user.certFile }),
-                                    ...(user.keyData && { keyData: user.keyData }),
-                                    ...(user.keyFile && { keyFile: user.keyFile }),
-                                    ...(user.exec ? { exec: user.exec } : {}),
-                                    ...(user.authProvider
-                                        ? { authProvider: user.authProvider }
-                                        : {}),
-                                },
-                            }),
-                        };
-                        this.logger.debug('Extracted kubeconfig options from base strategy', {
-                            hasCluster: !!kubeConfigOptions.cluster,
-                            hasUser: !!kubeConfigOptions.user,
-                        });
-                    }
-                }
-            }
-            catch (extractionError) {
-                this.logger.debug('Could not extract kubeconfig from base strategy, using default', {
-                    error: ensureError(extractionError).message,
-                });
-            }
-        }
-        return kubeConfigOptions;
-    }
-}
-//# sourceMappingURL=alchemy-strategy.js.map