@fjall/components-infrastructure 0.86.1 → 0.87.3

package/dist/lib/patterns/aws/interfaces/pattern.d.ts

@@ -0,0 +1,403 @@
+/**
+ * Type-safe pattern interfaces.
+ *
+ * These interfaces provide compile-time type safety for pattern resources.
+ * Patterns are high-level constructs that compose multiple infrastructure resources
+ * into a cohesive, opinionated deployment (e.g., Payload CMS, Next.js).
+ *
+ * @example
+ * const payload = app.addPattern(PatternFactory.build("PayloadApp", {
+ *   type: "payload",
+ *   name: "my-cms",
+ *   source: "../.."
+ * }));
+ * payload.getDatabase(); // ✓ Available on IPayload
+ * payload.getServer(); // ✓ Available on IPayload
+ */
+import { type ICertificate } from "aws-cdk-lib/aws-certificatemanager";
+import { type Duration } from "aws-cdk-lib";
+import { type Construct } from "constructs";
+import { type RelationalDatabase, type DynamoDBDatabase, type ProxyConfig, type ReadReplicaConfig, type CredentialsConfig, type EncryptionConfig, type AuroraEncryptionConfig, type AuroraWriterConfig, type AuroraReadersConfig, type PerformanceInsightsConfig, type PerformanceInsightsRetentionPeriod } from "../database.js";
+import { type LambdaCompute } from "../compute.js";
+import { type PrivateStorage } from "../storage.js";
+import { type QueueMessaging } from "../messaging.js";
+import { type Cdn, type SmartCdnBehaviour } from "../cdn.js";
+export type { ProxyConfig, ReadReplicaConfig, CredentialsConfig, EncryptionConfig, AuroraEncryptionConfig, AuroraWriterConfig, AuroraReadersConfig, PerformanceInsightsConfig, PerformanceInsightsRetentionPeriod };
+/**
+ * Full database configuration for patterns.
+ * Extends underlying DatabaseFactory props with pattern-specific defaults.
+ *
+ * @example
+ * // Minimal - use defaults
+ * database: { type: "Instance" }
+ *
+ * @example
+ * // Production-ready Instance
+ * database: {
+ *   type: "Instance",
+ *   instanceType: "t4g.large",
+ *   allocatedStorage: 50,
+ *   multiAz: true,
+ *   performanceInsights: { retentionPeriod: 31 },
+ *   encryption: { storageKey: { useCMK: true } }
+ * }
+ *
+ * @example
+ * // Aurora with readers
+ * database: {
+ *   type: "Aurora",
+ *   readers: { count: 2 },
+ *   allowVpcAccess: true
+ * }
+ */
+export interface PayloadDatabaseConfig {
+    /** Database type: "Instance" or "Aurora". Default: "Instance" */
+    type?: "Instance" | "Aurora";
+    /** Database name. Default: derived from pattern name */
+    databaseName?: string;
+    /** Database engine. Default: "postgresql" */
+    databaseEngine?: "postgresql" | "mysql";
+    /** Enable deletion protection. Default: true */
+    deletionProtection?: boolean;
+    /** Backup retention in days (1-35). Default: 7 */
+    backupRetention?: number;
+    /** Database port. Default: engine-specific (5432 for PostgreSQL) */
+    port?: number;
+    /** Make database publicly accessible (for local development). Default: false */
+    publiclyAccessible?: boolean;
+    /** IP CIDR to allow when publicly accessible (e.g., "203.0.113.0/32") */
+    allowedIpCidr?: string;
+    /**
+     * Instance type for RDS Instance databases.
+     * Examples: "t4g.micro", "t4g.small", "t4g.large", "r6g.large"
+     * Default: "t4g.small"
+     * Only applies when type: "Instance"
+     */
+    instanceType?: string;
+    /**
+     * Allocated storage in GB for RDS Instance.
+     * Default: 20
+     * Only applies when type: "Instance"
+     */
+    allocatedStorage?: number;
+    /**
+     * Enable Multi-AZ deployment for high availability.
+     * Creates a standby replica in a different AZ.
+     * Only applies when type: "Instance"
+     */
+    multiAz?: boolean;
+    /**
+     * Read replica configuration for RDS Instance.
+     * Set to false to explicitly disable.
+     * Only applies when type: "Instance"
+     */
+    readReplica?: ReadReplicaConfig | false;
+    /**
+     * Aurora writer instance configuration.
+     * Only applies when type: "Aurora"
+     */
+    writer?: AuroraWriterConfig;
+    /**
+     * Aurora reader instances configuration.
+     * Set to false to explicitly disable readers.
+     * Only applies when type: "Aurora"
+     */
+    readers?: AuroraReadersConfig | false;
+    /**
+     * Allow access from VPC CIDR (avoids cross-stack cyclic dependencies).
+     * Only applies when type: "Aurora"
+     */
+    allowVpcAccess?: boolean;
+    /**
+     * Enhanced monitoring interval.
+     * Only applies when type: "Aurora"
+     */
+    monitoringInterval?: Duration;
+    /**
+     * Preferred maintenance window (e.g., "sun:05:00-sun:06:00").
+     * Only applies when type: "Aurora"
+     */
+    preferredMaintenanceWindow?: string;
+    /**
+     * Performance Insights configuration.
+     * Set to false to explicitly disable.
+     * @example { retentionPeriod: 31 }
+     */
+    performanceInsights?: PerformanceInsightsConfig | false;
+    /**
+     * RDS Proxy configuration for connection pooling.
+     * Set to false to explicitly disable.
+     * @example { maxConnections: 100 }
+     */
+    proxy?: ProxyConfig | false;
+    /**
+     * Credentials configuration (username, rotation).
+     */
+    credentials?: CredentialsConfig;
+    /**
+     * Encryption configuration.
+     * For Instance: EncryptionConfig
+     * For Aurora: AuroraEncryptionConfig
+     * @example { storageKey: { useCMK: true } }
+     */
+    encryption?: EncryptionConfig | AuroraEncryptionConfig;
+    /** ARN or identifier of snapshot to restore from */
+    snapshotIdentifier?: string;
+    /** Username from the snapshot (required when restoring) */
+    snapshotUsername?: string;
+}
+/**
+ * Lambda function configuration for pattern sub-functions.
+ *
+ * @example
+ * server: { memorySize: 2048, timeout: 60 }
+ */
+export interface PatternLambdaConfig {
+    /** Memory size in MB. Range: 128-10240. */
+    memorySize?: number;
+    /** Timeout in seconds. Range: 1-900. */
+    timeout?: number;
+    /** Ephemeral storage size in MB. Range: 512-10240. Default: 512. */
+    ephemeralStorageSize?: number;
+}
+/**
+ * Full compute configuration for patterns.
+ * Allows per-function configuration for each Lambda in the pattern.
+ *
+ * @example
+ * // Configure individual functions
+ * compute: {
+ *   server: { memorySize: 2048, timeout: 60 },
+ *   imageOptimisation: { memorySize: 2048 },
+ *   revalidation: { memorySize: 1024, timeout: 600 }
+ * }
+ */
+export interface PayloadComputeConfig {
+    /**
+     * Server Lambda configuration.
+     * Handles main application requests.
+     * Defaults: memorySize=1536, timeout=30
+     */
+    server?: PatternLambdaConfig;
+    /**
+     * Image optimisation Lambda configuration.
+     * Handles Next.js image optimization.
+     * Defaults: memorySize=1536, timeout=30
+     */
+    imageOptimisation?: PatternLambdaConfig;
+    /**
+     * Revalidation Lambda configuration.
+     * Handles ISR revalidation from SQS queue.
+     * Defaults: memorySize=768, timeout=300
+     */
+    revalidation?: PatternLambdaConfig;
+}
+/**
+ * S3 bucket configuration for pattern sub-buckets.
+ */
+export interface PatternStorageBucketConfig {
+    /** Enable versioning. Default: false */
+    versioned?: boolean;
+}
+/**
+ * Full storage configuration for patterns.
+ * Allows per-bucket configuration for each S3 bucket in the pattern.
+ *
+ * @example
+ * storage: {
+ *   assets: { versioned: true },
+ *   cache: { versioned: false },
+ *   media: { versioned: true }
+ * }
+ */
+export interface PayloadStorageConfig {
+    /** Assets bucket (static files) */
+    assets?: PatternStorageBucketConfig;
+    /** Cache bucket (ISR cache) */
+    cache?: PatternStorageBucketConfig;
+    /** Media bucket (uploads) */
+    media?: PatternStorageBucketConfig;
+}
+/**
+ * SQS queue configuration for pattern messaging.
+ */
+export interface PatternQueueConfig {
+    /** Visibility timeout in seconds. Default: matches revalidation timeout */
+    visibilityTimeout?: number;
+    /** Message retention period in seconds. Default: 345600 (4 days) */
+    messageRetentionPeriod?: number;
+    /** Maximum message size in bytes. Default: 262144 (256 KB) */
+    maxMessageSize?: number;
+    /**
+     * Dead letter queue configuration.
+     * Set to false to explicitly disable.
+     */
+    deadLetterQueue?: {
+        enabled?: boolean;
+        maxReceiveCount?: number;
+    } | false;
+}
+/**
+ * Full messaging configuration for patterns.
+ *
+ * @example
+ * messaging: {
+ *   revalidationQueue: {
+ *     visibilityTimeout: 600,
+ *     deadLetterQueue: { enabled: true, maxReceiveCount: 5 }
+ *   }
+ * }
+ */
+export interface PayloadMessagingConfig {
+    /** Revalidation queue configuration */
+    revalidationQueue?: PatternQueueConfig;
+}
+/**
+ * CDN configuration for Payload pattern.
+ */
+export interface PayloadCdnConfig {
+    /** Custom domain names for CloudFront */
+    domainNames?: string[];
+    /** ACM certificate for custom domains (must be in us-east-1) */
+    certificate?: ICertificate;
+    /** ACM certificate ARN (alternative to certificate - must be in us-east-1) */
+    certificateArn?: string;
+    /** Additional CDN behaviours */
+    behaviours?: SmartCdnBehaviour[];
+}
+/**
+ * Payload pattern props.
+ *
+ * Configures a Payload CMS deployment with all required infrastructure:
+ * - RDS PostgreSQL database (Aurora or Instance)
+ * - S3 buckets (assets, cache, media)
+ * - DynamoDB table (tag cache)
+ * - SQS FIFO queue (revalidation)
+ * - Lambda functions (server, image optimisation, revalidation)
+ * - CloudFront distribution
+ *
+ * @example
+ * // Minimal - works out of box
+ * app.addPattern(PatternFactory.build("PayloadApp", {
+ *   type: "payload",
+ *   name: "my-cms"
+ * }));
+ *
+ * @example
+ * // With custom domain (auto-creates certificate + DNS)
+ * app.addPattern(PatternFactory.build("PayloadApp", {
+ *   type: "payload",
+ *   name: "my-cms",
+ *   domain: "cms.example.com"
+ * }));
+ *
+ * @example
+ * // Customised
+ * app.addPattern(PatternFactory.build("PayloadApp", {
+ *   type: "payload",
+ *   name: "my-cms",
+ *   database: {
+ *     type: "Instance",
+ *     publiclyAccessible: true
+ *   },
+ *   compute: {
+ *     server: { memorySize: 2048 }
+ *   }
+ * }));
+ */
+export interface IPayloadProps {
+    /** Pattern type discriminator */
+    type: "payload";
+    /** Pattern name (used for resource naming) */
+    name: string;
+    /**
+     * Custom domain for the Payload application.
+     * When provided, automatically:
+     * - Looks up the Route53 hosted zone
+     * - Creates an ACM certificate with DNS validation (in us-east-1)
+     * - Configures CloudFront with the certificate
+     * - Creates an A record (alias) pointing to CloudFront
+     *
+     * Requires: A Route53 hosted zone for the domain must exist.
+     *
+     * @example "cms.example.com"
+     */
+    domain?: string;
+    /** Database configuration */
+    database?: PayloadDatabaseConfig;
+    /** Compute (Lambda) configuration */
+    compute?: PayloadComputeConfig;
+    /** Storage (S3) configuration */
+    storage?: PayloadStorageConfig;
+    /** Messaging (SQS) configuration */
+    messaging?: PayloadMessagingConfig;
+    /** CDN (CloudFront) configuration - for advanced use. Use `domain` for simple setup. */
+    cdn?: PayloadCdnConfig;
+    /** Additional environment variables for server Lambda */
+    environment?: Record<string, string>;
+}
+/**
+ * Union of all pattern props.
+ * Extend this when adding new patterns (e.g., INextjsProps, IRemixProps).
+ */
+export type IPatternProps = IPayloadProps;
+/**
+ * Pattern type discriminator.
+ */
+export type PatternType = "payload";
+/**
+ * Base pattern interface.
+ * All patterns implement this interface.
+ */
+export interface IPattern {
+    /** The type of pattern. Used for runtime type narrowing. */
+    readonly patternType: PatternType;
+    /** The underlying CDK construct node. */
+    readonly node: Construct["node"];
+}
+/**
+ * Payload pattern interface.
+ * Provides access to all underlying resources for escape hatches.
+ *
+ * @example
+ * // Escape hatches - full access to underlying resources
+ * payload.getDatabase().grantConnect(someOtherLambda);
+ * payload.getServer().getLambdaFunction().addEnvironment("CUSTOM_VAR", "value");
+ * payload.getCdn().getDistribution().addBehavior("/custom/*", customOrigin);
+ */
+export interface IPayload extends IPattern {
+    readonly patternType: "payload";
+    /** Get the PostgreSQL database (Aurora or Instance) */
+    getDatabase(): RelationalDatabase;
+    /** Get the Server Lambda function */
+    getServer(): LambdaCompute;
+    /** Get the Image Optimisation Lambda function */
+    getImageOptimisation(): LambdaCompute;
+    /** Get the Revalidation Lambda function */
+    getRevalidation(): LambdaCompute;
+    /** Get the Assets S3 bucket (static files) */
+    getAssetsBucket(): PrivateStorage;
+    /** Get the Cache S3 bucket (ISR cache) */
+    getCacheBucket(): PrivateStorage;
+    /** Get the Media S3 bucket (uploads) */
+    getMediaBucket(): PrivateStorage;
+    /** Get the Tag Cache DynamoDB table */
+    getTagCache(): DynamoDBDatabase;
+    /** Get the Revalidation SQS queue */
+    getRevalidationQueue(): QueueMessaging;
+    /** Get the CloudFront distribution */
+    getCdn(): Cdn;
+}
+/**
+ * Union type representing any pattern interface.
+ * Use with type guards for generic handling.
+ */
+export type AnyPattern = IPayload;
+/**
+ * Type guard to check if a pattern is Payload.
+ */
+export declare function isPayloadPattern(pattern: IPattern): pattern is IPayload;
+/**
+ * Type guard to check if a resource is any pattern type.
+ */
+export declare function isPattern(resource: unknown): resource is IPattern;

package/dist/lib/patterns/aws/interfaces/pattern.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Type-safe pattern interfaces.
+ *
+ * These interfaces provide compile-time type safety for pattern resources.
+ * Patterns are high-level constructs that compose multiple infrastructure resources
+ * into a cohesive, opinionated deployment (e.g., Payload CMS, Next.js).
+ *
+ * @example
+ * const payload = app.addPattern(PatternFactory.build("PayloadApp", {
+ *   type: "payload",
+ *   name: "my-cms",
+ *   source: "../.."
+ * }));
+ * payload.getDatabase(); // ✓ Available on IPayload
+ * payload.getServer(); // ✓ Available on IPayload
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPayloadPattern = isPayloadPattern;
+exports.isPattern = isPattern;
+/**
+ * Type guard to check if a pattern is Payload.
+ */
+function isPayloadPattern(pattern) {
+    return pattern.patternType === "payload";
+}
+/**
+ * Type guard to check if a resource is any pattern type.
+ */
+function isPattern(resource) {
+    return (resource !== null &&
+        typeof resource === "object" &&
+        "patternType" in resource &&
+        typeof resource.patternType === "string");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pattern.js","sourceRoot":"","sources":["../../../../../lib/patterns/aws/interfaces/pattern.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;AA4cH,4CAEC;AAKD,8BAOC;AAjBD;;GAEG;AACH,SAAgB,gBAAgB,CAAC,OAAiB;IAChD,OAAO,OAAO,CAAC,WAAW,KAAK,SAAS,CAAC;AAC3C,CAAC;AAED;;GAEG;AACH,SAAgB,SAAS,CAAC,QAAiB;IACzC,OAAO,CACL,QAAQ,KAAK,IAAI;QACjB,OAAO,QAAQ,KAAK,QAAQ;QAC5B,aAAa,IAAI,QAAQ;QACzB,OAAQ,QAAqB,CAAC,WAAW,KAAK,QAAQ,CACvD,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Type-safe pattern interfaces.\n *\n * These interfaces provide compile-time type safety for pattern resources.\n * Patterns are high-level constructs that compose multiple infrastructure resources\n * into a cohesive, opinionated deployment (e.g., Payload CMS, Next.js).\n *\n * @example\n * const payload = app.addPattern(PatternFactory.build(\"PayloadApp\", {\n *   type: \"payload\",\n *   name: \"my-cms\",\n *   source: \"../..\"\n * }));\n * payload.getDatabase(); // ✓ Available on IPayload\n * payload.getServer(); // ✓ Available on IPayload\n */\n\nimport { type ICertificate } from \"aws-cdk-lib/aws-certificatemanager\";\nimport { type Duration } from \"aws-cdk-lib\";\nimport { type Construct } from \"constructs\";\n\nimport {\n  type RelationalDatabase,\n  type DynamoDBDatabase,\n  type ProxyConfig,\n  type ReadReplicaConfig,\n  type CredentialsConfig,\n  type EncryptionConfig,\n  type AuroraEncryptionConfig,\n  type AuroraWriterConfig,\n  type AuroraReadersConfig,\n  type PerformanceInsightsConfig,\n  type PerformanceInsightsRetentionPeriod\n} from \"../database.js\";\nimport { type LambdaCompute } from \"../compute.js\";\nimport { type PrivateStorage } from \"../storage.js\";\nimport { type QueueMessaging } from \"../messaging.js\";\nimport { type Cdn, type SmartCdnBehaviour } from \"../cdn.js\";\n\n// Re-export database types for consumer convenience\nexport type {\n  ProxyConfig,\n  ReadReplicaConfig,\n  CredentialsConfig,\n  EncryptionConfig,\n  AuroraEncryptionConfig,\n  AuroraWriterConfig,\n  AuroraReadersConfig,\n  PerformanceInsightsConfig,\n  PerformanceInsightsRetentionPeriod\n};\n\n/**\n * Full database configuration for patterns.\n * Extends underlying DatabaseFactory props with pattern-specific defaults.\n *\n * @example\n * // Minimal - use defaults\n * database: { type: \"Instance\" }\n *\n * @example\n * // Production-ready Instance\n * database: {\n *   type: \"Instance\",\n *   instanceType: \"t4g.large\",\n *   allocatedStorage: 50,\n *   multiAz: true,\n *   performanceInsights: { retentionPeriod: 31 },\n *   encryption: { storageKey: { useCMK: true } }\n * }\n *\n * @example\n * // Aurora with readers\n * database: {\n *   type: \"Aurora\",\n *   readers: { count: 2 },\n *   allowVpcAccess: true\n * }\n */\nexport interface PayloadDatabaseConfig {\n  // --- Base Configuration ---\n\n  /** Database type: \"Instance\" or \"Aurora\". Default: \"Instance\" */\n  type?: \"Instance\" | \"Aurora\";\n  /** Database name. Default: derived from pattern name */\n  databaseName?: string;\n  /** Database engine. Default: \"postgresql\" */\n  databaseEngine?: \"postgresql\" | \"mysql\";\n\n  // --- Common Configuration ---\n\n  /** Enable deletion protection. Default: true */\n  deletionProtection?: boolean;\n  /** Backup retention in days (1-35). Default: 7 */\n  backupRetention?: number;\n  /** Database port. Default: engine-specific (5432 for PostgreSQL) */\n  port?: number;\n\n  // --- Public Access (Development Use) ---\n\n  /** Make database publicly accessible (for local development). Default: false */\n  publiclyAccessible?: boolean;\n  /** IP CIDR to allow when publicly accessible (e.g., \"203.0.113.0/32\") */\n  allowedIpCidr?: string;\n\n  // --- Instance-Specific Configuration ---\n\n  /**\n   * Instance type for RDS Instance databases.\n   * Examples: \"t4g.micro\", \"t4g.small\", \"t4g.large\", \"r6g.large\"\n   * Default: \"t4g.small\"\n   * Only applies when type: \"Instance\"\n   */\n  instanceType?: string;\n  /**\n   * Allocated storage in GB for RDS Instance.\n   * Default: 20\n   * Only applies when type: \"Instance\"\n   */\n  allocatedStorage?: number;\n  /**\n   * Enable Multi-AZ deployment for high availability.\n   * Creates a standby replica in a different AZ.\n   * Only applies when type: \"Instance\"\n   */\n  multiAz?: boolean;\n  /**\n   * Read replica configuration for RDS Instance.\n   * Set to false to explicitly disable.\n   * Only applies when type: \"Instance\"\n   */\n  readReplica?: ReadReplicaConfig | false;\n\n  // --- Aurora-Specific Configuration ---\n\n  /**\n   * Aurora writer instance configuration.\n   * Only applies when type: \"Aurora\"\n   */\n  writer?: AuroraWriterConfig;\n  /**\n   * Aurora reader instances configuration.\n   * Set to false to explicitly disable readers.\n   * Only applies when type: \"Aurora\"\n   */\n  readers?: AuroraReadersConfig | false;\n  /**\n   * Allow access from VPC CIDR (avoids cross-stack cyclic dependencies).\n   * Only applies when type: \"Aurora\"\n   */\n  allowVpcAccess?: boolean;\n  /**\n   * Enhanced monitoring interval.\n   * Only applies when type: \"Aurora\"\n   */\n  monitoringInterval?: Duration;\n  /**\n   * Preferred maintenance window (e.g., \"sun:05:00-sun:06:00\").\n   * Only applies when type: \"Aurora\"\n   */\n  preferredMaintenanceWindow?: string;\n\n  // --- Shared Advanced Configuration ---\n\n  /**\n   * Performance Insights configuration.\n   * Set to false to explicitly disable.\n   * @example { retentionPeriod: 31 }\n   */\n  performanceInsights?: PerformanceInsightsConfig | false;\n  /**\n   * RDS Proxy configuration for connection pooling.\n   * Set to false to explicitly disable.\n   * @example { maxConnections: 100 }\n   */\n  proxy?: ProxyConfig | false;\n  /**\n   * Credentials configuration (username, rotation).\n   */\n  credentials?: CredentialsConfig;\n  /**\n   * Encryption configuration.\n   * For Instance: EncryptionConfig\n   * For Aurora: AuroraEncryptionConfig\n   * @example { storageKey: { useCMK: true } }\n   */\n  encryption?: EncryptionConfig | AuroraEncryptionConfig;\n\n  // --- Snapshot Restore ---\n\n  /** ARN or identifier of snapshot to restore from */\n  snapshotIdentifier?: string;\n  /** Username from the snapshot (required when restoring) */\n  snapshotUsername?: string;\n}\n\n/**\n * Lambda function configuration for pattern sub-functions.\n *\n * @example\n * server: { memorySize: 2048, timeout: 60 }\n */\nexport interface PatternLambdaConfig {\n  /** Memory size in MB. Range: 128-10240. */\n  memorySize?: number;\n  /** Timeout in seconds. Range: 1-900. */\n  timeout?: number;\n  /** Ephemeral storage size in MB. Range: 512-10240. Default: 512. */\n  ephemeralStorageSize?: number;\n}\n\n/**\n * Full compute configuration for patterns.\n * Allows per-function configuration for each Lambda in the pattern.\n *\n * @example\n * // Configure individual functions\n * compute: {\n *   server: { memorySize: 2048, timeout: 60 },\n *   imageOptimisation: { memorySize: 2048 },\n *   revalidation: { memorySize: 1024, timeout: 600 }\n * }\n */\nexport interface PayloadComputeConfig {\n  /**\n   * Server Lambda configuration.\n   * Handles main application requests.\n   * Defaults: memorySize=1536, timeout=30\n   */\n  server?: PatternLambdaConfig;\n  /**\n   * Image optimisation Lambda configuration.\n   * Handles Next.js image optimization.\n   * Defaults: memorySize=1536, timeout=30\n   */\n  imageOptimisation?: PatternLambdaConfig;\n  /**\n   * Revalidation Lambda configuration.\n   * Handles ISR revalidation from SQS queue.\n   * Defaults: memorySize=768, timeout=300\n   */\n  revalidation?: PatternLambdaConfig;\n}\n\n/**\n * S3 bucket configuration for pattern sub-buckets.\n */\nexport interface PatternStorageBucketConfig {\n  /** Enable versioning. Default: false */\n  versioned?: boolean;\n}\n\n/**\n * Full storage configuration for patterns.\n * Allows per-bucket configuration for each S3 bucket in the pattern.\n *\n * @example\n * storage: {\n *   assets: { versioned: true },\n *   cache: { versioned: false },\n *   media: { versioned: true }\n * }\n */\nexport interface PayloadStorageConfig {\n  /** Assets bucket (static files) */\n  assets?: PatternStorageBucketConfig;\n  /** Cache bucket (ISR cache) */\n  cache?: PatternStorageBucketConfig;\n  /** Media bucket (uploads) */\n  media?: PatternStorageBucketConfig;\n}\n\n/**\n * SQS queue configuration for pattern messaging.\n */\nexport interface PatternQueueConfig {\n  /** Visibility timeout in seconds. Default: matches revalidation timeout */\n  visibilityTimeout?: number;\n  /** Message retention period in seconds. Default: 345600 (4 days) */\n  messageRetentionPeriod?: number;\n  /** Maximum message size in bytes. Default: 262144 (256 KB) */\n  maxMessageSize?: number;\n  /**\n   * Dead letter queue configuration.\n   * Set to false to explicitly disable.\n   */\n  deadLetterQueue?:\n    | {\n        enabled?: boolean;\n        maxReceiveCount?: number;\n      }\n    | false;\n}\n\n/**\n * Full messaging configuration for patterns.\n *\n * @example\n * messaging: {\n *   revalidationQueue: {\n *     visibilityTimeout: 600,\n *     deadLetterQueue: { enabled: true, maxReceiveCount: 5 }\n *   }\n * }\n */\nexport interface PayloadMessagingConfig {\n  /** Revalidation queue configuration */\n  revalidationQueue?: PatternQueueConfig;\n}\n\n/**\n * CDN configuration for Payload pattern.\n */\nexport interface PayloadCdnConfig {\n  /** Custom domain names for CloudFront */\n  domainNames?: string[];\n  /** ACM certificate for custom domains (must be in us-east-1) */\n  certificate?: ICertificate;\n  /** ACM certificate ARN (alternative to certificate - must be in us-east-1) */\n  certificateArn?: string;\n  /** Additional CDN behaviours */\n  behaviours?: SmartCdnBehaviour[];\n}\n\n/**\n * Payload pattern props.\n *\n * Configures a Payload CMS deployment with all required infrastructure:\n * - RDS PostgreSQL database (Aurora or Instance)\n * - S3 buckets (assets, cache, media)\n * - DynamoDB table (tag cache)\n * - SQS FIFO queue (revalidation)\n * - Lambda functions (server, image optimisation, revalidation)\n * - CloudFront distribution\n *\n * @example\n * // Minimal - works out of box\n * app.addPattern(PatternFactory.build(\"PayloadApp\", {\n *   type: \"payload\",\n *   name: \"my-cms\"\n * }));\n *\n * @example\n * // With custom domain (auto-creates certificate + DNS)\n * app.addPattern(PatternFactory.build(\"PayloadApp\", {\n *   type: \"payload\",\n *   name: \"my-cms\",\n *   domain: \"cms.example.com\"\n * }));\n *\n * @example\n * // Customised\n * app.addPattern(PatternFactory.build(\"PayloadApp\", {\n *   type: \"payload\",\n *   name: \"my-cms\",\n *   database: {\n *     type: \"Instance\",\n *     publiclyAccessible: true\n *   },\n *   compute: {\n *     server: { memorySize: 2048 }\n *   }\n * }));\n */\nexport interface IPayloadProps {\n  /** Pattern type discriminator */\n  type: \"payload\";\n  /** Pattern name (used for resource naming) */\n  name: string;\n\n  /**\n   * Custom domain for the Payload application.\n   * When provided, automatically:\n   * - Looks up the Route53 hosted zone\n   * - Creates an ACM certificate with DNS validation (in us-east-1)\n   * - Configures CloudFront with the certificate\n   * - Creates an A record (alias) pointing to CloudFront\n   *\n   * Requires: A Route53 hosted zone for the domain must exist.\n   *\n   * @example \"cms.example.com\"\n   */\n  domain?: string;\n\n  /** Database configuration */\n  database?: PayloadDatabaseConfig;\n  /** Compute (Lambda) configuration */\n  compute?: PayloadComputeConfig;\n  /** Storage (S3) configuration */\n  storage?: PayloadStorageConfig;\n  /** Messaging (SQS) configuration */\n  messaging?: PayloadMessagingConfig;\n  /** CDN (CloudFront) configuration - for advanced use. Use `domain` for simple setup. */\n  cdn?: PayloadCdnConfig;\n\n  /** Additional environment variables for server Lambda */\n  environment?: Record<string, string>;\n}\n\n/**\n * Union of all pattern props.\n * Extend this when adding new patterns (e.g., INextjsProps, IRemixProps).\n */\nexport type IPatternProps = IPayloadProps; // | INextjsProps | IRemixProps in future\n\n/**\n * Pattern type discriminator.\n */\nexport type PatternType = \"payload\"; // | \"nextjs\" | \"remix\" in future\n\n/**\n * Base pattern interface.\n * All patterns implement this interface.\n */\nexport interface IPattern {\n  /** The type of pattern. Used for runtime type narrowing. */\n  readonly patternType: PatternType;\n\n  /** The underlying CDK construct node. */\n  readonly node: Construct[\"node\"];\n}\n\n/**\n * Payload pattern interface.\n * Provides access to all underlying resources for escape hatches.\n *\n * @example\n * // Escape hatches - full access to underlying resources\n * payload.getDatabase().grantConnect(someOtherLambda);\n * payload.getServer().getLambdaFunction().addEnvironment(\"CUSTOM_VAR\", \"value\");\n * payload.getCdn().getDistribution().addBehavior(\"/custom/*\", customOrigin);\n */\nexport interface IPayload extends IPattern {\n  readonly patternType: \"payload\";\n\n  /** Get the PostgreSQL database (Aurora or Instance) */\n  getDatabase(): RelationalDatabase;\n\n  /** Get the Server Lambda function */\n  getServer(): LambdaCompute;\n\n  /** Get the Image Optimisation Lambda function */\n  getImageOptimisation(): LambdaCompute;\n\n  /** Get the Revalidation Lambda function */\n  getRevalidation(): LambdaCompute;\n\n  /** Get the Assets S3 bucket (static files) */\n  getAssetsBucket(): PrivateStorage;\n\n  /** Get the Cache S3 bucket (ISR cache) */\n  getCacheBucket(): PrivateStorage;\n\n  /** Get the Media S3 bucket (uploads) */\n  getMediaBucket(): PrivateStorage;\n\n  /** Get the Tag Cache DynamoDB table */\n  getTagCache(): DynamoDBDatabase;\n\n  /** Get the Revalidation SQS queue */\n  getRevalidationQueue(): QueueMessaging;\n\n  /** Get the CloudFront distribution */\n  getCdn(): Cdn;\n}\n\n/**\n * Union type representing any pattern interface.\n * Use with type guards for generic handling.\n */\nexport type AnyPattern = IPayload; // | INextjs | IRemix in future\n\n/**\n * Type guard to check if a pattern is Payload.\n */\nexport function isPayloadPattern(pattern: IPattern): pattern is IPayload {\n  return pattern.patternType === \"payload\";\n}\n\n/**\n * Type guard to check if a resource is any pattern type.\n */\nexport function isPattern(resource: unknown): resource is IPattern {\n  return (\n    resource !== null &&\n    typeof resource === \"object\" &&\n    \"patternType\" in resource &&\n    typeof (resource as IPattern).patternType === \"string\"\n  );\n}\n"]}

package/dist/lib/patterns/aws/interfaces/storage.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Type-safe storage interfaces.
+ *
+ * These interfaces provide compile-time type safety for storage resources.
+ * All S3 bucket types are grouped under the Storage umbrella, with specific
+ * interfaces for each bucket type.
+ *
+ * @example
+ * const assets = app.addStorage(StorageFactory.build("Assets", { bucketType: "private" }));
+ * assets.getBucketName(); // ✓ Available on all storage types
+ *
+ * const website = app.addStorage(StorageFactory.build("Site", { bucketType: "website" }));
+ * website.getWebsiteUrl(); // ✓ Available on IWebsiteStorage
+ */
+import { type IBucket, type EventType, type IBucketNotificationDestination, type NotificationKeyFilter } from "aws-cdk-lib/aws-s3";
+import { type IGrantable, type Grant } from "aws-cdk-lib/aws-iam";
+import { type Construct } from "constructs";
+/**
+ * Storage type discriminator.
+ * Maps to S3 bucket configurations.
+ */
+export type StorageType = "private" | "website" | "publicRead";
+/**
+ * Base storage interface.
+ * All storage types implement this interface.
+ */
+export interface IStorage {
+    /** The type of storage resource. Used for runtime type narrowing. */
+    readonly storageType: StorageType;
+    /** The underlying CDK construct node. */
+    readonly node: Construct["node"];
+    /** Get the underlying S3 bucket. */
+    getBucket(): IBucket;
+    /** Get the bucket ARN. */
+    getBucketArn(): string;
+    /** Get the bucket name. */
+    getBucketName(): string;
+    /** Get the bucket domain name. */
+    getBucketDomainName(): string;
+    /** Get the regional bucket domain name. */
+    getBucketRegionalDomainName(): string;
+    /**
+     * Grant read permissions to a grantee.
+     * @param grantee The principal to grant read permissions to
+     */
+    grantRead(grantee: IGrantable): Grant;
+    /**
+     * Grant write permissions to a grantee.
+     * @param grantee The principal to grant write permissions to
+     */
+    grantWrite(grantee: IGrantable): Grant;
+    /**
+     * Grant read and write permissions to a grantee.
+     * @param grantee The principal to grant permissions to
+     */
+    grantReadWrite(grantee: IGrantable): Grant;
+    /**
+     * Grant delete permissions to a grantee.
+     * @param grantee The principal to grant delete permissions to
+     */
+    grantDelete(grantee: IGrantable): Grant;
+    /**
+     * Grant put permissions to a grantee.
+     * @param grantee The principal to grant put permissions to
+     */
+    grantPut(grantee: IGrantable): Grant;
+    /**
+     * Add an event notification to the bucket.
+     * @param event The event type to trigger on
+     * @param dest The notification destination
+     * @param filters Optional key filters
+     */
+    addEventNotification(event: EventType, dest: IBucketNotificationDestination, ...filters: NotificationKeyFilter[]): void;
+    /**
+     * Add an object created notification.
+     * @param dest The notification destination
+     * @param filters Optional key filters
+     */
+    addObjectCreatedNotification(dest: IBucketNotificationDestination, ...filters: NotificationKeyFilter[]): void;
+    /**
+     * Add an object removed notification.
+     * @param dest The notification destination
+     * @param filters Optional key filters
+     */
+    addObjectRemovedNotification(dest: IBucketNotificationDestination, ...filters: NotificationKeyFilter[]): void;
+}
+/**
+ * Private storage interface.
+ * Standard S3 bucket with optional encryption and versioning.
+ */
+export interface IPrivateStorage extends IStorage {
+    readonly storageType: "private";
+    /**
+     * Grant public access to objects under a prefix.
+     * Use with caution - makes objects publicly readable.
+     * @param keyPrefix Key prefixes to grant public access to
+     */
+    grantPublicAccess(...keyPrefix: string[]): Grant;
+}
+/**
+ * Website storage interface.
+ * S3 bucket configured for static website hosting.
+ */
+export interface IWebsiteStorage extends IStorage {
+    readonly storageType: "website";
+    /** Get the website URL. */
+    getWebsiteUrl(): string;
+}
+/**
+ * Public read storage interface.
+ * S3 bucket with public read access enabled.
+ */
+export interface IPublicStorage extends IStorage {
+    readonly storageType: "publicRead";
+}
+/**
+ * Union type representing any storage interface.
+ * Use with type guards for generic handling.
+ */
+export type AnyStorage = IPrivateStorage | IWebsiteStorage | IPublicStorage;
+/**
+ * Type guard to check if a storage is private.
+ */
+export declare function isPrivateStorage(storage: IStorage): storage is IPrivateStorage;
+/**
+ * Type guard to check if a storage is a website bucket.
+ */
+export declare function isWebsiteStorage(storage: IStorage): storage is IWebsiteStorage;
+/**
+ * Type guard to check if a storage is public read.
+ */
+export declare function isPublicStorage(storage: IStorage): storage is IPublicStorage;
+/**
+ * Type guard to check if a resource is any storage type.
+ */
+export declare function isStorage(resource: unknown): resource is IStorage;

package/dist/lib/patterns/aws/interfaces/storage.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Type-safe storage interfaces.
+ *
+ * These interfaces provide compile-time type safety for storage resources.
+ * All S3 bucket types are grouped under the Storage umbrella, with specific
+ * interfaces for each bucket type.
+ *
+ * @example
+ * const assets = app.addStorage(StorageFactory.build("Assets", { bucketType: "private" }));
+ * assets.getBucketName(); // ✓ Available on all storage types
+ *
+ * const website = app.addStorage(StorageFactory.build("Site", { bucketType: "website" }));
+ * website.getWebsiteUrl(); // ✓ Available on IWebsiteStorage
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPrivateStorage = isPrivateStorage;
+exports.isWebsiteStorage = isWebsiteStorage;
+exports.isPublicStorage = isPublicStorage;
+exports.isStorage = isStorage;
+/**
+ * Type guard to check if a storage is private.
+ */
+function isPrivateStorage(storage) {
+    return storage.storageType === "private";
+}
+/**
+ * Type guard to check if a storage is a website bucket.
+ */
+function isWebsiteStorage(storage) {
+    return storage.storageType === "website";
+}
+/**
+ * Type guard to check if a storage is public read.
+ */
+function isPublicStorage(storage) {
+    return storage.storageType === "publicRead";
+}
+/**
+ * Type guard to check if a resource is any storage type.
+ */
+function isStorage(resource) {
+    return (resource !== null &&
+        typeof resource === "object" &&
+        "storageType" in resource &&
+        typeof resource.storageType === "string");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../../../../lib/patterns/aws/interfaces/storage.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;AAqJH,4CAIC;AAKD,4CAIC;AAKD,0CAEC;AAKD,8BAOC;AAnCD;;GAEG;AACH,SAAgB,gBAAgB,CAC9B,OAAiB;IAEjB,OAAO,OAAO,CAAC,WAAW,KAAK,SAAS,CAAC;AAC3C,CAAC;AAED;;GAEG;AACH,SAAgB,gBAAgB,CAC9B,OAAiB;IAEjB,OAAO,OAAO,CAAC,WAAW,KAAK,SAAS,CAAC;AAC3C,CAAC;AAED;;GAEG;AACH,SAAgB,eAAe,CAAC,OAAiB;IAC/C,OAAO,OAAO,CAAC,WAAW,KAAK,YAAY,CAAC;AAC9C,CAAC;AAED;;GAEG;AACH,SAAgB,SAAS,CAAC,QAAiB;IACzC,OAAO,CACL,QAAQ,KAAK,IAAI;QACjB,OAAO,QAAQ,KAAK,QAAQ;QAC5B,aAAa,IAAI,QAAQ;QACzB,OAAQ,QAAqB,CAAC,WAAW,KAAK,QAAQ,CACvD,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Type-safe storage interfaces.\n *\n * These interfaces provide compile-time type safety for storage resources.\n * All S3 bucket types are grouped under the Storage umbrella, with specific\n * interfaces for each bucket type.\n *\n * @example\n * const assets = app.addStorage(StorageFactory.build(\"Assets\", { bucketType: \"private\" }));\n * assets.getBucketName(); // ✓ Available on all storage types\n *\n * const website = app.addStorage(StorageFactory.build(\"Site\", { bucketType: \"website\" }));\n * website.getWebsiteUrl(); // ✓ Available on IWebsiteStorage\n */\n\nimport {\n  type IBucket,\n  type EventType,\n  type IBucketNotificationDestination,\n  type NotificationKeyFilter\n} from \"aws-cdk-lib/aws-s3\";\nimport { type IGrantable, type Grant } from \"aws-cdk-lib/aws-iam\";\nimport { type Construct } from \"constructs\";\n\n/**\n * Storage type discriminator.\n * Maps to S3 bucket configurations.\n */\nexport type StorageType = \"private\" | \"website\" | \"publicRead\";\n\n/**\n * Base storage interface.\n * All storage types implement this interface.\n */\nexport interface IStorage {\n  /** The type of storage resource. Used for runtime type narrowing. */\n  readonly storageType: StorageType;\n\n  /** The underlying CDK construct node. */\n  readonly node: Construct[\"node\"];\n\n  /** Get the underlying S3 bucket. */\n  getBucket(): IBucket;\n\n  /** Get the bucket ARN. */\n  getBucketArn(): string;\n\n  /** Get the bucket name. */\n  getBucketName(): string;\n\n  /** Get the bucket domain name. */\n  getBucketDomainName(): string;\n\n  /** Get the regional bucket domain name. */\n  getBucketRegionalDomainName(): string;\n\n  /**\n   * Grant read permissions to a grantee.\n   * @param grantee The principal to grant read permissions to\n   */\n  grantRead(grantee: IGrantable): Grant;\n\n  /**\n   * Grant write permissions to a grantee.\n   * @param grantee The principal to grant write permissions to\n   */\n  grantWrite(grantee: IGrantable): Grant;\n\n  /**\n   * Grant read and write permissions to a grantee.\n   * @param grantee The principal to grant permissions to\n   */\n  grantReadWrite(grantee: IGrantable): Grant;\n\n  /**\n   * Grant delete permissions to a grantee.\n   * @param grantee The principal to grant delete permissions to\n   */\n  grantDelete(grantee: IGrantable): Grant;\n\n  /**\n   * Grant put permissions to a grantee.\n   * @param grantee The principal to grant put permissions to\n   */\n  grantPut(grantee: IGrantable): Grant;\n\n  /**\n   * Add an event notification to the bucket.\n   * @param event The event type to trigger on\n   * @param dest The notification destination\n   * @param filters Optional key filters\n   */\n  addEventNotification(\n    event: EventType,\n    dest: IBucketNotificationDestination,\n    ...filters: NotificationKeyFilter[]\n  ): void;\n\n  /**\n   * Add an object created notification.\n   * @param dest The notification destination\n   * @param filters Optional key filters\n   */\n  addObjectCreatedNotification(\n    dest: IBucketNotificationDestination,\n    ...filters: NotificationKeyFilter[]\n  ): void;\n\n  /**\n   * Add an object removed notification.\n   * @param dest The notification destination\n   * @param filters Optional key filters\n   */\n  addObjectRemovedNotification(\n    dest: IBucketNotificationDestination,\n    ...filters: NotificationKeyFilter[]\n  ): void;\n}\n\n/**\n * Private storage interface.\n * Standard S3 bucket with optional encryption and versioning.\n */\nexport interface IPrivateStorage extends IStorage {\n  readonly storageType: \"private\";\n\n  /**\n   * Grant public access to objects under a prefix.\n   * Use with caution - makes objects publicly readable.\n   * @param keyPrefix Key prefixes to grant public access to\n   */\n  grantPublicAccess(...keyPrefix: string[]): Grant;\n}\n\n/**\n * Website storage interface.\n * S3 bucket configured for static website hosting.\n */\nexport interface IWebsiteStorage extends IStorage {\n  readonly storageType: \"website\";\n\n  /** Get the website URL. */\n  getWebsiteUrl(): string;\n}\n\n/**\n * Public read storage interface.\n * S3 bucket with public read access enabled.\n */\nexport interface IPublicStorage extends IStorage {\n  readonly storageType: \"publicRead\";\n}\n\n/**\n * Union type representing any storage interface.\n * Use with type guards for generic handling.\n */\nexport type AnyStorage = IPrivateStorage | IWebsiteStorage | IPublicStorage;\n\n/**\n * Type guard to check if a storage is private.\n */\nexport function isPrivateStorage(\n  storage: IStorage\n): storage is IPrivateStorage {\n  return storage.storageType === \"private\";\n}\n\n/**\n * Type guard to check if a storage is a website bucket.\n */\nexport function isWebsiteStorage(\n  storage: IStorage\n): storage is IWebsiteStorage {\n  return storage.storageType === \"website\";\n}\n\n/**\n * Type guard to check if a storage is public read.\n */\nexport function isPublicStorage(storage: IStorage): storage is IPublicStorage {\n  return storage.storageType === \"publicRead\";\n}\n\n/**\n * Type guard to check if a resource is any storage type.\n */\nexport function isStorage(resource: unknown): resource is IStorage {\n  return (\n    resource !== null &&\n    typeof resource === \"object\" &&\n    \"storageType\" in resource &&\n    typeof (resource as IStorage).storageType === \"string\"\n  );\n}\n"]}