@byaga/cdk-patterns 0.6.1 → 0.8.0

package/src/CognitoApiGatewayAuthorizer.ts

@@ -0,0 +1,25 @@
+import { Construct } from 'constructs'
+import { CfnAuthorizer, IAuthorizer } from 'aws-cdk-lib/aws-apigateway'
+import { CfnAuthorizerProps } from 'aws-cdk-lib/aws-apigateway/lib/apigateway.generated'
+
+/**
+ * Custom construct that implements a Cognito based API Gateway Authorizer.
+ *
+ * @see https://docs.aws.amazon.com/cdk/latest/guide/constructs.html#constructs_author
+ *
+ * @see https://docs.aws.amazon.com/cdk/api/latest/docs/@aws-cdk_aws-apigateway.CfnAuthorizer.html
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-authorizer.html
+ * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html
+ * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-enable-cognito-user-pool.html
+ *
+ * @see https://github.com/aws/aws-cdk/issues/5618#issuecomment-666922559
+ */
+export class CognitoApiGatewayAuthorizer extends CfnAuthorizer implements IAuthorizer {
+    public readonly authorizerId: string
+
+    constructor(scope: Construct, id: string, props: CfnAuthorizerProps) {
+        super(scope, id, props)
+
+        this.authorizerId = this.ref
+    }
+}

package/src/{IDeployStack.ts → DeployStack.ts}

@@ -2,17 +2,17 @@ import {Stack} from 'aws-cdk-lib';
 import IStackArguments from './IStackArguments'
 import {IConstruct} from "constructs";
 
-export class IDeployStack extends Stack {
+export class DeployStack extends Stack {
     registry: { [t: string]: { [n: string]: any } } = {}
     stage: string
     name: string
 
     genName(...name: string[]): string {
-        return IDeployStack.genStackResourceName(this.name, this.stage, name.filter(n => !!n).join('-'))
+        return DeployStack.genStackResourceName(this.name, this.stage, name.filter(n => !!n).join('-'))
     }
 
     genId(...name: string[]): string {
-        return IDeployStack.genStackResourceId(this.name, this.stage, name.filter(n => !!n).join('-'))
+        return DeployStack.genStackResourceId(this.name, this.stage, name.filter(n => !!n).join('-'))
     }
 
     static genStackResourceName(stackName: string, resource: string, stage = 'develop') {
@@ -53,4 +53,4 @@ export class IDeployStack extends Stack {
         return instance;
     }
 }
-export default IDeployStack
+export default DeployStack

package/src/DynamoDbTable.ts

@@ -0,0 +1,40 @@
+import {CfnOutput, RemovalPolicy} from 'aws-cdk-lib';
+import {Table, BillingMode, AttributeType} from 'aws-cdk-lib/aws-dynamodb'
+import {Effect, Policy, PolicyStatement} from "aws-cdk-lib/aws-iam";
+import {DeployStack} from "./DeployStack"
+
+interface DynamoDbTableConfig {
+    partitionKey: string,
+    sortKey?: string
+}
+
+export class DynamoDbTable extends Table {
+    getPolicy: Policy
+
+    constructor(stack: DeployStack, id: string, props: DynamoDbTableConfig) {
+        console.log('Creating DynamoDb Table', stack.genName(id, 'data-table'))
+        super(stack, stack.genId(id, 'data-table'), {
+            tableName: stack.genName(id, 'data-table'),
+            partitionKey: {name: props.partitionKey, type: AttributeType.STRING},
+            sortKey: props.sortKey ? {name: props.sortKey, type: AttributeType.STRING} : undefined,
+            billingMode: BillingMode.PAY_PER_REQUEST,
+            removalPolicy: RemovalPolicy.DESTROY
+        });
+    stack.set('dynamo', id, this)
+
+        new CfnOutput(stack, stack.genId(id, 'table'), {
+            value: this.tableName,
+            exportName: stack.genName(id, 'table')
+        })
+
+        this.getPolicy = new Policy(stack, stack.genId(id, 'get-policy'), {
+            statements: [
+                new PolicyStatement({
+                    actions: ['dynamodb:GetItem'],
+                    effect: Effect.ALLOW,
+                    resources: [this.tableArn]
+                })
+            ]
+        })
+    }
+}

package/src/FunctionIntegration.ts

@@ -0,0 +1,83 @@
+import {DeployStack} from "./DeployStack";
+import {Function, FunctionProps} from "aws-cdk-lib/aws-lambda";
+import {
+    JsonSchema,
+    LambdaIntegration,
+    MethodOptions,
+    Model,
+    RequestValidator,
+    IResource
+} from "aws-cdk-lib/aws-apigateway";
+import {CfnOutput, Duration} from "aws-cdk-lib";
+import {applyHoneycombToLambda} from "./methods/apply-honeycomb-to-lambda";
+import {RetentionDays} from "aws-cdk-lib/aws-logs";
+import {RestApi} from "./RestApi";
+
+interface AddToApiOptions {
+    requestSchema?: JsonSchema,
+    methodOptions?: MethodOptions
+}
+
+export interface FunctionIntegrationProps {
+    funcProps: FunctionProps,
+    timeout?: Duration
+    memory?: number
+}
+
+export class FunctionIntegration extends Function {
+    stack: DeployStack
+    name: string
+
+    constructor(stack: DeployStack, id: string, options: FunctionIntegrationProps) {
+        const props = applyHoneycombToLambda(stack, {
+            functionName: stack.genName(id),
+            memorySize: options.memory || 256,
+            timeout: options.timeout || Duration.seconds(16),
+            logRetention: RetentionDays.ONE_WEEK,
+            ...options.funcProps
+        })
+
+        super(stack, stack.genId(id, 'lambda'), props);
+        this.stack = stack;
+        this.name = id;
+        stack.set('lambda', id, this)
+        new CfnOutput(stack, stack.genId(id, 'function-name'), {
+            value: this.functionName,
+            exportName: stack.genName(id, 'function-name')
+        });
+    }
+
+    attach(api: RestApi, httpMethod: string, path: string, props: AddToApiOptions) {
+        const resource: IResource = api.path(path)
+        const integration = new LambdaIntegration(this, {
+            requestTemplates: {
+                'application/json': '{ "statusCode": "200" }'
+            }
+        })
+
+        let options: MethodOptions = props?.methodOptions || {}
+        const schema = props?.requestSchema
+        if (schema) options = applySchema(this.stack, this.name, schema, options, resource)
+
+        const method = resource.addMethod(httpMethod, integration, options)
+    }
+}
+
+function applySchema(stack: DeployStack, name: string, schema: JsonSchema, options: MethodOptions, path: IResource): MethodOptions {
+    return {
+        ...options,
+        requestValidator: new RequestValidator(stack, stack.genId(name, 'validator'), {
+            restApi: path.api,
+            requestValidatorName: stack.genName(name, 'validator'),
+            validateRequestBody: true
+        }),
+        requestModels: {
+            'application/json': new Model(stack, stack.genId(name, 'model'), {
+                schema: schema,
+                contentType: 'application/json',
+                restApi: path.api,
+                modelName: stack.genId(name, 'model')
+            })
+        }
+    }
+}

package/src/ICorsConfig.ts

@@ -0,0 +1,5 @@
+export interface ICorsConfig {
+    maxAge?: number
+    exposeHeaders?: string[],
+    allowOrigin?: string|string[]
+}

package/src/NodeJsLambda.ts

@@ -0,0 +1,31 @@
+import {Code, FunctionOptions, Runtime} from "aws-cdk-lib/aws-lambda"
+import {DeployStack} from "./DeployStack";
+import {FunctionIntegration} from "./FunctionIntegration";
+import {buildNodeSource} from "./methods/build-node-source";
+import {Duration} from "aws-cdk-lib";
+import duration from "./methods/duration";
+
+interface NodeFunctionProps {
+    funcProps?: FunctionOptions
+    timeout?: Duration
+    memory?: number
+}
+
+export class NodeJsLambda extends FunctionIntegration {
+    constructor(stack: DeployStack, id: string, options?: NodeFunctionProps) {
+        console.log('Defining Node Lambda', id)
+        const done = duration()
+        const {buildDir} = buildNodeSource('lambda', id)
+        console.log('Total Build Duration (ms)', done())
+
+        super(stack, id, {
+            ...options,
+            funcProps: {
+                ...options?.funcProps,
+                code: Code.fromAsset(buildDir),
+                handler: `${id}.handler`,
+                runtime: Runtime.NODEJS_18_X
+            }
+        })
+    }
+}

package/src/Output.ts

@@ -0,0 +1,11 @@
+import {CfnOutput} from 'aws-cdk-lib/core';
+import {DeployStack} from './DeployStack';
+
+export class Output extends CfnOutput {
+    constructor(stack: DeployStack, name: string, value: string) {
+        super(stack, stack.genId(name, 'output'), {
+            value,
+            exportName: stack.genName(name)
+        })
+    }
+}

package/src/RestApi.ts

@@ -0,0 +1,178 @@
+import {
+    RestApi as RestApiBase,
+    BasePathMapping,
+    ContentHandling,
+    DomainName,
+    EndpointType,
+    MockIntegration,
+    IDomainName,
+    IResource
+} from "aws-cdk-lib/aws-apigateway";
+import {DeployStack} from "./DeployStack"
+import {ICorsConfig} from "./ICorsConfig";
+import {Duration, Size} from "aws-cdk-lib";
+import {Effect, Policy, PolicyStatement, Role} from "aws-cdk-lib/aws-iam";
+
+interface IRestApiConfig {
+    cors?: ICorsConfig,
+    allowCredentials: boolean
+}
+
+interface IBasePathMappingConfig {
+    domain?: IDomainName,
+    domainName?: string,
+    hostedZoneId?: string
+}
+
+interface IResourceNode {
+    children: { [key: string]: IResourceNode }
+    node: IResource
+}
+
+const DEFAULT_EXPOSE_HEADERS = ['Date']
+
+export class RestApi extends RestApiBase {
+    _id: string
+    _tree: IResourceNode
+
+
+    constructor(stack: DeployStack, id: string, props: IRestApiConfig) {
+        const {stage} = stack
+
+        console.log('Defining Rest API', stack.genId(id, 'api'))
+
+        const cors: ICorsConfig = props.cors || {}
+        const allowOrigins: string[] = Array.isArray(cors.allowOrigin) ? cors.allowOrigin : [cors.allowOrigin || '*']
+        super(stack, stack.genId(id, 'api'), {
+            restApiName: stack.genName('api'),
+            deploy: true,
+            deployOptions: {
+                stageName: stage,
+                tracingEnabled: true
+            },
+            minCompressionSize: Size.bytes(1000),
+            endpointConfiguration: {
+                types: [EndpointType.EDGE]
+            },
+            defaultCorsPreflightOptions: {
+                allowHeaders: ['*'],
+                allowMethods: ['*'],
+                allowCredentials: props.allowCredentials,
+                allowOrigins,
+                maxAge: Duration.seconds(cors.maxAge || 86400),
+                exposeHeaders: cors.exposeHeaders || DEFAULT_EXPOSE_HEADERS
+            }
+        })
+        this._id = id
+
+        // APIs MUST have at least one endpoint, so this will give it one
+        console.log('Adding health endpoint', '/health')
+        const health = this.root.addResource('health')
+        health.addMethod("GET", new MockIntegration({
+            requestTemplates: {
+                "application/json": "{\"statusCode\": 200}"
+            },
+            integrationResponses: [{
+                statusCode: '200',
+                contentHandling: ContentHandling.CONVERT_TO_TEXT,
+                responseTemplates: {
+                    'application/json': `
+##  See http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html
+##  This template will pass through all parameters including path, querystring, header, stage variables, and context through to the integration endpoint via the body/payload
+#set($allParams = $input.params())
+{
+"body-json" : $input.json('$'),
+"params" : {
+#foreach($type in $allParams.keySet())
+    #set($params = $allParams.get($type))
+"$type" : {
+    #foreach($paramName in $params.keySet())
+    "$paramName" : "$util.escapeJavaScript($params.get($paramName))"
+        #if($foreach.hasNext),#end
+    #end
+}
+    #if($foreach.hasNext),#end
+#end
+},
+"stage-variables" : {
+#foreach($key in $stageVariables.keySet())
+"$key" : "$util.escapeJavaScript($stageVariables.get($key))"
+    #if($foreach.hasNext),#end
+#end
+},
+"context" : {
+    "account-id" : "$context.identity.accountId",
+    "api-id" : "$context.apiId",
+    "api-key" : "$context.identity.apiKey",
+    "authorizer-principal-id" : "$context.authorizer.principalId",
+    "caller" : "$context.identity.caller",
+    "cognito-authentication-provider" : "$context.identity.cognitoAuthenticationProvider",
+    "cognito-authentication-type" : "$context.identity.cognitoAuthenticationType",
+    "cognito-identity-id" : "$context.identity.cognitoIdentityId",
+    "cognito-identity-pool-id" : "$context.identity.cognitoIdentityPoolId",
+    "http-method" : "$context.httpMethod",
+    "stage" : "$context.stage",
+    "source-ip" : "$context.identity.sourceIp",
+    "user" : "$context.identity.user",
+    "user-agent" : "$context.identity.userAgent",
+    "user-arn" : "$context.identity.userArn",
+    "request-id" : "$context.requestId",
+    "resource-id" : "$context.resourceId",
+    "resource-path" : "$context.resourcePath"
+    }
+}`
+                }
+            }]
+        }), {
+            methodResponses: [{statusCode: "200"}]
+        })
+
+        this._tree = {node: this.root, children: {}}
+    }
+
+    addBasePathMapping(stack: DeployStack, config: IBasePathMappingConfig) {
+        let domain = config.domain
+        if (!domain && config.domainName && config.hostedZoneId) {
+            domain = DomainName.fromDomainNameAttributes(stack, stack.genName('domain-name'), {
+                domainName: config.domainName,
+                domainNameAliasHostedZoneId: config.hostedZoneId,
+                domainNameAliasTarget: this.restApiRootResourceId
+            })
+        }
+        if (!domain) throw new Error('Missing Domain Configuration For Base Path Mapping')
+
+        new BasePathMapping(stack, stack.genId(this._id, 'base-path-mapping'), {
+            domainName: domain,
+            stage: this.deploymentStage,
+            restApi: this,
+            basePath: this._id
+        })
+    }
+
+    addAuthorizedRole(stack: DeployStack, roleArn: string): PolicyStatement {
+        const policyStatement = new PolicyStatement({
+            effect: Effect.ALLOW,
+            actions: ['execute-api:Invoke']
+        })
+
+        const authRole = Role.fromRoleArn(stack, stack.genId('authenticated-role'), roleArn)
+        authRole.attachInlinePolicy(new Policy(stack, stack.genId('api-access-policy'), {
+            statements: [policyStatement]
+        }))
+        return policyStatement;
+    }
+
+    path(uri: string): IResource {
+        const {node} = uri.split('/').reduce((resource, path) => {
+            if (!resource.children[path]) {
+                resource.children[path] = {
+                    children: {},
+                    node: resource.node.addResource(path)
+                }
+            }
+            return resource.children[path];
+        }, this._tree);
+
+        return node
+    }
+}

package/src/Role.ts

@@ -1,6 +1,7 @@
 import {FederatedPrincipal, IPrincipal, Role as CdkRole} from "aws-cdk-lib/aws-iam";
-import {CfnOutput, Duration} from "aws-cdk-lib";
-import {IDeployStack} from "./IDeployStack";
+import {Duration} from "aws-cdk-lib";
+import {Output} from './Output'
+import {DeployStack} from "./DeployStack";
 import {IManagedPolicy} from "aws-cdk-lib/aws-iam/lib/managed-policy";
 import {PolicyDocument} from "aws-cdk-lib/aws-iam/lib/policy-document";
 
@@ -137,7 +138,7 @@ interface IRoleProps {
 }
 
 export class Role extends CdkRole {
-    constructor(stack: IDeployStack, id: string, props: IRoleProps) {
+    constructor(stack: DeployStack, id: string, props: IRoleProps) {
         console.log('Defining Role', stack.genId(id))
         if (!props.assumedBy) {
             props.assumedBy = new FederatedPrincipal(
@@ -159,9 +160,6 @@ export class Role extends CdkRole {
             roleName: stack.genName(props.roleName || id),
             assumedBy: props.assumedBy
         })
-        new CfnOutput(stack, stack.genId(id, 'arn-output'), {
-            value: this.roleArn,
-            exportName: stack.genName(id, 'arn')
-        })
+        new Output(stack, `${id}-arn`, this.roleArn)
     }
 }

package/src/SsmParameter.ts

@@ -0,0 +1,47 @@
+import {DeployStack} from "./DeployStack";
+import {IStringParameter, StringParameter} from "aws-cdk-lib/aws-ssm";
+import {Effect, IGrantable, PolicyStatement} from "aws-cdk-lib/aws-iam";
+import {IKey} from "aws-cdk-lib/aws-kms";
+
+const paramCache: { [name: string]: IStringParameter } = {}
+
+interface SsmParameterOptions {
+    decryptWithKey?: IKey
+}
+
+export class SsmParameter {
+    parameterName: string
+    parameterArn: string
+    decryptWithKey?: IKey
+    _stack: DeployStack
+
+    constructor(stack: DeployStack, name: string, options?: SsmParameterOptions) {
+        if (name[0] !== '/') name = '/' + name
+        this.parameterName = `/${stack.name}${name}`;
+        this.parameterArn = `arn:aws:ssm:${stack.region}:${stack.account}:parameter${this.parameterName}`
+        this._stack = stack;
+        this.decryptWithKey = options?.decryptWithKey
+    }
+
+    grantRead(grantee: IGrantable) {
+        grantee.grantPrincipal.addToPrincipalPolicy(new PolicyStatement({
+            effect: Effect.ALLOW,
+            actions: ['ssm:GetParameter'],
+            resources: [this.parameterArn]
+        }))
+        if (this.decryptWithKey) {
+            this.decryptWithKey.grantDecrypt(grantee)
+        }
+    }
+
+    get stringValue() {
+        return this.getParameter().stringValue
+    }
+
+    getParameter() {
+        if (!paramCache[this.parameterArn]) {
+            paramCache[this.parameterArn] = StringParameter.fromStringParameterName(this._stack, this._stack.genId(this.parameterName.substring(1).replace('/', '_')), this.parameterName)
+        }
+        return paramCache[this.parameterArn]
+    }
+}

package/src/StaticWebSite.ts

@@ -0,0 +1,99 @@
+import {RemovalPolicy} from "aws-cdk-lib/core";
+import {Output} from './Output'
+import {DeployStack} from "./DeployStack";
+import {execSync} from "child_process";
+import * as fs from 'fs-extra'
+import * as path from 'path'
+import {Bucket} from "aws-cdk-lib/aws-s3"
+import {BucketDeployment, Source} from "aws-cdk-lib/aws-s3-deployment"
+import ApiCertificate from "./ApiCertificate";
+import {
+    CloudFrontAllowedMethods,
+    CloudFrontWebDistribution,
+    OriginAccessIdentity,
+    SSLMethod,
+    ViewerCertificate,
+    ViewerProtocolPolicy
+} from "aws-cdk-lib/aws-cloudfront"
+import IDomainConfig from "./IDomainConfig";
+import {PolicyStatement} from "aws-cdk-lib/aws-iam";
+import {ARecord, RecordTarget} from "aws-cdk-lib/aws-route53";
+import {CloudFrontTarget} from "aws-cdk-lib/aws-route53-targets";
+
+interface StaticWebSiteConfig {
+    srcDir?: string,
+    domain: IDomainConfig,
+    env: NodeJS.ProcessEnv
+}
+
+export class StaticWebSite {
+    constructor(stack: DeployStack, id: string, props: StaticWebSiteConfig) {
+        console.log('Deploying Static Web Site', id)
+        const srcDir = path.resolve("../src/", props.srcDir || '')
+        const buildDir = path.resolve("../dist/", props.srcDir || '')
+
+        console.log('Installing Prod Dependencies', id)
+        execSync('npm i --production --quiet', {
+            cwd: srcDir
+        })
+        console.log('Building UI Source', id)
+        execSync('npm run export', {
+            cwd: srcDir,
+            //env: props.env
+        })
+        fs.copySync(path.resolve(srcDir, "./out"), buildDir);
+
+        console.log('Creating HTTPS Certificate', id + '-certificate')
+        const certificate = new ApiCertificate(stack, id + '-certificate', props.domain);
+        console.log('Deploying Site Content Bucket', stack.genId(id, "content-bucket"))
+        const s3BucketSource = new Bucket(stack, stack.genId(id, "content-bucket"), {
+            bucketName: certificate.domain,
+            websiteIndexDocument: "index.html",
+            websiteErrorDocument: "error.html",
+            publicReadAccess: true,
+            removalPolicy: RemovalPolicy.DESTROY,
+            autoDeleteObjects: true
+        });
+        new Output(stack, `${id}-content-bucket`, s3BucketSource.bucketName);
+
+        const cloudFrontPolicy = new PolicyStatement({
+            actions: ['s3:GetBucket*', 's3:GetObject*', 's3:List*'],
+            resources: [s3BucketSource.bucketArn, s3BucketSource.bucketArn + '/*'],
+        })
+
+        new BucketDeployment(stack, stack.genId(id, 'bucket-deployment'), {
+            sources: [Source.asset(buildDir)],
+            destinationBucket: s3BucketSource
+        })
+        const originAccessIdentity = new OriginAccessIdentity(stack, "WebsiteOAI");
+         cloudFrontPolicy.addArnPrincipal(originAccessIdentity.cloudFrontOriginAccessIdentityS3CanonicalUserId)
+
+        const distro = new CloudFrontWebDistribution(stack, stack.genId(id, 'cloudfront-web-distribution'), {
+            enabled: true,
+            //priceClass:
+             originConfigs: [{
+                 s3OriginSource: {
+                     s3BucketSource,
+                     originAccessIdentity
+                 },
+                 behaviors: [{
+                     allowedMethods: CloudFrontAllowedMethods.GET_HEAD_OPTIONS,
+                     isDefaultBehavior: true
+                 }]
+             }],
+            viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+            viewerCertificate: ViewerCertificate.fromAcmCertificate(certificate, {
+                aliases: [certificate.domain],
+                sslMethod: SSLMethod.SNI
+            })
+        })
+        new Output(stack, `${id}-base-url`, "https://" + certificate.domain);
+
+        console.log('Setting Route53 A-Name Record', props.domain.domainName)
+         new ARecord(stack, stack.genId('alias'), {
+             zone: certificate.hostedZone,
+             recordName: certificate.domain,
+             target: RecordTarget.fromAlias(new CloudFrontTarget(distro))
+         })
+    }
+}

package/src/index.ts

@@ -1,6 +1,12 @@
 export {ApiCertificate} from "./ApiCertificate";
-export {IDeployStack} from "./IDeployStack";
+export {DeployStack} from "./DeployStack";
 export {IDomainConfig} from "./IDomainConfig";
 export {IHostedZoneConfig} from "./IHostedZoneConfig";
 export {IStackArguments} from "./IStackArguments";
 export {Role} from "./Role";
+export {StaticWebSite} from "./StaticWebSite";
+export {Output} from "./Output";
+export {RestApi} from "./RestApi";
+export {NodeJsLambda} from "./NodeJsLambda";
+export {DynamoDbTable} from "./DynamoDbTable";
+export {FunctionIntegration} from "./FunctionIntegration";

package/src/methods/apply-honeycomb-to-lambda.ts

@@ -0,0 +1,22 @@
+import {FunctionProps, ILayerVersion, LayerVersion} from "aws-cdk-lib/aws-lambda"
+import {DeployStack} from "../DeployStack";
+import {SsmParameter} from "../SsmParameter";
+
+let honeyCombLayer: ILayerVersion
+export function applyHoneycombToLambda(stack: DeployStack, props: FunctionProps): FunctionProps {
+    if (!honeyCombLayer) honeyCombLayer = LayerVersion.fromLayerVersionArn(stack, stack.genId('hc-layer'), `arn:aws:lambda:${stack.region}:702835727665:layer:honeycomb-lambda-extension-x86_64-v11-1-1:1`)
+
+    const layers = props.layers ? [...props.layers] : []
+    const environment = props.environment || {}
+
+    layers.push(honeyCombLayer)
+    environment.LIBHONEY_API_KEY = new SsmParameter(stack, `/honeycomb/api-key`).stringValue
+    environment.LIBHONEY_DATASET =new SsmParameter(stack, `/honeycomb/dataset`).stringValue
+    environment.LOGS_API_DISABLE_PLATFORM_MSGS = "true"
+
+    return {
+        ...props,
+        layers,
+        environment
+    }
+}