@fjall/components-infrastructure 0.76.0 → 0.77.1

package/dist/lib/app.d.ts

@@ -5,6 +5,37 @@ import { type Role } from "aws-cdk-lib/aws-iam";
 import { AwsStack } from "./resources";
 import { type Ecr } from "./resources/aws/storage/ecr";
 import { type Database } from "./patterns/aws/database";
+import { type INetworkProps, Network } from "./patterns/aws/network";
+/**
+ * Configuration options for App.getApp().
+ *
+ * @example
+ * // Create app with new VPC
+ * const app = App.getApp(appName, {
+ *   network: { maxAzs: 2, natGateways: false }
+ * });
+ *
+ * @example
+ * // Create app using existing VPC
+ * const app = App.getApp(appName, {
+ *   network: { useExisting: "vpc-12345678" }
+ * });
+ *
+ * @example
+ * // Create app without network (S3-only apps)
+ * const app = App.getApp(appName, { network: false });
+ */
+export interface IAppOptions {
+    /**
+     * Network configuration.
+     * - Object with INetworkProps: Create new VPC with config
+     * - false: No network (for S3-only apps)
+     * - { useExisting: string }: Use existing VPC by ID
+     */
+    network?: INetworkProps | false | {
+        useExisting: string;
+    };
+}
 /**
  * The basic corner-stone of all Fjall-hosted applications.
  *  This class is a singleton and should be used to create and manage
@@ -14,25 +45,49 @@ export declare class App extends CdkApp {
     private static instance;
     private name;
     private stacks;
-    private defaultVpc;
+    private vpc?;
+    private additionalVpcs;
     private defaultEcr;
     private defaultMonitoringRole;
-    private existingVpcId?;
+    private networkDisabled;
     private globalTags;
     private aspectApplied;
     private constructor();
     /**
-     * Get/Create a basic Fjall Application with standard tags applied
+     * Initialise the network (VPC) for this application.
+     */
+    private initialiseNetwork;
+    /**
+     * Get/Create a basic Fjall Application with standard tags applied.
+     *
      * @param name Application name
+     * @param options Configuration options including network settings
      * @returns {App}
+     *
+     * @example
+     * // Create app with new VPC
+     * const app = App.getApp(appName, {
+     *   network: { maxAzs: 2, natGateways: false }
+     * });
+     *
+     * @example
+     * // Create app using existing VPC
+     * const app = App.getApp(appName, {
+     *   network: { useExisting: "vpc-12345678" }
+     * });
+     *
+     * @example
+     * // Create app without network (S3-only apps)
+     * const app = App.getApp(appName, { network: false });
      */
-    static getApp(name?: string): App;
+    static getApp(name?: string, options?: IAppOptions): App;
     /**
      * Get/Create the singleton instance of the App
-     * @param name
+     * @param name Application name
+     * @param options Configuration options including network settings
      * @returns {App}
      */
-    static getInstance(name?: string): App;
+    static getInstance(name?: string, options?: IAppOptions): App;
     /**
      * Retrieve a stack by key. If the stack does not exist, it will be created.
      *  Dependencies are only applied the first time a stack is created.
@@ -44,6 +99,10 @@ export declare class App extends CdkApp {
     getStack(key: string, dependencies?: AwsStack | AwsStack[]): AwsStack;
     /**
      * Retrieve default compute stack - named as `${this.name}Compute`
+     *
+     * Only depends on Network. Database dependency is added automatically
+     * by CDK when compute resources reference database resources.
+     *
      * @returns {AwsStack}
      */
     getDefaultComputeStack(): AwsStack;
@@ -63,15 +122,22 @@ export declare class App extends CdkApp {
      */
     getDefaultStorageStack(): AwsStack;
     /**
-     * Retrieve default vpc. If the VPC does not exist it will be created.
-     * @returns {Vpc}
+     * Get a VPC by name. If no name is provided, returns the default VPC.
+     *
+     * This is a pure getter - it never creates infrastructure.
+     * Network must be configured via App.getApp() options or app.addNetwork().
+     *
+     * @param name - Optional name of the VPC to retrieve. If not provided, returns the default VPC.
+     * @returns {IVpc} The configured VPC
+     * @throws {Error} If network is disabled, not configured, or named VPC not found
      */
-    getDefaultVpc(): IVpc;
+    getVpc(name?: string): IVpc;
     /**
-     * Reuse an existing VPC.
-     * Accepts either a Vpc object or a plain VPC ID string for convenience.
+     * Get the names of all available VPCs.
+     *
+     * @returns {string[]} Array of VPC names. Includes "default" if the default VPC is configured.
      */
-    useExistingVpc(vpcId: string): void;
+    getVpcNames(): string[];
     /**
      * Retreive the default application container registry. If the registry does not exist
      *  it will be created.
@@ -102,6 +168,21 @@ export declare class App extends CdkApp {
      * Add a storage resource (S3) to the default storage stack using the factory pattern.
      */
     addStorage(fn: (app: App, scope: Construct) => Construct): any;
+    /**
+     * Add an additional network (VPC) to the application.
+     *
+     * Use this to create additional VPCs beyond the default VPC configured via App.getApp().
+     * Additional VPCs can be retrieved by name using app.getVpc(name).
+     *
+     * @param fn - Factory function that creates the Network construct
+     * @returns {Network} The created Network construct
+     *
+     * @example
+     * const isolatedVpc = app.addNetwork(
+     *   NetworkFactory.build("IsolatedVpc", { maxAzs: 2, natGateways: false })
+     * );
+     */
+    addNetwork(fn: (app: App, scope: Construct) => Network): Network;
     /**
      * Manually add a resource to the default database stack.
      */

package/dist/lib/app.js

@@ -5,6 +5,7 @@ const aws_cdk_lib_1 = require("aws-cdk-lib");
 const vpc_1 = require("./resources/aws/networking/vpc");
 const resources_1 = require("./resources");
 const ecr_1 = require("./resources/aws/storage/ecr");
+const network_1 = require("./patterns/aws/network");
 const standardTagsAspect_1 = require("./utils/standardTagsAspect");
 const getConfig_1 = require("./utils/getConfig");
 const monitoringRole_1 = require("./resources/aws/monitoring/monitoringRole");
@@ -15,36 +16,80 @@ const monitoring_1 = require("./config/monitoring");
  *   all resources in a Fjall application.
  */
 class App extends aws_cdk_lib_1.App {
-    constructor(name) {
+    constructor(name, options) {
         super();
         this.stacks = {};
+        this.additionalVpcs = new Map();
+        this.networkDisabled = false;
         this.globalTags = {};
         this.aspectApplied = false;
+        App.instance = this;
         if (name)
             this.name = name;
         else
             this.name = "FjallApp";
+        // Initialise network immediately if configured
+        if (options?.network === false) {
+            this.networkDisabled = true;
+        }
+        else if (options?.network) {
+            this.initialiseNetwork(options.network);
+        }
     }
     /**
-     * Get/Create a basic Fjall Application with standard tags applied
+     * Initialise the network (VPC) for this application.
+     */
+    initialiseNetwork(config) {
+        const networkStack = this.getDefaultNetworkStack();
+        if ("useExisting" in config) {
+            this.vpc = vpc_1.Vpc.fromLookup(networkStack.getStack(), `${this.name}ImportedVpc`, {
+                vpcId: config.useExisting
+            });
+        }
+        else {
+            const network = network_1.NetworkFactory.build(`${this.name}Vpc`, config)(this, networkStack.getStack());
+            this.vpc = network.getVpc();
+        }
+    }
+    /**
+     * Get/Create a basic Fjall Application with standard tags applied.
+     *
      * @param name Application name
+     * @param options Configuration options including network settings
      * @returns {App}
+     *
+     * @example
+     * // Create app with new VPC
+     * const app = App.getApp(appName, {
+     *   network: { maxAzs: 2, natGateways: false }
+     * });
+     *
+     * @example
+     * // Create app using existing VPC
+     * const app = App.getApp(appName, {
+     *   network: { useExisting: "vpc-12345678" }
+     * });
+     *
+     * @example
+     * // Create app without network (S3-only apps)
+     * const app = App.getApp(appName, { network: false });
      */
-    static getApp(name) {
-        const app = App.getInstance(name);
+    static getApp(name, options) {
+        const app = App.getInstance(name, options);
         app.initializeStandardTags();
         return app;
     }
     /**
      * Get/Create the singleton instance of the App
-     * @param name
+     * @param name Application name
+     * @param options Configuration options including network settings
      * @returns {App}
      */
-    static getInstance(name) {
+    static getInstance(name, options) {
         // Despite supporting multiple stacks you can still only ever
         // have a single Application per CDK deployment
         if (!App.instance) {
-            App.instance = new App(name);
+            App.instance = new App(name, options);
         }
         return App.instance;
     }
@@ -70,13 +115,14 @@ class App extends aws_cdk_lib_1.App {
     }
     /**
      * Retrieve default compute stack - named as `${this.name}Compute`
+     *
+     * Only depends on Network. Database dependency is added automatically
+     * by CDK when compute resources reference database resources.
+     *
      * @returns {AwsStack}
      */
     getDefaultComputeStack() {
-        return this.getStack(`${this.name}Compute`, [
-            this.getDefaultNetworkStack(),
-            this.getDefaultDatabaseStack()
-        ]);
+        return this.getStack(`${this.name}Compute`, this.getDefaultNetworkStack());
     }
     /**
      * Retrieve default network stack - named as `${this.name}Network`
@@ -100,49 +146,48 @@ class App extends aws_cdk_lib_1.App {
         return this.getStack(`${this.name}Storage`, this.getDefaultNetworkStack());
     }
     /**
-     * Retrieve default vpc. If the VPC does not exist it will be created.
-     * @returns {Vpc}
+     * Get a VPC by name. If no name is provided, returns the default VPC.
+     *
+     * This is a pure getter - it never creates infrastructure.
+     * Network must be configured via App.getApp() options or app.addNetwork().
+     *
+     * @param name - Optional name of the VPC to retrieve. If not provided, returns the default VPC.
+     * @returns {IVpc} The configured VPC
+     * @throws {Error} If network is disabled, not configured, or named VPC not found
      */
-    getDefaultVpc() {
-        const networkStack = this.getDefaultNetworkStack();
-        if (!this.defaultVpc) {
-            // Use an existing imported VPC if one was supplied
-            if (this.existingVpcId) {
-                this.defaultVpc = vpc_1.Vpc.fromLookup(networkStack.getStack(), `${this.name}ImportedVpc`, { vpcId: this.existingVpcId });
-            }
-            else {
-                // Attempt to automatically derive the account and region from the
-                // environment the CDK is running in. When an account ID is available,
-                // use it to import the corresponding IPAM pool so CIDRs are allocated
-                // from a central pool instead of using the default 10.0.0.0/16 block.
-                const accountId = this.node.tryGetContext("accountId") ||
-                    process.env.CDK_DEFAULT_ACCOUNT;
-                const region = process.env.CDK_DEFAULT_REGION;
-                const isManagedAccount = this.node.tryGetContext("managedAccount") === "true";
-                let ipv4IpamPoolId;
-                if (isManagedAccount && accountId && region) {
-                    // Include region suffix for region-specific IPAM pool exports
-                    const regionSuffix = region.replace(/-/g, "");
-                    ipv4IpamPoolId = aws_cdk_lib_1.Fn.importValue(`IpamPoolId${accountId}${regionSuffix}`);
-                }
-                this.defaultVpc = vpc_1.VpcFactory.build(`${this.name}DefaultVpc`, {
-                    accountId,
-                    region,
-                    ipv4IpamPoolId
-                })(this, networkStack.getStack());
+    getVpc(name) {
+        if (this.networkDisabled) {
+            throw new Error("Network is disabled for this app. Cannot get VPC. " +
+                "Pass network config to App.getApp() to enable networking.");
+        }
+        // If name is provided, look in additional VPCs first
+        if (name) {
+            const additionalVpc = this.additionalVpcs.get(name);
+            if (additionalVpc) {
+                return additionalVpc;
             }
+            throw new Error(`VPC '${name}' not found. Available VPCs: ${this.getVpcNames().join(", ")}. ` +
+                "Create additional VPCs using app.addNetwork(NetworkFactory.build(...)).");
         }
-        return this.defaultVpc;
+        // Return default VPC
+        if (!this.vpc) {
+            throw new Error("Network not configured. Pass network config to App.getApp(). " +
+                "Example: App.getApp(appName, { network: { maxAzs: 2 } })");
+        }
+        return this.vpc;
     }
     /**
-     * Reuse an existing VPC.
-     * Accepts either a Vpc object or a plain VPC ID string for convenience.
+     * Get the names of all available VPCs.
+     *
+     * @returns {string[]} Array of VPC names. Includes "default" if the default VPC is configured.
      */
-    useExistingVpc(vpcId) {
-        if (this.defaultVpc) {
-            throw new Error("useExistingVpc must be called before the default VPC has been created");
+    getVpcNames() {
+        const names = [];
+        if (this.vpc) {
+            names.push("default");
         }
-        this.existingVpcId = vpcId;
+        names.push(...this.additionalVpcs.keys());
+        return names;
     }
     /**
      * Retreive the default application container registry. If the registry does not exist
@@ -214,6 +259,29 @@ class App extends aws_cdk_lib_1.App {
         storageStack.addConstruct(storageConstruct);
         return storageConstruct;
     }
+    /**
+     * Add an additional network (VPC) to the application.
+     *
+     * Use this to create additional VPCs beyond the default VPC configured via App.getApp().
+     * Additional VPCs can be retrieved by name using app.getVpc(name).
+     *
+     * @param fn - Factory function that creates the Network construct
+     * @returns {Network} The created Network construct
+     *
+     * @example
+     * const isolatedVpc = app.addNetwork(
+     *   NetworkFactory.build("IsolatedVpc", { maxAzs: 2, natGateways: false })
+     * );
+     */
+    addNetwork(fn) {
+        const networkStack = this.getDefaultNetworkStack();
+        const network = fn(this, networkStack.getStack());
+        const vpcName = network.node.id;
+        // Store in additional VPCs map for retrieval via getVpc(name)
+        this.additionalVpcs.set(vpcName, network.getVpc());
+        networkStack.addConstruct(network);
+        return network;
+    }
     /**
      * Manually add a resource to the default database stack.
      */
@@ -270,4 +338,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 { App as CdkApp, Fn, Aspects } from \"aws-cdk-lib\";\nimport { type Construct } from \"constructs\";\nimport { Vpc, VpcFactory } from \"./resources/aws/networking/vpc\";\nimport { type IVpc } from \"aws-cdk-lib/aws-ec2\";\nimport { type Role } from \"aws-cdk-lib/aws-iam\";\n\nimport { AwsStack } from \"./resources\";\nimport { type Ecr, EcrFactory } from \"./resources/aws/storage/ecr\";\n\nimport { type Database } from \"./patterns/aws/database\";\nimport { StandardTagsAspect } from \"./utils/standardTagsAspect\";\nimport { getConfig } from \"./utils/getConfig\";\nimport MonitoringRoleFactory from \"./resources/aws/monitoring/monitoringRole\";\nimport { FJALL_MONITORING_CONFIG } from \"./config/monitoring\";\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 defaultVpc: IVpc;\n  private defaultEcr: Ecr;\n  private defaultMonitoringRole: Role;\n  private existingVpcId?: string;\n  private globalTags: { [key: string]: string } = {};\n  private aspectApplied = false;\n\n  private constructor(name?: string) {\n    super();\n\n    if (name) this.name = name;\n    else this.name = \"FjallApp\";\n  }\n\n  /**\n   * Get/Create a basic Fjall Application with standard tags applied\n   * @param name Application name\n   * @returns {App}\n   */\n  public static getApp(name?: string): App {\n    const app = App.getInstance(name);\n    app.initializeStandardTags();\n    return app;\n  }\n\n  /**\n   * Get/Create the singleton instance of the App\n   * @param name\n   * @returns {App}\n   */\n  public static getInstance(name?: string): 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);\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   * @returns {AwsStack}\n   */\n  public getDefaultComputeStack(): AwsStack {\n    return this.getStack(`${this.name}Compute`, [\n      this.getDefaultNetworkStack(),\n      this.getDefaultDatabaseStack()\n    ]);\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 vpc. If the VPC does not exist it will be created.\n   * @returns {Vpc}\n   */\n  public getDefaultVpc(): IVpc {\n    const networkStack = this.getDefaultNetworkStack();\n\n    if (!this.defaultVpc) {\n      // Use an existing imported VPC if one was supplied\n      if (this.existingVpcId) {\n        this.defaultVpc = Vpc.fromLookup(\n          networkStack.getStack(),\n          `${this.name}ImportedVpc`,\n          { vpcId: this.existingVpcId }\n        );\n      } else {\n        // Attempt to automatically derive the account and region from the\n        // environment the CDK is running in. When an account ID is available,\n        // use it to import the corresponding IPAM pool so CIDRs are allocated\n        // from a central pool instead of using the default 10.0.0.0/16 block.\n\n        const accountId =\n          this.node.tryGetContext(\"accountId\") ||\n          process.env.CDK_DEFAULT_ACCOUNT;\n        const region = process.env.CDK_DEFAULT_REGION;\n        const isManagedAccount =\n          this.node.tryGetContext(\"managedAccount\") === \"true\";\n\n        let ipv4IpamPoolId: string | undefined;\n        if (isManagedAccount && accountId && region) {\n          // Include region suffix for region-specific IPAM pool exports\n          const regionSuffix = region.replace(/-/g, \"\");\n          ipv4IpamPoolId = Fn.importValue(\n            `IpamPoolId${accountId}${regionSuffix}`\n          );\n        }\n\n        this.defaultVpc = VpcFactory.build(`${this.name}DefaultVpc`, {\n          accountId,\n          region,\n          ipv4IpamPoolId\n        })(this, networkStack.getStack());\n      }\n    }\n\n    return this.defaultVpc;\n  }\n\n  /**\n   * Reuse an existing VPC.\n   * Accepts either a Vpc object or a plain VPC ID string for convenience.\n   */\n  public useExistingVpc(vpcId: string): void {\n    if (this.defaultVpc) {\n      throw new Error(\n        \"useExistingVpc must be called before the default VPC has been created\"\n      );\n    }\n\n    this.existingVpcId = vpcId;\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   * Add a compute resource to the default compute stack using the factory pattern.\n   * Automatically creates monitoring role if not already created.\n   */\n  public addCompute(fn: (app: App, scope: Construct) => Construct): void {\n    // Auto-create monitoring role when compute is added\n    if (!this.defaultMonitoringRole) {\n      this.createMonitoringRole();\n    }\n\n    const computeStack = this.getDefaultComputeStack();\n    computeStack.addConstruct(fn(this, computeStack.getStack()));\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): any {\n    const storageStack = this.getDefaultStorageStack();\n    const storageConstruct = fn(this, storageStack.getStack());\n    storageStack.addConstruct(storageConstruct);\n\n    return storageConstruct;\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 initializeStandardTags(): 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 as a single aspect\n   */\n  private applyTagsAspect(): void {\n    if (!this.aspectApplied && Object.keys(this.globalTags).length > 0) {\n      // Apply ONE aspect with all tags using the CDK v2.206.0+ compatible StandardTagsAspect\n      Aspects.of(this).add(new StandardTagsAspect(this.globalTags));\n      this.aspectApplied = true;\n    }\n  }\n\n  /**\n   * Add custom tags to all resources in the app\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 but don't apply aspect yet\n    this.globalTags = {\n      ...this.globalTags,\n      ...tags\n    };\n    return this;\n  }\n}\n\nexport default App;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.js","sourceRoot":"","sources":["../../lib/app.ts"],"names":[],"mappings":"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","sourcesContent":["import { App as CdkApp, Aspects } from \"aws-cdk-lib\";\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  Network\n} from \"./patterns/aws/network\";\nimport { StandardTagsAspect } from \"./utils/standardTagsAspect\";\nimport { getConfig } from \"./utils/getConfig\";\nimport MonitoringRoleFactory from \"./resources/aws/monitoring/monitoringRole\";\nimport { FJALL_MONITORING_CONFIG } from \"./config/monitoring\";\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: Map<string, IVpc> = new Map();\n  private defaultEcr: Ecr;\n  private defaultMonitoringRole: Role;\n  private networkDisabled = false;\n  private globalTags: { [key: string]: string } = {};\n  private aspectApplied = false;\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    // 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/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.initializeStandardTags();\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   * Add a compute resource to the default compute stack using the factory pattern.\n   * Automatically creates monitoring role if not already created.\n   */\n  public addCompute(fn: (app: App, scope: Construct) => Construct): void {\n    // Auto-create monitoring role when compute is added\n    if (!this.defaultMonitoringRole) {\n      this.createMonitoringRole();\n    }\n\n    const computeStack = this.getDefaultComputeStack();\n    computeStack.addConstruct(fn(this, computeStack.getStack()));\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): any {\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 initializeStandardTags(): 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 as a single aspect\n   */\n  private applyTagsAspect(): void {\n    if (!this.aspectApplied && Object.keys(this.globalTags).length > 0) {\n      // Apply ONE aspect with all tags using the CDK v2.206.0+ compatible StandardTagsAspect\n      Aspects.of(this).add(new StandardTagsAspect(this.globalTags));\n      this.aspectApplied = true;\n    }\n  }\n\n  /**\n   * Add custom tags to all resources in the app\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 but don't apply aspect yet\n    this.globalTags = {\n      ...this.globalTags,\n      ...tags\n    };\n    return this;\n  }\n}\n\nexport default App;\n"]}

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

@@ -0,0 +1,41 @@
+import { IAspect } from "aws-cdk-lib";
+import { IConstruct } from "constructs";
+/**
+ * Resource metadata extracted from CDK constructs
+ */
+export interface ResourceMetadata {
+    resource_type: string;
+    name: string;
+    stack_name: string;
+}
+/**
+ * Complete resource inventory for an application
+ */
+export interface ResourceInventory {
+    resources: ResourceMetadata[];
+    generated_at: string;
+    app_name: string;
+}
+/**
+ * Aspect to collect resource metadata during CDK synthesis.
+ * Visits all constructs in the tree and extracts metadata for AWS resources.
+ *
+ * Usage:
+ *   const aspect = new ResourceInventoryAspect();
+ *   Aspects.of(app).add(aspect);
+ *   app.synth();
+ *   const inventory = aspect.getInventory();
+ */
+export declare class ResourceInventoryAspect implements IAspect {
+    private resources;
+    private processedResources;
+    visit(node: IConstruct): void;
+    /**
+     * Extract metadata from a CloudFormation resource
+     */
+    private extractMetadata;
+    /**
+     * Get collected resource inventory
+     */
+    getInventory(): ResourceMetadata[];
+}

package/dist/lib/aspects/resourceInventory.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceInventoryAspect = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+/**
+ * Aspect to collect resource metadata during CDK synthesis.
+ * Visits all constructs in the tree and extracts metadata for AWS resources.
+ *
+ * Usage:
+ *   const aspect = new ResourceInventoryAspect();
+ *   Aspects.of(app).add(aspect);
+ *   app.synth();
+ *   const inventory = aspect.getInventory();
+ */
+class ResourceInventoryAspect {
+    constructor() {
+        this.resources = [];
+        this.processedResources = new WeakSet();
+    }
+    visit(node) {
+        // Skip if already processed
+        if (this.processedResources.has(node)) {
+            return;
+        }
+        // Only process L1 (CFN) resources
+        if (aws_cdk_lib_1.CfnResource.isCfnResource(node)) {
+            const metadata = this.extractMetadata(node);
+            if (metadata) {
+                this.resources.push(metadata);
+            }
+            this.processedResources.add(node);
+        }
+    }
+    /**
+     * Extract metadata from a CloudFormation resource
+     */
+    extractMetadata(resource) {
+        const resourceType = resource.cfnResourceType;
+        const stack = aws_cdk_lib_1.Stack.of(resource);
+        const logicalId = stack.getLogicalId(resource);
+        const stackName = stack.stackName;
+        return {
+            resource_type: resourceType,
+            name: logicalId,
+            stack_name: stackName
+        };
+    }
+    /**
+     * Get collected resource inventory
+     */
+    getInventory() {
+        return this.resources;
+    }
+}
+exports.ResourceInventoryAspect = ResourceInventoryAspect;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/config/audit.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Audit configuration for cross-account CloudQuery access
+ */
+export declare const FJALL_AUDIT_CONFIG: {
+    /**
+     * Fjall webapp AWS account ID
+     * This account will be granted permission to assume audit roles for CloudQuery
+     */
+    readonly webappAwsAccountId: "985539798308";
+    /**
+     * IAM role naming convention
+     */
+    readonly roleNamePrefix: "FjallAudit";
+    /**
+     * IAM role path (for organizational structure)
+     */
+    readonly rolePath: "/";
+};

package/dist/lib/config/audit.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FJALL_AUDIT_CONFIG = void 0;
+/**
+ * Audit configuration for cross-account CloudQuery access
+ */
+exports.FJALL_AUDIT_CONFIG = {
+    /**
+     * Fjall webapp AWS account ID
+     * This account will be granted permission to assume audit roles for CloudQuery
+     */
+    webappAwsAccountId: "985539798308", // Fjall platform account
+    /**
+     * IAM role naming convention
+     */
+    roleNamePrefix: "FjallAudit",
+    /**
+     * IAM role path (for organizational structure)
+     */
+    rolePath: "/"
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXVkaXQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvY29uZmlnL2F1ZGl0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOztHQUVHO0FBQ1UsUUFBQSxrQkFBa0IsR0FBRztJQUNoQzs7O09BR0c7SUFDSCxrQkFBa0IsRUFBRSxjQUFjLEVBQUUseUJBQXlCO0lBRTdEOztPQUVHO0lBQ0gsY0FBYyxFQUFFLFlBQVk7SUFFNUI7O09BRUc7SUFDSCxRQUFRLEVBQUUsR0FBRztDQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEF1ZGl0IGNvbmZpZ3VyYXRpb24gZm9yIGNyb3NzLWFjY291bnQgQ2xvdWRRdWVyeSBhY2Nlc3NcbiAqL1xuZXhwb3J0IGNvbnN0IEZKQUxMX0FVRElUX0NPTkZJRyA9IHtcbiAgLyoqXG4gICAqIEZqYWxsIHdlYmFwcCBBV1MgYWNjb3VudCBJRFxuICAgKiBUaGlzIGFjY291bnQgd2lsbCBiZSBncmFudGVkIHBlcm1pc3Npb24gdG8gYXNzdW1lIGF1ZGl0IHJvbGVzIGZvciBDbG91ZFF1ZXJ5XG4gICAqL1xuICB3ZWJhcHBBd3NBY2NvdW50SWQ6IFwiOTg1NTM5Nzk4MzA4XCIsIC8vIEZqYWxsIHBsYXRmb3JtIGFjY291bnRcblxuICAvKipcbiAgICogSUFNIHJvbGUgbmFtaW5nIGNvbnZlbnRpb25cbiAgICovXG4gIHJvbGVOYW1lUHJlZml4OiBcIkZqYWxsQXVkaXRcIixcblxuICAvKipcbiAgICogSUFNIHJvbGUgcGF0aCAoZm9yIG9yZ2FuaXphdGlvbmFsIHN0cnVjdHVyZSlcbiAgICovXG4gIHJvbGVQYXRoOiBcIi9cIlxufSBhcyBjb25zdDtcbiJdfQ==