@fjall/generator 0.89.5 → 0.89.6

package/dist/src/generation/compute.js

@@ -1,596 +1,88 @@
-import { formatValue, getVariableName, emitExtraProperties } from "./common.js";
-import { DATABASE_ENV_VARS, getConnectedDatabases, generateDatabaseEnvVarEntries, buildDatabaseEnvVars, } from "./database.js";
-import { STORAGE_ENV_VARS, getConnectedStorage, generateStorageEnvVarEntries, buildStorageEnvVars, formatAllConnectionsCode, } from "./storageConnections.js";
-import { MESSAGING_ENV_VARS, getConnectedMessaging, generateMessagingEnvVarEntries, buildMessagingEnvVars, } from "./messagingConnections.js";
-import { COMPUTE_TYPE, DEPLOYMENT_TYPE, DEFAULT_COMPUTE_ARCHITECTURE, } from "../schemas/constants.js";
-/** Check if a compute resource has database connections */
-function computeHasDatabaseConnections(compute) {
-    return Boolean(compute.needsConnection && compute.connectedDatabase?.length);
-}
-/** Check if a compute resource has storage connections */
-function computeHasStorageConnections(compute) {
-    return Boolean(compute.connectedStorage?.length);
-}
-/** Check if a compute resource has messaging connections */
-function computeHasMessagingConnections(compute) {
-    return Boolean(compute.connectedMessaging?.length);
-}
-/** Check if a compute resource has any connections (database, storage, or messaging) */
-function computeHasConnections(compute) {
-    return (computeHasDatabaseConnections(compute) ||
-        computeHasStorageConnections(compute) ||
-        computeHasMessagingConnections(compute));
-}
-const BASE_ENVIRONMENT_VARS = {
-    ENVIRONMENT: { __expression: "getConfig().environment" },
-};
-function formatEnvBlock(vars, indent) {
-    return Object.entries(vars)
-        .map(([key, value]) => `${indent}${key}: ${formatValue(value)},`)
-        .join("\n");
-}
-export function generateLambdaCode(compute, _plan) {
-    let code = "";
-    if (compute.deployment === DEPLOYMENT_TYPE.CODE && compute.codePath) {
-        code += `
-    deployment: "${DEPLOYMENT_TYPE.CODE}",
-    code: Code.fromAsset("${compute.codePath}"),`;
-        if (compute.handler) {
-            code += `
-    handler: "${compute.handler}",`;
-        }
-        if (compute.runtime) {
-            code += `
-    runtime: Runtime.${compute.runtime},`;
-        }
-    }
-    else {
-        code += `
-    deployment: "${DEPLOYMENT_TYPE.CONTAINER}",
-    ecrRepository: app.getDefaultContainerRegistry(),`;
-    }
-    if (compute.timeout !== undefined) {
-        code += `
-    timeout: ${compute.timeout},`;
-    }
-    if (compute.memory !== undefined) {
-        code += `
-    memorySize: ${compute.memory},`;
-    }
-    if (compute.functionUrl) {
-        code += `
-    functionUrl: { authType: FunctionUrlAuthType.${compute.functionUrl.authType} },`;
-    }
-    if (compute.description) {
-        code += `
-    lambdaDescription: "${compute.description}",`;
-    }
-    if (compute.scheduleExpression) {
-        code += `
-    scheduleExpression: "${compute.scheduleExpression}",`;
-    }
-    if (compute.architecture ||
-        compute.deployment === DEPLOYMENT_TYPE.CONTAINER) {
-        const arch = compute.architecture ?? DEFAULT_COMPUTE_ARCHITECTURE;
-        code += `
-    architecture: Architecture.${arch},`;
-    }
-    if (compute.ephemeralStorageSize !== undefined) {
-        code += `
-    ephemeralStorageSize: ${compute.ephemeralStorageSize},`;
-    }
-    if (compute.functionName) {
-        code += `
-    functionName: "${compute.functionName}",`;
-    }
-    if (compute.ssmSecretsPath) {
-        code += `
-    ssmSecretsPath: "${compute.ssmSecretsPath}",`;
-    }
-    if (compute.ssmSecrets && compute.ssmSecrets.length > 0) {
-        const secretsList = compute.ssmSecrets.map((s) => `"${s}"`).join(", ");
-        code += `
-    secrets: [${secretsList}],`;
-    }
-    // When there are connections, generateLambdaConnectionsCode handles env vars.
-    // Otherwise, emit environment block here with base + user env vars.
-    if (!computeHasConnections(compute)) {
-        const allEnv = {
-            ...BASE_ENVIRONMENT_VARS,
-            ...compute.environment,
-        };
-        code += `
+import{formatValue as $,getVariableName as _,emitExtraProperties as y}from"./common.js";import{DATABASE_ENV_VARS as m,getConnectedDatabases as x,generateDatabaseEnvVarEntries as j,buildDatabaseEnvVars as B}from"./database.js";import{STORAGE_ENV_VARS as L,getConnectedStorage as M,generateStorageEnvVarEntries as I,buildStorageEnvVars as U,formatAllConnectionsCode as T}from"./storageConnections.js";import{MESSAGING_ENV_VARS as N,getConnectedMessaging as O,generateMessagingEnvVarEntries as H,buildMessagingEnvVars as z}from"./messagingConnections.js";import{COMPUTE_TYPE as E,DEPLOYMENT_TYPE as C,DEFAULT_COMPUTE_ARCHITECTURE as w}from"../schemas/constants.js";function v(e){return!!(e.needsConnection&&e.connectedDatabase?.length)}function p(e){return!!e.connectedStorage?.length}function b(e){return!!e.connectedMessaging?.length}function D(e){return v(e)||p(e)||b(e)}const A={ENVIRONMENT:{__expression:"getConfig().environment"}};function P(e,n){return Object.entries(e).map(([t,a])=>`${n}${t}: ${$(a)},`).join(`
+`)}function F(e,n){let t="";if(e.deployment===C.CODE&&e.codePath?(t+=`
+    deployment: "${C.CODE}",
+    code: Code.fromAsset("${e.codePath}"),`,e.handler&&(t+=`
+    handler: "${e.handler}",`),e.runtime&&(t+=`
+    runtime: Runtime.${e.runtime},`)):t+=`
+    deployment: "${C.CONTAINER}",
+    ecrRepository: app.getDefaultContainerRegistry(),`,e.timeout!==void 0&&(t+=`
+    timeout: ${e.timeout},`),e.memory!==void 0&&(t+=`
+    memorySize: ${e.memory},`),e.functionUrl&&(t+=`
+    functionUrl: { authType: FunctionUrlAuthType.${e.functionUrl.authType} },`),e.description&&(t+=`
+    lambdaDescription: "${e.description}",`),e.scheduleExpression&&(t+=`
+    scheduleExpression: "${e.scheduleExpression}",`),e.architecture||e.deployment===C.CONTAINER){const a=e.architecture??w;t+=`
+    architecture: Architecture.${a},`}if(e.ephemeralStorageSize!==void 0&&(t+=`
+    ephemeralStorageSize: ${e.ephemeralStorageSize},`),e.functionName&&(t+=`
+    functionName: "${e.functionName}",`),e.ssmSecretsPath&&(t+=`
+    ssmSecretsPath: "${e.ssmSecretsPath}",`),e.ssmSecrets&&e.ssmSecrets.length>0){const a=e.ssmSecrets.map(o=>`"${o}"`).join(", ");t+=`
+    secrets: [${a}],`}if(!D(e)){const a={...A,...e.environment};t+=`
     environment: {
-${formatEnvBlock(allEnv, "      ")}
-    },`;
-    }
-    code += emitExtraProperties(compute.extraProperties);
-    return code;
-}
-export function generateLambdaConnectionsCode(compute, plan) {
-    if (compute.type !== COMPUTE_TYPE.LAMBDA)
-        return "";
-    const hasDatabaseConnections = computeHasDatabaseConnections(compute);
-    const hasStorageConns = computeHasStorageConnections(compute);
-    const hasMessagingConns = computeHasMessagingConnections(compute);
-    if (!hasDatabaseConnections && !hasStorageConns && !hasMessagingConns)
-        return "";
-    const connectedDatabases = hasDatabaseConnections
-        ? getConnectedDatabases(plan, compute)
-        : [];
-    const connectedStorage = hasStorageConns
-        ? getConnectedStorage(plan, compute)
-        : [];
-    const connectedMessaging = hasMessagingConns
-        ? getConnectedMessaging(plan, compute)
-        : [];
-    if (connectedDatabases.length === 0 &&
-        connectedStorage.length === 0 &&
-        connectedMessaging.length === 0) {
-        return "";
-    }
-    // All env/secret values are stored as typed objects so formatValue handles
-    // them uniformly: __expression objects emit raw code, strings get JSON-quoted.
-    const envVars = {
-        ...BASE_ENVIRONMENT_VARS,
-    };
-    const secretVars = {};
-    // Database env vars
-    if (connectedDatabases.length > 0) {
-        const entries = generateDatabaseEnvVarEntries(connectedDatabases);
-        for (const entry of entries) {
-            // "true" is a literal string value (DATABASE_SSL); expressions are code refs
-            const value = entry.expression === `"true"`
-                ? "true"
-                : { __expression: entry.expression };
-            if (entry.isSecret) {
-                secretVars[entry.key] = { __expression: entry.expression };
-            }
-            else {
-                envVars[entry.key] = value;
-            }
-        }
-    }
-    // Storage env vars (no secrets — S3 uses IAM)
-    if (connectedStorage.length > 0) {
-        const entries = generateStorageEnvVarEntries(connectedStorage);
-        for (const entry of entries) {
-            envVars[entry.key] = { __expression: entry.expression };
-        }
-    }
-    // Messaging env vars (no secrets — SQS uses IAM)
-    if (connectedMessaging.length > 0) {
-        const entries = generateMessagingEnvVarEntries(connectedMessaging);
-        for (const entry of entries) {
-            envVars[entry.key] = { __expression: entry.expression };
-        }
-    }
-    // Merge compute.environment values directly — formatValue handles all types
-    if (compute.environment) {
-        for (const [key, value] of Object.entries(compute.environment)) {
-            envVars[key] = value;
-        }
-    }
-    let code = "";
-    // containerSecretsImport for database credentials (resolved at deploy time)
-    if (Object.keys(secretVars).length > 0) {
-        code += `
-    containerSecretsImport: {`;
-        for (const [key, value] of Object.entries(secretVars)) {
-            code += `
-      ${key}: ${formatValue(value)},`;
-        }
-        code += `
-    },`;
-    }
-    if (Object.keys(envVars).length > 0) {
-        code += `
-    environment: {`;
-        for (const [key, value] of Object.entries(envVars)) {
-            code += `
-      ${key}: ${formatValue(value)},`;
-        }
-        code += `
-    },`;
-    }
-    code += `
-    ${formatAllConnectionsCode(connectedDatabases, connectedStorage, connectedMessaging)}`;
-    return code;
-}
-export function generateEc2Code(compute) {
-    let code = "";
-    if (compute.instanceType) {
-        code += `
-    instanceType: "${compute.instanceType}",`;
-    }
-    if (compute.enableSSH !== undefined) {
-        code += compute.enableSSH
-            ? `
-    ssh: {},`
-            : `
-    ssh: false,`;
-    }
-    code += emitExtraProperties(compute.extraProperties);
-    return code;
-}
-function generateEcsClusterCode(compute) {
-    if (!compute.cluster)
-        return "";
-    const parts = [];
-    if (compute.cluster.directAccess) {
-        parts.push(`directAccess: true`);
-    }
-    if (compute.cluster.domain) {
-        parts.push(`domain: "${compute.cluster.domain}"`);
-    }
-    if (compute.cluster.loadBalancer !== undefined) {
-        parts.push(compute.cluster.loadBalancer === false
-            ? `loadBalancer: false`
-            : `loadBalancer: "${compute.cluster.loadBalancer}"`);
-    }
-    if (parts.length <= 1) {
-        return `
-    cluster: { ${parts[0] || ""} },`;
-    }
-    const inner = parts.map((p) => `\n      ${p},`).join("");
-    return `
-    cluster: {${inner}
-    },`;
-}
-function generateEcsContainerCode(containerConfig, shouldAddConnectionEnv, dbEnvVars, storageEnvVars, messagingEnvVars, baseEnvVars) {
-    let code = "";
-    if (containerConfig.name) {
-        code += `
-        name: "${containerConfig.name}",`;
-    }
-    if (containerConfig.image) {
-        code += `
-        image: "${containerConfig.image}",`;
-    }
-    if (containerConfig.port !== undefined) {
-        code += `
-        port: ${containerConfig.port},`;
-    }
-    if (containerConfig.essential !== undefined) {
-        code += `
-        essential: ${containerConfig.essential},`;
-    }
-    if (containerConfig.command?.length) {
-        code += `
-        command: ${JSON.stringify(containerConfig.command)},`;
-    }
-    if (containerConfig.entryPoint?.length) {
-        code += `
-        entryPoint: ${JSON.stringify(containerConfig.entryPoint)},`;
-    }
-    const connectionEnvKeys = [
-        DATABASE_ENV_VARS.HOST,
-        DATABASE_ENV_VARS.PORT,
-        DATABASE_ENV_VARS.NAME,
-        DATABASE_ENV_VARS.SSL,
-        DATABASE_ENV_VARS.USERNAME,
-        DATABASE_ENV_VARS.PASSWORD,
-        STORAGE_ENV_VARS.NAME,
-        MESSAGING_ENV_VARS.URL,
-        MESSAGING_ENV_VARS.ARN,
-    ];
-    const stripConnectionEnv = (env) => {
-        if (!env)
-            return env;
-        const filtered = {};
-        for (const [key, value] of Object.entries(env)) {
-            const isConnectionKey = connectionEnvKeys.some((connKey) => key === connKey || key.startsWith(`${connKey}_`));
-            if (!isConnectionKey) {
-                filtered[key] = value;
-            }
-        }
-        return Object.keys(filtered).length > 0 ? filtered : undefined;
-    };
-    // Base env vars (e.g. ENVIRONMENT) are always injected into every container.
-    // Connection env vars are only added to the first container of the service that needs them.
-    const containerEnv = shouldAddConnectionEnv
-        ? {
-            ...baseEnvVars,
-            ...dbEnvVars.env,
-            ...storageEnvVars.env,
-            ...messagingEnvVars.env,
-            ...containerConfig.environment,
-        }
-        : { ...baseEnvVars, ...stripConnectionEnv(containerConfig.environment) };
-    const containerSecrets = shouldAddConnectionEnv
-        ? { ...dbEnvVars.secrets, ...containerConfig.secretsImport }
-        : stripConnectionEnv(containerConfig.secretsImport);
-    if (containerEnv && Object.keys(containerEnv).length > 0) {
-        code += `
+${P(a,"      ")}
+    },`}return t+=y(e.extraProperties),t}function G(e,n){if(e.type!==E.LAMBDA)return"";const t=v(e),a=p(e),o=b(e);if(!t&&!a&&!o)return"";const g=t?x(n,e):[],d=a?M(n,e):[],f=o?O(n,e):[];if(g.length===0&&d.length===0&&f.length===0)return"";const c={...A},l={};if(g.length>0){const i=j(g);for(const r of i){const h=r.expression==='"true"'?"true":{__expression:r.expression};r.isSecret?l[r.key]={__expression:r.expression}:c[r.key]=h}}if(d.length>0){const i=I(d);for(const r of i)c[r.key]={__expression:r.expression}}if(f.length>0){const i=H(f);for(const r of i)c[r.key]={__expression:r.expression}}if(e.environment)for(const[i,r]of Object.entries(e.environment))c[i]=r;let s="";if(Object.keys(l).length>0){s+=`
+    containerSecretsImport: {`;for(const[i,r]of Object.entries(l))s+=`
+      ${i}: ${$(r)},`;s+=`
+    },`}if(Object.keys(c).length>0){s+=`
+    environment: {`;for(const[i,r]of Object.entries(c))s+=`
+      ${i}: ${$(r)},`;s+=`
+    },`}return s+=`
+    ${T(g,d,f)}`,s}function Y(e){let n="";return e.instanceType&&(n+=`
+    instanceType: "${e.instanceType}",`),e.enableSSH!==void 0&&(n+=e.enableSSH?`
+    ssh: {},`:`
+    ssh: false,`),n+=y(e.extraProperties),n}function J(e){if(!e.cluster)return"";const n=[];return e.cluster.directAccess&&n.push("directAccess: true"),e.cluster.domain&&n.push(`domain: "${e.cluster.domain}"`),e.cluster.loadBalancer!==void 0&&n.push(e.cluster.loadBalancer===!1?"loadBalancer: false":`loadBalancer: "${e.cluster.loadBalancer}"`),n.length<=1?`
+    cluster: { ${n[0]||""} },`:`
+    cluster: {${n.map(a=>`
+      ${a},`).join("")}
+    },`}function K(e,n,t,a,o,g){let d="";e.name&&(d+=`
+        name: "${e.name}",`),e.image&&(d+=`
+        image: "${e.image}",`),e.port!==void 0&&(d+=`
+        port: ${e.port},`),e.essential!==void 0&&(d+=`
+        essential: ${e.essential},`),e.command?.length&&(d+=`
+        command: ${JSON.stringify(e.command)},`),e.entryPoint?.length&&(d+=`
+        entryPoint: ${JSON.stringify(e.entryPoint)},`);const f=[m.HOST,m.PORT,m.NAME,m.SSL,m.USERNAME,m.PASSWORD,L.NAME,N.URL,N.ARN],c=i=>{if(!i)return i;const r={};for(const[h,u]of Object.entries(i))f.some(S=>h===S||h.startsWith(`${S}_`))||(r[h]=u);return Object.keys(r).length>0?r:void 0},l=n?{...g,...t.env,...a.env,...o.env,...e.environment}:{...g,...c(e.environment)},s=n?{...t.secrets,...e.secretsImport}:c(e.secretsImport);if(l&&Object.keys(l).length>0&&(d+=`
         environment: {
-${formatEnvBlock(containerEnv, "          ")}
-        },`;
-    }
-    if (containerSecrets && Object.keys(containerSecrets).length > 0) {
-        code += `
+${P(l,"          ")}
+        },`),s&&Object.keys(s).length>0&&(d+=`
         secretsImport: {
-${formatEnvBlock(containerSecrets, "          ")}
-        },`;
-    }
-    if (containerConfig.ssmSecrets && containerConfig.ssmSecrets.length > 0) {
-        const secretsList = containerConfig.ssmSecrets
-            .map((s) => `"${s}"`)
-            .join(", ");
-        code += `
-        secrets: [${secretsList}],`;
-    }
-    if (containerConfig.healthCheck) {
-        code += `
-        healthCheck: ${formatValue(containerConfig.healthCheck, "        ")},`;
-    }
-    code += emitExtraProperties(containerConfig.extraProperties, "        ");
-    return code;
-}
-function formatRoutingRule(rule, indent) {
-    const parts = [];
-    if (rule.path)
-        parts.push(`path: "${rule.path}"`);
-    if (rule.host)
-        parts.push(`host: "${rule.host}"`);
-    if (rule.priority !== undefined)
-        parts.push(`priority: ${rule.priority}`);
-    if (rule.healthCheckPath)
-        parts.push(`healthCheckPath: "${rule.healthCheckPath}"`);
-    if (parts.length <= 1) {
-        return `{ ${parts[0] || ""} }`;
-    }
-    const inner = parts.map((p) => `\n${indent}  ${p},`).join("");
-    return `{${inner}\n${indent}}`;
-}
-function generateEcsServiceRoutingCode(routing) {
-    const rules = Array.isArray(routing) ? routing : [routing];
-    if (rules.length === 1) {
-        const formatted = formatRoutingRule(rules[0], "      ");
-        return `
-      routing: ${formatted},`;
-    }
-    const entries = rules.map((r) => formatRoutingRule(r, "        "));
-    return `
+${P(s,"          ")}
+        },`),e.ssmSecrets&&e.ssmSecrets.length>0){const i=e.ssmSecrets.map(r=>`"${r}"`).join(", ");d+=`
+        secrets: [${i}],`}return e.healthCheck&&(d+=`
+        healthCheck: ${$(e.healthCheck,"        ")},`),d+=y(e.extraProperties,"        "),d}function k(e,n){const t=[];return e.path&&t.push(`path: "${e.path}"`),e.host&&t.push(`host: "${e.host}"`),e.priority!==void 0&&t.push(`priority: ${e.priority}`),e.healthCheckPath&&t.push(`healthCheckPath: "${e.healthCheckPath}"`),t.length<=1?`{ ${t[0]||""} }`:`{${t.map(o=>`
+${n}  ${o},`).join("")}
+${n}}`}function W(e){const n=Array.isArray(e)?e:[e];return n.length===1?`
+      routing: ${k(n[0],"      ")},`:`
       routing: [
-        ${entries.join(",\n        ")},
-      ],`;
-}
-function generateEcsServiceScalingCode(scaling) {
-    if (scaling === false) {
-        return `
-      scaling: false,`;
-    }
-    if (typeof scaling !== "object")
-        return "";
-    const hasScalingConfig = scaling.minCapacity !== undefined ||
-        scaling.maxCapacity !== undefined ||
-        scaling.desiredCount !== undefined ||
-        scaling.scalingType !== undefined;
-    if (!hasScalingConfig)
-        return "";
-    const scalingParts = [];
-    if (scaling.minCapacity !== undefined)
-        scalingParts.push(`minCapacity: ${scaling.minCapacity}`);
-    if (scaling.maxCapacity !== undefined)
-        scalingParts.push(`maxCapacity: ${scaling.maxCapacity}`);
-    if (scaling.desiredCount !== undefined)
-        scalingParts.push(`desiredCount: ${scaling.desiredCount}`);
-    if (scaling.scalingType)
-        scalingParts.push(`scalingType: "${scaling.scalingType}"`);
-    if (scalingParts.length <= 1) {
-        return `
-      scaling: { ${scalingParts[0] || ""} },`;
-    }
-    const inner = scalingParts.map((p) => `\n        ${p},`).join("");
-    return `
-      scaling: {${inner}
-      },`;
-}
-/** Derive which connection types a service needs (DRY — used for both container env and service-level connections) */
-function deriveServiceConnectionNeeds(service, isFirstService, compute) {
-    return {
-        needsDb: service.needsDatabaseConnection !== undefined
-            ? service.needsDatabaseConnection
-            : isFirstService && computeHasDatabaseConnections(compute),
-        needsStorage: service.needsStorageConnection !== undefined
-            ? service.needsStorageConnection
-            : isFirstService && computeHasStorageConnections(compute),
-        needsMessaging: service.needsMessagingConnection !== undefined
-            ? service.needsMessagingConnection
-            : isFirstService && computeHasMessagingConnections(compute),
-    };
-}
-function generateEcsServiceCode(options) {
-    const { service, isFirstService, hasConnections, dbEnvVars, storageEnvVars, messagingEnvVars, baseEnvVars, plan, compute, } = options;
-    let code = `
-      name: "${service.name}",`;
-    code += `
-      capacityProvider: "${service.capacityProvider}",`;
-    if (service.ec2Config) {
-        code += `
-      ec2Config: ${formatValue(service.ec2Config, "      ")},`;
-    }
-    if (service.dockerfilePath) {
-        code += `
-      dockerfilePath: "${service.dockerfilePath}",`;
-    }
-    if (service.dockerTarget) {
-        code += `
-      dockerTarget: "${service.dockerTarget}",`;
-    }
-    if (service.image) {
-        code += `
-      image: "${service.image}",`;
-    }
-    if (service.ssmSecretsPath) {
-        code += `
-      ssmSecretsPath: "${service.ssmSecretsPath}",`;
-    }
-    const connectionNeeds = deriveServiceConnectionNeeds(service, isFirstService, compute);
-    if (service.containers?.length) {
-        code += `
-      containers: [{`;
-        for (let i = 0; i < service.containers.length; i++) {
-            const container = service.containers[i];
-            if (!container)
-                continue;
-            const shouldAddConnectionEnv = i === 0 &&
-                (connectionNeeds.needsDb ||
-                    connectionNeeds.needsStorage ||
-                    connectionNeeds.needsMessaging) &&
-                hasConnections;
-            // Build per-container env vars: only include the connection types this service needs
-            const containerDbEnvVars = connectionNeeds.needsDb
-                ? dbEnvVars
-                : { env: {}, secrets: {} };
-            const containerStorageEnvVars = connectionNeeds.needsStorage
-                ? storageEnvVars
-                : { env: {}, secrets: {} };
-            const containerMessagingEnvVars = connectionNeeds.needsMessaging
-                ? messagingEnvVars
-                : { env: {}, secrets: {} };
-            if (i > 0) {
-                code += `
-      }, {`;
-            }
-            code += generateEcsContainerCode(container, shouldAddConnectionEnv, containerDbEnvVars, containerStorageEnvVars, containerMessagingEnvVars, baseEnvVars);
-        }
-        code += `
-      }],`;
-    }
-    if (service.routing) {
-        code += generateEcsServiceRoutingCode(service.routing);
-    }
-    if (service.cpu !== undefined) {
-        code += `
-      cpu: ${service.cpu},`;
-    }
-    if (service.memoryLimitMiB !== undefined) {
-        code += `
-      memoryLimitMiB: ${service.memoryLimitMiB},`;
-    }
-    if (service.desiredCount !== undefined) {
-        code += `
-      desiredCount: ${service.desiredCount},`;
-    }
-    if (service.scaling !== undefined) {
-        code += generateEcsServiceScalingCode(service.scaling);
-    }
-    code += emitExtraProperties(service.extraProperties, "      ");
-    if (connectionNeeds.needsDb ||
-        connectionNeeds.needsStorage ||
-        connectionNeeds.needsMessaging) {
-        const connectedDatabases = connectionNeeds.needsDb
-            ? getConnectedDatabases(plan, compute)
-            : [];
-        const connectedStorage = connectionNeeds.needsStorage
-            ? getConnectedStorage(plan, compute)
-            : [];
-        const connectedMessaging = connectionNeeds.needsMessaging
-            ? getConnectedMessaging(plan, compute)
-            : [];
-        if (connectedDatabases.length > 0 ||
-            connectedStorage.length > 0 ||
-            connectedMessaging.length > 0) {
-            code += `
-      ${formatAllConnectionsCode(connectedDatabases, connectedStorage, connectedMessaging)}`;
-        }
-    }
-    return code;
-}
-export function generateEcsCode(compute, plan) {
-    const hasConnections = computeHasConnections(compute);
-    const baseEnvVars = {
-        ...BASE_ENVIRONMENT_VARS,
-    };
-    // Database env vars only injected into containers with database connections
-    const dbEnvVars = {
-        env: {},
-        secrets: {},
-    };
-    if (computeHasDatabaseConnections(compute)) {
-        const builtEnvVars = buildDatabaseEnvVars(plan, compute);
-        Object.assign(dbEnvVars.env, builtEnvVars.env);
-        Object.assign(dbEnvVars.secrets, builtEnvVars.secrets);
-    }
-    // Storage env vars (no secrets — S3 uses IAM)
-    const storageEnvVars = {
-        env: {},
-        secrets: {},
-    };
-    if (computeHasStorageConnections(compute)) {
-        const builtStorageEnvVars = buildStorageEnvVars(plan, compute);
-        Object.assign(storageEnvVars.env, builtStorageEnvVars.env);
-    }
-    // Messaging env vars (no secrets — SQS uses IAM)
-    const messagingEnvVars = {
-        env: {},
-        secrets: {},
-    };
-    if (computeHasMessagingConnections(compute)) {
-        const builtMessagingEnvVars = buildMessagingEnvVars(plan, compute);
-        Object.assign(messagingEnvVars.env, builtMessagingEnvVars.env);
-    }
-    let code = `
-    ecrRepository: app.getDefaultContainerRegistry(),`;
-    code += generateEcsClusterCode(compute);
-    if (compute.services?.length) {
-        code += `
-    services: [{`;
-        for (let serviceIndex = 0; serviceIndex < compute.services.length; serviceIndex++) {
-            const service = compute.services[serviceIndex];
-            if (!service)
-                continue;
-            if (serviceIndex > 0) {
-                code += `
-    }, {`;
-            }
-            code += generateEcsServiceCode({
-                service,
-                isFirstService: serviceIndex === 0,
-                hasConnections: !!hasConnections,
-                dbEnvVars,
-                storageEnvVars,
-                messagingEnvVars,
-                baseEnvVars,
-                plan,
-                compute,
-            });
-        }
-        code += `
-    }],`;
-    }
-    code += emitExtraProperties(compute.extraProperties);
-    return code;
-}
-export function generateComputeCode(plan, cdnReferencedResources) {
-    if (plan.compute.length === 0)
-        return "";
-    let code = "";
-    for (let computeIndex = 0; computeIndex < plan.compute.length; computeIndex++) {
-        const compute = plan.compute[computeIndex];
-        const needsVariable = cdnReferencedResources.has(compute.name);
-        const computeVariable = getVariableName(compute);
-        const needsLeadingNewline = plan.database.length > 0 || plan.s3.length > 0 || computeIndex > 0;
-        const prefix = needsVariable ? `const ${computeVariable} = ` : "";
-        const leadingNewline = needsLeadingNewline ? "\n" : "";
-        code += `${leadingNewline}${prefix}app.addCompute(
-  ComputeFactory.build("${compute.name}", {
-    type: "${compute.type}",`;
-        if (compute.type === COMPUTE_TYPE.LAMBDA) {
-            code += generateLambdaCode(compute, plan);
-        }
-        else if (compute.type === COMPUTE_TYPE.EC2) {
-            code += generateEc2Code(compute);
-        }
-        else if (compute.type === COMPUTE_TYPE.ECS) {
-            code += generateEcsCode(compute, plan);
-        }
-        code += generateLambdaConnectionsCode(compute, plan);
-        code += `
+        ${n.map(a=>k(a,"        ")).join(`,
+        `)},
+      ],`}function q(e){if(e===!1)return`
+      scaling: false,`;if(typeof e!="object"||!(e.minCapacity!==void 0||e.maxCapacity!==void 0||e.desiredCount!==void 0||e.scalingType!==void 0))return"";const t=[];return e.minCapacity!==void 0&&t.push(`minCapacity: ${e.minCapacity}`),e.maxCapacity!==void 0&&t.push(`maxCapacity: ${e.maxCapacity}`),e.desiredCount!==void 0&&t.push(`desiredCount: ${e.desiredCount}`),e.scalingType&&t.push(`scalingType: "${e.scalingType}"`),t.length<=1?`
+      scaling: { ${t[0]||""} },`:`
+      scaling: {${t.map(o=>`
+        ${o},`).join("")}
+      },`}function Q(e,n,t){return{needsDb:e.needsDatabaseConnection!==void 0?e.needsDatabaseConnection:n&&v(t),needsStorage:e.needsStorageConnection!==void 0?e.needsStorageConnection:n&&p(t),needsMessaging:e.needsMessagingConnection!==void 0?e.needsMessagingConnection:n&&b(t)}}function X(e){const{service:n,isFirstService:t,hasConnections:a,dbEnvVars:o,storageEnvVars:g,messagingEnvVars:d,baseEnvVars:f,plan:c,compute:l}=e;let s=`
+      name: "${n.name}",`;s+=`
+      capacityProvider: "${n.capacityProvider}",`,n.ec2Config&&(s+=`
+      ec2Config: ${$(n.ec2Config,"      ")},`),n.dockerfilePath&&(s+=`
+      dockerfilePath: "${n.dockerfilePath}",`),n.dockerTarget&&(s+=`
+      dockerTarget: "${n.dockerTarget}",`),n.image&&(s+=`
+      image: "${n.image}",`),n.ssmSecretsPath&&(s+=`
+      ssmSecretsPath: "${n.ssmSecretsPath}",`);const i=Q(n,t,l);if(n.containers?.length){s+=`
+      containers: [{`;for(let r=0;r<n.containers.length;r++){const h=n.containers[r];if(!h)continue;const u=r===0&&(i.needsDb||i.needsStorage||i.needsMessaging)&&a,V=i.needsDb?o:{env:{},secrets:{}},S=i.needsStorage?g:{env:{},secrets:{}},R=i.needsMessaging?d:{env:{},secrets:{}};r>0&&(s+=`
+      }, {`),s+=K(h,u,V,S,R,f)}s+=`
+      }],`}if(n.routing&&(s+=W(n.routing)),n.cpu!==void 0&&(s+=`
+      cpu: ${n.cpu},`),n.memoryLimitMiB!==void 0&&(s+=`
+      memoryLimitMiB: ${n.memoryLimitMiB},`),n.desiredCount!==void 0&&(s+=`
+      desiredCount: ${n.desiredCount},`),n.scaling!==void 0&&(s+=q(n.scaling)),n.alarms===!1?s+=`
+      alarms: false,`:typeof n.alarms=="object"&&(s+=`
+      alarms: ${$(n.alarms,"      ")},`),s+=y(n.extraProperties,"      "),i.needsDb||i.needsStorage||i.needsMessaging){const r=i.needsDb?x(c,l):[],h=i.needsStorage?M(c,l):[],u=i.needsMessaging?O(c,l):[];(r.length>0||h.length>0||u.length>0)&&(s+=`
+      ${T(r,h,u)}`)}return s}function Z(e,n){const t=D(e),a={...A},o={env:{},secrets:{}};if(v(e)){const c=B(n,e);Object.assign(o.env,c.env),Object.assign(o.secrets,c.secrets)}const g={env:{},secrets:{}};if(p(e)){const c=U(n,e);Object.assign(g.env,c.env)}const d={env:{},secrets:{}};if(b(e)){const c=z(n,e);Object.assign(d.env,c.env)}let f=`
+    ecrRepository: app.getDefaultContainerRegistry(),`;if(f+=J(e),e.services?.length){f+=`
+    services: [{`;for(let c=0;c<e.services.length;c++){const l=e.services[c];l&&(c>0&&(f+=`
+    }, {`),f+=X({service:l,isFirstService:c===0,hasConnections:!!t,dbEnvVars:o,storageEnvVars:g,messagingEnvVars:d,baseEnvVars:a,plan:n,compute:e}))}f+=`
+    }],`}return f+=y(e.extraProperties),f+=`
+    ...(getConfig().environment === "production" ? { alertsTopic: "import:SharedAlarmTopicArn" } : {}),`,f}function ie(e,n){if(e.compute.length===0)return"";let t="";for(let a=0;a<e.compute.length;a++){const o=e.compute[a],g=n.has(o.name),d=_(o),f=e.database.length>0||e.s3.length>0||a>0,c=g?`const ${d} = `:"";t+=`${f?`
+`:""}${c}app.addCompute(
+  ComputeFactory.build("${o.name}", {
+    type: "${o.type}",`,o.type===E.LAMBDA?t+=F(o,e):o.type===E.EC2?t+=Y(o):o.type===E.ECS&&(t+=Z(o,e)),t+=G(o,e),t+=`
   })
 );
-`;
-    }
-    return code;
-}
+`}return t}export{ie as generateComputeCode,Y as generateEc2Code,Z as generateEcsCode,F as generateLambdaCode,G as generateLambdaConnectionsCode};