@diagramers/cli 1.0.23 → 1.0.25

package/src/services/project-updater.ts

@@ -1,117 +0,0 @@
-import * as fs from 'fs-extra';
-import * as path from 'path';
-import * as glob from 'glob';
-import chalk from 'chalk';
-
-export interface UpdateOptions {
-  force?: boolean;
-  backup?: boolean;
-}
-
-export class ProjectUpdater {
-  private currentProjectPath: string;
-
-  constructor() {
-    this.currentProjectPath = process.cwd();
-  }
-
-  async update(options: UpdateOptions): Promise<void> {
-    // Check if we're in a valid project directory
-    if (!await this.isValidProject()) {
-      throw new Error('Not a valid project directory. Please run this command from your project root.');
-    }
-
-    // Create backup if requested
-    if (options.backup) {
-      await this.createBackup();
-    }
-
-    // Get list of files that can be updated
-    const updateableFiles = await this.getUpdateableFiles();
-
-    // Check for conflicts
-    const conflicts = await this.checkConflicts(updateableFiles);
-    
-    if (conflicts.length > 0 && !options.force) {
-      console.log(chalk.yellow('⚠️  Conflicts detected in the following files:'));
-      conflicts.forEach(file => console.log(chalk.yellow(`   - ${file}`)));
-      console.log(chalk.yellow('Use --force to overwrite these files'));
-      throw new Error('Update aborted due to conflicts');
-    }
-
-    // Perform the update
-    await this.performUpdate(updateableFiles);
-
-    console.log(chalk.green('✅ Project updated successfully!'));
-  }
-
-  private async isValidProject(): Promise<boolean> {
-    const packageJsonPath = path.join(this.currentProjectPath, 'package.json');
-    const mainTsPath = path.join(this.currentProjectPath, 'main.ts');
-    
-    return await fs.pathExists(packageJsonPath) && await fs.pathExists(mainTsPath);
-  }
-
-  private async createBackup(): Promise<void> {
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-    const backupPath = path.join(this.currentProjectPath, `backup-${timestamp}`);
-    
-    await fs.copy(this.currentProjectPath, backupPath, {
-      filter: (src) => {
-        const relativePath = path.relative(this.currentProjectPath, src);
-        return !relativePath.startsWith('node_modules') && 
-               !relativePath.startsWith('.git') && 
-               !relativePath.startsWith('backup-');
-      }
-    });
-    
-    console.log(chalk.blue(`📦 Backup created at: ${backupPath}`));
-  }
-
-  private async getUpdateableFiles(): Promise<string[]> {
-    // For now, we'll update specific files that are commonly modified in templates
-    const updateableFiles = [
-      'src/helpers/dbcontext.ts',
-      'src/helpers/result.ts',
-      'src/helpers/enums.ts',
-      'src/config/index.ts',
-      'src/config/development.ts',
-      'src/config/staging.ts',
-      'src/config/production.ts',
-      'src/server/index.ts',
-      'webpack.config.js',
-      'tsconfig.json'
-    ];
-
-    return updateableFiles.filter(file => fs.existsSync(path.join(this.currentProjectPath, file)));
-  }
-
-  private async checkConflicts(files: string[]): Promise<string[]> {
-    const conflicts: string[] = [];
-
-    for (const file of files) {
-      const projectPath = path.join(this.currentProjectPath, file);
-      
-      if (await fs.pathExists(projectPath)) {
-        // For now, we'll consider all files as potentially conflicting
-        // In a real implementation, you'd compare with the template version
-        conflicts.push(file);
-      }
-    }
-
-    return conflicts;
-  }
-
-  private async performUpdate(files: string[]): Promise<void> {
-    console.log(chalk.blue('📝 Updating project files...'));
-    
-    // For now, we'll just report what would be updated
-    // In a real implementation, you'd copy from the latest template
-    for (const file of files) {
-      console.log(chalk.green(`✅ Would update: ${file}`));
-    }
-    
-    console.log(chalk.yellow('⚠️  Update mechanism is being improved.'));
-    console.log(chalk.yellow('   For now, manual updates are recommended.'));
-  }
-} 

package/src/services/relation-generator.ts

@@ -1,203 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-export type RelationType = 'one-to-one' | 'one-to-many' | 'many-to-many';
-
-export async function generateRelation(table1: string, table2: string, relationType: RelationType = 'one-to-one'): Promise<void> {
-  // Validate table names
-  if (!table1 || !table2 || !/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(table1) || !/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(table2)) {
-    throw new Error('Invalid table names. Use only letters, numbers, hyphens, and underscores. Must start with a letter.');
-  }
-
-  const table1Capitalized = table1.charAt(0).toUpperCase() + table1.slice(1);
-  const table2Capitalized = table2.charAt(0).toUpperCase() + table2.slice(1);
-  const currentDir = process.cwd();
-
-  // Check for required API project structure
-  const requiredDirs = ['src/entities', 'src/schemas'];
-  const missingDirs = requiredDirs.filter(dir => !fs.existsSync(path.join(currentDir, dir)));
-  if (missingDirs.length > 0) {
-    throw new Error(`This command should be run from a diagramers API project. Missing directories: ${missingDirs.join(', ')}`);
-  }
-
-  // Check if both tables exist
-  const table1EntityPath = path.join(currentDir, 'src/entities', `${table1}.ts`);
-  const table2EntityPath = path.join(currentDir, 'src/entities', `${table2}.ts`);
-  const table1SchemaPath = path.join(currentDir, 'src/schemas', `${table1}.ts`);
-  const table2SchemaPath = path.join(currentDir, 'src/schemas', `${table2}.ts`);
-
-  if (!fs.existsSync(table1EntityPath) || !fs.existsSync(table2EntityPath)) {
-    throw new Error(`Both tables must exist before creating relationships. Missing: ${!fs.existsSync(table1EntityPath) ? table1 : ''} ${!fs.existsSync(table2EntityPath) ? table2 : ''}`);
-  }
-
-  console.log(`🔗 Creating ${relationType} relationship between ${table1} and ${table2}...`);
-
-  // Update entities
-  console.log('📝 Updating entities...');
-  updateEntity(table1EntityPath, table1Capitalized, table2Capitalized, relationType, 'forward');
-  updateEntity(table2EntityPath, table2Capitalized, table1Capitalized, relationType, 'reverse');
-
-  // Update schemas
-  console.log('📋 Updating schemas...');
-  updateSchema(table1SchemaPath, table1Capitalized, table2Capitalized, relationType, 'forward');
-  updateSchema(table2SchemaPath, table2Capitalized, table1Capitalized, relationType, 'reverse');
-
-  console.log('✅ Relationship created successfully!');
-  console.log(`🔗 ${table1} ↔ ${table2} (${relationType})`);
-}
-
-function updateEntity(entityPath: string, tableCapitalized: string, relatedTableCapitalized: string, relationType: RelationType, direction: 'forward' | 'reverse'): void {
-  let entityContent = fs.readFileSync(entityPath, 'utf8');
-
-  // Add import for the related interface
-  const importStatement = `import { I${relatedTableCapitalized} } from './${direction === 'forward' ? relatedTableCapitalized.toLowerCase() : relatedTableCapitalized.toLowerCase()}';`;
-  if (!entityContent.includes(importStatement)) {
-    // Find the last import statement and add after it
-    const importRegex = /import.*from.*['"];?\s*$/gm;
-    const matches = [...entityContent.matchAll(importRegex)];
-    if (matches.length > 0) {
-      const lastImport = matches[matches.length - 1];
-      const insertIndex = lastImport.index! + lastImport[0].length;
-      entityContent = entityContent.slice(0, insertIndex) + '\n' + importStatement + entityContent.slice(insertIndex);
-    }
-  }
-
-  // Add relationship fields based on type
-  const interfaceRegex = /export interface I\w+ extends mongoose\.Document \{([^}]*)\}/s;
-  const match = entityContent.match(interfaceRegex);
-  
-  if (match) {
-    const interfaceContent = match[1];
-    const newFields = generateEntityFields(tableCapitalized, relatedTableCapitalized, relationType, direction);
-    
-    // Add new fields before the closing brace
-    const updatedInterfaceContent = interfaceContent.trim() + '\n    ' + newFields;
-    entityContent = entityContent.replace(interfaceRegex, `export interface I${tableCapitalized} extends mongoose.Document {$1${updatedInterfaceContent}\n}`);
-  }
-
-  fs.writeFileSync(entityPath, entityContent);
-}
-
-function updateSchema(schemaPath: string, tableCapitalized: string, relatedTableCapitalized: string, relationType: RelationType, direction: 'forward' | 'reverse'): void {
-  let schemaContent = fs.readFileSync(schemaPath, 'utf8');
-
-  // Add import for the related schema
-  const importStatement = `import { ${relatedTableCapitalized}Entity } from './${direction === 'forward' ? relatedTableCapitalized.toLowerCase() : relatedTableCapitalized.toLowerCase()}';`;
-  if (!schemaContent.includes(importStatement)) {
-    // Find the last import statement and add after it
-    const importRegex = /import.*from.*['"];?\s*$/gm;
-    const matches = [...schemaContent.matchAll(importRegex)];
-    if (matches.length > 0) {
-      const lastImport = matches[matches.length - 1];
-      const insertIndex = lastImport.index! + lastImport[0].length;
-      schemaContent = schemaContent.slice(0, insertIndex) + '\n' + importStatement + schemaContent.slice(insertIndex);
-    }
-  }
-
-  // Add schema fields based on relationship type
-  const schemaRegex = /export const \w+Schema = new mongoose\.Schema\(([^)]*),/s;
-  const match = schemaContent.match(schemaRegex);
-  
-  if (match) {
-    const schemaFields = match[1];
-    const newFields = generateSchemaFields(tableCapitalized, relatedTableCapitalized, relationType, direction);
-    
-    // Add new fields before the closing brace
-    const updatedSchemaFields = schemaFields.trim() + '\n        ' + newFields;
-    schemaContent = schemaContent.replace(schemaRegex, `export const ${tableCapitalized.toLowerCase()}Schema = new mongoose.Schema(${updatedSchemaFields},`);
-  }
-
-  // Add virtual fields and population methods
-  const modelRegex = /export const \w+Entity = mongoose\.model<.*>\(.*\);?\s*$/;
-  const virtualFields = generateVirtualFields(tableCapitalized, relatedTableCapitalized, relationType, direction);
-  
-  if (virtualFields) {
-    schemaContent = schemaContent.replace(modelRegex, `${virtualFields}\n\n$&`);
-  }
-
-  fs.writeFileSync(schemaPath, schemaContent);
-}
-
-function generateEntityFields(tableCapitalized: string, relatedTableCapitalized: string, relationType: RelationType, direction: 'forward' | 'reverse'): string {
-  switch (relationType) {
-    case 'one-to-one':
-      if (direction === 'forward') {
-        return `_${relatedTableCapitalized.toLowerCase()}Id: ObjectId,\n    ${relatedTableCapitalized.toLowerCase()}?: I${relatedTableCapitalized}`;
-      } else {
-        return `_${tableCapitalized.toLowerCase()}Id: ObjectId,\n    ${tableCapitalized.toLowerCase()}?: I${tableCapitalized}`;
-      }
-    
-    case 'one-to-many':
-      if (direction === 'forward') {
-        return `_${relatedTableCapitalized.toLowerCase()}Id: ObjectId,\n    ${relatedTableCapitalized.toLowerCase()}?: I${relatedTableCapitalized}`;
-      } else {
-        return `${tableCapitalized.toLowerCase()}s?: I${tableCapitalized}[]`;
-      }
-    
-    case 'many-to-many':
-      if (direction === 'forward') {
-        return `_${relatedTableCapitalized.toLowerCase()}Ids: ObjectId[],\n    ${relatedTableCapitalized.toLowerCase()}s?: I${relatedTableCapitalized}[]`;
-      } else {
-        return `_${tableCapitalized.toLowerCase()}Ids: ObjectId[],\n    ${tableCapitalized.toLowerCase()}s?: I${tableCapitalized}[]`;
-      }
-    
-    default:
-      return '';
-  }
-}
-
-function generateSchemaFields(tableCapitalized: string, relatedTableCapitalized: string, relationType: RelationType, direction: 'forward' | 'reverse'): string {
-  switch (relationType) {
-    case 'one-to-one':
-      if (direction === 'forward') {
-        return `_${relatedTableCapitalized.toLowerCase()}Id: {\n            type: mongoose.SchemaTypes.ObjectId,\n            ref: '${relatedTableCapitalized.toLowerCase()}',\n            required: false\n        }`;
-      } else {
-        return `_${tableCapitalized.toLowerCase()}Id: {\n            type: mongoose.SchemaTypes.ObjectId,\n            ref: '${tableCapitalized.toLowerCase()}',\n            required: false\n        }`;
-      }
-    
-    case 'one-to-many':
-      if (direction === 'forward') {
-        return `_${relatedTableCapitalized.toLowerCase()}Id: {\n            type: mongoose.SchemaTypes.ObjectId,\n            ref: '${relatedTableCapitalized.toLowerCase()}',\n            required: false\n        }`;
-      } else {
-        return ''; // No field needed for reverse one-to-many
-      }
-    
-    case 'many-to-many':
-      if (direction === 'forward') {
-        return `_${relatedTableCapitalized.toLowerCase()}Ids: [{\n            type: mongoose.SchemaTypes.ObjectId,\n            ref: '${relatedTableCapitalized.toLowerCase()}'\n        }]`;
-      } else {
-        return `_${tableCapitalized.toLowerCase()}Ids: [{\n            type: mongoose.SchemaTypes.ObjectId,\n            ref: '${tableCapitalized.toLowerCase()}'\n        }]`;
-      }
-    
-    default:
-      return '';
-  }
-}
-
-function generateVirtualFields(tableCapitalized: string, relatedTableCapitalized: string, relationType: RelationType, direction: 'forward' | 'reverse'): string {
-  switch (relationType) {
-    case 'one-to-one':
-      if (direction === 'forward') {
-        return `// Virtual populate for ${relatedTableCapitalized.toLowerCase()}\n${tableCapitalized.toLowerCase()}Schema.virtual('${relatedTableCapitalized.toLowerCase()}', {\n    ref: '${relatedTableCapitalized.toLowerCase()}',\n    localField: '_${relatedTableCapitalized.toLowerCase()}Id',\n    foreignField: '_id',\n    justOne: true\n});`;
-      } else {
-        return `// Virtual populate for ${tableCapitalized.toLowerCase()}\n${tableCapitalized.toLowerCase()}Schema.virtual('${tableCapitalized.toLowerCase()}', {\n    ref: '${tableCapitalized.toLowerCase()}',\n    localField: '_${tableCapitalized.toLowerCase()}Id',\n    foreignField: '_id',\n    justOne: true\n});`;
-      }
-    
-    case 'one-to-many':
-      if (direction === 'forward') {
-        return `// Virtual populate for ${relatedTableCapitalized.toLowerCase()}\n${tableCapitalized.toLowerCase()}Schema.virtual('${relatedTableCapitalized.toLowerCase()}', {\n    ref: '${relatedTableCapitalized.toLowerCase()}',\n    localField: '_${relatedTableCapitalized.toLowerCase()}Id',\n    foreignField: '_id',\n    justOne: true\n});`;
-      } else {
-        return `// Virtual populate for ${tableCapitalized.toLowerCase()}s\n${tableCapitalized.toLowerCase()}Schema.virtual('${tableCapitalized.toLowerCase()}s', {\n    ref: '${tableCapitalized.toLowerCase()}',\n    localField: '_id',\n    foreignField: '_${tableCapitalized.toLowerCase()}Id'\n});`;
-      }
-    
-    case 'many-to-many':
-      if (direction === 'forward') {
-        return `// Virtual populate for ${relatedTableCapitalized.toLowerCase()}s\n${tableCapitalized.toLowerCase()}Schema.virtual('${relatedTableCapitalized.toLowerCase()}s', {\n    ref: '${relatedTableCapitalized.toLowerCase()}',\n    localField: '_${relatedTableCapitalized.toLowerCase()}Ids',\n    foreignField: '_id'\n});`;
-      } else {
-        return `// Virtual populate for ${tableCapitalized.toLowerCase()}s\n${tableCapitalized.toLowerCase()}Schema.virtual('${tableCapitalized.toLowerCase()}s', {\n    ref: '${tableCapitalized.toLowerCase()}',\n    localField: '_${tableCapitalized.toLowerCase()}Ids',\n    foreignField: '_id'\n});`;
-      }
-    
-    default:
-      return '';
-  }
-} 

package/src/services/table-generator.ts

@@ -1,114 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-export async function generateTable(tableName: string): Promise<void> {
-  // Validate table name
-  if (!tableName || !/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(tableName)) {
-    throw new Error('Invalid table name. Use only letters, numbers, hyphens, and underscores. Must start with a letter.');
-  }
-
-  const tableNameCapitalized = tableName.charAt(0).toUpperCase() + tableName.slice(1);
-  const currentDir = process.cwd();
-
-  // Check for required API project structure
-  const requiredDirs = [
-    'src/entities',
-    'src/schemas'
-  ];
-  const missingDirs = requiredDirs.filter(dir => !fs.existsSync(path.join(currentDir, dir)));
-  if (missingDirs.length > 0) {
-    throw new Error(`This command should be run from a diagramers API project. Missing directories: ${missingDirs.join(', ')}`);
-  }
-
-  console.log('📝 Creating entity...');
-  const entityContent = generateEntityContent(tableName, tableNameCapitalized);
-  fs.writeFileSync(path.join(currentDir, 'src/entities', `${tableName}.ts`), entityContent);
-
-  console.log('📋 Creating schema...');
-  const schemaContent = generateSchemaContent(tableName, tableNameCapitalized);
-  fs.writeFileSync(path.join(currentDir, 'src/schemas', `${tableName}.ts`), schemaContent);
-
-  // Update dbcontext to include the new entity
-  updateDbContext(currentDir, tableName, tableNameCapitalized);
-
-  console.log('✅ Table generation completed!');
-  console.log(`📊 Entity: src/entities/${tableName}.ts`);
-  console.log(`📋 Schema: src/schemas/${tableName}.ts`);
-  console.log('🔄 dbcontext.ts updated');
-}
-
-function generateEntityContent(tableName: string, tableNameCapitalized: string): string {
-  return `import * as mongoose from 'mongoose';
-import { ObjectId } from "bson";
-
-export interface I${tableNameCapitalized} extends mongoose.Document {
-    _id: ObjectId,
-    name: string,
-    description?: string,
-    status: number,
-    createdAt: Date,
-    updatedAt: Date
-}`;
-}
-
-function generateSchemaContent(tableName: string, tableNameCapitalized: string): string {
-  return `import * as mongoose from 'mongoose';
-import { I${tableNameCapitalized} } from '../entities/${tableName}';
-
-export const ${tableName}Schema = new mongoose.Schema(
-    {
-        name: {
-            type: mongoose.SchemaTypes.String,
-            required: true,
-        },
-        description: {
-            type: mongoose.SchemaTypes.String,
-            required: false,
-        },
-        status: {
-            type: mongoose.SchemaTypes.Number,
-            default: 1,
-        }
-    },
-    { timestamps: true, suppressReservedKeysWarning: true },
-);
-
-export const ${tableNameCapitalized}Entity = mongoose.model<I${tableNameCapitalized}>('${tableName}', ${tableName}Schema);`;
-}
-
-function updateDbContext(currentDir: string, tableName: string, tableNameCapitalized: string): void {
-  const dbcontextPath = path.join(currentDir, 'src/helpers/dbcontext.ts');
-  if (!fs.existsSync(dbcontextPath)) {
-    console.log('⚠️ dbcontext.ts not found, skipping dbcontext update');
-    return;
-  }
-
-  let dbcontextContent = fs.readFileSync(dbcontextPath, 'utf8');
-  
-  // Add import
-  const importStatement = `import { ${tableNameCapitalized}Entity } from '../schemas/${tableName}';`;
-  if (!dbcontextContent.includes(importStatement)) {
-    // Find the last import statement and add after it
-    const importRegex = /import.*from.*['"];?\s*$/gm;
-    const matches = [...dbcontextContent.matchAll(importRegex)];
-    if (matches.length > 0) {
-      const lastImport = matches[matches.length - 1];
-      const insertIndex = lastImport.index! + lastImport[0].length;
-      dbcontextContent = dbcontextContent.slice(0, insertIndex) + '\n' + importStatement + dbcontextContent.slice(insertIndex);
-    }
-  }
-
-  // Add to dbcontext object
-  const dbcontextObjectRegex = /export\s+default\s*\{([^}]*)\}/s;
-  const match = dbcontextContent.match(dbcontextObjectRegex);
-  if (match) {
-    const objectContent = match[1];
-    if (!objectContent.includes(`${tableNameCapitalized}Entity`)) {
-      const newObjectContent = objectContent.trim() + `,\n    ${tableNameCapitalized}Entity`;
-      dbcontextContent = dbcontextContent.replace(dbcontextObjectRegex, `export default {$1${newObjectContent}\n}`);
-    }
-  }
-
-  fs.writeFileSync(dbcontextPath, dbcontextContent);
-  console.log('📊 Updated dbcontext.ts');
-} 

package/src/services/template-processor.ts

@@ -1,166 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-export async function processTemplate(projectName: string): Promise<void> {
-  if (!projectName) {
-    throw new Error('Project name is required');
-  }
-
-  const currentDir = process.cwd();
-
-  // Check for required API project structure
-  const requiredDirs = [
-    'src/entities',
-    'src/schemas',
-    'src/services',
-    'src/controllers',
-    'src/routes'
-  ];
-  const missingDirs = requiredDirs.filter(dir => !fs.existsSync(path.join(currentDir, dir)));
-  if (missingDirs.length > 0) {
-    throw new Error(`This command should be run from a diagramers API project. Missing directories: ${missingDirs.join(', ')}`);
-  }
-
-  // Convert project name to database-friendly format
-  const dbName = projectName
-    .toLowerCase()
-    .replace(/[^a-zA-Z0-9]/g, '_')
-    .replace(/_+/g, '_')
-    .replace(/^_|_$/g, '');
-
-  console.log(`🗄️ Database name will be: ${dbName}`);
-
-  // Process configuration files
-  console.log('📝 Updating configuration files...');
-
-  // Update development config
-  const devConfigPath = path.join(currentDir, 'src/config/development.ts');
-  if (fs.existsSync(devConfigPath)) {
-    let devConfig = fs.readFileSync(devConfigPath, 'utf8');
-    devConfig = devConfig.replace(
-      /mongodb:\/\/127\.0\.0\.1:27017\/[^,\s]+/g,
-      `mongodb://127.0.0.1:27017/${dbName}-development`
-    );
-    fs.writeFileSync(devConfigPath, devConfig);
-    console.log('   ✅ Updated development.ts');
-  }
-
-  // Update staging config
-  const stagingConfigPath = path.join(currentDir, 'src/config/staging.ts');
-  if (fs.existsSync(stagingConfigPath)) {
-    let stagingConfig = fs.readFileSync(stagingConfigPath, 'utf8');
-    stagingConfig = stagingConfig.replace(
-      /sendifier-staging/g,
-      `${dbName}-staging`
-    );
-    fs.writeFileSync(stagingConfigPath, stagingConfig);
-    console.log('   ✅ Updated staging.ts');
-  }
-
-  // Update production config
-  const prodConfigPath = path.join(currentDir, 'src/config/production.ts');
-  if (fs.existsSync(prodConfigPath)) {
-    let prodConfig = fs.readFileSync(prodConfigPath, 'utf8');
-    prodConfig = prodConfig.replace(
-      /sendifier-production/g,
-      `${dbName}-production`
-    );
-    fs.writeFileSync(prodConfigPath, prodConfig);
-    console.log('   ✅ Updated production.ts');
-  }
-
-  // Update package.json
-  const packageJsonPath = path.join(currentDir, 'package.json');
-  if (fs.existsSync(packageJsonPath)) {
-    let packageJsonContent = fs.readFileSync(packageJsonPath, 'utf8');
-    packageJsonContent = packageJsonContent.replace(
-      /"name":\s*"@diagramers\/api"/g,
-      `"name": "${projectName}"`
-    );
-    packageJsonContent = packageJsonContent.replace(
-      /"description":\s*"Diagramers API - A comprehensive Node\.js API template with TypeScript, Firebase Functions, and Socket\.io"/g,
-      `"description": "${projectName} - API project"`
-    );
-    fs.writeFileSync(packageJsonPath, packageJsonContent);
-    console.log('   ✅ Updated package.json');
-  }
-
-  // Update README.md
-  const readmePath = path.join(currentDir, 'README.md');
-  if (fs.existsSync(readmePath)) {
-    let readmeContent = fs.readFileSync(readmePath, 'utf8');
-    readmeContent = readmeContent.replace(
-      /# @diagramers\/api/g,
-      `# ${projectName}`
-    );
-    readmeContent = readmeContent.replace(
-      /A comprehensive Node\.js API template with TypeScript, Firebase Functions, and Socket\.io\./g,
-      `${projectName} - API project.`
-    );
-    fs.writeFileSync(readmePath, readmeContent);
-    console.log('   ✅ Updated README.md');
-  }
-
-  // Create .env file template
-  console.log('📄 Creating .env template...');
-  const envTemplate = generateEnvTemplate(dbName);
-  fs.writeFileSync(path.join(currentDir, '.env.example'), envTemplate);
-
-  console.log('✅ Template processing completed!');
-  console.log('');
-  console.log('📋 Summary:');
-  console.log(`   Project Name: ${projectName}`);
-  console.log(`   Database Name: ${dbName}`);
-  console.log(`   Development DB: ${dbName}-development`);
-  console.log(`   Staging DB: ${dbName}-staging`);
-  console.log(`   Production DB: ${dbName}-production`);
-  console.log('');
-  console.log('🚀 Next steps:');
-  console.log('   1. Copy .env.example to .env and configure your environment variables');
-  console.log('   2. Install dependencies: npm install');
-  console.log('   3. Build the project: npm run build:dev');
-  console.log('   4. Start the server: npm run serve');
-}
-
-function generateEnvTemplate(dbName: string): string {
-  return `# Environment Configuration
-NODE_ENV=development
-
-# Server Configuration
-PORT=4000
-HOST=localhost
-
-# Database Configuration
-MONGODB_URI=mongodb://127.0.0.1:27017/${dbName}-development
-
-# Firebase Configuration
-FIREBASE_API_KEY=your-api-key
-FIREBASE_AUTH_DOMAIN=your-project.firebaseapp.com
-FIREBASE_PROJECT_ID=your-project-id
-FIREBASE_STORAGE_BUCKET=your-project.appspot.com
-FIREBASE_MESSAGING_SENDER_ID=your-sender-id
-FIREBASE_APP_ID=your-app-id
-
-# JWT Configuration
-JWT_SECRET=your-jwt-secret-key
-
-# Twilio Configuration (for SMS)
-TWILIO_ACCOUNT_SID=your-account-sid
-TWILIO_AUTH_TOKEN=your-auth-token
-
-# Email Configuration
-SMTP_HOST=smtp.gmail.com
-SMTP_PORT=587
-SMTP_USER=your-email@gmail.com
-SMTP_PASS=your-app-password
-
-# Internal API Configuration
-INTERNAL_REQUEST_HEADER_VALUE=your-secret-header-value
-
-# Optional Configuration
-BASE_SITE_URL=http://localhost:3000
-LOCAL_API_TUNNEL_URL=https://your-ngrok-url.ngrok-free.app
-LOCAL_UI_TUNNEL_URL=https://your-ui-ngrok-url.ngrok-free.app
-BACKUP_DATABASES_FOLDER_PATH=/path/to/backup/folder
-EXTERNAL_HTTP_REQUEST_TIMEOUT=5000`;
-}