swallowkit 1.0.0-beta.7 → 1.0.0-beta.9

package/src/cli/commands/dev-seeds.ts

@@ -0,0 +1,358 @@
+import { Command } from "commander";
+import { CosmosClient, Database, PartitionKeyKind } from "@azure/cosmos";
+import * as fs from "fs";
+import * as path from "path";
+import { ensureSwallowKitProject } from "../../core/config";
+import { FieldInfo, ModelInfo, getAllModels, toKebabCase } from "../../core/scaffold/model-parser";
+
+export type SeedDocument = Record<string, unknown>;
+
+interface GenerateDevSeedTemplatesOptions {
+  environment: string;
+  modelsDir?: string;
+  seedsDir?: string;
+  force?: boolean;
+}
+
+interface ApplyDevSeedEnvironmentOptions {
+  client: CosmosClient;
+  databaseName: string;
+  environment: string;
+  models: ModelInfo[];
+  seedsDir?: string;
+}
+
+interface LoadedSeedFile {
+  model: ModelInfo;
+  containerName: string;
+  documents: SeedDocument[];
+  filePath: string;
+}
+
+export function getContainerNameForModel(model: Pick<ModelInfo, "name">): string {
+  return `${model.name}s`;
+}
+
+export function getSeedEnvironmentDir(environment: string, seedsDir: string = "dev-seeds"): string {
+  return path.join(process.cwd(), seedsDir, environment);
+}
+
+export function normalizeSeedIdentifier(value: string): string {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+
+export function parseSeedDocuments(content: string, filePath: string): SeedDocument[] {
+  const parsed: unknown = JSON.parse(content);
+
+  if (Array.isArray(parsed)) {
+    return parsed.map((item, index) => {
+      if (!isSeedDocument(item)) {
+        throw new Error(`${filePath} must contain only JSON objects. Invalid item at index ${index}.`);
+      }
+
+      return item;
+    });
+  }
+
+  if (isSeedDocument(parsed)) {
+    return [parsed];
+  }
+
+  throw new Error(`${filePath} must contain a JSON object or an array of JSON objects.`);
+}
+
+export async function loadProjectModels(modelsDir: string = "shared/models"): Promise<ModelInfo[]> {
+  return getAllModels(modelsDir);
+}
+
+export function buildSeedTemplateDocument(
+  model: ModelInfo,
+  allModels: ModelInfo[] = [model],
+  seenModels: Set<string> = new Set()
+): SeedDocument {
+  const modelLookup = new Map(allModels.map((candidate) => [candidate.name, candidate]));
+  return buildSeedTemplateDocumentInternal(model, modelLookup, seenModels);
+}
+
+export async function loadDevSeedFiles(
+  environment: string,
+  models: ModelInfo[],
+  seedsDir: string = "dev-seeds"
+): Promise<LoadedSeedFile[]> {
+  const environmentDir = getSeedEnvironmentDir(environment, seedsDir);
+  if (!fs.existsSync(environmentDir)) {
+    return [];
+  }
+
+  const modelAliases = buildModelAliasMap(models);
+  const seedFiles = fs.readdirSync(environmentDir).filter((entry) => entry.endsWith(".json"));
+  const loaded: LoadedSeedFile[] = [];
+
+  for (const fileName of seedFiles) {
+    const filePath = path.join(environmentDir, fileName);
+    const fileStem = path.basename(fileName, ".json");
+    const model = modelAliases.get(normalizeSeedIdentifier(fileStem));
+
+    if (!model) {
+      console.warn(`⚠️  Skipping seed file without matching schema: ${filePath}`);
+      continue;
+    }
+
+    const documents = parseSeedDocuments(fs.readFileSync(filePath, "utf-8"), filePath);
+    validateSeedDocuments(documents, filePath);
+
+    loaded.push({
+      model,
+      containerName: getContainerNameForModel(model),
+      documents,
+      filePath,
+    });
+  }
+
+  return loaded;
+}
+
+export async function applyDevSeedEnvironment({
+  client,
+  databaseName,
+  environment,
+  models,
+  seedsDir = "dev-seeds",
+}: ApplyDevSeedEnvironmentOptions): Promise<boolean> {
+  const environmentDir = getSeedEnvironmentDir(environment, seedsDir);
+  if (!fs.existsSync(environmentDir)) {
+    console.log(`ℹ️  Seed environment "${environment}" not found at ${environmentDir}. Keeping existing Cosmos DB data.`);
+    return false;
+  }
+
+  const seedFiles = await loadDevSeedFiles(environment, models, seedsDir);
+  if (seedFiles.length === 0) {
+    console.log(`ℹ️  No seed files found for environment "${environment}". Keeping existing Cosmos DB data.`);
+    return false;
+  }
+
+  const database = client.database(databaseName);
+  console.log(`🧪 Applying Cosmos DB seed data for environment "${environment}"...`);
+
+  for (const seedFile of seedFiles) {
+    await recreateContainer(database, seedFile.containerName);
+    const container = database.container(seedFile.containerName);
+
+    for (const document of seedFile.documents) {
+      await container.items.create(document);
+    }
+
+    console.log(
+      `✅ Seeded "${seedFile.containerName}" with ${seedFile.documents.length} item(s) from ${path.basename(seedFile.filePath)}`
+    );
+  }
+
+  console.log("✅ Cosmos DB seed replacement complete\n");
+  return true;
+}
+
+export async function generateDevSeedTemplates({
+  environment,
+  modelsDir = "shared/models",
+  seedsDir = "dev-seeds",
+  force = false,
+}: GenerateDevSeedTemplatesOptions): Promise<void> {
+  ensureSwallowKitProject("create-dev-seeds");
+
+  console.log(`🧪 Generating dev seed templates for environment "${environment}"...\n`);
+  const models = await loadProjectModels(modelsDir);
+
+  if (models.length === 0) {
+    console.log("⚠️  No schemas found under shared/models. Nothing was generated.");
+    return;
+  }
+
+  const environmentDir = getSeedEnvironmentDir(environment, seedsDir);
+  fs.mkdirSync(environmentDir, { recursive: true });
+
+  const writtenFiles: string[] = [];
+  const skippedFiles: string[] = [];
+
+  for (const model of models) {
+    const filePath = path.join(environmentDir, `${toKebabCase(model.name)}.json`);
+    if (!force && fs.existsSync(filePath)) {
+      skippedFiles.push(filePath);
+      continue;
+    }
+
+    const content = JSON.stringify([buildSeedTemplateDocument(model, models)], null, 2) + "\n";
+    fs.writeFileSync(filePath, content, "utf-8");
+    writtenFiles.push(filePath);
+    console.log(`✅ Created: ${filePath}`);
+  }
+
+  if (skippedFiles.length > 0) {
+    console.log("");
+    console.log(`⏭️  Skipped ${skippedFiles.length} existing file(s). Use --force to overwrite them.`);
+  }
+
+  console.log("");
+  console.log("📝 Next steps:");
+  console.log(`  1. Edit JSON files under ${environmentDir}`);
+  console.log(`  2. Run 'swallowkit dev --seed-env ${environment}' to replace emulator data before startup`);
+}
+
+export const devSeedsCommand = new Command()
+  .name("create-dev-seeds")
+  .description("Generate dev seed JSON templates under dev-seeds/<environment> from shared/models schemas")
+  .argument("<environment>", "Seed environment name")
+  .option("--models-dir <dir>", "Models directory", "shared/models")
+  .option("--seeds-dir <dir>", "Dev seeds directory", "dev-seeds")
+  .option("--force", "Overwrite existing seed JSON files", false)
+  .action(async (environment: string, options: { modelsDir?: string; seedsDir?: string; force?: boolean }) => {
+    await generateDevSeedTemplates({
+      environment,
+      modelsDir: options.modelsDir,
+      seedsDir: options.seedsDir,
+      force: options.force,
+    });
+  });
+
+function buildSeedTemplateDocumentInternal(
+  model: ModelInfo,
+  modelLookup: Map<string, ModelInfo>,
+  seenModels: Set<string>
+): SeedDocument {
+  const nextSeen = new Set(seenModels);
+  nextSeen.add(model.name);
+
+  const document: SeedDocument = {};
+
+  for (const field of model.fields) {
+    document[field.name] = buildTemplateValueForField(model, field, modelLookup, nextSeen);
+  }
+
+  return document;
+}
+
+function buildTemplateValueForField(
+  model: ModelInfo,
+  field: FieldInfo,
+  modelLookup: Map<string, ModelInfo>,
+  seenModels: Set<string>
+): unknown {
+  if (field.isNestedSchema && field.nestedModelName) {
+    const nestedModel = modelLookup.get(field.nestedModelName);
+    if (nestedModel) {
+      if (seenModels.has(nestedModel.name)) {
+        const fallback = { id: `${toKebabCase(nestedModel.name)}-001` };
+        return field.isArray ? [fallback] : fallback;
+      }
+
+      const nestedDocument = buildSeedTemplateDocumentInternal(nestedModel, modelLookup, seenModels);
+      return field.isArray ? [nestedDocument] : nestedDocument;
+    }
+  }
+
+  if (field.isArray) {
+    return [buildScalarTemplateValue(model, field)];
+  }
+
+  return buildScalarTemplateValue(model, field);
+}
+
+function buildScalarTemplateValue(model: ModelInfo, field: FieldInfo): unknown {
+  if (field.name === "id") {
+    return `${toKebabCase(model.name)}-001`;
+  }
+
+  if (field.enumValues && field.enumValues.length > 0) {
+    return field.enumValues[0];
+  }
+
+  if (field.type === "number") {
+    return 0;
+  }
+
+  if (field.type === "boolean") {
+    return false;
+  }
+
+  if (field.type === "date" || field.name.endsWith("At")) {
+    return "2026-01-01T00:00:00.000Z";
+  }
+
+  if (field.type === "object") {
+    return {};
+  }
+
+  return `${toKebabCase(model.name)}-${toKebabCase(field.name)}-sample`;
+}
+
+function buildModelAliasMap(models: ModelInfo[]): Map<string, ModelInfo> {
+  const aliases = new Map<string, ModelInfo>();
+
+  for (const model of models) {
+    const candidates = [
+      model.name,
+      model.schemaName,
+      toKebabCase(model.name),
+      path.basename(model.filePath, path.extname(model.filePath)),
+    ];
+
+    for (const candidate of candidates) {
+      const normalized = normalizeSeedIdentifier(candidate);
+      if (!aliases.has(normalized)) {
+        aliases.set(normalized, model);
+      }
+    }
+  }
+
+  return aliases;
+}
+
+function isSeedDocument(value: unknown): value is SeedDocument {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function validateSeedDocuments(documents: SeedDocument[], filePath: string): void {
+  const ids = new Set<string>();
+
+  documents.forEach((document, index) => {
+    if (typeof document.id !== "string" || document.id.trim().length === 0) {
+      throw new Error(`${filePath} item at index ${index} must contain a non-empty string id.`);
+    }
+
+    if (ids.has(document.id)) {
+      throw new Error(`${filePath} contains duplicate id "${document.id}".`);
+    }
+
+    ids.add(document.id);
+  });
+}
+
+async function recreateContainer(database: Database, containerName: string): Promise<void> {
+  try {
+    await database.container(containerName).delete();
+  } catch (error: any) {
+    if (error?.code !== 404) {
+      throw error;
+    }
+  }
+
+  try {
+    await database.containers.createIfNotExists({
+      id: containerName,
+      partitionKey: {
+        paths: ["/id"],
+        kind: PartitionKeyKind.Hash,
+        version: 2,
+      },
+    });
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.log(`⚠️  Failed to recreate "${containerName}" with full partition key definition: ${message}`);
+    console.log("🔄 Retrying with simple partition key...");
+    await database.containers.createIfNotExists({
+      id: containerName,
+      partitionKey: {
+        paths: ["/id"],
+      },
+    });
+  }
+}

package/src/cli/commands/dev.ts

@@ -5,6 +5,8 @@ import * as fs from 'fs';
 import * as os from 'os';
 import { CosmosClient, PartitionKeyKind } from '@azure/cosmos';
 import { ensureSwallowKitProject, getBackendLanguage } from '../../core/config';
+import { ModelInfo } from '../../core/scaffold/model-parser';
+import { applyDevSeedEnvironment, getContainerNameForModel, loadProjectModels } from './dev-seeds';
 import { BackendLanguage } from '../../types';
 import { detectFromProject, getCommands } from '../../utils/package-manager';
 
@@ -15,6 +17,7 @@ interface DevOptions {
   open?: boolean;
   verbose?: boolean;
   noFunctions?: boolean;
+  seedEnv?: string;
 }
 
 export function buildFunctionsStartArgs(functionsPort: string): string[] {
@@ -319,7 +322,8 @@ export const devCommand = new Command()
   .option('--open', 'Open browser automatically', false)
   .option('--verbose', 'Show verbose logs', false)
   .option('--no-functions', 'Skip Azure Functions startup', false)
-  .action(async (options: DevOptions & { functionsPort?: string; noFunctions?: boolean }) => {
+  .option('--seed-env <environment>', 'Replace Cosmos DB Emulator data from dev-seeds/<environment> before startup')
+  .action(async (options: DevOptions & { functionsPort?: string; noFunctions?: boolean; seedEnv?: string }) => {
     // SwallowKit プロジェクトディレクトリかどうかを検証
     ensureSwallowKitProject("dev");
 
@@ -331,7 +335,14 @@ export const devCommand = new Command()
     await startDevEnvironment(options);
   });
 
-async function initializeCosmosDB(databaseName: string): Promise<void> {
+interface CosmosInitializationResult {
+  endpoint: string;
+  key: string;
+  databaseName: string;
+  models: ModelInfo[];
+}
+
+async function initializeCosmosDB(databaseName: string): Promise<CosmosInitializationResult | null> {
   try {
     // Read local.settings.json from functions directory
     const functionsDir = path.join(process.cwd(), 'functions');
@@ -339,7 +350,7 @@ async function initializeCosmosDB(databaseName: string): Promise<void> {
     
     if (!fs.existsSync(localSettingsPath)) {
       console.log('⚠️  local.settings.json not found. Skipping Cosmos DB initialization.');
-      return;
+      return null;
     }
 
     const localSettings = JSON.parse(fs.readFileSync(localSettingsPath, 'utf-8'));
@@ -348,7 +359,7 @@ async function initializeCosmosDB(databaseName: string): Promise<void> {
     
     if (!connectionString) {
       console.log('⚠️  CosmosDBConnection not found in local.settings.json. Skipping Cosmos DB initialization.');
-      return;
+      return null;
     }
 
     console.log('🗄️  Initializing Cosmos DB...');
@@ -359,7 +370,7 @@ async function initializeCosmosDB(databaseName: string): Promise<void> {
     
     if (!endpointMatch || !keyMatch) {
       console.log('⚠️  Invalid CosmosDB connection string format.');
-      return;
+      return null;
     }
 
     const endpoint = endpointMatch[1];
@@ -373,72 +384,61 @@ async function initializeCosmosDB(databaseName: string): Promise<void> {
     const { database } = await client.databases.createIfNotExists({ id: dbName });
     console.log(`✅ Database "${dbName}" ready`);
 
-    // Read lib/scaffold-config.ts to get list of models
-    const scaffoldConfigPath = path.join(process.cwd(), 'lib', 'scaffold-config.ts');
-    if (fs.existsSync(scaffoldConfigPath)) {
-      const scaffoldConfigContent = fs.readFileSync(scaffoldConfigPath, 'utf-8');
+    const models = await loadProjectModels();
+    for (const model of models) {
+      const containerName = getContainerNameForModel(model);
       
-      // Parse TypeScript file to extract models array
-      const modelsMatch = scaffoldConfigContent.match(/models:\s*\[([\s\S]*?)\]\s*as\s*ScaffoldModel\[\]/);
-      if (modelsMatch) {
-        const modelsArrayContent = modelsMatch[1];
-        // Extract model names from objects like { name: 'Task', path: '/task', label: 'Task' }
-        const modelMatches = modelsArrayContent.matchAll(/\{\s*name:\s*['"](\w+)['"]/g);
-        const models = Array.from(modelMatches, m => m[1]);
-        
-        for (const modelName of models) {
-          const containerName = `${modelName}s`; // Pluralize model name
-          
-          // Try creating container with full partition key definition first
-          let containerCreated = false;
-          
-          try {
-            console.log(`🔧 Creating container "${containerName}" with partition key /id...`);
-            const containerResponse = await database.containers.createIfNotExists({
-              id: containerName,
-              partitionKey: {
-                paths: ['/id'],
-                kind: PartitionKeyKind.Hash,
-                version: 2
-              }
-            });
-            console.log(`✅ Container "${containerName}" ready (status: ${containerResponse.statusCode})`);
-            containerCreated = true;
-          } catch (error: any) {
-            console.log(`⚠️  Failed with full partition key definition: ${error.message}`);
-            console.log(`🔄 Retrying with simple partition key...`);
+      // Try creating container with full partition key definition first
+      let containerCreated = false;
+      
+      try {
+        console.log(`🔧 Creating container "${containerName}" with partition key /id...`);
+        const containerResponse = await database.containers.createIfNotExists({
+          id: containerName,
+          partitionKey: {
+            paths: ['/id'],
+            kind: PartitionKeyKind.Hash,
+            version: 2
           }
-          
-          // If first attempt failed, try with simple partition key definition
-          if (!containerCreated) {
-            try {
-              const containerResponse = await database.containers.createIfNotExists({
-                id: containerName,
-                partitionKey: {
-                  paths: ['/id']
-                }
-              });
-              console.log(`✅ Container "${containerName}" ready (status: ${containerResponse.statusCode})`);
-            } catch (containerError: any) {
-              console.error(`❌ Failed to create container "${containerName}":`, containerError.message);
-              console.error(`Error code: ${containerError.code}`);
-              if (containerError.body) {
-                console.error(`Response body:`, JSON.stringify(containerError.body, null, 2));
-              }
-              // Continue with other containers
+        });
+        console.log(`✅ Container "${containerName}" ready (status: ${containerResponse.statusCode})`);
+        containerCreated = true;
+      } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.log(`⚠️  Failed with full partition key definition: ${message}`);
+        console.log(`🔄 Retrying with simple partition key...`);
+      }
+      
+      // If first attempt failed, try with simple partition key definition
+      if (!containerCreated) {
+        try {
+          const containerResponse = await database.containers.createIfNotExists({
+            id: containerName,
+            partitionKey: {
+              paths: ['/id']
             }
+          });
+          console.log(`✅ Container "${containerName}" ready (status: ${containerResponse.statusCode})`);
+        } catch (containerError: any) {
+          console.error(`❌ Failed to create container "${containerName}":`, containerError.message);
+          console.error(`Error code: ${containerError.code}`);
+          if (containerError.body) {
+            console.error(`Response body:`, JSON.stringify(containerError.body, null, 2));
           }
+          // Continue with other containers
         }
       }
     }
 
     console.log('✅ Cosmos DB initialization complete\n');
+    return { endpoint, key: keyMatch[1], databaseName: dbName, models };
   } catch (error: any) {
     console.error('⚠️  Cosmos DB initialization failed:', error.message);
     if (error.stack) {
       console.error('Stack trace:', error.stack);
     }
     console.log('💡 Make sure Cosmos DB Emulator is running');
+    return null;
   }
 }
 
@@ -563,7 +563,18 @@ async function startDevEnvironment(options: DevOptions) {
         const appName = packageJson.name || 'App';
         const databaseName = `${appName.charAt(0).toUpperCase() + appName.slice(1)}Database`;
         
-        await initializeCosmosDB(databaseName);
+        const cosmosInitialization = await initializeCosmosDB(databaseName);
+        if (options.seedEnv && cosmosInitialization) {
+          await applyDevSeedEnvironment({
+            client: new CosmosClient({
+              endpoint: cosmosInitialization.endpoint,
+              key: cosmosInitialization.key,
+            }),
+            databaseName: cosmosInitialization.databaseName,
+            environment: options.seedEnv,
+            models: cosmosInitialization.models,
+          });
+        }
 
         console.log('');
         console.log('🚀 Starting Azure Functions...');

package/src/cli/commands/index.ts

@@ -4,5 +4,6 @@
 
 export { initCommand } from "./init";
 export { devCommand } from "./dev"; 
+export { devSeedsCommand } from "./dev-seeds";
 export { scaffoldCommand } from "./scaffold";
 export { createModelCommand } from "./create-model";

package/src/cli/commands/init.ts

@@ -424,6 +424,30 @@ export function buildCSharpFunctionsProjectSource(): string {
 `;
 }
 
+export function buildSwallowKitConfigSource(backendLanguage: BackendLanguage): string {
+  return `module.exports = {
+  backend: {
+    language: '${backendLanguage}',
+  },
+  functions: {
+    baseUrl: process.env.BACKEND_FUNCTIONS_BASE_URL || process.env.FUNCTIONS_BASE_URL || 'http://localhost:7071',
+  },
+  deployment: {
+    resourceGroup: process.env.AZURE_RESOURCE_GROUP || '',
+    swaName: process.env.AZURE_SWA_NAME || '',
+  },
+}
+`;
+}
+
+export function buildGeneratedProjectDependencies(projectName: string): Record<string, string> {
+  return {
+    '@azure/cosmos': '^4.0.0',
+    'applicationinsights': '^3.3.0',
+    [`@${projectName}/shared`]: '*',
+  };
+}
+
 async function addSwallowKitFiles(
   projectDir: string,
   options: InitOptions,
@@ -436,18 +460,14 @@ async function addSwallowKitFiles(
   
   const projectName = options.name;
 
-  // 1. Update package.json to add swallowkit and @azure/cosmos dependencies
+  // 1. Update package.json to add runtime dependencies for generated projects
   const packageJsonPath = path.join(projectDir, 'package.json');
   const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
   
-  // Add SwallowKit dependencies (Next.js version already upgraded by upgradeNextJs)
   // zod is in the shared workspace package, not here
   packageJson.dependencies = {
     ...packageJson.dependencies,
-    'swallowkit': 'latest',
-    '@azure/cosmos': '^4.0.0',
-    'applicationinsights': '^3.3.0',
-    [`@${projectName}/shared`]: '*',
+    ...buildGeneratedProjectDependencies(projectName),
   };
 
   if (backendLanguage !== "typescript") {
@@ -526,20 +546,7 @@ async function addSwallowKitFiles(
   }
 
   // 3. Create SwallowKit config
-  const swallowkitConfig = `/** @type {import('swallowkit').SwallowKitConfig} */
-module.exports = {
-  backend: {
-    language: '${backendLanguage}',
-  },
-  functions: {
-    baseUrl: process.env.BACKEND_FUNCTIONS_BASE_URL || process.env.FUNCTIONS_BASE_URL || 'http://localhost:7071',
-  },
-  deployment: {
-    resourceGroup: process.env.AZURE_RESOURCE_GROUP || '',
-    swaName: process.env.AZURE_SWA_NAME || '',
-  },
-}
-`;
+  const swallowkitConfig = buildSwallowKitConfigSource(backendLanguage);
   fs.writeFileSync(path.join(projectDir, 'swallowkit.config.js'), swallowkitConfig);
 
   // 4. Create shared workspace package for Zod models (Single Source of Truth)

package/src/cli/index.ts

@@ -8,7 +8,7 @@ if (process.platform === 'win32') {
 }
 
 import { Command } from "commander";
-import { initCommand, devCommand, scaffoldCommand, createModelCommand } from "./commands";
+import { initCommand, devCommand, devSeedsCommand, scaffoldCommand, createModelCommand } from "./commands";
 import { provisionCommand } from "./commands/provision";
 
 const program = new Command();
@@ -16,7 +16,7 @@ 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.5");
+  .version("1.0.0-beta.9");
 
 // Register commands
 program
@@ -41,6 +41,7 @@ program
   });
 
 program.addCommand(devCommand);
+program.addCommand(devSeedsCommand);
 
 program.addCommand(provisionCommand);