@stacksjs/ts-cloud 0.5.4 → 0.5.6

package/dist/deploy/serverless-app.d.ts

@@ -45,6 +45,12 @@ export type CodeSource = {
     kind: 'image';
     imageUri: string;
 };
+/**
+ * AWS caps the aggregate size of a function's environment variables at 4 KB.
+ * Check before the API call so we fail with an actionable message (which vars,
+ * how far over) instead of a cryptic `InvalidParameterValueException` mid-deploy.
+ */
+export declare function assertEnvWithinLimit(name: string, env: Record<string, string>): void;
 export declare function deployServerlessApp(config: CloudConfig, environment: EnvironmentType, opts?: DeployServerlessOptions): Promise<void>;
 export declare function redeployServerlessApp(config: CloudConfig, environment: EnvironmentType): Promise<void>;
 export declare function rollbackServerlessApp(config: CloudConfig, environment: EnvironmentType): Promise<void>;

package/dist/index.js

@@ -25845,16 +25845,21 @@ function resolveServerlessRuntime(app) {
     layerEnvVar: "TSCLOUD_NODE_LAYER_ARN"
   };
 }
-function resolveQueueNames(app, slug, env) {
+function resolveQueues(app, slug, env) {
   if (app.queues === false)
     return [];
   if (app.queues === undefined || app.queues === true)
-    return [`${slug}-${env}-default`];
+    return [{ name: `${slug}-${env}-default` }];
   return app.queues.map((q) => {
-    const name = typeof q === "string" ? q : Object.keys(q)[0];
-    return `${slug}-${env}-${name}`;
+    if (typeof q === "string")
+      return { name: `${slug}-${env}-${q}` };
+    const [name, concurrency] = Object.entries(q)[0];
+    return { name: `${slug}-${env}-${name}`, concurrency };
   });
 }
+function resolveQueueNames(app, slug, env) {
+  return resolveQueues(app, slug, env).map((q) => q.name);
+}
 function composeServerlessAppTemplate(opts) {
   const { app, environment, handlers } = opts;
   const slug = opts.config.project.slug;
@@ -25866,8 +25871,12 @@ function composeServerlessAppTemplate(opts) {
     queue: `${slug}-${environment}-queue`,
     cli: `${slug}-${environment}-cli`
   };
-  const queueNames = resolveQueueNames(app, slug, environment);
+  if (app.gatewayVersion === 1)
+    throw new Error("serverless app: `gatewayVersion: 1` (REST API) is not supported — ts-cloud uses API Gateway HTTP API (v2). Remove `gatewayVersion` or set it to 2.");
+  const queues = resolveQueues(app, slug, environment);
+  const queueNames = queues.map((q) => q.name);
   const hasQueue = queueNames.length > 0;
+  const logRetention = app.logRetention ?? 14;
   const imageMode = app.packaging === "image";
   const schedulerEnabled = (app.scheduler ?? "on") !== "off";
   const cacheEnabled = (app.cache?.driver ?? "dynamodb") === "dynamodb";
@@ -25983,7 +25992,7 @@ function composeServerlessAppTemplate(opts) {
   function addFunction(logicalId, name, handler8, mode, memory, timeout, reservedConcurrency, tmp = tmpStorage) {
     resources[`${logicalId}LogGroup`] = {
       Type: "AWS::Logs::LogGroup",
-      Properties: { LogGroupName: `/aws/lambda/${name}`, RetentionInDays: 14 }
+      Properties: { LogGroupName: `/aws/lambda/${name}`, RetentionInDays: logRetention }
     };
     const codeProps = imageMode ? {
       PackageType: "Image",
@@ -26124,19 +26133,21 @@ function composeServerlessAppTemplate(opts) {
         MessageRetentionPeriod: 1209600
       }
     };
-    queueNames.forEach((qName, i) => {
+    queues.forEach((q, i) => {
       const qId = `AppQueue${i}`;
+      const fnTimeout = app.queueTimeout ?? 120;
       resources[qId] = {
         Type: "AWS::SQS::Queue",
         Properties: {
-          QueueName: qName,
-          VisibilityTimeout: Math.max(app.queueTimeout ?? 120, app.queueTimeout ?? 120),
+          QueueName: q.name,
+          VisibilityTimeout: Math.min(43200, fnTimeout * 6),
           RedrivePolicy: {
             deadLetterTargetArn: Fn2.getAtt("AppQueueDlq", "Arn"),
             maxReceiveCount: app.queueTries ?? 3
           }
         }
       };
+      const concurrency = q.concurrency ?? app.queueConcurrency;
       resources[`${qId}Mapping`] = {
         Type: "AWS::Lambda::EventSourceMapping",
         Properties: {
@@ -26144,10 +26155,10 @@ function composeServerlessAppTemplate(opts) {
           FunctionName: Fn2.ref("QueueFunction"),
           BatchSize: 1,
           FunctionResponseTypes: ["ReportBatchItemFailures"],
-          ...app.queueConcurrency ? { ScalingConfig: { MaximumConcurrency: Math.max(2, app.queueConcurrency) } } : {}
+          ...concurrency ? { ScalingConfig: { MaximumConcurrency: Math.max(2, concurrency) } } : {}
         }
       };
-      outputs[`QueueUrl${i}`] = { Description: `Queue URL: ${qName}`, Value: Fn2.ref(qId) };
+      outputs[`QueueUrl${i}`] = { Description: `Queue URL: ${q.name}`, Value: Fn2.ref(qId) };
     });
   }
   if (schedulerEnabled) {
@@ -26262,7 +26273,7 @@ function composeServerlessAppTemplate(opts) {
           ...app.assetDomain ? {
             Aliases: [app.assetDomain],
             ViewerCertificate: {
-              AcmCertificateArn: app.assetCertificateArn,
+              AcmCertificateArn: app.assetCertificateArn ?? Fn2.ref("AssetsCertificate"),
               SslSupportMethod: "sni-only",
               MinimumProtocolVersion: "TLSv1.2_2021"
             }
@@ -26271,8 +26282,20 @@ function composeServerlessAppTemplate(opts) {
       }
     };
     if (app.assetDomain) {
-      if (!app.assetCertificateArn)
-        throw new Error("serverless app: `assetDomain` requires `assetCertificateArn` (a us-east-1 ACM cert — CloudFront only accepts certs from us-east-1).");
+      if (!app.assetCertificateArn) {
+        if (!app.hostedZoneId)
+          throw new Error("serverless app: `assetDomain` requires either `assetCertificateArn` (a us-east-1 ACM cert) or `hostedZoneId` (to auto-issue + validate one). CloudFront only accepts certs from us-east-1.");
+        if (region !== "us-east-1")
+          throw new Error(`serverless app: auto-issuing an asset-domain cert needs a us-east-1 app (CloudFront certs must be us-east-1); this app is in ${region}. Supply a pre-issued us-east-1 \`assetCertificateArn\` instead.`);
+        resources.AssetsCertificate = {
+          Type: "AWS::CertificateManager::Certificate",
+          Properties: {
+            DomainName: app.assetDomain,
+            ValidationMethod: "DNS",
+            DomainValidationOptions: [{ DomainName: app.assetDomain, HostedZoneId: app.hostedZoneId }]
+          }
+        };
+      }
       if (app.hostedZoneId) {
         resources.AssetsDomainRecord = {
           Type: "AWS::Route53::RecordSet",
@@ -83282,7 +83305,15 @@ async function uploadAssets(s32, bucket, dir, prefix, includeDotfiles = false) {
   }
   return count;
 }
+function assertEnvWithinLimit(name, env2) {
+  const bytes = Object.entries(env2).reduce((n, [k, v]) => n + Buffer.byteLength(`${k}=${v}`, "utf8"), 0);
+  if (bytes > 4096) {
+    const biggest = Object.entries(env2).map(([k, v]) => [k, Buffer.byteLength(`${k}=${v}`, "utf8")]).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([k, n]) => `${k} (${n}B)`).join(", ");
+    throw new Error(`${name}: environment variables total ${bytes}B, over AWS's 4096B limit (${bytes - 4096}B too large). ` + `Largest: ${biggest}. Move large/secret values out of env — store them in Secrets Manager and fetch at cold start.`);
+  }
+}
 async function applyFunction(lambda2, name, env2, code) {
+  assertEnvWithinLimit(name, env2);
   await withConflictRetry(() => lambda2.updateFunctionConfiguration({ FunctionName: name, Environment: { Variables: env2 } }));
   await lambda2.waitForFunctionActive(name, 120);
   const codeParams = code.kind === "image" ? { FunctionName: name, ImageUri: code.imageUri } : { FunctionName: name, S3Bucket: code.bucket, S3Key: code.key };
@@ -83437,6 +83468,7 @@ async function deployServerlessApp(config6, environment, opts = {}) {
     code: codeSource,
     previousSha: prior?.sha,
     previousCode: prior?.code,
+    previousFunctionEnv: prior?.functionEnv,
     functionEnv,
     functionNames: {
       http: composed.functionNames.http,
@@ -83508,14 +83540,17 @@ async function rollbackServerlessApp(config6, environment) {
     if (!name)
       continue;
     step(`Restoring ${mode} (${name})`);
-    await applyFunction(lambda2, name, release.functionEnv[mode] ?? {}, release.previousCode);
+    const env2 = release.previousFunctionEnv?.[mode] ?? release.functionEnv[mode] ?? {};
+    await applyFunction(lambda2, name, env2, release.previousCode);
   }
   await writeRelease(s32, ctx.artifactBucket, ctx.slug, environment, {
     ...release,
     sha: release.previousSha ?? release.sha,
     code: release.previousCode,
+    functionEnv: release.previousFunctionEnv ?? release.functionEnv,
     previousSha: undefined,
     previousCode: undefined,
+    previousFunctionEnv: undefined,
     timestamp: new Date().toISOString()
   });
   success("Rollback complete");
@@ -86720,6 +86755,7 @@ export {
   resolveServerlessArtifactBucketName,
   resolveServerlessAppStackName,
   resolveRegion,
+  resolveQueues,
   resolveQueueNames,
   resolveProjectStackName,
   resolveObjectStorage,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/ts-cloud",
   "type": "module",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "A lightweight, performant infrastructure-as-code library and CLI for deploying both server-based (EC2) and serverless applications.",
   "author": "Chris Breuer <chris@stacksjs.com>",
   "license": "MIT",
@@ -89,8 +89,8 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ts-cloud/aws-types": "0.5.4",
-    "@ts-cloud/core": "0.5.4",
+    "@ts-cloud/aws-types": "0.5.6",
+    "@ts-cloud/core": "0.5.6",
     "@stacksjs/ts-xml": "^0.1.0"
   },
   "devDependencies": {