sst 2.24.12 → 2.24.14

package/constructs/ApiGatewayV1Api.d.ts

@@ -145,7 +145,7 @@ export interface ApiGatewayV1ApiProps<Authorizers extends Record<string, ApiGate
          * });
          * ```
          */
-        authorizer?: "none" | "iam" | (string extends AuthorizerKeys ? never : AuthorizerKeys);
+        authorizer?: "none" | "iam" | (string extends AuthorizerKeys ? Omit<AuthorizerKeys, "none" | "iam"> : AuthorizerKeys);
         /**
          * An array of scopes to include in the authorization when using `user_pool` or `jwt` authorizers. These will be merged with the scopes from the attached authorizer.
          * @default []
@@ -220,7 +220,7 @@ export type ApiGatewayV1ApiRouteProps<AuthorizerKeys> = FunctionInlineDefinition
  */
 export interface ApiGatewayV1ApiFunctionRouteProps<AuthorizerKeys = never> {
     function?: FunctionDefinition;
-    authorizer?: "none" | "iam" | (string extends AuthorizerKeys ? never : AuthorizerKeys);
+    authorizer?: "none" | "iam" | (string extends AuthorizerKeys ? Omit<AuthorizerKeys, "none" | "iam"> : AuthorizerKeys);
     authorizationScopes?: string[];
     cdk?: {
         method?: Omit<apig.MethodOptions, "authorizer" | "authorizationType" | "authorizationScopes">;

package/constructs/ApiGatewayV1Api.js

@@ -735,7 +735,8 @@ export class ApiGatewayV1Api extends Construct {
                 ...routeProps.cdk?.method,
             };
         }
-        if (!this.props.authorizers || !this.props.authorizers[authorizerKey]) {
+        if (!this.props.authorizers ||
+            !this.props.authorizers[authorizerKey]) {
             throw new Error(`Cannot find authorizer "${authorizerKey.toString()}"`);
         }
         const authorizer = this.authorizersData[authorizerKey];

package/constructs/App.js

@@ -2,19 +2,20 @@ import path from "path";
 import fs from "fs";
 import { Stack } from "./Stack.js";
 import { isSSTConstruct, isStackConstruct, } from "./Construct.js";
+import { useFunctions } from "./Function.js";
 import { bindParameters, bindType } from "./util/functionBinding.js";
 import { stack } from "./FunctionalStack.js";
-import { createRequire } from "module";
 import { Auth } from "./Auth.js";
 import { useDeferredTasks } from "./deferred_task.js";
 import { AppContext } from "./context.js";
 import { useProject } from "../project.js";
 import { Logger } from "../logger.js";
-import { App as CDKApp, Tags, CfnResource, RemovalPolicy, Aspects, } from "aws-cdk-lib/core";
+import { App as CDKApp, Tags, CfnResource, RemovalPolicy, CustomResource, Aspects, } from "aws-cdk-lib/core";
 import { CfnFunction } from "aws-cdk-lib/aws-lambda";
 import { Bucket } from "aws-cdk-lib/aws-s3";
+import { Effect, Policy, PolicyStatement } from "aws-cdk-lib/aws-iam";
 import { CfnLogGroup } from "aws-cdk-lib/aws-logs";
-const require = createRequire(import.meta.url);
+import { useBootstrap } from "../bootstrap.js";
 function exitWithMessage(message) {
     console.error(message);
     process.exit(1);
@@ -177,6 +178,7 @@ export class App extends CDKApp {
         if (this.isFinished)
             return;
         this.isFinished = true;
+        const { config, paths } = useProject();
         Auth.injectConfig();
         this.buildConstructsMetadata();
         this.ensureUniqueConstructIds();
@@ -189,12 +191,43 @@ export class App extends CDKApp {
         await useDeferredTasks().run();
         this.createBindingSsmParameters();
         this.removeGovCloudUnsupportedResourceProperties();
-        const { config } = useProject();
+        const bootstrap = await useBootstrap();
         for (const child of this.node.children) {
             if (isStackConstruct(child)) {
                 // Tag stacks
                 Tags.of(child).add("sst:app", this.name);
                 Tags.of(child).add("sst:stage", this.stage);
+                if (child instanceof Stack) {
+                    const functions = useFunctions();
+                    const sourcemaps = functions.sourcemaps.forStack(child.stackName);
+                    if (sourcemaps.length) {
+                        const policy = new Policy(child, "FunctionSourcemapUploaderPolicy", {
+                            statements: [
+                                new PolicyStatement({
+                                    effect: Effect.ALLOW,
+                                    actions: ["s3:GetObject", "s3:PutObject"],
+                                    resources: [
+                                        sourcemaps[0].bucket.bucketArn + "/*",
+                                        `arn:${child.partition}:s3:::${bootstrap.bucket}/*`,
+                                    ],
+                                }),
+                            ],
+                        });
+                        child.customResourceHandler.role?.attachInlinePolicy(policy);
+                        const resource = new CustomResource(child, "FunctionSourcemapUploader", {
+                            serviceToken: child.customResourceHandler.functionArn,
+                            resourceType: "Custom::FunctionSourcemapUploader",
+                            properties: {
+                                app: this.name,
+                                stage: this.stage,
+                                bootstrap: bootstrap.bucket,
+                                bucket: sourcemaps[0].bucket.bucketName,
+                                functions: sourcemaps.map((s) => [s.arn, s.key]),
+                            },
+                        });
+                        resource.node.addDependency(policy);
+                    }
+                }
                 // Set removal policy
                 this.applyRemovalPolicy(child);
                 // Stack names need to be parameterized with the stage name

package/constructs/Function.d.ts

@@ -10,6 +10,7 @@ import * as functionUrlCors from "./util/functionUrlCors.js";
 import { Architecture, Function as CDKFunction, FunctionOptions, ILayerVersion, Runtime as CDKRuntime, Tracing } from "aws-cdk-lib/aws-lambda";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
 import { Size as CDKSize, Duration as CDKDuration } from "aws-cdk-lib/core";
+import { IBucket } from "aws-cdk-lib/aws-s3";
 declare const supportedRuntimes: {
     container: CDKRuntime;
     rust: CDKRuntime;
@@ -657,6 +658,18 @@ export declare class Function extends CDKFunction implements SSTConstruct {
     static mergeProps(baseProps?: FunctionProps, props?: FunctionProps): FunctionProps;
 }
 export declare const useFunctions: () => {
+    sourcemaps: {
+        add(stack: string, source: {
+            arn: string;
+            bucket: IBucket;
+            key: string;
+        }): void;
+        forStack(stack: string): {
+            arn: string;
+            bucket: IBucket;
+            key: string;
+        }[];
+    };
     fromID(id: string): FunctionProps | undefined;
     add(name: string, props: FunctionProps): void;
     readonly all: Record<string, FunctionProps>;

package/constructs/Function.js

@@ -1,6 +1,8 @@
 /* eslint-disable @typescript-eslint/ban-types */
 // Note: disabling ban-type rule so we don't get an error referencing the class Function
 import path from "path";
+import fs from "fs/promises";
+import zlib from "zlib";
 import { Stack } from "./Stack.js";
 import { Job } from "./Job.js";
 import { Secret } from "./Config.js";
@@ -24,8 +26,7 @@ import { StringParameter } from "aws-cdk-lib/aws-ssm";
 import { Platform } from "aws-cdk-lib/aws-ecr-assets";
 import { useBootstrap } from "../bootstrap.js";
 import { Colors } from "../cli/colors.js";
-import { BucketDeployment, Source } from "aws-cdk-lib/aws-s3-deployment";
-import { Bucket } from "aws-cdk-lib/aws-s3";
+import { Asset } from "aws-cdk-lib/aws-s3-assets";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 const supportedRuntimes = {
     container: CDKRuntime.FROM_IMAGE,
@@ -231,6 +232,7 @@ export class Function extends CDKFunction {
             useDeferredTasks().add(async () => {
                 if (props.runtime === "container")
                     Colors.line(`➜  Building the container image for the "${this.node.id}" function...`);
+                const project = useProject();
                 // Build function
                 const result = await useRuntimeHandlers().build(this.node.addr, "deploy");
                 if (result.type === "error") {
@@ -242,19 +244,23 @@ export class Function extends CDKFunction {
                 // No need to update code if runtime is container
                 if (props.runtime === "container")
                     return;
+                if (result.sourcemap) {
+                    const data = await fs.readFile(result.sourcemap);
+                    await fs.writeFile(result.sourcemap, zlib.gzipSync(data));
+                    const asset = new Asset(stack, this.id + "-Sourcemap", {
+                        path: result.sourcemap,
+                    });
+                    await fs.rm(result.sourcemap);
+                    useFunctions().sourcemaps.add(stack.stackName, {
+                        bucket: asset.bucket,
+                        key: asset.s3ObjectKey,
+                        arn: this.functionArn,
+                    });
+                }
                 // Update code
                 const cfnFunction = this.node.defaultChild;
                 const code = AssetCode.fromAsset(result.out);
                 const codeConfig = code.bind(this);
-                const bootstrap = await useBootstrap();
-                if (result.sourcemap)
-                    new BucketDeployment(this, "Sourcemap", {
-                        sources: [Source.asset(result.sourcemap)],
-                        contentEncoding: "gzip",
-                        contentType: "application/json",
-                        destinationBucket: Bucket.fromBucketName(this, "BootstrapBucket", bootstrap.bucket),
-                        destinationKeyPrefix: `sourcemap/${app.name}/${app.stage}/${this.functionArn}/`,
-                    });
                 cfnFunction.code = {
                     s3Bucket: codeConfig.s3Location?.bucketName,
                     s3Key: codeConfig.s3Location?.objectKey,
@@ -548,7 +554,19 @@ export class Function extends CDKFunction {
 }
 export const useFunctions = createAppContext(() => {
     const functions = {};
+    const sourcemaps = {};
     return {
+        sourcemaps: {
+            add(stack, source) {
+                let arr = sourcemaps[stack];
+                if (!arr)
+                    sourcemaps[stack] = arr = [];
+                arr.push(source);
+            },
+            forStack(stack) {
+                return sourcemaps[stack] || [];
+            },
+        },
         fromID(id) {
             const result = functions[id];
             if (!result)

package/node/future/auth/adapter/microsoft.d.ts

@@ -2,6 +2,7 @@ import { OidcBasicConfig } from "./oidc.js";
 type MicrosoftConfig = OidcBasicConfig & {
     mode: "oidc";
     prompt?: "login" | "none" | "consent" | "select_account";
+    tenantID?: string;
 };
 export declare function MicrosoftAdapter(config: MicrosoftConfig): () => Promise<{
     type: "success";

package/node/future/auth/adapter/microsoft.js

@@ -1,13 +1,15 @@
 import { Issuer } from "openid-client";
 import { OidcAdapter } from "./oidc.js";
-// These are the different Microsoft auth urls for different types of accounts:
-// Common: https://login.microsoftonline.com/common/v2.0 (both business and private)
-// Business: https://login.microsoftonline.com/{tenant}/v2.0
-// Private: https://login.microsoftonline.com/consumers/v2.0
-const issuer = await Issuer.discover("https://login.microsoftonline.com/common/v2.0");
 export function MicrosoftAdapter(config) {
+    const authority = config?.tenantID ?? "common";
+    const issuer = `https://login.microsoftonline.com/${authority}`;
     return OidcAdapter({
-        issuer,
+        issuer: new Issuer({
+            issuer: `${issuer}/v2.0`,
+            authorization_endpoint: `${issuer}/oauth2/v2.0/authorize`,
+            token_endpoint: `${issuer}/oauth2/v2.0/token`,
+            jwks_uri: `${issuer}/discovery/v2.0/keys`,
+        }),
         scope: "openid email profile",
         ...config,
     });

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.24.12",
+  "version": "2.24.14",
   "bin": {
     "sst": "cli/sst.js"
   },

package/runtime/handlers/node.js

@@ -158,7 +158,14 @@ export const useNodeHandler = Context.memo(async () => {
                                 : undefined,
                         }),
                     outfile: target,
-                    sourcemap: input.mode === "start" ? "linked" : true,
+                    // always generate sourcemaps in local
+                    // never generate sourcemaps if explicitly false
+                    // otherwise generate sourcemaps
+                    sourcemap: input.mode === "start"
+                        ? "linked"
+                        : nodejs.sourcemap === false
+                            ? false
+                            : true,
                     minify: nodejs.minify,
                     ...override,
                 };

package/runtime/handlers.js

@@ -1,11 +1,9 @@
 import { Context } from "../context/context.js";
 import { Logger } from "../logger.js";
 import path from "path";
-import zlib from "zlib";
 import fs from "fs/promises";
 import { useWatcher } from "../watcher.js";
 import { useBus } from "../bus.js";
-import crypto from "crypto";
 import { useProject } from "../project.js";
 import { useFunctions } from "../constructs/Function.js";
 export const useRuntimeHandlers = Context.memo(() => {
@@ -77,22 +75,11 @@ export const useRuntimeHandlers = Context.memo(() => {
                 }
                 if (func.hooks?.afterBuild)
                     await func.hooks.afterBuild(func, out);
-                let sourcemap;
-                if (built.sourcemap && mode === "deploy") {
-                    const data = await fs.readFile(built.sourcemap);
-                    await fs.rm(built.sourcemap);
-                    const hash = crypto.createHash("md5").update(data).digest("hex");
-                    const dir = path.join(project.paths.artifacts, "sourcemaps", functionID);
-                    await fs.rm(dir, { recursive: true, force: true });
-                    await fs.mkdir(dir, { recursive: true });
-                    sourcemap = dir;
-                    await fs.writeFile(path.join(dir, `${hash}.map`), zlib.gzipSync(data));
-                }
                 bus.publish("function.build.success", { functionID });
                 return {
                     ...built,
                     out,
-                    sourcemap,
+                    sourcemap: built.sourcemap,
                 };
             }
             if (pendingBuilds.has(functionID)) {
@@ -132,8 +119,8 @@ export const useFunctionBuilder = Context.memo(() => {
     watcher.subscribe("file.changed", async (evt) => {
         try {
             const functions = useFunctions();
-            for (const [functionID, props] of Object.entries(functions.all)) {
-                const handler = handlers.for(props.runtime);
+            for (const [functionID, info] of Object.entries(functions.all)) {
+                const handler = handlers.for(info.runtime);
                 if (!handler?.shouldBuild({
                     functionID,
                     file: evt.properties.file,