@fjall/components-infrastructure 0.86.0 → 0.87.3

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

@@ -0,0 +1,526 @@
+"use strict";
+/**
+ * Payload CMS Pattern.
+ *
+ * A high-level pattern that creates all infrastructure required for a
+ * Payload CMS deployment using OpenNext.
+ *
+ * Resources created:
+ * - RDS PostgreSQL database (Aurora or Instance)
+ * - 3 S3 buckets (assets, cache, media)
+ * - DynamoDB table (tag cache with GSI)
+ * - SQS FIFO queue (revalidation)
+ * - 3 Lambda functions (server, image optimisation, revalidation)
+ * - CloudFront distribution
+ *
+ * @example
+ * const payload = app.addPattern(PatternFactory.build("PayloadApp", {
+ *   type: "payload",
+ *   name: "my-cms"
+ * }));
+ *
+ * // Escape hatches
+ * payload.getDatabase().grantConnect(otherLambda);
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Payload = void 0;
+const constructs_1 = require("constructs");
+const crypto_1 = require("crypto");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_certificatemanager_1 = require("aws-cdk-lib/aws-certificatemanager");
+const aws_route53_1 = require("aws-cdk-lib/aws-route53");
+const aws_route53_targets_1 = require("aws-cdk-lib/aws-route53-targets");
+const database_js_1 = require("./database.js");
+const compute_js_1 = require("./compute.js");
+const storage_js_1 = require("./storage.js");
+const messaging_js_1 = require("./messaging.js");
+const cdn_js_1 = require("./cdn.js");
+const validationLogger_js_1 = require("../../utils/validationLogger.js");
+const PAYLOAD_DEFAULTS = {
+    /** Path to OpenNext output relative to app folder (CDK runs from fjall/<appname>) */
+    SOURCE: "../..",
+    DATABASE: {
+        TYPE: "Instance",
+        BACKUP_RETENTION: 7,
+        DELETION_PROTECTION: true
+    },
+    COMPUTE: {
+        SERVER_MEMORY: 1536,
+        SERVER_TIMEOUT: 30,
+        IMAGE_MEMORY: 1536,
+        IMAGE_TIMEOUT: 30,
+        REVALIDATION_MEMORY: 768,
+        REVALIDATION_TIMEOUT: 300
+    },
+    CACHE: {
+        MAX_AGE_SECONDS: 31536000 // 1 year
+    },
+    PATHS: {
+        STATIC: "/_next/static/*",
+        IMAGE: "/_next/image*",
+        API: "/api/*",
+        ADMIN: "/admin/*"
+    }
+};
+/**
+ * Convert a name to a valid database name (snake_case, alphanumeric only).
+ */
+function toValidDatabaseName(name) {
+    return name
+        .toLowerCase()
+        .replace(/-/g, "_")
+        .replace(/[^a-z0-9_]/g, "");
+}
+/**
+ * Convert a name to PascalCase for construct IDs.
+ */
+function toPascalCase(name) {
+    return name
+        .replace(/[-_](.)/g, (_, c) => c.toUpperCase())
+        .replace(/^./, (c) => c.toUpperCase());
+}
+/**
+ * Extract root domain from a full domain name.
+ * e.g., "cms.example.com" -> "example.com"
+ */
+function extractRootDomain(domain) {
+    const parts = domain.split(".");
+    return parts.length > 2 ? parts.slice(-2).join(".") : domain;
+}
+/**
+ * Safely get the underlying Lambda function from a compute resource.
+ * Throws a clear error if the function is not available.
+ */
+function requireFunction(compute, name) {
+    const fn = compute.getFunction();
+    if (!fn) {
+        throw new Error(`${name} Lambda function is not available. ` +
+            "This indicates an internal error in compute resource creation.");
+    }
+    return fn;
+}
+/**
+ * Extract Lambda config from props with defaults.
+ */
+function resolveLambdaConfig(config, defaults) {
+    return {
+        memorySize: config?.memorySize ?? defaults.memory,
+        timeout: config?.timeout ?? defaults.timeout,
+        ephemeralStorageSize: config?.ephemeralStorageSize
+    };
+}
+/**
+ * Payload CMS pattern implementation.
+ *
+ * Composes all required AWS resources for a Payload deployment.
+ */
+class Payload extends constructs_1.Construct {
+    constructor(scope, id, app, props) {
+        super(scope, id);
+        this.patternType = "payload";
+        this.app = app;
+        this.props = props;
+        this.pascalName = toPascalCase(props.name);
+        this.payloadSecret = (0, crypto_1.randomBytes)(32).toString("hex");
+        this.registerManifest();
+        this.validateProps();
+        this.createDatabase();
+        this.createStorageBuckets();
+        this.createTagCache();
+        this.createRevalidationQueue();
+        this.createLambdaFunctions();
+        this.createCdn();
+        this.createDnsRecord();
+    }
+    registerManifest() {
+        const manifestPattern = {
+            type: "payload",
+            name: this.props.name,
+            source: PAYLOAD_DEFAULTS.SOURCE
+        };
+        this.app.getManifestCollector().setPattern(manifestPattern);
+    }
+    validateProps() {
+        const dbConfig = this.props.database ?? {};
+        if (dbConfig.publiclyAccessible) {
+            validationLogger_js_1.FjallLogger.warn(`Payload database '${this.props.name}' is configured with public accessibility. ` +
+                "This is a security risk and should only be used for development.");
+        }
+    }
+    createDatabase() {
+        const dbConfig = this.props.database ?? {};
+        const databaseType = dbConfig.type ?? PAYLOAD_DEFAULTS.DATABASE.TYPE;
+        this._database =
+            databaseType === "Aurora"
+                ? this.createAuroraDatabase(dbConfig)
+                : this.createInstanceDatabase(dbConfig);
+    }
+    buildBaseDatabaseProps(dbConfig) {
+        return {
+            databaseName: dbConfig.databaseName ?? toValidDatabaseName(this.props.name),
+            databaseEngine: dbConfig.databaseEngine ?? "postgresql",
+            backupRetention: dbConfig.backupRetention ?? PAYLOAD_DEFAULTS.DATABASE.BACKUP_RETENTION,
+            deletionProtection: dbConfig.deletionProtection ??
+                PAYLOAD_DEFAULTS.DATABASE.DELETION_PROTECTION,
+            publiclyAccessible: dbConfig.publiclyAccessible,
+            port: dbConfig.port,
+            performanceInsights: dbConfig.performanceInsights,
+            proxy: dbConfig.proxy,
+            credentials: dbConfig.credentials,
+            snapshotIdentifier: dbConfig.snapshotIdentifier,
+            snapshotUsername: dbConfig.snapshotUsername
+        };
+    }
+    createAuroraDatabase(dbConfig) {
+        const auroraProps = {
+            type: "Aurora",
+            ...this.buildBaseDatabaseProps(dbConfig),
+            allowedIpCidr: dbConfig.allowedIpCidr,
+            encryption: dbConfig.encryption,
+            writer: dbConfig.writer,
+            readers: dbConfig.readers,
+            allowVpcAccess: dbConfig.allowVpcAccess,
+            monitoringInterval: dbConfig.monitoringInterval,
+            preferredMaintenanceWindow: dbConfig.preferredMaintenanceWindow
+        };
+        return this.app.addDatabase(database_js_1.DatabaseFactory.build(`${this.pascalName}Database`, auroraProps));
+    }
+    createInstanceDatabase(dbConfig) {
+        const instanceProps = {
+            type: "Instance",
+            ...this.buildBaseDatabaseProps(dbConfig),
+            publiclyAccessible: dbConfig.publiclyAccessible ?? false,
+            instanceType: dbConfig.instanceType,
+            allocatedStorage: dbConfig.allocatedStorage,
+            multiAz: dbConfig.multiAz,
+            readReplica: dbConfig.readReplica,
+            encryption: dbConfig.encryption
+        };
+        return this.app.addDatabase(database_js_1.DatabaseFactory.build(`${this.pascalName}Database`, instanceProps));
+    }
+    createStorageBuckets() {
+        this._assetsBucket = this.createAssetsBucket();
+        this._cacheBucket = this.createCacheBucket();
+        this._mediaBucket = this.createMediaBucket();
+    }
+    createAssetsBucket() {
+        const assetsConfig = this.props.storage?.assets ?? {};
+        const assetsProps = {
+            bucketType: "private",
+            versioned: assetsConfig.versioned ?? false,
+            deployment: {
+                source: `${PAYLOAD_DEFAULTS.SOURCE}/.open-next/assets`,
+                prune: true,
+                cacheControl: {
+                    maxAge: PAYLOAD_DEFAULTS.CACHE.MAX_AGE_SECONDS,
+                    immutable: true
+                }
+            }
+        };
+        return this.app.addStorage(storage_js_1.StorageFactory.build(`${this.pascalName}Assets`, assetsProps));
+    }
+    createCacheBucket() {
+        const cacheConfig = this.props.storage?.cache ?? {};
+        const cacheProps = {
+            bucketType: "private",
+            versioned: cacheConfig.versioned ?? false,
+            deployment: {
+                source: `${PAYLOAD_DEFAULTS.SOURCE}/.open-next/cache`,
+                prune: false // ISR adds files at runtime
+            }
+        };
+        return this.app.addStorage(storage_js_1.StorageFactory.build(`${this.pascalName}Cache`, cacheProps));
+    }
+    createMediaBucket() {
+        const mediaConfig = this.props.storage?.media ?? {};
+        const mediaProps = {
+            bucketType: "private",
+            versioned: mediaConfig.versioned ?? false
+        };
+        return this.app.addStorage(storage_js_1.StorageFactory.build(`${this.pascalName}Media`, mediaProps));
+    }
+    createTagCache() {
+        const tagCacheProps = {
+            type: "DynamoDB",
+            partitionKey: { name: "tag", type: "S" },
+            sortKey: { name: "path", type: "S" },
+            globalSecondaryIndexes: [
+                {
+                    indexName: "revalidate",
+                    partitionKey: { name: "path", type: "S" },
+                    sortKey: { name: "revalidatedAt", type: "N" }
+                }
+            ]
+        };
+        this._tagCache = this.app.addDatabase(database_js_1.DatabaseFactory.build(`${this.pascalName}TagCache`, tagCacheProps));
+    }
+    createRevalidationQueue() {
+        const queueConfig = this.props.messaging?.revalidationQueue ?? {};
+        const revalidationTimeout = this.props.compute?.revalidation?.timeout ??
+            PAYLOAD_DEFAULTS.COMPUTE.REVALIDATION_TIMEOUT;
+        // Resolve dead letter queue config
+        let dlqConfig;
+        if (queueConfig.deadLetterQueue === false) {
+            dlqConfig = undefined;
+        }
+        else if (queueConfig.deadLetterQueue) {
+            dlqConfig = {
+                enabled: queueConfig.deadLetterQueue.enabled ?? true,
+                maxReceiveCount: queueConfig.deadLetterQueue.maxReceiveCount ?? 3
+            };
+        }
+        else {
+            dlqConfig = { enabled: true, maxReceiveCount: 3 };
+        }
+        const queueProps = {
+            type: "queue",
+            queueType: "fifo",
+            visibilityTimeout: queueConfig.visibilityTimeout ?? revalidationTimeout,
+            messageRetentionPeriod: queueConfig.messageRetentionPeriod,
+            maxMessageSize: queueConfig.maxMessageSize,
+            contentBasedDeduplication: true,
+            deadLetterQueue: dlqConfig
+        };
+        this._revalidationQueue = this.app.addMessaging(messaging_js_1.MessagingFactory.build(`${this.pascalName}Revalidation`, queueProps));
+    }
+    createLambdaFunctions() {
+        this._server = this.createServerLambda();
+        this._imageOptimisation = this.createImageLambda();
+        this._revalidation = this.createRevalidationLambda();
+    }
+    createServerLambda() {
+        const { memorySize, timeout, ephemeralStorageSize } = resolveLambdaConfig(this.props.compute?.server, {
+            memory: PAYLOAD_DEFAULTS.COMPUTE.SERVER_MEMORY,
+            timeout: PAYLOAD_DEFAULTS.COMPUTE.SERVER_TIMEOUT
+        });
+        const serverProps = {
+            type: "lambda",
+            deployment: "code",
+            code: aws_lambda_1.Code.fromAsset(`${PAYLOAD_DEFAULTS.SOURCE}/.open-next/server-functions/default`),
+            handler: "index.handler",
+            runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+            architecture: aws_lambda_1.Architecture.ARM_64,
+            memorySize,
+            timeout,
+            ephemeralStorageSize,
+            functionUrl: {
+                authType: aws_lambda_1.FunctionUrlAuthType.NONE,
+                invokeMode: compute_js_1.InvokeMode.RESPONSE_STREAM
+            },
+            connections: [this._database],
+            secretsImport: {
+                DATABASE_USERNAME: this._database
+                    .getCredentials()
+                    .getImport("username"),
+                DATABASE_PASSWORD: this._database.getCredentials().getImport("password")
+            },
+            environment: this.buildServerEnvironment()
+        };
+        const server = this.app.addCompute(compute_js_1.ComputeFactory.build(`${this.pascalName}Server`, serverProps));
+        this.grantServerPermissions(server);
+        return server;
+    }
+    buildServerEnvironment() {
+        const baseEnv = {
+            DATABASE_HOST: this._database.getHostEndpoint(),
+            DATABASE_PORT: this._database.getHostPort(),
+            DATABASE_NAME: this._database.getDatabaseName(),
+            DATABASE_SSL: "true",
+            CACHE_BUCKET_NAME: this._cacheBucket.getBucketName(),
+            CACHE_BUCKET_REGION: this.app.region ?? "us-east-1",
+            CACHE_DYNAMO_TABLE: this._tagCache.getTableName(),
+            REVALIDATION_QUEUE_URL: this._revalidationQueue.getQueueUrl(),
+            REVALIDATION_QUEUE_REGION: this.app.region ?? "us-east-1",
+            MEDIA_BUCKET_NAME: this._mediaBucket.getBucketName(),
+            PAYLOAD_SECRET: this.payloadSecret
+        };
+        // Lock down CORS to custom domain when provided
+        const customDomain = this.props.cdn?.domainNames?.[0];
+        if (customDomain) {
+            baseEnv.NEXT_PUBLIC_SERVER_URL = `https://${customDomain}`;
+        }
+        return { ...baseEnv, ...this.props.environment };
+    }
+    grantServerPermissions(server) {
+        const serverFunction = requireFunction(server, "Server");
+        this._cacheBucket.grantReadWrite(serverFunction);
+        this._mediaBucket.grantReadWrite(serverFunction);
+        this._tagCache.grantReadWriteData(serverFunction);
+        this._revalidationQueue.grantSendMessages(serverFunction);
+    }
+    createImageLambda() {
+        const { memorySize, timeout, ephemeralStorageSize } = resolveLambdaConfig(this.props.compute?.imageOptimisation, {
+            memory: PAYLOAD_DEFAULTS.COMPUTE.IMAGE_MEMORY,
+            timeout: PAYLOAD_DEFAULTS.COMPUTE.IMAGE_TIMEOUT
+        });
+        const imageProps = {
+            type: "lambda",
+            deployment: "code",
+            code: aws_lambda_1.Code.fromAsset(`${PAYLOAD_DEFAULTS.SOURCE}/.open-next/image-optimization-function`),
+            handler: "index.handler",
+            runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+            architecture: aws_lambda_1.Architecture.ARM_64,
+            memorySize,
+            timeout,
+            ephemeralStorageSize,
+            functionUrl: { authType: aws_lambda_1.FunctionUrlAuthType.NONE },
+            environment: {
+                BUCKET_NAME: this._assetsBucket.getBucketName(),
+                BUCKET_KEY_PREFIX: "_assets"
+            }
+        };
+        const image = this.app.addCompute(compute_js_1.ComputeFactory.build(`${this.pascalName}ImageOptimisation`, imageProps));
+        const imageFunction = requireFunction(image, "ImageOptimisation");
+        this._assetsBucket.grantRead(imageFunction);
+        return image;
+    }
+    createRevalidationLambda() {
+        const { memorySize, timeout, ephemeralStorageSize } = resolveLambdaConfig(this.props.compute?.revalidation, {
+            memory: PAYLOAD_DEFAULTS.COMPUTE.REVALIDATION_MEMORY,
+            timeout: PAYLOAD_DEFAULTS.COMPUTE.REVALIDATION_TIMEOUT
+        });
+        const revalidationProps = {
+            type: "lambda",
+            deployment: "code",
+            code: aws_lambda_1.Code.fromAsset(`${PAYLOAD_DEFAULTS.SOURCE}/.open-next/revalidation-function`),
+            handler: "index.handler",
+            runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+            architecture: aws_lambda_1.Architecture.ARM_64,
+            memorySize,
+            timeout,
+            ephemeralStorageSize,
+            environment: {
+                CACHE_DYNAMO_TABLE: this._tagCache.getTableName(),
+                CACHE_BUCKET_NAME: this._cacheBucket.getBucketName()
+            }
+        };
+        const revalidation = this.app.addCompute(compute_js_1.ComputeFactory.build(`${this.pascalName}Revalidation`, revalidationProps));
+        const revalidationLambda = revalidation.getLambdaFunction();
+        revalidationLambda.addSqsEventSource(this._revalidationQueue.getQueue(), {
+            batchSize: 5
+        });
+        const revalidationFunction = requireFunction(revalidation, "Revalidation");
+        this._tagCache.grantReadWriteData(revalidationFunction);
+        this._cacheBucket.grantReadWrite(revalidationFunction);
+        this._revalidationQueue.grantConsumeMessages(revalidationFunction);
+        return revalidation;
+    }
+    createCdn() {
+        const { domainNames, certificate } = this.resolveDomainConfig();
+        const cdnProps = {
+            originType: "auto",
+            origin: this._server,
+            cachePolicy: "CACHING_DISABLED",
+            defaultAllowedMethods: "ALL",
+            forwardHostHeader: true,
+            priceClass: "PriceClass_100",
+            domainNames,
+            certificate,
+            behaviours: [
+                {
+                    pathPattern: PAYLOAD_DEFAULTS.PATHS.STATIC,
+                    origin: this._assetsBucket,
+                    cachePolicy: "CACHING_OPTIMIZED"
+                },
+                {
+                    pathPattern: PAYLOAD_DEFAULTS.PATHS.IMAGE,
+                    origin: this._imageOptimisation,
+                    cachePolicy: "CACHING_OPTIMIZED"
+                },
+                {
+                    pathPattern: PAYLOAD_DEFAULTS.PATHS.API,
+                    origin: this._server,
+                    cachePolicy: "CACHING_DISABLED",
+                    allowedMethods: "ALL"
+                },
+                {
+                    pathPattern: PAYLOAD_DEFAULTS.PATHS.ADMIN,
+                    origin: this._server,
+                    cachePolicy: "CACHING_DISABLED",
+                    allowedMethods: "ALL"
+                },
+                ...(this.props.cdn?.behaviours ?? [])
+            ]
+        };
+        this._cdn = this.app.addCdn(cdn_js_1.CdnFactory.build(`${this.pascalName}Cdn`, cdnProps));
+    }
+    resolveDomainConfig() {
+        if (this.props.domain) {
+            return this.resolveSimpleDomain();
+        }
+        if (this.props.cdn?.domainNames?.length) {
+            return this.resolveAdvancedDomain();
+        }
+        return {
+            domainNames: undefined,
+            certificate: undefined,
+            hostedZone: undefined
+        };
+    }
+    resolveSimpleDomain() {
+        const domain = this.props.domain;
+        const rootDomain = extractRootDomain(domain);
+        const hostedZone = aws_route53_1.HostedZone.fromLookup(this, `${this.pascalName}HostedZone`, { domainName: rootDomain });
+        const certificate = new aws_certificatemanager_1.Certificate(this, `${this.pascalName}Certificate`, {
+            domainName: domain,
+            validation: aws_certificatemanager_1.CertificateValidation.fromDns(hostedZone)
+        });
+        return { domainNames: [domain], certificate, hostedZone };
+    }
+    resolveAdvancedDomain() {
+        const cdnConfig = this.props.cdn;
+        const certificate = cdnConfig.certificate ??
+            (cdnConfig.certificateArn
+                ? aws_certificatemanager_1.Certificate.fromCertificateArn(this, `${this.pascalName}Certificate`, cdnConfig.certificateArn)
+                : undefined);
+        return {
+            domainNames: cdnConfig.domainNames,
+            certificate,
+            hostedZone: undefined
+        };
+    }
+    createDnsRecord() {
+        if (!this.props.domain)
+            return;
+        const { hostedZone } = this.resolveDomainConfig();
+        if (!hostedZone)
+            return;
+        new aws_route53_1.ARecord(this, `${this.pascalName}AliasRecord`, {
+            zone: hostedZone,
+            recordName: this.props.domain,
+            target: aws_route53_1.RecordTarget.fromAlias(new aws_route53_targets_1.CloudFrontTarget(this._cdn.getDistribution()))
+        });
+    }
+    getDatabase() {
+        return this._database;
+    }
+    getServer() {
+        return this._server;
+    }
+    getImageOptimisation() {
+        return this._imageOptimisation;
+    }
+    getRevalidation() {
+        return this._revalidation;
+    }
+    getAssetsBucket() {
+        return this._assetsBucket;
+    }
+    getCacheBucket() {
+        return this._cacheBucket;
+    }
+    getMediaBucket() {
+        return this._mediaBucket;
+    }
+    getTagCache() {
+        return this._tagCache;
+    }
+    getRevalidationQueue() {
+        return this._revalidationQueue;
+    }
+    getCdn() {
+        return this._cdn;
+    }
+}
+exports.Payload = Payload;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"payload.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/payload.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Payload CMS Pattern.\n *\n * A high-level pattern that creates all infrastructure required for a\n * Payload CMS deployment using OpenNext.\n *\n * Resources created:\n * - RDS PostgreSQL database (Aurora or Instance)\n * - 3 S3 buckets (assets, cache, media)\n * - DynamoDB table (tag cache with GSI)\n * - SQS FIFO queue (revalidation)\n * - 3 Lambda functions (server, image optimisation, revalidation)\n * - CloudFront distribution\n *\n * @example\n * const payload = app.addPattern(PatternFactory.build(\"PayloadApp\", {\n *   type: \"payload\",\n *   name: \"my-cms\"\n * }));\n *\n * // Escape hatches\n * payload.getDatabase().grantConnect(otherLambda);\n */\n\nimport { Construct } from \"constructs\";\nimport { randomBytes } from \"crypto\";\nimport {\n  Code,\n  Runtime,\n  Architecture,\n  FunctionUrlAuthType,\n  type IFunction\n} from \"aws-cdk-lib/aws-lambda\";\nimport {\n  Certificate,\n  CertificateValidation,\n  type ICertificate\n} from \"aws-cdk-lib/aws-certificatemanager\";\nimport { HostedZone, ARecord, RecordTarget } from \"aws-cdk-lib/aws-route53\";\nimport { CloudFrontTarget } from \"aws-cdk-lib/aws-route53-targets\";\n\nimport type App from \"../../app.js\";\nimport { type IPayloadProps, type IPayload } from \"./interfaces/pattern.js\";\nimport { type ManifestPattern } from \"../../utils/manifestWriter.js\";\nimport {\n  type RelationalDatabase,\n  type DynamoDBDatabase,\n  DatabaseFactory,\n  type AuroraDatabaseProps,\n  type InstanceDatabaseProps,\n  type DynamoDBDatabaseProps\n} from \"./database.js\";\nimport {\n  ComputeFactory,\n  type LambdaCompute,\n  InvokeMode,\n  type CodeLambdaProps\n} from \"./compute.js\";\nimport {\n  StorageFactory,\n  type PrivateStorage,\n  type PrivateS3Props\n} from \"./storage.js\";\nimport {\n  MessagingFactory,\n  type QueueMessaging,\n  type IQueueProps\n} from \"./messaging.js\";\nimport { CdnFactory, type Cdn, type SmartCdnProps } from \"./cdn.js\";\nimport { FjallLogger } from \"../../utils/validationLogger.js\";\n\nconst PAYLOAD_DEFAULTS = {\n  /** Path to OpenNext output relative to app folder (CDK runs from fjall/<appname>) */\n  SOURCE: \"../..\",\n  DATABASE: {\n    TYPE: \"Instance\" as const,\n    BACKUP_RETENTION: 7,\n    DELETION_PROTECTION: true\n  },\n  COMPUTE: {\n    SERVER_MEMORY: 1536,\n    SERVER_TIMEOUT: 30,\n    IMAGE_MEMORY: 1536,\n    IMAGE_TIMEOUT: 30,\n    REVALIDATION_MEMORY: 768,\n    REVALIDATION_TIMEOUT: 300\n  },\n  CACHE: {\n    MAX_AGE_SECONDS: 31536000 // 1 year\n  },\n  PATHS: {\n    STATIC: \"/_next/static/*\",\n    IMAGE: \"/_next/image*\",\n    API: \"/api/*\",\n    ADMIN: \"/admin/*\"\n  }\n} as const;\n\n/**\n * Convert a name to a valid database name (snake_case, alphanumeric only).\n */\nfunction toValidDatabaseName(name: string): string {\n  return name\n    .toLowerCase()\n    .replace(/-/g, \"_\")\n    .replace(/[^a-z0-9_]/g, \"\");\n}\n\n/**\n * Convert a name to PascalCase for construct IDs.\n */\nfunction toPascalCase(name: string): string {\n  return name\n    .replace(/[-_](.)/g, (_, c) => c.toUpperCase())\n    .replace(/^./, (c) => c.toUpperCase());\n}\n\n/**\n * Extract root domain from a full domain name.\n * e.g., \"cms.example.com\" -> \"example.com\"\n */\nfunction extractRootDomain(domain: string): string {\n  const parts = domain.split(\".\");\n  return parts.length > 2 ? parts.slice(-2).join(\".\") : domain;\n}\n\n/**\n * Safely get the underlying Lambda function from a compute resource.\n * Throws a clear error if the function is not available.\n */\nfunction requireFunction(compute: LambdaCompute, name: string): IFunction {\n  const fn = compute.getFunction();\n  if (!fn) {\n    throw new Error(\n      `${name} Lambda function is not available. ` +\n        \"This indicates an internal error in compute resource creation.\"\n    );\n  }\n  return fn;\n}\n\n/**\n * Base database properties shared between Aurora and Instance.\n * Uses Pick to extract common properties from the database config.\n */\ntype BaseDatabaseProps = Pick<\n  InstanceDatabaseProps,\n  | \"databaseName\"\n  | \"databaseEngine\"\n  | \"backupRetention\"\n  | \"deletionProtection\"\n  | \"publiclyAccessible\"\n  | \"port\"\n  | \"performanceInsights\"\n  | \"proxy\"\n  | \"credentials\"\n  | \"snapshotIdentifier\"\n  | \"snapshotUsername\"\n>;\n\n/**\n * Lambda configuration with resolved defaults.\n */\ninterface ResolvedLambdaConfig {\n  memorySize: number;\n  timeout: number;\n  ephemeralStorageSize?: number;\n}\n\n/**\n * Extract Lambda config from props with defaults.\n */\nfunction resolveLambdaConfig(\n  config:\n    | { memorySize?: number; timeout?: number; ephemeralStorageSize?: number }\n    | undefined,\n  defaults: { memory: number; timeout: number }\n): ResolvedLambdaConfig {\n  return {\n    memorySize: config?.memorySize ?? defaults.memory,\n    timeout: config?.timeout ?? defaults.timeout,\n    ephemeralStorageSize: config?.ephemeralStorageSize\n  };\n}\n\n/**\n * Payload CMS pattern implementation.\n *\n * Composes all required AWS resources for a Payload deployment.\n */\nexport class Payload extends Construct implements IPayload {\n  public readonly patternType = \"payload\" as const;\n\n  private readonly app: App;\n  private readonly props: IPayloadProps;\n  private readonly pascalName: string;\n  private readonly payloadSecret: string;\n\n  private _database!: RelationalDatabase;\n  private _server!: LambdaCompute;\n  private _imageOptimisation!: LambdaCompute;\n  private _revalidation!: LambdaCompute;\n  private _assetsBucket!: PrivateStorage;\n  private _cacheBucket!: PrivateStorage;\n  private _mediaBucket!: PrivateStorage;\n  private _tagCache!: DynamoDBDatabase;\n  private _revalidationQueue!: QueueMessaging;\n  private _cdn!: Cdn;\n\n  constructor(scope: Construct, id: string, app: App, props: IPayloadProps) {\n    super(scope, id);\n\n    this.app = app;\n    this.props = props;\n    this.pascalName = toPascalCase(props.name);\n    this.payloadSecret = randomBytes(32).toString(\"hex\");\n\n    this.registerManifest();\n    this.validateProps();\n\n    this.createDatabase();\n    this.createStorageBuckets();\n    this.createTagCache();\n    this.createRevalidationQueue();\n    this.createLambdaFunctions();\n    this.createCdn();\n    this.createDnsRecord();\n  }\n\n  private registerManifest(): void {\n    const manifestPattern: ManifestPattern = {\n      type: \"payload\",\n      name: this.props.name,\n      source: PAYLOAD_DEFAULTS.SOURCE\n    };\n    this.app.getManifestCollector().setPattern(manifestPattern);\n  }\n\n  private validateProps(): void {\n    const dbConfig = this.props.database ?? {};\n    if (dbConfig.publiclyAccessible) {\n      FjallLogger.warn(\n        `Payload database '${this.props.name}' is configured with public accessibility. ` +\n          \"This is a security risk and should only be used for development.\"\n      );\n    }\n  }\n\n  private createDatabase(): void {\n    const dbConfig = this.props.database ?? {};\n    const databaseType = dbConfig.type ?? PAYLOAD_DEFAULTS.DATABASE.TYPE;\n\n    this._database =\n      databaseType === \"Aurora\"\n        ? this.createAuroraDatabase(dbConfig)\n        : this.createInstanceDatabase(dbConfig);\n  }\n\n  private buildBaseDatabaseProps(\n    dbConfig: NonNullable<IPayloadProps[\"database\"]>\n  ): BaseDatabaseProps {\n    return {\n      databaseName:\n        dbConfig.databaseName ?? toValidDatabaseName(this.props.name),\n      databaseEngine: dbConfig.databaseEngine ?? \"postgresql\",\n      backupRetention:\n        dbConfig.backupRetention ?? PAYLOAD_DEFAULTS.DATABASE.BACKUP_RETENTION,\n      deletionProtection:\n        dbConfig.deletionProtection ??\n        PAYLOAD_DEFAULTS.DATABASE.DELETION_PROTECTION,\n      publiclyAccessible: dbConfig.publiclyAccessible,\n      port: dbConfig.port,\n      performanceInsights: dbConfig.performanceInsights,\n      proxy: dbConfig.proxy,\n      credentials: dbConfig.credentials,\n      snapshotIdentifier: dbConfig.snapshotIdentifier,\n      snapshotUsername: dbConfig.snapshotUsername\n    };\n  }\n\n  private createAuroraDatabase(\n    dbConfig: NonNullable<IPayloadProps[\"database\"]>\n  ): RelationalDatabase {\n    const auroraProps: AuroraDatabaseProps = {\n      type: \"Aurora\",\n      ...this.buildBaseDatabaseProps(dbConfig),\n      allowedIpCidr: dbConfig.allowedIpCidr,\n      encryption: dbConfig.encryption as AuroraDatabaseProps[\"encryption\"],\n      writer: dbConfig.writer,\n      readers: dbConfig.readers,\n      allowVpcAccess: dbConfig.allowVpcAccess,\n      monitoringInterval: dbConfig.monitoringInterval,\n      preferredMaintenanceWindow: dbConfig.preferredMaintenanceWindow\n    };\n    return this.app.addDatabase(\n      DatabaseFactory.build(`${this.pascalName}Database`, auroraProps)\n    );\n  }\n\n  private createInstanceDatabase(\n    dbConfig: NonNullable<IPayloadProps[\"database\"]>\n  ): RelationalDatabase {\n    const instanceProps: InstanceDatabaseProps = {\n      type: \"Instance\",\n      ...this.buildBaseDatabaseProps(dbConfig),\n      publiclyAccessible: dbConfig.publiclyAccessible ?? false,\n      instanceType: dbConfig.instanceType,\n      allocatedStorage: dbConfig.allocatedStorage,\n      multiAz: dbConfig.multiAz,\n      readReplica: dbConfig.readReplica,\n      encryption: dbConfig.encryption as InstanceDatabaseProps[\"encryption\"]\n    };\n    return this.app.addDatabase(\n      DatabaseFactory.build(`${this.pascalName}Database`, instanceProps)\n    );\n  }\n\n  private createStorageBuckets(): void {\n    this._assetsBucket = this.createAssetsBucket();\n    this._cacheBucket = this.createCacheBucket();\n    this._mediaBucket = this.createMediaBucket();\n  }\n\n  private createAssetsBucket(): PrivateStorage {\n    const assetsConfig = this.props.storage?.assets ?? {};\n    const assetsProps: PrivateS3Props = {\n      bucketType: \"private\",\n      versioned: assetsConfig.versioned ?? false,\n      deployment: {\n        source: `${PAYLOAD_DEFAULTS.SOURCE}/.open-next/assets`,\n        prune: true,\n        cacheControl: {\n          maxAge: PAYLOAD_DEFAULTS.CACHE.MAX_AGE_SECONDS,\n          immutable: true\n        }\n      }\n    };\n    return this.app.addStorage(\n      StorageFactory.build(`${this.pascalName}Assets`, assetsProps)\n    );\n  }\n\n  private createCacheBucket(): PrivateStorage {\n    const cacheConfig = this.props.storage?.cache ?? {};\n    const cacheProps: PrivateS3Props = {\n      bucketType: \"private\",\n      versioned: cacheConfig.versioned ?? false,\n      deployment: {\n        source: `${PAYLOAD_DEFAULTS.SOURCE}/.open-next/cache`,\n        prune: false // ISR adds files at runtime\n      }\n    };\n    return this.app.addStorage(\n      StorageFactory.build(`${this.pascalName}Cache`, cacheProps)\n    );\n  }\n\n  private createMediaBucket(): PrivateStorage {\n    const mediaConfig = this.props.storage?.media ?? {};\n    const mediaProps: PrivateS3Props = {\n      bucketType: \"private\",\n      versioned: mediaConfig.versioned ?? false\n    };\n    return this.app.addStorage(\n      StorageFactory.build(`${this.pascalName}Media`, mediaProps)\n    );\n  }\n\n  private createTagCache(): void {\n    const tagCacheProps: DynamoDBDatabaseProps = {\n      type: \"DynamoDB\",\n      partitionKey: { name: \"tag\", type: \"S\" },\n      sortKey: { name: \"path\", type: \"S\" },\n      globalSecondaryIndexes: [\n        {\n          indexName: \"revalidate\",\n          partitionKey: { name: \"path\", type: \"S\" },\n          sortKey: { name: \"revalidatedAt\", type: \"N\" }\n        }\n      ]\n    };\n    this._tagCache = this.app.addDatabase(\n      DatabaseFactory.build(`${this.pascalName}TagCache`, tagCacheProps)\n    );\n  }\n\n  private createRevalidationQueue(): void {\n    const queueConfig = this.props.messaging?.revalidationQueue ?? {};\n    const revalidationTimeout =\n      this.props.compute?.revalidation?.timeout ??\n      PAYLOAD_DEFAULTS.COMPUTE.REVALIDATION_TIMEOUT;\n\n    // Resolve dead letter queue config\n    let dlqConfig: IQueueProps[\"deadLetterQueue\"];\n    if (queueConfig.deadLetterQueue === false) {\n      dlqConfig = undefined;\n    } else if (queueConfig.deadLetterQueue) {\n      dlqConfig = {\n        enabled: queueConfig.deadLetterQueue.enabled ?? true,\n        maxReceiveCount: queueConfig.deadLetterQueue.maxReceiveCount ?? 3\n      };\n    } else {\n      dlqConfig = { enabled: true, maxReceiveCount: 3 };\n    }\n\n    const queueProps: IQueueProps = {\n      type: \"queue\",\n      queueType: \"fifo\",\n      visibilityTimeout: queueConfig.visibilityTimeout ?? revalidationTimeout,\n      messageRetentionPeriod: queueConfig.messageRetentionPeriod,\n      maxMessageSize: queueConfig.maxMessageSize,\n      contentBasedDeduplication: true,\n      deadLetterQueue: dlqConfig\n    };\n    this._revalidationQueue = this.app.addMessaging(\n      MessagingFactory.build(`${this.pascalName}Revalidation`, queueProps)\n    );\n  }\n\n  private createLambdaFunctions(): void {\n    this._server = this.createServerLambda();\n    this._imageOptimisation = this.createImageLambda();\n    this._revalidation = this.createRevalidationLambda();\n  }\n\n  private createServerLambda(): LambdaCompute {\n    const { memorySize, timeout, ephemeralStorageSize } = resolveLambdaConfig(\n      this.props.compute?.server,\n      {\n        memory: PAYLOAD_DEFAULTS.COMPUTE.SERVER_MEMORY,\n        timeout: PAYLOAD_DEFAULTS.COMPUTE.SERVER_TIMEOUT\n      }\n    );\n\n    const serverProps: CodeLambdaProps = {\n      type: \"lambda\",\n      deployment: \"code\",\n      code: Code.fromAsset(\n        `${PAYLOAD_DEFAULTS.SOURCE}/.open-next/server-functions/default`\n      ),\n      handler: \"index.handler\",\n      runtime: Runtime.NODEJS_22_X,\n      architecture: Architecture.ARM_64,\n      memorySize,\n      timeout,\n      ephemeralStorageSize,\n      functionUrl: {\n        authType: FunctionUrlAuthType.NONE,\n        invokeMode: InvokeMode.RESPONSE_STREAM\n      },\n      connections: [this._database],\n      secretsImport: {\n        DATABASE_USERNAME: this._database\n          .getCredentials()\n          .getImport(\"username\"),\n        DATABASE_PASSWORD: this._database.getCredentials().getImport(\"password\")\n      },\n      environment: this.buildServerEnvironment()\n    };\n\n    const server = this.app.addCompute(\n      ComputeFactory.build(`${this.pascalName}Server`, serverProps)\n    );\n\n    this.grantServerPermissions(server);\n    return server;\n  }\n\n  private buildServerEnvironment(): Record<string, string> {\n    const baseEnv: Record<string, string> = {\n      DATABASE_HOST: this._database.getHostEndpoint(),\n      DATABASE_PORT: this._database.getHostPort(),\n      DATABASE_NAME: this._database.getDatabaseName(),\n      DATABASE_SSL: \"true\",\n      CACHE_BUCKET_NAME: this._cacheBucket.getBucketName(),\n      CACHE_BUCKET_REGION: this.app.region ?? \"us-east-1\",\n      CACHE_DYNAMO_TABLE: this._tagCache.getTableName(),\n      REVALIDATION_QUEUE_URL: this._revalidationQueue.getQueueUrl(),\n      REVALIDATION_QUEUE_REGION: this.app.region ?? \"us-east-1\",\n      MEDIA_BUCKET_NAME: this._mediaBucket.getBucketName(),\n      PAYLOAD_SECRET: this.payloadSecret\n    };\n\n    // Lock down CORS to custom domain when provided\n    const customDomain = this.props.cdn?.domainNames?.[0];\n    if (customDomain) {\n      baseEnv.NEXT_PUBLIC_SERVER_URL = `https://${customDomain}`;\n    }\n\n    return { ...baseEnv, ...this.props.environment };\n  }\n\n  private grantServerPermissions(server: LambdaCompute): void {\n    const serverFunction = requireFunction(server, \"Server\");\n    this._cacheBucket.grantReadWrite(serverFunction);\n    this._mediaBucket.grantReadWrite(serverFunction);\n    this._tagCache.grantReadWriteData(serverFunction);\n    this._revalidationQueue.grantSendMessages(serverFunction);\n  }\n\n  private createImageLambda(): LambdaCompute {\n    const { memorySize, timeout, ephemeralStorageSize } = resolveLambdaConfig(\n      this.props.compute?.imageOptimisation,\n      {\n        memory: PAYLOAD_DEFAULTS.COMPUTE.IMAGE_MEMORY,\n        timeout: PAYLOAD_DEFAULTS.COMPUTE.IMAGE_TIMEOUT\n      }\n    );\n\n    const imageProps: CodeLambdaProps = {\n      type: \"lambda\",\n      deployment: \"code\",\n      code: Code.fromAsset(\n        `${PAYLOAD_DEFAULTS.SOURCE}/.open-next/image-optimization-function`\n      ),\n      handler: \"index.handler\",\n      runtime: Runtime.NODEJS_22_X,\n      architecture: Architecture.ARM_64,\n      memorySize,\n      timeout,\n      ephemeralStorageSize,\n      functionUrl: { authType: FunctionUrlAuthType.NONE },\n      environment: {\n        BUCKET_NAME: this._assetsBucket.getBucketName(),\n        BUCKET_KEY_PREFIX: \"_assets\"\n      }\n    };\n\n    const image = this.app.addCompute(\n      ComputeFactory.build(`${this.pascalName}ImageOptimisation`, imageProps)\n    );\n\n    const imageFunction = requireFunction(image, \"ImageOptimisation\");\n    this._assetsBucket.grantRead(imageFunction);\n\n    return image;\n  }\n\n  private createRevalidationLambda(): LambdaCompute {\n    const { memorySize, timeout, ephemeralStorageSize } = resolveLambdaConfig(\n      this.props.compute?.revalidation,\n      {\n        memory: PAYLOAD_DEFAULTS.COMPUTE.REVALIDATION_MEMORY,\n        timeout: PAYLOAD_DEFAULTS.COMPUTE.REVALIDATION_TIMEOUT\n      }\n    );\n\n    const revalidationProps: CodeLambdaProps = {\n      type: \"lambda\",\n      deployment: \"code\",\n      code: Code.fromAsset(\n        `${PAYLOAD_DEFAULTS.SOURCE}/.open-next/revalidation-function`\n      ),\n      handler: \"index.handler\",\n      runtime: Runtime.NODEJS_22_X,\n      architecture: Architecture.ARM_64,\n      memorySize,\n      timeout,\n      ephemeralStorageSize,\n      environment: {\n        CACHE_DYNAMO_TABLE: this._tagCache.getTableName(),\n        CACHE_BUCKET_NAME: this._cacheBucket.getBucketName()\n      }\n    };\n\n    const revalidation = this.app.addCompute(\n      ComputeFactory.build(`${this.pascalName}Revalidation`, revalidationProps)\n    );\n\n    const revalidationLambda = revalidation.getLambdaFunction();\n    revalidationLambda.addSqsEventSource(this._revalidationQueue.getQueue(), {\n      batchSize: 5\n    });\n\n    const revalidationFunction = requireFunction(revalidation, \"Revalidation\");\n    this._tagCache.grantReadWriteData(revalidationFunction);\n    this._cacheBucket.grantReadWrite(revalidationFunction);\n    this._revalidationQueue.grantConsumeMessages(revalidationFunction);\n\n    return revalidation;\n  }\n\n  private createCdn(): void {\n    const { domainNames, certificate } = this.resolveDomainConfig();\n\n    const cdnProps: SmartCdnProps = {\n      originType: \"auto\",\n      origin: this._server,\n      cachePolicy: \"CACHING_DISABLED\",\n      defaultAllowedMethods: \"ALL\",\n      forwardHostHeader: true,\n      priceClass: \"PriceClass_100\",\n      domainNames,\n      certificate,\n      behaviours: [\n        {\n          pathPattern: PAYLOAD_DEFAULTS.PATHS.STATIC,\n          origin: this._assetsBucket,\n          cachePolicy: \"CACHING_OPTIMIZED\"\n        },\n        {\n          pathPattern: PAYLOAD_DEFAULTS.PATHS.IMAGE,\n          origin: this._imageOptimisation,\n          cachePolicy: \"CACHING_OPTIMIZED\"\n        },\n        {\n          pathPattern: PAYLOAD_DEFAULTS.PATHS.API,\n          origin: this._server,\n          cachePolicy: \"CACHING_DISABLED\",\n          allowedMethods: \"ALL\"\n        },\n        {\n          pathPattern: PAYLOAD_DEFAULTS.PATHS.ADMIN,\n          origin: this._server,\n          cachePolicy: \"CACHING_DISABLED\",\n          allowedMethods: \"ALL\"\n        },\n        ...(this.props.cdn?.behaviours ?? [])\n      ]\n    };\n\n    this._cdn = this.app.addCdn(\n      CdnFactory.build(`${this.pascalName}Cdn`, cdnProps)\n    );\n  }\n\n  private resolveDomainConfig(): {\n    domainNames: string[] | undefined;\n    certificate: ICertificate | undefined;\n    hostedZone: ReturnType<typeof HostedZone.fromLookup> | undefined;\n  } {\n    if (this.props.domain) {\n      return this.resolveSimpleDomain();\n    }\n\n    if (this.props.cdn?.domainNames?.length) {\n      return this.resolveAdvancedDomain();\n    }\n\n    return {\n      domainNames: undefined,\n      certificate: undefined,\n      hostedZone: undefined\n    };\n  }\n\n  private resolveSimpleDomain(): {\n    domainNames: string[];\n    certificate: ICertificate;\n    hostedZone: ReturnType<typeof HostedZone.fromLookup>;\n  } {\n    const domain = this.props.domain!;\n    const rootDomain = extractRootDomain(domain);\n\n    const hostedZone = HostedZone.fromLookup(\n      this,\n      `${this.pascalName}HostedZone`,\n      { domainName: rootDomain }\n    );\n\n    const certificate = new Certificate(this, `${this.pascalName}Certificate`, {\n      domainName: domain,\n      validation: CertificateValidation.fromDns(hostedZone)\n    });\n\n    return { domainNames: [domain], certificate, hostedZone };\n  }\n\n  private resolveAdvancedDomain(): {\n    domainNames: string[];\n    certificate: ICertificate | undefined;\n    hostedZone: undefined;\n  } {\n    const cdnConfig = this.props.cdn!;\n    const certificate =\n      cdnConfig.certificate ??\n      (cdnConfig.certificateArn\n        ? Certificate.fromCertificateArn(\n            this,\n            `${this.pascalName}Certificate`,\n            cdnConfig.certificateArn\n          )\n        : undefined);\n\n    return {\n      domainNames: cdnConfig.domainNames!,\n      certificate,\n      hostedZone: undefined\n    };\n  }\n\n  private createDnsRecord(): void {\n    if (!this.props.domain) return;\n\n    const { hostedZone } = this.resolveDomainConfig();\n    if (!hostedZone) return;\n\n    new ARecord(this, `${this.pascalName}AliasRecord`, {\n      zone: hostedZone,\n      recordName: this.props.domain,\n      target: RecordTarget.fromAlias(\n        new CloudFrontTarget(this._cdn.getDistribution())\n      )\n    });\n  }\n\n  getDatabase(): RelationalDatabase {\n    return this._database;\n  }\n\n  getServer(): LambdaCompute {\n    return this._server;\n  }\n\n  getImageOptimisation(): LambdaCompute {\n    return this._imageOptimisation;\n  }\n\n  getRevalidation(): LambdaCompute {\n    return this._revalidation;\n  }\n\n  getAssetsBucket(): PrivateStorage {\n    return this._assetsBucket;\n  }\n\n  getCacheBucket(): PrivateStorage {\n    return this._cacheBucket;\n  }\n\n  getMediaBucket(): PrivateStorage {\n    return this._mediaBucket;\n  }\n\n  getTagCache(): DynamoDBDatabase {\n    return this._tagCache;\n  }\n\n  getRevalidationQueue(): QueueMessaging {\n    return this._revalidationQueue;\n  }\n\n  getCdn(): Cdn {\n    return this._cdn;\n  }\n}\n"]}