@sst-community/sst 4.20.0 → 5.0.0-alpha.1

package/platform/types/components/aws/v5/function.d.ts

@@ -0,0 +1,582 @@
+import { ComponentResourceOptions, Output } from "@pulumi/pulumi";
+import { V5Args } from "../../parts-component";
+import { Plain } from "../../args";
+import type { Input } from "../../input";
+import { FunctionArgs as OriginalFunctionArgs } from "../function";
+import { Efs as OriginalEfs } from "../efs";
+import { type TakesVpc } from "../helpers/vpc";
+import { Efs } from "./efs";
+import { FunctionEnvironmentUpdate } from "../providers/function-environment-update";
+import { KvKeys } from "../providers/kv-keys";
+import { KvRoutesUpdate } from "../providers/kv-routes-update";
+declare const parts: {
+    /**
+     * The IAM Role the function uses.
+     */
+    role: typeof import("@pulumi/aws/iam/role").Role;
+    /**
+     * The CloudWatch Log Group the function's logs are stored in. It isn't created when
+     * `logging` is `false`.
+     */
+    logGroup: import("../..").OptionalPart<typeof import("@pulumi/aws/cloudwatch/logGroup").LogGroup>;
+    /**
+     * The function's code: a zip file in the asset bucket of your account. A Python
+     * function deployed as a container has an `image` instead.
+     */
+    code: import("../..").OptionalPart<typeof import("@pulumi/aws/s3/bucketObjectv2").BucketObjectv2>;
+    /**
+     * The source maps of the function's code, one for each file the build writes. They
+     * are numbered from `0`, and they're only known once the function is built.
+     */
+    sourcemap: import("../..").ManyPart<typeof import("@pulumi/aws/s3/bucketObjectv2").BucketObjectv2>;
+    /**
+     * The container image of a Python function that's deployed as a container.
+     */
+    image: import("../..").OptionalPart<typeof import("@pulumi/docker-build/image").Image>;
+    /**
+     * The AWS Lambda function.
+     */
+    function: typeof import("@pulumi/aws/lambda/function").Function;
+    /**
+     * The Lambda function URL, when `url` is enabled.
+     */
+    url: import("../..").OptionalPart<typeof import("@pulumi/aws/lambda/functionUrl").FunctionUrl>;
+    /**
+     * The alias the URL of a durable function points to.
+     */
+    urlAlias: import("../..").OptionalPart<typeof import("@pulumi/aws/lambda/alias").Alias>;
+    /**
+     * The permission to call the function's URL: for everyone, or for the router's
+     * distribution when the URL is behind a router that signs its requests. When the URL
+     * is behind a router, it's only known once the router is.
+     */
+    urlAccess: import("../..").OptionalPart<typeof import("@pulumi/aws/lambda/permission").Permission>;
+    /**
+     * The permission to invoke the function through its URL. It's given to whoever
+     * `urlAccess` is.
+     */
+    urlInvoke: import("../..").OptionalPart<typeof import("@pulumi/aws/lambda/permission").Permission>;
+    /**
+     * What the router needs to know to reach the function's URL, stored in the router's
+     * key value store.
+     */
+    routeKey: import("../..").OptionalPart<typeof KvKeys>;
+    /**
+     * The entry for the function's URL in the router's list of routes.
+     */
+    routesUpdate: import("../..").OptionalPart<typeof KvRoutesUpdate>;
+    /**
+     * The provisioned concurrency of the function, when `concurrency.provisioned` is set.
+     */
+    provisioned: import("../..").OptionalPart<typeof import("@pulumi/aws/lambda/provisionedConcurrencyConfig").ProvisionedConcurrencyConfig>;
+    /**
+     * The settings for asynchronous invocations, when `retries` is set.
+     */
+    eventInvokeConfig: import("../..").OptionalPart<typeof import("@pulumi/aws/lambda/functionEventInvokeConfig").FunctionEventInvokeConfig>;
+    /**
+     * The environment variables added with `addEnvironment`.
+     */
+    environmentUpdate: import("../..").OptionalPart<typeof FunctionEnvironmentUpdate>;
+};
+type Logging = Exclude<Plain<OriginalFunctionArgs["logging"]>, false | undefined>;
+type Url = Exclude<Plain<OriginalFunctionArgs["url"]>, boolean | undefined>;
+type Python = NonNullable<Plain<OriginalFunctionArgs["python"]>>;
+type Concurrency = NonNullable<Plain<OriginalFunctionArgs["concurrency"]>>;
+export interface FunctionLoggingArgs extends Omit<Logging, "logGroup"> {
+}
+export interface FunctionUrlArgs extends Omit<Url, "route" | "authorization"> {
+    /**
+     * The authorization used for the function URL. Supports [IAM authorization](https://docs.aws.amazon.com/lambda/latest/dg/urls-auth.html).
+     *
+     * It decides which permissions are created, so it has to be a plain value.
+     *
+     * @default `"none"`
+     * @example
+     * ```js
+     * {
+     *   url: {
+     *     authorization: "iam"
+     *   }
+     * }
+     * ```
+     */
+    authorization?: "none" | "iam";
+}
+export interface FunctionPythonArgs extends Omit<Python, "container"> {
+    /**
+     * Set this to `true` to deploy the function as a container image. That lifts the
+     * 250MB limit on the unzipped package to 10GB, and lets you use your own Dockerfile.
+     * It needs the Docker daemon to be running.
+     *
+     * It decides whether an image is built, so it has to be a plain value.
+     *
+     * @default `false`
+     * @example
+     * ```js
+     * {
+     *   python: {
+     *     container: true
+     *   }
+     * }
+     * ```
+     *
+     * To use a custom Dockerfile, add one to the root of the uv workspace of the function.
+     *
+     * Disable the Docker build cache, for environments like Localstack where exporting
+     * the cache to ECR isn't supported.
+     *
+     * ```js
+     * {
+     *   python: {
+     *     container: {
+     *       cache: false
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    container?: boolean | {
+        cache?: Input<boolean>;
+    };
+}
+export interface FunctionConcurrencyArgs extends Omit<Concurrency, "provisioned"> {
+    /**
+     * Provisioned concurrency keeps a number of Lambda instances ready to handle
+     * requests, which reduces cold starts. It incurs extra charges, and it needs
+     * `versioning` to be enabled.
+     *
+     * It decides whether the provisioned concurrency is created, so it has to be a
+     * plain number.
+     *
+     * @default No provisioned concurrency
+     * @example
+     * ```js
+     * {
+     *   concurrency: {
+     *     provisioned: 10
+     *   }
+     * }
+     * ```
+     */
+    provisioned?: number;
+}
+export interface FunctionArgs extends V5Args<TakesVpc<Omit<OriginalFunctionArgs, "live" | "dev" | "role" | "logging" | "url" | "python" | "concurrency" | "volume">>, typeof parts> {
+    /**
+     * Mount an EFS file system to the function.
+     *
+     * @example
+     * Create an EFS file system.
+     *
+     * ```ts title="sst.config.ts"
+     * const vpc = new sst.aws.Vpc("MyVpc");
+     * const fileSystem = new sst.aws.v5.Efs("MyFileSystem", { vpc });
+     * ```
+     *
+     * And pass it in.
+     *
+     * ```js
+     * {
+     *   volume: {
+     *     efs: fileSystem
+     *   }
+     * }
+     * ```
+     *
+     * By default, the file system will be mounted to `/mnt/efs`. You can change this by
+     * passing in the `path` property.
+     *
+     * ```js
+     * {
+     *   volume: {
+     *     efs: fileSystem,
+     *     path: "/mnt/my-files"
+     *   }
+     * }
+     * ```
+     *
+     * To use an existing EFS, you can pass in an EFS access point ARN.
+     *
+     * ```js
+     * {
+     *   volume: {
+     *     efs: "arn:aws:elasticfilesystem:us-east-1:123456789012:access-point/fsap-12345678",
+     *   }
+     * }
+     * ```
+     */
+    volume?: Input<{
+        /**
+         * The EFS file system to mount. Or an EFS access point ARN.
+         */
+        efs: Input<OriginalEfs | Efs | string>;
+        /**
+         * The path to mount the volume.
+         * @default `"/mnt/efs"`
+         */
+        path?: Input<string>;
+    }>;
+    /**
+     * Disable running this function [_Live_](/docs/live/) in `sst dev`.
+     *
+     * By default, the functions in your app are run locally in `sst dev`. To do this, a
+     * _stub_ version of your function is deployed, instead of the real function. You can
+     * turn this off by setting `dev` to `false`. It has to be a plain value.
+     *
+     * @default `true`
+     * @example
+     * ```js
+     * {
+     *   dev: false
+     * }
+     * ```
+     */
+    dev?: Plain<OriginalFunctionArgs["dev"]>;
+    /**
+     * Configure the function logs in CloudWatch. Or pass in `false` to disable writing
+     * logs: the function is then not given permissions to write to CloudWatch.
+     *
+     * Whether the function logs has to be a plain value. The fields can be outputs.
+     *
+     * To write to a log group you already have, pass it in `existing.logGroup`.
+     *
+     * @default `{retention: "1 month", format: "text"}`
+     * @example
+     * ```js
+     * {
+     *   logging: false
+     * }
+     * ```
+     */
+    logging?: false | FunctionLoggingArgs;
+    /**
+     * Enable [Lambda function URLs](https://docs.aws.amazon.com/lambda/latest/dg/lambda-urls.html).
+     * These are dedicated endpoints for your Lambda functions.
+     *
+     * Whether there is a URL, and whether it's served through a router, have to be plain
+     * values. The fields of the CORS settings can be outputs.
+     *
+     * @default `false`
+     * @example
+     * Enable it with the default options.
+     * ```js
+     * {
+     *   url: true
+     * }
+     * ```
+     *
+     * Configure the authorization and CORS settings for the URL.
+     * ```js
+     * {
+     *   url: {
+     *     authorization: "iam",
+     *     cors: {
+     *       allowOrigins: ["https://example.com"]
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    url?: boolean | FunctionUrlArgs;
+    /**
+     * Configure how your Python function is packaged.
+     */
+    python?: FunctionPythonArgs;
+    /**
+     * Configure the concurrency settings for the function.
+     *
+     * @default No concurrency settings set
+     * @example
+     * ```js
+     * {
+     *   concurrency: {
+     *     provisioned: 10,
+     *     reserved: 50
+     *   }
+     * }
+     * ```
+     */
+    concurrency?: FunctionConcurrencyArgs;
+}
+declare const Function_base: import("../..").ComponentClass<{
+    /**
+     * The IAM Role the function uses.
+     */
+    role: typeof import("@pulumi/aws/iam/role").Role;
+    /**
+     * The CloudWatch Log Group the function's logs are stored in. It isn't created when
+     * `logging` is `false`.
+     */
+    logGroup: import("../..").OptionalPart<typeof import("@pulumi/aws/cloudwatch/logGroup").LogGroup>;
+    /**
+     * The function's code: a zip file in the asset bucket of your account. A Python
+     * function deployed as a container has an `image` instead.
+     */
+    code: import("../..").OptionalPart<typeof import("@pulumi/aws/s3/bucketObjectv2").BucketObjectv2>;
+    /**
+     * The source maps of the function's code, one for each file the build writes. They
+     * are numbered from `0`, and they're only known once the function is built.
+     */
+    sourcemap: import("../..").ManyPart<typeof import("@pulumi/aws/s3/bucketObjectv2").BucketObjectv2>;
+    /**
+     * The container image of a Python function that's deployed as a container.
+     */
+    image: import("../..").OptionalPart<typeof import("@pulumi/docker-build/image").Image>;
+    /**
+     * The AWS Lambda function.
+     */
+    function: typeof import("@pulumi/aws/lambda/function").Function;
+    /**
+     * The Lambda function URL, when `url` is enabled.
+     */
+    url: import("../..").OptionalPart<typeof import("@pulumi/aws/lambda/functionUrl").FunctionUrl>;
+    /**
+     * The alias the URL of a durable function points to.
+     */
+    urlAlias: import("../..").OptionalPart<typeof import("@pulumi/aws/lambda/alias").Alias>;
+    /**
+     * The permission to call the function's URL: for everyone, or for the router's
+     * distribution when the URL is behind a router that signs its requests. When the URL
+     * is behind a router, it's only known once the router is.
+     */
+    urlAccess: import("../..").OptionalPart<typeof import("@pulumi/aws/lambda/permission").Permission>;
+    /**
+     * The permission to invoke the function through its URL. It's given to whoever
+     * `urlAccess` is.
+     */
+    urlInvoke: import("../..").OptionalPart<typeof import("@pulumi/aws/lambda/permission").Permission>;
+    /**
+     * What the router needs to know to reach the function's URL, stored in the router's
+     * key value store.
+     */
+    routeKey: import("../..").OptionalPart<typeof KvKeys>;
+    /**
+     * The entry for the function's URL in the router's list of routes.
+     */
+    routesUpdate: import("../..").OptionalPart<typeof KvRoutesUpdate>;
+    /**
+     * The provisioned concurrency of the function, when `concurrency.provisioned` is set.
+     */
+    provisioned: import("../..").OptionalPart<typeof import("@pulumi/aws/lambda/provisionedConcurrencyConfig").ProvisionedConcurrencyConfig>;
+    /**
+     * The settings for asynchronous invocations, when `retries` is set.
+     */
+    eventInvokeConfig: import("../..").OptionalPart<typeof import("@pulumi/aws/lambda/functionEventInvokeConfig").FunctionEventInvokeConfig>;
+    /**
+     * The environment variables added with `addEnvironment`.
+     */
+    environmentUpdate: import("../..").OptionalPart<typeof FunctionEnvironmentUpdate>;
+}>;
+/**
+ * The `Function` component lets you add serverless functions to your app.
+ * It uses [AWS Lambda](https://aws.amazon.com/lambda/).
+ *
+ * It takes the same args as [`sst.aws.Function`](/docs/component/aws/function), apart from the
+ * few listed under [Switch from `Function`](#switch-from-function). It's built from parts,
+ * so every resource it creates can be transformed, is available in `nodes`, and can be
+ * swapped for one you already have.
+ *
+ * @example
+ *
+ * #### Minimal example
+ *
+ * Pass in the path to your handler function.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.Function("MyFunction", {
+ *   handler: "src/lambda.handler"
+ * });
+ * ```
+ *
+ * The runtimes, and what `handler` means for each, are the same as for
+ * [`sst.aws.Function`](/docs/component/aws/function#handler).
+ *
+ * #### Set additional config
+ *
+ * ```ts {3,4} title="sst.config.ts"
+ * new sst.aws.v5.Function("MyFunction", {
+ *   handler: "src/lambda.handler",
+ *   timeout: "3 minutes",
+ *   memory: "1024 MB"
+ * });
+ * ```
+ *
+ * #### Link resources
+ *
+ * [Link resources](/docs/linking/) to the function. This will grant permissions
+ * to the resources and allow you to access it in your handler.
+ *
+ * ```ts {5} title="sst.config.ts"
+ * const bucket = new sst.aws.v5.Bucket("MyBucket");
+ *
+ * new sst.aws.v5.Function("MyFunction", {
+ *   handler: "src/lambda.handler",
+ *   link: [bucket]
+ * });
+ * ```
+ *
+ * ```ts title="src/lambda.ts"
+ * import { Resource } from "sst";
+ *
+ * console.log(Resource.MyBucket.name);
+ * ```
+ *
+ * #### Enable function URLs
+ *
+ * ```ts {3} title="sst.config.ts"
+ * new sst.aws.v5.Function("MyFunction", {
+ *   handler: "src/lambda.handler",
+ *   url: true
+ * });
+ * ```
+ *
+ * #### Change what's created
+ *
+ * Every resource the function creates is a part you can transform.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.Function("MyFunction", {
+ *   handler: "src/lambda.handler",
+ *   url: true,
+ *   transform: {
+ *     function: { tracingConfig: { mode: "Active" } },
+ *     logGroup: { logGroupClass: "INFREQUENT_ACCESS" },
+ *     url: { invokeMode: "RESPONSE_STREAM" }
+ *   }
+ * });
+ * ```
+ *
+ * #### Use a role or log group you already have
+ *
+ * Pass the resource, or the name to look it up by.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.Function("MyFunction", {
+ *   handler: "src/lambda.handler",
+ *   existing: {
+ *     role: "my-lambda-role",
+ *     logGroup: "/my/shared/logs"
+ *   }
+ * });
+ * ```
+ *
+ * #### Switch from `sst.aws.Function`
+ *
+ * Change `sst.aws.Function` to `sst.aws.v5.Function` and keep the name. The function, its
+ * role, log group, code and URL are kept. A few things are written differently:
+ *
+ * - `dev`, `logging`, `url`, `url.authorization`, `python`, `python.container`,
+ *   `concurrency` and `concurrency.provisioned` have to be plain values, not outputs.
+ * - `role: roleArn` becomes `existing: { role }`, with the role or its name.
+ * - `logging: { logGroup: name }` becomes `existing: { logGroup }`, with the log group
+ *   or its name.
+ * - `live: false` becomes `dev: false`, and `url.route` becomes `url.router`.
+ * - The way `sst.aws.Function` takes those four still works.
+ * - `nodes.function` and `nodes.logGroup` are the resources themselves, not outputs.
+ * - The alias the URL of a durable function points at is created with the function's
+ *   `provider`. `sst.aws.Function` created it with your app's provider, whatever the
+ *   function was given. If a durable function has a `url` and a `provider`, the alias is
+ *   replaced on switch, and the URL with it.
+ * - `transform: { function: { environment: { variables: { A: "1" } } } }` adds a
+ *   variable where it used to replace them all.
+ *
+ * The V5 components create their functions, like a queue's subscriber, as
+ * `sst.aws.v5.Function` too. There you can keep writing the function the way
+ * `sst.aws.Function` takes it.
+ *
+ * ```ts title="sst.config.ts" del={1} ins={2}
+ * new sst.aws.Function("MyFunction", { handler: "src/lambda.handler" });
+ * new sst.aws.v5.Function("MyFunction", { handler: "src/lambda.handler" });
+ * ```
+ */
+export declare class Function extends Function_base {
+    private readonly durable;
+    private readonly fn;
+    private readonly urlEndpoint;
+    constructor(name: string, args: FunctionArgs, opts?: ComponentResourceOptions);
+    /**
+     * The Lambda function URL if `url` is enabled.
+     */
+    get url(): Output<string>;
+    /**
+     * The name of the Lambda function.
+     */
+    get name(): Output<string>;
+    /**
+     * The ARN of the Lambda function.
+     */
+    get arn(): Output<string>;
+    private get useQualifiedTarget();
+    /** @internal */
+    get targetArn(): Output<string>;
+    /** @internal */
+    get qualifier(): Output<string | undefined>;
+    /** @internal */
+    get targetInvokeArn(): Output<string>;
+    /** @internal */
+    get targetResponseStreamingInvokeArn(): Output<string>;
+    /**
+     * Add environment variables lazily to the function after the function is created.
+     *
+     * This is useful for adding environment variables that are only available after the
+     * function is created, like the function URL. It can be called once.
+     *
+     * @param environment The environment variables to add to the function.
+     *
+     * @example
+     * Add the function URL as an environment variable.
+     *
+     * ```ts title="sst.config.ts"
+     * const fn = new sst.aws.v5.Function("MyFunction", {
+     *   handler: "src/handler.handler",
+     *   url: true,
+     * });
+     *
+     * fn.addEnvironment({
+     *   URL: fn.url,
+     * });
+     * ```
+     */
+    addEnvironment(environment: Input<Record<string, Input<string>>>): FunctionEnvironmentUpdate;
+    /**
+     * Linking a function gives the linked resource its name and URL, and lets it invoke
+     * the function.
+     */
+    link(): {
+        properties: {
+            qualifier?: Output<string | undefined> | undefined;
+            name: Output<string>;
+            url: Output<string | undefined>;
+        };
+        include: {
+            effect?: "allow" | "deny" | undefined;
+            actions: string[];
+            resources: Input<Input<string>[]>;
+            conditions?: Input<Input<{
+                test: Input<string>;
+                variable: Input<string>;
+                values: Input<Input<string>[]>;
+            }>[]> | undefined;
+            type: "aws.permission";
+        }[];
+    };
+    /**
+     * Reference an existing function with the given function name. This is useful when you
+     * create a function in one stage and want to share it in another. Linking it gives the
+     * linked resource its name and lets it invoke the function.
+     *
+     * @param name The name of the component.
+     * @param functionName The name of the existing Lambda function.
+     * @param opts Component resource options.
+     *
+     * @example
+     *
+     * ```ts title="sst.config.ts"
+     * const fn = $app.stage === "frank"
+     *   ? sst.aws.v5.Function.get("MyFunction", "app-dev-MyFunctionFunction-abcdefgh")
+     *   : new sst.aws.v5.Function("MyFunction", { handler: "src/lambda.handler" });
+     * ```
+     */
+    static get(name: string, functionName: Input<string>, opts?: ComponentResourceOptions): Function;
+}
+export {};
+//# sourceMappingURL=function.d.ts.map

package/platform/types/components/aws/v5/function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../../../../src/components/aws/v5/function.ts"],"names":[],"mappings":"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"}

package/platform/types/components/aws/v5/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The V5 components. Each one has the name of the component it replaces, so
+ * they're exported together as `sst.aws.v5`: `sst.aws.v5.Queue` next to
+ * `sst.aws.Queue`.
+ */
+export * from "./alb";
+export * from "./apigatewayv2";
+export * from "./app-sync";
+export * from "./aurora";
+export * from "./bucket";
+export * from "./bus";
+export * from "./cluster";
+export * from "./cognito-user-pool";
+export * from "./cognito-user-pool-client";
+export * from "./cron-v2";
+export * from "./dsql";
+export * from "./dynamo";
+export * from "./efs";
+export * from "./function";
+export * from "./mysql";
+export * from "./postgres";
+export * from "./queue";
+export * from "./redis";
+export * from "./service";
+export * from "./sns-topic";
+export * from "./task";
+//# sourceMappingURL=index.d.ts.map

package/platform/types/components/aws/v5/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/aws/v5/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,cAAc,OAAO,CAAC;AACtB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,OAAO,CAAC;AACtB,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,OAAO,CAAC;AACtB,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC"}