@stacksjs/ts-cloud 0.5.8 → 0.5.10

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

@@ -99,6 +99,35 @@ export declare function getCommandRecord(config: CloudConfig, environment: Envir
  * whitespace argument parsing.
  */
 export declare function runDbQuery(config: CloudConfig, environment: EnvironmentType, sql: string): Promise<string>;
+export interface ServerlessFunctionInfo {
+    mode: 'http' | 'queue' | 'cli';
+    name: string;
+    /** `live` alias version when provisioned concurrency is on, else '$LATEST'. */
+    version: string;
+    provisioned?: {
+        status: string;
+        allocated: number;
+        requested: number;
+    };
+}
+export interface ServerlessInfo {
+    slug: string;
+    environment: string;
+    region: string;
+    stackStatus: string;
+    endpoint?: string;
+    assetUrl?: string;
+    scheduler: 'on' | 'off' | 'sub-minute';
+    queues: string[];
+    provisionedConcurrency: number;
+    functions: ServerlessFunctionInfo[];
+    lastRelease?: {
+        sha: string;
+        timestamp: string;
+    };
+}
+/** Gather an operational summary of a deployed serverless app. */
+export declare function serverlessInfo(config: CloudConfig, environment: EnvironmentType): Promise<ServerlessInfo>;
 /** Rescale the serverless Aurora cluster's min/max ACU capacity. */
 export declare function scaleServerlessDatabase(config: CloudConfig, environment: EnvironmentType, minCapacity: number, maxCapacity: number): Promise<void>;
 /**

package/dist/index.js

@@ -26026,6 +26026,28 @@ function composeServerlessAppTemplate(opts) {
   addFunction("CliFunction", functionNames.cli, handlers.cli, "cli", app.cliMemory ?? 1024, app.cliTimeout ?? 900, undefined, app.cliTmpStorage ?? tmpStorage);
   if (hasQueue)
     addFunction("QueueFunction", functionNames.queue, handlers.queue, "queue", app.queueMemory ?? 1024, app.queueTimeout ?? 120, undefined, app.queueTmpStorage ?? tmpStorage);
+  const pc = (app.provisionedConcurrency ?? 0) > 0 ? app.provisionedConcurrency : 0;
+  const fnLogicalIds = ["HttpFunction", "CliFunction", ...hasQueue ? ["QueueFunction"] : []];
+  if (pc) {
+    for (const L of fnLogicalIds) {
+      resources[`${L}Version`] = {
+        Type: "AWS::Lambda::Version",
+        DeletionPolicy: "Retain",
+        Properties: { FunctionName: Fn2.ref(L) }
+      };
+      resources[`${L}Alias`] = {
+        Type: "AWS::Lambda::Alias",
+        Properties: {
+          FunctionName: Fn2.ref(L),
+          Name: "live",
+          FunctionVersion: Fn2.getAtt(`${L}Version`, "Version"),
+          ProvisionedConcurrencyConfig: { ProvisionedConcurrentExecutions: pc }
+        }
+      };
+    }
+  }
+  const invokeArn = (L) => pc ? Fn2.ref(`${L}Alias`) : Fn2.getAtt(L, "Arn");
+  const invokeName = (L) => pc ? Fn2.ref(`${L}Alias`) : Fn2.ref(L);
   resources.HttpApi = {
     Type: "AWS::ApiGatewayV2::Api",
     Properties: {
@@ -26038,7 +26060,7 @@ function composeServerlessAppTemplate(opts) {
     Properties: {
       ApiId: Fn2.ref("HttpApi"),
       IntegrationType: "AWS_PROXY",
-      IntegrationUri: Fn2.getAtt("HttpFunction", "Arn"),
+      IntegrationUri: invokeArn("HttpFunction"),
       PayloadFormatVersion: "2.0"
     }
   };
@@ -26061,7 +26083,7 @@ function composeServerlessAppTemplate(opts) {
   resources.HttpPermission = {
     Type: "AWS::Lambda::Permission",
     Properties: {
-      FunctionName: Fn2.ref("HttpFunction"),
+      FunctionName: invokeName("HttpFunction"),
       Action: "lambda:InvokeFunction",
       Principal: "apigateway.amazonaws.com",
       SourceArn: Fn2.sub("arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:${HttpApi}/*/*")
@@ -26152,7 +26174,7 @@ function composeServerlessAppTemplate(opts) {
         Type: "AWS::Lambda::EventSourceMapping",
         Properties: {
           EventSourceArn: Fn2.getAtt(qId, "Arn"),
-          FunctionName: Fn2.ref("QueueFunction"),
+          FunctionName: invokeName("QueueFunction"),
           BatchSize: 1,
           FunctionResponseTypes: ["ReportBatchItemFailures"],
           ...concurrency ? { ScalingConfig: { MaximumConcurrency: Math.max(2, concurrency) } } : {}
@@ -26170,7 +26192,7 @@ function composeServerlessAppTemplate(opts) {
         State: "ENABLED",
         Targets: [{
           Id: "cli",
-          Arn: Fn2.getAtt("CliFunction", "Arn"),
+          Arn: invokeArn("CliFunction"),
           Input: JSON.stringify({ command: "schedule:run" })
         }]
       }
@@ -26178,7 +26200,7 @@ function composeServerlessAppTemplate(opts) {
     resources.SchedulerPermission = {
       Type: "AWS::Lambda::Permission",
       Properties: {
-        FunctionName: Fn2.ref("CliFunction"),
+        FunctionName: invokeName("CliFunction"),
         Action: "lambda:InvokeFunction",
         Principal: "events.amazonaws.com",
         SourceArn: Fn2.getAtt("SchedulerRule", "Arn")
@@ -74242,6 +74264,35 @@ class LambdaClient {
       body: JSON.stringify(rest)
     });
   }
+  async getAlias(functionName, name) {
+    try {
+      return await this.client.request({
+        service: "lambda",
+        region: this.region,
+        method: "GET",
+        path: `/2015-03-31/functions/${encodeURIComponent(functionName)}/aliases/${encodeURIComponent(name)}`
+      });
+    } catch (err) {
+      if (/ResourceNotFound/i.test(String(err?.message)))
+        return null;
+      throw err;
+    }
+  }
+  async getProvisionedConcurrencyConfig(functionName, qualifier) {
+    try {
+      return await this.client.request({
+        service: "lambda",
+        region: this.region,
+        method: "GET",
+        path: `/2019-09-30/functions/${encodeURIComponent(functionName)}/provisioned-concurrency`,
+        queryParams: { Qualifier: qualifier }
+      });
+    } catch (err) {
+      if (/ProvisionedConcurrencyConfigNotFound|ResourceNotFound/i.test(String(err?.message)))
+        return null;
+      throw err;
+    }
+  }
   async putProvisionedConcurrencyConfig(params) {
     const { FunctionName, Qualifier, ProvisionedConcurrentExecutions } = params;
     return this.client.request({
@@ -83439,6 +83490,14 @@ async function applyFunction(lambda2, name, env2, code) {
   await withConflictRetry(() => lambda2.updateFunctionCode(codeParams));
   await lambda2.waitForFunctionActive(name, 120);
 }
+async function publishAndFlip(lambda2, name) {
+  const published = await withConflictRetry(() => lambda2.publishVersion({ FunctionName: name }));
+  const version2 = published.Version;
+  if (!version2)
+    throw new Error(`publishVersion returned no version for ${name}`);
+  await withConflictRetry(() => lambda2.updateAlias({ FunctionName: name, Name: "live", FunctionVersion: version2 }));
+  return version2;
+}
 async function deployServerlessApp(config6, environment, opts = {}) {
   const ctx = resolveContext(config6, environment);
   const { app, slug, region, stackName, artifactBucket } = ctx;
@@ -83582,12 +83641,22 @@ async function deployServerlessApp(config6, environment, opts = {}) {
     functionEnv.queue = buildFunctionEnv(app, ctx, environment, "queue", secrets, assetUrl, primaryQueue, infraEnv);
     await applyFunction(lambda2, composed.functionNames.queue, functionEnv.queue, codeSource);
   }
+  const usesProvisionedConcurrency = (app.provisionedConcurrency ?? 0) > 0;
+  const functionVersions = {};
+  if (usesProvisionedConcurrency) {
+    step("Publishing versions + flipping live alias");
+    functionVersions.http = await publishAndFlip(lambda2, composed.functionNames.http);
+    functionVersions.cli = await publishAndFlip(lambda2, composed.functionNames.cli);
+    if (composed.queueNames.length)
+      functionVersions.queue = await publishAndFlip(lambda2, composed.functionNames.queue);
+  }
   await writeRelease(s32, artifactBucket, slug, environment, {
     sha: artifactSha,
     code: codeSource,
     previousSha: prior?.sha,
     previousCode: prior?.code,
     previousFunctionEnv: prior?.functionEnv,
+    ...usesProvisionedConcurrency ? { functionVersions, previousFunctionVersions: prior?.functionVersions } : {},
     functionEnv,
     functionNames: {
       http: composed.functionNames.http,
@@ -83646,6 +83715,9 @@ async function redeployServerlessApp(config6, environment) {
       continue;
     step(`Re-activating ${mode} (${name})`);
     await applyFunction(lambda2, name, release.functionEnv[mode] ?? {}, release.code);
+    const version2 = release.functionVersions?.[mode];
+    if (version2)
+      await withConflictRetry(() => lambda2.updateAlias({ FunctionName: name, Name: "live", FunctionVersion: version2 }));
   }
   success("Redeploy complete");
 }
@@ -83663,15 +83735,20 @@ async function rollbackServerlessApp(config6, environment) {
     step(`Restoring ${mode} (${name})`);
     const env2 = release.previousFunctionEnv?.[mode] ?? release.functionEnv[mode] ?? {};
     await applyFunction(lambda2, name, env2, release.previousCode);
+    const prevVersion = release.previousFunctionVersions?.[mode];
+    if (prevVersion)
+      await withConflictRetry(() => lambda2.updateAlias({ FunctionName: name, Name: "live", FunctionVersion: prevVersion }));
   }
   await writeRelease(s32, ctx.artifactBucket, ctx.slug, environment, {
     ...release,
     sha: release.previousSha ?? release.sha,
     code: release.previousCode,
     functionEnv: release.previousFunctionEnv ?? release.functionEnv,
+    functionVersions: release.previousFunctionVersions ?? release.functionVersions,
     previousSha: undefined,
     previousCode: undefined,
     previousFunctionEnv: undefined,
+    previousFunctionVersions: undefined,
     timestamp: new Date().toISOString()
   });
   success("Rollback complete");
@@ -83688,6 +83765,10 @@ async function setMaintenance(config6, environment, enabled, bypassSecret) {
   if (!enabled)
     delete env2.MAINTENANCE_BYPASS_SECRET;
   await withConflictRetry(() => lambda2.updateFunctionConfiguration({ FunctionName: httpName, Environment: { Variables: env2 } }));
+  if ((ctx.app.provisionedConcurrency ?? 0) > 0) {
+    await lambda2.waitForFunctionActive(httpName, 120);
+    await publishAndFlip(lambda2, httpName);
+  }
   success(enabled ? "Application is now in maintenance mode (503)" : "Application is live");
 }
 async function runRemoteCommand(config6, environment, command) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/ts-cloud",
   "type": "module",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "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.8",
-    "@ts-cloud/core": "0.5.8",
+    "@ts-cloud/aws-types": "0.5.10",
+    "@ts-cloud/core": "0.5.10",
     "@stacksjs/ts-xml": "^0.1.0"
   },
   "devDependencies": {