@fjall/components-infrastructure 0.86.1 → 0.87.3

package/dist/lib/patterns/aws/messaging.d.ts

@@ -0,0 +1,183 @@
+import { type Construct } from "constructs";
+import { type IGrantable, type Grant } from "aws-cdk-lib/aws-iam";
+import type App from "../../app";
+import { SQSQueue } from "../../resources/aws/messaging/sqs";
+import { SNSTopic } from "../../resources/aws/messaging/sns";
+import { EventBridgeBus } from "../../resources/aws/messaging/eventbridge";
+import { type IQueueMessaging, type ITopicMessaging, type IEventBusMessaging, type AnyMessaging } from "./interfaces/messaging.js";
+import { type IQueueConnector } from "./interfaces/connector.js";
+/**
+ * Queue messaging props with type discriminator.
+ */
+export interface IQueueProps {
+    /** Type discriminator for messaging type. */
+    type: "queue";
+    queueType?: "standard" | "fifo";
+    visibilityTimeout?: number;
+    messageRetentionPeriod?: number;
+    receiveMessageWaitTime?: number;
+    maxMessageSize?: number;
+    deliveryDelay?: number;
+    deadLetterQueue?: {
+        enabled: boolean;
+        maxReceiveCount?: number;
+    };
+    encryption?: "SSE_SQS" | "SSE_KMS" | "NONE";
+    kmsKeyArn?: string;
+    contentBasedDeduplication?: boolean;
+    fifoThroughputLimit?: "perQueue" | "perMessageGroupId";
+    deduplicationScope?: "queue" | "messageGroup";
+    removalPolicy?: "DESTROY" | "RETAIN";
+}
+/**
+ * Topic messaging props with type discriminator.
+ */
+export interface ITopicProps {
+    /** Type discriminator for messaging type. */
+    type: "topic";
+    topicName?: string;
+    displayName?: string;
+    fifo?: boolean;
+    contentBasedDeduplication?: boolean;
+    removalPolicy?: "DESTROY" | "RETAIN";
+}
+/**
+ * EventBus messaging props with type discriminator.
+ */
+export interface IEventBusProps {
+    /** Type discriminator for messaging type. */
+    type: "eventBus";
+    eventBusName?: string;
+    removalPolicy?: "DESTROY" | "RETAIN";
+}
+/**
+ * Union type for all messaging props.
+ */
+export type IMessagingProps = IQueueProps | ITopicProps | IEventBusProps;
+/**
+ * SQS queue messaging wrapper implementing IQueueMessaging interface.
+ * Provides grant methods and Fjall patterns for queue messaging.
+ */
+export declare class QueueMessaging extends SQSQueue implements IQueueMessaging, IQueueConnector {
+    /** Type discriminator for runtime type narrowing. */
+    readonly messagingType: "queue";
+    /** The connector type for unified connection processing. */
+    readonly connectorType: "queue";
+    constructor(scope: Construct, id: string, props: IQueueProps);
+    /**
+     * Grant send message permissions to the grantee.
+     * Implements IQueueMessaging.grantSendMessages.
+     */
+    grantSendMessages(grantee: IGrantable): Grant;
+    /**
+     * Grant consume (receive and delete) message permissions to the grantee.
+     * Implements IQueueMessaging.grantConsumeMessages.
+     */
+    grantConsumeMessages(grantee: IGrantable): Grant;
+    /**
+     * Grant purge permissions to the grantee.
+     * Implements IQueueMessaging.grantPurge.
+     */
+    grantPurge(grantee: IGrantable): Grant;
+    /**
+     * Grant specific actions to the grantee.
+     * Implements IQueueMessaging.grant.
+     */
+    grant(grantee: IGrantable, ...actions: string[]): Grant;
+    /**
+     * Grant full access (send and consume) to the grantee.
+     * Implements IQueueMessaging.grantFull and IQueueConnector.grantFull.
+     */
+    grantFull(grantee: IGrantable): Grant;
+}
+/**
+ * SNS topic messaging wrapper implementing ITopicMessaging interface.
+ * Provides grant methods and Fjall patterns for topic messaging.
+ */
+export declare class TopicMessaging extends SNSTopic implements ITopicMessaging {
+    /** Type discriminator for runtime type narrowing. */
+    readonly messagingType: "topic";
+    constructor(scope: Construct, id: string, props: ITopicProps);
+    /**
+     * Grant publish permissions to the grantee.
+     * Implements ITopicMessaging.grantPublish.
+     */
+    grantPublish(grantee: IGrantable): Grant;
+    /**
+     * Grant subscribe permissions to the grantee.
+     * Implements ITopicMessaging.grantSubscribe.
+     */
+    grantSubscribe(grantee: IGrantable): Grant;
+}
+/**
+ * EventBridge event bus messaging wrapper implementing IEventBusMessaging interface.
+ * Provides grant methods and Fjall patterns for event-driven messaging.
+ */
+export declare class EventBusMessaging extends EventBridgeBus implements IEventBusMessaging {
+    /** Type discriminator for runtime type narrowing. */
+    readonly messagingType: "eventBus";
+    constructor(scope: Construct, id: string, props: IEventBusProps);
+    /**
+     * Grant put events permissions to the grantee.
+     * Implements IEventBusMessaging.grantPutEventsTo.
+     */
+    grantPutEventsTo(grantee: IGrantable): Grant;
+}
+/**
+ * Factory for creating messaging resources.
+ *
+ * Supports:
+ * - Queue (SQS)
+ * - Topic (SNS)
+ * - EventBus (EventBridge)
+ *
+ * @example
+ * // Standard queue with DLQ
+ * const notifications = app.addMessaging(MessagingFactory.build("Notifications", {
+ *   type: "queue",
+ *   queueType: "standard",
+ *   deadLetterQueue: { enabled: true, maxReceiveCount: 3 }
+ * }));
+ *
+ * @example
+ * // SNS Topic for pub/sub
+ * const alerts = app.addMessaging(MessagingFactory.build("Alerts", {
+ *   type: "topic",
+ *   displayName: "Alert Notifications"
+ * }));
+ *
+ * @example
+ * // EventBridge for event-driven architecture
+ * const events = app.addMessaging(MessagingFactory.build("DomainEvents", {
+ *   type: "eventBus"
+ * }));
+ *
+ * @example
+ * // Grant permissions
+ * notifications.grantSendMessages(producerLambda);
+ * alerts.grantPublish(apiService);
+ * events.grantPutEventsTo(orderService);
+ */
+export declare class MessagingFactory {
+    /**
+     * Build a queue messaging factory function.
+     */
+    static build(id: string, props: IQueueProps): (app: App, scope: Construct) => QueueMessaging;
+    /**
+     * Build a topic messaging factory function.
+     */
+    static build(id: string, props: ITopicProps): (app: App, scope: Construct) => TopicMessaging;
+    /**
+     * Build an event bus messaging factory function.
+     */
+    static build(id: string, props: IEventBusProps): (app: App, scope: Construct) => EventBusMessaging;
+    /**
+     * Build a messaging factory function (generic).
+     */
+    static build(id: string, props: IMessagingProps): (app: App, scope: Construct) => AnyMessaging;
+}
+export type { SQSQueueProps } from "../../resources/aws/messaging/sqs";
+export type { SNSTopicProps } from "../../resources/aws/messaging/sns";
+export type { EventBridgeBusProps } from "../../resources/aws/messaging/eventbridge";
+export type { IQueueMessaging, ITopicMessaging, IEventBusMessaging, AnyMessaging, IQueue, ITopic, IEventBus } from "./interfaces/messaging.js";
+export { isQueueMessaging, isTopicMessaging, isEventBusMessaging } from "./interfaces/messaging.js";

package/dist/lib/patterns/aws/messaging.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEventBusMessaging = exports.isTopicMessaging = exports.isQueueMessaging = exports.MessagingFactory = exports.EventBusMessaging = exports.TopicMessaging = exports.QueueMessaging = void 0;
+const sqs_1 = require("../../resources/aws/messaging/sqs");
+const sns_1 = require("../../resources/aws/messaging/sns");
+const eventbridge_1 = require("../../resources/aws/messaging/eventbridge");
+const validationLogger_js_1 = require("../../utils/validationLogger.js");
+/**
+ * Validates SQS props and logs warnings for misconfigured options.
+ */
+function validateSQSProps(props) {
+    // Validate visibility timeout range (0-43200 seconds = 12 hours)
+    if (props.visibilityTimeout !== undefined &&
+        (props.visibilityTimeout < 0 || props.visibilityTimeout > 43200)) {
+        throw new Error("visibilityTimeout must be between 0 and 43200 seconds (12 hours)");
+    }
+    // Validate message retention period (60-1209600 seconds = 1 minute to 14 days)
+    if (props.messageRetentionPeriod !== undefined &&
+        (props.messageRetentionPeriod < 60 ||
+            props.messageRetentionPeriod > 1209600)) {
+        throw new Error("messageRetentionPeriod must be between 60 and 1209600 seconds (1 minute to 14 days)");
+    }
+    // Warn about FIFO-specific options on standard queues
+    if (props.queueType !== "fifo") {
+        if (props.contentBasedDeduplication !== undefined) {
+            validationLogger_js_1.FjallLogger.warn("'contentBasedDeduplication' is only applicable to FIFO queues. " +
+                "This setting will be ignored for standard queues.");
+        }
+        if (props.fifoThroughputLimit !== undefined) {
+            validationLogger_js_1.FjallLogger.warn("'fifoThroughputLimit' is only applicable to FIFO queues. " +
+                "This setting will be ignored for standard queues.");
+        }
+        if (props.deduplicationScope !== undefined) {
+            validationLogger_js_1.FjallLogger.warn("'deduplicationScope' is only applicable to FIFO queues. " +
+                "This setting will be ignored for standard queues.");
+        }
+    }
+    // Validate KMS encryption
+    if (props.kmsKeyArn && props.encryption !== "SSE_KMS") {
+        validationLogger_js_1.FjallLogger.warn("'kmsKeyArn' provided but 'encryption' is not SSE_KMS. " +
+            "The KMS key will be ignored.");
+    }
+}
+/**
+ * Validates SNS Topic props.
+ */
+function validateTopicProps(props) {
+    // Warn about FIFO-specific options on standard topics
+    if (!props.fifo && props.contentBasedDeduplication !== undefined) {
+        validationLogger_js_1.FjallLogger.warn("'contentBasedDeduplication' is only applicable to FIFO topics. " +
+            "This setting will be ignored for standard topics.");
+    }
+}
+/**
+ * SQS queue messaging wrapper implementing IQueueMessaging interface.
+ * Provides grant methods and Fjall patterns for queue messaging.
+ */
+class QueueMessaging extends sqs_1.SQSQueue {
+    constructor(scope, id, props) {
+        const queueProps = {
+            queueType: props.queueType,
+            visibilityTimeout: props.visibilityTimeout,
+            messageRetentionPeriod: props.messageRetentionPeriod,
+            receiveMessageWaitTime: props.receiveMessageWaitTime,
+            maxMessageSize: props.maxMessageSize,
+            deliveryDelay: props.deliveryDelay,
+            deadLetterQueue: props.deadLetterQueue,
+            encryption: props.encryption,
+            kmsKeyArn: props.kmsKeyArn,
+            contentBasedDeduplication: props.contentBasedDeduplication,
+            fifoThroughputLimit: props.fifoThroughputLimit,
+            deduplicationScope: props.deduplicationScope,
+            removalPolicy: props.removalPolicy
+        };
+        super(scope, id, queueProps);
+        /** Type discriminator for runtime type narrowing. */
+        this.messagingType = "queue";
+        /** The connector type for unified connection processing. */
+        this.connectorType = "queue";
+    }
+    /**
+     * Grant send message permissions to the grantee.
+     * Implements IQueueMessaging.grantSendMessages.
+     */
+    grantSendMessages(grantee) {
+        return this.getQueue().grantSendMessages(grantee);
+    }
+    /**
+     * Grant consume (receive and delete) message permissions to the grantee.
+     * Implements IQueueMessaging.grantConsumeMessages.
+     */
+    grantConsumeMessages(grantee) {
+        return this.getQueue().grantConsumeMessages(grantee);
+    }
+    /**
+     * Grant purge permissions to the grantee.
+     * Implements IQueueMessaging.grantPurge.
+     */
+    grantPurge(grantee) {
+        return this.getQueue().grantPurge(grantee);
+    }
+    /**
+     * Grant specific actions to the grantee.
+     * Implements IQueueMessaging.grant.
+     */
+    grant(grantee, ...actions) {
+        return this.getQueue().grant(grantee, ...actions);
+    }
+    /**
+     * Grant full access (send and consume) to the grantee.
+     * Implements IQueueMessaging.grantFull and IQueueConnector.grantFull.
+     */
+    grantFull(grantee) {
+        this.grantSendMessages(grantee);
+        return this.grantConsumeMessages(grantee);
+    }
+}
+exports.QueueMessaging = QueueMessaging;
+/**
+ * SNS topic messaging wrapper implementing ITopicMessaging interface.
+ * Provides grant methods and Fjall patterns for topic messaging.
+ */
+class TopicMessaging extends sns_1.SNSTopic {
+    constructor(scope, id, props) {
+        const topicProps = {
+            topicName: props.topicName,
+            displayName: props.displayName,
+            fifo: props.fifo,
+            contentBasedDeduplication: props.contentBasedDeduplication,
+            removalPolicy: props.removalPolicy
+        };
+        super(scope, id, topicProps);
+        /** Type discriminator for runtime type narrowing. */
+        this.messagingType = "topic";
+    }
+    /**
+     * Grant publish permissions to the grantee.
+     * Implements ITopicMessaging.grantPublish.
+     */
+    grantPublish(grantee) {
+        return this.getTopic().grantPublish(grantee);
+    }
+    /**
+     * Grant subscribe permissions to the grantee.
+     * Implements ITopicMessaging.grantSubscribe.
+     */
+    grantSubscribe(grantee) {
+        return this.getTopic().grantSubscribe(grantee);
+    }
+}
+exports.TopicMessaging = TopicMessaging;
+/**
+ * EventBridge event bus messaging wrapper implementing IEventBusMessaging interface.
+ * Provides grant methods and Fjall patterns for event-driven messaging.
+ */
+class EventBusMessaging extends eventbridge_1.EventBridgeBus {
+    constructor(scope, id, props) {
+        const eventBusProps = {
+            eventBusName: props.eventBusName,
+            removalPolicy: props.removalPolicy
+        };
+        super(scope, id, eventBusProps);
+        /** Type discriminator for runtime type narrowing. */
+        this.messagingType = "eventBus";
+    }
+    /**
+     * Grant put events permissions to the grantee.
+     * Implements IEventBusMessaging.grantPutEventsTo.
+     */
+    grantPutEventsTo(grantee) {
+        return this.getEventBus().grantPutEventsTo(grantee);
+    }
+}
+exports.EventBusMessaging = EventBusMessaging;
+/**
+ * Factory for creating messaging resources.
+ *
+ * Supports:
+ * - Queue (SQS)
+ * - Topic (SNS)
+ * - EventBus (EventBridge)
+ *
+ * @example
+ * // Standard queue with DLQ
+ * const notifications = app.addMessaging(MessagingFactory.build("Notifications", {
+ *   type: "queue",
+ *   queueType: "standard",
+ *   deadLetterQueue: { enabled: true, maxReceiveCount: 3 }
+ * }));
+ *
+ * @example
+ * // SNS Topic for pub/sub
+ * const alerts = app.addMessaging(MessagingFactory.build("Alerts", {
+ *   type: "topic",
+ *   displayName: "Alert Notifications"
+ * }));
+ *
+ * @example
+ * // EventBridge for event-driven architecture
+ * const events = app.addMessaging(MessagingFactory.build("DomainEvents", {
+ *   type: "eventBus"
+ * }));
+ *
+ * @example
+ * // Grant permissions
+ * notifications.grantSendMessages(producerLambda);
+ * alerts.grantPublish(apiService);
+ * events.grantPutEventsTo(orderService);
+ */
+class MessagingFactory {
+    /**
+     * Implementation of the build method.
+     */
+    static build(id, props) {
+        return (_app, scope) => {
+            switch (props.type) {
+                case "queue":
+                    validateSQSProps(props);
+                    return new QueueMessaging(scope, id, props);
+                case "topic":
+                    validateTopicProps(props);
+                    return new TopicMessaging(scope, id, props);
+                case "eventBus":
+                    return new EventBusMessaging(scope, id, props);
+                default: {
+                    const _exhaustive = props;
+                    throw new Error(`Unsupported messaging type: ${_exhaustive.type}`);
+                }
+            }
+        };
+    }
+}
+exports.MessagingFactory = MessagingFactory;
+// Re-export type guards
+var messaging_js_1 = require("./interfaces/messaging.js");
+Object.defineProperty(exports, "isQueueMessaging", { enumerable: true, get: function () { return messaging_js_1.isQueueMessaging; } });
+Object.defineProperty(exports, "isTopicMessaging", { enumerable: true, get: function () { return messaging_js_1.isTopicMessaging; } });
+Object.defineProperty(exports, "isEventBusMessaging", { enumerable: true, get: function () { return messaging_js_1.isEventBusMessaging; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"messaging.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/messaging.ts"],"names":[],"mappings":"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","sourcesContent":["import { type Construct } from \"constructs\";\nimport { type IGrantable, type Grant } from \"aws-cdk-lib/aws-iam\";\n\nimport type App from \"../../app\";\nimport {\n  SQSQueue,\n  type SQSQueueProps\n} from \"../../resources/aws/messaging/sqs\";\nimport {\n  SNSTopic,\n  type SNSTopicProps\n} from \"../../resources/aws/messaging/sns\";\nimport {\n  EventBridgeBus,\n  type EventBridgeBusProps\n} from \"../../resources/aws/messaging/eventbridge\";\nimport { FjallLogger } from \"../../utils/validationLogger.js\";\nimport {\n  type IQueueMessaging,\n  type ITopicMessaging,\n  type IEventBusMessaging,\n  type AnyMessaging\n} from \"./interfaces/messaging.js\";\nimport { type IQueueConnector } from \"./interfaces/connector.js\";\n\n/**\n * Queue messaging props with type discriminator.\n */\nexport interface IQueueProps {\n  /** Type discriminator for messaging type. */\n  type: \"queue\";\n  queueType?: \"standard\" | \"fifo\";\n  visibilityTimeout?: number;\n  messageRetentionPeriod?: number;\n  receiveMessageWaitTime?: number;\n  maxMessageSize?: number;\n  deliveryDelay?: number;\n  deadLetterQueue?: {\n    enabled: boolean;\n    maxReceiveCount?: number;\n  };\n  encryption?: \"SSE_SQS\" | \"SSE_KMS\" | \"NONE\";\n  kmsKeyArn?: string;\n  contentBasedDeduplication?: boolean;\n  fifoThroughputLimit?: \"perQueue\" | \"perMessageGroupId\";\n  deduplicationScope?: \"queue\" | \"messageGroup\";\n  removalPolicy?: \"DESTROY\" | \"RETAIN\";\n}\n\n/**\n * Topic messaging props with type discriminator.\n */\nexport interface ITopicProps {\n  /** Type discriminator for messaging type. */\n  type: \"topic\";\n  topicName?: string;\n  displayName?: string;\n  fifo?: boolean;\n  contentBasedDeduplication?: boolean;\n  removalPolicy?: \"DESTROY\" | \"RETAIN\";\n}\n\n/**\n * EventBus messaging props with type discriminator.\n */\nexport interface IEventBusProps {\n  /** Type discriminator for messaging type. */\n  type: \"eventBus\";\n  eventBusName?: string;\n  removalPolicy?: \"DESTROY\" | \"RETAIN\";\n}\n\n/**\n * Union type for all messaging props.\n */\nexport type IMessagingProps = IQueueProps | ITopicProps | IEventBusProps;\n\n/**\n * Validates SQS props and logs warnings for misconfigured options.\n */\nfunction validateSQSProps(props: IQueueProps): void {\n  // Validate visibility timeout range (0-43200 seconds = 12 hours)\n  if (\n    props.visibilityTimeout !== undefined &&\n    (props.visibilityTimeout < 0 || props.visibilityTimeout > 43200)\n  ) {\n    throw new Error(\n      \"visibilityTimeout must be between 0 and 43200 seconds (12 hours)\"\n    );\n  }\n\n  // Validate message retention period (60-1209600 seconds = 1 minute to 14 days)\n  if (\n    props.messageRetentionPeriod !== undefined &&\n    (props.messageRetentionPeriod < 60 ||\n      props.messageRetentionPeriod > 1209600)\n  ) {\n    throw new Error(\n      \"messageRetentionPeriod must be between 60 and 1209600 seconds (1 minute to 14 days)\"\n    );\n  }\n\n  // Warn about FIFO-specific options on standard queues\n  if (props.queueType !== \"fifo\") {\n    if (props.contentBasedDeduplication !== undefined) {\n      FjallLogger.warn(\n        \"'contentBasedDeduplication' is only applicable to FIFO queues. \" +\n          \"This setting will be ignored for standard queues.\"\n      );\n    }\n    if (props.fifoThroughputLimit !== undefined) {\n      FjallLogger.warn(\n        \"'fifoThroughputLimit' is only applicable to FIFO queues. \" +\n          \"This setting will be ignored for standard queues.\"\n      );\n    }\n    if (props.deduplicationScope !== undefined) {\n      FjallLogger.warn(\n        \"'deduplicationScope' is only applicable to FIFO queues. \" +\n          \"This setting will be ignored for standard queues.\"\n      );\n    }\n  }\n\n  // Validate KMS encryption\n  if (props.kmsKeyArn && props.encryption !== \"SSE_KMS\") {\n    FjallLogger.warn(\n      \"'kmsKeyArn' provided but 'encryption' is not SSE_KMS. \" +\n        \"The KMS key will be ignored.\"\n    );\n  }\n}\n\n/**\n * Validates SNS Topic props.\n */\nfunction validateTopicProps(props: ITopicProps): void {\n  // Warn about FIFO-specific options on standard topics\n  if (!props.fifo && props.contentBasedDeduplication !== undefined) {\n    FjallLogger.warn(\n      \"'contentBasedDeduplication' is only applicable to FIFO topics. \" +\n        \"This setting will be ignored for standard topics.\"\n    );\n  }\n}\n\n/**\n * SQS queue messaging wrapper implementing IQueueMessaging interface.\n * Provides grant methods and Fjall patterns for queue messaging.\n */\nexport class QueueMessaging\n  extends SQSQueue\n  implements IQueueMessaging, IQueueConnector\n{\n  /** Type discriminator for runtime type narrowing. */\n  public readonly messagingType = \"queue\" as const;\n\n  /** The connector type for unified connection processing. */\n  public readonly connectorType = \"queue\" as const;\n\n  constructor(scope: Construct, id: string, props: IQueueProps) {\n    const queueProps: SQSQueueProps = {\n      queueType: props.queueType,\n      visibilityTimeout: props.visibilityTimeout,\n      messageRetentionPeriod: props.messageRetentionPeriod,\n      receiveMessageWaitTime: props.receiveMessageWaitTime,\n      maxMessageSize: props.maxMessageSize,\n      deliveryDelay: props.deliveryDelay,\n      deadLetterQueue: props.deadLetterQueue,\n      encryption: props.encryption,\n      kmsKeyArn: props.kmsKeyArn,\n      contentBasedDeduplication: props.contentBasedDeduplication,\n      fifoThroughputLimit: props.fifoThroughputLimit,\n      deduplicationScope: props.deduplicationScope,\n      removalPolicy: props.removalPolicy\n    };\n    super(scope, id, queueProps);\n  }\n\n  /**\n   * Grant send message permissions to the grantee.\n   * Implements IQueueMessaging.grantSendMessages.\n   */\n  public grantSendMessages(grantee: IGrantable): Grant {\n    return this.getQueue().grantSendMessages(grantee);\n  }\n\n  /**\n   * Grant consume (receive and delete) message permissions to the grantee.\n   * Implements IQueueMessaging.grantConsumeMessages.\n   */\n  public grantConsumeMessages(grantee: IGrantable): Grant {\n    return this.getQueue().grantConsumeMessages(grantee);\n  }\n\n  /**\n   * Grant purge permissions to the grantee.\n   * Implements IQueueMessaging.grantPurge.\n   */\n  public grantPurge(grantee: IGrantable): Grant {\n    return this.getQueue().grantPurge(grantee);\n  }\n\n  /**\n   * Grant specific actions to the grantee.\n   * Implements IQueueMessaging.grant.\n   */\n  public grant(grantee: IGrantable, ...actions: string[]): Grant {\n    return this.getQueue().grant(grantee, ...actions);\n  }\n\n  /**\n   * Grant full access (send and consume) to the grantee.\n   * Implements IQueueMessaging.grantFull and IQueueConnector.grantFull.\n   */\n  public grantFull(grantee: IGrantable): Grant {\n    this.grantSendMessages(grantee);\n    return this.grantConsumeMessages(grantee);\n  }\n}\n\n/**\n * SNS topic messaging wrapper implementing ITopicMessaging interface.\n * Provides grant methods and Fjall patterns for topic messaging.\n */\nexport class TopicMessaging extends SNSTopic implements ITopicMessaging {\n  /** Type discriminator for runtime type narrowing. */\n  public readonly messagingType = \"topic\" as const;\n\n  constructor(scope: Construct, id: string, props: ITopicProps) {\n    const topicProps: SNSTopicProps = {\n      topicName: props.topicName,\n      displayName: props.displayName,\n      fifo: props.fifo,\n      contentBasedDeduplication: props.contentBasedDeduplication,\n      removalPolicy: props.removalPolicy\n    };\n    super(scope, id, topicProps);\n  }\n\n  /**\n   * Grant publish permissions to the grantee.\n   * Implements ITopicMessaging.grantPublish.\n   */\n  public grantPublish(grantee: IGrantable): Grant {\n    return this.getTopic().grantPublish(grantee);\n  }\n\n  /**\n   * Grant subscribe permissions to the grantee.\n   * Implements ITopicMessaging.grantSubscribe.\n   */\n  public grantSubscribe(grantee: IGrantable): Grant {\n    return this.getTopic().grantSubscribe(grantee);\n  }\n}\n\n/**\n * EventBridge event bus messaging wrapper implementing IEventBusMessaging interface.\n * Provides grant methods and Fjall patterns for event-driven messaging.\n */\nexport class EventBusMessaging\n  extends EventBridgeBus\n  implements IEventBusMessaging\n{\n  /** Type discriminator for runtime type narrowing. */\n  public readonly messagingType = \"eventBus\" as const;\n\n  constructor(scope: Construct, id: string, props: IEventBusProps) {\n    const eventBusProps: EventBridgeBusProps = {\n      eventBusName: props.eventBusName,\n      removalPolicy: props.removalPolicy\n    };\n    super(scope, id, eventBusProps);\n  }\n\n  /**\n   * Grant put events permissions to the grantee.\n   * Implements IEventBusMessaging.grantPutEventsTo.\n   */\n  public grantPutEventsTo(grantee: IGrantable): Grant {\n    return this.getEventBus().grantPutEventsTo(grantee);\n  }\n}\n\n/**\n * Factory for creating messaging resources.\n *\n * Supports:\n * - Queue (SQS)\n * - Topic (SNS)\n * - EventBus (EventBridge)\n *\n * @example\n * // Standard queue with DLQ\n * const notifications = app.addMessaging(MessagingFactory.build(\"Notifications\", {\n *   type: \"queue\",\n *   queueType: \"standard\",\n *   deadLetterQueue: { enabled: true, maxReceiveCount: 3 }\n * }));\n *\n * @example\n * // SNS Topic for pub/sub\n * const alerts = app.addMessaging(MessagingFactory.build(\"Alerts\", {\n *   type: \"topic\",\n *   displayName: \"Alert Notifications\"\n * }));\n *\n * @example\n * // EventBridge for event-driven architecture\n * const events = app.addMessaging(MessagingFactory.build(\"DomainEvents\", {\n *   type: \"eventBus\"\n * }));\n *\n * @example\n * // Grant permissions\n * notifications.grantSendMessages(producerLambda);\n * alerts.grantPublish(apiService);\n * events.grantPutEventsTo(orderService);\n */\nexport class MessagingFactory {\n  /**\n   * Build a queue messaging factory function.\n   */\n  static build(\n    id: string,\n    props: IQueueProps\n  ): (app: App, scope: Construct) => QueueMessaging;\n\n  /**\n   * Build a topic messaging factory function.\n   */\n  static build(\n    id: string,\n    props: ITopicProps\n  ): (app: App, scope: Construct) => TopicMessaging;\n\n  /**\n   * Build an event bus messaging factory function.\n   */\n  static build(\n    id: string,\n    props: IEventBusProps\n  ): (app: App, scope: Construct) => EventBusMessaging;\n\n  /**\n   * Build a messaging factory function (generic).\n   */\n  static build(\n    id: string,\n    props: IMessagingProps\n  ): (app: App, scope: Construct) => AnyMessaging;\n\n  /**\n   * Implementation of the build method.\n   */\n  static build(\n    id: string,\n    props: IMessagingProps\n  ): (app: App, scope: Construct) => AnyMessaging {\n    return (_app: App, scope: Construct): AnyMessaging => {\n      switch (props.type) {\n        case \"queue\":\n          validateSQSProps(props);\n          return new QueueMessaging(scope, id, props);\n        case \"topic\":\n          validateTopicProps(props);\n          return new TopicMessaging(scope, id, props);\n        case \"eventBus\":\n          return new EventBusMessaging(scope, id, props);\n        default: {\n          const _exhaustive: never = props;\n          throw new Error(\n            `Unsupported messaging type: ${(_exhaustive as IMessagingProps).type}`\n          );\n        }\n      }\n    };\n  }\n}\n\n// Re-export types for convenience\nexport type { SQSQueueProps } from \"../../resources/aws/messaging/sqs\";\nexport type { SNSTopicProps } from \"../../resources/aws/messaging/sns\";\nexport type { EventBridgeBusProps } from \"../../resources/aws/messaging/eventbridge\";\n\n// Re-export interface types\nexport type {\n  IQueueMessaging,\n  ITopicMessaging,\n  IEventBusMessaging,\n  AnyMessaging,\n  IQueue,\n  ITopic,\n  IEventBus\n} from \"./interfaces/messaging.js\";\n\n// Re-export type guards\nexport {\n  isQueueMessaging,\n  isTopicMessaging,\n  isEventBusMessaging\n} from \"./interfaces/messaging.js\";\n"]}

package/dist/lib/patterns/aws/network.js

@@ -4,16 +4,17 @@ exports.Network = exports.NetworkFactory = void 0;
 const constructs_1 = require("constructs");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const vpc_1 = require("../../resources/aws/networking/vpc");
+const validationLogger_js_1 = require("../../utils/validationLogger.js");
 function validateNetworkProps(props) {
     if (props.maxAzs !== undefined && (props.maxAzs < 1 || props.maxAzs > 3)) {
-        console.warn(`[Fjall] Warning: 'maxAzs' should be between 1 and 3. Got: ${props.maxAzs}.`);
+        validationLogger_js_1.FjallLogger.warn(`'maxAzs' should be between 1 and 3. Got: ${props.maxAzs}.`);
     }
     if (typeof props.natGateways === "object" &&
         props.natGateways !== null &&
         props.natGateways.count !== undefined) {
         const maxAzs = props.maxAzs ?? 3;
         if (props.natGateways.count > maxAzs) {
-            console.warn(`[Fjall] Warning: 'natGateways.count' (${props.natGateways.count}) exceeds maxAzs (${maxAzs}).`);
+            validationLogger_js_1.FjallLogger.warn(`'natGateways.count' (${props.natGateways.count}) exceeds maxAzs (${maxAzs}).`);
         }
     }
     if (props.transitGateway && !props.transitGateway.id) {
@@ -78,7 +79,6 @@ class Network extends constructs_1.Construct {
     resolveEndpointsConfig(config) {
         if (config === false)
             return false;
-        // Default: gateway endpoints enabled
         if (config === undefined) {
             return { gateway: { s3: true, dynamodb: true } };
         }
@@ -97,4 +97,4 @@ class Network extends constructs_1.Construct {
     }
 }
 exports.Network = Network;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/network.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport { Fn } from \"aws-cdk-lib\";\nimport { type IVpc } from \"aws-cdk-lib/aws-ec2\";\n\nimport type App from \"../../app\";\nimport { Vpc, type VpcProps } from \"../../resources/aws/networking/vpc\";\n\nexport interface NatConfig {\n  count?: number;\n}\n\nexport interface FlowLogConfig {\n  destination?: \"cloudwatch\" | \"s3\";\n  retentionDays?: number;\n  trafficType?: \"ALL\" | \"ACCEPT\" | \"REJECT\";\n}\n\nexport interface GatewayEndpointsConfig {\n  s3?: boolean;\n  dynamodb?: boolean;\n}\n\nexport interface InterfaceEndpointsConfig {\n  ecr?: boolean;\n  secretsManager?: boolean;\n  kms?: boolean;\n  cloudwatchLogs?: boolean;\n  ssm?: boolean;\n  sts?: boolean;\n}\n\nexport interface VpcEndpointsConfig {\n  gateway?: GatewayEndpointsConfig | false;\n  interface?: InterfaceEndpointsConfig | false;\n}\n\nexport interface SubnetConfig {\n  cidrMask?: number;\n}\n\nexport interface SubnetsConfig {\n  public?: SubnetConfig;\n  private?: SubnetConfig;\n  isolated?: SubnetConfig | false;\n}\n\nexport interface TransitGatewayConfig {\n  id: string;\n}\n\n/**\n * Network (VPC) configuration.\n *\n * @example\n * // Minimal cost VPC (no NAT, gateway endpoints only)\n * { natGateways: false }\n *\n * @example\n * // Production VPC with 1 NAT gateway\n * { natGateways: { count: 1 }, flowLogs: {} }\n *\n * @example\n * // High-availability VPC with interface endpoints\n * { maxAzs: 3, natGateways: { count: 3 }, vpcEndpoints: { interface: { ecr: true } } }\n */\nexport interface INetworkProps {\n  vpcName?: string;\n  maxAzs?: number;\n  cidrMask?: number;\n  natGateways?: NatConfig | false;\n  flowLogs?: FlowLogConfig | false;\n  vpcEndpoints?: VpcEndpointsConfig | false;\n  subnets?: SubnetsConfig;\n  transitGateway?: TransitGatewayConfig;\n}\n\nfunction validateNetworkProps(props: INetworkProps): void {\n  if (props.maxAzs !== undefined && (props.maxAzs < 1 || props.maxAzs > 3)) {\n    console.warn(\n      `[Fjall] Warning: 'maxAzs' should be between 1 and 3. Got: ${props.maxAzs}.`\n    );\n  }\n\n  if (\n    typeof props.natGateways === \"object\" &&\n    props.natGateways !== null &&\n    props.natGateways.count !== undefined\n  ) {\n    const maxAzs = props.maxAzs ?? 3;\n    if (props.natGateways.count > maxAzs) {\n      console.warn(\n        `[Fjall] Warning: 'natGateways.count' (${props.natGateways.count}) exceeds maxAzs (${maxAzs}).`\n      );\n    }\n  }\n\n  if (props.transitGateway && !props.transitGateway.id) {\n    throw new Error(\"Transit Gateway configuration requires 'id'.\");\n  }\n}\n\nexport class NetworkFactory {\n  static build(id: string, props: INetworkProps) {\n    return (app: App, scope: Construct) => {\n      validateNetworkProps(props);\n      return new Network(scope, id, props, app);\n    };\n  }\n}\n\nexport class Network extends Construct {\n  public readonly vpc: Vpc;\n\n  constructor(scope: Construct, id: string, props: INetworkProps, app: App) {\n    super(scope, id);\n    this.vpc = this.createVpc(id, props, app);\n  }\n\n  private createVpc(id: string, props: INetworkProps, app: App): Vpc {\n    const accountId =\n      app.node.tryGetContext(\"accountId\") || process.env.CDK_DEFAULT_ACCOUNT;\n    const region = process.env.CDK_DEFAULT_REGION;\n    const isManagedAccount =\n      app.node.tryGetContext(\"managedAccount\") === \"true\";\n\n    let ipv4IpamPoolId: string | undefined;\n    if (isManagedAccount && accountId && region) {\n      const regionSuffix = region.replace(/-/g, \"\");\n      ipv4IpamPoolId = Fn.importValue(`IpamPoolId${accountId}${regionSuffix}`);\n    }\n\n    const vpcProps: VpcProps = {\n      vpcName: props.vpcName,\n      accountId,\n      region,\n      ipv4IpamPoolId,\n      maxAzs: props.maxAzs,\n      vpcCidrMask: props.cidrMask,\n      subnetCidrMask: props.subnets?.private?.cidrMask,\n      natGatewayConfig: this.resolveNatConfig(props.natGateways),\n      flowLogConfig: this.resolveFlowLogConfig(props.flowLogs),\n      endpointsConfig: this.resolveEndpointsConfig(props.vpcEndpoints)\n    };\n\n    return new Vpc(this, id, vpcProps);\n  }\n\n  private resolveNatConfig(\n    config: NatConfig | false | undefined\n  ): { count?: number } | false | undefined {\n    if (config === undefined) return undefined;\n    if (config === false) return false;\n    return { count: config.count };\n  }\n\n  private resolveFlowLogConfig(config: FlowLogConfig | false | undefined):\n    | {\n        destination?: \"cloudwatch\" | \"s3\";\n        retentionDays?: number;\n        trafficType?: \"ALL\" | \"ACCEPT\" | \"REJECT\";\n      }\n    | false\n    | undefined {\n    if (config === undefined) return undefined;\n    if (config === false) return false;\n    return {\n      destination: config.destination,\n      retentionDays: config.retentionDays,\n      trafficType: config.trafficType\n    };\n  }\n\n  private resolveEndpointsConfig(\n    config: VpcEndpointsConfig | false | undefined\n  ):\n    | {\n        gateway?: { s3?: boolean; dynamodb?: boolean } | false;\n        interface?:\n          | {\n              ecr?: boolean;\n              secretsManager?: boolean;\n              kms?: boolean;\n              cloudwatchLogs?: boolean;\n              ssm?: boolean;\n              sts?: boolean;\n            }\n          | false;\n      }\n    | false\n    | undefined {\n    if (config === false) return false;\n\n    // Default: gateway endpoints enabled\n    if (config === undefined) {\n      return { gateway: { s3: true, dynamodb: true } };\n    }\n\n    return {\n      gateway:\n        config.gateway === false\n          ? false\n          : {\n              s3: config.gateway?.s3 ?? true,\n              dynamodb: config.gateway?.dynamodb ?? true\n            },\n      interface: config.interface === false ? false : config.interface\n    };\n  }\n\n  getVpc(): IVpc {\n    return this.vpc;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/network.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport { Fn } from \"aws-cdk-lib\";\nimport { type IVpc } from \"aws-cdk-lib/aws-ec2\";\n\nimport type App from \"../../app\";\nimport { Vpc, type VpcProps } from \"../../resources/aws/networking/vpc\";\nimport { FjallLogger } from \"../../utils/validationLogger.js\";\n\nexport interface NatConfig {\n  count?: number;\n}\n\nexport interface FlowLogConfig {\n  destination?: \"cloudwatch\" | \"s3\";\n  retentionDays?: number;\n  trafficType?: \"ALL\" | \"ACCEPT\" | \"REJECT\";\n}\n\nexport interface GatewayEndpointsConfig {\n  s3?: boolean;\n  dynamodb?: boolean;\n}\n\nexport interface InterfaceEndpointsConfig {\n  ecr?: boolean;\n  secretsManager?: boolean;\n  kms?: boolean;\n  cloudwatchLogs?: boolean;\n  ssm?: boolean;\n  sts?: boolean;\n}\n\nexport interface VpcEndpointsConfig {\n  gateway?: GatewayEndpointsConfig | false;\n  interface?: InterfaceEndpointsConfig | false;\n}\n\nexport interface SubnetConfig {\n  cidrMask?: number;\n}\n\nexport interface SubnetsConfig {\n  public?: SubnetConfig;\n  private?: SubnetConfig;\n  isolated?: SubnetConfig | false;\n}\n\nexport interface TransitGatewayConfig {\n  id: string;\n}\n\n/**\n * Network (VPC) configuration.\n *\n * @example\n * // Minimal cost VPC (no NAT, gateway endpoints only)\n * { natGateways: false }\n *\n * @example\n * // Production VPC with 1 NAT gateway\n * { natGateways: { count: 1 }, flowLogs: {} }\n *\n * @example\n * // High-availability VPC with interface endpoints\n * { maxAzs: 3, natGateways: { count: 3 }, vpcEndpoints: { interface: { ecr: true } } }\n */\nexport interface INetworkProps {\n  vpcName?: string;\n  maxAzs?: number;\n  cidrMask?: number;\n  natGateways?: NatConfig | false;\n  flowLogs?: FlowLogConfig | false;\n  vpcEndpoints?: VpcEndpointsConfig | false;\n  subnets?: SubnetsConfig;\n  transitGateway?: TransitGatewayConfig;\n}\n\nfunction validateNetworkProps(props: INetworkProps): void {\n  if (props.maxAzs !== undefined && (props.maxAzs < 1 || props.maxAzs > 3)) {\n    FjallLogger.warn(\n      `'maxAzs' should be between 1 and 3. Got: ${props.maxAzs}.`\n    );\n  }\n\n  if (\n    typeof props.natGateways === \"object\" &&\n    props.natGateways !== null &&\n    props.natGateways.count !== undefined\n  ) {\n    const maxAzs = props.maxAzs ?? 3;\n    if (props.natGateways.count > maxAzs) {\n      FjallLogger.warn(\n        `'natGateways.count' (${props.natGateways.count}) exceeds maxAzs (${maxAzs}).`\n      );\n    }\n  }\n\n  if (props.transitGateway && !props.transitGateway.id) {\n    throw new Error(\"Transit Gateway configuration requires 'id'.\");\n  }\n}\n\nexport class NetworkFactory {\n  static build(id: string, props: INetworkProps) {\n    return (app: App, scope: Construct) => {\n      validateNetworkProps(props);\n      return new Network(scope, id, props, app);\n    };\n  }\n}\n\nexport class Network extends Construct {\n  public readonly vpc: Vpc;\n\n  constructor(scope: Construct, id: string, props: INetworkProps, app: App) {\n    super(scope, id);\n    this.vpc = this.createVpc(id, props, app);\n  }\n\n  private createVpc(id: string, props: INetworkProps, app: App): Vpc {\n    const accountId =\n      app.node.tryGetContext(\"accountId\") || process.env.CDK_DEFAULT_ACCOUNT;\n    const region = process.env.CDK_DEFAULT_REGION;\n    const isManagedAccount =\n      app.node.tryGetContext(\"managedAccount\") === \"true\";\n\n    let ipv4IpamPoolId: string | undefined;\n    if (isManagedAccount && accountId && region) {\n      const regionSuffix = region.replace(/-/g, \"\");\n      ipv4IpamPoolId = Fn.importValue(`IpamPoolId${accountId}${regionSuffix}`);\n    }\n\n    const vpcProps: VpcProps = {\n      vpcName: props.vpcName,\n      accountId,\n      region,\n      ipv4IpamPoolId,\n      maxAzs: props.maxAzs,\n      vpcCidrMask: props.cidrMask,\n      subnetCidrMask: props.subnets?.private?.cidrMask,\n      natGatewayConfig: this.resolveNatConfig(props.natGateways),\n      flowLogConfig: this.resolveFlowLogConfig(props.flowLogs),\n      endpointsConfig: this.resolveEndpointsConfig(props.vpcEndpoints)\n    };\n\n    return new Vpc(this, id, vpcProps);\n  }\n\n  private resolveNatConfig(\n    config: NatConfig | false | undefined\n  ): { count?: number } | false | undefined {\n    if (config === undefined) return undefined;\n    if (config === false) return false;\n    return { count: config.count };\n  }\n\n  private resolveFlowLogConfig(config: FlowLogConfig | false | undefined):\n    | {\n        destination?: \"cloudwatch\" | \"s3\";\n        retentionDays?: number;\n        trafficType?: \"ALL\" | \"ACCEPT\" | \"REJECT\";\n      }\n    | false\n    | undefined {\n    if (config === undefined) return undefined;\n    if (config === false) return false;\n    return {\n      destination: config.destination,\n      retentionDays: config.retentionDays,\n      trafficType: config.trafficType\n    };\n  }\n\n  private resolveEndpointsConfig(\n    config: VpcEndpointsConfig | false | undefined\n  ):\n    | {\n        gateway?: { s3?: boolean; dynamodb?: boolean } | false;\n        interface?:\n          | {\n              ecr?: boolean;\n              secretsManager?: boolean;\n              kms?: boolean;\n              cloudwatchLogs?: boolean;\n              ssm?: boolean;\n              sts?: boolean;\n            }\n          | false;\n      }\n    | false\n    | undefined {\n    if (config === false) return false;\n\n    if (config === undefined) {\n      return { gateway: { s3: true, dynamodb: true } };\n    }\n\n    return {\n      gateway:\n        config.gateway === false\n          ? false\n          : {\n              s3: config.gateway?.s3 ?? true,\n              dynamodb: config.gateway?.dynamodb ?? true\n            },\n      interface: config.interface === false ? false : config.interface\n    };\n  }\n\n  getVpc(): IVpc {\n    return this.vpc;\n  }\n}\n"]}

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

@@ -0,0 +1,67 @@
+/**
+ * Pattern Factory for High-Level Infrastructure Patterns.
+ *
+ * PatternFactory creates composite infrastructure patterns that encapsulate
+ * multiple related resources into a single, cohesive unit. This reduces
+ * boilerplate and ensures best practices for common deployment scenarios.
+ *
+ * Currently supported patterns:
+ * - `payload`: Payload CMS deployment with OpenNext
+ *
+ * @example
+ * // Minimal - works out of box
+ * const payload = app.addPattern(PatternFactory.build("PayloadApp", {
+ *   type: "payload",
+ *   name: "my-cms",
+ *   source: "../.."
+ * }));
+ *
+ * @example
+ * // Customised with escape hatches
+ * const payload = app.addPattern(PatternFactory.build("PayloadApp", {
+ *   type: "payload",
+ *   name: "my-cms",
+ *   source: "../..",
+ *   database: { type: "Aurora", publiclyAccessible: false },
+ *   compute: { memorySize: 2048 }
+ * }));
+ *
+ * // Access underlying resources for advanced customisation
+ * payload.getDatabase().grantConnect(otherLambda);
+ * payload.getServer().getLambdaFunction().addEnvironment("CUSTOM", "value");
+ */
+import { type Construct } from "constructs";
+import type App from "../../app.js";
+import { Payload } from "./payload.js";
+import { type IPayloadProps, type IPatternProps, type AnyPattern } from "./interfaces/pattern.js";
+/**
+ * Factory for creating high-level infrastructure patterns.
+ *
+ * Uses discriminated union (type: "payload" | ...) to route to specific implementations.
+ * Each pattern type has specific props and returns a specific interface.
+ */
+export declare class PatternFactory {
+    /**
+     * Build a Payload CMS pattern.
+     *
+     * Creates a complete Payload CMS infrastructure:
+     * - RDS PostgreSQL database (Aurora or Instance)
+     * - S3 buckets (assets, cache, media)
+     * - DynamoDB table (tag cache)
+     * - SQS FIFO queue (revalidation)
+     * - Lambda functions (server, image optimization, revalidation)
+     * - CloudFront distribution
+     *
+     * @param id - Construct ID (used for resource naming)
+     * @param props - Payload pattern configuration
+     * @returns Factory function to create the pattern
+     */
+    static build(id: string, props: IPayloadProps): (app: App, scope: Construct) => Payload;
+    /**
+     * Generic build method (implementation signature).
+     */
+    static build(id: string, props: IPatternProps): (app: App, scope: Construct) => AnyPattern;
+}
+export { Payload };
+export type { IPayloadProps, IPatternProps, AnyPattern, IPayload, PayloadDatabaseConfig, PayloadComputeConfig, PayloadCdnConfig } from "./interfaces/pattern.js";
+export { isPayloadPattern, isPattern } from "./interfaces/pattern.js";