@venturekit/core 0.0.0-dev.20260307234057

package/dist/presets.js

@@ -0,0 +1,345 @@
+"use strict";
+/**
+ * VentureKit Presets
+ *
+ * AWS-like preset sizes that expand to explicit configuration values.
+ * Users can use these as shortcuts and override specific fields.
+ *
+ * Merge order: PRESET ← USER_OVERRIDES
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATA_SAFETY_CONFIG = exports.DEFAULT_DATA_SAFETY = exports.PRESET_LARGE = exports.PRESET_MEDIUM = exports.PRESET_MICRO = exports.PRESET_NANO = void 0;
+exports.getPreset = getPreset;
+/**
+ * Default IAM config (empty - VentureKit handles basic permissions)
+ */
+const DEFAULT_IAM = {
+    managedPolicyArns: [],
+    inlineStatements: [],
+};
+/**
+ * Default subnet config
+ */
+const DEFAULT_SUBNETS = {
+    publicSubnets: { cidrMask: 24 },
+    privateSubnets: { cidrMask: 24 },
+    isolatedSubnets: undefined,
+};
+/**
+ * Default security group rules (allow all outbound)
+ */
+const DEFAULT_SECURITY_GROUP = {
+    lambdaSecurityGroupIngress: [],
+    lambdaSecurityGroupEgress: [
+        { protocol: '-1', fromPort: 0, toPort: 0, cidrBlocks: ['0.0.0.0/0'], description: 'Allow all outbound' },
+    ],
+};
+/**
+ * NANO preset - Minimal resources for development/testing
+ *
+ * Use case: Local development, CI/CD testing, proof of concepts
+ * Cost: ~$5-15/month
+ */
+exports.PRESET_NANO = {
+    lambda: {
+        memoryMb: 128,
+        timeoutSec: 10,
+        logRetentionDays: 7,
+        reservedConcurrency: undefined,
+        provisionedConcurrency: undefined,
+        tracingEnabled: false,
+        vpcEnabled: false,
+        runtime: 'nodejs20.x',
+        architecture: 'arm64',
+        iam: DEFAULT_IAM,
+        environmentVariables: {},
+        layers: [],
+    },
+    api: {
+        throttleRateLimit: 10,
+        throttleBurstLimit: 20,
+        detailedMetricsEnabled: false,
+    },
+    vpc: {
+        maxAzs: 2,
+        natGateways: 0,
+        cidr: '10.0.0.0/16',
+        flowLogsEnabled: false,
+        flowLogsRetentionDays: 7,
+        ...DEFAULT_SUBNETS,
+        enableVpcEndpoints: false,
+        ...DEFAULT_SECURITY_GROUP,
+    },
+    observability: {
+        logs: {
+            namePattern: '/venturekit/{name}/{env}/{function}',
+            streamNamePattern: '{instance}/{timestamp}',
+            retentionDays: 7,
+        },
+        metrics: {
+            namespace: 'VentureKit',
+            detailedMetricsEnabled: false,
+            defaultDimensions: {},
+        },
+        alarms: {
+            enabled: false,
+            topicArn: undefined,
+            evaluationPeriods: 3,
+            periodSec: 60,
+        },
+        tracing: {
+            enabled: false,
+            samplingRate: 0.05,
+        },
+    },
+    websocket: {
+        enabled: false,
+        routeSelectionExpression: '$request.body.action',
+        idleTimeoutSec: 600,
+        throttleRateLimit: 10,
+        throttleBurstLimit: 20,
+    },
+};
+/**
+ * MICRO preset - Small production workloads
+ *
+ * Use case: Early-stage startups, low-traffic APIs, internal tools
+ * Cost: ~$30-80/month
+ */
+exports.PRESET_MICRO = {
+    lambda: {
+        memoryMb: 256,
+        timeoutSec: 10,
+        logRetentionDays: 14,
+        reservedConcurrency: undefined,
+        provisionedConcurrency: undefined,
+        tracingEnabled: false,
+        vpcEnabled: true,
+        runtime: 'nodejs20.x',
+        architecture: 'arm64',
+        iam: DEFAULT_IAM,
+        environmentVariables: {},
+        layers: [],
+    },
+    api: {
+        throttleRateLimit: 50,
+        throttleBurstLimit: 100,
+        detailedMetricsEnabled: false,
+    },
+    vpc: {
+        maxAzs: 2,
+        natGateways: 1,
+        cidr: '10.0.0.0/16',
+        flowLogsEnabled: false,
+        flowLogsRetentionDays: 14,
+        ...DEFAULT_SUBNETS,
+        enableVpcEndpoints: true,
+        ...DEFAULT_SECURITY_GROUP,
+    },
+    observability: {
+        logs: {
+            namePattern: '/venturekit/{name}/{env}/{function}',
+            streamNamePattern: '{instance}/{timestamp}',
+            retentionDays: 14,
+        },
+        metrics: {
+            namespace: 'VentureKit',
+            detailedMetricsEnabled: false,
+            defaultDimensions: {},
+        },
+        alarms: {
+            enabled: false,
+            topicArn: undefined,
+            evaluationPeriods: 3,
+            periodSec: 60,
+        },
+        tracing: {
+            enabled: false,
+            samplingRate: 0.1,
+        },
+    },
+    websocket: {
+        enabled: false,
+        routeSelectionExpression: '$request.body.action',
+        idleTimeoutSec: 600,
+        throttleRateLimit: 50,
+        throttleBurstLimit: 100,
+    },
+};
+/**
+ * MEDIUM preset - Standard production workloads
+ *
+ * Use case: Growing startups, moderate traffic, customer-facing APIs
+ * Cost: ~$100-300/month
+ */
+exports.PRESET_MEDIUM = {
+    lambda: {
+        memoryMb: 512,
+        timeoutSec: 15,
+        logRetentionDays: 30,
+        reservedConcurrency: undefined,
+        provisionedConcurrency: undefined,
+        tracingEnabled: true,
+        vpcEnabled: true,
+        runtime: 'nodejs20.x',
+        architecture: 'arm64',
+        iam: DEFAULT_IAM,
+        environmentVariables: {},
+        layers: [],
+    },
+    api: {
+        throttleRateLimit: 100,
+        throttleBurstLimit: 200,
+        detailedMetricsEnabled: true,
+    },
+    vpc: {
+        maxAzs: 2,
+        natGateways: 1,
+        cidr: '10.0.0.0/16',
+        flowLogsEnabled: true,
+        flowLogsRetentionDays: 30,
+        ...DEFAULT_SUBNETS,
+        isolatedSubnets: { cidrMask: 24 },
+        enableVpcEndpoints: true,
+        ...DEFAULT_SECURITY_GROUP,
+    },
+    observability: {
+        logs: {
+            namePattern: '/venturekit/{name}/{env}/{function}',
+            streamNamePattern: '{instance}/{timestamp}',
+            retentionDays: 30,
+        },
+        metrics: {
+            namespace: 'VentureKit',
+            detailedMetricsEnabled: true,
+            defaultDimensions: {},
+        },
+        alarms: {
+            enabled: true,
+            topicArn: undefined,
+            evaluationPeriods: 3,
+            periodSec: 60,
+        },
+        tracing: {
+            enabled: true,
+            samplingRate: 0.25,
+        },
+    },
+    websocket: {
+        enabled: false,
+        routeSelectionExpression: '$request.body.action',
+        idleTimeoutSec: 600,
+        throttleRateLimit: 100,
+        throttleBurstLimit: 200,
+    },
+};
+/**
+ * LARGE preset - High-traffic production workloads
+ *
+ * Use case: Scaled startups, high traffic, mission-critical APIs
+ * Cost: ~$500+/month
+ */
+exports.PRESET_LARGE = {
+    lambda: {
+        memoryMb: 1024,
+        timeoutSec: 30,
+        logRetentionDays: 90,
+        reservedConcurrency: undefined,
+        provisionedConcurrency: undefined,
+        tracingEnabled: true,
+        vpcEnabled: true,
+        runtime: 'nodejs20.x',
+        architecture: 'arm64',
+        iam: DEFAULT_IAM,
+        environmentVariables: {},
+        layers: [],
+    },
+    api: {
+        throttleRateLimit: 500,
+        throttleBurstLimit: 1000,
+        detailedMetricsEnabled: true,
+    },
+    vpc: {
+        maxAzs: 3,
+        natGateways: 2,
+        cidr: '10.0.0.0/16',
+        flowLogsEnabled: true,
+        flowLogsRetentionDays: 90,
+        ...DEFAULT_SUBNETS,
+        isolatedSubnets: { cidrMask: 24 },
+        enableVpcEndpoints: true,
+        ...DEFAULT_SECURITY_GROUP,
+    },
+    observability: {
+        logs: {
+            namePattern: '/venturekit/{name}/{env}/{function}',
+            streamNamePattern: '{instance}/{timestamp}',
+            retentionDays: 90,
+        },
+        metrics: {
+            namespace: 'VentureKit',
+            detailedMetricsEnabled: true,
+            defaultDimensions: {},
+        },
+        alarms: {
+            enabled: true,
+            topicArn: undefined,
+            evaluationPeriods: 3,
+            periodSec: 60,
+        },
+        tracing: {
+            enabled: true,
+            samplingRate: 0.5,
+        },
+    },
+    websocket: {
+        enabled: false,
+        routeSelectionExpression: '$request.body.action',
+        idleTimeoutSec: 600,
+        throttleRateLimit: 500,
+        throttleBurstLimit: 1000,
+    },
+};
+/**
+ * Get preset configuration by name
+ */
+function getPreset(preset) {
+    switch (preset) {
+        case 'nano':
+            return exports.PRESET_NANO;
+        case 'micro':
+            return exports.PRESET_MICRO;
+        case 'medium':
+            return exports.PRESET_MEDIUM;
+        case 'large':
+            return exports.PRESET_LARGE;
+        default:
+            throw new Error(`Unknown preset: ${preset}`);
+    }
+}
+/**
+ * Default data safety per environment
+ */
+exports.DEFAULT_DATA_SAFETY = {
+    dev: 'relaxed',
+    stage: 'standard',
+    prod: 'strict',
+};
+/**
+ * Data safety configurations
+ */
+exports.DATA_SAFETY_CONFIG = {
+    strict: {
+        removalPolicy: 'retain',
+        deletionProtection: true,
+    },
+    standard: {
+        removalPolicy: 'retain',
+        deletionProtection: true,
+    },
+    relaxed: {
+        removalPolicy: 'destroy',
+        deletionProtection: false,
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"presets.js","sourceRoot":"","sources":["../src/presets.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * VentureKit Presets\n * \n * AWS-like preset sizes that expand to explicit configuration values.\n * Users can use these as shortcuts and override specific fields.\n * \n * Merge order: PRESET ← USER_OVERRIDES\n */\n\nimport { LambdaEnvConfig } from './types/lambda';\nimport { ApiEnvConfig } from './types/api';\nimport { VpcEnvConfig } from './types/vpc';\nimport { ObservabilityEnvConfig } from './types/observability';\nimport { WebSocketEnvConfig } from './types/websocket';\nimport { Preset, DataSafety } from './types/env';\n\n/**\n * Preset configuration (fully specified, no optionals)\n */\nexport interface PresetConfig {\n  lambda: LambdaEnvConfig;\n  api: Omit<ApiEnvConfig, 'cors' | 'customDomain'>;\n  vpc: VpcEnvConfig;\n  observability: ObservabilityEnvConfig;\n  websocket: WebSocketEnvConfig;\n}\n\n/**\n * Default IAM config (empty - VentureKit handles basic permissions)\n */\nconst DEFAULT_IAM = {\n  managedPolicyArns: [],\n  inlineStatements: [],\n};\n\n/**\n * Default subnet config\n */\nconst DEFAULT_SUBNETS = {\n  publicSubnets: { cidrMask: 24 },\n  privateSubnets: { cidrMask: 24 },\n  isolatedSubnets: undefined,\n};\n\n/**\n * Default security group rules (allow all outbound)\n */\nconst DEFAULT_SECURITY_GROUP = {\n  lambdaSecurityGroupIngress: [],\n  lambdaSecurityGroupEgress: [\n    { protocol: '-1', fromPort: 0, toPort: 0, cidrBlocks: ['0.0.0.0/0'], description: 'Allow all outbound' },\n  ],\n};\n\n/**\n * NANO preset - Minimal resources for development/testing\n * \n * Use case: Local development, CI/CD testing, proof of concepts\n * Cost: ~$5-15/month\n */\nexport const PRESET_NANO: PresetConfig = {\n  lambda: {\n    memoryMb: 128,\n    timeoutSec: 10,\n    logRetentionDays: 7,\n    reservedConcurrency: undefined,\n    provisionedConcurrency: undefined,\n    tracingEnabled: false,\n    vpcEnabled: false,\n    runtime: 'nodejs20.x',\n    architecture: 'arm64',\n    iam: DEFAULT_IAM,\n    environmentVariables: {},\n    layers: [],\n  },\n  api: {\n    throttleRateLimit: 10,\n    throttleBurstLimit: 20,\n    detailedMetricsEnabled: false,\n  },\n  vpc: {\n    maxAzs: 2,\n    natGateways: 0,\n    cidr: '10.0.0.0/16',\n    flowLogsEnabled: false,\n    flowLogsRetentionDays: 7,\n    ...DEFAULT_SUBNETS,\n    enableVpcEndpoints: false,\n    ...DEFAULT_SECURITY_GROUP,\n  },\n  observability: {\n    logs: {\n      namePattern: '/venturekit/{name}/{env}/{function}',\n      streamNamePattern: '{instance}/{timestamp}',\n      retentionDays: 7,\n    },\n    metrics: {\n      namespace: 'VentureKit',\n      detailedMetricsEnabled: false,\n      defaultDimensions: {},\n    },\n    alarms: {\n      enabled: false,\n      topicArn: undefined,\n      evaluationPeriods: 3,\n      periodSec: 60,\n    },\n    tracing: {\n      enabled: false,\n      samplingRate: 0.05,\n    },\n  },\n  websocket: {\n    enabled: false,\n    routeSelectionExpression: '$request.body.action',\n    idleTimeoutSec: 600,\n    throttleRateLimit: 10,\n    throttleBurstLimit: 20,\n  },\n};\n\n/**\n * MICRO preset - Small production workloads\n * \n * Use case: Early-stage startups, low-traffic APIs, internal tools\n * Cost: ~$30-80/month\n */\nexport const PRESET_MICRO: PresetConfig = {\n  lambda: {\n    memoryMb: 256,\n    timeoutSec: 10,\n    logRetentionDays: 14,\n    reservedConcurrency: undefined,\n    provisionedConcurrency: undefined,\n    tracingEnabled: false,\n    vpcEnabled: true,\n    runtime: 'nodejs20.x',\n    architecture: 'arm64',\n    iam: DEFAULT_IAM,\n    environmentVariables: {},\n    layers: [],\n  },\n  api: {\n    throttleRateLimit: 50,\n    throttleBurstLimit: 100,\n    detailedMetricsEnabled: false,\n  },\n  vpc: {\n    maxAzs: 2,\n    natGateways: 1,\n    cidr: '10.0.0.0/16',\n    flowLogsEnabled: false,\n    flowLogsRetentionDays: 14,\n    ...DEFAULT_SUBNETS,\n    enableVpcEndpoints: true,\n    ...DEFAULT_SECURITY_GROUP,\n  },\n  observability: {\n    logs: {\n      namePattern: '/venturekit/{name}/{env}/{function}',\n      streamNamePattern: '{instance}/{timestamp}',\n      retentionDays: 14,\n    },\n    metrics: {\n      namespace: 'VentureKit',\n      detailedMetricsEnabled: false,\n      defaultDimensions: {},\n    },\n    alarms: {\n      enabled: false,\n      topicArn: undefined,\n      evaluationPeriods: 3,\n      periodSec: 60,\n    },\n    tracing: {\n      enabled: false,\n      samplingRate: 0.1,\n    },\n  },\n  websocket: {\n    enabled: false,\n    routeSelectionExpression: '$request.body.action',\n    idleTimeoutSec: 600,\n    throttleRateLimit: 50,\n    throttleBurstLimit: 100,\n  },\n};\n\n/**\n * MEDIUM preset - Standard production workloads\n * \n * Use case: Growing startups, moderate traffic, customer-facing APIs\n * Cost: ~$100-300/month\n */\nexport const PRESET_MEDIUM: PresetConfig = {\n  lambda: {\n    memoryMb: 512,\n    timeoutSec: 15,\n    logRetentionDays: 30,\n    reservedConcurrency: undefined,\n    provisionedConcurrency: undefined,\n    tracingEnabled: true,\n    vpcEnabled: true,\n    runtime: 'nodejs20.x',\n    architecture: 'arm64',\n    iam: DEFAULT_IAM,\n    environmentVariables: {},\n    layers: [],\n  },\n  api: {\n    throttleRateLimit: 100,\n    throttleBurstLimit: 200,\n    detailedMetricsEnabled: true,\n  },\n  vpc: {\n    maxAzs: 2,\n    natGateways: 1,\n    cidr: '10.0.0.0/16',\n    flowLogsEnabled: true,\n    flowLogsRetentionDays: 30,\n    ...DEFAULT_SUBNETS,\n    isolatedSubnets: { cidrMask: 24 },\n    enableVpcEndpoints: true,\n    ...DEFAULT_SECURITY_GROUP,\n  },\n  observability: {\n    logs: {\n      namePattern: '/venturekit/{name}/{env}/{function}',\n      streamNamePattern: '{instance}/{timestamp}',\n      retentionDays: 30,\n    },\n    metrics: {\n      namespace: 'VentureKit',\n      detailedMetricsEnabled: true,\n      defaultDimensions: {},\n    },\n    alarms: {\n      enabled: true,\n      topicArn: undefined,\n      evaluationPeriods: 3,\n      periodSec: 60,\n    },\n    tracing: {\n      enabled: true,\n      samplingRate: 0.25,\n    },\n  },\n  websocket: {\n    enabled: false,\n    routeSelectionExpression: '$request.body.action',\n    idleTimeoutSec: 600,\n    throttleRateLimit: 100,\n    throttleBurstLimit: 200,\n  },\n};\n\n/**\n * LARGE preset - High-traffic production workloads\n * \n * Use case: Scaled startups, high traffic, mission-critical APIs\n * Cost: ~$500+/month\n */\nexport const PRESET_LARGE: PresetConfig = {\n  lambda: {\n    memoryMb: 1024,\n    timeoutSec: 30,\n    logRetentionDays: 90,\n    reservedConcurrency: undefined,\n    provisionedConcurrency: undefined,\n    tracingEnabled: true,\n    vpcEnabled: true,\n    runtime: 'nodejs20.x',\n    architecture: 'arm64',\n    iam: DEFAULT_IAM,\n    environmentVariables: {},\n    layers: [],\n  },\n  api: {\n    throttleRateLimit: 500,\n    throttleBurstLimit: 1000,\n    detailedMetricsEnabled: true,\n  },\n  vpc: {\n    maxAzs: 3,\n    natGateways: 2,\n    cidr: '10.0.0.0/16',\n    flowLogsEnabled: true,\n    flowLogsRetentionDays: 90,\n    ...DEFAULT_SUBNETS,\n    isolatedSubnets: { cidrMask: 24 },\n    enableVpcEndpoints: true,\n    ...DEFAULT_SECURITY_GROUP,\n  },\n  observability: {\n    logs: {\n      namePattern: '/venturekit/{name}/{env}/{function}',\n      streamNamePattern: '{instance}/{timestamp}',\n      retentionDays: 90,\n    },\n    metrics: {\n      namespace: 'VentureKit',\n      detailedMetricsEnabled: true,\n      defaultDimensions: {},\n    },\n    alarms: {\n      enabled: true,\n      topicArn: undefined,\n      evaluationPeriods: 3,\n      periodSec: 60,\n    },\n    tracing: {\n      enabled: true,\n      samplingRate: 0.5,\n    },\n  },\n  websocket: {\n    enabled: false,\n    routeSelectionExpression: '$request.body.action',\n    idleTimeoutSec: 600,\n    throttleRateLimit: 500,\n    throttleBurstLimit: 1000,\n  },\n};\n\n/**\n * Get preset configuration by name\n */\nexport function getPreset(preset: Preset): PresetConfig {\n  switch (preset) {\n    case 'nano':\n      return PRESET_NANO;\n    case 'micro':\n      return PRESET_MICRO;\n    case 'medium':\n      return PRESET_MEDIUM;\n    case 'large':\n      return PRESET_LARGE;\n    default:\n      throw new Error(`Unknown preset: ${preset}`);\n  }\n}\n\n/**\n * Default data safety per environment\n */\nexport const DEFAULT_DATA_SAFETY: Record<string, DataSafety> = {\n  dev: 'relaxed',\n  stage: 'standard',\n  prod: 'strict',\n};\n\n/**\n * Data safety configurations\n */\nexport const DATA_SAFETY_CONFIG: Record<DataSafety, { \n  removalPolicy: 'retain' | 'destroy';\n  deletionProtection: boolean;\n}> = {\n  strict: {\n    removalPolicy: 'retain',\n    deletionProtection: true,\n  },\n  standard: {\n    removalPolicy: 'retain',\n    deletionProtection: true,\n  },\n  relaxed: {\n    removalPolicy: 'destroy',\n    deletionProtection: false,\n  },\n};\n"]}

package/dist/resolve.d.ts

@@ -0,0 +1,28 @@
+/**
+ * VentureKit Configuration Resolution
+ *
+ * Merges base config + env config input into a fully resolved configuration.
+ *
+ * Merge order: PRESET ← USER_OVERRIDES
+ *
+ * This ensures:
+ * - Presets provide sensible defaults
+ * - Users can override any specific field
+ * - Final config has no undefined values (except where explicitly typed)
+ */
+import { BaseConfig } from './types/base';
+import { SecurityConfig } from './types/security';
+import { EnvConfig, EnvConfigInput, Environment } from './types/env';
+import { ResolvedConfig } from './types/resolved';
+/**
+ * Resolve environment configuration
+ *
+ * Takes user input and produces a fully resolved EnvConfig.
+ */
+export declare function resolveEnvConfig(env: Environment, input: EnvConfigInput): EnvConfig;
+/**
+ * Resolve full configuration
+ *
+ * Merges base config + security config + env config into a complete ResolvedConfig.
+ */
+export declare function resolveConfig(base: BaseConfig, security: SecurityConfig, env: Environment, envInput: EnvConfigInput): ResolvedConfig;

package/dist/resolve.js

@@ -0,0 +1,188 @@
+"use strict";
+/**
+ * VentureKit Configuration Resolution
+ *
+ * Merges base config + env config input into a fully resolved configuration.
+ *
+ * Merge order: PRESET ← USER_OVERRIDES
+ *
+ * This ensures:
+ * - Presets provide sensible defaults
+ * - Users can override any specific field
+ * - Final config has no undefined values (except where explicitly typed)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEnvConfig = resolveEnvConfig;
+exports.resolveConfig = resolveConfig;
+const presets_1 = require("./presets");
+/**
+ * Resolve Lambda configuration
+ */
+function resolveLambda(preset, input) {
+    if (!input)
+        return preset.lambda;
+    const { iam, ...rest } = input;
+    return {
+        ...preset.lambda,
+        ...rest,
+        iam: iam ? {
+            managedPolicyArns: iam.managedPolicyArns ?? preset.lambda.iam.managedPolicyArns,
+            inlineStatements: iam.inlineStatements ?? preset.lambda.iam.inlineStatements,
+        } : preset.lambda.iam,
+    };
+}
+/**
+ * Resolve API configuration
+ */
+function resolveApi(preset, input) {
+    const base = {
+        ...preset.api,
+        cors: undefined,
+        customDomain: undefined,
+    };
+    if (!input)
+        return base;
+    const { cors, customDomain, ...rest } = input;
+    const result = { ...base, ...rest };
+    // Handle CORS separately (partial merge)
+    if (cors) {
+        const defaultCors = {
+            allowOrigins: ['*'],
+            allowMethods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+            allowHeaders: ['Content-Type', 'Authorization'],
+            allowCredentials: false,
+            maxAgeSec: 86400,
+        };
+        result.cors = { ...defaultCors, ...cors };
+    }
+    // Custom domain is all-or-nothing
+    if (customDomain) {
+        result.customDomain = customDomain;
+    }
+    return result;
+}
+/**
+ * Resolve VPC configuration
+ */
+function resolveVpc(preset, input) {
+    if (!input)
+        return preset.vpc;
+    const { publicSubnets, privateSubnets, isolatedSubnets, ...rest } = input;
+    const result = { ...preset.vpc, ...rest };
+    if (publicSubnets) {
+        result.publicSubnets = { ...preset.vpc.publicSubnets, ...publicSubnets };
+    }
+    if (privateSubnets) {
+        result.privateSubnets = { ...preset.vpc.privateSubnets, ...privateSubnets };
+    }
+    if (isolatedSubnets !== undefined) {
+        if (isolatedSubnets && preset.vpc.isolatedSubnets) {
+            result.isolatedSubnets = { ...preset.vpc.isolatedSubnets, ...isolatedSubnets };
+        }
+        else if (isolatedSubnets) {
+            result.isolatedSubnets = { cidrMask: isolatedSubnets.cidrMask ?? 24 };
+        }
+        else {
+            result.isolatedSubnets = undefined;
+        }
+    }
+    return result;
+}
+/**
+ * Resolve Observability configuration
+ */
+function resolveObservability(preset, input) {
+    if (!input)
+        return preset.observability;
+    const { logs, metrics, alarms, tracing, ...shorthands } = input;
+    // Start with preset
+    const result = { ...preset.observability };
+    // Apply nested configs
+    if (logs) {
+        result.logs = { ...result.logs, ...logs };
+    }
+    if (metrics) {
+        result.metrics = { ...result.metrics, ...metrics };
+    }
+    if (alarms) {
+        result.alarms = { ...result.alarms, ...alarms };
+    }
+    if (tracing) {
+        result.tracing = { ...result.tracing, ...tracing };
+    }
+    // Apply shorthands
+    if (shorthands.alarmsEnabled !== undefined) {
+        result.alarms.enabled = shorthands.alarmsEnabled;
+    }
+    if (shorthands.tracingEnabled !== undefined) {
+        result.tracing.enabled = shorthands.tracingEnabled;
+    }
+    if (shorthands.logRetentionDays !== undefined) {
+        result.logs.retentionDays = shorthands.logRetentionDays;
+    }
+    if (shorthands.detailedMetricsEnabled !== undefined) {
+        result.metrics.detailedMetricsEnabled = shorthands.detailedMetricsEnabled;
+    }
+    return result;
+}
+/**
+ * Resolve WebSocket configuration
+ */
+function resolveWebSocket(preset, input) {
+    if (!input)
+        return preset.websocket;
+    return { ...preset.websocket, ...input };
+}
+/**
+ * Resolve environment configuration
+ *
+ * Takes user input and produces a fully resolved EnvConfig.
+ */
+function resolveEnvConfig(env, input) {
+    // Determine preset (default to 'micro' if not specified)
+    const presetName = input.preset ?? 'micro';
+    const preset = (0, presets_1.getPreset)(presetName);
+    // Determine data safety (default based on environment)
+    const dataSafety = input.dataSafety ?? presets_1.DEFAULT_DATA_SAFETY[env];
+    return {
+        env,
+        dataSafety,
+        lambda: resolveLambda(preset, input.lambda),
+        api: resolveApi(preset, input.api),
+        vpc: resolveVpc(preset, input.vpc),
+        observability: resolveObservability(preset, input.observability),
+        websocket: resolveWebSocket(preset, input.websocket),
+    };
+}
+/**
+ * Resolve full configuration
+ *
+ * Merges base config + security config + env config into a complete ResolvedConfig.
+ */
+function resolveConfig(base, security, env, envInput) {
+    const envConfig = resolveEnvConfig(env, envInput);
+    return {
+        // From base
+        name: base.name,
+        displayName: base.displayName,
+        region: base.region,
+        // From security
+        scopes: security.scopes,
+        appClients: security.appClients,
+        // From env
+        env: envConfig.env,
+        dataSafety: envConfig.dataSafety,
+        lambda: envConfig.lambda,
+        api: envConfig.api,
+        vpc: envConfig.vpc,
+        observability: envConfig.observability,
+        websocket: envConfig.websocket,
+        // Auto-generated
+        tags: {
+            Project: base.name,
+            Environment: env,
+            ManagedBy: 'venturekit',
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resolve.js","sourceRoot":"","sources":["../src/resolve.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * VentureKit Configuration Resolution\n * \n * Merges base config + env config input into a fully resolved configuration.\n * \n * Merge order: PRESET ← USER_OVERRIDES\n * \n * This ensures:\n * - Presets provide sensible defaults\n * - Users can override any specific field\n * - Final config has no undefined values (except where explicitly typed)\n */\n\nimport { BaseConfig } from './types/base';\nimport { SecurityConfig } from './types/security';\nimport { EnvConfig, EnvConfigInput, Environment, DataSafety } from './types/env';\nimport { LambdaEnvConfig } from './types/lambda';\nimport { ApiEnvConfig, CorsConfig } from './types/api';\nimport { VpcEnvConfig } from './types/vpc';\nimport { ObservabilityEnvConfig } from './types/observability';\nimport { WebSocketEnvConfig } from './types/websocket';\nimport { ResolvedConfig } from './types/resolved';\nimport { getPreset, DEFAULT_DATA_SAFETY, PresetConfig } from './presets';\n\n/**\n * Resolve Lambda configuration\n */\nfunction resolveLambda(\n  preset: PresetConfig,\n  input: EnvConfigInput['lambda']\n): LambdaEnvConfig {\n  if (!input) return preset.lambda;\n  \n  const { iam, ...rest } = input;\n  \n  return {\n    ...preset.lambda,\n    ...rest,\n    iam: iam ? {\n      managedPolicyArns: iam.managedPolicyArns ?? preset.lambda.iam.managedPolicyArns,\n      inlineStatements: iam.inlineStatements ?? preset.lambda.iam.inlineStatements,\n    } : preset.lambda.iam,\n  };\n}\n\n/**\n * Resolve API configuration\n */\nfunction resolveApi(\n  preset: PresetConfig,\n  input: EnvConfigInput['api']\n): ApiEnvConfig {\n  const base: ApiEnvConfig = {\n    ...preset.api,\n    cors: undefined,\n    customDomain: undefined,\n  };\n  \n  if (!input) return base;\n  \n  const { cors, customDomain, ...rest } = input;\n  \n  const result: ApiEnvConfig = { ...base, ...rest };\n  \n  // Handle CORS separately (partial merge)\n  if (cors) {\n    const defaultCors: CorsConfig = {\n      allowOrigins: ['*'],\n      allowMethods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],\n      allowHeaders: ['Content-Type', 'Authorization'],\n      allowCredentials: false,\n      maxAgeSec: 86400,\n    };\n    result.cors = { ...defaultCors, ...cors };\n  }\n  \n  // Custom domain is all-or-nothing\n  if (customDomain) {\n    result.customDomain = customDomain;\n  }\n  \n  return result;\n}\n\n/**\n * Resolve VPC configuration\n */\nfunction resolveVpc(\n  preset: PresetConfig,\n  input: EnvConfigInput['vpc']\n): VpcEnvConfig {\n  if (!input) return preset.vpc;\n  \n  const { publicSubnets, privateSubnets, isolatedSubnets, ...rest } = input;\n  \n  const result: VpcEnvConfig = { ...preset.vpc, ...rest };\n  \n  if (publicSubnets) {\n    result.publicSubnets = { ...preset.vpc.publicSubnets, ...publicSubnets };\n  }\n  if (privateSubnets) {\n    result.privateSubnets = { ...preset.vpc.privateSubnets, ...privateSubnets };\n  }\n  if (isolatedSubnets !== undefined) {\n    if (isolatedSubnets && preset.vpc.isolatedSubnets) {\n      result.isolatedSubnets = { ...preset.vpc.isolatedSubnets, ...isolatedSubnets };\n    } else if (isolatedSubnets) {\n      result.isolatedSubnets = { cidrMask: isolatedSubnets.cidrMask ?? 24 };\n    } else {\n      result.isolatedSubnets = undefined;\n    }\n  }\n  \n  return result;\n}\n\n/**\n * Resolve Observability configuration\n */\nfunction resolveObservability(\n  preset: PresetConfig,\n  input: EnvConfigInput['observability']\n): ObservabilityEnvConfig {\n  if (!input) return preset.observability;\n  \n  const { logs, metrics, alarms, tracing, ...shorthands } = input;\n  \n  // Start with preset\n  const result = { ...preset.observability };\n  \n  // Apply nested configs\n  if (logs) {\n    result.logs = { ...result.logs, ...logs };\n  }\n  if (metrics) {\n    result.metrics = { ...result.metrics, ...metrics };\n  }\n  if (alarms) {\n    result.alarms = { ...result.alarms, ...alarms };\n  }\n  if (tracing) {\n    result.tracing = { ...result.tracing, ...tracing };\n  }\n  \n  // Apply shorthands\n  if (shorthands.alarmsEnabled !== undefined) {\n    result.alarms.enabled = shorthands.alarmsEnabled;\n  }\n  if (shorthands.tracingEnabled !== undefined) {\n    result.tracing.enabled = shorthands.tracingEnabled;\n  }\n  if (shorthands.logRetentionDays !== undefined) {\n    result.logs.retentionDays = shorthands.logRetentionDays;\n  }\n  if (shorthands.detailedMetricsEnabled !== undefined) {\n    result.metrics.detailedMetricsEnabled = shorthands.detailedMetricsEnabled;\n  }\n  \n  return result;\n}\n\n/**\n * Resolve WebSocket configuration\n */\nfunction resolveWebSocket(\n  preset: PresetConfig,\n  input: EnvConfigInput['websocket']\n): WebSocketEnvConfig {\n  if (!input) return preset.websocket;\n  return { ...preset.websocket, ...input };\n}\n\n/**\n * Resolve environment configuration\n * \n * Takes user input and produces a fully resolved EnvConfig.\n */\nexport function resolveEnvConfig(\n  env: Environment,\n  input: EnvConfigInput\n): EnvConfig {\n  // Determine preset (default to 'micro' if not specified)\n  const presetName = input.preset ?? 'micro';\n  const preset = getPreset(presetName);\n  \n  // Determine data safety (default based on environment)\n  const dataSafety = input.dataSafety ?? DEFAULT_DATA_SAFETY[env];\n  \n  return {\n    env,\n    dataSafety,\n    lambda: resolveLambda(preset, input.lambda),\n    api: resolveApi(preset, input.api),\n    vpc: resolveVpc(preset, input.vpc),\n    observability: resolveObservability(preset, input.observability),\n    websocket: resolveWebSocket(preset, input.websocket),\n  };\n}\n\n/**\n * Resolve full configuration\n * \n * Merges base config + security config + env config into a complete ResolvedConfig.\n */\nexport function resolveConfig(\n  base: BaseConfig,\n  security: SecurityConfig,\n  env: Environment,\n  envInput: EnvConfigInput\n): ResolvedConfig {\n  const envConfig = resolveEnvConfig(env, envInput);\n  \n  return {\n    // From base\n    name: base.name,\n    displayName: base.displayName,\n    region: base.region,\n    \n    // From security\n    scopes: security.scopes,\n    appClients: security.appClients,\n    \n    // From env\n    env: envConfig.env,\n    dataSafety: envConfig.dataSafety,\n    lambda: envConfig.lambda,\n    api: envConfig.api,\n    vpc: envConfig.vpc,\n    observability: envConfig.observability,\n    websocket: envConfig.websocket,\n    \n    // Auto-generated\n    tags: {\n      Project: base.name,\n      Environment: env,\n      ManagedBy: 'venturekit',\n    },\n  };\n}\n"]}

package/dist/types/api.d.ts

@@ -0,0 +1,54 @@
+/**
+ * API Gateway Environment Configuration
+ *
+ * Controls rate limiting and API behavior per environment.
+ * All fields are REQUIRED - no implicit defaults at the type level.
+ */
+/**
+ * CORS configuration
+ */
+export interface CorsConfig {
+    /** Allowed origins (e.g., ['https://app.example.com']) */
+    allowOrigins: string[];
+    /** Allowed HTTP methods */
+    allowMethods: string[];
+    /** Allowed headers */
+    allowHeaders: string[];
+    /** Allow credentials */
+    allowCredentials: boolean;
+    /** Max age in seconds for preflight cache */
+    maxAgeSec: number;
+}
+/**
+ * Custom domain configuration
+ */
+export interface CustomDomainConfig {
+    /** Domain name (e.g., 'api.example.com') */
+    domainName: string;
+    /** ACM certificate ARN */
+    certificateArn: string;
+}
+/**
+ * API Gateway configuration
+ *
+ * All fields required - use presets or explicit values.
+ */
+export interface ApiEnvConfig {
+    /** Steady-state request rate limit (requests per second) */
+    throttleRateLimit: number;
+    /** Burst capacity (concurrent requests) */
+    throttleBurstLimit: number;
+    /** Enable detailed CloudWatch metrics */
+    detailedMetricsEnabled: boolean;
+    /** CORS configuration (undefined = no CORS) */
+    cors: CorsConfig | undefined;
+    /** Custom domain (undefined = use default API Gateway domain) */
+    customDomain: CustomDomainConfig | undefined;
+}
+/**
+ * API configuration input (for user overrides)
+ */
+export type ApiEnvConfigInput = Partial<Omit<ApiEnvConfig, 'cors' | 'customDomain'>> & {
+    cors?: Partial<CorsConfig>;
+    customDomain?: CustomDomainConfig;
+};