@pwrdrvr/microapps-cdk 0.3.4 → 0.3.5-alpha.2

package/lib/MicroAppsSvcs.js

@@ -59,73 +59,6 @@ class MicroAppsSvcs extends constructs_1.Construct {
             this._table = props.table;
         }
         //
-        // Router Lambda Function
-        //
-        // Create Router Lambda Function
-        const routerFuncProps = {
-            functionName: assetNameRoot ? `${assetNameRoot}-router${assetNameSuffix}` : undefined,
-            memorySize: 1769,
-            logRetention: logs.RetentionDays.ONE_MONTH,
-            runtime: lambda.Runtime.NODEJS_16_X,
-            timeout: aws_cdk_lib_1.Duration.seconds(15),
-            environment: {
-                NODE_ENV: appEnv,
-                DATABASE_TABLE_NAME: this._table.tableName,
-                AWS_NODEJS_CONNECTION_REUSE_ENABLED: '1',
-                ROOT_PATH_PREFIX: rootPathPrefix,
-            },
-        };
-        if (process.env.NODE_ENV === 'test' &&
-            fs_1.existsSync(path.join(__dirname, '..', '..', 'microapps-router', 'dist', 'index.js'))) {
-            // This is for local dev
-            this._routerFunc = new lambda.Function(this, 'router-func', {
-                code: lambda.Code.fromAsset(path.join(__dirname, '..', '..', 'microapps-router', 'dist')),
-                handler: 'index.handler',
-                ...routerFuncProps,
-            });
-        }
-        else if (fs_1.existsSync(path.join(__dirname, 'microapps-router', 'index.js'))) {
-            // This is for built apps packaged with the CDK construct
-            this._routerFunc = new lambda.Function(this, 'router-func', {
-                code: lambda.Code.fromAsset(path.join(__dirname, 'microapps-router')),
-                handler: 'index.handler',
-                ...routerFuncProps,
-            });
-        }
-        else {
-            // Create Router Lambda Layer
-            const routerDataFiles = new lambda.LayerVersion(this, 'router-templates', {
-                code: lambda.Code.fromAsset(path.join(__dirname, '..', '..', 'microapps-router', 'templates')),
-                removalPolicy,
-            });
-            this._routerFunc = new lambdaNodejs.NodejsFunction(this, 'router-func', {
-                entry: path.join(__dirname, '..', '..', 'microapps-router', 'src', 'index.ts'),
-                handler: 'handler',
-                bundling: {
-                    minify: true,
-                    sourceMap: true,
-                },
-                layers: [routerDataFiles],
-                ...routerFuncProps,
-            });
-        }
-        if (removalPolicy !== undefined) {
-            this._routerFunc.applyRemovalPolicy(removalPolicy);
-        }
-        const policyReadTarget = new iam.PolicyStatement({
-            effect: iam.Effect.ALLOW,
-            actions: ['s3:GetObject'],
-            resources: [`${bucketApps.bucketArn}/*`],
-        });
-        for (const router of [this._routerFunc]) {
-            router.addToRolePolicy(policyReadTarget);
-            // Give the Router access to DynamoDB table
-            this._table.grantReadData(router);
-            this._table.grant(router, 'dynamodb:DescribeTable');
-        }
-        // Create alias for Router
-        const routerAlias = this._routerFunc.addAlias('CurrentVersion');
-        //
         // Deployer Lambda Function
         //
         // Create Deployer Lambda Function
@@ -388,6 +321,73 @@ class MicroAppsSvcs extends constructs_1.Construct {
         });
         this._deployerFunc.addToRolePolicy(policyAPIManageLambdas);
         if (httpApi) {
+            //
+            // Router Lambda Function
+            //
+            // Create Router Lambda Function
+            const routerFuncProps = {
+                functionName: assetNameRoot ? `${assetNameRoot}-router${assetNameSuffix}` : undefined,
+                memorySize: 1769,
+                logRetention: logs.RetentionDays.ONE_MONTH,
+                runtime: lambda.Runtime.NODEJS_16_X,
+                timeout: aws_cdk_lib_1.Duration.seconds(15),
+                environment: {
+                    NODE_ENV: appEnv,
+                    DATABASE_TABLE_NAME: this._table.tableName,
+                    AWS_NODEJS_CONNECTION_REUSE_ENABLED: '1',
+                    ROOT_PATH_PREFIX: rootPathPrefix,
+                },
+            };
+            if (process.env.NODE_ENV === 'test' &&
+                fs_1.existsSync(path.join(__dirname, '..', '..', 'microapps-router', 'dist', 'index.js'))) {
+                // This is for local dev
+                this._routerFunc = new lambda.Function(this, 'router-func', {
+                    code: lambda.Code.fromAsset(path.join(__dirname, '..', '..', 'microapps-router', 'dist')),
+                    handler: 'index.handler',
+                    ...routerFuncProps,
+                });
+            }
+            else if (fs_1.existsSync(path.join(__dirname, 'microapps-router', 'index.js'))) {
+                // This is for built apps packaged with the CDK construct
+                this._routerFunc = new lambda.Function(this, 'router-func', {
+                    code: lambda.Code.fromAsset(path.join(__dirname, 'microapps-router')),
+                    handler: 'index.handler',
+                    ...routerFuncProps,
+                });
+            }
+            else {
+                // Create Router Lambda Layer
+                const routerDataFiles = new lambda.LayerVersion(this, 'router-templates', {
+                    code: lambda.Code.fromAsset(path.join(__dirname, '..', '..', 'microapps-router', 'templates')),
+                    removalPolicy,
+                });
+                this._routerFunc = new lambdaNodejs.NodejsFunction(this, 'router-func', {
+                    entry: path.join(__dirname, '..', '..', 'microapps-router', 'src', 'index.ts'),
+                    handler: 'handler',
+                    bundling: {
+                        minify: true,
+                        sourceMap: true,
+                    },
+                    layers: [routerDataFiles],
+                    ...routerFuncProps,
+                });
+            }
+            if (removalPolicy !== undefined) {
+                this._routerFunc.applyRemovalPolicy(removalPolicy);
+            }
+            const policyReadTarget = new iam.PolicyStatement({
+                effect: iam.Effect.ALLOW,
+                actions: ['s3:GetObject'],
+                resources: [`${bucketApps.bucketArn}/*`],
+            });
+            for (const router of [this._routerFunc]) {
+                router.addToRolePolicy(policyReadTarget);
+                // Give the Router access to DynamoDB table
+                this._table.grantReadData(router);
+                this._table.grant(router, 'dynamodb:DescribeTable');
+            }
+            // Create alias for Router
+            const routerAlias = this._routerFunc.addAlias('CurrentVersion');
             // This creates an integration and a router
             const route = new apigwy.HttpRoute(this, 'route-default', {
                 httpApi,
@@ -421,5 +421,5 @@ class MicroAppsSvcs extends constructs_1.Construct {
 }
 exports.MicroAppsSvcs = MicroAppsSvcs;
 _a = JSII_RTTI_SYMBOL_1;
-MicroAppsSvcs[_a] = { fqn: "@pwrdrvr/microapps-cdk.MicroAppsSvcs", version: "0.3.4" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MicroAppsSvcs.js","sourceRoot":"","sources":["../src/MicroAppsSvcs.ts"],"names":[],"mappings":"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","sourcesContent":["import { existsSync } from 'fs';\nimport * as path from 'path';\nimport * as apigwy from '@aws-cdk/aws-apigatewayv2-alpha';\nimport * as apigwyAuth from '@aws-cdk/aws-apigatewayv2-authorizers-alpha';\nimport * as apigwyint from '@aws-cdk/aws-apigatewayv2-integrations-alpha';\nimport { Aws, Duration, PhysicalName, RemovalPolicy, Stack } from 'aws-cdk-lib';\nimport * as cf from 'aws-cdk-lib/aws-cloudfront';\nimport * as dynamodb from 'aws-cdk-lib/aws-dynamodb';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as lambdaNodejs from 'aws-cdk-lib/aws-lambda-nodejs';\nimport * as logs from 'aws-cdk-lib/aws-logs';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport { Construct } from 'constructs';\n\n/**\n * Properties to initialize an instance of `MicroAppsSvcs`.\n */\nexport interface MicroAppsSvcsProps {\n  /**\n   * RemovalPolicy override for child resources\n   *\n   * Note: if set to DESTROY the S3 buckes will have `autoDeleteObjects` set to `true`\n   *\n   * @default - per resource default\n   */\n  readonly removalPolicy?: RemovalPolicy;\n\n  /**\n   * S3 bucket for deployed applications\n   */\n  readonly bucketApps: s3.IBucket;\n\n  /**\n   * CloudFront Origin Access Identity for the deployed applications bucket\n   */\n  readonly bucketAppsOAI: cf.OriginAccessIdentity;\n\n  /**\n   * S3 bucket for staged applications (prior to deploy)\n   */\n  readonly bucketAppsStaging: s3.IBucket;\n\n  /**\n   * API Gateway v2 HTTP for Router and app\n   */\n  readonly httpApi?: apigwy.HttpApi;\n\n  /**\n   * Application environment, passed as `NODE_ENV`\n   * to the Router and Deployer Lambda functions\n   */\n  readonly appEnv: string;\n\n  /**\n   * Optional asset name root\n   *\n   * @example microapps\n   * @default - resource names auto assigned\n   */\n  readonly assetNameRoot?: string;\n\n  /**\n   * Optional asset name suffix\n   *\n   * @example -dev-pr-12\n   * @default none\n   */\n  readonly assetNameSuffix?: string;\n\n  /**\n   * Use a strict S3 Bucket Policy that prevents applications\n   * from reading/writing/modifying/deleting files in the S3 Bucket\n   * outside of the path that is specific to their app/version.\n   *\n   * This setting should be used when applications are less than\n   * fully trusted.\n   *\n   * @default false\n   */\n  readonly s3StrictBucketPolicy?: boolean;\n\n  /**\n   * Applies when using s3StrictBucketPolicy = true\n   *\n   * IAM Role or IAM User names to exclude from the DENY rules on the S3 Bucket Policy.\n   *\n   * Roles that are Assumed must instead have their AROA added to `s3PolicyBypassAROAs`.\n   *\n   * Typically any admin roles / users that need to view or manage the S3 Bucket\n   * would be added to this list.\n   *\n   * @example ['arn:aws:iam::1234567890123:role/AdminAccess', 'arn:aws:iam::1234567890123:user/MyAdminUser']\n   *\n   * @see s3PolicyBypassAROAs\n   */\n  readonly s3PolicyBypassPrincipalARNs?: string[];\n\n  /**\n   * Applies when using s3StrictBucketPolicy = true\n   *\n   * AROAs of the IAM Role to exclude from the DENY rules on the S3 Bucket Policy.\n   * This allows sessions that assume the IAM Role to be excluded from the\n   * DENY rules on the S3 Bucket Policy.\n   *\n   * Typically any admin roles / users that need to view or manage the S3 Bucket\n   * would be added to this list.\n   *\n   * Roles / users that are used directly, not assumed, can be added to `s3PolicyBypassRoleNames` instead.\n   *\n   * Note: This AROA must be specified to prevent this policy from locking\n   * out non-root sessions that have assumed the admin role.\n   *\n   * The notPrincipals will only match the role name exactly and will not match\n   * any session that has assumed the role since notPrincipals does not allow\n   * wildcard matches and does not do wildcard matches implicitly either.\n   *\n   * The AROA must be used because there are only 3 Principal variables available:\n   *  https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html#principaltable\n   *  aws:username, aws:userid, aws:PrincipalTag\n   *\n   * For an assumed role, aws:username is blank, aws:userid is:\n   *  [unique id AKA AROA for Role]:[session name]\n   *\n   * Table of unique ID prefixes such as AROA:\n   *  https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-prefixes\n   *\n   * The name of the role is simply not available for an assumed role and, if it was,\n   * a complicated comparison would be requierd to prevent exclusion\n   * of applying the Deny Rule to roles from other accounts.\n   *\n   * To get the AROA with the AWS CLI:\n   *   aws iam get-role --role-name ROLE-NAME\n   *   aws iam get-user -–user-name USER-NAME\n   *\n   * @example [ 'AROA1234567890123' ]\n   *\n   * @see s3StrictBucketPolicy\n   */\n  readonly s3PolicyBypassAROAs?: string[];\n\n  /**\n   * Path prefix on the root of the deployment\n   *\n   * @example dev/\n   * @default none\n   */\n  readonly rootPathPrefix?: string;\n\n  /**\n   * Require IAM auth on API Gateway\n   *\n   * @default true\n   */\n  readonly requireIAMAuthorization?: boolean;\n\n  /**\n   * Existing table for apps/versions/rules\n   *\n   * @warning - It is *strongly* suggested that production stacks create\n   * their own DynamoDB Table and pass it into this construct, for protection\n   * against data loss due to logical ID changes, the ability to configure\n   * Provisioned capacity with Auto Scaling, the ability to add additional indices, etc.\n   *\n   * Requirements:\n   * - Hash Key: `PK`\n   * - Sort Key: `SK`\n   *\n   * @default created by construct\n   */\n  readonly table?: dynamodb.ITable;\n}\n\n/**\n * Represents a MicroApps Services\n */\nexport interface IMicroAppsSvcs {\n  /**\n   * DynamoDB table used by Router, Deployer, and Release console app\n   */\n  readonly table: dynamodb.ITable;\n\n  /**\n   * Lambda function for the Deployer\n   */\n  readonly deployerFunc: lambda.IFunction;\n\n  /**\n   * Lambda function for the Router\n   */\n  readonly routerFunc: lambda.IFunction;\n}\n\n/**\n * Create a new MicroApps Services construct, including the Deployer\n * and Router Lambda Functions, and the DynamoDB Table used by both.\n */\nexport class MicroAppsSvcs extends Construct implements IMicroAppsSvcs {\n  private _ownedTable?: dynamodb.Table;\n  private _table: dynamodb.ITable;\n  public get table(): dynamodb.ITable {\n    return this._table;\n  }\n\n  private _deployerFunc: lambda.Function;\n  public get deployerFunc(): lambda.IFunction {\n    return this._deployerFunc;\n  }\n\n  private _routerFunc: lambda.Function;\n  public get routerFunc(): lambda.IFunction {\n    return this._routerFunc;\n  }\n\n  constructor(scope: Construct, id: string, props?: MicroAppsSvcsProps) {\n    super(scope, id);\n\n    if (props === undefined) {\n      throw new Error('props cannot be undefined');\n    }\n\n    const {\n      bucketApps,\n      bucketAppsOAI,\n      bucketAppsStaging,\n      s3PolicyBypassAROAs = [],\n      s3PolicyBypassPrincipalARNs = [],\n      s3StrictBucketPolicy = false,\n      appEnv,\n      httpApi,\n      removalPolicy,\n      assetNameRoot,\n      assetNameSuffix,\n      rootPathPrefix = '',\n      requireIAMAuthorization = true,\n    } = props;\n\n    if (s3StrictBucketPolicy === true) {\n      if (s3PolicyBypassAROAs.length === 0 && s3PolicyBypassPrincipalARNs.length === 0) {\n        throw new Error(\n          's3StrictBucketPolicy cannot be true without specifying at least one s3PolicyBypassAROAs or s3PolicyBypassPrincipalARNs',\n        );\n      }\n    }\n\n    //\n    // DynamoDB Table\n    //\n    if (props.table === undefined) {\n      // Create able if none passed\n      this._ownedTable = new dynamodb.Table(this, 'table', {\n        tableName: assetNameRoot\n          ? `${assetNameRoot}${assetNameSuffix}`\n          : PhysicalName.GENERATE_IF_NEEDED,\n        billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,\n        partitionKey: {\n          name: 'PK',\n          type: dynamodb.AttributeType.STRING,\n        },\n        sortKey: {\n          name: 'SK',\n          type: dynamodb.AttributeType.STRING,\n        },\n        removalPolicy,\n      });\n      this._table = this._ownedTable;\n    } else {\n      this._table = props.table;\n    }\n\n    //\n    // Router Lambda Function\n    //\n\n    // Create Router Lambda Function\n    const routerFuncProps: Omit<lambda.FunctionProps, 'handler' | 'code'> = {\n      functionName: assetNameRoot ? `${assetNameRoot}-router${assetNameSuffix}` : undefined,\n      memorySize: 1769,\n      logRetention: logs.RetentionDays.ONE_MONTH,\n      runtime: lambda.Runtime.NODEJS_16_X,\n      timeout: Duration.seconds(15),\n      environment: {\n        NODE_ENV: appEnv,\n        DATABASE_TABLE_NAME: this._table.tableName,\n        AWS_NODEJS_CONNECTION_REUSE_ENABLED: '1',\n        ROOT_PATH_PREFIX: rootPathPrefix,\n      },\n    };\n    if (\n      process.env.NODE_ENV === 'test' &&\n      existsSync(path.join(__dirname, '..', '..', 'microapps-router', 'dist', 'index.js'))\n    ) {\n      // This is for local dev\n      this._routerFunc = new lambda.Function(this, 'router-func', {\n        code: lambda.Code.fromAsset(path.join(__dirname, '..', '..', 'microapps-router', 'dist')),\n        handler: 'index.handler',\n        ...routerFuncProps,\n      });\n    } else if (existsSync(path.join(__dirname, 'microapps-router', 'index.js'))) {\n      // This is for built apps packaged with the CDK construct\n      this._routerFunc = new lambda.Function(this, 'router-func', {\n        code: lambda.Code.fromAsset(path.join(__dirname, 'microapps-router')),\n        handler: 'index.handler',\n        ...routerFuncProps,\n      });\n    } else {\n      // Create Router Lambda Layer\n      const routerDataFiles = new lambda.LayerVersion(this, 'router-templates', {\n        code: lambda.Code.fromAsset(\n          path.join(__dirname, '..', '..', 'microapps-router', 'templates'),\n        ),\n        removalPolicy,\n      });\n\n      this._routerFunc = new lambdaNodejs.NodejsFunction(this, 'router-func', {\n        entry: path.join(__dirname, '..', '..', 'microapps-router', 'src', 'index.ts'),\n        handler: 'handler',\n        bundling: {\n          minify: true,\n          sourceMap: true,\n        },\n        layers: [routerDataFiles],\n        ...routerFuncProps,\n      });\n    }\n    if (removalPolicy !== undefined) {\n      this._routerFunc.applyRemovalPolicy(removalPolicy);\n    }\n    const policyReadTarget = new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions: ['s3:GetObject'],\n      resources: [`${bucketApps.bucketArn}/*`],\n    });\n    for (const router of [this._routerFunc]) {\n      router.addToRolePolicy(policyReadTarget);\n      // Give the Router access to DynamoDB table\n      this._table.grantReadData(router);\n      this._table.grant(router, 'dynamodb:DescribeTable');\n    }\n    // Create alias for Router\n    const routerAlias = this._routerFunc.addAlias('CurrentVersion');\n\n    //\n    // Deployer Lambda Function\n    //\n\n    // Create Deployer Lambda Function\n    const iamRoleUploadName = assetNameRoot\n      ? `${assetNameRoot}-deployer-upload${assetNameSuffix}`\n      : undefined;\n    const deployerFuncName = assetNameRoot\n      ? `${assetNameRoot}-deployer${assetNameSuffix}`\n      : undefined;\n    const deployerFuncProps: Omit<lambda.FunctionProps, 'handler' | 'code'> = {\n      functionName: deployerFuncName,\n      memorySize: 1769,\n      logRetention: logs.RetentionDays.ONE_MONTH,\n      runtime: lambda.Runtime.NODEJS_16_X,\n      timeout: Duration.seconds(15),\n      environment: {\n        NODE_ENV: appEnv,\n        ...(httpApi ? { APIGWY_ID: httpApi.httpApiId } : {}),\n        DATABASE_TABLE_NAME: this._table.tableName,\n        FILESTORE_STAGING_BUCKET: bucketAppsStaging.bucketName,\n        FILESTORE_DEST_BUCKET: bucketApps.bucketName,\n        AWS_NODEJS_CONNECTION_REUSE_ENABLED: '1',\n        ROOT_PATH_PREFIX: rootPathPrefix,\n        REQUIRE_IAM_AUTHORIZATION: requireIAMAuthorization ? 'true' : 'false',\n      },\n    };\n    if (\n      process.env.NODE_ENV === 'test' &&\n      existsSync(path.join(__dirname, '..', '..', 'microapps-deployer', 'dist', 'index.js'))\n    ) {\n      // This is for local dev\n      this._deployerFunc = new lambda.Function(this, 'deployer-func', {\n        code: lambda.Code.fromAsset(path.join(__dirname, '..', '..', 'microapps-deployer', 'dist')),\n        handler: 'index.handler',\n        ...deployerFuncProps,\n      });\n    } else if (existsSync(path.join(__dirname, 'microapps-deployer', 'index.js'))) {\n      // This is for built apps packaged with the CDK construct\n      this._deployerFunc = new lambda.Function(this, 'deployer-func', {\n        code: lambda.Code.fromAsset(path.join(__dirname, 'microapps-deployer')),\n        handler: 'index.handler',\n        ...deployerFuncProps,\n      });\n    } else {\n      this._deployerFunc = new lambdaNodejs.NodejsFunction(this, 'deployer-func', {\n        entry: path.join(__dirname, '..', '..', 'microapps-deployer', 'src', 'index.ts'),\n        handler: 'handler',\n        bundling: {\n          minify: true,\n          sourceMap: true,\n        },\n        ...deployerFuncProps,\n      });\n    }\n    if (removalPolicy !== undefined) {\n      this._deployerFunc.applyRemovalPolicy(removalPolicy);\n    }\n    // Give the Deployer access to DynamoDB table\n    this._table.grantReadWriteData(this._deployerFunc);\n    this._table.grant(this._deployerFunc, 'dynamodb:DescribeTable');\n\n    //\n    // Deloyer upload temp role\n    // Deployer assumes this role with a limited policy to generate\n    // an STS temp token to return to microapps-publish for the upload.\n    //\n    const iamRoleUpload = new iam.Role(this, 'deployer-upload-role', {\n      roleName: iamRoleUploadName,\n      inlinePolicies: {\n        uploadPolicy: new iam.PolicyDocument({\n          statements: [\n            new iam.PolicyStatement({\n              actions: ['s3:ListBucket'],\n              resources: [bucketAppsStaging.bucketArn],\n            }),\n            new iam.PolicyStatement({\n              actions: ['s3:PutObject', 's3:GetObject', 's3:AbortMultipartUpload'],\n              resources: [`${bucketAppsStaging.bucketArn}/*`],\n            }),\n          ],\n        }),\n      },\n      assumedBy: this._deployerFunc.grantPrincipal,\n    });\n    this._deployerFunc.addEnvironment('UPLOAD_ROLE_NAME', iamRoleUpload.roleName);\n\n    //\n    // Update S3 permissions\n    //\n    // Create PrincipalARN List\n    const s3PolicyBypassArnPrincipals: iam.ArnPrincipal[] = [];\n    for (const arnPrincipal of s3PolicyBypassPrincipalARNs) {\n      s3PolicyBypassArnPrincipals.push(new iam.ArnPrincipal(arnPrincipal));\n    }\n    // Create AROA List that matches assumed sessions\n    const s3PolicyBypassAROAMatches: string[] = [];\n    for (const aroa of s3PolicyBypassAROAs) {\n      s3PolicyBypassAROAMatches.push(`${aroa}:*`);\n    }\n    // Deny apps from reading:\n    // - If they are missing the microapp-name tag\n    // - Anything outside of the folder that matches their microapp-name tag\n    const policyDenyPrefixOutsideTag = new iam.PolicyStatement({\n      sid: 'deny-prefix-outside-microapp-name-tag',\n      effect: iam.Effect.DENY,\n      actions: ['s3:*'],\n      notPrincipals: [\n        new iam.CanonicalUserPrincipal(\n          bucketAppsOAI.cloudFrontOriginAccessIdentityS3CanonicalUserId,\n        ),\n        new iam.AccountRootPrincipal(),\n        ...s3PolicyBypassArnPrincipals,\n        this._deployerFunc.grantPrincipal,\n      ],\n      notResources: [\n        `${bucketApps.bucketArn}/\\${aws:PrincipalTag/microapp-name}/*`,\n        bucketApps.bucketArn,\n      ],\n      conditions: {\n        Null: { 'aws:PrincipalTag/microapp-name': 'false' },\n        // StringNotLike: {'aws:'}\n      },\n    });\n    if (removalPolicy !== undefined) {\n      policyDenyPrefixOutsideTag.addCondition(\n        // Allows the DeletableBucket Lambda to delete items in the buckets\n        'StringNotLike',\n        { 'aws:PrincipalTag/application': `${Stack.of(this).stackName}-core*` },\n      );\n    }\n    const policyDenyMissingTag = new iam.PolicyStatement({\n      sid: 'deny-missing-microapp-name-tag',\n      effect: iam.Effect.DENY,\n      actions: ['s3:*'],\n      notPrincipals: [\n        new iam.CanonicalUserPrincipal(\n          bucketAppsOAI.cloudFrontOriginAccessIdentityS3CanonicalUserId,\n        ),\n        new iam.AccountRootPrincipal(),\n        // Exclude the Deployer Function directly\n        this._deployerFunc.grantPrincipal,\n        // 2021-12-04 - Not 100% sure that this is actually needed...\n        // Let's test this and remove if actually not necessary\n        new iam.ArnPrincipal(\n          `arn:aws:sts::${Aws.ACCOUNT_ID}:assumed-role/${this._deployerFunc.role?.roleName}/${this._deployerFunc.functionName}`,\n        ),\n        ...s3PolicyBypassArnPrincipals,\n      ],\n      resources: [`${bucketApps.bucketArn}/*`, bucketApps.bucketArn],\n      conditions: {\n        Null: { 'aws:PrincipalTag/microapp-name': 'true' },\n        // Note: This AROA must be specified to prevent this policy from locking\n        // out non-root sessions that have assumed the admin role.\n        // The notPrincipals will only match the role name exactly and will not match\n        // any session that has assumed the role since notPrincipals does not allow\n        // wildcard matches and does not do them implicitly either.\n        // The AROA must be used because there are only 3 Principal variables:\n        //  https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html#principaltable\n        //  aws:username, aws:userid, aws:PrincipalTag\n        // For an assumed role, aws:username is blank, aws:userid is:\n        //  [unique id AKA AROA for Role]:[session name]\n        // Table of unique ID prefixes such as AROA:\n        //  https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-prefixes\n        // The name of the role is simply not available and if it was\n        // we'd need to write a complicated comparison to make sure\n        // that we didn't exclude the Deny tag from roles in other accounts.\n        //\n        // To get the AROA with the AWS CLI:\n        //   aws iam get-role --role-name ROLE-NAME\n        //   aws iam get-user -–user-name USER-NAME\n        StringNotLike: { 'aws:userid': [Aws.ACCOUNT_ID, ...s3PolicyBypassAROAMatches] },\n      },\n    });\n    if (removalPolicy !== undefined) {\n      policyDenyMissingTag.addCondition(\n        // Allows the DeletableBucket Lambda to delete items in the buckets\n        'StringNotLike',\n        { 'aws:PrincipalTag/application': `${Stack.of(this).stackName}-core*` },\n      );\n    }\n    const policyCloudFrontAccess = new iam.PolicyStatement({\n      sid: 'cloudfront-oai-access',\n      effect: iam.Effect.ALLOW,\n      actions: ['s3:GetObject', 's3:ListBucket'],\n      principals: [\n        new iam.CanonicalUserPrincipal(\n          bucketAppsOAI.cloudFrontOriginAccessIdentityS3CanonicalUserId,\n        ),\n      ],\n      resources: [`${bucketApps.bucketArn}/*`, bucketApps.bucketArn],\n    });\n\n    if (bucketApps.policy === undefined) {\n      const document = new s3.BucketPolicy(this, 's3-policy', {\n        bucket: bucketApps,\n      }).document;\n      document.addStatements(policyCloudFrontAccess);\n\n      if (s3StrictBucketPolicy) {\n        document.addStatements(policyDenyPrefixOutsideTag);\n        document.addStatements(policyDenyMissingTag);\n      }\n    } else {\n      bucketApps.policy.document.addStatements(policyCloudFrontAccess);\n\n      if (s3StrictBucketPolicy) {\n        bucketApps.policy.document.addStatements(policyDenyPrefixOutsideTag);\n        bucketApps.policy.document.addStatements(policyDenyMissingTag);\n      }\n    }\n\n    // Allow the Lambda to read from the staging bucket\n    const policyReadListStaging = new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      // FIXME: Allow Deployer to delete from Staging bucket\n      actions: ['s3:DeleteObject', 's3:GetObject', 's3:ListBucket'],\n      resources: [`${bucketAppsStaging.bucketArn}/*`, bucketAppsStaging.bucketArn],\n    });\n    this._deployerFunc.addToRolePolicy(policyReadListStaging);\n\n    // Allow the Lambda to write to the target bucket and delete\n    const policyReadWriteListTarget = new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions: ['s3:DeleteObject', 's3:GetObject', 's3:PutObject', 's3:ListBucket'],\n      resources: [`${bucketApps.bucketArn}/*`, bucketApps.bucketArn],\n    });\n    this._deployerFunc.addToRolePolicy(policyReadWriteListTarget);\n\n    // Allow the deployer to get a temporary STS token\n    const policyGetSTSToken = new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions: ['sts:GetFederationToken'],\n      resources: ['*'],\n    });\n    this._deployerFunc.addToRolePolicy(policyGetSTSToken);\n\n    // Allow the deployer to assume the upload role\n    const policyAssumeUpload = new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions: ['sts:AssumeRole'],\n      resources: [iamRoleUpload.roleArn],\n    });\n    this._deployerFunc.addToRolePolicy(policyAssumeUpload);\n\n    //\n    // Give Deployer permissions to create routes and integrations\n    // on the API Gateway API.\n    //\n\n    // Grant the ability to List all APIs (we have to find it)\n    const policyAPIList = new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions: ['apigateway:GET'],\n      resources: [`arn:aws:apigateway:${Aws.REGION}::/apis`],\n    });\n    this._deployerFunc.addToRolePolicy(policyAPIList);\n\n    if (httpApi) {\n      // Grant full control over the API we created\n      const policyAPIManage = new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: ['apigateway:*'],\n        resources: [\n          `arn:aws:apigateway:${Aws.REGION}:${Aws.ACCOUNT_ID}:${httpApi.httpApiId}/*`,\n          `arn:aws:apigateway:${Aws.REGION}::/apis/${httpApi.httpApiId}/integrations/*`,\n          `arn:aws:apigateway:${Aws.REGION}::/apis/${httpApi.httpApiId}/integrations`,\n          `arn:aws:apigateway:${Aws.REGION}::/apis/${httpApi.httpApiId}/routes`,\n          `arn:aws:apigateway:${Aws.REGION}::/apis/${httpApi.httpApiId}/routes/*`,\n        ],\n      });\n      this._deployerFunc.addToRolePolicy(policyAPIManage);\n    }\n\n    // Grant full control over lambdas that indicate they are microapps\n    const policyAPIManageLambdas = new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions: ['lambda:*'],\n      resources: [\n        `arn:aws:lambda:${Aws.REGION}:${Aws.ACCOUNT_ID}:function:*`,\n        `arn:aws:lambda:${Aws.REGION}:${Aws.ACCOUNT_ID}:function:*:*`,\n      ],\n      conditions: {\n        StringEqualsIfExists: { 'aws:ResourceTag/microapp-managed': 'true' },\n      },\n    });\n    this._deployerFunc.addToRolePolicy(policyAPIManageLambdas);\n\n    if (httpApi) {\n      // This creates an integration and a router\n      const route = new apigwy.HttpRoute(this, 'route-default', {\n        httpApi,\n        routeKey: apigwy.HttpRouteKey.DEFAULT,\n        integration: new apigwyint.HttpLambdaIntegration('router-integration', routerAlias),\n        authorizer: requireIAMAuthorization ? new apigwyAuth.HttpIamAuthorizer() : undefined,\n      });\n\n      let routeArn = route.routeArn;\n      // Remove the trailing `/` on the ARN, which is not correct\n      if (routeArn.endsWith('/')) {\n        routeArn = routeArn.slice(0, routeArn.length - 1);\n      }\n\n      // Grant API Gateway permission to invoke the Lambda\n      new lambda.CfnPermission(this, 'router-invoke', {\n        action: 'lambda:InvokeFunction',\n        functionName: this._routerFunc.functionName,\n        principal: 'apigateway.amazonaws.com',\n        sourceArn: routeArn,\n      });\n    }\n  }\n}\n"]}
+MicroAppsSvcs[_a] = { fqn: "@pwrdrvr/microapps-cdk.MicroAppsSvcs", version: "0.3.5-alpha.2" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MicroAppsSvcs.js","sourceRoot":"","sources":["../src/MicroAppsSvcs.ts"],"names":[],"mappings":"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","sourcesContent":["import { existsSync } from 'fs';\nimport * as path from 'path';\nimport * as apigwy from '@aws-cdk/aws-apigatewayv2-alpha';\nimport * as apigwyAuth from '@aws-cdk/aws-apigatewayv2-authorizers-alpha';\nimport * as apigwyint from '@aws-cdk/aws-apigatewayv2-integrations-alpha';\nimport { Aws, Duration, PhysicalName, RemovalPolicy, Stack } from 'aws-cdk-lib';\nimport * as cf from 'aws-cdk-lib/aws-cloudfront';\nimport * as dynamodb from 'aws-cdk-lib/aws-dynamodb';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as lambdaNodejs from 'aws-cdk-lib/aws-lambda-nodejs';\nimport * as logs from 'aws-cdk-lib/aws-logs';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport { Construct } from 'constructs';\n\n/**\n * Properties to initialize an instance of `MicroAppsSvcs`.\n */\nexport interface MicroAppsSvcsProps {\n  /**\n   * RemovalPolicy override for child resources\n   *\n   * Note: if set to DESTROY the S3 buckes will have `autoDeleteObjects` set to `true`\n   *\n   * @default - per resource default\n   */\n  readonly removalPolicy?: RemovalPolicy;\n\n  /**\n   * S3 bucket for deployed applications\n   */\n  readonly bucketApps: s3.IBucket;\n\n  /**\n   * CloudFront Origin Access Identity for the deployed applications bucket\n   */\n  readonly bucketAppsOAI: cf.OriginAccessIdentity;\n\n  /**\n   * S3 bucket for staged applications (prior to deploy)\n   */\n  readonly bucketAppsStaging: s3.IBucket;\n\n  /**\n   * API Gateway v2 HTTP for Router and app\n   */\n  readonly httpApi?: apigwy.HttpApi;\n\n  /**\n   * Application environment, passed as `NODE_ENV`\n   * to the Router and Deployer Lambda functions\n   */\n  readonly appEnv: string;\n\n  /**\n   * Optional asset name root\n   *\n   * @example microapps\n   * @default - resource names auto assigned\n   */\n  readonly assetNameRoot?: string;\n\n  /**\n   * Optional asset name suffix\n   *\n   * @example -dev-pr-12\n   * @default none\n   */\n  readonly assetNameSuffix?: string;\n\n  /**\n   * Use a strict S3 Bucket Policy that prevents applications\n   * from reading/writing/modifying/deleting files in the S3 Bucket\n   * outside of the path that is specific to their app/version.\n   *\n   * This setting should be used when applications are less than\n   * fully trusted.\n   *\n   * @default false\n   */\n  readonly s3StrictBucketPolicy?: boolean;\n\n  /**\n   * Applies when using s3StrictBucketPolicy = true\n   *\n   * IAM Role or IAM User names to exclude from the DENY rules on the S3 Bucket Policy.\n   *\n   * Roles that are Assumed must instead have their AROA added to `s3PolicyBypassAROAs`.\n   *\n   * Typically any admin roles / users that need to view or manage the S3 Bucket\n   * would be added to this list.\n   *\n   * @example ['arn:aws:iam::1234567890123:role/AdminAccess', 'arn:aws:iam::1234567890123:user/MyAdminUser']\n   *\n   * @see s3PolicyBypassAROAs\n   */\n  readonly s3PolicyBypassPrincipalARNs?: string[];\n\n  /**\n   * Applies when using s3StrictBucketPolicy = true\n   *\n   * AROAs of the IAM Role to exclude from the DENY rules on the S3 Bucket Policy.\n   * This allows sessions that assume the IAM Role to be excluded from the\n   * DENY rules on the S3 Bucket Policy.\n   *\n   * Typically any admin roles / users that need to view or manage the S3 Bucket\n   * would be added to this list.\n   *\n   * Roles / users that are used directly, not assumed, can be added to `s3PolicyBypassRoleNames` instead.\n   *\n   * Note: This AROA must be specified to prevent this policy from locking\n   * out non-root sessions that have assumed the admin role.\n   *\n   * The notPrincipals will only match the role name exactly and will not match\n   * any session that has assumed the role since notPrincipals does not allow\n   * wildcard matches and does not do wildcard matches implicitly either.\n   *\n   * The AROA must be used because there are only 3 Principal variables available:\n   *  https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html#principaltable\n   *  aws:username, aws:userid, aws:PrincipalTag\n   *\n   * For an assumed role, aws:username is blank, aws:userid is:\n   *  [unique id AKA AROA for Role]:[session name]\n   *\n   * Table of unique ID prefixes such as AROA:\n   *  https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-prefixes\n   *\n   * The name of the role is simply not available for an assumed role and, if it was,\n   * a complicated comparison would be requierd to prevent exclusion\n   * of applying the Deny Rule to roles from other accounts.\n   *\n   * To get the AROA with the AWS CLI:\n   *   aws iam get-role --role-name ROLE-NAME\n   *   aws iam get-user -–user-name USER-NAME\n   *\n   * @example [ 'AROA1234567890123' ]\n   *\n   * @see s3StrictBucketPolicy\n   */\n  readonly s3PolicyBypassAROAs?: string[];\n\n  /**\n   * Path prefix on the root of the deployment\n   *\n   * @example dev/\n   * @default none\n   */\n  readonly rootPathPrefix?: string;\n\n  /**\n   * Require IAM auth on API Gateway\n   *\n   * @default true\n   */\n  readonly requireIAMAuthorization?: boolean;\n\n  /**\n   * Existing table for apps/versions/rules\n   *\n   * @warning - It is *strongly* suggested that production stacks create\n   * their own DynamoDB Table and pass it into this construct, for protection\n   * against data loss due to logical ID changes, the ability to configure\n   * Provisioned capacity with Auto Scaling, the ability to add additional indices, etc.\n   *\n   * Requirements:\n   * - Hash Key: `PK`\n   * - Sort Key: `SK`\n   *\n   * @default created by construct\n   */\n  readonly table?: dynamodb.ITable;\n}\n\n/**\n * Represents a MicroApps Services\n */\nexport interface IMicroAppsSvcs {\n  /**\n   * DynamoDB table used by Router, Deployer, and Release console app\n   */\n  readonly table: dynamodb.ITable;\n\n  /**\n   * Lambda function for the Deployer\n   */\n  readonly deployerFunc: lambda.IFunction;\n\n  /**\n   * Lambda function for the Router\n   */\n  readonly routerFunc?: lambda.IFunction;\n}\n\n/**\n * Create a new MicroApps Services construct, including the Deployer\n * and Router Lambda Functions, and the DynamoDB Table used by both.\n */\nexport class MicroAppsSvcs extends Construct implements IMicroAppsSvcs {\n  private _ownedTable?: dynamodb.Table;\n  private _table: dynamodb.ITable;\n  public get table(): dynamodb.ITable {\n    return this._table;\n  }\n\n  private _deployerFunc: lambda.Function;\n  public get deployerFunc(): lambda.IFunction {\n    return this._deployerFunc;\n  }\n\n  private _routerFunc?: lambda.Function;\n  public get routerFunc(): lambda.IFunction | undefined {\n    return this._routerFunc;\n  }\n\n  constructor(scope: Construct, id: string, props?: MicroAppsSvcsProps) {\n    super(scope, id);\n\n    if (props === undefined) {\n      throw new Error('props cannot be undefined');\n    }\n\n    const {\n      bucketApps,\n      bucketAppsOAI,\n      bucketAppsStaging,\n      s3PolicyBypassAROAs = [],\n      s3PolicyBypassPrincipalARNs = [],\n      s3StrictBucketPolicy = false,\n      appEnv,\n      httpApi,\n      removalPolicy,\n      assetNameRoot,\n      assetNameSuffix,\n      rootPathPrefix = '',\n      requireIAMAuthorization = true,\n    } = props;\n\n    if (s3StrictBucketPolicy === true) {\n      if (s3PolicyBypassAROAs.length === 0 && s3PolicyBypassPrincipalARNs.length === 0) {\n        throw new Error(\n          's3StrictBucketPolicy cannot be true without specifying at least one s3PolicyBypassAROAs or s3PolicyBypassPrincipalARNs',\n        );\n      }\n    }\n\n    //\n    // DynamoDB Table\n    //\n    if (props.table === undefined) {\n      // Create able if none passed\n      this._ownedTable = new dynamodb.Table(this, 'table', {\n        tableName: assetNameRoot\n          ? `${assetNameRoot}${assetNameSuffix}`\n          : PhysicalName.GENERATE_IF_NEEDED,\n        billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,\n        partitionKey: {\n          name: 'PK',\n          type: dynamodb.AttributeType.STRING,\n        },\n        sortKey: {\n          name: 'SK',\n          type: dynamodb.AttributeType.STRING,\n        },\n        removalPolicy,\n      });\n      this._table = this._ownedTable;\n    } else {\n      this._table = props.table;\n    }\n\n    //\n    // Deployer Lambda Function\n    //\n\n    // Create Deployer Lambda Function\n    const iamRoleUploadName = assetNameRoot\n      ? `${assetNameRoot}-deployer-upload${assetNameSuffix}`\n      : undefined;\n    const deployerFuncName = assetNameRoot\n      ? `${assetNameRoot}-deployer${assetNameSuffix}`\n      : undefined;\n    const deployerFuncProps: Omit<lambda.FunctionProps, 'handler' | 'code'> = {\n      functionName: deployerFuncName,\n      memorySize: 1769,\n      logRetention: logs.RetentionDays.ONE_MONTH,\n      runtime: lambda.Runtime.NODEJS_16_X,\n      timeout: Duration.seconds(15),\n      environment: {\n        NODE_ENV: appEnv,\n        ...(httpApi ? { APIGWY_ID: httpApi.httpApiId } : {}),\n        DATABASE_TABLE_NAME: this._table.tableName,\n        FILESTORE_STAGING_BUCKET: bucketAppsStaging.bucketName,\n        FILESTORE_DEST_BUCKET: bucketApps.bucketName,\n        AWS_NODEJS_CONNECTION_REUSE_ENABLED: '1',\n        ROOT_PATH_PREFIX: rootPathPrefix,\n        REQUIRE_IAM_AUTHORIZATION: requireIAMAuthorization ? 'true' : 'false',\n      },\n    };\n    if (\n      process.env.NODE_ENV === 'test' &&\n      existsSync(path.join(__dirname, '..', '..', 'microapps-deployer', 'dist', 'index.js'))\n    ) {\n      // This is for local dev\n      this._deployerFunc = new lambda.Function(this, 'deployer-func', {\n        code: lambda.Code.fromAsset(path.join(__dirname, '..', '..', 'microapps-deployer', 'dist')),\n        handler: 'index.handler',\n        ...deployerFuncProps,\n      });\n    } else if (existsSync(path.join(__dirname, 'microapps-deployer', 'index.js'))) {\n      // This is for built apps packaged with the CDK construct\n      this._deployerFunc = new lambda.Function(this, 'deployer-func', {\n        code: lambda.Code.fromAsset(path.join(__dirname, 'microapps-deployer')),\n        handler: 'index.handler',\n        ...deployerFuncProps,\n      });\n    } else {\n      this._deployerFunc = new lambdaNodejs.NodejsFunction(this, 'deployer-func', {\n        entry: path.join(__dirname, '..', '..', 'microapps-deployer', 'src', 'index.ts'),\n        handler: 'handler',\n        bundling: {\n          minify: true,\n          sourceMap: true,\n        },\n        ...deployerFuncProps,\n      });\n    }\n    if (removalPolicy !== undefined) {\n      this._deployerFunc.applyRemovalPolicy(removalPolicy);\n    }\n    // Give the Deployer access to DynamoDB table\n    this._table.grantReadWriteData(this._deployerFunc);\n    this._table.grant(this._deployerFunc, 'dynamodb:DescribeTable');\n\n    //\n    // Deloyer upload temp role\n    // Deployer assumes this role with a limited policy to generate\n    // an STS temp token to return to microapps-publish for the upload.\n    //\n    const iamRoleUpload = new iam.Role(this, 'deployer-upload-role', {\n      roleName: iamRoleUploadName,\n      inlinePolicies: {\n        uploadPolicy: new iam.PolicyDocument({\n          statements: [\n            new iam.PolicyStatement({\n              actions: ['s3:ListBucket'],\n              resources: [bucketAppsStaging.bucketArn],\n            }),\n            new iam.PolicyStatement({\n              actions: ['s3:PutObject', 's3:GetObject', 's3:AbortMultipartUpload'],\n              resources: [`${bucketAppsStaging.bucketArn}/*`],\n            }),\n          ],\n        }),\n      },\n      assumedBy: this._deployerFunc.grantPrincipal,\n    });\n    this._deployerFunc.addEnvironment('UPLOAD_ROLE_NAME', iamRoleUpload.roleName);\n\n    //\n    // Update S3 permissions\n    //\n    // Create PrincipalARN List\n    const s3PolicyBypassArnPrincipals: iam.ArnPrincipal[] = [];\n    for (const arnPrincipal of s3PolicyBypassPrincipalARNs) {\n      s3PolicyBypassArnPrincipals.push(new iam.ArnPrincipal(arnPrincipal));\n    }\n    // Create AROA List that matches assumed sessions\n    const s3PolicyBypassAROAMatches: string[] = [];\n    for (const aroa of s3PolicyBypassAROAs) {\n      s3PolicyBypassAROAMatches.push(`${aroa}:*`);\n    }\n    // Deny apps from reading:\n    // - If they are missing the microapp-name tag\n    // - Anything outside of the folder that matches their microapp-name tag\n    const policyDenyPrefixOutsideTag = new iam.PolicyStatement({\n      sid: 'deny-prefix-outside-microapp-name-tag',\n      effect: iam.Effect.DENY,\n      actions: ['s3:*'],\n      notPrincipals: [\n        new iam.CanonicalUserPrincipal(\n          bucketAppsOAI.cloudFrontOriginAccessIdentityS3CanonicalUserId,\n        ),\n        new iam.AccountRootPrincipal(),\n        ...s3PolicyBypassArnPrincipals,\n        this._deployerFunc.grantPrincipal,\n      ],\n      notResources: [\n        `${bucketApps.bucketArn}/\\${aws:PrincipalTag/microapp-name}/*`,\n        bucketApps.bucketArn,\n      ],\n      conditions: {\n        Null: { 'aws:PrincipalTag/microapp-name': 'false' },\n        // StringNotLike: {'aws:'}\n      },\n    });\n    if (removalPolicy !== undefined) {\n      policyDenyPrefixOutsideTag.addCondition(\n        // Allows the DeletableBucket Lambda to delete items in the buckets\n        'StringNotLike',\n        { 'aws:PrincipalTag/application': `${Stack.of(this).stackName}-core*` },\n      );\n    }\n    const policyDenyMissingTag = new iam.PolicyStatement({\n      sid: 'deny-missing-microapp-name-tag',\n      effect: iam.Effect.DENY,\n      actions: ['s3:*'],\n      notPrincipals: [\n        new iam.CanonicalUserPrincipal(\n          bucketAppsOAI.cloudFrontOriginAccessIdentityS3CanonicalUserId,\n        ),\n        new iam.AccountRootPrincipal(),\n        // Exclude the Deployer Function directly\n        this._deployerFunc.grantPrincipal,\n        // 2021-12-04 - Not 100% sure that this is actually needed...\n        // Let's test this and remove if actually not necessary\n        new iam.ArnPrincipal(\n          `arn:aws:sts::${Aws.ACCOUNT_ID}:assumed-role/${this._deployerFunc.role?.roleName}/${this._deployerFunc.functionName}`,\n        ),\n        ...s3PolicyBypassArnPrincipals,\n      ],\n      resources: [`${bucketApps.bucketArn}/*`, bucketApps.bucketArn],\n      conditions: {\n        Null: { 'aws:PrincipalTag/microapp-name': 'true' },\n        // Note: This AROA must be specified to prevent this policy from locking\n        // out non-root sessions that have assumed the admin role.\n        // The notPrincipals will only match the role name exactly and will not match\n        // any session that has assumed the role since notPrincipals does not allow\n        // wildcard matches and does not do them implicitly either.\n        // The AROA must be used because there are only 3 Principal variables:\n        //  https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html#principaltable\n        //  aws:username, aws:userid, aws:PrincipalTag\n        // For an assumed role, aws:username is blank, aws:userid is:\n        //  [unique id AKA AROA for Role]:[session name]\n        // Table of unique ID prefixes such as AROA:\n        //  https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-prefixes\n        // The name of the role is simply not available and if it was\n        // we'd need to write a complicated comparison to make sure\n        // that we didn't exclude the Deny tag from roles in other accounts.\n        //\n        // To get the AROA with the AWS CLI:\n        //   aws iam get-role --role-name ROLE-NAME\n        //   aws iam get-user -–user-name USER-NAME\n        StringNotLike: { 'aws:userid': [Aws.ACCOUNT_ID, ...s3PolicyBypassAROAMatches] },\n      },\n    });\n    if (removalPolicy !== undefined) {\n      policyDenyMissingTag.addCondition(\n        // Allows the DeletableBucket Lambda to delete items in the buckets\n        'StringNotLike',\n        { 'aws:PrincipalTag/application': `${Stack.of(this).stackName}-core*` },\n      );\n    }\n    const policyCloudFrontAccess = new iam.PolicyStatement({\n      sid: 'cloudfront-oai-access',\n      effect: iam.Effect.ALLOW,\n      actions: ['s3:GetObject', 's3:ListBucket'],\n      principals: [\n        new iam.CanonicalUserPrincipal(\n          bucketAppsOAI.cloudFrontOriginAccessIdentityS3CanonicalUserId,\n        ),\n      ],\n      resources: [`${bucketApps.bucketArn}/*`, bucketApps.bucketArn],\n    });\n\n    if (bucketApps.policy === undefined) {\n      const document = new s3.BucketPolicy(this, 's3-policy', {\n        bucket: bucketApps,\n      }).document;\n      document.addStatements(policyCloudFrontAccess);\n\n      if (s3StrictBucketPolicy) {\n        document.addStatements(policyDenyPrefixOutsideTag);\n        document.addStatements(policyDenyMissingTag);\n      }\n    } else {\n      bucketApps.policy.document.addStatements(policyCloudFrontAccess);\n\n      if (s3StrictBucketPolicy) {\n        bucketApps.policy.document.addStatements(policyDenyPrefixOutsideTag);\n        bucketApps.policy.document.addStatements(policyDenyMissingTag);\n      }\n    }\n\n    // Allow the Lambda to read from the staging bucket\n    const policyReadListStaging = new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      // FIXME: Allow Deployer to delete from Staging bucket\n      actions: ['s3:DeleteObject', 's3:GetObject', 's3:ListBucket'],\n      resources: [`${bucketAppsStaging.bucketArn}/*`, bucketAppsStaging.bucketArn],\n    });\n    this._deployerFunc.addToRolePolicy(policyReadListStaging);\n\n    // Allow the Lambda to write to the target bucket and delete\n    const policyReadWriteListTarget = new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions: ['s3:DeleteObject', 's3:GetObject', 's3:PutObject', 's3:ListBucket'],\n      resources: [`${bucketApps.bucketArn}/*`, bucketApps.bucketArn],\n    });\n    this._deployerFunc.addToRolePolicy(policyReadWriteListTarget);\n\n    // Allow the deployer to get a temporary STS token\n    const policyGetSTSToken = new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions: ['sts:GetFederationToken'],\n      resources: ['*'],\n    });\n    this._deployerFunc.addToRolePolicy(policyGetSTSToken);\n\n    // Allow the deployer to assume the upload role\n    const policyAssumeUpload = new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions: ['sts:AssumeRole'],\n      resources: [iamRoleUpload.roleArn],\n    });\n    this._deployerFunc.addToRolePolicy(policyAssumeUpload);\n\n    //\n    // Give Deployer permissions to create routes and integrations\n    // on the API Gateway API.\n    //\n\n    // Grant the ability to List all APIs (we have to find it)\n    const policyAPIList = new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions: ['apigateway:GET'],\n      resources: [`arn:aws:apigateway:${Aws.REGION}::/apis`],\n    });\n    this._deployerFunc.addToRolePolicy(policyAPIList);\n\n    if (httpApi) {\n      // Grant full control over the API we created\n      const policyAPIManage = new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: ['apigateway:*'],\n        resources: [\n          `arn:aws:apigateway:${Aws.REGION}:${Aws.ACCOUNT_ID}:${httpApi.httpApiId}/*`,\n          `arn:aws:apigateway:${Aws.REGION}::/apis/${httpApi.httpApiId}/integrations/*`,\n          `arn:aws:apigateway:${Aws.REGION}::/apis/${httpApi.httpApiId}/integrations`,\n          `arn:aws:apigateway:${Aws.REGION}::/apis/${httpApi.httpApiId}/routes`,\n          `arn:aws:apigateway:${Aws.REGION}::/apis/${httpApi.httpApiId}/routes/*`,\n        ],\n      });\n      this._deployerFunc.addToRolePolicy(policyAPIManage);\n    }\n\n    // Grant full control over lambdas that indicate they are microapps\n    const policyAPIManageLambdas = new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions: ['lambda:*'],\n      resources: [\n        `arn:aws:lambda:${Aws.REGION}:${Aws.ACCOUNT_ID}:function:*`,\n        `arn:aws:lambda:${Aws.REGION}:${Aws.ACCOUNT_ID}:function:*:*`,\n      ],\n      conditions: {\n        StringEqualsIfExists: { 'aws:ResourceTag/microapp-managed': 'true' },\n      },\n    });\n    this._deployerFunc.addToRolePolicy(policyAPIManageLambdas);\n\n    if (httpApi) {\n      //\n      // Router Lambda Function\n      //\n\n      // Create Router Lambda Function\n      const routerFuncProps: Omit<lambda.FunctionProps, 'handler' | 'code'> = {\n        functionName: assetNameRoot ? `${assetNameRoot}-router${assetNameSuffix}` : undefined,\n        memorySize: 1769,\n        logRetention: logs.RetentionDays.ONE_MONTH,\n        runtime: lambda.Runtime.NODEJS_16_X,\n        timeout: Duration.seconds(15),\n        environment: {\n          NODE_ENV: appEnv,\n          DATABASE_TABLE_NAME: this._table.tableName,\n          AWS_NODEJS_CONNECTION_REUSE_ENABLED: '1',\n          ROOT_PATH_PREFIX: rootPathPrefix,\n        },\n      };\n      if (\n        process.env.NODE_ENV === 'test' &&\n        existsSync(path.join(__dirname, '..', '..', 'microapps-router', 'dist', 'index.js'))\n      ) {\n        // This is for local dev\n        this._routerFunc = new lambda.Function(this, 'router-func', {\n          code: lambda.Code.fromAsset(path.join(__dirname, '..', '..', 'microapps-router', 'dist')),\n          handler: 'index.handler',\n          ...routerFuncProps,\n        });\n      } else if (existsSync(path.join(__dirname, 'microapps-router', 'index.js'))) {\n        // This is for built apps packaged with the CDK construct\n        this._routerFunc = new lambda.Function(this, 'router-func', {\n          code: lambda.Code.fromAsset(path.join(__dirname, 'microapps-router')),\n          handler: 'index.handler',\n          ...routerFuncProps,\n        });\n      } else {\n        // Create Router Lambda Layer\n        const routerDataFiles = new lambda.LayerVersion(this, 'router-templates', {\n          code: lambda.Code.fromAsset(\n            path.join(__dirname, '..', '..', 'microapps-router', 'templates'),\n          ),\n          removalPolicy,\n        });\n\n        this._routerFunc = new lambdaNodejs.NodejsFunction(this, 'router-func', {\n          entry: path.join(__dirname, '..', '..', 'microapps-router', 'src', 'index.ts'),\n          handler: 'handler',\n          bundling: {\n            minify: true,\n            sourceMap: true,\n          },\n          layers: [routerDataFiles],\n          ...routerFuncProps,\n        });\n      }\n      if (removalPolicy !== undefined) {\n        this._routerFunc.applyRemovalPolicy(removalPolicy);\n      }\n      const policyReadTarget = new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: ['s3:GetObject'],\n        resources: [`${bucketApps.bucketArn}/*`],\n      });\n      for (const router of [this._routerFunc]) {\n        router.addToRolePolicy(policyReadTarget);\n        // Give the Router access to DynamoDB table\n        this._table.grantReadData(router);\n        this._table.grant(router, 'dynamodb:DescribeTable');\n      }\n      // Create alias for Router\n      const routerAlias = this._routerFunc.addAlias('CurrentVersion');\n\n      // This creates an integration and a router\n      const route = new apigwy.HttpRoute(this, 'route-default', {\n        httpApi,\n        routeKey: apigwy.HttpRouteKey.DEFAULT,\n        integration: new apigwyint.HttpLambdaIntegration('router-integration', routerAlias),\n        authorizer: requireIAMAuthorization ? new apigwyAuth.HttpIamAuthorizer() : undefined,\n      });\n\n      let routeArn = route.routeArn;\n      // Remove the trailing `/` on the ARN, which is not correct\n      if (routeArn.endsWith('/')) {\n        routeArn = routeArn.slice(0, routeArn.length - 1);\n      }\n\n      // Grant API Gateway permission to invoke the Lambda\n      new lambda.CfnPermission(this, 'router-invoke', {\n        action: 'lambda:InvokeFunction',\n        functionName: this._routerFunc.functionName,\n        principal: 'apigateway.amazonaws.com',\n        sourceArn: routeArn,\n      });\n    }\n  }\n}\n"]}

package/lib/MicroAppsTable.js

@@ -47,5 +47,5 @@ class MicroAppsTable extends constructs_1.Construct {
 }
 exports.MicroAppsTable = MicroAppsTable;
 _a = JSII_RTTI_SYMBOL_1;
-MicroAppsTable[_a] = { fqn: "@pwrdrvr/microapps-cdk.MicroAppsTable", version: "0.3.4" };
+MicroAppsTable[_a] = { fqn: "@pwrdrvr/microapps-cdk.MicroAppsTable", version: "0.3.5-alpha.2" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/microapps-deployer/index.js

@@ -78,7 +78,7 @@ For more information please go to https://github.com/aws/aws-sdk-js-v3#functiona
 `+e.slice(i,s),i=s+1),d=a;return c+=`
 `,e.length-i>t&&d>i?c+=e.slice(i,d)+`
 `+e.slice(d+1):c+=e.slice(i),c.slice(1)}function H8e(e){for(var t="",n=0,r,i=0;i<e.length;n>=65536?i+=2:i++)n=fm(e,i),r=Ln[n],!r&&wm(n)?(t+=e[i],n>=65536&&(t+=e[i+1])):t+=r||M8e(n);return t}function J8e(e,t,n){var r="",i=e.tag,s,d,a;for(s=0,d=n.length;s<d;s+=1)a=n[s],e.replacer&&(a=e.replacer.call(n,String(s),a)),(ds(e,t,a,!1,!1)||typeof a>"u"&&ds(e,t,null,!1,!1))&&(r!==""&&(r+=","+(e.condenseFlow?"":" ")),r+=e.dump);e.tag=i,e.dump="["+r+"]"}function AY(e,t,n,r){var i="",s=e.tag,d,a,c;for(d=0,a=n.length;d<a;d+=1)c=n[d],e.replacer&&(c=e.replacer.call(n,String(d),c)),(ds(e,t+1,c,!0,!0,!1,!0)||typeof c>"u"&&ds(e,t+1,null,!0,!0,!1,!0))&&((!r||i!=="")&&(i+=$q(e,t)),e.dump&&gm===e.dump.charCodeAt(0)?i+="-":i+="- ",i+=e.dump);e.tag=s,e.dump=i||"[]"}function X8e(e,t,n){var r="",i=e.tag,s=Object.keys(n),d,a,c,l,u;for(d=0,a=s.length;d<a;d+=1)u="",r!==""&&(u+=", "),e.condenseFlow&&(u+='"'),c=s[d],l=n[c],e.replacer&&(l=e.replacer.call(n,c,l)),ds(e,t,c,!1,!1)&&(e.dump.length>1024&&(u+="? "),u+=e.dump+(e.condenseFlow?'"':"")+":"+(e.condenseFlow?"":" "),ds(e,t,l,!1,!1)&&(u+=e.dump,r+=u));e.tag=i,e.dump="{"+r+"}"}function K8e(e,t,n,r){var i="",s=e.tag,d=Object.keys(n),a,c,l,u,w,E;if(e.sortKeys===!0)d.sort();else if(typeof e.sortKeys=="function")d.sort(e.sortKeys);else if(e.sortKeys)throw new Qn("sortKeys must be a boolean or a function");for(a=0,c=d.length;a<c;a+=1)E="",(!r||i!=="")&&(E+=$q(e,t)),l=d[a],u=n[l],e.replacer&&(u=e.replacer.call(n,l,u)),ds(e,t+1,l,!0,!0,!0)&&(w=e.tag!==null&&e.tag!=="?"||e.dump&&e.dump.length>1024,w&&(e.dump&&gm===e.dump.charCodeAt(0)?E+="?":E+="? "),E+=e.dump,w&&(E+=$q(e,t)),ds(e,t+1,u,!0,w)&&(e.dump&&gm===e.dump.charCodeAt(0)?E+=":":E+=": ",E+=e.dump,i+=E));e.tag=s,e.dump=i||"{}"}function xY(e,t,n){var r,i,s,d,a,c;for(i=n?e.explicitTypes:e.implicitTypes,s=0,d=i.length;s<d;s+=1)if(a=i[s],(a.instanceOf||a.predicate)&&(!a.instanceOf||typeof t=="object"&&t instanceof a.instanceOf)&&(!a.predicate||a.predicate(t))){if(n?a.multi&&a.representName?e.tag=a.representName(t):e.tag=a.tag:e.tag="?",a.represent){if(c=e.styleMap[a.tag]||a.defaultStyle,FY.call(a.represent)==="[object Function]")r=a.represent(t,c);else if(jY.call(a.represent,c))r=a.represent[c](t,c);else throw new Qn("!<"+a.tag+'> tag resolver accepts not "'+c+'" style');e.dump=r}return!0}return!1}function ds(e,t,n,r,i,s,d){e.tag=null,e.dump=n,xY(e,n,!1)||xY(e,n,!0);var a=FY.call(e.dump),c=r,l;r&&(r=e.flowLevel<0||e.flowLevel>t);var u=a==="[object Object]"||a==="[object Array]",w,E;if(u&&(w=e.duplicates.indexOf(n),E=w!==-1),(e.tag!==null&&e.tag!=="?"||E||e.indent!==2&&t>0)&&(i=!1),E&&e.usedDuplicates[w])e.dump="*ref_"+w;else{if(u&&E&&!e.usedDuplicates[w]&&(e.usedDuplicates[w]=!0),a==="[object Object]")r&&Object.keys(e.dump).length!==0?(K8e(e,t,e.dump,i),E&&(e.dump="&ref_"+w+e.dump)):(X8e(e,t,e.dump),E&&(e.dump="&ref_"+w+" "+e.dump));else if(a==="[object Array]")r&&e.dump.length!==0?(e.noArrayIndent&&!d&&t>0?AY(e,t-1,e.dump,i):AY(e,t,e.dump,i),E&&(e.dump="&ref_"+w+e.dump)):(J8e(e,t,e.dump),E&&(e.dump="&ref_"+w+" "+e.dump));else if(a==="[object String]")e.tag!=="?"&&V8e(e,e.dump,t,s,c);else{if(a==="[object Undefined]")return!1;if(e.skipInvalid)return!1;throw new Qn("unacceptable kind of an object to dump "+a)}e.tag!==null&&e.tag!=="?"&&(l=encodeURI(e.tag[0]==="!"?e.tag.slice(1):e.tag).replace(/!/g,"%21"),e.tag[0]==="!"?l="!"+l:l.slice(0,18)==="tag:yaml.org,2002:"?l="!!"+l.slice(18):l="!<"+l+">",e.dump=l+" "+e.dump)}return!0}function W8e(e,t){var n=[],r=[],i,s;for(Jq(e,n,r),i=0,s=r.length;i<s;i+=1)t.duplicates.push(n[r[i]]);t.usedDuplicates=new Array(s)}function Jq(e,t,n){var r,i,s;if(e!==null&&typeof e=="object")if(i=t.indexOf(e),i!==-1)n.indexOf(i)===-1&&n.push(i);else if(t.push(e),Array.isArray(e))for(i=0,s=e.length;i<s;i+=1)Jq(e[i],t,n);else for(r=Object.keys(e),i=0,s=r.length;i<s;i+=1)Jq(e[r[i]],t,n)}function Q8e(e,t){t=t||{};var n=new B8e(t);n.noRefs||W8e(e,n);var r=e;return n.replacer&&(r=n.replacer.call({"":r},"",r)),ds(n,0,r,!0,!0)?n.dump+`
-`:""}var Y8e=Q8e,Z8e={dump:Y8e};function Yq(e,t){return function(){throw new Error("Function yaml."+e+" is removed in js-yaml 4. Use yaml."+t+" instead, which is now safe by default.")}}var QY=BY.load,L4t=BY.loadAll,D4t=Z8e.dump;var M4t=Yq("safeLoad","load"),O4t=Yq("safeLoadAll","loadAll"),B4t=Yq("safeDump","dump");var Gr=pn(Yd()),yne=pn(Yd());var sE=pn(gne()),iE=class{static async getExistingFiles(t){let n=[];for(let r of t)await(0,sE.pathExists)(r)&&n.push(r);return n}static getExistingFilesSync(t){let n=[];for(let r of t)(0,sE.pathExistsSync)(r)&&n.push(r);return n}};var hne=pn(Yd()),Lm=class{};En([(0,hne.Property)({doc:"ID of API Gateway to integrate with",nullable:!1,default:"none",env:"APIGWY_ID"})],Lm.prototype,"apiId",2);var wne=pn(Yd()),Dm=class{};En([(0,wne.Property)({doc:"DynamoDB Table Name",default:"MicroApps",env:"DATABASE_TABLE_NAME"})],Dm.prototype,"tableName",2);var JL=pn(Yd()),sc=class{};En([(0,JL.Property)({doc:"Staging bucket to copy staged apps from",default:"microapps-staging",env:"FILESTORE_STAGING_BUCKET"})],sc.prototype,"stagingBucket",2),En([(0,JL.Property)({doc:"Destination bucket to copy staged apps to",default:"microapps",env:"FILESTORE_DEST_BUCKET"})],sc.prototype,"destinationBucket",2);var Gt=class{static configFiles(){let t=["./configs/config.yaml","./configs/config.yml",`./configs/config-${Gt.envLevel}.yaml`,`./configs/config-${Gt.envLevel}.yml`];return iE.getExistingFilesSync(t)}static get instance(){if(Gt._instance===void 0){let t=new yne.TSConvict(Gt);Gt._instance=t.load(Gt.configFiles())}return Gt._instance}static get envLevel(){let t=process.env.NODE_ENV||"dev";return t.startsWith("prod")?"prod":t==="qa"?"qa":t==="local"?"local":"dev"}};En([Gr.Property(Dm)],Gt.prototype,"db",2),En([Gr.Property(Lm)],Gt.prototype,"apigwy",2),En([Gr.Property(sc)],Gt.prototype,"filestore",2),En([Gr.Property({doc:"AWS Account ID for app Lambda function",default:0,env:"AWS_ACCOUNT_ID"})],Gt.prototype,"awsAccountID",2),En([Gr.Property({doc:"AWS Region for app Lambda function",default:"us-east-1",env:"AWS_REGION"})],Gt.prototype,"awsRegion",2),En([Gr.Property({doc:"Role name to be used for temp STS upload tokens",default:"microapps-deployer-upload-dev",env:"UPLOAD_ROLE_NAME"})],Gt.prototype,"uploadRoleName",2),En([Gr.Property({doc:"Path prefix for this deployment",default:"",env:"ROOT_PATH_PREFIX"})],Gt.prototype,"rootPathPrefix",2),En([Gr.Property({doc:"Require IAM Authorization on all created routes",default:!0,env:"REQUIRE_IAM_AUTHORIZATION"})],Gt.prototype,"requireIAMAuthorization",2),Gt=En([Gr.Config({file:"config.yml",validationMethod:"strict",parser:{extension:["yml","yaml"],parse:QY},formats:{url:oE.url,ipaddress:oE.ipaddress}})],Gt);var KL=pn(SC());function XL(e){return e==null||e===""}var Mm=class{static async CreateApp(t){let{dbManager:n,app:r}=t;return XL(r.appName)||XL(r.displayName)||XL(r.type)?{statusCode:400}:await KL.Application.Load({dbManager:n,key:{AppName:r.appName}})!==void 0?{statusCode:200}:(await new KL.Application({AppName:r.appName,DisplayName:r.displayName}).Save(n),{statusCode:201})}};var w2=pn(require("crypto")),vn=pn(mse()),Zt=pn(Bde()),$r=pn(xge()),VT=pn(Cd()),Es=pn(SC()),Kge=pn(Lge());var Xge=pn(Jge()),it=class{};it.Instance=new Xge.LambdaLog({silent:process.env.JEST_WORKER_ID!==void 0});var ji=new Zt.LambdaClient({maxAttempts:8}),gp=new $r.S3Client({maxAttempts:16}),O$t=new VT.STSClient({maxAttempts:8}),hp=new vn.ApiGatewayV2Client({maxAttempts:8}),fn=class{static async DeployVersionPreflight(t){var u,w,E;let{dbManager:n,request:r,config:i}=t,{appName:s,semVer:d,needS3Creds:a=!0,overwrite:c=!1}=r,l=await Es.Version.LoadVersion({dbManager:n,key:{AppName:s,SemVer:d}});if(l!==void 0&&l.Status!=="pending")if(c)it.Instance.info("Warning: App/Version already exists",{appName:r.appName,semVer:r.semVer});else return it.Instance.info("Error: App/Version already exists",{appName:r.appName,semVer:r.semVer}),{statusCode:200};if(it.Instance.info("App/Version does not exist",{appName:s,semVer:d}),a){let T={Statement:[{Effect:"Allow",Action:["s3:PutObject","s3:GetObject","s3:AbortMultipartUpload"],Resource:[`arn:aws:s3:::${i.filestore.stagingBucket}/*`]},{Effect:"Allow",Action:["s3:ListBucket"],Resource:[`arn:aws:s3:::${i.filestore.stagingBucket}`]}],Version:"2012-10-17"};it.Instance.debug("Temp IAM Policy",{policy:JSON.stringify(T)});let P=await O$t.send(new VT.AssumeRoleCommand({RoleArn:`arn:aws:iam::${i.awsAccountID}:role/${i.uploadRoleName}`,DurationSeconds:60*60,RoleSessionName:fn.SHA1Hash(fn.GetBucketPrefix(r,i)),Policy:JSON.stringify(T)}));return it.Instance.info("finished request - returning s3 creds"),{statusCode:404,s3UploadUrl:`s3://${i.filestore.stagingBucket}/${fn.GetBucketPrefix(r,i)}`,awsCredentials:{accessKeyId:(u=P.Credentials)==null?void 0:u.AccessKeyId,secretAccessKey:(w=P.Credentials)==null?void 0:w.SecretAccessKey,sessionToken:(E=P.Credentials)==null?void 0:E.SessionToken}}}else return it.Instance.info("finished request - not returning s3 creds"),{statusCode:404}}static async DeployVersion(t){let{dbManager:n,request:r,config:i}=t,{appType:s="lambda",overwrite:d=!1,startupType:a="iframe"}=r;it.Instance.debug("Got Body:",r);let c=await Es.Version.LoadVersion({dbManager:n,key:{AppName:r.appName,SemVer:r.semVer}});if(c!==void 0&&c.Status==="routed")if(d)it.Instance.info("Warning: App/Version already exists",{appName:r.appName,semVer:r.semVer});else return it.Instance.info("Error: App/Version already exists",{appName:r.appName,semVer:r.semVer}),{statusCode:409};if(a==="direct"&&["lambda"].includes(s))return it.Instance.info("Error: Incompatible app type and startup type",{appType:s,startupType:a}),{statusCode:400};if(d&&c&&(c.DefaultFile=r.defaultFile,c.Type=s,c.StartupType=a,r.lambdaARN&&(c.LambdaARN=r.lambdaARN)),c===void 0&&(c=new Es.Version(o({AppName:r.appName,SemVer:r.semVer,Type:s,Status:"pending",DefaultFile:r.defaultFile,StartupType:a},r.lambdaARN?{LambdaARN:r.lambdaARN}:{})),await c.Save(n)),d||c.Status==="pending"){let{stagingBucket:u}=i.filestore,w=fn.GetBucketPrefix(r,i)+"/";await fn.CopyToProdBucket(u,w,fn.GetBucketPrefix(r,i),i),c.DefaultFile=r.defaultFile,c.Status="assets-copied",await c.Save(n)}if(s==="lambda"){let u=i.apigwy.apiId;if(d||c.Status==="assets-copied"){let E=i.awsAccountID,T=i.awsRegion,P=!0;try{let I=await ji.send(new Zt.GetPolicyCommand({FunctionName:r.lambdaARN}));if(I.Policy!==void 0){let F=JSON.parse(I.Policy);F.Statement!==void 0&&F.Statement.filter(G=>G.Sid==="microapps-version-root"||G.Sid==="microapps-version").length===2&&(P=!1)}}catch(I){if(I.name!=="ResourceNotFoundException")throw I}P&&(await ji.send(new Zt.AddPermissionCommand({Principal:"apigateway.amazonaws.com",StatementId:"microapps-version-root",Action:"lambda:InvokeFunction",FunctionName:r.lambdaARN,SourceArn:`arn:aws:execute-api:${T}:${E}:${u}/*/*/${r.appName}/${r.semVer}`})),await ji.send(new Zt.AddPermissionCommand({Principal:"apigateway.amazonaws.com",StatementId:"microapps-version",Action:"lambda:InvokeFunction",FunctionName:r.lambdaARN,SourceArn:`arn:aws:execute-api:${T}:${E}:${u}/*/*/${r.appName}/${r.semVer}/{proxy+}`}))),c.Status="permissioned",await c.Save(n)}let w="";if(d||c.Status==="permissioned")if(c.IntegrationID!==void 0&&c.IntegrationID!=="")w=c.IntegrationID,it.Instance.info("integration already created, skipping creation",{IntegrationId:w});else{try{w=(await hp.send(new vn.CreateIntegrationCommand({ApiId:u,IntegrationType:vn.IntegrationType.AWS_PROXY,IntegrationMethod:"POST",PayloadFormatVersion:"2.0",IntegrationUri:r.lambdaARN}))).IntegrationId}catch(E){if(E.name==="AccessDeniedException")return it.Instance.error("AccessDeniedException adding integration to API Gateway",{error:E}),{statusCode:401}}c.IntegrationID=w,c.Status="integrated",await c.Save(n)}if(d||c.Status==="integrated"){if(c.RouteIDAppVersion!==void 0&&c.RouteIDAppVersion!=="")it.Instance.info("route app/version already created, skipping creation",{IntegrationId:w,RouteIDAppVersion:c.RouteIDAppVersion});else try{let E=await hp.send(new vn.CreateRouteCommand({ApiId:u,Target:`integrations/${w}`,RouteKey:`ANY /${r.appName}/${r.semVer}`,AuthorizationType:i.requireIAMAuthorization?vn.AuthorizationType.AWS_IAM:vn.AuthorizationType.NONE}));it.Instance.info("created RouteIDAppVersion",{result:E}),c.RouteIDAppVersion=`${E.RouteId}`}catch(E){if(E.name==="AccessDeniedException")return it.Instance.error("AccessDeniedException adding route to API Gateway",{error:E}),{statusCode:401};it.Instance.error("Caught unexpected error on app/ver route add"),it.Instance.error(E)}if(c.RouteIDAppVersionSplat!==void 0&&c.RouteIDAppVersionSplat!=="")it.Instance.info("route app/version/* already created, skipping creation",{IntegrationId:w,RouteIDAppVersionSplat:c.RouteIDAppVersionSplat});else try{let E=await hp.send(new vn.CreateRouteCommand({ApiId:u,Target:`integrations/${w}`,RouteKey:`ANY /${r.appName}/${r.semVer}/{proxy+}`,AuthorizationType:i.requireIAMAuthorization?vn.AuthorizationType.AWS_IAM:vn.AuthorizationType.NONE}));it.Instance.info("created RouteIDAppVersionSplat",{result:E}),c.RouteIDAppVersionSplat=`${E.RouteId}`}catch(E){if(E.name==="AccessDeniedException")return it.Instance.error("AccessDeniedException adding route to API Gateway",{error:E}),{statusCode:401};it.Instance.error("Caught unexpected error on {proxy+} route add"),it.Instance.error(E)}c.Status="routed",await c.Save(n)}}else if(s==="lambda-url"){if(!r.lambdaARN)throw new Error("Missing lambdaARN for lambda-url app type");let{lambdaARNBase:u,lambdaARNAlias:w}=fn.ExtractARNandAlias(r.lambdaARN);if(d||c.Status==="assets-copied"){let E=await ji.send(new Zt.ListTagsCommand({Resource:u}));(E.Tags===void 0||E.Tags["microapp-managed"]!=="true")&&await ji.send(new Zt.TagResourceCommand({Resource:u,Tags:{"microapp-managed":"true"}})),c.Status="permissioned",await c.Save(n)}if(d||c.Status==="permissioned"){let E,T;try{T=await ji.send(new Zt.GetFunctionUrlConfigCommand({FunctionName:u,Qualifier:w})),T.FunctionUrl&&(E=T.FunctionUrl)}catch(P){if(P.name!=="ResourceNotFoundException")throw P}T!=null&&T.FunctionUrl||(E=(await ji.send(new Zt.CreateFunctionUrlConfigCommand({FunctionName:u,Qualifier:w,AuthType:"AWS_IAM"}))).FunctionUrl),c.Status="routed",E&&(c.URL=E),await c.Save(n)}}else if(s==="static")c.Status==="assets-copied"&&(c.Status="routed",await c.Save(n));else throw new Error(`Unknown app type: ${s}`);let l=await Es.Rules.Load({dbManager:n,key:{AppName:r.appName}});return l===void 0&&(l=new Es.Rules({AppName:r.appName,RuleSet:{},Version:1}),l.RuleSet.default={SemVer:r.semVer,AttributeName:"",AttributeValue:""},await l.Save(n)),it.Instance.info("finished request"),{statusCode:201}}static ExtractARNandAlias(t){let n=t==null?void 0:t.substring(0,t.lastIndexOf(":")),r=t==null?void 0:t.substring(t.lastIndexOf(":")+1);return{lambdaARNBase:n,lambdaARNAlias:r}}static async DeleteVersion(t){let{dbManager:n,request:r,config:i}=t;it.Instance.debug("Got Body:",r);let s=await Es.Version.LoadVersion({dbManager:n,key:{AppName:r.appName,SemVer:r.semVer}});if(s===void 0)return it.Instance.info("Error: App/Version does not exist",{appName:r.appName,semVer:r.semVer}),{statusCode:404};let d=fn.GetBucketPrefix(r,i)+"/";if(await this.DeleteFromDestinationBucket(d,i),s.Type==="lambda"){let a=i.apigwy.apiId;if(s.RouteIDAppVersion===""&&s.RouteIDAppVersionSplat==="")it.Instance.warn("no RouteIDs to delete");else{for(let c of[s.RouteIDAppVersion,s.RouteIDAppVersionSplat])try{await hp.send(new vn.DeleteRouteCommand({ApiId:a,RouteId:c}))}catch(l){if(l.name==="AccessDeniedException")return it.Instance.error("AccessDeniedException removing route from API Gateway",{error:l,apiId:a,routeId:c}),{statusCode:401};it.Instance.error("Caught unexpected error on app/ver route remove",{error:l,apiId:a,routeId:c})}if(s.IntegrationID!==void 0&&s.IntegrationID!=="")try{await hp.send(new vn.DeleteIntegrationCommand({ApiId:a,IntegrationId:s.IntegrationID}))}catch(c){if(c.name==="AccessDeniedException")return it.Instance.error("AccessDeniedException removing integration from API Gateway",{error:c,apiId:a,integrationId:s.IntegrationID}),{statusCode:401};it.Instance.error("Caught unexpected error removing integration from API Gateway",{error:c,apiId:a,integrationId:s.IntegrationID})}}}if((s.Type==="lambda"||s.Type==="lambda-url")&&s.LambdaARN){let{lambdaARNBase:a,lambdaARNAlias:c}=fn.ExtractARNandAlias(s.LambdaARN);try{let l=await ji.send(new Zt.GetAliasCommand({FunctionName:a,Name:c}));if(await ji.send(new Zt.DeleteAliasCommand({FunctionName:a,Name:c})),l.FunctionVersion)try{await ji.send(new Zt.DeleteFunctionCommand({FunctionName:a,Qualifier:l.FunctionVersion}))}catch(u){if(u.name!=="ResourceConflictException")throw u;it.Instance.info("Version is still in use by another alias, not deleting")}}catch(l){if(l.name!=="ResourceNotFoundException")throw l}}return await Es.Version.DeleteVersion({dbManager:n,key:{AppName:r.appName,SemVer:r.semVer}}),it.Instance.info("finished request"),{statusCode:200}}static SHA256Hash(t){return w2.default.createHash("sha256").update(t).digest("hex")}static SHA1Hash(t){return w2.default.createHash("sha1").update(t).digest("hex")}static async CopyFilesInList(t,n,r,i,s){t===void 0||t.Contents===void 0||await(0,Kge.default)(t.Contents,async d=>{var c;let a=(c=d.Key)==null?void 0:c.slice(r.length);await gp.send(new $r.CopyObjectCommand({CopySource:`${n}/${d.Key}`,Bucket:s.filestore.destinationBucket,Key:`${i}/${a}`})),await gp.send(new $r.DeleteObjectCommand({Bucket:n,Key:d.Key}))},{concurrency:4})}static async CopyToProdBucket(t,n,r,i){let s;do{let d=(s==null?void 0:s.NextContinuationToken)!==void 0?{ContinuationToken:s.NextContinuationToken}:{};s=await gp.send(new $r.ListObjectsV2Command(o({Bucket:t,Prefix:n},d))),await fn.CopyFilesInList(s,t,n,r,i)}while(s.IsTruncated)}static async DeleteFromDestinationBucket(t,n){var i;let r;do{let s=(r==null?void 0:r.NextContinuationToken)!==void 0?{ContinuationToken:r.NextContinuationToken}:{};r=await gp.send(new $r.ListObjectsV2Command(o({Bucket:n.filestore.destinationBucket,Prefix:t},s)));let d=[];(i=r.Contents)==null||i.map(a=>{d.push({Key:a.Key})}),d.length>0&&await gp.send(new $r.DeleteObjectsCommand({Bucket:n.filestore.destinationBucket,Delete:{Objects:d}}))}while(r.IsTruncated)}static GetBucketPrefix(t,n){return`${n.rootPathPrefix===""?"":`${n.rootPathPrefix}/`}${fn.GetAppNameOrRootTrailingSlash(t)}${t.semVer}`.toLowerCase()}static GetAppNameOrRootTrailingSlash(t){return t.appName==="[root]"?"":`${t.appName}/`}};var B$t=it.Instance,qo,S2=new Wge.DynamoDBClient({maxAttempts:8});function F$t(e){qo=e.dbManager,S2=e.dynamoClient}qo=new y2.DBManager({dynamoClient:S2,tableName:Gt.instance.db.tableName});var wp=Gt.instance;async function j$t(e,t){if(B$t.options.meta={awsRequestId:t==null?void 0:t.awsRequestId,requestType:e.type},qo===void 0&&(qo=new y2.DBManager({dynamoClient:S2,tableName:Gt.instance.db.tableName})),wp.awsAccountID===0&&(t==null?void 0:t.invokedFunctionArn)!==void 0){let r=t.invokedFunctionArn.split(":")[4];r!==""&&(wp.awsAccountID=parseInt(r,10))}it.Instance.info("received request",{request:e});try{switch(e.type){case"createApp":{let n=e;return await Mm.CreateApp({dbManager:qo,app:n})}case"deleteVersion":{let n=e;return await fn.DeleteVersion({dbManager:qo,request:n,config:wp})}case"deployVersionPreflight":{let n=e;return await fn.DeployVersionPreflight({dbManager:qo,request:n,config:wp})}case"deployVersion":{let n=e;return await fn.DeployVersion({dbManager:qo,request:n,config:wp})}default:return{statusCode:400}}}catch(n){return it.Instance.error("Caught unexpected exception in handler"),it.Instance.error(n),{statusCode:500}}}0&&(module.exports={handler,overrideDBManager});
+`:""}var Y8e=Q8e,Z8e={dump:Y8e};function Yq(e,t){return function(){throw new Error("Function yaml."+e+" is removed in js-yaml 4. Use yaml."+t+" instead, which is now safe by default.")}}var QY=BY.load,L4t=BY.loadAll,D4t=Z8e.dump;var M4t=Yq("safeLoad","load"),O4t=Yq("safeLoadAll","loadAll"),B4t=Yq("safeDump","dump");var Gr=pn(Yd()),yne=pn(Yd());var sE=pn(gne()),iE=class{static async getExistingFiles(t){let n=[];for(let r of t)await(0,sE.pathExists)(r)&&n.push(r);return n}static getExistingFilesSync(t){let n=[];for(let r of t)(0,sE.pathExistsSync)(r)&&n.push(r);return n}};var hne=pn(Yd()),Lm=class{};En([(0,hne.Property)({doc:"ID of API Gateway to integrate with",nullable:!1,default:"none",env:"APIGWY_ID"})],Lm.prototype,"apiId",2);var wne=pn(Yd()),Dm=class{};En([(0,wne.Property)({doc:"DynamoDB Table Name",default:"MicroApps",env:"DATABASE_TABLE_NAME"})],Dm.prototype,"tableName",2);var JL=pn(Yd()),sc=class{};En([(0,JL.Property)({doc:"Staging bucket to copy staged apps from",default:"microapps-staging",env:"FILESTORE_STAGING_BUCKET"})],sc.prototype,"stagingBucket",2),En([(0,JL.Property)({doc:"Destination bucket to copy staged apps to",default:"microapps",env:"FILESTORE_DEST_BUCKET"})],sc.prototype,"destinationBucket",2);var Gt=class{static configFiles(){let t=["./configs/config.yaml","./configs/config.yml",`./configs/config-${Gt.envLevel}.yaml`,`./configs/config-${Gt.envLevel}.yml`];return iE.getExistingFilesSync(t)}static get instance(){if(Gt._instance===void 0){let t=new yne.TSConvict(Gt);Gt._instance=t.load(Gt.configFiles())}return Gt._instance}static get envLevel(){let t=process.env.NODE_ENV||"dev";return t.startsWith("prod")?"prod":t==="qa"?"qa":t==="local"?"local":"dev"}};En([Gr.Property(Dm)],Gt.prototype,"db",2),En([Gr.Property(Lm)],Gt.prototype,"apigwy",2),En([Gr.Property(sc)],Gt.prototype,"filestore",2),En([Gr.Property({doc:"AWS Account ID for app Lambda function",default:"",env:"AWS_ACCOUNT_ID"})],Gt.prototype,"awsAccountID",2),En([Gr.Property({doc:"AWS Region for app Lambda function",default:"us-east-1",env:"AWS_REGION"})],Gt.prototype,"awsRegion",2),En([Gr.Property({doc:"Role name to be used for temp STS upload tokens",default:"microapps-deployer-upload-dev",env:"UPLOAD_ROLE_NAME"})],Gt.prototype,"uploadRoleName",2),En([Gr.Property({doc:"Path prefix for this deployment",default:"",env:"ROOT_PATH_PREFIX"})],Gt.prototype,"rootPathPrefix",2),En([Gr.Property({doc:"Require IAM Authorization on all created routes",default:!0,env:"REQUIRE_IAM_AUTHORIZATION"})],Gt.prototype,"requireIAMAuthorization",2),Gt=En([Gr.Config({file:"config.yml",validationMethod:"strict",parser:{extension:["yml","yaml"],parse:QY},formats:{url:oE.url,ipaddress:oE.ipaddress}})],Gt);var KL=pn(SC());function XL(e){return e==null||e===""}var Mm=class{static async CreateApp(t){let{dbManager:n,app:r}=t;return XL(r.appName)||XL(r.displayName)||XL(r.type)?{statusCode:400}:await KL.Application.Load({dbManager:n,key:{AppName:r.appName}})!==void 0?{statusCode:200}:(await new KL.Application({AppName:r.appName,DisplayName:r.displayName}).Save(n),{statusCode:201})}};var w2=pn(require("crypto")),vn=pn(mse()),Zt=pn(Bde()),$r=pn(xge()),VT=pn(Cd()),Es=pn(SC()),Kge=pn(Lge());var Xge=pn(Jge()),it=class{};it.Instance=new Xge.LambdaLog({silent:process.env.JEST_WORKER_ID!==void 0});var ji=new Zt.LambdaClient({maxAttempts:8}),gp=new $r.S3Client({maxAttempts:16}),O$t=new VT.STSClient({maxAttempts:8}),hp=new vn.ApiGatewayV2Client({maxAttempts:8}),fn=class{static async DeployVersionPreflight(t){var u,w,E;let{dbManager:n,request:r,config:i}=t,{appName:s,semVer:d,needS3Creds:a=!0,overwrite:c=!1}=r,l=await Es.Version.LoadVersion({dbManager:n,key:{AppName:s,SemVer:d}});if(l!==void 0&&l.Status!=="pending")if(c)it.Instance.info("Warning: App/Version already exists",{appName:r.appName,semVer:r.semVer});else return it.Instance.info("Error: App/Version already exists",{appName:r.appName,semVer:r.semVer}),{statusCode:200};if(it.Instance.info("App/Version does not exist",{appName:s,semVer:d}),a){let T={Statement:[{Effect:"Allow",Action:["s3:PutObject","s3:GetObject","s3:AbortMultipartUpload"],Resource:[`arn:aws:s3:::${i.filestore.stagingBucket}/*`]},{Effect:"Allow",Action:["s3:ListBucket"],Resource:[`arn:aws:s3:::${i.filestore.stagingBucket}`]}],Version:"2012-10-17"};it.Instance.debug("Temp IAM Policy",{policy:JSON.stringify(T)});let P=await O$t.send(new VT.AssumeRoleCommand({RoleArn:`arn:aws:iam::${i.awsAccountID}:role/${i.uploadRoleName}`,DurationSeconds:60*60,RoleSessionName:fn.SHA1Hash(fn.GetBucketPrefix(r,i)),Policy:JSON.stringify(T)}));return it.Instance.info("finished request - returning s3 creds"),{statusCode:404,s3UploadUrl:`s3://${i.filestore.stagingBucket}/${fn.GetBucketPrefix(r,i)}`,awsCredentials:{accessKeyId:(u=P.Credentials)==null?void 0:u.AccessKeyId,secretAccessKey:(w=P.Credentials)==null?void 0:w.SecretAccessKey,sessionToken:(E=P.Credentials)==null?void 0:E.SessionToken}}}else return it.Instance.info("finished request - not returning s3 creds"),{statusCode:404}}static async DeployVersion(t){let{dbManager:n,request:r,config:i}=t,{appType:s="lambda",overwrite:d=!1,startupType:a="iframe"}=r;it.Instance.debug("Got Body:",r);let c=await Es.Version.LoadVersion({dbManager:n,key:{AppName:r.appName,SemVer:r.semVer}});if(c!==void 0&&c.Status==="routed")if(d)it.Instance.info("Warning: App/Version already exists",{appName:r.appName,semVer:r.semVer});else return it.Instance.info("Error: App/Version already exists",{appName:r.appName,semVer:r.semVer}),{statusCode:409};if(a==="direct"&&["lambda"].includes(s))return it.Instance.info("Error: Incompatible app type and startup type",{appType:s,startupType:a}),{statusCode:400};if(d&&c&&(c.DefaultFile=r.defaultFile,c.Type=s,c.StartupType=a,r.lambdaARN&&(c.LambdaARN=r.lambdaARN)),c===void 0&&(c=new Es.Version(o({AppName:r.appName,SemVer:r.semVer,Type:s,Status:"pending",DefaultFile:r.defaultFile,StartupType:a},r.lambdaARN?{LambdaARN:r.lambdaARN}:{})),await c.Save(n)),d||c.Status==="pending"){let{stagingBucket:u}=i.filestore,w=fn.GetBucketPrefix(r,i)+"/";await fn.CopyToProdBucket(u,w,fn.GetBucketPrefix(r,i),i),c.DefaultFile=r.defaultFile,c.Status="assets-copied",await c.Save(n)}if(s==="lambda"){let u=i.apigwy.apiId;if(d||c.Status==="assets-copied"){let E=i.awsAccountID,T=i.awsRegion,P=!0;try{let I=await ji.send(new Zt.GetPolicyCommand({FunctionName:r.lambdaARN}));if(I.Policy!==void 0){let F=JSON.parse(I.Policy);F.Statement!==void 0&&F.Statement.filter(G=>G.Sid==="microapps-version-root"||G.Sid==="microapps-version").length===2&&(P=!1)}}catch(I){if(I.name!=="ResourceNotFoundException")throw I}P&&(await ji.send(new Zt.AddPermissionCommand({Principal:"apigateway.amazonaws.com",StatementId:"microapps-version-root",Action:"lambda:InvokeFunction",FunctionName:r.lambdaARN,SourceArn:`arn:aws:execute-api:${T}:${E}:${u}/*/*/${r.appName}/${r.semVer}`})),await ji.send(new Zt.AddPermissionCommand({Principal:"apigateway.amazonaws.com",StatementId:"microapps-version",Action:"lambda:InvokeFunction",FunctionName:r.lambdaARN,SourceArn:`arn:aws:execute-api:${T}:${E}:${u}/*/*/${r.appName}/${r.semVer}/{proxy+}`}))),c.Status="permissioned",await c.Save(n)}let w="";if(d||c.Status==="permissioned")if(c.IntegrationID!==void 0&&c.IntegrationID!=="")w=c.IntegrationID,it.Instance.info("integration already created, skipping creation",{IntegrationId:w});else{try{w=(await hp.send(new vn.CreateIntegrationCommand({ApiId:u,IntegrationType:vn.IntegrationType.AWS_PROXY,IntegrationMethod:"POST",PayloadFormatVersion:"2.0",IntegrationUri:r.lambdaARN}))).IntegrationId}catch(E){if(E.name==="AccessDeniedException")return it.Instance.error("AccessDeniedException adding integration to API Gateway",{error:E}),{statusCode:401}}c.IntegrationID=w,c.Status="integrated",await c.Save(n)}if(d||c.Status==="integrated"){if(c.RouteIDAppVersion!==void 0&&c.RouteIDAppVersion!=="")it.Instance.info("route app/version already created, skipping creation",{IntegrationId:w,RouteIDAppVersion:c.RouteIDAppVersion});else try{let E=await hp.send(new vn.CreateRouteCommand({ApiId:u,Target:`integrations/${w}`,RouteKey:`ANY /${r.appName}/${r.semVer}`,AuthorizationType:i.requireIAMAuthorization?vn.AuthorizationType.AWS_IAM:vn.AuthorizationType.NONE}));it.Instance.info("created RouteIDAppVersion",{result:E}),c.RouteIDAppVersion=`${E.RouteId}`}catch(E){if(E.name==="AccessDeniedException")return it.Instance.error("AccessDeniedException adding route to API Gateway",{error:E}),{statusCode:401};it.Instance.error("Caught unexpected error on app/ver route add"),it.Instance.error(E)}if(c.RouteIDAppVersionSplat!==void 0&&c.RouteIDAppVersionSplat!=="")it.Instance.info("route app/version/* already created, skipping creation",{IntegrationId:w,RouteIDAppVersionSplat:c.RouteIDAppVersionSplat});else try{let E=await hp.send(new vn.CreateRouteCommand({ApiId:u,Target:`integrations/${w}`,RouteKey:`ANY /${r.appName}/${r.semVer}/{proxy+}`,AuthorizationType:i.requireIAMAuthorization?vn.AuthorizationType.AWS_IAM:vn.AuthorizationType.NONE}));it.Instance.info("created RouteIDAppVersionSplat",{result:E}),c.RouteIDAppVersionSplat=`${E.RouteId}`}catch(E){if(E.name==="AccessDeniedException")return it.Instance.error("AccessDeniedException adding route to API Gateway",{error:E}),{statusCode:401};it.Instance.error("Caught unexpected error on {proxy+} route add"),it.Instance.error(E)}c.Status="routed",await c.Save(n)}}else if(s==="lambda-url"){if(!r.lambdaARN)throw new Error("Missing lambdaARN for lambda-url app type");let{lambdaARNBase:u,lambdaARNAlias:w}=fn.ExtractARNandAlias(r.lambdaARN);if(d||c.Status==="assets-copied"){let E=await ji.send(new Zt.ListTagsCommand({Resource:u}));(E.Tags===void 0||E.Tags["microapp-managed"]!=="true")&&await ji.send(new Zt.TagResourceCommand({Resource:u,Tags:{"microapp-managed":"true"}})),c.Status="permissioned",await c.Save(n)}if(d||c.Status==="permissioned"){let E,T;try{T=await ji.send(new Zt.GetFunctionUrlConfigCommand({FunctionName:u,Qualifier:w})),T.FunctionUrl&&(E=T.FunctionUrl)}catch(P){if(P.name!=="ResourceNotFoundException")throw P}T!=null&&T.FunctionUrl||(E=(await ji.send(new Zt.CreateFunctionUrlConfigCommand({FunctionName:u,Qualifier:w,AuthType:"AWS_IAM"}))).FunctionUrl),c.Status="routed",E&&(c.URL=E),await c.Save(n)}}else if(s==="static")c.Status==="assets-copied"&&(c.Status="routed",await c.Save(n));else throw new Error(`Unknown app type: ${s}`);let l=await Es.Rules.Load({dbManager:n,key:{AppName:r.appName}});return l===void 0&&(l=new Es.Rules({AppName:r.appName,RuleSet:{},Version:1}),l.RuleSet.default={SemVer:r.semVer,AttributeName:"",AttributeValue:""},await l.Save(n)),it.Instance.info("finished request"),{statusCode:201}}static ExtractARNandAlias(t){let n=t==null?void 0:t.substring(0,t.lastIndexOf(":")),r=t==null?void 0:t.substring(t.lastIndexOf(":")+1);return{lambdaARNBase:n,lambdaARNAlias:r}}static async DeleteVersion(t){let{dbManager:n,request:r,config:i}=t;it.Instance.debug("Got Body:",r);let s=await Es.Version.LoadVersion({dbManager:n,key:{AppName:r.appName,SemVer:r.semVer}});if(s===void 0)return it.Instance.info("Error: App/Version does not exist",{appName:r.appName,semVer:r.semVer}),{statusCode:404};let d=fn.GetBucketPrefix(r,i)+"/";if(await this.DeleteFromDestinationBucket(d,i),s.Type==="lambda"){let a=i.apigwy.apiId;if(s.RouteIDAppVersion===""&&s.RouteIDAppVersionSplat==="")it.Instance.warn("no RouteIDs to delete");else{for(let c of[s.RouteIDAppVersion,s.RouteIDAppVersionSplat])try{await hp.send(new vn.DeleteRouteCommand({ApiId:a,RouteId:c}))}catch(l){if(l.name==="AccessDeniedException")return it.Instance.error("AccessDeniedException removing route from API Gateway",{error:l,apiId:a,routeId:c}),{statusCode:401};it.Instance.error("Caught unexpected error on app/ver route remove",{error:l,apiId:a,routeId:c})}if(s.IntegrationID!==void 0&&s.IntegrationID!=="")try{await hp.send(new vn.DeleteIntegrationCommand({ApiId:a,IntegrationId:s.IntegrationID}))}catch(c){if(c.name==="AccessDeniedException")return it.Instance.error("AccessDeniedException removing integration from API Gateway",{error:c,apiId:a,integrationId:s.IntegrationID}),{statusCode:401};it.Instance.error("Caught unexpected error removing integration from API Gateway",{error:c,apiId:a,integrationId:s.IntegrationID})}}}if((s.Type==="lambda"||s.Type==="lambda-url")&&s.LambdaARN){let{lambdaARNBase:a,lambdaARNAlias:c}=fn.ExtractARNandAlias(s.LambdaARN);try{let l=await ji.send(new Zt.GetAliasCommand({FunctionName:a,Name:c}));if(await ji.send(new Zt.DeleteAliasCommand({FunctionName:a,Name:c})),l.FunctionVersion)try{await ji.send(new Zt.DeleteFunctionCommand({FunctionName:a,Qualifier:l.FunctionVersion}))}catch(u){if(u.name!=="ResourceConflictException")throw u;it.Instance.info("Version is still in use by another alias, not deleting")}}catch(l){if(l.name!=="ResourceNotFoundException")throw l}}return await Es.Version.DeleteVersion({dbManager:n,key:{AppName:r.appName,SemVer:r.semVer}}),it.Instance.info("finished request"),{statusCode:200}}static SHA256Hash(t){return w2.default.createHash("sha256").update(t).digest("hex")}static SHA1Hash(t){return w2.default.createHash("sha1").update(t).digest("hex")}static async CopyFilesInList(t,n,r,i,s){t===void 0||t.Contents===void 0||await(0,Kge.default)(t.Contents,async d=>{var c;let a=(c=d.Key)==null?void 0:c.slice(r.length);await gp.send(new $r.CopyObjectCommand({CopySource:`${n}/${d.Key}`,Bucket:s.filestore.destinationBucket,Key:`${i}/${a}`})),await gp.send(new $r.DeleteObjectCommand({Bucket:n,Key:d.Key}))},{concurrency:4})}static async CopyToProdBucket(t,n,r,i){let s;do{let d=(s==null?void 0:s.NextContinuationToken)!==void 0?{ContinuationToken:s.NextContinuationToken}:{};s=await gp.send(new $r.ListObjectsV2Command(o({Bucket:t,Prefix:n},d))),await fn.CopyFilesInList(s,t,n,r,i)}while(s.IsTruncated)}static async DeleteFromDestinationBucket(t,n){var i;let r;do{let s=(r==null?void 0:r.NextContinuationToken)!==void 0?{ContinuationToken:r.NextContinuationToken}:{};r=await gp.send(new $r.ListObjectsV2Command(o({Bucket:n.filestore.destinationBucket,Prefix:t},s)));let d=[];(i=r.Contents)==null||i.map(a=>{d.push({Key:a.Key})}),d.length>0&&await gp.send(new $r.DeleteObjectsCommand({Bucket:n.filestore.destinationBucket,Delete:{Objects:d}}))}while(r.IsTruncated)}static GetBucketPrefix(t,n){return`${n.rootPathPrefix===""?"":`${n.rootPathPrefix}/`}${fn.GetAppNameOrRootTrailingSlash(t)}${t.semVer}`.toLowerCase()}static GetAppNameOrRootTrailingSlash(t){return t.appName==="[root]"?"":`${t.appName}/`}};var B$t=it.Instance,qo,S2=new Wge.DynamoDBClient({maxAttempts:8});function F$t(e){qo=e.dbManager,S2=e.dynamoClient}qo=new y2.DBManager({dynamoClient:S2,tableName:Gt.instance.db.tableName});var wp=Gt.instance;async function j$t(e,t){if(B$t.options.meta={awsRequestId:t==null?void 0:t.awsRequestId,requestType:e.type},qo===void 0&&(qo=new y2.DBManager({dynamoClient:S2,tableName:Gt.instance.db.tableName})),wp.awsAccountID===""&&(t==null?void 0:t.invokedFunctionArn)!==void 0){let r=t.invokedFunctionArn.split(":")[4];r!==""&&(wp.awsAccountID=r)}it.Instance.info("received request",{request:e});try{switch(e.type){case"createApp":{let n=e;return await Mm.CreateApp({dbManager:qo,app:n})}case"deleteVersion":{let n=e;return await fn.DeleteVersion({dbManager:qo,request:n,config:wp})}case"deployVersionPreflight":{let n=e;return await fn.DeployVersionPreflight({dbManager:qo,request:n,config:wp})}case"deployVersion":{let n=e;return await fn.DeployVersion({dbManager:qo,request:n,config:wp})}default:return{statusCode:400}}}catch(n){return it.Instance.error("Caught unexpected exception in handler"),it.Instance.error(n),{statusCode:500}}}0&&(module.exports={handler,overrideDBManager});
 /*! *****************************************************************************
 Copyright (C) Microsoft. All rights reserved.
 Licensed under the Apache License, Version 2.0 (the "License"); you may not use