swallowkit 1.0.0-beta.2 → 1.0.0-beta.20

package/src/__tests__/dev-seeds.test.ts

@@ -0,0 +1,112 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { createBasicModelInfo } from "./fixtures";
+import {
+  buildSeedTemplateDocument,
+  getContainerNameForModel,
+  loadDevSeedFiles,
+  normalizeSeedIdentifier,
+  parseSeedDocuments,
+} from "../cli/commands/dev-seeds";
+
+describe("dev seed helpers", () => {
+  const originalCwd = process.cwd();
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-dev-seeds-"));
+    process.chdir(tempDir);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("builds Cosmos container names from model names", () => {
+    expect(getContainerNameForModel(createBasicModelInfo())).toBe("Todos");
+  });
+
+  it("normalizes seed identifiers across common naming styles", () => {
+    expect(normalizeSeedIdentifier("todo-items")).toBe("todoitems");
+    expect(normalizeSeedIdentifier("Todo_Items")).toBe("todoitems");
+    expect(normalizeSeedIdentifier("todoSchema")).toBe("todoschema");
+  });
+
+  it("wraps a single JSON object into a document array", () => {
+    expect(parseSeedDocuments('{"id":"todo-001","title":"Hello"}', "todo.json")).toEqual([
+      { id: "todo-001", title: "Hello" },
+    ]);
+  });
+
+  it("loads matching seed files for an environment", async () => {
+    const seedsDir = path.join(tempDir, "dev-seeds", "local");
+    fs.mkdirSync(seedsDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(seedsDir, "todo.json"),
+      JSON.stringify([{ id: "todo-001", title: "First task" }], null, 2),
+      "utf-8"
+    );
+    fs.writeFileSync(
+      path.join(seedsDir, "ignored.json"),
+      JSON.stringify([{ id: "ignored-001" }], null, 2),
+      "utf-8"
+    );
+
+    const loaded = await loadDevSeedFiles("local", [createBasicModelInfo()]);
+
+    expect(loaded).toHaveLength(1);
+    expect(loaded[0]).toMatchObject({
+      containerName: "Todos",
+      documents: [{ id: "todo-001", title: "First task" }],
+    });
+  });
+
+  it("rejects seed documents without ids", async () => {
+    const seedsDir = path.join(tempDir, "dev-seeds", "local");
+    fs.mkdirSync(seedsDir, { recursive: true });
+    fs.writeFileSync(path.join(seedsDir, "todo.json"), JSON.stringify([{ title: "Missing id" }], null, 2), "utf-8");
+
+    await expect(loadDevSeedFiles("local", [createBasicModelInfo()])).rejects.toThrow(/non-empty string id/);
+  });
+
+  it("builds nested template documents from related schemas", () => {
+    const category = createBasicModelInfo({
+      name: "Category",
+      displayName: "Category",
+      schemaName: "categorySchema",
+      filePath: "/models/category.ts",
+      fields: [
+        { name: "id", type: "string", isOptional: false, isArray: false },
+        { name: "name", type: "string", isOptional: false, isArray: false },
+      ],
+      hasCreatedAt: false,
+      hasUpdatedAt: false,
+    });
+    const todo = createBasicModelInfo({
+      fields: [
+        { name: "id", type: "string", isOptional: false, isArray: false },
+        { name: "title", type: "string", isOptional: false, isArray: false },
+        {
+          name: "category",
+          type: "object",
+          isOptional: true,
+          isArray: false,
+          isNestedSchema: true,
+          nestedModelName: "Category",
+          nestedSchemaName: "categorySchema",
+        },
+      ],
+    });
+
+    expect(buildSeedTemplateDocument(todo, [todo, category])).toEqual({
+      id: "todo-001",
+      title: "todo-title-sample",
+      category: {
+        id: "category-001",
+        name: "category-name-sample",
+      },
+    });
+  });
+});

package/src/__tests__/dev.test.ts

@@ -0,0 +1,148 @@
+import * as path from "path";
+import {
+  buildFunctionsStartArgs,
+  buildNextDevArgs,
+  buildDevCommand,
+  buildPythonFunctionsEnv,
+  DevOptions,
+  getPythonVirtualEnvPaths,
+} from "../cli/commands/dev";
+import { createProgram, normalizeDevCommandArgv } from "../cli/index";
+
+describe("dev command helpers", () => {
+  it("passes the requested port to Azure Functions Core Tools", () => {
+    expect(buildFunctionsStartArgs("7076")).toEqual(["start", "--port", "7076"]);
+  });
+
+  it("uses webpack mode for npm-based Next.js dev", () => {
+    expect(buildNextDevArgs("npm", "3012")).toEqual(["next", "dev", "--port", "3012", "--webpack"]);
+  });
+
+  it("uses pnpm exec for pnpm-based Next.js dev", () => {
+    expect(buildNextDevArgs("pnpm", "3012")).toEqual(["exec", "next", "dev", "--port", "3012", "--webpack"]);
+  });
+
+  it("builds Python virtual environment paths under functions/.venv", () => {
+    const functionsDir = path.join("C:\\repo", "functions");
+    const paths = getPythonVirtualEnvPaths(functionsDir);
+
+    expect(paths.venvDir).toBe(path.join(functionsDir, ".venv"));
+    expect(paths.binDir.endsWith(process.platform === "win32" ? path.join(".venv", "Scripts") : path.join(".venv", "bin"))).toBe(true);
+    expect(paths.pythonExecutable.endsWith(process.platform === "win32" ? path.join("Scripts", "python.exe") : path.join("bin", "python"))).toBe(true);
+  });
+
+  it("injects Python virtual environment settings for Functions", () => {
+    const functionsDir = path.join("C:\\repo", "functions");
+    const env = buildPythonFunctionsEnv({ PATH: "C:\\Windows\\System32" }, functionsDir);
+    const expectedBinDir = getPythonVirtualEnvPaths(functionsDir).binDir;
+
+    expect(env.VIRTUAL_ENV).toBe(path.join(functionsDir, ".venv"));
+    expect(env.languageWorkers__python__defaultExecutablePath).toBe(
+      getPythonVirtualEnvPaths(functionsDir).pythonExecutable
+    );
+    expect(env.PATH?.startsWith(`${expectedBinDir}${path.delimiter}`)).toBe(true);
+  });
+});
+
+describe("dev CLI parser", () => {
+  async function parseDevOptions(argv: string[]): Promise<DevOptions> {
+    let capturedOptions: DevOptions | undefined;
+    const logSpy = jest.spyOn(console, "log").mockImplementation(() => undefined);
+    const program = createProgram(buildDevCommand(async (options) => {
+      capturedOptions = options;
+    }, () => undefined));
+
+    program.exitOverride();
+
+    try {
+      await program.parseAsync(normalizeDevCommandArgv(argv));
+    } finally {
+      logSpy.mockRestore();
+    }
+
+    expect(capturedOptions).toBeDefined();
+    return capturedOptions!;
+  }
+
+  it("normalizes dev options placed before the subcommand", () => {
+    expect(
+      normalizeDevCommandArgv([
+        "node",
+        "swallowkit",
+        "--seed-env",
+        "local",
+        "--mock-connectors",
+        "dev",
+        "--port",
+        "3001",
+      ])
+    ).toEqual([
+      "node",
+      "swallowkit",
+      "dev",
+      "--seed-env",
+      "local",
+      "--mock-connectors",
+      "--port",
+      "3001",
+    ]);
+  });
+
+  it("keeps non-dev commands unchanged", () => {
+    const argv = ["node", "swallowkit", "create-model", "dev", "--connector", "external"];
+    expect(normalizeDevCommandArgv(argv)).toEqual(argv);
+  });
+
+  it("parses the same dev options regardless of whether they appear before or after the subcommand", async () => {
+    const expected = {
+      port: "3001",
+      functionsPort: "7072",
+      host: "127.0.0.1",
+      open: true,
+      verbose: true,
+      noFunctions: true,
+      seedEnv: "local",
+      mockConnectors: true,
+    };
+
+    const optionsAfterCommand = await parseDevOptions([
+      "node",
+      "swallowkit",
+      "dev",
+      "--port",
+      "3001",
+      "--functions-port",
+      "7072",
+      "--host",
+      "127.0.0.1",
+      "--open",
+      "--verbose",
+      "--no-functions",
+      "--seed-env",
+      "local",
+      "--mock-connectors",
+    ]);
+
+    const optionsBeforeCommand = await parseDevOptions([
+      "node",
+      "swallowkit",
+      "--verbose",
+      "--host",
+      "127.0.0.1",
+      "--seed-env",
+      "local",
+      "--mock-connectors",
+      "--no-functions",
+      "--port",
+      "3001",
+      "--functions-port",
+      "7072",
+      "--open",
+      "dev",
+    ]);
+
+    expect(optionsAfterCommand).toMatchObject(expected);
+    expect(optionsBeforeCommand).toMatchObject(expected);
+    expect(optionsBeforeCommand).toMatchObject(optionsAfterCommand);
+  });
+});

package/src/__tests__/fixtures.ts

@@ -0,0 +1,144 @@
+import { ModelInfo } from "../core/scaffold/model-parser";
+
+/**
+ * テスト用の基本的な ModelInfo フィクスチャ
+ */
+export function createBasicModelInfo(overrides?: Partial<ModelInfo>): ModelInfo {
+  return {
+    name: "Todo",
+    displayName: "Todo",
+    schemaName: "todoSchema",
+    filePath: "/models/todo.ts",
+    fields: [
+      { name: "id", type: "string", isOptional: false, isArray: false },
+      { name: "title", type: "string", isOptional: false, isArray: false },
+      { name: "description", type: "string", isOptional: true, isArray: false },
+      { name: "completed", type: "boolean", isOptional: false, isArray: false },
+      { name: "createdAt", type: "string", isOptional: false, isArray: false },
+      { name: "updatedAt", type: "string", isOptional: false, isArray: false },
+    ],
+    hasId: true,
+    hasCreatedAt: true,
+    hasUpdatedAt: true,
+    nestedSchemaRefs: [],
+    partitionKey: '/id',
+    ...overrides,
+  };
+}
+
+/**
+ * RDB コネクタ (read-only) 付きの ModelInfo フィクスチャ
+ */
+export function createRdbConnectorModelInfo(overrides?: Partial<ModelInfo>): ModelInfo {
+  return createBasicModelInfo({
+    name: "User",
+    displayName: "User",
+    schemaName: "userSchema",
+    filePath: "/models/user.ts",
+    fields: [
+      { name: "id", type: "string", isOptional: false, isArray: false },
+      { name: "employeeCode", type: "string", isOptional: false, isArray: false },
+      { name: "name", type: "string", isOptional: false, isArray: false },
+      { name: "email", type: "string", isOptional: false, isArray: false },
+      { name: "department", type: "string", isOptional: true, isArray: false },
+      { name: "createdAt", type: "string", isOptional: true, isArray: false },
+      { name: "updatedAt", type: "string", isOptional: true, isArray: false },
+    ],
+    connectorConfig: {
+      connector: "mysql",
+      operations: ["getAll", "getById"],
+      table: "users",
+      idColumn: "id",
+    },
+    ...overrides,
+  });
+}
+
+/**
+ * API コネクタ (read-write) 付きの ModelInfo フィクスチャ
+ */
+export function createApiConnectorModelInfo(overrides?: Partial<ModelInfo>): ModelInfo {
+  return createBasicModelInfo({
+    name: "BacklogIssue",
+    displayName: "BacklogIssue",
+    schemaName: "backlogIssueSchema",
+    filePath: "/models/backlog-issue.ts",
+    fields: [
+      { name: "id", type: "string", isOptional: false, isArray: false },
+      { name: "projectId", type: "string", isOptional: false, isArray: false },
+      { name: "issueKey", type: "string", isOptional: false, isArray: false },
+      { name: "summary", type: "string", isOptional: false, isArray: false },
+      { name: "description", type: "string", isOptional: true, isArray: false },
+      { name: "createdAt", type: "string", isOptional: true, isArray: false },
+      { name: "updatedAt", type: "string", isOptional: true, isArray: false },
+    ],
+    connectorConfig: {
+      connector: "backlog",
+      operations: ["getAll", "getById", "create", "update"],
+      endpoints: {
+        getAll: "GET /issues",
+        getById: "GET /issues/{id}",
+        create: "POST /issues",
+        update: "PATCH /issues/{id}",
+      },
+    },
+    ...overrides,
+  });
+}
+
+/**
+ * 外部キーを含む ModelInfo フィクスチャ
+ */
+export function createModelInfoWithForeignKey(): ModelInfo {
+  return createBasicModelInfo({
+    name: "Task",
+    displayName: "Task",
+    schemaName: "taskSchema",
+    filePath: "/models/task.ts",
+    fields: [
+      { name: "id", type: "string", isOptional: false, isArray: false },
+      { name: "title", type: "string", isOptional: false, isArray: false },
+      {
+        name: "categoryId",
+        type: "string",
+        isOptional: false,
+        isArray: false,
+        isForeignKey: true,
+        referencedModel: "Category",
+      },
+      { name: "createdAt", type: "string", isOptional: false, isArray: false },
+      { name: "updatedAt", type: "string", isOptional: false, isArray: false },
+    ],
+  });
+}
+
+/**
+ * enum フィールドを含む ModelInfo フィクスチャ
+ */
+export function createModelInfoWithEnum(): ModelInfo {
+  return createBasicModelInfo({
+    name: "Issue",
+    displayName: "Issue",
+    schemaName: "issueSchema",
+    filePath: "/models/issue.ts",
+    fields: [
+      { name: "id", type: "string", isOptional: false, isArray: false },
+      { name: "title", type: "string", isOptional: false, isArray: false },
+      {
+        name: "status",
+        type: "string",
+        isOptional: false,
+        isArray: false,
+        enumValues: ["open", "in_progress", "closed"],
+      },
+      {
+        name: "priority",
+        type: "number",
+        isOptional: true,
+        isArray: false,
+      },
+      { name: "createdAt", type: "string", isOptional: false, isArray: false },
+      { name: "updatedAt", type: "string", isOptional: false, isArray: false },
+    ],
+  });
+}

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

@@ -0,0 +1,237 @@
+import {
+  generateCSharpAzureFunctionsCRUD,
+  generateCompactAzureFunctionsCRUD,
+  generatePythonAzureFunctionsCRUD,
+} from "../core/scaffold/functions-generator";
+import { createBasicModelInfo, createModelInfoWithEnum } from "./fixtures";
+
+describe("generateCompactAzureFunctionsCRUD", () => {
+  it("generates correct CRUD code for a basic model", () => {
+    const model = createBasicModelInfo();
+    const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+    expect(code).toMatchSnapshot();
+  });
+
+  it("generates correct CRUD code for a model with enum fields", () => {
+    const model = createModelInfoWithEnum();
+    const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+    expect(code).toMatchSnapshot();
+  });
+
+  it("imports the correct schema from shared package", () => {
+    const model = createBasicModelInfo();
+    const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+    expect(code).toContain("import { todoSchema } from '@myapp/shared'");
+  });
+
+  it("uses correct container name (PascalCase + s)", () => {
+    const model = createBasicModelInfo();
+    const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+    expect(code).toContain("const containerName = 'Todos'");
+  });
+
+  it("registers correct route names (camelCase)", () => {
+    const model = createBasicModelInfo();
+    const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+    expect(code).toContain("'todo-get-all'");
+    expect(code).toContain("'todo-get-by-id'");
+    expect(code).toContain("'todo-create'");
+    expect(code).toContain("'todo-update'");
+    expect(code).toContain("'todo-delete'");
+  });
+
+  it("generates all CRUD HTTP methods", () => {
+    const model = createBasicModelInfo();
+    const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+    expect(code).toContain("methods: ['GET']");
+    expect(code).toContain("methods: ['POST']");
+    expect(code).toContain("methods: ['PUT']");
+    expect(code).toContain("methods: ['DELETE']");
+  });
+
+  it("uses correct route patterns", () => {
+    const model = createBasicModelInfo();
+    const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+    expect(code).toContain("route: 'todo'");
+    expect(code).toContain("route: 'todo/{id}'");
+  });
+
+  it("handles multi-word model names correctly", () => {
+    const model = createBasicModelInfo({
+      name: "TodoItem",
+      schemaName: "todoItemSchema",
+    });
+    const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+    expect(code).toContain("const containerName = 'TodoItems'");
+    expect(code).toContain("route: 'todoItem'");
+    expect(code).toContain("'todoItem-get-all'");
+  });
+
+  it("generates C# Cosmos-backed CRUD handlers", () => {
+    const model = createBasicModelInfo();
+    const code = generateCSharpAzureFunctionsCRUD(model);
+    expect(code).toContain("public sealed class TodoFunctions");
+    expect(code).toContain('[Function("todoGetAll")]');
+    expect(code).toContain('Route = "todo/{id}"');
+    expect(code).toContain("CreateCosmosClient()");
+    expect(code).toContain('new CosmosClientOptions { ConnectionMode = ConnectionMode.Gateway }');
+    expect(code).toContain('endpoint.Contains("localhost:8081", StringComparison.OrdinalIgnoreCase)');
+    expect(code).toContain("container.ReadItemStreamAsync");
+    expect(code).toContain("JsonNode.Parse(document.RootElement.GetRawText())?.AsObject()");
+    expect(code).toContain("container.CreateItemStreamAsync");
+    expect(code).toContain("container.ReplaceItemStreamAsync");
+    expect(code).toContain("payload.ToJsonString()");
+    expect(code).toContain("container.DeleteItemAsync<JsonObject>");
+  });
+
+  it("generates Python Cosmos-backed CRUD handlers", () => {
+    const model = createBasicModelInfo();
+    const generated = generatePythonAzureFunctionsCRUD(model);
+    expect(generated.registration).toContain("from blueprints.todo import bp as todo_bp");
+    expect(generated.registration).toContain("app.register_blueprint(todo_bp)");
+    expect(generated.blueprint).toContain('@bp.route(route="todo", methods=["GET"])');
+    expect(generated.blueprint).toContain("def todo_create");
+    expect(generated.blueprint).toContain("from azure.cosmos import CosmosClient, exceptions");
+    expect(generated.blueprint).toContain("container.query_items");
+    expect(generated.blueprint).toContain("container.read_item");
+    expect(generated.blueprint).toContain("container.create_item");
+    expect(generated.blueprint).toContain("container.replace_item");
+    expect(generated.blueprint).toContain("container.delete_item");
+  });
+
+  // --- Custom Partition Key Tests ---
+
+  describe("custom partition key (TS)", () => {
+    it("uses input binding when partitionKey is /id (default)", () => {
+      const model = createBasicModelInfo({ partitionKey: "/id" });
+      const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+      expect(code).toContain("partitionKey: '{id}'");
+      expect(code).toContain("container.item(id, id).delete()");
+    });
+
+    it("uses SDK direct call when partitionKey is not /id", () => {
+      const model = createBasicModelInfo({
+        partitionKey: "/tenantId",
+        fields: [
+          { name: "id", type: "string", isOptional: false, isArray: false },
+          { name: "tenantId", type: "string", isOptional: false, isArray: false },
+          { name: "title", type: "string", isOptional: false, isArray: false },
+          { name: "createdAt", type: "string", isOptional: false, isArray: false },
+          { name: "updatedAt", type: "string", isOptional: false, isArray: false },
+        ],
+      });
+      const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+
+      // Should NOT have input binding with partitionKey
+      expect(code).not.toContain("partitionKey: '{id}'");
+      // getById should use SDK query
+      expect(code).toContain("custom partition key");
+      expect(code).toContain("SELECT * FROM c WHERE c.id = @id");
+      // delete should read doc first to get PK value
+      expect(code).toContain("resources[0].tenantId");
+      expect(code).toContain("container.item(id, pkValue).delete()");
+    });
+
+    it("generates snapshot for custom partition key TS", () => {
+      const model = createBasicModelInfo({
+        partitionKey: "/tenantId",
+        fields: [
+          { name: "id", type: "string", isOptional: false, isArray: false },
+          { name: "tenantId", type: "string", isOptional: false, isArray: false },
+          { name: "title", type: "string", isOptional: false, isArray: false },
+          { name: "createdAt", type: "string", isOptional: false, isArray: false },
+          { name: "updatedAt", type: "string", isOptional: false, isArray: false },
+        ],
+      });
+      const code = generateCompactAzureFunctionsCRUD(model, "@myapp/shared");
+      expect(code).toMatchSnapshot();
+    });
+  });
+
+  describe("custom partition key (C#)", () => {
+    it("uses ReadItemStreamAsync when partitionKey is /id", () => {
+      const model = createBasicModelInfo({ partitionKey: "/id" });
+      const code = generateCSharpAzureFunctionsCRUD(model);
+      expect(code).toContain("ReadItemStreamAsync(id, new PartitionKey(id))");
+      expect(code).toContain("DeleteItemAsync<JsonObject>(id, new PartitionKey(id))");
+    });
+
+    it("uses query when partitionKey is not /id", () => {
+      const model = createBasicModelInfo({
+        partitionKey: "/tenantId",
+        fields: [
+          { name: "id", type: "string", isOptional: false, isArray: false },
+          { name: "tenantId", type: "string", isOptional: false, isArray: false },
+          { name: "title", type: "string", isOptional: false, isArray: false },
+          { name: "createdAt", type: "string", isOptional: false, isArray: false },
+          { name: "updatedAt", type: "string", isOptional: false, isArray: false },
+        ],
+      });
+      const code = generateCSharpAzureFunctionsCRUD(model);
+      // ReadCosmosItemAsync should use query instead of point read
+      expect(code).toContain("GetItemQueryStreamIterator(query)");
+      expect(code).not.toContain("ReadItemStreamAsync(id, new PartitionKey(id))");
+      // Delete should read doc first for PK value
+      expect(code).toContain('existing["tenantId"]');
+    });
+
+    it("generates snapshot for custom partition key C#", () => {
+      const model = createBasicModelInfo({
+        partitionKey: "/tenantId",
+        fields: [
+          { name: "id", type: "string", isOptional: false, isArray: false },
+          { name: "tenantId", type: "string", isOptional: false, isArray: false },
+          { name: "title", type: "string", isOptional: false, isArray: false },
+          { name: "createdAt", type: "string", isOptional: false, isArray: false },
+          { name: "updatedAt", type: "string", isOptional: false, isArray: false },
+        ],
+      });
+      const code = generateCSharpAzureFunctionsCRUD(model);
+      expect(code).toMatchSnapshot();
+    });
+  });
+
+  describe("custom partition key (Python)", () => {
+    it("uses read_item with partition_key=item_id when partitionKey is /id", () => {
+      const model = createBasicModelInfo({ partitionKey: "/id" });
+      const generated = generatePythonAzureFunctionsCRUD(model);
+      expect(generated.blueprint).toContain("partition_key=item_id");
+    });
+
+    it("uses cross-partition query when partitionKey is not /id", () => {
+      const model = createBasicModelInfo({
+        partitionKey: "/tenantId",
+        fields: [
+          { name: "id", type: "string", isOptional: false, isArray: false },
+          { name: "tenantId", type: "string", isOptional: false, isArray: false },
+          { name: "title", type: "string", isOptional: false, isArray: false },
+          { name: "createdAt", type: "string", isOptional: false, isArray: false },
+          { name: "updatedAt", type: "string", isOptional: false, isArray: false },
+        ],
+      });
+      const generated = generatePythonAzureFunctionsCRUD(model);
+      // Should not use direct read_item with partition_key=item_id
+      expect(generated.blueprint).not.toContain("partition_key=item_id");
+      // Should use cross-partition query
+      expect(generated.blueprint).toContain("enable_cross_partition_query=True");
+      expect(generated.blueprint).toContain('SELECT * FROM c WHERE c.id = @id');
+      // Delete should get PK value from document
+      expect(generated.blueprint).toContain('.get("tenantId")');
+    });
+
+    it("generates snapshot for custom partition key Python", () => {
+      const model = createBasicModelInfo({
+        partitionKey: "/tenantId",
+        fields: [
+          { name: "id", type: "string", isOptional: false, isArray: false },
+          { name: "tenantId", type: "string", isOptional: false, isArray: false },
+          { name: "title", type: "string", isOptional: false, isArray: false },
+          { name: "createdAt", type: "string", isOptional: false, isArray: false },
+          { name: "updatedAt", type: "string", isOptional: false, isArray: false },
+        ],
+      });
+      const generated = generatePythonAzureFunctionsCRUD(model);
+      expect(generated.blueprint).toMatchSnapshot();
+    });
+  });
+});