@akanjs/devkit 2.3.9-rc.0 → 2.3.9-rc.10

package/workflow/moduleIndex.test.ts

@@ -0,0 +1,296 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import type { AkanModuleContext } from "../akanContext";
+import type { Workspace } from "../commandDecorators";
+import { buildAkanModuleContextIndex } from "./moduleIndex";
+
+const tempRoots: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+const makeWorkspace = async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "akan-module-index-"));
+  tempRoots.push(root);
+  return {
+    root,
+    workspace: { workspaceRoot: root } as Workspace,
+  };
+};
+
+const writeText = async (filePath: string, content: string) => {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, content);
+};
+
+const moduleContext = (files: string[], name = "post"): AkanModuleContext => ({
+  kind: "domain",
+  name,
+  folderName: name,
+  sysName: "demo",
+  sysType: "app",
+  path: `apps/demo/lib/${name}`,
+  abstract: { path: `apps/demo/lib/${name}/${name}.abstract.md`, exists: true, headings: [] },
+  files,
+});
+
+describe("buildAkanModuleContextIndex", () => {
+  test("indexes constant, dictionary model, projection, spans, and partial presence without source bodies", async () => {
+    const { root, workspace } = await makeWorkspace();
+    const modulePath = path.join(root, "apps/demo/lib/post");
+    await writeText(
+      path.join(modulePath, "post.constant.ts"),
+      `
+import { Int } from "akanjs/base";
+import { via } from "akanjs/constant";
+
+export class PostInput extends via((_field) => ({
+  title: _field(String),
+  count: _field(Int, { default: 0 }),
+  metadata: _field({ nested: ["secret"] }),
+})) {}
+
+export class PostObject extends via(PostInput, (field) => ({})) {}
+export class LightPost extends via(PostObject, ["title"] as const, (resolve) => ({})) {}
+export class Post extends via(PostObject, LightPost, (resolve) => ({})) {}
+`,
+    );
+    await writeText(
+      path.join(modulePath, "post.dictionary.ts"),
+      `
+import { modelDictionary } from "akanjs/dictionary";
+import type { Post } from "./post.constant";
+
+export const dictionary = modelDictionary(["en", "ko"])
+  .model<Post>((t) => ({
+    title: t(["Title", "제목"]),
+  }))
+  .slice<PostSlice>((fn) => ({
+    inPublic: fn(["Post In Public", "Post 공개"]).arg((t) => ({
+      ignored: t(["Ignored", "Ignored"]),
+    })),
+  }))
+  .translate({});
+`,
+    );
+
+    const index = await buildAkanModuleContextIndex(
+      workspace,
+      moduleContext(["post.abstract.md", "post.constant.ts", "post.dictionary.ts"]),
+      { field: "count" },
+    );
+
+    expect(index).toMatchObject({
+      schemaVersion: 1,
+      app: "demo",
+      module: "post",
+      moduleClassName: "Post",
+      constant: { inputClassName: "PostInput", builderName: "_field" },
+      dictionary: { modelClassName: "Post", translatorName: "t" },
+    });
+    expect(index.constant?.fields.map((field) => [field.name, field.order, field.typeSummary])).toEqual([
+      ["title", 0, "_field(String)"],
+      ["count", 1, "_field(Int)"],
+      ["metadata", 2, "_field(object-literal)"],
+    ]);
+    expect(index.dictionary?.fields.map((field) => field.name)).toEqual(["title"]);
+    expect(index.dictionary?.fields.map((field) => field.name)).not.toContain("ignored");
+    expect(index.constant?.lightProjection?.fields.map((field) => field.name)).toEqual(["title"]);
+    expect(index.constant?.fields[0]?.sourceSpan).toMatchObject({
+      file: "apps/demo/lib/post/post.constant.ts",
+      startLine: expect.any(Number),
+      endLine: expect.any(Number),
+      startOffset: expect.any(Number),
+      endOffset: expect.any(Number),
+    });
+    expect(index.fieldPresence.find((field) => field.name === "count")).toMatchObject({
+      requested: true,
+      constant: true,
+      dictionary: false,
+      lightProjection: false,
+    });
+    expect(index.diagnostics.map((diagnostic) => diagnostic.code)).toContain("module-index-field-presence-partial");
+    expect(JSON.stringify(index)).not.toContain("export class");
+    expect(JSON.stringify(index)).not.toContain("modelDictionary");
+    expect(JSON.stringify(index)).not.toContain("secret");
+    expect(JSON.stringify(index)).not.toContain("제목");
+  });
+
+  test("reports missing and casing mismatch diagnostics with expected and actual paths", async () => {
+    const { root, workspace } = await makeWorkspace();
+    const modulePath = path.join(root, "apps/demo/lib/post");
+    await writeText(path.join(modulePath, "Post.Constant.ts"), "export class PostInput {}\n");
+
+    const index = await buildAkanModuleContextIndex(workspace, moduleContext(["Post.Constant.ts"]));
+
+    expect(index.files.find((file) => file.kind === "constant")).toMatchObject({
+      path: "apps/demo/lib/post/Post.Constant.ts",
+      expectedPath: "apps/demo/lib/post/post.constant.ts",
+      casing: "mismatch",
+      present: true,
+    });
+    expect(index.files.find((file) => file.kind === "dictionary")).toMatchObject({
+      expectedPath: "apps/demo/lib/post/post.dictionary.ts",
+      casing: "missing",
+      present: false,
+    });
+    expect(index.diagnostics.map((diagnostic) => diagnostic.code)).toContain("module-index-file-casing-mismatch");
+    expect(index.diagnostics.map((diagnostic) => diagnostic.code)).toContain("module-index-file-missing");
+    expect(index.diagnostics.flatMap((diagnostic) => diagnostic.context?.paths ?? [])).not.toContain(
+      "apps/demo/lib/post/Post.Template.tsx",
+    );
+    expect(index.diagnostics.flatMap((diagnostic) => diagnostic.context?.paths ?? [])).not.toContain(
+      "apps/demo/lib/post/post.service.ts",
+    );
+  });
+
+  test("indexes field builder callbacks, dictionary block returns, and pascal module names", async () => {
+    const { root, workspace } = await makeWorkspace();
+    const modulePath = path.join(root, "apps/demo/lib/blog-post");
+    await writeText(
+      path.join(modulePath, "blog-post.constant.ts"),
+      `
+import { via } from "akanjs/constant";
+
+export class BlogPostInput extends via((field) => ({
+  title: field(String),
+})) {}
+
+export class BlogPostObject extends via(BlogPostInput, (field) => ({})) {}
+export class LightBlogPost extends via(BlogPostObject, ["title"] as const, (resolve) => ({})) {}
+export class BlogPost extends via(BlogPostObject, LightBlogPost, (resolve) => ({})) {}
+`,
+    );
+    await writeText(
+      path.join(modulePath, "blog-post.dictionary.ts"),
+      `
+import { modelDictionary } from "akanjs/dictionary";
+import type { BlogPost } from "./blog-post.constant";
+
+export const dictionary = modelDictionary(["en"]).model<BlogPost>((t) => {
+  return {
+    title: t(["Title"]),
+  };
+});
+`,
+    );
+
+    const index = await buildAkanModuleContextIndex(
+      workspace,
+      moduleContext(["blog-post.abstract.md", "blog-post.constant.ts", "blog-post.dictionary.ts"], "blog-post"),
+      { field: "title" },
+    );
+
+    expect(index.moduleClassName).toBe("BlogPost");
+    expect(index.constant).toMatchObject({ inputClassName: "BlogPostInput", builderName: "field" });
+    expect(index.constant?.fields.map((field) => [field.name, field.typeSummary])).toEqual([
+      ["title", "field(String)"],
+    ]);
+    expect(index.dictionary).toMatchObject({ modelClassName: "BlogPost", translatorName: "t" });
+    expect(index.dictionary?.fields.map((field) => field.name)).toEqual(["title"]);
+    expect(index.constant?.lightProjection?.fields.map((field) => field.name)).toEqual(["title"]);
+    expect(index.diagnostics.map((diagnostic) => diagnostic.code)).not.toContain(
+      "module-index-dictionary-model-missing",
+    );
+    expect(JSON.stringify(index)).not.toContain("return {");
+  });
+
+  test("reports parse and unsupported constant shape diagnostics", async () => {
+    const validDictionary = `
+import { modelDictionary } from "akanjs/dictionary";
+import type { Post } from "./post.constant";
+
+export const dictionary = modelDictionary(["en"]).model<Post>((t) => ({}));
+`;
+    const cases = [
+      {
+        name: "invalid-typescript",
+        constant: "export class PostInput extends via((field) => ({ title: field(String), })) {\n",
+        expectedCode: "module-index-typescript-parse-error",
+      },
+      {
+        name: "missing-input",
+        constant: "export class Post extends via(() => ({})) {}\n",
+        expectedCode: "module-index-constant-input-missing",
+      },
+      {
+        name: "missing-via",
+        constant: "export class PostInput {}\n",
+        expectedCode: "module-index-constant-via-missing",
+      },
+      {
+        name: "malformed-via",
+        constant: "export class PostInput extends via(PostObject) {}\n",
+        expectedCode: "module-index-constant-builder-missing",
+      },
+      {
+        name: "missing-builder-object",
+        constant: "export class PostInput extends via((field) => field(String)) {}\n",
+        expectedCode: "module-index-constant-builder-object-missing",
+      },
+    ];
+
+    for (const item of cases) {
+      const { root, workspace } = await makeWorkspace();
+      const modulePath = path.join(root, "apps/demo/lib/post");
+      await writeText(path.join(modulePath, "post.constant.ts"), item.constant);
+      await writeText(path.join(modulePath, "post.dictionary.ts"), validDictionary);
+
+      const index = await buildAkanModuleContextIndex(
+        workspace,
+        moduleContext(["post.abstract.md", "post.constant.ts", "post.dictionary.ts"]),
+      );
+
+      expect(
+        index.diagnostics.map((diagnostic) => diagnostic.code),
+        item.name,
+      ).toContain(item.expectedCode);
+      expect(JSON.stringify(index), item.name).not.toContain(item.constant.trim());
+    }
+  });
+
+  test("reports unsupported dictionary model callback shapes", async () => {
+    const validConstant = `
+import { via } from "akanjs/constant";
+
+export class PostInput extends via((field) => ({})) {}
+`;
+    const cases = [
+      {
+        name: "missing-callback",
+        dictionary: 'export const dictionary = modelDictionary(["en"]).model<Post>();\n',
+        expectedCode: "module-index-dictionary-builder-missing",
+      },
+      {
+        name: "missing-object-return",
+        dictionary: 'export const dictionary = modelDictionary(["en"]).model<Post>((t) => t(["Title"]));\n',
+        expectedCode: "module-index-dictionary-builder-object-missing",
+      },
+    ];
+
+    for (const item of cases) {
+      const { root, workspace } = await makeWorkspace();
+      const modulePath = path.join(root, "apps/demo/lib/post");
+      await writeText(path.join(modulePath, "post.constant.ts"), validConstant);
+      await writeText(path.join(modulePath, "post.dictionary.ts"), item.dictionary);
+
+      const index = await buildAkanModuleContextIndex(
+        workspace,
+        moduleContext(["post.abstract.md", "post.constant.ts", "post.dictionary.ts"]),
+      );
+
+      expect(
+        index.diagnostics.map((diagnostic) => diagnostic.code),
+        item.name,
+      ).toContain(item.expectedCode);
+      expect(
+        index.diagnostics.map((diagnostic) => diagnostic.code),
+        item.name,
+      ).not.toContain("module-index-dictionary-model-missing");
+      expect(JSON.stringify(index), item.name).not.toContain(item.dictionary.trim());
+    }
+  });
+});