@fjall/components-infrastructure 2.29.0 → 2.30.0

package/dist/lib/app.d.ts

@@ -17,7 +17,7 @@ import { type ServiceRegistrationProps } from "./resources/aws/networking/servic
 import { type IPrivateDnsNamespace, type IService } from "aws-cdk-lib/aws-servicediscovery";
 import { type AnyCompute } from "./patterns/aws/compute.js";
 import { type Storage, type StorageFactoryFn } from "./patterns/aws/storage.js";
-import { type AnyPattern } from "./patterns/aws/pattern.js";
+import { type AnyPattern, type PatternFactoryFn } from "./patterns/aws/pattern.js";
 import { type BackupTier } from "./utils/backupTierMapping.js";
 import { type ResourceInventory } from "./aspects/resourceInventory.js";
 import { type ManifestCollector } from "./utils/manifestWriter.js";
@@ -146,8 +146,11 @@ export declare class App extends CdkApp {
     /**
      * Retrieve default CDN stack - named as `${this.name}Cdn`
      *
-     * Depends on Network. Compute/Storage dependencies are added automatically
-     * by CDK when CDN resources reference ALB or S3 bucket resources.
+     * Depends on Network when networking is enabled. Compute/Storage dependencies
+     * are added automatically by CDK when CDN resources reference ALB or S3 bucket
+     * resources. When the app is networkless (a static site: S3 + CloudFront +
+     * forms Function URL), the Network dependency is omitted so no empty Network
+     * stack is synthesised.
      */
     getDefaultCdnStack(): AwsStack;
     /**
@@ -382,7 +385,8 @@ export declare class App extends CdkApp {
      * payload.getServer().getLambdaFunction().addEnvironment("CUSTOM", "value");
      * payload.getCdn().getDistribution().addBehavior("/custom/*", customOrigin);
      */
-    addPattern<T extends AnyPattern & Construct>(fn: (app: App, scope: Construct) => T): T;
+    addPattern<T extends AnyPattern & Construct>(fn: PatternFactoryFn<T>): T;
+    private resolvePatternStack;
     /**
      * Add an additional network (VPC) to the application.
      *

package/dist/lib/app.js

@@ -216,11 +216,14 @@ export class App extends CdkApp {
     /**
      * Retrieve default CDN stack - named as `${this.name}Cdn`
      *
-     * Depends on Network. Compute/Storage dependencies are added automatically
-     * by CDK when CDN resources reference ALB or S3 bucket resources.
+     * Depends on Network when networking is enabled. Compute/Storage dependencies
+     * are added automatically by CDK when CDN resources reference ALB or S3 bucket
+     * resources. When the app is networkless (a static site: S3 + CloudFront +
+     * forms Function URL), the Network dependency is omitted so no empty Network
+     * stack is synthesised.
      */
     getDefaultCdnStack() {
-        return this.getStack(`${this.stackPrefix}Cdn`, this.getDefaultNetworkStack());
+        return this.getStack(`${this.stackPrefix}Cdn`, this.networkDisabled ? undefined : this.getDefaultNetworkStack());
     }
     /**
      * Retrieve default messaging stack - named as `${this.name}Messaging`
@@ -614,11 +617,23 @@ export class App extends CdkApp {
      * payload.getCdn().getDistribution().addBehavior("/custom/*", customOrigin);
      */
     addPattern(fn) {
-        const computeStack = this.getDefaultComputeStack();
-        const pattern = fn(this, computeStack.getStack());
-        computeStack.addConstruct(pattern);
+        const stack = this.resolvePatternStack(fn.stackPlacement);
+        const pattern = fn(this, stack.getStack());
+        stack.addConstruct(pattern);
         return pattern;
     }
+    resolvePatternStack(placement) {
+        switch (placement) {
+            case "cdn":
+                return this.getDefaultCdnStack();
+            case "compute":
+            case undefined:
+                return this.getDefaultComputeStack();
+            default:
+                // Compile error on a new placement — do not let it default to compute.
+                return assertNeverPlacement(placement);
+        }
+    }
     /**
      * Add an additional network (VPC) to the application.
      *
@@ -715,4 +730,7 @@ export class App extends CdkApp {
         return assembly;
     }
 }
+function assertNeverPlacement(value) {
+    throw new Error(`Unhandled pattern stack placement: ${String(value)}`);
+}
 export default App;

package/dist/lib/lambda-assets/static-site-forms/asset/index.js

@@ -0,0 +1,175 @@
+/**
+ * Static-site contact-form handler (Lambda Function URL → SES).
+ *
+ * Authored directly under asset/ as CJS — the only dependency,
+ * @aws-sdk/client-sesv2, ships in the Lambda Node 22 runtime, so there is no
+ * build step. asset/package.json pins CJS resolution.
+ *
+ * Security posture (Function URL authType NONE — see staticSite.ts). The
+ * endpoint is public and unauthenticated. Be precise about what each control
+ * actually buys, because it is easy to mistake this for authentication:
+ * - The Origin/Referer check stops a browser on another site from POSTing here
+ *   (it cannot forge those headers). It does NOT stop a non-browser client,
+ *   which sets them freely. It is a nuisance filter, not an auth gate.
+ * - A populated honeypot field (_gotcha) marks a bot → silent 200, no send.
+ * - What actually bounds abuse: the function's reserved concurrency (capped in
+ *   staticSite.ts, so a flood cannot drain account-wide Lambda concurrency),
+ *   SES account send limits, and the fact that both sender and recipient are
+ *   fixed at deploy time — whatever a caller sends, the mail can only ever go
+ *   from noreply@<domain> to the site owner.
+ *
+ * Logging discipline: status + requestId + SES error NAME only — never the
+ * parsed body or the recipient address (both are submitter PII).
+ */
+"use strict";
+
+const { SESv2Client, SendEmailCommand } = require("@aws-sdk/client-sesv2");
+
+const client = new SESv2Client({});
+
+const CONTACT_TO = process.env.CONTACT_TO;
+const CONTACT_FROM = process.env.CONTACT_FROM;
+const ALLOWED_ORIGIN = process.env.ALLOWED_ORIGIN;
+
+const MAX_NAME = 200;
+const MAX_EMAIL = 320;
+const MAX_MESSAGE = 5000;
+
+exports.handler = async (event) => {
+  const requestId = event?.requestContext?.requestId ?? "unknown";
+  const method = event?.requestContext?.http?.method ?? "";
+
+  if (method !== "POST") {
+    return respond(405, { error: "Method not allowed" });
+  }
+
+  const headers = normaliseHeaders(event?.headers);
+  if (!originAllowed(headers)) {
+    log("warn", "origin rejected", requestId);
+    return respond(403, { error: "Forbidden" });
+  }
+
+  let fields;
+  try {
+    fields = parseBody(event);
+  } catch {
+    log("warn", "invalid body", requestId);
+    return respond(400, { error: "Invalid request body" });
+  }
+
+  // Populated honeypot ⇒ bot: pretend success so it does not probe further.
+  if (typeof fields._gotcha === "string" && fields._gotcha.trim() !== "") {
+    return respond(200, { ok: true });
+  }
+
+  const name = String(fields.name ?? "").slice(0, MAX_NAME);
+  const email = String(fields.email ?? "").slice(0, MAX_EMAIL);
+  const message = String(fields.message ?? "").slice(0, MAX_MESSAGE);
+
+  if (message.trim() === "") {
+    return respond(400, { error: "Message is required" });
+  }
+
+  try {
+    await client.send(
+      new SendEmailCommand({
+        FromEmailAddress: CONTACT_FROM,
+        Destination: { ToAddresses: [CONTACT_TO] },
+        ...(isValidEmail(email) && { ReplyToAddresses: [email] }),
+        Content: {
+          Simple: {
+            Subject: {
+              Data: `Contact form: ${name || "(no name)"}`.slice(0, MAX_NAME)
+            },
+            Body: { Text: { Data: buildBody(name, email, message) } }
+          }
+        }
+      })
+    );
+    log("info", "sent", requestId);
+    return respond(200, { ok: true });
+  } catch (err) {
+    log("error", "ses send failed", requestId, err?.name);
+    return respond(502, { error: "Failed to send message" });
+  }
+};
+
+function normaliseHeaders(headers) {
+  const out = {};
+  if (headers && typeof headers === "object") {
+    for (const [key, value] of Object.entries(headers)) {
+      out[key.toLowerCase()] = value;
+    }
+  }
+  return out;
+}
+
+function originAllowed(headers) {
+  if (!ALLOWED_ORIGIN) return false;
+  const origin = headers.origin;
+  if (origin) return origin === ALLOWED_ORIGIN;
+  // Some clients omit Origin on same-site POSTs — fall back to the Referer's
+  // origin. Compare whole origins: a prefix test would accept a Referer of
+  // https://example.com.attacker.test/ for ALLOWED_ORIGIN https://example.com.
+  const referer = headers.referer;
+  if (referer) return originOf(referer) === ALLOWED_ORIGIN;
+  return false;
+}
+
+function originOf(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return undefined;
+  }
+}
+
+function parseBody(event) {
+  const raw =
+    event?.isBase64Encoded && typeof event.body === "string"
+      ? Buffer.from(event.body, "base64").toString("utf8")
+      : (event?.body ?? "");
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("{")) {
+    return JSON.parse(trimmed);
+  }
+  // application/x-www-form-urlencoded fallback
+  const params = new URLSearchParams(trimmed);
+  const fields = {};
+  for (const [key, value] of params.entries()) {
+    fields[key] = value;
+  }
+  return fields;
+}
+
+function isValidEmail(value) {
+  return /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(value);
+}
+
+function buildBody(name, email, message) {
+  return [
+    `Name: ${name || "(not provided)"}`,
+    `Email: ${email || "(not provided)"}`,
+    "",
+    message
+  ].join("\n");
+}
+
+function respond(statusCode, body) {
+  return {
+    statusCode,
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  };
+}
+
+function log(level, msg, requestId, errorName) {
+  console.log(
+    JSON.stringify({
+      level,
+      msg,
+      requestId,
+      ...(errorName && { error: errorName })
+    })
+  );
+}

package/dist/lib/lambda-assets/static-site-forms/asset/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "commonjs",
+  "private": true
+}

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

@@ -2,10 +2,11 @@ import { type Construct } from "constructs";
 import { type IBucket } from "aws-cdk-lib/aws-s3";
 import { type IApplicationLoadBalancer } from "aws-cdk-lib/aws-elasticloadbalancingv2";
 import { type ICertificate } from "aws-cdk-lib/aws-certificatemanager";
-import { type ICachePolicy } from "aws-cdk-lib/aws-cloudfront";
+import { type ICachePolicy, type IResponseHeadersPolicy } from "aws-cdk-lib/aws-cloudfront";
 import type App from "../../app.js";
 import { CloudFrontDistribution, type CachePolicyPreset, type AccessGateConfig } from "../../resources/aws/cdn/index.js";
 import { type ICdn } from "./interfaces/cdn.js";
+import type { StaticSiteRouting } from "@fjall/util";
 import { type Storage } from "./storage.js";
 import { type AnyCompute } from "./compute.js";
 /**
@@ -32,7 +33,24 @@ export interface S3CdnProps extends BaseCdnProps {
     originType: "s3";
     bucket: IBucket | Storage;
     originPath?: string;
+    /** OAI (default) or OAC (single-stack only — see cloudFront.ts). */
+    originAccess?: "oai" | "oac";
+    /** Object served for `/` (static sites: "index.html"). */
+    defaultRootObject?: string;
+    /** "multipage" → clean-URL `.html` rewriting; "spa" → 403/404 fallback to index. */
+    routing?: StaticSiteRouting;
+    /** Security-headers policy (built by the caller, e.g. SecurityHeadersPolicy). */
+    responseHeadersPolicy?: IResponseHeadersPolicy;
+    /**
+     * Origin-request policy for the default behaviour. Defaults to forwarding
+     * viewer headers, as every distribution has since before the static-site
+     * pattern. `none` suits an origin that ignores them — S3 serves objects by
+     * key — but it is opt-in: flipping the default would strip
+     * `OriginRequestPolicyId` from live distributions on their next deploy.
+     */
+    originRequestPolicy?: "all-viewer-except-host" | "none";
 }
+export type { StaticSiteRouting };
 /**
  * ALB origin CDN props - use with Application Load Balancer
  */
@@ -135,4 +153,3 @@ export declare class CdnFactory {
      */
     static build(id: string, props: ICdnProps): (_app: App, scope: Construct) => Cdn;
 }
-export {};

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

@@ -71,6 +71,15 @@ export class Cdn extends CloudFrontDistribution {
             (props.certificateArn
                 ? Certificate.fromCertificateArn(scope, `${id}Certificate`, props.certificateArn)
                 : undefined);
+        const s3Routing = props.originType === "s3"
+            ? {
+                defaultRootObject: props.defaultRootObject,
+                cleanUrls: props.routing === "multipage",
+                spaFallback: props.routing === "spa",
+                responseHeadersPolicy: props.responseHeadersPolicy,
+                originRequestPolicy: props.originRequestPolicy
+            }
+            : {};
         return {
             defaultOrigin,
             defaultCachePolicy: props.cachePolicy,
@@ -83,7 +92,8 @@ export class Cdn extends CloudFrontDistribution {
             logBucket: props.logBucket,
             priceClass: props.priceClass,
             forwardHostHeader: props.forwardHostHeader,
-            accessGate: props.accessGate
+            accessGate: props.accessGate,
+            ...s3Routing
         };
     }
     /**
@@ -112,7 +122,8 @@ export class Cdn extends CloudFrontDistribution {
                 return {
                     type: "s3",
                     bucket,
-                    originPath: props.originPath
+                    originPath: props.originPath,
+                    originAccess: props.originAccess
                 };
             }
             case "alb": {

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

@@ -21,8 +21,10 @@ import { type RelationalDatabase, type DynamoDBDatabase, type ProxyConfig, type
 import { type LambdaCompute } from "../compute.js";
 import { type Storage } from "../storage.js";
 import { type QueueMessaging } from "../messaging.js";
-import { type Cdn, type SmartCdnBehaviour } from "../cdn.js";
+import { type Cdn, type SmartCdnBehaviour, type StaticSiteRouting } from "../cdn.js";
+import { type LambdaFunction } from "../../../resources/aws/compute/index.js";
 import type { ManagedDomainExports } from "../../../utils/domainTypes.js";
+import type { PatternType } from "@fjall/util";
 export type { ProxyConfig, ReadReplicaConfig, CredentialsConfig, EncryptionConfig, AuroraEncryptionConfig, AuroraWriterConfig, AuroraReadersConfig, DatabaseInsightsConfig };
 /**
  * Full database configuration for patterns.
@@ -339,15 +341,121 @@ export interface IPayloadProps {
     /** Additional environment variables for server Lambda */
     environment?: Record<string, string>;
 }
+/**
+ * Build configuration for a static site — the single source of truth read by
+ * both the CDK construct (`outputDir` is what BucketDeployment uploads) and the
+ * deploy-core builder (`command` runs in `source` before synth).
+ */
+export interface StaticSiteBuildConfig {
+    /** Build command run in `source` (e.g. "npm run build"). */
+    command: string;
+    /** Directory (relative to `source`) holding the built site (e.g. "out"). */
+    outputDir: string;
+}
+/**
+ * Security-header configuration for a static site.
+ */
+export interface StaticSiteSecurityConfig {
+    /** Ship the four safe headers (HSTS/nosniff/frame/referrer). */
+    headers?: boolean;
+    /** Opt-in Content-Security-Policy. Absent ⇒ no CSP header (a wrong policy
+     * silently breaks inline hydration, so it is never a shipped default). */
+    contentSecurityPolicy?: string;
+}
+/**
+ * Contact-form configuration for a static site. Requires a custom `domain`: SES
+ * sends only from a verified identity, and the site's domain is the identity
+ * this pattern verifies. The endpoint is `https://<domain>/api/contact`.
+ *
+ * `to` and `from` are separate axes. `to` is where submissions land and is
+ * unconstrained — a personal mailbox is the common case. `from` is the envelope
+ * sender and must sit at `domain`. The submitter's own address is put in
+ * Reply-To at send time, so replying from the inbox reaches them.
+ */
+export interface StaticSiteFormsConfig {
+    /** Where submissions are delivered. Any address — not an SES identity. */
+    to: string;
+    /** Envelope sender; must be an address at `domain`. Default `noreply@<domain>`. */
+    from?: string;
+    /**
+     * Origin allowed to POST the form — the browser CORS allow-origin and the
+     * server-side Origin gate. An exact origin (`https://example.com`, no path,
+     * no trailing slash). Default `https://<domain>`.
+     */
+    corsOrigin?: string;
+    /**
+     * Concurrent executions the endpoint may hold. The Function URL is public and
+     * unauthenticated, so this caps both the SES bill and the account-wide Lambda
+     * concurrency a flood can consume. Default 5.
+     */
+    maxConcurrency?: number;
+}
+/**
+ * CDN configuration for a static site — advanced per-path override passthrough.
+ */
+export interface StaticSiteCdnConfig {
+    /** Additional CDN behaviours (per-path overrides). */
+    behaviours?: SmartCdnBehaviour[];
+}
+/**
+ * Static-site pattern props.
+ *
+ * Serves a pre-built folder of files from a private S3 bucket behind CloudFront
+ * with OAC, clean URLs, security headers, an optional custom domain, and an
+ * optional contact-form endpoint (Lambda Function URL → SES, CloudFront-fronted).
+ *
+ * @example
+ * app.addPattern(PatternFactory.build("LbexcSite", {
+ *   type: "staticsite",
+ *   name: "lbexc",
+ *   source: "../../lbexc-static-export",
+ *   build: { command: "npm run build", outputDir: "out" },
+ *   routing: "multipage",
+ *   security: { headers: true },
+ *   domain: "lbexc.com",
+ *   forms: { to: "hello@lbexc.com", corsOrigin: "https://lbexc.com" }
+ * }));
+ */
+export interface IStaticSiteProps {
+    /** Pattern type discriminator */
+    type: "staticsite";
+    /** Pattern name (used for resource naming) */
+    name: string;
+    /** Repo root the build runs in and assets are uploaded from. */
+    source: string;
+    /** Build command + output directory (single source of truth). */
+    build: StaticSiteBuildConfig;
+    /** "multipage" (clean-URL `.html` rewriting) or "spa". Default: "multipage". */
+    routing?: StaticSiteRouting;
+    /** Security-header configuration. */
+    security?: StaticSiteSecurityConfig;
+    /** Custom domain (same machinery as payload). Required when `forms` is set. */
+    domain?: string;
+    /** Import zone and cert from a managed domain stack instead of creating inline */
+    managedDomain?: ManagedDomainExports;
+    /** Optional contact-form endpoint (Lambda → SES). Requires `domain`. */
+    forms?: StaticSiteFormsConfig;
+    /** CDN configuration - for advanced per-path overrides. */
+    cdn?: StaticSiteCdnConfig;
+}
 /**
  * Union of all pattern props.
  * Extend this when adding new patterns (e.g., INextjsProps, IRemixProps).
  */
-export type IPatternProps = IPayloadProps;
+export type IPatternProps = IPayloadProps | IStaticSiteProps;
 /**
- * Pattern type discriminator.
+ * Pattern type discriminator. The vocabulary is owned by `@fjall/util` and
+ * shared with the generator, the deploy manifest and the CLI — see
+ * `PATTERN_REGISTRY` there, which is what forces a new pattern to declare its
+ * stack placement and construct id rather than inheriting whichever branch
+ * happened to be the `else`.
+ *
+ * Note the vocabulary is wider than `IPatternProps`: `nextjs` is declared in
+ * `PATTERN_REGISTRY` but has no construct, so it is deliberately absent from the
+ * union above and `PatternFactory.build` will not accept it — the omission here
+ * is the single enforcement of that gap.
  */
-export type PatternType = "payload";
+export type { PatternType };
 /**
  * Base pattern interface.
  * All patterns implement this interface.
@@ -391,15 +499,36 @@ export interface IPayload extends IPattern {
     /** Get the CloudFront distribution */
     getCdn(): Cdn;
 }
+/**
+ * Static-site pattern interface.
+ * Provides access to the underlying resources for escape hatches.
+ *
+ * @example
+ * site.getBucket().getBucket().addLifecycleRule({ ... });
+ * site.getCdn().getDistribution().addBehavior("/custom/*", customOrigin);
+ */
+export interface IStaticSite extends IPattern {
+    readonly patternType: "staticsite";
+    /** Get the private S3 origin bucket */
+    getBucket(): Storage;
+    /** Get the CloudFront distribution */
+    getCdn(): Cdn;
+    /** Get the contact-form Lambda (undefined when `forms` is not configured) */
+    getFormsFunction(): LambdaFunction | undefined;
+}
 /**
  * Union type representing any pattern interface.
  * Use with type guards for generic handling.
  */
-export type AnyPattern = IPayload;
+export type AnyPattern = IPayload | IStaticSite;
 /**
  * Type guard to check if a pattern is Payload.
  */
 export declare function isPayloadPattern(pattern: IPattern): pattern is IPayload;
+/**
+ * Type guard to check if a pattern is a static site.
+ */
+export declare function isStaticSitePattern(pattern: IPattern): pattern is IStaticSite;
 /**
  * Type guard to check if a resource is any pattern type.
  */

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

@@ -20,6 +20,12 @@
 export function isPayloadPattern(pattern) {
     return pattern.patternType === "payload";
 }
+/**
+ * Type guard to check if a pattern is a static site.
+ */
+export function isStaticSitePattern(pattern) {
+    return pattern.patternType === "staticsite";
+}
 /**
  * Type guard to check if a resource is any pattern type.
  */

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

@@ -31,9 +31,19 @@
  * payload.getServer().getLambdaFunction().addEnvironment("CUSTOM", "value");
  */
 import { type Construct } from "constructs";
+import { type PatternStackPlacement } from "@fjall/util";
 import type App from "../../app.js";
 import { Payload } from "./payload.js";
-import { type IPayloadProps, type IPatternProps, type AnyPattern } from "./interfaces/pattern.js";
+import { StaticSite } from "./staticSite.js";
+import { type IPayloadProps, type IStaticSiteProps, type IPatternProps, type AnyPattern } from "./interfaces/pattern.js";
+/**
+ * A pattern factory thunk. Carries a `stackPlacement` so `addPattern` can route
+ * the pattern node to the CDN stack (static site — no VPC or compute) rather
+ * than the compute stack (payload). Mirrors `StorageFactoryFn`.
+ */
+export type PatternFactoryFn<T extends AnyPattern = AnyPattern> = ((app: App, scope: Construct) => T) & {
+    stackPlacement?: PatternStackPlacement;
+};
 /**
  * Factory for creating high-level infrastructure patterns.
  *
@@ -56,12 +66,17 @@ export declare class PatternFactory {
      * @param props - Payload pattern configuration
      * @returns Factory function to create the pattern
      */
-    static build(id: string, props: IPayloadProps): (app: App, scope: Construct) => Payload;
+    static build(id: string, props: IPayloadProps): PatternFactoryFn<Payload>;
+    /**
+     * Build a static-site pattern (private S3 + CloudFront/OAC, optional forms).
+     */
+    static build(id: string, props: IStaticSiteProps): PatternFactoryFn<StaticSite>;
     /**
      * Generic build method (implementation signature).
      */
-    static build(id: string, props: IPatternProps): (app: App, scope: Construct) => AnyPattern;
+    static build(id: string, props: IPatternProps): PatternFactoryFn;
 }
 export { Payload };
-export type { IPayloadProps, IPatternProps, AnyPattern, IPayload, PayloadDatabaseConfig, PayloadComputeConfig, PayloadCdnConfig } from "./interfaces/pattern.js";
-export { isPayloadPattern, isPattern } from "./interfaces/pattern.js";
+export { StaticSite };
+export type { IPayloadProps, IStaticSiteProps, IPatternProps, PatternType, AnyPattern, IPayload, IStaticSite, PayloadDatabaseConfig, PayloadComputeConfig, PayloadCdnConfig, StaticSiteBuildConfig, StaticSiteSecurityConfig, StaticSiteFormsConfig, StaticSiteCdnConfig } from "./interfaces/pattern.js";
+export { isPayloadPattern, isStaticSitePattern, isPattern } from "./interfaces/pattern.js";

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

@@ -30,7 +30,9 @@
  * payload.getDatabase().grantConnect(otherLambda);
  * payload.getServer().getLambdaFunction().addEnvironment("CUSTOM", "value");
  */
+import { PATTERN_REGISTRY } from "@fjall/util";
 import { Payload } from "./payload.js";
+import { StaticSite } from "./staticSite.js";
 /**
  * Factory for creating high-level infrastructure patterns.
  *
@@ -43,21 +45,25 @@ export class PatternFactory {
      * Routes to specific pattern implementations based on type discriminator.
      */
     static build(id, props) {
-        return (app, scope) => {
-            const { type } = props;
-            switch (type) {
+        const fn = (app, scope) => {
+            switch (props.type) {
                 case "payload":
                     return new Payload(scope, id, app, props);
+                case "staticsite":
+                    return new StaticSite(scope, id, app, props);
                 default: {
                     // Exhaustive check ensures all pattern types are handled
-                    const _exhaustive = type;
-                    throw new Error(`Unsupported pattern type: ${String(_exhaustive)}`);
+                    const _exhaustive = props;
+                    throw new Error(`Unsupported pattern type: ${String(_exhaustive.type)}`);
                 }
             }
         };
+        fn.stackPlacement = PATTERN_REGISTRY[props.type].stackPlacement;
+        return fn;
     }
 }
 // Re-export types for convenience
 export { Payload };
+export { StaticSite };
 // Re-export type guards
-export { isPayloadPattern, isPattern } from "./interfaces/pattern.js";
+export { isPayloadPattern, isStaticSitePattern, isPattern } from "./interfaces/pattern.js";