swallowkit 1.0.0-beta.2 → 1.0.0-beta.21

package/src/core/mock/zod-mock-generator.ts

@@ -0,0 +1,205 @@
+/**
+ * Zod スキーマ（ModelInfo）からモックデータを自動生成する
+ * フィールド名・型のヒューリスティクスで現実的な値を生成
+ */
+
+import { ModelInfo, FieldInfo, toCamelCase, toKebabCase } from "../scaffold/model-parser";
+
+/**
+ * 単一のモックドキュメントを生成
+ */
+export function generateMockDocument(
+  model: ModelInfo,
+  index: number,
+  allModels: ModelInfo[] = [model],
+  seenModels: Set<string> = new Set()
+): Record<string, unknown> {
+  const nextSeen = new Set(seenModels);
+  nextSeen.add(model.name);
+
+  const doc: Record<string, unknown> = {};
+  for (const field of model.fields) {
+    doc[field.name] = generateFieldValue(model, field, index, allModels, nextSeen);
+  }
+  return doc;
+}
+
+/**
+ * 複数のモックドキュメントを生成
+ */
+export function generateMockDocuments(
+  model: ModelInfo,
+  count: number = 5,
+  allModels: ModelInfo[] = [model]
+): Record<string, unknown>[] {
+  const docs: Record<string, unknown>[] = [];
+  for (let i = 0; i < count; i++) {
+    docs.push(generateMockDocument(model, i + 1, allModels));
+  }
+  return docs;
+}
+
+// ─── Field Value Generation ─────────────────────────────────
+
+function generateFieldValue(
+  model: ModelInfo,
+  field: FieldInfo,
+  index: number,
+  allModels: ModelInfo[],
+  seenModels: Set<string>
+): unknown {
+  // ネストされたスキーマ
+  if (field.isNestedSchema && field.nestedModelName) {
+    const nestedModel = allModels.find((m) => m.name === field.nestedModelName);
+    if (nestedModel && !seenModels.has(nestedModel.name)) {
+      const nested = generateMockDocument(nestedModel, index, allModels, seenModels);
+      return field.isArray ? [nested] : nested;
+    }
+    const fallback = { id: `${toKebabCase(field.nestedModelName!)}-${padIndex(index)}` };
+    return field.isArray ? [fallback] : fallback;
+  }
+
+  if (field.isArray) {
+    return [generateScalarValue(model, field, index)];
+  }
+
+  return generateScalarValue(model, field, index);
+}
+
+function generateScalarValue(
+  model: ModelInfo,
+  field: FieldInfo,
+  index: number
+): unknown {
+  const name = field.name.toLowerCase();
+  const modelKebab = toKebabCase(model.name);
+
+  // id フィールド
+  if (field.name === "id") {
+    return `${modelKebab}-${padIndex(index)}`;
+  }
+
+  // enum フィールド — ラウンドロビン
+  if (field.enumValues && field.enumValues.length > 0) {
+    return field.enumValues[(index - 1) % field.enumValues.length];
+  }
+
+  // boolean フィールド
+  if (field.type === "boolean") {
+    return index % 2 === 0;
+  }
+
+  // number フィールド
+  if (field.type === "number") {
+    return generateNumberValue(name, index);
+  }
+
+  // date フィールド / *At パターン
+  if (field.type === "date" || name.endsWith("at")) {
+    return generateDateValue(index);
+  }
+
+  // object フィールド
+  if (field.type === "object") {
+    return {};
+  }
+
+  // string フィールド — 名前パターンで分岐
+  return generateStringValue(model, field, index);
+}
+
+function generateStringValue(model: ModelInfo, field: FieldInfo, index: number): string {
+  const name = field.name.toLowerCase();
+  const modelKebab = toKebabCase(model.name);
+
+  // email
+  if (name.includes("email") || name.includes("mail")) {
+    return `${modelKebab}-${padIndex(index)}@example.com`;
+  }
+
+  // URL / ウェブサイト
+  if (name.includes("url") || name.includes("website") || name.includes("link") || name === "href") {
+    return `https://example.com/${modelKebab}/${padIndex(index)}`;
+  }
+
+  // 電話番号
+  if (name.includes("phone") || name.includes("tel")) {
+    return `090-0000-${String(index).padStart(4, "0")}`;
+  }
+
+  // 名前系
+  if (name === "name" || name === "displayname" || name === "fullname" || name === "username") {
+    return `${model.name} ${index}`;
+  }
+  if (name === "firstname" || name === "givenname") {
+    return `FirstName${index}`;
+  }
+  if (name === "lastname" || name === "familyname" || name === "surname") {
+    return `LastName${index}`;
+  }
+
+  // タイトル / 件名
+  if (name === "title" || name === "subject" || name === "summary") {
+    return `Sample ${model.displayName || model.name} ${index}`;
+  }
+
+  // 説明 / 本文
+  if (name === "description" || name === "body" || name === "content" || name === "text") {
+    return `This is a sample ${toCamelCase(model.name)} description for item ${index}.`;
+  }
+
+  // コード / キー
+  if (name.includes("code") || name.includes("key") && !name.includes("api")) {
+    return `${modelKebab.toUpperCase().replace(/-/g, "_")}-${String(index).padStart(3, "0")}`;
+  }
+
+  // ステータス
+  if (name === "status") {
+    const statuses = ["active", "inactive", "pending"];
+    return statuses[(index - 1) % statuses.length];
+  }
+
+  // タイプ / カテゴリ
+  if (name === "type" || name === "category") {
+    return `type-${((index - 1) % 3) + 1}`;
+  }
+
+  // 住所
+  if (name.includes("address") || name.includes("city") || name.includes("country")) {
+    return `Address ${index}`;
+  }
+
+  // 部署
+  if (name === "department" || name === "team" || name === "group") {
+    const depts = ["Engineering", "Sales", "Marketing", "Support", "HR"];
+    return depts[(index - 1) % depts.length];
+  }
+
+  // *Id パターン（外部キー）
+  if (name.endsWith("id") && name !== "id") {
+    const refName = field.name.replace(/Id$/, "");
+    return `${toKebabCase(refName)}-${padIndex(((index - 1) % 3) + 1)}`;
+  }
+
+  // デフォルト
+  return `${modelKebab}-${toKebabCase(field.name)}-${index}`;
+}
+
+function generateNumberValue(name: string, index: number): number {
+  if (name.includes("age")) return 20 + index;
+  if (name.includes("price") || name.includes("cost") || name.includes("amount")) return index * 1000;
+  if (name.includes("count") || name.includes("quantity") || name.includes("qty")) return index * 5;
+  if (name.includes("priority") || name.includes("order") || name.includes("sort")) return index;
+  if (name.includes("rating") || name.includes("score")) return Math.min(index, 5);
+  return index;
+}
+
+function generateDateValue(index: number): string {
+  const baseDate = new Date("2026-01-01T00:00:00.000Z");
+  baseDate.setDate(baseDate.getDate() + index);
+  return baseDate.toISOString();
+}
+
+function padIndex(index: number): string {
+  return String(index).padStart(3, "0");
+}

package/src/core/operations/create-model.ts

@@ -0,0 +1,174 @@
+import * as fs from "fs";
+import * as path from "path";
+import { ensureSwallowKitProject, loadConfig } from "../config";
+import { toPascalCase } from "../scaffold/model-parser";
+import { syncProjectManifest } from "../project/manifest";
+
+export interface CreateModelOperationOptions {
+  names: string[];
+  modelsDir?: string;
+  connector?: string;
+  overwriteMode?: "prompt" | "always" | "never";
+  confirmOverwrite?: (filePath: string) => Promise<boolean>;
+}
+
+export interface CreateModelOperationResult {
+  createdFiles: string[];
+  skippedFiles: string[];
+  updatedIndex: boolean;
+  connectorType?: "rdb" | "api";
+}
+
+function generateModelTemplate(modelName: string): string {
+  const pascalName = toPascalCase(modelName);
+
+  return `import { z } from 'zod/v4';
+
+// ${pascalName} model (Zod official pattern: same name for value and type)
+export const ${pascalName} = z.object({
+  id: z.string(),
+  name: z.string().min(1),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+});
+
+export type ${pascalName} = z.infer<typeof ${pascalName}>;
+
+// Display name for UI
+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.endsWith("s") ? kebabName : `${kebabName}s`;
+
+  const schema = `import { z } from 'zod/v4';
+
+// ${pascalName} model (Zod official pattern: same name for value and type)
+export const ${pascalName} = z.object({
+  id: z.string(),
+  name: z.string().min(1),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+});
+
+export type ${pascalName} = z.infer<typeof ${pascalName}>;
+
+// Display name for UI
+export const displayName = '${pascalName}';
+`;
+
+  if (connectorType === "rdb") {
+    return `${schema}
+// SwallowKit Connector Metadata
+export const connectorConfig = {
+  connector: '${connectorName}',
+  operations: ['getAll', 'getById'] as const,
+  table: '${pluralName}',
+  idColumn: 'id',
+};
+`;
+  }
+
+  return `${schema}
+// SwallowKit Connector Metadata
+export const connectorConfig = {
+  connector: '${connectorName}',
+  operations: ['getAll', 'getById', 'create', 'update'] as const,
+  endpoints: {
+    getAll: 'GET /${pluralName}',
+    getById: 'GET /${pluralName}/{id}',
+    create: 'POST /${pluralName}',
+    update: 'PATCH /${pluralName}/{id}',
+  },
+};
+`;
+}
+
+function updateSharedIndex(kebabName: string, pascalName: string): boolean {
+  const indexPath = path.join("shared", "index.ts");
+
+  if (!fs.existsSync(indexPath)) {
+    return false;
+  }
+
+  const content = fs.readFileSync(indexPath, "utf-8");
+  const exportLine = `export { ${pascalName} } from './models/${kebabName}';`;
+
+  if (content.includes(exportLine)) {
+    return false;
+  }
+
+  fs.appendFileSync(indexPath, `${exportLine}\n`);
+  return true;
+}
+
+export async function createModelOperation(options: CreateModelOperationOptions): Promise<CreateModelOperationResult> {
+  ensureSwallowKitProject("create-model");
+
+  let connectorType: "rdb" | "api" | undefined;
+  if (options.connector) {
+    const config = loadConfig();
+    const connectorDefinition = config.connectors?.[options.connector];
+    if (!connectorDefinition) {
+      throw new Error(
+        `Connector '${options.connector}' not found in swallowkit.config.js. ` +
+          `Run 'swallowkit add-connector ${options.connector} --type=<rdb|api>' first.`
+      );
+    }
+
+    connectorType = connectorDefinition.type;
+  }
+
+  const modelsDir = options.modelsDir || "shared/models";
+  if (!fs.existsSync(modelsDir)) {
+    fs.mkdirSync(modelsDir, { recursive: true });
+  }
+
+  const createdFiles: string[] = [];
+  const skippedFiles: string[] = [];
+  let updatedIndex = false;
+
+  for (const name of options.names) {
+    const kebabName = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+    const filePath = path.join(modelsDir, `${kebabName}.ts`);
+    const pascalName = toPascalCase(name);
+
+    if (fs.existsSync(filePath)) {
+      const overwriteMode = options.overwriteMode || "prompt";
+      const shouldOverwrite = overwriteMode === "always"
+        ? true
+        : overwriteMode === "never"
+          ? false
+          : options.confirmOverwrite
+            ? await options.confirmOverwrite(filePath)
+            : false;
+
+      if (!shouldOverwrite) {
+        skippedFiles.push(filePath.replace(/\\/g, "/"));
+        continue;
+      }
+    }
+
+    const content = options.connector && connectorType
+      ? generateConnectorModelTemplate(name, options.connector, connectorType)
+      : generateModelTemplate(name);
+    fs.writeFileSync(filePath, content, "utf-8");
+    createdFiles.push(filePath.replace(/\\/g, "/"));
+
+    if (updateSharedIndex(kebabName, pascalName)) {
+      updatedIndex = true;
+    }
+  }
+
+  await syncProjectManifest();
+
+  return {
+    createdFiles,
+    skippedFiles,
+    updatedIndex,
+    ...(connectorType ? { connectorType } : {}),
+  };
+}

package/src/core/operations/runtime.ts

@@ -0,0 +1,235 @@
+import * as fs from "fs";
+import * as path from "path";
+
+export interface CapturedConsoleMessages {
+  logs: string[];
+  warnings: string[];
+  errors: string[];
+}
+
+export interface FileMutationSummary {
+  createdFiles: string[];
+  updatedFiles: string[];
+  appendedFiles: string[];
+  deletedFiles: string[];
+  createdDirectories: string[];
+}
+
+export class ProcessExitInterceptError extends Error {
+  readonly exitCode: number;
+
+  constructor(exitCode: number) {
+    super(`Process exited with code ${exitCode}`);
+    this.name = "ProcessExitInterceptError";
+    this.exitCode = exitCode;
+  }
+}
+
+function formatConsoleArgs(args: unknown[]): string {
+  return args
+    .map((arg) => {
+      if (typeof arg === "string") {
+        return arg;
+      }
+
+      if (arg instanceof Error) {
+        return arg.stack || arg.message;
+      }
+
+      try {
+        return JSON.stringify(arg);
+      } catch {
+        return String(arg);
+      }
+    })
+    .join(" ");
+}
+
+function normalizePathForSummary(targetPath: string): string {
+  const relative = path.relative(process.cwd(), targetPath);
+  return relative && !relative.startsWith("..") ? relative.replace(/\\/g, "/") : targetPath.replace(/\\/g, "/");
+}
+
+interface FileSystemEntrySnapshot {
+  type: "file" | "directory";
+  mtimeMs: number;
+  size: number;
+}
+
+function snapshotFileSystem(rootDirectory: string): Map<string, FileSystemEntrySnapshot> {
+  const snapshot = new Map<string, FileSystemEntrySnapshot>();
+  const excludedDirectoryNames = new Set([".git", "node_modules"]);
+
+  function walk(currentDirectory: string): void {
+    for (const entry of fs.readdirSync(currentDirectory, { withFileTypes: true })) {
+      if (entry.isDirectory() && excludedDirectoryNames.has(entry.name)) {
+        continue;
+      }
+
+      const entryPath = path.join(currentDirectory, entry.name);
+      const stats = fs.statSync(entryPath);
+      snapshot.set(entryPath, {
+        type: entry.isDirectory() ? "directory" : "file",
+        mtimeMs: stats.mtimeMs,
+        size: stats.size,
+      });
+
+      if (entry.isDirectory()) {
+        walk(entryPath);
+      }
+    }
+  }
+
+  if (fs.existsSync(rootDirectory)) {
+    walk(rootDirectory);
+  }
+
+  return snapshot;
+}
+
+export async function withWorkingDirectory<T>(directory: string, action: () => Promise<T>): Promise<T> {
+  const originalDirectory = process.cwd();
+  process.chdir(directory);
+
+  try {
+    return await action();
+  } finally {
+    process.chdir(originalDirectory);
+  }
+}
+
+export async function captureConsoleMessages<T>(
+  action: () => Promise<T>
+): Promise<{ result: T; messages: CapturedConsoleMessages }> {
+  const messages: CapturedConsoleMessages = {
+    logs: [],
+    warnings: [],
+    errors: [],
+  };
+
+  const originalLog = console.log;
+  const originalWarn = console.warn;
+  const originalError = console.error;
+
+  console.log = (...args: unknown[]) => {
+    messages.logs.push(formatConsoleArgs(args));
+  };
+  console.warn = (...args: unknown[]) => {
+    messages.warnings.push(formatConsoleArgs(args));
+  };
+  console.error = (...args: unknown[]) => {
+    messages.errors.push(formatConsoleArgs(args));
+  };
+
+  try {
+    const result = await action();
+    return { result, messages };
+  } finally {
+    console.log = originalLog;
+    console.warn = originalWarn;
+    console.error = originalError;
+  }
+}
+
+export async function captureConsoleMessagesWithError<T>(
+  action: () => Promise<T>
+): Promise<{ result?: T; messages: CapturedConsoleMessages; error?: unknown }> {
+  const messages: CapturedConsoleMessages = {
+    logs: [],
+    warnings: [],
+    errors: [],
+  };
+
+  const originalLog = console.log;
+  const originalWarn = console.warn;
+  const originalError = console.error;
+
+  console.log = (...args: unknown[]) => {
+    messages.logs.push(formatConsoleArgs(args));
+  };
+  console.warn = (...args: unknown[]) => {
+    messages.warnings.push(formatConsoleArgs(args));
+  };
+  console.error = (...args: unknown[]) => {
+    messages.errors.push(formatConsoleArgs(args));
+  };
+
+  try {
+    return { result: await action(), messages };
+  } catch (error) {
+    return { messages, error };
+  } finally {
+    console.log = originalLog;
+    console.warn = originalWarn;
+    console.error = originalError;
+  }
+}
+
+export async function interceptProcessExit<T>(action: () => Promise<T>): Promise<T> {
+  const originalExit = process.exit;
+
+  process.exit = ((code?: number | string | null) => {
+    const normalizedCode = typeof code === "number"
+      ? code
+      : typeof process.exitCode === "number"
+        ? process.exitCode
+        : 1;
+    throw new ProcessExitInterceptError(normalizedCode);
+  }) as typeof process.exit;
+
+  try {
+    return await action();
+  } finally {
+    process.exit = originalExit;
+  }
+}
+
+export async function trackFileMutations<T>(
+  action: () => Promise<T>
+): Promise<{ result: T; mutations: FileMutationSummary }> {
+  const rootDirectory = process.cwd();
+  const before = snapshotFileSystem(rootDirectory);
+  const result = await action();
+  const after = snapshotFileSystem(rootDirectory);
+
+  const createdFiles = new Set<string>();
+  const updatedFiles = new Set<string>();
+  const deletedFiles = new Set<string>();
+  const createdDirectories = new Set<string>();
+
+  for (const [entryPath, afterEntry] of after.entries()) {
+    const beforeEntry = before.get(entryPath);
+    if (!beforeEntry) {
+      if (afterEntry.type === "directory") {
+        createdDirectories.add(normalizePathForSummary(entryPath));
+      } else {
+        createdFiles.add(normalizePathForSummary(entryPath));
+      }
+      continue;
+    }
+
+    if (
+      afterEntry.type === "file" &&
+      (beforeEntry.mtimeMs !== afterEntry.mtimeMs || beforeEntry.size !== afterEntry.size)
+    ) {
+      updatedFiles.add(normalizePathForSummary(entryPath));
+    }
+  }
+
+  for (const [entryPath, beforeEntry] of before.entries()) {
+    if (!after.has(entryPath) && beforeEntry.type === "file") {
+      deletedFiles.add(normalizePathForSummary(entryPath));
+    }
+  }
+
+  return {
+    result,
+    mutations: {
+      createdFiles: Array.from(createdFiles).sort(),
+      updatedFiles: Array.from(updatedFiles).sort(),
+      appendedFiles: [],
+      deletedFiles: Array.from(deletedFiles).sort(),
+      createdDirectories: Array.from(createdDirectories).sort(),
+    },
+  };
+}

package/src/core/operations/scaffold-machine.ts

@@ -0,0 +1,91 @@
+import { scaffoldCommand } from "../../cli/commands/scaffold";
+import {
+  captureConsoleMessagesWithError,
+  interceptProcessExit,
+  ProcessExitInterceptError,
+  trackFileMutations,
+} from "./runtime";
+
+export interface MachineScaffoldOperationOptions {
+  model: string;
+  functionsDir?: string;
+  apiDir?: string;
+  apiOnly?: boolean;
+}
+
+export interface MachineScaffoldOperationResult {
+  createdFiles: string[];
+  updatedFiles: string[];
+  appendedFiles: string[];
+  deletedFiles: string[];
+  createdDirectories: string[];
+  diagnostics: string[];
+}
+
+function deriveErrorMessage(messages: { errors: string[]; warnings: string[]; logs: string[] }): string {
+  const errorText = messages.errors[messages.errors.length - 1];
+  if (errorText) {
+    return errorText.replace(/^\s*❌\s*/, "").trim();
+  }
+
+  const warningText = messages.warnings[messages.warnings.length - 1];
+  if (warningText) {
+    return warningText.trim();
+  }
+
+  const logText = messages.logs[messages.logs.length - 1];
+  if (logText) {
+    return logText.trim();
+  }
+
+  return "Scaffold failed.";
+}
+
+export async function runMachineScaffoldOperation(
+  options: MachineScaffoldOperationOptions
+): Promise<MachineScaffoldOperationResult> {
+  const originalMachineOutput = process.env.SWALLOWKIT_MACHINE_OUTPUT;
+  process.env.SWALLOWKIT_MACHINE_OUTPUT = "1";
+
+  try {
+    const tracked = await trackFileMutations(async () => {
+      const captured = await captureConsoleMessagesWithError(async () => {
+        await interceptProcessExit(async () => {
+          await scaffoldCommand(options);
+        });
+      });
+
+      if (captured.error) {
+        if (captured.error instanceof ProcessExitInterceptError) {
+          throw new Error(deriveErrorMessage(captured.messages));
+        }
+
+        if (captured.error instanceof Error) {
+          throw captured.error;
+        }
+
+        throw new Error(deriveErrorMessage(captured.messages));
+      }
+
+      return captured.messages;
+    });
+
+    return {
+      createdFiles: tracked.mutations.createdFiles,
+      updatedFiles: tracked.mutations.updatedFiles,
+      appendedFiles: tracked.mutations.appendedFiles,
+      deletedFiles: tracked.mutations.deletedFiles,
+      createdDirectories: tracked.mutations.createdDirectories,
+      diagnostics: [
+        ...tracked.result.warnings.map((warning) => `warning:${warning}`),
+        ...tracked.result.errors.map((error) => `error:${error}`),
+      ],
+    };
+  } finally {
+    if (originalMachineOutput === undefined) {
+      delete process.env.SWALLOWKIT_MACHINE_OUTPUT;
+    } else {
+      process.env.SWALLOWKIT_MACHINE_OUTPUT = originalMachineOutput;
+    }
+  }
+}