@sst-community/sst 0.0.0-placeholder.0 → 4.17.2

package/dist/aws/realtime.d.ts

@@ -0,0 +1,118 @@
+import { IoTCustomAuthorizerHandler, PolicyDocument } from "aws-lambda";
+/**
+ * The `realtime` client SDK is available through the following.
+ *
+ * @example
+ * ```js title="src/authorizer.ts"
+ * import { realtime } from "sst/aws/realtime";
+ * ```
+ */
+export declare namespace realtime {
+    interface AuthResult {
+        /**
+         * The principal ID of the authorized client. This could be a user ID, username, or
+         * phone number.
+         *
+         * The value must be an alphanumeric string with at least one, and no more than 128,
+         * characters and match the regex pattern, `([a-zA-Z0-9]){1,128}`.
+         */
+        principalId?: string;
+        /**
+         * The maximum duration in seconds of the connection to IoT Core.
+         *
+         * :::note
+         * This is set when the connection is established and cannot be modified during subsequent
+         * policy refresh authorization handler invocations.
+         * :::
+         *
+         * The minimum value is 300 seconds, and the maximum is 86400 seconds.
+         * @default `86400`
+         */
+        disconnectAfterInSeconds?: number;
+        /**
+         * The duration in seconds between policy refreshes. After the given duration, IoT Core
+         * will invoke the authorization handler function.
+         *
+         * The minimum value is 300 seconds, and the maximum value is 86400 seconds.
+         */
+        refreshAfterInSeconds?: number;
+        /**
+         * The topics the client can subscribe to.
+         * @example
+         * For example, this subscribes to two specific topics.
+         * ```js
+         * {
+         *   subscribe: ["chat/room1", "chat/room2"]
+         * }
+         * ```
+         *
+         * And to subscribe to all topics under a given prefix.
+         * ```js
+         * {
+         *   subscribe: ["chat/*"]
+         * }
+         * ```
+         */
+        subscribe?: string[];
+        /**
+         * The topics the client can publish to.
+         * @example
+         * For example, this publishes to two specific topics.
+         * ```js
+         * {
+         *   publish: ["chat/room1", "chat/room2"]
+         * }
+         * ```
+         * And to publish to all topics under a given prefix.
+         * ```js
+         * {
+         *   publish: ["chat/*"]
+         * }
+         * ```
+         */
+        publish?: string[];
+        /**
+         * Any additional [IoT Core policy documents](https://docs.aws.amazon.com/iot/latest/developerguide/iot-policies.html) to attach to the client.
+         *
+         * There's a maximum of 10 policy documents. Where each document can contain a maximum of
+         * 2048 characters.
+         * @example
+         * ```js
+         * {
+         *   policyDocuments: [
+         *     {
+         *       Version: "2012-10-17",
+         *       Statement: [
+         *         {
+         *           Action: "iot:Publish",
+         *           Effect: "Allow",
+         *           Resource: "*"
+         *         }
+         *       ]
+         *     }
+         *   ]
+         * }
+         * ```
+         */
+        policyDocuments?: PolicyDocument[];
+    }
+    /**
+     * Creates an authorization handler for the `Realtime` component. It validates
+     * the token and grants permissions for the topics the client can subscribe and publish to.
+     *
+     * @example
+     * ```js title="src/authorizer.ts" "realtime.authorizer"
+     * export const handler = realtime.authorizer(async (token) => {
+     *   // Validate the token
+     *   console.log(token);
+     *
+     *   // Return the topics to subscribe and publish
+     *   return {
+     *     subscribe: ["*"],
+     *     publish: ["*"],
+     *   };
+     * });
+     * ```
+     */
+    function authorizer(input: (token: string) => Promise<AuthResult>): IoTCustomAuthorizerHandler;
+}

package/dist/aws/realtime.js

@@ -0,0 +1,83 @@
+/**
+ * The `realtime` client SDK is available through the following.
+ *
+ * @example
+ * ```js title="src/authorizer.ts"
+ * import { realtime } from "sst/aws/realtime";
+ * ```
+ */
+export var realtime;
+(function (realtime) {
+    /**
+     * Creates an authorization handler for the `Realtime` component. It validates
+     * the token and grants permissions for the topics the client can subscribe and publish to.
+     *
+     * @example
+     * ```js title="src/authorizer.ts" "realtime.authorizer"
+     * export const handler = realtime.authorizer(async (token) => {
+     *   // Validate the token
+     *   console.log(token);
+     *
+     *   // Return the topics to subscribe and publish
+     *   return {
+     *     subscribe: ["*"],
+     *     publish: ["*"],
+     *   };
+     * });
+     * ```
+     */
+    function authorizer(input) {
+        return async (evt, context) => {
+            const [, partition, , region, accountId] = context.invokedFunctionArn.split(":");
+            const token = Buffer.from(evt.protocolData.mqtt?.password ?? "", "base64").toString();
+            const { principalId = evt.protocolData.mqtt?.username || Date.now().toString(), disconnectAfterInSeconds = 86400, refreshAfterInSeconds = 300, subscribe, publish, policyDocuments, } = await input(token);
+            return {
+                isAuthenticated: true,
+                principalId,
+                disconnectAfterInSeconds,
+                refreshAfterInSeconds,
+                policyDocuments: [
+                    {
+                        Version: "2012-10-17",
+                        Statement: [
+                            {
+                                Action: "iot:Connect",
+                                Effect: "Allow",
+                                Resource: "*",
+                            },
+                            ...(subscribe
+                                ? [
+                                    {
+                                        Action: "iot:Receive",
+                                        Effect: "Allow",
+                                        Resource: subscribe.map((t) => `arn:${partition}:iot:${region}:${accountId}:topic/${t}`),
+                                    },
+                                ]
+                                : []),
+                            ...(subscribe
+                                ? [
+                                    {
+                                        Action: "iot:Subscribe",
+                                        Effect: "Allow",
+                                        Resource: subscribe.map((t) => `arn:${partition}:iot:${region}:${accountId}:topicfilter/${t}`),
+                                    },
+                                ]
+                                : []),
+                            ...(publish
+                                ? [
+                                    {
+                                        Action: "iot:Publish",
+                                        Effect: "Allow",
+                                        Resource: publish.map((t) => `arn:${partition}:iot:${region}:${accountId}:topic/${t}`),
+                                    },
+                                ]
+                                : []),
+                        ],
+                    },
+                    ...(policyDocuments ?? []),
+                ],
+            };
+        };
+    }
+    realtime.authorizer = authorizer;
+})(realtime || (realtime = {}));

package/dist/aws/task.d.ts

@@ -0,0 +1,228 @@
+import { type AwsOptions } from "./client.js";
+/**
+ * The `task` client SDK is available through the following.
+ *
+ * @example
+ * ```js title="src/app.ts"
+ * import { task } from "sst/aws/task";
+ * ```
+ *
+ * If you are not using Node.js, you can use the AWS SDK instead. For example, you can call
+ * [`RunTask`](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html) to
+ * run a task.
+ */
+export declare namespace task {
+    /**
+     * The link data for the task.
+     *
+     * @example
+     * For example, let's say you have a task.
+     *
+     * ```js title="sst.config.ts"
+     * new sst.aws.Task("MyTask", { cluster });
+     * ```
+     *
+     * `Resource.MyTask` will have all the link data.
+     *
+     * ```js title="src/app.ts"
+     * import { Resource } from "sst";
+     *
+     * console.log(Resource.MyTask);
+     * ```
+     */
+    export interface Resource {
+        /**
+         * The ARN of the cluster.
+         */
+        cluster: string;
+        /**
+         * The ARN of the task definition.
+         */
+        taskDefinition: string;
+        /**
+         * The subnets to use for the task.
+         */
+        subnets: string[];
+        /**
+         * The security groups to use for the task.
+         */
+        securityGroups: string[];
+        /**
+         * Whether to assign a public IP address to the task.
+         */
+        assignPublicIp: boolean;
+        /**
+         * The names of the containers in the task.
+         */
+        containers: string[];
+    }
+    export interface Options {
+        /**
+         * Configure the options for the [aws4fetch](https://github.com/mhart/aws4fetch)
+         * [`AWSClient`](https://github.com/mhart/aws4fetch?tab=readme-ov-file#new-awsclientoptions) used internally by the SDK.
+         */
+        aws?: AwsOptions;
+    }
+    export interface RunOptions extends Options {
+        /**
+         * Configure the capacity provider; regular Fargate or Fargate Spot, for this task.
+         *
+         * @default `"fargate"`
+         */
+        capacity?: "fargate" | "spot";
+        /**
+         * Overrides the memory allocated for this task in the task definition.
+         */
+        memory?: `${number} GB`;
+        /**
+         * Overrides the CPU allocated for this task in the task definition.
+         */
+        cpu?: `${number} vCPU`;
+        /**
+         * Overrides the ephemeral storage allocated for this task in the task definition.
+         */
+        storage?: `${number} GB`;
+    }
+    interface Task {
+        /**
+         * The ARN of the task.
+         */
+        arn: string;
+        /**
+         * The status of the task.
+         */
+        status: string;
+    }
+    export interface DescribeResponse extends Task {
+        /**
+         * The raw response from the AWS ECS DescribeTasks API.
+         * @see [@aws-sdk/client-ecs.DescribeTasksResponse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ecs/Interface/DescribeTasksResponse/)
+         */
+        response: any;
+    }
+    export interface RunResponse extends Task {
+        /**
+         * The raw response from the AWS ECS RunTask API.
+         * @see [@aws-sdk/client-ecs.RunTaskResponse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ecs/Interface/RunTaskResponse/)
+         */
+        response: any;
+    }
+    export interface StopResponse extends Task {
+        /**
+         * The raw response from the AWS ECS StopTask API.
+         * @see [@aws-sdk/client-ecs.StopTaskResponse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ecs/Interface/StopTaskResponse/)
+         */
+        response: any;
+    }
+    /**
+     * Get the details of a given task.
+     *
+     * :::note
+     * If a task had been stopped over an hour ago, it's not returned.
+     * :::
+     *
+     * @example
+     *
+     * For example, let's say you had previously started a task.
+     *
+     * ```js title="src/app.ts"
+     * const runRet = await task.run(Resource.MyTask);
+     * const taskArn = runRet.tasks[0].taskArn;
+     * ```
+     *
+     * You can use that to get the details of the task.
+     *
+     * ```js title="src/app.ts"
+     * const describeRet = await task.describe(Resource.MyTask, taskArn);
+     * console.log(describeRet.status);
+     * ```
+     *
+     * If you are not using Node.js, you can use the AWS SDK and call
+     * [`DescribeTasks`](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html).
+     */
+    export function describe(resource: Resource, task: string, options?: Options): Promise<DescribeResponse>;
+    /**
+     * Runs a task.
+     *
+     * @example
+     *
+     * For example, let's say you have defined a task.
+     *
+     * ```js title="sst.config.ts"
+     * new sst.aws.Task("MyTask", { cluster });
+     * ```
+     *
+     * You can then run the task in your application with the SDK.
+     *
+     * ```js title="src/app.ts" {4}
+     * import { Resource } from "sst";
+     * import { task } from "sst/aws/task";
+     *
+     * const runRet = await task.run(Resource.MyTask);
+     * const taskArn = runRet.tasks[0].taskArn;
+     * ```
+     *
+     * This internally calls an AWS SDK API that returns an array of tasks. But in our case,
+     * there's only one task.
+     *
+     * The `taskArn` is the ARN of the task. You can use it to call the `describe` or `stop`
+     * functions.
+     *
+     * You can also pass in any environment variables to the task.
+     *
+     * ```js title="src/app.ts"
+     * await task.run(Resource.MyTask, {
+     *   MY_ENV_VAR: "my-value"
+     * });
+     * ```
+     *
+     * If you are not using Node.js, you can use the AWS SDK and call
+     * [`RunTask`](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html).
+     */
+    export function run(resource: Resource, environment?: Record<string, string>, options?: RunOptions): Promise<RunResponse>;
+    /**
+     * Stops a task.
+     *
+     * @example
+     *
+     * For example, let's say you had previously started a task.
+     *
+     * ```js title="src/app.ts"
+     * const runRet = await task.run(Resource.MyTask);
+     * const taskArn = runRet.tasks[0].taskArn;
+     * ```
+     *
+     * You can stop the task with the following.
+     *
+     * ```js title="src/app.ts"
+     * const stopRet = await task.stop(Resource.MyTask, taskArn);
+     * ```
+     *
+     * Stopping a task is asnychronous. When you call `stop`, AWS marks a task to be stopped,
+     * but it may take a few minutes for the task to actually stop.
+     *
+     * :::note
+     * Stopping a task in asyncrhonous.
+     * :::
+     *
+     * In most cases you probably don't need to check if it has been stopped. But if necessary,
+     * you can use the `describe` function to get a task's status.
+     *
+     * If you are not using Node.js, you can use the AWS SDK and call
+     * [`StopTask`](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_StopTask.html).
+     */
+    export function stop(resource: Resource, task: string, options?: Options): Promise<StopResponse>;
+    export class DescribeError extends Error {
+        readonly response: Response;
+        constructor(response: Response);
+    }
+    export class RunError extends Error {
+        readonly response: Response;
+        constructor(response: Response);
+    }
+    export class StopError extends Error {
+        readonly response: Response;
+        constructor(response: Response);
+    }
+    export {};
+}

package/dist/aws/task.js

@@ -0,0 +1,232 @@
+import { awsFetch } from "./client.js";
+/**
+ * The `task` client SDK is available through the following.
+ *
+ * @example
+ * ```js title="src/app.ts"
+ * import { task } from "sst/aws/task";
+ * ```
+ *
+ * If you are not using Node.js, you can use the AWS SDK instead. For example, you can call
+ * [`RunTask`](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html) to
+ * run a task.
+ */
+export var task;
+(function (task_1) {
+    /**
+     * Get the details of a given task.
+     *
+     * :::note
+     * If a task had been stopped over an hour ago, it's not returned.
+     * :::
+     *
+     * @example
+     *
+     * For example, let's say you had previously started a task.
+     *
+     * ```js title="src/app.ts"
+     * const runRet = await task.run(Resource.MyTask);
+     * const taskArn = runRet.tasks[0].taskArn;
+     * ```
+     *
+     * You can use that to get the details of the task.
+     *
+     * ```js title="src/app.ts"
+     * const describeRet = await task.describe(Resource.MyTask, taskArn);
+     * console.log(describeRet.status);
+     * ```
+     *
+     * If you are not using Node.js, you can use the AWS SDK and call
+     * [`DescribeTasks`](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html).
+     */
+    async function describe(resource, task, options) {
+        const res = await awsFetch("ecs", "/", {
+            method: "POST",
+            headers: {
+                "X-Amz-Target": "AmazonEC2ContainerServiceV20141113.DescribeTasks",
+                "Content-Type": "application/x-amz-json-1.1",
+            },
+            body: JSON.stringify({
+                cluster: resource.cluster,
+                tasks: [task],
+            }),
+        }, options);
+        if (!res.ok)
+            throw new DescribeError(res);
+        const data = (await res.json());
+        if (!data.tasks?.length)
+            throw new DescribeError(res);
+        return {
+            arn: data.tasks[0].taskArn,
+            status: data.tasks[0].lastStatus,
+            response: data,
+        };
+    }
+    task_1.describe = describe;
+    /**
+     * Runs a task.
+     *
+     * @example
+     *
+     * For example, let's say you have defined a task.
+     *
+     * ```js title="sst.config.ts"
+     * new sst.aws.Task("MyTask", { cluster });
+     * ```
+     *
+     * You can then run the task in your application with the SDK.
+     *
+     * ```js title="src/app.ts" {4}
+     * import { Resource } from "sst";
+     * import { task } from "sst/aws/task";
+     *
+     * const runRet = await task.run(Resource.MyTask);
+     * const taskArn = runRet.tasks[0].taskArn;
+     * ```
+     *
+     * This internally calls an AWS SDK API that returns an array of tasks. But in our case,
+     * there's only one task.
+     *
+     * The `taskArn` is the ARN of the task. You can use it to call the `describe` or `stop`
+     * functions.
+     *
+     * You can also pass in any environment variables to the task.
+     *
+     * ```js title="src/app.ts"
+     * await task.run(Resource.MyTask, {
+     *   MY_ENV_VAR: "my-value"
+     * });
+     * ```
+     *
+     * If you are not using Node.js, you can use the AWS SDK and call
+     * [`RunTask`](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html).
+     */
+    async function run(resource, environment, options) {
+        const res = await awsFetch("ecs", "/", {
+            method: "POST",
+            headers: {
+                "X-Amz-Target": "AmazonEC2ContainerServiceV20141113.RunTask",
+                "Content-Type": "application/x-amz-json-1.1",
+            },
+            body: JSON.stringify({
+                capacityProviderStrategy: [
+                    {
+                        capacityProvider: options?.capacity === "spot" ? "FARGATE_SPOT" : "FARGATE",
+                        weight: 1,
+                    },
+                ],
+                cluster: resource.cluster,
+                taskDefinition: resource.taskDefinition,
+                networkConfiguration: {
+                    awsvpcConfiguration: {
+                        subnets: resource.subnets,
+                        securityGroups: resource.securityGroups,
+                        assignPublicIp: resource.assignPublicIp ? "ENABLED" : "DISABLED",
+                    },
+                },
+                overrides: {
+                    ...(options?.cpu ? { cpu: (parseFloat(options.cpu.replace(" vCPU", "")) * 1024).toString() } : {}),
+                    ...(options?.memory ? { memory: (parseFloat(options.memory.replace(" GB", "")) * 1024).toString() } : {}),
+                    ...(options?.storage ? { ephemeralStorage: { sizeInGiB: parseInt(options.storage.replace(" GB", "")) } } : {}),
+                    containerOverrides: resource.containers.map((name) => ({
+                        name,
+                        environment: Object.entries(environment ?? {}).map(([key, value]) => ({
+                            name: key,
+                            value,
+                        })),
+                    })),
+                },
+            }),
+        }, options);
+        if (!res.ok)
+            throw new RunError(res);
+        const data = (await res.json());
+        if (!data.tasks?.length)
+            throw new RunError(res);
+        return {
+            arn: data.tasks[0].taskArn,
+            status: data.tasks[0].lastStatus,
+            response: data,
+        };
+    }
+    task_1.run = run;
+    /**
+     * Stops a task.
+     *
+     * @example
+     *
+     * For example, let's say you had previously started a task.
+     *
+     * ```js title="src/app.ts"
+     * const runRet = await task.run(Resource.MyTask);
+     * const taskArn = runRet.tasks[0].taskArn;
+     * ```
+     *
+     * You can stop the task with the following.
+     *
+     * ```js title="src/app.ts"
+     * const stopRet = await task.stop(Resource.MyTask, taskArn);
+     * ```
+     *
+     * Stopping a task is asnychronous. When you call `stop`, AWS marks a task to be stopped,
+     * but it may take a few minutes for the task to actually stop.
+     *
+     * :::note
+     * Stopping a task in asyncrhonous.
+     * :::
+     *
+     * In most cases you probably don't need to check if it has been stopped. But if necessary,
+     * you can use the `describe` function to get a task's status.
+     *
+     * If you are not using Node.js, you can use the AWS SDK and call
+     * [`StopTask`](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_StopTask.html).
+     */
+    async function stop(resource, task, options) {
+        const res = await awsFetch("ecs", "/", {
+            method: "POST",
+            headers: {
+                "X-Amz-Target": "AmazonEC2ContainerServiceV20141113.StopTask",
+                "Content-Type": "application/x-amz-json-1.1",
+            },
+            body: JSON.stringify({
+                cluster: resource.cluster,
+                task,
+            }),
+        }, options);
+        if (!res.ok)
+            throw new StopError(res);
+        const data = (await res.json());
+        if (!data.task)
+            throw new StopError(res);
+        return {
+            arn: data.task.taskArn,
+            status: data.task.lastStatus,
+            response: data,
+        };
+    }
+    task_1.stop = stop;
+    class DescribeError extends Error {
+        response;
+        constructor(response) {
+            super("Failed to describe task");
+            this.response = response;
+        }
+    }
+    task_1.DescribeError = DescribeError;
+    class RunError extends Error {
+        response;
+        constructor(response) {
+            super("Failed to run task");
+            this.response = response;
+        }
+    }
+    task_1.RunError = RunError;
+    class StopError extends Error {
+        response;
+        constructor(response) {
+            super("Failed to stop task");
+            this.response = response;
+        }
+    }
+    task_1.StopError = StopError;
+})(task || (task = {}));