Configuration

class Config {
  /**
   * Create a configuration bag for the specified name (defaults to current project)
   */
  constructor(name?: string);

  // Plain configuration methods
  get<K extends string = string>(key: string, opts?: StringConfigOptions<K>): K | undefined;
  require<K extends string = string>(key: string, opts?: StringConfigOptions<K>): K;
  getBoolean(key: string): boolean | undefined;
  requireBoolean(key: string): boolean;
  getNumber(key: string, opts?: NumberConfigOptions): number | undefined;
  requireNumber(key: string, opts?: NumberConfigOptions): number;
  getObject<T>(key: string): T | undefined;
  requireObject<T>(key: string): T;

  // Secret configuration methods
  getSecret<K extends string = string>(key: string, opts?: StringConfigOptions<K>): Output<K | undefined>;
  requireSecret<K extends string = string>(key: string, opts?: StringConfigOptions<K>): Output<K>;
  getSecretBoolean(key: string): Output<boolean | undefined>;
  requireSecretBoolean(key: string): Output<boolean>;
  getSecretNumber(key: string, opts?: NumberConfigOptions): Output<number | undefined>;
  requireSecretNumber(key: string, opts?: NumberConfigOptions): Output<number>;
  getSecretObject<T>(key: string): Output<T | undefined>;
  requireSecretObject<T>(key: string): Output<T>;

  readonly name: string;
}

interface StringConfigOptions<K> {
  allowedValues?: K[];
}

interface NumberConfigOptions {
  min?: number;
  max?: number;
}

import { Config } from "@pulumi/pulumi";

const config = new Config();

// Get optional string value
const environment = config.get("environment") || "development";

// Get required string value
const region = config.require("region");

// Get typed values
const instanceCount = config.getNumber("instanceCount") || 1;
const enableFeature = config.getBoolean("enableFeature") || false;

// Get complex objects
interface DatabaseConfig {
  host: string;
  port: number;
  database: string;
}

const dbConfig = config.requireObject<DatabaseConfig>("database");

import { Config } from "@pulumi/pulumi";

const config = new Config();

// Get secret values (returns Output<T>)
const apiKey = config.requireSecret("apiKey");
const dbPassword = config.getSecret("dbPassword");

// Use secrets in resources
const database = new aws.rds.Instance("db", {
  username: "admin",
  password: dbPassword, // Output<string | undefined>
  // ... other properties
});

import { Config } from "@pulumi/pulumi";

// Default config uses current project name
const config = new Config();

// Named config for specific component
const redisConfig = new Config("redis");
const cacheSize = redisConfig.getNumber("cacheSize") || 128;

// Cross-project config
const sharedConfig = new Config("shared-infra");
const vpcId = sharedConfig.require("vpcId");

import { Config } from "@pulumi/pulumi";

const config = new Config();

// String with allowed values
const size = config.get("size", {
  allowedValues: ["small", "medium", "large"]
}) || "medium";

// Number with constraints
const port = config.getNumber("port", {
  min: 1024,
  max: 65535
}) || 8080;

import { Config } from "@pulumi/pulumi";

const config = new Config();

// Validate required configuration at program start
function validateConfig() {
  const required = ["region", "environment"];
  const missing = required.filter(key => !config.get(key));
  
  if (missing.length > 0) {
    throw new Error(`Missing required configuration: ${missing.join(", ")}`);
  }
}

validateConfig();

// Environment-specific defaults
function getInstanceType(): string {
  const env = config.require("environment");
  const instanceType = config.get("instanceType");
  
  if (instanceType) {
    return instanceType;
  }
  
  // Environment-based defaults
  switch (env) {
    case "production":
      return "t3.large";
    case "staging":
      return "t3.medium";
    default:
      return "t3.micro";
  }
}