@intentius/chant 0.0.1

package/src/lint/rules/evl009-composite-no-constant.ts

@@ -0,0 +1,171 @@
+import * as ts from "typescript";
+import type { LintRule, LintContext, LintDiagnostic } from "../rule";
+import { getCompositeFactory } from "./composite-scope";
+
+/**
+ * EVL009: No extractable constants inside Composite factory
+ *
+ * Composite factories should only reference props, sibling members, and barrel refs.
+ * Object literals and arrays-of-objects that don't reference any of these are
+ * extractable constants that belong in a separate file (e.g. defaults.ts).
+ *
+ * Triggers on: assumeRolePolicyDocument: { Version: "2012-10-17", Statement: [...] }
+ * Triggers on: managedPolicyArns: ["arn:aws:iam::aws:policy/..."]
+ * OK: assumeRolePolicyDocument: _.$.lambdaTrustPolicy
+ * OK: policies: props.policies
+ * OK: role: role.arn
+ * OK: action: "lambda:InvokeFunction" (simple string literal — not an object)
+ */
+
+/**
+ * Check whether any leaf node in the subtree references:
+ * - The props parameter identifier
+ * - A barrel ref (_.$ or $)
+ * - A local variable declared in the composite factory body
+ */
+function referencesPropsOrMembers(
+  node: ts.Node,
+  propsName: string,
+  localNames: Set<string>,
+): boolean {
+  if (ts.isIdentifier(node)) {
+    // Direct props reference
+    if (node.text === propsName) return true;
+    // Local variable reference (sibling member)
+    if (localNames.has(node.text)) return true;
+  }
+
+  // Barrel ref: _.$.something or $.something
+  if (ts.isPropertyAccessExpression(node)) {
+    if (isBarrelRef(node)) return true;
+  }
+
+  let found = false;
+  ts.forEachChild(node, (child) => {
+    if (!found && referencesPropsOrMembers(child, propsName, localNames)) {
+      found = true;
+    }
+  });
+  return found;
+}
+
+function isBarrelRef(node: ts.PropertyAccessExpression): boolean {
+  // _.$.x or $.x
+  const expr = node.expression;
+  if (ts.isIdentifier(expr) && expr.text === "$") return true;
+  if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.name) && expr.name.text === "$") {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Check if a value is an extractable constant:
+ * - Object literal (with any nesting)
+ * - Array literal containing object literals
+ * Simple primitives (string, number, boolean) are allowed inline.
+ */
+function isExtractableShape(node: ts.Node): boolean {
+  if (ts.isObjectLiteralExpression(node)) return true;
+  if (ts.isArrayLiteralExpression(node)) {
+    return node.elements.some(
+      (el) => ts.isObjectLiteralExpression(el) || ts.isArrayLiteralExpression(el),
+    );
+  }
+  return false;
+}
+
+function checkComposite(
+  call: ts.CallExpression,
+  context: LintContext,
+  diagnostics: LintDiagnostic[],
+): void {
+  const factory = call.arguments[0];
+  if (!factory || (!ts.isArrowFunction(factory) && !ts.isFunctionExpression(factory))) return;
+
+  // Get props parameter name
+  const propsParam = factory.parameters[0];
+  const propsName = propsParam && ts.isIdentifier(propsParam.name) ? propsParam.name.text : "";
+
+  // Collect local variable names declared in the factory body
+  const localNames = new Set<string>();
+  const body = factory.body;
+  if (ts.isBlock(body)) {
+    for (const stmt of body.statements) {
+      if (ts.isVariableStatement(stmt)) {
+        for (const decl of stmt.declarationList.declarations) {
+          if (ts.isIdentifier(decl.name)) {
+            localNames.add(decl.name.text);
+          }
+        }
+      }
+    }
+  }
+
+  // Walk all NewExpression nodes inside the factory body
+  checkForConstants(body, context, diagnostics, propsName, localNames);
+}
+
+function checkForConstants(
+  node: ts.Node,
+  context: LintContext,
+  diagnostics: LintDiagnostic[],
+  propsName: string,
+  localNames: Set<string>,
+): void {
+  if (ts.isNewExpression(node) && node.arguments && node.arguments.length > 0) {
+    const firstArg = node.arguments[0];
+    if (ts.isObjectLiteralExpression(firstArg)) {
+      for (const prop of firstArg.properties) {
+        if (!ts.isPropertyAssignment(prop)) continue;
+        const value = prop.initializer;
+
+        if (isExtractableShape(value) && !referencesPropsOrMembers(value, propsName, localNames)) {
+          const propName = ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)
+            ? (ts.isIdentifier(prop.name) ? prop.name.text : prop.name.text)
+            : "<computed>";
+
+          const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
+            value.getStart(context.sourceFile),
+          );
+
+          diagnostics.push({
+            file: context.filePath,
+            line: line + 1,
+            column: character + 1,
+            ruleId: "EVL009",
+            severity: "warning",
+            message: `Extractable constant in Composite factory property "${propName}" — move to a separate file and reference via _.$.name`,
+          });
+        }
+      }
+    }
+  }
+
+  ts.forEachChild(node, (child) =>
+    checkForConstants(child, context, diagnostics, propsName, localNames),
+  );
+}
+
+function checkNode(node: ts.Node, context: LintContext, diagnostics: LintDiagnostic[]): void {
+  if (ts.isCallExpression(node)) {
+    const factory = getCompositeFactory(node);
+    if (factory) {
+      checkComposite(node, context, diagnostics);
+      return; // Don't recurse further — checkComposite handles it
+    }
+  }
+
+  ts.forEachChild(node, (child) => checkNode(child, context, diagnostics));
+}
+
+export const evl009CompositeNoConstantRule: LintRule = {
+  id: "EVL009",
+  severity: "warning",
+  category: "style",
+  check(context: LintContext): LintDiagnostic[] {
+    const diagnostics: LintDiagnostic[] = [];
+    checkNode(context.sourceFile, context, diagnostics);
+    return diagnostics;
+  },
+};

package/src/lint/rules/evl010-composite-no-transform.test.ts

@@ -0,0 +1,121 @@
+import { describe, test, expect } from "bun:test";
+import * as ts from "typescript";
+import { evl010CompositeNoTransformRule } from "./evl010-composite-no-transform";
+import type { LintContext } from "../rule";
+
+function createContext(code: string, filePath = "test.ts"): LintContext {
+  const sourceFile = ts.createSourceFile(filePath, code, ts.ScriptTarget.Latest, true);
+  return { sourceFile, entities: [], filePath, lexicon: undefined };
+}
+
+describe("EVL010: composite-no-transform", () => {
+  test("rule metadata", () => {
+    expect(evl010CompositeNoTransformRule.id).toBe("EVL010");
+    expect(evl010CompositeNoTransformRule.severity).toBe("warning");
+    expect(evl010CompositeNoTransformRule.category).toBe("style");
+  });
+
+  test("flags .map() inside Composite factory", () => {
+    const ctx = createContext(`
+      const MyComp = Composite((props) => {
+        const role = new Role({
+          policies: props.items.map(x => new Policy(x)),
+        });
+        return { role };
+      }, "MyComp");
+    `);
+    const diags = evl010CompositeNoTransformRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].ruleId).toBe("EVL010");
+    expect(diags[0].message).toContain(".map()");
+  });
+
+  test("flags .filter() inside Composite factory", () => {
+    const ctx = createContext(`
+      const MyComp = Composite((props) => {
+        const role = new Role({
+          policies: props.items.filter(Boolean),
+        });
+        return { role };
+      }, "MyComp");
+    `);
+    const diags = evl010CompositeNoTransformRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].message).toContain(".filter()");
+  });
+
+  test("flags .reduce() inside Composite factory", () => {
+    const ctx = createContext(`
+      const MyComp = _.Composite((props) => {
+        const tags = Object.keys(props.env).reduce((acc, k) => {
+          acc[k] = props.env[k];
+          return acc;
+        }, {});
+        const bucket = new Bucket({ tags });
+        return { bucket };
+      }, "MyComp");
+    `);
+    const diags = evl010CompositeNoTransformRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].message).toContain(".reduce()");
+  });
+
+  test("flags .flatMap() inside Composite factory", () => {
+    const ctx = createContext(`
+      const MyComp = Composite((props) => {
+        const role = new Role({
+          policies: props.groups.flatMap(g => g.policies),
+        });
+        return { role };
+      }, "MyComp");
+    `);
+    const diags = evl010CompositeNoTransformRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].message).toContain(".flatMap()");
+  });
+
+  test("does not flag .map() outside Composite factory", () => {
+    const ctx = createContext(`
+      const items = data.map(x => new Thing(x));
+    `);
+    expect(evl010CompositeNoTransformRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("does not flag props pass-through", () => {
+    const ctx = createContext(`
+      const MyComp = Composite((props) => {
+        const role = new Role({
+          policies: props.policies,
+        });
+        return { role };
+      }, "MyComp");
+    `);
+    expect(evl010CompositeNoTransformRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("does not flag array literal", () => {
+    const ctx = createContext(`
+      const MyComp = Composite((props) => {
+        const role = new Role({
+          managedPolicyArns: [props.arn],
+        });
+        return { role };
+      }, "MyComp");
+    `);
+    expect(evl010CompositeNoTransformRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("flags multiple transforms", () => {
+    const ctx = createContext(`
+      const MyComp = Composite((props) => {
+        const role = new Role({
+          policies: props.items.map(x => new Policy(x)),
+          tags: props.tags.filter(t => t.active),
+        });
+        return { role };
+      }, "MyComp");
+    `);
+    const diags = evl010CompositeNoTransformRule.check(ctx);
+    expect(diags).toHaveLength(2);
+  });
+});

package/src/lint/rules/evl010-composite-no-transform.ts

@@ -0,0 +1,69 @@
+import * as ts from "typescript";
+import type { LintRule, LintContext, LintDiagnostic } from "../rule";
+import { isInsideCompositeFactory } from "./composite-scope";
+
+/**
+ * EVL010: No data transformation inside Composite factory
+ *
+ * Composite factories should only compose resources from props, not transform data.
+ * Data transformation (map, filter, reduce, etc.) should happen before passing props.
+ *
+ * Triggers on: props.items.map(x => new Thing(x))
+ * Triggers on: props.list.filter(Boolean)
+ * Triggers on: Object.keys(props.env).reduce(...)
+ * OK: props.policies (pass-through)
+ * OK: [a, b] (array literal)
+ */
+
+const TRANSFORM_METHODS = new Set([
+  "map",
+  "filter",
+  "reduce",
+  "flatMap",
+  "forEach",
+  "find",
+  "some",
+  "every",
+  "sort",
+  "reverse",
+  "splice",
+  "slice",
+  "concat",
+]);
+
+function checkNode(node: ts.Node, context: LintContext, diagnostics: LintDiagnostic[]): void {
+  if (
+    ts.isCallExpression(node) &&
+    ts.isPropertyAccessExpression(node.expression) &&
+    isInsideCompositeFactory(node)
+  ) {
+    const methodName = node.expression.name.text;
+    if (TRANSFORM_METHODS.has(methodName)) {
+      const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
+        node.expression.name.getStart(context.sourceFile),
+      );
+
+      diagnostics.push({
+        file: context.filePath,
+        line: line + 1,
+        column: character + 1,
+        ruleId: "EVL010",
+        severity: "warning",
+        message: `Data transformation .${methodName}() inside Composite factory — transform data before passing it as props`,
+      });
+    }
+  }
+
+  ts.forEachChild(node, (child) => checkNode(child, context, diagnostics));
+}
+
+export const evl010CompositeNoTransformRule: LintRule = {
+  id: "EVL010",
+  severity: "warning",
+  category: "style",
+  check(context: LintContext): LintDiagnostic[] {
+    const diagnostics: LintDiagnostic[] = [];
+    checkNode(context.sourceFile, context, diagnostics);
+    return diagnostics;
+  },
+};

package/src/lint/rules/export-required.test.ts

@@ -0,0 +1,213 @@
+import { describe, test, expect } from "bun:test";
+import * as ts from "typescript";
+import { exportRequiredRule } from "./export-required";
+import type { LintContext } from "../rule";
+
+function createContext(code: string, filePath = "test.ts"): LintContext {
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    code,
+    ts.ScriptTarget.Latest,
+    true
+  );
+
+  return {
+    sourceFile,
+    entities: [],
+    filePath,
+    lexicon: undefined,
+  };
+}
+
+describe("COR008: export-required", () => {
+  test("rule metadata", () => {
+    expect(exportRequiredRule.id).toBe("COR008");
+    expect(exportRequiredRule.severity).toBe("warning");
+    expect(exportRequiredRule.category).toBe("correctness");
+  });
+
+  test("does not trigger when declarable is assigned to exported variable", () => {
+    const code = `
+      class Bucket implements Declarable {
+        readonly [Symbol.for("chant.declarable")] = true;
+        readonly entityType = "Bucket";
+      }
+      export const bucket = new Bucket();
+    `;
+    const context = createContext(code);
+    const diagnostics = exportRequiredRule.check(context);
+    expect(diagnostics).toHaveLength(0);
+  });
+
+  test("triggers when declarable is created without export", () => {
+    const code = `
+      class Bucket implements Declarable {
+        readonly [Symbol.for("chant.declarable")] = true;
+        readonly entityType = "Bucket";
+      }
+      new Bucket();
+    `;
+    const context = createContext(code);
+    const diagnostics = exportRequiredRule.check(context);
+
+    expect(diagnostics).toHaveLength(1);
+    expect(diagnostics[0].ruleId).toBe("COR008");
+    expect(diagnostics[0].severity).toBe("warning");
+    expect(diagnostics[0].message).toContain("Bucket");
+    expect(diagnostics[0].message).toContain("is not exported");
+    expect(diagnostics[0].message).toContain("chant can discover it during synthesis");
+  });
+
+  test("triggers when declarable is assigned to non-exported variable", () => {
+    const code = `
+      class Bucket implements Declarable {
+        readonly [Symbol.for("chant.declarable")] = true;
+        readonly entityType = "Bucket";
+      }
+      const bucket = new Bucket();
+    `;
+    const context = createContext(code);
+    const diagnostics = exportRequiredRule.check(context);
+
+    expect(diagnostics).toHaveLength(1);
+    expect(diagnostics[0].message).toContain("'bucket' (Bucket)");
+  });
+
+  test("does not trigger on non-declarable class instantiations", () => {
+    const code = `
+      class RegularClass {
+        value: number;
+        constructor(val: number) {
+          this.value = val;
+        }
+      }
+      new RegularClass(42);
+    `;
+    const context = createContext(code);
+    const diagnostics = exportRequiredRule.check(context);
+    expect(diagnostics).toHaveLength(0);
+  });
+
+  test("does not trigger on exported non-declarable class", () => {
+    const code = `
+      class RegularClass {}
+      export const obj = new RegularClass();
+    `;
+    const context = createContext(code);
+    const diagnostics = exportRequiredRule.check(context);
+    expect(diagnostics).toHaveLength(0);
+  });
+
+  test("handles multiple declarable instances", () => {
+    const code = `
+      class Bucket implements Declarable {
+        readonly [Symbol.for("chant.declarable")] = true;
+        readonly entityType = "Bucket";
+      }
+      new Bucket();
+      new Bucket();
+    `;
+    const context = createContext(code);
+    const diagnostics = exportRequiredRule.check(context);
+
+    expect(diagnostics).toHaveLength(2);
+    expect(diagnostics[0].ruleId).toBe("COR008");
+    expect(diagnostics[1].ruleId).toBe("COR008");
+  });
+
+  test("handles mixed exported and non-exported declarables", () => {
+    const code = `
+      class Bucket implements Declarable {
+        readonly [Symbol.for("chant.declarable")] = true;
+        readonly entityType = "Bucket";
+      }
+      export const bucket1 = new Bucket();
+      new Bucket();
+      export const bucket2 = new Bucket();
+    `;
+    const context = createContext(code);
+    const diagnostics = exportRequiredRule.check(context);
+
+    expect(diagnostics).toHaveLength(1);
+  });
+
+  test("reports correct line and column numbers", () => {
+    const code = `
+      class Bucket implements Declarable {
+        readonly [Symbol.for("chant.declarable")] = true;
+        readonly entityType = "Bucket";
+      }
+      new Bucket();
+    `;
+    const context = createContext(code);
+    const diagnostics = exportRequiredRule.check(context);
+
+    expect(diagnostics).toHaveLength(1);
+    expect(diagnostics[0].line).toBe(6);
+    expect(diagnostics[0].column).toBeGreaterThan(0);
+    expect(diagnostics[0].file).toBe("test.ts");
+  });
+
+  test("handles declarable with constructor arguments", () => {
+    const code = `
+      class Parameter implements Declarable {
+        readonly [Symbol.for("chant.declarable")] = true;
+        readonly entityType = "Parameter";
+        constructor(name: string, value: string) {}
+      }
+      new Parameter("key", "value");
+    `;
+    const context = createContext(code);
+    const diagnostics = exportRequiredRule.check(context);
+
+    expect(diagnostics).toHaveLength(1);
+    expect(diagnostics[0].message).toContain("'Parameter'");
+    expect(diagnostics[0].message).toContain("is not exported");
+  });
+
+  test("allows exported variable with declarable", () => {
+    const code = `
+      class Bucket implements Declarable {
+        readonly [Symbol.for("chant.declarable")] = true;
+        readonly entityType = "Bucket";
+      }
+      export const myBucket = new Bucket();
+    `;
+    const context = createContext(code);
+    const diagnostics = exportRequiredRule.check(context);
+    expect(diagnostics).toHaveLength(0);
+  });
+
+  test("handles nested new expressions", () => {
+    const code = `
+      class Bucket implements Declarable {
+        readonly [Symbol.for("chant.declarable")] = true;
+        readonly entityType = "Bucket";
+      }
+      class Wrapper {
+        constructor(bucket: Bucket) {}
+      }
+      new Wrapper(new Bucket());
+    `;
+    const context = createContext(code);
+    const diagnostics = exportRequiredRule.check(context);
+
+    // Inner new Bucket() should trigger
+    expect(diagnostics.length).toBeGreaterThanOrEqual(1);
+    const bucketDiagnostic = diagnostics.find(d => d.message.includes("Bucket"));
+    expect(bucketDiagnostic).toBeDefined();
+  });
+
+  test("handles export statement with multiple declarations", () => {
+    const code = `
+      class Bucket implements Declarable {
+        readonly [Symbol.for("chant.declarable")] = true;
+        readonly entityType = "Bucket";
+      }
+      export const bucket1 = new Bucket(), bucket2 = new Bucket();
+    `;
+    const context = createContext(code);
+    const diagnostics = exportRequiredRule.check(context);
+    expect(diagnostics).toHaveLength(0);
+  });
+});