@intentius/chant 0.0.1

package/src/lint/rules/evl007-invalid-siblings.ts

@@ -0,0 +1,139 @@
+import * as ts from "typescript";
+import type { LintRule, LintContext, LintDiagnostic } from "../rule";
+
+/**
+ * EVL007: Invalid Siblings Access
+ *
+ * In a Composite factory, resource() callbacks receive a `siblings` parameter.
+ * Accessing siblings.key must reference a key that exists in the composite's
+ * resource map.
+ */
+
+function checkNode(node: ts.Node, context: LintContext, diagnostics: LintDiagnostic[]): void {
+  // Look for Composite(...) calls
+  if (
+    ts.isCallExpression(node) &&
+    ts.isIdentifier(node.expression) &&
+    node.expression.text === "Composite"
+  ) {
+    // The factory function is the argument to Composite
+    const factoryArg = node.arguments[0];
+    if (factoryArg && (ts.isArrowFunction(factoryArg) || ts.isFunctionExpression(factoryArg))) {
+      checkCompositeFactory(factoryArg, context, diagnostics);
+    }
+  }
+
+  ts.forEachChild(node, (child) => checkNode(child, context, diagnostics));
+}
+
+function checkCompositeFactory(
+  factory: ts.ArrowFunction | ts.FunctionExpression,
+  context: LintContext,
+  diagnostics: LintDiagnostic[],
+): void {
+  // The factory body should contain an object literal with resource() calls
+  // that define the composite members. Collect the keys.
+  const body = factory.body;
+  let memberKeys: Set<string> | null = null;
+
+  if (ts.isBlock(body)) {
+    // Look for return statement with object literal
+    for (const stmt of body.statements) {
+      if (ts.isReturnStatement(stmt) && stmt.expression && ts.isObjectLiteralExpression(stmt.expression)) {
+        memberKeys = collectObjectKeys(stmt.expression);
+      }
+    }
+  } else if (ts.isParenthesizedExpression(body) && ts.isObjectLiteralExpression(body.expression)) {
+    memberKeys = collectObjectKeys(body.expression);
+  } else if (ts.isObjectLiteralExpression(body)) {
+    memberKeys = collectObjectKeys(body);
+  }
+
+  if (!memberKeys || memberKeys.size === 0) return;
+
+  // Now find resource() calls within the factory and check siblings access
+  walkForResourceCalls(body, memberKeys, context, diagnostics);
+}
+
+function collectObjectKeys(obj: ts.ObjectLiteralExpression): Set<string> {
+  const keys = new Set<string>();
+  for (const prop of obj.properties) {
+    if (ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop)) {
+      if (ts.isIdentifier(prop.name!)) {
+        keys.add(prop.name!.text);
+      } else if (ts.isStringLiteral(prop.name!)) {
+        keys.add(prop.name!.text);
+      }
+    }
+  }
+  return keys;
+}
+
+function walkForResourceCalls(
+  node: ts.Node,
+  memberKeys: Set<string>,
+  context: LintContext,
+  diagnostics: LintDiagnostic[],
+): void {
+  if (
+    ts.isCallExpression(node) &&
+    ts.isIdentifier(node.expression) &&
+    node.expression.text === "resource"
+  ) {
+    // resource(Type, (props, siblings) => ...)
+    const callback = node.arguments[1];
+    if (callback && (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback))) {
+      const siblingsParam = callback.parameters[1];
+      if (siblingsParam && ts.isIdentifier(siblingsParam.name)) {
+        const siblingsName = siblingsParam.name.text;
+        checkSiblingsAccess(callback.body, siblingsName, memberKeys, context, diagnostics);
+      }
+    }
+  }
+
+  ts.forEachChild(node, (child) =>
+    walkForResourceCalls(child, memberKeys, context, diagnostics),
+  );
+}
+
+function checkSiblingsAccess(
+  node: ts.Node,
+  siblingsName: string,
+  memberKeys: Set<string>,
+  context: LintContext,
+  diagnostics: LintDiagnostic[],
+): void {
+  if (ts.isPropertyAccessExpression(node)) {
+    if (ts.isIdentifier(node.expression) && node.expression.text === siblingsName) {
+      const accessedKey = node.name.text;
+      if (!memberKeys.has(accessedKey)) {
+        const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
+          node.getStart(context.sourceFile),
+        );
+        diagnostics.push({
+          file: context.filePath,
+          line: line + 1,
+          column: character + 1,
+          ruleId: "EVL007",
+          severity: "error",
+          message: `Invalid siblings access — "${accessedKey}" is not a member of this composite`,
+        });
+      }
+    }
+  }
+
+  ts.forEachChild(node, (child) =>
+    checkSiblingsAccess(child, siblingsName, memberKeys, context, diagnostics),
+  );
+}
+
+export const evl007InvalidSiblingsRule: LintRule = {
+  id: "EVL007",
+  severity: "error",
+  category: "correctness",
+  check(context: LintContext): LintDiagnostic[] {
+    const diagnostics: LintDiagnostic[] = [];
+    checkNode(context.sourceFile, context, diagnostics);
+    return diagnostics;
+  },
+};

package/src/lint/rules/evl008-unresolvable-barrel-ref.test.ts

@@ -0,0 +1,118 @@
+import { describe, test, expect } from "bun:test";
+import * as ts from "typescript";
+import { evl008UnresolvableBarrelRefRule } from "./evl008-unresolvable-barrel-ref";
+import type { LintContext } from "../rule";
+
+function createContext(
+  code: string,
+  barrelExports?: Set<string>,
+  filePath = "test.ts",
+): LintContext {
+  const sourceFile = ts.createSourceFile(filePath, code, ts.ScriptTarget.Latest, true);
+  return { sourceFile, entities: [], filePath, lexicon: undefined, barrelExports };
+}
+
+describe("EVL008: unresolvable-barrel-ref", () => {
+  test("rule metadata", () => {
+    expect(evl008UnresolvableBarrelRefRule.id).toBe("EVL008");
+    expect(evl008UnresolvableBarrelRefRule.severity).toBe("error");
+    expect(evl008UnresolvableBarrelRefRule.category).toBe("correctness");
+  });
+
+  test("skips when no barrelExports provided", () => {
+    const ctx = createContext(`
+      export const $ = barrel(import.meta.dir);
+      const x = $.myBucket;
+    `);
+    expect(evl008UnresolvableBarrelRefRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("allows valid direct barrel reference", () => {
+    const exports = new Set(["myBucket", "myRole"]);
+    const ctx = createContext(
+      `
+      export const $ = barrel(import.meta.dir);
+      const x = $.myBucket;
+    `,
+      exports,
+    );
+    expect(evl008UnresolvableBarrelRefRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("flags invalid direct barrel reference", () => {
+    const exports = new Set(["myBucket", "myRole"]);
+    const ctx = createContext(
+      `
+      export const $ = barrel(import.meta.dir);
+      const x = $.nonExistent;
+    `,
+      exports,
+    );
+    const diags = evl008UnresolvableBarrelRefRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].ruleId).toBe("EVL008");
+    expect(diags[0].message).toContain("nonExistent");
+    expect(diags[0].message).toContain("not exported");
+  });
+
+  test("allows valid namespace barrel reference", () => {
+    const exports = new Set(["myBucket"]);
+    const ctx = createContext(
+      `
+      import * as _ from "./_";
+      const x = _.$.myBucket;
+    `,
+      exports,
+    );
+    expect(evl008UnresolvableBarrelRefRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("flags invalid namespace barrel reference", () => {
+    const exports = new Set(["myBucket"]);
+    const ctx = createContext(
+      `
+      import * as _ from "./_";
+      const x = _.$.missing;
+    `,
+      exports,
+    );
+    const diags = evl008UnresolvableBarrelRefRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].message).toContain("missing");
+  });
+
+  test("does not flag when no barrel usage in file", () => {
+    const exports = new Set(["myBucket"]);
+    const ctx = createContext(`const x = someObj.prop;`, exports);
+    expect(evl008UnresolvableBarrelRefRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("flags multiple invalid references", () => {
+    const exports = new Set(["myBucket"]);
+    const ctx = createContext(
+      `
+      export const $ = barrel(import.meta.dir);
+      const a = $.missing1;
+      const b = $.missing2;
+    `,
+      exports,
+    );
+    expect(evl008UnresolvableBarrelRefRule.check(ctx)).toHaveLength(2);
+  });
+
+  test("handles mixed valid and invalid", () => {
+    const exports = new Set(["bucket", "role"]);
+    const ctx = createContext(
+      `
+      export const $ = barrel(import.meta.dir);
+      const a = $.bucket;
+      const b = $.missing;
+      const c = $.role;
+    `,
+      exports,
+    );
+    const diags = evl008UnresolvableBarrelRefRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].message).toContain("missing");
+  });
+});

package/src/lint/rules/evl008-unresolvable-barrel-ref.ts

@@ -0,0 +1,140 @@
+import * as ts from "typescript";
+import type { LintRule, LintContext, LintDiagnostic } from "../rule";
+
+/**
+ * EVL008: Unresolvable Barrel Reference
+ *
+ * When accessing the barrel variable (e.g., $.resourceName), the
+ * referenced name must exist in the project's barrel exports.
+ * Requires barrelExports on LintContext.
+ */
+
+/**
+ * Find the barrel variable name in a source file.
+ *
+ * Patterns:
+ * - `export const $ = barrel(...)` → "$"
+ * - `import * as _ from "./_"` then `_.$` → "$" accessed via "_"
+ */
+function findBarrelVarName(sourceFile: ts.SourceFile): string | null {
+  for (const stmt of sourceFile.statements) {
+    // export const $ = barrel(...)
+    if (
+      ts.isVariableStatement(stmt) &&
+      stmt.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)
+    ) {
+      for (const decl of stmt.declarationList.declarations) {
+        if (
+          ts.isIdentifier(decl.name) &&
+          decl.name.text === "$" &&
+          decl.initializer &&
+          ts.isCallExpression(decl.initializer) &&
+          ts.isIdentifier(decl.initializer.expression) &&
+          decl.initializer.expression.text === "barrel"
+        ) {
+          return "$";
+        }
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Find namespace imports that re-export the barrel.
+ * e.g., `import * as _ from "./_"` — then _.$ accesses the barrel.
+ */
+function findBarrelNamespaceImports(sourceFile: ts.SourceFile): string[] {
+  const names: string[] = [];
+  for (const stmt of sourceFile.statements) {
+    if (
+      ts.isImportDeclaration(stmt) &&
+      stmt.importClause?.namedBindings &&
+      ts.isNamespaceImport(stmt.importClause.namedBindings) &&
+      stmt.moduleSpecifier &&
+      ts.isStringLiteral(stmt.moduleSpecifier)
+    ) {
+      const spec = stmt.moduleSpecifier.text;
+      // Convention: barrel files are "_" or "./_"
+      if (spec === "./_" || spec === "_") {
+        names.push(stmt.importClause.namedBindings.name.text);
+      }
+    }
+  }
+  return names;
+}
+
+function checkNode(
+  node: ts.Node,
+  context: LintContext,
+  diagnostics: LintDiagnostic[],
+  barrelVar: string | null,
+  namespaceImports: string[],
+): void {
+  if (ts.isPropertyAccessExpression(node)) {
+    const accessedName = node.name.text;
+
+    // Direct barrel access: $.resourceName
+    if (barrelVar && ts.isIdentifier(node.expression) && node.expression.text === barrelVar) {
+      if (context.barrelExports && !context.barrelExports.has(accessedName)) {
+        const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
+          node.getStart(context.sourceFile),
+        );
+        diagnostics.push({
+          file: context.filePath,
+          line: line + 1,
+          column: character + 1,
+          ruleId: "EVL008",
+          severity: "error",
+          message: `Unresolvable barrel reference — "${accessedName}" is not exported from the barrel`,
+        });
+      }
+    }
+
+    // Namespace access: _.$.resourceName
+    if (
+      ts.isPropertyAccessExpression(node.expression) &&
+      ts.isIdentifier(node.expression.expression) &&
+      namespaceImports.includes(node.expression.expression.text) &&
+      node.expression.name.text === "$"
+    ) {
+      if (context.barrelExports && !context.barrelExports.has(accessedName)) {
+        const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
+          node.getStart(context.sourceFile),
+        );
+        diagnostics.push({
+          file: context.filePath,
+          line: line + 1,
+          column: character + 1,
+          ruleId: "EVL008",
+          severity: "error",
+          message: `Unresolvable barrel reference — "${accessedName}" is not exported from the barrel`,
+        });
+      }
+    }
+  }
+
+  ts.forEachChild(node, (child) =>
+    checkNode(child, context, diagnostics, barrelVar, namespaceImports),
+  );
+}
+
+export const evl008UnresolvableBarrelRefRule: LintRule = {
+  id: "EVL008",
+  severity: "error",
+  category: "correctness",
+  check(context: LintContext): LintDiagnostic[] {
+    // Skip if no barrel exports data is available
+    if (!context.barrelExports) return [];
+
+    const barrelVar = findBarrelVarName(context.sourceFile);
+    const namespaceImports = findBarrelNamespaceImports(context.sourceFile);
+
+    // If this file doesn't use the barrel, nothing to check
+    if (!barrelVar && namespaceImports.length === 0) return [];
+
+    const diagnostics: LintDiagnostic[] = [];
+    checkNode(context.sourceFile, context, diagnostics, barrelVar, namespaceImports);
+    return diagnostics;
+  },
+};

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

@@ -0,0 +1,162 @@
+import { describe, test, expect } from "bun:test";
+import * as ts from "typescript";
+import { evl009CompositeNoConstantRule } from "./evl009-composite-no-constant";
+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("EVL009: composite-no-constant", () => {
+  test("rule metadata", () => {
+    expect(evl009CompositeNoConstantRule.id).toBe("EVL009");
+    expect(evl009CompositeNoConstantRule.severity).toBe("warning");
+    expect(evl009CompositeNoConstantRule.category).toBe("style");
+  });
+
+  test("flags inline object literal that doesn't reference props", () => {
+    const ctx = createContext(`
+      const MyComp = Composite((props) => {
+        const role = new Role({
+          assumeRolePolicyDocument: {
+            Version: "2012-10-17",
+            Statement: [{ Effect: "Allow", Principal: { Service: "lambda.amazonaws.com" }, Action: "sts:AssumeRole" }],
+          },
+        });
+        return { role };
+      }, "MyComp");
+    `);
+    const diags = evl009CompositeNoConstantRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].ruleId).toBe("EVL009");
+    expect(diags[0].message).toContain("assumeRolePolicyDocument");
+    expect(diags[0].message).toContain("_.$.name");
+  });
+
+  test("flags inline array with objects that doesn't reference props", () => {
+    const ctx = createContext(`
+      const MyComp = Composite((props) => {
+        const role = new Role({
+          managedPolicyArns: ["arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole", "arn:aws:iam::aws:policy/AmazonS3ReadOnly"],
+        });
+        return { role };
+      }, "MyComp");
+    `);
+    // Array of simple strings — NOT flagged (no objects inside)
+    expect(evl009CompositeNoConstantRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("flags array containing objects", () => {
+    const ctx = createContext(`
+      const MyComp = Composite((props) => {
+        const role = new Role({
+          policies: [{ policyName: "S3Access", policyDocument: { Version: "2012-10-17" } }],
+        });
+        return { role };
+      }, "MyComp");
+    `);
+    const diags = evl009CompositeNoConstantRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].message).toContain("policies");
+  });
+
+  test("allows barrel refs (_.$.name)", () => {
+    const ctx = createContext(`
+      const MyComp = _.Composite((props) => {
+        const role = new Role({
+          assumeRolePolicyDocument: _.$.lambdaTrustPolicy,
+        });
+        return { role };
+      }, "MyComp");
+    `);
+    expect(evl009CompositeNoConstantRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("allows props references", () => {
+    const ctx = createContext(`
+      const MyComp = Composite((props) => {
+        const role = new Role({
+          policies: props.policies,
+        });
+        return { role };
+      }, "MyComp");
+    `);
+    expect(evl009CompositeNoConstantRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("allows object containing props reference", () => {
+    const ctx = createContext(`
+      const MyComp = Composite((props) => {
+        const func = new Function({
+          environment: { variables: { NAME: props.name } },
+        });
+        return { func };
+      }, "MyComp");
+    `);
+    expect(evl009CompositeNoConstantRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("allows sibling member reference", () => {
+    const ctx = createContext(`
+      const MyComp = Composite((props) => {
+        const role = new Role({ assumeRolePolicyDocument: _.$.trustPolicy });
+        const func = new Function({
+          config: { roleArn: role.arn },
+        });
+        return { role, func };
+      }, "MyComp");
+    `);
+    expect(evl009CompositeNoConstantRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("allows simple string literals (not extractable)", () => {
+    const ctx = createContext(`
+      const MyComp = Composite((props) => {
+        const perm = new Permission({
+          action: "lambda:InvokeFunction",
+          principal: "apigateway.amazonaws.com",
+        });
+        return { perm };
+      }, "MyComp");
+    `);
+    expect(evl009CompositeNoConstantRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("does not flag outside Composite", () => {
+    const ctx = createContext(`
+      const role = new Role({
+        assumeRolePolicyDocument: { Version: "2012-10-17" },
+      });
+    `);
+    expect(evl009CompositeNoConstantRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("flags multiple extractable constants", () => {
+    const ctx = createContext(`
+      const MyComp = Composite((props) => {
+        const role = new Role({
+          trustPolicy: { Version: "2012-10-17", Statement: [] },
+          config: { retryAttempts: 3, timeout: 30 },
+        });
+        return { role };
+      }, "MyComp");
+    `);
+    const diags = evl009CompositeNoConstantRule.check(ctx);
+    expect(diags).toHaveLength(2);
+  });
+
+  test("allows array wrapping barrel ref", () => {
+    const ctx = createContext(`
+      const MyComp = Composite((props) => {
+        const role = new Role({
+          managedPolicyArns: [_.$.lambdaBasicExecutionArn],
+        });
+        return { role };
+      }, "MyComp");
+    `);
+    // Array with barrel ref inside — not flagged (contains barrel ref)
+    // Also it's an array of identifiers, no objects inside
+    expect(evl009CompositeNoConstantRule.check(ctx)).toHaveLength(0);
+  });
+});