@crossdelta/infrastructure 0.2.26 → 0.3.0-beta.1

package/dist/core/types.d.ts

@@ -0,0 +1,419 @@
+/**
+ * Provider-agnostic core types for infrastructure configuration.
+ *
+ * These types serve as the foundation for all cloud providers (DOKS, EKS, AKS, GKE).
+ * Provider-specific implementations extend these core types with their own features.
+ */
+import type * as pulumi from '@pulumi/pulumi';
+/**
+ * Supported cloud providers.
+ */
+export declare const Provider: {
+    /** DigitalOcean Kubernetes Service */
+    readonly DOKS: "doks";
+    /** Amazon Elastic Kubernetes Service */
+    readonly EKS: "eks";
+    /** Azure Kubernetes Service */
+    readonly AKS: "aks";
+    /** Google Kubernetes Engine */
+    readonly GKE: "gke";
+    /** Local Kubernetes (minikube, kind, k3s) */
+    readonly LOCAL: "local";
+};
+export type Provider = (typeof Provider)[keyof typeof Provider];
+/**
+ * CPU and memory resource specifications.
+ */
+export interface Resources {
+    /** CPU (e.g., '100m', '0.5', '2') */
+    cpu?: string;
+    /** Memory (e.g., '128Mi', '1Gi') */
+    memory?: string;
+}
+/**
+ * Resource requests and limits for containers.
+ */
+export interface ResourceConfig {
+    /** Guaranteed resources */
+    requests?: Resources;
+    /** Maximum resources */
+    limits?: Resources;
+}
+/**
+ * Port protocol type.
+ */
+export type PortProtocol = 'TCP' | 'UDP' | 'HTTP' | 'HTTPS' | 'GRPC';
+/**
+ * Unified port configuration.
+ *
+ * Replaces the inconsistent httpPort/internalPorts/containerPort model
+ * with a single, flexible port definition.
+ */
+export interface PortConfig {
+    /** Port name (e.g., 'http', 'grpc', 'metrics') */
+    name?: string;
+    /** Port number the container listens on */
+    port: number;
+    /** External port (if different from container port) */
+    targetPort?: number;
+    /** Protocol (defaults to 'TCP') */
+    protocol?: PortProtocol;
+    /** Whether this port is exposed publicly via ingress (defaults to false) */
+    public?: boolean;
+}
+/**
+ * Service port configuration.
+ *
+ * Supports both simple (single port) and complex (multiple ports) configurations.
+ */
+export interface ServicePorts {
+    /**
+     * Primary port (required).
+     * Used for health checks and as default port for service URLs.
+     */
+    primary: PortConfig;
+    /**
+     * Additional ports (optional).
+     * For services that expose multiple ports (e.g., HTTP + metrics).
+     */
+    additional?: PortConfig[];
+}
+/**
+ * Helper to create a simple single-port configuration.
+ */
+export declare function createPort(port: number, options?: Partial<Omit<PortConfig, 'port'>>): ServicePorts;
+/**
+ * Helper to create a multi-port configuration.
+ *
+ * @deprecated Use PortsBuilder for better API. Example: ports().primary(4222).add(8222).build()
+ */
+export declare function createPorts(primary: PortConfig, additional: PortConfig[]): ServicePorts;
+/**
+ * Fluent builder for service ports configuration.
+ *
+ * Provides a cleaner, more intuitive API for defining ports.
+ *
+ * @example
+ * ```typescript
+ * // Simple single port
+ * const ports = ports().http(8080).build()
+ *
+ * // Public HTTP port
+ * const ports = ports().http(3000).public().build()
+ *
+ * // Multiple ports
+ * const ports = ports()
+ *   .primary(4222, 'client')
+ *   .add(8222, 'monitoring').public()
+ *   .add(6222, 'routing')
+ *   .build()
+ *
+ * // With protocols
+ * const ports = ports()
+ *   .http(8080).public()
+ *   .grpc(9090)
+ *   .add(9091, 'metrics')
+ *   .build()
+ * ```
+ */
+export declare class PortsBuilder {
+    private _primary?;
+    private _additional;
+    private _lastPort?;
+    /**
+     * Set primary port with optional name.
+     */
+    primary(port: number, name?: string): this;
+    /**
+     * Set primary HTTP port.
+     */
+    http(port: number, name?: string): this;
+    /**
+     * Set primary HTTPS port.
+     */
+    https(port: number, name?: string): this;
+    /**
+     * Set primary gRPC port.
+     */
+    grpc(port: number, name?: string): this;
+    /**
+     * Add an additional port.
+     */
+    add(port: number, name?: string, protocol?: PortProtocol): this;
+    /**
+     * Add an additional HTTP port.
+     */
+    addHttp(port: number, name?: string): this;
+    /**
+     * Add an additional gRPC port.
+     */
+    addGrpc(port: number, name?: string): this;
+    /**
+     * Mark the last added port as public (exposed via ingress).
+     */
+    public(): this;
+    /**
+     * Set protocol for the last added port.
+     */
+    protocol(protocol: PortProtocol): this;
+    /**
+     * Set target port (external port) for the last added port.
+     */
+    targetPort(targetPort: number): this;
+    /**
+     * Build the final ServicePorts configuration.
+     */
+    build(): ServicePorts;
+}
+/**
+ * Create a new ports builder (fluent API).
+ *
+ * @example
+ * ```typescript
+ * // Simple HTTP service
+ * const config = {
+ *   ports: ports().http(8080).public().build()
+ * }
+ *
+ * // NATS with multiple ports
+ * const config = {
+ *   ports: ports()
+ *     .primary(4222, 'client')
+ *     .add(8222, 'monitoring').public()
+ *     .add(6222, 'routing')
+ *     .build()
+ * }
+ * ```
+ */
+export declare function ports(): PortsBuilder;
+/**
+ * Health check type.
+ */
+export type HealthCheckType = 'http' | 'tcp' | 'exec' | 'grpc';
+/**
+ * Health check configuration.
+ */
+export interface HealthCheck {
+    /** Type of health check */
+    type?: HealthCheckType;
+    /** HTTP path (for http checks) */
+    path?: string;
+    /** Port to check (defaults to primary port) */
+    port?: number;
+    /** Initial delay before starting checks (seconds) */
+    initialDelaySeconds?: number;
+    /** Period between checks (seconds) */
+    periodSeconds?: number;
+    /** Number of consecutive failures before unhealthy */
+    failureThreshold?: number;
+    /** Number of consecutive successes to be healthy */
+    successThreshold?: number;
+    /** Timeout for each check (seconds) */
+    timeoutSeconds?: number;
+}
+/**
+ * Path matching type for ingress rules.
+ */
+export type PathType = 'Prefix' | 'Exact' | 'Regex';
+/**
+ * TLS configuration for ingress.
+ */
+export interface TLSConfig {
+    /** Enable TLS */
+    enabled: boolean;
+    /** Certificate issuer (e.g., 'letsencrypt-production', 'letsencrypt-staging') */
+    issuer?: string;
+    /** Secret name for certificate (auto-generated if not provided) */
+    secretName?: string;
+}
+/**
+ * Ingress rule configuration.
+ */
+export interface IngressConfig {
+    /** Path for routing (e.g., '/', '/api') */
+    path: string;
+    /** Path matching type (defaults to 'Prefix') */
+    pathType?: PathType;
+    /** Strip path prefix before forwarding (defaults to true) */
+    stripPrefix?: boolean;
+    /** Hostname (required for TLS) */
+    host?: string;
+    /** Additional hostnames (e.g., www subdomain) */
+    additionalHosts?: string[];
+    /** TLS configuration */
+    tls?: TLSConfig;
+    /** Custom annotations */
+    annotations?: Record<string, string>;
+}
+/**
+ * Volume access mode.
+ */
+export type VolumeAccessMode = 'ReadWriteOnce' | 'ReadOnlyMany' | 'ReadWriteMany';
+/**
+ * Volume mount configuration.
+ */
+export interface VolumeMount {
+    /** Volume name (unique identifier) */
+    name: string;
+    /** Mount path in container */
+    mountPath: string;
+    /** Volume size (e.g., '10Gi') */
+    size?: string;
+    /** Storage class (provider-specific) */
+    storageClass?: string;
+    /** Access mode */
+    accessMode?: VolumeAccessMode;
+    /** Read-only mount */
+    readOnly?: boolean;
+}
+/**
+ * Service type.
+ */
+export type ServiceType = 'ClusterIP' | 'NodePort' | 'LoadBalancer';
+/**
+ * Core service configuration (provider-agnostic).
+ *
+ * This is the base configuration that all providers implement.
+ * Provider-specific features are added via extensions.
+ *
+ * @example
+ * ```typescript
+ * // Simple HTTP service
+ * const config: CoreServiceConfig = {
+ *   name: 'api',
+ *   ports: createPort(8080, { public: true }),
+ *   replicas: 2,
+ * }
+ *
+ * // Complex service with multiple ports
+ * const config: CoreServiceConfig = {
+ *   name: 'nats',
+ *   ports: createPorts(
+ *     { port: 4222, name: 'client', protocol: 'TCP' },
+ *     [{ port: 8222, name: 'monitoring', protocol: 'HTTP' }]
+ *   ),
+ *   volumes: [{ name: 'data', mountPath: '/data', size: '10Gi' }],
+ * }
+ * ```
+ */
+export interface CoreServiceConfig {
+    /** Unique service name */
+    name: string;
+    /**
+     * Container image (e.g., 'ghcr.io/org/app:latest').
+     * If not specified, auto-generated from provider config + service name.
+     */
+    image?: string;
+    /** Port configuration */
+    ports: ServicePorts;
+    /** Number of replicas (defaults to 1) */
+    replicas?: number;
+    /** Environment variables (plain values) */
+    env?: Record<string, pulumi.Input<string>>;
+    /** Secret environment variables */
+    secrets?: Record<string, pulumi.Input<string>>;
+    /** Ingress configuration (for public services) */
+    ingress?: IngressConfig;
+    /** Health check configuration */
+    healthCheck?: HealthCheck;
+    /** Resource requests and limits */
+    resources?: ResourceConfig;
+    /** Volume mounts for persistent storage */
+    volumes?: VolumeMount[];
+    /** Command to run (overrides container entrypoint) */
+    command?: string[];
+    /** Arguments to pass to command */
+    args?: string[];
+    /** Additional labels */
+    labels?: Record<string, string>;
+    /** Additional annotations */
+    annotations?: Record<string, string>;
+    /** Service type (defaults to 'ClusterIP') */
+    serviceType?: ServiceType;
+    /** Skip deployment (useful for temporarily disabling) */
+    skip?: boolean;
+    /** Image pull policy */
+    imagePullPolicy?: 'Always' | 'Never' | 'IfNotPresent';
+    /** Image pull secret name for private registries */
+    imagePullSecretName?: string;
+}
+/**
+ * Node pool configuration.
+ */
+export interface NodePoolConfig {
+    /** Node pool name */
+    name: string;
+    /** Instance/droplet size (provider-specific) */
+    size: string;
+    /** Number of nodes (ignored if autoScale is set) */
+    nodeCount?: number;
+    /** Auto-scaling configuration */
+    autoScale?: {
+        minNodes: number;
+        maxNodes: number;
+    };
+    /** Node labels */
+    labels?: Record<string, string>;
+    /** Node taints */
+    taints?: Array<{
+        key: string;
+        value: string;
+        effect: 'NoSchedule' | 'PreferNoSchedule' | 'NoExecute';
+    }>;
+}
+/**
+ * Core cluster configuration (provider-agnostic).
+ */
+export interface CoreClusterConfig {
+    /** Cluster name */
+    name: string;
+    /** Region/zone */
+    region: string;
+    /** Kubernetes version */
+    version?: string;
+    /** Node pools */
+    nodePools: NodePoolConfig[];
+    /** Enable high availability control plane */
+    ha?: boolean;
+    /** Enable auto-upgrade */
+    autoUpgrade?: boolean;
+    /** Tags */
+    tags?: string[];
+}
+/**
+ * Core VPC/network configuration (provider-agnostic).
+ */
+export interface CoreNetworkConfig {
+    /** Network name */
+    name: string;
+    /** Region/zone */
+    region: string;
+    /** IP range (CIDR notation) */
+    cidrBlock?: string;
+    /** Description */
+    description?: string;
+}
+/**
+ * Service deployment result.
+ */
+export interface ServiceDeploymentResult {
+    /** Service name */
+    name: string;
+    /** Internal service URL (for service-to-service communication) */
+    internalUrl: pulumi.Output<string>;
+    /** Service DNS name within cluster */
+    serviceDns: string;
+    /** Public URL (if ingress is configured) */
+    publicUrl?: pulumi.Output<string>;
+}
+/**
+ * Cluster deployment result.
+ */
+export interface ClusterDeploymentResult {
+    /** Cluster name */
+    name: string;
+    /** Kubernetes endpoint */
+    endpoint: pulumi.Output<string>;
+    /** Kubeconfig for cluster access */
+    kubeconfig: pulumi.Output<string>;
+}

package/dist/env.cjs

@@ -33,21 +33,15 @@ __export(exports_env, {
   getServicePort: () => getServicePort
 });
 module.exports = __toCommonJS(exports_env);
-
-// lib/helpers/service-runtime.ts
-var toEnvKey = (name) => name.toUpperCase().replace(/-/g, "_");
-function getServicePort(serviceName, defaultPort = 8080) {
-  const envKey = `${toEnvKey(serviceName)}_PORT`;
-  const envValue = process.env[envKey];
-  if (envValue) {
-    const parsed = Number(envValue);
-    if (!Number.isNaN(parsed)) {
-      return parsed;
-    }
+var getServicePort = (serviceName) => {
+  const envVar = `${serviceName.toUpperCase().replace(/-/g, "_")}_PORT`;
+  const port = Number(process.env.PORT || process.env[envVar]);
+  if (!port || Number.isNaN(port)) {
+    throw new Error(`Port not found for service '${serviceName}'. ` + `Expected environment variable: ${envVar}. ` + `Run 'bun run generate-env' to create .env.local`);
   }
-  return defaultPort;
-}
-function getServiceUrl(serviceName) {
-  const envKey = `${toEnvKey(serviceName)}_URL`;
-  return process.env[envKey];
-}
+  return port;
+};
+var getServiceUrl = (serviceName) => {
+  const envVar = `${serviceName.toUpperCase().replace(/-/g, "_")}_URL`;
+  return process.env[envVar];
+};

package/dist/env.d.ts

@@ -2,7 +2,21 @@
  * Environment helpers for services to read configuration.
  * Use this entry point in production services (Node.js, NestJS, etc.)
  *
+ * @deprecated This module is being phased out. Use environment variables directly.
+ *
  * @example
- * import { getServicePort, getServiceUrl } from '@crossdelta/infrastructure/env'
+ * // Instead of importing from /env, use process.env directly:
+ * const port = Number(process.env.PORT || process.env.MY_SERVICE_PORT) || 4001
+ */
+/**
+ * Get the port for a service from environment variables.
+ * @throws Error if port is not found in environment
+ * @deprecated Use process.env directly: Number(process.env.MY_SERVICE_PORT)
+ */
+export declare const getServicePort: (serviceName: string) => number;
+/**
+ * Get the URL for a service.
+ * @throws Error if service URL is not found in environment
+ * @deprecated Use process.env or construct URLs manually
  */
-export * from './helpers/service-runtime';
+export declare const getServiceUrl: (serviceName: string) => string | undefined;

package/dist/env.js

@@ -1,20 +1,16 @@
-// lib/helpers/service-runtime.ts
-var toEnvKey = (name) => name.toUpperCase().replace(/-/g, "_");
-function getServicePort(serviceName, defaultPort = 8080) {
-  const envKey = `${toEnvKey(serviceName)}_PORT`;
-  const envValue = process.env[envKey];
-  if (envValue) {
-    const parsed = Number(envValue);
-    if (!Number.isNaN(parsed)) {
-      return parsed;
-    }
+// lib/env.ts
+var getServicePort = (serviceName) => {
+  const envVar = `${serviceName.toUpperCase().replace(/-/g, "_")}_PORT`;
+  const port = Number(process.env.PORT || process.env[envVar]);
+  if (!port || Number.isNaN(port)) {
+    throw new Error(`Port not found for service '${serviceName}'. ` + `Expected environment variable: ${envVar}. ` + `Run 'bun run generate-env' to create .env.local`);
   }
-  return defaultPort;
-}
-function getServiceUrl(serviceName) {
-  const envKey = `${toEnvKey(serviceName)}_URL`;
-  return process.env[envKey];
-}
+  return port;
+};
+var getServiceUrl = (serviceName) => {
+  const envVar = `${serviceName.toUpperCase().replace(/-/g, "_")}_URL`;
+  return process.env[envVar];
+};
 export {
   getServiceUrl,
   getServicePort

package/dist/helpers/discover-services.d.ts

@@ -1,5 +1,66 @@
 import type { K8sServiceConfig } from '../runtimes/doks/types';
 /**
+ * Options for discovering service configurations.
+ */
+export interface DiscoverOptions {
+    /** Path to services directory (relative to cwd or absolute) */
+    servicesDir?: string;
+    /** Filter services by name (regex) */
+    filter?: RegExp | string;
+    /** Include only these services (by name) */
+    include?: string[];
+    /** Exclude these services (by name) */
+    exclude?: string[];
+    /** Sort services by name (defaults to true) */
+    sort?: boolean;
+    /** Validate configurations (check for duplicate ports, missing required fields) */
+    validate?: boolean;
+    /** Auto-generate images for services without image specified */
+    autoImage?: boolean;
+    /** Registry for auto-generated images (defaults to pf.registry from package.json) */
+    registry?: string;
+    /** Inject environment variables into all services */
+    env?: Record<string, string>;
+    /** Tag filter: only include services with these tags */
+    tags?: string[];
+}
+/**
+ * Service discovery result with metadata.
+ */
+export interface DiscoveryResult {
+    /** Discovered service configurations */
+    configs: K8sServiceConfig[];
+    /** Total number of service files found */
+    totalFiles: number;
+    /** Number of services after filtering */
+    filteredCount: number;
+    /** Services that were skipped (skip: true) */
+    skipped: string[];
+    /** Validation warnings */
+    warnings: string[];
+}
+/**
+ * Smart service configuration discovery with filtering, validation, and auto-generation.
+ *
+ * @example
+ * ```typescript
+ * // Simple discovery (backward compatible)
+ * const configs = discoverServiceConfigs('services')
+ *
+ * // Advanced discovery with options
+ * const result = discoverServiceConfigsWithOptions({
+ *   servicesDir: 'services',
+ *   filter: /^api-/,  // Only services starting with 'api-'
+ *   exclude: ['api-test'],
+ *   validate: true,
+ *   env: { NODE_ENV: 'production' }
+ * })
+ * ```
+ */
+export declare function discoverServiceConfigsWithOptions(options?: DiscoverOptions): DiscoveryResult;
+/**
+ * Simple service discovery (backward compatible).
+ *
  * Auto-discovers all K8s service configurations from infra/services directory.
  * Each .ts file (except index.ts) should export a K8sServiceConfig as default.
  *
@@ -11,11 +72,7 @@ import type { K8sServiceConfig } from '../runtimes/doks/types';
  *
  * @example
  * ```typescript
- * // Config without image - will use pf.registry automatically
- * const config: K8sServiceConfig = {
- *   name: 'my-service',
- *   containerPort: 4001,
- * }
+ * const configs = discoverServiceConfigs('services')
  * ```
  */
 export declare function discoverServiceConfigs(servicesDir?: string): K8sServiceConfig[];

package/dist/helpers/docker-hub-image.d.ts

@@ -1,6 +1,5 @@
-import { type ImageConfig } from '../types';
 /**
- * Helper to create a Docker Hub image config.
+ * Helper to create a Docker Hub image string.
  * For official images, use 'library' as the registry.
  *
  * @example
@@ -11,4 +10,4 @@ import { type ImageConfig } from '../types';
  * // User image: bitnami/redis:7.0
  * dockerHubImage('redis', '7.0', 'bitnami')
  */
-export declare const dockerHubImage: (repository: string, tag: string, registry?: string) => ImageConfig;
+export declare const dockerHubImage: (repository: string, tag: string, registry?: string) => string;

package/dist/helpers/index.d.ts

@@ -1,9 +1,2 @@
-export * from './config';
 export * from './discover-services';
 export * from './docker-hub-image';
-export * from './droplet-builder';
-export * from './image';
-export * from './otel';
-export * from './service-builder';
-export * from './service-runtime';
-export * from './service-urls';