swallowkit 1.0.0-beta.55 → 1.0.0-beta.57

package/src/core/scaffold/native-schema-generator.ts

@@ -1,7 +1,9 @@
 import * as fs from "fs";
+import * as os from "os";
 import * as path from "path";
 import { spawn, spawnSync } from "child_process";
 import { BackendLanguage } from "../../types";
+import { FileOperationSession } from "../operations/file-session";
 import { ModelInfo, toKebabCase } from "./model-parser";
 import { generateOpenApiDocument } from "./openapi-generator";
 import {
@@ -621,23 +623,47 @@ function mergePythonInitSource(existingSource: string | undefined, generatedSour
   return `${normalizedExisting}${missingLines.join("\n")}\n`;
 }
 
-function writeMergedPythonInitFile(filePath: string, generatedSource: string): void {
-  const existingSource = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf-8") : undefined;
-  fs.writeFileSync(filePath, mergePythonInitSource(existingSource, generatedSource), "utf-8");
+function writeMergedPythonInitFile(
+  filePath: string,
+  generatedSource: string,
+  session: FileOperationSession,
+  sourceModel: string
+): void {
+  const existingSource = session.fileExists(filePath) ? session.readFile(filePath) : undefined;
+  session.writeFile(filePath, mergePythonInitSource(existingSource, generatedSource), {
+    ownership: "extension-point",
+    generator: "native-schema",
+    sourceModel,
+  });
 }
 
-function ensureCSharpCodegenProjectFiles(functionsRoot: string): void {
+function ensureCSharpCodegenProjectFiles(
+  functionsRoot: string,
+  session: FileOperationSession,
+  sourceModel: string
+): void {
   const toolManifestPath = path.join(functionsRoot, ".config", "dotnet-tools.json");
-  fs.mkdirSync(path.dirname(toolManifestPath), { recursive: true });
-  if (!fs.existsSync(toolManifestPath)) {
-    fs.writeFileSync(toolManifestPath, buildCSharpCodegenToolManifestSource(), "utf-8");
+  if (!session.fileExists(toolManifestPath)) {
+    session.writeFile(toolManifestPath, buildCSharpCodegenToolManifestSource(), {
+      ownership: "generated-once",
+      generator: "native-schema",
+      sourceModel,
+    });
   }
 }
 
-function ensurePythonCodegenProjectFiles(functionsRoot: string): string {
+function ensurePythonCodegenProjectFiles(
+  functionsRoot: string,
+  session: FileOperationSession,
+  sourceModel: string
+): string {
   const requirementsPath = path.join(functionsRoot, "requirements.codegen.txt");
-  if (!fs.existsSync(requirementsPath)) {
-    fs.writeFileSync(requirementsPath, buildPythonCodegenRequirementsSource(), "utf-8");
+  if (!session.fileExists(requirementsPath)) {
+    session.writeFile(requirementsPath, buildPythonCodegenRequirementsSource(), {
+      ownership: "generated-once",
+      generator: "native-schema",
+      sourceModel,
+    });
   }
   return requirementsPath;
 }
@@ -676,8 +702,7 @@ async function ensureProjectLocalUvCommand(projectRoot: string): Promise<{ comma
   return { command: localUvExecutable, env: uvEnv };
 }
 
-async function ensurePythonCodegenEnvironment(functionsRoot: string): Promise<string> {
-  const requirementsPath = ensurePythonCodegenProjectFiles(functionsRoot);
+async function ensurePythonCodegenEnvironment(functionsRoot: string, requirementsPath: string): Promise<string> {
   const projectRoot = getPythonProjectRoot(functionsRoot);
   const { command: uvCommand, env: uvEnv } = await ensureProjectLocalUvCommand(projectRoot);
   const venvDir = path.join(functionsRoot, ".codegen-venv");
@@ -711,79 +736,125 @@ async function ensurePythonCodegenEnvironment(functionsRoot: string): Promise<st
   return venvPython;
 }
 
-async function generateCSharpSchemaArtifacts(
+/**
+ * 外部 codegen toolchain の事前検証。プロジェクトには一切書き込まず、
+ * OS 一時ディレクトリ上で NSwag / datamodel-code-generator を実行して失敗を早期検出する。
+ */
+export async function validateNativeSchemaToolchain(
   models: ModelInfo[],
-  specPath: string,
-  outputDir: string,
+  rootModel: ModelInfo,
+  backendLanguage: Exclude<BackendLanguage, "typescript">,
   functionsRoot: string
 ): Promise<void> {
-  ensureCSharpCodegenProjectFiles(functionsRoot);
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-native-codegen-"));
+  try {
+    const specPath = path.join(tempDir, `${toKebabCase(rootModel.name)}.openapi.json`);
+    fs.writeFileSync(specPath, generateOpenApiDocument(models, rootModel), "utf-8");
+
+    if (backendLanguage === "csharp") {
+      if (!canRun("dotnet", ["--version"], tempDir)) {
+        throw new Error(
+          "The .NET SDK is required to generate C# backend schema assets.\n" +
+            "Install the .NET 8 SDK and retry."
+        );
+      }
 
-  if (!canRun("dotnet", ["--version"], functionsRoot)) {
-    throw new Error(
-      "The .NET SDK is required to generate C# backend schema assets.\n" +
-        "Install the .NET 8 SDK and retry."
-    );
-  }
+      // プロジェクトの tool manifest（バージョン固定）があればそれを尊重し、なければ一時 manifest で検証する
+      const projectManifestPath = path.join(functionsRoot, ".config", "dotnet-tools.json");
+      let toolCwd = functionsRoot;
+      if (!fs.existsSync(projectManifestPath)) {
+        fs.mkdirSync(path.join(tempDir, ".config"), { recursive: true });
+        fs.writeFileSync(path.join(tempDir, ".config", "dotnet-tools.json"), buildCSharpCodegenToolManifestSource(), "utf-8");
+        toolCwd = tempDir;
+      }
 
-  const tempContractsPath = path.join(outputDir, ".native-temp", "Contracts.cs");
-  fs.mkdirSync(path.dirname(tempContractsPath), { recursive: true });
+      await runCommand("dotnet", ["tool", "restore"], toolCwd, "Failed to restore the NSwag dotnet tool.");
+      await runCommand(
+        "dotnet",
+        getCSharpNativeGeneratorArgs(specPath, path.join(tempDir, "Contracts.cs")),
+        toolCwd,
+        "NSwag failed to generate C# backend schema assets."
+      );
+    } else {
+      const projectRequirementsPath = path.join(functionsRoot, "requirements.codegen.txt");
+      let requirementsPath = projectRequirementsPath;
+      if (!fs.existsSync(projectRequirementsPath)) {
+        requirementsPath = path.join(tempDir, "requirements.codegen.txt");
+        fs.writeFileSync(requirementsPath, buildPythonCodegenRequirementsSource(), "utf-8");
+      }
 
-  await runCommand(
-    "dotnet",
-    ["tool", "restore"],
-    functionsRoot,
-    "Failed to restore the NSwag dotnet tool."
-  );
-  await runCommand(
-    "dotnet",
-    getCSharpNativeGeneratorArgs(specPath, tempContractsPath),
-    functionsRoot,
-    "NSwag failed to generate C# backend schema assets."
-  );
+      // .codegen-venv は environment cache であり managed artifact ではない(既存挙動どおり functionsRoot 配下)
+      fs.mkdirSync(functionsRoot, { recursive: true });
+      const pythonExecutable = await ensurePythonCodegenEnvironment(functionsRoot, requirementsPath);
+      await runCommand(
+        pythonExecutable,
+        getPythonNativeGeneratorArgs(specPath, path.join(tempDir, "models.py")),
+        functionsRoot,
+        "datamodel-code-generator failed to generate Python backend schema assets."
+      );
+    }
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
 
-  fs.rmSync(path.dirname(tempContractsPath), { recursive: true, force: true });
+async function generateCSharpSchemaArtifacts(
+  models: ModelInfo[],
+  outputDir: string,
+  functionsRoot: string,
+  session: FileOperationSession,
+  sourceModel: string
+): Promise<void> {
+  ensureCSharpCodegenProjectFiles(functionsRoot, session, sourceModel);
 
   const optionPath = getCSharpSchemaOptionPath(outputDir);
-  fs.mkdirSync(path.dirname(optionPath), { recursive: true });
-  fs.writeFileSync(optionPath, generateLegacyCompatibleOptionSource(), "utf-8");
+  session.writeFile(optionPath, generateLegacyCompatibleOptionSource(), {
+    ownership: "managed",
+    generator: "native-schema",
+    sourceModel,
+  });
 
   for (const model of models) {
     const modelPath = getCSharpSchemaModelPath(outputDir, model.name);
-    fs.mkdirSync(path.dirname(modelPath), { recursive: true });
-    fs.writeFileSync(modelPath, generateLegacyCompatibleCSharpModelSource(model), "utf-8");
+    session.writeFile(modelPath, generateLegacyCompatibleCSharpModelSource(model), {
+      ownership: "managed",
+      generator: "native-schema",
+      sourceModel,
+    });
   }
 }
 
 async function generatePythonSchemaArtifacts(
   models: ModelInfo[],
-  specPath: string,
   outputDir: string,
-  functionsRoot: string
+  functionsRoot: string,
+  session: FileOperationSession,
+  sourceModel: string
 ): Promise<void> {
-  const pythonExecutable = await ensurePythonCodegenEnvironment(functionsRoot);
-  const tempModelsPath = path.join(outputDir, ".native-temp", "models.py");
-  fs.mkdirSync(path.dirname(tempModelsPath), { recursive: true });
-
-  await runCommand(
-    pythonExecutable,
-    getPythonNativeGeneratorArgs(specPath, tempModelsPath),
-    functionsRoot,
-    "datamodel-code-generator failed to generate Python backend schema assets."
-  );
-
-  fs.rmSync(path.dirname(tempModelsPath), { recursive: true, force: true });
+  ensurePythonCodegenProjectFiles(functionsRoot, session, sourceModel);
 
   const packageRoot = path.join(outputDir, "backend_models");
   const modelsRoot = path.join(packageRoot, "models");
-  fs.mkdirSync(modelsRoot, { recursive: true });
-  writeMergedPythonInitFile(path.join(packageRoot, "__init__.py"), buildGeneratedPythonPackageInitSource(models));
-  writeMergedPythonInitFile(path.join(modelsRoot, "__init__.py"), buildGeneratedPythonModelsInitSource(models));
+  writeMergedPythonInitFile(
+    path.join(packageRoot, "__init__.py"),
+    buildGeneratedPythonPackageInitSource(models),
+    session,
+    sourceModel
+  );
+  writeMergedPythonInitFile(
+    path.join(modelsRoot, "__init__.py"),
+    buildGeneratedPythonModelsInitSource(models),
+    session,
+    sourceModel
+  );
 
   for (const model of models) {
     const modelPath = getPythonSchemaModelPath(outputDir, model.name);
-    fs.mkdirSync(path.dirname(modelPath), { recursive: true });
-    fs.writeFileSync(modelPath, generateLegacyCompatiblePythonModelSource(model), "utf-8");
+    session.writeFile(modelPath, generateLegacyCompatiblePythonModelSource(model), {
+      ownership: "managed",
+      generator: "native-schema",
+      sourceModel,
+    });
   }
 }
 
@@ -791,18 +862,27 @@ export async function generateLanguageSchemaArtifacts(
   models: ModelInfo[],
   rootModel: ModelInfo,
   functionsDir: string,
-  backendLanguage: Exclude<BackendLanguage, "typescript">
+  backendLanguage: Exclude<BackendLanguage, "typescript">,
+  session: FileOperationSession = new FileOperationSession("commit")
 ): Promise<void> {
-  console.log("\n🧬 Generating OpenAPI export and native schema assets...");
+  const planning = session.mode === "collect";
+  console.log(
+    planning
+      ? "\n\ud83e\uddec Planning OpenAPI export and native schema assets..."
+      : "\n\ud83e\uddec Generating OpenAPI export and native schema assets..."
+  );
 
   const projectRoot = process.cwd();
   const functionsRoot = path.join(projectRoot, functionsDir);
   const openApiDir = path.join(functionsRoot, "openapi");
-  fs.mkdirSync(openApiDir, { recursive: true });
 
   const specPath = path.join(openApiDir, `${toKebabCase(rootModel.name)}.openapi.json`);
-  fs.writeFileSync(specPath, generateOpenApiDocument(models, rootModel), "utf-8");
-  console.log(`✅ Created: ${specPath}`);
+  session.writeFile(specPath, generateOpenApiDocument(models, rootModel), {
+    ownership: "managed",
+    generator: "native-schema",
+    sourceModel: rootModel.name,
+  });
+  console.log(planning ? `\ud83d\udccb Will create: ${specPath}` : `\u2705 Created: ${specPath}`);
 
   const outputDir = path.join(
     functionsRoot,
@@ -810,13 +890,15 @@ export async function generateLanguageSchemaArtifacts(
     backendLanguage === "csharp" ? "csharp-models" : "python-models"
   );
 
-  fs.mkdirSync(outputDir, { recursive: true });
-
   if (backendLanguage === "csharp") {
-    await generateCSharpSchemaArtifacts(models, specPath, outputDir, functionsRoot);
+    await generateCSharpSchemaArtifacts(models, outputDir, functionsRoot, session, rootModel.name);
   } else {
-    await generatePythonSchemaArtifacts(models, specPath, outputDir, functionsRoot);
+    await generatePythonSchemaArtifacts(models, outputDir, functionsRoot, session, rootModel.name);
   }
 
-  console.log(`✅ Generated ${backendLanguage} schema assets: ${outputDir}`);
+  console.log(
+    planning
+      ? `\ud83d\udccb Will generate ${backendLanguage} schema assets: ${outputDir}`
+      : `\u2705 Generated ${backendLanguage} schema assets: ${outputDir}`
+  );
 }

package/src/core/scaffold/nextjs-generator.ts

@@ -10,7 +10,7 @@ import { ModelInfo, toCamelCase } from "./model-parser";
  * BFF callFunction ヘルパー (lib/api/call-function.ts) のコードを生成
  */
 export function generateBFFCallFunction(): string {
-  return `import { NextRequest, NextResponse } from 'next/server';
+  return `import { NextResponse } from 'next/server';
 import { z } from 'zod/v4';
 
 /**
@@ -43,13 +43,13 @@ function getFunctionsKeyHeaders(functionsBaseUrl: string): Record<string, string
   throw new Error('BACKEND_FUNCTIONS_KEY is required for non-local Functions calls');
 }
 
-interface CallFunctionConfig<TInput = any, TOutput = any> {
+interface CallFunctionConfig<TInput = unknown, TOutput = unknown> {
   /** HTTP メソッド */
   method: 'GET' | 'POST' | 'PUT' | 'DELETE';
   /** Azure Functions のパス (例: '/api/todo', '/api/todo/123') */
   path: string;
   /** リクエストボディ (POST/PUT 用) */
-  body?: any;
+  body?: unknown;
   /** 入力バリデーション用 Zod スキーマ (省略時はバリデーションなし) */
   inputSchema?: z.ZodSchema<TInput>;
   /** 出力バリデーション用 Zod スキーマ (省略時はそのまま返す) */
@@ -58,7 +58,7 @@ interface CallFunctionConfig<TInput = any, TOutput = any> {
   successStatus?: number;
 }
 
-export async function callFunction<TInput = any, TOutput = any>(
+export async function callFunction<TInput = unknown, TOutput = unknown>(
   config: CallFunctionConfig<TInput, TOutput>
 ): Promise<NextResponse> {
   const { method, path, body, inputSchema, responseSchema, successStatus = 200 } = config;
@@ -121,10 +121,10 @@ export async function callFunction<TInput = any, TOutput = any>(
     }
 
     return NextResponse.json(data, { status: successStatus });
-  } catch (error: any) {
+  } catch (error) {
     console.error(\`[BFF] Error:\`, error);
     return NextResponse.json(
-      { error: error.message || 'Internal server error' },
+      { error: error instanceof Error ? error.message : 'Internal server error' },
       { status: 500 }
     );
   }

package/src/core/scaffold/ui-generator.ts

@@ -71,7 +71,7 @@ export function generateListPage(model: ModelInfo, sharedPackageName: string, au
     const refModelCamel = toCamelCase(refModel);
     return `    fetch('/api/${refModelCamel}')
       .then(res => res.json())
-      .then((data: any[]) => {
+      .then((data: Array<{ id: string; name?: string; title?: string }>) => {
         const map: Record<string, string> = {};
         data.forEach(item => {
           // name または title フィールドを表示用文字列として使用
@@ -138,8 +138,8 @@ ${hasForeignKeys ? foreignKeyFetches : ''}
       if (!res.ok) throw new Error('Failed to delete ${modelCamel}');
 
       set${modelName}s(${modelCamel}s.filter((item) => item.id !== id));
-    } catch (err: any) {
-      alert(\`Error: \${err.message}\`);
+    } catch (err) {
+      alert(\`Error: \${err instanceof Error ? err.message : String(err)}\`);
     }
   };
 
@@ -216,7 +216,7 @@ ${displayFields.map(f => {
     const displayField = f.nestedDisplayField || 'name';
     if (f.isArray) {
       return `                  <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-900 dark:text-gray-100">
-                    {Array.isArray(item.${f.name}) ? item.${f.name}.map((ref: any) => ref?.${displayField} || '-').join(', ') : '-'}
+                    {Array.isArray(item.${f.name}) ? item.${f.name}.map((ref: unknown) => (ref as { ${displayField}?: string } | null)?.${displayField} || '-').join(', ') : '-'}
                   </td>`;
     } else {
       return `                  <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-900 dark:text-gray-100">
@@ -317,7 +317,7 @@ export function generateDetailPage(model: ModelInfo, sharedPackageName: string,
     const refModelCamel = toCamelCase(refModel);
     return `    fetch('/api/${refModelCamel}')
       .then(res => res.json())
-      .then((data: any[]) => {
+      .then((data: Array<{ id: string; name?: string; title?: string }>) => {
         const map: Record<string, string> = {};
         data.forEach(item => {
           map[item.id] = item.name || item.title || item.id;
@@ -389,8 +389,8 @@ ${hasForeignKeys ? foreignKeyFetches : ''}
       if (!res.ok) throw new Error('Failed to delete ${modelCamel}');
 
       router.push('/${modelKebab}');
-    } catch (err: any) {
-      alert(\`Error: \${err.message}\`);
+    } catch (err) {
+      alert(\`Error: \${err instanceof Error ? err.message : String(err)}\`);
     }
   };
 
@@ -455,7 +455,7 @@ ${model.fields.map(f => {
     if (f.isArray) {
       return `            <div>
               <dt className="text-sm font-medium text-gray-500 dark:text-gray-400">${label}</dt>
-              <dd className="mt-1 text-sm text-gray-900 dark:text-gray-100">{Array.isArray(${modelCamel}.${f.name}) ? ${modelCamel}.${f.name}.map((ref: any) => ref?.${displayField} || '-').join(', ') : '-'}</dd>
+              <dd className="mt-1 text-sm text-gray-900 dark:text-gray-100">{Array.isArray(${modelCamel}.${f.name}) ? ${modelCamel}.${f.name}.map((ref: unknown) => (ref as { ${displayField}?: string } | null)?.${displayField} || '-').join(', ') : '-'}</dd>
             </div>`;
     } else {
       return `            <div>
@@ -547,7 +547,7 @@ export function generateFormComponent(model: ModelInfo, sharedPackageName: strin
     return `    // ${refModelPascal} の一覧を取得
     fetch('/api/${refModelCamel}')
       .then(res => res.json())
-      .then(data => set${refModelPascal}Options(data.map((item: any) => ({ id: item.id, name: item.${displayField} || item.name || item.title || item.id }))))
+      .then(data => set${refModelPascal}Options(data.map((item: Record<string, string>) => ({ id: item.id, name: item.${displayField} || item.name || item.title || item.id }))))
       .catch(err => console.error('Failed to load ${refModelPascal} options:', err));`;
   }).join('\n');
   
@@ -581,7 +581,7 @@ ${formFields.map(f => {
   // ネストスキーマの場合は参照ID（単一: string, 配列: string[]）を管理
   if (f.isNestedSchema) {
     if (f.isArray) {
-      return `    ${f.name}Ids: initialData?.${f.name} ? (Array.isArray(initialData.${f.name}) ? initialData.${f.name}.map((item: any) => item.id) : []) : [] as string[],`;
+      return `    ${f.name}Ids: initialData?.${f.name} ? (Array.isArray(initialData.${f.name}) ? initialData.${f.name}.map((item: { id: string }) => item.id) : []) : [] as string[],`;
     } else {
       return `    ${f.name}Id: initialData?.${f.name}?.id ?? '',`;
     }
@@ -615,7 +615,7 @@ ${needsUseEffect ? `
 ${hasForignKeys ? foreignKeyFields.map(f => `    // ${f.referencedModel} の一覧を取得
     fetch('/api/${toKebabCase(f.referencedModel!)}')
       .then(res => res.json())
-      .then(data => set${f.referencedModel}Options(data.map((item: any) => ({ id: item.id, name: item.name || item.title || item.id }))))
+      .then(data => set${f.referencedModel}Options(data.map((item: Record<string, string>) => ({ id: item.id, name: item.name || item.title || item.id }))))
       .catch(err => console.error('Failed to load ${f.referencedModel} options:', err));`).join('\n') : ''}
 ${hasNestedSchemas ? nestedSchemaFetches : ''}
   }, []);
@@ -627,7 +627,7 @@ ${hasNestedSchemas ? nestedSchemaFetches : ''}
 
     try {
       // Array フィールドをカンマ区切りから配列に変換
-      const submitData: any = { ...formData };
+      const submitData: Record<string, unknown> = { ...formData };
 ${formFields.filter(f => f.isArray && !f.isNestedSchema).map(f => `      if (typeof submitData.${f.name} === 'string') {
         submitData.${f.name} = submitData.${f.name}.split(',').map((s: string) => s.trim()).filter((s: string) => s.length > 0);
       }`).join('\n')}
@@ -651,7 +651,7 @@ ${nestedSchemaFields.map(f => {
   if (f.isArray) {
     return `      // ${refModelPascal} 配列参照の変換
       if (submitData.${f.name}Ids) {
-        submitData.${f.name} = submitData.${f.name}Ids
+        submitData.${f.name} = (submitData.${f.name}Ids as string[])
           .map((refId: string) => ${refModelCamel}Options.find(opt => opt.id === refId))
           .filter(Boolean);
         delete submitData.${f.name}Ids;
@@ -688,17 +688,17 @@ ${nestedSchemaFields.map(f => {
       }
 
       router.push('/${toKebabCase(modelName)}');
-    } catch (err: any) {
-      if (err.issues) {
+    } catch (err) {
+      if (err instanceof z.ZodError) {
         // Zod validation errors
         const fieldErrors: Record<string, string> = {};
-        err.issues.forEach((error: any) => {
-          const field = error.path[0];
-          fieldErrors[field] = error.message;
+        err.issues.forEach((issue) => {
+          const field = String(issue.path[0]);
+          fieldErrors[field] = issue.message;
         });
         setErrors(fieldErrors);
       } else {
-        alert(\`Error: \${err.message}\`);
+        alert(\`Error: \${err instanceof Error ? err.message : String(err)}\`);
       }
       setLoading(false);
     }