@crossdelta/infrastructure 0.2.27 → 0.3.0-beta.2

package/bin/generate-env.ts

@@ -37,8 +37,7 @@ const resolveNumber = (value: string, fileContent: string): number | undefined =
 }
 
 const extract = {
-  string: (content: string, pattern: RegExp): string | undefined =>
-    content.match(pattern)?.[1],
+  string: (content: string, pattern: RegExp): string | undefined => content.match(pattern)?.[1],
 
   number: (content: string, pattern: RegExp): number | undefined => {
     const match = content.match(pattern)?.[1]
@@ -72,7 +71,7 @@ const loadPulumiConfig = async (infraDir: string, stack: string): Promise<string
   try {
     const result = Bun.spawnSync(['pulumi', 'config', '--show-secrets', '--json', '--stack', stack, '--cwd', infraDir])
     if (result.exitCode !== 0) return []
-    
+
     const config = JSON.parse(result.stdout.toString()) as Record<string, PulumiConfigEntry>
 
     return Object.entries(config)
@@ -89,10 +88,8 @@ const loadPulumiConfig = async (infraDir: string, stack: string): Promise<string
 
 const discoverServices = (servicesDir: string): MinimalServiceConfig[] => {
   if (!existsSync(servicesDir)) return []
-  
-  const files = readdirSync(servicesDir).filter(
-    (file) => file.endsWith('.ts') && file !== 'index.ts'
-  )
+
+  const files = readdirSync(servicesDir).filter((file) => file.endsWith('.ts') && file !== 'index.ts')
 
   return files.map((file) => {
     const content = readFileSync(join(servicesDir, file), 'utf-8')

package/dist/core/compat.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Compatibility helpers for migrating from old port models to unified port config.
+ *
+ * These helpers allow gradual migration from the inconsistent
+ * httpPort/internalPorts/containerPort model to the unified ServicePorts model.
+ */
+import type { ServicePorts } from './types';
+/**
+ * Legacy port configuration (App Platform style).
+ */
+export interface LegacyAppPlatformPorts {
+    /** Public HTTP port */
+    httpPort?: number;
+    /** Internal-only ports */
+    internalPorts?: number[];
+}
+/**
+ * Legacy port configuration (Kubernetes style).
+ */
+export interface LegacyK8sPorts {
+    /** Container port */
+    containerPort: number;
+    /** Additional ports */
+    additionalPorts?: Array<{
+        name: string;
+        port: number;
+        targetPort?: number;
+        protocol?: 'TCP' | 'UDP';
+    }>;
+}
+/**
+ * Convert legacy App Platform port config to unified model.
+ *
+ * @example
+ * ```typescript
+ * // Old style
+ * { httpPort: 3000 }
+ *
+ * // Converts to
+ * { primary: { port: 3000, name: 'http', public: true } }
+ * ```
+ */
+export declare function fromAppPlatformPorts(config: LegacyAppPlatformPorts): ServicePorts;
+/**
+ * Convert legacy Kubernetes port config to unified model.
+ *
+ * @example
+ * ```typescript
+ * // Old style
+ * { containerPort: 4001 }
+ *
+ * // Converts to
+ * { primary: { port: 4001, name: 'http' } }
+ * ```
+ */
+export declare function fromK8sPorts(config: LegacyK8sPorts): ServicePorts;
+/**
+ * Extract primary port number from ServicePorts (for backward compatibility).
+ */
+export declare function getPrimaryPort(ports: ServicePorts): number;
+/**
+ * Get all port numbers from ServicePorts.
+ */
+export declare function getAllPorts(ports: ServicePorts): number[];
+/**
+ * Get public ports from ServicePorts.
+ */
+export declare function getPublicPorts(ports: ServicePorts): number[];
+/**
+ * Check if any port is public.
+ */
+export declare function hasPublicPort(ports: ServicePorts): boolean;

package/dist/core/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Core provider-agnostic infrastructure types and utilities.
+ *
+ * This module provides the foundation for multi-cloud infrastructure management.
+ */
+export * from './compat';
+export * from './runtime';
+export * from './types';

package/dist/core/runtime-detection.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Runtime detection utilities
+ *
+ * Separate from main runtime.ts to avoid Pulumi imports in tests
+ */
+/**
+ * Detect runtime from environment or configuration.
+ *
+ * Priority:
+ * 1. INFRASTRUCTURE_PROVIDER env var
+ * 2. Default to 'doks'
+ *
+ * Note: Pulumi config detection is handled in the main runtime.ts file
+ */
+export declare function detectRuntimeProvider(): string;

package/dist/core/runtime.d.ts

@@ -0,0 +1,221 @@
+/**
+ * Runtime adapter interfaces for provider-agnostic infrastructure management.
+ *
+ * Each cloud provider (DOKS, EKS, AKS, GKE) implements these interfaces
+ * to provide a consistent API across different platforms.
+ */
+import * as pulumi from '@pulumi/pulumi';
+import type { ClusterDeploymentResult, CoreClusterConfig, CoreNetworkConfig, CoreServiceConfig, ServiceDeploymentResult } from './types';
+/**
+ * Runtime adapter for a specific cloud provider.
+ *
+ * Each provider implements this interface to translate core configurations
+ * into provider-specific resources.
+ *
+ * @example
+ * ```typescript
+ * // Create DOKS adapter
+ * const runtime = createDOKSRuntime()
+ *
+ * // Deploy cluster
+ * const cluster = await runtime.createCluster(clusterConfig)
+ *
+ * // Deploy services
+ * const service = await runtime.deployService(serviceConfig, cluster.provider)
+ * ```
+ */
+export interface RuntimeAdapter {
+    /** Provider identifier */
+    readonly provider: string;
+    /**
+     * Create a VPC/network.
+     */
+    createNetwork(config: CoreNetworkConfig): Promise<NetworkResult>;
+    /**
+     * Create a Kubernetes cluster.
+     */
+    createCluster(config: CoreClusterConfig, networkId?: pulumi.Input<string>): Promise<ClusterResult>;
+    /**
+     * Deploy a service to the cluster.
+     */
+    deployService(config: CoreServiceConfig, options: DeployServiceOptions): Promise<ServiceDeploymentResult>;
+    /**
+     * Deploy multiple services to the cluster.
+     */
+    deployServices(configs: CoreServiceConfig[], options: DeployServicesOptions): Promise<ServiceDeploymentResult[]>;
+    /**
+     * Configure ingress controller for the cluster.
+     */
+    configureIngress?(options: ConfigureIngressOptions): Promise<IngressResult>;
+    /**
+     * Configure certificate management (e.g., cert-manager, AWS ACM).
+     */
+    configureCertManager?(options: ConfigureCertManagerOptions): Promise<void>;
+}
+/**
+ * Network creation result.
+ */
+export interface NetworkResult {
+    /** Network ID */
+    id: pulumi.Output<string>;
+    /** Network name */
+    name: string;
+    /** CIDR block */
+    cidrBlock?: pulumi.Output<string>;
+}
+/**
+ * Cluster creation result.
+ */
+export interface ClusterResult extends ClusterDeploymentResult {
+    /** Cluster ID */
+    id: pulumi.Output<string>;
+    /** Kubernetes provider (for deploying resources) */
+    provider: any;
+    /** VPC/Network ID */
+    networkId?: pulumi.Output<string>;
+}
+/**
+ * Ingress controller result.
+ */
+export interface IngressResult {
+    /** Ingress controller name */
+    name: string;
+    /** Public IP/hostname */
+    endpoint?: pulumi.Output<string>;
+}
+/**
+ * Options for deploying a single service.
+ */
+export interface DeployServiceOptions {
+    /** Kubernetes provider */
+    provider: any;
+    /** Namespace to deploy to */
+    namespace: string;
+    /** Image pull secret name */
+    imagePullSecretName?: string;
+    /** Additional environment variables to inject */
+    additionalEnv?: Record<string, pulumi.Input<string>>;
+}
+/**
+ * Options for deploying multiple services.
+ */
+export interface DeployServicesOptions extends DeployServiceOptions {
+    /** Filter services by name (regex) */
+    filter?: RegExp;
+}
+/**
+ * Options for configuring ingress.
+ */
+export interface ConfigureIngressOptions {
+    /** Kubernetes provider */
+    provider: any;
+    /** Namespace */
+    namespace: string;
+    /** Ingress class name */
+    ingressClassName?: string;
+    /** Load balancer IP (optional, for static IP) */
+    loadBalancerIp?: string;
+}
+/**
+ * Options for configuring cert manager.
+ */
+export interface ConfigureCertManagerOptions {
+    /** Kubernetes provider */
+    provider: any;
+    /** Namespace */
+    namespace?: string;
+    /** Email for Let's Encrypt notifications */
+    email: string;
+    /** Staging mode (for testing) */
+    staging?: boolean;
+}
+/**
+ * Runtime factory function signature.
+ */
+export type RuntimeFactory = () => RuntimeAdapter;
+/**
+ * Register a runtime adapter for a provider.
+ *
+ * @example
+ * ```typescript
+ * registerRuntime('doks', createDOKSRuntime)
+ * ```
+ */
+export declare function registerRuntime(provider: string, factory: RuntimeFactory): void;
+/**
+ * Get a runtime adapter for a provider.
+ *
+ * @example
+ * ```typescript
+ * const runtime = getRuntime('doks')
+ * ```
+ */
+export declare function getRuntime(provider: string): RuntimeAdapter;
+/**
+ * Detect runtime from environment or configuration.
+ *
+ * Priority:
+ * 1. INFRASTRUCTURE_PROVIDER env var
+ * 2. Pulumi config (infrastructure:provider)
+ * 3. Default to 'doks'
+ */
+export declare function detectRuntime(): string;
+/**
+ * Runtime component configuration
+ *
+ * Configures which runtime components to deploy and their settings.
+ */
+export interface RuntimeDeploymentConfig {
+    /** NATS configuration */
+    nats?: {
+        enabled: boolean;
+        config?: any;
+    };
+    /** Ingress configuration */
+    ingress?: {
+        enabled: boolean;
+        config?: any;
+    };
+    /** Certificate manager configuration */
+    certManager?: {
+        enabled: boolean;
+        config?: any;
+    };
+}
+/**
+ * Runtime deployment result
+ */
+export interface RuntimeDeploymentResult {
+    /** NATS internal URL */
+    natsUrl?: pulumi.Output<string>;
+    /** LoadBalancer IP (if ingress enabled) */
+    loadBalancerIp?: pulumi.Output<string>;
+    /** Cert manager ready */
+    certManagerReady?: boolean;
+}
+/**
+ * Deploy runtime components using the detected or specified runtime adapter.
+ *
+ * This is a convenience function that:
+ * 1. Detects or uses the specified runtime provider
+ * 2. Deploys optional runtime components (NATS, Ingress, Cert-Manager)
+ * 3. Returns URLs and metadata for the deployed components
+ *
+ * @example
+ * ```typescript
+ * const runtime = deployRuntime(provider, 'default', {
+ *   nats: {
+ *     enabled: true,
+ *     config: { jetstream: { enabled: true, storageSize: '1Gi' } }
+ *   },
+ *   ingress: {
+ *     enabled: true,
+ *     config: { replicas: 1 }
+ *   }
+ * })
+ *
+ * console.log('NATS URL:', runtime.natsUrl)
+ * console.log('LoadBalancer IP:', runtime.loadBalancerIp)
+ * ```
+ */
+export declare function deployRuntime(provider: any, namespace: string, config: RuntimeDeploymentConfig, runtimeProvider?: string): RuntimeDeploymentResult;