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

package/src/cli/index.ts

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+
+import { execSync } from "child_process";
+import { Command } from "commander";
+import { initCommand, devCommand, devSeedsCommand, scaffoldCommand, createModelCommand } from "./commands";
+import { provisionCommand } from "./commands/provision";
+import { addConnectorCommand } from "./commands/add-connector";
+import { addAuthCommand } from "./commands/add-auth";
+import { isMachineCommand, runMachineCli } from "../machine";
+
+export const CLI_VERSION = require("../../package.json").version as string;
+
+const DEV_OPTION_ARITY = new Map<string, 0 | 1>([
+  ["-p", 1],
+  ["--port", 1],
+  ["-f", 1],
+  ["--functions-port", 1],
+  ["--host", 1],
+  ["--seed-env", 1],
+  ["-o", 0],
+  ["--open", 0],
+  ["-v", 0],
+  ["--verbose", 0],
+  ["--no-functions", 0],
+  ["--mock-connectors", 0],
+]);
+
+function ensureUtf8ConsoleOnWindows(): void {
+  if (process.platform === 'win32') {
+    try {
+      execSync('chcp 65001', { stdio: 'ignore' });
+    } catch {
+      // ignore — non-critical
+    }
+  }
+}
+
+function isDevOptionSequence(tokens: string[]): boolean {
+  if (tokens.length === 0) {
+    return false;
+  }
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    const arity = DEV_OPTION_ARITY.get(token);
+
+    if (arity === undefined) {
+      return false;
+    }
+
+    if (arity === 1) {
+      const value = tokens[index + 1];
+      if (value === undefined || value === "dev") {
+        return false;
+      }
+      index += 1;
+    }
+  }
+
+  return true;
+}
+
+export function normalizeDevCommandArgv(argv: string[]): string[] {
+  if (argv.length <= 3) {
+    return argv;
+  }
+
+  const prefix = argv.slice(0, 2);
+  const args = argv.slice(2);
+  const devIndex = args.indexOf("dev");
+
+  if (devIndex <= 0) {
+    return argv;
+  }
+
+  const leadingTokens = args.slice(0, devIndex);
+  if (!isDevOptionSequence(leadingTokens)) {
+    return argv;
+  }
+
+  return [
+    ...prefix,
+    "dev",
+    ...leadingTokens,
+    ...args.slice(devIndex + 1),
+  ];
+}
+
+export function createProgram(devCommandOverride: Command = devCommand): Command {
+  const program = new Command();
+
+  program
+    .name("swallowkit")
+    .description("Next.js framework optimized for Azure deployment - Automatically splits SSR into individual Azure Functions")
+    .version(CLI_VERSION);
+
+  // Register commands
+  program
+    .command("init [project-name]")
+    .description("Initialize a new SwallowKit project")
+    .option("--template <template>", "Template to use", "default")
+    .option("--next-version <version>", "Next.js version to install (e.g., 16.0.7, latest)", "latest")
+    .option("--cicd <provider>", "CI/CD provider: github | azure | skip")
+    .option("--backend-language <language>", "Azure Functions backend language: typescript | csharp | python")
+    .option("--cosmos-db-mode <mode>", "Cosmos DB mode: freetier | serverless")
+    .option("--vnet <option>", "Network security: outbound | none")
+    .action((projectName, options) => {
+      initCommand({
+        name: projectName || "swallowkit-app",
+        template: options.template,
+        nextVersion: options.nextVersion,
+        cicd: options.cicd,
+        backendLanguage: options.backendLanguage,
+        cosmosDbMode: options.cosmosDbMode,
+        vnet: options.vnet,
+      });
+    });
+
+  program.addCommand(devCommandOverride);
+  program.addCommand(devSeedsCommand);
+
+  program.addCommand(provisionCommand);
+
+  program
+    .command("create-model <names...>")
+    .description("Create model template files with id, createdAt, and updatedAt fields")
+    .option("--models-dir <dir>", "Models directory", "shared/models")
+    .option("--connector <name>", "Associate model with a connector defined in swallowkit.config.js")
+    .action((names, options) => {
+      createModelCommand({
+        names,
+        modelsDir: options.modelsDir,
+        connector: options.connector,
+      });
+    });
+
+  program
+    .command("scaffold <model>")
+    .description("Generate CRUD code for Azure Functions and Next.js BFF from Zod models")
+    .option("--functions-dir <dir>", "Azure Functions directory", "functions")
+    .option("--api-dir <dir>", "Next.js API routes directory", "app/api")
+    .option("--api-only", "Generate API only, skip UI components", false)
+    .action((model, options) => {
+      scaffoldCommand({
+        model,
+        functionsDir: options.functionsDir,
+        apiDir: options.apiDir,
+        apiOnly: options.apiOnly,
+      });
+    });
+
+  program
+    .command("add-connector <name>")
+    .description("Add an external data source connector configuration")
+    .requiredOption("--type <type>", "Connector type: rdb | api")
+    .option("--provider <provider>", "RDB provider: mysql | postgres | sqlserver", "mysql")
+    .action((name, options) => {
+      addConnectorCommand({
+        name,
+        type: options.type,
+        provider: options.provider,
+      });
+    });
+
+  program
+    .command("add-auth")
+    .description("Add authentication and authorization to the project")
+    .option("--provider <provider>", "Auth provider: custom-jwt | swa | swa-custom | none", "custom-jwt")
+    .action((options) => {
+      addAuthCommand({
+        provider: options.provider,
+      });
+    });
+
+  return program;
+}
+
+export async function runCli(argv: string[] = process.argv): Promise<void> {
+  ensureUtf8ConsoleOnWindows();
+  if (isMachineCommand(argv)) {
+    await runMachineCli(argv);
+    return;
+  }
+
+  await createProgram().parseAsync(normalizeDevCommandArgv(argv));
+}
+
+if (require.main === module) {
+  void runCli().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+  });
+}

package/src/core/config.ts

@@ -0,0 +1,308 @@
+import * as fs from "fs";
+import { createRequire } from "module";
+import * as path from "path";
+import { AuthConfig, BackendLanguage, ConnectorDefinition, SwallowKitConfig } from "../types";
+import { detectFromProject, getCommands } from "../utils/package-manager";
+
+const requireFromHere = createRequire(__filename);
+
+function unwrapConfigModule(
+  loadedConfig: Partial<SwallowKitConfig> | { default?: Partial<SwallowKitConfig> }
+): Partial<SwallowKitConfig> {
+  if (typeof loadedConfig === "object" && loadedConfig !== null && "default" in loadedConfig) {
+    return loadedConfig.default ?? {};
+  }
+  return loadedConfig as Partial<SwallowKitConfig>;
+}
+
+const VALID_BACKEND_LANGUAGES: BackendLanguage[] = ["typescript", "csharp", "python"];
+
+/**
+ * デフォルト設定
+ */
+const DEFAULT_CONFIG: SwallowKitConfig = {
+  database: {},
+  backend: {
+    language: "typescript",
+  },
+  api: {
+    endpoint: "/api/_swallowkit",
+    cors: {
+      origin: "*",
+      credentials: true,
+    },
+  },
+};
+
+/**
+ * 設定ファイルを読み込み
+ */
+export function loadConfig(configPath?: string): SwallowKitConfig {
+  const defaultPaths = [
+    "swallowkit.config.json",
+    "swallowkit.config.js",
+    ".swallowkitrc.json",
+  ];
+
+  const paths = configPath ? [configPath] : defaultPaths;
+
+  for (const filePath of paths) {
+    const fullPath = path.resolve(process.cwd(), filePath);
+    
+    if (fs.existsSync(fullPath)) {
+      try {
+        console.log(`📋 設定ファイルを読み込み: ${filePath}`);
+        
+        if (filePath.endsWith(".json")) {
+          const configData = fs.readFileSync(fullPath, "utf-8");
+          const userConfig = JSON.parse(configData);
+          return mergeConfig(DEFAULT_CONFIG, userConfig);
+        } else if (filePath.endsWith(".js")) {
+          delete requireFromHere.cache[fullPath];
+          const loadedConfig = requireFromHere(fullPath) as Partial<SwallowKitConfig> | { default?: Partial<SwallowKitConfig> };
+          return mergeConfig(DEFAULT_CONFIG, unwrapConfigModule(loadedConfig));
+        }
+      } catch (error) {
+        console.warn(`⚠️ 設定ファイルの読み込みに失敗: ${filePath}`, error);
+      }
+    }
+  }
+
+  console.log("📋 デフォルト設定を使用");
+  return DEFAULT_CONFIG;
+}
+
+/**
+ * 設定をマージ
+ */
+function mergeConfig(defaultConfig: SwallowKitConfig, userConfig: Partial<SwallowKitConfig>): SwallowKitConfig {
+  return {
+    database: {
+      ...defaultConfig.database,
+      ...userConfig.database,
+    },
+    backend: {
+      ...defaultConfig.backend,
+      ...userConfig.backend,
+    },
+    api: {
+      ...defaultConfig.api,
+      ...userConfig.api,
+      cors: {
+        ...defaultConfig.api?.cors,
+        ...userConfig.api?.cors,
+      },
+    },
+    connectors: userConfig.connectors ?? defaultConfig.connectors,
+    auth: userConfig.auth
+      ? { ...defaultConfig.auth, ...userConfig.auth }
+      : defaultConfig.auth,
+  };
+}
+
+/**
+ * 設定ファイルを生成
+ */
+export function generateConfig(outputPath: string = "swallowkit.config.json"): void {
+  const config = {
+    $schema: "https://swallowkit.dev/schema.json",
+    database: {
+      connectionString: "your-cosmos-connection-string",
+      databaseName: "SwallowKitDB",
+    },
+    backend: {
+      language: "typescript",
+    },
+    api: {
+      endpoint: "/api/_swallowkit",
+      cors: {
+        origin: ["http://localhost:3000"],
+        credentials: true,
+      },
+    },
+  };
+
+  fs.writeFileSync(outputPath, JSON.stringify(config, null, 2));
+  console.log(`✅ 設定ファイルを生成しました: ${outputPath}`);
+}
+
+/**
+ * 環境変数からの設定読み込み
+ */
+export function loadConfigFromEnv(): Partial<SwallowKitConfig> {
+  const config: Partial<SwallowKitConfig> = {};
+
+  // データベース設定
+  if (process.env.SWALLOWKIT_DB_CONNECTION_STRING) {
+    config.database = {
+      ...config.database,
+      connectionString: process.env.SWALLOWKIT_DB_CONNECTION_STRING,
+    };
+  }
+
+  if (process.env.SWALLOWKIT_DB_NAME) {
+    config.database = {
+      ...config.database,
+      databaseName: process.env.SWALLOWKIT_DB_NAME,
+    };
+  }
+
+  // API設定
+  if (process.env.SWALLOWKIT_API_ENDPOINT) {
+    config.api = {
+      ...config.api,
+      endpoint: process.env.SWALLOWKIT_API_ENDPOINT,
+    };
+  }
+
+  if (process.env.SWALLOWKIT_BACKEND_LANGUAGE) {
+    config.backend = {
+      ...config.backend,
+      language: process.env.SWALLOWKIT_BACKEND_LANGUAGE as BackendLanguage,
+    };
+  }
+
+  return config;
+}
+
+export function getBackendLanguage(configPath?: string): BackendLanguage {
+  const language = getFullConfig(configPath).backend?.language;
+  if (language && VALID_BACKEND_LANGUAGES.includes(language)) {
+    return language;
+  }
+
+  return "typescript";
+}
+
+/**
+ * 完全な設定を取得（ファイル + 環境変数）
+ */
+export function getFullConfig(configPath?: string): SwallowKitConfig {
+  const fileConfig = loadConfig(configPath);
+  const envConfig = loadConfigFromEnv();
+  
+  return mergeConfig(fileConfig, envConfig);
+}
+
+/**
+ * コネクタ定義を名前で取得
+ */
+export function getConnectorDefinition(connectorName: string, configPath?: string): ConnectorDefinition | undefined {
+  const config = getFullConfig(configPath);
+  return config.connectors?.[connectorName];
+}
+
+/**
+ * 認証設定を取得
+ */
+export function getAuthConfig(configPath?: string): AuthConfig | undefined {
+  const config = getFullConfig(configPath);
+  return config.auth;
+}
+
+/**
+ * 設定の検証
+ */
+const VALID_CONNECTOR_TYPES = ["rdb", "api"];
+const VALID_RDB_PROVIDERS = ["mysql", "postgres", "sqlserver"];
+const VALID_API_AUTH_TYPES = ["apiKey", "bearer", "oauth2"];
+
+export function validateConfig(config: SwallowKitConfig): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  // データベース設定の検証
+  if (config.database && !config.database.connectionString) {
+    errors.push("Cosmos DB connection string is required");
+  }
+
+  // API設定の検証
+  if (config.api?.endpoint && !config.api.endpoint.startsWith("/")) {
+    errors.push("API endpoint must start with '/'");
+  }
+
+  if (config.backend?.language && !VALID_BACKEND_LANGUAGES.includes(config.backend.language)) {
+    errors.push("Backend language must be one of: typescript, csharp, python");
+  }
+
+  // コネクタ設定の検証
+  if (config.connectors) {
+    for (const [name, connector] of Object.entries(config.connectors)) {
+      if (!VALID_CONNECTOR_TYPES.includes(connector.type)) {
+        errors.push(`Connector '${name}': type must be one of: ${VALID_CONNECTOR_TYPES.join(", ")}`);
+        continue;
+      }
+
+      if (connector.type === "rdb") {
+        if (!connector.provider || !VALID_RDB_PROVIDERS.includes(connector.provider)) {
+          errors.push(`Connector '${name}': provider must be one of: ${VALID_RDB_PROVIDERS.join(", ")}`);
+        }
+        if (!connector.connectionEnvVar) {
+          errors.push(`Connector '${name}': connectionEnvVar is required`);
+        }
+      }
+
+      if (connector.type === "api") {
+        if (!connector.baseUrlEnvVar) {
+          errors.push(`Connector '${name}': baseUrlEnvVar is required`);
+        }
+        if (connector.auth && !VALID_API_AUTH_TYPES.includes(connector.auth.type)) {
+          errors.push(`Connector '${name}': auth.type must be one of: ${VALID_API_AUTH_TYPES.join(", ")}`);
+        }
+      }
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * SwallowKit プロジェクトディレクトリかどうかを検証するための設定ファイルパス一覧
+ */
+const SWALLOWKIT_PROJECT_MARKERS = [
+  "swallowkit.config.js",
+  "swallowkit.config.json",
+  ".swallowkitrc.json",
+];
+
+/**
+ * 現在のディレクトリが SwallowKit プロジェクトディレクトリかどうかを検証
+ * @param projectRoot 検証するディレクトリパス（省略時は process.cwd()）
+ * @returns プロジェクトが有効な場合は true、無効な場合は false
+ */
+export function isSwallowKitProject(projectRoot?: string): boolean {
+  const cwd = projectRoot || process.cwd();
+  
+  // swallowkit 設定ファイルの存在をチェック
+  for (const marker of SWALLOWKIT_PROJECT_MARKERS) {
+    const markerPath = path.resolve(cwd, marker);
+    if (fs.existsSync(markerPath)) {
+      return true;
+    }
+  }
+  
+  return false;
+}
+
+/**
+ * SwallowKit プロジェクトディレクトリかどうかを検証し、無効な場合はエラーメッセージを表示して終了
+ * init 以外のコマンドの冒頭で呼び出すこと
+ * @param commandName コマンド名（エラーメッセージ用）
+ * @param projectRoot 検証するディレクトリパス（省略時は process.cwd()）
+ */
+export function ensureSwallowKitProject(commandName: string, projectRoot?: string): void {
+  if (!isSwallowKitProject(projectRoot)) {
+    console.error(`❌ Error: This directory is not a SwallowKit project.`);
+    console.error(`\n   The '${commandName}' command must be run from a SwallowKit project directory.`);
+    console.error(`   A SwallowKit project should contain one of the following files:`);
+    for (const marker of SWALLOWKIT_PROJECT_MARKERS) {
+      console.error(`     - ${marker}`);
+    }
+    const pmCmd = getCommands(detectFromProject());
+    console.error(`\n💡 Tip: Run '${pmCmd.dlx} swallowkit init' first to create a new SwallowKit project,`);
+    console.error(`   or navigate to an existing SwallowKit project directory.`);
+    process.exit(1);
+  }
+}