@orcabus/platform-cdk-constructs 0.0.6 → 0.0.7-alpha.4

package/index.ts

@@ -1,3 +1,17 @@
-export * as apigateway from "./api-gateway";
-export * as deploymentPipeline from "./deployment-stack-pipeline";
+// Get stage name
 export * as utils from "./utils";
+
+// Deployment pipeline constructs
+export * as deploymentPipeline from "./deployment-stack-pipeline";
+
+// Api Gateway constructs
+export * as apigateway from "./api-gateway";
+
+// DynamoDB Constructs
+export * as dynamodb from "./dynamodb";
+
+// ECS / Fargate Constructs
+export * as ecs from "./ecs";
+
+// Lambda Constructs
+export * as lambda from "./lambda";

package/lambda/build_python/Dockerfile

@@ -0,0 +1,60 @@
+# NOTES -
+# THIS IS FROM https://github.com/aws/aws-cdk/blob/main/packages/%40aws-cdk/aws-lambda-python-alpha/lib/Dockerfile
+# We have made the following changes:
+# 1. Added the installation of 'uv'
+# 2. Addded in the UV_CACHE_DIR environment variable
+# 3. Replaced 'pip' with 'uv pip' in the main code chunk
+# 4. Replaced /usr/app/venv/pip with uv pip shell script wrapper
+# The correct AWS SAM build image based on the runtime of the function will be
+# passed as build arg. The default allows to do `docker build .` when testing.
+ARG IMAGE=public.ecr.aws/sam/build-python3.12:latest
+FROM $IMAGE
+
+ARG TARGETPLATFORM
+ARG PIP_INDEX_URL
+ARG PIP_EXTRA_INDEX_URL
+ARG HTTPS_PROXY
+ARG POETRY_VERSION=1.5.1
+
+# ADDITION: Install uv
+RUN curl -LsSf https://astral.sh/uv/install.sh | XDG_CONFIG_HOME=/tmp UV_INSTALL_DIR=/usr/bin sh
+
+# Add virtualenv path
+ENV PATH="/usr/app/venv/bin:$PATH"
+
+# set the pip cache location
+ENV PIP_CACHE_DIR=/tmp/pip-cache
+
+# set the poetry cache
+ENV POETRY_CACHE_DIR=/tmp/poetry-cache
+
+# ADDITION: set the uv cache
+ENV UV_CACHE_DIR=/tmp/uv-cache
+
+# ADDITION: Replace 'pip' with uv pip in the following chunk
+RUN \
+    # create a new virtualenv for python to use
+    # so that it isn't using root
+    python -m venv /usr/app/venv && \
+    # Create a new location for the pip cache
+    mkdir /tmp/pip-cache && \
+    # Ensure all users can write to pip cache
+    chmod -R 777 /tmp/pip-cache && \
+    # Upgrade pip (required by cryptography v3.4 and above, which is a dependency of poetry)
+    uv pip install --upgrade pip && \
+    # Create a new location for the poetry cache
+    mkdir /tmp/poetry-cache && \
+    # Ensure all users can write to poetry cache
+    chmod -R 777 /tmp/poetry-cache && \
+    # Ensure all users can write to uv cache
+    chmod -R 777 /tmp/uv-cache && \
+    # Install pipenv and poetry
+    uv pip install poetry==$POETRY_VERSION && \
+    # Ensure no temporary files remain in the caches
+    rm -rf /tmp/pip-cache/* /tmp/poetry-cache/* /tmp/uv-cache/*
+
+# ADDITION: Replace /usr/app/venv/pip with uv pip
+RUN printf '#!/usr/bin/env bash \nuv pip $@\n' > /usr/app/venv/bin/pip && \
+    printf '#!/usr/bin/env bash \nuv pip $@\n' > /usr/app/venv/bin/pip3
+
+CMD [ "python" ]

package/lambda/config.d.ts

@@ -0,0 +1,11 @@
+import { StageName } from "../utils";
+export declare const DEFAULT_ORCABUS_TOKEN_SECRET_ID = "orcabus/token-service-jwt";
+export declare const DEFAULT_HOSTNAME_SSM_PARAMETER = "/hosted_zone/umccr/name";
+export declare const MART_ENV_VARS: {
+    athenaWorkgroupName: string;
+    athenaDatasourceName: string;
+    athenaDatabaseName: string;
+};
+export declare const MART_S3_BUCKET: Record<StageName, string>;
+export declare const MART_S3_PREFIX = "athena-query-results/";
+export declare const MART_LAMBDA_FUNCTION_NAME = "orcavault";

package/lambda/config.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MART_LAMBDA_FUNCTION_NAME = exports.MART_S3_PREFIX = exports.MART_S3_BUCKET = exports.MART_ENV_VARS = exports.DEFAULT_HOSTNAME_SSM_PARAMETER = exports.DEFAULT_ORCABUS_TOKEN_SECRET_ID = void 0;
+const utils_1 = require("../utils");
+exports.DEFAULT_ORCABUS_TOKEN_SECRET_ID = 'orcabus/token-service-jwt';
+exports.DEFAULT_HOSTNAME_SSM_PARAMETER = '/hosted_zone/umccr/name';
+exports.MART_ENV_VARS = {
+    athenaWorkgroupName: 'orcahouse',
+    athenaDatasourceName: 'orcavault',
+    athenaDatabaseName: 'mart'
+};
+exports.MART_S3_BUCKET = {
+    BETA: `data-sharing-artifacts-${utils_1.accountIdAlias.BETA}-${utils_1.region}`,
+    GAMMA: `data-sharing-artifacts-${utils_1.accountIdAlias.GAMMA}-${utils_1.region}`,
+    PROD: `data-sharing-artifacts-${utils_1.accountIdAlias.PROD}-${utils_1.region}`
+};
+exports.MART_S3_PREFIX = 'athena-query-results/';
+exports.MART_LAMBDA_FUNCTION_NAME = 'orcavault';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLG9DQUEyRDtBQUU5QyxRQUFBLCtCQUErQixHQUFJLDJCQUEyQixDQUFBO0FBQzlELFFBQUEsOEJBQThCLEdBQUcseUJBQXlCLENBQUE7QUFFMUQsUUFBQSxhQUFhLEdBQUc7SUFDekIsbUJBQW1CLEVBQUUsV0FBVztJQUNoQyxvQkFBb0IsRUFBRSxXQUFXO0lBQ2pDLGtCQUFrQixFQUFFLE1BQU07Q0FDN0IsQ0FBQTtBQUVZLFFBQUEsY0FBYyxHQUE4QjtJQUNyRCxJQUFJLEVBQUUsMEJBQTBCLHNCQUFjLENBQUMsSUFBSSxJQUFJLGNBQU0sRUFBRTtJQUMvRCxLQUFLLEVBQUUsMEJBQTBCLHNCQUFjLENBQUMsS0FBSyxJQUFJLGNBQU0sRUFBRTtJQUNqRSxJQUFJLEVBQUUsMEJBQTBCLHNCQUFjLENBQUMsSUFBSSxJQUFJLGNBQU0sRUFBRTtDQUNsRSxDQUFBO0FBQ1ksUUFBQSxjQUFjLEdBQUcsdUJBQXVCLENBQUE7QUFDeEMsUUFBQSx5QkFBeUIsR0FBRyxXQUFXLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge2FjY291bnRJZEFsaWFzLCByZWdpb24sIFN0YWdlTmFtZX0gZnJvbSBcIi4uL3V0aWxzXCI7XG5cbmV4cG9ydCBjb25zdCBERUZBVUxUX09SQ0FCVVNfVE9LRU5fU0VDUkVUX0lEID0gICdvcmNhYnVzL3Rva2VuLXNlcnZpY2Utand0J1xuZXhwb3J0IGNvbnN0IERFRkFVTFRfSE9TVE5BTUVfU1NNX1BBUkFNRVRFUiA9ICcvaG9zdGVkX3pvbmUvdW1jY3IvbmFtZSdcblxuZXhwb3J0IGNvbnN0IE1BUlRfRU5WX1ZBUlMgPSB7XG4gICAgYXRoZW5hV29ya2dyb3VwTmFtZTogJ29yY2Fob3VzZScsXG4gICAgYXRoZW5hRGF0YXNvdXJjZU5hbWU6ICdvcmNhdmF1bHQnLFxuICAgIGF0aGVuYURhdGFiYXNlTmFtZTogJ21hcnQnXG59XG5cbmV4cG9ydCBjb25zdCBNQVJUX1MzX0JVQ0tFVDogUmVjb3JkPFN0YWdlTmFtZSwgc3RyaW5nPiA9IHtcbiAgICBCRVRBOiBgZGF0YS1zaGFyaW5nLWFydGlmYWN0cy0ke2FjY291bnRJZEFsaWFzLkJFVEF9LSR7cmVnaW9ufWAsXG4gICAgR0FNTUE6IGBkYXRhLXNoYXJpbmctYXJ0aWZhY3RzLSR7YWNjb3VudElkQWxpYXMuR0FNTUF9LSR7cmVnaW9ufWAsXG4gICAgUFJPRDogYGRhdGEtc2hhcmluZy1hcnRpZmFjdHMtJHthY2NvdW50SWRBbGlhcy5QUk9EfS0ke3JlZ2lvbn1gXG59XG5leHBvcnQgY29uc3QgTUFSVF9TM19QUkVGSVggPSAnYXRoZW5hLXF1ZXJ5LXJlc3VsdHMvJ1xuZXhwb3J0IGNvbnN0IE1BUlRfTEFNQkRBX0ZVTkNUSU9OX05BTUUgPSAnb3JjYXZhdWx0J1xuIl19

package/lambda/index.d.ts

@@ -0,0 +1,59 @@
+import { PythonFunction, PythonFunctionProps } from "@aws-cdk/aws-lambda-python-alpha";
+import { Construct } from "constructs";
+export interface OrcabusResourcesProps {
+    /**
+     * Provide the orcabusTokenSecretId, otherwise it will default to @DEFAULT_ORCABUS_TOKEN_SECRET_ID
+     */
+    readonly orcabusTokenSecretId?: string;
+    /**
+     * Provide the hostnameSsmParameterName, otherwise it will default to @DEFAULT_HOSTNAME_SSM_PARAMETER
+     */
+    readonly hostnameSsmParameterName?: string;
+}
+export interface MartEnvironmentVariables {
+    /**
+     * Provide the athenaWorkgroupName, otherwise it will default to @MART_ENV_VARS.ATHENA_WORKGROUP_NAME
+     */
+    readonly athenaWorkgroupName?: string;
+    /**
+     * Provide the athenaDatasourceName, otherwise it will default to @MART_ENV_VARS.athenaDatasourceName
+     */
+    readonly athenaDatasourceName?: string;
+    /**
+     * Provide the athenaDatabaseName, otherwise it will default to @MART_ENV_VARS.ATHENA_DATABASE_NAME
+     */
+    readonly athenaDatabaseName?: string;
+}
+export interface PythonUvFunctionProps extends PythonFunctionProps {
+    /**
+     * Whether or not to include the orcabus api tools layer in the lambda function build
+     */
+    readonly includeOrcabusApiToolsLayer?: boolean;
+    /**
+     * Whether or not to include the mart layer in the lambda function build
+     * Note that the mart layer is a little heavier than the orcabus api tools layer
+     * Since we require pandas to be installed
+     */
+    readonly includeMartLayer?: boolean;
+    /**
+     * Provide the orcabusTokenResources, optional, otherwise it will default to
+     * @DEFAULT_ORCABUS_TOKEN_SECRET_ID and @DEFAULT_HOSTNAME_SSM_PARAMETER
+     * for the secret and SSM parameter respectively
+     */
+    readonly orcabusTokenResources?: OrcabusResourcesProps;
+    /**
+     * Provide the martEnvironmentVariables, optional, otherwise it will default to
+     * @MART_ENV_VARS.ATHENA_WORKGROUP_NAME, @MART_ENV_VARS.ATHENA_DATASOURCE_NAME
+     * and @MART_ENV_VARS.ATHENA_DATABASE_NAME for the athena workgroup, datasource and database respectively
+     */
+    readonly martEnvironmentVariables?: MartEnvironmentVariables;
+}
+export declare class PythonUvFunction extends PythonFunction {
+    private static orcabusApiToolsLayer;
+    private static martLayer;
+    constructor(scope: Construct, id: string, props: PythonUvFunctionProps);
+    private buildOrcabusApiToolsLayer;
+    private buildMartToolsLayer;
+    private setOrcabusResources;
+    private setAthenaResources;
+}

package/lambda/index.js

@@ -0,0 +1,242 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythonUvFunction = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_lambda_python_alpha_1 = require("@aws-cdk/aws-lambda-python-alpha");
+const lambda = __importStar(require("aws-cdk-lib/aws-lambda"));
+const secretsManager = __importStar(require("aws-cdk-lib/aws-secretsmanager"));
+const ssm = __importStar(require("aws-cdk-lib/aws-ssm"));
+const iam = __importStar(require("aws-cdk-lib/aws-iam"));
+const s3 = __importStar(require("aws-cdk-lib/aws-s3"));
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const path_1 = __importDefault(require("path"));
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const config_1 = require("./config");
+const utils_1 = require("../utils");
+function getPythonUvDockerImage() {
+    return aws_cdk_lib_1.DockerImage.fromBuild(path_1.default.join(__dirname, 'build_python'));
+}
+class PythonUvFunction extends aws_lambda_python_alpha_1.PythonFunction {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@orcabus/platform-cdk-constructs.lambda.PythonUvFunction", version: "0.0.7-alpha.4" };
+    // Class constructs, to be used for caching the layers
+    // This means that if there are multiple lambdas throughout the stack
+    // They will all use the same layer
+    static orcabusApiToolsLayer;
+    static martLayer;
+    constructor(scope, id, props) {
+        const uvProps = {
+            ...props,
+            bundling: {
+                ...props.bundling,
+                buildArgs: {
+                    ...props.bundling?.buildArgs,
+                    // Add TARGETPLATFORM to build args if it's not already set
+                    TARGETPLATFORM: props.bundling?.buildArgs?.TARGETPLATFORM ?? lambda.Architecture.ARM_64.dockerPlatform,
+                },
+                image: getPythonUvDockerImage(),
+                commandHooks: {
+                    // @ts-ignore
+                    beforeBundling(inputDir, outputDir) {
+                        return [];
+                    },
+                    // @ts-ignore
+                    afterBundling(inputDir, outputDir) {
+                        return [`rm -rf ${outputDir}/pandas/tests`];
+                    },
+                },
+            },
+            paramsAndSecrets: props.paramsAndSecrets ??
+                aws_lambda_1.ParamsAndSecretsLayerVersion.fromVersion(aws_lambda_1.ParamsAndSecretsVersions.V1_0_103, {
+                    cacheEnabled: true,
+                    cacheSize: 300,
+                    logLevel: aws_lambda_1.ParamsAndSecretsLogLevel.DEBUG,
+                }),
+        };
+        super(scope, id, uvProps);
+        if (props.includeOrcabusApiToolsLayer) {
+            /* Set the environment variables for the Orcabus resources */
+            this.setOrcabusResources(props.orcabusTokenResources ?? {});
+            /* Build the orcabus Api tools layer */
+            this.buildOrcabusApiToolsLayer();
+            this.addLayers(PythonUvFunction.orcabusApiToolsLayer);
+        }
+        if (props.includeMartLayer) {
+            /* Set the environment variables for the mart resources */
+            this.setAthenaResources(props.martEnvironmentVariables ?? {});
+            /* Build the mart layer */
+            this.buildMartToolsLayer();
+            this.addLayers(PythonUvFunction.martLayer);
+        }
+    }
+    buildOrcabusApiToolsLayer() {
+        // Only build orcabus api layer if it doesn't exist
+        if (!PythonUvFunction.orcabusApiToolsLayer) {
+            PythonUvFunction.orcabusApiToolsLayer = new aws_lambda_python_alpha_1.PythonLayerVersion(this, 'orcabusApiToolsLayer', {
+                layerVersionName: 'orcabusApiToolsLayer',
+                entry: path_1.default.join(__dirname, 'layers/orcabus_api_tools'),
+                compatibleRuntimes: [lambda.Runtime.PYTHON_3_12],
+                compatibleArchitectures: [lambda.Architecture.ARM_64],
+                license: 'GPL3',
+                description: 'orcabusApiToolsLayer',
+                bundling: {
+                    image: getPythonUvDockerImage(),
+                    commandHooks: {
+                        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                        beforeBundling(inputDir, outputDir) {
+                            return [];
+                        },
+                        afterBundling(inputDir, outputDir) {
+                            return [
+                                `pip install ${inputDir} --target ${outputDir}`,
+                                `find ${outputDir} -name 'pandas' -exec rm -rf {}/tests/ \\;`,
+                            ];
+                        },
+                    },
+                },
+            });
+        }
+    }
+    buildMartToolsLayer() {
+        // Only build the layer if it doesn't exist
+        if (!PythonUvFunction.martLayer) {
+            PythonUvFunction.martLayer = new aws_lambda_python_alpha_1.PythonLayerVersion(this, 'martToolsLayer', {
+                layerVersionName: 'martToolsLayer',
+                entry: path_1.default.join(__dirname, 'layers/mart_tools'),
+                compatibleRuntimes: [lambda.Runtime.PYTHON_3_12],
+                compatibleArchitectures: [lambda.Architecture.ARM_64],
+                license: 'GPL3',
+                description: 'martToolsLayer',
+                bundling: {
+                    image: getPythonUvDockerImage(),
+                    commandHooks: {
+                        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                        beforeBundling(inputDir, outputDir) {
+                            return [];
+                        },
+                        afterBundling(inputDir, outputDir) {
+                            return [
+                                `pip install ${inputDir} --target ${outputDir}`,
+                                `find ${outputDir} -name 'pandas' -exec rm -rf {}/tests/ \\;`,
+                            ];
+                        },
+                    },
+                },
+            });
+        }
+    }
+    setOrcabusResources(props) {
+        // Set secret object
+        const orcabusTokenSecretId = secretsManager.Secret.fromSecretNameV2(this, 'orcabusTokenSecretId', props.orcabusTokenSecretId ?? config_1.DEFAULT_ORCABUS_TOKEN_SECRET_ID);
+        const hostnameSsmParameterName = ssm.StringParameter.fromStringParameterName(this, 'hostnameSsmParameterName', props.hostnameSsmParameterName ?? config_1.DEFAULT_HOSTNAME_SSM_PARAMETER);
+        // Add permissions for the secret and SSM parameter
+        // To the current version
+        orcabusTokenSecretId.grantRead(this.currentVersion);
+        hostnameSsmParameterName.grantRead(this.currentVersion);
+        // Add environment variables
+        this.addEnvironment('ORCABUS_TOKEN_SECRET_ID', orcabusTokenSecretId.secretName);
+        this.addEnvironment('HOSTNAME_SSM_PARAMETER_NAME', hostnameSsmParameterName.parameterName);
+    }
+    setAthenaResources(props) {
+        // Resolve the stage name by performing a reverse lookup using cdk.Aws.ACCOUNT_ID on accountIdAlias
+        const stageName = (0, utils_1.resolveStageName)();
+        const athenaS3Bucket = s3.Bucket.fromBucketName(this, 'athenaS3Bucket', config_1.MART_S3_BUCKET[stageName]);
+        const athenaFunctionName = lambda.Function.fromFunctionName(this, 'lambdaFunctionName', config_1.MART_LAMBDA_FUNCTION_NAME);
+        // Add env vars
+        // Iterate over kv pairs of MART_ENV_VARS
+        for (const [key, value] of Object.entries(config_1.MART_ENV_VARS)) {
+            // After
+            if (props[key] !== undefined) {
+                this.addEnvironment(key, props[key]);
+            }
+            else {
+                this.addEnvironment(key, value);
+            }
+        }
+        // Permissions
+        this.currentVersion.addToRolePolicy(
+        // From https://docs.aws.amazon.com/athena/latest/ug/example-policies-workgroup.html
+        new iam.PolicyStatement({
+            actions: [
+                // Workgroup lists
+                'athena:ListEngineVersions',
+                'athena:ListWorkGroups',
+                'athena:ListDataCatalogs',
+                'athena:ListDatabases',
+                'athena:GetDatabase',
+                'athena:ListTableMetadata',
+                'athena:GetTableMetadata',
+                'athena:GetDataCatalog',
+            ],
+            resources: [`arn:aws:athena:${utils_1.region}:${utils_1.accountIdAlias[stageName]}:*`],
+        }));
+        this.currentVersion.addToRolePolicy(
+        // From https://docs.aws.amazon.com/athena/latest/ug/example-policies-workgroup.html
+        new iam.PolicyStatement({
+            actions: [
+                // Workgroup executions
+                'athena:BatchGetQueryExecution',
+                'athena:GetQueryExecution',
+                'athena:ListQueryExecutions',
+                'athena:StartQueryExecution',
+                'athena:StopQueryExecution',
+                'athena:GetQueryResults',
+                'athena:GetQueryResultsStream',
+                'athena:CreateNamedQuery',
+                'athena:GetNamedQuery',
+                'athena:BatchGetNamedQuery',
+                'athena:ListNamedQueries',
+                'athena:DeleteNamedQuery',
+                'athena:CreatePreparedStatement',
+                'athena:GetPreparedStatement',
+                'athena:ListPreparedStatements',
+                'athena:UpdatePreparedStatement',
+                'athena:DeletePreparedStatement',
+            ],
+            resources: [
+                `arn:aws:athena:${utils_1.region}:${utils_1.accountIdAlias[stageName]}:workgroup/${config_1.MART_ENV_VARS.athenaWorkgroupName}`,
+            ],
+        }));
+        // Add read access to the S3 bucket
+        athenaS3Bucket.grantReadWrite(this.currentVersion, `${config_1.MART_S3_PREFIX}*`);
+        // Add invoke access to the lambda function
+        athenaFunctionName.grantInvoke(this.currentVersion);
+    }
+}
+exports.PythonUvFunction = PythonUvFunction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import {PythonFunction, PythonFunctionProps, PythonLayerVersion} from \"@aws-cdk/aws-lambda-python-alpha\";\nimport {Construct} from \"constructs\";\nimport * as lambda from \"aws-cdk-lib/aws-lambda\";\nimport * as secretsManager from \"aws-cdk-lib/aws-secretsmanager\";\nimport * as ssm from \"aws-cdk-lib/aws-ssm\";\nimport * as iam from \"aws-cdk-lib/aws-iam\";\nimport * as s3 from \"aws-cdk-lib/aws-s3\";\nimport {DockerImage} from 'aws-cdk-lib';\n\nimport path from \"path\";\n\nimport {\n    ParamsAndSecretsLayerVersion,\n    ParamsAndSecretsLogLevel,\n    ParamsAndSecretsVersions,\n} from 'aws-cdk-lib/aws-lambda';\nimport {\n    DEFAULT_HOSTNAME_SSM_PARAMETER,\n    DEFAULT_ORCABUS_TOKEN_SECRET_ID,\n    MART_ENV_VARS, MART_LAMBDA_FUNCTION_NAME,\n    MART_S3_BUCKET,\n    MART_S3_PREFIX\n} from \"./config\";\nimport {accountIdAlias, region, resolveStageName} from \"../utils\";\n\n\nfunction getPythonUvDockerImage(): DockerImage {\n    return DockerImage.fromBuild(path.join(__dirname, 'build_python'));\n}\n\nexport interface OrcabusResourcesProps {\n    /**\n     * Provide the orcabusTokenSecretId, otherwise it will default to @DEFAULT_ORCABUS_TOKEN_SECRET_ID\n     */\n    readonly orcabusTokenSecretId?: string\n\n    /**\n     * Provide the hostnameSsmParameterName, otherwise it will default to @DEFAULT_HOSTNAME_SSM_PARAMETER\n     */\n    readonly hostnameSsmParameterName?: string\n}\n\nexport interface MartEnvironmentVariables {\n    /**\n     * Provide the athenaWorkgroupName, otherwise it will default to @MART_ENV_VARS.ATHENA_WORKGROUP_NAME\n     */\n    readonly athenaWorkgroupName?: string\n\n    /**\n     * Provide the athenaDatasourceName, otherwise it will default to @MART_ENV_VARS.athenaDatasourceName\n     */\n    readonly athenaDatasourceName?: string\n\n    /**\n     * Provide the athenaDatabaseName, otherwise it will default to @MART_ENV_VARS.ATHENA_DATABASE_NAME\n     */\n    readonly athenaDatabaseName?: string\n}\n\nexport interface PythonUvFunctionProps extends PythonFunctionProps {\n    /**\n     * Whether or not to include the orcabus api tools layer in the lambda function build\n     */\n    readonly includeOrcabusApiToolsLayer?: boolean\n\n    /**\n     * Whether or not to include the mart layer in the lambda function build\n     * Note that the mart layer is a little heavier than the orcabus api tools layer\n     * Since we require pandas to be installed\n     */\n    readonly includeMartLayer?: boolean\n\n    /**\n     * Provide the orcabusTokenResources, optional, otherwise it will default to\n     * @DEFAULT_ORCABUS_TOKEN_SECRET_ID and @DEFAULT_HOSTNAME_SSM_PARAMETER\n     * for the secret and SSM parameter respectively\n     */\n    readonly orcabusTokenResources?: OrcabusResourcesProps\n\n    /**\n     * Provide the martEnvironmentVariables, optional, otherwise it will default to\n     * @MART_ENV_VARS.ATHENA_WORKGROUP_NAME, @MART_ENV_VARS.ATHENA_DATASOURCE_NAME\n     * and @MART_ENV_VARS.ATHENA_DATABASE_NAME for the athena workgroup, datasource and database respectively\n     */\n    readonly martEnvironmentVariables?: MartEnvironmentVariables\n}\n\n\nexport class PythonUvFunction extends PythonFunction {\n    // Class constructs, to be used for caching the layers\n    // This means that if there are multiple lambdas throughout the stack\n    // They will all use the same layer\n    private static orcabusApiToolsLayer: lambda.ILayerVersion;\n    private static martLayer: lambda.ILayerVersion;\n\n    constructor(scope: Construct, id: string, props: PythonUvFunctionProps) {\n        const uvProps = {\n            ...props,\n            bundling: {\n                ...props.bundling,\n                buildArgs: {\n                    ...props.bundling?.buildArgs,\n                    // Add TARGETPLATFORM to build args if it's not already set\n                    TARGETPLATFORM:\n                        props.bundling?.buildArgs?.TARGETPLATFORM ?? lambda.Architecture.ARM_64.dockerPlatform,\n                },\n                image: getPythonUvDockerImage(),\n                commandHooks: {\n                    // @ts-ignore\n                    beforeBundling(inputDir: string, outputDir: string): string[] {\n                        return [];\n                    },\n                    // @ts-ignore\n                    afterBundling(inputDir: string, outputDir: string): string[] {\n                        return [`rm -rf ${outputDir}/pandas/tests`];\n                    },\n                },\n            },\n            paramsAndSecrets:\n                props.paramsAndSecrets ??\n                ParamsAndSecretsLayerVersion.fromVersion(ParamsAndSecretsVersions.V1_0_103, {\n                    cacheEnabled: true,\n                    cacheSize: 300,\n                    logLevel: ParamsAndSecretsLogLevel.DEBUG,\n                }),\n        };\n        super(scope, id, uvProps);\n\n        if (props.includeOrcabusApiToolsLayer) {\n            /* Set the environment variables for the Orcabus resources */\n            this.setOrcabusResources(props.orcabusTokenResources ?? {})\n\n            /* Build the orcabus Api tools layer */\n            this.buildOrcabusApiToolsLayer()\n            this.addLayers(PythonUvFunction.orcabusApiToolsLayer)\n        }\n\n        if (props.includeMartLayer) {\n            /* Set the environment variables for the mart resources */\n            this.setAthenaResources(props.martEnvironmentVariables ?? {})\n\n            /* Build the mart layer */\n            this.buildMartToolsLayer()\n            this.addLayers(PythonUvFunction.martLayer)\n        }\n    }\n\n    private buildOrcabusApiToolsLayer() {\n        // Only build orcabus api layer if it doesn't exist\n        if (!PythonUvFunction.orcabusApiToolsLayer) {\n            PythonUvFunction.orcabusApiToolsLayer = new PythonLayerVersion(this, 'orcabusApiToolsLayer', {\n                layerVersionName: 'orcabusApiToolsLayer',\n                entry: path.join(__dirname, 'layers/orcabus_api_tools'),\n                compatibleRuntimes: [lambda.Runtime.PYTHON_3_12],\n                compatibleArchitectures: [lambda.Architecture.ARM_64],\n                license: 'GPL3',\n                description: 'orcabusApiToolsLayer',\n                bundling: {\n                    image: getPythonUvDockerImage(),\n                    commandHooks: {\n                        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                        beforeBundling(inputDir: string, outputDir: string): string[] {\n                            return [];\n                        },\n                        afterBundling(inputDir: string, outputDir: string): string[] {\n                            return [\n                                `pip install ${inputDir} --target ${outputDir}`,\n                                `find ${outputDir} -name 'pandas' -exec rm -rf {}/tests/ \\\\;`,\n                            ];\n                        },\n                    },\n                },\n            });\n        }\n    }\n\n    private buildMartToolsLayer() {\n        // Only build the layer if it doesn't exist\n        if (!PythonUvFunction.martLayer) {\n            PythonUvFunction.martLayer = new PythonLayerVersion(this, 'martToolsLayer', {\n                layerVersionName: 'martToolsLayer',\n                entry: path.join(__dirname, 'layers/mart_tools'),\n                compatibleRuntimes: [lambda.Runtime.PYTHON_3_12],\n                compatibleArchitectures: [lambda.Architecture.ARM_64],\n                license: 'GPL3',\n                description: 'martToolsLayer',\n                bundling: {\n                    image: getPythonUvDockerImage(),\n                    commandHooks: {\n                        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                        beforeBundling(inputDir: string, outputDir: string): string[] {\n                            return [];\n                        },\n                        afterBundling(inputDir: string, outputDir: string): string[] {\n                            return [\n                                `pip install ${inputDir} --target ${outputDir}`,\n                                `find ${outputDir} -name 'pandas' -exec rm -rf {}/tests/ \\\\;`,\n                            ];\n                        },\n                    },\n                },\n            });\n        }\n\n    }\n\n    private setOrcabusResources(\n        props: OrcabusResourcesProps\n    ) {\n        // Set secret object\n        const orcabusTokenSecretId = secretsManager.Secret.fromSecretNameV2(\n            this, 'orcabusTokenSecretId',\n            props.orcabusTokenSecretId ?? DEFAULT_ORCABUS_TOKEN_SECRET_ID\n        );\n        const hostnameSsmParameterName = ssm.StringParameter.fromStringParameterName(\n            this, 'hostnameSsmParameterName',\n            props.hostnameSsmParameterName ?? DEFAULT_HOSTNAME_SSM_PARAMETER,\n        )\n\n        // Add permissions for the secret and SSM parameter\n        // To the current version\n        orcabusTokenSecretId.grantRead(this.currentVersion);\n        hostnameSsmParameterName.grantRead(this.currentVersion)\n\n        // Add environment variables\n        this.addEnvironment(\n            'ORCABUS_TOKEN_SECRET_ID', orcabusTokenSecretId.secretName,\n        )\n        this.addEnvironment(\n            'HOSTNAME_SSM_PARAMETER_NAME', hostnameSsmParameterName.parameterName,\n        )\n    }\n\n\n    private setAthenaResources(\n        props: MartEnvironmentVariables\n    ) {\n        // Resolve the stage name by performing a reverse lookup using cdk.Aws.ACCOUNT_ID on accountIdAlias\n        const stageName = resolveStageName()\n\n        const athenaS3Bucket = s3.Bucket.fromBucketName(\n            this, 'athenaS3Bucket',\n            MART_S3_BUCKET[stageName]\n        )\n\n        const athenaFunctionName = lambda.Function.fromFunctionName(\n            this, 'lambdaFunctionName', MART_LAMBDA_FUNCTION_NAME\n        )\n\n        // Add env vars\n        // Iterate over kv pairs of MART_ENV_VARS\n        for (const [key, value] of Object.entries(MART_ENV_VARS)) {\n            // After\n            if (props[key as keyof MartEnvironmentVariables] !== undefined) {\n                this.addEnvironment(key, props[key as keyof MartEnvironmentVariables]!);\n            } else {\n                this.addEnvironment(key, value);\n            }\n        }\n\n        // Permissions\n        this.currentVersion.addToRolePolicy(\n            // From https://docs.aws.amazon.com/athena/latest/ug/example-policies-workgroup.html\n            new iam.PolicyStatement({\n                actions: [\n                    // Workgroup lists\n                    'athena:ListEngineVersions',\n                    'athena:ListWorkGroups',\n                    'athena:ListDataCatalogs',\n                    'athena:ListDatabases',\n                    'athena:GetDatabase',\n                    'athena:ListTableMetadata',\n                    'athena:GetTableMetadata',\n                    'athena:GetDataCatalog',\n                ],\n                resources: [`arn:aws:athena:${region}:${accountIdAlias[stageName]}:*`],\n            })\n        );\n\n        this.currentVersion.addToRolePolicy(\n            // From https://docs.aws.amazon.com/athena/latest/ug/example-policies-workgroup.html\n            new iam.PolicyStatement({\n                actions: [\n                    // Workgroup executions\n                    'athena:BatchGetQueryExecution',\n                    'athena:GetQueryExecution',\n                    'athena:ListQueryExecutions',\n                    'athena:StartQueryExecution',\n                    'athena:StopQueryExecution',\n                    'athena:GetQueryResults',\n                    'athena:GetQueryResultsStream',\n                    'athena:CreateNamedQuery',\n                    'athena:GetNamedQuery',\n                    'athena:BatchGetNamedQuery',\n                    'athena:ListNamedQueries',\n                    'athena:DeleteNamedQuery',\n                    'athena:CreatePreparedStatement',\n                    'athena:GetPreparedStatement',\n                    'athena:ListPreparedStatements',\n                    'athena:UpdatePreparedStatement',\n                    'athena:DeletePreparedStatement',\n                ],\n                resources: [\n                    `arn:aws:athena:${region}:${accountIdAlias[stageName]}:workgroup/${MART_ENV_VARS.athenaWorkgroupName}`,\n                ],\n            })\n        );\n\n        // Add read access to the S3 bucket\n        athenaS3Bucket.grantReadWrite(\n            this.currentVersion,\n            `${MART_S3_PREFIX}*`\n        )\n\n        // Add invoke access to the lambda function\n        athenaFunctionName.grantInvoke(\n            this.currentVersion\n        )\n    }\n}\n\n\n\n\n"]}