@fjall/components-infrastructure 35.0.0 → 36.0.0

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

@@ -5,6 +5,7 @@ import { RdsAuroraGlobal } from "../../resources/aws/database/rdsAuroraGlobal.js
 import { DynamoDBTable } from "../../resources/aws/database/dynamodb.js";
 import { ClickHouseDatabase } from "./clickhouseDatabase.js";
 import { FjallLogger, warnIfPropertiesIgnored } from "../../utils/validationLogger.js";
+import { DATABASE_WARN_GROUPS } from "./databasePropApplicability.js";
 import { toPascalCase } from "../../utils/capitaliseString.js";
 import { ResourceNaming } from "../../utils/resourceNaming.js";
 import { resolveAlertsTopic as resolveAlertsTopicShared } from "../../utils/resolveAlertsTopic.js";
@@ -127,12 +128,9 @@ function validateRelationalDatabaseProps(props) {
         throw new Error("GlobalAurora database requires 'primaryRegion'. " +
             "Specify the AWS region where the primary cluster will be created.");
     }
-    // Instance-only options on Aurora/GlobalAurora
-    warnIfPropertiesIgnored(props, ["readReplica", "multiAz", "allocatedStorage", "iamAuthentication"], "Instance", "Instance database");
-    // Aurora-only options on Instance
-    warnIfPropertiesIgnored(props, ["readers", "writer"], ["Aurora", "GlobalAurora"], "Aurora database");
-    // GlobalAurora-only options on non-global databases
-    warnIfPropertiesIgnored(props, ["primaryRegion", "secondaryRegions", "enableGlobalWriteForwarding"], "GlobalAurora", "GlobalAurora database");
+    for (const group of DATABASE_WARN_GROUPS) {
+        warnIfPropertiesIgnored(props, group.properties, group.applicableTypes, group.typeName);
+    }
 }
 /**
  * Validates database props and logs warnings for ignored or misconfigured options.

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

@@ -0,0 +1,15 @@
+import type { AuroraDatabaseProps, GlobalAuroraDatabaseProps, InstanceDatabaseProps } from "./database.js";
+import { type RelationalDatabaseType } from "./interfaces/database.js";
+type AllDatabasePropKeys = keyof AuroraDatabaseProps | keyof InstanceDatabaseProps | keyof GlobalAuroraDatabaseProps;
+export interface DatabaseWarnGroup {
+    properties: string[];
+    applicableTypes: RelationalDatabaseType[];
+    typeName: string;
+}
+export declare const DATABASE_WARN_GROUPS: readonly DatabaseWarnGroup[];
+/**
+ * Runtime key set for tests — derived from the compiled guard, never
+ * re-listed (typescript-standards § compile-time guards).
+ */
+export declare const ALL_DATABASE_PROP_KEYS: AllDatabasePropKeys[];
+export {};

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

@@ -0,0 +1,98 @@
+import { RELATIONAL_DATABASE_TYPES } from "./interfaces/database.js";
+/**
+ * Compile-time lockstep guard for `validateRelationalDatabaseProps`'s
+ * ignored-prop warnings — the database twin of `COMPUTE_PROP_APPLICABILITY`.
+ * The Record over the full top-level key union rejects BOTH a missing key (a
+ * new prop added to any relational props interface fails TS2741 here until
+ * classified) and a stale extra key (a removed/renamed prop fails TS2353).
+ * `"all"` means the prop is declared on every relational variant and never
+ * warns; a list names the variants that declare it, and a prop declared on
+ * two of the three variants is first-class here — the shape no
+ * single-variant hand list (or Exclude-difference bucket) can express.
+ *
+ * Applicability is DECLARATION, not type identity: `engine` and `encryption`
+ * map `"all"` although their TYPES differ per variant (`IClusterEngine` vs
+ * `IInstanceEngine`, `AuroraEncryptionConfig` vs `EncryptionConfig`) — every
+ * variant reads them, so they are never ignored and must never warn.
+ */
+const DATABASE_PROP_APPLICABILITY = {
+    type: "all",
+    vpc: "all",
+    databaseName: "all",
+    instanceType: "all",
+    deletionProtection: "all",
+    appBackupTier: "all",
+    alertsTopic: "all",
+    alarms: "all",
+    applicationId: "all",
+    migrations: "all",
+    databaseEngine: "all",
+    engine: "all",
+    port: "all",
+    proxy: "all",
+    credentials: "all",
+    encryption: "all",
+    backupRetention: "all",
+    databaseInsights: "all",
+    snapshotIdentifier: "all",
+    snapshotUsername: "all",
+    writer: ["Aurora", "GlobalAurora"],
+    readers: ["Aurora", "GlobalAurora"],
+    monitoringInterval: ["Aurora", "GlobalAurora"],
+    preferredMaintenanceWindow: ["Aurora", "GlobalAurora"],
+    removalPolicy: ["Aurora"],
+    engineVersion: ["Aurora"],
+    clusterIdentifier: ["Aurora"],
+    credentialsSecretName: ["Aurora"],
+    credentialsKmsAliasName: ["Aurora"],
+    serverlessV2MinCapacity: ["Aurora"],
+    serverlessV2MaxCapacity: ["Aurora"],
+    serverlessV2AutoPauseDuration: ["Aurora"],
+    enableDataApi: ["Aurora"],
+    allowVpcAccess: ["Aurora"],
+    allowedIpCidr: ["Aurora"],
+    publiclyAccessible: ["Aurora", "Instance"],
+    primaryRegion: ["GlobalAurora"],
+    secondaryRegions: ["GlobalAurora"],
+    globalClusterIdentifier: ["GlobalAurora"],
+    enableGlobalWriteForwarding: ["GlobalAurora"],
+    allocatedStorage: ["Instance"],
+    multiAz: ["Instance"],
+    readReplica: ["Instance"],
+    iamAuthentication: ["Instance"]
+};
+/**
+ * The variant literals are already the user-facing vocabulary (the
+ * `type: "Aurora"` a user writes), so the warning names exactly that —
+ * no label table to keep in step. Groups are keyed on the variants in
+ * `RELATIONAL_DATABASE_TYPES` order, so two entries declaring the same
+ * variants in a different order land in one group with one label.
+ */
+const orderedVariants = (variants) => [...variants].sort((a, b) => RELATIONAL_DATABASE_TYPES.indexOf(a) -
+    RELATIONAL_DATABASE_TYPES.indexOf(b));
+export const DATABASE_WARN_GROUPS = (() => {
+    const groups = new Map();
+    for (const [prop, applicability] of Object.entries(DATABASE_PROP_APPLICABILITY)) {
+        if (applicability === "all")
+            continue;
+        const applicableTypes = orderedVariants(applicability);
+        const key = applicableTypes.join("+");
+        const existing = groups.get(key);
+        if (existing !== undefined) {
+            existing.properties.push(prop);
+        }
+        else {
+            groups.set(key, {
+                properties: [prop],
+                applicableTypes,
+                typeName: applicableTypes.join(" or ") + " database"
+            });
+        }
+    }
+    return [...groups.values()];
+})();
+/**
+ * Runtime key set for tests — derived from the compiled guard, never
+ * re-listed (typescript-standards § compile-time guards).
+ */
+export const ALL_DATABASE_PROP_KEYS = Object.keys(DATABASE_PROP_APPLICABILITY);

package/dist/lib/resources/aws/compute/lifecycleHookLambda.source.cjs

@@ -92,32 +92,60 @@ async function findExistingTaskArn(client, clusterArn, startedBy) {
   return result.taskArns[0];
 }
 
+function describeFailureReason(desc) {
+  const failure = desc && desc.failures && desc.failures[0];
+  return failure && failure.reason ? failure.reason : "no failure reported";
+}
+
+// DescribeTasks is eventually consistent with RunTask: for a few seconds
+// after a launch it answers `tasks: []` with a MISSING failure for the very
+// ARN RunTask just returned. Until the task has been seen once, a miss is
+// "not visible yet" and the poll continues; once it has been seen, a miss is
+// the task vanishing, which is loud. A task never seen inside one
+// invocation's poll budget is loud too — that is a hundred seconds, not
+// consistency lag.
 async function pollTaskUntilStopped(client, clusterArn, taskArn, sleep) {
   const sleepFn =
     sleep || ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  let seen = false;
+  let lastMissReason = "no failure reported";
   for (let i = 0; i < MAX_POLLS_PER_INVOCATION; i++) {
     const desc = await client.send(
       new DescribeTasksCommand({ cluster: clusterArn, tasks: [taskArn] })
     );
     const task = desc.tasks && desc.tasks[0];
-    if (!task) {
-      return { hookStatus: "FAILED", reason: "DescribeTasks returned no task" };
-    }
-    if (task.lastStatus === "STOPPED") {
-      const exitCode =
-        task.containers && task.containers[0]
-          ? task.containers[0].exitCode
-          : undefined;
-      if (exitCode === 0) return { hookStatus: "SUCCEEDED" };
-      return {
-        hookStatus: "FAILED",
-        reason: `Task exited ${exitCode}: ${task.stoppedReason || "no reason"}`
-      };
+    if (task) {
+      seen = true;
+      if (task.lastStatus === "STOPPED") {
+        const exitCode =
+          task.containers && task.containers[0]
+            ? task.containers[0].exitCode
+            : undefined;
+        if (exitCode === 0) return { hookStatus: "SUCCEEDED" };
+        return {
+          hookStatus: "FAILED",
+          reason: `Task exited ${exitCode}: ${task.stoppedReason || "no reason"}`
+        };
+      }
+    } else {
+      lastMissReason = describeFailureReason(desc);
+      if (seen) {
+        return {
+          hookStatus: "FAILED",
+          reason: `DescribeTasks returned no task after it had been seen (${lastMissReason})`
+        };
+      }
     }
     if (i < MAX_POLLS_PER_INVOCATION - 1) {
       await sleepFn(POLL_INTERVAL_MS);
     }
   }
+  if (!seen) {
+    return {
+      hookStatus: "FAILED",
+      reason: `DescribeTasks returned no task in ${MAX_POLLS_PER_INVOCATION} polls (${lastMissReason})`
+    };
+  }
   return {
     hookStatus: "IN_PROGRESS",
     callBackDelay: HOOK_CALLBACK_DELAY_SECONDS

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fjall/components-infrastructure",
-  "version": "35.0.0",
+  "version": "36.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fjall-tech/fjall.git",
@@ -80,8 +80,8 @@
   },
   "dependencies": {
     "@aws-sdk/client-organizations": "^3.1098.0",
-    "@fjall/generator": "^35.0.0",
-    "@fjall/util": "^35.0.0",
+    "@fjall/generator": "^36.0.0",
+    "@fjall/util": "^36.0.0",
     "constructs": "^10.7.2",
     "zod": "^4.4.3"
   },