@intentius/chant 0.0.5 → 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-adapter.ts

@@ -0,0 +1,158 @@
+/**
+ * Runtime adapter — abstracts Bun-specific APIs so chant can run on Bun or Node.js.
+ *
+ * Auto-detects the host runtime and delegates to the appropriate implementation.
+ * The `target` parameter (from config) controls what gets spawned (bun vs node/npx/npm),
+ * not which adapter class is used.
+ */
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { createHash } from "crypto";
+import { execFile } from "child_process";
+// @ts-ignore — picomatch has no types declaration
+import picomatch from "picomatch";
+
+export interface SpawnResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+export interface RuntimeCommands {
+  /** Runtime binary: "bun" | "node" */
+  runner: string;
+  /** Package executor: "bunx" | "npx" */
+  exec: string;
+  /** Pack command: ["bun", "pm", "pack"] | ["npm", "pack"] */
+  packCmd: string[];
+}
+
+export interface RuntimeAdapter {
+  readonly name: "bun" | "node";
+  /** Hash content and return hex string */
+  hash(content: string): string;
+  /** Algorithm name recorded in integrity.json */
+  readonly hashAlgorithm: string;
+  /** Test whether filePath matches a glob pattern */
+  globMatch(pattern: string, filePath: string): boolean;
+  /** Spawn a child process and collect output */
+  spawn(cmd: string[], opts?: { cwd?: string }): Promise<SpawnResult>;
+  /** Commands to use when spawning package manager / executor */
+  readonly commands: RuntimeCommands;
+}
+
+// ── Bun adapter ──────────────────────────────────────────────────
+
+class BunRuntimeAdapter implements RuntimeAdapter {
+  readonly name = "bun" as const;
+  readonly hashAlgorithm = "xxhash64";
+  readonly commands: RuntimeCommands;
+
+  constructor(target: "bun" | "node") {
+    this.commands =
+      target === "node"
+        ? { runner: "node", exec: "npx", packCmd: ["npm", "pack"] }
+        : { runner: "bun", exec: "bunx", packCmd: ["bun", "pm", "pack"] };
+  }
+
+  hash(content: string): string {
+    return Bun.hash(content).toString(16);
+  }
+
+  globMatch(pattern: string, filePath: string): boolean {
+    const glob = new Bun.Glob(pattern);
+    return glob.match(filePath);
+  }
+
+  async spawn(cmd: string[], opts?: { cwd?: string }): Promise<SpawnResult> {
+    const proc = Bun.spawn(cmd, {
+      cwd: opts?.cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ]);
+    const exitCode = await proc.exited;
+    return { stdout, stderr, exitCode };
+  }
+}
+
+// ── Node adapter ─────────────────────────────────────────────────
+
+class NodeRuntimeAdapter implements RuntimeAdapter {
+  readonly name = "node" as const;
+  readonly hashAlgorithm = "sha256";
+  readonly commands: RuntimeCommands;
+
+  constructor(target: "bun" | "node") {
+    this.commands =
+      target === "bun"
+        ? { runner: "bun", exec: "bunx", packCmd: ["bun", "pm", "pack"] }
+        : { runner: "node", exec: "npx", packCmd: ["npm", "pack"] };
+  }
+
+  hash(content: string): string {
+    return createHash("sha256").update(content).digest("hex");
+  }
+
+  globMatch(pattern: string, filePath: string): boolean {
+    return picomatch(pattern)(filePath);
+  }
+
+  async spawn(cmd: string[], opts?: { cwd?: string }): Promise<SpawnResult> {
+    return new Promise((resolve) => {
+      execFile(cmd[0], cmd.slice(1), { cwd: opts?.cwd, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+        resolve({
+          stdout: stdout ?? "",
+          stderr: stderr ?? "",
+          exitCode: err ? (err as any).code ?? 1 : 0,
+        });
+      });
+    });
+  }
+}
+
+// ── Singleton ────────────────────────────────────────────────────
+
+let _runtime: RuntimeAdapter | undefined;
+
+/**
+ * Detect whether we're running under Bun.
+ */
+function isBun(): boolean {
+  return typeof globalThis.Bun !== "undefined";
+}
+
+/**
+ * Initialize the runtime adapter singleton.
+ *
+ * @param target - Which commands to spawn ("bun" or "node"). Defaults to auto-detect.
+ *   Controls the `commands` property, not which adapter class is used.
+ */
+export function initRuntime(target?: "bun" | "node"): RuntimeAdapter {
+  const resolvedTarget = target ?? (isBun() ? "bun" : "node");
+  _runtime = isBun()
+    ? new BunRuntimeAdapter(resolvedTarget)
+    : new NodeRuntimeAdapter(resolvedTarget);
+  return _runtime;
+}
+
+/**
+ * Get the runtime adapter. Lazily initializes with auto-detection if not yet set.
+ */
+export function getRuntime(): RuntimeAdapter {
+  if (!_runtime) {
+    return initRuntime();
+  }
+  return _runtime;
+}
+
+/**
+ * Convert `import.meta.url` to a directory path.
+ * Works on both Bun and Node (replaces Bun-only `import.meta.dir`).
+ */
+export function moduleDir(importMetaUrl: string): string {
+  return dirname(fileURLToPath(importMetaUrl));
+}

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 });

package/src/serializer-walker.test.ts

@@ -93,15 +93,6 @@ describe("walkValue", () => {
     expect(walkValue({ a: 1, b: { c: 2 } }, names, mockVisitor)).toEqual({ a: 1, b: { c: 2 } });
   });
 
-  test("applies transformKey when provided", () => {
-    const visitor: SerializerVisitor = {
-      ...mockVisitor,
-      transformKey: (k) => k.toUpperCase(),
-    };
-    const names = new Map<Declarable, string>();
-    expect(walkValue({ foo: 1, bar: 2 }, names, visitor)).toEqual({ FOO: 1, BAR: 2 });
-  });
-
   test("complex nested structure", () => {
     const resource = makeDeclarable("Test::Role");
     const ref = new AttrRef(resource, "arn");

package/src/serializer-walker.ts

@@ -17,8 +17,6 @@ export interface SerializerVisitor {
   resourceRef(logicalName: string): unknown;
   /** Format a property-level Declarable by walking its props. */
   propertyDeclarable(entity: Declarable, walk: (v: unknown) => unknown): unknown;
-  /** Optional key transformation (e.g. camelCase → PascalCase). */
-  transformKey?(key: string): string;
 }
 
 /**
@@ -73,7 +71,7 @@ export function walkValue(
   if (typeof value === "object") {
     const result: Record<string, unknown> = {};
     for (const [key, val] of Object.entries(value)) {
-      const outKey = visitor.transformKey ? visitor.transformKey(key) : key;
+      const outKey = key;
       result[outKey] = walkValue(val, entityNames, visitor);
     }
     return result;

package/src/cli/commands/__fixtures__/init-lexicon-output/src/codegen/rollback.ts

@@ -1,45 +0,0 @@
-import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, cpSync } from "fs";
-import { join, basename } from "path";
-
-export interface Snapshot {
-  timestamp: string;
-  resources: number;
-  path: string;
-}
-
-/**
- * List available generation snapshots.
- */
-export function listSnapshots(snapshotsDir: string): Snapshot[] {
-  if (!existsSync(snapshotsDir)) return [];
-
-  return readdirSync(snapshotsDir)
-    .filter((d) => !d.startsWith("."))
-    .sort()
-    .reverse()
-    .map((dir) => {
-      const fullPath = join(snapshotsDir, dir);
-      const metaPath = join(fullPath, "meta.json");
-      let resources = 0;
-      if (existsSync(metaPath)) {
-        try {
-          const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
-          resources = meta.resources ?? 0;
-        } catch {}
-      }
-      return { timestamp: dir, resources, path: fullPath };
-    });
-}
-
-/**
- * Restore a snapshot to the generated directory.
- */
-export function restoreSnapshot(timestamp: string, generatedDir: string): void {
-  const snapshotsDir = join(generatedDir, "..", "..", ".snapshots");
-  const snapshotDir = join(snapshotsDir, timestamp);
-  if (!existsSync(snapshotDir)) {
-    throw new Error(`Snapshot not found: ${timestamp}`);
-  }
-  mkdirSync(generatedDir, { recursive: true });
-  cpSync(snapshotDir, generatedDir, { recursive: true });
-}

package/src/codegen/case.test.ts

@@ -1,30 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { toCamelCase, toPascalCase } from "./case";
-
-describe("toCamelCase", () => {
-  test("lowercases first character", () => {
-    expect(toCamelCase("BucketName")).toBe("bucketName");
-  });
-
-  test("preserves already-camelCase", () => {
-    expect(toCamelCase("already")).toBe("already");
-  });
-
-  test("handles single character", () => {
-    expect(toCamelCase("A")).toBe("a");
-  });
-});
-
-describe("toPascalCase", () => {
-  test("uppercases first character", () => {
-    expect(toPascalCase("bucketName")).toBe("BucketName");
-  });
-
-  test("preserves already-PascalCase", () => {
-    expect(toPascalCase("Already")).toBe("Already");
-  });
-
-  test("handles single character", () => {
-    expect(toPascalCase("a")).toBe("A");
-  });
-});

package/src/codegen/case.ts

@@ -1,11 +0,0 @@
-/**
- * Case conversion utilities for codegen.
- */
-
-export function toCamelCase(name: string): string {
-  return name.charAt(0).toLowerCase() + name.slice(1);
-}
-
-export function toPascalCase(name: string): string {
-  return name.charAt(0).toUpperCase() + name.slice(1);
-}

package/src/codegen/rollback.test.ts

@@ -1,92 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { mkdirSync, writeFileSync, rmSync, readFileSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import { snapshotArtifacts, saveSnapshot, restoreSnapshot, listSnapshots } from "./rollback";
-
-function makeTempDir(): string {
-  const dir = join(tmpdir(), `chant-rollback-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-describe("rollback", () => {
-  test("snapshot captures generated files with default artifact names", () => {
-    const dir = makeTempDir();
-    const genDir = join(dir, "generated");
-    mkdirSync(genDir, { recursive: true });
-
-    writeFileSync(join(genDir, "lexicon.json"), '{"Bucket":{"kind":"resource"}}');
-    writeFileSync(join(genDir, "index.d.ts"), "declare class Bucket {}");
-    writeFileSync(join(genDir, "index.ts"), "export const Bucket = {};");
-
-    const snapshot = snapshotArtifacts(genDir);
-    expect(snapshot.files["lexicon.json"]).toBeDefined();
-    expect(snapshot.files["index.d.ts"]).toBeDefined();
-    expect(snapshot.files["index.ts"]).toBeDefined();
-    expect(snapshot.hashes["lexicon.json"]).toBeDefined();
-    expect(snapshot.resourceCount).toBe(1);
-
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  test("snapshot uses custom artifact names", () => {
-    const dir = makeTempDir();
-    const genDir = join(dir, "generated");
-    mkdirSync(genDir, { recursive: true });
-
-    writeFileSync(join(genDir, "my-lexicon.json"), '{"Resource":{"kind":"resource"}}');
-    writeFileSync(join(genDir, "types.d.ts"), "declare class Resource {}");
-
-    const snapshot = snapshotArtifacts(genDir, ["my-lexicon.json", "types.d.ts"]);
-    expect(snapshot.files["my-lexicon.json"]).toBeDefined();
-    expect(snapshot.files["types.d.ts"]).toBeDefined();
-    expect(snapshot.resourceCount).toBe(1);
-
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  test("save and list snapshots", () => {
-    const dir = makeTempDir();
-    const snapshotsDir = join(dir, ".snapshots");
-
-    const snapshot = {
-      timestamp: "2025-01-01T00:00:00.000Z",
-      files: { "test.json": "{}" },
-      hashes: { "test.json": "abc123" },
-      resourceCount: 0,
-    };
-
-    saveSnapshot(snapshot, snapshotsDir);
-    const list = listSnapshots(snapshotsDir);
-    expect(list.length).toBe(1);
-    expect(list[0].timestamp).toBe("2025-01-01T00:00:00.000Z");
-
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  test("restore snapshot overwrites generated files", () => {
-    const dir = makeTempDir();
-    const genDir = join(dir, "generated");
-    const snapshotsDir = join(dir, ".snapshots");
-    mkdirSync(genDir, { recursive: true });
-
-    writeFileSync(join(genDir, "lexicon.json"), '{"original":true}');
-
-    const snapshot = snapshotArtifacts(genDir);
-    const snapshotPath = saveSnapshot(snapshot, snapshotsDir);
-
-    writeFileSync(join(genDir, "lexicon.json"), '{"modified":true}');
-    expect(readFileSync(join(genDir, "lexicon.json"), "utf-8")).toBe('{"modified":true}');
-
-    restoreSnapshot(snapshotPath, genDir);
-    expect(readFileSync(join(genDir, "lexicon.json"), "utf-8")).toBe('{"original":true}');
-
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  test("listSnapshots returns empty for nonexistent dir", () => {
-    const list = listSnapshots("/nonexistent/path");
-    expect(list).toHaveLength(0);
-  });
-});

package/src/codegen/rollback.ts

@@ -1,115 +0,0 @@
-/**
- * Artifact snapshot and restore for generation rollback.
- */
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "fs";
-import { join } from "path";
-import { hashArtifact } from "../lexicon-integrity";
-
-export interface ArtifactSnapshot {
-  timestamp: string;
-  files: Record<string, string>;
-  hashes: Record<string, string>;
-  resourceCount: number;
-}
-
-export interface SnapshotInfo {
-  path: string;
-  timestamp: string;
-  resourceCount: number;
-}
-
-const DEFAULT_ARTIFACT_NAMES = ["lexicon.json", "index.d.ts", "index.ts"];
-
-/**
- * Snapshot current generated artifacts.
- *
- * @param generatedDir - Directory containing generated artifacts
- * @param artifactNames - List of filenames to snapshot (defaults to generic names)
- */
-export function snapshotArtifacts(
-  generatedDir: string,
-  artifactNames: string[] = DEFAULT_ARTIFACT_NAMES,
-): ArtifactSnapshot {
-  const files: Record<string, string> = {};
-  const hashes: Record<string, string> = {};
-  let resourceCount = 0;
-
-  for (const entry of artifactNames) {
-    const path = join(generatedDir, entry);
-    if (existsSync(path)) {
-      const content = readFileSync(path, "utf-8");
-      files[entry] = content;
-      hashes[entry] = hashArtifact(content);
-
-      // Count resources in any .json artifact
-      if (entry.endsWith(".json")) {
-        try {
-          const parsed = JSON.parse(content);
-          resourceCount = Object.values(parsed).filter(
-            (e: any) => e && typeof e === "object" && e.kind === "resource"
-          ).length;
-        } catch {}
-      }
-    }
-  }
-
-  return {
-    timestamp: new Date().toISOString(),
-    files,
-    hashes,
-    resourceCount,
-  };
-}
-
-/**
- * Save a snapshot to the .snapshots directory.
- */
-export function saveSnapshot(snapshot: ArtifactSnapshot, snapshotsDir: string): string {
-  mkdirSync(snapshotsDir, { recursive: true });
-
-  const filename = `${snapshot.timestamp.replace(/[:.]/g, "-")}.json`;
-  const path = join(snapshotsDir, filename);
-  writeFileSync(path, JSON.stringify(snapshot, null, 2));
-  return path;
-}
-
-/**
- * Restore a snapshot to the generated directory.
- */
-export function restoreSnapshot(snapshotPath: string, generatedDir: string): void {
-  const raw = readFileSync(snapshotPath, "utf-8");
-  const snapshot: ArtifactSnapshot = JSON.parse(raw);
-
-  mkdirSync(generatedDir, { recursive: true });
-  for (const [filename, content] of Object.entries(snapshot.files)) {
-    writeFileSync(join(generatedDir, filename), content);
-  }
-}
-
-/**
- * List available snapshots.
- */
-export function listSnapshots(snapshotsDir: string): SnapshotInfo[] {
-  if (!existsSync(snapshotsDir)) return [];
-
-  const entries = readdirSync(snapshotsDir)
-    .filter((f) => f.endsWith(".json"))
-    .sort()
-    .reverse();
-
-  const snapshots: SnapshotInfo[] = [];
-  for (const entry of entries) {
-    try {
-      const path = join(snapshotsDir, entry);
-      const raw = readFileSync(path, "utf-8");
-      const data = JSON.parse(raw);
-      snapshots.push({
-        path,
-        timestamp: data.timestamp,
-        resourceCount: data.resourceCount ?? 0,
-      });
-    } catch {}
-  }
-
-  return snapshots;
-}