@fjall/components-infrastructure 0.86.1 → 0.87.3

package/dist/lib/utils/manifestWriter.js

@@ -0,0 +1,233 @@
+"use strict";
+/**
+ * Fjall Manifest Writer.
+ *
+ * Writes a manifest file during CDK synthesis that contains resolved service
+ * configuration, pattern details, and template hashes. This replaces fragile
+ * AST parsing of infrastructure.ts in the CLI.
+ *
+ * The manifest is written to cdk.out/fjall-manifest.json after synthesis.
+ *
+ * NOTE: This file uses synchronous file operations (writeFileSync, readFileSync, etc.)
+ * because CDK synthesis is inherently synchronous. The synth() method blocks until
+ * complete, so async operations would provide no benefit and add complexity.
+ *
+ * TYPE DUPLICATION NOTE: The interfaces below (ManifestService, ManifestPattern, etc.)
+ * are mirrored by Zod schemas in cli/src/types/FjallManifest.ts. The CLI schemas are
+ * the authoritative source for validation. If you modify these interfaces, update
+ * the Zod schemas to match. Future work: extract to shared @fjall/types package.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManifestCollector = void 0;
+exports.writeManifest = writeManifest;
+exports.readExistingManifest = readExistingManifest;
+exports.getManifestCollector = getManifestCollector;
+exports.getCurrentCollector = getCurrentCollector;
+exports.resetManifestCollector = resetManifestCollector;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const crypto_1 = require("crypto");
+const validationLogger_js_1 = require("./validationLogger.js");
+/** Current manifest schema version. Must match MANIFEST_SCHEMA_VERSION in CLI's FjallManifest.ts */
+const MANIFEST_SCHEMA_VERSION = 1;
+/** Manifest file name */
+const MANIFEST_FILE_NAME = "fjall-manifest.json";
+/**
+ * Collected manifest data during synthesis.
+ * Stores all data that will be written to the manifest file.
+ */
+class ManifestCollector {
+    constructor(appName) {
+        this.services = [];
+        this.lambdas = [];
+        this.appName = appName;
+    }
+    /**
+     * Add a service configuration.
+     */
+    addService(service) {
+        if (!this.services.some((s) => s.name === service.name)) {
+            this.services.push(service);
+        }
+    }
+    /**
+     * Add a Lambda function configuration.
+     */
+    addLambda(lambda) {
+        if (!this.lambdas.some((l) => l.name === lambda.name)) {
+            this.lambdas.push(lambda);
+        }
+    }
+    /**
+     * Set the pattern configuration.
+     */
+    setPattern(pattern) {
+        this.pattern = pattern;
+    }
+    /**
+     * Set the ECR repository configuration.
+     */
+    setEcr(ecr) {
+        this.ecr = ecr;
+    }
+    /**
+     * Get collected services.
+     */
+    getServices() {
+        return this.services;
+    }
+    /**
+     * Get collected Lambda functions.
+     */
+    getLambdas() {
+        return this.lambdas;
+    }
+    /**
+     * Get pattern configuration.
+     */
+    getPattern() {
+        return this.pattern;
+    }
+    /**
+     * Get ECR configuration.
+     */
+    getEcr() {
+        return this.ecr;
+    }
+    /**
+     * Get the application name.
+     */
+    getAppName() {
+        return this.appName;
+    }
+}
+exports.ManifestCollector = ManifestCollector;
+/**
+ * Compute SHA-256 hash of a CloudFormation template file.
+ * Normalises JSON to ensure consistent hashes.
+ */
+function computeTemplateHash(templatePath) {
+    try {
+        const content = (0, fs_1.readFileSync)(templatePath, "utf-8");
+        const normalised = JSON.stringify(JSON.parse(content));
+        return (0, crypto_1.createHash)("sha256").update(normalised).digest("hex");
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        validationLogger_js_1.FjallLogger.warn(`Failed to compute hash for ${templatePath}: ${errorMessage}`);
+        return null;
+    }
+}
+/**
+ * Find all template files in cdk.out and compute their hashes.
+ */
+function computeStackHashes(cdkOutPath) {
+    const stacks = {};
+    const synthTimestamp = new Date().toISOString();
+    try {
+        const files = (0, fs_1.readdirSync)(cdkOutPath);
+        const templateFiles = files.filter((f) => f.endsWith(".template.json"));
+        for (const templateFile of templateFiles) {
+            const templatePath = (0, path_1.join)(cdkOutPath, templateFile);
+            const stackName = (0, path_1.basename)(templateFile, ".template.json");
+            const hash = computeTemplateHash(templatePath);
+            if (hash) {
+                stacks[stackName] = {
+                    templateHash: hash,
+                    synthTimestamp
+                };
+            }
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        validationLogger_js_1.FjallLogger.warn(`Failed to read cdk.out for hash computation: ${errorMessage}`);
+    }
+    return stacks;
+}
+/**
+ * Write the manifest file to cdk.out.
+ *
+ * @param assembly - The CloudAssembly from synth
+ * @param collector - The manifest collector with service data
+ */
+function writeManifest(assembly, collector) {
+    const cdkOutPath = assembly.directory;
+    const manifestPath = (0, path_1.join)(cdkOutPath, MANIFEST_FILE_NAME);
+    const stacks = computeStackHashes(cdkOutPath);
+    const manifest = {
+        version: MANIFEST_SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        appName: collector.getAppName(),
+        services: collector.getServices(),
+        lambdas: collector.getLambdas(),
+        stacks
+    };
+    const pattern = collector.getPattern();
+    if (pattern) {
+        manifest.pattern = pattern;
+    }
+    const ecr = collector.getEcr();
+    if (ecr) {
+        manifest.ecr = ecr;
+    }
+    try {
+        (0, fs_1.writeFileSync)(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+        validationLogger_js_1.FjallLogger.info(`Fjall manifest written to ${manifestPath}`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        validationLogger_js_1.FjallLogger.warn(`Failed to write Fjall manifest: ${errorMessage}`);
+    }
+}
+/**
+ * Read an existing manifest file (for preserving deployment history).
+ */
+function readExistingManifest(cdkOutPath) {
+    const manifestPath = (0, path_1.join)(cdkOutPath, MANIFEST_FILE_NAME);
+    if (!(0, fs_1.existsSync)(manifestPath)) {
+        return null;
+    }
+    try {
+        const content = (0, fs_1.readFileSync)(manifestPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        validationLogger_js_1.FjallLogger.warn(`Failed to parse existing manifest: ${message}`);
+        return null;
+    }
+}
+/**
+ * Global manifest collector instance.
+ *
+ * CDK's architecture guarantees one App per process, so a global singleton is safe here.
+ * The collector is created when App is constructed and used throughout synthesis.
+ * resetManifestCollector() is provided for testing scenarios where multiple Apps
+ * may be created in the same process.
+ */
+let globalCollector = null;
+/**
+ * Get or create the global manifest collector.
+ * Called by App during construction to initialise the collector.
+ */
+function getManifestCollector(appName) {
+    if (!globalCollector || globalCollector.getAppName() !== appName) {
+        globalCollector = new ManifestCollector(appName);
+    }
+    return globalCollector;
+}
+/**
+ * Get the current global manifest collector.
+ * Returns null if not initialised.
+ */
+function getCurrentCollector() {
+    return globalCollector;
+}
+/**
+ * Reset the global collector (for testing).
+ */
+function resetManifestCollector() {
+    globalCollector = null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manifestWriter.js","sourceRoot":"","sources":["../../../lib/utils/manifestWriter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Fjall Manifest Writer.\n *\n * Writes a manifest file during CDK synthesis that contains resolved service\n * configuration, pattern details, and template hashes. This replaces fragile\n * AST parsing of infrastructure.ts in the CLI.\n *\n * The manifest is written to cdk.out/fjall-manifest.json after synthesis.\n *\n * NOTE: This file uses synchronous file operations (writeFileSync, readFileSync, etc.)\n * because CDK synthesis is inherently synchronous. The synth() method blocks until\n * complete, so async operations would provide no benefit and add complexity.\n *\n * TYPE DUPLICATION NOTE: The interfaces below (ManifestService, ManifestPattern, etc.)\n * are mirrored by Zod schemas in cli/src/types/FjallManifest.ts. The CLI schemas are\n * the authoritative source for validation. If you modify these interfaces, update\n * the Zod schemas to match. Future work: extract to shared @fjall/types package.\n */\n\nimport { writeFileSync, readFileSync, existsSync, readdirSync } from \"fs\";\nimport { join, basename } from \"path\";\nimport { createHash } from \"crypto\";\nimport type { CloudAssembly } from \"aws-cdk-lib/cx-api\";\n\nimport { FjallLogger } from \"./validationLogger.js\";\n\n/** Current manifest schema version. Must match MANIFEST_SCHEMA_VERSION in CLI's FjallManifest.ts */\nconst MANIFEST_SCHEMA_VERSION = 1 as const;\n\n/**\n * Service configuration extracted from ECS services.\n */\nexport interface ManifestService {\n  /** Service name (must match ECS service name) */\n  name: string;\n  /** Cluster name this service belongs to */\n  clusterName?: string;\n  /** Path to Dockerfile relative to app root */\n  dockerfilePath?: string;\n  /** Docker build target for multi-stage builds */\n  dockerTarget?: string;\n  /** Container port */\n  containerPort?: number;\n  /** SSM secrets configured for this service (aggregated from all containers) */\n  secrets?: string[];\n  /** SSM secrets path (derived or explicit) */\n  ssmSecretsPath?: string;\n}\n\n/**\n * Pattern configuration extracted from PatternFactory.\n */\nexport interface ManifestPattern {\n  /** Pattern type */\n  type: \"payload\";\n  /** Pattern name (CMS name) */\n  name: string;\n  /** Source directory containing build output */\n  source: string;\n}\n\n/**\n * ECR configuration.\n */\nexport interface ManifestEcr {\n  /** ECR repository name */\n  repositoryName: string;\n}\n\n/**\n * Lambda function configuration extracted from Lambda compute.\n * Enables CLI discovery of Lambda functions for secrets management.\n */\nexport interface ManifestLambda {\n  /** Lambda function name (construct ID) */\n  name: string;\n  /** SSM secrets configured for this Lambda */\n  secrets?: string[];\n  /** SSM secrets path (derived or explicit) */\n  ssmSecretsPath?: string;\n}\n\n/**\n * Stack hash entry computed from synthesised template.\n */\nexport interface ManifestStackHash {\n  /** SHA-256 hash of the synthesised template */\n  templateHash: string;\n  /** ISO timestamp when synth completed */\n  synthTimestamp: string;\n}\n\n/**\n * Fjall manifest - generated during CDK synth.\n */\nexport interface FjallManifest {\n  /** Schema version for future compatibility */\n  version: typeof MANIFEST_SCHEMA_VERSION;\n  /** ISO timestamp when manifest was generated */\n  generatedAt: string;\n  /** Application name */\n  appName: string;\n  /** Resolved service configurations */\n  services: ManifestService[];\n  /** Lambda function configurations */\n  lambdas: ManifestLambda[];\n  /** Pattern configuration (if using PatternFactory) */\n  pattern?: ManifestPattern;\n  /** ECR configuration */\n  ecr?: ManifestEcr;\n  /** Template hashes by stack name */\n  stacks: Record<string, ManifestStackHash>;\n}\n\n/** Manifest file name */\nconst MANIFEST_FILE_NAME = \"fjall-manifest.json\";\n\n/**\n * Collected manifest data during synthesis.\n * Stores all data that will be written to the manifest file.\n */\nexport class ManifestCollector {\n  private services: ManifestService[] = [];\n  private lambdas: ManifestLambda[] = [];\n  private pattern?: ManifestPattern;\n  private ecr?: ManifestEcr;\n  private appName: string;\n\n  constructor(appName: string) {\n    this.appName = appName;\n  }\n\n  /**\n   * Add a service configuration.\n   */\n  addService(service: ManifestService): void {\n    if (!this.services.some((s) => s.name === service.name)) {\n      this.services.push(service);\n    }\n  }\n\n  /**\n   * Add a Lambda function configuration.\n   */\n  addLambda(lambda: ManifestLambda): void {\n    if (!this.lambdas.some((l) => l.name === lambda.name)) {\n      this.lambdas.push(lambda);\n    }\n  }\n\n  /**\n   * Set the pattern configuration.\n   */\n  setPattern(pattern: ManifestPattern): void {\n    this.pattern = pattern;\n  }\n\n  /**\n   * Set the ECR repository configuration.\n   */\n  setEcr(ecr: ManifestEcr): void {\n    this.ecr = ecr;\n  }\n\n  /**\n   * Get collected services.\n   */\n  getServices(): ManifestService[] {\n    return this.services;\n  }\n\n  /**\n   * Get collected Lambda functions.\n   */\n  getLambdas(): ManifestLambda[] {\n    return this.lambdas;\n  }\n\n  /**\n   * Get pattern configuration.\n   */\n  getPattern(): ManifestPattern | undefined {\n    return this.pattern;\n  }\n\n  /**\n   * Get ECR configuration.\n   */\n  getEcr(): ManifestEcr | undefined {\n    return this.ecr;\n  }\n\n  /**\n   * Get the application name.\n   */\n  getAppName(): string {\n    return this.appName;\n  }\n}\n\n/**\n * Compute SHA-256 hash of a CloudFormation template file.\n * Normalises JSON to ensure consistent hashes.\n */\nfunction computeTemplateHash(templatePath: string): string | null {\n  try {\n    const content = readFileSync(templatePath, \"utf-8\");\n    const normalised = JSON.stringify(JSON.parse(content));\n    return createHash(\"sha256\").update(normalised).digest(\"hex\");\n  } catch (error) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    FjallLogger.warn(\n      `Failed to compute hash for ${templatePath}: ${errorMessage}`\n    );\n    return null;\n  }\n}\n\n/**\n * Find all template files in cdk.out and compute their hashes.\n */\nfunction computeStackHashes(\n  cdkOutPath: string\n): Record<string, ManifestStackHash> {\n  const stacks: Record<string, ManifestStackHash> = {};\n  const synthTimestamp = new Date().toISOString();\n\n  try {\n    const files = readdirSync(cdkOutPath);\n    const templateFiles = files.filter((f) => f.endsWith(\".template.json\"));\n\n    for (const templateFile of templateFiles) {\n      const templatePath = join(cdkOutPath, templateFile);\n      const stackName = basename(templateFile, \".template.json\");\n      const hash = computeTemplateHash(templatePath);\n\n      if (hash) {\n        stacks[stackName] = {\n          templateHash: hash,\n          synthTimestamp\n        };\n      }\n    }\n  } catch (error) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    FjallLogger.warn(\n      `Failed to read cdk.out for hash computation: ${errorMessage}`\n    );\n  }\n\n  return stacks;\n}\n\n/**\n * Write the manifest file to cdk.out.\n *\n * @param assembly - The CloudAssembly from synth\n * @param collector - The manifest collector with service data\n */\nexport function writeManifest(\n  assembly: CloudAssembly,\n  collector: ManifestCollector\n): void {\n  const cdkOutPath = assembly.directory;\n  const manifestPath = join(cdkOutPath, MANIFEST_FILE_NAME);\n\n  const stacks = computeStackHashes(cdkOutPath);\n\n  const manifest: FjallManifest = {\n    version: MANIFEST_SCHEMA_VERSION,\n    generatedAt: new Date().toISOString(),\n    appName: collector.getAppName(),\n    services: collector.getServices(),\n    lambdas: collector.getLambdas(),\n    stacks\n  };\n\n  const pattern = collector.getPattern();\n  if (pattern) {\n    manifest.pattern = pattern;\n  }\n\n  const ecr = collector.getEcr();\n  if (ecr) {\n    manifest.ecr = ecr;\n  }\n\n  try {\n    writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), \"utf-8\");\n    FjallLogger.info(`Fjall manifest written to ${manifestPath}`);\n  } catch (error) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    FjallLogger.warn(`Failed to write Fjall manifest: ${errorMessage}`);\n  }\n}\n\n/**\n * Read an existing manifest file (for preserving deployment history).\n */\nexport function readExistingManifest(cdkOutPath: string): FjallManifest | null {\n  const manifestPath = join(cdkOutPath, MANIFEST_FILE_NAME);\n\n  if (!existsSync(manifestPath)) {\n    return null;\n  }\n\n  try {\n    const content = readFileSync(manifestPath, \"utf-8\");\n    return JSON.parse(content) as FjallManifest;\n  } catch (error) {\n    const message = error instanceof Error ? error.message : String(error);\n    FjallLogger.warn(`Failed to parse existing manifest: ${message}`);\n    return null;\n  }\n}\n\n/**\n * Global manifest collector instance.\n *\n * CDK's architecture guarantees one App per process, so a global singleton is safe here.\n * The collector is created when App is constructed and used throughout synthesis.\n * resetManifestCollector() is provided for testing scenarios where multiple Apps\n * may be created in the same process.\n */\nlet globalCollector: ManifestCollector | null = null;\n\n/**\n * Get or create the global manifest collector.\n * Called by App during construction to initialise the collector.\n */\nexport function getManifestCollector(appName: string): ManifestCollector {\n  if (!globalCollector || globalCollector.getAppName() !== appName) {\n    globalCollector = new ManifestCollector(appName);\n  }\n  return globalCollector;\n}\n\n/**\n * Get the current global manifest collector.\n * Returns null if not initialised.\n */\nexport function getCurrentCollector(): ManifestCollector | null {\n  return globalCollector;\n}\n\n/**\n * Reset the global collector (for testing).\n */\nexport function resetManifestCollector(): void {\n  globalCollector = null;\n}\n"]}

package/dist/lib/utils/standardTagsAspect.js

@@ -20,25 +20,20 @@ class StandardTagsAspect {
         this.processedResources = new WeakSet();
     }
     visit(node) {
-        // Skip if already processed
         if (this.processedResources.has(node)) {
             return;
         }
-        // Process L1 (CFN) resources only
         if (!aws_cdk_lib_1.CfnResource.isCfnResource(node)) {
             return;
         }
         const resource = node;
         this.processedResources.add(node);
-        // Skip SecretRotation resources as they create nested stacks
         if (resource.node.path.includes("SecretRotation")) {
             return;
         }
-        // Add IPAM pool tag for VPCs with IPAM configuration
         if (resource.cfnResourceType === "AWS::EC2::VPC") {
             this.addIpamPoolTag(resource);
         }
-        // Add disaster recovery tier tag for S3 buckets with backupVaultTier
         if (resource.cfnResourceType === "AWS::S3::Bucket") {
             this.addBackupTierTag(resource);
         }
@@ -71,10 +66,8 @@ class StandardTagsAspect {
      * - enterprise -> "enterprise"
      */
     addBackupTierTag(resource) {
-        // Walk up the construct tree to find the L2 S3Bucket construct
         let construct = resource;
         while (construct) {
-            // Check if this is our custom S3Bucket class with backupVaultTier property
             const backupConstruct = construct;
             if (backupConstruct.backupVaultTier) {
                 const tier = backupConstruct.backupVaultTier;
@@ -92,4 +85,4 @@ class StandardTagsAspect {
     }
 }
 exports.StandardTagsAspect = StandardTagsAspect;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,34 @@
+/**
+ * Fjall validation logging utilities.
+ * Centralises warning and info messages for consistent formatting.
+ * Also writes to JSONL file for debugging and support.
+ */
+export declare const FjallLogger: {
+    /**
+     * Log a warning message with Fjall prefix.
+     */
+    readonly warn: (message: string) => void;
+    /**
+     * Log an info message with Fjall prefix.
+     */
+    readonly info: (message: string) => void;
+};
+/**
+ * Warn if a property is set but will be ignored for the given type.
+ * Used across factories to alert users about type-specific properties.
+ *
+ * @param props - The props object with a `type` discriminator
+ * @param property - The property name to check
+ * @param applicableType - The type(s) where this property is used
+ * @param typeName - Human-readable type name for the message
+ */
+export declare function warnIfPropertyIgnored<T extends {
+    type: string;
+}>(props: T, property: string, applicableType: string | string[], typeName: string): void;
+/**
+ * Warn if any of the specified properties are set but will be ignored.
+ * Convenience wrapper for checking multiple properties at once.
+ */
+export declare function warnIfPropertiesIgnored<T extends {
+    type: string;
+}>(props: T, properties: string[], applicableType: string | string[], typeName: string): void;

package/dist/lib/utils/validationLogger.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Fjall validation logging utilities.
+ * Centralises warning and info messages for consistent formatting.
+ * Also writes to JSONL file for debugging and support.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FjallLogger = void 0;
+exports.warnIfPropertyIgnored = warnIfPropertyIgnored;
+exports.warnIfPropertiesIgnored = warnIfPropertiesIgnored;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const LOG_DIR = process.env.FJALL_LOG_DIR ?? (0, path_1.join)((0, os_1.homedir)(), ".fjall", "logs");
+const LOG_FILE = (0, path_1.join)(LOG_DIR, "infrastructure.jsonl");
+/**
+ * Write a log entry to the infrastructure JSONL file
+ */
+function writeToLog(level, message) {
+    try {
+        if (!(0, fs_1.existsSync)(LOG_DIR)) {
+            (0, fs_1.mkdirSync)(LOG_DIR, { recursive: true });
+        }
+        const entry = JSON.stringify({
+            timestamp: new Date().toISOString(),
+            level,
+            component: "Infrastructure",
+            message,
+            source: "cdk-subprocess"
+        });
+        (0, fs_1.appendFileSync)(LOG_FILE, entry + "\n");
+    }
+    catch {
+        // Never crash CDK on logging failure
+    }
+}
+exports.FjallLogger = {
+    /**
+     * Log a warning message with Fjall prefix.
+     */
+    warn: (message) => {
+        console.warn(`[Fjall] Warning: ${message}`);
+        writeToLog("warn", message);
+    },
+    /**
+     * Log an info message with Fjall prefix.
+     */
+    info: (message) => {
+        console.info(`[Fjall] Note: ${message}`);
+        writeToLog("info", message);
+    }
+};
+/**
+ * Warn if a property is set but will be ignored for the given type.
+ * Used across factories to alert users about type-specific properties.
+ *
+ * @param props - The props object with a `type` discriminator
+ * @param property - The property name to check
+ * @param applicableType - The type(s) where this property is used
+ * @param typeName - Human-readable type name for the message
+ */
+function warnIfPropertyIgnored(props, property, applicableType, typeName) {
+    const propsRecord = props;
+    const types = Array.isArray(applicableType)
+        ? applicableType
+        : [applicableType];
+    if (!types.includes(props.type) &&
+        property in propsRecord &&
+        propsRecord[property] !== undefined) {
+        exports.FjallLogger.warn(`'${property}' is only used for ${typeName} type. ` +
+            `It will be ignored for type '${props.type}'.`);
+    }
+}
+/**
+ * Warn if any of the specified properties are set but will be ignored.
+ * Convenience wrapper for checking multiple properties at once.
+ */
+function warnIfPropertiesIgnored(props, properties, applicableType, typeName) {
+    for (const property of properties) {
+        warnIfPropertyIgnored(props, property, applicableType, typeName);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fjall/components-infrastructure",
-  "version": "0.86.1",
+  "version": "0.87.3",
   "bin": {
     "infrastructure": "bin/infrastructure.js"
   },
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "@aws-sdk/client-organizations": "^3.716.0",
-    "@fjall/util": "^0.86.1",
+    "@fjall/util": "^0.87.3",
     "@pepperize/cdk-organizations": "^0.7.135",
     "cdk-time-sleep": "^1.0.0",
     "constructs": "^10.0.0",
@@ -45,7 +45,7 @@
   "overrides": {
     "@smithy/core": "2.5.5"
   },
-  "gitHead": "18fcab64c8b43a0507191d418592f3cda68fe6c6",
+  "gitHead": "be3b6f5bee0c9d1fe50e0be4816ffd87eb07e4c4",
   "peerDependencies": {
     "aws-cdk": "^2.206.0",
     "aws-cdk-lib": "^2.206.0",

package/dist/lib/__tests__/setup.d.ts

@@ -1,48 +0,0 @@
-import { App } from "aws-cdk-lib";
-import { Template } from "aws-cdk-lib/assertions";
-import { Stack } from "aws-cdk-lib";
-/**
- * Test utilities for CDK infrastructure testing
- */
-export declare class TestUtils {
-    /**
-     * Create a test app with proper environment settings
-     */
-    static createTestApp(): App;
-    /**
-     * Create a test stack within a test app
-     */
-    static createTestStack(app?: App): Stack;
-    /**
-     * Get CloudFormation template from a stack for assertions
-     */
-    static getTemplate(stack: Stack): Template;
-    /**
-     * Generate consistent snapshot from CDK stack
-     */
-    static getSnapshotTemplate(stack: Stack): any;
-    /**
-     * Clean up template for consistent snapshots by removing random IDs
-     */
-    static sanitiseTemplate(template: any): any;
-}
-/**
- * Common test data for infrastructure patterns
- */
-export declare const TestData: {
-    defaultTags: {
-        "fjall:costAllocation:environment": string;
-        "fjall:costAllocation:owner": string;
-    };
-    defaultAccountId: string;
-    defaultRegion: string;
-    vpc: {
-        vpcId: string;
-    };
-    basicApp: {
-        serviceName: string;
-        environment: string;
-        containerPort: number;
-        owner: string;
-    };
-};