@fjall/generator 0.89.5 → 0.89.6

package/dist/src/ast/astComputeParser.js

@@ -1,473 +1 @@
-import * as ts from "typescript";
-import { isPlainObject, isParsedObject, isIdentifierRef, isExpressionRef, isCallRef, asString, asNumber, asBoolean, asStringArray, asStringUnion, captureExtraProperties, collectFromAst, extractVariableName, isFactoryBuildCall, isFactoryMethodCall, parseObjectLiteral, } from "./astCommonParser.js";
-import { COMPUTE_TYPES, DEPLOYMENT_TYPES, EC2_INSTANCE_TYPES, ECS_CAPACITY_PROVIDERS, } from "../schemas/constants.js";
-// ---- Extraction helpers ----
-function extractComputeResource(buildCall) {
-    if (buildCall.arguments.length < 2)
-        return null;
-    const nameArg = buildCall.arguments[0];
-    const configArg = buildCall.arguments[1];
-    if (!ts.isStringLiteral(nameArg) ||
-        !ts.isObjectLiteralExpression(configArg)) {
-        return null;
-    }
-    const resourceName = nameArg.text;
-    const config = parseObjectLiteral(configArg);
-    return {
-        resourceName,
-        type: asString(config.type) ?? "ecs",
-        config,
-        node: buildCall,
-    };
-}
-/** Find all compute resources from addCompute calls */
-export function findComputeResources(sourceFile) {
-    return collectFromAst(sourceFile, (node) => {
-        if (!ts.isCallExpression(node) || !isFactoryMethodCall(node, "addCompute"))
-            return null;
-        const computeArg = node.arguments[0];
-        if (!isFactoryBuildCall(computeArg, "ComputeFactory"))
-            return null;
-        const resource = extractComputeResource(computeArg);
-        if (resource) {
-            const varName = extractVariableName(node);
-            if (varName)
-                resource.variableName = varName;
-        }
-        return resource;
-    });
-}
-// ---- Internal helpers ----
-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;
-    const warmPoolVal = ec2ConfigVal.warmPool;
-    const warmPool = isParsedObject(warmPoolVal)
-        ? {
-            minSize: asNumber(warmPoolVal.minSize),
-            reuseOnScaleIn: asBoolean(warmPoolVal.reuseOnScaleIn),
-        }
-        : 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),
-        warmPool,
-    };
-}
-/** 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(computeResources, databaseResources, s3Resources, plan) {
-    return 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, databaseResources, s3Resources);
-        applyTypeSpecificConfig(computePlan, compute);
-        inferDatabaseConnectionsFromEnv(computePlan, compute.config.services, plan.database);
-        inferStorageConnectionsFromEnv(computePlan, compute.config.services, plan.s3);
-        return computePlan;
-    });
-}
+import*as S from"typescript";import{asString as a,asNumber as f,asBoolean as v,asStringArray as E,asStringUnion as d,captureExtraProperties as l,collectFromAst as C,extractVariableName as u,isFactoryBuildCall as m,isFactoryMethodCall as b,isParsedObject as g,parseObjectLiteral as x}from"./astCommonParser.js";import{COMPUTE_TYPES as T,DEPLOYMENT_TYPES as A,EC2_INSTANCE_TYPES as D}from"../schemas/constants.js";import{assignIfDefined as o,extractCallStringArg as _,extractClusterConfig as O,extractEnumString as y,isEnvironmentRecord as N,parseEcsService as R}from"./astComputeParserHelpers.js";import{inferDatabaseConnectionsFromEnv as Y,inferStorageConnectionsFromEnv as F,resolveConnectedDatabaseNames as U,resolveConnectedStorageNames as k}from"./astComputeConnectionParser.js";function K(e){if(e.arguments.length<2)return null;const n=e.arguments[0],i=e.arguments[1];if(!S.isStringLiteral(n)||!S.isObjectLiteralExpression(i))return null;const t=n.text,r=x(i);return{resourceName:t,type:a(r.type)??"ecs",config:r,node:e}}function w(e){return C(e,n=>{if(!S.isCallExpression(n)||!b(n,"addCompute"))return null;const i=n.arguments[0];if(!m(i,"ComputeFactory"))return null;const t=K(i);if(t){const r=u(n);r&&(t.variableName=r)}return t})}function L(e,n){o(n,"dockerfilePath",a(e.config.dockerfilePath));const i=e.config.cluster;i!==void 0&&(n.cluster=O(i));const t=e.config.services;t!==void 0&&Array.isArray(t)&&(n.services=t.filter(s=>g(s)).map(R));const r=new Set(["type","ecrRepository","dockerfilePath","cluster","services","connections"]),c=l(e.config,r);c.length>0&&(n.extraProperties=c)}function V(e,n){if(o(n,"deployment",d(e.config.deployment,A)),o(n,"timeout",f(e.config.timeout)),o(n,"memory",f(e.config.memorySize)??f(e.config.memory)),o(n,"handler",a(e.config.handler)),o(n,"runtime",y(e.config.runtime,"Runtime")),N(e.config.environment)&&(n.environment=e.config.environment),N(e.config.secrets))n.secrets=e.config.secrets;else{const s=E(e.config.secrets);s&&(n.ssmSecrets=s)}const i=e.config.functionUrl;if(g(i)){const s=y(i.authType,"FunctionUrlAuthType");(s==="NONE"||s==="AWS_IAM")&&(n.functionUrl={authType:s})}const t=e.config.code;if(t!==void 0){const s=_(t);s&&(n.codePath=s)}o(n,"description",a(e.config.lambdaDescription)),o(n,"scheduleExpression",a(e.config.scheduleExpression)),o(n,"architecture",y(e.config.architecture,"Architecture")),o(n,"ephemeralStorageSize",f(e.config.ephemeralStorageSize)),o(n,"functionName",a(e.config.functionName)),o(n,"ssmSecretsPath",a(e.config.ssmSecretsPath));const r=new Set(["type","deployment","timeout","memorySize","memory","handler","runtime","environment","secrets","functionUrl","code","connections","ecrRepository","containerSecretsImport","lambdaDescription","scheduleExpression","architecture","ephemeralStorageSize","functionName","ssmSecretsPath"]),c=l(e.config,r);c.length>0&&(n.extraProperties=c)}function z(e,n){o(n,"instanceType",d(e.config.instanceType,D));const i=e.config.ssh;i===!1?n.enableSSH=!1:i!==void 0&&g(i)?n.enableSSH=!0:o(n,"enableSSH",v(e.config.enableSSH)),o(n,"keyName",a(e.config.keyName)),o(n,"userData",a(e.config.userData)),e.config.securityGroups!==void 0&&(n.securityGroups=E(e.config.securityGroups));const t=new Set(["type","instanceType","ssh","enableSSH","keyName","userData","securityGroups","connections"]),r=l(e.config,t);r.length>0&&(n.extraProperties=r)}function H(e,n,i,t){let r=n.config.connections;if(!r&&Array.isArray(n.config.services)){const h=n.config.services[0];g(h)&&(r=h.connections)}if(!r)return;const c=U(r,i);c.length>0&&(e.needsConnection=!0,e.connectedDatabase=c);const s=k(r,t);s.length>0&&(e.connectedStorage=s)}function M(e,n){({ecs:L,lambda:V,ec2:z})[e.type]?.(n,e)}function B(e,n,i,t){return e.map(r=>{const c=d(r.config.type,T)??"ecs",s={name:r.resourceName,type:c,needsConnection:!1,connectedDatabase:[],...r.variableName&&{variableName:r.variableName}};return H(s,r,n,i),M(s,r),Y(s,r.config.services,t.database),F(s,r.config.services,t.s3),s})}export{B as convertComputeResources,w as findComputeResources};

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

@@ -0,0 +1,21 @@
+/**
+ * Read-only AST parsing helpers for compute resources. Split out of
+ * astComputeParser.ts to keep both files within the 400-line budget. Used
+ * only by astComputeParser.ts. Write paths live in src/codemod/. Do not add
+ * mutation helpers here.
+ */
+import { type ParsedValue, type ParsedObject, type IdentifierRef } from "./astCommonParser.js";
+import { type ComputeResourcePlan } from "../schemas/resourceSchemas.js";
+export type EnvironmentRecord = Record<string, string | number | boolean | IdentifierRef | {
+    __expression: string;
+} | {
+    __call: string;
+}>;
+export declare function isEnvironmentRecord(value: ParsedValue | undefined): value is EnvironmentRecord;
+export declare function extractClusterConfig(cluster: ParsedValue): ComputeResourcePlan["cluster"];
+export declare function parseEcsService(service: ParsedObject): NonNullable<ComputeResourcePlan["services"]>[number];
+/** Extract a string from a literal or an expression like `Prefix.VALUE` -> "VALUE" */
+export declare function extractEnumString(value: ParsedValue, prefix: string): string | undefined;
+/** Extract a string argument from a call expression like `Code.fromAsset("./path")` */
+export declare function extractCallStringArg(value: ParsedValue): string | undefined;
+export declare function assignIfDefined<K extends keyof ComputeResourcePlan>(target: ComputeResourcePlan, key: K, value: ComputeResourcePlan[K] | undefined): void;

package/dist/src/ast/astComputeParserHelpers.js

@@ -0,0 +1 @@
+import{isPlainObject as u,isParsedObject as a,isExpressionRef as S,isCallRef as y,asString as n,asNumber as r,asBoolean as d,asStringArray as c,asStringUnion as m,captureExtraProperties as p}from"./astCommonParser.js";import{ECS_CAPACITY_PROVIDERS as h}from"../schemas/constants.js";const C=["public","internal"];function P(e){return e!==void 0&&u(e)}function E(e){if(!a(e))return;const t={};for(const[i,o]of Object.entries(e))if(a(o)){const s=n(o.id),f=n(o.name);s&&f&&(t[i]={id:s,name:f,field:n(o.field)})}return Object.keys(t).length>0?t:void 0}function A(e){if(!a(e))return;const t=c(e.command);if(!(!t||t.length===0))return{command:t,interval:r(e.interval),timeout:r(e.timeout),retries:r(e.retries),startPeriod:r(e.startPeriod)}}function _(e){const i=p(e,new Set(["name","image","port","environment","essential","command","entryPoint","secretsImport","secrets","healthCheck"]));return{name:n(e.name),image:n(e.image),port:r(e.port),environment:P(e.environment)?e.environment:void 0,essential:d(e.essential),command:c(e.command),entryPoint:c(e.entryPoint),secretsImport:E(e.secretsImport),ssmSecrets:c(e.secrets),healthCheck:A(e.healthCheck),extraProperties:i.length>0?i:void 0}}function x(e){if(Array.isArray(e))return e.filter(a).map(t=>({path:n(t.path),host:n(t.host),priority:r(t.priority),healthCheckPath:n(t.healthCheckPath)}));if(a(e))return{path:n(e.path),host:n(e.host),priority:r(e.priority),healthCheckPath:n(e.healthCheckPath)}}const g=["CPU","MEMORY"],l=["ARM","STANDARD"];function R(e){if(e===!1)return!1;if(a(e))return{minCapacity:r(e.minCapacity),maxCapacity:r(e.maxCapacity),desiredCount:r(e.desiredCount),scalingType:m(e.scalingType,g)}}function T(e){if(!a(e))return;const t=e.warmPool,i=a(t)?{minSize:r(t.minSize),reuseOnScaleIn:d(t.reuseOnScaleIn)}:void 0;return{instanceType:n(e.instanceType),amiHardwareType:m(e.amiHardwareType,l),minCapacity:r(e.minCapacity),maxCapacity:r(e.maxCapacity),memoryLimitMiB:r(e.memoryLimitMiB),warmPool:i}}function I(e){if(!a(e))return;const t=e.loadBalancer;return{domain:n(e.domain),loadBalancer:t===!1?!1:m(t,C),directAccess:d(e.directAccess)}}function k(e){const t=e.containers,i=Array.isArray(t)?t.filter(a).map(_):void 0,s=p(e,new Set(["name","image","dockerfilePath","dockerTarget","ssmSecretsPath","containers","routing","connections","cpu","memoryLimitMiB","desiredCount","scaling","capacityProvider","ec2Config"]));return{name:n(e.name)??"",image:n(e.image),dockerfilePath:n(e.dockerfilePath),dockerTarget:n(e.dockerTarget),ssmSecretsPath:n(e.ssmSecretsPath),containers:i,routing:x(e.routing),cpu:r(e.cpu),memoryLimitMiB:r(e.memoryLimitMiB),desiredCount:r(e.desiredCount),scaling:R(e.scaling),capacityProvider:m(e.capacityProvider,h)??"FARGATE",ec2Config:T(e.ec2Config),...s.length>0&&{extraProperties:s}}}function B(e,t){const i=n(e);if(i)return i;if(S(e)&&e.__expression.startsWith(t+"."))return e.__expression.slice(t.length+1)}function M(e){return y(e)?e.__call.match(/\(\s*"([^"]+)"\s*\)/)?.[1]:void 0}function Y(e,t,i){i!==void 0&&(e[t]=i)}export{Y as assignIfDefined,M as extractCallStringArg,I as extractClusterConfig,B as extractEnumString,P as isEnvironmentRecord,k as parseEcsService};

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

@@ -1,5 +1,14 @@
+/**
+ * Read-only AST parser for the database section of infrastructure.ts
+ * (RDS Instance, Aurora, GlobalAurora). DynamoDB tables are handled in
+ * astDynamoDBParser.ts. Used by fjall list and by the deploy-worker's
+ * convertToResourcePlan. Write paths live in src/codemod/. Do not add
+ * mutation helpers here.
+ */
 import * as ts from "typescript";
 import type { ApplicationResourcePlan, ExtraProperty } from "../schemas/resourceSchemas.js";
+import { type ParsedDynamoDBResource } from "./astDynamoDBParser.js";
+export { type ParsedDynamoDBResource, convertDynamoDBResources, } from "./astDynamoDBParser.js";
 interface ParsedProxyConfig {
     maxConnections?: number;
     maxIdleConnections?: number;
@@ -69,27 +78,6 @@ export interface ParsedDatabaseResource {
     extraProperties?: ExtraProperty[];
     node: ts.Node;
 }
-declare const DYNAMODB_KEY_TYPES: readonly ["S", "N", "B"];
-type DynamoDBKeyType = (typeof DYNAMODB_KEY_TYPES)[number];
-interface DynamoDBKey {
-    name: string;
-    type: DynamoDBKeyType;
-}
-export interface ParsedDynamoDBResource {
-    variableName?: string;
-    resourceName: string;
-    partitionKey: DynamoDBKey;
-    sortKey?: DynamoDBKey;
-    globalSecondaryIndexes?: Array<{
-        indexName: string;
-        partitionKey: DynamoDBKey;
-        sortKey?: DynamoDBKey;
-    }>;
-    ttlAttribute?: string;
-    stream?: boolean;
-    extraProperties?: ExtraProperty[];
-    node: ts.Node;
-}
 /** Find all database resources (including DynamoDB) from addDatabase calls */
 export declare function findDatabaseResources(sourceFile: ts.SourceFile): ParsedDatabaseResource[];
 /** Split DynamoDB resources (type: "DynamoDB") from regular database resources */
@@ -99,6 +87,3 @@ export declare function splitDynamoDBFromDatabases(allResources: ParsedDatabaseR
 };
 /** Convert parsed database resources to plan format */
 export declare function convertDatabaseResources(databaseResources: ParsedDatabaseResource[]): ApplicationResourcePlan["database"];
-/** Convert parsed DynamoDB resources to plan format */
-export declare function convertDynamoDBResources(dynamodbResources: ParsedDynamoDBResource[]): ApplicationResourcePlan["dynamodb"];
-export {};