@fjall/generator 0.88.4

package/dist/src/generation/database.js

@@ -0,0 +1,201 @@
+/**
+ * Database Code Generation
+ *
+ * Functions for generating database infrastructure code including
+ * RDS Instance, Aurora, and GlobalAurora configurations.
+ */
+import { buildProperty, getVariableName, emitExtraProperties, } from "./common.js";
+export const DATABASE_ENV_VARS = Object.freeze({
+    HOST: "DATABASE_HOST",
+    PORT: "DATABASE_PORT",
+    NAME: "DATABASE_NAME",
+    SSL: "DATABASE_SSL",
+    USERNAME: "DATABASE_USERNAME",
+    PASSWORD: "DATABASE_PASSWORD",
+});
+export const CREDENTIAL_KEYS = Object.freeze({
+    USERNAME: "username",
+    PASSWORD: "password",
+});
+/**
+ * Get databases connected to a compute resource
+ */
+export function getConnectedDatabases(plan, compute) {
+    const connected = compute.connectedDatabase;
+    if (!connected?.length)
+        return [];
+    return plan.database.filter((db) => connected.includes(db.name));
+}
+/**
+ * Generate credential expression for database secrets.
+ * Both ECS and Lambda now use the unified getImport() API.
+ * The infrastructure layer handles the difference:
+ * - ECS: native Secrets Manager injection via EcsSecret.fromSecretsManager()
+ * - Lambda: CloudFormation dynamic reference resolved at deploy time
+ */
+function getCredentialExpression(dbVar, credentialKey) {
+    return `${dbVar}.getCredentials().getImport("${credentialKey}")`;
+}
+/**
+ * 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 function generateDatabaseEnvVarEntries(connectedDatabases) {
+    const entries = [];
+    const addEntry = (key, expression, isSecret) => {
+        entries.push({ key, expression, isSecret });
+    };
+    if (connectedDatabases.length === 1) {
+        const dbVar = getVariableName(connectedDatabases[0]);
+        addEntry(DATABASE_ENV_VARS.HOST, `${dbVar}.getHostEndpoint()`, false);
+        addEntry(DATABASE_ENV_VARS.PORT, `${dbVar}.getHostPort()`, false);
+        addEntry(DATABASE_ENV_VARS.NAME, `${dbVar}.getDatabaseName()`, false);
+        addEntry(DATABASE_ENV_VARS.SSL, `"true"`, false);
+        addEntry(DATABASE_ENV_VARS.USERNAME, getCredentialExpression(dbVar, CREDENTIAL_KEYS.USERNAME), true);
+        addEntry(DATABASE_ENV_VARS.PASSWORD, getCredentialExpression(dbVar, CREDENTIAL_KEYS.PASSWORD), true);
+    }
+    else {
+        for (const [index, database] of connectedDatabases.entries()) {
+            const dbVar = getVariableName(database);
+            const suffix = index === 0 ? "" : `_${index + 1}`;
+            addEntry(`${DATABASE_ENV_VARS.HOST}${suffix}`, `${dbVar}.getHostEndpoint()`, false);
+            addEntry(`${DATABASE_ENV_VARS.PORT}${suffix}`, `${dbVar}.getHostPort()`, false);
+            addEntry(`${DATABASE_ENV_VARS.NAME}${suffix}`, `${dbVar}.getDatabaseName()`, false);
+            addEntry(`${DATABASE_ENV_VARS.SSL}${suffix}`, `"true"`, false);
+            addEntry(`${DATABASE_ENV_VARS.USERNAME}${suffix}`, getCredentialExpression(dbVar, CREDENTIAL_KEYS.USERNAME), true);
+            addEntry(`${DATABASE_ENV_VARS.PASSWORD}${suffix}`, getCredentialExpression(dbVar, CREDENTIAL_KEYS.PASSWORD), true);
+        }
+    }
+    return entries;
+}
+/**
+ * Format database connections array for generated infrastructure code
+ */
+export function formatConnectionsCode(connectedDatabases) {
+    const dbVars = connectedDatabases.map((db) => getVariableName(db)).join(", ");
+    return `connections: [${dbVars}],`;
+}
+/**
+ * Build database environment variables for a compute resource
+ */
+export function buildDatabaseEnvVars(plan, compute) {
+    const env = {};
+    const secrets = {};
+    if (!compute.needsConnection || !compute.connectedDatabase?.length) {
+        return { env, secrets };
+    }
+    const connectedDatabases = getConnectedDatabases(plan, compute);
+    const entries = generateDatabaseEnvVarEntries(connectedDatabases);
+    for (const entry of entries) {
+        const value = entry.expression === `"true"`
+            ? "true"
+            : { __expression: entry.expression };
+        if (entry.isSecret) {
+            secrets[entry.key] = { __expression: entry.expression };
+        }
+        else {
+            env[entry.key] = value;
+        }
+    }
+    return { env, secrets };
+}
+function generateDatabaseSharedProps(database) {
+    let code = "";
+    code += buildProperty(database.port !== undefined, "port", database.port);
+    code += buildProperty(database.deletionProtection !== undefined, "deletionProtection", database.deletionProtection);
+    code += buildProperty(database.snapshotIdentifier !== undefined, "snapshotIdentifier", database.snapshotIdentifier, "string");
+    code += buildProperty(database.snapshotUsername !== undefined, "snapshotUsername", database.snapshotUsername, "string");
+    return code;
+}
+function generateDatabaseInstanceProps(database) {
+    if (database.type !== "Instance")
+        return "";
+    let code = "";
+    code += buildProperty(database.instanceType !== undefined, "instanceType", database.instanceType, "string");
+    code += buildProperty(database.multiAz !== undefined, "multiAz", database.multiAz);
+    code += buildProperty(database.publiclyAccessible !== undefined, "publiclyAccessible", database.publiclyAccessible);
+    code += buildProperty(database.enableSecretRotation !== undefined, "enableSecretRotation", database.enableSecretRotation);
+    code += buildProperty(database.encryption !== undefined, "encryption", database.encryption, "object");
+    code += buildProperty(database.databaseInsights !== undefined, "databaseInsights", database.databaseInsights, "boolean-or-object");
+    code += buildProperty(database.proxy !== undefined, "proxy", database.proxy, "boolean-or-object");
+    code += buildProperty(database.readReplica !== undefined, "readReplica", database.readReplica, "boolean-or-object");
+    code += buildProperty(database.credentials !== undefined, "credentials", database.credentials, "object");
+    code += buildProperty(database.backupRetention !== undefined, "backupRetention", database.backupRetention);
+    return code;
+}
+function generateDatabaseAuroraProps(database) {
+    if (database.type !== "Aurora" && database.type !== "GlobalAurora")
+        return "";
+    let code = "";
+    code += buildProperty(database.encryption !== undefined, "encryption", database.encryption, "object");
+    code += buildProperty(database.databaseInsights !== undefined, "databaseInsights", database.databaseInsights, "boolean-or-object");
+    code += buildProperty(database.proxy !== undefined, "proxy", database.proxy, "boolean-or-object");
+    code += buildProperty(database.credentials !== undefined, "credentials", database.credentials, "object");
+    code += buildProperty(database.writer !== undefined, "writer", database.writer, "object");
+    code += buildProperty(database.readers !== undefined, "readers", database.readers, "boolean-or-object");
+    code += buildProperty(database.backupRetention !== undefined, "backupRetention", database.backupRetention);
+    code += buildProperty(database.preferredMaintenanceWindow !== undefined, "preferredMaintenanceWindow", database.preferredMaintenanceWindow, "string");
+    return code;
+}
+function generateDatabaseGlobalAuroraProps(database) {
+    if (database.type !== "GlobalAurora")
+        return "";
+    let code = "";
+    code += buildProperty(database.primaryRegion !== undefined, "primaryRegion", database.primaryRegion, "string");
+    if (database.secondaryRegions !== undefined &&
+        database.secondaryRegions.length > 0) {
+        code += `
+    secondaryRegions: [${database.secondaryRegions.map((r) => `"${r}"`).join(", ")}],`;
+    }
+    code += buildProperty(database.globalClusterIdentifier !== undefined, "globalClusterIdentifier", database.globalClusterIdentifier, "string");
+    code += buildProperty(database.enableGlobalWriteForwarding !== undefined, "enableGlobalWriteForwarding", database.enableGlobalWriteForwarding);
+    return code;
+}
+/**
+ * Check if a database needs a variable assignment (referenced by compute)
+ */
+export function databaseNeedsVariable(database, plan) {
+    return plan.compute.some((compute) => compute.needsConnection &&
+        compute.connectedDatabase?.includes(database.name));
+}
+/**
+ * Generate database infrastructure code
+ */
+export function generateDatabaseCode(plan) {
+    if (plan.database.length === 0)
+        return "";
+    let code = "";
+    for (let dbIndex = 0; dbIndex < plan.database.length; dbIndex++) {
+        const database = plan.database[dbIndex];
+        const databaseVariable = getVariableName(database);
+        const hasConnections = databaseNeedsVariable(database, plan);
+        const needsLeadingNewline = dbIndex > 0;
+        const prefix = hasConnections ? `const ${databaseVariable} = ` : "";
+        const leadingNewline = needsLeadingNewline ? "\n" : "";
+        code += `${leadingNewline}${prefix}app.addDatabase(
+  DatabaseFactory.build("${database.name}", {
+    vpc: app.getVpc(),
+    type: "${database.type}",
+    databaseName: "${database.databaseName}",`;
+        // Engine expression round-trip: emit raw CDK expression if preserved
+        if (database.engineExpression) {
+            code += `
+    engine: ${database.engineExpression},`;
+        }
+        else if (database.databaseEngine) {
+            code += `
+    databaseEngine: "${database.databaseEngine}",`;
+        }
+        code += generateDatabaseSharedProps(database);
+        code += generateDatabaseInstanceProps(database);
+        code += generateDatabaseAuroraProps(database);
+        code += generateDatabaseGlobalAuroraProps(database);
+        code += emitExtraProperties(database.extraProperties);
+        code += `
+  })
+);
+`;
+    }
+    return code;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Code Generation Modules
+ *
+ * This module re-exports all code generation utilities for generating
+ * infrastructure code from resource plans.
+ */
+export { type IdentifierValue, type ExpressionValue, type CallValue, type SpecialValue, isSpecialValue, toPascalCase, toKebab, toValidDatabaseName, toVariableName, formatValue, buildProperty, getVariableName, resolveResourceVariable, emitExtraProperties, } from "./common.js";
+export { DATABASE_ENV_VARS, CREDENTIAL_KEYS, type DatabaseEnvVarEntry, type DatabaseEnvVars, getConnectedDatabases, generateDatabaseEnvVarEntries, formatConnectionsCode, buildDatabaseEnvVars, databaseNeedsVariable, generateDatabaseCode, } from "./database.js";
+export { STORAGE_ENV_VARS, type StorageEnvVarEntry, type StorageEnvVars, getConnectedStorage, generateStorageEnvVarEntries, buildStorageEnvVars, formatAllConnectionsCode, } from "./storageConnections.js";
+export { generateLambdaCode, generateLambdaConnectionsCode, generateEc2Code, generateEcsCode, generateComputeCode, } from "./compute.js";
+export { generateS3Code, generateDynamoDBCode, generateSQSCode, s3NeedsVariable, } from "./storage.js";
+export { generateNetworkCode, generateTags, generateAppInit, generateImports, generateCDNCode, collectCdnReferencedResources, usesPatternApproach, generatePatternCodeWithComments, } from "./infrastructure.js";

package/dist/src/generation/index.js

@@ -0,0 +1,18 @@
+/**
+ * Code Generation Modules
+ *
+ * This module re-exports all code generation utilities for generating
+ * infrastructure code from resource plans.
+ */
+// Common utilities
+export { isSpecialValue, toPascalCase, toKebab, toValidDatabaseName, toVariableName, formatValue, buildProperty, getVariableName, resolveResourceVariable, emitExtraProperties, } from "./common.js";
+// Database generation
+export { DATABASE_ENV_VARS, CREDENTIAL_KEYS, getConnectedDatabases, generateDatabaseEnvVarEntries, formatConnectionsCode, buildDatabaseEnvVars, databaseNeedsVariable, generateDatabaseCode, } from "./database.js";
+// Storage connections
+export { STORAGE_ENV_VARS, getConnectedStorage, generateStorageEnvVarEntries, buildStorageEnvVars, formatAllConnectionsCode, } from "./storageConnections.js";
+// Compute generation
+export { generateLambdaCode, generateLambdaConnectionsCode, generateEc2Code, generateEcsCode, generateComputeCode, } from "./compute.js";
+// Storage generation
+export { generateS3Code, generateDynamoDBCode, generateSQSCode, s3NeedsVariable, } from "./storage.js";
+// Infrastructure generation
+export { generateNetworkCode, generateTags, generateAppInit, generateImports, generateCDNCode, collectCdnReferencedResources, usesPatternApproach, generatePatternCodeWithComments, } from "./infrastructure.js";

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

@@ -0,0 +1,44 @@
+/**
+ * Infrastructure Code Generation
+ *
+ * Functions for generating infrastructure setup code including
+ * network configuration, tags, imports, CDN, and app initialisation.
+ */
+import type { ApplicationResourcePlan } from "../schemas/resourceSchemas.js";
+export declare const COST_ALLOCATION_TAG: "fjall:costAllocation:owner";
+export declare const DEFAULT_COST_ALLOCATION_OWNER: "engineering";
+/**
+ * Generate network infrastructure code for additional networks
+ */
+export declare function generateNetworkCode(plan: ApplicationResourcePlan): string;
+/**
+ * Generate tags infrastructure code
+ */
+export declare function generateTags(plan: ApplicationResourcePlan): string;
+/**
+ * Generate app initialisation code
+ */
+export declare function generateAppInit(plan: ApplicationResourcePlan): string;
+/**
+ * Generate import statements for the infrastructure file
+ */
+export declare function generateImports(plan: ApplicationResourcePlan): string;
+/**
+ * Generate CDN infrastructure code
+ */
+export declare function generateCDNCode(plan: ApplicationResourcePlan): string;
+/**
+ * Collect CDN-referenced resources for compute variable naming
+ */
+export declare function collectCdnReferencedResources(plan: ApplicationResourcePlan): Set<string>;
+/**
+ * Check if a plan uses the pattern approach (PatternFactory).
+ * When patternConfig is present, we generate a single PatternFactory.build() call
+ * instead of individual factory calls for each resource.
+ */
+export declare function usesPatternApproach(plan: ApplicationResourcePlan): boolean;
+/**
+ * Generate pattern infrastructure code with clean formatting.
+ * Handles both Payload and Next.js OpenNext patterns.
+ */
+export declare function generatePatternCodeWithComments(plan: ApplicationResourcePlan): string;

package/dist/src/generation/infrastructure.js

@@ -0,0 +1,389 @@
+/**
+ * Infrastructure Code Generation
+ *
+ * Functions for generating infrastructure setup code including
+ * network configuration, tags, imports, CDN, and app initialisation.
+ */
+import { toVariableName, toPascalCase, formatValue, resolveResourceVariable, emitExtraProperties, } from "./common.js";
+import { COMPUTE_TYPE } from "../schemas/constants.js";
+export const COST_ALLOCATION_TAG = "fjall:costAllocation:owner";
+export const DEFAULT_COST_ALLOCATION_OWNER = "engineering";
+/**
+ * Check if value is an empty object {}.
+ * Used to filter out meaningless config like `flowLogs: {}`.
+ */
+function isEmptyObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        Object.keys(value).length === 0);
+}
+/**
+ * Clean network config by removing empty flowLogs.
+ * `flowLogs: {}` means "use defaults" which is the same as omitting it.
+ * Only keep flowLogs when it's `false` (explicitly disabled) or has config.
+ */
+function cleanNetworkConfig(network) {
+    const cleaned = { ...network };
+    if (isEmptyObject(cleaned.flowLogs)) {
+        delete cleaned.flowLogs;
+    }
+    return cleaned;
+}
+/**
+ * Generate network infrastructure code for additional networks
+ */
+export function generateNetworkCode(plan) {
+    if (!plan.additionalNetworks || plan.additionalNetworks.length === 0) {
+        return "";
+    }
+    let code = "";
+    for (const network of plan.additionalNetworks) {
+        const varName = toVariableName(network.name);
+        const config = {};
+        if (network.maxAzs !== undefined)
+            config.maxAzs = network.maxAzs;
+        if (network.natGateways !== undefined)
+            config.natGateways = network.natGateways;
+        if (network.flowLogs !== undefined)
+            config.flowLogs = network.flowLogs;
+        if (network.vpcEndpoints !== undefined)
+            config.vpcEndpoints = network.vpcEndpoints;
+        const cleanedConfig = cleanNetworkConfig(config);
+        code += `const ${varName} = app.addNetwork(
+  NetworkFactory.build("${network.name}", ${formatValue(cleanedConfig, "  ")})
+);
+
+`;
+    }
+    return code;
+}
+/**
+ * Generate tags infrastructure code
+ */
+export function generateTags(plan) {
+    const tags = {};
+    if (plan.tags && Object.keys(plan.tags).length > 0) {
+        Object.assign(tags, plan.tags);
+    }
+    if (!tags[COST_ALLOCATION_TAG]) {
+        tags[COST_ALLOCATION_TAG] = plan.owner || DEFAULT_COST_ALLOCATION_OWNER;
+    }
+    const tagEntries = Object.entries(tags)
+        .map(([key, value]) => `  "${key}": "${value}"`)
+        .join(",\n");
+    return `app.addTags({
+${tagEntries}
+});
+
+`;
+}
+/**
+ * Generate app initialisation code
+ */
+export function generateAppInit(plan) {
+    let code = `
+const appName = "${plan.appName}";
+`;
+    const backupConfig = plan.backup && typeof plan.backup === "object" ? plan.backup : undefined;
+    const tunnelConfig = plan.tunnel && typeof plan.tunnel === "object" ? plan.tunnel : undefined;
+    const tunnelSnippet = tunnelConfig
+        ? tunnelConfig.instanceType
+            ? `tunnel: { instanceType: "${tunnelConfig.instanceType}" }`
+            : "tunnel: true"
+        : undefined;
+    if (plan.vpcId) {
+        code += `const app = App.getApp(appName, {
+  network: { useExisting: "${plan.vpcId}" }`;
+        if (backupConfig) {
+            code += `,
+  backup: { tier: "${backupConfig.tier}" }`;
+        }
+        if (tunnelSnippet) {
+            code += `,
+  ${tunnelSnippet}`;
+        }
+        code += `
+});
+`;
+    }
+    else if (plan.network) {
+        const cleanedNetwork = cleanNetworkConfig(plan.network);
+        code += `const app = App.getApp(appName, {
+  network: ${formatValue(cleanedNetwork, "  ")}`;
+        if (backupConfig) {
+            code += `,
+  backup: { tier: "${backupConfig.tier}" }`;
+        }
+        if (tunnelSnippet) {
+            code += `,
+  ${tunnelSnippet}`;
+        }
+        code += `
+});
+`;
+    }
+    else {
+        code += `const app = App.getApp(appName, { network: false`;
+        if (backupConfig) {
+            code += `, backup: { tier: "${backupConfig.tier}" }`;
+        }
+        if (tunnelSnippet) {
+            code += `, ${tunnelSnippet}`;
+        }
+        code += ` });
+`;
+    }
+    code += `
+`;
+    return code;
+}
+/**
+ * Generate import statements for the infrastructure file
+ */
+export function generateImports(plan) {
+    const imports = [];
+    if (plan.patternConfig) {
+        imports.push("PatternFactory");
+    }
+    else {
+        if (plan.database.length > 0) {
+            imports.push("DatabaseFactory");
+        }
+        if (plan.s3.length > 0) {
+            imports.push("StorageFactory");
+        }
+        if (plan.compute.length > 0) {
+            imports.push("ComputeFactory");
+            imports.push("getConfig");
+        }
+        if (plan.dynamodb &&
+            plan.dynamodb.length > 0 &&
+            plan.database.length === 0) {
+            imports.push("DatabaseFactory");
+        }
+        if (plan.sqs && plan.sqs.length > 0) {
+            imports.push("MessagingFactory");
+        }
+        if (plan.cdn) {
+            imports.push("CdnFactory");
+        }
+        const hasCodeBasedLambda = plan.compute.some((c) => c.type === COMPUTE_TYPE.LAMBDA && c.deployment === "code");
+        if (hasCodeBasedLambda) {
+            imports.push("Code");
+            imports.push("Runtime");
+        }
+        const hasFunctionUrl = plan.compute.some((c) => c.type === COMPUTE_TYPE.LAMBDA && c.functionUrl);
+        if (hasFunctionUrl) {
+            imports.push("FunctionUrlAuthType");
+        }
+        const hasArchitecture = plan.compute.some((c) => c.type === COMPUTE_TYPE.LAMBDA &&
+            (c.architecture || c.deployment === "container"));
+        if (hasArchitecture) {
+            imports.push("Architecture");
+        }
+    }
+    if (plan.additionalNetworks && plan.additionalNetworks.length > 0) {
+        imports.push("NetworkFactory");
+    }
+    // Merge additional named imports for @fjall/components-infrastructure
+    if (plan.additionalManagedImports) {
+        for (const extra of plan.additionalManagedImports) {
+            if (extra.moduleSpecifier === "@fjall/components-infrastructure" ||
+                extra.moduleSpecifier === "@fjall/infrastructure") {
+                for (const name of extra.namedImports) {
+                    if (!imports.includes(name)) {
+                        imports.push(name);
+                    }
+                }
+            }
+        }
+    }
+    const importList = imports.length > 0 ? `, ${imports.join(", ")}` : "";
+    let code = `#!/usr/bin/env node
+
+import { App${importList} } from "@fjall/components-infrastructure";
+`;
+    // Append separate lines for other managed modules (aws-cdk-lib/*, constructs)
+    if (plan.additionalManagedImports) {
+        for (const extra of plan.additionalManagedImports) {
+            if (extra.moduleSpecifier === "@fjall/components-infrastructure" ||
+                extra.moduleSpecifier === "@fjall/infrastructure") {
+                continue;
+            }
+            const namedPart = extra.namedImports.length > 0
+                ? `{ ${extra.namedImports.join(", ")} }`
+                : "";
+            const defaultPart = extra.defaultImport ?? "";
+            const importParts = [defaultPart, namedPart].filter(Boolean).join(", ");
+            if (importParts) {
+                code += `import ${importParts} from "${extra.moduleSpecifier}";\n`;
+            }
+        }
+    }
+    return code;
+}
+/**
+ * Generate CDN infrastructure code
+ */
+export function generateCDNCode(plan) {
+    if (!plan.cdn)
+        return "";
+    const defaultOriginVar = resolveResourceVariable(plan, plan.cdn.defaultOriginRef);
+    let code = `
+app.addCdn(
+  CdnFactory.build("${plan.cdn.name}", {
+    originType: "auto",
+    origin: ${defaultOriginVar}`;
+    if (plan.cdn.behaviours && plan.cdn.behaviours.length > 0) {
+        const behavioursStr = plan.cdn.behaviours
+            .map((b) => {
+            const originVar = resolveResourceVariable(plan, b.originRef);
+            let bCode = `{\n        pathPattern: "${b.pathPattern}",\n        origin: ${originVar},`;
+            if (b.cachePolicy) {
+                bCode += `\n        cachePolicy: "${b.cachePolicy}",`;
+            }
+            bCode += `\n      }`;
+            return bCode;
+        })
+            .join(",\n      ");
+        code += `,
+    behaviours: [
+      ${behavioursStr}
+    ]`;
+    }
+    if (plan.cdn.customDomain) {
+        code += `,
+    domainNames: ["${plan.cdn.customDomain}"]`;
+    }
+    if (plan.cdn.certificateArn) {
+        code += `,
+    certificateArn: "${plan.cdn.certificateArn}"`;
+    }
+    if (plan.cdn.accessGate !== undefined) {
+        if (plan.cdn.accessGate === false) {
+            code += `,
+    accessGate: false`;
+        }
+        else {
+            code += `,
+    accessGate: ${formatValue(plan.cdn.accessGate, "    ")}`;
+        }
+    }
+    code += emitExtraProperties(plan.cdn.extraProperties);
+    code += `
+  })
+);
+`;
+    return code;
+}
+/**
+ * Collect CDN-referenced resources for compute variable naming
+ */
+export function collectCdnReferencedResources(plan) {
+    const cdnReferencedResources = new Set();
+    if (plan.cdn) {
+        if (plan.cdn.defaultOriginRef) {
+            cdnReferencedResources.add(plan.cdn.defaultOriginRef);
+        }
+        if (plan.cdn.behaviours) {
+            for (const behaviour of plan.cdn.behaviours) {
+                cdnReferencedResources.add(behaviour.originRef);
+            }
+        }
+    }
+    return cdnReferencedResources;
+}
+/**
+ * Check if a plan uses the pattern approach (PatternFactory).
+ * When patternConfig is present, we generate a single PatternFactory.build() call
+ * instead of individual factory calls for each resource.
+ */
+export function usesPatternApproach(plan) {
+    return plan.patternConfig !== undefined;
+}
+/** Default values for OpenNext pattern code generation (matches tier presets). */
+const OPENNEXT_DEFAULTS = Object.freeze({
+    database: {
+        type: "Instance",
+        backupRetention: 7,
+        deletionProtection: true,
+    },
+    compute: {
+        server: { memorySize: 1536, timeout: 30 },
+        imageOptimisation: { memorySize: 1536, timeout: 30 },
+        revalidation: { memorySize: 768, timeout: 300 },
+    },
+});
+/**
+ * Generate pattern infrastructure code with clean formatting.
+ * Handles both Payload and Next.js OpenNext patterns.
+ */
+export function generatePatternCodeWithComments(plan) {
+    if (!plan.patternConfig)
+        return "";
+    const config = plan.patternConfig;
+    const pascalName = toPascalCase(config.name);
+    const typeSuffix = config.type === "payload" ? "Payload" : "Nextjs";
+    const constructId = `${pascalName}${typeSuffix}`;
+    let code = `app.addPattern(
+  PatternFactory.build("${constructId}", {
+    type: "${config.type}",
+    name: "${config.name}",`;
+    if (config.domain) {
+        code += `
+    domain: "${config.domain}",`;
+    }
+    if (config.type === "payload" || config.type === "nextjs") {
+        const db = config.database || {};
+        const compute = config.compute || {};
+        const dbType = db.type || OPENNEXT_DEFAULTS.database.type;
+        const backupRetention = db.backupRetention ?? OPENNEXT_DEFAULTS.database.backupRetention;
+        const deletionProtection = db.deletionProtection ?? OPENNEXT_DEFAULTS.database.deletionProtection;
+        code += `
+    database: {
+      type: "${dbType}",`;
+        if (db.databaseName) {
+            code += `
+      databaseName: "${db.databaseName}",`;
+        }
+        if (dbType === "Instance" && db.instanceType) {
+            code += `
+      instanceType: "${db.instanceType}",`;
+        }
+        code += `
+      backupRetention: ${backupRetention},
+      deletionProtection: ${deletionProtection},
+    },`;
+        const serverMemory = compute.server?.memorySize ?? OPENNEXT_DEFAULTS.compute.server.memorySize;
+        const serverTimeout = compute.server?.timeout ?? OPENNEXT_DEFAULTS.compute.server.timeout;
+        const imageMemory = compute.imageOptimisation?.memorySize ??
+            OPENNEXT_DEFAULTS.compute.imageOptimisation.memorySize;
+        const imageTimeout = compute.imageOptimisation?.timeout ??
+            OPENNEXT_DEFAULTS.compute.imageOptimisation.timeout;
+        const revalidationMemory = compute.revalidation?.memorySize ??
+            OPENNEXT_DEFAULTS.compute.revalidation.memorySize;
+        const revalidationTimeout = compute.revalidation?.timeout ??
+            OPENNEXT_DEFAULTS.compute.revalidation.timeout;
+        code += `
+    compute: {
+      server: {
+        memorySize: ${serverMemory},
+        timeout: ${serverTimeout},
+      },
+      imageOptimisation: {
+        memorySize: ${imageMemory},
+        timeout: ${imageTimeout},
+      },
+      revalidation: {
+        memorySize: ${revalidationMemory},
+        timeout: ${revalidationTimeout},
+      },
+    },`;
+    }
+    code += `
+  })
+);
+
+`;
+    return code;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Storage Code Generation
+ *
+ * Functions for generating storage infrastructure code including
+ * S3 buckets, DynamoDB tables, and SQS queues.
+ */
+import type { ApplicationResourcePlan, S3ResourcePlan } from "../schemas/resourceSchemas.js";
+/**
+ * Check if an S3 bucket needs a variable assignment (referenced by compute or CDN)
+ */
+export declare function s3NeedsVariable(bucket: S3ResourcePlan, plan: ApplicationResourcePlan): boolean;
+/**
+ * Generate S3 bucket infrastructure code
+ */
+export declare function generateS3Code(plan: ApplicationResourcePlan): string;
+/**
+ * Generate DynamoDB table infrastructure code
+ */
+export declare function generateDynamoDBCode(plan: ApplicationResourcePlan): string;
+/**
+ * Generate SQS queue infrastructure code
+ */
+export declare function generateSQSCode(plan: ApplicationResourcePlan): string;