@fjall/generator 0.88.4 → 0.89.4

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

@@ -5,26 +5,11 @@
  */
 import type { IdentifierValue, ExpressionValue, CallValue, SpecialValue } from "../schemas/resourceSchemas.js";
 export type { IdentifierValue, ExpressionValue, CallValue, SpecialValue };
+export { toPascalCase, toKebab, toValidDatabaseName } from "@fjall/util";
 /**
  * Type guard to check if a value is a special code generation value
  */
 export declare function isSpecialValue(value: unknown): value is SpecialValue;
-/**
- * Convert hyphenated/underscored names to PascalCase for resource names
- */
-export declare function toPascalCase(str: string): string;
-/**
- * Convert any case (PascalCase, camelCase, kebab-case, snake_case) to kebab-case.
- * Three-pass regex: split acronyms, split camel boundaries, replace separators.
- * e.g., "MyApp" -> "my-app", "AWSLambda" -> "aws-lambda", "myApp" -> "my-app"
- */
-export declare function toKebab(str: string): string;
-/**
- * Convert a name to a valid RDS database name (snake_case).
- * RDS API allows letters, numbers, and underscores for PostgreSQL/MySQL DatabaseName.
- * Hyphens are rejected, so convert them to underscores.
- */
-export declare function toValidDatabaseName(name: string): string;
 /**
  * Convert resource names to camelCase variable names
  */

package/dist/src/generation/common.js

@@ -3,6 +3,8 @@
  *
  * Shared helper functions used across all generation modules.
  */
+// Re-export case conversion functions from @fjall/util for backwards compatibility
+export { toPascalCase, toKebab, toValidDatabaseName } from "@fjall/util";
 /**
  * Type guard to check if a value is a special code generation value
  */
@@ -15,34 +17,6 @@ export function isSpecialValue(value) {
         typeof obj.__expression === "string" ||
         typeof obj.__call === "string");
 }
-/**
- * Convert hyphenated/underscored names to PascalCase for resource names
- */
-export function toPascalCase(str) {
-    return str
-        .replace(/[-_](.)/g, (_, c) => c.toUpperCase())
-        .replace(/^./, (c) => c.toUpperCase());
-}
-/**
- * Convert any case (PascalCase, camelCase, kebab-case, snake_case) to kebab-case.
- * Three-pass regex: split acronyms, split camel boundaries, replace separators.
- * e.g., "MyApp" -> "my-app", "AWSLambda" -> "aws-lambda", "myApp" -> "my-app"
- */
-export function toKebab(str) {
-    return str
-        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
-        .replace(/([a-z\d])([A-Z])/g, "$1-$2")
-        .replace(/[\s_]+/g, "-")
-        .toLowerCase();
-}
-/**
- * Convert a name to a valid RDS database name (snake_case).
- * RDS API allows letters, numbers, and underscores for PostgreSQL/MySQL DatabaseName.
- * Hyphens are rejected, so convert them to underscores.
- */
-export function toValidDatabaseName(name) {
-    return toKebab(name).replace(/-/g, "_");
-}
 /**
  * Convert resource names to camelCase variable names
  */

package/dist/src/generation/compute.js

@@ -1,6 +1,7 @@
 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) {
@@ -10,10 +11,15 @@ function computeHasDatabaseConnections(compute) {
 function computeHasStorageConnections(compute) {
     return Boolean(compute.connectedStorage?.length);
 }
-/** Check if a compute resource has any connections (database or storage) */
+/** 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));
+        computeHasStorageConnections(compute) ||
+        computeHasMessagingConnections(compute));
 }
 const BASE_ENVIRONMENT_VARS = {
     ENVIRONMENT: { __expression: "getConfig().environment" },
@@ -106,7 +112,8 @@ export function generateLambdaConnectionsCode(compute, plan) {
         return "";
     const hasDatabaseConnections = computeHasDatabaseConnections(compute);
     const hasStorageConns = computeHasStorageConnections(compute);
-    if (!hasDatabaseConnections && !hasStorageConns)
+    const hasMessagingConns = computeHasMessagingConnections(compute);
+    if (!hasDatabaseConnections && !hasStorageConns && !hasMessagingConns)
         return "";
     const connectedDatabases = hasDatabaseConnections
         ? getConnectedDatabases(plan, compute)
@@ -114,7 +121,12 @@ export function generateLambdaConnectionsCode(compute, plan) {
     const connectedStorage = hasStorageConns
         ? getConnectedStorage(plan, compute)
         : [];
-    if (connectedDatabases.length === 0 && connectedStorage.length === 0) {
+    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
@@ -146,6 +158,13 @@ export function generateLambdaConnectionsCode(compute, plan) {
             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)) {
@@ -175,7 +194,7 @@ export function generateLambdaConnectionsCode(compute, plan) {
     },`;
     }
     code += `
-    ${formatAllConnectionsCode(connectedDatabases, connectedStorage)}`;
+    ${formatAllConnectionsCode(connectedDatabases, connectedStorage, connectedMessaging)}`;
     return code;
 }
 export function generateEc2Code(compute) {
@@ -218,7 +237,7 @@ function generateEcsClusterCode(compute) {
     cluster: {${inner}
     },`;
 }
-function generateEcsContainerCode(containerConfig, shouldAddConnectionEnv, dbEnvVars, storageEnvVars, baseEnvVars) {
+function generateEcsContainerCode(containerConfig, shouldAddConnectionEnv, dbEnvVars, storageEnvVars, messagingEnvVars, baseEnvVars) {
     let code = "";
     if (containerConfig.name) {
         code += `
@@ -252,6 +271,8 @@ function generateEcsContainerCode(containerConfig, shouldAddConnectionEnv, dbEnv
         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)
@@ -272,6 +293,7 @@ function generateEcsContainerCode(containerConfig, shouldAddConnectionEnv, dbEnv
             ...baseEnvVars,
             ...dbEnvVars.env,
             ...storageEnvVars.env,
+            ...messagingEnvVars.env,
             ...containerConfig.environment,
         }
         : { ...baseEnvVars, ...stripConnectionEnv(containerConfig.environment) };
@@ -364,8 +386,22 @@ function generateEcsServiceScalingCode(scaling) {
       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, baseEnvVars, plan, compute, } = options;
+    const { service, isFirstService, hasConnections, dbEnvVars, storageEnvVars, messagingEnvVars, baseEnvVars, plan, compute, } = options;
     let code = `
       name: "${service.name}",`;
     code += `
@@ -390,6 +426,7 @@ function generateEcsServiceCode(options) {
         code += `
       ssmSecretsPath: "${service.ssmSecretsPath}",`;
     }
+    const connectionNeeds = deriveServiceConnectionNeeds(service, isFirstService, compute);
     if (service.containers?.length) {
         code += `
       containers: [{`;
@@ -397,25 +434,26 @@ function generateEcsServiceCode(options) {
             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;
+            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 = serviceNeedsDb
+            const containerDbEnvVars = connectionNeeds.needsDb
                 ? dbEnvVars
                 : { env: {}, secrets: {} };
-            const containerStorageEnvVars = serviceNeedsStorage
+            const containerStorageEnvVars = connectionNeeds.needsStorage
                 ? storageEnvVars
                 : { env: {}, secrets: {} };
+            const containerMessagingEnvVars = connectionNeeds.needsMessaging
+                ? messagingEnvVars
+                : { env: {}, secrets: {} };
             if (i > 0) {
                 code += `
       }, {`;
             }
-            code += generateEcsContainerCode(container, shouldAddConnectionEnv, containerDbEnvVars, containerStorageEnvVars, baseEnvVars);
+            code += generateEcsContainerCode(container, shouldAddConnectionEnv, containerDbEnvVars, containerStorageEnvVars, containerMessagingEnvVars, baseEnvVars);
         }
         code += `
       }],`;
@@ -439,22 +477,23 @@ function generateEcsServiceCode(options) {
         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
+    if (connectionNeeds.needsDb ||
+        connectionNeeds.needsStorage ||
+        connectionNeeds.needsMessaging) {
+        const connectedDatabases = connectionNeeds.needsDb
             ? getConnectedDatabases(plan, compute)
             : [];
-        const connectedStorage = serviceNeedsStorageConnection
+        const connectedStorage = connectionNeeds.needsStorage
             ? getConnectedStorage(plan, compute)
             : [];
-        if (connectedDatabases.length > 0 || connectedStorage.length > 0) {
+        const connectedMessaging = connectionNeeds.needsMessaging
+            ? getConnectedMessaging(plan, compute)
+            : [];
+        if (connectedDatabases.length > 0 ||
+            connectedStorage.length > 0 ||
+            connectedMessaging.length > 0) {
             code += `
-      ${formatAllConnectionsCode(connectedDatabases, connectedStorage)}`;
+      ${formatAllConnectionsCode(connectedDatabases, connectedStorage, connectedMessaging)}`;
         }
     }
     return code;
@@ -483,6 +522,15 @@ export function generateEcsCode(compute, plan) {
         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);
@@ -503,6 +551,7 @@ export function generateEcsCode(compute, plan) {
                 hasConnections: !!hasConnections,
                 dbEnvVars,
                 storageEnvVars,
+                messagingEnvVars,
                 baseEnvVars,
                 plan,
                 compute,

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

@@ -7,6 +7,7 @@
 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 { MESSAGING_ENV_VARS, type MessagingEnvVarEntry, type MessagingEnvVars, getConnectedMessaging, generateMessagingEnvVarEntries, buildMessagingEnvVars, } from "./messagingConnections.js";
 export { generateLambdaCode, generateLambdaConnectionsCode, generateEc2Code, generateEcsCode, generateComputeCode, } from "./compute.js";
-export { generateS3Code, generateDynamoDBCode, generateSQSCode, s3NeedsVariable, } from "./storage.js";
+export { generateS3Code, generateDynamoDBCode, generateSQSCode, s3NeedsVariable, sqsNeedsVariable, } from "./storage.js";
 export { generateNetworkCode, generateTags, generateAppInit, generateImports, generateCDNCode, collectCdnReferencedResources, usesPatternApproach, generatePatternCodeWithComments, } from "./infrastructure.js";

package/dist/src/generation/index.js

@@ -10,9 +10,11 @@ export { isSpecialValue, toPascalCase, toKebab, toValidDatabaseName, toVariableN
 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";
+// Messaging connections
+export { MESSAGING_ENV_VARS, getConnectedMessaging, generateMessagingEnvVarEntries, buildMessagingEnvVars, } from "./messagingConnections.js";
 // Compute generation
 export { generateLambdaCode, generateLambdaConnectionsCode, generateEc2Code, generateEcsCode, generateComputeCode, } from "./compute.js";
 // Storage generation
-export { generateS3Code, generateDynamoDBCode, generateSQSCode, s3NeedsVariable, } from "./storage.js";
+export { generateS3Code, generateDynamoDBCode, generateSQSCode, s3NeedsVariable, sqsNeedsVariable, } from "./storage.js";
 // Infrastructure generation
 export { generateNetworkCode, generateTags, generateAppInit, generateImports, generateCDNCode, collectCdnReferencedResources, usesPatternApproach, generatePatternCodeWithComments, } from "./infrastructure.js";

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

@@ -0,0 +1,33 @@
+/**
+ * Messaging Connection Code Generation
+ *
+ * Functions for generating messaging connection code (env vars, connections array)
+ * following the same pattern as database and storage connections.
+ */
+import type { SQSResourcePlan, ApplicationResourcePlan, ComputeResourcePlan } from "../schemas/resourceSchemas.js";
+export declare const MESSAGING_ENV_VARS: Readonly<{
+    readonly URL: "QUEUE_URL";
+    readonly ARN: "QUEUE_ARN";
+}>;
+export type MessagingEnvVarEntry = {
+    key: string;
+    expression: string;
+};
+export interface MessagingEnvVars {
+    env: Record<string, unknown>;
+    secrets: Record<string, unknown>;
+}
+/**
+ * Get SQS queues connected to a compute resource
+ */
+export declare function getConnectedMessaging(plan: ApplicationResourcePlan, compute: ComputeResourcePlan): SQSResourcePlan[];
+/**
+ * Generate messaging environment variable entries for a list of connected queues.
+ * SQS uses IAM-based access, so there are no secrets — only QUEUE_URL and QUEUE_ARN env vars.
+ */
+export declare function generateMessagingEnvVarEntries(connectedMessaging: SQSResourcePlan[]): MessagingEnvVarEntry[];
+/**
+ * Build messaging environment variables for a compute resource.
+ * SQS always uses IAM — secrets is always empty.
+ */
+export declare function buildMessagingEnvVars(plan: ApplicationResourcePlan, compute: ComputeResourcePlan): MessagingEnvVars;

package/dist/src/generation/messagingConnections.js

@@ -0,0 +1,73 @@
+/**
+ * Messaging Connection Code Generation
+ *
+ * Functions for generating messaging connection code (env vars, connections array)
+ * following the same pattern as database and storage connections.
+ */
+import { getVariableName } from "./common.js";
+export const MESSAGING_ENV_VARS = Object.freeze({
+    URL: "QUEUE_URL",
+    ARN: "QUEUE_ARN",
+});
+/**
+ * Get SQS queues connected to a compute resource
+ */
+export function getConnectedMessaging(plan, compute) {
+    const { connectedMessaging } = compute;
+    if (!connectedMessaging?.length)
+        return [];
+    return (plan.sqs ?? []).filter((queue) => connectedMessaging.includes(queue.name));
+}
+/**
+ * Generate messaging environment variable entries for a list of connected queues.
+ * SQS uses IAM-based access, so there are no secrets — only QUEUE_URL and QUEUE_ARN env vars.
+ */
+export function generateMessagingEnvVarEntries(connectedMessaging) {
+    const entries = [];
+    if (connectedMessaging.length === 1) {
+        const queue = connectedMessaging[0];
+        if (!queue)
+            return entries;
+        const queueVar = getVariableName(queue);
+        entries.push({
+            key: MESSAGING_ENV_VARS.URL,
+            expression: `${queueVar}.getQueueUrl()`,
+        });
+        entries.push({
+            key: MESSAGING_ENV_VARS.ARN,
+            expression: `${queueVar}.getQueueArn()`,
+        });
+    }
+    else {
+        for (const [index, queue] of connectedMessaging.entries()) {
+            const queueVar = getVariableName(queue);
+            const suffix = index === 0 ? "" : `_${index + 1}`;
+            entries.push({
+                key: `${MESSAGING_ENV_VARS.URL}${suffix}`,
+                expression: `${queueVar}.getQueueUrl()`,
+            });
+            entries.push({
+                key: `${MESSAGING_ENV_VARS.ARN}${suffix}`,
+                expression: `${queueVar}.getQueueArn()`,
+            });
+        }
+    }
+    return entries;
+}
+/**
+ * Build messaging environment variables for a compute resource.
+ * SQS always uses IAM — secrets is always empty.
+ */
+export function buildMessagingEnvVars(plan, compute) {
+    const env = {};
+    const secrets = {};
+    if (!compute.connectedMessaging?.length) {
+        return { env, secrets };
+    }
+    const connectedMessaging = getConnectedMessaging(plan, compute);
+    const entries = generateMessagingEnvVarEntries(connectedMessaging);
+    for (const entry of entries) {
+        env[entry.key] = { __expression: entry.expression };
+    }
+    return { env, secrets };
+}

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

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

package/dist/src/generation/storage.js

@@ -138,6 +138,12 @@ const ${tableVariable} = app.addDatabase(
     }
     return code;
 }
+/**
+ * Check if an SQS queue needs a variable assignment (referenced by compute)
+ */
+export function sqsNeedsVariable(queue, plan) {
+    return plan.compute.some((compute) => compute.connectedMessaging?.includes(queue.name));
+}
 /**
  * Generate SQS queue infrastructure code
  */
@@ -147,8 +153,10 @@ export function generateSQSCode(plan) {
     let code = "";
     for (const queue of plan.sqs) {
         const queueVariable = getVariableName(queue);
+        const hasReferences = sqsNeedsVariable(queue, plan);
+        const prefix = hasReferences ? `const ${queueVariable} = ` : "";
         code += `
-const ${queueVariable} = app.addMessaging(
+${prefix}app.addMessaging(
   MessagingFactory.build("${queue.name}", {
     type: "queue",
     queueType: "${queue.queueType}"`;

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

@@ -4,7 +4,7 @@
  * Functions for generating storage connection code (env vars, connections array)
  * following the same pattern as database connections.
  */
-import type { S3ResourcePlan, ApplicationResourcePlan, ComputeResourcePlan, DatabaseResourcePlan } from "../schemas/resourceSchemas.js";
+import type { S3ResourcePlan, SQSResourcePlan, ApplicationResourcePlan, ComputeResourcePlan, DatabaseResourcePlan } from "../schemas/resourceSchemas.js";
 export declare const STORAGE_ENV_VARS: Readonly<{
     readonly NAME: "BUCKET_NAME";
 }>;
@@ -32,6 +32,6 @@ export declare function generateStorageEnvVarEntries(connectedStorage: S3Resourc
 export declare function buildStorageEnvVars(plan: ApplicationResourcePlan, compute: ComputeResourcePlan): StorageEnvVars;
 /**
  * Format combined connections array for generated infrastructure code.
- * Merges both database and storage variable names into a single connections line.
+ * Merges database, storage, and messaging variable names into a single connections line.
  */
-export declare function formatAllConnectionsCode(connectedDatabases: DatabaseResourcePlan[], connectedStorage: S3ResourcePlan[]): string;
+export declare function formatAllConnectionsCode(connectedDatabases: DatabaseResourcePlan[], connectedStorage: S3ResourcePlan[], connectedMessaging?: SQSResourcePlan[]): string;

package/dist/src/generation/storageConnections.js

@@ -24,7 +24,10 @@ export function getConnectedStorage(plan, compute) {
 export function generateStorageEnvVarEntries(connectedStorage) {
     const entries = [];
     if (connectedStorage.length === 1) {
-        const bucketVar = getVariableName(connectedStorage[0]);
+        const bucket = connectedStorage[0];
+        if (!bucket)
+            return entries;
+        const bucketVar = getVariableName(bucket);
         entries.push({
             key: STORAGE_ENV_VARS.NAME,
             expression: `${bucketVar}.getBucketName()`,
@@ -61,11 +64,12 @@ export function buildStorageEnvVars(plan, compute) {
 }
 /**
  * Format combined connections array for generated infrastructure code.
- * Merges both database and storage variable names into a single connections line.
+ * Merges database, storage, and messaging variable names into a single connections line.
  */
-export function formatAllConnectionsCode(connectedDatabases, connectedStorage) {
+export function formatAllConnectionsCode(connectedDatabases, connectedStorage, connectedMessaging = []) {
     const dbVars = connectedDatabases.map((db) => getVariableName(db));
     const storageVars = connectedStorage.map((b) => getVariableName(b));
-    const allVars = [...dbVars, ...storageVars].join(", ");
+    const messagingVars = connectedMessaging.map((q) => getVariableName(q));
+    const allVars = [...dbVars, ...storageVars, ...messagingVars].join(", ");
     return `connections: [${allVars}],`;
 }

package/dist/src/index.d.ts

@@ -8,3 +8,4 @@ export * from "./generation/index.js";
 export * from "./presets/index.js";
 export * from "./ast/index.js";
 export * from "./planning/index.js";
+export * from "./dns/index.js";

package/dist/src/index.js

@@ -17,3 +17,5 @@ export * from "./presets/index.js";
 export * from "./ast/index.js";
 // Resource planning
 export * from "./planning/index.js";
+// DNS
+export * from "./dns/index.js";

package/dist/src/planning/resourcePlanning.js

@@ -17,7 +17,6 @@ export function planApplicationResources(appName, appType, includeDatabase = tru
         database: [],
         s3: [],
         compute: [],
-        importedResources: [],
     };
     if (appType === "custom") {
         return basePlan;
@@ -136,7 +135,6 @@ export function planOpenNextResources(appName, pattern, options) {
         s3: [],
         compute: [],
         tags: tags ?? {},
-        importedResources: [],
     });
 }
 function mergeDatabaseConfig(database, tierPreset) {

package/dist/src/presets/tierTypes.d.ts

@@ -5,6 +5,7 @@
  * consumers. Extracted from tierPresets.ts for maintainability.
  */
 import type { EcsCapacityProvider, BackupVaultTier } from "../schemas/constants.js";
+import type { WarmPool } from "../schemas/computeSchemas.js";
 /**
  * Proxy configuration for tier presets
  * Presence = enabled. Use `false` to explicitly disable.
@@ -105,7 +106,7 @@ export interface DatabaseTierPreset {
  * Only applies when capacityProvider is "EC2".
  */
 export interface TierEc2CapacityConfig {
-    /** EC2 instance type. Default: "t3.micro" */
+    /** EC2 instance type. Default: "t4g.micro" */
     instanceType?: string;
     /** AMI hardware type. Default: "ARM" for cost efficiency */
     amiHardwareType?: "ARM" | "STANDARD";
@@ -115,6 +116,8 @@ export interface TierEc2CapacityConfig {
     maxCapacity?: number;
     /** Memory limit for container in MiB. Default: 400 */
     memoryLimitMiB?: number;
+    /** Warm pool configuration for faster instance start times. */
+    warmPool?: WarmPool;
 }
 /**
  * Cluster configuration for ECS tier presets.