@fjall/generator 0.88.4

package/dist/src/ast/astComputeParser.d.ts

@@ -0,0 +1,4 @@
+import { type ParsedInfrastructure } from "./astInfrastructureParser.js";
+import { type ApplicationResourcePlan } from "../schemas/resourceSchemas.js";
+/** Convert parsed compute resources to plan format */
+export declare function convertComputeResources(parsed: ParsedInfrastructure, plan: ApplicationResourcePlan): ApplicationResourcePlan["compute"];

package/dist/src/ast/astComputeParser.js

@@ -0,0 +1,427 @@
+import { isPlainObject, isParsedObject, isIdentifierRef, isExpressionRef, isCallRef, asString, asNumber, asBoolean, asStringArray, asStringUnion, captureExtraProperties, } from "./astInfrastructureParser.js";
+import { COMPUTE_TYPES, DEPLOYMENT_TYPES, EC2_INSTANCE_TYPES, ECS_CAPACITY_PROVIDERS, } from "../schemas/constants.js";
+const MAX_DATABASE_CONNECTION_INDICES = 10;
+const LOAD_BALANCER_TYPES = ["public", "internal"];
+function isEnvironmentRecord(value) {
+    return value !== undefined && isPlainObject(value);
+}
+function parseContainerSecretsImport(secretsImportValue) {
+    if (!isParsedObject(secretsImportValue))
+        return undefined;
+    const result = {};
+    for (const [key, val] of Object.entries(secretsImportValue)) {
+        if (isParsedObject(val)) {
+            const id = asString(val.id);
+            const name = asString(val.name);
+            if (id && name) {
+                result[key] = { id, name, field: asString(val.field) };
+            }
+        }
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+function parseContainerHealthCheck(healthCheckValue) {
+    if (!isParsedObject(healthCheckValue))
+        return undefined;
+    const cmd = asStringArray(healthCheckValue.command);
+    if (!cmd || cmd.length === 0)
+        return undefined;
+    return {
+        command: cmd,
+        interval: asNumber(healthCheckValue.interval),
+        timeout: asNumber(healthCheckValue.timeout),
+        retries: asNumber(healthCheckValue.retries),
+        startPeriod: asNumber(healthCheckValue.startPeriod),
+    };
+}
+function parseServiceContainer(c) {
+    const CONTAINER_KNOWN_KEYS = new Set([
+        "name",
+        "image",
+        "port",
+        "environment",
+        "essential",
+        "command",
+        "entryPoint",
+        "secretsImport",
+        "secrets",
+        "healthCheck",
+    ]);
+    const extras = captureExtraProperties(c, CONTAINER_KNOWN_KEYS);
+    return {
+        name: asString(c.name),
+        image: asString(c.image),
+        port: asNumber(c.port),
+        environment: isEnvironmentRecord(c.environment) ? c.environment : undefined,
+        essential: asBoolean(c.essential),
+        command: asStringArray(c.command),
+        entryPoint: asStringArray(c.entryPoint),
+        secretsImport: parseContainerSecretsImport(c.secretsImport),
+        ssmSecrets: asStringArray(c.secrets),
+        healthCheck: parseContainerHealthCheck(c.healthCheck),
+        extraProperties: extras.length > 0 ? extras : undefined,
+    };
+}
+function parseServiceRouting(routingVal) {
+    if (Array.isArray(routingVal)) {
+        return routingVal.filter(isParsedObject).map((rule) => ({
+            path: asString(rule.path),
+            host: asString(rule.host),
+            priority: asNumber(rule.priority),
+            healthCheckPath: asString(rule.healthCheckPath),
+        }));
+    }
+    if (!isParsedObject(routingVal))
+        return undefined;
+    return {
+        path: asString(routingVal.path),
+        host: asString(routingVal.host),
+        priority: asNumber(routingVal.priority),
+        healthCheckPath: asString(routingVal.healthCheckPath),
+    };
+}
+const SCALING_TYPES = ["CPU", "MEMORY"];
+const AMI_HARDWARE_TYPES = ["ARM", "STANDARD"];
+function parseServiceScaling(scalingVal) {
+    if (scalingVal === false)
+        return false;
+    if (!isParsedObject(scalingVal))
+        return undefined;
+    return {
+        minCapacity: asNumber(scalingVal.minCapacity),
+        maxCapacity: asNumber(scalingVal.maxCapacity),
+        desiredCount: asNumber(scalingVal.desiredCount),
+        scalingType: asStringUnion(scalingVal.scalingType, SCALING_TYPES),
+    };
+}
+function parseServiceEc2Config(ec2ConfigVal) {
+    if (!isParsedObject(ec2ConfigVal))
+        return undefined;
+    return {
+        instanceType: asString(ec2ConfigVal.instanceType),
+        amiHardwareType: asStringUnion(ec2ConfigVal.amiHardwareType, AMI_HARDWARE_TYPES),
+        minCapacity: asNumber(ec2ConfigVal.minCapacity),
+        maxCapacity: asNumber(ec2ConfigVal.maxCapacity),
+        memoryLimitMiB: asNumber(ec2ConfigVal.memoryLimitMiB),
+    };
+}
+/** Resolve connected database names from AST connection references */
+function resolveConnectedDatabaseNames(connections, databaseResources) {
+    if (!Array.isArray(connections))
+        return [];
+    return connections
+        .filter(isIdentifierRef)
+        .map((conn) => databaseResources.find((db) => db.variableName === conn.__identifier))
+        .filter((db) => db !== undefined)
+        .map((db) => db.resourceName);
+}
+/** Resolve connected storage names from AST connection references */
+function resolveConnectedStorageNames(connections, s3Resources) {
+    if (!Array.isArray(connections))
+        return [];
+    return connections
+        .filter(isIdentifierRef)
+        .map((conn) => s3Resources.find((s3) => s3.variableName === conn.__identifier))
+        .filter((s3) => s3 !== undefined)
+        .map((s3) => s3.resourceName);
+}
+/** Infer database connections from environment variables in ECS containers */
+function inferDatabaseConnectionsFromEnv(computePlan, servicesVal, databasePlans) {
+    if (!Array.isArray(servicesVal) || servicesVal.length === 0)
+        return;
+    const firstService = servicesVal[0];
+    if (!isParsedObject(firstService))
+        return;
+    const containersVal = firstService.containers;
+    if (!Array.isArray(containersVal) || containersVal.length === 0)
+        return;
+    const firstContainer = containersVal[0];
+    if (!isParsedObject(firstContainer) ||
+        !isParsedObject(firstContainer.environment)) {
+        return;
+    }
+    const env = firstContainer.environment;
+    if (env.DATABASE_HOST || env.DATABASE_PORT || env.DATABASE_NAME) {
+        computePlan.needsConnection = true;
+        if (databasePlans.length > 0 &&
+            (computePlan.connectedDatabase ?? []).length === 0) {
+            computePlan.connectedDatabase = [databasePlans[0].name];
+        }
+    }
+    for (let i = 1; i <= MAX_DATABASE_CONNECTION_INDICES; i++) {
+        if (env[`DATABASE_HOST_${i}`] ||
+            env[`DATABASE_PORT_${i}`] ||
+            env[`DATABASE_NAME_${i}`]) {
+            computePlan.needsConnection = true;
+        }
+    }
+}
+/** Infer storage connections from environment variables in ECS containers */
+function inferStorageConnectionsFromEnv(computePlan, servicesVal, s3Plans) {
+    if (!Array.isArray(servicesVal) || servicesVal.length === 0)
+        return;
+    const firstService = servicesVal[0];
+    if (!isParsedObject(firstService))
+        return;
+    const containersVal = firstService.containers;
+    if (!Array.isArray(containersVal) || containersVal.length === 0)
+        return;
+    const firstContainer = containersVal[0];
+    if (!isParsedObject(firstContainer) ||
+        !isParsedObject(firstContainer.environment)) {
+        return;
+    }
+    const env = firstContainer.environment;
+    if (env.BUCKET_NAME) {
+        if (s3Plans.length > 0 &&
+            (computePlan.connectedStorage ?? []).length === 0) {
+            computePlan.connectedStorage = [s3Plans[0].name];
+        }
+    }
+}
+function extractClusterConfig(cluster) {
+    if (!isParsedObject(cluster))
+        return undefined;
+    const loadBalancerVal = cluster.loadBalancer;
+    return {
+        domain: asString(cluster.domain),
+        loadBalancer: loadBalancerVal === false
+            ? false
+            : asStringUnion(loadBalancerVal, LOAD_BALANCER_TYPES),
+        directAccess: asBoolean(cluster.directAccess),
+    };
+}
+function parseEcsService(service) {
+    const containersVal = service.containers;
+    const containers = Array.isArray(containersVal)
+        ? containersVal.filter(isParsedObject).map(parseServiceContainer)
+        : undefined;
+    const ECS_SERVICE_KNOWN_KEYS = new Set([
+        "name",
+        "image",
+        "dockerfilePath",
+        "dockerTarget",
+        "ssmSecretsPath",
+        "containers",
+        "routing",
+        "connections",
+        "cpu",
+        "memoryLimitMiB",
+        "desiredCount",
+        "scaling",
+        "capacityProvider",
+        "ec2Config",
+    ]);
+    const extras = captureExtraProperties(service, ECS_SERVICE_KNOWN_KEYS);
+    return {
+        name: asString(service.name) ?? "",
+        image: asString(service.image),
+        dockerfilePath: asString(service.dockerfilePath),
+        dockerTarget: asString(service.dockerTarget),
+        ssmSecretsPath: asString(service.ssmSecretsPath),
+        containers,
+        routing: parseServiceRouting(service.routing),
+        cpu: asNumber(service.cpu),
+        memoryLimitMiB: asNumber(service.memoryLimitMiB),
+        desiredCount: asNumber(service.desiredCount),
+        scaling: parseServiceScaling(service.scaling),
+        capacityProvider: asStringUnion(service.capacityProvider, ECS_CAPACITY_PROVIDERS) ??
+            "FARGATE",
+        ec2Config: parseServiceEc2Config(service.ec2Config),
+        ...(extras.length > 0 && { extraProperties: extras }),
+    };
+}
+function assignIfDefined(target, key, value) {
+    if (value !== undefined)
+        target[key] = value;
+}
+function convertEcsCompute(compute, computePlan) {
+    assignIfDefined(computePlan, "dockerfilePath", asString(compute.config.dockerfilePath));
+    const cluster = compute.config.cluster;
+    if (cluster !== undefined) {
+        computePlan.cluster = extractClusterConfig(cluster);
+    }
+    const services = compute.config.services;
+    if (services !== undefined && Array.isArray(services)) {
+        computePlan.services = services
+            .filter((s) => isParsedObject(s))
+            .map(parseEcsService);
+    }
+    const ECS_KNOWN_KEYS = new Set([
+        "type",
+        "ecrRepository",
+        "dockerfilePath",
+        "cluster",
+        "services",
+        "connections",
+    ]);
+    const extras = captureExtraProperties(compute.config, ECS_KNOWN_KEYS);
+    if (extras.length > 0)
+        computePlan.extraProperties = extras;
+}
+/** Extract a string from a literal or an expression like `Prefix.VALUE` → "VALUE" */
+function extractEnumString(value, prefix) {
+    const str = asString(value);
+    if (str)
+        return str;
+    if (isExpressionRef(value) && value.__expression.startsWith(prefix + ".")) {
+        return value.__expression.slice(prefix.length + 1);
+    }
+    return undefined;
+}
+/** Extract a string argument from a call expression like `Code.fromAsset("./path")` */
+function extractCallStringArg(value) {
+    if (!isCallRef(value))
+        return undefined;
+    const match = value.__call.match(/\(\s*"([^"]+)"\s*\)/);
+    return match?.[1];
+}
+function convertLambdaCompute(compute, computePlan) {
+    assignIfDefined(computePlan, "deployment", asStringUnion(compute.config.deployment, DEPLOYMENT_TYPES));
+    assignIfDefined(computePlan, "timeout", asNumber(compute.config.timeout));
+    // Code gen emits `memorySize` but plan field is `memory` — handle both keys
+    assignIfDefined(computePlan, "memory", asNumber(compute.config.memorySize) ?? asNumber(compute.config.memory));
+    assignIfDefined(computePlan, "handler", asString(compute.config.handler));
+    // Code gen emits `runtime: Runtime.NODEJS_20_X` — extract enum value from expression
+    assignIfDefined(computePlan, "runtime", extractEnumString(compute.config.runtime, "Runtime"));
+    if (isEnvironmentRecord(compute.config.environment)) {
+        computePlan.environment = compute.config.environment;
+    }
+    // secrets can be EnvironmentRecord (Secrets Manager) or string[] (SSM secrets)
+    if (isEnvironmentRecord(compute.config.secrets)) {
+        computePlan.secrets = compute.config.secrets;
+    }
+    else {
+        const ssmSecrets = asStringArray(compute.config.secrets);
+        if (ssmSecrets)
+            computePlan.ssmSecrets = ssmSecrets;
+    }
+    // Extract functionUrl: { authType: FunctionUrlAuthType.NONE }
+    const functionUrlVal = compute.config.functionUrl;
+    if (isParsedObject(functionUrlVal)) {
+        const authType = extractEnumString(functionUrlVal.authType, "FunctionUrlAuthType");
+        if (authType === "NONE" || authType === "AWS_IAM") {
+            computePlan.functionUrl = { authType };
+        }
+    }
+    // Extract codePath from `code: Code.fromAsset("./path")`
+    const codeVal = compute.config.code;
+    if (codeVal !== undefined) {
+        const codePath = extractCallStringArg(codeVal);
+        if (codePath) {
+            computePlan.codePath = codePath;
+        }
+    }
+    // CDK prop is `lambdaDescription` — plan stores as `description`
+    assignIfDefined(computePlan, "description", asString(compute.config.lambdaDescription));
+    assignIfDefined(computePlan, "scheduleExpression", asString(compute.config.scheduleExpression));
+    assignIfDefined(computePlan, "architecture", extractEnumString(compute.config.architecture, "Architecture"));
+    assignIfDefined(computePlan, "ephemeralStorageSize", asNumber(compute.config.ephemeralStorageSize));
+    assignIfDefined(computePlan, "functionName", asString(compute.config.functionName));
+    assignIfDefined(computePlan, "ssmSecretsPath", asString(compute.config.ssmSecretsPath));
+    const LAMBDA_KNOWN_KEYS = new Set([
+        "type",
+        "deployment",
+        "timeout",
+        "memorySize",
+        "memory",
+        "handler",
+        "runtime",
+        "environment",
+        "secrets",
+        "functionUrl",
+        "code",
+        "connections",
+        "ecrRepository",
+        "containerSecretsImport",
+        "lambdaDescription",
+        "scheduleExpression",
+        "architecture",
+        "ephemeralStorageSize",
+        "functionName",
+        "ssmSecretsPath",
+    ]);
+    const extras = captureExtraProperties(compute.config, LAMBDA_KNOWN_KEYS);
+    if (extras.length > 0)
+        computePlan.extraProperties = extras;
+}
+function convertEc2Compute(compute, computePlan) {
+    assignIfDefined(computePlan, "instanceType", asStringUnion(compute.config.instanceType, EC2_INSTANCE_TYPES));
+    // Code gen emits `ssh: {}` or `ssh: false` — map to enableSSH boolean.
+    // Also accept `enableSSH: true/false` for manually-written code.
+    const sshVal = compute.config.ssh;
+    if (sshVal === false) {
+        computePlan.enableSSH = false;
+    }
+    else if (sshVal !== undefined && isParsedObject(sshVal)) {
+        computePlan.enableSSH = true;
+    }
+    else {
+        assignIfDefined(computePlan, "enableSSH", asBoolean(compute.config.enableSSH));
+    }
+    assignIfDefined(computePlan, "keyName", asString(compute.config.keyName));
+    assignIfDefined(computePlan, "userData", asString(compute.config.userData));
+    if (compute.config.securityGroups !== undefined) {
+        computePlan.securityGroups = asStringArray(compute.config.securityGroups);
+    }
+    const EC2_KNOWN_KEYS = new Set([
+        "type",
+        "instanceType",
+        "ssh",
+        "enableSSH",
+        "keyName",
+        "userData",
+        "securityGroups",
+        "connections",
+    ]);
+    const extras = captureExtraProperties(compute.config, EC2_KNOWN_KEYS);
+    if (extras.length > 0)
+        computePlan.extraProperties = extras;
+}
+function applyConnectionConfig(computePlan, compute, databaseResources, s3Resources) {
+    // Check top-level connections first, then service-level (ECS generated format)
+    let connections = compute.config.connections;
+    if (!connections && Array.isArray(compute.config.services)) {
+        const firstService = compute.config.services[0];
+        if (isParsedObject(firstService)) {
+            connections = firstService.connections;
+        }
+    }
+    if (!connections)
+        return;
+    const connectedDbNames = resolveConnectedDatabaseNames(connections, databaseResources);
+    if (connectedDbNames.length > 0) {
+        computePlan.needsConnection = true;
+        computePlan.connectedDatabase = connectedDbNames;
+    }
+    const connectedStorageNames = resolveConnectedStorageNames(connections, s3Resources);
+    if (connectedStorageNames.length > 0) {
+        computePlan.connectedStorage = connectedStorageNames;
+    }
+}
+function applyTypeSpecificConfig(computePlan, compute) {
+    const TYPE_CONVERTERS = {
+        ecs: convertEcsCompute,
+        lambda: convertLambdaCompute,
+        ec2: convertEc2Compute,
+    };
+    TYPE_CONVERTERS[computePlan.type]?.(compute, computePlan);
+}
+/** Convert parsed compute resources to plan format */
+export function convertComputeResources(parsed, plan) {
+    return parsed.computeResources.map((compute) => {
+        const computeType = asStringUnion(compute.config.type, COMPUTE_TYPES) ?? "ecs";
+        const computePlan = {
+            name: compute.resourceName,
+            type: computeType,
+            needsConnection: false,
+            connectedDatabase: [],
+            ...(compute.variableName && { variableName: compute.variableName }),
+        };
+        applyConnectionConfig(computePlan, compute, parsed.databaseResources, parsed.s3Resources);
+        applyTypeSpecificConfig(computePlan, compute);
+        inferDatabaseConnectionsFromEnv(computePlan, compute.config.services, plan.database);
+        inferStorageConnectionsFromEnv(computePlan, compute.config.services, plan.s3);
+        return computePlan;
+    });
+}