@fjall/generator 0.88.4

package/dist/src/generation/compute.js

@@ -0,0 +1,547 @@
+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 { 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 any connections (database or storage) */
+function computeHasConnections(compute) {
+    return (computeHasDatabaseConnections(compute) ||
+        computeHasStorageConnections(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 += `
+    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);
+    if (!hasDatabaseConnections && !hasStorageConns)
+        return "";
+    const connectedDatabases = hasDatabaseConnections
+        ? getConnectedDatabases(plan, compute)
+        : [];
+    const connectedStorage = hasStorageConns
+        ? getConnectedStorage(plan, compute)
+        : [];
+    if (connectedDatabases.length === 0 && connectedStorage.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 };
+        }
+    }
+    // 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)}`;
+    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, 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,
+    ];
+    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,
+            ...containerConfig.environment,
+        }
+        : { ...baseEnvVars, ...stripConnectionEnv(containerConfig.environment) };
+    const containerSecrets = shouldAddConnectionEnv
+        ? { ...dbEnvVars.secrets, ...containerConfig.secretsImport }
+        : stripConnectionEnv(containerConfig.secretsImport);
+    if (containerEnv && Object.keys(containerEnv).length > 0) {
+        code += `
+        environment: {
+${formatEnvBlock(containerEnv, "          ")}
+        },`;
+    }
+    if (containerSecrets && Object.keys(containerSecrets).length > 0) {
+        code += `
+        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 `
+      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}
+      },`;
+}
+function generateEcsServiceCode(options) {
+    const { service, isFirstService, hasConnections, dbEnvVars, storageEnvVars, 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}",`;
+    }
+    if (service.containers?.length) {
+        code += `
+      containers: [{`;
+        for (let i = 0; i < service.containers.length; i++) {
+            const container = service.containers[i];
+            if (!container)
+                continue;
+            const serviceNeedsDb = service.needsDatabaseConnection !== undefined
+                ? service.needsDatabaseConnection
+                : isFirstService && computeHasDatabaseConnections(compute);
+            const serviceNeedsStorage = service.needsStorageConnection !== undefined
+                ? service.needsStorageConnection
+                : isFirstService && computeHasStorageConnections(compute);
+            const shouldAddConnectionEnv = i === 0 && (serviceNeedsDb || serviceNeedsStorage) && hasConnections;
+            // Build per-container env vars: only include the connection types this service needs
+            const containerDbEnvVars = serviceNeedsDb
+                ? dbEnvVars
+                : { env: {}, secrets: {} };
+            const containerStorageEnvVars = serviceNeedsStorage
+                ? storageEnvVars
+                : { env: {}, secrets: {} };
+            if (i > 0) {
+                code += `
+      }, {`;
+            }
+            code += generateEcsContainerCode(container, shouldAddConnectionEnv, containerDbEnvVars, containerStorageEnvVars, 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, "      ");
+    const serviceNeedsDbConnection = service.needsDatabaseConnection !== undefined
+        ? service.needsDatabaseConnection
+        : isFirstService && computeHasDatabaseConnections(compute);
+    const serviceNeedsStorageConnection = service.needsStorageConnection !== undefined
+        ? service.needsStorageConnection
+        : isFirstService && computeHasStorageConnections(compute);
+    if (serviceNeedsDbConnection || serviceNeedsStorageConnection) {
+        const connectedDatabases = serviceNeedsDbConnection
+            ? getConnectedDatabases(plan, compute)
+            : [];
+        const connectedStorage = serviceNeedsStorageConnection
+            ? getConnectedStorage(plan, compute)
+            : [];
+        if (connectedDatabases.length > 0 || connectedStorage.length > 0) {
+            code += `
+      ${formatAllConnectionsCode(connectedDatabases, connectedStorage)}`;
+        }
+    }
+    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);
+    }
+    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,
+                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 += `
+  })
+);
+`;
+    }
+    return code;
+}

package/dist/src/generation/database.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Database Code Generation
+ *
+ * Functions for generating database infrastructure code including
+ * RDS Instance, Aurora, and GlobalAurora configurations.
+ */
+import type { DatabaseResourcePlan, ApplicationResourcePlan, ComputeResourcePlan } from "../schemas/resourceSchemas.js";
+export declare const DATABASE_ENV_VARS: Readonly<{
+    readonly HOST: "DATABASE_HOST";
+    readonly PORT: "DATABASE_PORT";
+    readonly NAME: "DATABASE_NAME";
+    readonly SSL: "DATABASE_SSL";
+    readonly USERNAME: "DATABASE_USERNAME";
+    readonly PASSWORD: "DATABASE_PASSWORD";
+}>;
+export declare const CREDENTIAL_KEYS: Readonly<{
+    readonly USERNAME: "username";
+    readonly PASSWORD: "password";
+}>;
+export type DatabaseEnvVarEntry = {
+    key: string;
+    expression: string;
+    isSecret: boolean;
+};
+export interface DatabaseEnvVars {
+    env: Record<string, unknown>;
+    secrets: Record<string, unknown>;
+}
+/**
+ * Get databases connected to a compute resource
+ */
+export declare function getConnectedDatabases(plan: ApplicationResourcePlan, compute: ComputeResourcePlan): DatabaseResourcePlan[];
+/**
+ * Generate database environment variable entries for a list of connected databases.
+ * Both ECS and Lambda use containerSecretsImport with getImport() for credentials.
+ * Credential entries are always marked as secrets (isSecret: true).
+ */
+export declare function generateDatabaseEnvVarEntries(connectedDatabases: DatabaseResourcePlan[]): DatabaseEnvVarEntry[];
+/**
+ * Format database connections array for generated infrastructure code
+ */
+export declare function formatConnectionsCode(connectedDatabases: DatabaseResourcePlan[]): string;
+/**
+ * Build database environment variables for a compute resource
+ */
+export declare function buildDatabaseEnvVars(plan: ApplicationResourcePlan, compute: ComputeResourcePlan): DatabaseEnvVars;
+/**
+ * Check if a database needs a variable assignment (referenced by compute)
+ */
+export declare function databaseNeedsVariable(database: DatabaseResourcePlan, plan: ApplicationResourcePlan): boolean;
+/**
+ * Generate database infrastructure code
+ */
+export declare function generateDatabaseCode(plan: ApplicationResourcePlan): string;