@fjall/components-infrastructure 0.88.3 → 0.88.4

package/dist/lib/utils/connector.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * Unified connector interface for bidirectional connections.
+ *
+ * This module provides a unified `IConnector` interface that enables
+ * bidirectional connections between compute resources (ECS, Lambda, EC2)
+ * and data resources (S3, DynamoDB, SQS, RDS).
+ *
+ * The connector pattern unifies:
+ * - Security group rules (IConnectable) for RDS, ECS, etc.
+ * - IAM grants for S3, DynamoDB, SQS
+ *
+ * @example
+ * // Simple connections (default permissions)
+ * const api = app.addCompute(ComputeFactory.build("Api", {
+ *   type: "ecs",
+ *   services: [{
+ *     name: "api",
+ *     capacityProvider: "FARGATE",
+ *     connections: [database, bucket, cache, queue]
+ *   }]
+ * }));
+ *
+ * @example
+ * // Explicit access levels
+ * const worker = app.addCompute(ComputeFactory.build("Worker", {
+ *   type: "ecs",
+ *   services: [{
+ *     name: "worker",
+ *     capacityProvider: "FARGATE",
+ *     connections: [
+ *       database,                              // Security group (RDS)
+ *       { resource: cache, access: "read" },   // Read-only DynamoDB
+ *       { resource: bucket, access: "write" }, // Write-only S3
+ *       { resource: queue, access: "consume" } // Consume-only SQS
+ *     ]
+ *   }]
+ * }));
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONNECTION_TYPE = void 0;
+exports.isConnectionAccess = isConnectionAccess;
+exports.isMessagingAccess = isMessagingAccess;
+exports.isConnector = isConnector;
+exports.isConnectable = isConnectable;
+exports.isConnectionConfig = isConnectionConfig;
+exports.isStorageConnector = isStorageConnector;
+exports.isDynamoDBConnector = isDynamoDBConnector;
+exports.isQueueConnector = isQueueConnector;
+exports.isSecurityGroupConnector = isSecurityGroupConnector;
+/** Connection result types. */
+exports.CONNECTION_TYPE = {
+    SECURITY_GROUP: "securityGroup",
+    IAM: "iam"
+};
+const VALID_CONNECTION_ACCESS = [
+    "read",
+    "write",
+    "readWrite"
+];
+const VALID_MESSAGING_ACCESS = [
+    "send",
+    "consume",
+    "full"
+];
+/** Check if a value is a valid ConnectionAccess. */
+function isConnectionAccess(value) {
+    return (typeof value === "string" &&
+        VALID_CONNECTION_ACCESS.includes(value));
+}
+/** Check if a value is a valid MessagingAccess. */
+function isMessagingAccess(value) {
+    return (typeof value === "string" &&
+        VALID_MESSAGING_ACCESS.includes(value));
+}
+/**
+ * Type guard to check if a resource is a connector.
+ * Returns AnyConnector for discriminated union narrowing in switch statements.
+ */
+function isConnector(resource) {
+    return (resource !== null &&
+        typeof resource === "object" &&
+        "connectorType" in resource);
+}
+/**
+ * Type guard to check if a resource is a CDK IConnectable.
+ * Checks for the `connections` property that IConnectable resources have.
+ */
+function isConnectable(resource) {
+    return (resource !== null &&
+        typeof resource === "object" &&
+        "connections" in resource);
+}
+/**
+ * Type guard to check if a connection spec is a ConnectionConfig.
+ */
+function isConnectionConfig(spec) {
+    return spec !== null && typeof spec === "object" && "resource" in spec;
+}
+/** Type guard for storage connectors (S3 buckets). */
+function isStorageConnector(connector) {
+    return connector.connectorType === "storage";
+}
+/** Type guard for DynamoDB connectors. */
+function isDynamoDBConnector(connector) {
+    return connector.connectorType === "dynamodb";
+}
+/** Type guard for queue connectors (SQS queues). */
+function isQueueConnector(connector) {
+    return connector.connectorType === "queue";
+}
+/** Type guard for security group connectors (RDS, ECS). */
+function isSecurityGroupConnector(connector) {
+    return (connector.connectorType === "securityGroup" ||
+        connector.connectorType === "relational");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connector.js","sourceRoot":"","sources":["../../../lib/utils/connector.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;;;AA2KH,gDAKC;AAGD,8CAKC;AAMD,kCAMC;AAMD,sCAMC;AAKD,gDAIC;AAGD,gDAIC;AAGD,kDAIC;AAGD,4CAIC;AAGD,4DAOC;AAjHD,+BAA+B;AAClB,QAAA,eAAe,GAAG;IAC7B,cAAc,EAAE,eAAe;IAC/B,GAAG,EAAE,KAAK;CACF,CAAC;AAoBX,MAAM,uBAAuB,GAAgC;IAC3D,MAAM;IACN,OAAO;IACP,WAAW;CACZ,CAAC;AACF,MAAM,sBAAsB,GAA+B;IACzD,MAAM;IACN,SAAS;IACT,MAAM;CACP,CAAC;AAEF,oDAAoD;AACpD,SAAgB,kBAAkB,CAAC,KAAc;IAC/C,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,uBAAuB,CAAC,QAAQ,CAAC,KAAyB,CAAC,CAC5D,CAAC;AACJ,CAAC;AAED,mDAAmD;AACnD,SAAgB,iBAAiB,CAAC,KAAc;IAC9C,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,sBAAsB,CAAC,QAAQ,CAAC,KAAwB,CAAC,CAC1D,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAgB,WAAW,CAAC,QAAiB;IAC3C,OAAO,CACL,QAAQ,KAAK,IAAI;QACjB,OAAO,QAAQ,KAAK,QAAQ;QAC5B,eAAe,IAAI,QAAQ,CAC5B,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAgB,aAAa,CAAC,QAAiB;IAC7C,OAAO,CACL,QAAQ,KAAK,IAAI;QACjB,OAAO,QAAQ,KAAK,QAAQ;QAC5B,aAAa,IAAI,QAAQ,CAC1B,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,kBAAkB,CAChC,IAAoB;IAEpB,OAAO,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,UAAU,IAAI,IAAI,CAAC;AACzE,CAAC;AAED,sDAAsD;AACtD,SAAgB,kBAAkB,CAChC,SAAqB;IAErB,OAAO,SAAS,CAAC,aAAa,KAAK,SAAS,CAAC;AAC/C,CAAC;AAED,0CAA0C;AAC1C,SAAgB,mBAAmB,CACjC,SAAqB;IAErB,OAAO,SAAS,CAAC,aAAa,KAAK,UAAU,CAAC;AAChD,CAAC;AAED,oDAAoD;AACpD,SAAgB,gBAAgB,CAC9B,SAAqB;IAErB,OAAO,SAAS,CAAC,aAAa,KAAK,OAAO,CAAC;AAC7C,CAAC;AAED,2DAA2D;AAC3D,SAAgB,wBAAwB,CACtC,SAAqB;IAErB,OAAO,CACL,SAAS,CAAC,aAAa,KAAK,eAAe;QAC3C,SAAS,CAAC,aAAa,KAAK,YAAY,CACzC,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Unified connector interface for bidirectional connections.\n *\n * This module provides a unified `IConnector` interface that enables\n * bidirectional connections between compute resources (ECS, Lambda, EC2)\n * and data resources (S3, DynamoDB, SQS, RDS).\n *\n * The connector pattern unifies:\n * - Security group rules (IConnectable) for RDS, ECS, etc.\n * - IAM grants for S3, DynamoDB, SQS\n *\n * @example\n * // Simple connections (default permissions)\n * const api = app.addCompute(ComputeFactory.build(\"Api\", {\n *   type: \"ecs\",\n *   services: [{\n *     name: \"api\",\n *     capacityProvider: \"FARGATE\",\n *     connections: [database, bucket, cache, queue]\n *   }]\n * }));\n *\n * @example\n * // Explicit access levels\n * const worker = app.addCompute(ComputeFactory.build(\"Worker\", {\n *   type: \"ecs\",\n *   services: [{\n *     name: \"worker\",\n *     capacityProvider: \"FARGATE\",\n *     connections: [\n *       database,                              // Security group (RDS)\n *       { resource: cache, access: \"read\" },   // Read-only DynamoDB\n *       { resource: bucket, access: \"write\" }, // Write-only S3\n *       { resource: queue, access: \"consume\" } // Consume-only SQS\n *     ]\n *   }]\n * }));\n */\n\nimport { type IConnectable } from \"aws-cdk-lib/aws-ec2\";\nimport { type IGrantable, type Grant } from \"aws-cdk-lib/aws-iam\";\n\n/**\n * Connector type discriminator.\n * - \"storage\": S3 buckets\n * - \"dynamodb\": DynamoDB tables\n * - \"queue\": SQS queues\n * - \"securityGroup\": Resources with security groups (ECS, Lambda with VPC)\n * - \"relational\": RDS databases (uses security groups)\n */\nexport type ConnectorType =\n  | \"storage\"\n  | \"dynamodb\"\n  | \"queue\"\n  | \"securityGroup\"\n  | \"relational\";\n\n/**\n * Access level for storage and DynamoDB connectors.\n */\nexport type ConnectionAccess = \"read\" | \"write\" | \"readWrite\";\n\n/**\n * Access level for messaging connectors (SQS).\n */\nexport type MessagingAccess = \"send\" | \"consume\" | \"full\";\n\n/**\n * Base connector interface.\n * All connector types implement this interface.\n */\nexport interface IConnector {\n  /** The type of connector resource. Used for runtime type narrowing. */\n  readonly connectorType: ConnectorType;\n}\n\n/**\n * Storage connector interface (S3).\n * Provides IAM grant methods for S3 bucket access.\n */\nexport interface IStorageConnector extends IConnector {\n  readonly connectorType: \"storage\";\n\n  /** Grant read permissions to the grantee. */\n  grantRead(grantee: IGrantable): Grant;\n\n  /** Grant write permissions to the grantee. */\n  grantWrite(grantee: IGrantable): Grant;\n\n  /** Grant read and write permissions to the grantee. */\n  grantReadWrite(grantee: IGrantable): Grant;\n}\n\n/**\n * DynamoDB connector interface.\n * Provides IAM grant methods for DynamoDB table access.\n */\nexport interface IDynamoDBConnector extends IConnector {\n  readonly connectorType: \"dynamodb\";\n\n  /** Grant read data permissions to the grantee. */\n  grantReadData(grantee: IGrantable): Grant;\n\n  /** Grant write data permissions to the grantee. */\n  grantWriteData(grantee: IGrantable): Grant;\n\n  /** Grant read and write data permissions to the grantee. */\n  grantReadWriteData(grantee: IGrantable): Grant;\n}\n\n/**\n * Queue connector interface (SQS).\n * Provides IAM grant methods for SQS queue access.\n */\nexport interface IQueueConnector extends IConnector {\n  readonly connectorType: \"queue\";\n\n  /** Grant send message permissions to the grantee. */\n  grantSendMessages(grantee: IGrantable): Grant;\n\n  /** Grant consume (receive and delete) message permissions to the grantee. */\n  grantConsumeMessages(grantee: IGrantable): Grant;\n\n  /** Grant full access (send and consume) to the grantee. */\n  grantFull(grantee: IGrantable): Grant;\n}\n\n/**\n * Security group connector interface (RDS, ECS with VPC).\n * Provides access to the security group connections for network-level access.\n *\n * Both \"securityGroup\" and \"relational\" types use this interface:\n * - \"relational\": RDS databases (Aurora, Instance, GlobalAurora)\n * - \"securityGroup\": Other resources requiring security group rules (ECS, EC2)\n */\nexport interface ISecurityGroupConnector extends IConnector {\n  readonly connectorType: \"securityGroup\" | \"relational\";\n\n  /** The security group connections for this resource. */\n  readonly connections: IConnectable[\"connections\"];\n}\n\n/**\n * Union type representing any connector interface.\n */\nexport type AnyConnector =\n  | IStorageConnector\n  | IDynamoDBConnector\n  | IQueueConnector\n  | ISecurityGroupConnector;\n\n/**\n * Connection configuration with explicit access level.\n * Use this to specify non-default access levels.\n */\nexport interface ConnectionConfig {\n  /** The resource to connect to. */\n  resource: AnyConnector | IConnectable;\n\n  /** The access level to grant. Defaults vary by resource type. */\n  access?: ConnectionAccess | MessagingAccess;\n}\n\n/**\n * Connection specification.\n * Can be:\n * - IConnectable: Legacy security group resource\n * - AnyConnector: Unified connector resource\n * - ConnectionConfig: Explicit access configuration\n */\nexport type ConnectionSpec = IConnectable | AnyConnector | ConnectionConfig;\n\n/** Connection result types. */\nexport const CONNECTION_TYPE = {\n  SECURITY_GROUP: \"securityGroup\",\n  IAM: \"iam\"\n} as const;\n\nexport type ConnectionType =\n  (typeof CONNECTION_TYPE)[keyof typeof CONNECTION_TYPE];\n\n/**\n * Result of processing a connection.\n * Contains the grant result for IAM-based connections.\n */\nexport interface ConnectionResult {\n  /** The resource that was connected. */\n  resource: AnyConnector | IConnectable;\n\n  /** The grant result if IAM permissions were granted. */\n  grant?: Grant;\n\n  /** The type of connection that was made. */\n  connectionType: ConnectionType;\n}\n\nconst VALID_CONNECTION_ACCESS: readonly ConnectionAccess[] = [\n  \"read\",\n  \"write\",\n  \"readWrite\"\n];\nconst VALID_MESSAGING_ACCESS: readonly MessagingAccess[] = [\n  \"send\",\n  \"consume\",\n  \"full\"\n];\n\n/** Check if a value is a valid ConnectionAccess. */\nexport function isConnectionAccess(value: unknown): value is ConnectionAccess {\n  return (\n    typeof value === \"string\" &&\n    VALID_CONNECTION_ACCESS.includes(value as ConnectionAccess)\n  );\n}\n\n/** Check if a value is a valid MessagingAccess. */\nexport function isMessagingAccess(value: unknown): value is MessagingAccess {\n  return (\n    typeof value === \"string\" &&\n    VALID_MESSAGING_ACCESS.includes(value as MessagingAccess)\n  );\n}\n\n/**\n * Type guard to check if a resource is a connector.\n * Returns AnyConnector for discriminated union narrowing in switch statements.\n */\nexport function isConnector(resource: unknown): resource is AnyConnector {\n  return (\n    resource !== null &&\n    typeof resource === \"object\" &&\n    \"connectorType\" in resource\n  );\n}\n\n/**\n * Type guard to check if a resource is a CDK IConnectable.\n * Checks for the `connections` property that IConnectable resources have.\n */\nexport function isConnectable(resource: unknown): resource is IConnectable {\n  return (\n    resource !== null &&\n    typeof resource === \"object\" &&\n    \"connections\" in resource\n  );\n}\n\n/**\n * Type guard to check if a connection spec is a ConnectionConfig.\n */\nexport function isConnectionConfig(\n  spec: ConnectionSpec\n): spec is ConnectionConfig {\n  return spec !== null && typeof spec === \"object\" && \"resource\" in spec;\n}\n\n/** Type guard for storage connectors (S3 buckets). */\nexport function isStorageConnector(\n  connector: IConnector\n): connector is IStorageConnector {\n  return connector.connectorType === \"storage\";\n}\n\n/** Type guard for DynamoDB connectors. */\nexport function isDynamoDBConnector(\n  connector: IConnector\n): connector is IDynamoDBConnector {\n  return connector.connectorType === \"dynamodb\";\n}\n\n/** Type guard for queue connectors (SQS queues). */\nexport function isQueueConnector(\n  connector: IConnector\n): connector is IQueueConnector {\n  return connector.connectorType === \"queue\";\n}\n\n/** Type guard for security group connectors (RDS, ECS). */\nexport function isSecurityGroupConnector(\n  connector: IConnector\n): connector is ISecurityGroupConnector {\n  return (\n    connector.connectorType === \"securityGroup\" ||\n    connector.connectorType === \"relational\"\n  );\n}\n"]}

package/dist/lib/utils/databaseTypes.d.ts

@@ -0,0 +1,85 @@
+import { type Duration } from "aws-cdk-lib";
+import { type IKey } from "aws-cdk-lib/aws-kms";
+import { type SubnetSelection } from "aws-cdk-lib/aws-ec2";
+export type DatabaseEngine = "postgresql" | "mysql";
+export interface EngineConfig {
+    defaultUsername: string;
+    sslParameters: Record<string, string>;
+    rotationAppName: string;
+}
+export interface ProxyConfig {
+    maxConnections?: number;
+    maxIdleConnections?: number;
+    connectionBorrowTimeout?: number;
+    requireTLS?: boolean;
+    vpcSubnets?: SubnetSelection;
+}
+export interface ReadReplicaConfig {
+    instanceType?: string;
+    availabilityZone?: string;
+}
+export interface CredentialsConfig {
+    username?: string;
+    secretRotation?: SecretRotationConfig | false;
+}
+export interface SecretRotationConfig {
+    automaticallyAfter?: Duration;
+}
+export interface EncryptionConfig {
+    storageKey?: EncryptionKeySpec;
+}
+/** Configuration for Database Insights (formerly Performance Insights). */
+export interface DatabaseInsightsConfig {
+    encryptionKey?: EncryptionKeySpec;
+    /** Database Insights mode. Default: "standard". */
+    mode?: "standard" | "advanced";
+}
+export interface AwsManagedKey {
+    readonly awsManaged: true;
+}
+export interface CustomerManagedKeyMarker {
+    readonly useCMK: true;
+}
+export type EncryptionKeySpec = IKey | AwsManagedKey | CustomerManagedKeyMarker;
+export declare function isAwsManagedKey(spec: EncryptionKeySpec | undefined): spec is AwsManagedKey;
+/**
+ * Type guard to check if CMK is explicitly requested.
+ */
+export declare function isCMKRequested(spec: EncryptionKeySpec | undefined): spec is CustomerManagedKeyMarker;
+/**
+ * Convenience constant for specifying AWS managed encryption (the default).
+ * @example
+ * encryption: { storageKey: AWS_MANAGED }
+ */
+export declare const AWS_MANAGED: AwsManagedKey;
+/**
+ * Convenience constant for explicitly requesting CMK.
+ * @example
+ * encryption: { storageKey: USE_CMK }
+ */
+export declare const USE_CMK: CustomerManagedKeyMarker;
+/**
+ * **DESTRUCTIVE**: Changing `storageKey` after cluster creation causes cluster REPLACEMENT.
+ */
+export interface AuroraEncryptionConfig {
+    /** DESTRUCTIVE: Changing after creation causes cluster replacement */
+    storageKey?: EncryptionKeySpec;
+}
+export interface AuroraReaderConfig {
+    scaleWithWriter?: boolean;
+    enableDatabaseInsights?: boolean;
+    identifierSuffix?: string;
+    availabilityZone?: string;
+}
+export interface AuroraWriterConfig {
+    enableDatabaseInsights?: boolean;
+    identifierSuffix?: string;
+    availabilityZone?: string;
+}
+export interface AuroraReadersConfig {
+    /** Mutually exclusive with instances */
+    count?: number;
+    /** Mutually exclusive with count */
+    instances?: AuroraReaderConfig[];
+    defaultEnableDatabaseInsights?: boolean;
+}

package/dist/lib/utils/databaseTypes.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USE_CMK = exports.AWS_MANAGED = void 0;
+exports.isAwsManagedKey = isAwsManagedKey;
+exports.isCMKRequested = isCMKRequested;
+// Type guard to check if the encryption key spec is AWS managed.
+function isAwsManagedKey(spec) {
+    return (spec !== undefined &&
+        typeof spec === "object" &&
+        "awsManaged" in spec &&
+        spec.awsManaged === true);
+}
+/**
+ * Type guard to check if CMK is explicitly requested.
+ */
+function isCMKRequested(spec) {
+    return (spec !== undefined &&
+        typeof spec === "object" &&
+        "useCMK" in spec &&
+        spec.useCMK === true);
+}
+/**
+ * Convenience constant for specifying AWS managed encryption (the default).
+ * @example
+ * encryption: { storageKey: AWS_MANAGED }
+ */
+exports.AWS_MANAGED = { awsManaged: true };
+/**
+ * Convenience constant for explicitly requesting CMK.
+ * @example
+ * encryption: { storageKey: USE_CMK }
+ */
+exports.USE_CMK = { useCMK: true };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/utils/env.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Declarative environment configuration utility.
+ *
+ * Resolves environment-specific values at CDK synth time without requiring
+ * an App instance. This allows `env()` to be used in `App.getApp()` arguments.
+ *
+ * @example
+ * ```ts
+ * import { App, env } from "@fjall/components-infrastructure";
+ *
+ * const app = App.getApp("myapp", {
+ *   network: { maxAzs: env({ default: 2, production: 3 }) }
+ * });
+ * ```
+ */
+type EnvConfig<T> = {
+    default: T;
+} & Partial<Record<string, T>>;
+/**
+ * Resolve the current deployment environment without App dependency.
+ *
+ * Resolution order:
+ * 1. Module cache (cached after first call)
+ * 2. `process.env.ENVIRONMENT`
+ * 3. `-c environment=<value>` from process.argv
+ * 4. `CDK_DEFAULT_ACCOUNT` → providerAccounts lookup
+ * 5. `-c accountName=<value>` → providerAccounts lookup
+ * 6. `"unknown"` (with warning)
+ */
+export declare function getEnvironment(): string;
+/**
+ * Resolve an environment-specific value at CDK synth time.
+ *
+ * @param config - Object with `default` key and optional environment overrides
+ * @returns The value for the current environment, or the default
+ */
+export declare function env<T>(config: EnvConfig<T>): T;
+/**
+ * Reset the environment cache. For testing only.
+ */
+export declare function _resetEnvironmentCache(): void;
+export {};

package/dist/lib/utils/env.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvironment = getEnvironment;
+exports.env = env;
+exports._resetEnvironmentCache = _resetEnvironmentCache;
+const util_1 = require("@fjall/util");
+let cachedEnvironment;
+/**
+ * Resolve the current deployment environment without App dependency.
+ *
+ * Resolution order:
+ * 1. Module cache (cached after first call)
+ * 2. `process.env.ENVIRONMENT`
+ * 3. `-c environment=<value>` from process.argv
+ * 4. `CDK_DEFAULT_ACCOUNT` → providerAccounts lookup
+ * 5. `-c accountName=<value>` → providerAccounts lookup
+ * 6. `"unknown"` (with warning)
+ */
+function getEnvironment() {
+    if (cachedEnvironment !== undefined) {
+        return cachedEnvironment;
+    }
+    // 1. process.env.ENVIRONMENT
+    if (process.env.ENVIRONMENT) {
+        cachedEnvironment = process.env.ENVIRONMENT;
+        return cachedEnvironment;
+    }
+    // 2. -c environment=<value> from process.argv
+    const envFromArgv = parseContextArg("environment");
+    if (envFromArgv) {
+        cachedEnvironment = envFromArgv;
+        return cachedEnvironment;
+    }
+    // 3. CDK_DEFAULT_ACCOUNT → providerAccounts lookup
+    const accountId = process.env.CDK_DEFAULT_ACCOUNT;
+    if (accountId) {
+        const env = resolveEnvironmentFromAccountId(accountId);
+        if (env) {
+            cachedEnvironment = env;
+            return cachedEnvironment;
+        }
+    }
+    // 4. -c accountName=<value> → providerAccounts lookup
+    const accountName = parseContextArg("accountName");
+    if (accountName) {
+        const env = resolveEnvironmentFromAccountName(accountName);
+        if (env) {
+            cachedEnvironment = env;
+            return cachedEnvironment;
+        }
+    }
+    // 5. Fallback
+    console.warn("[fjall] Could not determine environment. " +
+        "Set ENVIRONMENT env var or pass -c environment=<value>.");
+    cachedEnvironment = "unknown";
+    return cachedEnvironment;
+}
+/**
+ * Resolve an environment-specific value at CDK synth time.
+ *
+ * @param config - Object with `default` key and optional environment overrides
+ * @returns The value for the current environment, or the default
+ */
+function env(config) {
+    const environment = getEnvironment();
+    if (environment in config) {
+        return config[environment];
+    }
+    return config.default;
+}
+/**
+ * Reset the environment cache. For testing only.
+ */
+function _resetEnvironmentCache() {
+    cachedEnvironment = undefined;
+}
+/**
+ * Parse a `-c key=value` argument from process.argv.
+ */
+function parseContextArg(key) {
+    const args = process.argv;
+    for (let i = 0; i < args.length - 1; i++) {
+        if (args[i] === "-c") {
+            const parts = args[i + 1].split("=");
+            if (parts[0] === key && parts.length >= 2) {
+                return parts.slice(1).join("=");
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Look up environment from account ID via fjall config providerAccounts.
+ */
+function resolveEnvironmentFromAccountId(accountId) {
+    try {
+        const config = util_1.Config.loadConfig();
+        const account = config.getProviderAccountById(accountId);
+        return account?.environment;
+    }
+    catch (err) {
+        // Config may not exist yet (first deploy, CI). Caller falls back to next strategy.
+        if (process.env.FJALL_DEBUG) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[fjall] Config lookup by accountId failed: ${msg}\n`);
+        }
+        return undefined;
+    }
+}
+/**
+ * Look up environment from account name via fjall config providerAccounts.
+ */
+function resolveEnvironmentFromAccountName(accountName) {
+    try {
+        const config = util_1.Config.loadConfig();
+        const account = config.getProviderAccount(accountName);
+        return account?.environment;
+    }
+    catch (err) {
+        // Config may not exist yet (first deploy, CI). Caller falls back to next strategy.
+        if (process.env.FJALL_DEBUG) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[fjall] Config lookup by accountName failed: ${msg}\n`);
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"env.js","sourceRoot":"","sources":["../../../lib/utils/env.ts"],"names":[],"mappings":"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","sourcesContent":["import { Config as FjallConfig } from \"@fjall/util\";\n\n/**\n * Declarative environment configuration utility.\n *\n * Resolves environment-specific values at CDK synth time without requiring\n * an App instance. This allows `env()` to be used in `App.getApp()` arguments.\n *\n * @example\n * ```ts\n * import { App, env } from \"@fjall/components-infrastructure\";\n *\n * const app = App.getApp(\"myapp\", {\n *   network: { maxAzs: env({ default: 2, production: 3 }) }\n * });\n * ```\n */\n\ntype EnvConfig<T> = { default: T } & Partial<Record<string, T>>;\n\nlet cachedEnvironment: string | undefined;\n\n/**\n * Resolve the current deployment environment without App dependency.\n *\n * Resolution order:\n * 1. Module cache (cached after first call)\n * 2. `process.env.ENVIRONMENT`\n * 3. `-c environment=<value>` from process.argv\n * 4. `CDK_DEFAULT_ACCOUNT` → providerAccounts lookup\n * 5. `-c accountName=<value>` → providerAccounts lookup\n * 6. `\"unknown\"` (with warning)\n */\nexport function getEnvironment(): string {\n  if (cachedEnvironment !== undefined) {\n    return cachedEnvironment;\n  }\n\n  // 1. process.env.ENVIRONMENT\n  if (process.env.ENVIRONMENT) {\n    cachedEnvironment = process.env.ENVIRONMENT;\n    return cachedEnvironment;\n  }\n\n  // 2. -c environment=<value> from process.argv\n  const envFromArgv = parseContextArg(\"environment\");\n  if (envFromArgv) {\n    cachedEnvironment = envFromArgv;\n    return cachedEnvironment;\n  }\n\n  // 3. CDK_DEFAULT_ACCOUNT → providerAccounts lookup\n  const accountId = process.env.CDK_DEFAULT_ACCOUNT;\n  if (accountId) {\n    const env = resolveEnvironmentFromAccountId(accountId);\n    if (env) {\n      cachedEnvironment = env;\n      return cachedEnvironment;\n    }\n  }\n\n  // 4. -c accountName=<value> → providerAccounts lookup\n  const accountName = parseContextArg(\"accountName\");\n  if (accountName) {\n    const env = resolveEnvironmentFromAccountName(accountName);\n    if (env) {\n      cachedEnvironment = env;\n      return cachedEnvironment;\n    }\n  }\n\n  // 5. Fallback\n  console.warn(\n    \"[fjall] Could not determine environment. \" +\n      \"Set ENVIRONMENT env var or pass -c environment=<value>.\"\n  );\n  cachedEnvironment = \"unknown\";\n  return cachedEnvironment;\n}\n\n/**\n * Resolve an environment-specific value at CDK synth time.\n *\n * @param config - Object with `default` key and optional environment overrides\n * @returns The value for the current environment, or the default\n */\nexport function env<T>(config: EnvConfig<T>): T {\n  const environment = getEnvironment();\n\n  if (environment in config) {\n    return config[environment] as T;\n  }\n\n  return config.default;\n}\n\n/**\n * Reset the environment cache. For testing only.\n */\nexport function _resetEnvironmentCache(): void {\n  cachedEnvironment = undefined;\n}\n\n/**\n * Parse a `-c key=value` argument from process.argv.\n */\nfunction parseContextArg(key: string): string | undefined {\n  const args = process.argv;\n  for (let i = 0; i < args.length - 1; i++) {\n    if (args[i] === \"-c\") {\n      const parts = args[i + 1].split(\"=\");\n      if (parts[0] === key && parts.length >= 2) {\n        return parts.slice(1).join(\"=\");\n      }\n    }\n  }\n  return undefined;\n}\n\n/**\n * Look up environment from account ID via fjall config providerAccounts.\n */\nfunction resolveEnvironmentFromAccountId(\n  accountId: string\n): string | undefined {\n  try {\n    const config = FjallConfig.loadConfig();\n    const account = config.getProviderAccountById(accountId);\n    return account?.environment;\n  } catch (err) {\n    // Config may not exist yet (first deploy, CI). Caller falls back to next strategy.\n    if (process.env.FJALL_DEBUG) {\n      const msg = err instanceof Error ? err.message : String(err);\n      process.stderr.write(\n        `[fjall] Config lookup by accountId failed: ${msg}\\n`\n      );\n    }\n    return undefined;\n  }\n}\n\n/**\n * Look up environment from account name via fjall config providerAccounts.\n */\nfunction resolveEnvironmentFromAccountName(\n  accountName: string\n): string | undefined {\n  try {\n    const config = FjallConfig.loadConfig();\n    const account = config.getProviderAccount(accountName);\n    return account?.environment;\n  } catch (err) {\n    // Config may not exist yet (first deploy, CI). Caller falls back to next strategy.\n    if (process.env.FJALL_DEBUG) {\n      const msg = err instanceof Error ? err.message : String(err);\n      process.stderr.write(\n        `[fjall] Config lookup by accountName failed: ${msg}\\n`\n      );\n    }\n    return undefined;\n  }\n}\n"]}

package/dist/lib/utils/getConfig.d.ts

@@ -1,13 +1,8 @@
 import { type Account } from "@aws-sdk/client-organizations";
-export interface ICostAllocationTags {
-    TagKey: string;
-    Status: string;
-}
 export interface Config {
     region: string;
     environment: string;
     existingAccounts: Account[];
-    costAllocationTags: ICostAllocationTags[];
     accountId?: string;
     accountName?: string;
     accountIds?: Record<string, string>;

package/dist/lib/utils/getConfig.js

@@ -10,7 +10,6 @@ function getConfig(accountName) {
         region: process.env.AWS_REGION || "us-east-1",
         environment: "unknown",
         existingAccounts: [],
-        costAllocationTags: [],
         secondaryRegions: [],
         allRegions: []
     };
@@ -28,8 +27,6 @@ function getConfig(accountName) {
             config.accountIds[pa.name] = pa.id;
         }
     }
-    // Get cost allocation tags
-    config.costAllocationTags = fjallConfig.getCostAllocationTags();
     // Get regions configuration
     config.primaryRegion = fjallConfig.getPrimaryRegion();
     config.secondaryRegions = fjallConfig.getSecondaryRegions() || [];
@@ -72,4 +69,4 @@ function getConfig(accountName) {
     return config;
 }
 exports.default = getConfig;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0Q29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vbGliL3V0aWxzL2dldENvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQW1CQSw4QkF3RUM7QUF6RkQsZ0NBQXlCO0FBQ3pCLHNDQUFvRDtBQUNwRCx5REFBaUQ7QUFlakQsU0FBZ0IsU0FBUyxDQUFDLFdBQW9CO0lBQzVDLE1BQU0sR0FBRyxHQUFHLGFBQUcsQ0FBQyxXQUFXLEVBQUUsQ0FBQztJQUU5QixNQUFNLE1BQU0sR0FBVztRQUNyQixNQUFNLEVBQUUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxVQUFVLElBQUksV0FBVztRQUM3QyxXQUFXLEVBQUUsU0FBUztRQUN0QixnQkFBZ0IsRUFBRSxFQUFFO1FBQ3BCLGdCQUFnQixFQUFFLEVBQUU7UUFDcEIsVUFBVSxFQUFFLEVBQUU7S0FDZixDQUFDO0lBRUYsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsVUFBVTtRQUN6Qiw4QkFBVyxDQUFDLElBQUksQ0FBQyxnREFBZ0QsQ0FBQyxDQUFDO0lBRXJFLDJDQUEyQztJQUMzQyxNQUFNLFdBQVcsR0FBRyxhQUFXLENBQUMsVUFBVSxFQUFFLENBQUM7SUFFN0Msd0JBQXdCO0lBQ3hCLE1BQU0sQ0FBQyxnQkFBZ0IsR0FBRyxXQUFXLENBQUMsbUJBQW1CLEVBQUUsQ0FBQztJQUU1RCwyREFBMkQ7SUFDM0QsTUFBTSxnQkFBZ0IsR0FBRyxXQUFXLENBQUMsVUFBVSxDQUFDLGdCQUFnQixJQUFJLEVBQUUsQ0FBQztJQUN2RSxJQUFJLGdCQUFnQixDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUUsQ0FBQztRQUNoQyxNQUFNLENBQUMsVUFBVSxHQUFHLEVBQUUsQ0FBQztRQUN2QixLQUFLLE1BQU0sRUFBRSxJQUFJLGdCQUFnQixFQUFFLENBQUM7WUFDbEMsTUFBTSxDQUFDLFVBQVUsQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLEVBQUUsQ0FBQztRQUNyQyxDQUFDO0lBQ0gsQ0FBQztJQUVELDRCQUE0QjtJQUM1QixNQUFNLENBQUMsYUFBYSxHQUFHLFdBQVcsQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDO0lBQ3RELE1BQU0sQ0FBQyxnQkFBZ0IsR0FBRyxXQUFXLENBQUMsbUJBQW1CLEVBQUUsSUFBSSxFQUFFLENBQUM7SUFDbEUsTUFBTSxDQUFDLFVBQVUsR0FBRyxXQUFXLENBQUMsYUFBYSxFQUFFLENBQUM7SUFDaEQsTUFBTSxDQUFDLHNCQUFzQixHQUFHLFdBQVcsQ0FBQyx5QkFBeUIsRUFBRSxDQUFDO0lBRXhFLDZEQUE2RDtJQUM3RCxJQUFJLENBQUMsV0FBVztRQUFFLFdBQVcsR0FBRyxHQUFHLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxhQUFhLENBQUMsQ0FBQztJQUN0RSxvRUFBb0U7SUFDcEUsSUFBSSxXQUFXLEVBQUUsQ0FBQztRQUNoQixNQUFNLGVBQWUsR0FBRyxXQUFXLENBQUMsa0JBQWtCLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDcEUsSUFBSSxlQUFlLEVBQUUsQ0FBQztZQUNwQixNQUFNLENBQUMsU0FBUyxHQUFHLGVBQWUsQ0FBQyxFQUFFLENBQUM7WUFDdEMsTUFBTSxDQUFDLFdBQVcsR0FBRyxlQUFlLENBQUMsSUFBSSxDQUFDO1lBQzFDLE1BQU0sQ0FBQyxXQUFXLEdBQUcsZUFBZSxDQUFDLFdBQVcsQ0FBQztRQUNuRCxDQUFDO0lBQ0gsQ0FBQztJQUVELGtGQUFrRjtJQUNsRixJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBQ3hCLE1BQU0sU0FBUyxHQUFHLEdBQUcsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQ3RELHdFQUF3RTtRQUN4RSxJQUFJLFNBQVMsRUFBRSxDQUFDO1lBQ2QsTUFBTSxDQUFDLFNBQVMsR0FBRyxTQUFTLENBQUM7WUFFN0IsTUFBTSxlQUFlLEdBQUcsV0FBVyxDQUFDLHNCQUFzQixDQUFDLFNBQVMsQ0FBQyxDQUFDO1lBQ3RFLElBQUksZUFBZSxFQUFFLENBQUM7Z0JBQ3BCLE1BQU0sQ0FBQyxXQUFXLEdBQUcsZUFBZSxDQUFDLElBQUksQ0FBQztnQkFDMUMsTUFBTSxDQUFDLFdBQVcsR0FBRyxlQUFlLENBQUMsV0FBVyxDQUFDO1lBQ25ELENBQUM7UUFDSCxDQUFDO0lBQ0gsQ0FBQztJQUVELHdEQUF3RDtJQUN4RCxNQUFNLGtCQUFrQixHQUFHLEdBQUcsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLGFBQWEsQ0FBQyxDQUFDO0lBQ2pFLElBQUksa0JBQWtCLEVBQUUsQ0FBQztRQUN2QixNQUFNLENBQUMsV0FBVyxHQUFHLGtCQUFrQixDQUFDO0lBQzFDLENBQUM7U0FBTSxJQUFJLE9BQU8sQ0FBQyxHQUFHLENBQUMsV0FBVyxJQUFJLE1BQU0sQ0FBQyxXQUFXLEtBQUssU0FBUyxFQUFFLENBQUM7UUFDdkUsNkRBQTZEO1FBQzdELE1BQU0sQ0FBQyxXQUFXLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxXQUFXLENBQUM7SUFDL0MsQ0FBQztJQUVELE9BQU8sTUFBTSxDQUFDO0FBQ2hCLENBQUM7QUFFRCxrQkFBZSxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB0eXBlIEFjY291bnQgfSBmcm9tIFwiQGF3cy1zZGsvY2xpZW50LW9yZ2FuaXphdGlvbnNcIjtcblxuaW1wb3J0IEFwcCBmcm9tIFwiLi4vYXBwXCI7XG5pbXBvcnQgeyBDb25maWcgYXMgRmphbGxDb25maWcgfSBmcm9tIFwiQGZqYWxsL3V0aWxcIjtcbmltcG9ydCB7IEZqYWxsTG9nZ2VyIH0gZnJvbSBcIi4vdmFsaWRhdGlvbkxvZ2dlclwiO1xuXG5leHBvcnQgaW50ZXJmYWNlIENvbmZpZyB7XG4gIHJlZ2lvbjogc3RyaW5nO1xuICBlbnZpcm9ubWVudDogc3RyaW5nO1xuICBleGlzdGluZ0FjY291bnRzOiBBY2NvdW50W107XG4gIGFjY291bnRJZD86IHN0cmluZztcbiAgYWNjb3VudE5hbWU/OiBzdHJpbmc7XG4gIGFjY291bnRJZHM/OiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+O1xuICBwcmltYXJ5UmVnaW9uPzogc3RyaW5nO1xuICBzZWNvbmRhcnlSZWdpb25zOiBzdHJpbmdbXTtcbiAgYWxsUmVnaW9uczogc3RyaW5nW107XG4gIGRpc2FzdGVyUmVjb3ZlcnlSZWdpb24/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRDb25maWcoYWNjb3VudE5hbWU/OiBzdHJpbmcpOiBDb25maWcge1xuICBjb25zdCBhcHAgPSBBcHAuZ2V0SW5zdGFuY2UoKTtcblxuICBjb25zdCBjb25maWc6IENvbmZpZyA9IHtcbiAgICByZWdpb246IHByb2Nlc3MuZW52LkFXU19SRUdJT04gfHwgXCJ1cy1lYXN0LTFcIixcbiAgICBlbnZpcm9ubWVudDogXCJ1bmtub3duXCIsXG4gICAgZXhpc3RpbmdBY2NvdW50czogW10sXG4gICAgc2Vjb25kYXJ5UmVnaW9uczogW10sXG4gICAgYWxsUmVnaW9uczogW11cbiAgfTtcblxuICBpZiAoIXByb2Nlc3MuZW52LkFXU19SRUdJT04pXG4gICAgRmphbGxMb2dnZXIud2FybihcIkFXU19SRUdJT04gaXMgbm90IHNldCwgZGVmYXVsdGluZyB0byB1cy1lYXN0LTFcIik7XG5cbiAgLy8gUmV0cmlldmUgYW55IHByZS1leGlzdGluZyBhY2NvdW50IGNvbmZpZ1xuICBjb25zdCBmamFsbENvbmZpZyA9IEZqYWxsQ29uZmlnLmxvYWRDb25maWcoKTtcblxuICAvLyBHZXQgZXhpc3RpbmcgYWNjb3VudHNcbiAgY29uZmlnLmV4aXN0aW5nQWNjb3VudHMgPSBmamFsbENvbmZpZy5nZXRFeGlzdGluZ0FjY291bnRzKCk7XG5cbiAgLy8gQnVpbGQgYWNjb3VudCBJRHMgbWFwIGZyb20gcHJvdmlkZXIgYWNjb3VudHMgKG5hbWUg4oaSIGlkKVxuICBjb25zdCBwcm92aWRlckFjY291bnRzID0gZmphbGxDb25maWcucm9vdENvbmZpZy5wcm92aWRlckFjY291bnRzIHx8IFtdO1xuICBpZiAocHJvdmlkZXJBY2NvdW50cy5sZW5ndGggPiAwKSB7XG4gICAgY29uZmlnLmFjY291bnRJZHMgPSB7fTtcbiAgICBmb3IgKGNvbnN0IHBhIG9mIHByb3ZpZGVyQWNjb3VudHMpIHtcbiAgICAgIGNvbmZpZy5hY2NvdW50SWRzW3BhLm5hbWVdID0gcGEuaWQ7XG4gICAgfVxuICB9XG5cbiAgLy8gR2V0IHJlZ2lvbnMgY29uZmlndXJhdGlvblxuICBjb25maWcucHJpbWFyeVJlZ2lvbiA9IGZqYWxsQ29uZmlnLmdldFByaW1hcnlSZWdpb24oKTtcbiAgY29uZmlnLnNlY29uZGFyeVJlZ2lvbnMgPSBmamFsbENvbmZpZy5nZXRTZWNvbmRhcnlSZWdpb25zKCkgfHwgW107XG4gIGNvbmZpZy5hbGxSZWdpb25zID0gZmphbGxDb25maWcuZ2V0QWxsUmVnaW9ucygpO1xuICBjb25maWcuZGlzYXN0ZXJSZWNvdmVyeVJlZ2lvbiA9IGZqYWxsQ29uZmlnLmdldERpc2FzdGVyUmVjb3ZlcnlSZWdpb24oKTtcblxuICAvLyBJZiB1bnNwZWNpZmllZCBhY2NvdW50IG5hbWUgLSB0cnkgdG8gcmV0cmlldmUgZnJvbSBjb250ZXh0XG4gIGlmICghYWNjb3VudE5hbWUpIGFjY291bnROYW1lID0gYXBwLm5vZGUudHJ5R2V0Q29udGV4dChcImFjY291bnROYW1lXCIpO1xuICAvLyBJZiB3ZSBoYXZlIGFuIGFjY291bnQgbmFtZSAtIGxvb2sgZm9yIGFzc29jaWF0ZWQgcHJvdmlkZXIgYWNjb3VudFxuICBpZiAoYWNjb3VudE5hbWUpIHtcbiAgICBjb25zdCBwcm92aWRlckFjY291bnQgPSBmamFsbENvbmZpZy5nZXRQcm92aWRlckFjY291bnQoYWNjb3VudE5hbWUpO1xuICAgIGlmIChwcm92aWRlckFjY291bnQpIHtcbiAgICAgIGNvbmZpZy5hY2NvdW50SWQgPSBwcm92aWRlckFjY291bnQuaWQ7XG4gICAgICBjb25maWcuYWNjb3VudE5hbWUgPSBwcm92aWRlckFjY291bnQubmFtZTtcbiAgICAgIGNvbmZpZy5lbnZpcm9ubWVudCA9IHByb3ZpZGVyQWNjb3VudC5lbnZpcm9ubWVudDtcbiAgICB9XG4gIH1cblxuICAvLyBJZiB3ZSBzdGlsbCBkb24ndCBoYXZlIGFuIGFjY291bnQgbmFtZSAtIHRyeSB0byByZXRyaWV2ZSBhY2NvdW50SWQgZnJvbSBjb250ZXh0XG4gIGlmICghY29uZmlnLmFjY291bnROYW1lKSB7XG4gICAgY29uc3QgYWNjb3VudElkID0gYXBwLm5vZGUudHJ5R2V0Q29udGV4dChcImFjY291bnRJZFwiKTtcbiAgICAvLyBJZiB3ZSBmaW5kIGFuIGFjY291bnRJZCAtIHJldHJpZXZlIHRoZSBhc3NvY2lhdGVkIGFjY291bnQgZnJvbSBjb25maWdcbiAgICBpZiAoYWNjb3VudElkKSB7XG4gICAgICBjb25maWcuYWNjb3VudElkID0gYWNjb3VudElkO1xuXG4gICAgICBjb25zdCBwcm92aWRlckFjY291bnQgPSBmamFsbENvbmZpZy5nZXRQcm92aWRlckFjY291bnRCeUlkKGFjY291bnRJZCk7XG4gICAgICBpZiAocHJvdmlkZXJBY2NvdW50KSB7XG4gICAgICAgIGNvbmZpZy5hY2NvdW50TmFtZSA9IHByb3ZpZGVyQWNjb3VudC5uYW1lO1xuICAgICAgICBjb25maWcuZW52aXJvbm1lbnQgPSBwcm92aWRlckFjY291bnQuZW52aXJvbm1lbnQ7XG4gICAgICB9XG4gICAgfVxuICB9XG5cbiAgLy8gQ2hlY2sgZm9yIGVudmlyb25tZW50IGZyb20gY29udGV4dCAoaGlnaGVzdCBwcmlvcml0eSlcbiAgY29uc3QgY29udGV4dEVudmlyb25tZW50ID0gYXBwLm5vZGUudHJ5R2V0Q29udGV4dChcImVudmlyb25tZW50XCIpO1xuICBpZiAoY29udGV4dEVudmlyb25tZW50KSB7XG4gICAgY29uZmlnLmVudmlyb25tZW50ID0gY29udGV4dEVudmlyb25tZW50O1xuICB9IGVsc2UgaWYgKHByb2Nlc3MuZW52LkVOVklST05NRU5UICYmIGNvbmZpZy5lbnZpcm9ubWVudCA9PT0gXCJ1bmtub3duXCIpIHtcbiAgICAvLyBGYWxsIGJhY2sgdG8gRU5WSVJPTk1FTlQgdmFyaWFibGUgaWYgbm8gb3RoZXIgc291cmNlIGZvdW5kXG4gICAgY29uZmlnLmVudmlyb25tZW50ID0gcHJvY2Vzcy5lbnYuRU5WSVJPTk1FTlQ7XG4gIH1cblxuICByZXR1cm4gY29uZmlnO1xufVxuXG5leHBvcnQgZGVmYXVsdCBnZXRDb25maWc7XG4iXX0=

package/dist/lib/utils/index.d.ts

@@ -1,5 +1,11 @@
+export * from "./backupTierMapping";
 export * from "./capitaliseString";
+export * from "./connections";
+export * from "./databaseTypes";
 export * from "./getConfig";
+export * from "./removalPolicy";
 export * from "./resourceNaming";
 export * from "./standardTagsAspect";
 export * from "./validationLogger";
+export * from "./env";
+export * from "./vpcUtils";

package/dist/lib/utils/index.js

@@ -14,9 +14,15 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./backupTierMapping"), exports);
 __exportStar(require("./capitaliseString"), exports);
+__exportStar(require("./connections"), exports);
+__exportStar(require("./databaseTypes"), exports);
 __exportStar(require("./getConfig"), exports);
+__exportStar(require("./removalPolicy"), exports);
 __exportStar(require("./resourceNaming"), exports);
 __exportStar(require("./standardTagsAspect"), exports);
 __exportStar(require("./validationLogger"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHFEQUFtQztBQUNuQyw4Q0FBNEI7QUFDNUIsbURBQWlDO0FBQ2pDLHVEQUFxQztBQUNyQyxxREFBbUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9jYXBpdGFsaXNlU3RyaW5nXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9nZXRDb25maWdcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3Jlc291cmNlTmFtaW5nXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zdGFuZGFyZFRhZ3NBc3BlY3RcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3ZhbGlkYXRpb25Mb2dnZXJcIjtcbiJdfQ==
+__exportStar(require("./env"), exports);
+__exportStar(require("./vpcUtils"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHNEQUFvQztBQUNwQyxxREFBbUM7QUFDbkMsZ0RBQThCO0FBQzlCLGtEQUFnQztBQUNoQyw4Q0FBNEI7QUFDNUIsa0RBQWdDO0FBQ2hDLG1EQUFpQztBQUNqQyx1REFBcUM7QUFDckMscURBQW1DO0FBQ25DLHdDQUFzQjtBQUN0Qiw2Q0FBMkIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9iYWNrdXBUaWVyTWFwcGluZ1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vY2FwaXRhbGlzZVN0cmluZ1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29ubmVjdGlvbnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RhdGFiYXNlVHlwZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2dldENvbmZpZ1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vcmVtb3ZhbFBvbGljeVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vcmVzb3VyY2VOYW1pbmdcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3N0YW5kYXJkVGFnc0FzcGVjdFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdmFsaWRhdGlvbkxvZ2dlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZW52XCI7XG5leHBvcnQgKiBmcm9tIFwiLi92cGNVdGlsc1wiO1xuIl19

package/dist/lib/utils/removalPolicy.d.ts

@@ -0,0 +1,2 @@
+import { RemovalPolicy } from "aws-cdk-lib";
+export declare function toRemovalPolicy(value?: "DESTROY" | "RETAIN" | "SNAPSHOT"): RemovalPolicy;

package/dist/lib/utils/removalPolicy.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRemovalPolicy = toRemovalPolicy;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+function toRemovalPolicy(value) {
+    switch (value) {
+        case "DESTROY":
+            return aws_cdk_lib_1.RemovalPolicy.DESTROY;
+        case "SNAPSHOT":
+            return aws_cdk_lib_1.RemovalPolicy.SNAPSHOT;
+        case "RETAIN":
+        default:
+            return aws_cdk_lib_1.RemovalPolicy.RETAIN;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3ZhbFBvbGljeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi91dGlscy9yZW1vdmFsUG9saWN5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBRUEsMENBWUM7QUFkRCw2Q0FBNEM7QUFFNUMsU0FBZ0IsZUFBZSxDQUM3QixLQUF5QztJQUV6QyxRQUFRLEtBQUssRUFBRSxDQUFDO1FBQ2QsS0FBSyxTQUFTO1lBQ1osT0FBTywyQkFBYSxDQUFDLE9BQU8sQ0FBQztRQUMvQixLQUFLLFVBQVU7WUFDYixPQUFPLDJCQUFhLENBQUMsUUFBUSxDQUFDO1FBQ2hDLEtBQUssUUFBUSxDQUFDO1FBQ2Q7WUFDRSxPQUFPLDJCQUFhLENBQUMsTUFBTSxDQUFDO0lBQ2hDLENBQUM7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmVtb3ZhbFBvbGljeSB9IGZyb20gXCJhd3MtY2RrLWxpYlwiO1xuXG5leHBvcnQgZnVuY3Rpb24gdG9SZW1vdmFsUG9saWN5KFxuICB2YWx1ZT86IFwiREVTVFJPWVwiIHwgXCJSRVRBSU5cIiB8IFwiU05BUFNIT1RcIlxuKTogUmVtb3ZhbFBvbGljeSB7XG4gIHN3aXRjaCAodmFsdWUpIHtcbiAgICBjYXNlIFwiREVTVFJPWVwiOlxuICAgICAgcmV0dXJuIFJlbW92YWxQb2xpY3kuREVTVFJPWTtcbiAgICBjYXNlIFwiU05BUFNIT1RcIjpcbiAgICAgIHJldHVybiBSZW1vdmFsUG9saWN5LlNOQVBTSE9UO1xuICAgIGNhc2UgXCJSRVRBSU5cIjpcbiAgICBkZWZhdWx0OlxuICAgICAgcmV0dXJuIFJlbW92YWxQb2xpY3kuUkVUQUlOO1xuICB9XG59XG4iXX0=

package/dist/lib/utils/standardTagsAspect.d.ts

@@ -23,6 +23,10 @@ export declare class StandardTagsAspect implements IAspect {
     private addIpamPoolTag;
     /**
      * Add disaster recovery tier tag to S3 buckets with backupVaultTier property.
+     * This serves as a per-resource override when `backupVaultTier` is set on a
+     * specific S3 bucket. CDK child tags override parent tags, so this takes
+     * precedence over the app-level backup tag set via `App.getApp({ backup })`.
+     *
      * Tag format: fjall:disasterRecovery:tier = "{tier}"
      *
      * Tier mapping: