@fjall/components-infrastructure 0.11.0 → 0.12.0

package/dist/lib/resources/aws/iam/identityCenter/lambda/assignmentHandler.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const client_sso_admin_1 = require("@aws-sdk/client-sso-admin");
+const client_sts_1 = require("@aws-sdk/client-sts");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const ssoAdmin = new client_sso_admin_1.SSOAdminClient();
+const sts = new client_sts_1.STSClient();
+const s3 = new client_s3_1.S3Client();
+// Helper function to add delay
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+// Function to send response to CloudFormation
+const sendResponse = async (event, response) => {
+    console.info("Sending CloudFormation response:");
+    console.info(`Status: ${response.Status}`);
+    console.info(`PhysicalResourceId: ${response.PhysicalResourceId}`);
+    if (response.Reason) {
+        console.info(`Reason: ${response.Reason}`);
+    }
+    const responseBody = JSON.stringify(response);
+    console.info(`Sending response to: ${event.ResponseURL}`);
+    try {
+        // Extract bucket and key from the pre-signed URL
+        const url = new URL(event.ResponseURL);
+        const bucketName = url.hostname.split(".")[0];
+        const key = url.pathname.substring(1); // remove leading slash
+        // Use S3 client to upload directly
+        await s3.send(new client_s3_1.PutObjectCommand({
+            Bucket: bucketName,
+            Key: key,
+            Body: responseBody,
+            ContentType: "application/json"
+        }));
+        console.info(`Status code: 200`);
+        console.info(`Status message: OK`);
+    }
+    catch (error) {
+        console.error("Error sending response:", error);
+        throw error;
+    }
+};
+// Function to check if an assignment exists
+const verifyAssignmentExists = async (instanceArn, permissionSetArn, targetId, principalId, principalType, retries = 10, delay = 5000) => {
+    for (let attempt = 1; attempt <= retries; attempt++) {
+        try {
+            console.info(`Verifying assignment exists - attempt ${attempt}/${retries}`);
+            const listResponse = await ssoAdmin.send(new client_sso_admin_1.ListAccountAssignmentsCommand({
+                InstanceArn: instanceArn,
+                AccountId: targetId,
+                PermissionSetArn: permissionSetArn
+            }));
+            const assignments = listResponse.AccountAssignments || [];
+            console.info(`Found ${assignments.length} assignments for account ${targetId} and permission set`);
+            const exists = assignments.some((assignment) => assignment.PrincipalId === principalId &&
+                assignment.PrincipalType === principalType);
+            if (exists) {
+                console.info("Assignment exists");
+                return true;
+            }
+            if (attempt < retries) {
+                console.info(`Assignment not found, waiting ${delay / 1000} seconds before retrying...`);
+                await sleep(delay);
+            }
+        }
+        catch (error) {
+            console.error(`Error verifying assignment (attempt ${attempt}/${retries}):`, error);
+            if (attempt < retries) {
+                console.info(`Waiting ${delay / 1000} seconds before retrying...`);
+                await sleep(delay);
+            }
+        }
+    }
+    console.info("Assignment not found after maximum retries");
+    return false;
+};
+// Handle CloudFormation custom resource event
+const handler = async (event) => {
+    console.info("Received event: ", JSON.stringify(event, null, 2));
+    // Log environment variables (without sensitive data)
+    console.info("Environment variables: " +
+        JSON.stringify({
+            AWS_REGION: process.env.AWS_REGION,
+            AWS_EXECUTION_ENV: process.env.AWS_EXECUTION_ENV,
+            AWS_LAMBDA_FUNCTION_NAME: process.env.AWS_LAMBDA_FUNCTION_NAME,
+            AWS_LAMBDA_FUNCTION_VERSION: process.env.AWS_LAMBDA_FUNCTION_VERSION,
+            AWS_LAMBDA_FUNCTION_MEMORY_SIZE: process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE
+        }));
+    // Get current identity for debugging purposes
+    try {
+        const identity = await sts.send(new client_sts_1.GetCallerIdentityCommand({}));
+        console.info("Current identity: ", JSON.stringify(identity, null, 2));
+    }
+    catch (error) {
+        console.error("Error getting caller identity:", error);
+    }
+    const { InstanceArn: instanceArn, PermissionSetArn: permissionSetArn, PrincipalType: principalTypeStr, PrincipalId: principalId, TargetType: targetTypeStr, TargetId: targetId } = event.ResourceProperties;
+    // Convert string types to enum types
+    const principalType = principalTypeStr;
+    const targetType = targetTypeStr;
+    // Generate a consistent physical ID regardless of whether the assignment exists
+    const physicalResourceId = event.PhysicalResourceId ||
+        `${permissionSetArn}-${principalId}-${targetId}`;
+    // Prepare the response
+    const response = {
+        Status: "SUCCESS",
+        PhysicalResourceId: physicalResourceId,
+        StackId: event.StackId,
+        RequestId: event.RequestId,
+        LogicalResourceId: event.LogicalResourceId
+    };
+    const MAX_RETRIES = 5;
+    try {
+        switch (event.RequestType) {
+            case "Create":
+            case "Update":
+                const operation = event.RequestType === "Create" ? "Creating" : "Updating";
+                // Check if assignment already exists for updates to avoid errors
+                if (event.RequestType === "Update") {
+                    const exists = await verifyAssignmentExists(instanceArn, permissionSetArn, targetId, principalId, principalTypeStr);
+                    if (exists) {
+                        console.info("Assignment already exists for update operation - no action needed");
+                        await sendResponse(event, response);
+                        return response;
+                    }
+                }
+                // Create the assignment
+                for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+                    console.info(`Attempt ${attempt}/${MAX_RETRIES}`);
+                    console.info(`${operation} Account Assignment`);
+                    try {
+                        await ssoAdmin.send(new client_sso_admin_1.CreateAccountAssignmentCommand({
+                            InstanceArn: instanceArn,
+                            PermissionSetArn: permissionSetArn,
+                            PrincipalType: principalType,
+                            PrincipalId: principalId,
+                            TargetType: targetType,
+                            TargetId: targetId
+                        }));
+                        console.info("Create assignment command sent successfully");
+                        console.info("Verifying assignment exists");
+                        // Verify the assignment was created
+                        const exists = await verifyAssignmentExists(instanceArn, permissionSetArn, targetId, principalId, principalTypeStr);
+                        if (exists) {
+                            console.info("Assignment verified successfully");
+                            await sendResponse(event, response);
+                            return response;
+                        }
+                        else {
+                            throw new Error("Assignment verification failed: Assignment not found after creation");
+                        }
+                    }
+                    catch (error) {
+                        console.error(`Error in attempt ${attempt}:`, error);
+                        // If it's the last attempt, propagate the error
+                        if (attempt === MAX_RETRIES) {
+                            throw error;
+                        }
+                        // If it's a ConflictException or the assignment already exists, consider it a success
+                        if (error.name === "ConflictException" ||
+                            error.message.includes("already exists") ||
+                            (await verifyAssignmentExists(instanceArn, permissionSetArn, targetId, principalId, principalTypeStr))) {
+                            console.info("Assignment already exists or was created successfully");
+                            await sendResponse(event, response);
+                            return response;
+                        }
+                        // Otherwise, wait and retry
+                        await sleep(2000 * attempt); // Exponential backoff
+                    }
+                }
+                break;
+            case "Delete":
+                // Check if assignment exists before attempting deletion
+                const assignmentExists = await verifyAssignmentExists(instanceArn, permissionSetArn, targetId, principalId, principalTypeStr);
+                if (!assignmentExists) {
+                    console.info("Assignment does not exist, no need to delete");
+                    await sendResponse(event, response);
+                    return response;
+                }
+                // Delete the assignment
+                for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+                    console.info(`Attempt ${attempt}/${MAX_RETRIES}`);
+                    console.info("Deleting Account Assignment");
+                    try {
+                        await ssoAdmin.send(new client_sso_admin_1.DeleteAccountAssignmentCommand({
+                            InstanceArn: instanceArn,
+                            PermissionSetArn: permissionSetArn,
+                            PrincipalType: principalType,
+                            PrincipalId: principalId,
+                            TargetType: targetType,
+                            TargetId: targetId
+                        }));
+                        console.info("Delete assignment command sent successfully");
+                        console.info("Verifying assignment does not exist");
+                        // Here we're inverting the logic - wait for the assignment to NOT exist
+                        const stillExists = await verifyAssignmentExists(instanceArn, permissionSetArn, targetId, principalId, principalTypeStr);
+                        if (!stillExists) {
+                            console.info("Assignment deleted successfully");
+                            await sendResponse(event, response);
+                            return response;
+                        }
+                        else {
+                            // On the final attempt, consider it an error if it still exists
+                            if (attempt === MAX_RETRIES) {
+                                throw new Error("Assignment verification failed: Assignment still exists after deletion");
+                            }
+                            // Otherwise, wait and retry the verification
+                            console.info(`Assignment still exists after deletion attempt ${attempt}, waiting...`);
+                            await sleep(3000);
+                        }
+                    }
+                    catch (error) {
+                        console.error(`Error in delete attempt ${attempt}:`, error);
+                        // If it's a ResourceNotFoundException, consider it a success
+                        if (error.name === "ResourceNotFoundException" ||
+                            error.message.includes("does not exist")) {
+                            console.info("Assignment does not exist or was already deleted");
+                            await sendResponse(event, response);
+                            return response;
+                        }
+                        // On the last attempt, propagate the error
+                        if (attempt === MAX_RETRIES) {
+                            throw error;
+                        }
+                        // Otherwise, wait and retry
+                        await sleep(2000 * attempt);
+                    }
+                }
+                break;
+        }
+    }
+    catch (error) {
+        console.error(`Operation failed: ${error.message}`, error);
+        response.Status = "FAILED";
+        response.Reason = `${event.RequestType} operation failed: ${error.message}`;
+        try {
+            await sendResponse(event, response);
+        }
+        catch (responseError) {
+            console.error("Failed to send response to CloudFormation:", responseError);
+        }
+        throw error;
+    }
+    return response;
+};
+exports.handler = handler;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assignmentHandler.js","sourceRoot":"","sources":["../../../../../../../lib/resources/aws/iam/identityCenter/lambda/assignmentHandler.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  SSOAdminClient,\n  CreateAccountAssignmentCommand,\n  DeleteAccountAssignmentCommand,\n  ListAccountAssignmentsCommand,\n  AccountAssignment,\n  PrincipalType,\n  TargetType\n} from \"@aws-sdk/client-sso-admin\";\nimport { STSClient, GetCallerIdentityCommand } from \"@aws-sdk/client-sts\";\nimport { PutObjectCommand, S3Client } from \"@aws-sdk/client-s3\";\n\ninterface CloudFormationEvent {\n  RequestType: \"Create\" | \"Update\" | \"Delete\";\n  ResponseURL: string;\n  StackId: string;\n  RequestId: string;\n  ResourceType: string;\n  LogicalResourceId: string;\n  PhysicalResourceId?: string;\n  ResourceProperties: {\n    ServiceToken: string;\n    InstanceArn: string;\n    PermissionSetArn: string;\n    PrincipalType: string;\n    PrincipalId: string;\n    TargetType: string;\n    TargetId: string;\n    [key: string]: any;\n  };\n  OldResourceProperties?: {\n    [key: string]: any;\n  };\n}\n\ninterface CloudFormationResponse {\n  Status: \"SUCCESS\" | \"FAILED\";\n  PhysicalResourceId: string;\n  StackId: string;\n  RequestId: string;\n  LogicalResourceId: string;\n  Reason?: string;\n  Data?: {\n    [key: string]: any;\n  };\n}\n\nconst ssoAdmin = new SSOAdminClient();\nconst sts = new STSClient();\nconst s3 = new S3Client();\n\n// Helper function to add delay\nconst sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));\n\n// Function to send response to CloudFormation\nconst sendResponse = async (\n  event: CloudFormationEvent,\n  response: CloudFormationResponse\n): Promise<void> => {\n  console.info(\"Sending CloudFormation response:\");\n  console.info(`Status: ${response.Status}`);\n  console.info(`PhysicalResourceId: ${response.PhysicalResourceId}`);\n  if (response.Reason) {\n    console.info(`Reason: ${response.Reason}`);\n  }\n\n  const responseBody = JSON.stringify(response);\n  console.info(`Sending response to: ${event.ResponseURL}`);\n\n  try {\n    // Extract bucket and key from the pre-signed URL\n    const url = new URL(event.ResponseURL);\n    const bucketName = url.hostname.split(\".\")[0];\n    const key = url.pathname.substring(1); // remove leading slash\n\n    // Use S3 client to upload directly\n    await s3.send(\n      new PutObjectCommand({\n        Bucket: bucketName,\n        Key: key,\n        Body: responseBody,\n        ContentType: \"application/json\"\n      })\n    );\n\n    console.info(`Status code: 200`);\n    console.info(`Status message: OK`);\n  } catch (error) {\n    console.error(\"Error sending response:\", error);\n    throw error;\n  }\n};\n\n// Function to check if an assignment exists\nconst verifyAssignmentExists = async (\n  instanceArn: string,\n  permissionSetArn: string,\n  targetId: string,\n  principalId: string,\n  principalType: string,\n  retries = 10,\n  delay = 5000\n): Promise<boolean> => {\n  for (let attempt = 1; attempt <= retries; attempt++) {\n    try {\n      console.info(\n        `Verifying assignment exists - attempt ${attempt}/${retries}`\n      );\n\n      const listResponse = await ssoAdmin.send(\n        new ListAccountAssignmentsCommand({\n          InstanceArn: instanceArn,\n          AccountId: targetId,\n          PermissionSetArn: permissionSetArn\n        })\n      );\n\n      const assignments = listResponse.AccountAssignments || [];\n\n      console.info(\n        `Found ${assignments.length} assignments for account ${targetId} and permission set`\n      );\n\n      const exists = assignments.some(\n        (assignment: AccountAssignment) =>\n          assignment.PrincipalId === principalId &&\n          assignment.PrincipalType === (principalType as PrincipalType)\n      );\n\n      if (exists) {\n        console.info(\"Assignment exists\");\n        return true;\n      }\n\n      if (attempt < retries) {\n        console.info(\n          `Assignment not found, waiting ${\n            delay / 1000\n          } seconds before retrying...`\n        );\n        await sleep(delay);\n      }\n    } catch (error: any) {\n      console.error(\n        `Error verifying assignment (attempt ${attempt}/${retries}):`,\n        error\n      );\n\n      if (attempt < retries) {\n        console.info(`Waiting ${delay / 1000} seconds before retrying...`);\n        await sleep(delay);\n      }\n    }\n  }\n\n  console.info(\"Assignment not found after maximum retries\");\n  return false;\n};\n\n// Handle CloudFormation custom resource event\nexport const handler = async (event: CloudFormationEvent): Promise<any> => {\n  console.info(\"Received event: \", JSON.stringify(event, null, 2));\n\n  // Log environment variables (without sensitive data)\n  console.info(\n    \"Environment variables: \" +\n      JSON.stringify({\n        AWS_REGION: process.env.AWS_REGION,\n        AWS_EXECUTION_ENV: process.env.AWS_EXECUTION_ENV,\n        AWS_LAMBDA_FUNCTION_NAME: process.env.AWS_LAMBDA_FUNCTION_NAME,\n        AWS_LAMBDA_FUNCTION_VERSION: process.env.AWS_LAMBDA_FUNCTION_VERSION,\n        AWS_LAMBDA_FUNCTION_MEMORY_SIZE:\n          process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE\n      })\n  );\n\n  // Get current identity for debugging purposes\n  try {\n    const identity = await sts.send(new GetCallerIdentityCommand({}));\n    console.info(\"Current identity: \", JSON.stringify(identity, null, 2));\n  } catch (error) {\n    console.error(\"Error getting caller identity:\", error);\n  }\n\n  const {\n    InstanceArn: instanceArn,\n    PermissionSetArn: permissionSetArn,\n    PrincipalType: principalTypeStr,\n    PrincipalId: principalId,\n    TargetType: targetTypeStr,\n    TargetId: targetId\n  } = event.ResourceProperties;\n\n  // Convert string types to enum types\n  const principalType = principalTypeStr as PrincipalType;\n  const targetType = targetTypeStr as TargetType;\n\n  // Generate a consistent physical ID regardless of whether the assignment exists\n  const physicalResourceId =\n    event.PhysicalResourceId ||\n    `${permissionSetArn}-${principalId}-${targetId}`;\n\n  // Prepare the response\n  const response: CloudFormationResponse = {\n    Status: \"SUCCESS\",\n    PhysicalResourceId: physicalResourceId,\n    StackId: event.StackId,\n    RequestId: event.RequestId,\n    LogicalResourceId: event.LogicalResourceId\n  };\n\n  const MAX_RETRIES = 5;\n\n  try {\n    switch (event.RequestType) {\n      case \"Create\":\n      case \"Update\":\n        const operation =\n          event.RequestType === \"Create\" ? \"Creating\" : \"Updating\";\n\n        // Check if assignment already exists for updates to avoid errors\n        if (event.RequestType === \"Update\") {\n          const exists = await verifyAssignmentExists(\n            instanceArn,\n            permissionSetArn,\n            targetId,\n            principalId,\n            principalTypeStr\n          );\n\n          if (exists) {\n            console.info(\n              \"Assignment already exists for update operation - no action needed\"\n            );\n            await sendResponse(event, response);\n            return response;\n          }\n        }\n\n        // Create the assignment\n        for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {\n          console.info(`Attempt ${attempt}/${MAX_RETRIES}`);\n          console.info(`${operation} Account Assignment`);\n\n          try {\n            await ssoAdmin.send(\n              new CreateAccountAssignmentCommand({\n                InstanceArn: instanceArn,\n                PermissionSetArn: permissionSetArn,\n                PrincipalType: principalType,\n                PrincipalId: principalId,\n                TargetType: targetType,\n                TargetId: targetId\n              })\n            );\n\n            console.info(\"Create assignment command sent successfully\");\n            console.info(\"Verifying assignment exists\");\n\n            // Verify the assignment was created\n            const exists = await verifyAssignmentExists(\n              instanceArn,\n              permissionSetArn,\n              targetId,\n              principalId,\n              principalTypeStr\n            );\n\n            if (exists) {\n              console.info(\"Assignment verified successfully\");\n              await sendResponse(event, response);\n              return response;\n            } else {\n              throw new Error(\n                \"Assignment verification failed: Assignment not found after creation\"\n              );\n            }\n          } catch (error: any) {\n            console.error(`Error in attempt ${attempt}:`, error);\n\n            // If it's the last attempt, propagate the error\n            if (attempt === MAX_RETRIES) {\n              throw error;\n            }\n\n            // If it's a ConflictException or the assignment already exists, consider it a success\n            if (\n              error.name === \"ConflictException\" ||\n              error.message.includes(\"already exists\") ||\n              (await verifyAssignmentExists(\n                instanceArn,\n                permissionSetArn,\n                targetId,\n                principalId,\n                principalTypeStr\n              ))\n            ) {\n              console.info(\n                \"Assignment already exists or was created successfully\"\n              );\n              await sendResponse(event, response);\n              return response;\n            }\n\n            // Otherwise, wait and retry\n            await sleep(2000 * attempt); // Exponential backoff\n          }\n        }\n\n        break;\n\n      case \"Delete\":\n        // Check if assignment exists before attempting deletion\n        const assignmentExists = await verifyAssignmentExists(\n          instanceArn,\n          permissionSetArn,\n          targetId,\n          principalId,\n          principalTypeStr\n        );\n\n        if (!assignmentExists) {\n          console.info(\"Assignment does not exist, no need to delete\");\n          await sendResponse(event, response);\n          return response;\n        }\n\n        // Delete the assignment\n        for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {\n          console.info(`Attempt ${attempt}/${MAX_RETRIES}`);\n          console.info(\"Deleting Account Assignment\");\n\n          try {\n            await ssoAdmin.send(\n              new DeleteAccountAssignmentCommand({\n                InstanceArn: instanceArn,\n                PermissionSetArn: permissionSetArn,\n                PrincipalType: principalType,\n                PrincipalId: principalId,\n                TargetType: targetType,\n                TargetId: targetId\n              })\n            );\n\n            console.info(\"Delete assignment command sent successfully\");\n            console.info(\"Verifying assignment does not exist\");\n\n            // Here we're inverting the logic - wait for the assignment to NOT exist\n            const stillExists = await verifyAssignmentExists(\n              instanceArn,\n              permissionSetArn,\n              targetId,\n              principalId,\n              principalTypeStr\n            );\n\n            if (!stillExists) {\n              console.info(\"Assignment deleted successfully\");\n              await sendResponse(event, response);\n              return response;\n            } else {\n              // On the final attempt, consider it an error if it still exists\n              if (attempt === MAX_RETRIES) {\n                throw new Error(\n                  \"Assignment verification failed: Assignment still exists after deletion\"\n                );\n              }\n\n              // Otherwise, wait and retry the verification\n              console.info(\n                `Assignment still exists after deletion attempt ${attempt}, waiting...`\n              );\n              await sleep(3000);\n            }\n          } catch (error: any) {\n            console.error(`Error in delete attempt ${attempt}:`, error);\n\n            // If it's a ResourceNotFoundException, consider it a success\n            if (\n              error.name === \"ResourceNotFoundException\" ||\n              error.message.includes(\"does not exist\")\n            ) {\n              console.info(\"Assignment does not exist or was already deleted\");\n              await sendResponse(event, response);\n              return response;\n            }\n\n            // On the last attempt, propagate the error\n            if (attempt === MAX_RETRIES) {\n              throw error;\n            }\n\n            // Otherwise, wait and retry\n            await sleep(2000 * attempt);\n          }\n        }\n\n        break;\n    }\n  } catch (error: any) {\n    console.error(`Operation failed: ${error.message}`, error);\n    response.Status = \"FAILED\";\n    response.Reason = `${event.RequestType} operation failed: ${error.message}`;\n\n    try {\n      await sendResponse(event, response);\n    } catch (responseError) {\n      console.error(\n        \"Failed to send response to CloudFormation:\",\n        responseError\n      );\n    }\n\n    throw error;\n  }\n\n  return response;\n};\n"]}

package/dist/lib/utils/getAsync.js

@@ -7,9 +7,7 @@ const fs = require("fs");
  */
 class Accounts {
     constructor(region) {
-        this.configFile = "fjall/accounts-config.json";
-        // Ensure fjall directory exists
-        fs.mkdirSync("fjall", { recursive: true });
+        this.configFile = "../accounts-config.json";
         // Make API Call
         const client = new client_organizations_1.OrganizationsClient({
             region: region
@@ -34,4 +32,4 @@ class Accounts {
     }
 }
 exports.default = Accounts;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/utils/getCidr.js

@@ -3,9 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs = require("fs");
 class CidrBlock {
     constructor() {
-        this.configFile = "fjall/cidr-config.json";
-        // Ensure fjall directory exists
-        fs.mkdirSync("fjall", { recursive: true });
+        this.configFile = "../cidr-config.json";
         // Import config, or create it if it doesn't exist
         if (fs.existsSync(this.configFile)) {
             const configString = fs.readFileSync(this.configFile, "utf-8");
@@ -39,4 +37,4 @@ class CidrBlock {
     }
 }
 exports.default = CidrBlock;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0Q2lkci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi91dGlscy9nZXRDaWRyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEseUJBQXlCO0FBTXpCLE1BQXFCLFNBQVM7SUFJNUI7UUFGUSxlQUFVLEdBQUcscUJBQXFCLENBQUM7UUFHekMsa0RBQWtEO1FBQ2xELElBQUksRUFBRSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLEVBQUUsQ0FBQztZQUNuQyxNQUFNLFlBQVksR0FBRyxFQUFFLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsT0FBTyxDQUFDLENBQUM7WUFDL0QsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBQzVDLENBQUM7YUFBTSxDQUFDO1lBQ04sSUFBSSxDQUFDLFNBQVMsR0FBRyxFQUFFLENBQUM7WUFDcEIsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxJQUFJLEdBQUcsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDO2dCQUM5QixJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsR0FBRyxJQUFJLENBQUM7WUFDeEMsQ0FBQztZQUNELE1BQU0sWUFBWSxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUM7WUFDN0QsRUFBRSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLFlBQVksQ0FBQyxDQUFDO1FBQ2xELENBQUM7SUFDSCxDQUFDO0lBRUQsVUFBVTtRQUNSLG9DQUFvQztRQUNwQyxNQUFNLFlBQVksR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBQzdELEVBQUUsQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxZQUFZLENBQUMsQ0FBQztJQUNsRCxDQUFDO0lBRUQsWUFBWTtRQUNWLEtBQUssTUFBTSxHQUFHLElBQUksSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ2pDLElBQUksSUFBSSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDO2dCQUN4QixPQUFPLEdBQUcsQ0FBQztZQUNiLENBQUM7UUFDSCxDQUFDO1FBQ0QsT0FBTyxXQUFXLENBQUM7SUFDckIsQ0FBQztJQUVELFdBQVcsQ0FBQyxTQUFpQixFQUFFLE1BQWU7UUFDNUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsR0FBRyxNQUFNLENBQUM7UUFDbkMsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDO0lBQ3BCLENBQUM7Q0FDRjtBQXRDRCw0QkFzQ0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBmcyBmcm9tIFwiZnNcIjtcblxuaW50ZXJmYWNlIGNpZHJUYWJsZSB7XG4gIFtrZXk6IHN0cmluZ106IGJvb2xlYW47XG59XG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIENpZHJCbG9jayB7XG4gIHByaXZhdGUgY2lkckJsb2NrOiBjaWRyVGFibGU7XG4gIHByaXZhdGUgY29uZmlnRmlsZSA9IFwiLi4vY2lkci1jb25maWcuanNvblwiO1xuXG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIC8vIEltcG9ydCBjb25maWcsIG9yIGNyZWF0ZSBpdCBpZiBpdCBkb2Vzbid0IGV4aXN0XG4gICAgaWYgKGZzLmV4aXN0c1N5bmModGhpcy5jb25maWdGaWxlKSkge1xuICAgICAgY29uc3QgY29uZmlnU3RyaW5nID0gZnMucmVhZEZpbGVTeW5jKHRoaXMuY29uZmlnRmlsZSwgXCJ1dGYtOFwiKTtcbiAgICAgIHRoaXMuY2lkckJsb2NrID0gSlNPTi5wYXJzZShjb25maWdTdHJpbmcpO1xuICAgIH0gZWxzZSB7XG4gICAgICB0aGlzLmNpZHJCbG9jayA9IHt9O1xuICAgICAgZm9yIChsZXQgaSA9IDE7IGkgPD0gMjU1OyBpKyspIHtcbiAgICAgICAgdGhpcy5jaWRyQmxvY2tbYCR7aX0uMC4wLjAvOGBdID0gdHJ1ZTtcbiAgICAgIH1cbiAgICAgIGNvbnN0IGNvbmZpZ1N0cmluZyA9IEpTT04uc3RyaW5naWZ5KHRoaXMuY2lkckJsb2NrLCBudWxsLCAyKTtcbiAgICAgIGZzLndyaXRlRmlsZVN5bmModGhpcy5jb25maWdGaWxlLCBjb25maWdTdHJpbmcpO1xuICAgIH1cbiAgfVxuXG4gIHdyaXRlU3RhdGUoKSB7XG4gICAgLy8gSlNPTi1pZnkgY29uZmlnIGFuZCB3cml0ZSB0byBmaWxlXG4gICAgY29uc3QgY29uZmlnU3RyaW5nID0gSlNPTi5zdHJpbmdpZnkodGhpcy5jaWRyQmxvY2ssIG51bGwsIDIpO1xuICAgIGZzLndyaXRlRmlsZVN5bmModGhpcy5jb25maWdGaWxlLCBjb25maWdTdHJpbmcpO1xuICB9XG5cbiAgZ2V0Q2lkckJsb2NrKCkge1xuICAgIGZvciAoY29uc3Qga2V5IGluIHRoaXMuY2lkckJsb2NrKSB7XG4gICAgICBpZiAodGhpcy5jaWRyQmxvY2tba2V5XSkge1xuICAgICAgICByZXR1cm4ga2V5O1xuICAgICAgfVxuICAgIH1cbiAgICByZXR1cm4gXCIwLjAuMC4wLzhcIjtcbiAgfVxuXG4gIHVwZGF0ZVN0YXRlKGNpZHJCbG9jazogc3RyaW5nLCBzdGF0dXM6IGJvb2xlYW4pIHtcbiAgICB0aGlzLmNpZHJCbG9ja1tjaWRyQmxvY2tdID0gc3RhdHVzO1xuICAgIHRoaXMud3JpdGVTdGF0ZSgpO1xuICB9XG59XG4iXX0=

package/dist/lib/utils/getConfig.js

@@ -7,7 +7,7 @@ function getConfig(accountName) {
     const app = app_1.default.getInstance();
     const config = {
         region: process.env.AWS_REGION || "us-east-1",
-        environment: "development",
+        environment: "unknown",
         existingAccounts: [],
         costAllocationTags: []
     };
@@ -47,4 +47,4 @@ function getConfig(accountName) {
     return config;
 }
 exports.default = getConfig;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fjall/components-infrastructure",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "bin": {
     "infrastructure": "bin/infrastructure.js"
   },
@@ -35,7 +35,7 @@
   "dependencies": {
     "@aws-sdk/client-cost-explorer": "^3.717.0",
     "@aws-sdk/client-organizations": "^3.716.0",
-    "@fjall/util": "^0.11.0",
+    "@fjall/util": "^0.12.0",
     "@pepperize/cdk-organizations": "^0.7.135",
     "aws-cdk": "^2.146.0",
     "aws-cdk-lib": "^2.146.0",
@@ -48,5 +48,5 @@
   "overrides": {
     "@smithy/core": "2.5.5"
   },
-  "gitHead": "7ab5e1dc2ea5a86282e60d1515264bb67c7d7659"
+  "gitHead": "117b6649a358c71c4fce68b9a8e3d73027dd3d45"
 }

package/dist/lib/patterns/aws/ec2.d.ts

@@ -1,43 +0,0 @@
-import { BlockDevice, IMachineImage, IVpc, SubnetType, UserData, SecurityGroup, IConnectable, Connections } from "aws-cdk-lib/aws-ec2";
-import { Construct } from "constructs";
-import { StackProps } from "aws-cdk-lib";
-import { Role } from "aws-cdk-lib/aws-iam";
-import { KeyValue } from "../../types";
-interface ExistingVpcConfig {
-    vpcId?: string;
-    subnetType?: SubnetType;
-}
-interface NewVpcConfig {
-    subnetType: SubnetType;
-}
-export type VpcProps = ExistingVpcConfig | NewVpcConfig;
-interface Ec2InstanceProps extends StackProps {
-    spotCapacityPercentage?: number;
-    blockDevices?: BlockDevice[];
-    accountId?: string;
-    serviceName: string;
-    vpc: VpcProps;
-    minCapcity?: number;
-    maxCapacity?: number;
-    instanceType: string;
-    machineImage?: IMachineImage;
-    userData?: UserData;
-    role?: Role;
-    enableSSH?: boolean;
-    tags: KeyValue;
-}
-export declare class Ec2Instance extends Construct implements IConnectable {
-    private launchTemplate;
-    vpc: IVpc;
-    asgSecurityGroup: SecurityGroup;
-    private autoScalingGroup;
-    private keyPair;
-    constructor(scope: Construct, id: string, props: Ec2InstanceProps);
-    connections: Connections;
-    addVpc(props: Ec2InstanceProps): void;
-    addKeyPair(props: Ec2InstanceProps): void;
-    addLaunchTemplate(props: Ec2InstanceProps): void;
-    addAutoScalingGroup(props: Ec2InstanceProps): void;
-    suspendAutoScaling(): void;
-}
-export {};

package/dist/lib/patterns/aws/ec2.js

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Ec2Instance = void 0;
-const aws_ec2_1 = require("aws-cdk-lib/aws-ec2");
-const constructs_1 = require("constructs");
-const aws_cdk_lib_1 = require("aws-cdk-lib");
-const tagResource_1 = require("../../utils/tagResource");
-const aws_autoscaling_1 = require("aws-cdk-lib/aws-autoscaling");
-const awsCustomResource_1 = require("../../resources/aws/utilities/awsCustomResource");
-const custom_resources_1 = require("aws-cdk-lib/custom-resources");
-const vpc_1 = require("../../resources/aws/networking/vpc");
-class Ec2Instance extends constructs_1.Construct {
-    constructor(scope, id, props) {
-        super(scope, id);
-        this.addVpc(props);
-        if (props.enableSSH) {
-            this.addKeyPair(props);
-        }
-        this.addLaunchTemplate(props);
-        this.addAutoScalingGroup(props);
-        this.suspendAutoScaling();
-        //TODO: Add load balancer as boolean prop, then configure load balancer
-    }
-    addVpc(props) {
-        if ("vpcId" in props.vpc) {
-            this.vpc = vpc_1.Vpc.fromLookup(this, `${props.serviceName}Vpc`, {
-                vpcId: props.vpc.vpcId
-            });
-        }
-        else {
-            this.vpc = new vpc_1.Vpc(this, `${props.serviceName}Vpc`, {
-                accountId: props.accountId,
-                tags: props.tags,
-                subnetConfiguration: [
-                    {
-                        name: `${props.serviceName}`,
-                        subnetType: props.vpc.subnetType || aws_ec2_1.SubnetType.PRIVATE_WITH_EGRESS
-                    }
-                ]
-            });
-        }
-    }
-    addKeyPair(props) {
-        // TODO: Breakout into a seperate construct for use with better prop handling
-        this.keyPair = new aws_ec2_1.KeyPair(this, "KeyPair", {
-            keyPairName: `${props.serviceName}KeyPair`
-        });
-    }
-    addLaunchTemplate(props) {
-        this.asgSecurityGroup = new aws_ec2_1.SecurityGroup(this, `AsgSecurityGroup`, {
-            vpc: this.vpc,
-            description: `Security group for the ${props.serviceName} auto scaling group`
-        });
-        if (props.enableSSH) {
-            this.asgSecurityGroup.addIngressRule(aws_ec2_1.Peer.anyIpv4(), aws_ec2_1.Port.tcp(22), "Allow SSH");
-        }
-        this.launchTemplate = new aws_ec2_1.LaunchTemplate(this, "LaunchTemplate", {
-            launchTemplateName: `${props.serviceName}LaunchTemplate`,
-            instanceType: new aws_ec2_1.InstanceType(`${props.instanceType}`),
-            machineImage: props.machineImage || aws_ec2_1.MachineImage.latestAmazonLinux2(),
-            userData: props.userData,
-            role: props.role,
-            blockDevices: props?.blockDevices,
-            securityGroup: this.asgSecurityGroup,
-            detailedMonitoring: true,
-            requireImdsv2: true,
-            httpPutResponseHopLimit: 2,
-            httpTokens: aws_ec2_1.LaunchTemplateHttpTokens.REQUIRED,
-            instanceMetadataTags: true,
-            keyPair: this.keyPair
-        });
-    }
-    addAutoScalingGroup(props) {
-        // TODO: Support spot instances
-        // TODO: Handle terminating EC2 instances when updating, currently hangs.
-        this.autoScalingGroup = new aws_autoscaling_1.AutoScalingGroup(this, "AutoScalingGroup", {
-            vpc: this.vpc,
-            vpcSubnets: {
-                subnetType: props.enableSSH ? aws_ec2_1.SubnetType.PUBLIC : undefined
-            },
-            minCapacity: props.minCapcity,
-            maxCapacity: props.maxCapacity,
-            launchTemplate: this.launchTemplate,
-            cooldown: aws_cdk_lib_1.Duration.seconds(60),
-            groupMetrics: [aws_autoscaling_1.GroupMetrics.all()],
-            updatePolicy: aws_autoscaling_1.UpdatePolicy.replacingUpdate(),
-            newInstancesProtectedFromScaleIn: true,
-            // securityGroup: this.asgSecurityGroup,
-            terminationPolicies: [
-                aws_autoscaling_1.TerminationPolicy.OLDEST_LAUNCH_CONFIGURATION,
-                aws_autoscaling_1.TerminationPolicy.CLOSEST_TO_NEXT_INSTANCE_HOUR
-            ],
-            ssmSessionPermissions: true
-        });
-        (0, tagResource_1.default)(this.autoScalingGroup, props.tags);
-    }
-    suspendAutoScaling() {
-        new awsCustomResource_1.AwsCustomResource(this, "SuspendAutoscaling", {
-            functionName: "suspendAutoScaling",
-            onCreate: {
-                service: "AutoScaling",
-                action: "suspendProcesses",
-                parameters: {
-                    AutoScalingGroupName: this.autoScalingGroup.autoScalingGroupName,
-                    ScalingProcesses: ["AZRebalance"]
-                },
-                physicalResourceId: custom_resources_1.PhysicalResourceId.of("suspendAutoScaling")
-            },
-            onUpdate: {
-                service: "AutoScaling",
-                action: "suspendProcesses",
-                parameters: {
-                    AutoScalingGroupName: this.autoScalingGroup.autoScalingGroupName,
-                    ScalingProcesses: ["AZRebalance"]
-                },
-                physicalResourceId: custom_resources_1.PhysicalResourceId.of("suspendAutoScaling")
-            },
-            resourceType: "Custom::suspendAutoscaling"
-        });
-    }
-}
-exports.Ec2Instance = Ec2Instance;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ec2.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/ec2.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BlockDevice,\n  IMachineImage,\n  InstanceType,\n  IVpc,\n  LaunchTemplate,\n  SubnetType,\n  UserData,\n  MachineImage,\n  LaunchTemplateHttpTokens,\n  KeyPair,\n  IKeyPair,\n  SecurityGroup,\n  Peer,\n  Port,\n  IConnectable,\n  Connections\n} from \"aws-cdk-lib/aws-ec2\";\nimport { Construct } from \"constructs\";\nimport { Duration, StackProps } from \"aws-cdk-lib\";\nimport tagResource from \"../../utils/tagResource\";\nimport { Role } from \"aws-cdk-lib/aws-iam\";\nimport {\n  AutoScalingGroup,\n  GroupMetrics,\n  TerminationPolicy,\n  UpdatePolicy\n} from \"aws-cdk-lib/aws-autoscaling\";\nimport { KeyValue } from \"../../types\";\nimport { AwsCustomResource } from \"../../resources/aws/utilities/awsCustomResource\";\nimport { PhysicalResourceId } from \"aws-cdk-lib/custom-resources\";\nimport { Vpc } from \"../../resources/aws/networking/vpc\";\n\ninterface ExistingVpcConfig {\n  vpcId?: string;\n  subnetType?: SubnetType;\n}\n\ninterface NewVpcConfig {\n  subnetType: SubnetType;\n}\n\nexport type VpcProps = ExistingVpcConfig | NewVpcConfig;\n\ninterface Ec2InstanceProps extends StackProps {\n  spotCapacityPercentage?: number;\n  blockDevices?: BlockDevice[];\n  accountId?: string;\n  serviceName: string;\n  vpc: VpcProps;\n  minCapcity?: number;\n  maxCapacity?: number;\n  instanceType: string;\n  machineImage?: IMachineImage;\n  userData?: UserData;\n  role?: Role;\n  enableSSH?: boolean;\n  tags: KeyValue;\n}\n\nexport class Ec2Instance extends Construct implements IConnectable {\n  private launchTemplate: LaunchTemplate;\n  public vpc: IVpc;\n  public asgSecurityGroup: SecurityGroup;\n  private autoScalingGroup: AutoScalingGroup;\n  private keyPair: IKeyPair;\n\n  constructor(scope: Construct, id: string, props: Ec2InstanceProps) {\n    super(scope, id);\n\n    this.addVpc(props);\n    if (props.enableSSH) {\n      this.addKeyPair(props);\n    }\n    this.addLaunchTemplate(props);\n    this.addAutoScalingGroup(props);\n    this.suspendAutoScaling();\n\n    //TODO: Add load balancer as boolean prop, then configure load balancer\n  }\n  connections: Connections;\n\n  addVpc(props: Ec2InstanceProps) {\n    if (\"vpcId\" in props.vpc) {\n      this.vpc = Vpc.fromLookup(this, `${props.serviceName}Vpc`, {\n        vpcId: props.vpc.vpcId\n      });\n    } else {\n      this.vpc = new Vpc(this, `${props.serviceName}Vpc`, {\n        accountId: props.accountId,\n        tags: props.tags,\n        subnetConfiguration: [\n          {\n            name: `${props.serviceName}`,\n            subnetType: props.vpc.subnetType || SubnetType.PRIVATE_WITH_EGRESS\n          }\n        ]\n      });\n    }\n  }\n\n  addKeyPair(props: Ec2InstanceProps) {\n    // TODO: Breakout into a seperate construct for use with better prop handling\n    this.keyPair = new KeyPair(this, \"KeyPair\", {\n      keyPairName: `${props.serviceName}KeyPair`\n    });\n  }\n\n  addLaunchTemplate(props: Ec2InstanceProps) {\n    this.asgSecurityGroup = new SecurityGroup(this, `AsgSecurityGroup`, {\n      vpc: this.vpc,\n      description: `Security group for the ${props.serviceName} auto scaling group`\n    });\n\n    if (props.enableSSH) {\n      this.asgSecurityGroup.addIngressRule(\n        Peer.anyIpv4(),\n        Port.tcp(22),\n        \"Allow SSH\"\n      );\n    }\n\n    this.launchTemplate = new LaunchTemplate(this, \"LaunchTemplate\", {\n      launchTemplateName: `${props.serviceName}LaunchTemplate`,\n      instanceType: new InstanceType(`${props.instanceType}`),\n      machineImage: props.machineImage || MachineImage.latestAmazonLinux2(),\n      userData: props.userData,\n      role: props.role,\n      blockDevices: props?.blockDevices,\n      securityGroup: this.asgSecurityGroup,\n      detailedMonitoring: true,\n      requireImdsv2: true,\n      httpPutResponseHopLimit: 2,\n      httpTokens: LaunchTemplateHttpTokens.REQUIRED,\n      instanceMetadataTags: true,\n      keyPair: this.keyPair\n    });\n  }\n\n  addAutoScalingGroup(props: Ec2InstanceProps) {\n    // TODO: Support spot instances\n    // TODO: Handle terminating EC2 instances when updating, currently hangs.\n    this.autoScalingGroup = new AutoScalingGroup(this, \"AutoScalingGroup\", {\n      vpc: this.vpc,\n      vpcSubnets: {\n        subnetType: props.enableSSH ? SubnetType.PUBLIC : undefined\n      },\n      minCapacity: props.minCapcity,\n      maxCapacity: props.maxCapacity,\n      launchTemplate: this.launchTemplate,\n      cooldown: Duration.seconds(60),\n      groupMetrics: [GroupMetrics.all()],\n      updatePolicy: UpdatePolicy.replacingUpdate(),\n      newInstancesProtectedFromScaleIn: true,\n      // securityGroup: this.asgSecurityGroup,\n      terminationPolicies: [\n        TerminationPolicy.OLDEST_LAUNCH_CONFIGURATION,\n        TerminationPolicy.CLOSEST_TO_NEXT_INSTANCE_HOUR\n      ],\n      ssmSessionPermissions: true\n    });\n    tagResource(this.autoScalingGroup, props.tags);\n  }\n\n  suspendAutoScaling() {\n    new AwsCustomResource(this, \"SuspendAutoscaling\", {\n      functionName: \"suspendAutoScaling\",\n      onCreate: {\n        service: \"AutoScaling\",\n        action: \"suspendProcesses\",\n        parameters: {\n          AutoScalingGroupName: this.autoScalingGroup.autoScalingGroupName,\n          ScalingProcesses: [\"AZRebalance\"]\n        },\n        physicalResourceId: PhysicalResourceId.of(\"suspendAutoScaling\")\n      },\n      onUpdate: {\n        service: \"AutoScaling\",\n        action: \"suspendProcesses\",\n        parameters: {\n          AutoScalingGroupName: this.autoScalingGroup.autoScalingGroupName,\n          ScalingProcesses: [\"AZRebalance\"]\n        },\n        physicalResourceId: PhysicalResourceId.of(\"suspendAutoScaling\")\n      },\n      resourceType: \"Custom::suspendAutoscaling\"\n    });\n  }\n}\n"]}