@mandujs/core 0.8.2 → 0.9.0

package/src/generator/contract-glue.test.ts

@@ -0,0 +1,211 @@
+/**
+ * Contract Glue Generator Tests
+ */
+
+import { describe, test, expect } from "bun:test";
+import {
+  generateContractTypeGlue,
+  generateContractTemplate,
+  generateContractTypesIndex,
+} from "./contract-glue";
+import type { RouteSpec } from "../spec/schema";
+
+describe("generateContractTypeGlue", () => {
+  test("should generate type glue for route with contract", () => {
+    const route: RouteSpec = {
+      id: "users",
+      pattern: "/api/users",
+      kind: "api",
+      module: "generated/routes/api/users.ts",
+      contractModule: "spec/contracts/users.contract.ts",
+      slotModule: "spec/slots/users.slot.ts",
+    };
+
+    const result = generateContractTypeGlue(route);
+
+    expect(result).toContain("// Generated by Mandu");
+    expect(result).toContain("import type { InferContract");
+    expect(result).toContain("export type UsersContract");
+    expect(result).toContain("export type UsersGetQuery");
+    expect(result).toContain("export type UsersPostBody");
+    expect(result).toContain("export type UsersResponse200");
+    expect(result).toContain("export { contract }");
+  });
+
+  test("should return empty string for route without contract", () => {
+    const route: RouteSpec = {
+      id: "users",
+      pattern: "/api/users",
+      kind: "api",
+      module: "generated/routes/api/users.ts",
+      slotModule: "spec/slots/users.slot.ts",
+    };
+
+    const result = generateContractTypeGlue(route);
+
+    expect(result).toBe("");
+  });
+
+  test("should convert kebab-case to PascalCase", () => {
+    const route: RouteSpec = {
+      id: "user-profiles",
+      pattern: "/api/user-profiles",
+      kind: "api",
+      module: "generated/routes/api/user-profiles.ts",
+      contractModule: "spec/contracts/user-profiles.contract.ts",
+    };
+
+    const result = generateContractTypeGlue(route);
+
+    expect(result).toContain("export type UserProfilesContract");
+    expect(result).toContain("export type UserProfilesGetQuery");
+  });
+
+  test("should convert snake_case to PascalCase", () => {
+    const route: RouteSpec = {
+      id: "user_settings",
+      pattern: "/api/user_settings",
+      kind: "api",
+      module: "generated/routes/api/user_settings.ts",
+      contractModule: "spec/contracts/user_settings.contract.ts",
+    };
+
+    const result = generateContractTypeGlue(route);
+
+    expect(result).toContain("export type UserSettingsContract");
+  });
+});
+
+describe("generateContractTemplate", () => {
+  test("should generate template with GET method", () => {
+    const route: RouteSpec = {
+      id: "users",
+      pattern: "/api/users",
+      kind: "api",
+      module: "generated/routes/api/users.ts",
+      methods: ["GET"],
+    };
+
+    const result = generateContractTemplate(route);
+
+    expect(result).toContain("// 📜 Mandu Contract - users");
+    expect(result).toContain("// Pattern: /api/users");
+    expect(result).toContain('import { z } from "zod"');
+    expect(result).toContain("Mandu.contract({");
+    expect(result).toContain("GET: {");
+    expect(result).toContain("query: z.object({");
+    expect(result).not.toContain("POST:");
+  });
+
+  test("should generate template with GET and POST methods", () => {
+    const route: RouteSpec = {
+      id: "users",
+      pattern: "/api/users",
+      kind: "api",
+      module: "generated/routes/api/users.ts",
+      methods: ["GET", "POST"],
+    };
+
+    const result = generateContractTemplate(route);
+
+    expect(result).toContain("GET: {");
+    expect(result).toContain("POST: {");
+    expect(result).toContain("body: z.object({");
+    expect(result).toContain("201: z.object({"); // 201 for POST
+  });
+
+  test("should generate template with all CRUD methods", () => {
+    const route: RouteSpec = {
+      id: "users",
+      pattern: "/api/users/:id",
+      kind: "api",
+      module: "generated/routes/api/users.ts",
+      methods: ["GET", "POST", "PUT", "PATCH", "DELETE"],
+    };
+
+    const result = generateContractTemplate(route);
+
+    expect(result).toContain("GET: {");
+    expect(result).toContain("POST: {");
+    expect(result).toContain("PUT: {");
+    expect(result).toContain("PATCH: {");
+    expect(result).toContain("DELETE: {");
+  });
+
+  test("should include helpful comments", () => {
+    const route: RouteSpec = {
+      id: "users",
+      pattern: "/api/users",
+      kind: "api",
+      module: "generated/routes/api/users.ts",
+      methods: ["GET"],
+    };
+
+    const result = generateContractTemplate(route);
+
+    expect(result).toContain("// TODO:");
+    expect(result).toContain("💡 Contract 사용법:");
+    expect(result).toContain("mandu generate");
+  });
+
+  test("should set correct description and tags", () => {
+    const route: RouteSpec = {
+      id: "user-profiles",
+      pattern: "/api/user-profiles",
+      kind: "api",
+      module: "generated/routes/api/user-profiles.ts",
+      methods: ["GET"],
+    };
+
+    const result = generateContractTemplate(route);
+
+    expect(result).toContain('description: "UserProfiles API"');
+    expect(result).toContain('tags: ["user-profiles"]');
+  });
+
+  test("should include error response schemas", () => {
+    const route: RouteSpec = {
+      id: "users",
+      pattern: "/api/users",
+      kind: "api",
+      module: "generated/routes/api/users.ts",
+      methods: ["GET"],
+    };
+
+    const result = generateContractTemplate(route);
+
+    expect(result).toContain("400: z.object({");
+    expect(result).toContain("error: z.string()");
+    expect(result).toContain("404: z.object({");
+  });
+});
+
+describe("generateContractTypesIndex", () => {
+  test("should generate index file with all route exports", () => {
+    const routeIds = ["users", "posts", "comments"];
+
+    const result = generateContractTypesIndex(routeIds);
+
+    expect(result).toContain("// Generated by Mandu");
+    expect(result).toContain('export * from "./users.types";');
+    expect(result).toContain('export * from "./posts.types";');
+    expect(result).toContain('export * from "./comments.types";');
+  });
+
+  test("should handle empty route list", () => {
+    const routeIds: string[] = [];
+
+    const result = generateContractTypesIndex(routeIds);
+
+    expect(result).toContain("// Generated by Mandu");
+    expect(result).not.toContain("export *");
+  });
+
+  test("should handle single route", () => {
+    const routeIds = ["users"];
+
+    const result = generateContractTypesIndex(routeIds);
+
+    expect(result).toContain('export * from "./users.types";');
+  });
+});

package/src/guard/check.ts

@@ -1,6 +1,7 @@
 import { GUARD_RULES, FORBIDDEN_IMPORTS, type GuardViolation } from "./rules";
 import { verifyLock, computeHash } from "../spec/lock";
 import { runContractGuardCheck } from "./contract-guard";
+import { validateSlotContent } from "../slot/validator";
 import type { RoutesManifest } from "../spec/schema";
 import type { GeneratedMap } from "../generator/generate";
 import path from "path";
@@ -147,6 +148,51 @@ export async function checkSlotFileExists(
   return violations;
 }
 
+// Rule 6: Slot content validation (신규)
+export async function checkSlotContentValidation(
+  manifest: RoutesManifest,
+  rootDir: string
+): Promise<GuardViolation[]> {
+  const violations: GuardViolation[] = [];
+
+  for (const route of manifest.routes) {
+    if (!route.slotModule) continue;
+
+    const slotPath = path.join(rootDir, route.slotModule);
+    const content = await readFileContent(slotPath);
+
+    if (!content) continue; // File doesn't exist, handled by checkSlotFileExists
+
+    const validationResult = validateSlotContent(content);
+
+    // Convert slot validation issues to guard violations
+    for (const issue of validationResult.issues) {
+      if (issue.severity === "error") {
+        // Map slot issue codes to guard rule IDs
+        let ruleId = "SLOT_VALIDATION_ERROR";
+        if (issue.code === "MISSING_DEFAULT_EXPORT") {
+          ruleId = GUARD_RULES.SLOT_MISSING_DEFAULT_EXPORT?.id ?? "SLOT_MISSING_DEFAULT_EXPORT";
+        } else if (issue.code === "NO_RESPONSE_PATTERN" || issue.code === "INVALID_HANDLER_RETURN") {
+          ruleId = GUARD_RULES.SLOT_INVALID_RETURN?.id ?? "SLOT_INVALID_RETURN";
+        } else if (issue.code === "MISSING_FILLING_PATTERN") {
+          ruleId = GUARD_RULES.SLOT_MISSING_FILLING_PATTERN?.id ?? "SLOT_MISSING_FILLING_PATTERN";
+        }
+
+        violations.push({
+          ruleId,
+          file: route.slotModule,
+          message: `[${route.id}] ${issue.message}`,
+          suggestion: issue.suggestion,
+          line: issue.line,
+          severity: issue.severity,
+        });
+      }
+    }
+  }
+
+  return violations;
+}
+
 // Rule 4: Forbidden imports in generated files
 export async function checkForbiddenImportsInGenerated(
   rootDir: string,
@@ -249,7 +295,11 @@ export async function runGuardCheck(
   const slotViolations = await checkSlotFileExists(manifest, rootDir);
   violations.push(...slotViolations);
 
-  // Rule 6-9: Contract-related checks
+  // Rule 6: Slot content validation (신규 - 강화된 검증)
+  const slotContentViolations = await checkSlotContentValidation(manifest, rootDir);
+  violations.push(...slotContentViolations);
+
+  // Rule 7-10: Contract-related checks
   const contractViolations = await runContractGuardCheck(manifest, rootDir);
   violations.push(...contractViolations);
 

package/src/guard/contract-guard.test.ts

@@ -0,0 +1,303 @@
+/**
+ * Contract Guard Tests
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdir, rm, writeFile } from "fs/promises";
+import path from "path";
+import {
+  checkMissingContract,
+  checkContractFileExists,
+  checkContractSlotConsistency,
+  runContractGuardCheck,
+} from "./contract-guard";
+import type { RoutesManifest } from "../spec/schema";
+
+const TEST_DIR = path.join(process.cwd(), ".test-guard");
+
+describe("Contract Guard", () => {
+  beforeEach(async () => {
+    await mkdir(TEST_DIR, { recursive: true });
+    await mkdir(path.join(TEST_DIR, "spec/contracts"), { recursive: true });
+    await mkdir(path.join(TEST_DIR, "spec/slots"), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+  });
+
+  describe("checkMissingContract", () => {
+    test("should detect API routes without contracts", async () => {
+      const manifest: RoutesManifest = {
+        version: 1,
+        routes: [
+          {
+            id: "users",
+            pattern: "/api/users",
+            kind: "api",
+            module: "generated/routes/api/users.ts",
+            slotModule: "spec/slots/users.slot.ts",
+            // No contractModule
+          },
+        ],
+      };
+
+      const violations = await checkMissingContract(manifest, TEST_DIR);
+
+      expect(violations.length).toBe(1);
+      expect(violations[0].ruleId).toBe("CONTRACT_MISSING");
+      expect(violations[0].routeId).toBe("users");
+    });
+
+    test("should pass API routes with contracts", async () => {
+      const manifest: RoutesManifest = {
+        version: 1,
+        routes: [
+          {
+            id: "users",
+            pattern: "/api/users",
+            kind: "api",
+            module: "generated/routes/api/users.ts",
+            slotModule: "spec/slots/users.slot.ts",
+            contractModule: "spec/contracts/users.contract.ts",
+          },
+        ],
+      };
+
+      const violations = await checkMissingContract(manifest, TEST_DIR);
+
+      expect(violations.length).toBe(0);
+    });
+
+    test("should skip non-API routes", async () => {
+      const manifest: RoutesManifest = {
+        version: 1,
+        routes: [
+          {
+            id: "home",
+            pattern: "/",
+            kind: "page",
+            module: "generated/routes/home.ts",
+            slotModule: "spec/slots/home.slot.ts",
+            // No contractModule - but that's fine for pages
+          },
+        ],
+      };
+
+      const violations = await checkMissingContract(manifest, TEST_DIR);
+
+      expect(violations.length).toBe(0);
+    });
+  });
+
+  describe("checkContractFileExists", () => {
+    test("should detect missing contract files", async () => {
+      const manifest: RoutesManifest = {
+        version: 1,
+        routes: [
+          {
+            id: "users",
+            pattern: "/api/users",
+            kind: "api",
+            module: "generated/routes/api/users.ts",
+            contractModule: "spec/contracts/users.contract.ts",
+          },
+        ],
+      };
+
+      const violations = await checkContractFileExists(manifest, TEST_DIR);
+
+      expect(violations.length).toBe(1);
+      expect(violations[0].ruleId).toBe("CONTRACT_NOT_FOUND");
+    });
+
+    test("should pass when contract file exists", async () => {
+      // Create contract file
+      await writeFile(
+        path.join(TEST_DIR, "spec/contracts/users.contract.ts"),
+        `export default { request: {}, response: {} }`
+      );
+
+      const manifest: RoutesManifest = {
+        version: 1,
+        routes: [
+          {
+            id: "users",
+            pattern: "/api/users",
+            kind: "api",
+            module: "generated/routes/api/users.ts",
+            contractModule: "spec/contracts/users.contract.ts",
+          },
+        ],
+      };
+
+      const violations = await checkContractFileExists(manifest, TEST_DIR);
+
+      expect(violations.length).toBe(0);
+    });
+  });
+
+  describe("checkContractSlotConsistency", () => {
+    test("should detect methods in contract but not in slot", async () => {
+      // Create contract with GET and POST
+      await writeFile(
+        path.join(TEST_DIR, "spec/contracts/users.contract.ts"),
+        `
+        export default {
+          request: {
+            GET: { query: {} },
+            POST: { body: {} },
+            DELETE: {},
+          },
+          response: {},
+        };
+        `
+      );
+
+      // Create slot with only GET
+      await writeFile(
+        path.join(TEST_DIR, "spec/slots/users.slot.ts"),
+        `
+        export default Mandu.filling()
+          .get((ctx) => ctx.ok({ data: [] }));
+        `
+      );
+
+      const manifest: RoutesManifest = {
+        version: 1,
+        routes: [
+          {
+            id: "users",
+            pattern: "/api/users",
+            kind: "api",
+            module: "generated/routes/api/users.ts",
+            contractModule: "spec/contracts/users.contract.ts",
+            slotModule: "spec/slots/users.slot.ts",
+          },
+        ],
+      };
+
+      const violations = await checkContractSlotConsistency(manifest, TEST_DIR);
+
+      expect(violations.length).toBe(1);
+      expect(violations[0].ruleId).toBe("CONTRACT_METHOD_NOT_IMPLEMENTED");
+      expect(violations[0].missingMethods).toContain("POST");
+      expect(violations[0].missingMethods).toContain("DELETE");
+    });
+
+    test("should detect methods in slot but not in contract", async () => {
+      // Create contract with only GET
+      await writeFile(
+        path.join(TEST_DIR, "spec/contracts/users.contract.ts"),
+        `
+        export default {
+          request: {
+            GET: { query: {} },
+          },
+          response: {},
+        };
+        `
+      );
+
+      // Create slot with GET, POST, and DELETE
+      await writeFile(
+        path.join(TEST_DIR, "spec/slots/users.slot.ts"),
+        `
+        export default Mandu.filling()
+          .get((ctx) => ctx.ok({ data: [] }))
+          .post((ctx) => ctx.created({}))
+          .delete((ctx) => ctx.noContent());
+        `
+      );
+
+      const manifest: RoutesManifest = {
+        version: 1,
+        routes: [
+          {
+            id: "users",
+            pattern: "/api/users",
+            kind: "api",
+            module: "generated/routes/api/users.ts",
+            contractModule: "spec/contracts/users.contract.ts",
+            slotModule: "spec/slots/users.slot.ts",
+          },
+        ],
+      };
+
+      const violations = await checkContractSlotConsistency(manifest, TEST_DIR);
+
+      expect(violations.length).toBe(1);
+      expect(violations[0].ruleId).toBe("CONTRACT_METHOD_UNDOCUMENTED");
+      expect(violations[0].undocumentedMethods).toContain("POST");
+      expect(violations[0].undocumentedMethods).toContain("DELETE");
+    });
+
+    test("should pass when contract and slot are in sync", async () => {
+      // Create contract with GET and POST
+      await writeFile(
+        path.join(TEST_DIR, "spec/contracts/users.contract.ts"),
+        `
+        export default {
+          request: {
+            GET: { query: {} },
+            POST: { body: {} },
+          },
+          response: {},
+        };
+        `
+      );
+
+      // Create slot with GET and POST
+      await writeFile(
+        path.join(TEST_DIR, "spec/slots/users.slot.ts"),
+        `
+        export default Mandu.filling()
+          .get((ctx) => ctx.ok({ data: [] }))
+          .post((ctx) => ctx.created({}));
+        `
+      );
+
+      const manifest: RoutesManifest = {
+        version: 1,
+        routes: [
+          {
+            id: "users",
+            pattern: "/api/users",
+            kind: "api",
+            module: "generated/routes/api/users.ts",
+            contractModule: "spec/contracts/users.contract.ts",
+            slotModule: "spec/slots/users.slot.ts",
+          },
+        ],
+      };
+
+      const violations = await checkContractSlotConsistency(manifest, TEST_DIR);
+
+      expect(violations.length).toBe(0);
+    });
+  });
+
+  describe("runContractGuardCheck", () => {
+    test("should run all checks", async () => {
+      // Missing contract file
+      const manifest: RoutesManifest = {
+        version: 1,
+        routes: [
+          {
+            id: "users",
+            pattern: "/api/users",
+            kind: "api",
+            module: "generated/routes/api/users.ts",
+            contractModule: "spec/contracts/users.contract.ts",
+            slotModule: "spec/slots/users.slot.ts",
+          },
+        ],
+      };
+
+      const violations = await runContractGuardCheck(manifest, TEST_DIR);
+
+      // Should find CONTRACT_NOT_FOUND
+      expect(violations.some((v) => v.ruleId === "CONTRACT_NOT_FOUND")).toBe(true);
+    });
+  });
+});

package/src/guard/rules.ts

@@ -3,12 +3,15 @@ export interface GuardViolation {
   file: string;
   message: string;
   suggestion: string;
+  line?: number;
+  severity?: "error" | "warning";
 }
 
 export interface GuardRule {
   id: string;
   name: string;
   description: string;
+  severity: "error" | "warning";
 }
 
 export const GUARD_RULES: Record<string, GuardRule> = {
@@ -16,47 +19,81 @@ export const GUARD_RULES: Record<string, GuardRule> = {
     id: "SPEC_HASH_MISMATCH",
     name: "Spec Hash Mismatch",
     description: "spec.lock.json의 해시와 현재 spec이 일치하지 않습니다",
+    severity: "error",
   },
   GENERATED_MANUAL_EDIT: {
     id: "GENERATED_MANUAL_EDIT",
     name: "Generated File Manual Edit",
     description: "generated 파일이 수동으로 변경되었습니다",
+    severity: "error",
   },
   INVALID_GENERATED_IMPORT: {
     id: "INVALID_GENERATED_IMPORT",
     name: "Invalid Generated Import",
     description: "non-generated 파일에서 generated 파일을 직접 import 했습니다",
+    severity: "error",
   },
   FORBIDDEN_IMPORT_IN_GENERATED: {
     id: "FORBIDDEN_IMPORT_IN_GENERATED",
     name: "Forbidden Import in Generated",
     description: "generated 파일에서 금지된 모듈을 import 했습니다",
+    severity: "error",
   },
   SLOT_NOT_FOUND: {
     id: "SLOT_NOT_FOUND",
     name: "Slot File Not Found",
     description: "spec에 명시된 slotModule 파일을 찾을 수 없습니다",
+    severity: "error",
+  },
+  // Slot validation rules (신규)
+  SLOT_MISSING_DEFAULT_EXPORT: {
+    id: "SLOT_MISSING_DEFAULT_EXPORT",
+    name: "Slot Missing Default Export",
+    description: "Slot 파일에 export default가 없습니다",
+    severity: "error",
+  },
+  SLOT_INVALID_RETURN: {
+    id: "SLOT_INVALID_RETURN",
+    name: "Slot Invalid Handler Return",
+    description: "Slot 핸들러가 올바른 Response를 반환하지 않습니다",
+    severity: "error",
+  },
+  SLOT_NO_RESPONSE_PATTERN: {
+    id: "SLOT_NO_RESPONSE_PATTERN",
+    name: "Slot No Response Pattern",
+    description: "Slot 핸들러에 ctx.ok(), ctx.json() 등의 응답 패턴이 없습니다",
+    severity: "error",
+  },
+  SLOT_MISSING_FILLING_PATTERN: {
+    id: "SLOT_MISSING_FILLING_PATTERN",
+    name: "Slot Missing Filling Pattern",
+    description: "Slot 파일에 Mandu.filling() 패턴이 없습니다",
+    severity: "error",
   },
   // Contract-related rules
   CONTRACT_MISSING: {
     id: "CONTRACT_MISSING",
     name: "Contract Missing",
     description: "API 라우트에 contract가 정의되지 않았습니다",
+    severity: "warning",
   },
   CONTRACT_NOT_FOUND: {
     id: "CONTRACT_NOT_FOUND",
     name: "Contract File Not Found",
     description: "spec에 명시된 contractModule 파일을 찾을 수 없습니다",
+    severity: "error",
   },
   CONTRACT_METHOD_NOT_IMPLEMENTED: {
     id: "CONTRACT_METHOD_NOT_IMPLEMENTED",
     name: "Contract Method Not Implemented",
     description: "Contract에 정의된 메서드가 Slot에 구현되지 않았습니다",
+    severity: "error",
   },
   CONTRACT_METHOD_UNDOCUMENTED: {
     id: "CONTRACT_METHOD_UNDOCUMENTED",
     name: "Contract Method Undocumented",
     description: "Slot에 구현된 메서드가 Contract에 문서화되지 않았습니다",
+    severity: "warning",
   },
 };
 

package/src/index.ts

@@ -10,3 +10,5 @@ export * from "./slot";
 export * from "./bundler";
 export * from "./contract";
 export * from "./openapi";
+export * from "./brain";
+export * from "./watcher";