swallowkit 1.0.0-beta.8 → 1.0.0

package/src/cli/index.ts

@@ -1,74 +1,352 @@
 #!/usr/bin/env node
 
-// Ensure UTF-8 console output on Windows (fixes emoji/Unicode garbling in PowerShell 5.1)
-if (process.platform === 'win32') {
-  try {
-    require('child_process').execSync('chcp 65001', { stdio: 'ignore' });
-  } catch { /* ignore — non-critical */ }
-}
-
+import { execSync } from "child_process";
+import { readFileSync } from "fs";
+import * as path from "path";
 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 { planScaffoldOperation } from "../core/operations/scaffold-plan";
+import { inspectArtifacts } from "../core/project/artifacts";
+import { detectDrift } from "../core/project/drift";
+import { runVerify } from "../core/verify";
+import { isMachineCommand, runMachineCli } from "../machine";
+
+const packageJsonPath = path.resolve(__dirname, "../../package.json");
+export const CLI_VERSION = JSON.parse(readFileSync(packageJsonPath, "utf8")).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],
+  ["--swa-port", 1],
+  ["--no-swa", 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;
+  }
 
-const program = new Command();
-
-program
-  .name("swallowkit")
-  .description("Next.js framework optimized for Azure deployment - Automatically splits SSR into individual Azure Functions")
-  .version("1.0.0-beta.8");
-
-// 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,
+  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("--package-manager <manager>", "Package manager: npm | pnpm (defaults to invocation context)")
+    .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")
+    .option("--swa-plan <plan>", "Azure Static Web Apps plan: free | standard")
+    .action((projectName, options) => {
+      initCommand({
+        name: projectName || "swallowkit-app",
+        template: options.template,
+        nextVersion: options.nextVersion,
+        packageManager: options.packageManager,
+        cicd: options.cicd,
+        backendLanguage: options.backendLanguage,
+        cosmosDbMode: options.cosmosDbMode,
+        vnet: options.vnet,
+        swaPlan: options.swaPlan,
+      });
     });
-  });
 
-program.addCommand(devCommand);
-program.addCommand(devSeedsCommand);
+  program.addCommand(devCommandOverride);
+  program.addCommand(devSeedsCommand);
 
-program.addCommand(provisionCommand);
+  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")
-  .action((names, options) => {
-    createModelCommand({
-      names,
-      modelsDir: options.modelsDir,
+  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("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", "Skip UI components; still update Functions, BFF routes, OpenAPI, and native schema assets", false)
+    .option("--dry-run", "Show planned file changes without writing anything", false)
+    .action(async (model, options) => {
+      if (options.dryRun) {
+        await runScaffoldDryRun({
+          model,
+          functionsDir: options.functionsDir,
+          apiDir: options.apiDir,
+          apiOnly: options.apiOnly,
+        });
+        return;
+      }
+
+      await scaffoldCommand({
+        model,
+        functionsDir: options.functionsDir,
+        apiDir: options.apiDir,
+        apiOnly: options.apiOnly,
+      });
     });
-  });
 
-program.parse();
+  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 | external-token | swa-custom | none", "custom-jwt")
+    .option("--scheme <name>", "Add a named authentication scheme")
+    .option("--allowed-providers <list>", "Comma-separated SWA identity providers to allow (e.g. github,aad); defaults to aad")
+    .action((options) => {
+      addAuthCommand({
+        provider: options.provider,
+        scheme: options.scheme,
+        allowedProviders: options.allowedProviders ? String(options.allowedProviders).split(",") : undefined,
+      });
+    });
+
+  program
+    .command("status")
+    .description("Show generated artifact status and drift against the current project state")
+    .option("--artifacts", "List all tracked artifacts with ownership", false)
+    .action(async (options) => {
+      await runStatusCommand({ artifacts: options.artifacts });
+    });
+
+  program
+    .command("verify")
+    .description("Run verification checks (structure, drift, typecheck)")
+    .option("--checks <ids>", "Comma-separated check ids to run (structure,drift,typecheck)")
+    .action(async (options) => {
+      await runVerifyCommand({ checks: options.checks });
+    });
+
+  return program;
+}
+
+async function runScaffoldDryRun(options: { model: string; functionsDir?: string; apiDir?: string; apiOnly?: boolean }): Promise<void> {
+  console.log("🔍 Scaffold dry-run — no files will be written.\n");
+
+  const plan = await planScaffoldOperation(options);
+
+  const actionIcons: Record<string, string> = {
+    create: "➕",
+    update: "♻️ ",
+    overwrite: "⚠️ ",
+    append: "🔗",
+    delete: "🗑️ ",
+    skip: "⏭️ ",
+  };
+
+  for (const operation of plan.operations) {
+    if (operation.action === "skip") continue;
+    const icon = actionIcons[operation.action] ?? "•";
+    const conflictNote = operation.conflict ? ` (conflict: ${operation.conflictReason})` : "";
+    console.log(`  ${icon} ${operation.action.padEnd(9)} ${operation.path} [${operation.ownership}]${conflictNote}`);
+  }
+
+  const skipped = plan.operations.filter((operation) => operation.action === "skip").length;
+  if (skipped > 0) {
+    console.log(`  ⏭️  ${skipped} file(s) unchanged (skipped)`);
+  }
+
+  if (plan.warnings.length > 0) {
+    console.log("\n⚠️  Warnings:");
+    for (const warning of plan.warnings) {
+      console.log(`  - ${warning}`);
+    }
+  }
+
+  console.log(`\n📋 Plan ${plan.planId} saved.`);
+  if (plan.requiresApproval) {
+    console.log(`⚠️  ${plan.conflicts.length} file(s) were modified after generation and would be overwritten.`);
+    console.log(`   Review the conflicts, then run: swallowkit scaffold ${options.model} (or machine apply scaffold --plan ${plan.planId} --approve)`);
+  } else {
+    console.log(`   Run without --dry-run to apply: swallowkit scaffold ${options.model}`);
+  }
+}
+
+async function runStatusCommand(options: { artifacts?: boolean }): Promise<void> {
+  const inspection = inspectArtifacts();
+  const drift = await detectDrift();
+
+  console.log("📦 SwallowKit project status\n");
+
+  if (!inspection.ledgerFound) {
+    console.log("ℹ️  No artifact ledger (.swallowkit/artifacts.json) found yet.");
+    console.log("   Run scaffold once with this SwallowKit version to start tracking artifacts.\n");
+  } else {
+    const total = inspection.artifacts.length;
+    const missing = inspection.artifacts.filter((artifact) => !artifact.exists).length;
+    const modified = inspection.artifacts.filter((artifact) => artifact.modified).length;
+    console.log(`  Tracked artifacts: ${total}`);
+    console.log(`  Modified after generation: ${modified}`);
+    console.log(`  Missing: ${missing}\n`);
+
+    if (options.artifacts) {
+      for (const artifact of inspection.artifacts) {
+        const flags = [
+          artifact.modified ? "modified" : null,
+          !artifact.exists ? "missing" : null,
+        ].filter(Boolean);
+        const suffix = flags.length > 0 ? ` (${flags.join(", ")})` : "";
+        console.log(`  - ${artifact.path} [${artifact.ownership}]${suffix}`);
+      }
+      console.log("");
+    }
+  }
+
+  if (drift.findings.length === 0) {
+    console.log("✅ No drift detected.");
+    return;
+  }
+
+  console.log(`⚠️  Drift findings (${drift.findings.length}):`);
+  for (const finding of drift.findings) {
+    console.log(`  [${finding.severity}] ${finding.kind}: ${finding.message}`);
+    console.log(`     → ${finding.repairAction}`);
+  }
+}
+
+async function runVerifyCommand(options: { checks?: string }): Promise<void> {
+  console.log("🔎 Running verification checks...\n");
+
+  const result = await runVerify(options.checks ? options.checks.split(",") : undefined);
+
+  const statusIcons: Record<string, string> = {
+    pass: "✅",
+    fail: "❌",
+    skip: "⏭️ ",
+    error: "💥",
+  };
+
+  for (const check of result.checks) {
+    console.log(`  ${statusIcons[check.status]} ${check.id.padEnd(10)} ${check.title} (${check.durationMs}ms)`);
+    if (check.status === "fail" || check.status === "error") {
+      for (const action of check.suggestedActions) {
+        console.log(`     → ${action}`);
+      }
+    }
+  }
+
+  console.log(
+    `\n${result.summary.done ? "✅" : "❌"} ${result.summary.passed} passed, ${result.summary.failed} failed, ${result.summary.skipped} skipped, ${result.summary.errors} error(s)`
+  );
+
+  if (!result.summary.done) {
+    console.log('   Details: swallowkit machine explain failure');
+    process.exitCode = 1;
+  }
+}
+
+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

@@ -1,8 +1,20 @@
 import * as fs from "fs";
+import { createRequire } from "module";
 import * as path from "path";
-import { BackendLanguage, SwallowKitConfig } from "../types";
+import { AuthConfig, AuthProvider, BackendLanguage, ConnectorDefinition, NormalizedAuthConfig, 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"];
 
 /**
@@ -25,7 +37,7 @@ const DEFAULT_CONFIG: SwallowKitConfig = {
 /**
  * 設定ファイルを読み込み
  */
-export function loadConfig(configPath?: string): SwallowKitConfig {
+export function loadConfig(configPath?: string, throwOnError = false, quiet = false): SwallowKitConfig {
   const defaultPaths = [
     "swallowkit.config.json",
     "swallowkit.config.js",
@@ -39,24 +51,25 @@ export function loadConfig(configPath?: string): SwallowKitConfig {
     
     if (fs.existsSync(fullPath)) {
       try {
-        console.log(`📋 設定ファイルを読み込み: ${filePath}`);
+        if (!quiet) 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 require.cache[fullPath];
-          const userConfig = require(fullPath);
-          return mergeConfig(DEFAULT_CONFIG, userConfig.default || userConfig);
+          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);
+        if (throwOnError) throw error;
+        if (!quiet) console.warn(`⚠️ 設定ファイルの読み込みに失敗: ${filePath}`, error);
       }
     }
   }
 
-  console.log("📋 デフォルト設定を使用");
+  if (!quiet) console.log("📋 デフォルト設定を使用");
   return DEFAULT_CONFIG;
 }
 
@@ -81,6 +94,11 @@ function mergeConfig(defaultConfig: SwallowKitConfig, userConfig: Partial<Swallo
         ...userConfig.api?.cors,
       },
     },
+    connectors: userConfig.connectors ?? defaultConfig.connectors,
+    auth: userConfig.auth
+      ? { ...defaultConfig.auth, ...userConfig.auth }
+      : defaultConfig.auth,
+    verify: userConfig.verify ?? defaultConfig.verify,
   };
 }
 
@@ -168,14 +186,104 @@ export function getFullConfig(configPath?: string): SwallowKitConfig {
   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;
+}
+
+/** Load configuration for mutating/generation commands and fail instead of silently falling back. */
+export function getValidatedFullConfig(configPath?: string): SwallowKitConfig {
+  const config = mergeConfig(loadConfig(configPath, true), loadConfigFromEnv());
+  const validation = validateConfig(config);
+  if (!validation.valid) throw new Error(`Invalid SwallowKit configuration:\n${validation.errors.map(error => `- ${error}`).join("\n")}`);
+  return config;
+}
+
+const VALID_AUTH_PROVIDERS: AuthProvider[] = ["custom-jwt", "swa", "external-token", "swa-custom", "none"];
+const AUTH_NAME = /^[A-Za-z][A-Za-z0-9_-]*$/;
+
+/** Convert the legacy single-provider shape to the canonical named-scheme shape. */
+export function normalizeAuthConfig(auth?: AuthConfig): NormalizedAuthConfig | undefined {
+  if (!auth) return undefined;
+  const schemes = { ...(auth.schemes ?? {}) };
+  if (auth.provider && auth.provider !== "none" && !schemes.default) {
+    schemes.default = { provider: auth.provider, customJwt: auth.customJwt, swa: auth.swa };
+  }
+  const rawDefault = auth.authorization?.defaultPolicy ?? (Object.keys(schemes).length ? "authenticated" : "anonymous");
+  return {
+    ...auth,
+    schemes,
+    authorization: {
+      ...auth.authorization,
+      defaultPolicy: rawDefault === "public" ? "anonymous" : rawDefault,
+      policies: { ...(auth.authorization?.policies ?? {}) },
+    },
+  };
+}
+
+export function getNormalizedAuthConfig(configPath?: string): NormalizedAuthConfig | undefined {
+  return normalizeAuthConfig(getAuthConfig(configPath));
+}
+
 /**
  * 設定の検証
  */
+const VALID_CONNECTOR_TYPES = ["rdb", "api"];
+const VALID_RDB_PROVIDERS = ["mysql", "postgres", "sqlserver"];
+const VALID_API_AUTH_TYPES = ["apiKey", "bearer", "oauth2"];
+
+function hasConfiguredDatabase(config: SwallowKitConfig): boolean {
+  return Boolean(config.database && Object.keys(config.database).length > 0);
+}
+
 export function validateConfig(config: SwallowKitConfig): { valid: boolean; errors: string[] } {
   const errors: string[] = [];
 
+  const auth = normalizeAuthConfig(config.auth);
+  if (auth) {
+    for (const [name, scheme] of Object.entries(auth.schemes)) {
+      const base = `auth.schemes.${name}`;
+      if (!AUTH_NAME.test(name)) errors.push(`${base}: scheme name must match ${AUTH_NAME}; rename the scheme`);
+      if (!VALID_AUTH_PROVIDERS.includes(scheme.provider)) errors.push(`${base}.provider: unsupported provider '${scheme.provider}'; use ${VALID_AUTH_PROVIDERS.join(", ")}`);
+      if (scheme.provider === "none" || scheme.provider === "swa-custom") errors.push(`${base}.provider: '${scheme.provider}' cannot be used as a named scheme; use swa, external-token, or custom-jwt`);
+      if (scheme.provider === "custom-jwt") {
+        const jwt = scheme.customJwt ?? (name === "default" ? auth.customJwt : undefined);
+        for (const key of ["userConnector", "userTable", "loginIdColumn", "passwordHashColumn", "rolesColumn"] as const) {
+          if (!jwt?.[key]) errors.push(`${base}.customJwt.${key}: required for custom-jwt; configure this value`);
+        }
+      }
+    }
+    for (const [name, policy] of Object.entries(auth.authorization.policies)) {
+      const base = `auth.authorization.policies.${name}`;
+      if (!AUTH_NAME.test(name)) errors.push(`${base}: policy name must match ${AUTH_NAME}; rename the policy`);
+      if (!Array.isArray(policy.schemes) || policy.schemes.length === 0) errors.push(`${base}.schemes: provide at least one named scheme`);
+      for (const scheme of policy.schemes ?? []) if (!auth.schemes[scheme]) errors.push(`${base}.schemes: undefined scheme '${scheme}'; define auth.schemes.${scheme}`);
+      const sources = new Map<string, string>();
+      for (const schemeName of policy.schemes ?? []) {
+        const provider = auth.schemes[schemeName]?.provider;
+        const source = provider === "swa" ? "x-ms-client-principal" : provider === "custom-jwt" || provider === "external-token" ? "authorization-bearer" : provider;
+        if (source && sources.has(source)) errors.push(`${base}.schemes: '${sources.get(source)}' and '${schemeName}' both use ${source}; split the policy so credential selection is deterministic`);
+        else if (source) sources.set(source, schemeName);
+      }
+    }
+    const defaultPolicy = auth.authorization.defaultPolicy;
+    if (defaultPolicy === "authenticated" && !auth.schemes.default && Object.keys(auth.schemes).length !== 1) errors.push("auth.authorization.defaultPolicy: 'authenticated' requires auth.schemes.default (or exactly one scheme); set a default scheme or use a named policy");
+    else if (!["anonymous", "authenticated"].includes(defaultPolicy) && !auth.authorization.policies[defaultPolicy]) errors.push(`auth.authorization.defaultPolicy: undefined policy '${defaultPolicy}'; define auth.authorization.policies.${defaultPolicy}`);
+  }
+
   // データベース設定の検証
-  if (config.database && !config.database.connectionString) {
+  if (hasConfiguredDatabase(config) && !config.database?.connectionString) {
     errors.push("Cosmos DB connection string is required");
   }
 
@@ -188,6 +296,34 @@ export function validateConfig(config: SwallowKitConfig): { valid: boolean; erro
     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,