swallowkit 1.0.0-beta.9 → 1.0.0

package/src/__tests__/scaffold.test.ts

@@ -1,39 +1,302 @@
 import * as path from "path";
-import { getCSharpSchemaArtifactPruneTargets, getOpenApiGeneratorArgs } from "../cli/commands/scaffold";
+import * as fs from "fs";
+import * as os from "os";
+import { EventEmitter } from "events";
+import * as childProcess from "child_process";
+import { generateCosmosContainer, generateUIComponents } from "../cli/commands/scaffold";
+import {
+  NSWAG_CONSOLECORE_VERSION,
+  buildCSharpCodegenToolManifestSource,
+  buildPythonCodegenRequirementsSource,
+  generateLanguageSchemaArtifacts,
+  getCSharpNativeGeneratorArgs,
+  getCSharpSchemaModelPath,
+  getCSharpSchemaOptionPath,
+  getPythonNativeGeneratorArgs,
+  getPythonSchemaModelPath,
+} from "../core/scaffold/native-schema-generator";
+import { createBasicModelInfo } from "./fixtures";
 
-describe("getOpenApiGeneratorArgs", () => {
-  it("keeps supporting files for C# model generation", () => {
-    const args = getOpenApiGeneratorArgs("spec.json", "out", "csharp");
-    const globalPropertyIndex = args.indexOf("--global-property");
+describe("authenticated UI scaffold layouts", () => {
+  const originalCwd = process.cwd();
+  let tempDir: string;
+  const authOptions = {
+    authPolicy: { policy: "staffOnly" },
+    writeRoles: ["authenticated"],
+    authContextImport: "@/lib/auth/schemes/staff/auth-context",
+  };
 
-    expect(globalPropertyIndex).toBeGreaterThanOrEqual(0);
-    expect(args[globalPropertyIndex + 1]).toBe("models,supportingFiles,apis=false,modelDocs=false,modelTests=false");
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(originalCwd, ".tmp-auth-layout-"));
+    process.chdir(tempDir);
   });
 
-  it("continues omitting supporting files for Python model generation", () => {
-    const args = getOpenApiGeneratorArgs("spec.json", "out", "python");
-    const globalPropertyIndex = args.indexOf("--global-property");
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("writes a model-scoped provider layout and regenerates it stably", async () => {
+    const model = createBasicModelInfo({ name: "Product", schemaName: "productSchema" });
+
+    await generateUIComponents(model, "@fixture/shared", authOptions);
+    const layoutPath = path.join(tempDir, "app", "product", "layout.tsx");
+    const first = fs.readFileSync(layoutPath, "utf-8");
+    await generateUIComponents(model, "@fixture/shared", authOptions);
+    const second = fs.readFileSync(layoutPath, "utf-8");
+
+    expect(second).toBe(first);
+    expect(second).toContain("from '@/lib/auth/schemes/staff/auth-context'");
+    expect(second.match(/import \{ AuthProvider \}/g)).toHaveLength(1);
+    expect(second.match(/<AuthProvider>/g)).toHaveLength(1);
+    expect(fs.readFileSync(path.join(tempDir, "app", "product", "page.tsx"), "utf-8"))
+      .toContain("from '@/lib/auth/schemes/staff/auth-context'");
+  });
+
+  it("does not create an auth layout for an unauthenticated model or affect another route", async () => {
+    await generateUIComponents(createBasicModelInfo({ name: "Product", schemaName: "productSchema" }), "@fixture/shared");
+    await generateUIComponents(createBasicModelInfo({ name: "Line", schemaName: "lineSchema" }), "@fixture/shared");
+
+    expect(fs.existsSync(path.join(tempDir, "app", "product", "layout.tsx"))).toBe(false);
+    expect(fs.existsSync(path.join(tempDir, "app", "line", "layout.tsx"))).toBe(false);
+    expect(fs.readFileSync(path.join(tempDir, "app", "line", "page.tsx"), "utf-8"))
+      .not.toContain("schemes/staff/auth-context");
+  });
+
+  it("builds the generated authenticated CRUD routes with Next.js", async () => {
+    const model = createBasicModelInfo({ name: "Product", schemaName: "productSchema" });
+    await generateUIComponents(model, "@fixture/shared", authOptions);
+
+    writeFile(path.join(tempDir, "app", "layout.tsx"), `export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return <html><body>{children}</body></html>;
+}
+`);
+    writeFile(path.join(tempDir, "lib", "auth", "schemes", "staff", "auth-context.tsx"), `'use client';
+import { createContext, useContext } from 'react';
+const AuthContext = createContext<{ user: { id: string }; loading: boolean; hasAnyRole: (roles: string[]) => boolean } | null>(null);
+export function AuthProvider({ children }: { children: React.ReactNode }) {
+  return <AuthContext.Provider value={{ user: { id: 'test' }, loading: false, hasAnyRole: () => true }}>{children}</AuthContext.Provider>;
+}
+export function useAuth() {
+  const value = useContext(AuthContext);
+  if (!value) throw new Error('useAuth must be used within an AuthProvider');
+  return value;
+}
+`);
+    writeFile(path.join(tempDir, "shared.ts"), `import { z } from 'zod/v4';
+export const productSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string().optional(),
+  completed: z.boolean(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+`);
+    writeFile(path.join(tempDir, "package.json"), JSON.stringify({
+      private: true,
+      scripts: { build: "next build" },
+    }, null, 2));
+    writeFile(path.join(tempDir, "tsconfig.json"), JSON.stringify({
+      compilerOptions: {
+        target: "ES2020",
+        lib: ["dom", "dom.iterable", "esnext"],
+        strict: true,
+        noEmit: true,
+        esModuleInterop: true,
+        module: "esnext",
+        moduleResolution: "bundler",
+        resolveJsonModule: true,
+        isolatedModules: true,
+        jsx: "preserve",
+        baseUrl: ".",
+        paths: { "@/*": ["./*"], "@fixture/shared": ["./shared.ts"] },
+      },
+      include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+      exclude: ["node_modules"],
+    }, null, 2));
+
+    const npmCommand = process.platform === "win32"
+      ? { file: process.env.ComSpec ?? "cmd.exe", args: ["/d", "/s", "/c", "npm run build"] }
+      : { file: "npm", args: ["run", "build"] };
+    expect(() => childProcess.execFileSync(npmCommand.file, npmCommand.args, {
+      cwd: tempDir,
+      env: { ...process.env, NEXT_TELEMETRY_DISABLED: "1" },
+      stdio: "pipe",
+      timeout: 120_000,
+    })).not.toThrow();
+  }, 150_000);
+});
+
+jest.mock("child_process", () => {
+  const actual = jest.requireActual<typeof import("child_process")>("child_process");
+  return {
+    ...actual,
+    spawn: jest.fn(),
+    spawnSync: jest.fn(),
+  };
+});
+
+function writeFile(filePath: string, content: string): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content, "utf-8");
+}
+
+function mockSuccessfulSpawn() {
+  const spawnMock = childProcess.spawn as unknown as any;
+  spawnMock.mockImplementation(() => {
+    const child = new EventEmitter() as childProcess.ChildProcess;
+    process.nextTick(() => child.emit("close", 0));
+    return child;
+  });
+  return spawnMock;
+}
+
+describe("native schema generators", () => {
+  it("writes a dotnet tool manifest for NSwag", () => {
+    const manifest = JSON.parse(buildCSharpCodegenToolManifestSource());
+
+    expect(manifest.version).toBe(1);
+    expect(manifest.tools["nswag.consolecore"].version).toBe(NSWAG_CONSOLECORE_VERSION);
+    expect(manifest.tools["nswag.consolecore"].commands).toEqual(["nswag"]);
+  });
+
+  it("pins python schema generation requirements without Java", () => {
+    expect(buildPythonCodegenRequirementsSource()).toContain("datamodel-code-generator");
+    expect(buildPythonCodegenRequirementsSource()).not.toContain("openapi-generator");
+  });
 
-    expect(globalPropertyIndex).toBeGreaterThanOrEqual(0);
-    expect(args[globalPropertyIndex + 1]).toBe(
-      "models,apis=false,supportingFiles=false,modelDocs=false,modelTests=false"
+  it("builds NSwag arguments for model-only C# generation", () => {
+    const outputPath = path.join(os.tmpdir(), "swallowkit-csharp-codegen-example", "Contracts.cs");
+    const args = getCSharpNativeGeneratorArgs("C:\\temp\\todo.openapi.json", outputPath);
+
+    expect(args.slice(0, 4)).toEqual(["tool", "run", "nswag", "openapi2csclient"]);
+    expect(args).toContain("/GenerateClientClasses:false");
+    expect(args).toContain("/GenerateDtoTypes:true");
+    expect(args).toContain("/GenerateNullableReferenceTypes:true");
+    expect(args).toContain(`/output:${outputPath}`);
+  });
+
+  it("builds datamodel-code-generator arguments for python assets", () => {
+    const outputPath = path.join(os.tmpdir(), "swallowkit-python-codegen-example", "models.py");
+    const args = getPythonNativeGeneratorArgs("C:\\temp\\todo.openapi.json", outputPath);
+
+    expect(args).toEqual(
+      expect.arrayContaining([
+        "-m",
+        "datamodel_code_generator",
+        "--input-file-type",
+        "openapi",
+        "--output-model-type",
+        "pydantic_v2.BaseModel",
+        "--disable-timestamp",
+        outputPath,
+      ])
+    );
+  });
+
+  it("keeps generated asset paths under functions/generated", () => {
+    expect(getCSharpSchemaModelPath("C:\\temp\\generated\\csharp-models", "Product")).toBe(
+      path.join("C:\\temp\\generated\\csharp-models", "src", "SwallowKitBackendModels", "Model", "Product.cs")
+    );
+    expect(getCSharpSchemaOptionPath("C:\\temp\\generated\\csharp-models")).toBe(
+      path.join("C:\\temp\\generated\\csharp-models", "src", "SwallowKitBackendModels", "Client", "Option.cs")
+    );
+    expect(getPythonSchemaModelPath("C:\\temp\\generated\\python-models", "Product")).toBe(
+      path.join("C:\\temp\\generated\\python-models", "backend_models", "models", "product.py")
     );
   });
+describe("generateCosmosContainer", () => {
+  const originalCwd = process.cwd();
+  let tempDir: string;
 
-  it("prunes extra C# artifacts that pull in unused dependencies", () => {
-    const targets = getCSharpSchemaArtifactPruneTargets("C:\\temp\\generated\\csharp-models");
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-cosmos-container-"));
+    process.chdir(tempDir);
+    fs.mkdirSync(path.join(tempDir, "infra", "containers"), { recursive: true });
+    fs.writeFileSync(path.join(tempDir, "infra", "main.bicep"), "module cosmosDbServerless 'modules/cosmosdb-serverless.bicep' = if (cosmosDbMode == 'serverless') {\n  name: 'cosmosDb'\n}\n");
+  });
 
-    expect(targets).toEqual([
-      path.join("C:\\temp\\generated\\csharp-models", "src", "SwallowKitBackendModels.Test"),
-      path.join("C:\\temp\\generated\\csharp-models", "src", "SwallowKitBackendModels", "Api"),
-      path.join("C:\\temp\\generated\\csharp-models", "src", "SwallowKitBackendModels", "Extensions"),
-    ]);
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tempDir, { recursive: true, force: true });
   });
 
-  it("keeps only Option.cs from generated C# client helpers", () => {
-    const args = getOpenApiGeneratorArgs("spec.json", "out", "csharp");
+  it("generates container templates without container-level throughput settings", async () => {
+    await generateCosmosContainer({ name: "SurveyResponse", partitionKey: "/id" });
+
+    const containerFilePath = path.join(tempDir, "infra", "containers", "survey-response-container.bicep");
+    const containerContent = fs.readFileSync(containerFilePath, "utf-8");
+    const mainContent = fs.readFileSync(path.join(tempDir, "infra", "main.bicep"), "utf-8");
+
+    expect(containerContent).toContain("resource container");
+    expect(containerContent).not.toContain("throughput");
+    expect(containerContent).not.toContain("options:");
+    expect(mainContent).toContain("module surveyResponseContainer 'containers/survey-response-container.bicep'");
+    expect(mainContent).not.toContain("dependsOn");
+  });
+});
+  describe("non-destructive native schema generation", () => {
+    const originalCwd = process.cwd();
+    let tempDir: string;
+    let spawnSyncMock: any;
+    let spawnMock: any;
+
+    beforeEach(() => {
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-native-schema-"));
+      process.chdir(tempDir);
+      fs.mkdirSync(path.join(tempDir, "functions"), { recursive: true });
+      spawnSyncMock = childProcess.spawnSync as unknown as any;
+      spawnSyncMock.mockReturnValue({ status: 0 });
+      spawnMock = mockSuccessfulSpawn();
+    });
+
+    afterEach(() => {
+      spawnMock.mockReset();
+      spawnSyncMock.mockReset();
+      process.chdir(originalCwd);
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    it("preserves existing C# generated directory contents while writing only requested model files", async () => {
+      const outputDir = path.join(tempDir, "functions", "generated", "csharp-models");
+      writeFile(path.join(outputDir, "README.md"), "keep me\n");
+      writeFile(path.join(outputDir, "SwallowKitBackendModels.csproj"), "<Project />\n");
+      writeFile(path.join(outputDir, "src", "SwallowKitBackendModels", "Model", "Member.cs"), "// existing member\n");
+
+      const estimate = createBasicModelInfo({ name: "Estimate", filePath: path.join(tempDir, "shared", "models", "estimate.ts") });
+
+      await generateLanguageSchemaArtifacts([estimate], estimate, "functions", "csharp");
+
+      expect(fs.readFileSync(path.join(outputDir, "README.md"), "utf-8")).toBe("keep me\n");
+      expect(fs.existsSync(path.join(outputDir, "SwallowKitBackendModels.csproj"))).toBe(true);
+      expect(fs.readFileSync(getCSharpSchemaModelPath(outputDir, "Member"), "utf-8")).toBe("// existing member\n");
+      expect(fs.existsSync(getCSharpSchemaModelPath(outputDir, "Todo"))).toBe(false);
+      expect(fs.existsSync(getCSharpSchemaModelPath(outputDir, "Estimate"))).toBe(true);
+      expect(fs.existsSync(getCSharpSchemaOptionPath(outputDir))).toBe(true);
+    });
+
+    it("preserves existing Python generated directory contents while appending requested model exports", async () => {
+      const outputDir = path.join(tempDir, "functions", "generated", "python-models");
+      writeFile(path.join(outputDir, "README.md"), "keep python\n");
+      writeFile(path.join(outputDir, "backend_models", "models", "member.py"), "# existing member\n");
+      writeFile(path.join(outputDir, "backend_models", "__init__.py"), "from .models.member import Member\n");
+      writeFile(path.join(outputDir, "backend_models", "models", "__init__.py"), "from .member import Member\n");
+
+      const estimate = createBasicModelInfo({ name: "Estimate", filePath: path.join(tempDir, "shared", "models", "estimate.ts") });
+
+      await generateLanguageSchemaArtifacts([estimate], estimate, "functions", "python");
 
-    expect(args).toContain("csharp");
-    expect(getCSharpSchemaArtifactPruneTargets("C:\\temp\\generated\\csharp-models")).toHaveLength(3);
+      expect(fs.readFileSync(path.join(outputDir, "README.md"), "utf-8")).toBe("keep python\n");
+      expect(fs.readFileSync(path.join(outputDir, "backend_models", "models", "member.py"), "utf-8")).toBe("# existing member\n");
+      expect(fs.existsSync(getPythonSchemaModelPath(outputDir, "Todo"))).toBe(false);
+      expect(fs.existsSync(getPythonSchemaModelPath(outputDir, "Estimate"))).toBe(true);
+      const packageInit = fs.readFileSync(path.join(outputDir, "backend_models", "__init__.py"), "utf-8");
+      const modelsInit = fs.readFileSync(path.join(outputDir, "backend_models", "models", "__init__.py"), "utf-8");
+      expect(packageInit).toContain("from .models.member import Member");
+      expect(packageInit).toContain("from .models.estimate import Estimate");
+      expect(modelsInit).toContain("from .member import Member");
+      expect(modelsInit).toContain("from .estimate import Estimate");
+    });
   });
 });

package/src/__tests__/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "../..",
+    "types": ["node", "jest"]
+  },
+  "include": [
+    "./**/*.ts",
+    "../**/*.ts"
+  ],
+  "exclude": [
+    "../../dist",
+    "../../node_modules"
+  ]
+}

package/src/__tests__/ui-generator.test.ts

@@ -1,16 +1,56 @@
+import * as fs from "fs";
+import * as path from "path";
+import { execFileSync } from "child_process";
 import {
   generateListPage,
   generateDetailPage,
   generateFormComponent,
   generateNewPage,
   generateEditPage,
+  generateAuthLayout,
 } from "../core/scaffold/ui-generator";
 import {
   createBasicModelInfo,
   createModelInfoWithForeignKey,
+  createModelInfoWithNullableForeignKeys,
   createModelInfoWithEnum,
 } from "./fixtures";
 
+const namedAuthOptions = {
+  authPolicy: { policy: "staffOnly" },
+  writeRoles: ["authenticated"],
+  authContextImport: "@/lib/auth/schemes/staff/auth-context",
+};
+
+describe("generateAuthLayout", () => {
+  it("uses the same resolved auth context as authenticated CRUD pages", () => {
+    const model = createBasicModelInfo({ name: "Product" });
+    const layout = generateAuthLayout(model, namedAuthOptions);
+    const listPage = generateListPage(model, "@myapp/shared", namedAuthOptions);
+    const newPage = generateNewPage(model, namedAuthOptions);
+
+    expect(layout).toContain("import { AuthProvider } from '@/lib/auth/schemes/staff/auth-context';");
+    expect(layout).toContain("<AuthProvider>{children}</AuthProvider>");
+    expect(layout).toContain("function ProductLayout");
+    expect(listPage).toContain("import { useAuth } from '@/lib/auth/schemes/staff/auth-context';");
+    expect(newPage).toContain("import { useAuth } from '@/lib/auth/schemes/staff/auth-context';");
+  });
+
+  it("does not generate an auth layout without auth options", () => {
+    expect(generateAuthLayout(createBasicModelInfo({ name: "Product" }))).toBeUndefined();
+  });
+
+  it("is deterministic and does not duplicate providers or imports", () => {
+    const model = createBasicModelInfo({ name: "Product" });
+    const first = generateAuthLayout(model, namedAuthOptions);
+    const second = generateAuthLayout(model, namedAuthOptions);
+
+    expect(second).toBe(first);
+    expect(first?.match(/import \{ AuthProvider \}/g)).toHaveLength(1);
+    expect(first?.match(/<AuthProvider>/g)).toHaveLength(1);
+  });
+});
+
 describe("generateListPage", () => {
   it("generates list page for basic model (snapshot)", () => {
     const model = createBasicModelInfo();
@@ -48,6 +88,15 @@ describe("generateListPage", () => {
     const code = generateListPage(model, "@myapp/shared");
     expect(code).toContain("categoryId");
   });
+
+  it("guards optional and nullable foreign key map lookups", () => {
+    const code = generateListPage(createModelInfoWithNullableForeignKeys(), "@myapp/shared");
+
+    expect(code).toContain("requiredUserMap[item.requiredUserId] || item.requiredUserId");
+    expect(code).toContain("item.optionalUserId ? optionalUserMap[item.optionalUserId] || item.optionalUserId : '-'");
+    expect(code).toContain("item.nullableUserId ? nullableUserMap[item.nullableUserId] || item.nullableUserId : '-'");
+    expect(code).not.toContain("requiredUserId ?");
+  });
 });
 
 describe("generateDetailPage", () => {
@@ -68,6 +117,61 @@ describe("generateDetailPage", () => {
     const code = generateDetailPage(model, "@myapp/shared");
     expect(code).toContain("DELETE");
   });
+
+  it("guards optional and nullable foreign key map lookups", () => {
+    const code = generateDetailPage(createModelInfoWithNullableForeignKeys(), "@myapp/shared");
+
+    expect(code).toContain("requiredUserMap[coupon.requiredUserId] || coupon.requiredUserId");
+    expect(code).toContain("coupon.optionalUserId ? optionalUserMap[coupon.optionalUserId] || coupon.optionalUserId : '-'");
+    expect(code).toContain("coupon.nullableUserId ? nullableUserMap[coupon.nullableUserId] || coupon.nullableUserId : '-'");
+    expect(code).not.toContain("requiredUserId ?");
+  });
+
+  it("generates list and detail pages that pass strict TypeScript checking", () => {
+    const tempDir = fs.mkdtempSync(path.join(process.cwd(), ".tmp-ui-generator-"));
+    const model = createModelInfoWithNullableForeignKeys();
+
+    try {
+      fs.writeFileSync(path.join(tempDir, "list.tsx"), generateListPage(model, "@myapp/shared"));
+      fs.writeFileSync(path.join(tempDir, "detail.tsx"), generateDetailPage(model, "@myapp/shared"));
+      fs.writeFileSync(
+        path.join(tempDir, "shared.ts"),
+        `import { z } from 'zod/v4';
+export const couponSchema = z.object({
+  id: z.string(),
+  requiredUserId: z.string(),
+  optionalUserId: z.string().optional(),
+  nullableUserId: z.string().nullable(),
+});
+`
+      );
+      fs.writeFileSync(
+        path.join(tempDir, "tsconfig.json"),
+        JSON.stringify({
+          compilerOptions: {
+            target: "ES2020",
+            module: "commonjs",
+            moduleResolution: "node",
+            jsx: "react-jsx",
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            noEmit: true,
+            baseUrl: ".",
+            paths: { "@myapp/shared": ["./shared.ts"] },
+          },
+          include: ["*.ts", "*.tsx"],
+        })
+      );
+
+      expect(() => execFileSync(process.execPath, [require.resolve("typescript/bin/tsc"), "-p", tempDir], {
+        cwd: process.cwd(),
+        stdio: "pipe",
+      })).not.toThrow();
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
 });
 
 describe("generateFormComponent", () => {

package/src/__tests__/zod-mock-generator.test.ts

@@ -0,0 +1,132 @@
+/**
+ * Zod モックデータジェネレーターのテスト
+ */
+
+import { generateMockDocument, generateMockDocuments } from "../core/mock/zod-mock-generator";
+import {
+  createBasicModelInfo,
+  createRdbConnectorModelInfo,
+  createApiConnectorModelInfo,
+  createModelInfoWithEnum,
+} from "./fixtures";
+
+describe("generateMockDocument", () => {
+  it("generates a document with all model fields", () => {
+    const model = createBasicModelInfo();
+    const doc = generateMockDocument(model, 1);
+
+    expect(doc).toHaveProperty("id");
+    expect(doc).toHaveProperty("title");
+    expect(doc).toHaveProperty("description");
+    expect(doc).toHaveProperty("completed");
+    expect(doc).toHaveProperty("createdAt");
+    expect(doc).toHaveProperty("updatedAt");
+  });
+
+  it("generates id using model name and index", () => {
+    const model = createBasicModelInfo();
+    const doc = generateMockDocument(model, 1);
+    expect(doc.id).toBe("todo-001");
+  });
+
+  it("generates different values for different indices", () => {
+    const model = createBasicModelInfo();
+    const doc1 = generateMockDocument(model, 1);
+    const doc2 = generateMockDocument(model, 2);
+    expect(doc1.id).not.toBe(doc2.id);
+    expect(doc1.title).not.toBe(doc2.title);
+  });
+
+  it("generates boolean fields with alternating values", () => {
+    const model = createBasicModelInfo();
+    const doc1 = generateMockDocument(model, 1);
+    const doc2 = generateMockDocument(model, 2);
+    expect(typeof doc1.completed).toBe("boolean");
+    expect(doc1.completed).not.toBe(doc2.completed);
+  });
+
+  it("generates ISO date strings for *At fields", () => {
+    const model = createBasicModelInfo();
+    const doc = generateMockDocument(model, 1);
+    expect(typeof doc.createdAt).toBe("string");
+    // Should be parseable as ISO date
+    expect(new Date(doc.createdAt as string).toISOString()).toBe(doc.createdAt);
+  });
+
+  it("generates string values for title fields", () => {
+    const model = createBasicModelInfo();
+    const doc = generateMockDocument(model, 1);
+    expect(typeof doc.title).toBe("string");
+    expect(doc.title).toContain("1");
+  });
+
+  it("handles optional string fields", () => {
+    const model = createBasicModelInfo();
+    const doc = generateMockDocument(model, 1);
+    // description is optional but still gets a value for mock data
+    expect(typeof doc.description).toBe("string");
+  });
+
+  it("generates email-like values for email fields", () => {
+    const model = createRdbConnectorModelInfo();
+    const doc = generateMockDocument(model, 1);
+    expect(doc.email).toContain("@example.com");
+  });
+
+  it("generates department values for department fields", () => {
+    const model = createRdbConnectorModelInfo();
+    const doc = generateMockDocument(model, 1);
+    expect(typeof doc.department).toBe("string");
+    // Should be one of the department names
+    expect(["Engineering", "Sales", "Marketing", "Support", "HR"]).toContain(doc.department);
+  });
+
+  it("cycles enum values across indices", () => {
+    const model = createModelInfoWithEnum();
+    const doc1 = generateMockDocument(model, 1);
+    const doc2 = generateMockDocument(model, 2);
+    const doc3 = generateMockDocument(model, 3);
+    expect(doc1.status).toBe("open");
+    expect(doc2.status).toBe("in_progress");
+    expect(doc3.status).toBe("closed");
+  });
+
+  it("generates foreign key references for *Id fields", () => {
+    const model = createApiConnectorModelInfo();
+    const doc = generateMockDocument(model, 1);
+    expect(typeof doc.projectId).toBe("string");
+    expect(doc.projectId).toContain("project-");
+  });
+});
+
+describe("generateMockDocuments", () => {
+  it("generates the specified number of documents", () => {
+    const model = createBasicModelInfo();
+    const docs = generateMockDocuments(model, 3);
+    expect(docs).toHaveLength(3);
+  });
+
+  it("defaults to 5 documents", () => {
+    const model = createBasicModelInfo();
+    const docs = generateMockDocuments(model);
+    expect(docs).toHaveLength(5);
+  });
+
+  it("generates unique ids for each document", () => {
+    const model = createBasicModelInfo();
+    const docs = generateMockDocuments(model, 5);
+    const ids = docs.map((d) => d.id);
+    const uniqueIds = new Set(ids);
+    expect(uniqueIds.size).toBe(5);
+  });
+
+  it("works with connector models", () => {
+    const model = createRdbConnectorModelInfo();
+    const docs = generateMockDocuments(model, 3);
+    expect(docs).toHaveLength(3);
+    // All should have email fields with @example.com
+    for (const doc of docs) {
+      expect(doc.email).toContain("@example.com");
+    }
+  });
+});