@fjall/components-infrastructure 2.33.0 → 3.0.0

package/dist/lib/utils/domainTypes.js

@@ -1,2 +1,65 @@
-export { DNS_APEX, getDomainExportNames } from "@fjall/util";
-export const ALIAS_CDK_PREFIX = "ALIAS:";
+import { DNS_APEX } from "@fjall/util";
+export { DNS_APEX, getDomainExportNames, isManagedDomainBinding } from "@fjall/util";
+/**
+ * Dot-boundary suffix matching. Rejects pathological cases where a user-supplied
+ * zone appears as a suffix of another zone (e.g. 'evilexample.com' against
+ * zone 'example.com' — `endsWith('example.com')` returns true without the
+ * leading dot). Shared by the patterns-layer domain validation and the
+ * resources-layer ECS networking (lowest common layer per generator-standards
+ * § Infrastructure Layer Boundaries).
+ */
+export function isWithinZone(candidate, zoneName) {
+    if (candidate === zoneName) {
+        return true;
+    }
+    return candidate.endsWith(`.${zoneName}`);
+}
+/**
+ * Canonical BIND-semantics resolver for DNS record names — the single
+ * authority shared by the patterns-layer domain validation and the
+ * resources-layer dnsRecord family (lowest common layer per
+ * generator-standards § Infrastructure Layer Boundaries). Contract:
+ *
+ * - `'@'` — the zone apex; resolves to the zone name.
+ * - Trailing dot — an absolute FQDN; must equal the zone or end with
+ *   `.<zone>.`, otherwise the name belongs to another zone and is rejected.
+ *   The conventional trailing dot is shed on return because CloudFormation
+ *   RecordSet names carry none at this layer (CDK re-appends it).
+ * - No trailing dot — relative to the zone regardless of label count
+ *   (`www` and `s1._domainkey` alike); the zone is appended exactly once.
+ * - A dotless name that already ends with the bare zone is ambiguous between
+ *   the relative and absolute readings and is rejected, naming both honest
+ *   spellings.
+ */
+export function resolveRecordFqdn(recordName, zoneName) {
+    if (recordName === DNS_APEX) {
+        return zoneName;
+    }
+    if (recordName.endsWith(".")) {
+        const absolute = recordName.slice(0, -1);
+        if (absolute !== zoneName && !absolute.endsWith(`.${zoneName}`)) {
+            throw new Error(`DNS record name '${recordName}' is absolute (trailing dot) but ` +
+                `lies outside zone '${zoneName}'. Cure: an absolute name must be ` +
+                `'${zoneName}.' or end with '.${zoneName}.'; records for another ` +
+                `zone belong on that zone's own Domain construct.`);
+        }
+        return absolute;
+    }
+    if (recordName === zoneName || recordName.endsWith(`.${zoneName}`)) {
+        const relativeSpelling = recordName === zoneName
+            ? DNS_APEX
+            : recordName.slice(0, -(zoneName.length + 1));
+        throw new Error(`DNS record name '${recordName}' ends with zone '${zoneName}' but has ` +
+            `no trailing dot, so it is ambiguous between relative ` +
+            `('${recordName}.${zoneName}') and absolute ('${recordName}'). ` +
+            `Cure: spell it '${relativeSpelling}' (relative to the zone) or ` +
+            `'${recordName}.' (absolute).`);
+    }
+    return `${recordName}.${zoneName}`;
+}
+/**
+ * Default deploy phase when `phase` is omitted — the complete build. The
+ * two-step guard (R2) sets `"zone"` explicitly for step 1, so the safe
+ * default for a single-shot deploy is everything.
+ */
+export const DOMAIN_DEPLOY_DEFAULT_PHASE = "full";

package/dist/lib/utils/managedDomainContext.d.ts

@@ -0,0 +1,37 @@
+/**
+ * CDK-context channel for CLI-injected managed-domain bindings (design
+ * 2026-07-17 domain-management gold-plating, D2 — resolution by injection).
+ *
+ * At deploy time the Fjall CLI resolves each app-consumed domain against the
+ * declared `fjall/domains/` components (DescribeStacks on the domain stack)
+ * and injects one context entry per zone:
+ *
+ *   -c fjall:managedDomain:<zoneName>=<JSON ManagedDomainBinding>
+ *
+ * (emitter: deploy-core `CdkArgumentBuilder.buildContextArgs` — keep the
+ * prefix literal in sync). Constructs read the entry ahead of their BYO
+ * `zoneName`/`hostedZone` props; an EXPLICIT `managedDomain` prop still wins
+ * over the injected value. Bare-CDK synth simply lacks the context and falls
+ * back to explicit props.
+ *
+ * Utils layer on purpose: consumed by both the resources layer
+ * (`ecsNetworking.addHostedZone`) and the patterns layer
+ * (`patternDomain.resolvePatternZone`), and utils is their lowest common
+ * layer (generator-standards § Infrastructure Layer Boundaries).
+ */
+import type { Node } from "constructs";
+import type { ManagedDomainBinding } from "@fjall/util";
+export declare const MANAGED_DOMAIN_CONTEXT_PREFIX: "fjall:managedDomain:";
+export declare function getManagedDomainContextKey(zoneName: string): string;
+/**
+ * Read the CLI-injected {@link ManagedDomainBinding} for `domainName`,
+ * walking exact → parent zones (mirroring the CLI's
+ * `DomainService.matchManagedDomain` semantics: `app.example.com` matches a
+ * binding injected for `example.com`). Returns undefined when no entry is
+ * present (bare-CDK synth); throws a context-prefixed, value-echoing,
+ * cure-naming error when an entry exists but is malformed — a corrupt
+ * binding must fail the synth, never fall through to a guessed zone.
+ *
+ * `context` prefixes every error, e.g. `Static site 'marketing'`.
+ */
+export declare function readInjectedManagedDomainBinding(node: Node, domainName: string, context: string): ManagedDomainBinding | undefined;

package/dist/lib/utils/managedDomainContext.js

@@ -0,0 +1,111 @@
+/**
+ * CDK-context channel for CLI-injected managed-domain bindings (design
+ * 2026-07-17 domain-management gold-plating, D2 — resolution by injection).
+ *
+ * At deploy time the Fjall CLI resolves each app-consumed domain against the
+ * declared `fjall/domains/` components (DescribeStacks on the domain stack)
+ * and injects one context entry per zone:
+ *
+ *   -c fjall:managedDomain:<zoneName>=<JSON ManagedDomainBinding>
+ *
+ * (emitter: deploy-core `CdkArgumentBuilder.buildContextArgs` — keep the
+ * prefix literal in sync). Constructs read the entry ahead of their BYO
+ * `zoneName`/`hostedZone` props; an EXPLICIT `managedDomain` prop still wins
+ * over the injected value. Bare-CDK synth simply lacks the context and falls
+ * back to explicit props.
+ *
+ * Utils layer on purpose: consumed by both the resources layer
+ * (`ecsNetworking.addHostedZone`) and the patterns layer
+ * (`patternDomain.resolvePatternZone`), and utils is their lowest common
+ * layer (generator-standards § Infrastructure Layer Boundaries).
+ */
+export const MANAGED_DOMAIN_CONTEXT_PREFIX = "fjall:managedDomain:";
+export function getManagedDomainContextKey(zoneName) {
+    return `${MANAGED_DOMAIN_CONTEXT_PREFIX}${zoneName}`;
+}
+const REQUIRED_STRING_FIELDS = ["zoneName", "hostedZoneId"];
+const OPTIONAL_STRING_FIELDS = [
+    "certificateArn",
+    "usEast1CertificateArn",
+    "delegationRoleArn"
+];
+const KNOWN_FIELDS = [
+    ...REQUIRED_STRING_FIELDS,
+    ...OPTIONAL_STRING_FIELDS
+];
+/**
+ * Read the CLI-injected {@link ManagedDomainBinding} for `domainName`,
+ * walking exact → parent zones (mirroring the CLI's
+ * `DomainService.matchManagedDomain` semantics: `app.example.com` matches a
+ * binding injected for `example.com`). Returns undefined when no entry is
+ * present (bare-CDK synth); throws a context-prefixed, value-echoing,
+ * cure-naming error when an entry exists but is malformed — a corrupt
+ * binding must fail the synth, never fall through to a guessed zone.
+ *
+ * `context` prefixes every error, e.g. `Static site 'marketing'`.
+ */
+export function readInjectedManagedDomainBinding(node, domainName, context) {
+    const labels = domainName.split(".");
+    for (let i = 0; i < labels.length; i++) {
+        const candidate = labels.slice(i).join(".");
+        const key = getManagedDomainContextKey(candidate);
+        const raw = node.tryGetContext(key);
+        if (raw === undefined)
+            continue;
+        return parseManagedDomainBinding(raw, candidate, key, context);
+    }
+    return undefined;
+}
+function parseManagedDomainBinding(raw, zoneName, key, context) {
+    let value = raw;
+    if (typeof raw === "string") {
+        try {
+            value = JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`${context}: CDK context '${key}' is not valid JSON (got '${raw}'). ` +
+                "The value must be a JSON ManagedDomainBinding " +
+                "({ zoneName, hostedZoneId, certificateArn?, " +
+                "usEast1CertificateArn?, delegationRoleArn? }) — re-run the deploy " +
+                "through the Fjall CLI, or correct the hand-set context entry.");
+        }
+    }
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(`${context}: CDK context '${key}' must be a JSON object ` +
+            `ManagedDomainBinding (got ${JSON.stringify(value)}). Re-run the ` +
+            "deploy through the Fjall CLI, or correct the hand-set context entry.");
+    }
+    const record = value;
+    for (const field of Object.keys(record)) {
+        if (!KNOWN_FIELDS.includes(field)) {
+            throw new Error(`${context}: CDK context '${key}' carries unknown field '${field}' ` +
+                `(got ${JSON.stringify(record)}). Known fields: ` +
+                `${KNOWN_FIELDS.join(", ")}. Re-run the deploy through the Fjall ` +
+                "CLI, or correct the hand-set context entry.");
+        }
+    }
+    for (const field of REQUIRED_STRING_FIELDS) {
+        if (typeof record[field] !== "string" || record[field] === "") {
+            throw new Error(`${context}: CDK context '${key}' is missing required string field ` +
+                `'${field}' (got ${JSON.stringify(record[field])}). Redeploy the ` +
+                `domain stack ('fjall domain deploy ${zoneName}') so the CLI ` +
+                "injects a complete binding, or correct the hand-set context entry.");
+        }
+    }
+    for (const field of OPTIONAL_STRING_FIELDS) {
+        const fieldValue = record[field];
+        if (fieldValue !== undefined && typeof fieldValue !== "string") {
+            throw new Error(`${context}: CDK context '${key}' field '${field}' must be a string ` +
+                `when present (got ${JSON.stringify(fieldValue)}). Re-run the ` +
+                "deploy through the Fjall CLI, or correct the hand-set context entry.");
+        }
+    }
+    if (record.zoneName !== zoneName) {
+        throw new Error(`${context}: CDK context '${key}' declares zoneName ` +
+            `'${String(record.zoneName)}', which does not match the key's zone ` +
+            `'${zoneName}'. The injection contract keys each binding by its own ` +
+            "zone — re-run the deploy through the Fjall CLI, or correct the " +
+            "hand-set context entry.");
+    }
+    return record;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fjall/components-infrastructure",
-  "version": "2.33.0",
+  "version": "3.0.0",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
   "bin": {
@@ -67,8 +67,8 @@
   },
   "dependencies": {
     "@aws-sdk/client-organizations": "^3.1038.0",
-    "@fjall/generator": "^2.33.0",
-    "@fjall/util": "^2.33.0",
+    "@fjall/generator": "^3.0.0",
+    "@fjall/util": "^3.0.0",
     "constructs": "^10.6.0"
   },
   "overrides": {
@@ -82,5 +82,5 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "gitHead": "61c0d1917597c6d02e8e78b03420afdd194eaafc"
+  "gitHead": "848a386e3e2244401b76faabd02818c682d231e8"
 }