@intentius/chant 0.0.8 → 0.0.9

package/src/resource-attributes.test.ts

@@ -0,0 +1,79 @@
+import { describe, test, expect, spyOn } from "bun:test";
+import { resolveDependsOn } from "./resource-attributes";
+import { DECLARABLE_MARKER, type Declarable } from "./declarable";
+
+function mockDeclarable(type = "AWS::S3::Bucket"): Declarable {
+  return {
+    [DECLARABLE_MARKER]: true,
+    lexicon: "aws",
+    entityType: type,
+    kind: "resource",
+  } as Declarable;
+}
+
+describe("resolveDependsOn", () => {
+  test("resolves a single Declarable to its logical name", () => {
+    const bucket = mockDeclarable();
+    const entityNames = new Map<Declarable, string>([[bucket, "MyBucket"]]);
+
+    const result = resolveDependsOn(bucket, entityNames, "MyResource");
+    expect(result).toEqual(["MyBucket"]);
+  });
+
+  test("resolves an array of Declarables", () => {
+    const bucket = mockDeclarable("AWS::S3::Bucket");
+    const role = mockDeclarable("AWS::IAM::Role");
+    const entityNames = new Map<Declarable, string>([
+      [bucket, "MyBucket"],
+      [role, "MyRole"],
+    ]);
+
+    const result = resolveDependsOn([bucket, role], entityNames, "MyResource");
+    expect(result).toEqual(["MyBucket", "MyRole"]);
+  });
+
+  test("passes through a single string", () => {
+    const entityNames = new Map<Declarable, string>();
+    const result = resolveDependsOn("ExternalResource", entityNames, "MyResource");
+    expect(result).toEqual(["ExternalResource"]);
+  });
+
+  test("passes through an array of strings", () => {
+    const entityNames = new Map<Declarable, string>();
+    const result = resolveDependsOn(["ResA", "ResB"], entityNames, "MyResource");
+    expect(result).toEqual(["ResA", "ResB"]);
+  });
+
+  test("handles mixed strings and Declarables", () => {
+    const bucket = mockDeclarable();
+    const entityNames = new Map<Declarable, string>([[bucket, "MyBucket"]]);
+
+    const result = resolveDependsOn(["ManualRef", bucket], entityNames, "MyResource");
+    expect(result).toEqual(["ManualRef", "MyBucket"]);
+  });
+
+  test("warns and skips Declarable not found in entityNames", () => {
+    const bucket = mockDeclarable();
+    const entityNames = new Map<Declarable, string>(); // bucket not registered
+    const spy = spyOn(console, "warn").mockImplementation(() => {});
+
+    const result = resolveDependsOn(bucket, entityNames, "MyResource");
+    expect(result).toEqual([]);
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy.mock.calls[0][0]).toContain("MyResource");
+
+    spy.mockRestore();
+  });
+
+  test("returns empty array for empty array input", () => {
+    const entityNames = new Map<Declarable, string>();
+    const result = resolveDependsOn([], entityNames, "MyResource");
+    expect(result).toEqual([]);
+  });
+
+  test("skips non-string non-Declarable values silently", () => {
+    const entityNames = new Map<Declarable, string>();
+    const result = resolveDependsOn([42, null, true] as unknown[], entityNames, "MyResource");
+    expect(result).toEqual([]);
+  });
+});

package/src/resource-attributes.ts

@@ -0,0 +1,42 @@
+/**
+ * Utilities for resolving resource-level attributes (DependsOn, Condition, etc.).
+ *
+ * Shared by lexicon serializers — the DependsOn resolution logic converts
+ * Declarable object references to logical names.
+ */
+
+import type { Declarable } from "./declarable";
+
+/**
+ * Resolve a DependsOn value (Declarable, string, or mixed array) into
+ * an array of logical resource names.
+ *
+ * - Strings pass through as-is (user-specified logical names)
+ * - Declarable objects are looked up in the entityNames map
+ * - Unknown values emit a console warning and are skipped
+ */
+export function resolveDependsOn(
+  deps: unknown,
+  entityNames: Map<Declarable, string>,
+  resourceName: string,
+): string[] {
+  const items = Array.isArray(deps) ? deps : [deps];
+  const resolved: string[] = [];
+
+  for (const dep of items) {
+    if (typeof dep === "string") {
+      resolved.push(dep);
+    } else if (typeof dep === "object" && dep !== null && "entityType" in dep) {
+      const depName = entityNames.get(dep as Declarable);
+      if (depName) {
+        resolved.push(depName);
+      } else {
+        console.warn(
+          `[chant] warning: DependsOn in "${resourceName}" references a declarable not found in the build — is the target resource exported?`,
+        );
+      }
+    }
+  }
+
+  return resolved;
+}

package/src/runtime.ts

@@ -22,13 +22,14 @@ export function createResource(
   type: string,
   lexicon: string,
   attrMap: Record<string, string>,
-): new (props: Record<string, unknown>) => Record<string, unknown> {
-  const ResourceClass = function (this: Record<string, unknown>, props: Record<string, unknown>) {
+): new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => Record<string, unknown> {
+  const ResourceClass = function (this: Record<string, unknown>, props: Record<string, unknown>, attributes?: Record<string, unknown>) {
     Object.defineProperty(this, DECLARABLE_MARKER, { value: true, enumerable: false });
     Object.defineProperty(this, "lexicon", { value: lexicon, enumerable: false });
     Object.defineProperty(this, "entityType", { value: type, enumerable: false });
     Object.defineProperty(this, "kind", { value: "resource", enumerable: false });
     Object.defineProperty(this, "props", { value: props ?? {}, enumerable: false, configurable: true });
+    Object.defineProperty(this, "attributes", { value: attributes ?? {}, enumerable: false, configurable: true });
 
     // Create AttrRef instances for each attribute
     // Must be enumerable so getAttributes() can discover them for resolveAttrRefs()
@@ -39,7 +40,7 @@ export function createResource(
         writable: false,
       });
     }
-  } as unknown as new (props: Record<string, unknown>) => Record<string, unknown>;
+  } as unknown as new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => Record<string, unknown>;
 
   // Set the constructor name for debugging
   Object.defineProperty(ResourceClass, "name", { value: type.split("::").pop() ?? type });