@intentius/chant 0.101.0 → 0.104.0

package/src/config.test.ts

@@ -1,6 +1,7 @@
 import { describe, test, expect, beforeEach, afterEach, vi } from "vitest";
 import {
   loadChantConfig,
+  InvalidChantConfigError,
   loadChantConfigUpward,
   DEFAULT_CHANT_CONFIG,
   resolveAutoReleaseDisabled,
@@ -129,6 +130,26 @@ describe("loadChantConfig", () => {
     expect(result.config.release?.autoRecord).toBe(false);
   });
 
+  // #2523: run.on is the project's default Op runtime for `chant run`.
+  test("loads chant.config.json with run.on", async () => {
+    writeFileSync(join(TEST_DIR, "chant.config.json"), JSON.stringify({ run: { on: "mylexicon" } }));
+    const result = await loadChantConfig(TEST_DIR);
+    expect(result.config.run?.on).toBe("mylexicon");
+  });
+
+  test.each([
+    ["a non-string run.on", { run: { on: 5 } }, /run\.on/],
+    ["an empty run.on", { run: { on: "" } }, /run\.on/],
+    ["a misspelt key in run", { run: { onn: "mylexicon" } }, /run.*onn/],
+  ])("rejects %s, naming the config file and the key", async (_, raw, key) => {
+    writeFileSync(join(TEST_DIR, "chant.config.json"), JSON.stringify(raw));
+    const err = await loadChantConfig(TEST_DIR).catch((e: unknown) => e);
+    expect(err).toBeInstanceOf(InvalidChantConfigError);
+    expect((err as InvalidChantConfigError).key).toBe("run");
+    expect((err as Error).message).toContain("chant.config.json");
+    expect((err as Error).message).toMatch(key);
+  });
+
   // #606: sbom.format sets the project-wide default SBOM format for every
   // `generate-sbom` step that doesn't specify its own.
   test("loads chant.config.json with sbom.format: cyclonedx", async () => {

package/src/config.ts

@@ -164,6 +164,11 @@ export const ChantConfigSchema = z.object({
   release: z.object({
     autoRecord: z.boolean().optional(),
   }).optional(),
+  // Strict: a misspelt key here would leave Ops on the local runtime with
+  // nothing said (#2523).
+  run: z.object({
+    on: z.string().min(1).optional(),
+  }).strict().optional(),
   sbom: z.object({
     format: z.enum(["spdx", "cyclonedx"]).optional(),
     enabled: z.boolean().optional(),
@@ -370,6 +375,16 @@ export interface ChantConfig {
     autoRecord?: boolean;
   };
 
+  /** Defaults for `chant run` and its subcommands (#2523). */
+  run?: {
+    /**
+     * The runtime that hosts this project's Op runs when `--on` is not
+     * given: a configured lexicon that declares an `opRuntime`, or `"local"`.
+     * `--on` overrides it, and `--on local` selects the built-in runtime.
+     */
+    on?: string;
+  };
+
   /**
    * Project-wide SBOM generation defaults (#606, epic #551 follow-up to
    * #564/#568). Consumed by the `generate-sbom` capability

package/src/declarable.test.ts

@@ -4,6 +4,7 @@ import {
   type Declarable,
   isDeclarable,
   isPropertyDeclarable,
+  isObservableDeclarable,
 } from "./declarable";
 
 describe("DECLARABLE_MARKER", () => {
@@ -123,6 +124,26 @@ describe("isPropertyDeclarable", () => {
   });
 });
 
+describe("isObservableDeclarable (#3001)", () => {
+  const base = { lexicon: "test", [DECLARABLE_MARKER]: true as const };
+
+  test("is true for a resource-kind declarable with props", () => {
+    expect(isObservableDeclarable({ ...base, entityType: "R", kind: "resource", props: {} } as Declarable)).toBe(true);
+  });
+
+  test("is true for a declarable with props and no kind", () => {
+    expect(isObservableDeclarable({ ...base, entityType: "R", props: {} } as Declarable)).toBe(true);
+  });
+
+  test("is false for a property-kind declarable, though it carries props", () => {
+    expect(isObservableDeclarable({ ...base, entityType: "P", kind: "property", props: {} } as Declarable)).toBe(false);
+  });
+
+  test("is false for a declarable without props (an output, a directive)", () => {
+    expect(isObservableDeclarable({ ...base, entityType: "O", kind: "output" })).toBe(false);
+  });
+});
+
 describe("Declarable interface", () => {
   test("allows creating objects without kind field (backward compatibility)", () => {
     const obj: Declarable = {

package/src/declarable.ts

@@ -130,3 +130,22 @@ function carriesForeignDeclarableMarker(value: object): boolean {
 export function isPropertyDeclarable(value: Declarable): boolean {
   return value.kind === "property";
 }
+
+/**
+ * A declarable with a live counterpart of its own: what the live paths
+ * (`describeResources`, `observeResourcesDeep`, the snapshot, the diff and the
+ * change set) put in front of a lexicon's reader.
+ *
+ * Outputs, parameters and serializer directives carry no `props` and are
+ * already left out by {@link isResourceDeclarable}. A property-kind declarable
+ * (`createProperty`: Grafana's panels, an aws `SecurityGroup_Ingress`) does
+ * carry `props`, but it exists only inside the resource that holds it, and the
+ * deep diff already compares it as part of that resource's tree (#1314).
+ * Asking a reader about one on its own makes the answer either "absent", so
+ * `lifecycle plan` proposes a `create`, or "not observed", a hole for
+ * something read in full (#3001). This is the same test `graph-ir.ts` uses to
+ * keep property-kind declarables off the graph's nodes.
+ */
+export function isObservableDeclarable(value: Declarable): value is ResourceDeclarable {
+  return isResourceDeclarable(value) && !isPropertyDeclarable(value);
+}

package/src/discovery/fold-composite.test.ts

@@ -322,6 +322,37 @@ describe("composite factory interpretation (chant #1023)", () => {
     expect(run).toContain("GetAtt");
   });
 
+  test("a call whose props name a member of a same-file composite call interprets too (chant#3325)", async () => {
+    await writeComposite(
+      ADMISSIBLE_BODY,
+      `export const Reader = Composite((props) => {
+        const reader = new Role({ RoleName: props.name, Description: props.bucket.Arn });
+        return { reader };
+      }, "Reader");`,
+    );
+    await writeMain(`
+      import { Reader, WebApp } from "../composites";
+      export const web = WebApp({ name: "data" });
+      export const readers = Reader({ name: "readers", bucket: web.bucket });
+    `);
+
+    const runResult = await build(srcDir, [specSerializer], undefined, { fold: false });
+    resetFoldExecutionCounts();
+    const foldResult = await build(srcDir, [specSerializer], undefined, {
+      fold: true,
+      lexicons: [LEXICON_NAME],
+    });
+
+    expect(foldResult.errors).toEqual([]);
+    expect(foldResult.foldDecisions.map((d) => d.mode)).toEqual(["fold"]);
+    // `web` is interpreted once: the declarator and the reference share it.
+    expect(foldExecutionCounts()).toMatchObject({ factoryInterpretations: 2, projectFactoryInvocations: 0 });
+    const folded = String(foldResult.outputs.get(LEXICON_NAME));
+    expect(folded).toBe(String(runResult.outputs.get(LEXICON_NAME)));
+    expect(folded).toContain('"webBucket"');
+    expect(JSON.parse(folded).readersReader.props.Description).toEqual({ GetAtt: ["webBucket", "Arn"] });
+  });
+
   test("provenance is stamped from the source's own composite name", async () => {
     await writeComposite(ADMISSIBLE_BODY);
     await writeMain(CALL_WEBAPP);
@@ -450,10 +481,15 @@ describe("composite factory interpretation (chant #1023)", () => {
     expect([...result.entities.keys()].sort()).toEqual(["webBucket", "webRole"]);
   });
 
-  test("a lexicon-package composite is deliberately not interpreted (rule 1)", async () => {
-    // `LambdaApi` is a composite the aws lexicon itself publishes. It folds —
-    // by invocation, in-process, which is exactly what #1093's allowlist
-    // permits for a package the CLI has already loaded.
+  test("a lexicon-package composite whose body declines is invoked, and the file still folds (rule 1)", async () => {
+    // `LambdaApi` is a composite the aws lexicon itself publishes, reached
+    // through the package barrel. Since chant#3247 it is a candidate for
+    // interpretation like a project composite. Its body declines: the nested
+    // `LambdaFunction` is outside the subset and is invoked (package code,
+    // which #1093's allowlist permits), and `defaults?.permission` on an
+    // absent `defaults` does not resolve. The decline lands where the code
+    // always landed: the package's factory is invoked in-process and the file
+    // folds. The attempt's nested invocation is counted too, hence two.
     await writeMain(`
       import { LambdaApi } from ${JSON.stringify(LEXICON)};
       export const api = LambdaApi({
@@ -469,7 +505,7 @@ describe("composite factory interpretation (chant #1023)", () => {
     expect(result.errors).toEqual([]);
     expect(result.foldDecisions.find((d) => d.file.endsWith("main.ts"))?.mode).toBe("fold");
     expect(foldExecutionCounts()).toMatchObject({ factoryInterpretations: 0, projectFactoryInvocations: 0 });
-    expect(foldExecutionCounts().factoryInvocations).toBe(1);
+    expect(foldExecutionCounts().factoryInvocations).toBe(2);
     expect(result.entities.size).toBeGreaterThan(0);
   });
 

package/src/discovery/fold-import.test.ts

@@ -1007,6 +1007,135 @@ describe("tryFoldFile — registered intrinsic tagged templates (#1039)", () =>
   });
 });
 
+// chant #3196 — a registered tag that returns an entity (the shape the sql
+// lexicon's `table`/`view` tags take): it reads `strings.raw`, renders an
+// interpolated entity by its name, and records it as a dependency. Fold has to
+// hand it the TemplateStringsArray a real tagged call does, and a same-file
+// reference to one has to read the one entity discovery registers.
+describe("tryFoldFile — tags that read raw strings and return entities (#3196)", () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `chant-fold-import-tag-entity-test-${Date.now()}-${Math.random()}`);
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  const TABLE: IntrinsicDef = { name: "table", isTag: true };
+  const SUB: IntrinsicDef = { name: "Sub", isTag: true };
+
+  async function writeTagDefs(): Promise<void> {
+    await writeFile(
+      join(testDir, "tags.ts"),
+      `
+        import { createResource } from ${JSON.stringify(runtimePath)};
+        import { INTRINSIC_MARKER } from ${JSON.stringify(intrinsicPath)};
+        const Table = createResource("Test::Table", "test", {});
+
+        export function table(strings, ...values) {
+          if (!Object.isFrozen(strings) || !Object.isFrozen(strings.raw)) throw new Error("not a TemplateStringsArray");
+          let ddl = strings.raw[0];
+          const dependsOn = [];
+          values.forEach((v, i) => {
+            if (v && typeof v === "object" && v.props) {
+              dependsOn.push(v);
+              ddl += v.props.name;
+            } else {
+              ddl += String(v);
+            }
+            ddl += strings.raw[i + 1];
+          });
+          const name = /CREATE (?:TABLE|VIEW) (\\w+)/.exec(ddl)?.[1];
+          return new Table({ name, ddl, cooked: strings.join("|"), dependsOn });
+        }
+
+        export function Sub(strings, ...values) {
+          return { [INTRINSIC_MARKER]: true, strings: [...strings], values, toJSON() { return { "Test::Sub": strings.join("") }; } };
+        }
+      `,
+    );
+  }
+
+  type Props = { name: string; ddl: string; cooked: string; dependsOn: unknown[] };
+  const propsOf = (entity: unknown): Props => (entity as { props: Props }).props;
+
+  test("a backslash in the template folds to the same text running gives", async () => {
+    await writeTagDefs();
+    const file = join(testDir, "main.ts");
+    await writeFile(
+      file,
+      "import { table } from \"./tags\";\n" +
+        "export const users = table`CREATE TABLE users (re String DEFAULT '\\d+\\t', nl String DEFAULT '\\n')`;\n",
+    );
+
+    const result = await tryFoldFile(file, [TABLE]);
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const folded = propsOf(result.exportedValues.get("users"));
+    const ran = propsOf((await import(file)).users);
+
+    expect(folded.ddl).toBe("CREATE TABLE users (re String DEFAULT '\\d+\\t', nl String DEFAULT '\\n')");
+    expect(folded.ddl).toBe(ran.ddl);
+    expect(folded.cooked).toBe(ran.cooked);
+  });
+
+  test("a tag referencing a same-file tag const folds, and reads the one entity discovery registers", async () => {
+    await writeTagDefs();
+    const file = join(testDir, "main.ts");
+    await writeFile(
+      file,
+      `
+        import { table } from "./tags";
+        throw new Error("must never execute — the file folds");
+        export const events = table\`CREATE TABLE events (user_id UUID)\`;
+        export const active = table\`CREATE VIEW active AS SELECT user_id FROM \${events} -- \${events.props.name}\`;
+      `,
+    );
+
+    const result = await tryFoldFile(file, [TABLE]);
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.entities.map(([name]) => name)).toEqual(["events", "active"]);
+    const events = result.entities[0][1];
+    const active = propsOf(result.entities[1][1]);
+    expect(active.ddl).toBe("CREATE VIEW active AS SELECT user_id FROM events -- events");
+    expect(active.dependsOn).toHaveLength(1);
+    expect(active.dependsOn[0]).toBe(events);
+  });
+
+  test("a resource holding a same-file tag const shares the instance running gives it", async () => {
+    await writeTagDefs();
+    await writeFile(
+      join(testDir, "resources.ts"),
+      `
+        import { createResource } from ${JSON.stringify(runtimePath)};
+        export const Bucket = createResource("Test::Bucket", "test", {});
+      `,
+    );
+    const file = join(testDir, "main.ts");
+    await writeFile(
+      file,
+      `
+        import { Bucket } from "./resources";
+        import { Sub } from "./tags";
+        export const name = Sub\`data-\\\\d\`;
+        export const bucket = new Bucket({ name });
+      `,
+    );
+
+    const result = await tryFoldFile(file, [SUB]);
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const name = result.exportedValues.get("name");
+    expect(isIntrinsic(name)).toBe(true);
+    expect((result.exportedValues.get("bucket") as { props: { name: unknown } }).props.name).toBe(name);
+    expect(JSON.stringify(name)).toBe(JSON.stringify((await import(file)).name));
+  });
+});
+
 describe("tryFoldFile — build-time parameters (chant #1064)", () => {
   let testDir: string;