@fjall/components-infrastructure 0.86.0 → 0.87.3

package/README.md

@@ -26,7 +26,7 @@ When a VPC is created in the same stack resources that rely on it will automatic
 ```typescript
 new AwsStack(`${id}App`)
   .addNetwork(FjallVpc.build(`${id}Vpc`))
-  .addResource(Fargate.build(`${id}Fargate`));
+  .addConstruct(Fargate.build(`${id}Fargate`));
 ```
 
 2. In the same CDK Application but different stack
@@ -41,7 +41,7 @@ const vpcStack = new AwsStack(`${id}Network`).addNetwork(
 
 const newStack = new AwsStack(`${id}Compute`, { dependencies: [vpcStack] })
   .addNetwork(vpcStack.getNetwork())
-  .addResource(Fargate.build(`${id}Fargate`));
+  .addConstruct(Fargate.build(`${id}Fargate`));
 ```
 
 3. Different CDK Applications
@@ -64,7 +64,7 @@ const newStack = new AwsStack(`${id}Compute`, {
   dependencies: [vpcStack]
 })
   .addNetwork(FjallVpc.import(`${id}Vpc`, `${id}Network`))
-  .addResource(Fargate.build(`${id}Fargate`));
+  .addConstruct(Fargate.build(`${id}Fargate`));
 ```
 
 ## Publishing package to npm

package/dist/lib/app.d.ts

@@ -5,9 +5,15 @@ import { type IVpc } from "aws-cdk-lib/aws-ec2";
 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 AnyDatabase } from "./patterns/aws/database";
 import { type INetworkProps, type Network } from "./patterns/aws/network";
+import { type Cdn } from "./patterns/aws/cdn";
+import { type AnyMessaging } from "./patterns/aws/messaging";
+import { type AnyCompute } from "./patterns/aws/compute";
+import { type AnyStorage } from "./patterns/aws/storage";
+import { type AnyPattern } from "./patterns/aws/pattern";
 import { type ResourceInventory } from "./aspects/resourceInventory";
+import { type ManifestCollector } from "./utils/manifestWriter";
 /**
  * Configuration options for App.getApp().
  *
@@ -57,6 +63,7 @@ export declare class App extends CdkApp {
     private globalTags;
     private aspectApplied;
     private resourceInventory;
+    private manifestCollector;
     private constructor();
     /**
      * Initialise the network (VPC) for this application.
@@ -131,6 +138,25 @@ export declare class App extends CdkApp {
      * @returns {AwsStack}
      */
     getDefaultStorageStack(): AwsStack;
+    /**
+     * Retrieve default CDN stack - named as `${this.name}Cdn`
+     *
+     * Depends on Network. Compute/Storage dependencies are added automatically
+     * by CDK when CDN resources reference ALB or S3 bucket resources.
+     *
+     * @returns {AwsStack}
+     */
+    getDefaultCdnStack(): AwsStack;
+    /**
+     * Retrieve default messaging stack - named as `${this.name}Messaging`
+     *
+     * Used for SQS queues, SNS topics, and EventBridge event buses.
+     * Depends on Network only. These are regional services that don't
+     * require VPC, but we maintain consistent stack dependency patterns.
+     *
+     * @returns {AwsStack}
+     */
+    getDefaultMessagingStack(): AwsStack;
     /**
      * Get a VPC by name. If no name is provided, returns the default VPC.
      *
@@ -187,21 +213,150 @@ export declare class App extends CdkApp {
      * Add a compute resource to the default compute stack using the factory pattern.
      * Automatically creates monitoring role if not already created.
      *
-     * Supports ComputeFactory (ECS, EC2, Lambda).
+     * Returns the appropriate compute type based on the factory configuration:
+     * - EcsCompute for type: "ecs"
+     * - LambdaCompute for type: "lambda"
+     * - Ec2Compute for type: "ec2"
+     *
+     * @example
+     * // ECS compute - returns EcsCompute
+     * const api = app.addCompute(ComputeFactory.build("Api", {
+     *   type: "ecs",
+     *   services: [{ name: "api", ... }]
+     * }));
+     * api.getLoadBalancer(); // Available on EcsCompute
+     *
+     * @example
+     * // Lambda compute - returns LambdaCompute
+     * const worker = app.addCompute(ComputeFactory.build("Worker", {
+     *   type: "lambda",
+     *   functions: [{ name: "process", ... }]
+     * }));
+     * worker.getFunction("process"); // Available on LambdaCompute
      */
-    addCompute<T extends Construct>(fn: (app: App, scope: Construct) => T): T;
+    addCompute<T extends AnyCompute>(fn: (app: App, scope: Construct) => T): T;
     /**
      * Manually add a resource to the default compute stack.
      */
     addComputeResource(resource: Construct): void;
     /**
      * Add a database resource to the default database stack using the factory pattern.
+     * Returns the appropriate database type based on the factory used.
+     *
+     * @example
+     * // Aurora database - returns RelationalDatabase
+     * const db = app.addDatabase(DatabaseFactory.build("Main", {
+     *   type: "Aurora",
+     *   databaseName: "myapp"
+     * }));
+     * db.getHostEndpoint(); // Available
+     *
+     * @example
+     * // DynamoDB table - returns DynamoDBDatabase
+     * const cache = app.addDatabase(DatabaseFactory.build("Cache", {
+     *   type: "DynamoDB",
+     *   partitionKey: { name: "id", type: "S" }
+     * }));
+     * cache.getTableName(); // Available
      */
-    addDatabase(fn: (app: App, scope: Construct) => Construct): Database;
+    addDatabase<T extends AnyDatabase>(fn: (app: App, scope: Construct) => T): T;
     /**
      * Add a storage resource (S3) to the default storage stack using the factory pattern.
+     *
+     * Returns the appropriate storage type based on the factory configuration:
+     * - PrivateStorage for bucketType: "private"
+     * - WebsiteStorage for bucketType: "website"
+     * - PublicStorage for bucketType: "publicRead"
+     *
+     * @example
+     * // Private storage - returns PrivateStorage
+     * const assets = app.addStorage(StorageFactory.build("Assets", {
+     *   bucketType: "private"
+     * }));
+     * assets.grantPublicAccess("public/*"); // Available on PrivateStorage
+     *
+     * @example
+     * // Website storage - returns WebsiteStorage
+     * const site = app.addStorage(StorageFactory.build("Site", {
+     *   bucketType: "website"
+     * }));
+     * site.getWebsiteUrl(); // Available on WebsiteStorage
      */
-    addStorage(fn: (app: App, scope: Construct) => Construct): Construct;
+    addStorage<T extends AnyStorage>(fn: (app: App, scope: Construct) => T): T;
+    /**
+     * Add a CDN resource (CloudFront) to the default CDN stack using the factory pattern.
+     *
+     * @example
+     * // S3 origin
+     * const assets = app.addStorage(StorageFactory.build("Assets", { bucketType: "private" }));
+     * app.addCdn(CdnFactory.build("AssetsCdn", {
+     *   originType: "s3",
+     *   bucket: assets
+     * }));
+     *
+     * @example
+     * // ALB origin (ECS)
+     * const api = app.addCompute(ComputeFactory.build("Api", { type: "ecs", ... }));
+     * app.addCdn(CdnFactory.build("ApiCdn", {
+     *   originType: "alb",
+     *   loadBalancer: api
+     * }));
+     */
+    addCdn(fn: (app: App, scope: Construct) => Cdn): Cdn;
+    /**
+     * Add a messaging resource to the default queue stack using the factory pattern.
+     *
+     * Returns the appropriate messaging type based on the factory configuration.
+     * Currently supports queue (SQS), with future support planned for
+     * topic (SNS), eventbus (EventBridge), and stream (Kinesis).
+     *
+     * @example
+     * // Queue messaging - returns QueueMessaging
+     * const notifications = app.addMessaging(MessagingFactory.build("Notifications", {
+     *   type: "queue",
+     *   queueType: "standard",
+     *   deadLetterQueue: { enabled: true, maxReceiveCount: 3 }
+     * }));
+     * notifications.grantSendMessages(apiFunction);
+     *
+     * @example
+     * // FIFO queue for OpenNext revalidation
+     * const revalidation = app.addMessaging(MessagingFactory.build("Revalidation", {
+     *   type: "queue",
+     *   queueType: "fifo",
+     *   visibilityTimeout: 300,
+     *   contentBasedDeduplication: true
+     * }));
+     */
+    addMessaging<T extends AnyMessaging>(fn: (app: App, scope: Construct) => T): T;
+    /**
+     * Add a high-level infrastructure pattern to the application.
+     *
+     * Patterns are composite constructs that create multiple related resources
+     * as a single, cohesive unit. They encapsulate best practices and reduce
+     * boilerplate for common deployment scenarios.
+     *
+     * Currently supported patterns:
+     * - `payload`: Payload CMS deployment with OpenNext
+     *
+     * Returns the appropriate pattern interface based on the factory configuration,
+     * providing access to all underlying resources via escape hatches.
+     *
+     * @example
+     * // Payload CMS pattern - returns Payload
+     * const payload = app.addPattern(PatternFactory.build("PayloadApp", {
+     *   type: "payload",
+     *   name: "my-cms",
+     *   source: "../.."
+     * }));
+     *
+     * @example
+     * // Escape hatches - access underlying resources
+     * payload.getDatabase().grantConnect(otherLambda);
+     * payload.getServer().getLambdaFunction().addEnvironment("CUSTOM", "value");
+     * payload.getCdn().getDistribution().addBehavior("/custom/*", customOrigin);
+     */
+    addPattern<T extends AnyPattern>(fn: (app: App, scope: Construct) => T): T;
     /**
      * Add an additional network (VPC) to the application.
      *
@@ -254,7 +409,12 @@ export declare class App extends CdkApp {
      */
     exportResourceInventory(): ResourceInventory;
     /**
-     * Override synth to automatically export resource inventory
+     * Get the manifest collector for registering services and patterns.
+     * Used by ComputeFactory and PatternFactory to register their configurations.
+     */
+    getManifestCollector(): ManifestCollector;
+    /**
+     * Override synth to automatically export resource inventory and manifest
      */
     synth(options?: StageSynthesisOptions): CloudAssembly;
 }