@fjall/components-infrastructure 0.86.1 → 0.87.4

package/dist/lib/app.js

@@ -12,6 +12,8 @@ const monitoringRole_1 = require("./resources/aws/monitoring/monitoringRole");
 const monitoring_1 = require("./config/monitoring");
 const auditRole_1 = require("./resources/aws/audit/auditRole");
 const audit_1 = require("./config/audit");
+const validationLogger_1 = require("./utils/validationLogger");
+const manifestWriter_1 = require("./utils/manifestWriter");
 /**
  * The basic corner-stone of all Fjall-hosted applications.
  *  This class is a singleton and should be used to create and manage
@@ -26,10 +28,9 @@ class App extends aws_cdk_lib_1.App {
         this.globalTags = {};
         this.aspectApplied = false;
         App.instance = this;
-        if (name)
-            this.name = name;
-        else
-            this.name = "FjallApp";
+        this.name = name ?? "FjallApp";
+        // Initialise manifest collector for build-time service discovery
+        this.manifestCollector = (0, manifestWriter_1.getManifestCollector)(this.name);
         this.initialiseStandardTags();
         // Initialise network immediately if configured
         if (options?.network === false) {
@@ -101,6 +102,29 @@ class App extends aws_cdk_lib_1.App {
         if (!App.instance) {
             App.instance = new App(name, options);
         }
+        else {
+            // If singleton exists but name differs, update it (before any infra is defined)
+            if (name && App.instance.name !== name) {
+                // Warn if network already initialised - changing name after network exists creates a mismatch
+                if (App.instance.vpc) {
+                    validationLogger_1.FjallLogger.warn(`App name changed from "${App.instance.name}" to "${name}" after network was initialised. ` +
+                        `VPC will have name "${App.instance.name}Vpc" but app name is "${name}". ` +
+                        `Ensure App.getApp() is called with the final name before initialising network.`);
+                }
+                App.instance.name = name;
+                // Reinitialise standard tags with the new name
+                App.instance.initialiseStandardTags();
+            }
+            // If options provided but network not yet initialised, initialise it now
+            if (options?.network === false) {
+                App.instance.networkDisabled = true;
+            }
+            else if (options?.network &&
+                !App.instance.vpc &&
+                !App.instance.networkDisabled) {
+                App.instance.initialiseNetwork(options.network);
+            }
+        }
         return App.instance;
     }
     /**
@@ -155,6 +179,29 @@ class App extends aws_cdk_lib_1.App {
     getDefaultStorageStack() {
         return this.getStack(`${this.name}Storage`, this.getDefaultNetworkStack());
     }
+    /**
+     * Retrieve default CDN stack - named as `${this.name}Cdn`
+     *
+     * Depends on Network. Compute/Storage dependencies are added automatically
+     * by CDK when CDN resources reference ALB or S3 bucket resources.
+     *
+     * @returns {AwsStack}
+     */
+    getDefaultCdnStack() {
+        return this.getStack(`${this.name}Cdn`, this.getDefaultNetworkStack());
+    }
+    /**
+     * Retrieve default messaging stack - named as `${this.name}Messaging`
+     *
+     * Used for SQS queues, SNS topics, and EventBridge event buses.
+     * Depends on Network only. These are regional services that don't
+     * require VPC, but we maintain consistent stack dependency patterns.
+     *
+     * @returns {AwsStack}
+     */
+    getDefaultMessagingStack() {
+        return this.getStack(`${this.name}Messaging`, this.getDefaultNetworkStack());
+    }
     /**
      * Get a VPC by name. If no name is provided, returns the default VPC.
      *
@@ -280,7 +327,26 @@ class App extends aws_cdk_lib_1.App {
      * Add a compute resource to the default compute stack using the factory pattern.
      * Automatically creates monitoring role if not already created.
      *
-     * Supports ComputeFactory (ECS, EC2, Lambda).
+     * Returns the appropriate compute type based on the factory configuration:
+     * - EcsCompute for type: "ecs"
+     * - LambdaCompute for type: "lambda"
+     * - Ec2Compute for type: "ec2"
+     *
+     * @example
+     * // ECS compute - returns EcsCompute
+     * const api = app.addCompute(ComputeFactory.build("Api", {
+     *   type: "ecs",
+     *   services: [{ name: "api", ... }]
+     * }));
+     * api.getLoadBalancer(); // Available on EcsCompute
+     *
+     * @example
+     * // Lambda compute - returns LambdaCompute
+     * const worker = app.addCompute(ComputeFactory.build("Worker", {
+     *   type: "lambda",
+     *   functions: [{ name: "process", ... }]
+     * }));
+     * worker.getFunction("process"); // Available on LambdaCompute
      */
     addCompute(fn) {
         // Auto-create monitoring role when compute is added
@@ -301,6 +367,23 @@ class App extends aws_cdk_lib_1.App {
     }
     /**
      * Add a database resource to the default database stack using the factory pattern.
+     * Returns the appropriate database type based on the factory used.
+     *
+     * @example
+     * // Aurora database - returns RelationalDatabase
+     * const db = app.addDatabase(DatabaseFactory.build("Main", {
+     *   type: "Aurora",
+     *   databaseName: "myapp"
+     * }));
+     * db.getHostEndpoint(); // Available
+     *
+     * @example
+     * // DynamoDB table - returns DynamoDBDatabase
+     * const cache = app.addDatabase(DatabaseFactory.build("Cache", {
+     *   type: "DynamoDB",
+     *   partitionKey: { name: "id", type: "S" }
+     * }));
+     * cache.getTableName(); // Available
      */
     addDatabase(fn) {
         const databaseStack = this.getDefaultDatabaseStack();
@@ -310,6 +393,25 @@ class App extends aws_cdk_lib_1.App {
     }
     /**
      * Add a storage resource (S3) to the default storage stack using the factory pattern.
+     *
+     * Returns the appropriate storage type based on the factory configuration:
+     * - PrivateStorage for bucketType: "private"
+     * - WebsiteStorage for bucketType: "website"
+     * - PublicStorage for bucketType: "publicRead"
+     *
+     * @example
+     * // Private storage - returns PrivateStorage
+     * const assets = app.addStorage(StorageFactory.build("Assets", {
+     *   bucketType: "private"
+     * }));
+     * assets.grantPublicAccess("public/*"); // Available on PrivateStorage
+     *
+     * @example
+     * // Website storage - returns WebsiteStorage
+     * const site = app.addStorage(StorageFactory.build("Site", {
+     *   bucketType: "website"
+     * }));
+     * site.getWebsiteUrl(); // Available on WebsiteStorage
      */
     addStorage(fn) {
         const storageStack = this.getDefaultStorageStack();
@@ -317,6 +419,95 @@ class App extends aws_cdk_lib_1.App {
         storageStack.addConstruct(storageConstruct);
         return storageConstruct;
     }
+    /**
+     * Add a CDN resource (CloudFront) to the default CDN stack using the factory pattern.
+     *
+     * @example
+     * // S3 origin
+     * const assets = app.addStorage(StorageFactory.build("Assets", { bucketType: "private" }));
+     * app.addCdn(CdnFactory.build("AssetsCdn", {
+     *   originType: "s3",
+     *   bucket: assets
+     * }));
+     *
+     * @example
+     * // ALB origin (ECS)
+     * const api = app.addCompute(ComputeFactory.build("Api", { type: "ecs", ... }));
+     * app.addCdn(CdnFactory.build("ApiCdn", {
+     *   originType: "alb",
+     *   loadBalancer: api
+     * }));
+     */
+    addCdn(fn) {
+        const cdnStack = this.getDefaultCdnStack();
+        const cdn = fn(this, cdnStack.getStack());
+        cdnStack.addConstruct(cdn);
+        return cdn;
+    }
+    /**
+     * Add a messaging resource to the default queue stack using the factory pattern.
+     *
+     * Returns the appropriate messaging type based on the factory configuration.
+     * Currently supports queue (SQS), with future support planned for
+     * topic (SNS), eventbus (EventBridge), and stream (Kinesis).
+     *
+     * @example
+     * // Queue messaging - returns QueueMessaging
+     * const notifications = app.addMessaging(MessagingFactory.build("Notifications", {
+     *   type: "queue",
+     *   queueType: "standard",
+     *   deadLetterQueue: { enabled: true, maxReceiveCount: 3 }
+     * }));
+     * notifications.grantSendMessages(apiFunction);
+     *
+     * @example
+     * // FIFO queue for OpenNext revalidation
+     * const revalidation = app.addMessaging(MessagingFactory.build("Revalidation", {
+     *   type: "queue",
+     *   queueType: "fifo",
+     *   visibilityTimeout: 300,
+     *   contentBasedDeduplication: true
+     * }));
+     */
+    addMessaging(fn) {
+        const messagingStack = this.getDefaultMessagingStack();
+        const messaging = fn(this, messagingStack.getStack());
+        messagingStack.addConstruct(messaging);
+        return messaging;
+    }
+    /**
+     * Add a high-level infrastructure pattern to the application.
+     *
+     * Patterns are composite constructs that create multiple related resources
+     * as a single, cohesive unit. They encapsulate best practices and reduce
+     * boilerplate for common deployment scenarios.
+     *
+     * Currently supported patterns:
+     * - `payload`: Payload CMS deployment with OpenNext
+     *
+     * Returns the appropriate pattern interface based on the factory configuration,
+     * providing access to all underlying resources via escape hatches.
+     *
+     * @example
+     * // Payload CMS pattern - returns Payload
+     * const payload = app.addPattern(PatternFactory.build("PayloadApp", {
+     *   type: "payload",
+     *   name: "my-cms",
+     *   source: "../.."
+     * }));
+     *
+     * @example
+     * // Escape hatches - access underlying resources
+     * payload.getDatabase().grantConnect(otherLambda);
+     * payload.getServer().getLambdaFunction().addEnvironment("CUSTOM", "value");
+     * payload.getCdn().getDistribution().addBehavior("/custom/*", customOrigin);
+     */
+    addPattern(fn) {
+        const computeStack = this.getDefaultComputeStack();
+        const pattern = fn(this, computeStack.getStack());
+        computeStack.addConstruct(pattern);
+        return pattern;
+    }
     /**
      * Add an additional network (VPC) to the application.
      *
@@ -408,30 +599,31 @@ class App extends aws_cdk_lib_1.App {
     exportResourceInventory() {
         return {
             resources: this.resourceInventory.getInventory(),
-            generated_at: new Date().toISOString(),
-            app_name: this.name
+            generatedAt: new Date().toISOString(),
+            appName: this.name
         };
     }
     /**
-     * Override synth to automatically export resource inventory
+     * Get the manifest collector for registering services and patterns.
+     * Used by ComputeFactory and PatternFactory to register their configurations.
+     */
+    getManifestCollector() {
+        return this.manifestCollector;
+    }
+    /**
+     * Override synth to automatically export resource inventory and manifest
      */
     synth(options) {
         // Call parent synth first
         const assembly = super.synth(options);
-        // After synthesis, write resource inventory to cdk.out
+        // After synthesis, write Fjall manifest to cdk.out
         try {
-            // const fs = require("fs");
-            // const path = require("path");
-            // const inventory = this.exportResourceInventory();
-            // const inventoryPath = path.join(
-            //   assembly.directory,
-            //   "resource-inventory.json"
-            // );
-            // fs.writeFileSync(inventoryPath, JSON.stringify(inventory, null, 2));
+            (0, manifestWriter_1.writeManifest)(assembly, this.manifestCollector);
         }
         catch (error) {
-            // Don't fail synth if inventory export fails
-            console.warn("Failed to export resource inventory:", error);
+            // Don't fail synth if manifest export fails
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            validationLogger_1.FjallLogger.warn(`Failed to export Fjall manifest: ${errorMessage}`);
         }
         return assembly;
     }
@@ -439,4 +631,4 @@ class App extends aws_cdk_lib_1.App {
 exports.App = App;
 App.instance = null;
 exports.default = App;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.js","sourceRoot":"","sources":["../../lib/app.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  App as CdkApp,\n  Aspects,\n  Tags,\n  type StageSynthesisOptions\n} from \"aws-cdk-lib\";\nimport { type CloudAssembly } from \"aws-cdk-lib/cx-api\";\nimport { type Construct } from \"constructs\";\nimport { Vpc } from \"./resources/aws/networking/vpc\";\nimport { type IVpc } from \"aws-cdk-lib/aws-ec2\";\nimport { type Role } from \"aws-cdk-lib/aws-iam\";\nimport { AwsStack } from \"./resources\";\nimport { type Ecr, EcrFactory } from \"./resources/aws/storage/ecr\";\nimport { type Database } from \"./patterns/aws/database\";\nimport {\n  type INetworkProps,\n  NetworkFactory,\n  type Network\n} from \"./patterns/aws/network\";\nimport { StandardTagsAspect } from \"./utils/standardTagsAspect\";\nimport {\n  type ResourceInventoryAspect,\n  type ResourceInventory\n} from \"./aspects/resourceInventory\";\nimport { getConfig } from \"./utils/getConfig\";\nimport MonitoringRoleFactory from \"./resources/aws/monitoring/monitoringRole\";\nimport { FJALL_MONITORING_CONFIG } from \"./config/monitoring\";\nimport AuditRoleFactory from \"./resources/aws/audit/auditRole\";\nimport { FJALL_AUDIT_CONFIG } from \"./config/audit\";\n\n/**\n * Configuration options for App.getApp().\n *\n * @example\n * // Create app with new VPC\n * const app = App.getApp(appName, {\n *   network: { maxAzs: 2, natGateways: false }\n * });\n *\n * @example\n * // Create app using existing VPC\n * const app = App.getApp(appName, {\n *   network: { useExisting: \"vpc-12345678\" }\n * });\n *\n * @example\n * // Create app without network (S3-only apps)\n * const app = App.getApp(appName, { network: false });\n */\nexport interface IAppOptions {\n  /**\n   * Network configuration.\n   * - Object with INetworkProps: Create new VPC with config\n   * - false: No network (for S3-only apps)\n   * - { useExisting: string }: Use existing VPC by ID\n   */\n  network?: INetworkProps | false | { useExisting: string };\n}\n\n/**\n * The basic corner-stone of all Fjall-hosted applications.\n *  This class is a singleton and should be used to create and manage\n *   all resources in a Fjall application.\n */\nexport class App extends CdkApp {\n  private static instance: App | null = null;\n\n  private name: string;\n  private stacks: { [key: string]: AwsStack } = {};\n\n  private vpc?: IVpc;\n  private additionalVpcs = new Map<string, IVpc>();\n  private defaultEcr: Ecr;\n  private defaultMonitoringRole: Role;\n  private defaultAuditRole: Role;\n  private auditRoleExternalId?: string;\n  private networkDisabled = false;\n  private globalTags: { [key: string]: string } = {};\n  private aspectApplied = false;\n  private resourceInventory: ResourceInventoryAspect;\n\n  private constructor(name?: string, options?: IAppOptions) {\n    super();\n\n    App.instance = this;\n\n    if (name) this.name = name;\n    else this.name = \"FjallApp\";\n\n    this.initialiseStandardTags();\n\n    // Initialise network immediately if configured\n    if (options?.network === false) {\n      this.networkDisabled = true;\n    } else if (options?.network) {\n      this.initialiseNetwork(options.network);\n    }\n  }\n\n  /**\n   * Initialise the network (VPC) for this application.\n   */\n  private initialiseNetwork(\n    config: INetworkProps | { useExisting: string }\n  ): void {\n    const networkStack = this.getDefaultNetworkStack();\n\n    if (\"useExisting\" in config) {\n      this.vpc = Vpc.fromLookup(\n        networkStack.getStack(),\n        `${this.name}ImportedVpc`,\n        {\n          vpcId: config.useExisting\n        }\n      );\n    } else {\n      const network = NetworkFactory.build(`${this.name}Vpc`, config)(\n        this,\n        networkStack.getStack()\n      );\n      this.vpc = network.getVpc();\n    }\n  }\n\n  /**\n   * Get the application name.\n   * @returns {string} The application name\n   */\n  public getName(): string {\n    return this.name;\n  }\n\n  /**\n   * Get/Create a basic Fjall Application with standard tags applied.\n   *\n   * @param name Application name\n   * @param options Configuration options including network settings\n   * @returns {App}\n   *\n   * @example\n   * // Create app with new VPC\n   * const app = App.getApp(appName, {\n   *   network: { maxAzs: 2, natGateways: false }\n   * });\n   *\n   * @example\n   * // Create app using existing VPC\n   * const app = App.getApp(appName, {\n   *   network: { useExisting: \"vpc-12345678\" }\n   * });\n   *\n   * @example\n   * // Create app without network (S3-only apps)\n   * const app = App.getApp(appName, { network: false });\n   */\n  public static getApp(name?: string, options?: IAppOptions): App {\n    const app = App.getInstance(name, options);\n    app.initialiseStandardTags();\n    return app;\n  }\n\n  /**\n   * Get/Create the singleton instance of the App\n   * @param name Application name\n   * @param options Configuration options including network settings\n   * @returns {App}\n   */\n  public static getInstance(name?: string, options?: IAppOptions): App {\n    // Despite supporting multiple stacks you can still only ever\n    // have a single Application per CDK deployment\n    if (!App.instance) {\n      App.instance = new App(name, options);\n    }\n\n    return App.instance;\n  }\n\n  /**\n   * Retrieve a stack by key. If the stack does not exist, it will be created.\n   *  Dependencies are only applied the first time a stack is created.\n   *\n   * @param key - The key of the stack\n   * @param dependencies - The stack(s) that this stack depends on\n   * @returns {AwsStack}\n   */\n  public getStack(key: string, dependencies?: AwsStack | AwsStack[]): AwsStack {\n    // Apply the aspect once before creating the first stack\n    if (\n      !this.aspectApplied &&\n      Object.keys(this.stacks).length === 0 &&\n      Object.keys(this.globalTags).length > 0\n    ) {\n      this.applyTagsAspect();\n    }\n\n    if (!this.stacks[key]) {\n      this.stacks[key] = new AwsStack(key, dependencies);\n    }\n\n    return this.stacks[key];\n  }\n\n  /**\n   * Retrieve default compute stack - named as `${this.name}Compute`\n   *\n   * Only depends on Network. Database dependency is added automatically\n   * by CDK when compute resources reference database resources.\n   *\n   * @returns {AwsStack}\n   */\n  public getDefaultComputeStack(): AwsStack {\n    return this.getStack(`${this.name}Compute`, this.getDefaultNetworkStack());\n  }\n\n  /**\n   * Retrieve default network stack - named as `${this.name}Network`\n   * @returns {AwsStack}\n   */\n  public getDefaultNetworkStack(): AwsStack {\n    return this.getStack(`${this.name}Network`);\n  }\n\n  /**\n   * Retrieve default database stack - named as `${this.name}Database`\n   * @returns {AwsStack}\n   */\n  public getDefaultDatabaseStack(): AwsStack {\n    return this.getStack(`${this.name}Database`, this.getDefaultNetworkStack());\n  }\n\n  /**\n   * Retrieve default storage stack - named as `${this.name}Storage`\n   * @returns {AwsStack}\n   */\n  public getDefaultStorageStack(): AwsStack {\n    return this.getStack(`${this.name}Storage`, this.getDefaultNetworkStack());\n  }\n\n  /**\n   * Get a VPC by name. If no name is provided, returns the default VPC.\n   *\n   * This is a pure getter - it never creates infrastructure.\n   * Network must be configured via App.getApp() options or app.addNetwork().\n   *\n   * @param name - Optional name of the VPC to retrieve. If not provided, returns the default VPC.\n   * @returns {IVpc} The configured VPC\n   * @throws {Error} If network is disabled, not configured, or named VPC not found\n   */\n  public getVpc(name?: string): IVpc {\n    if (this.networkDisabled) {\n      throw new Error(\n        \"Network is disabled for this app. Cannot get VPC. \" +\n          \"Pass network config to App.getApp() to enable networking.\"\n      );\n    }\n\n    // If name is provided, look in additional VPCs first\n    if (name) {\n      const additionalVpc = this.additionalVpcs.get(name);\n      if (additionalVpc) {\n        return additionalVpc;\n      }\n      throw new Error(\n        `VPC '${name}' not found. Available VPCs: ${this.getVpcNames().join(\", \")}. ` +\n          \"Create additional VPCs using app.addNetwork(NetworkFactory.build(...)).\"\n      );\n    }\n\n    // Return default VPC\n    if (!this.vpc) {\n      throw new Error(\n        \"Network not configured. Pass network config to App.getApp(). \" +\n          \"Example: App.getApp(appName, { network: { maxAzs: 2 } })\"\n      );\n    }\n    return this.vpc;\n  }\n\n  /**\n   * Get the names of all available VPCs.\n   *\n   * @returns {string[]} Array of VPC names. Includes \"default\" if the default VPC is configured.\n   */\n  public getVpcNames(): string[] {\n    const names: string[] = [];\n    if (this.vpc) {\n      names.push(\"default\");\n    }\n    names.push(...this.additionalVpcs.keys());\n    return names;\n  }\n\n  /**\n   * Retreive the default application container registry. If the registry does not exist\n   *  it will be created.\n   */\n  public getDefaultContainerRegistry(): Ecr {\n    if (!this.defaultEcr) {\n      const networkStack = this.getDefaultNetworkStack();\n\n      this.defaultEcr = EcrFactory.build(`${this.name}Ecr`)(\n        this,\n        networkStack.getStack()\n      );\n    }\n\n    return this.defaultEcr;\n  }\n\n  /**\n   * Create a cross-account monitoring role in the Network stack that allows\n   * the Fjall webapp to query CloudWatch metrics and ECS status.\n   *\n   * @param webappAccountId - Optional AWS account ID of the Fjall webapp. Defaults to configured platform account.\n   * @returns {Role} The created monitoring role\n   */\n  public createMonitoringRole(webappAccountId?: string): Role {\n    if (!this.defaultMonitoringRole) {\n      const networkStack = this.getDefaultNetworkStack();\n      const accountId =\n        webappAccountId || FJALL_MONITORING_CONFIG.webappAwsAccountId;\n\n      this.defaultMonitoringRole = MonitoringRoleFactory.build(\n        `${this.name}MonitoringRole`,\n        {\n          webappAccountId: accountId,\n          appName: this.name,\n          roleNamePrefix: FJALL_MONITORING_CONFIG.roleNamePrefix,\n          rolePath: FJALL_MONITORING_CONFIG.rolePath\n        }\n      )(this, networkStack.getStack());\n\n      // Register the role with the network stack\n      networkStack.addConstruct(this.defaultMonitoringRole);\n    }\n\n    return this.defaultMonitoringRole;\n  }\n\n  /**\n   * Create a cross-account audit role in the Network stack that allows\n   * the Fjall platform to use CloudQuery for comprehensive AWS resource auditing.\n   *\n   * This is an explicit opt-in feature. Call this method to enable CloudQuery\n   * audit capabilities for your application.\n   *\n   * @param webappAccountId - Optional AWS account ID of the Fjall webapp. Defaults to configured platform account.\n   * @param externalId - Optional external ID for additional security. If not provided, a unique ID will be generated.\n   * @returns {Role} The created audit role\n   */\n  public createAuditRole(webappAccountId?: string, externalId?: string): Role {\n    if (!this.defaultAuditRole) {\n      const networkStack = this.getDefaultNetworkStack();\n      const accountId =\n        webappAccountId || FJALL_AUDIT_CONFIG.webappAwsAccountId;\n\n      // Generate or use provided external ID\n      this.auditRoleExternalId = externalId || this.generateAuditExternalId();\n\n      this.defaultAuditRole = AuditRoleFactory.build(`${this.name}AuditRole`, {\n        webappAccountId: accountId,\n        appName: this.name,\n        externalId: this.auditRoleExternalId,\n        roleNamePrefix: FJALL_AUDIT_CONFIG.roleNamePrefix,\n        rolePath: FJALL_AUDIT_CONFIG.rolePath\n      })(this, networkStack.getStack());\n\n      // Register the role with the network stack\n      networkStack.addConstruct(this.defaultAuditRole);\n    }\n\n    return this.defaultAuditRole;\n  }\n\n  /**\n   * Get the external ID used for the audit role\n   * @returns {string | undefined} The external ID if audit role has been created\n   */\n  public getAuditRoleExternalId(): string | undefined {\n    return this.auditRoleExternalId;\n  }\n\n  /**\n   * Generate a unique external ID for audit role\n   * Format: fjall-audit-{appName}-{timestamp}\n   */\n  private generateAuditExternalId(): string {\n    const timestamp = Date.now();\n    return `fjall-audit-${this.name.toLowerCase()}-${timestamp}`;\n  }\n\n  /**\n   * Add a compute resource to the default compute stack using the factory pattern.\n   * Automatically creates monitoring role if not already created.\n   *\n   * Supports ComputeFactory (ECS, EC2, Lambda).\n   */\n  public addCompute<T extends Construct>(\n    fn: (app: App, scope: Construct) => T\n  ): T {\n    // Auto-create monitoring role when compute is added\n    if (!this.defaultMonitoringRole) {\n      this.createMonitoringRole();\n    }\n\n    const computeStack = this.getDefaultComputeStack();\n    const construct = fn(this, computeStack.getStack());\n    computeStack.addConstruct(construct);\n    return construct;\n  }\n\n  /**\n   * Manually add a resource to the default compute stack.\n   */\n  public addComputeResource(resource: Construct): void {\n    const computeStack = this.getDefaultComputeStack();\n    computeStack.addConstruct(resource);\n  }\n\n  /**\n   * Add a database resource to the default database stack using the factory pattern.\n   */\n  public addDatabase(fn: (app: App, scope: Construct) => Construct): Database {\n    const databaseStack = this.getDefaultDatabaseStack();\n    const databaseConstruct = fn(this, databaseStack.getStack());\n    databaseStack.addConstruct(databaseConstruct);\n\n    return databaseConstruct as unknown as Database;\n  }\n\n  /**\n   * Add a storage resource (S3) to the default storage stack using the factory pattern.\n   */\n  public addStorage(fn: (app: App, scope: Construct) => Construct): Construct {\n    const storageStack = this.getDefaultStorageStack();\n    const storageConstruct = fn(this, storageStack.getStack());\n    storageStack.addConstruct(storageConstruct);\n\n    return storageConstruct;\n  }\n\n  /**\n   * Add an additional network (VPC) to the application.\n   *\n   * Use this to create additional VPCs beyond the default VPC configured via App.getApp().\n   * Additional VPCs can be retrieved by name using app.getVpc(name).\n   *\n   * @param fn - Factory function that creates the Network construct\n   * @returns {Network} The created Network construct\n   *\n   * @example\n   * const isolatedVpc = app.addNetwork(\n   *   NetworkFactory.build(\"IsolatedVpc\", { maxAzs: 2, natGateways: false })\n   * );\n   */\n  public addNetwork(fn: (app: App, scope: Construct) => Network): Network {\n    const networkStack = this.getDefaultNetworkStack();\n    const network = fn(this, networkStack.getStack());\n    const vpcName = network.node.id;\n\n    // Store in additional VPCs map for retrieval via getVpc(name)\n    this.additionalVpcs.set(vpcName, network.getVpc());\n    networkStack.addConstruct(network);\n\n    return network;\n  }\n\n  /**\n   * Manually add a resource to the default database stack.\n   */\n  public addDatabaseResource(resource: Construct): void {\n    const databaseStack = this.getDefaultDatabaseStack();\n    databaseStack.addConstruct(resource);\n  }\n\n  /**\n   * Manually add a resource to the default storage stack.\n   */\n  public addStorageResource(resource: Construct): void {\n    const storageStack = this.getDefaultStorageStack();\n    storageStack.addConstruct(resource);\n  }\n\n  /**\n   * Initialize standard tags\n   */\n  private initialiseStandardTags(): void {\n    const config = getConfig();\n    this.globalTags = {\n      \"fjall:costAllocation:environment\": config.environment,\n      \"fjall:costAllocation:service\": this.name\n    };\n  }\n\n  /**\n   * Apply all tags using CDK's native Tags.of().add() API\n   */\n  private applyTagsAspect(): void {\n    if (!this.aspectApplied && Object.keys(this.globalTags).length > 0) {\n      // Apply standard tags using Tags.of(this).add()\n      Object.entries(this.globalTags).forEach(([key, value]) => {\n        Tags.of(this).add(key, value);\n      });\n\n      // Apply aspect for resource-specific tags (IPAM pool, backup tier)\n      Aspects.of(this).add(new StandardTagsAspect());\n\n      this.aspectApplied = true;\n    }\n  }\n\n  /**\n   * Add custom tags to all resources in the app.\n   *\n   * @param tags Custom tags to apply to all resources\n   * @example\n   * app.addTags({\n   *   \"fjall:costAllocation:owner\": \"platform-team\",\n   *   \"fjall:costAllocation:cost-center\": \"CC-123\",\n   *   \"team:slack-channel\": \"#platform-alerts\"\n   * });\n   */\n  public addTags(tags: { [key: string]: string }): App {\n    // Merge tags into globalTags for tracking\n    this.globalTags = {\n      ...this.globalTags,\n      ...tags\n    };\n    Object.entries(tags).forEach(([key, value]) => {\n      Tags.of(this).add(key, value);\n    });\n\n    return this;\n  }\n\n  /**\n   * Export resource inventory collected during synthesis\n   * Call this after app.synth() to get complete resource inventory\n   * @returns {ResourceInventory} Complete inventory of all resources in the app\n   */\n  public exportResourceInventory(): ResourceInventory {\n    return {\n      resources: this.resourceInventory.getInventory(),\n      generated_at: new Date().toISOString(),\n      app_name: this.name\n    };\n  }\n\n  /**\n   * Override synth to automatically export resource inventory\n   */\n  public synth(options?: StageSynthesisOptions): CloudAssembly {\n    // Call parent synth first\n    const assembly = super.synth(options);\n\n    // After synthesis, write resource inventory to cdk.out\n    try {\n      // const fs = require(\"fs\");\n      // const path = require(\"path\");\n      // const inventory = this.exportResourceInventory();\n      // const inventoryPath = path.join(\n      //   assembly.directory,\n      //   \"resource-inventory.json\"\n      // );\n      // fs.writeFileSync(inventoryPath, JSON.stringify(inventory, null, 2));\n    } catch (error) {\n      // Don't fail synth if inventory export fails\n      console.warn(\"Failed to export resource inventory:\", error);\n    }\n\n    return assembly;\n  }\n}\n\nexport default App;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.js","sourceRoot":"","sources":["../../lib/app.ts"],"names":[],"mappings":";;;AAAA,6CAKqB;AAGrB,wDAAqD;AAGrD,2CAAuC;AACvC,qDAAmE;AAEnE,oDAIgC;AAMhC,mEAAgE;AAKhE,iDAA8C;AAC9C,8EAA8E;AAC9E,oDAA8D;AAC9D,+DAA+D;AAC/D,0CAAoD;AACpD,+DAAuD;AACvD,2DAIgC;AA+BhC;;;;GAIG;AACH,MAAa,GAAI,SAAQ,iBAAM;IAkB7B,YAAoB,IAAa,EAAE,OAAqB;QACtD,KAAK,EAAE,CAAC;QAfF,WAAM,GAAgC,EAAE,CAAC;QAGzC,mBAAc,GAAG,IAAI,GAAG,EAAgB,CAAC;QAKzC,oBAAe,GAAG,KAAK,CAAC;QACxB,eAAU,GAA8B,EAAE,CAAC;QAC3C,kBAAa,GAAG,KAAK,CAAC;QAO5B,GAAG,CAAC,QAAQ,GAAG,IAAI,CAAC;QAEpB,IAAI,CAAC,IAAI,GAAG,IAAI,IAAI,UAAU,CAAC;QAE/B,iEAAiE;QACjE,IAAI,CAAC,iBAAiB,GAAG,IAAA,qCAAoB,EAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEzD,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAE9B,+CAA+C;QAC/C,IAAI,OAAO,EAAE,OAAO,KAAK,KAAK,EAAE,CAAC;YAC/B,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC9B,CAAC;aAAM,IAAI,OAAO,EAAE,OAAO,EAAE,CAAC;YAC5B,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAC1C,CAAC;IACH,CAAC;IAED;;OAEG;IACK,iBAAiB,CACvB,MAA+C;QAE/C,MAAM,YAAY,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAEnD,IAAI,aAAa,IAAI,MAAM,EAAE,CAAC;YAC5B,IAAI,CAAC,GAAG,GAAG,SAAG,CAAC,UAAU,CACvB,YAAY,CAAC,QAAQ,EAAE,EACvB,GAAG,IAAI,CAAC,IAAI,aAAa,EACzB;gBACE,KAAK,EAAE,MAAM,CAAC,WAAW;aAC1B,CACF,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,MAAM,OAAO,GAAG,wBAAc,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,IAAI,KAAK,EAAE,MAAM,CAAC,CAC7D,IAAI,EACJ,YAAY,CAAC,QAAQ,EAAE,CACxB,CAAC;YACF,IAAI,CAAC,GAAG,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;QAC9B,CAAC;IACH,CAAC;IAED;;;OAGG;IACI,OAAO;QACZ,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACI,MAAM,CAAC,MAAM,CAAC,IAAa,EAAE,OAAqB;QACvD,MAAM,GAAG,GAAG,GAAG,CAAC,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAC3C,GAAG,CAAC,sBAAsB,EAAE,CAAC;QAC7B,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,WAAW,CAAC,IAAa,EAAE,OAAqB;QAC5D,6DAA6D;QAC7D,+CAA+C;QAC/C,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC;YAClB,GAAG,CAAC,QAAQ,GAAG,IAAI,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QACxC,CAAC;aAAM,CAAC;YACN,gFAAgF;YAChF,IAAI,IAAI,IAAI,GAAG,CAAC,QAAQ,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBACvC,8FAA8F;gBAC9F,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;oBACrB,8BAAW,CAAC,IAAI,CACd,0BAA0B,GAAG,CAAC,QAAQ,CAAC,IAAI,SAAS,IAAI,mCAAmC;wBACzF,uBAAuB,GAAG,CAAC,QAAQ,CAAC,IAAI,yBAAyB,IAAI,KAAK;wBAC1E,gFAAgF,CACnF,CAAC;gBACJ,CAAC;gBACD,GAAG,CAAC,QAAQ,CAAC,IAAI,GAAG,IAAI,CAAC;gBACzB,+CAA+C;gBAC/C,GAAG,CAAC,QAAQ,CAAC,sBAAsB,EAAE,CAAC;YACxC,CAAC;YAED,yEAAyE;YACzE,IAAI,OAAO,EAAE,OAAO,KAAK,KAAK,EAAE,CAAC;gBAC/B,GAAG,CAAC,QAAQ,CAAC,eAAe,GAAG,IAAI,CAAC;YACtC,CAAC;iBAAM,IACL,OAAO,EAAE,OAAO;gBAChB,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG;gBACjB,CAAC,GAAG,CAAC,QAAQ,CAAC,eAAe,EAC7B,CAAC;gBACD,GAAG,CAAC,QAAQ,CAAC,iBAAiB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YAClD,CAAC;QACH,CAAC;QAED,OAAO,GAAG,CAAC,QAAQ,CAAC;IACtB,CAAC;IAED;;;;;;;OAOG;IACI,QAAQ,CAAC,GAAW,EAAE,YAAoC;QAC/D,wDAAwD;QACxD,IACE,CAAC,IAAI,CAAC,aAAa;YACnB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC;YACrC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,GAAG,CAAC,EACvC,CAAC;YACD,IAAI,CAAC,eAAe,EAAE,CAAC;QACzB,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;YACtB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,oBAAQ,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;QACrD,CAAC;QAED,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC1B,CAAC;IAED;;;;;;;OAOG;IACI,sBAAsB;QAC3B,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,IAAI,SAAS,EAAE,IAAI,CAAC,sBAAsB,EAAE,CAAC,CAAC;IAC7E,CAAC;IAED;;;OAGG;IACI,sBAAsB;QAC3B,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,IAAI,SAAS,CAAC,CAAC;IAC9C,CAAC;IAED;;;OAGG;IACI,uBAAuB;QAC5B,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,IAAI,UAAU,EAAE,IAAI,CAAC,sBAAsB,EAAE,CAAC,CAAC;IAC9E,CAAC;IAED;;;OAGG;IACI,sBAAsB;QAC3B,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,IAAI,SAAS,EAAE,IAAI,CAAC,sBAAsB,EAAE,CAAC,CAAC;IAC7E,CAAC;IAED;;;;;;;OAOG;IACI,kBAAkB;QACvB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,IAAI,KAAK,EAAE,IAAI,CAAC,sBAAsB,EAAE,CAAC,CAAC;IACzE,CAAC;IAED;;;;;;;;OAQG;IACI,wBAAwB;QAC7B,OAAO,IAAI,CAAC,QAAQ,CAClB,GAAG,IAAI,CAAC,IAAI,WAAW,EACvB,IAAI,CAAC,sBAAsB,EAAE,CAC9B,CAAC;IACJ,CAAC;IAED;;;;;;;;;OASG;IACI,MAAM,CAAC,IAAa;QACzB,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CACb,oDAAoD;gBAClD,2DAA2D,CAC9D,CAAC;QACJ,CAAC;QAED,qDAAqD;QACrD,IAAI,IAAI,EAAE,CAAC;YACT,MAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACpD,IAAI,aAAa,EAAE,CAAC;gBAClB,OAAO,aAAa,CAAC;YACvB,CAAC;YACD,MAAM,IAAI,KAAK,CACb,QAAQ,IAAI,gCAAgC,IAAI,CAAC,WAAW,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;gBAC3E,yEAAyE,CAC5E,CAAC;QACJ,CAAC;QAED,qBAAqB;QACrB,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CACb,+DAA+D;gBAC7D,0DAA0D,CAC7D,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC,GAAG,CAAC;IAClB,CAAC;IAED;;;;OAIG;IACI,WAAW;QAChB,MAAM,KAAK,GAAa,EAAE,CAAC;QAC3B,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;YACb,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACxB,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC,CAAC;QAC1C,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;OAGG;IACI,2BAA2B;QAChC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,MAAM,YAAY,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;YAEnD,IAAI,CAAC,UAAU,GAAG,gBAAU,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,IAAI,KAAK,CAAC,CACnD,IAAI,EACJ,YAAY,CAAC,QAAQ,EAAE,CACxB,CAAC;QACJ,CAAC;QAED,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED;;;;;;OAMG;IACI,oBAAoB,CAAC,eAAwB;QAClD,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAChC,MAAM,YAAY,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;YACnD,MAAM,SAAS,GACb,eAAe,IAAI,oCAAuB,CAAC,kBAAkB,CAAC;YAEhE,IAAI,CAAC,qBAAqB,GAAG,wBAAqB,CAAC,KAAK,CACtD,GAAG,IAAI,CAAC,IAAI,gBAAgB,EAC5B;gBACE,eAAe,EAAE,SAAS;gBAC1B,OAAO,EAAE,IAAI,CAAC,IAAI;gBAClB,cAAc,EAAE,oCAAuB,CAAC,cAAc;gBACtD,QAAQ,EAAE,oCAAuB,CAAC,QAAQ;aAC3C,CACF,CAAC,IAAI,EAAE,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC;YAEjC,2CAA2C;YAC3C,YAAY,CAAC,YAAY,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;QACxD,CAAC;QAED,OAAO,IAAI,CAAC,qBAAqB,CAAC;IACpC,CAAC;IAED;;;;;;;;;;OAUG;IACI,eAAe,CAAC,eAAwB,EAAE,UAAmB;QAClE,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC3B,MAAM,YAAY,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;YACnD,MAAM,SAAS,GACb,eAAe,IAAI,0BAAkB,CAAC,kBAAkB,CAAC;YAE3D,uCAAuC;YACvC,IAAI,CAAC,mBAAmB,GAAG,UAAU,IAAI,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAExE,IAAI,CAAC,gBAAgB,GAAG,mBAAgB,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,IAAI,WAAW,EAAE;gBACtE,eAAe,EAAE,SAAS;gBAC1B,OAAO,EAAE,IAAI,CAAC,IAAI;gBAClB,UAAU,EAAE,IAAI,CAAC,mBAAmB;gBACpC,cAAc,EAAE,0BAAkB,CAAC,cAAc;gBACjD,QAAQ,EAAE,0BAAkB,CAAC,QAAQ;aACtC,CAAC,CAAC,IAAI,EAAE,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC;YAElC,2CAA2C;YAC3C,YAAY,CAAC,YAAY,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QACnD,CAAC;QAED,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IAED;;;OAGG;IACI,sBAAsB;QAC3B,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IAED;;;OAGG;IACK,uBAAuB;QAC7B,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7B,OAAO,eAAe,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,SAAS,EAAE,CAAC;IAC/D,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACI,UAAU,CACf,EAAqC;QAErC,oDAAoD;QACpD,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAChC,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC9B,CAAC;QAED,MAAM,YAAY,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;QACnD,MAAM,SAAS,GAAG,EAAE,CAAC,IAAI,EAAE,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC;QACpD,YAAY,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QACrC,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;OAEG;IACI,kBAAkB,CAAC,QAAmB;QAC3C,MAAM,YAAY,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;QACnD,YAAY,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;IACtC,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACI,WAAW,CAChB,EAAqC;QAErC,MAAM,aAAa,GAAG,IAAI,CAAC,uBAAuB,EAAE,CAAC;QACrD,MAAM,iBAAiB,GAAG,EAAE,CAAC,IAAI,EAAE,aAAa,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC7D,aAAa,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC;QAE9C,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACI,UAAU,CACf,EAAqC;QAErC,MAAM,YAAY,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;QACnD,MAAM,gBAAgB,GAAG,EAAE,CAAC,IAAI,EAAE,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC3D,YAAY,CAAC,YAAY,CAAC,gBAAgB,CAAC,CAAC;QAE5C,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACI,MAAM,CAAC,EAAuC;QACnD,MAAM,QAAQ,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC3C,MAAM,GAAG,GAAG,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC1C,QAAQ,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QAE3B,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACI,YAAY,CACjB,EAAqC;QAErC,MAAM,cAAc,GAAG,IAAI,CAAC,wBAAwB,EAAE,CAAC;QACvD,MAAM,SAAS,GAAG,EAAE,CAAC,IAAI,EAAE,cAAc,CAAC,QAAQ,EAAE,CAAC,CAAC;QACtD,cAAc,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QAEvC,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACI,UAAU,CACf,EAAqC;QAErC,MAAM,YAAY,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;QACnD,MAAM,OAAO,GAAG,EAAE,CAAC,IAAI,EAAE,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC;QAClD,YAAY,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QACnC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;;;;;;;;;;OAaG;IACI,UAAU,CAAC,EAA2C;QAC3D,MAAM,YAAY,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;QACnD,MAAM,OAAO,GAAG,EAAE,CAAC,IAAI,EAAE,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC;QAClD,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QAEhC,8DAA8D;QAC9D,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;QACnD,YAAY,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAEnC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;OAEG;IACI,mBAAmB,CAAC,QAAmB;QAC5C,MAAM,aAAa,GAAG,IAAI,CAAC,uBAAuB,EAAE,CAAC;QACrD,aAAa,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;IACvC,CAAC;IAED;;OAEG;IACI,kBAAkB,CAAC,QAAmB;QAC3C,MAAM,YAAY,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;QACnD,YAAY,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;IACtC,CAAC;IAED;;OAEG;IACK,sBAAsB;QAC5B,MAAM,MAAM,GAAG,IAAA,qBAAS,GAAE,CAAC;QAC3B,IAAI,CAAC,UAAU,GAAG;YAChB,kCAAkC,EAAE,MAAM,CAAC,WAAW;YACtD,8BAA8B,EAAE,IAAI,CAAC,IAAI;SAC1C,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,eAAe;QACrB,IAAI,CAAC,IAAI,CAAC,aAAa,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACnE,gDAAgD;YAChD,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;gBACvD,kBAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YAChC,CAAC,CAAC,CAAC;YAEH,mEAAmE;YACnE,qBAAO,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,uCAAkB,EAAE,CAAC,CAAC;YAE/C,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC5B,CAAC;IACH,CAAC;IAED;;;;;;;;;;OAUG;IACI,OAAO,CAAC,IAA+B;QAC5C,0CAA0C;QAC1C,IAAI,CAAC,UAAU,GAAG;YAChB,GAAG,IAAI,CAAC,UAAU;YAClB,GAAG,IAAI;SACR,CAAC;QACF,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;YAC5C,kBAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAChC,CAAC,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACI,uBAAuB;QAC5B,OAAO;YACL,SAAS,EAAE,IAAI,CAAC,iBAAiB,CAAC,YAAY,EAAE;YAChD,WAAW,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACrC,OAAO,EAAE,IAAI,CAAC,IAAI;SACnB,CAAC;IACJ,CAAC;IAED;;;OAGG;IACI,oBAAoB;QACzB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,OAA+B;QAC1C,0BAA0B;QAC1B,MAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAEtC,mDAAmD;QACnD,IAAI,CAAC;YACH,IAAA,8BAAa,EAAC,QAAQ,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAClD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,4CAA4C;YAC5C,MAAM,YAAY,GAChB,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACzD,8BAAW,CAAC,IAAI,CAAC,oCAAoC,YAAY,EAAE,CAAC,CAAC;QACvE,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;;AAptBH,kBAqtBC;AAptBgB,YAAQ,GAAe,IAAI,AAAnB,CAAoB;AAstB7C,kBAAe,GAAG,CAAC","sourcesContent":["import {\n  App as CdkApp,\n  Aspects,\n  Tags,\n  type StageSynthesisOptions\n} from \"aws-cdk-lib\";\nimport { type CloudAssembly } from \"aws-cdk-lib/cx-api\";\nimport { type Construct } from \"constructs\";\nimport { Vpc } from \"./resources/aws/networking/vpc\";\nimport { type IVpc } from \"aws-cdk-lib/aws-ec2\";\nimport { type Role } from \"aws-cdk-lib/aws-iam\";\nimport { AwsStack } from \"./resources\";\nimport { type Ecr, EcrFactory } from \"./resources/aws/storage/ecr\";\nimport { type AnyDatabase } from \"./patterns/aws/database\";\nimport {\n  type INetworkProps,\n  NetworkFactory,\n  type Network\n} from \"./patterns/aws/network\";\nimport { type Cdn } from \"./patterns/aws/cdn\";\nimport { type AnyMessaging } from \"./patterns/aws/messaging\";\nimport { type AnyCompute } from \"./patterns/aws/compute\";\nimport { type AnyStorage } from \"./patterns/aws/storage\";\nimport { type AnyPattern } from \"./patterns/aws/pattern\";\nimport { StandardTagsAspect } from \"./utils/standardTagsAspect\";\nimport {\n  type ResourceInventoryAspect,\n  type ResourceInventory\n} from \"./aspects/resourceInventory\";\nimport { getConfig } from \"./utils/getConfig\";\nimport MonitoringRoleFactory from \"./resources/aws/monitoring/monitoringRole\";\nimport { FJALL_MONITORING_CONFIG } from \"./config/monitoring\";\nimport AuditRoleFactory from \"./resources/aws/audit/auditRole\";\nimport { FJALL_AUDIT_CONFIG } from \"./config/audit\";\nimport { FjallLogger } from \"./utils/validationLogger\";\nimport {\n  getManifestCollector,\n  writeManifest,\n  type ManifestCollector\n} from \"./utils/manifestWriter\";\n\n/**\n * Configuration options for App.getApp().\n *\n * @example\n * // Create app with new VPC\n * const app = App.getApp(appName, {\n *   network: { maxAzs: 2, natGateways: false }\n * });\n *\n * @example\n * // Create app using existing VPC\n * const app = App.getApp(appName, {\n *   network: { useExisting: \"vpc-12345678\" }\n * });\n *\n * @example\n * // Create app without network (S3-only apps)\n * const app = App.getApp(appName, { network: false });\n */\nexport interface IAppOptions {\n  /**\n   * Network configuration.\n   * - Object with INetworkProps: Create new VPC with config\n   * - false: No network (for S3-only apps)\n   * - { useExisting: string }: Use existing VPC by ID\n   */\n  network?: INetworkProps | false | { useExisting: string };\n}\n\n/**\n * The basic corner-stone of all Fjall-hosted applications.\n *  This class is a singleton and should be used to create and manage\n *   all resources in a Fjall application.\n */\nexport class App extends CdkApp {\n  private static instance: App | null = null;\n\n  private name: string;\n  private stacks: { [key: string]: AwsStack } = {};\n\n  private vpc?: IVpc;\n  private additionalVpcs = new Map<string, IVpc>();\n  private defaultEcr!: Ecr;\n  private defaultMonitoringRole!: Role;\n  private defaultAuditRole!: Role;\n  private auditRoleExternalId?: string;\n  private networkDisabled = false;\n  private globalTags: { [key: string]: string } = {};\n  private aspectApplied = false;\n  private resourceInventory!: ResourceInventoryAspect;\n  private manifestCollector: ManifestCollector;\n\n  private constructor(name?: string, options?: IAppOptions) {\n    super();\n\n    App.instance = this;\n\n    this.name = name ?? \"FjallApp\";\n\n    // Initialise manifest collector for build-time service discovery\n    this.manifestCollector = getManifestCollector(this.name);\n\n    this.initialiseStandardTags();\n\n    // Initialise network immediately if configured\n    if (options?.network === false) {\n      this.networkDisabled = true;\n    } else if (options?.network) {\n      this.initialiseNetwork(options.network);\n    }\n  }\n\n  /**\n   * Initialise the network (VPC) for this application.\n   */\n  private initialiseNetwork(\n    config: INetworkProps | { useExisting: string }\n  ): void {\n    const networkStack = this.getDefaultNetworkStack();\n\n    if (\"useExisting\" in config) {\n      this.vpc = Vpc.fromLookup(\n        networkStack.getStack(),\n        `${this.name}ImportedVpc`,\n        {\n          vpcId: config.useExisting\n        }\n      );\n    } else {\n      const network = NetworkFactory.build(`${this.name}Vpc`, config)(\n        this,\n        networkStack.getStack()\n      );\n      this.vpc = network.getVpc();\n    }\n  }\n\n  /**\n   * Get the application name.\n   * @returns {string} The application name\n   */\n  public getName(): string {\n    return this.name;\n  }\n\n  /**\n   * Get/Create a basic Fjall Application with standard tags applied.\n   *\n   * @param name Application name\n   * @param options Configuration options including network settings\n   * @returns {App}\n   *\n   * @example\n   * // Create app with new VPC\n   * const app = App.getApp(appName, {\n   *   network: { maxAzs: 2, natGateways: false }\n   * });\n   *\n   * @example\n   * // Create app using existing VPC\n   * const app = App.getApp(appName, {\n   *   network: { useExisting: \"vpc-12345678\" }\n   * });\n   *\n   * @example\n   * // Create app without network (S3-only apps)\n   * const app = App.getApp(appName, { network: false });\n   */\n  public static getApp(name?: string, options?: IAppOptions): App {\n    const app = App.getInstance(name, options);\n    app.initialiseStandardTags();\n    return app;\n  }\n\n  /**\n   * Get/Create the singleton instance of the App\n   * @param name Application name\n   * @param options Configuration options including network settings\n   * @returns {App}\n   */\n  public static getInstance(name?: string, options?: IAppOptions): App {\n    // Despite supporting multiple stacks you can still only ever\n    // have a single Application per CDK deployment\n    if (!App.instance) {\n      App.instance = new App(name, options);\n    } else {\n      // If singleton exists but name differs, update it (before any infra is defined)\n      if (name && App.instance.name !== name) {\n        // Warn if network already initialised - changing name after network exists creates a mismatch\n        if (App.instance.vpc) {\n          FjallLogger.warn(\n            `App name changed from \"${App.instance.name}\" to \"${name}\" after network was initialised. ` +\n              `VPC will have name \"${App.instance.name}Vpc\" but app name is \"${name}\". ` +\n              `Ensure App.getApp() is called with the final name before initialising network.`\n          );\n        }\n        App.instance.name = name;\n        // Reinitialise standard tags with the new name\n        App.instance.initialiseStandardTags();\n      }\n\n      // If options provided but network not yet initialised, initialise it now\n      if (options?.network === false) {\n        App.instance.networkDisabled = true;\n      } else if (\n        options?.network &&\n        !App.instance.vpc &&\n        !App.instance.networkDisabled\n      ) {\n        App.instance.initialiseNetwork(options.network);\n      }\n    }\n\n    return App.instance;\n  }\n\n  /**\n   * Retrieve a stack by key. If the stack does not exist, it will be created.\n   *  Dependencies are only applied the first time a stack is created.\n   *\n   * @param key - The key of the stack\n   * @param dependencies - The stack(s) that this stack depends on\n   * @returns {AwsStack}\n   */\n  public getStack(key: string, dependencies?: AwsStack | AwsStack[]): AwsStack {\n    // Apply the aspect once before creating the first stack\n    if (\n      !this.aspectApplied &&\n      Object.keys(this.stacks).length === 0 &&\n      Object.keys(this.globalTags).length > 0\n    ) {\n      this.applyTagsAspect();\n    }\n\n    if (!this.stacks[key]) {\n      this.stacks[key] = new AwsStack(key, dependencies);\n    }\n\n    return this.stacks[key];\n  }\n\n  /**\n   * Retrieve default compute stack - named as `${this.name}Compute`\n   *\n   * Only depends on Network. Database dependency is added automatically\n   * by CDK when compute resources reference database resources.\n   *\n   * @returns {AwsStack}\n   */\n  public getDefaultComputeStack(): AwsStack {\n    return this.getStack(`${this.name}Compute`, this.getDefaultNetworkStack());\n  }\n\n  /**\n   * Retrieve default network stack - named as `${this.name}Network`\n   * @returns {AwsStack}\n   */\n  public getDefaultNetworkStack(): AwsStack {\n    return this.getStack(`${this.name}Network`);\n  }\n\n  /**\n   * Retrieve default database stack - named as `${this.name}Database`\n   * @returns {AwsStack}\n   */\n  public getDefaultDatabaseStack(): AwsStack {\n    return this.getStack(`${this.name}Database`, this.getDefaultNetworkStack());\n  }\n\n  /**\n   * Retrieve default storage stack - named as `${this.name}Storage`\n   * @returns {AwsStack}\n   */\n  public getDefaultStorageStack(): AwsStack {\n    return this.getStack(`${this.name}Storage`, this.getDefaultNetworkStack());\n  }\n\n  /**\n   * Retrieve default CDN stack - named as `${this.name}Cdn`\n   *\n   * Depends on Network. Compute/Storage dependencies are added automatically\n   * by CDK when CDN resources reference ALB or S3 bucket resources.\n   *\n   * @returns {AwsStack}\n   */\n  public getDefaultCdnStack(): AwsStack {\n    return this.getStack(`${this.name}Cdn`, this.getDefaultNetworkStack());\n  }\n\n  /**\n   * Retrieve default messaging stack - named as `${this.name}Messaging`\n   *\n   * Used for SQS queues, SNS topics, and EventBridge event buses.\n   * Depends on Network only. These are regional services that don't\n   * require VPC, but we maintain consistent stack dependency patterns.\n   *\n   * @returns {AwsStack}\n   */\n  public getDefaultMessagingStack(): AwsStack {\n    return this.getStack(\n      `${this.name}Messaging`,\n      this.getDefaultNetworkStack()\n    );\n  }\n\n  /**\n   * Get a VPC by name. If no name is provided, returns the default VPC.\n   *\n   * This is a pure getter - it never creates infrastructure.\n   * Network must be configured via App.getApp() options or app.addNetwork().\n   *\n   * @param name - Optional name of the VPC to retrieve. If not provided, returns the default VPC.\n   * @returns {IVpc} The configured VPC\n   * @throws {Error} If network is disabled, not configured, or named VPC not found\n   */\n  public getVpc(name?: string): IVpc {\n    if (this.networkDisabled) {\n      throw new Error(\n        \"Network is disabled for this app. Cannot get VPC. \" +\n          \"Pass network config to App.getApp() to enable networking.\"\n      );\n    }\n\n    // If name is provided, look in additional VPCs first\n    if (name) {\n      const additionalVpc = this.additionalVpcs.get(name);\n      if (additionalVpc) {\n        return additionalVpc;\n      }\n      throw new Error(\n        `VPC '${name}' not found. Available VPCs: ${this.getVpcNames().join(\", \")}. ` +\n          \"Create additional VPCs using app.addNetwork(NetworkFactory.build(...)).\"\n      );\n    }\n\n    // Return default VPC\n    if (!this.vpc) {\n      throw new Error(\n        \"Network not configured. Pass network config to App.getApp(). \" +\n          \"Example: App.getApp(appName, { network: { maxAzs: 2 } })\"\n      );\n    }\n    return this.vpc;\n  }\n\n  /**\n   * Get the names of all available VPCs.\n   *\n   * @returns {string[]} Array of VPC names. Includes \"default\" if the default VPC is configured.\n   */\n  public getVpcNames(): string[] {\n    const names: string[] = [];\n    if (this.vpc) {\n      names.push(\"default\");\n    }\n    names.push(...this.additionalVpcs.keys());\n    return names;\n  }\n\n  /**\n   * Retreive the default application container registry. If the registry does not exist\n   *  it will be created.\n   */\n  public getDefaultContainerRegistry(): Ecr {\n    if (!this.defaultEcr) {\n      const networkStack = this.getDefaultNetworkStack();\n\n      this.defaultEcr = EcrFactory.build(`${this.name}Ecr`)(\n        this,\n        networkStack.getStack()\n      );\n    }\n\n    return this.defaultEcr;\n  }\n\n  /**\n   * Create a cross-account monitoring role in the Network stack that allows\n   * the Fjall webapp to query CloudWatch metrics and ECS status.\n   *\n   * @param webappAccountId - Optional AWS account ID of the Fjall webapp. Defaults to configured platform account.\n   * @returns {Role} The created monitoring role\n   */\n  public createMonitoringRole(webappAccountId?: string): Role {\n    if (!this.defaultMonitoringRole) {\n      const networkStack = this.getDefaultNetworkStack();\n      const accountId =\n        webappAccountId || FJALL_MONITORING_CONFIG.webappAwsAccountId;\n\n      this.defaultMonitoringRole = MonitoringRoleFactory.build(\n        `${this.name}MonitoringRole`,\n        {\n          webappAccountId: accountId,\n          appName: this.name,\n          roleNamePrefix: FJALL_MONITORING_CONFIG.roleNamePrefix,\n          rolePath: FJALL_MONITORING_CONFIG.rolePath\n        }\n      )(this, networkStack.getStack());\n\n      // Register the role with the network stack\n      networkStack.addConstruct(this.defaultMonitoringRole);\n    }\n\n    return this.defaultMonitoringRole;\n  }\n\n  /**\n   * Create a cross-account audit role in the Network stack that allows\n   * the Fjall platform to use CloudQuery for comprehensive AWS resource auditing.\n   *\n   * This is an explicit opt-in feature. Call this method to enable CloudQuery\n   * audit capabilities for your application.\n   *\n   * @param webappAccountId - Optional AWS account ID of the Fjall webapp. Defaults to configured platform account.\n   * @param externalId - Optional external ID for additional security. If not provided, a unique ID will be generated.\n   * @returns {Role} The created audit role\n   */\n  public createAuditRole(webappAccountId?: string, externalId?: string): Role {\n    if (!this.defaultAuditRole) {\n      const networkStack = this.getDefaultNetworkStack();\n      const accountId =\n        webappAccountId || FJALL_AUDIT_CONFIG.webappAwsAccountId;\n\n      // Generate or use provided external ID\n      this.auditRoleExternalId = externalId || this.generateAuditExternalId();\n\n      this.defaultAuditRole = AuditRoleFactory.build(`${this.name}AuditRole`, {\n        webappAccountId: accountId,\n        appName: this.name,\n        externalId: this.auditRoleExternalId,\n        roleNamePrefix: FJALL_AUDIT_CONFIG.roleNamePrefix,\n        rolePath: FJALL_AUDIT_CONFIG.rolePath\n      })(this, networkStack.getStack());\n\n      // Register the role with the network stack\n      networkStack.addConstruct(this.defaultAuditRole);\n    }\n\n    return this.defaultAuditRole;\n  }\n\n  /**\n   * Get the external ID used for the audit role\n   * @returns {string | undefined} The external ID if audit role has been created\n   */\n  public getAuditRoleExternalId(): string | undefined {\n    return this.auditRoleExternalId;\n  }\n\n  /**\n   * Generate a unique external ID for audit role\n   * Format: fjall-audit-{appName}-{timestamp}\n   */\n  private generateAuditExternalId(): string {\n    const timestamp = Date.now();\n    return `fjall-audit-${this.name.toLowerCase()}-${timestamp}`;\n  }\n\n  /**\n   * Add a compute resource to the default compute stack using the factory pattern.\n   * Automatically creates monitoring role if not already created.\n   *\n   * Returns the appropriate compute type based on the factory configuration:\n   * - EcsCompute for type: \"ecs\"\n   * - LambdaCompute for type: \"lambda\"\n   * - Ec2Compute for type: \"ec2\"\n   *\n   * @example\n   * // ECS compute - returns EcsCompute\n   * const api = app.addCompute(ComputeFactory.build(\"Api\", {\n   *   type: \"ecs\",\n   *   services: [{ name: \"api\", ... }]\n   * }));\n   * api.getLoadBalancer(); // Available on EcsCompute\n   *\n   * @example\n   * // Lambda compute - returns LambdaCompute\n   * const worker = app.addCompute(ComputeFactory.build(\"Worker\", {\n   *   type: \"lambda\",\n   *   functions: [{ name: \"process\", ... }]\n   * }));\n   * worker.getFunction(\"process\"); // Available on LambdaCompute\n   */\n  public addCompute<T extends AnyCompute>(\n    fn: (app: App, scope: Construct) => T\n  ): T {\n    // Auto-create monitoring role when compute is added\n    if (!this.defaultMonitoringRole) {\n      this.createMonitoringRole();\n    }\n\n    const computeStack = this.getDefaultComputeStack();\n    const construct = fn(this, computeStack.getStack());\n    computeStack.addConstruct(construct);\n    return construct;\n  }\n\n  /**\n   * Manually add a resource to the default compute stack.\n   */\n  public addComputeResource(resource: Construct): void {\n    const computeStack = this.getDefaultComputeStack();\n    computeStack.addConstruct(resource);\n  }\n\n  /**\n   * Add a database resource to the default database stack using the factory pattern.\n   * Returns the appropriate database type based on the factory used.\n   *\n   * @example\n   * // Aurora database - returns RelationalDatabase\n   * const db = app.addDatabase(DatabaseFactory.build(\"Main\", {\n   *   type: \"Aurora\",\n   *   databaseName: \"myapp\"\n   * }));\n   * db.getHostEndpoint(); // Available\n   *\n   * @example\n   * // DynamoDB table - returns DynamoDBDatabase\n   * const cache = app.addDatabase(DatabaseFactory.build(\"Cache\", {\n   *   type: \"DynamoDB\",\n   *   partitionKey: { name: \"id\", type: \"S\" }\n   * }));\n   * cache.getTableName(); // Available\n   */\n  public addDatabase<T extends AnyDatabase>(\n    fn: (app: App, scope: Construct) => T\n  ): T {\n    const databaseStack = this.getDefaultDatabaseStack();\n    const databaseConstruct = fn(this, databaseStack.getStack());\n    databaseStack.addConstruct(databaseConstruct);\n\n    return databaseConstruct;\n  }\n\n  /**\n   * Add a storage resource (S3) to the default storage stack using the factory pattern.\n   *\n   * Returns the appropriate storage type based on the factory configuration:\n   * - PrivateStorage for bucketType: \"private\"\n   * - WebsiteStorage for bucketType: \"website\"\n   * - PublicStorage for bucketType: \"publicRead\"\n   *\n   * @example\n   * // Private storage - returns PrivateStorage\n   * const assets = app.addStorage(StorageFactory.build(\"Assets\", {\n   *   bucketType: \"private\"\n   * }));\n   * assets.grantPublicAccess(\"public/*\"); // Available on PrivateStorage\n   *\n   * @example\n   * // Website storage - returns WebsiteStorage\n   * const site = app.addStorage(StorageFactory.build(\"Site\", {\n   *   bucketType: \"website\"\n   * }));\n   * site.getWebsiteUrl(); // Available on WebsiteStorage\n   */\n  public addStorage<T extends AnyStorage>(\n    fn: (app: App, scope: Construct) => T\n  ): T {\n    const storageStack = this.getDefaultStorageStack();\n    const storageConstruct = fn(this, storageStack.getStack());\n    storageStack.addConstruct(storageConstruct);\n\n    return storageConstruct;\n  }\n\n  /**\n   * Add a CDN resource (CloudFront) to the default CDN stack using the factory pattern.\n   *\n   * @example\n   * // S3 origin\n   * const assets = app.addStorage(StorageFactory.build(\"Assets\", { bucketType: \"private\" }));\n   * app.addCdn(CdnFactory.build(\"AssetsCdn\", {\n   *   originType: \"s3\",\n   *   bucket: assets\n   * }));\n   *\n   * @example\n   * // ALB origin (ECS)\n   * const api = app.addCompute(ComputeFactory.build(\"Api\", { type: \"ecs\", ... }));\n   * app.addCdn(CdnFactory.build(\"ApiCdn\", {\n   *   originType: \"alb\",\n   *   loadBalancer: api\n   * }));\n   */\n  public addCdn(fn: (app: App, scope: Construct) => Cdn): Cdn {\n    const cdnStack = this.getDefaultCdnStack();\n    const cdn = fn(this, cdnStack.getStack());\n    cdnStack.addConstruct(cdn);\n\n    return cdn;\n  }\n\n  /**\n   * Add a messaging resource to the default queue stack using the factory pattern.\n   *\n   * Returns the appropriate messaging type based on the factory configuration.\n   * Currently supports queue (SQS), with future support planned for\n   * topic (SNS), eventbus (EventBridge), and stream (Kinesis).\n   *\n   * @example\n   * // Queue messaging - returns QueueMessaging\n   * const notifications = app.addMessaging(MessagingFactory.build(\"Notifications\", {\n   *   type: \"queue\",\n   *   queueType: \"standard\",\n   *   deadLetterQueue: { enabled: true, maxReceiveCount: 3 }\n   * }));\n   * notifications.grantSendMessages(apiFunction);\n   *\n   * @example\n   * // FIFO queue for OpenNext revalidation\n   * const revalidation = app.addMessaging(MessagingFactory.build(\"Revalidation\", {\n   *   type: \"queue\",\n   *   queueType: \"fifo\",\n   *   visibilityTimeout: 300,\n   *   contentBasedDeduplication: true\n   * }));\n   */\n  public addMessaging<T extends AnyMessaging>(\n    fn: (app: App, scope: Construct) => T\n  ): T {\n    const messagingStack = this.getDefaultMessagingStack();\n    const messaging = fn(this, messagingStack.getStack());\n    messagingStack.addConstruct(messaging);\n\n    return messaging;\n  }\n\n  /**\n   * Add a high-level infrastructure pattern to the application.\n   *\n   * Patterns are composite constructs that create multiple related resources\n   * as a single, cohesive unit. They encapsulate best practices and reduce\n   * boilerplate for common deployment scenarios.\n   *\n   * Currently supported patterns:\n   * - `payload`: Payload CMS deployment with OpenNext\n   *\n   * Returns the appropriate pattern interface based on the factory configuration,\n   * providing access to all underlying resources via escape hatches.\n   *\n   * @example\n   * // Payload CMS pattern - returns Payload\n   * const payload = app.addPattern(PatternFactory.build(\"PayloadApp\", {\n   *   type: \"payload\",\n   *   name: \"my-cms\",\n   *   source: \"../..\"\n   * }));\n   *\n   * @example\n   * // Escape hatches - access underlying resources\n   * payload.getDatabase().grantConnect(otherLambda);\n   * payload.getServer().getLambdaFunction().addEnvironment(\"CUSTOM\", \"value\");\n   * payload.getCdn().getDistribution().addBehavior(\"/custom/*\", customOrigin);\n   */\n  public addPattern<T extends AnyPattern>(\n    fn: (app: App, scope: Construct) => T\n  ): T {\n    const computeStack = this.getDefaultComputeStack();\n    const pattern = fn(this, computeStack.getStack());\n    computeStack.addConstruct(pattern);\n    return pattern;\n  }\n\n  /**\n   * Add an additional network (VPC) to the application.\n   *\n   * Use this to create additional VPCs beyond the default VPC configured via App.getApp().\n   * Additional VPCs can be retrieved by name using app.getVpc(name).\n   *\n   * @param fn - Factory function that creates the Network construct\n   * @returns {Network} The created Network construct\n   *\n   * @example\n   * const isolatedVpc = app.addNetwork(\n   *   NetworkFactory.build(\"IsolatedVpc\", { maxAzs: 2, natGateways: false })\n   * );\n   */\n  public addNetwork(fn: (app: App, scope: Construct) => Network): Network {\n    const networkStack = this.getDefaultNetworkStack();\n    const network = fn(this, networkStack.getStack());\n    const vpcName = network.node.id;\n\n    // Store in additional VPCs map for retrieval via getVpc(name)\n    this.additionalVpcs.set(vpcName, network.getVpc());\n    networkStack.addConstruct(network);\n\n    return network;\n  }\n\n  /**\n   * Manually add a resource to the default database stack.\n   */\n  public addDatabaseResource(resource: Construct): void {\n    const databaseStack = this.getDefaultDatabaseStack();\n    databaseStack.addConstruct(resource);\n  }\n\n  /**\n   * Manually add a resource to the default storage stack.\n   */\n  public addStorageResource(resource: Construct): void {\n    const storageStack = this.getDefaultStorageStack();\n    storageStack.addConstruct(resource);\n  }\n\n  /**\n   * Initialize standard tags\n   */\n  private initialiseStandardTags(): void {\n    const config = getConfig();\n    this.globalTags = {\n      \"fjall:costAllocation:environment\": config.environment,\n      \"fjall:costAllocation:service\": this.name\n    };\n  }\n\n  /**\n   * Apply all tags using CDK's native Tags.of().add() API\n   */\n  private applyTagsAspect(): void {\n    if (!this.aspectApplied && Object.keys(this.globalTags).length > 0) {\n      // Apply standard tags using Tags.of(this).add()\n      Object.entries(this.globalTags).forEach(([key, value]) => {\n        Tags.of(this).add(key, value);\n      });\n\n      // Apply aspect for resource-specific tags (IPAM pool, backup tier)\n      Aspects.of(this).add(new StandardTagsAspect());\n\n      this.aspectApplied = true;\n    }\n  }\n\n  /**\n   * Add custom tags to all resources in the app.\n   *\n   * @param tags Custom tags to apply to all resources\n   * @example\n   * app.addTags({\n   *   \"fjall:costAllocation:owner\": \"platform-team\",\n   *   \"fjall:costAllocation:cost-center\": \"CC-123\",\n   *   \"team:slack-channel\": \"#platform-alerts\"\n   * });\n   */\n  public addTags(tags: { [key: string]: string }): App {\n    // Merge tags into globalTags for tracking\n    this.globalTags = {\n      ...this.globalTags,\n      ...tags\n    };\n    Object.entries(tags).forEach(([key, value]) => {\n      Tags.of(this).add(key, value);\n    });\n\n    return this;\n  }\n\n  /**\n   * Export resource inventory collected during synthesis\n   * Call this after app.synth() to get complete resource inventory\n   * @returns {ResourceInventory} Complete inventory of all resources in the app\n   */\n  public exportResourceInventory(): ResourceInventory {\n    return {\n      resources: this.resourceInventory.getInventory(),\n      generatedAt: new Date().toISOString(),\n      appName: this.name\n    };\n  }\n\n  /**\n   * Get the manifest collector for registering services and patterns.\n   * Used by ComputeFactory and PatternFactory to register their configurations.\n   */\n  public getManifestCollector(): ManifestCollector {\n    return this.manifestCollector;\n  }\n\n  /**\n   * Override synth to automatically export resource inventory and manifest\n   */\n  public synth(options?: StageSynthesisOptions): CloudAssembly {\n    // Call parent synth first\n    const assembly = super.synth(options);\n\n    // After synthesis, write Fjall manifest to cdk.out\n    try {\n      writeManifest(assembly, this.manifestCollector);\n    } catch (error) {\n      // Don't fail synth if manifest export fails\n      const errorMessage =\n        error instanceof Error ? error.message : String(error);\n      FjallLogger.warn(`Failed to export Fjall manifest: ${errorMessage}`);\n    }\n\n    return assembly;\n  }\n}\n\nexport default App;\n"]}

package/dist/lib/aspects/resourceInventory.d.ts

@@ -4,17 +4,17 @@ import { type IConstruct } from "constructs";
  * Resource metadata extracted from CDK constructs
  */
 export interface ResourceMetadata {
-    resource_type: string;
+    resourceType: string;
     name: string;
-    stack_name: string;
+    stackName: string;
 }
 /**
  * Complete resource inventory for an application
  */
 export interface ResourceInventory {
     resources: ResourceMetadata[];
-    generated_at: string;
-    app_name: string;
+    generatedAt: string;
+    appName: string;
 }
 /**
  * Aspect to collect resource metadata during CDK synthesis.

package/dist/lib/aspects/resourceInventory.js

@@ -40,9 +40,9 @@ class ResourceInventoryAspect {
         const logicalId = stack.getLogicalId(resource);
         const stackName = stack.stackName;
         return {
-            resource_type: resourceType,
+            resourceType,
             name: logicalId,
-            stack_name: stackName
+            stackName
         };
     }
     /**
@@ -53,4 +53,4 @@ class ResourceInventoryAspect {
     }
 }
 exports.ResourceInventoryAspect = ResourceInventoryAspect;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/config/aws/backupGlobalSettings.js

@@ -14,7 +14,6 @@ class BackupGlobalSettings extends constructs_1.Construct {
             isDelegatedAdministratorEnabled: enableDelegatedAdministrator.toString(),
             isMpaEnabled: enableMpa.toString()
         };
-        // Update global settings on create and update
         new awsCustomResource_1.AwsCustomResource(this, "BackupGlobalSettings", {
             functionName: "updateBackupGlobalSettings",
             onCreate: {
@@ -48,4 +47,4 @@ class BackupGlobalSettings extends constructs_1.Construct {
     }
 }
 exports.BackupGlobalSettings = BackupGlobalSettings;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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