swallowkit 1.1.2 → 2.0.0-alpha.10

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

@@ -1,4 +1,4 @@
-import { FieldInfo, ModelInfo, toCamelCase } from "./model-parser";
+import { FieldInfo, ModelInfo, toCamelCase, toPascalCase } from "./model-parser";
 
 type OpenApiSchema =
   | {
@@ -11,9 +11,59 @@ type OpenApiSchema =
       additionalProperties?: boolean;
       nullable?: boolean;
       $ref?: string;
+      minLength?: number;
+      maxLength?: number;
+      pattern?: string;
+      minimum?: number;
+      maximum?: number;
+      exclusiveMinimum?: boolean;
+      exclusiveMaximum?: boolean;
+      minItems?: number;
+      maxItems?: number;
     };
 
+/**
+ * Promote inline `z.object({...})` fields to named models (e.g. ProbeItem.nested -> ProbeItemNested)
+ * so OpenAPI components and native classes keep their shape. Expanded fields reference the new model.
+ */
+export function expandInlineObjectModels(models: ModelInfo[]): ModelInfo[] {
+  const names = new Set(models.map((model) => model.name));
+  const synthetic: ModelInfo[] = [];
+
+  const expand = (owner: ModelInfo): ModelInfo => ({
+    ...owner,
+    fields: owner.fields.map((field) => {
+      if (!field.objectFields || field.isNestedSchema) return field;
+      let name = `${owner.name}${toPascalCase(field.name)}`;
+      while (names.has(name)) name = `${name}Object`;
+      names.add(name);
+      const nested = expand({
+        ...owner,
+        name,
+        displayName: name,
+        schemaName: name,
+        fields: field.objectFields,
+        hasId: field.objectFields.some((child) => child.name === "id"),
+        hasCreatedAt: field.objectFields.some((child) => child.name === "createdAt"),
+        hasUpdatedAt: field.objectFields.some((child) => child.name === "updatedAt"),
+        nestedSchemaRefs: [],
+        partitionKey: "/id",
+        connectorConfig: undefined,
+        authPolicy: undefined,
+      });
+      synthetic.push(nested);
+      const rest = { ...field };
+      delete rest.objectFields;
+      return { ...rest, isNestedSchema: true, nestedModelName: name };
+    }),
+  });
+
+  const expanded = models.map(expand);
+  return [...expanded, ...synthetic];
+}
+
 function toScalarSchema(field: FieldInfo): OpenApiSchema {
+  const constraints = field.constraints ?? {};
   if (field.enumValues?.length) {
     return {
       type: "string",
@@ -25,7 +75,10 @@ function toScalarSchema(field: FieldInfo): OpenApiSchema {
     case "string":
       return {
         type: "string",
-        format: field.name.toLowerCase().endsWith("at") ? "date-time" : undefined,
+        ...(field.format && field.format !== "time" ? { format: field.format } : {}),
+        ...(constraints.minLength !== undefined ? { minLength: constraints.minLength } : {}),
+        ...(constraints.maxLength !== undefined ? { maxLength: constraints.maxLength } : {}),
+        ...(constraints.pattern !== undefined ? { pattern: constraints.pattern } : {}),
       };
     case "date":
       return {
@@ -34,7 +87,11 @@ function toScalarSchema(field: FieldInfo): OpenApiSchema {
       };
     case "number":
       return {
-        type: "number",
+        ...(field.isInteger ? { type: "integer", format: "int64" } : { type: "number", format: "double" }),
+        ...(constraints.minimum !== undefined ? { minimum: constraints.minimum } : {}),
+        ...(constraints.exclusiveMinimum ? { exclusiveMinimum: true } : {}),
+        ...(constraints.maximum !== undefined ? { maximum: constraints.maximum } : {}),
+        ...(constraints.exclusiveMaximum ? { exclusiveMaximum: true } : {}),
       };
     case "boolean":
       return {
@@ -59,6 +116,8 @@ function toFieldSchema(field: FieldInfo): OpenApiSchema {
     return {
       type: "array",
       items: schema,
+      ...(field.constraints?.minItems !== undefined ? { minItems: field.constraints.minItems } : {}),
+      ...(field.constraints?.maxItems !== undefined ? { maxItems: field.constraints.maxItems } : {}),
     };
   }
 
@@ -82,11 +141,10 @@ function createComponentSchema(model: ModelInfo): OpenApiSchema {
     required,
   };
 }
-
 export function generateOpenApiDocument(models: ModelInfo[], rootModel: ModelInfo): string {
   const rootModelRoute = toCamelCase(rootModel.name);
   const components = Object.fromEntries(
-    models.map((model) => [model.name, createComponentSchema(model)])
+    expandInlineObjectModels(models).map((model) => [model.name, createComponentSchema(model)])
   );
 
   const document = {

package/src/core/scaffold/react-bff-generator.ts

@@ -0,0 +1,292 @@
+import { AuthConfig } from "../../types";
+import { normalizeAuthConfig } from "../config";
+import { ModelInfo, toCamelCase } from "./model-parser";
+
+export function generateManagedFunctionConfig(
+  route: string,
+  methods: readonly string[],
+  entry: string
+): string {
+  return (
+    JSON.stringify(
+      {
+        scriptFile: `../dist/${entry}/index.js`,
+        bindings: [
+          {
+            authLevel: "anonymous",
+            type: "httpTrigger",
+            direction: "in",
+            name: "req",
+            methods: methods.map((method) => method.toLowerCase()),
+            route,
+          },
+          { type: "http", direction: "out", name: "$return" },
+        ],
+      },
+      null,
+      2
+    ) + "\n"
+  );
+}
+
+export function getAuthCookieName(projectName: string): string {
+  return (
+    projectName.replace(/^@[^/]+\//, "").replace(/[^a-z0-9-]/g, "-") +
+    "-auth-token"
+  );
+}
+
+/** Request-local credentials: never share authentication state between invocations. */
+export function generateReactBffHelper(
+  projectName: string,
+  auth?: AuthConfig
+): string {
+  const providers = new Set(
+    Object.values(normalizeAuthConfig(auth)?.schemes ?? {}).map(
+      (scheme) => scheme.provider
+    )
+  );
+  return `import type { HttpRequest, HttpResponse } from '@azure/functions';
+import { z } from 'zod/v4';
+
+// SwallowKit BFF Call Function Helper (SWA managed Functions)
+const forwardSwa = ${providers.has("swa")};
+const forwardBearer = ${providers.has("custom-jwt") || providers.has("external-token")};
+const authCookieName = '${getAuthCookieName(projectName)}';
+
+export class BffError extends Error {
+  constructor(public status: number, message: string) { super(message); }
+}
+
+export function json(body: unknown, status = 200): HttpResponse {
+  return { status, body, headers: { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' } };
+}
+
+export function parseBody(request: HttpRequest): unknown {
+  if (request.body === undefined || request.body === '') throw new BffError(400, 'Request body is required');
+  if (typeof request.body !== 'string') return request.body;
+  try { return JSON.parse(request.body); }
+  catch { throw new BffError(400, 'Invalid JSON body'); }
+}
+
+function credentialHeaders(request: HttpRequest): Record<string, string> {
+  const result: Record<string, string> = {};
+  if (forwardBearer) {
+    const authorization = request.headers.authorization;
+    const cookie = request.headers.cookie?.split(';').map(value => value.trim()).find(value => value.startsWith(authCookieName + '='));
+    if (authorization?.startsWith('Bearer ')) result.Authorization = authorization;
+    else if (cookie) {
+      try { result.Authorization = 'Bearer ' + decodeURIComponent(cookie.slice(authCookieName.length + 1)); }
+      catch { throw new BffError(401, 'Invalid authentication cookie'); }
+    }
+  }
+  // SWA injects this header at the trusted managed API boundary. Never expose the backend key to clients.
+  if (forwardSwa && request.headers['x-ms-client-principal']) {
+    const encoded = request.headers['x-ms-client-principal'];
+    try {
+      const decoded = Buffer.from(encoded, 'base64');
+      if (decoded.toString('base64') !== encoded) throw new Error('Invalid encoding');
+      const value = JSON.parse(decoded.toString('utf8'));
+      if (typeof value.identityProvider !== 'string' || !value.identityProvider ||
+          typeof value.userId !== 'string' || !value.userId ||
+          !Array.isArray(value.userRoles) || !value.userRoles.includes('authenticated')) {
+        throw new Error('Invalid principal');
+      }
+      result['x-ms-client-principal'] = Buffer.from(JSON.stringify({
+        identityProvider: value.identityProvider, userId: value.userId,
+        userDetails: typeof value.userDetails === 'string' ? value.userDetails : '',
+        userRoles: value.userRoles.filter((role: unknown) => typeof role === 'string'),
+      })).toString('base64');
+    } catch {
+      throw new BffError(401, 'Invalid SWA client principal');
+    }
+  }
+  return result;
+}
+
+export async function backendRequest(request: HttpRequest, method: string, path: string, body?: unknown): Promise<Response> {
+  const baseUrl = process.env.BACKEND_FUNCTIONS_BASE_URL || process.env.FUNCTIONS_BASE_URL || 'http://localhost:7071';
+  const parsedUrl = new URL(baseUrl);
+  const local = parsedUrl.protocol === 'http:' && ['localhost', '127.0.0.1', '[::1]'].includes(parsedUrl.hostname);
+  const key = process.env.BACKEND_FUNCTIONS_KEY;
+  if (!key && !local) throw new Error('BACKEND_FUNCTIONS_KEY is required for non-local Functions calls');
+  if (!local && parsedUrl.protocol !== 'https:') throw new Error('Remote Functions calls require HTTPS');
+  return fetch(baseUrl.replace(/\\/$/, '') + path, {
+    method,
+    headers: { 'Content-Type': 'application/json', ...credentialHeaders(request), ...(key ? { 'x-functions-key': key } : {}) },
+    body: body === undefined ? undefined : JSON.stringify(body),
+    redirect: 'error',
+  });
+}
+
+interface CallFunctionConfig {
+  request: HttpRequest;
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+  path: string;
+  body?: unknown;
+  inputSchema?: z.ZodType;
+  responseSchema?: z.ZodType;
+  successStatus?: number;
+}
+
+export async function callFunction(config: CallFunctionConfig): Promise<HttpResponse> {
+  try {
+    let body = config.body;
+    if (config.inputSchema) {
+      const result = config.inputSchema.safeParse(body);
+      if (!result.success) return json({ error: 'Validation failed', details: result.error.issues }, 400);
+      body = result.data;
+    }
+    const response = await backendRequest(config.request, config.method, config.path, body);
+    if (response.status === 204) return { status: 204 };
+    if (!response.ok) {
+      console.error('[BFF] Backend request failed:', response.status);
+      return json({ error: 'Backend request failed' }, response.status);
+    }
+    const data: unknown = await response.json();
+    if (config.responseSchema) {
+      const result = config.responseSchema.safeParse(data);
+      if (!result.success) {
+        console.error('[BFF] Backend response validation failed');
+        return json({ error: 'Invalid backend response' }, 502);
+      }
+      return json(result.data, config.successStatus ?? 200);
+    }
+    return json(data, config.successStatus ?? 200);
+  } catch (error) {
+    return handleError(error);
+  }
+}
+
+export function handleError(error: unknown): HttpResponse {
+  if (error instanceof BffError) return json({ error: error.message }, error.status);
+  console.error('[BFF] Request failed:', error instanceof Error ? error.name : 'UnknownError');
+  return json({ error: 'Backend request failed' }, 502);
+}
+`;
+}
+
+export function generateReactBffRoute(
+  model: ModelInfo,
+  sharedPackageName: string
+): string {
+  const modelCamel = toCamelCase(model.name);
+  const operations = new Set(
+    model.connectorConfig?.operations ?? [
+      "getAll",
+      "getById",
+      "create",
+      "update",
+      "delete",
+    ]
+  );
+  const managedFields = model.fields
+    .filter((field) => ["id", "createdAt", "updatedAt"].includes(field.name))
+    .map((field) => `${field.name}: true`)
+    .join(", ");
+  const clauses: string[] = [];
+  if (operations.has("getAll"))
+    clauses.push(
+      `    if (request.method === 'GET' && !id) return callFunction({ request, method: 'GET', path, responseSchema: z.array(${model.schemaName}) });`
+    );
+  if (operations.has("getById"))
+    clauses.push(
+      `    if (request.method === 'GET' && id) return callFunction({ request, method: 'GET', path, responseSchema: ${model.schemaName} });`
+    );
+  if (operations.has("create"))
+    clauses.push(
+      `    if (request.method === 'POST' && !id) return callFunction({ request, method: 'POST', path, body: parseBody(request), inputSchema: InputSchema, responseSchema: ${model.schemaName}, successStatus: 201 });`
+    );
+  if (operations.has("update"))
+    clauses.push(
+      `    if (request.method === 'PUT' && id) return callFunction({ request, method: 'PUT', path, body: parseBody(request), inputSchema: InputSchema, responseSchema: ${model.schemaName} });`
+    );
+  if (operations.has("delete"))
+    clauses.push(
+      `    if (request.method === 'DELETE' && id) return callFunction({ request, method: 'DELETE', path });`
+    );
+  return `import type { AzureFunction, Context, HttpRequest } from '@azure/functions';
+import { z } from 'zod/v4';
+import { ${model.schemaName} } from '${sharedPackageName}';
+import { callFunction, parseBody, json, handleError } from '../lib/call-function';
+
+const InputSchema = ${model.schemaName}.omit({ ${managedFields} });
+
+const handler: AzureFunction = async (_context: Context, request: HttpRequest) => {
+  try {
+    const id = request.params.id;
+    const path = '/api/${modelCamel}' + (id ? '/' + encodeURIComponent(id) : '');
+${clauses.join("\n")}
+    return json({ error: 'Method not allowed' }, 405);
+  } catch (error) { return handleError(error); }
+};
+export default handler;
+`;
+}
+
+export function generateReactGreetBff(): string {
+  return `import type { AzureFunction, Context, HttpRequest } from '@azure/functions';
+import { callFunction, parseBody, handleError } from '../lib/call-function';
+
+const handler: AzureFunction = async (_context: Context, request: HttpRequest) => {
+  try {
+    const body = request.method === 'POST' ? parseBody(request) : undefined;
+    return callFunction({
+      request, method: request.method === 'POST' ? 'POST' : 'GET',
+      path: '/api/greet?name=' + encodeURIComponent(request.query.name || 'World'), body,
+    });
+  } catch (error) { return handleError(error); }
+};
+export default handler;
+`;
+}
+
+export function generateReactAuthBff(
+  projectName: string,
+  sharedPackageName: string,
+  customJwt: boolean
+): string {
+  return `import type { AzureFunction, Context, HttpRequest } from '@azure/functions';
+${customJwt ? `import { z } from 'zod/v4';\nimport { AuthUser, LoginRequest, LoginResponse } from '${sharedPackageName}';` : ""}
+import { backendRequest, callFunction, parseBody, json, handleError } from '../lib/call-function';
+
+const cookieName = '${getAuthCookieName(projectName)}';
+${
+  customJwt
+    ? `const CurrentUser = z.preprocess(value => {
+  if (!value || typeof value !== 'object') return value;
+  return { ...value, id: 'id' in value ? value.id : 'sub' in value ? value.sub : undefined };
+}, AuthUser);
+`
+    : ""
+}
+const handler: AzureFunction = async (_context: Context, request: HttpRequest) => {
+  try {
+    const action = request.params.action;
+    if (action === 'me' && request.method === 'GET') return callFunction({ request, method: 'GET', path: '/api/auth/me'${customJwt ? ", responseSchema: CurrentUser" : ""} });
+${
+  customJwt
+    ? `    if (action === 'logout' && request.method === 'POST') {
+      const response = json({ message: 'Logged out' });
+      response.headers = { ...response.headers, 'Set-Cookie': cookieName + '=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0' };
+      return response;
+    }
+    if (action === 'login' && request.method === 'POST') {
+      const input = LoginRequest.safeParse(parseBody(request));
+      if (!input.success) return json({ error: 'Validation failed', details: input.error.issues }, 400);
+      const result = await backendRequest(request, 'POST', '/api/auth/login', input.data);
+      if (!result.ok) return json({ error: 'Authentication failed' }, result.status);
+      const data = LoginResponse.parse(await result.json());
+      const response = json({ user: data.user });
+      const secure = process.env.WEBSITE_SITE_NAME || process.env.NODE_ENV === 'production';
+      response.headers = { ...response.headers, 'Set-Cookie': cookieName + '=' + encodeURIComponent(data.token) + '; Path=/; HttpOnly; SameSite=Lax; Max-Age=86400' + (secure ? '; Secure' : '') };
+      return response;
+    }`
+    : ""
+}
+    return json({ error: 'Not found' }, 404);
+  } catch (error) { return handleError(error); }
+};
+export default handler;
+`;
+}

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

@@ -0,0 +1,51 @@
+import { ModelInfo, toKebabCase } from "./model-parser";
+import { UIAuthOptions } from "./ui-generator";
+
+/** Adapt the shared CRUD presentation templates to React Router, without a Next.js runtime. */
+export function adaptReactPage(source: string): string {
+  return source
+    .replace(/^'use client';?\s*\r?\n/, "")
+    .replace(
+      /import Link from 'next\/link';/g,
+      "import { Link } from 'react-router-dom';"
+    )
+    .replace(
+      /import \{ useParams, useRouter \} from 'next\/navigation';/g,
+      "import { useParams, useNavigate } from 'react-router-dom';"
+    )
+    .replace(
+      /import \{ useRouter \} from 'next\/navigation';/g,
+      "import { useNavigate } from 'react-router-dom';"
+    )
+    .replace(/\buseRouter\(\)/g, "useNavigate()")
+    .replace(/\brouter\.(?:push|replace)\(/g, "router(")
+    .replace(/^\s*router\.refresh\(\);?\s*$/gm, "")
+    .replace(/(<Link\b[^>]*?)\bhref=/gs, "$1to=")
+    .replace(/\[params\]/g, "[params.id]");
+}
+
+export function generateReactModelRoutes(
+  model: ModelInfo,
+  auth?: UIAuthOptions
+): string {
+  const slug = toKebabCase(model.name);
+  return `import type { RouteObject } from 'react-router-dom';
+${auth ? "import { Outlet } from 'react-router-dom';\nimport Layout from './layout';" : ""}
+import List from './page';
+import Detail from './[id]/page';
+import New from './new/page';
+import Edit from './[id]/edit/page';
+
+const routes: RouteObject[] = [{
+  path: '/${slug}',
+  ${auth ? "element: <Layout><Outlet /></Layout>," : ""}
+  children: [
+    { index: true, element: <List /> },
+    { path: 'new', element: <New /> },
+    { path: ':id', element: <Detail /> },
+    { path: ':id/edit', element: <Edit /> },
+  ],
+}];
+export default routes;
+`;
+}

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

@@ -3,7 +3,7 @@
  * CRUD 画面（一覧、詳細、新規作成、編集）を生成する
  */
 
-import { ModelInfo, toCamelCase, toKebabCase } from "./model-parser";
+import { FieldInfo, ModelInfo, toCamelCase, toKebabCase } from "./model-parser";
 import { ModelAuthPolicy } from "../../types";
 
 /** auth が有効かつ authPolicy が存在する場合に渡されるオプション */
@@ -18,6 +18,21 @@ export interface UIAuthOptions {
 /**
  * 認証付きCRUDルートを、ページ側のuseAuthと同じAuthProviderで囲むレイアウトを生成する。
  */
+/** Lookup state and fetches are per referenced model; several fields may reference the same model. */
+function uniqueByReferencedModel(fields: FieldInfo[]): FieldInfo[] {
+  const seen = new Set<string>();
+  return fields.filter((field) => {
+    if (!field.referencedModel || seen.has(field.referencedModel)) return false;
+    seen.add(field.referencedModel);
+    return true;
+  });
+}
+
+/** Untyped or inline z.object fields (not references to another model) are edited and shown as JSON. */
+function isJsonField(f: FieldInfo): boolean {
+  return f.type === "object" && !f.isNestedSchema;
+}
+
 export function generateAuthLayout(model: ModelInfo, authOptions?: UIAuthOptions): string | undefined {
   if (!authOptions) return undefined;
 
@@ -59,14 +74,14 @@ export function generateListPage(model: ModelInfo, sharedPackageName: string, au
   const hasForeignKeys = foreignKeyFields.length > 0;
   
   // 外部キー用のstate定義を生成
-  const foreignKeyStates = foreignKeyFields.map(f => {
+  const foreignKeyStates = uniqueByReferencedModel(foreignKeyFields).map(f => {
     const refModel = f.referencedModel!;
     const refModelCamel = toCamelCase(refModel);
     return `  const [${refModelCamel}Map, set${refModel}Map] = useState<Record<string, string>>({});`;
   }).join('\n');
   
   // 外部キーデータのフェッチロジックを生成
-  const foreignKeyFetches = foreignKeyFields.map(f => {
+  const foreignKeyFetches = uniqueByReferencedModel(foreignKeyFields).map(f => {
     const refModel = f.referencedModel!;
     const refModelCamel = toCamelCase(refModel);
     return `    fetch('/api/${refModelCamel}')
@@ -234,6 +249,10 @@ ${displayFields.map(f => {
     return `                  <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-900 dark:text-gray-100">
                     {${refModelCamel}Map[item.${f.name}] || item.${f.name}}
                   </td>`;
+  } else if (isJsonField(f)) {
+    return `                  <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-900 dark:text-gray-100">
+                    {item.${f.name} === undefined ? '-' : JSON.stringify(item.${f.name})}
+                  </td>`;
   } else {
     return `                  <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-900 dark:text-gray-100">
                     {String(item.${f.name})}
@@ -305,14 +324,14 @@ export function generateDetailPage(model: ModelInfo, sharedPackageName: string,
   const hasForeignKeys = foreignKeyFields.length > 0;
   
   // 外部キー用のstate定義を生成
-  const foreignKeyStates = foreignKeyFields.map(f => {
+  const foreignKeyStates = uniqueByReferencedModel(foreignKeyFields).map(f => {
     const refModel = f.referencedModel!;
     const refModelCamel = toCamelCase(refModel);
     return `  const [${refModelCamel}Map, set${refModel}Map] = useState<Record<string, string>>({});`;
   }).join('\n');
   
   // 外部キーデータのフェッチロジックを生成
-  const foreignKeyFetches = foreignKeyFields.map(f => {
+  const foreignKeyFetches = uniqueByReferencedModel(foreignKeyFields).map(f => {
     const refModel = f.referencedModel!;
     const refModelCamel = toCamelCase(refModel);
     return `    fetch('/api/${refModelCamel}')
@@ -476,6 +495,11 @@ ${model.fields.map(f => {
               <dt className="text-sm font-medium text-gray-500 dark:text-gray-400">${refModel}</dt>
               <dd className="mt-1 text-sm text-gray-900 dark:text-gray-100">{${refModelCamel}Map[${modelCamel}.${f.name}] || ${modelCamel}.${f.name}}</dd>
             </div>`;
+  } else if (isJsonField(f)) {
+    return `            <div>
+              <dt className="text-sm font-medium text-gray-500 dark:text-gray-400">${f.name}</dt>
+              <dd className="mt-1 text-sm text-gray-900 dark:text-gray-100"><pre className="whitespace-pre-wrap">{${modelCamel}.${f.name} === undefined ? '-' : JSON.stringify(${modelCamel}.${f.name}, null, 2)}</pre></dd>
+            </div>`;
   } else {
     return `            <div>
               <dt className="text-sm font-medium text-gray-500 dark:text-gray-400">${f.name}</dt>
@@ -573,7 +597,7 @@ export default function ${modelName}Form({ initialData, isEdit = false }: ${mode
   const router = useRouter();
   const [loading, setLoading] = useState(false);
   const [errors, setErrors] = useState<Record<string, string>>({});
-${hasForignKeys ? foreignKeyFields.map(f => `  const [${toCamelCase(f.referencedModel!)}Options, set${f.referencedModel}Options] = useState<Array<{ id: string; name: string }>>([]);`).join('\n') : ''}
+${hasForignKeys ? uniqueByReferencedModel(foreignKeyFields).map(f => `  const [${toCamelCase(f.referencedModel!)}Options, set${f.referencedModel}Options] = useState<Array<{ id: string; name: string }>>([]);`).join('\n') : ''}
 ${hasNestedSchemas ? nestedSchemaStates : ''}
   
   const [formData, setFormData] = useState({
@@ -587,6 +611,11 @@ ${formFields.map(f => {
     }
   }
   
+  // インラインオブジェクトは JSON テキストとして編集する
+  if (isJsonField(f)) {
+    return `    ${f.name}: initialData?.${f.name} !== undefined ? JSON.stringify(initialData.${f.name}, null, 2) : '',`;
+  }
+
   let defaultValue = "''";
   if (f.isArray) {
     // Array の場合は空文字列（カンマ区切りで入力するため）
@@ -612,7 +641,7 @@ ${formFields.map(f => {
 ${needsUseEffect ? `
   // 参照データの選択肢を取得
   useEffect(() => {
-${hasForignKeys ? foreignKeyFields.map(f => `    // ${f.referencedModel} の一覧を取得
+${hasForignKeys ? uniqueByReferencedModel(foreignKeyFields).map(f => `    // ${f.referencedModel} の一覧を取得
     fetch('/api/${toKebabCase(f.referencedModel!)}')
       .then(res => res.json())
       .then(data => set${f.referencedModel}Options(data.map((item: Record<string, string>) => ({ id: item.id, name: item.name || item.title || item.id }))))
@@ -628,7 +657,19 @@ ${hasNestedSchemas ? nestedSchemaFetches : ''}
     try {
       // Array フィールドをカンマ区切りから配列に変換
       const submitData: Record<string, unknown> = { ...formData };
-${formFields.filter(f => f.isArray && !f.isNestedSchema).map(f => `      if (typeof submitData.${f.name} === 'string') {
+${formFields.filter(isJsonField).length > 0 ? `      // JSON フィールド（インラインオブジェクト）を解析
+${formFields.filter(isJsonField).map(f => `      if (submitData.${f.name} === '') {
+        submitData.${f.name} = undefined;
+      } else if (typeof submitData.${f.name} === 'string') {
+        try {
+          submitData.${f.name} = JSON.parse(submitData.${f.name});
+        } catch {
+          setErrors({ ${f.name}: 'Invalid JSON' });
+          setLoading(false);
+          return;
+        }
+      }`).join('\n')}
+` : ''}${formFields.filter(f => f.isArray && !f.isNestedSchema && !isJsonField(f)).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')}
 ${formFields.filter(f => f.enumValues && f.enumValues.length > 0).length > 0 ? `
@@ -833,6 +874,27 @@ ${f.enumValues.map(v => `          <option value="${v}">${v}</option>`).join('\n
       </div>`;
   }
   
+  // インラインオブジェクトは JSON テキストエリア
+  if (isJsonField(f)) {
+    return `      <div>
+        <label htmlFor="${f.name}" className="block text-sm font-medium text-gray-700 dark:text-gray-300">
+          ${f.name}${!f.isOptional ? ' *' : ''} <span className="text-xs text-gray-500">(JSON)</span>
+        </label>
+        <textarea
+          id="${f.name}"
+          name="${f.name}"
+          rows={4}
+          value={formData.${f.name}}
+          onChange={(e) => setFormData({ ...formData, ${f.name}: e.target.value })}
+          className="mt-1 block w-full rounded-md border border-gray-300 dark:border-gray-600 bg-white dark:bg-gray-700 text-gray-900 dark:text-gray-100 shadow-sm px-3 py-2 font-mono focus:border-blue-500 focus:ring-blue-500 dark:focus:border-blue-400 dark:focus:ring-blue-400"
+          ${!f.isOptional ? 'required' : ''}
+        />
+        {errors.${f.name} && (
+          <p className="mt-1 text-sm text-red-600 dark:text-red-400">{errors.${f.name}}</p>
+        )}
+      </div>`;
+  }
+
   // Array の場合はカンマ区切りテキスト
   if (f.isArray) {
     return `      <div>