sst 1.16.0 → 2.0.0-rc.1

package/cli/telemetry/telemetry.js

@@ -0,0 +1,90 @@
+import Conf from "conf";
+import { createHash, randomBytes } from "crypto";
+import { postPayload } from "./post-payload.js";
+import { getRawProjectId } from "./project-id.js";
+import { getEnvironmentData } from "./environment.js";
+import { cyan } from "colorette";
+const TELEMETRY_API = "https://telemetry.sst.dev/events";
+const TELEMETRY_KEY_ENABLED = "telemetry.enabled";
+const TELEMETRY_KEY_NOTIFY_DATE = "telemetry.notifiedAt";
+const TELEMETRY_KEY_ID = `telemetry.anonymousId`;
+const conf = initializeConf();
+const sessionId = randomBytes(32).toString("hex");
+const projectId = hash(getRawProjectId());
+const anonymousId = getAnonymousId();
+notify();
+export function enable() {
+    conf && conf.set(TELEMETRY_KEY_ENABLED, true);
+}
+export function disable() {
+    conf && conf.set(TELEMETRY_KEY_ENABLED, false);
+}
+export function isEnabled() {
+    if (!conf) {
+        return false;
+    }
+    return conf.get(TELEMETRY_KEY_ENABLED, true) !== false;
+}
+export function trackCli(command) {
+    record("CLI_COMMAND", {
+        command,
+    });
+}
+function initializeConf() {
+    try {
+        // @ts-expect-error
+        return new Conf({ projectName: "sst" });
+    }
+    catch (_) {
+        return null;
+    }
+}
+function notify() {
+    if (!conf || willNotRecord()) {
+        return;
+    }
+    // Do not notify if user has been notified before.
+    if (conf.get(TELEMETRY_KEY_NOTIFY_DATE) !== undefined) {
+        return;
+    }
+    conf.set(TELEMETRY_KEY_NOTIFY_DATE, Date.now().toString());
+    console.log(`${cyan("Attention")}: SST now collects completely anonymous telemetry regarding usage. This is used to guide SST's roadmap.`);
+    console.log(`You can learn more, including how to opt-out of this anonymous program, by heading over to:`);
+    console.log("https://docs.sst.dev/anonymous-telemetry");
+    console.log();
+}
+function willNotRecord() {
+    return !isEnabled() || !!process.env.SST_TELEMETRY_DISABLED;
+}
+function record(name, properties) {
+    if (willNotRecord()) {
+        return Promise.resolve();
+    }
+    const context = {
+        anonymousId,
+        projectId,
+        sessionId,
+    };
+    return postPayload(TELEMETRY_API, {
+        context,
+        environment: getEnvironmentData(),
+        events: [
+            {
+                name,
+                properties,
+            },
+        ],
+    });
+}
+function getAnonymousId() {
+    const val = conf && conf.get(TELEMETRY_KEY_ID);
+    if (val) {
+        return val;
+    }
+    const generated = randomBytes(32).toString("hex");
+    conf && conf.set(TELEMETRY_KEY_ID, generated);
+    return generated;
+}
+function hash(payload) {
+    return createHash("sha256").update(payload).digest("hex");
+}

package/cli/ui/deploy.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" resolution-mode="require"/>
+import { Stacks } from "../../stacks/index.js";
+interface Props {
+    stacks: string[];
+}
+export declare const DeploymentUI: (props: Props) => JSX.Element;
+export declare function printDeploymentResults(results: Awaited<ReturnType<typeof Stacks.deployMany>>): void;
+export {};

package/{dist/cli → cli}/ui/deploy.js

@@ -4,6 +4,7 @@ import { useBus } from "../../bus.js";
 import { Stacks } from "../../stacks/index.js";
 import inkSpinner from "ink-spinner";
 import { useProject } from "../../app.js";
+import { blue, bold, green, red } from "colorette";
 // @ts-ignore
 const { default: Spinner } = inkSpinner;
 const FullScreen = (props) => {
@@ -98,7 +99,44 @@ export const DeploymentUI = (props) => {
                         " ",
                         resource.LogicalResourceId,
                         " ",
-                        resource.ResourceStatusReason),
+                        resource.ResourceStatusReason,
+                        " "),
                     React.createElement(Text, { color: color(resource.ResourceStatus || "") }, resource.ResourceStatus))))));
         })));
 };
+export function printDeploymentResults(results) {
+    console.log();
+    console.log(`----------------------------`);
+    console.log(`| Stack deployment results |`);
+    console.log(`----------------------------`);
+    for (const [stack, result] of Object.entries(results)) {
+        const icon = (() => {
+            if (Stacks.isSuccess(result.status))
+                return green("✔");
+            if (Stacks.isFailed(result.status))
+                return red("✖");
+        })();
+        console.log(`${icon} ${stack}`);
+        const outputs = Object.entries(result.outputs).filter(([key, _]) => {
+            if (key.startsWith("Export"))
+                return false;
+            if (key.includes("SstSiteEnv"))
+                return false;
+            return true;
+        });
+        if (outputs.length > 0) {
+            console.log(`  ${blue("Outputs:")}`);
+            for (const key of Object.keys(Object.fromEntries(outputs)).sort()) {
+                const value = result.outputs[key];
+                console.log(bold(`    ${key}: ${value}`));
+            }
+        }
+        if (Object.entries(result.errors).length > 0) {
+            console.log(`  ${red("Errors:")}`);
+            for (const [id, error] of Object.entries(result.errors)) {
+                console.log(bold(`    ${id}: ${error}`));
+            }
+        }
+    }
+    console.log();
+}

package/{dist/config.js → config.js}

@@ -3,11 +3,20 @@ import { GetFunctionConfigurationCommand, LambdaClient, UpdateFunctionConfigurat
 import { pipe, map } from "remeda";
 import { useProject } from "./app.js";
 import { useAWSClient } from "./credentials.js";
-import { useFunctions } from "./stacks/metadata.js";
+import { Stacks } from "./stacks/index.js";
 export var Config;
 (function (Config) {
     async function parameters() {
         const result = [];
+        for await (const p of scan(PREFIX.FALLBACK)) {
+            const parsed = parse(p.Name);
+            if (parsed.type === "secrets")
+                continue;
+            result.push({
+                ...parsed,
+                value: p.Value,
+            });
+        }
         for await (const p of scan(PREFIX.STAGE)) {
             const parsed = parse(p.Name);
             if (parsed.type === "secrets")
@@ -67,7 +76,7 @@ export var Config;
                 id: input.key,
                 type: "Secret",
                 prop: "value",
-                fallback: true,
+                fallback: input.fallback,
             }),
             Value: input.value,
             Type: "SecureString",
@@ -103,8 +112,11 @@ export var Config;
     Config.removeSecret = removeSecret;
     async function restart(key) {
         const lambda = useAWSClient(LambdaClient);
-        const functions = await useFunctions();
-        const filtered = Object.values(functions).filter((f) => f.data.secrets.includes(key));
+        const metadata = await Stacks.metadata();
+        const filtered = Object.values(metadata)
+            .flat()
+            .filter((f) => f.type === "Function")
+            .filter((f) => f.data.secrets.includes(key));
         await Promise.all(filtered.map(async (f) => {
             const config = await lambda.send(new GetFunctionConfigurationCommand({
                 FunctionName: f.data.arn,

package/{dist/constructs → constructs}/Api.d.ts

@@ -393,7 +393,7 @@ export interface ApiProps<Authorizers extends Record<string, ApiAuthorizer> = Re
         httpStages?: Omit<apig.HttpStageProps, "httpApi">[];
     };
 }
-export declare type ApiRouteProps<AuthorizerKeys> = FunctionInlineDefinition | ApiFunctionRouteProps<AuthorizerKeys> | ApiHttpRouteProps<AuthorizerKeys> | ApiAlbRouteProps<AuthorizerKeys> | ApiPothosRouteProps<AuthorizerKeys>;
+export declare type ApiRouteProps<AuthorizerKeys> = FunctionInlineDefinition | ApiFunctionRouteProps<AuthorizerKeys> | ApiHttpRouteProps<AuthorizerKeys> | ApiAlbRouteProps<AuthorizerKeys> | ApiGraphQLRouteProps<AuthorizerKeys> | ApiPothosRouteProps<AuthorizerKeys>;
 interface ApiBaseRouteProps<AuthorizerKeys = string> {
     authorizer?: "none" | "iam" | (string extends AuthorizerKeys ? Omit<AuthorizerKeys, "none" | "iam"> : AuthorizerKeys);
     authorizationScopes?: string[];
@@ -487,20 +487,38 @@ export interface ApiAlbRouteProps<AuthorizersKeys> extends ApiBaseRouteProps<Aut
 }
 /**
  * Specify a route handler that handles GraphQL queries using Pothos
- *
+ * @deprecated "pothos" routes are deprecated for the Api construct, and will be removed in SST v2. Use "graphql" routes instead. Read more about how to upgrade here — https://docs.sst.dev/upgrade-guide#upgrade-to-v118
  * @example
  * ```js
+ * // Change
  * api.addRoutes(stack, {
  *   "POST /graphql": {
- *      type: "pothos",
- *      schema: "backend/functions/graphql/schema.ts",
- *      output: "graphql/schema.graphql",
- *      function: {
- *        handler: "functions/graphql/graphql.ts",
- *      },
- *      commands: [
- *        "./genql graphql/graphql.schema graphql/
- *      ]
+ *     type: "pothos",
+ *     function: {
+ *       handler: "functions/graphql/graphql.ts",
+ *     },
+ *     schema: "backend/functions/graphql/schema.ts",
+ *     output: "graphql/schema.graphql",
+ *     commands: [
+ *       "./genql graphql/graphql.schema graphql/
+ *     ]
+ *   }
+ * })
+ *
+ * // To
+ * api.addRoutes(stack, {
+ *   "POST /graphql": {
+ *     type: "graphql",
+ *     function: {
+ *       handler: "functions/graphql/graphql.ts",
+ *     },
+ *     pothos: {
+ *       schema: "backend/functions/graphql/schema.ts",
+ *       output: "graphql/schema.graphql",
+ *       commands: [
+ *         "./genql graphql/graphql.schema graphql/
+ *       ]
+ *     }
  *   }
  * })
  * ```
@@ -524,6 +542,49 @@ export interface ApiPothosRouteProps<AuthorizerKeys> extends ApiBaseRouteProps<A
      */
     commands?: string[];
 }
+/**
+ * Specify a route handler that handles GraphQL queries using Pothos
+ *
+ * @example
+ * ```js
+ * api.addRoutes(stack, {
+ *   "POST /graphql": {
+ *      type: "graphql",
+ *      function: {
+ *        handler: "functions/graphql/graphql.ts",
+ *      },
+ *      pothos: {
+ *        schema: "backend/functions/graphql/schema.ts",
+ *        output: "graphql/schema.graphql",
+ *        commands: [
+ *          "./genql graphql/graphql.schema graphql/
+ *        ]
+ *      }
+ *   }
+ * })
+ * ```
+ */
+export interface ApiGraphQLRouteProps<AuthorizerKeys> extends ApiBaseRouteProps<AuthorizerKeys> {
+    type: "graphql";
+    /**
+     * The function definition used to create the function for this route. Must be a graphql handler
+     */
+    function: FunctionDefinition;
+    pothos?: {
+        /**
+         * Path to pothos schema
+         */
+        schema?: string;
+        /**
+         * File to write graphql schema to
+         */
+        output?: string;
+        /**
+         * Commands to run after generating schema. Useful for code generation steps
+         */
+        commands?: string[];
+    };
+}
 /**
  * The Api construct is a higher level CDK construct that makes it easy to create an API.
  *
@@ -702,7 +763,17 @@ export declare class Api<Authorizers extends Record<string, ApiAuthorizer> = Rec
                 output: string | undefined;
                 commands: string[] | undefined;
             } | {
-                type: "url" | "alb" | "lambda_function";
+                type: "graphql";
+                route: string;
+                fn: {
+                    node: string;
+                    stack: string;
+                } | undefined;
+                schema: string | undefined;
+                output: string | undefined;
+                commands: string[] | undefined;
+            } | {
+                type: "lambda_function" | "url" | "alb";
                 route: string;
                 fn?: undefined;
                 schema?: undefined;
@@ -728,9 +799,24 @@ export declare class Api<Authorizers extends Record<string, ApiAuthorizer> = Rec
     private createHttpIntegration;
     private createAlbIntegration;
     protected createPothosIntegration(scope: Construct, routeKey: string, routeProps: ApiPothosRouteProps<keyof Authorizers>, postfixName: string): apig.HttpRouteIntegration;
+    protected createGraphQLIntegration(scope: Construct, routeKey: string, routeProps: ApiGraphQLRouteProps<keyof Authorizers>, postfixName: string): apig.HttpRouteIntegration;
     protected createCdkFunctionIntegration(scope: Construct, routeKey: string, routeProps: ApiFunctionRouteProps<keyof Authorizers>, postfixName: string): apig.HttpRouteIntegration;
     protected createFunctionIntegration(scope: Construct, routeKey: string, routeProps: ApiFunctionRouteProps<keyof Authorizers>, postfixName: string): apig.HttpRouteIntegration;
     private buildRouteAuth;
     private normalizeRouteKey;
+    /**
+     * Binds the given list of resources to a specific route.
+     *
+     * @example
+     * ```js
+     * const api = new Api(stack, "Api");
+     *
+     * api.setCors({
+     *   allowMethods: ["GET"],
+     * });
+     * ```
+     *
+     */
+    setCors(cors?: boolean | ApiCorsProps): void;
 }
 export {};

package/{dist/constructs → constructs}/Api.js

@@ -1,5 +1,5 @@
 import { Construct } from "constructs";
-import * as cdk from "aws-cdk-lib";
+import * as cdkLib from "aws-cdk-lib";
 import * as cognito from "aws-cdk-lib/aws-cognito";
 import * as apig from "@aws-cdk/aws-apigatewayv2-alpha";
 import * as apigAuthorizers from "@aws-cdk/aws-apigatewayv2-authorizers-alpha";
@@ -35,10 +35,16 @@ const PayloadFormatVersions = ["1.0", "2.0"];
  * ```
  */
 export class Api extends Construct {
+    id;
+    cdk;
+    props;
+    _customDomainUrl;
+    routesData;
+    authorizersData;
+    bindingForAllRoutes = [];
+    permissionsAttachedForAllRoutes = [];
     constructor(scope, id, props) {
         super(scope, props?.cdk?.id || id);
-        this.bindingForAllRoutes = [];
-        this.permissionsAttachedForAllRoutes = [];
         this.id = id;
         this.props = props || {};
         this.cdk = {};
@@ -121,7 +127,9 @@ export class Api extends Construct {
         const route = this.routesData[this.normalizeRouteKey(routeKey)];
         if (!route)
             return;
-        if (route.type === "function" || route.type === "pothos") {
+        if (route.type === "function" ||
+            route.type === "pothos" ||
+            route.type === "graphql") {
             return route.function;
         }
     }
@@ -136,7 +144,9 @@ export class Api extends Construct {
      */
     bind(constructs) {
         for (const route of Object.values(this.routesData)) {
-            if (route.type === "function" || route.type === "pothos") {
+            if (route.type === "function" ||
+                route.type === "pothos" ||
+                route.type === "graphql") {
                 route.function.bind(constructs);
             }
         }
@@ -175,7 +185,9 @@ export class Api extends Construct {
      */
     attachPermissions(permissions) {
         for (const route of Object.values(this.routesData)) {
-            if (route.type === "function" || route.type === "pothos") {
+            if (route.type === "function" ||
+                route.type === "pothos" ||
+                route.type === "graphql") {
                 route.function.attachPermissions(permissions);
             }
         }
@@ -227,6 +239,15 @@ export class Api extends Construct {
                             output: data.output,
                             commands: data.commands,
                         };
+                    if (data.type === "graphql")
+                        return {
+                            type: "graphql",
+                            route: key,
+                            fn: getFunctionRef(data.function),
+                            schema: data.schema,
+                            output: data.output,
+                            commands: data.commands,
+                        };
                     return { type: data.type, route: key };
                 }),
             },
@@ -376,7 +397,7 @@ export class Api extends Construct {
                             value.responseTypes.map((type) => apigAuthorizers.HttpLambdaResponseType[type.toUpperCase()]),
                         resultsCacheTtl: value.resultsCacheTtl
                             ? toCdkDuration(value.resultsCacheTtl)
-                            : cdk.Duration.seconds(0),
+                            : cdkLib.Duration.seconds(0),
                     });
                 }
             }
@@ -450,6 +471,12 @@ export class Api extends Construct {
                     this.createPothosIntegration(scope, routeKey, routeValue, postfixName),
                 ];
             }
+            if (routeValue.type === "graphql") {
+                return [
+                    routeValue,
+                    this.createGraphQLIntegration(scope, routeKey, routeValue, postfixName),
+                ];
+            }
             if (routeValue.cdk?.function) {
                 return [
                     routeValue,
@@ -532,6 +559,24 @@ export class Api extends Construct {
         }
         return result;
     }
+    createGraphQLIntegration(scope, routeKey, routeProps, postfixName) {
+        const result = this.createFunctionIntegration(scope, routeKey, {
+            ...routeProps,
+            type: "function",
+            payloadFormatVersion: "2.0",
+        }, postfixName);
+        const data = this.routesData[routeKey];
+        if (data.type === "function") {
+            this.routesData[routeKey] = {
+                ...data,
+                type: "graphql",
+                output: routeProps.pothos?.output,
+                schema: routeProps.pothos?.schema,
+                commands: routeProps.pothos?.commands,
+            };
+        }
+        return result;
+    }
     createCdkFunctionIntegration(scope, routeKey, routeProps, postfixName) {
         ///////////////////
         // Get payload format
@@ -633,4 +678,45 @@ export class Api extends Construct {
     normalizeRouteKey(routeKey) {
         return routeKey.split(/\s+/).join(" ");
     }
+    /**
+     * Binds the given list of resources to a specific route.
+     *
+     * @example
+     * ```js
+     * const api = new Api(stack, "Api");
+     *
+     * api.setCors({
+     *   allowMethods: ["GET"],
+     * });
+     * ```
+     *
+     */
+    setCors(cors) {
+        const { cdk } = this.props;
+        if (isCDKConstruct(cdk?.httpApi)) {
+            // Cannot set CORS if cdk.httpApi is a construct.
+            if (cors !== undefined) {
+                throw new Error(`Cannot configure the "cors" when "cdk.httpApi" is a construct`);
+            }
+        }
+        else {
+            // Cannot set CORS via cdk.httpApi. Always use Api.cors.
+            const httpApiProps = (cdk?.httpApi || {});
+            if (httpApiProps.corsPreflight !== undefined) {
+                throw new Error(`Cannot configure the "httpApi.corsPreflight" in the Api`);
+            }
+            const corsConfig = apigV2Cors.buildCorsConfig(cors);
+            if (corsConfig) {
+                const cfnApi = this.cdk.httpApi.node.defaultChild;
+                cfnApi.corsConfiguration = {
+                    allowCredentials: corsConfig?.allowCredentials,
+                    allowHeaders: corsConfig?.allowHeaders,
+                    allowMethods: corsConfig?.allowMethods,
+                    allowOrigins: corsConfig?.allowOrigins,
+                    exposeHeaders: corsConfig?.exposeHeaders,
+                    maxAge: corsConfig?.maxAge?.toSeconds(),
+                };
+            }
+        }
+    }
 }

package/{dist/constructs → constructs}/ApiGatewayV1Api.js

@@ -44,13 +44,18 @@ const allowedMethods = [
  * ```
  */
 export class ApiGatewayV1Api extends Construct {
+    id;
+    cdk;
+    _deployment;
+    _customDomainUrl;
+    importedResources = {};
+    props;
+    functions = {};
+    authorizersData = {};
+    bindingForAllRoutes = [];
+    permissionsAttachedForAllRoutes = [];
     constructor(scope, id, props) {
         super(scope, props?.cdk?.id || id);
-        this.importedResources = {};
-        this.functions = {};
-        this.authorizersData = {};
-        this.bindingForAllRoutes = [];
-        this.permissionsAttachedForAllRoutes = [];
         this.id = id;
         this.props = props || {};
         this.cdk = {};

package/{dist/constructs → constructs}/App.d.ts

@@ -2,9 +2,8 @@ import * as cdk from "aws-cdk-lib";
 import * as lambda from "aws-cdk-lib/aws-lambda";
 import * as cxapi from "aws-cdk-lib/cx-api";
 import { SSTConstruct } from "./Construct.js";
-import { FunctionProps, FunctionHandlerProps } from "./Function.js";
+import { FunctionProps } from "./Function.js";
 import * as Config from "./Config.js";
-import { BaseSiteEnvironmentOutputsInfo } from "./BaseSite.js";
 import { Permissions } from "./util/permission.js";
 import { StackProps } from "./Stack.js";
 import { FunctionalStack } from "./FunctionalStack.js";
@@ -40,14 +39,8 @@ export interface AppDeployProps {
     readonly debugStartedAt?: number;
     readonly debugBridge?: string;
     readonly debugIncreaseTimeout?: boolean;
-    readonly mode: "deploy" | "start" | "remove";
+    readonly mode: "deploy" | "dev" | "remove";
     readonly bootstrap: Awaited<ReturnType<typeof useBootstrap>>;
-    /**
-     * The callback after synth completes, used by `sst start`.
-     *
-     * @default - Defaults to undefined
-     */
-    readonly synthCallback?: (lambdaHandlers: FunctionHandlerProps[], siteEnvironments: BaseSiteEnvironmentOutputsInfo[]) => void;
 }
 declare type AppRemovalPolicy = Lowercase<keyof typeof cdk.RemovalPolicy>;
 export declare type AppProps = cdk.AppProps;
@@ -80,8 +73,6 @@ export declare class App extends cdk.App {
      */
     readonly account: string;
     /** @internal */
-    readonly buildDir: string;
-    /** @internal */
     readonly debugBridge?: string;
     /** @internal */
     readonly debugEndpoint?: string;
@@ -102,15 +93,6 @@ export declare class App extends cdk.App {
     private _defaultRemovalPolicy?;
     /** @internal */
     get defaultRemovalPolicy(): "destroy" | "retain" | "snapshot" | undefined;
-    /**
-     * The callback after synth completes.
-     */
-    private readonly synthCallback?;
-    /**
-     * A list of Lambda functions in the app
-     */
-    private readonly lambdaHandlers;
-    private readonly siteEnvironments;
     /**
      * Skip building Function code
      * Note that on `sst remove`, we do not want to bundle the Lambda functions.
@@ -211,20 +193,16 @@ export declare class App extends cdk.App {
      */
     addDefaultFunctionLayers(layers: lambda.ILayerVersion[]): void;
     synth(options?: cdk.StageSynthesisOptions): cxapi.CloudAssembly;
-    runDeferredBuilds(): Promise<void>;
+    finish(): Promise<void>;
     isRunningSSTTest(): boolean;
-    registerLambdaHandler(handler: FunctionHandlerProps): void;
-    registerSiteEnvironment(environment: BaseSiteEnvironmentOutputsInfo): void;
     getInputFilesFromEsbuildMetafile(file: string): Array<string>;
+    private createBindingSsmParameters;
     private buildConstructsMetadata;
     private buildConstructsMetadata_collectConstructs;
     private applyRemovalPolicy;
     private removeGovCloudUnsupportedResourceProperties;
     private ensureUniqueConstructIds;
     private codegenTypes;
-    private codegenFindNodeModulesPath;
-    private codegenCreateIndexType;
-    private codegenCreateConstructTypes;
     stack<T extends FunctionalStack<any>>(fn: T, props?: StackProps & {
         id?: string;
     }): ReturnType<T> extends Promise<any> ? Promise<void> : App;