@intentius/chant 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Declarative infrastructure-as-code toolkit — TypeScript on Bun",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",

package/src/build.test.ts

@@ -2,6 +2,7 @@ import { describe, test, expect, beforeEach, afterEach } from "bun:test";
 import { build, partitionByLexicon, detectCrossLexiconRefs } from "./build";
 import { output } from "./lexicon-output";
 import { AttrRef } from "./attrref";
+import { INTRINSIC_MARKER } from "./intrinsic";
 import type { Serializer } from "./serializer";
 import type { Declarable } from "./declarable";
 import { DECLARABLE_MARKER } from "./declarable";
@@ -359,14 +360,14 @@ describe("detectCrossLexiconRefs", () => {
     expect(explicitOutputs[0].outputName).toBe("MyCustomArnName");
 
     // Merge logic: explicit wins (same parent object + attribute)
-    const explicitRefs = explicitOutputs.map((o: { _sourceParent: WeakRef<object>; sourceAttribute: string }) => ({
-      parent: o._sourceParent.deref(),
+    const explicitRefs = explicitOutputs.map((o: { _sourceParent: WeakRef<object> | null; sourceAttribute: string | null }) => ({
+      parent: o._sourceParent?.deref(),
       attribute: o.sourceAttribute,
     }));
     const merged = [
       ...explicitOutputs,
       ...autoDetected.filter((auto) => {
-        const autoParent = auto._sourceParent.deref();
+        const autoParent = auto._sourceParent?.deref();
         return !explicitRefs.some(
           (e: { parent: object | undefined; attribute: string }) =>
             e.parent === autoParent && e.attribute === auto.sourceAttribute
@@ -403,6 +404,32 @@ describe("detectCrossLexiconRefs", () => {
     expect(detected).toHaveLength(0);
   });
 
+  test("intrinsic-based output() is passed to every lexicon's serializer", () => {
+    const alphaEntity = {
+      lexicon: "alpha",
+      entityType: "Alpha::Resource",
+      [DECLARABLE_MARKER]: true,
+    } as Declarable;
+
+    const mockIntrinsic = {
+      [INTRINSIC_MARKER]: true as const,
+      toJSON: () => ({ "Fn::Sub": "http://example.com/path" }),
+    };
+    const intrinsicOutput = output(mockIntrinsic, "MyUrl");
+
+    const entities = new Map<string, Declarable>([
+      ["alphaEntity", alphaEntity],
+      ["myUrl", intrinsicOutput as unknown as Declarable],
+    ]);
+
+    const { collectLexiconOutputs } = require("./build");
+    const collected = collectLexiconOutputs(entities);
+    expect(collected).toHaveLength(1);
+    expect(collected[0].outputName).toBe("MyUrl");
+    expect(collected[0].sourceLexicon).toBe("");
+    expect(collected[0].getOutputValue()).toEqual({ "Fn::Sub": "http://example.com/path" });
+  });
+
   test("deduplicates when same cross-lexicon ref appears in multiple entities", () => {
     const alphaBucket = {
       lexicon: "alpha",

package/src/build.ts

@@ -105,7 +105,7 @@ export function collectLexiconOutputs(
     if (isLexiconOutput(entity as unknown)) {
       const lexiconOutput = entity as unknown as LexiconOutput;
       // Resolve source entity name from the WeakRef parent identity
-      const parent = lexiconOutput._sourceParent.deref();
+      const parent = lexiconOutput._sourceParent?.deref();
       let sourceName = name;
       if (parent) {
         for (const [entityName, e] of entities) {
@@ -287,7 +287,7 @@ function generateManifest(
     outputsRecord[output.outputName] = {
       source: output.sourceLexicon,
       entity: output.sourceEntity,
-      attribute: output.sourceAttribute,
+      attribute: output.sourceAttribute ?? "",
     };
   }
 
@@ -391,22 +391,29 @@ export async function build(
   // Merge: explicit outputs take precedence over auto-detected ones.
   // Match by parent object identity + attribute to detect collisions.
   const explicitRefs = explicitOutputs.map((o) => ({
-    parent: o._sourceParent.deref(),
+    parent: o._sourceParent?.deref(),
     attribute: o.sourceAttribute,
   }));
   const lexiconOutputs = [
     ...explicitOutputs,
     ...autoOutputs.filter((auto) => {
-      const autoParent = auto._sourceParent.deref();
+      const autoParent = auto._sourceParent?.deref();
       return !explicitRefs.some(
         (e) => e.parent === autoParent && e.attribute === auto.sourceAttribute
       );
     }),
   ];
 
-  // Group outputs by source lexicon
+  // Group outputs by source lexicon.
+  // Intrinsic-based outputs (sourceLexicon === "") have no source entity to derive a lexicon from,
+  // so they are included in every lexicon's output list.
   const outputsByLexicon = new Map<string, LexiconOutput[]>();
+  const unassignedOutputs: LexiconOutput[] = [];
   for (const output of lexiconOutputs) {
+    if (!output.sourceLexicon) {
+      unassignedOutputs.push(output);
+      continue;
+    }
     if (!outputsByLexicon.has(output.sourceLexicon)) {
       outputsByLexicon.set(output.sourceLexicon, []);
     }
@@ -418,7 +425,10 @@ export async function build(
   for (const [lexiconName, lexiconEntities] of partitions) {
     const serializer = serializersByName.get(lexiconName);
     if (serializer) {
-      const lexiconLexiconOutputs = outputsByLexicon.get(lexiconName) ?? [];
+      const lexiconLexiconOutputs = [
+        ...(outputsByLexicon.get(lexiconName) ?? []),
+        ...unassignedOutputs,
+      ];
       outputs.set(lexiconName, serializer.serialize(lexiconEntities, lexiconLexiconOutputs));
     } else {
       warnings.push(`No serializer found for lexicon "${lexiconName}"`);

package/src/lexicon-output.test.ts

@@ -71,6 +71,27 @@ describe("LexiconOutput", () => {
 
     expect(() => new LexiconOutput(ref, "Test")).toThrow("no lexicon field");
   });
+
+  test("accepts an Intrinsic and sets sourceAttribute to null", () => {
+    const mockIntrinsic = { [INTRINSIC_MARKER]: true as const, toJSON: () => ({ "Fn::Sub": "hello" }) };
+    const lo = new LexiconOutput(mockIntrinsic, "MyOutput");
+    expect(lo.sourceAttribute).toBeNull();
+    expect(lo.sourceLexicon).toBe("");
+    expect(lo.outputName).toBe("MyOutput");
+  });
+
+  test("getOutputValue() returns Fn::GetAtt for AttrRef-based output", () => {
+    const bucket = new MockResource();
+    const lo = new LexiconOutput(bucket.arn, "BucketArn");
+    lo._setSourceEntity("myBucket");
+    expect(lo.getOutputValue()).toEqual({ "Fn::GetAtt": ["myBucket", "Arn"] });
+  });
+
+  test("getOutputValue() returns intrinsic toJSON for Intrinsic-based output", () => {
+    const mockIntrinsic = { [INTRINSIC_MARKER]: true as const, toJSON: () => ({ "Fn::Sub": "http://${Param}/path" }) };
+    const lo = new LexiconOutput(mockIntrinsic, "MyUrl");
+    expect(lo.getOutputValue()).toEqual({ "Fn::Sub": "http://${Param}/path" });
+  });
 });
 
 describe("LexiconOutput.auto", () => {

package/src/lexicon-output.ts

@@ -6,31 +6,47 @@ import { AttrRef } from "./attrref";
  * with any consuming lexicon (e.g. GitHub, Cloudflare).
  *
  * Implements Intrinsic so it can be used as Value<string> anywhere.
+ *
+ * Accepts either an AttrRef (resource attribute reference) or any Intrinsic
+ * (e.g. Sub, Join) for computed output values like constructed URLs.
  */
 export class LexiconOutput implements Intrinsic {
   readonly [INTRINSIC_MARKER] = true as const;
   readonly sourceLexicon: string;
   readonly sourceEntity: string;
-  readonly sourceAttribute: string;
+  readonly sourceAttribute: string | null;
   readonly outputName: string;
   /** @internal WeakRef to the source entity object for identity-based matching */
-  readonly _sourceParent: WeakRef<object>;
+  readonly _sourceParent: WeakRef<object> | null;
+  /** @internal Intrinsic value when constructed from an Intrinsic rather than AttrRef */
+  private readonly _intrinsic: Intrinsic | null;
 
-  constructor(ref: AttrRef, name: string) {
-    const parent = ref.parent.deref();
-    if (!parent) {
-      throw new Error("Cannot create LexiconOutput: parent entity has been garbage collected");
-    }
+  constructor(ref: AttrRef | Intrinsic, name: string) {
+    if (ref instanceof AttrRef) {
+      const parent = ref.parent.deref();
+      if (!parent) {
+        throw new Error("Cannot create LexiconOutput: parent entity has been garbage collected");
+      }
 
-    if (!("lexicon" in parent) || typeof (parent as Record<string, unknown>).lexicon !== "string") {
-      throw new Error("Cannot create LexiconOutput: parent entity has no lexicon field");
-    }
+      if (!("lexicon" in parent) || typeof (parent as Record<string, unknown>).lexicon !== "string") {
+        throw new Error("Cannot create LexiconOutput: parent entity has no lexicon field");
+      }
 
-    this.sourceLexicon = (parent as Record<string, unknown>).lexicon as string;
-    this.sourceEntity = "";
-    this.sourceAttribute = ref.attribute;
-    this.outputName = name;
-    this._sourceParent = ref.parent;
+      this.sourceLexicon = (parent as Record<string, unknown>).lexicon as string;
+      this.sourceEntity = "";
+      this.sourceAttribute = ref.attribute;
+      this.outputName = name;
+      this._sourceParent = ref.parent;
+      this._intrinsic = null;
+    } else {
+      // Intrinsic (Sub, Join, Ref, etc.) — no parent entity tracking needed
+      this.sourceLexicon = "";
+      this.sourceEntity = "";
+      this.sourceAttribute = null;
+      this.outputName = name;
+      this._sourceParent = null;
+      this._intrinsic = ref;
+    }
   }
 
   /**
@@ -42,6 +58,18 @@ export class LexiconOutput implements Intrinsic {
     (this as { sourceEntity: string }).sourceEntity = name;
   }
 
+  /**
+   * Returns the CloudFormation Output Value for this output.
+   * For AttrRef-based outputs: emits Fn::GetAtt.
+   * For Intrinsic-based outputs: delegates to the intrinsic's toJSON().
+   */
+  getOutputValue(): unknown {
+    if (this._intrinsic) {
+      return this._intrinsic.toJSON();
+    }
+    return { "Fn::GetAtt": [this.sourceEntity, this.sourceAttribute] };
+  }
+
   /**
    * Create a LexiconOutput with an auto-generated name from entity name and attribute.
    * Used during cross-lexicon ref auto-detection.
@@ -63,14 +91,19 @@ export class LexiconOutput implements Intrinsic {
 }
 
 /**
- * Create a LexiconOutput from an AttrRef and a user-provided output name.
+ * Create a LexiconOutput from an AttrRef or Intrinsic and a user-provided output name.
  *
- * Usage:
+ * Usage with AttrRef:
  * ```ts
  * const bucketArn = output(dataBucket.arn, "DataBucketArn");
  * ```
+ *
+ * Usage with an intrinsic (e.g. a constructed URL):
+ * ```ts
+ * const solrUrl = output(Sub`http://${Ref(albDnsName)}/solr`, "solrUrl");
+ * ```
  */
-export function output(ref: AttrRef, name: string): LexiconOutput {
+export function output(ref: AttrRef | Intrinsic, name: string): LexiconOutput {
   return new LexiconOutput(ref, name);
 }