swallowkit 1.0.0-beta.4 → 1.0.0-beta.40

package/src/__tests__/package-manager.test.ts

@@ -0,0 +1,201 @@
+import {
+  getCommands,
+  getWorkspaceConfig,
+  getCiSetupStep,
+  getAzurePipelinesSetup,
+  getBuildScript,
+  getSwaAppBuildCommand,
+  getFunctionsPrestart,
+  getFunctionsStartScript,
+  spawnArgs,
+} from "../utils/package-manager";
+
+describe("getCommands", () => {
+  describe("pnpm", () => {
+    const cmds = getCommands("pnpm");
+
+    it("returns correct name", () => {
+      expect(cmds.name).toBe("pnpm");
+    });
+
+    it("returns correct install command", () => {
+      expect(cmds.install).toBe("pnpm install");
+    });
+
+    it("returns correct ci command", () => {
+      expect(cmds.ci).toBe("pnpm install --frozen-lockfile");
+    });
+
+    it("returns correct add command", () => {
+      expect(cmds.add).toBe("pnpm add");
+    });
+
+    it("returns correct addDev command", () => {
+      expect(cmds.addDev).toBe("pnpm add -D");
+    });
+
+    it("returns correct exec command", () => {
+      expect(cmds.exec).toBe("pnpm exec");
+    });
+
+    it("returns correct dlx command", () => {
+      expect(cmds.dlx).toBe("pnpm dlx");
+    });
+
+    it("returns correct runFilter for workspace", () => {
+      expect(cmds.runFilter("shared")).toBe("pnpm run --filter shared");
+    });
+
+    it("returns --use-pnpm flag for create-next-app", () => {
+      expect(cmds.createNextAppFlag).toBe("--use-pnpm");
+    });
+  });
+
+  describe("npm", () => {
+    const cmds = getCommands("npm");
+
+    it("returns correct name", () => {
+      expect(cmds.name).toBe("npm");
+    });
+
+    it("returns correct install command", () => {
+      expect(cmds.install).toBe("npm install");
+    });
+
+    it("returns correct ci command", () => {
+      expect(cmds.ci).toBe("npm ci");
+    });
+
+    it("returns correct add command", () => {
+      expect(cmds.add).toBe("npm install");
+    });
+
+    it("returns correct addDev command", () => {
+      expect(cmds.addDev).toBe("npm install -D");
+    });
+
+    it("returns correct exec command", () => {
+      expect(cmds.exec).toBe("npx");
+    });
+
+    it("returns correct dlx command", () => {
+      expect(cmds.dlx).toBe("npx");
+    });
+
+    it("returns correct runFilter for workspace", () => {
+      expect(cmds.runFilter("shared")).toBe("npm run --workspace=shared");
+    });
+
+    it("returns null for create-next-app flag", () => {
+      expect(cmds.createNextAppFlag).toBeNull();
+    });
+  });
+});
+
+describe("getWorkspaceConfig", () => {
+  it("returns pnpm-workspace.yaml config for pnpm", () => {
+    const config = getWorkspaceConfig("pnpm", ["packages/*", "apps/*"]);
+    expect(config.type).toBe("file");
+    if (config.type === "file") {
+      expect(config.filename).toBe("pnpm-workspace.yaml");
+      expect(config.content).toContain("packages:");
+      expect(config.content).toContain("  - packages/*");
+      expect(config.content).toContain("  - apps/*");
+    }
+  });
+
+  it("returns packageJson config for npm", () => {
+    const config = getWorkspaceConfig("npm", ["packages/*", "apps/*"]);
+    expect(config.type).toBe("packageJson");
+    if (config.type === "packageJson") {
+      expect(config.field).toBe("workspaces");
+      expect(config.value).toEqual(["packages/*", "apps/*"]);
+    }
+  });
+});
+
+describe("getCiSetupStep", () => {
+  it("returns pnpm setup step for pnpm", () => {
+    const step = getCiSetupStep("pnpm");
+    expect(step).toContain("pnpm/action-setup");
+    expect(step).toContain("version: latest");
+  });
+
+  it("returns empty string for npm", () => {
+    expect(getCiSetupStep("npm")).toBe("");
+  });
+});
+
+describe("getSwaAppBuildCommand", () => {
+  it("returns a pnpm build command for pnpm projects", () => {
+    expect(getSwaAppBuildCommand("pnpm")).toBe("pnpm install --frozen-lockfile && pnpm run build");
+  });
+
+  it("returns an npm build command for npm projects", () => {
+    expect(getSwaAppBuildCommand("npm")).toBe("npm ci && npm run build");
+  });
+});
+
+describe("getAzurePipelinesSetup", () => {
+  it("returns corepack step for pnpm", () => {
+    const step = getAzurePipelinesSetup("pnpm");
+    expect(step).toContain("corepack enable");
+    expect(step).toContain("pnpm");
+  });
+
+  it("returns empty string for npm", () => {
+    expect(getAzurePipelinesSetup("npm")).toBe("");
+  });
+});
+
+describe("getBuildScript", () => {
+  it("uses pnpm run --filter for pnpm", () => {
+    expect(getBuildScript("pnpm")).toContain("pnpm run --filter shared build");
+    expect(getBuildScript("pnpm")).toContain("fs.cpSync");
+  });
+
+  it("uses npm run --workspace for npm", () => {
+    expect(getBuildScript("npm")).toContain("npm run --workspace=shared build");
+    expect(getBuildScript("npm")).toContain("fs.cpSync");
+  });
+});
+
+describe("getFunctionsPrestart", () => {
+  it("uses pnpm run build for pnpm", () => {
+    expect(getFunctionsPrestart("pnpm")).toBe("pnpm run build");
+  });
+
+  it("uses npm run build for npm", () => {
+    expect(getFunctionsPrestart("npm")).toBe("npm run build");
+  });
+});
+
+describe("getFunctionsStartScript", () => {
+  it("uses pnpm start for pnpm", () => {
+    expect(getFunctionsStartScript("pnpm")).toContain("pnpm start");
+  });
+
+  it("uses npm start for npm", () => {
+    expect(getFunctionsStartScript("npm")).toContain("npm start");
+  });
+
+  it("uses func start for csharp backends", () => {
+    expect(getFunctionsStartScript("pnpm", "csharp")).toBe("cd functions && func start");
+  });
+
+  it("uses func start for python backends", () => {
+    expect(getFunctionsStartScript("npm", "python")).toBe("cd functions && func start");
+  });
+});
+
+describe("spawnArgs", () => {
+  it("returns cmd and args for pnpm", () => {
+    const result = spawnArgs("pnpm", ["add", "next@latest"]);
+    expect(result).toEqual({ cmd: "pnpm", args: ["add", "next@latest"] });
+  });
+
+  it("returns cmd and args for npm", () => {
+    const result = spawnArgs("npm", ["install", "next@latest"]);
+    expect(result).toEqual({ cmd: "npm", args: ["install", "next@latest"] });
+  });
+});

package/src/__tests__/python-uv.test.ts

@@ -0,0 +1,48 @@
+import * as path from "path";
+import {
+  buildProjectLocalUvEnv,
+  buildUvPipInstallArgs,
+  buildUvVenvArgs,
+  getProjectLocalUvPaths,
+  getPythonProjectRoot,
+} from "../utils/python-uv";
+
+describe("python uv helpers", () => {
+  it("keeps uv-managed state inside the project", () => {
+    const projectRoot = "C:\\repo";
+    const uvPaths = getProjectLocalUvPaths(projectRoot);
+
+    expect(uvPaths.stateDir).toBe(path.join(projectRoot, ".uv"));
+    expect(uvPaths.cacheDir).toBe(path.join(projectRoot, ".uv", "cache"));
+    expect(uvPaths.pythonInstallDir).toBe(path.join(projectRoot, ".uv", "python"));
+    expect(uvPaths.localUvExecutable.endsWith(process.platform === "win32" ? path.join(".uv", "bin", "uv.exe") : path.join(".uv", "bin", "uv"))).toBe(true);
+  });
+
+  it("derives the project root from the functions directory", () => {
+    expect(getPythonProjectRoot(path.join("C:\\repo", "functions"))).toBe("C:\\repo");
+  });
+
+  it("builds project-local uv environment variables", () => {
+    const env = buildProjectLocalUvEnv({ PATH: "C:\\Windows\\System32" }, "C:\\repo");
+
+    expect(env.UV_CACHE_DIR).toBe(path.join("C:\\repo", ".uv", "cache"));
+    expect(env.UV_PYTHON_INSTALL_DIR).toBe(path.join("C:\\repo", ".uv", "python"));
+    expect(env.UV_TOOL_DIR).toBe(path.join("C:\\repo", ".uv", "tools"));
+    expect(env.UV_TOOL_BIN_DIR).toBe(path.join("C:\\repo", ".uv", "tools", "bin"));
+    expect(env.UV_MANAGED_PYTHON).toBeUndefined();
+    expect(env.UV_PYTHON_PREFERENCE).toBe("only-managed");
+    expect(env.UV_PYTHON_NO_REGISTRY).toBe(process.platform === "win32" ? "true" : undefined);
+  });
+
+  it("builds uv commands for venv creation and requirements installation", () => {
+    expect(buildUvVenvArgs(".venv")).toEqual(["venv", ".venv", "--python", "3.11"]);
+    expect(buildUvPipInstallArgs(path.join("C:\\repo", "functions", ".venv", "Scripts", "python.exe"), "requirements.txt")).toEqual([
+      "pip",
+      "install",
+      "--python",
+      path.join("C:\\repo", "functions", ".venv", "Scripts", "python.exe"),
+      "-r",
+      "requirements.txt",
+    ]);
+  });
+});

package/src/__tests__/scaffold.test.ts

@@ -0,0 +1,191 @@
+import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
+import { EventEmitter } from "events";
+import * as childProcess from "child_process";
+import { generateCosmosContainer } 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";
+
+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");
+  });
+
+  it("builds NSwag arguments for model-only C# generation", () => {
+    const outputPath = path.join("C:\\temp\\generated\\csharp-models", ".native-temp", "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("C:\\temp\\generated\\python-models", ".native-temp", "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;
+
+  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");
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  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(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__/string-utils.test.ts

@@ -0,0 +1,75 @@
+import { toPascalCase, toCamelCase, toKebabCase } from "../core/scaffold/model-parser";
+
+describe("toPascalCase", () => {
+  it("converts kebab-case to PascalCase", () => {
+    expect(toPascalCase("todo-item")).toBe("TodoItem");
+  });
+
+  it("converts snake_case to PascalCase", () => {
+    expect(toPascalCase("todo_item")).toBe("TodoItem");
+  });
+
+  it("handles single word", () => {
+    expect(toPascalCase("todo")).toBe("Todo");
+  });
+
+  it("handles already PascalCase (no separators)", () => {
+    expect(toPascalCase("Todo")).toBe("Todo");
+  });
+
+  it("handles multiple segments", () => {
+    expect(toPascalCase("my-cool-model")).toBe("MyCoolModel");
+  });
+
+  it("handles empty string", () => {
+    expect(toPascalCase("")).toBe("");
+  });
+});
+
+describe("toCamelCase", () => {
+  it("converts kebab-case to camelCase", () => {
+    expect(toCamelCase("todo-item")).toBe("todoItem");
+  });
+
+  it("converts snake_case to camelCase", () => {
+    expect(toCamelCase("todo_item")).toBe("todoItem");
+  });
+
+  it("handles single word", () => {
+    expect(toCamelCase("Todo")).toBe("todo");
+  });
+
+  it("handles PascalCase input (lowercases first char)", () => {
+    expect(toCamelCase("TodoItem")).toBe("todoItem");
+  });
+
+  it("handles empty string", () => {
+    expect(toCamelCase("")).toBe("");
+  });
+});
+
+describe("toKebabCase", () => {
+  it("converts PascalCase to kebab-case", () => {
+    expect(toKebabCase("TodoItem")).toBe("todo-item");
+  });
+
+  it("converts camelCase to kebab-case", () => {
+    expect(toKebabCase("todoItem")).toBe("todo-item");
+  });
+
+  it("handles single lowercase word", () => {
+    expect(toKebabCase("todo")).toBe("todo");
+  });
+
+  it("handles multiple capitals", () => {
+    expect(toKebabCase("MyCoolModel")).toBe("my-cool-model");
+  });
+
+  it("handles already kebab-case", () => {
+    expect(toKebabCase("todo-item")).toBe("todo-item");
+  });
+
+  it("handles empty string", () => {
+    expect(toKebabCase("")).toBe("");
+  });
+});

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

@@ -0,0 +1,144 @@
+import {
+  generateListPage,
+  generateDetailPage,
+  generateFormComponent,
+  generateNewPage,
+  generateEditPage,
+} from "../core/scaffold/ui-generator";
+import {
+  createBasicModelInfo,
+  createModelInfoWithForeignKey,
+  createModelInfoWithEnum,
+} from "./fixtures";
+
+describe("generateListPage", () => {
+  it("generates list page for basic model (snapshot)", () => {
+    const model = createBasicModelInfo();
+    const code = generateListPage(model, "@myapp/shared");
+    expect(code).toMatchSnapshot();
+  });
+
+  it("contains 'use client' directive", () => {
+    const model = createBasicModelInfo();
+    const code = generateListPage(model, "@myapp/shared");
+    expect(code).toContain("'use client'");
+  });
+
+  it("imports schema from shared package", () => {
+    const model = createBasicModelInfo();
+    const code = generateListPage(model, "@myapp/shared");
+    expect(code).toContain("@myapp/shared");
+  });
+
+  it("fetches from correct API endpoint", () => {
+    const model = createBasicModelInfo();
+    const code = generateListPage(model, "@myapp/shared");
+    expect(code).toContain("/api/todo");
+  });
+
+  it("displays up to 3 non-id fields", () => {
+    const model = createBasicModelInfo();
+    const code = generateListPage(model, "@myapp/shared");
+    // title, description, completed — first 3 non-id fields
+    expect(code).toContain("title");
+  });
+
+  it("handles foreign key fields", () => {
+    const model = createModelInfoWithForeignKey();
+    const code = generateListPage(model, "@myapp/shared");
+    expect(code).toContain("categoryId");
+  });
+});
+
+describe("generateDetailPage", () => {
+  it("generates detail page (snapshot)", () => {
+    const model = createBasicModelInfo();
+    const code = generateDetailPage(model, "@myapp/shared");
+    expect(code).toMatchSnapshot();
+  });
+
+  it("contains 'use client' directive", () => {
+    const model = createBasicModelInfo();
+    const code = generateDetailPage(model, "@myapp/shared");
+    expect(code).toContain("'use client'");
+  });
+
+  it("includes delete button", () => {
+    const model = createBasicModelInfo();
+    const code = generateDetailPage(model, "@myapp/shared");
+    expect(code).toContain("DELETE");
+  });
+});
+
+describe("generateFormComponent", () => {
+  it("generates form component (snapshot)", () => {
+    const model = createBasicModelInfo();
+    const code = generateFormComponent(model, "@myapp/shared");
+    expect(code).toMatchSnapshot();
+  });
+
+  it("generates inputs for non-managed fields", () => {
+    const model = createBasicModelInfo();
+    const code = generateFormComponent(model, "@myapp/shared");
+    // title and description should have form inputs
+    expect(code).toContain("title");
+    expect(code).toContain("description");
+  });
+
+  it("generates enum select for enum fields", () => {
+    const model = createModelInfoWithEnum();
+    const code = generateFormComponent(model, "@myapp/shared");
+    expect(code).toContain("select");
+    expect(code).toContain("open");
+    expect(code).toContain("in_progress");
+    expect(code).toContain("closed");
+  });
+
+  it("generates checkbox for boolean fields", () => {
+    const model = createBasicModelInfo();
+    const code = generateFormComponent(model, "@myapp/shared");
+    expect(code).toContain("checkbox");
+  });
+});
+
+describe("generateNewPage", () => {
+  it("generates new page (snapshot)", () => {
+    const model = createBasicModelInfo();
+    const code = generateNewPage(model);
+    expect(code).toMatchSnapshot();
+  });
+
+  it("contains form component reference", () => {
+    const model = createBasicModelInfo();
+    const code = generateNewPage(model);
+    expect(code).toContain("Form");
+  });
+
+  it("references the form component", () => {
+    const model = createBasicModelInfo();
+    const code = generateNewPage(model);
+    expect(code).toContain("TodoForm");
+    expect(code).toContain("Create New Todo");
+  });
+});
+
+describe("generateEditPage", () => {
+  it("generates edit page (snapshot)", () => {
+    const model = createBasicModelInfo();
+    const code = generateEditPage(model, "@myapp/shared");
+    expect(code).toMatchSnapshot();
+  });
+
+  it("loads existing data and passes to form", () => {
+    const model = createBasicModelInfo();
+    const code = generateEditPage(model, "@myapp/shared");
+    expect(code).toContain("initialData");
+    expect(code).toContain("isEdit={true}");
+  });
+
+  it("fetches existing data for editing", () => {
+    const model = createBasicModelInfo();
+    const code = generateEditPage(model, "@myapp/shared");
+    expect(code).toContain("/api/todo/");
+  });
+});