@fjall/components-infrastructure 0.86.0 → 0.87.3

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

@@ -1,17 +1,57 @@
 import { Construct } from "constructs";
-import { type IBucket } from "aws-cdk-lib/aws-s3";
+import { type IBucket, type EventType, type IBucketNotificationDestination, type NotificationKeyFilter } from "aws-cdk-lib/aws-s3";
+import { BucketDeployment } from "aws-cdk-lib/aws-s3-deployment";
+import { type IGrantable, type Grant } from "aws-cdk-lib/aws-iam";
 import type App from "../../app";
-import { type BackupVaultTier } from "../../resources/aws/storage";
-type S3BucketType = "private" | "website" | "publicRead";
+import { S3Bucket, S3WebsiteBucket, S3PublicReadBucket, type BackupVaultTier } from "../../resources/aws/storage";
+import { type StorageType, type IPrivateStorage, type IWebsiteStorage, type IPublicStorage } from "./interfaces/storage.js";
+import { type IStorageConnector } from "./interfaces/connector.js";
+export { type StorageType, type IStorage, type IPrivateStorage, type IWebsiteStorage, type IPublicStorage, type AnyStorage, isPrivateStorage, isWebsiteStorage, isPublicStorage } from "./interfaces/storage.js";
+export type S3BucketType = "private" | "website" | "publicRead";
+export interface StorageTypeConfig {
+    supportsPublicRead: boolean;
+    supportsWebsiteHosting: boolean;
+    defaultPublicAccess: boolean;
+}
+export declare const STORAGE_TYPE_CONFIG: Record<S3BucketType, StorageTypeConfig>;
+export declare function getStorageTypeConfig(type: S3BucketType): StorageTypeConfig;
 type BaseS3Props = {
     backupVaultTier?: BackupVaultTier;
     versioned?: boolean;
     encryption?: "AES256" | "KMS";
     kmsKeyArn?: string;
 };
+/**
+ * Configuration for automatic asset deployment to S3.
+ * When provided, creates a BucketDeployment that uploads files during CDK deploy.
+ */
+export interface S3DeploymentConfig {
+    /** Path to the asset directory (relative to CDK app root) */
+    source: string;
+    /**
+     * Whether to remove files from bucket that aren't in the source.
+     * Default: true for static assets, false for caches that grow at runtime.
+     */
+    prune?: boolean;
+    /**
+     * Cache control settings for uploaded files.
+     * If not provided, no cache headers are set.
+     */
+    cacheControl?: {
+        /** Max age in seconds (e.g., 31536000 for 1 year) */
+        maxAge?: number;
+        /** Mark as immutable (browser won't revalidate) */
+        immutable?: boolean;
+    };
+}
 export interface PrivateS3Props extends BaseS3Props {
     bucketType: "private";
     publicReadAccess?: boolean;
+    /**
+     * Optional deployment configuration.
+     * When provided, automatically uploads files to the bucket during CDK deploy.
+     */
+    deployment?: S3DeploymentConfig;
 }
 export interface WebsiteS3Props extends BaseS3Props {
     bucketType: "website";
@@ -26,23 +66,95 @@ export interface PublicReadS3Props extends BaseS3Props {
     bucketType: "publicRead";
 }
 export type IS3Props = PrivateS3Props | WebsiteS3Props | PublicReadS3Props;
+/**
+ * Factory for creating S3 storage resources with type-safe return types.
+ *
+ * @example
+ * // Private bucket
+ * const assets = app.addStorage(StorageFactory.build("Assets", { bucketType: "private" }));
+ * assets.grantPublicAccess(); // ✓ Available on PrivateStorage
+ *
+ * // Website bucket
+ * const site = app.addStorage(StorageFactory.build("Site", { bucketType: "website" }));
+ * site.getWebsiteUrl(); // ✓ Available on WebsiteStorage
+ */
 export declare class StorageFactory {
-    static build<T extends IS3Props>(id: string, props: T): (app: App, scope: Construct) => S3Storage;
+    /** Build a private storage bucket */
+    static build(id: string, props: PrivateS3Props): (app: App, scope: Construct) => PrivateStorage;
+    /** Build a website storage bucket */
+    static build(id: string, props: WebsiteS3Props): (app: App, scope: Construct) => WebsiteStorage;
+    /** Build a public read storage bucket */
+    static build(id: string, props: PublicReadS3Props): (app: App, scope: Construct) => PublicStorage;
 }
-export declare class S3Storage extends Construct {
-    id: string;
-    scope: Construct;
-    private bucket;
-    private bucketType;
+/**
+ * Base S3 storage class.
+ * Specific storage types (PrivateStorage, WebsiteStorage, PublicStorage) extend this.
+ */
+declare abstract class S3StorageBase extends Construct implements IStorageConnector {
+    readonly id: string;
+    readonly scope: Construct;
+    /** The type of storage resource. Used for runtime type narrowing. */
+    abstract readonly storageType: StorageType;
+    /** The connector type for unified connection processing. */
+    readonly connectorType: "storage";
+    protected bucket: S3Bucket | S3WebsiteBucket | S3PublicReadBucket;
+    protected _bucketType: S3BucketType;
     constructor(scope: Construct, id: string, props: IS3Props);
-    addS3Bucket(props: IS3Props): void;
-    private addPrivateBucket;
-    private addWebsiteBucket;
-    private addPublicReadBucket;
-    private addOutputs;
+    protected initialisePrivateBucket(props: PrivateS3Props): void;
+    protected initialiseWebsiteBucket(props: WebsiteS3Props): void;
+    protected initialisePublicReadBucket(props: PublicReadS3Props): void;
+    protected addOutputs(): void;
     getBucket(): IBucket;
     getBucketName(): string;
     getBucketArn(): string;
     getBucketType(): S3BucketType;
+    getBucketDomainName(): string;
+    getBucketRegionalDomainName(): string;
+    getS3Bucket(): S3Bucket | S3WebsiteBucket | S3PublicReadBucket;
+    grantRead(grantee: IGrantable): Grant;
+    grantWrite(grantee: IGrantable): Grant;
+    grantReadWrite(grantee: IGrantable): Grant;
+    grantDelete(grantee: IGrantable): Grant;
+    grantPut(grantee: IGrantable): Grant;
+    addEventNotification(event: EventType, dest: IBucketNotificationDestination, ...filters: NotificationKeyFilter[]): void;
+    addObjectCreatedNotification(dest: IBucketNotificationDestination, ...filters: NotificationKeyFilter[]): void;
+    addObjectRemovedNotification(dest: IBucketNotificationDestination, ...filters: NotificationKeyFilter[]): void;
+}
+/**
+ * Private S3 storage.
+ * Standard bucket with optional encryption and versioning.
+ */
+export declare class PrivateStorage extends S3StorageBase implements IPrivateStorage {
+    readonly storageType: "private";
+    private _deployment?;
+    constructor(scope: Construct, id: string, props: PrivateS3Props);
+    private createDeployment;
+    /**
+     * Grant public access to objects under a prefix.
+     * Use with caution - makes objects publicly readable.
+     */
+    grantPublicAccess(...keyPrefix: string[]): Grant;
+    /**
+     * Get the BucketDeployment construct if one was created.
+     * Returns undefined if no deployment was configured.
+     */
+    getDeployment(): BucketDeployment | undefined;
+}
+/**
+ * Website S3 storage.
+ * Bucket configured for static website hosting.
+ */
+export declare class WebsiteStorage extends S3StorageBase implements IWebsiteStorage {
+    readonly storageType: "website";
+    constructor(scope: Construct, id: string, props: WebsiteS3Props);
+    /** Get the website URL. */
+    getWebsiteUrl(): string;
+}
+/**
+ * Public read S3 storage.
+ * Bucket with public read access enabled.
+ */
+export declare class PublicStorage extends S3StorageBase implements IPublicStorage {
+    readonly storageType: "publicRead";
+    constructor(scope: Construct, id: string, props: PublicReadS3Props);
 }
-export {};

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

@@ -1,83 +1,173 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.S3Storage = exports.StorageFactory = void 0;
+exports.PublicStorage = exports.WebsiteStorage = exports.PrivateStorage = exports.StorageFactory = exports.STORAGE_TYPE_CONFIG = exports.isPublicStorage = exports.isWebsiteStorage = exports.isPrivateStorage = void 0;
+exports.getStorageTypeConfig = getStorageTypeConfig;
 const constructs_1 = require("constructs");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const aws_s3_deployment_1 = require("aws-cdk-lib/aws-s3-deployment");
+const aws_kms_1 = require("aws-cdk-lib/aws-kms");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const storage_1 = require("../../resources/aws/storage");
+const validationLogger_js_1 = require("../../utils/validationLogger.js");
+// Re-export interfaces and type guards
+var storage_js_1 = require("./interfaces/storage.js");
+Object.defineProperty(exports, "isPrivateStorage", { enumerable: true, get: function () { return storage_js_1.isPrivateStorage; } });
+Object.defineProperty(exports, "isWebsiteStorage", { enumerable: true, get: function () { return storage_js_1.isWebsiteStorage; } });
+Object.defineProperty(exports, "isPublicStorage", { enumerable: true, get: function () { return storage_js_1.isPublicStorage; } });
+function toBucketEncryption(encryption) {
+    if (!encryption)
+        return undefined;
+    return encryption === "AES256"
+        ? aws_s3_1.BucketEncryption.S3_MANAGED
+        : aws_s3_1.BucketEncryption.KMS;
+}
+function toHttpMethod(method) {
+    const methodMap = {
+        GET: aws_s3_1.HttpMethods.GET,
+        PUT: aws_s3_1.HttpMethods.PUT,
+        POST: aws_s3_1.HttpMethods.POST,
+        DELETE: aws_s3_1.HttpMethods.DELETE,
+        HEAD: aws_s3_1.HttpMethods.HEAD
+    };
+    return methodMap[method] ?? aws_s3_1.HttpMethods.GET;
+}
+function toCorsRules(cors) {
+    if (!cors)
+        return undefined;
+    return cors.map((rule) => ({
+        allowedOrigins: rule.allowedOrigins,
+        allowedMethods: rule.allowedMethods.map(toHttpMethod)
+    }));
+}
+exports.STORAGE_TYPE_CONFIG = {
+    private: {
+        supportsPublicRead: true,
+        supportsWebsiteHosting: false,
+        defaultPublicAccess: false
+    },
+    website: {
+        supportsPublicRead: true,
+        supportsWebsiteHosting: true,
+        defaultPublicAccess: true
+    },
+    publicRead: {
+        supportsPublicRead: true,
+        supportsWebsiteHosting: false,
+        defaultPublicAccess: true
+    }
+};
+function getStorageTypeConfig(type) {
+    return exports.STORAGE_TYPE_CONFIG[type];
+}
+/**
+ * Validates storage props and logs warnings for ignored or misconfigured options.
+ * These checks help catch issues when props come from dynamic sources where
+ * TypeScript's compile-time checks may not apply.
+ */
+function validateStorageProps(props) {
+    // Validate encryption: KMS requires kmsKeyArn
+    if (props.encryption === "KMS" && !props.kmsKeyArn) {
+        validationLogger_js_1.FjallLogger.warn("'encryption' is set to 'KMS' but 'kmsKeyArn' is not provided. " +
+            "The bucket will use the default AWS managed key.");
+    }
+    // Warn about kmsKeyArn when encryption is not KMS
+    if (props.kmsKeyArn && props.encryption !== "KMS") {
+        validationLogger_js_1.FjallLogger.warn("'kmsKeyArn' is provided but 'encryption' is not set to 'KMS'. " +
+            "The KMS key will be ignored. Set encryption: 'KMS' to use the key.");
+    }
+    // Website-only options on non-website buckets
+    // Note: Using bucketType as discriminator with "type" alias for the helper
+    const propsWithType = { ...props, type: props.bucketType };
+    (0, validationLogger_js_1.warnIfPropertiesIgnored)(propsWithType, ["websiteIndexDocument", "websiteErrorDocument", "cors"], "website", "website bucket");
+    // Private-only options on non-private buckets
+    (0, validationLogger_js_1.warnIfPropertiesIgnored)(propsWithType, ["publicReadAccess"], "private", "private bucket");
+}
+/**
+ * Factory for creating S3 storage resources with type-safe return types.
+ *
+ * @example
+ * // Private bucket
+ * const assets = app.addStorage(StorageFactory.build("Assets", { bucketType: "private" }));
+ * assets.grantPublicAccess(); // ✓ Available on PrivateStorage
+ *
+ * // Website bucket
+ * const site = app.addStorage(StorageFactory.build("Site", { bucketType: "website" }));
+ * site.getWebsiteUrl(); // ✓ Available on WebsiteStorage
+ */
 class StorageFactory {
+    /** Implementation - returns appropriate storage type based on props */
     static build(id, props) {
-        return (app, scope) => {
-            return new S3Storage(scope, id, props);
+        return (_app, scope) => {
+            validateStorageProps(props);
+            switch (props.bucketType) {
+                case "private":
+                    return new PrivateStorage(scope, id, props);
+                case "website":
+                    return new WebsiteStorage(scope, id, props);
+                case "publicRead":
+                    return new PublicStorage(scope, id, props);
+                default: {
+                    const _exhaustive = props;
+                    throw new Error(`Unsupported bucket type: ${_exhaustive.bucketType}`);
+                }
+            }
         };
     }
 }
 exports.StorageFactory = StorageFactory;
-class S3Storage extends constructs_1.Construct {
+/**
+ * Base S3 storage class.
+ * Specific storage types (PrivateStorage, WebsiteStorage, PublicStorage) extend this.
+ */
+class S3StorageBase extends constructs_1.Construct {
     constructor(scope, id, props) {
         super(scope, id);
+        /** The connector type for unified connection processing. */
+        this.connectorType = "storage";
         this.id = id;
         this.scope = scope;
-        this.bucketType = props.bucketType;
-        this.addS3Bucket(props);
-    }
-    addS3Bucket(props) {
-        switch (props.bucketType) {
-            case "private":
-                this.addPrivateBucket(props);
-                break;
-            case "website":
-                this.addWebsiteBucket(props);
-                break;
-            case "publicRead":
-                this.addPublicReadBucket(props);
-                break;
-            default: {
-                // Exhaustiveness check
-                const _exhaustive = props;
-                throw new Error(`Unsupported S3 bucket type ${props.bucketType}`);
-            }
-        }
+        this._bucketType = props.bucketType;
     }
-    addPrivateBucket(props) {
+    initialisePrivateBucket(props) {
+        const encryptionKey = props.kmsKeyArn
+            ? aws_kms_1.Key.fromKeyArn(this, `${this.id}KmsKey`, props.kmsKeyArn)
+            : undefined;
         this.bucket = new storage_1.S3Bucket(this, `${this.id}Bucket`, {
             backupVaultTier: props.backupVaultTier,
             versioned: props.versioned,
-            encryption: props.encryption,
-            encryptionKey: props.kmsKeyArn ? undefined : undefined, // KMS key handling
+            encryption: toBucketEncryption(props.encryption),
+            encryptionKey,
             publicReadAccess: props.publicReadAccess
         });
         this.addOutputs();
     }
-    addWebsiteBucket(props) {
+    initialiseWebsiteBucket(props) {
         this.bucket = new storage_1.S3WebsiteBucket(this, `${this.id}Bucket`, {
             backupVaultTier: props.backupVaultTier,
             versioned: props.versioned,
-            encryption: props.encryption,
+            encryption: toBucketEncryption(props.encryption),
             websiteIndexDocument: props.websiteIndexDocument,
             websiteErrorDocument: props.websiteErrorDocument,
-            cors: props.cors
+            cors: toCorsRules(props.cors)
         });
         this.addOutputs();
     }
-    addPublicReadBucket(props) {
+    initialisePublicReadBucket(props) {
         this.bucket = new storage_1.S3PublicReadBucket(this, `${this.id}Bucket`, {
             backupVaultTier: props.backupVaultTier,
             versioned: props.versioned,
-            encryption: props.encryption
+            encryption: toBucketEncryption(props.encryption)
         });
         this.addOutputs();
     }
     addOutputs() {
         const stackName = aws_cdk_lib_1.Stack.of(this).stackName;
-        // Export bucket ARN for monitoring
-        // Use stack name prefix to ensure uniqueness across apps in same region
         new aws_cdk_lib_1.CfnOutput(this, `${this.id}BucketArn`, {
             key: `${stackName}${this.id}BucketArn`,
             exportName: `${stackName}${this.id}BucketArn`,
             value: this.bucket.bucketArn,
             description: `S3 Bucket ARN for ${this.id}`
         });
-        // Export bucket name for convenience
         new aws_cdk_lib_1.CfnOutput(this, `${this.id}BucketName`, {
             key: `${stackName}${this.id}BucketName`,
             exportName: `${stackName}${this.id}BucketName`,
@@ -95,8 +185,114 @@ class S3Storage extends constructs_1.Construct {
         return this.bucket.bucketArn;
     }
     getBucketType() {
-        return this.bucketType;
+        return this._bucketType;
+    }
+    getBucketDomainName() {
+        return this.bucket.bucketDomainName;
+    }
+    getBucketRegionalDomainName() {
+        return this.bucket.bucketRegionalDomainName;
+    }
+    getS3Bucket() {
+        return this.bucket;
+    }
+    grantRead(grantee) {
+        return this.bucket.grantRead(grantee);
+    }
+    grantWrite(grantee) {
+        return this.bucket.grantWrite(grantee);
+    }
+    grantReadWrite(grantee) {
+        return this.bucket.grantReadWrite(grantee);
+    }
+    grantDelete(grantee) {
+        return this.bucket.grantDelete(grantee);
+    }
+    grantPut(grantee) {
+        return this.bucket.grantPut(grantee);
+    }
+    addEventNotification(event, dest, ...filters) {
+        this.bucket.addEventNotification(event, dest, ...filters);
+    }
+    addObjectCreatedNotification(dest, ...filters) {
+        this.bucket.addObjectCreatedNotification(dest, ...filters);
+    }
+    addObjectRemovedNotification(dest, ...filters) {
+        this.bucket.addObjectRemovedNotification(dest, ...filters);
+    }
+}
+/**
+ * Private S3 storage.
+ * Standard bucket with optional encryption and versioning.
+ */
+class PrivateStorage extends S3StorageBase {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.storageType = "private";
+        this.initialisePrivateBucket(props);
+        if (props.deployment) {
+            this._deployment = this.createDeployment(id, props.deployment);
+        }
+    }
+    createDeployment(id, config) {
+        const cacheControlHeaders = [];
+        if (config.cacheControl?.maxAge !== undefined) {
+            cacheControlHeaders.push(aws_s3_deployment_1.CacheControl.maxAge(aws_cdk_lib_1.Duration.seconds(config.cacheControl.maxAge)));
+        }
+        if (config.cacheControl?.immutable) {
+            cacheControlHeaders.push(aws_s3_deployment_1.CacheControl.immutable());
+        }
+        return new aws_s3_deployment_1.BucketDeployment(this, `${id}Deployment`, {
+            sources: [aws_s3_deployment_1.Source.asset(config.source)],
+            destinationBucket: this.bucket,
+            prune: config.prune ?? true,
+            ...(cacheControlHeaders.length > 0 && {
+                cacheControl: cacheControlHeaders
+            })
+        });
+    }
+    /**
+     * Grant public access to objects under a prefix.
+     * Use with caution - makes objects publicly readable.
+     */
+    grantPublicAccess(...keyPrefix) {
+        return this.bucket.grantPublicAccess(...keyPrefix);
+    }
+    /**
+     * Get the BucketDeployment construct if one was created.
+     * Returns undefined if no deployment was configured.
+     */
+    getDeployment() {
+        return this._deployment;
+    }
+}
+exports.PrivateStorage = PrivateStorage;
+/**
+ * Website S3 storage.
+ * Bucket configured for static website hosting.
+ */
+class WebsiteStorage extends S3StorageBase {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.storageType = "website";
+        this.initialiseWebsiteBucket(props);
+    }
+    /** Get the website URL. */
+    getWebsiteUrl() {
+        return this.bucket.bucketWebsiteUrl ?? "";
+    }
+}
+exports.WebsiteStorage = WebsiteStorage;
+/**
+ * Public read S3 storage.
+ * Bucket with public read access enabled.
+ */
+class PublicStorage extends S3StorageBase {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.storageType = "publicRead";
+        this.initialisePublicReadBucket(props);
     }
 }
-exports.S3Storage = S3Storage;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/storage.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport { type IBucket } from \"aws-cdk-lib/aws-s3\";\nimport { CfnOutput, Stack } from \"aws-cdk-lib\";\n\nimport type App from \"../../app\";\nimport {\n  S3Bucket,\n  S3WebsiteBucket,\n  S3PublicReadBucket,\n  type BackupVaultTier\n} from \"../../resources/aws/storage\";\n\ntype S3BucketType = \"private\" | \"website\" | \"publicRead\";\n\ntype BaseS3Props = {\n  backupVaultTier?: BackupVaultTier;\n  versioned?: boolean;\n  encryption?: \"AES256\" | \"KMS\";\n  kmsKeyArn?: string;\n};\n\nexport interface PrivateS3Props extends BaseS3Props {\n  bucketType: \"private\";\n  publicReadAccess?: boolean;\n}\n\nexport interface WebsiteS3Props extends BaseS3Props {\n  bucketType: \"website\";\n  websiteIndexDocument?: string;\n  websiteErrorDocument?: string;\n  cors?: Array<{\n    allowedOrigins: string[];\n    allowedMethods: string[];\n  }>;\n}\n\nexport interface PublicReadS3Props extends BaseS3Props {\n  bucketType: \"publicRead\";\n}\n\nexport type IS3Props = PrivateS3Props | WebsiteS3Props | PublicReadS3Props;\n\nexport class StorageFactory {\n  static build<T extends IS3Props>(id: string, props: T) {\n    return (app: App, scope: Construct) => {\n      return new S3Storage(scope, id, props);\n    };\n  }\n}\n\nexport class S3Storage extends Construct {\n  public id: string;\n  public scope: Construct;\n\n  private bucket: S3Bucket | S3WebsiteBucket | S3PublicReadBucket;\n  private bucketType: S3BucketType;\n\n  constructor(scope: Construct, id: string, props: IS3Props) {\n    super(scope, id);\n    this.id = id;\n    this.scope = scope;\n    this.bucketType = props.bucketType;\n\n    this.addS3Bucket(props);\n  }\n\n  addS3Bucket(props: IS3Props) {\n    switch (props.bucketType) {\n      case \"private\":\n        this.addPrivateBucket(props);\n        break;\n      case \"website\":\n        this.addWebsiteBucket(props);\n        break;\n      case \"publicRead\":\n        this.addPublicReadBucket(props);\n        break;\n      default: {\n        // Exhaustiveness check\n        const _exhaustive: never = props;\n        throw new Error(\n          `Unsupported S3 bucket type ${(props as any).bucketType}`\n        );\n      }\n    }\n  }\n\n  private addPrivateBucket(props: PrivateS3Props) {\n    this.bucket = new S3Bucket(this, `${this.id}Bucket`, {\n      backupVaultTier: props.backupVaultTier,\n      versioned: props.versioned,\n      encryption: props.encryption as any,\n      encryptionKey: props.kmsKeyArn ? undefined : undefined, // KMS key handling\n      publicReadAccess: props.publicReadAccess\n    });\n    this.addOutputs();\n  }\n\n  private addWebsiteBucket(props: WebsiteS3Props) {\n    this.bucket = new S3WebsiteBucket(this, `${this.id}Bucket`, {\n      backupVaultTier: props.backupVaultTier,\n      versioned: props.versioned,\n      encryption: props.encryption as any,\n      websiteIndexDocument: props.websiteIndexDocument,\n      websiteErrorDocument: props.websiteErrorDocument,\n      cors: props.cors as any\n    });\n    this.addOutputs();\n  }\n\n  private addPublicReadBucket(props: PublicReadS3Props) {\n    this.bucket = new S3PublicReadBucket(this, `${this.id}Bucket`, {\n      backupVaultTier: props.backupVaultTier,\n      versioned: props.versioned,\n      encryption: props.encryption as any\n    });\n    this.addOutputs();\n  }\n\n  private addOutputs() {\n    const stackName = Stack.of(this).stackName;\n\n    // Export bucket ARN for monitoring\n    // Use stack name prefix to ensure uniqueness across apps in same region\n    new CfnOutput(this, `${this.id}BucketArn`, {\n      key: `${stackName}${this.id}BucketArn`,\n      exportName: `${stackName}${this.id}BucketArn`,\n      value: this.bucket.bucketArn,\n      description: `S3 Bucket ARN for ${this.id}`\n    });\n\n    // Export bucket name for convenience\n    new CfnOutput(this, `${this.id}BucketName`, {\n      key: `${stackName}${this.id}BucketName`,\n      exportName: `${stackName}${this.id}BucketName`,\n      value: this.bucket.bucketName,\n      description: `S3 Bucket Name for ${this.id}`\n    });\n  }\n\n  getBucket(): IBucket {\n    return this.bucket;\n  }\n\n  getBucketName(): string {\n    return this.bucket.bucketName;\n  }\n\n  getBucketArn(): string {\n    return this.bucket.bucketArn;\n  }\n\n  getBucketType(): S3BucketType {\n    return this.bucketType;\n  }\n}\n"]}
+exports.PublicStorage = PublicStorage;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/storage.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport {\n  type IBucket,\n  type EventType,\n  type IBucketNotificationDestination,\n  type NotificationKeyFilter,\n  BucketEncryption,\n  HttpMethods,\n  type CorsRule\n} from \"aws-cdk-lib/aws-s3\";\nimport {\n  BucketDeployment,\n  Source,\n  CacheControl\n} from \"aws-cdk-lib/aws-s3-deployment\";\nimport { type IGrantable, type Grant } from \"aws-cdk-lib/aws-iam\";\nimport { Key } from \"aws-cdk-lib/aws-kms\";\nimport { CfnOutput, Duration, Stack } from \"aws-cdk-lib\";\n\nimport type App from \"../../app\";\nimport {\n  S3Bucket,\n  S3WebsiteBucket,\n  S3PublicReadBucket,\n  type BackupVaultTier\n} from \"../../resources/aws/storage\";\nimport {\n  FjallLogger,\n  warnIfPropertiesIgnored\n} from \"../../utils/validationLogger.js\";\nimport {\n  type StorageType,\n  type IPrivateStorage,\n  type IWebsiteStorage,\n  type IPublicStorage,\n  type AnyStorage\n} from \"./interfaces/storage.js\";\nimport { type IStorageConnector } from \"./interfaces/connector.js\";\n\n// Re-export interfaces and type guards\nexport {\n  type StorageType,\n  type IStorage,\n  type IPrivateStorage,\n  type IWebsiteStorage,\n  type IPublicStorage,\n  type AnyStorage,\n  isPrivateStorage,\n  isWebsiteStorage,\n  isPublicStorage\n} from \"./interfaces/storage.js\";\n\ntype EncryptionType = \"AES256\" | \"KMS\";\n\nfunction toBucketEncryption(\n  encryption?: EncryptionType\n): BucketEncryption | undefined {\n  if (!encryption) return undefined;\n  return encryption === \"AES256\"\n    ? BucketEncryption.S3_MANAGED\n    : BucketEncryption.KMS;\n}\n\nfunction toHttpMethod(method: string): HttpMethods {\n  const methodMap: Record<string, HttpMethods> = {\n    GET: HttpMethods.GET,\n    PUT: HttpMethods.PUT,\n    POST: HttpMethods.POST,\n    DELETE: HttpMethods.DELETE,\n    HEAD: HttpMethods.HEAD\n  };\n  return methodMap[method] ?? HttpMethods.GET;\n}\n\nfunction toCorsRules(\n  cors?: Array<{ allowedOrigins: string[]; allowedMethods: string[] }>\n): CorsRule[] | undefined {\n  if (!cors) return undefined;\n  return cors.map((rule) => ({\n    allowedOrigins: rule.allowedOrigins,\n    allowedMethods: rule.allowedMethods.map(toHttpMethod)\n  }));\n}\n\nexport type S3BucketType = \"private\" | \"website\" | \"publicRead\";\n\nexport interface StorageTypeConfig {\n  supportsPublicRead: boolean;\n  supportsWebsiteHosting: boolean;\n  defaultPublicAccess: boolean;\n}\n\nexport const STORAGE_TYPE_CONFIG: Record<S3BucketType, StorageTypeConfig> = {\n  private: {\n    supportsPublicRead: true,\n    supportsWebsiteHosting: false,\n    defaultPublicAccess: false\n  },\n  website: {\n    supportsPublicRead: true,\n    supportsWebsiteHosting: true,\n    defaultPublicAccess: true\n  },\n  publicRead: {\n    supportsPublicRead: true,\n    supportsWebsiteHosting: false,\n    defaultPublicAccess: true\n  }\n};\n\nexport function getStorageTypeConfig(type: S3BucketType): StorageTypeConfig {\n  return STORAGE_TYPE_CONFIG[type];\n}\n\ntype BaseS3Props = {\n  backupVaultTier?: BackupVaultTier;\n  versioned?: boolean;\n  encryption?: \"AES256\" | \"KMS\";\n  kmsKeyArn?: string;\n};\n\n/**\n * Configuration for automatic asset deployment to S3.\n * When provided, creates a BucketDeployment that uploads files during CDK deploy.\n */\nexport interface S3DeploymentConfig {\n  /** Path to the asset directory (relative to CDK app root) */\n  source: string;\n  /**\n   * Whether to remove files from bucket that aren't in the source.\n   * Default: true for static assets, false for caches that grow at runtime.\n   */\n  prune?: boolean;\n  /**\n   * Cache control settings for uploaded files.\n   * If not provided, no cache headers are set.\n   */\n  cacheControl?: {\n    /** Max age in seconds (e.g., 31536000 for 1 year) */\n    maxAge?: number;\n    /** Mark as immutable (browser won't revalidate) */\n    immutable?: boolean;\n  };\n}\n\nexport interface PrivateS3Props extends BaseS3Props {\n  bucketType: \"private\";\n  publicReadAccess?: boolean;\n  /**\n   * Optional deployment configuration.\n   * When provided, automatically uploads files to the bucket during CDK deploy.\n   */\n  deployment?: S3DeploymentConfig;\n}\n\nexport interface WebsiteS3Props extends BaseS3Props {\n  bucketType: \"website\";\n  websiteIndexDocument?: string;\n  websiteErrorDocument?: string;\n  cors?: Array<{\n    allowedOrigins: string[];\n    allowedMethods: string[];\n  }>;\n}\n\nexport interface PublicReadS3Props extends BaseS3Props {\n  bucketType: \"publicRead\";\n}\n\nexport type IS3Props = PrivateS3Props | WebsiteS3Props | PublicReadS3Props;\n\n/**\n * Validates storage props and logs warnings for ignored or misconfigured options.\n * These checks help catch issues when props come from dynamic sources where\n * TypeScript's compile-time checks may not apply.\n */\nfunction validateStorageProps(props: IS3Props): void {\n  // Validate encryption: KMS requires kmsKeyArn\n  if (props.encryption === \"KMS\" && !props.kmsKeyArn) {\n    FjallLogger.warn(\n      \"'encryption' is set to 'KMS' but 'kmsKeyArn' is not provided. \" +\n        \"The bucket will use the default AWS managed key.\"\n    );\n  }\n\n  // Warn about kmsKeyArn when encryption is not KMS\n  if (props.kmsKeyArn && props.encryption !== \"KMS\") {\n    FjallLogger.warn(\n      \"'kmsKeyArn' is provided but 'encryption' is not set to 'KMS'. \" +\n        \"The KMS key will be ignored. Set encryption: 'KMS' to use the key.\"\n    );\n  }\n\n  // Website-only options on non-website buckets\n  // Note: Using bucketType as discriminator with \"type\" alias for the helper\n  const propsWithType = { ...props, type: props.bucketType };\n  warnIfPropertiesIgnored(\n    propsWithType,\n    [\"websiteIndexDocument\", \"websiteErrorDocument\", \"cors\"],\n    \"website\",\n    \"website bucket\"\n  );\n\n  // Private-only options on non-private buckets\n  warnIfPropertiesIgnored(\n    propsWithType,\n    [\"publicReadAccess\"],\n    \"private\",\n    \"private bucket\"\n  );\n}\n\n/**\n * Factory for creating S3 storage resources with type-safe return types.\n *\n * @example\n * // Private bucket\n * const assets = app.addStorage(StorageFactory.build(\"Assets\", { bucketType: \"private\" }));\n * assets.grantPublicAccess(); // ✓ Available on PrivateStorage\n *\n * // Website bucket\n * const site = app.addStorage(StorageFactory.build(\"Site\", { bucketType: \"website\" }));\n * site.getWebsiteUrl(); // ✓ Available on WebsiteStorage\n */\nexport class StorageFactory {\n  /** Build a private storage bucket */\n  static build(\n    id: string,\n    props: PrivateS3Props\n  ): (app: App, scope: Construct) => PrivateStorage;\n  /** Build a website storage bucket */\n  static build(\n    id: string,\n    props: WebsiteS3Props\n  ): (app: App, scope: Construct) => WebsiteStorage;\n  /** Build a public read storage bucket */\n  static build(\n    id: string,\n    props: PublicReadS3Props\n  ): (app: App, scope: Construct) => PublicStorage;\n  /** Implementation - returns appropriate storage type based on props */\n  static build(\n    id: string,\n    props: IS3Props\n  ): (app: App, scope: Construct) => AnyStorage {\n    return (_app: App, scope: Construct) => {\n      validateStorageProps(props);\n\n      switch (props.bucketType) {\n        case \"private\":\n          return new PrivateStorage(scope, id, props);\n        case \"website\":\n          return new WebsiteStorage(scope, id, props);\n        case \"publicRead\":\n          return new PublicStorage(scope, id, props);\n        default: {\n          const _exhaustive: never = props;\n          throw new Error(\n            `Unsupported bucket type: ${(_exhaustive as IS3Props).bucketType}`\n          );\n        }\n      }\n    };\n  }\n}\n\n/**\n * Base S3 storage class.\n * Specific storage types (PrivateStorage, WebsiteStorage, PublicStorage) extend this.\n */\nabstract class S3StorageBase extends Construct implements IStorageConnector {\n  public readonly id: string;\n  public readonly scope: Construct;\n\n  /** The type of storage resource. Used for runtime type narrowing. */\n  public abstract readonly storageType: StorageType;\n\n  /** The connector type for unified connection processing. */\n  public readonly connectorType = \"storage\" as const;\n\n  protected bucket!: S3Bucket | S3WebsiteBucket | S3PublicReadBucket;\n  protected _bucketType: S3BucketType;\n\n  constructor(scope: Construct, id: string, props: IS3Props) {\n    super(scope, id);\n    this.id = id;\n    this.scope = scope;\n    this._bucketType = props.bucketType;\n  }\n\n  protected initialisePrivateBucket(props: PrivateS3Props) {\n    const encryptionKey = props.kmsKeyArn\n      ? Key.fromKeyArn(this, `${this.id}KmsKey`, props.kmsKeyArn)\n      : undefined;\n\n    this.bucket = new S3Bucket(this, `${this.id}Bucket`, {\n      backupVaultTier: props.backupVaultTier,\n      versioned: props.versioned,\n      encryption: toBucketEncryption(props.encryption),\n      encryptionKey,\n      publicReadAccess: props.publicReadAccess\n    });\n    this.addOutputs();\n  }\n\n  protected initialiseWebsiteBucket(props: WebsiteS3Props) {\n    this.bucket = new S3WebsiteBucket(this, `${this.id}Bucket`, {\n      backupVaultTier: props.backupVaultTier,\n      versioned: props.versioned,\n      encryption: toBucketEncryption(props.encryption),\n      websiteIndexDocument: props.websiteIndexDocument,\n      websiteErrorDocument: props.websiteErrorDocument,\n      cors: toCorsRules(props.cors)\n    });\n    this.addOutputs();\n  }\n\n  protected initialisePublicReadBucket(props: PublicReadS3Props) {\n    this.bucket = new S3PublicReadBucket(this, `${this.id}Bucket`, {\n      backupVaultTier: props.backupVaultTier,\n      versioned: props.versioned,\n      encryption: toBucketEncryption(props.encryption)\n    });\n    this.addOutputs();\n  }\n\n  protected addOutputs() {\n    const stackName = Stack.of(this).stackName;\n\n    new CfnOutput(this, `${this.id}BucketArn`, {\n      key: `${stackName}${this.id}BucketArn`,\n      exportName: `${stackName}${this.id}BucketArn`,\n      value: this.bucket.bucketArn,\n      description: `S3 Bucket ARN for ${this.id}`\n    });\n\n    new CfnOutput(this, `${this.id}BucketName`, {\n      key: `${stackName}${this.id}BucketName`,\n      exportName: `${stackName}${this.id}BucketName`,\n      value: this.bucket.bucketName,\n      description: `S3 Bucket Name for ${this.id}`\n    });\n  }\n\n  getBucket(): IBucket {\n    return this.bucket;\n  }\n\n  getBucketName(): string {\n    return this.bucket.bucketName;\n  }\n\n  getBucketArn(): string {\n    return this.bucket.bucketArn;\n  }\n\n  getBucketType(): S3BucketType {\n    return this._bucketType;\n  }\n\n  getBucketDomainName(): string {\n    return this.bucket.bucketDomainName;\n  }\n\n  getBucketRegionalDomainName(): string {\n    return this.bucket.bucketRegionalDomainName;\n  }\n\n  getS3Bucket(): S3Bucket | S3WebsiteBucket | S3PublicReadBucket {\n    return this.bucket;\n  }\n\n  grantRead(grantee: IGrantable): Grant {\n    return this.bucket.grantRead(grantee);\n  }\n\n  grantWrite(grantee: IGrantable): Grant {\n    return this.bucket.grantWrite(grantee);\n  }\n\n  grantReadWrite(grantee: IGrantable): Grant {\n    return this.bucket.grantReadWrite(grantee);\n  }\n\n  grantDelete(grantee: IGrantable): Grant {\n    return this.bucket.grantDelete(grantee);\n  }\n\n  grantPut(grantee: IGrantable): Grant {\n    return this.bucket.grantPut(grantee);\n  }\n\n  addEventNotification(\n    event: EventType,\n    dest: IBucketNotificationDestination,\n    ...filters: NotificationKeyFilter[]\n  ): void {\n    this.bucket.addEventNotification(event, dest, ...filters);\n  }\n\n  addObjectCreatedNotification(\n    dest: IBucketNotificationDestination,\n    ...filters: NotificationKeyFilter[]\n  ): void {\n    this.bucket.addObjectCreatedNotification(dest, ...filters);\n  }\n\n  addObjectRemovedNotification(\n    dest: IBucketNotificationDestination,\n    ...filters: NotificationKeyFilter[]\n  ): void {\n    this.bucket.addObjectRemovedNotification(dest, ...filters);\n  }\n}\n\n/**\n * Private S3 storage.\n * Standard bucket with optional encryption and versioning.\n */\nexport class PrivateStorage extends S3StorageBase implements IPrivateStorage {\n  public readonly storageType = \"private\" as const;\n\n  private _deployment?: BucketDeployment;\n\n  constructor(scope: Construct, id: string, props: PrivateS3Props) {\n    super(scope, id, props);\n    this.initialisePrivateBucket(props);\n\n    if (props.deployment) {\n      this._deployment = this.createDeployment(id, props.deployment);\n    }\n  }\n\n  private createDeployment(\n    id: string,\n    config: S3DeploymentConfig\n  ): BucketDeployment {\n    const cacheControlHeaders: CacheControl[] = [];\n\n    if (config.cacheControl?.maxAge !== undefined) {\n      cacheControlHeaders.push(\n        CacheControl.maxAge(Duration.seconds(config.cacheControl.maxAge))\n      );\n    }\n    if (config.cacheControl?.immutable) {\n      cacheControlHeaders.push(CacheControl.immutable());\n    }\n\n    return new BucketDeployment(this, `${id}Deployment`, {\n      sources: [Source.asset(config.source)],\n      destinationBucket: this.bucket,\n      prune: config.prune ?? true,\n      ...(cacheControlHeaders.length > 0 && {\n        cacheControl: cacheControlHeaders\n      })\n    });\n  }\n\n  /**\n   * Grant public access to objects under a prefix.\n   * Use with caution - makes objects publicly readable.\n   */\n  grantPublicAccess(...keyPrefix: string[]): Grant {\n    return this.bucket.grantPublicAccess(...keyPrefix);\n  }\n\n  /**\n   * Get the BucketDeployment construct if one was created.\n   * Returns undefined if no deployment was configured.\n   */\n  getDeployment(): BucketDeployment | undefined {\n    return this._deployment;\n  }\n}\n\n/**\n * Website S3 storage.\n * Bucket configured for static website hosting.\n */\nexport class WebsiteStorage extends S3StorageBase implements IWebsiteStorage {\n  public readonly storageType = \"website\" as const;\n\n  constructor(scope: Construct, id: string, props: WebsiteS3Props) {\n    super(scope, id, props);\n    this.initialiseWebsiteBucket(props);\n  }\n\n  /** Get the website URL. */\n  getWebsiteUrl(): string {\n    return this.bucket.bucketWebsiteUrl ?? \"\";\n  }\n}\n\n/**\n * Public read S3 storage.\n * Bucket with public read access enabled.\n */\nexport class PublicStorage extends S3StorageBase implements IPublicStorage {\n  public readonly storageType = \"publicRead\" as const;\n\n  constructor(scope: Construct, id: string, props: PublicReadS3Props) {\n    super(scope, id, props);\n    this.initialisePublicReadBucket(props);\n  }\n}\n"]}

package/dist/lib/resources/aws/backup/backupPlan.js

@@ -9,19 +9,16 @@ class BackupPlan extends constructs_1.Construct {
     constructor(scope, id, props) {
         super(scope, id);
         const tagKey = props.tagKey || "fjall:disasterRecovery:tier";
-        // Create backup plan with provided rules
         this.plan = new aws_backup_1.BackupPlan(this, `${props.planName}Plan`, {
             backupPlanName: props.planName,
             backupVault: props.backupVault.vault,
             backupPlanRules: props.rules
         });
-        // Create tag-based selection
         this.selection = new aws_backup_1.BackupSelection(this, `${props.planName}Selection`, {
             backupPlan: this.plan,
             resources: [aws_backup_1.BackupResource.fromTag(tagKey, props.tagValue)],
             role: this.createBackupRole(props)
         });
-        // Export plan ARN (wrapper handles sanitisation)
         this.planArn = new aws_cdk_lib_1.CfnOutput(this, `${props.planName}PlanArn`, {
             key: `${props.planName}PlanArn`,
             value: this.plan.backupPlanArn,
@@ -33,10 +30,8 @@ class BackupPlan extends constructs_1.Construct {
             assumedBy: new iam.ServicePrincipal("backup.amazonaws.com"),
             description: `Backup role for ${props.planName}`,
             managedPolicies: [
-                // Core backup policies
                 iam.ManagedPolicy.fromAwsManagedPolicyName("service-role/AWSBackupServiceRolePolicyForBackup"),
                 iam.ManagedPolicy.fromAwsManagedPolicyName("service-role/AWSBackupServiceRolePolicyForRestores"),
-                // S3 backup support
                 iam.ManagedPolicy.fromAwsManagedPolicyName("AWSBackupServiceRolePolicyForS3Backup"),
                 iam.ManagedPolicy.fromAwsManagedPolicyName("AWSBackupServiceRolePolicyForS3Restore")
             ]
@@ -62,4 +57,4 @@ class BackupPlan extends constructs_1.Construct {
     }
 }
 exports.BackupPlan = BackupPlan;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFja3VwUGxhbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYi9yZXNvdXJjZXMvYXdzL2JhY2t1cC9iYWNrdXBQbGFuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDJDQUF1QztBQUN2Qyw2Q0FBd0M7QUFDeEMsdURBS2dDO0FBQ2hDLDJDQUEyQztBQVczQyxNQUFhLFVBQVcsU0FBUSxzQkFBUztJQUt2QyxZQUFZLEtBQWdCLEVBQUUsRUFBVSxFQUFFLEtBQXNCO1FBQzlELEtBQUssQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFFakIsTUFBTSxNQUFNLEdBQUcsS0FBSyxDQUFDLE1BQU0sSUFBSSw2QkFBNkIsQ0FBQztRQUU3RCxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksdUJBQUksQ0FBQyxJQUFJLEVBQUUsR0FBRyxLQUFLLENBQUMsUUFBUSxNQUFNLEVBQUU7WUFDbEQsY0FBYyxFQUFFLEtBQUssQ0FBQyxRQUFRO1lBQzlCLFdBQVcsRUFBRSxLQUFLLENBQUMsV0FBVyxDQUFDLEtBQUs7WUFDcEMsZUFBZSxFQUFFLEtBQUssQ0FBQyxLQUFLO1NBQzdCLENBQUMsQ0FBQztRQUVILElBQUksQ0FBQyxTQUFTLEdBQUcsSUFBSSw0QkFBZSxDQUFDLElBQUksRUFBRSxHQUFHLEtBQUssQ0FBQyxRQUFRLFdBQVcsRUFBRTtZQUN2RSxVQUFVLEVBQUUsSUFBSSxDQUFDLElBQUk7WUFDckIsU0FBUyxFQUFFLENBQUMsMkJBQWMsQ0FBQyxPQUFPLENBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUMzRCxJQUFJLEVBQUUsSUFBSSxDQUFDLGdCQUFnQixDQUFDLEtBQUssQ0FBQztTQUNuQyxDQUFDLENBQUM7UUFFSCxJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksdUJBQVMsQ0FBQyxJQUFJLEVBQUUsR0FBRyxLQUFLLENBQUMsUUFBUSxTQUFTLEVBQUU7WUFDN0QsR0FBRyxFQUFFLEdBQUcsS0FBSyxDQUFDLFFBQVEsU0FBUztZQUMvQixLQUFLLEVBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxhQUFhO1lBQzlCLFVBQVUsRUFBRSxHQUFHLEtBQUssQ0FBQyxRQUFRLGVBQWU7U0FDN0MsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVPLGdCQUFnQixDQUFDLEtBQXNCO1FBQzdDLE1BQU0sSUFBSSxHQUFHLElBQUksR0FBRyxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsR0FBRyxLQUFLLENBQUMsUUFBUSxZQUFZLEVBQUU7WUFDN0QsU0FBUyxFQUFFLElBQUksR0FBRyxDQUFDLGdCQUFnQixDQUFDLHNCQUFzQixDQUFDO1lBQzNELFdBQVcsRUFBRSxtQkFBbUIsS0FBSyxDQUFDLFFBQVEsRUFBRTtZQUNoRCxlQUFlLEVBQUU7Z0JBQ2YsR0FBRyxDQUFDLGFBQWEsQ0FBQyx3QkFBd0IsQ0FDeEMsa0RBQWtELENBQ25EO2dCQUNELEdBQUcsQ0FBQyxhQUFhLENBQUMsd0JBQXdCLENBQ3hDLG9EQUFvRCxDQUNyRDtnQkFDRCxHQUFHLENBQUMsYUFBYSxDQUFDLHdCQUF3QixDQUN4Qyx1Q0FBdUMsQ0FDeEM7Z0JBQ0QsR0FBRyxDQUFDLGFBQWEsQ0FBQyx3QkFBd0IsQ0FDeEMsd0NBQXdDLENBQ3pDO2FBQ0Y7U0FDRixDQUFDLENBQUM7UUFFSCxJQUFJLENBQUMsV0FBVyxDQUNkLElBQUksR0FBRyxDQUFDLGVBQWUsQ0FBQztZQUN0QixNQUFNLEVBQUUsR0FBRyxDQUFDLE1BQU0sQ0FBQyxLQUFLO1lBQ3hCLE9BQU8sRUFBRTtnQkFDUCxzQkFBc0I7Z0JBQ3RCLHdDQUF3QztnQkFDeEMsb0NBQW9DO2dCQUNwQyx5QkFBeUI7Z0JBQ3pCLHdCQUF3QjtnQkFDeEIsbUNBQW1DO2FBQ3BDO1lBQ0QsU0FBUyxFQUFFLENBQUMsR0FBRyxDQUFDO1NBQ2pCLENBQUMsQ0FDSCxDQUFDO1FBQ0YsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBRUQsTUFBTSxDQUFDLEtBQUssQ0FBQyxFQUFVLEVBQUUsS0FBc0I7UUFDN0MsT0FBTyxDQUFDLEtBQWdCLEVBQUUsRUFBRTtZQUMxQixPQUFPLElBQUksVUFBVSxDQUFDLEtBQUssRUFBRSxFQUFFLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFDMUMsQ0FBQyxDQUFDO0lBQ0osQ0FBQztDQUNGO0FBdkVELGdDQXVFQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbnN0cnVjdCB9IGZyb20gXCJjb25zdHJ1Y3RzXCI7XG5pbXBvcnQgeyBDZm5PdXRwdXQgfSBmcm9tIFwiYXdzLWNkay1saWJcIjtcbmltcG9ydCB7XG4gIEJhY2t1cFBsYW4gYXMgUGxhbixcbiAgQmFja3VwU2VsZWN0aW9uLFxuICBCYWNrdXBSZXNvdXJjZSxcbiAgdHlwZSBCYWNrdXBQbGFuUnVsZVxufSBmcm9tIFwiYXdzLWNkay1saWIvYXdzLWJhY2t1cFwiO1xuaW1wb3J0ICogYXMgaWFtIGZyb20gXCJhd3MtY2RrLWxpYi9hd3MtaWFtXCI7XG5pbXBvcnQgeyB0eXBlIEJhY2t1cFZhdWx0IH0gZnJvbSBcIi4vYmFja3VwVmF1bHRcIjtcblxuZXhwb3J0IGludGVyZmFjZSBCYWNrdXBQbGFuUHJvcHMge1xuICBwbGFuTmFtZTogc3RyaW5nO1xuICBydWxlczogQmFja3VwUGxhblJ1bGVbXTtcbiAgYmFja3VwVmF1bHQ6IEJhY2t1cFZhdWx0O1xuICB0YWdWYWx1ZTogc3RyaW5nO1xuICB0YWdLZXk/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBjbGFzcyBCYWNrdXBQbGFuIGV4dGVuZHMgQ29uc3RydWN0IHtcbiAgcHVibGljIHJlYWRvbmx5IHBsYW46IFBsYW47XG4gIHB1YmxpYyByZWFkb25seSBzZWxlY3Rpb246IEJhY2t1cFNlbGVjdGlvbjtcbiAgcHVibGljIHJlYWRvbmx5IHBsYW5Bcm46IENmbk91dHB1dDtcblxuICBjb25zdHJ1Y3RvcihzY29wZTogQ29uc3RydWN0LCBpZDogc3RyaW5nLCBwcm9wczogQmFja3VwUGxhblByb3BzKSB7XG4gICAgc3VwZXIoc2NvcGUsIGlkKTtcblxuICAgIGNvbnN0IHRhZ0tleSA9IHByb3BzLnRhZ0tleSB8fCBcImZqYWxsOmRpc2FzdGVyUmVjb3Zlcnk6dGllclwiO1xuXG4gICAgdGhpcy5wbGFuID0gbmV3IFBsYW4odGhpcywgYCR7cHJvcHMucGxhbk5hbWV9UGxhbmAsIHtcbiAgICAgIGJhY2t1cFBsYW5OYW1lOiBwcm9wcy5wbGFuTmFtZSxcbiAgICAgIGJhY2t1cFZhdWx0OiBwcm9wcy5iYWNrdXBWYXVsdC52YXVsdCxcbiAgICAgIGJhY2t1cFBsYW5SdWxlczogcHJvcHMucnVsZXNcbiAgICB9KTtcblxuICAgIHRoaXMuc2VsZWN0aW9uID0gbmV3IEJhY2t1cFNlbGVjdGlvbih0aGlzLCBgJHtwcm9wcy5wbGFuTmFtZX1TZWxlY3Rpb25gLCB7XG4gICAgICBiYWNrdXBQbGFuOiB0aGlzLnBsYW4sXG4gICAgICByZXNvdXJjZXM6IFtCYWNrdXBSZXNvdXJjZS5mcm9tVGFnKHRhZ0tleSwgcHJvcHMudGFnVmFsdWUpXSxcbiAgICAgIHJvbGU6IHRoaXMuY3JlYXRlQmFja3VwUm9sZShwcm9wcylcbiAgICB9KTtcblxuICAgIHRoaXMucGxhbkFybiA9IG5ldyBDZm5PdXRwdXQodGhpcywgYCR7cHJvcHMucGxhbk5hbWV9UGxhbkFybmAsIHtcbiAgICAgIGtleTogYCR7cHJvcHMucGxhbk5hbWV9UGxhbkFybmAsXG4gICAgICB2YWx1ZTogdGhpcy5wbGFuLmJhY2t1cFBsYW5Bcm4sXG4gICAgICBleHBvcnROYW1lOiBgJHtwcm9wcy5wbGFuTmFtZX1CYWNrdXBQbGFuQXJuYFxuICAgIH0pO1xuICB9XG5cbiAgcHJpdmF0ZSBjcmVhdGVCYWNrdXBSb2xlKHByb3BzOiBCYWNrdXBQbGFuUHJvcHMpOiBpYW0uUm9sZSB7XG4gICAgY29uc3Qgcm9sZSA9IG5ldyBpYW0uUm9sZSh0aGlzLCBgJHtwcm9wcy5wbGFuTmFtZX1CYWNrdXBSb2xlYCwge1xuICAgICAgYXNzdW1lZEJ5OiBuZXcgaWFtLlNlcnZpY2VQcmluY2lwYWwoXCJiYWNrdXAuYW1hem9uYXdzLmNvbVwiKSxcbiAgICAgIGRlc2NyaXB0aW9uOiBgQmFja3VwIHJvbGUgZm9yICR7cHJvcHMucGxhbk5hbWV9YCxcbiAgICAgIG1hbmFnZWRQb2xpY2llczogW1xuICAgICAgICBpYW0uTWFuYWdlZFBvbGljeS5mcm9tQXdzTWFuYWdlZFBvbGljeU5hbWUoXG4gICAgICAgICAgXCJzZXJ2aWNlLXJvbGUvQVdTQmFja3VwU2VydmljZVJvbGVQb2xpY3lGb3JCYWNrdXBcIlxuICAgICAgICApLFxuICAgICAgICBpYW0uTWFuYWdlZFBvbGljeS5mcm9tQXdzTWFuYWdlZFBvbGljeU5hbWUoXG4gICAgICAgICAgXCJzZXJ2aWNlLXJvbGUvQVdTQmFja3VwU2VydmljZVJvbGVQb2xpY3lGb3JSZXN0b3Jlc1wiXG4gICAgICAgICksXG4gICAgICAgIGlhbS5NYW5hZ2VkUG9saWN5LmZyb21Bd3NNYW5hZ2VkUG9saWN5TmFtZShcbiAgICAgICAgICBcIkFXU0JhY2t1cFNlcnZpY2VSb2xlUG9saWN5Rm9yUzNCYWNrdXBcIlxuICAgICAgICApLFxuICAgICAgICBpYW0uTWFuYWdlZFBvbGljeS5mcm9tQXdzTWFuYWdlZFBvbGljeU5hbWUoXG4gICAgICAgICAgXCJBV1NCYWNrdXBTZXJ2aWNlUm9sZVBvbGljeUZvclMzUmVzdG9yZVwiXG4gICAgICAgIClcbiAgICAgIF1cbiAgICB9KTtcblxuICAgIHJvbGUuYWRkVG9Qb2xpY3koXG4gICAgICBuZXcgaWFtLlBvbGljeVN0YXRlbWVudCh7XG4gICAgICAgIGVmZmVjdDogaWFtLkVmZmVjdC5BTExPVyxcbiAgICAgICAgYWN0aW9uczogW1xuICAgICAgICAgIFwicmRzOk1vZGlmeURCSW5zdGFuY2VcIixcbiAgICAgICAgICBcInJkczpEZXNjcmliZURCSW5zdGFuY2VBdXRvbWF0ZWRCYWNrdXBzXCIsXG4gICAgICAgICAgXCJyZHM6UmVzdG9yZURCSW5zdGFuY2VUb1BvaW50SW5UaW1lXCIsXG4gICAgICAgICAgXCJyZHM6RGVzY3JpYmVEQkluc3RhbmNlc1wiLFxuICAgICAgICAgIFwicmRzOkRlc2NyaWJlREJDbHVzdGVyc1wiLFxuICAgICAgICAgIFwicmRzOlJlc3RvcmVEQkNsdXN0ZXJUb1BvaW50SW5UaW1lXCJcbiAgICAgICAgXSxcbiAgICAgICAgcmVzb3VyY2VzOiBbXCIqXCJdXG4gICAgICB9KVxuICAgICk7XG4gICAgcmV0dXJuIHJvbGU7XG4gIH1cblxuICBzdGF0aWMgYnVpbGQoaWQ6IHN0cmluZywgcHJvcHM6IEJhY2t1cFBsYW5Qcm9wcykge1xuICAgIHJldHVybiAoc2NvcGU6IENvbnN0cnVjdCkgPT4ge1xuICAgICAgcmV0dXJuIG5ldyBCYWNrdXBQbGFuKHNjb3BlLCBpZCwgcHJvcHMpO1xuICAgIH07XG4gIH1cbn1cbiJdfQ==