swallowkit 1.0.0-beta.15 → 1.0.0-beta.17

package/src/__tests__/auth.test.ts

@@ -9,7 +9,7 @@ import {
   generateBFFAuthLoginRoute,
   generateBFFAuthLogoutRoute,
   generateBFFAuthMeRoute,
-  generateMiddleware,
+  generateProxy,
   generateLoginPage,
   generateAuthContext,
   generateBFFCallFunctionWithAuth,
@@ -230,49 +230,49 @@ describe("generateBFFAuthMeRoute", () => {
 });
 
 // ============================================================
-// auth-generator: Middleware
+// auth-generator: Proxy (formerly Middleware)
 // ============================================================
-describe("generateMiddleware", () => {
+describe("generateProxy", () => {
   it("checks for auth cookie", () => {
-    const code = generateMiddleware("test-project");
+    const code = generateProxy("test-project");
     expect(code).toContain("test-project-auth-token");
     expect(code).toContain("cookies.get");
   });
 
   it("redirects to /login for unauthenticated page requests", () => {
-    const code = generateMiddleware("test-project");
+    const code = generateProxy("test-project");
     expect(code).toContain("/login");
     expect(code).toContain("redirect");
   });
 
   it("returns 401 for unauthenticated API requests", () => {
-    const code = generateMiddleware("test-project");
+    const code = generateProxy("test-project");
     expect(code).toContain("401");
     expect(code).toContain("Unauthorized");
   });
 
   it("injects Authorization header from cookie", () => {
-    const code = generateMiddleware("test-project");
+    const code = generateProxy("test-project");
     expect(code).toContain("Authorization");
     expect(code).toContain("Bearer");
   });
 
   it("skips public paths", () => {
-    const code = generateMiddleware("test-project");
+    const code = generateProxy("test-project");
     expect(code).toContain("/login");
     expect(code).toContain("/api/auth/login");
   });
 
   it("checks JWT expiry (base64 decode, no signature verification)", () => {
-    const code = generateMiddleware("test-project");
+    const code = generateProxy("test-project");
     expect(code).toContain("atob");
     expect(code).toContain("exp");
   });
 
-  it("exports matcher config", () => {
-    const code = generateMiddleware("test-project");
-    expect(code).toContain("export const config");
-    expect(code).toContain("matcher");
+  it("exports proxy function instead of middleware", () => {
+    const code = generateProxy("test-project");
+    expect(code).toContain("export function proxy");
+    expect(code).not.toContain("export function middleware");
   });
 });
 

package/src/__tests__/fixtures.ts

@@ -21,6 +21,7 @@ export function createBasicModelInfo(overrides?: Partial<ModelInfo>): ModelInfo
     hasCreatedAt: true,
     hasUpdatedAt: true,
     nestedSchemaRefs: [],
+    partitionKey: '/id',
     ...overrides,
   };
 }

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

@@ -98,4 +98,140 @@ describe("generateCompactAzureFunctionsCRUD", () => {
     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();
+    });
+  });
 });

package/src/__tests__/model-parser.test.ts

@@ -0,0 +1,72 @@
+import { parsePartitionKey } from "../core/scaffold/model-parser";
+
+describe("parsePartitionKey", () => {
+  it("returns default '/id' when no partitionKey export exists", () => {
+    const content = `
+import { z } from 'zod/v4';
+
+export const Todo = z.object({
+  id: z.string(),
+  title: z.string(),
+});
+export type Todo = z.infer<typeof Todo>;
+`;
+    expect(parsePartitionKey(content)).toBe("/id");
+  });
+
+  it("extracts explicit partitionKey with single quotes", () => {
+    const content = `
+import { z } from 'zod/v4';
+
+export const Order = z.object({
+  id: z.string(),
+  tenantId: z.string(),
+  items: z.array(z.string()),
+});
+export type Order = z.infer<typeof Order>;
+export const partitionKey = '/tenantId';
+`;
+    expect(parsePartitionKey(content)).toBe("/tenantId");
+  });
+
+  it("extracts explicit partitionKey with double quotes", () => {
+    const content = `
+export const User = z.object({ id: z.string(), email: z.string() });
+export const partitionKey = "/email";
+`;
+    expect(parsePartitionKey(content)).toBe("/email");
+  });
+
+  it("extracts /id as explicit partitionKey", () => {
+    const content = `
+export const Todo = z.object({ id: z.string() });
+export const partitionKey = '/id';
+`;
+    expect(parsePartitionKey(content)).toBe("/id");
+  });
+
+  it("handles nested/hierarchical partition key paths", () => {
+    const content = `
+export const partitionKey = '/address/city';
+`;
+    expect(parsePartitionKey(content)).toBe("/address/city");
+  });
+
+  it("ignores commented-out partitionKey", () => {
+    const content = `
+// export const partitionKey = '/tenantId';
+export const Todo = z.object({ id: z.string() });
+`;
+    // The regex matches inside comments too — this is acceptable since
+    // the pattern follows the same approach as parseConnectorConfig/parseAuthPolicy
+    // In practice, commented-out exports are rare in model files
+    expect(parsePartitionKey(content)).toBe("/tenantId");
+  });
+
+  it("handles extra spaces around equals sign", () => {
+    const content = `
+export const partitionKey   =   '/customerId';
+`;
+    expect(parsePartitionKey(content)).toBe("/customerId");
+  });
+});

package/src/cli/commands/add-auth.ts

@@ -18,7 +18,7 @@ import {
   generateBFFAuthLoginRoute,
   generateBFFAuthLogoutRoute,
   generateBFFAuthMeRoute,
-  generateMiddleware,
+  generateProxy,
   generateLoginPage,
   generateAuthContext,
   generateBFFCallFunctionWithAuth,
@@ -76,6 +76,9 @@ export async function addAuthCommand(options: AddAuthOptions) {
   fs.writeFileSync(authModelPath, generateAuthModels(), "utf-8");
   console.log(` Created: shared/models/auth.ts`);
 
+  // Ensure shared package has build infrastructure (tsconfig, build script)
+  ensureSharedBuildInfrastructure(cwd);
+
   // Update shared/index.ts to re-export auth
   updateSharedIndex(cwd);
 
@@ -91,11 +94,11 @@ export async function addAuthCommand(options: AddAuthOptions) {
   console.log("\n Generating BFF auth routes...");
   generateBFFAuth(cwd, projectName, sharedPackageName);
 
-  // 4. Generate middleware
-  console.log("\n  Generating middleware...");
-  const middlewarePath = path.join(cwd, "middleware.ts");
-  fs.writeFileSync(middlewarePath, generateMiddleware(projectName), "utf-8");
-  console.log(` Created: middleware.ts`);
+  // 4. Generate proxy
+  console.log("\n  Generating proxy...");
+  const proxyPath = path.join(cwd, "proxy.ts");
+  fs.writeFileSync(proxyPath, generateProxy(projectName), "utf-8");
+  console.log(` Created: proxy.ts`);
 
   // 5. Generate login page
   console.log("\n Generating login page...");
@@ -143,6 +146,73 @@ export async function addAuthCommand(options: AddAuthOptions) {
   console.log(`  5. Run scaffold to regenerate functions with auth guards`);
 }
 
+/**
+ * Ensure the shared package has proper build infrastructure
+ * (tsconfig.json, build script, typescript devDependency).
+ * Required for `dev` command which runs `npm run --workspace=shared build`.
+ */
+function ensureSharedBuildInfrastructure(cwd: string): void {
+  const sharedDir = path.join(cwd, "shared");
+  const pkgPath = path.join(sharedDir, "package.json");
+  if (!fs.existsSync(pkgPath)) return;
+
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+  let updated = false;
+
+  // Ensure scripts.build exists
+  if (!pkg.scripts?.build) {
+    if (!pkg.scripts) pkg.scripts = {};
+    pkg.scripts.build = "tsc";
+    pkg.scripts.watch = "tsc --watch";
+    updated = true;
+  }
+
+  // Ensure main points to compiled output
+  if (!pkg.main || pkg.main === "index.ts") {
+    pkg.main = "dist/index.js";
+    pkg.types = "dist/index.d.ts";
+    updated = true;
+  }
+
+  // Ensure typescript devDependency
+  if (!pkg.devDependencies?.typescript) {
+    if (!pkg.devDependencies) pkg.devDependencies = {};
+    pkg.devDependencies.typescript = "^5.0.0";
+    updated = true;
+  }
+
+  if (updated) {
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2), "utf-8");
+    console.log(` Updated: shared/package.json (added build infrastructure)`);
+  }
+
+  // Ensure tsconfig.json exists
+  const tsconfigPath = path.join(sharedDir, "tsconfig.json");
+  if (!fs.existsSync(tsconfigPath)) {
+    const tsconfig = {
+      compilerOptions: {
+        target: "ES2020",
+        module: "commonjs",
+        moduleResolution: "node",
+        lib: ["ES2020"],
+        outDir: "dist",
+        rootDir: ".",
+        declaration: true,
+        declarationMap: true,
+        sourceMap: true,
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+      },
+      include: ["index.ts", "models/**/*"],
+      exclude: ["node_modules", "dist"],
+    };
+    fs.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2), "utf-8");
+    console.log(` Created: shared/tsconfig.json`);
+  }
+}
+
 function updateSharedIndex(cwd: string): void {
   const indexPath = path.join(cwd, "shared", "index.ts");
   if (fs.existsSync(indexPath)) {
@@ -226,6 +296,25 @@ function generateFunctionsAuth(
 
     // __init__.py
     fs.writeFileSync(path.join(authDir, "__init__.py"), "", "utf-8");
+
+    // Register auth blueprint in function_app.py
+    const functionAppPath = path.join(functionsDir, "function_app.py");
+    if (fs.existsSync(functionAppPath)) {
+      const content = fs.readFileSync(functionAppPath, "utf-8");
+      const authImport = "from blueprints.auth import bp as auth_bp";
+      const authRegister = "app.register_blueprint(auth_bp)";
+      if (!content.includes(authImport)) {
+        const marker = "# SwallowKit scaffold registrations";
+        if (content.includes(marker)) {
+          const updated = content.replace(
+            marker,
+            `${authImport}\n${authRegister}\n${marker}`
+          );
+          fs.writeFileSync(functionAppPath, updated, "utf-8");
+          console.log(` Updated: functions/function_app.py (registered auth blueprint)`);
+        }
+      }
+    }
   }
 }
 

package/src/cli/commands/create-model.ts

@@ -45,7 +45,7 @@ export const displayName = '${pascalName}';
 function generateConnectorModelTemplate(modelName: string, connectorName: string, connectorType: 'rdb' | 'api'): string {
   const pascalName = toPascalCase(modelName);
   const kebabName = modelName.toLowerCase().replace(/[^a-z0-9]+/g, '-');
-  const pluralName = kebabName + 's';
+  const pluralName = kebabName.endsWith('s') ? kebabName : kebabName + 's';
 
   const schema = `import { z } from 'zod/v4';
 

package/src/cli/commands/dev-seeds.ts

@@ -30,7 +30,7 @@ interface LoadedSeedFile {
 }
 
 export function getContainerNameForModel(model: Pick<ModelInfo, "name">): string {
-  return `${model.name}s`;
+  return model.name.endsWith('s') ? model.name : `${model.name}s`;
 }
 
 export function getSeedEnvironmentDir(environment: string, seedsDir: string = "dev-seeds"): string {
@@ -135,7 +135,7 @@ export async function applyDevSeedEnvironment({
   console.log(`🧪 Applying Cosmos DB seed data for environment "${environment}"...`);
 
   for (const seedFile of seedFiles) {
-    await recreateContainer(database, seedFile.containerName);
+    await recreateContainer(database, seedFile.containerName, seedFile.model.partitionKey);
     const container = database.container(seedFile.containerName);
 
     for (const document of seedFile.documents) {
@@ -326,7 +326,7 @@ function validateSeedDocuments(documents: SeedDocument[], filePath: string): voi
   });
 }
 
-async function recreateContainer(database: Database, containerName: string): Promise<void> {
+async function recreateContainer(database: Database, containerName: string, partitionKeyPath: string = '/id'): Promise<void> {
   try {
     await database.container(containerName).delete();
   } catch (error: any) {
@@ -339,7 +339,7 @@ async function recreateContainer(database: Database, containerName: string): Pro
     await database.containers.createIfNotExists({
       id: containerName,
       partitionKey: {
-        paths: ["/id"],
+        paths: [partitionKeyPath],
         kind: PartitionKeyKind.Hash,
         version: 2,
       },
@@ -351,7 +351,7 @@ async function recreateContainer(database: Database, containerName: string): Pro
     await database.containers.createIfNotExists({
       id: containerName,
       partitionKey: {
-        paths: ["/id"],
+        paths: [partitionKeyPath],
       },
     });
   }

package/src/cli/commands/dev.ts

@@ -395,11 +395,11 @@ async function initializeCosmosDB(databaseName: string): Promise<CosmosInitializ
       let containerCreated = false;
       
       try {
-        console.log(`🔧 Creating container "${containerName}" with partition key /id...`);
+        console.log(`🔧 Creating container "${containerName}" with partition key ${model.partitionKey}...`);
         const containerResponse = await database.containers.createIfNotExists({
           id: containerName,
           partitionKey: {
-            paths: ['/id'],
+            paths: [model.partitionKey],
             kind: PartitionKeyKind.Hash,
             version: 2
           }
@@ -418,7 +418,7 @@ async function initializeCosmosDB(databaseName: string): Promise<CosmosInitializ
           const containerResponse = await database.containers.createIfNotExists({
             id: containerName,
             partitionKey: {
-              paths: ['/id']
+              paths: [model.partitionKey]
             }
           });
           console.log(`✅ Container "${containerName}" ready (status: ${containerResponse.statusCode})`);
@@ -458,10 +458,28 @@ async function startDevEnvironment(options: DevOptions) {
   const processes: ChildProcess[] = [];
   let functionsEnv: NodeJS.ProcessEnv = process.env;
   let mockServer: ConnectorMockServer | null = null;
+  let envLocalPath = '';
+  let envLocalDefaultUrl = ''; // default Functions URL to restore on shutdown
 
   // Cleanup processes on Ctrl+C
   process.on('SIGINT', async () => {
     console.log('\n🛑 Stopping development servers...');
+    // Restore .env.local to default Functions port on shutdown
+    if (envLocalPath && envLocalDefaultUrl) {
+      try {
+        if (fs.existsSync(envLocalPath)) {
+          const content = fs.readFileSync(envLocalPath, 'utf-8');
+          if (content.includes('BACKEND_FUNCTIONS_BASE_URL=') &&
+              !content.includes(`BACKEND_FUNCTIONS_BASE_URL=${envLocalDefaultUrl}`)) {
+            const restored = content.replace(
+              /^BACKEND_FUNCTIONS_BASE_URL=.*/m,
+              `BACKEND_FUNCTIONS_BASE_URL=${envLocalDefaultUrl}`
+            );
+            fs.writeFileSync(envLocalPath, restored, 'utf-8');
+          }
+        }
+      } catch { /* ignore */ }
+    }
     if (mockServer) {
       await mockServer.stop();
     }
@@ -604,28 +622,34 @@ async function startDevEnvironment(options: DevOptions) {
     if (hasFunctions && !options.noFunctions) {
       // Build shared package before starting Functions
       const sharedDir = path.join(process.cwd(), 'shared');
-      if (fs.existsSync(sharedDir) && fs.existsSync(path.join(sharedDir, 'package.json'))) {
-        console.log('📦 Building shared package...');
-        const filterArgs = pm === 'pnpm'
-          ? ['run', '--filter', 'shared', 'build']
-          : ['run', '--workspace=shared', 'build'];
-        const sharedBuild = spawn(pm, filterArgs, {
-          cwd: process.cwd(),
-          shell: true,
-          stdio: 'inherit',
-        });
+      const sharedPkgPath = path.join(sharedDir, 'package.json');
+      if (fs.existsSync(sharedDir) && fs.existsSync(sharedPkgPath)) {
+        const sharedPkg = JSON.parse(fs.readFileSync(sharedPkgPath, 'utf-8'));
+        if (sharedPkg.scripts?.build) {
+          console.log('📦 Building shared package...');
+          const filterArgs = pm === 'pnpm'
+            ? ['run', '--filter', 'shared', 'build']
+            : ['run', '--workspace=shared', 'build'];
+          const sharedBuild = spawn(pm, filterArgs, {
+            cwd: process.cwd(),
+            shell: true,
+            stdio: 'inherit',
+          });
 
-        await new Promise<void>((resolve, reject) => {
-          sharedBuild.on('close', (code) => {
-            if (code === 0) {
-              console.log('✅ Shared package built successfully');
-              resolve();
-            } else {
-              reject(new Error(`Shared package build failed with code ${code}`));
-            }
+          await new Promise<void>((resolve, reject) => {
+            sharedBuild.on('close', (code) => {
+              if (code === 0) {
+                console.log('✅ Shared package built successfully');
+                resolve();
+              } else {
+                reject(new Error(`Shared package build failed with code ${code}`));
+              }
+            });
+            sharedBuild.on('error', reject);
           });
-          sharedBuild.on('error', reject);
-        });
+        } else {
+          console.log('⚠️  Shared package has no build script — skipping build. Run "swallowkit add-auth" to fix.');
+        }
       }
 
       // Azure Functions を起動
@@ -783,6 +807,26 @@ async function startDevEnvironment(options: DevOptions) {
       }, 3000);
     }
 
+    // Ensure .env.local points to bffTargetPort so Next.js reads the correct backend URL.
+    // When --mock-connectors is active, bffTargetPort = mock port (7072); otherwise = Functions port (7071).
+    // Next.js may load .env.local values that override spawn env vars, so we must keep them in sync.
+    envLocalPath = path.join(process.cwd(), '.env.local');
+    envLocalDefaultUrl = `http://${options.host || 'localhost'}:${functionsPort}`;
+    const bffTargetUrl = `http://${options.host || 'localhost'}:${bffTargetPort}`;
+    try {
+      if (fs.existsSync(envLocalPath)) {
+        const envContent = fs.readFileSync(envLocalPath, 'utf-8');
+        if (envContent.includes('BACKEND_FUNCTIONS_BASE_URL=') &&
+            !envContent.includes(`BACKEND_FUNCTIONS_BASE_URL=${bffTargetUrl}`)) {
+          const updated = envContent.replace(
+            /^BACKEND_FUNCTIONS_BASE_URL=.*/m,
+            `BACKEND_FUNCTIONS_BASE_URL=${bffTargetUrl}`
+          );
+          fs.writeFileSync(envLocalPath, updated, 'utf-8');
+        }
+      }
+    } catch { /* ignore */ }
+
     const nextEnv: NodeJS.ProcessEnv = {
       ...process.env,
       BACKEND_FUNCTIONS_BASE_URL: `http://${options.host || 'localhost'}:${bffTargetPort}`,

package/src/cli/commands/init.ts

@@ -1781,7 +1781,7 @@ app.http('{model}-get-all', {
 | UI page directory | \`app/{kebab-case}/\` | \`app/todo/page.tsx\` |
 | React component | PascalCase | \`TodoForm.tsx\` |
 | Cosmos DB container | PascalCase + 's' | \`Todos\` |
-| Cosmos DB partition key | \`/id\` | Always \`/id\` |
+| Cosmos DB partition key | \`/id\` (default) | Custom: \`export const partitionKey = '/field'\` |
 | Bicep container file | \`infra/containers/{kebab-case}-container.bicep\` | \`infra/containers/todo-container.bicep\` |
 
 ## Adding New Models (SwallowKit CLI Skills)
@@ -1842,7 +1842,7 @@ Deploys Bicep infrastructure: Static Web Apps, Functions, Cosmos DB, Storage, Ma
 - **Do not** manually duplicate model definitions across layers. Use the shared package.
 - **Do not** manually create CRUD boilerplate. Use \`swallowkit scaffold\`.
 - **Do not** hardcode Cosmos DB connection strings. Use Managed Identity (\`CosmosDBConnection__accountEndpoint\`) in production and emulator settings locally.
-- **Do not** change the partition key strategy. All containers use \`/id\` as the partition key.
+- By default, all containers use \`/id\` as the partition key. To use a custom partition key, add \`export const partitionKey = '/yourField'\` to the model file. The scaffold command will apply it across all layers.
 
 ## Technology Stack
 
@@ -1920,7 +1920,7 @@ Frontend (Next.js App Router) → BFF (Next.js API Routes) → Backend (Azure Fu
 
 - Schema/type: PascalCase, same name for both (\`export const Todo = z.object({...}); export type Todo = z.infer<typeof Todo>;\`)
 - Files: kebab-case (\`shared/models/todo.ts\`, backend handlers under \`functions/\`)
-- Cosmos DB containers: PascalCase + 's' (\`Todos\`), partition key always \`/id\`
+- Cosmos DB containers: PascalCase + 's' (\`Todos\`), partition key default \`/id\` (customizable via \`export const partitionKey\`)
 
 ## Managed Fields
 
@@ -2017,7 +2017,7 @@ Files in \`functions/\` contain all business logic and data access for this appl
 - For TypeScript backends, use Cosmos DB **input/output bindings** (\`extraInputs\`/\`extraOutputs\`) for reads and writes.
 - For C#/Python backends, consume the generated OpenAPI-derived assets in \`functions/generated/\`.
 - Auto-generate \`id\` (UUID), \`createdAt\`, and \`updatedAt\` on the backend. Never trust client-sent values.
-- Container names are PascalCase + 's' (e.g., \`Todos\`). Partition key is always \`/id\`.
+- Container names are PascalCase + 's' (e.g., \`Todos\`). Partition key defaults to \`/id\` but can be customized per model.
 
 ## Handler Pattern