@fjall/components-infrastructure 2.29.0 → 2.30.3

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

@@ -0,0 +1,67 @@
+import { Construct } from "constructs";
+import { type Role } from "aws-cdk-lib/aws-iam";
+import { type CICDProvider } from "../../resources/aws/cicd/cicdRole";
+export interface CICDRoleProps {
+    /**
+     * The CI/CD provider (github-actions, buildkite, gitlab-ci)
+     */
+    provider: CICDProvider;
+    /**
+     * For GitHub Actions: repository in format "org/repo"
+     * For Buildkite: organization slug
+     * For GitLab CI: project path in format "group/project"
+     */
+    repositoryOrOrg: string;
+    /**
+     * Optional custom role name
+     * Defaults to "FjallDeploy-{provider}-{appName}"
+     */
+    roleName?: string;
+    /**
+     * Optional ARN of existing OIDC provider (skips creation)
+     * Useful when OIDC provider already exists in the account
+     */
+    existingProviderArn?: string;
+}
+/**
+ * High-level pattern for adding CI/CD OIDC authentication to an application.
+ *
+ * This creates an OIDC provider (if needed) and a deploy role that can be assumed
+ * by your CI/CD system without long-lived credentials.
+ *
+ * @example
+ * ```typescript
+ * import { App, CICDRole } from "@fjall/components-infrastructure";
+ *
+ * const app = App.getApp("MyApp");
+ *
+ * // Add GitHub Actions OIDC authentication
+ * const cicdRole = new CICDRole(app, "GitHubDeployRole", {
+ *   provider: "github-actions",
+ *   repositoryOrOrg: "myorg/myrepo"
+ * });
+ *
+ * // Continue with normal application setup
+ * app.addCompute(/* ... *\/);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Use existing OIDC provider (created via fjall cicd setup)
+ * const cicdRole = new CICDRole(app, "GitHubDeployRole", {
+ *   provider: "github-actions",
+ *   repositoryOrOrg: "myorg/myrepo",
+ *   existingProviderArn: "arn:aws:iam::123456789012:oidc-provider/token.actions.githubusercontent.com"
+ * });
+ * ```
+ */
+export declare class CICDRole extends Construct {
+    readonly role: Role;
+    readonly provider: CICDProvider;
+    constructor(scope: Construct, id: string, props: CICDRoleProps);
+    /**
+     * Get the role ARN for use in CI/CD configuration
+     */
+    getRoleArn(): string;
+}
+export default CICDRole;

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CICDRole = void 0;
+const constructs_1 = require("constructs");
+const app_1 = require("../../app");
+const cicdRole_1 = require("../../resources/aws/cicd/cicdRole");
+/**
+ * High-level pattern for adding CI/CD OIDC authentication to an application.
+ *
+ * This creates an OIDC provider (if needed) and a deploy role that can be assumed
+ * by your CI/CD system without long-lived credentials.
+ *
+ * @example
+ * ```typescript
+ * import { App, CICDRole } from "@fjall/components-infrastructure";
+ *
+ * const app = App.getApp("MyApp");
+ *
+ * // Add GitHub Actions OIDC authentication
+ * const cicdRole = new CICDRole(app, "GitHubDeployRole", {
+ *   provider: "github-actions",
+ *   repositoryOrOrg: "myorg/myrepo"
+ * });
+ *
+ * // Continue with normal application setup
+ * app.addCompute(/* ... *\/);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Use existing OIDC provider (created via fjall cicd setup)
+ * const cicdRole = new CICDRole(app, "GitHubDeployRole", {
+ *   provider: "github-actions",
+ *   repositoryOrOrg: "myorg/myrepo",
+ *   existingProviderArn: "arn:aws:iam::123456789012:oidc-provider/token.actions.githubusercontent.com"
+ * });
+ * ```
+ */
+class CICDRole extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        // Get the App instance
+        const app = scope instanceof app_1.default ? scope : app_1.default.getInstance();
+        const networkStack = app.getDefaultNetworkStack();
+        this.provider = props.provider;
+        // Build the config for the factory
+        const config = {
+            provider: props.provider,
+            appName: app["name"],
+            repositoryOrOrg: props.repositoryOrOrg,
+            roleName: props.roleName,
+            existingProviderArn: props.existingProviderArn
+        };
+        // Create the CI/CD role using the factory
+        this.role = cicdRole_1.default.build(`${app["name"]}CICDRole`, config)(app, networkStack.getStack());
+        // Register the role with the network stack
+        networkStack.addConstruct(this.role);
+    }
+    /**
+     * Get the role ARN for use in CI/CD configuration
+     */
+    getRoleArn() {
+        return this.role.roleArn;
+    }
+}
+exports.CICDRole = CICDRole;
+exports.default = CICDRole;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -221,6 +221,10 @@ export class ComputeFactory {
                         ...computeProps,
                         appName: app.getName()
                     };
+                    // `ecrRepository` is already defaulted to the app's shared default
+                    // container registry above (line ~323) when omitted — the same
+                    // repo ECS services push into — so a container Lambda always has
+                    // one by this point, whether or not `docker` is set.
                     // Always register Lambda with manifest collector for CLI discovery
                     // This ensures all Lambdas are discoverable for secrets management,
                     // even those that don't currently have secrets configured
@@ -242,6 +246,11 @@ export class ComputeFactory {
                     if (lambdaImportedSecretNames.size > 0) {
                         manifestLambda.importedSecretNames = Array.from(lambdaImportedSecretNames);
                     }
+                    if (lambdaComputeProps.deployment === "container" &&
+                        lambdaComputeProps.docker !== undefined) {
+                        manifestLambda.docker = lambdaComputeProps.docker;
+                        manifestLambda.imageKey = lambdaComputeProps.image ?? id;
+                    }
                     collector.addLambda(manifestLambda);
                     return new LambdaCompute(scope, id, lambdaComputeProps);
                 }

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

@@ -8,6 +8,7 @@ import { type ILambdaCompute } from "./interfaces/compute.js";
 import { type ConnectionSpec } from "./interfaces/connector.js";
 import { LambdaFunction } from "../../resources/aws/compute/lambda.js";
 import { type SecretImport } from "../../resources/aws/secrets/index.js";
+import { type DockerBuild } from "@fjall/util/manifest/schemas";
 export { Architecture, HttpMethod, InvokeMode, type FunctionUrlCorsOptions } from "aws-cdk-lib/aws-lambda";
 /**
  * Lambda function URL configuration.
@@ -114,17 +115,47 @@ interface BaseLambdaProps {
  * automatically set to FROM_IMAGE.
  *
  * @example
+ * // Bring your own image (built/pushed out of band)
  * app.addCompute(ComputeFactory.build("ImageLambda", {
  *   type: "lambda",
  *   deployment: "container",
  *   ecrRepository: app.getDefaultContainerRegistry()
  * }));
+ *
+ * @example
+ * // fjall builds and pushes the image on every `fjall deploy`
+ * app.addCompute(ComputeFactory.build("ImageLambda", {
+ *   type: "lambda",
+ *   deployment: "container",
+ *   docker: { path: "lambda.Dockerfile" }
+ * }));
  */
 export interface ContainerLambdaProps extends BaseLambdaProps {
     /** Container-based deployment using ECR image */
     deployment: "container";
-    /** ECR repository containing the Lambda container image */
-    ecrRepository: Repository | RepositoryImage;
+    /**
+     * ECR repository containing the Lambda container image. Optional when
+     * `docker` is set — defaults to the app's shared default container
+     * registry (the same repo ECS services push into).
+     */
+    ecrRepository?: Repository | RepositoryImage;
+    /**
+     * When set, `fjall deploy` builds and pushes this Dockerfile into the app's
+     * shared default container registry, then wires the function to the
+     * resulting content-hash-tagged image — the same mechanism ECS services
+     * already use. Omit to keep managing the image out of band (the previous
+     * behaviour: the function tracks a moving `:latest` tag in `ecrRepository`).
+     */
+    docker?: DockerBuild;
+    /**
+     * Shared build/tag key for Lambda functions that intentionally run the
+     * same container image (e.g. several handlers packaged from one
+     * Dockerfile). Functions sharing one `image` value build once and share
+     * one content-hash tag. Defaults to this Lambda's own construct id, so
+     * omitting it is safe when no sharing is intended. Only meaningful when
+     * `docker` is set.
+     */
+    image?: string;
 }
 /**
  * Code-based Lambda using inline code or S3.
@@ -177,8 +208,12 @@ export interface ResolvedLambdaDeployment {
 /**
  * Resolve Lambda deployment configuration from props.
  * Handles container vs code deployment types.
+ *
+ * `scope`/`id` are only used on the container-with-`docker` path, to create
+ * (or reuse) the per-key `CfnParameter` that `fjall deploy` overrides with
+ * the content-hash tag after building and pushing the image.
  */
-export declare function resolveLambdaDeployment(props: LambdaComputeProps): ResolvedLambdaDeployment;
+export declare function resolveLambdaDeployment(scope: Construct, id: string, props: LambdaComputeProps): ResolvedLambdaDeployment;
 /**
  * Lambda compute wrapper implementing ILambdaCompute.
  * Provides type-safe access to Lambda-specific resources.

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

@@ -4,18 +4,45 @@ import { Repository } from "aws-cdk-lib/aws-ecr";
 import { Construct } from "constructs";
 import { processConnections } from "../../utils/connections.js";
 import { LambdaFunction } from "../../resources/aws/compute/lambda.js";
+import { getOrCreateImageTagParameter } from "../../resources/aws/compute/imageTagParameter.js";
 import { COMPUTE_DEFAULTS } from "./compute.js";
+import { evaluateBakeGuard } from "@fjall/util/docker";
+import { toKebab } from "@fjall/util";
 // Re-export Lambda types from CDK for user convenience
 export { Architecture, HttpMethod, InvokeMode } from "aws-cdk-lib/aws-lambda";
 /**
  * Resolve Lambda deployment configuration from props.
  * Handles container vs code deployment types.
+ *
+ * `scope`/`id` are only used on the container-with-`docker` path, to create
+ * (or reuse) the per-key `CfnParameter` that `fjall deploy` overrides with
+ * the content-hash tag after building and pushing the image.
  */
-export function resolveLambdaDeployment(props) {
+export function resolveLambdaDeployment(scope, id, props) {
     if (props.deployment === "container") {
+        if (!props.ecrRepository) {
+            throw new Error(`Lambda '${id}': ecrRepository is required unless \`docker\` is set ` +
+                "(ComputeFactory fills it in automatically from the app's default container registry when docker is present).");
+        }
         if (!(props.ecrRepository instanceof Repository)) {
             throw new Error("ecrRepository must be a Repository instance for Lambda compute type");
         }
+        if (props.docker !== undefined) {
+            const appPrefix = props.appName !== undefined ? toKebab(props.appName) : "";
+            const findings = evaluateBakeGuard(props.docker.buildArgs, appPrefix).findings;
+            if (findings.length > 0) {
+                throw new Error(`Lambda '${id}': ${findings.map((f) => f.message).join(" ")}`);
+            }
+            const tagKey = props.image ?? id;
+            const param = getOrCreateImageTagParameter(scope, tagKey);
+            return {
+                code: Code.fromEcrImage(props.ecrRepository, {
+                    tagOrDigest: param.valueAsString
+                }),
+                handler: Handler.FROM_IMAGE,
+                runtime: Runtime.FROM_IMAGE
+            };
+        }
         return {
             code: Code.fromEcrImage(props.ecrRepository, {
                 tagOrDigest: COMPUTE_DEFAULTS.ECS.IMAGE_TAG
@@ -40,7 +67,7 @@ export class LambdaCompute extends Construct {
     lambdaFunction;
     constructor(scope, id, props) {
         super(scope, id);
-        const { code, handler, runtime } = resolveLambdaDeployment(props);
+        const { code, handler, runtime } = resolveLambdaDeployment(scope, id, props);
         // Convert presence-based functionUrl config to legacy boolean format
         const functionUrlConfig = props.functionUrl;
         const enableFunctionUrl = functionUrlConfig !== undefined && functionUrlConfig !== false;

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

@@ -0,0 +1,28 @@
+import { Construct } from "constructs";
+import { type ARecordProps, type CnameRecordProps, HostedZone as AWSHostedZone, type MxRecordProps, type NsRecordProps, type TxtRecordProps } from "aws-cdk-lib/aws-route53";
+import { type AwsStack } from "../../resources";
+export interface HostedZoneProps {
+    zoneName: string;
+    hostedZoneId?: string;
+}
+export declare class HostedZoneFactory {
+    static import(stack: AwsStack, hostedZoneId: string, zoneName: string): HostedZone;
+}
+export declare class HostedZone extends Construct {
+    private hostedZone;
+    private hostedZoneId;
+    private importedHostedZone;
+    private zoneName;
+    private scope;
+    constructor(scope: Construct, id: string, props: HostedZoneProps);
+    getInternalHostedZone(): AWSHostedZone;
+    safeZoneName(): string;
+    addHostedZone(zoneName: string): void;
+    importHostedZone(zoneName: string): void;
+    delegateHostedZone(): void;
+    addARecord(props: Omit<ARecordProps, "zone">): void;
+    addCname(props: Omit<CnameRecordProps, "zone">): void;
+    addMx(props: Omit<MxRecordProps, "zone">): void;
+    addNS(props: Omit<NsRecordProps, "zone">): void;
+    addTxt(props: Omit<TxtRecordProps, "zone">): void;
+}

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

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostedZone = exports.HostedZoneFactory = void 0;
+const constructs_1 = require("constructs");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const iam_1 = require("../../resources/aws/iam");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_route53_1 = require("aws-cdk-lib/aws-route53");
+function getSafeZoneName(zoneName) {
+    return zoneName.split(".").join("");
+}
+class HostedZoneFactory {
+    static import(stack, hostedZoneId, zoneName) {
+        const safeZoneName = getSafeZoneName(zoneName);
+        return new HostedZone(stack.getStack(), `${safeZoneName}HostedZone`, {
+            hostedZoneId: hostedZoneId,
+            zoneName: zoneName
+        });
+    }
+}
+exports.HostedZoneFactory = HostedZoneFactory;
+class HostedZone extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.scope = scope;
+        this.zoneName = props.zoneName;
+        // If a hostedZoneId is provided import it, unless create a new hosted zone
+        if (!props.hostedZoneId) {
+            this.addHostedZone(props.zoneName);
+            this.hostedZoneId = this.hostedZone.hostedZoneId;
+            this.delegateHostedZone();
+        }
+        else {
+            this.hostedZoneId = props.hostedZoneId;
+            this.importHostedZone(props.zoneName);
+        }
+    }
+    getInternalHostedZone() {
+        return this.hostedZone || this.importedHostedZone;
+    }
+    safeZoneName() {
+        return getSafeZoneName(this.zoneName);
+    }
+    addHostedZone(zoneName) {
+        this.hostedZone = new aws_route53_1.HostedZone(this, `${this.safeZoneName}HostedZone`, {
+            zoneName: zoneName,
+            comment: `Hosted Zone for ${zoneName}`
+        });
+    }
+    importHostedZone(zoneName) {
+        this.importedHostedZone = aws_route53_1.HostedZone.fromHostedZoneAttributes(
+        // HostedZone.fromHostedZoneAttributes explicitly must be passed a stack as parent scope
+        this.scope, 
+        // Use safeZoneName in the id so we can theoretically
+        //  import multiple hosted zones in a single app
+        `${this.safeZoneName()}ImportedHostedZone`, {
+            hostedZoneId: this.hostedZoneId,
+            zoneName: zoneName
+        });
+        aws_cdk_lib_1.Tags.of(this.importedHostedZone).add("fjall:costAllocation:environment", "management");
+        aws_cdk_lib_1.Tags.of(this.importedHostedZone).add("fjall:costAllocation:service", "hostedZone");
+        aws_cdk_lib_1.Tags.of(this.importedHostedZone).add("fjall:costAllocation:domain", zoneName);
+        // Make export name unique by including the stack name to avoid conflicts
+        // when multiple stacks import the same hosted zone
+        const stack = aws_cdk_lib_1.Stack.of(this);
+        const stackName = stack.stackName;
+        const exportName = `${stackName}${this.safeZoneName()}HostedZoneId`;
+        new aws_cdk_lib_1.CfnOutput(this, `${this.safeZoneName()}HostedZoneId`, {
+            key: `${this.safeZoneName()}HostedZoneId`,
+            value: this.hostedZoneId,
+            exportName: exportName
+        });
+    }
+    delegateHostedZone() {
+        const domainName = this.hostedZone.zoneName.split(".", 1);
+        const role = new iam_1.Role(this, `${domainName}DelegateHostedZoneRole`, {
+            assumedBy: new aws_iam_1.OrganizationPrincipal(aws_cdk_lib_1.Fn.importValue("OrganisationId")),
+            roleName: `${domainName}DelegateHostedZoneRole`,
+            inlinePolicies: {
+                ["listHostedZones"]: new aws_iam_1.PolicyDocument({
+                    statements: [
+                        new aws_iam_1.PolicyStatement({
+                            actions: ["route53:ListHostedZonesByName"],
+                            resources: ["*"]
+                        })
+                    ]
+                }),
+                ["changeResourceRecordSets"]: new aws_iam_1.PolicyDocument({
+                    statements: [
+                        new aws_iam_1.PolicyStatement({
+                            actions: ["route53:ChangeResourceRecordSets"],
+                            resources: [
+                                `arn:aws:route53:::hostedzone/${this.hostedZone.hostedZoneId}`
+                            ]
+                        })
+                    ]
+                })
+            }
+        });
+        this.hostedZone.grantDelegation(role);
+        new aws_cdk_lib_1.CfnOutput(this, "DelegateHostedZoneRoleArn", {
+            key: `${domainName}DelegateHostedZoneRoleArn`,
+            value: role.roleArn,
+            exportName: `${domainName}DelegateHostedZoneRoleArn`
+        });
+    }
+    addARecord(props) {
+        new aws_route53_1.ARecord(this, "ARecord", {
+            zone: this.importedHostedZone,
+            recordName: props.recordName,
+            comment: props.comment || `A Record for ${this.importedHostedZone.zoneName}`,
+            target: props.target,
+            ttl: props.ttl
+        });
+    }
+    addCname(props) {
+        new aws_route53_1.CnameRecord(this, ``, {
+            domainName: props.domainName,
+            zone: this.importedHostedZone,
+            comment: props.comment || `CNAME Record for ${this.importedHostedZone.zoneName}`,
+            ttl: props.ttl
+        });
+    }
+    addMx(props) {
+        new aws_route53_1.MxRecord(this, ``, {
+            zone: this.importedHostedZone,
+            comment: props.comment || `MX Record for ${this.importedHostedZone.zoneName}`,
+            values: props.values,
+            ttl: props.ttl
+        });
+    }
+    addNS(props) {
+        new aws_route53_1.NsRecord(this, ``, {
+            zone: this.importedHostedZone,
+            comment: props.comment || `NS Record for ${this.importedHostedZone.zoneName}`,
+            values: props.values,
+            ttl: props.ttl
+        });
+    }
+    addTxt(props) {
+        new aws_route53_1.TxtRecord(this, ``, {
+            zone: this.importedHostedZone,
+            comment: props.comment || `TXT Record for ${this.importedHostedZone.zoneName}`,
+            values: props.values,
+            ttl: props.ttl
+        });
+    }
+}
+exports.HostedZone = HostedZone;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hostedZone.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/hostedZone.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport { CfnOutput, Fn, Stack, Tags } from \"aws-cdk-lib\";\nimport { Role } from \"../../resources/aws/iam\";\nimport {\n  OrganizationPrincipal,\n  PolicyDocument,\n  PolicyStatement\n} from \"aws-cdk-lib/aws-iam\";\nimport {\n  ARecord,\n  type ARecordProps,\n  CnameRecord,\n  type CnameRecordProps,\n  HostedZone as AWSHostedZone,\n  type IHostedZone,\n  MxRecord,\n  type MxRecordProps,\n  NsRecord,\n  type NsRecordProps,\n  TxtRecord,\n  type TxtRecordProps\n} from \"aws-cdk-lib/aws-route53\";\n\nimport { type AwsStack } from \"../../resources\";\n\nfunction getSafeZoneName(zoneName: string) {\n  return zoneName.split(\".\").join(\"\");\n}\n\nexport interface HostedZoneProps {\n  zoneName: string;\n  hostedZoneId?: string;\n}\n\nexport class HostedZoneFactory {\n  static import(stack: AwsStack, hostedZoneId: string, zoneName: string) {\n    const safeZoneName = getSafeZoneName(zoneName);\n\n    return new HostedZone(stack.getStack(), `${safeZoneName}HostedZone`, {\n      hostedZoneId: hostedZoneId,\n      zoneName: zoneName\n    });\n  }\n}\n\nexport class HostedZone extends Construct {\n  private hostedZone: AWSHostedZone;\n  private hostedZoneId: string;\n  private importedHostedZone: IHostedZone;\n  private zoneName: string;\n\n  private scope: Construct;\n\n  constructor(scope: Construct, id: string, props: HostedZoneProps) {\n    super(scope, id);\n\n    this.scope = scope;\n    this.zoneName = props.zoneName;\n\n    // If a hostedZoneId is provided import it, unless create a new hosted zone\n    if (!props.hostedZoneId) {\n      this.addHostedZone(props.zoneName);\n      this.hostedZoneId = this.hostedZone.hostedZoneId;\n      this.delegateHostedZone();\n    } else {\n      this.hostedZoneId = props.hostedZoneId;\n      this.importHostedZone(props.zoneName);\n    }\n  }\n\n  getInternalHostedZone() {\n    return this.hostedZone || this.importedHostedZone;\n  }\n\n  safeZoneName() {\n    return getSafeZoneName(this.zoneName);\n  }\n\n  addHostedZone(zoneName: string) {\n    this.hostedZone = new AWSHostedZone(\n      this,\n      `${this.safeZoneName}HostedZone`,\n      {\n        zoneName: zoneName,\n        comment: `Hosted Zone for ${zoneName}`\n      }\n    );\n  }\n\n  importHostedZone(zoneName: string) {\n    this.importedHostedZone = AWSHostedZone.fromHostedZoneAttributes(\n      // HostedZone.fromHostedZoneAttributes explicitly must be passed a stack as parent scope\n      this.scope,\n\n      // Use safeZoneName in the id so we can theoretically\n      //  import multiple hosted zones in a single app\n      `${this.safeZoneName()}ImportedHostedZone`,\n      {\n        hostedZoneId: this.hostedZoneId,\n        zoneName: zoneName\n      }\n    );\n\n    Tags.of(this.importedHostedZone).add(\n      \"fjall:costAllocation:environment\",\n      \"management\"\n    );\n    Tags.of(this.importedHostedZone).add(\n      \"fjall:costAllocation:service\",\n      \"hostedZone\"\n    );\n    Tags.of(this.importedHostedZone).add(\n      \"fjall:costAllocation:domain\",\n      zoneName\n    );\n\n    // Make export name unique by including the stack name to avoid conflicts\n    // when multiple stacks import the same hosted zone\n    const stack = Stack.of(this);\n    const stackName = stack.stackName;\n    const exportName = `${stackName}${this.safeZoneName()}HostedZoneId`;\n\n    new CfnOutput(this, `${this.safeZoneName()}HostedZoneId`, {\n      key: `${this.safeZoneName()}HostedZoneId`,\n      value: this.hostedZoneId,\n      exportName: exportName\n    });\n  }\n\n  delegateHostedZone() {\n    const domainName = this.hostedZone.zoneName.split(\".\", 1);\n    const role = new Role(this, `${domainName}DelegateHostedZoneRole`, {\n      assumedBy: new OrganizationPrincipal(Fn.importValue(\"OrganisationId\")),\n      roleName: `${domainName}DelegateHostedZoneRole`,\n      inlinePolicies: {\n        [\"listHostedZones\"]: new PolicyDocument({\n          statements: [\n            new PolicyStatement({\n              actions: [\"route53:ListHostedZonesByName\"],\n              resources: [\"*\"]\n            })\n          ]\n        }),\n        [\"changeResourceRecordSets\"]: new PolicyDocument({\n          statements: [\n            new PolicyStatement({\n              actions: [\"route53:ChangeResourceRecordSets\"],\n              resources: [\n                `arn:aws:route53:::hostedzone/${this.hostedZone.hostedZoneId}`\n              ]\n            })\n          ]\n        })\n      }\n    });\n\n    this.hostedZone.grantDelegation(role);\n\n    new CfnOutput(this, \"DelegateHostedZoneRoleArn\", {\n      key: `${domainName}DelegateHostedZoneRoleArn`,\n      value: role.roleArn,\n      exportName: `${domainName}DelegateHostedZoneRoleArn`\n    });\n  }\n\n  public addARecord(props: Omit<ARecordProps, \"zone\">) {\n    new ARecord(this, \"ARecord\", {\n      zone: this.importedHostedZone,\n      recordName: props.recordName,\n      comment:\n        props.comment || `A Record for ${this.importedHostedZone.zoneName}`,\n      target: props.target,\n      ttl: props.ttl\n    });\n  }\n\n  public addCname(props: Omit<CnameRecordProps, \"zone\">) {\n    new CnameRecord(this, ``, {\n      domainName: props.domainName,\n      zone: this.importedHostedZone,\n      comment:\n        props.comment || `CNAME Record for ${this.importedHostedZone.zoneName}`,\n      ttl: props.ttl\n    });\n  }\n\n  public addMx(props: Omit<MxRecordProps, \"zone\">) {\n    new MxRecord(this, ``, {\n      zone: this.importedHostedZone,\n      comment:\n        props.comment || `MX Record for ${this.importedHostedZone.zoneName}`,\n      values: props.values,\n      ttl: props.ttl\n    });\n  }\n\n  public addNS(props: Omit<NsRecordProps, \"zone\">) {\n    new NsRecord(this, ``, {\n      zone: this.importedHostedZone,\n      comment:\n        props.comment || `NS Record for ${this.importedHostedZone.zoneName}`,\n      values: props.values,\n      ttl: props.ttl\n    });\n  }\n\n  public addTxt(props: Omit<TxtRecordProps, \"zone\">) {\n    new TxtRecord(this, ``, {\n      zone: this.importedHostedZone,\n      comment:\n        props.comment || `TXT Record for ${this.importedHostedZone.zoneName}`,\n      values: props.values,\n      ttl: props.ttl\n    });\n  }\n}\n"]}