swallowkit 1.0.0-beta.6 → 1.0.0-beta.61

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

@@ -0,0 +1,159 @@
+/**
+ * SwallowKit Add-Connector コマンド
+ * swallowkit.config.js にコネクタ設定を追加する
+ */
+
+import * as fs from "fs";
+import { detectFromProject, getCommands } from "../../utils/package-manager";
+import * as path from "path";
+import { ensureSwallowKitProject } from "../../core/config";
+import { ApiConnectorConfig, ConnectorDefinition } from "../../types";
+import { syncProjectManifest } from "../../core/project/manifest";
+
+interface AddConnectorOptions {
+  name: string;
+  type: "rdb" | "api";
+  provider?: "mysql" | "postgres" | "sqlserver";
+}
+
+/**
+ * add-connector コマンド
+ */
+export async function addConnectorCommand(options: AddConnectorOptions) {
+  ensureSwallowKitProject("add-connector");
+
+  console.log(`🔌 SwallowKit Add-Connector: Adding '${options.name}' connector...\n`);
+
+  const configPath = findConfigFile();
+  if (!configPath) {
+    console.error("❌ swallowkit.config.js not found. Run 'swallowkit init' first.");
+    process.exit(1);
+  }
+
+  // Build connector definition
+  const connectorDef = buildConnectorDefinition(options);
+
+  // Update config file
+  updateConfigWithConnector(configPath, options.name, connectorDef);
+  await syncProjectManifest();
+
+  console.log(`\n✅ Connector '${options.name}' added successfully!`);
+  console.log("\n📝 Next steps:");
+  console.log(`  1. Review the connector settings in ${configPath}`);
+  console.log(`  2. Set the required environment variables in functions/local.settings.json`);
+  console.log(`  3. Create models with: ${getCommands(detectFromProject()).exec} swallowkit create-model <name> --connector=${options.name}`);
+}
+
+function findConfigFile(): string | null {
+  const candidates = ["swallowkit.config.js", "swallowkit.config.json", ".swallowkitrc.json"];
+  for (const candidate of candidates) {
+    const fullPath = path.resolve(process.cwd(), candidate);
+    if (fs.existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+
+function buildConnectorDefinition(options: AddConnectorOptions): ConnectorDefinition {
+  const name = options.name.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+
+  if (options.type === "rdb") {
+    return {
+      type: "rdb",
+      provider: options.provider || "mysql",
+      connectionEnvVar: `${name}_CONNECTION_STRING`,
+    };
+  }
+
+  return {
+    type: "api",
+    baseUrlEnvVar: `${name}_API_BASE_URL`,
+    auth: {
+      type: "apiKey",
+      envVar: `${name}_API_KEY`,
+      placement: "query",
+      paramName: "apiKey",
+    },
+  };
+}
+
+/**
+ * swallowkit.config.js にコネクタ設定を追加
+ */
+export function updateConfigWithConnector(
+  configPath: string,
+  connectorName: string,
+  connectorDef: ConnectorDefinition
+): void {
+  const content = fs.readFileSync(configPath, "utf-8");
+
+  if (configPath.endsWith(".json")) {
+    // JSON config
+    const config = JSON.parse(content);
+    if (!config.connectors) {
+      config.connectors = {};
+    }
+    config.connectors[connectorName] = connectorDef;
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+    console.log(`✅ Updated: ${configPath}`);
+    return;
+  }
+
+  // JS config — append connectors section
+  if (content.includes("connectors:") || content.includes("connectors :")) {
+    console.log(`⚠️  'connectors' section already exists in ${configPath}. Please add the connector manually:`);
+    console.log(formatConnectorSnippet(connectorName, connectorDef));
+    return;
+  }
+
+  // Find the last property before the closing of module.exports
+  const closingBraceIdx = content.lastIndexOf("}");
+  if (closingBraceIdx === -1) {
+    console.error("❌ Could not parse config file structure. Please add the connector manually:");
+    console.log(formatConnectorSnippet(connectorName, connectorDef));
+    return;
+  }
+
+  // Check if we need a comma before inserting
+  const beforeClosing = content.substring(0, closingBraceIdx).trimEnd();
+  const needsComma = !beforeClosing.endsWith(",") && !beforeClosing.endsWith("{");
+
+  const connectorBlock = generateConnectorJSBlock(connectorName, connectorDef);
+  const insertion = `${needsComma ? "," : ""}\n  // コネクタ定義\n  connectors: {\n${connectorBlock}\n  },\n`;
+
+  const newContent = content.substring(0, closingBraceIdx) + insertion + content.substring(closingBraceIdx);
+  fs.writeFileSync(configPath, newContent, "utf-8");
+  console.log(`✅ Updated: ${configPath}`);
+}
+
+function generateConnectorJSBlock(name: string, def: ConnectorDefinition): string {
+  if (def.type === "rdb") {
+    return `    ${name}: {
+      type: 'rdb',
+      provider: '${def.provider}',
+      connectionEnvVar: '${def.connectionEnvVar}',
+    },`;
+  }
+
+  const apiDef: ApiConnectorConfig = def;
+  let authBlock = "";
+  if (apiDef.auth) {
+    authBlock = `
+      auth: {
+        type: '${apiDef.auth.type}',
+        envVar: '${apiDef.auth.envVar}',
+        placement: '${apiDef.auth.placement || "query"}',
+        paramName: '${apiDef.auth.paramName || "apiKey"}',
+      },`;
+  }
+
+  return `    ${name}: {
+      type: 'api',
+      baseUrlEnvVar: '${apiDef.baseUrlEnvVar}',${authBlock}
+    },`;
+}
+
+function formatConnectorSnippet(name: string, def: ConnectorDefinition): string {
+  return `\n  ${name}: ${JSON.stringify(def, null, 4)}\n`;
+}

package/src/cli/commands/cosmos-worktree-isolation.ts

@@ -0,0 +1,130 @@
+import { execFileSync } from "child_process";
+import { createHash } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+
+const WORKTREE_HASH_LENGTH = 8;
+
+export interface GitWorktreeInfo {
+  worktreeRoot: string;
+  gitDir: string;
+  gitCommonDir: string;
+  isLinkedWorktree: boolean;
+}
+
+export interface CosmosDatabaseNameResolution {
+  databaseName: string;
+  worktreeIsolationEnabled: boolean;
+  worktreeRoot?: string;
+}
+
+export type GitCommandRunner = (args: string[], cwd: string) => string;
+
+const runGitCommand: GitCommandRunner = (args, cwd) =>
+  execFileSync("git", args, {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "ignore"],
+    windowsHide: true,
+  });
+
+/**
+ * Resolve Git's worktree metadata without relying on whether .git is a file or
+ * directory. A linked worktree has a per-worktree Git directory that differs
+ * from the repository's common Git directory.
+ */
+export function resolveGitWorktreeInfo(
+  cwd: string = process.cwd(),
+  runGit: GitCommandRunner = runGitCommand
+): GitWorktreeInfo | null {
+  try {
+    const output = runGit(
+      [
+        "rev-parse",
+        "--show-toplevel",
+        "--absolute-git-dir",
+        "--git-common-dir",
+      ],
+      cwd
+    );
+    const lines = output.split(/\r?\n/).map((line) => line.trim());
+    const [worktreeRootOutput, gitDirOutput, gitCommonDirOutput] = lines;
+
+    if (!worktreeRootOutput || !gitDirOutput || !gitCommonDirOutput) {
+      return null;
+    }
+
+    const worktreeRoot = canonicalizePath(worktreeRootOutput, cwd);
+    const gitDir = canonicalizePath(gitDirOutput, cwd);
+    const gitCommonDir = canonicalizePath(gitCommonDirOutput, cwd);
+
+    return {
+      worktreeRoot,
+      gitDir,
+      gitCommonDir,
+      isLinkedWorktree: gitDir !== gitCommonDir,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Produce a stable, database-safe identifier for a canonical worktree path.
+ */
+export function createWorktreePathHash(worktreeRoot: string): string {
+  return createHash("sha256")
+    .update(canonicalizePath(worktreeRoot), "utf-8")
+    .digest("hex")
+    .slice(0, WORKTREE_HASH_LENGTH);
+}
+
+export function applyCosmosDatabaseWorktreeIsolation(
+  baseDatabaseName: string,
+  worktreeInfo: GitWorktreeInfo | null
+): CosmosDatabaseNameResolution {
+  if (!worktreeInfo?.isLinkedWorktree) {
+    return {
+      databaseName: baseDatabaseName,
+      worktreeIsolationEnabled: false,
+    };
+  }
+
+  const suffix = createWorktreePathHash(worktreeInfo.worktreeRoot);
+  return {
+    databaseName: `${baseDatabaseName}_${suffix}`,
+    worktreeIsolationEnabled: true,
+    worktreeRoot: worktreeInfo.worktreeRoot,
+  };
+}
+
+export function resolveCosmosDatabaseNameForWorktree(
+  baseDatabaseName: string,
+  cwd: string = process.cwd(),
+  runGit: GitCommandRunner = runGitCommand
+): CosmosDatabaseNameResolution {
+  return applyCosmosDatabaseWorktreeIsolation(
+    baseDatabaseName,
+    resolveGitWorktreeInfo(cwd, runGit)
+  );
+}
+
+function canonicalizePath(
+  value: string,
+  basePath: string = process.cwd()
+): string {
+  const absolutePath = path.resolve(basePath, value);
+  let canonicalPath = absolutePath;
+
+  try {
+    canonicalPath = fs.realpathSync.native(absolutePath);
+  } catch {
+    // Git metadata can disappear between discovery and normalization. The
+    // normalized absolute path remains a stable fallback for this invocation.
+  }
+
+  const normalizedPath = path.normalize(canonicalPath).normalize("NFC");
+  return process.platform === "win32"
+    ? normalizedPath.toLowerCase()
+    : normalizedPath;
+}

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

@@ -0,0 +1,62 @@
+import * as readline from "readline";
+import { createModelOperation } from "../../core/operations/create-model";
+import { detectFromProject, getCommands } from "../../utils/package-manager";
+
+interface CreateModelOptions {
+  names: string[]; // モデル名のリスト（例: ["todo", "user", "post"]）
+  modelsDir?: string; // モデルディレクトリ（デフォルト: "shared/models"）
+  connector?: string; // コネクタ名（例: "mysql", "backlog"）
+}
+
+/**
+ * ユーザーに確認を求める
+ */
+function askConfirmation(question: string): Promise<boolean> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+
+/**
+ * create-model コマンド
+ */
+export async function createModelCommand(options: CreateModelOptions) {
+  console.log("🏗️  SwallowKit Create-Model: Generating model templates...\n");
+
+  const result = await createModelOperation({
+    names: options.names,
+    modelsDir: options.modelsDir,
+    connector: options.connector,
+    overwriteMode: "prompt",
+    confirmOverwrite: async (filePath) => askConfirmation(`⚠️  File ${filePath} already exists. Overwrite? (y/N): `),
+  });
+
+  // サマリー表示
+  console.log("\n📋 Summary:");
+  if (result.connectorType && options.connector) {
+    console.log(`  🔌 Connector: ${options.connector} (${result.connectorType})`);
+  }
+  if (result.createdFiles.length > 0) {
+    console.log(`  ✅ Created ${result.createdFiles.length} model(s): ${result.createdFiles.join(", ")}`);
+  }
+  if (result.skippedFiles.length > 0) {
+    console.log(`  ⏭️  Skipped ${result.skippedFiles.length} model(s): ${result.skippedFiles.join(", ")}`);
+  }
+  if (result.updatedIndex) {
+    console.log("  📦 Updated shared/index.ts");
+  }
+
+  if (result.createdFiles.length > 0) {
+    console.log("\n📝 Next steps:");
+    console.log("  1. Customize the generated model fields in shared/models/");
+    console.log(`  2. Run '${getCommands(detectFromProject()).exec} swallowkit scaffold <model>' to generate CRUD code`);
+  }
+}