swallowkit 1.0.0-beta.9 → 1.0.0

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

@@ -0,0 +1,191 @@
+import * as path from "path";
+import { ensureSwallowKitProject, loadConfig } from "../config";
+import { toPascalCase } from "../scaffold/model-parser";
+import { syncProjectManifest } from "../project/manifest";
+import { recordSessionOperations } from "../project/artifacts";
+import { FileOperationSession, getActiveFileSession } from "./file-session";
+
+const CREATE_MODEL_GENERATOR = "create-model";
+
+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, session: FileOperationSession): boolean {
+  const indexPath = path.join(process.cwd(), "shared", "index.ts");
+
+  if (!session.fileExists(indexPath)) {
+    return false;
+  }
+
+  const content = session.readFile(indexPath);
+  const exportLine = `export { ${pascalName} } from './models/${kebabName}';`;
+
+  if (content.includes(exportLine)) {
+    return false;
+  }
+
+  session.writeFile(indexPath, `${content}${exportLine}\n`, {
+    ownership: "extension-point",
+    generator: CREATE_MODEL_GENERATOR,
+  });
+  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";
+
+  const session = getActiveFileSession() ?? new FileOperationSession("commit");
+  // jest 等の環境で path.resolve の内部 cwd キャッシュが process.chdir と食い違うことが
+  // あるため、cwd を明示的に固定して絶対パスを組み立てる。
+  const projectRoot = process.cwd();
+  const resolveFromRoot = (relativePath: string) =>
+    path.isAbsolute(relativePath) ? relativePath : path.join(projectRoot, relativePath);
+
+  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 (session.fileExists(resolveFromRoot(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);
+    session.writeFile(resolveFromRoot(filePath), content, {
+      ownership: "user-owned",
+      generator: CREATE_MODEL_GENERATOR,
+      sourceModel: pascalName,
+    });
+    createdFiles.push(filePath.replace(/\\/g, "/"));
+
+    if (updateSharedIndex(kebabName, pascalName, session)) {
+      updatedIndex = true;
+    }
+  }
+
+  if (session.mode === "commit") {
+    recordSessionOperations(session.operations, {});
+    await syncProjectManifest();
+  }
+
+  return {
+    createdFiles,
+    skippedFiles,
+    updatedIndex,
+    ...(connectorType ? { connectorType } : {}),
+  };
+}

package/src/core/operations/file-session.ts

@@ -0,0 +1,222 @@
+/**
+ * FileOperationSession — SwallowKit generator 由来のファイル書き込みを一元管理する抽象。
+ *
+ * - mode "commit": 従来どおりディスクへ書き込みつつ、操作を記録する。
+ * - mode "collect": ディスクへは一切書き込まず、仮想オーバーレイ上で操作を収集する(Plan / dry-run 用)。
+ *
+ * すべての生成物には Artifact Ownership を付与し、Plan/Apply/Drift 検出の基礎データとする。
+ */
+
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+
+export type FileSessionMode = "commit" | "collect";
+
+export type ArtifactOwnership =
+  | "managed"
+  | "generated-once"
+  | "user-owned"
+  | "extension-point"
+  | "metadata";
+
+export type FileSessionActionKind = "create" | "modify" | "append" | "delete" | "skip";
+
+export interface FileWriteMeta {
+  ownership: ArtifactOwnership;
+  generator: string;
+  sourceModel?: string;
+}
+
+export interface RecordedFileOperation {
+  /** Project-relative POSIX path */
+  path: string;
+  absolutePath: string;
+  action: FileSessionActionKind;
+  ownership: ArtifactOwnership;
+  generator: string;
+  sourceModel?: string;
+  existedBefore: boolean;
+  /** sha256 (LF normalized) of on-disk content before the session touched the file */
+  previousHash: string | null;
+  /** sha256 (LF normalized) of the new content; null for delete */
+  newHash: string | null;
+}
+
+export function normalizeContentForHash(content: string): string {
+  return content.replace(/\r\n/g, "\n");
+}
+
+export function hashContent(content: string): string {
+  return crypto.createHash("sha256").update(normalizeContentForHash(content), "utf-8").digest("hex");
+}
+
+export function hashFileIfExists(absolutePath: string): string | null {
+  try {
+    if (!fs.existsSync(absolutePath) || !fs.statSync(absolutePath).isFile()) {
+      return null;
+    }
+    return hashContent(fs.readFileSync(absolutePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+export function toProjectRelativePath(rootDirectory: string, absolutePath: string): string {
+  const relative = path.relative(rootDirectory, absolutePath);
+  return relative && !relative.startsWith("..")
+    ? relative.replace(/\\/g, "/")
+    : absolutePath.replace(/\\/g, "/");
+}
+
+export class FileOperationSession {
+  readonly mode: FileSessionMode;
+  readonly rootDirectory: string;
+  readonly warnings: string[] = [];
+
+  private readonly operationsByPath = new Map<string, RecordedFileOperation>();
+  private readonly inputFingerprintsByPath = new Map<string, string | null>();
+  /** overlay: absolute normalized path -> content (null = deleted in session) */
+  private readonly overlay = new Map<string, string | null>();
+
+  constructor(mode: FileSessionMode, rootDirectory: string = process.cwd()) {
+    this.mode = mode;
+    this.rootDirectory = rootDirectory;
+  }
+
+  get operations(): RecordedFileOperation[] {
+    return Array.from(this.operationsByPath.values()).sort((a, b) => a.path.localeCompare(b.path));
+  }
+
+  get inputFingerprints(): Record<string, string | null> {
+    return Object.fromEntries(
+      Array.from(this.inputFingerprintsByPath.entries()).sort(([left], [right]) => left.localeCompare(right))
+    );
+  }
+
+  addWarning(message: string): void {
+    if (!this.warnings.includes(message)) {
+      this.warnings.push(message);
+    }
+  }
+
+  registerInput(absolutePath: string): void {
+    const relativePath = toProjectRelativePath(this.rootDirectory, absolutePath);
+    this.inputFingerprintsByPath.set(relativePath, hashFileIfExists(absolutePath));
+  }
+
+  private overlayKey(absolutePath: string): string {
+    return path.resolve(absolutePath);
+  }
+
+  fileExists(absolutePath: string): boolean {
+    const key = this.overlayKey(absolutePath);
+    if (this.overlay.has(key)) {
+      return this.overlay.get(key) !== null;
+    }
+    return fs.existsSync(absolutePath);
+  }
+
+  readFile(absolutePath: string): string {
+    const key = this.overlayKey(absolutePath);
+    if (this.overlay.has(key)) {
+      const content = this.overlay.get(key);
+      if (content === null || content === undefined) {
+        throw new Error(`File was deleted in this session: ${absolutePath}`);
+      }
+      return content;
+    }
+    return fs.readFileSync(absolutePath, "utf-8");
+  }
+
+  writeFile(absolutePath: string, content: string, meta: FileWriteMeta): RecordedFileOperation {
+    const key = this.overlayKey(absolutePath);
+    const relativePath = toProjectRelativePath(this.rootDirectory, absolutePath);
+    const existing = this.operationsByPath.get(relativePath);
+
+    const existedBefore = existing ? existing.existedBefore : fs.existsSync(absolutePath);
+    const previousHash = existing ? existing.previousHash : hashFileIfExists(absolutePath);
+    const newHash = hashContent(content);
+
+    let action: FileSessionActionKind;
+    if (!existedBefore) {
+      action = "create";
+    } else if (newHash === previousHash) {
+      action = "skip";
+    } else if (meta.ownership === "extension-point") {
+      action = "append";
+    } else {
+      action = "modify";
+    }
+
+    const operation: RecordedFileOperation = {
+      path: relativePath,
+      absolutePath,
+      action,
+      ownership: meta.ownership,
+      generator: meta.generator,
+      sourceModel: meta.sourceModel ?? existing?.sourceModel,
+      existedBefore,
+      previousHash,
+      newHash,
+    };
+    this.operationsByPath.set(relativePath, operation);
+    this.overlay.set(key, content);
+
+    if (this.mode === "commit" && action !== "skip") {
+      fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+      fs.writeFileSync(absolutePath, content, "utf-8");
+    }
+
+    return operation;
+  }
+
+  deleteFile(absolutePath: string, meta: FileWriteMeta): RecordedFileOperation | null {
+    if (!this.fileExists(absolutePath)) {
+      return null;
+    }
+
+    const key = this.overlayKey(absolutePath);
+    const relativePath = toProjectRelativePath(this.rootDirectory, absolutePath);
+    const existing = this.operationsByPath.get(relativePath);
+
+    const operation: RecordedFileOperation = {
+      path: relativePath,
+      absolutePath,
+      action: "delete",
+      ownership: meta.ownership,
+      generator: meta.generator,
+      sourceModel: meta.sourceModel ?? existing?.sourceModel,
+      existedBefore: existing ? existing.existedBefore : true,
+      previousHash: existing ? existing.previousHash : hashFileIfExists(absolutePath),
+      newHash: null,
+    };
+    this.operationsByPath.set(relativePath, operation);
+    this.overlay.set(key, null);
+
+    if (this.mode === "commit" && fs.existsSync(absolutePath)) {
+      fs.unlinkSync(absolutePath);
+    }
+
+    return operation;
+  }
+}
+
+let activeSession: FileOperationSession | null = null;
+
+export function getActiveFileSession(): FileOperationSession | null {
+  return activeSession;
+}
+
+export async function runWithFileSession<T>(
+  session: FileOperationSession,
+  action: () => Promise<T>
+): Promise<T> {
+  const previous = activeSession;
+  activeSession = session;
+  try {
+    return await action();
+  } finally {
+    activeSession = previous;
+  }
+}

package/src/core/operations/provision-operations.ts

@@ -0,0 +1,297 @@
+/**
+ * Plan / Apply Provision — Azure プロビジョニングの事前計画と承認付き実行。
+ *
+ * - plan provision: ローカルの決定論的プリフライト(Bicep 解析・az CLI 有無)のみ。
+ *   ネットワークアクセスや az login を必要とする操作は行わない。
+ *   --what-if を明示した場合のみ az deployment group what-if を実行する。
+ * - apply provision: 常に承認(--approve)必須。承認なしでは requires-human で停止する。
+ */
+
+import * as crypto from "crypto";
+import * as path from "path";
+import { spawnSync } from "child_process";
+import { MachineCommandError } from "../../machine/errors";
+import { getSwallowKitVersion } from "../../version";
+import { inspectInfra, InfraInspection } from "../project/infra";
+import { deletePlanState, loadPlanState, savePlanState } from "../project/state";
+import { hashFileIfExists } from "./file-session";
+
+const RESOURCE_GROUP_PATTERN = /^[A-Za-z0-9._()-]{1,90}$/;
+const LOCATION_PATTERN = /^[a-z0-9]{3,30}$/;
+const SUBSCRIPTION_PATTERN = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+
+export interface PlanProvisionOptions {
+  resourceGroup: string;
+  location: string;
+  swaLocation: string;
+  subscription?: string;
+  /** 明示指定時のみ az deployment group what-if を実行(az login 済みが前提) */
+  whatIf?: boolean;
+}
+
+export interface ProvisionPlanData {
+  planId: string;
+  planType: "provision";
+  resourceGroup: string;
+  location: string;
+  swaLocation: string;
+  subscription?: string;
+  createdAt: string;
+  swallowkitVersion: string;
+  azCliAvailable: boolean;
+  infra: InfraInspection;
+  /** apply 時に実行されるコマンド(レビュー用) */
+  commands: string[];
+  whatIfResult?: string;
+  warnings: string[];
+  /** provision は常に人間の承認が必要 */
+  requiresApproval: true;
+  fingerprints: Record<string, string | null>;
+}
+
+function validateProvisionInputs(options: PlanProvisionOptions): void {
+  if (!RESOURCE_GROUP_PATTERN.test(options.resourceGroup)) {
+    throw new MachineCommandError(
+      "invalid-arguments",
+      `Invalid resource group name: ${options.resourceGroup}`,
+      undefined,
+      "failed"
+    );
+  }
+  if (!LOCATION_PATTERN.test(options.location) || !LOCATION_PATTERN.test(options.swaLocation)) {
+    throw new MachineCommandError(
+      "invalid-arguments",
+      "Locations must be lowercase Azure region names (e.g. japaneast, eastasia).",
+      undefined,
+      "failed"
+    );
+  }
+  if (options.subscription && !SUBSCRIPTION_PATTERN.test(options.subscription)) {
+    throw new MachineCommandError(
+      "invalid-arguments",
+      "Subscription must be a GUID.",
+      undefined,
+      "failed"
+    );
+  }
+}
+
+function isAzCliAvailable(): boolean {
+  try {
+    const result = spawnSync("az", ["--version"], { shell: true, stdio: "ignore", timeout: 30_000 });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+
+function buildProvisionCommands(options: PlanProvisionOptions, mainBicepPath: string, parametersPath: string): string[] {
+  const commands: string[] = [];
+  if (options.subscription) {
+    commands.push(`az account set --subscription ${options.subscription}`);
+  }
+  commands.push(`az group create --name ${options.resourceGroup} --location ${options.location}`);
+  commands.push(
+    `az deployment group create --resource-group ${options.resourceGroup} --template-file "${mainBicepPath}" --parameters "${parametersPath}" --parameters location=${options.location} --parameters swaLocation=${options.swaLocation}`
+  );
+  return commands;
+}
+
+export async function planProvisionOperation(options: PlanProvisionOptions): Promise<ProvisionPlanData> {
+  const projectRoot = process.cwd();
+  validateProvisionInputs(options);
+
+  const infra = inspectInfra(projectRoot);
+  const warnings = [...infra.warnings];
+
+  if (!infra.mainBicep.exists) {
+    throw new MachineCommandError(
+      "infra-not-found",
+      'infra/main.bicep not found. Run "swallowkit init" to generate infrastructure files.',
+      undefined,
+      "blocked"
+    );
+  }
+  if (!infra.parametersFile.exists) {
+    warnings.push("infra/main.parameters.json not found; deployment will fail until it is created.");
+  }
+
+  const azCliAvailable = isAzCliAvailable();
+  if (!azCliAvailable) {
+    warnings.push("az-cli-not-found: Azure CLI is not installed. Install it before applying: https://aka.ms/azure-cli");
+  }
+
+  const mainBicepPath = path.join(projectRoot, "infra", "main.bicep");
+  const parametersPath = path.join(projectRoot, "infra", "main.parameters.json");
+  const commands = buildProvisionCommands(options, mainBicepPath, parametersPath);
+
+  let whatIfResult: string | undefined;
+  if (options.whatIf) {
+    if (!azCliAvailable) {
+      throw new MachineCommandError(
+        "az-cli-not-found",
+        "Azure CLI is required for --what-if. Install it first: https://aka.ms/azure-cli",
+        undefined,
+        "blocked"
+      );
+    }
+    const whatIfArgs = [
+      "deployment", "group", "what-if",
+      "--resource-group", options.resourceGroup,
+      "--template-file", `"${mainBicepPath}"`,
+      "--parameters", `"${parametersPath}"`,
+      "--parameters", `location=${options.location}`,
+      "--parameters", `swaLocation=${options.swaLocation}`,
+      "--no-pretty-print",
+    ];
+    const result = spawnSync("az", whatIfArgs, { shell: true, encoding: "utf-8", timeout: 300_000 });
+    if (result.status !== 0) {
+      throw new MachineCommandError(
+        "what-if-failed",
+        `az deployment group what-if failed: ${(result.stderr || result.stdout || "").trim().slice(0, 2000)}`,
+        undefined,
+        "blocked"
+      );
+    }
+    whatIfResult = (result.stdout || "").trim();
+  }
+
+  const fingerprints: Record<string, string | null> = {
+    "infra/main.bicep": hashFileIfExists(mainBicepPath),
+    "infra/main.parameters.json": hashFileIfExists(parametersPath),
+  };
+
+  const planId = crypto
+    .createHash("sha256")
+    .update(
+      JSON.stringify({
+        resourceGroup: options.resourceGroup,
+        location: options.location,
+        swaLocation: options.swaLocation,
+        subscription: options.subscription,
+        fingerprints,
+      })
+    )
+    .digest("hex")
+    .slice(0, 12);
+
+  const plan: ProvisionPlanData = {
+    planId,
+    planType: "provision",
+    resourceGroup: options.resourceGroup,
+    location: options.location,
+    swaLocation: options.swaLocation,
+    ...(options.subscription ? { subscription: options.subscription } : {}),
+    createdAt: new Date().toISOString(),
+    swallowkitVersion: getSwallowKitVersion(),
+    azCliAvailable,
+    infra,
+    commands,
+    ...(whatIfResult !== undefined ? { whatIfResult } : {}),
+    warnings,
+    requiresApproval: true,
+    fingerprints,
+  };
+
+  savePlanState(plan, projectRoot);
+  return plan;
+}
+
+export interface ApplyProvisionOptions {
+  planId: string;
+  approve?: boolean;
+}
+
+export interface ApplyProvisionResult {
+  planId: string;
+  resourceGroup: string;
+  location: string;
+  swaLocation: string;
+  executedCommands: string[];
+  deploymentOutputs?: Record<string, unknown>;
+  warnings: string[];
+}
+
+export async function applyProvisionOperation(options: ApplyProvisionOptions): Promise<ApplyProvisionResult> {
+  const projectRoot = process.cwd();
+
+  const plan = loadPlanState<ProvisionPlanData>(options.planId, projectRoot);
+  if (!plan) {
+    throw new MachineCommandError(
+      "plan-not-found",
+      `Plan "${options.planId}" was not found. Run "plan provision" to create a new plan.`,
+      { planId: options.planId },
+      "blocked"
+    );
+  }
+
+  // Bicep が plan 後に変更されていないか確認
+  const changedFiles: string[] = [];
+  for (const [relativePath, expectedHash] of Object.entries(plan.fingerprints)) {
+    const currentHash = hashFileIfExists(path.join(projectRoot, relativePath));
+    if (currentHash !== expectedHash) changedFiles.push(relativePath);
+  }
+  if (changedFiles.length > 0) {
+    throw new MachineCommandError(
+      "stale-plan",
+      `Plan "${options.planId}" is stale: ${changedFiles.join(", ")} changed after the plan was created. Re-run "plan provision".`,
+      { planId: options.planId, changedFiles },
+      "blocked"
+    );
+  }
+
+  if (!options.approve) {
+    throw new MachineCommandError(
+      "approval-required",
+      "Provisioning creates billable Azure resources and always requires human approval. Review plan.commands and re-run with --approve.",
+      { planId: plan.planId, commands: plan.commands },
+      "requires-human"
+    );
+  }
+
+  if (!isAzCliAvailable()) {
+    throw new MachineCommandError(
+      "az-cli-not-found",
+      "Azure CLI is not installed. Install it first: https://aka.ms/azure-cli",
+      undefined,
+      "blocked"
+    );
+  }
+
+  const executedCommands: string[] = [];
+  const warnings = [...plan.warnings];
+  let deploymentOutputs: Record<string, unknown> | undefined;
+
+  for (const command of plan.commands) {
+    const result = spawnSync(command, [], { shell: true, encoding: "utf-8" });
+    executedCommands.push(command);
+    if (result.status !== 0) {
+      throw new MachineCommandError(
+        "provision-failed",
+        `Command failed: ${command}\n${(result.stderr || result.stdout || "").trim().slice(0, 4000)}`,
+        { executedCommands },
+        "failed"
+      );
+    }
+    if (command.includes("deployment group create")) {
+      try {
+        const deployment = JSON.parse(result.stdout || "{}");
+        deploymentOutputs = deployment.properties?.outputs;
+      } catch {
+        warnings.push("Could not parse deployment output JSON.");
+      }
+    }
+  }
+
+  deletePlanState(plan.planId, projectRoot);
+
+  return {
+    planId: plan.planId,
+    resourceGroup: plan.resourceGroup,
+    location: plan.location,
+    swaLocation: plan.swaLocation,
+    executedCommands,
+    ...(deploymentOutputs ? { deploymentOutputs } : {}),
+    warnings,
+  };
+}