@tamyla/clodo-framework 3.0.15 → 3.1.1

package/dist/service-management/generators/documentation/DeploymentDocsGenerator.js

@@ -0,0 +1,244 @@
+import { BaseGenerator } from '../BaseGenerator.js';
+import { join } from 'path';
+import { writeFileSync, mkdirSync } from 'fs';
+
+/**
+ * Deployment Documentation Generator
+ * Generates comprehensive deployment guide for all environments
+ */
+export class DeploymentDocsGenerator extends BaseGenerator {
+  /**
+   * Generate deployment documentation
+   * @param {Object} context - Generation context
+   * @returns {Promise<string>} Path to generated deployment docs file
+   */
+  async generate(context) {
+    const {
+      coreInputs,
+      confirmedValues,
+      servicePath
+    } = this.extractContext(context);
+    if (!this.shouldGenerate(context)) {
+      return null;
+    }
+
+    // Ensure docs directory exists
+    const docsDir = join(servicePath, 'docs');
+    mkdirSync(docsDir, {
+      recursive: true
+    });
+    const deploymentDocsContent = this._generateDeploymentDocsContent(coreInputs, confirmedValues);
+    const filePath = join(servicePath, 'docs', 'DEPLOYMENT.md');
+    writeFileSync(filePath, deploymentDocsContent, 'utf8');
+    return filePath;
+  }
+
+  /**
+   * Generate deployment documentation content
+   * @private
+   */
+  _generateDeploymentDocsContent(coreInputs, confirmedValues) {
+    return `# ${confirmedValues.displayName} - Deployment Guide
+
+## Overview
+
+This guide covers deploying ${confirmedValues.displayName} to different environments using the Clodo Framework.
+
+## Environments
+
+### Development
+- **URL**: ${confirmedValues.developmentUrl}
+- **Environment**: development
+- **Configuration**: \`config/development.env\`
+
+### Staging
+- **URL**: ${confirmedValues.stagingUrl}
+- **Environment**: staging
+- **Configuration**: \`config/staging.env\`
+
+### Production
+- **URL**: ${confirmedValues.productionUrl}
+- **Environment**: production
+- **Configuration**: \`config/production.env\`
+
+## Prerequisites
+
+- Node.js 18+
+- Cloudflare account with Workers enabled
+- Wrangler CLI installed
+- PowerShell (for deployment scripts)
+
+## Initial Setup
+
+1. **Clone and setup**:
+   \`\`\`bash
+   git clone ${confirmedValues.gitRepositoryUrl}
+   cd ${coreInputs.serviceName}
+   .\\scripts\\setup.ps1
+   \`\`\`
+
+2. **Configure environment**:
+   Edit \`.env\` with your Cloudflare credentials:
+   \`\`\`bash
+   CLOUDFLARE_ACCOUNT_ID=your_account_id
+   CLOUDFLARE_ZONE_ID=your_zone_id
+   CLOUDFLARE_API_TOKEN=your_api_token
+   \`\`\`
+
+3. **Setup database** (if enabled):
+   ${confirmedValues.features.database ? `
+   Create a Cloudflare D1 database and update \`wrangler.toml\`:
+   \`\`\`toml
+   [[d1_databases]]
+   binding = "DB"
+   database_name = "${confirmedValues.databaseName}"
+   database_id = "your_database_id"
+   \`\`\`
+   ` : 'Database not required for this service type.'}
+
+## Development Deployment
+
+\`\`\`bash
+# Start local development server
+npm run dev
+
+# Server will be available at http://localhost:8787
+\`\`\`
+
+## Staging Deployment
+
+\`\`\`bash
+# Deploy to staging
+.\\scripts\\deploy.ps1 -Environment staging
+
+# Run health checks
+.\\scripts\\health-check.ps1 -Environment staging
+\`\`\`
+
+## Production Deployment
+
+\`\`\`bash
+# Deploy to production
+.\\scripts\\deploy.ps1 -Environment production
+
+# Verify deployment
+.\\scripts\\health-check.ps1 -Environment production
+\`\`\`
+
+## Automated Deployment
+
+### GitHub Actions
+
+The service includes GitHub Actions workflows for automated deployment:
+
+- **CI**: Runs on every push to main branch
+- **Deploy**: Deploys to staging on successful CI
+- **Release**: Deploys to production on tag creation
+
+### Manual CI/CD
+
+\`\`\`bash
+# Run full CI pipeline locally
+npm run lint
+npm test
+npm run build
+
+# Deploy if all checks pass
+.\\scripts\\deploy.ps1 -Environment production
+\`\`\`
+
+## Monitoring and Health Checks
+
+### Health Check Endpoint
+
+\`\`\`bash
+curl ${confirmedValues.productionUrl}${confirmedValues.healthCheckPath}
+\`\`\`
+
+### Automated Health Monitoring
+
+The deployment scripts include automated health checks. For production monitoring, consider:
+
+- Cloudflare Analytics
+- External monitoring services
+- Log aggregation tools
+
+## Rollback Strategy
+
+### Quick Rollback
+
+\`\`\`bash
+# Deploy previous version
+wrangler deploy --env production
+
+# Or redeploy from git
+git checkout previous-version
+npm run deploy
+\`\`\`
+
+### Database Rollback
+
+${confirmedValues.features.database ? `
+If database schema changes need rollback:
+
+1. Restore from backup
+2. Run migration rollback scripts
+3. Update wrangler.toml if needed
+` : 'No database rollback required for this service type.'}
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Deployment fails with authentication error**
+   - Check Cloudflare API token permissions
+   - Verify account ID and zone ID
+
+2. **Health check fails**
+   - Check database connectivity
+   - Verify environment variables
+   - Review worker logs
+
+3. **API returns 500 errors**
+   - Check worker logs in Cloudflare dashboard
+   - Verify service configuration
+   - Test locally first
+
+### Logs and Debugging
+
+\`\`\`bash
+# View worker logs
+wrangler tail
+
+# Check deployment status
+wrangler deployments list
+
+# View environment info
+wrangler whoami
+\`\`\`
+
+## Security Considerations
+
+- Store secrets in Cloudflare Workers secrets, not environment variables
+- Use HTTPS for all production endpoints
+- Implement proper authentication and authorization
+- Regularly rotate API tokens
+- Monitor for unusual activity
+
+## Performance Optimization
+
+- Enable caching where appropriate
+- Use appropriate database indexes
+- Monitor response times
+- Optimize bundle size
+- Consider edge deployment locations
+`;
+  }
+
+  /**
+   * Determine if generator should run
+   */
+  shouldGenerate(context) {
+    return true; // Always generate deployment documentation
+  }
+}

package/dist/service-management/generators/documentation/ReadmeGenerator.js

@@ -0,0 +1,196 @@
+import { BaseGenerator } from '../BaseGenerator.js';
+import { join } from 'path';
+import { writeFileSync } from 'fs';
+
+/**
+ * README Generator
+ * Generates comprehensive README.md documentation for services
+ */
+export class ReadmeGenerator extends BaseGenerator {
+  /**
+   * Generate README.md
+   * @param {Object} context - Generation context
+   * @returns {Promise<string>} Path to generated README file
+   */
+  async generate(context) {
+    const {
+      coreInputs,
+      confirmedValues,
+      servicePath
+    } = this.extractContext(context);
+    if (!this.shouldGenerate(context)) {
+      return null;
+    }
+    const readmeContent = this._generateReadmeContent(coreInputs, confirmedValues);
+    const filePath = join(servicePath, 'README.md');
+    writeFileSync(filePath, readmeContent, 'utf8');
+    return filePath;
+  }
+
+  /**
+   * Generate README content
+   * @private
+   */
+  _generateReadmeContent(coreInputs, confirmedValues) {
+    return `# ${confirmedValues.displayName}
+
+${confirmedValues.description}
+
+## 🚀 Quick Start
+
+\\\`\\\`\\\`bash
+# Setup development environment
+.\\\\scripts\\\\setup.ps1
+
+# Start development server
+npm run dev
+
+# Run tests
+npm test
+
+# Deploy to production
+.\\\\scripts\\\\deploy.ps1 -Environment production
+\\\`\\\`\\\`
+
+## 📋 Features
+
+${Object.entries(confirmedValues.features).filter(([, enabled]) => enabled).map(([feature]) => `- ✅ ${feature.replace(/([A-Z])/g, ' $1').toLowerCase()}`).join('\n')}
+
+## 🏗️ Architecture
+
+This service is built with the **Clodo Framework** and follows a three-tier architecture:
+
+1. **Input Collection**: Collects and validates service requirements
+2. **Smart Confirmations**: Generates and confirms derived configuration values
+3. **Automated Generation**: Creates all necessary configuration files and components
+
+## 📁 Project Structure
+
+\`\`\`
+${coreInputs.serviceName}/
+├── src/
+│   ├── config/
+│   │   └── domains.js          # Domain configuration
+│   ├── worker/
+│   │   └── index.js            # Cloudflare Worker entry point
+│   ├── handlers/
+│   │   └── service-handlers.js # Request handlers
+│   ├── middleware/
+│   │   └── service-middleware.js # Request/response middleware
+│   ├── schemas/
+│   │   └── service-schema.js   # Data validation schemas
+│   └── utils/
+│       └── service-utils.js    # Utility functions
+├── scripts/
+│   ├── deploy.ps1              # Deployment script
+│   ├── setup.ps1               # Environment setup
+│   └── health-check.ps1        # Health monitoring
+├── test/
+│   ├── unit/                   # Unit tests
+│   └── integration/            # Integration tests
+├── config/                     # Environment configurations
+├── docs/                       # Documentation
+└── wrangler.toml               # Cloudflare Workers config
+\`\`\`
+
+## 🔧 Configuration
+
+### Environment Variables
+
+Copy \`.env.example\` to \`.env\` and configure:
+
+\`\`\`bash
+# Cloudflare Configuration
+CLOUDFLARE_ACCOUNT_ID=your_account_id
+CLOUDFLARE_ZONE_ID=your_zone_id
+CLOUDFLARE_API_TOKEN=your_api_token
+
+# Service Configuration
+SERVICE_NAME=${coreInputs.serviceName}
+SERVICE_TYPE=${coreInputs.serviceType}
+DOMAIN_NAME=${coreInputs.domainName}
+ENVIRONMENT=${coreInputs.environment}
+\`\`\`
+
+### Service URLs
+
+- **Production**: ${confirmedValues.productionUrl}
+- **Staging**: ${confirmedValues.stagingUrl}
+- **Development**: ${confirmedValues.developmentUrl}
+- **Documentation**: ${confirmedValues.documentationUrl}
+
+## 🧪 Testing
+
+\`\`\`bash
+# Run all tests
+npm test
+
+# Run with coverage
+npm run test:coverage
+
+# Run integration tests only
+npm test -- --testPathPattern=integration
+\`\`\`
+
+## 🚀 Deployment
+
+### Development
+
+\`\`\`bash
+npm run dev
+\`\`\`
+
+### Staging
+
+\`\`\`bash
+.\\scripts\\deploy.ps1 -Environment staging
+\`\`\`
+
+### Production
+
+\`\`\`bash
+.\\scripts\\deploy.ps1 -Environment production
+\`\`\`
+
+## 🏥 Health Checks
+
+\`\`\`bash
+# Check service health
+.\\scripts\\health-check.ps1 -Environment production
+\`\`\`
+
+Health check endpoint: \`${confirmedValues.healthCheckPath}\`
+
+## 📚 API Documentation
+
+API Base Path: \`${confirmedValues.apiBasePath}\`
+
+See [API Documentation](./docs/API.md) for detailed endpoint information.
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests
+5. Submit a pull request
+
+## 📄 License
+
+${confirmedValues.author} - Generated by Clodo Framework v3.0.0
+
+## 🔗 Links
+
+- **Repository**: ${confirmedValues.gitRepositoryUrl}
+- **Documentation**: ${confirmedValues.documentationUrl}
+- **Health Check**: ${confirmedValues.productionUrl}${confirmedValues.healthCheckPath}
+`;
+  }
+
+  /**
+   * Determine if generator should run
+   */
+  shouldGenerate(context) {
+    return true; // Always generate README
+  }
+}

package/dist/service-management/generators/schemas/ServiceSchemaGenerator.js

@@ -0,0 +1,190 @@
+import { BaseGenerator } from '../BaseGenerator.js';
+import { join } from 'path';
+
+/**
+ * ServiceSchemaGenerator
+ * 
+ * Generates src/schemas/service-schema.js with Zod schemas.
+ */
+export class ServiceSchemaGenerator extends BaseGenerator {
+  constructor(options = {}) {
+    super({
+      name: 'ServiceSchemaGenerator',
+      description: 'Generates service Zod schemas',
+      outputPath: 'src/schemas/service-schema.js',
+      ...options
+    });
+  }
+  shouldGenerate(context) {
+    return true;
+  }
+  async generate(context) {
+    const coreInputs = context.coreInputs || context;
+    const confirmedValues = context.confirmedValues || context;
+    const servicePath = context.servicePath || context.outputDir;
+    this.setContext({
+      coreInputs,
+      confirmedValues,
+      servicePath
+    });
+    const typeSchemas = this._generateTypeSpecificSchemas(coreInputs.serviceType);
+    const content = `/**
+ * ${confirmedValues.displayName} - Service Schema
+ *
+ * Generated by Clodo Framework GenerationEngine
+ * Service Type: ${coreInputs.serviceType}
+ */
+
+import { z } from 'zod';
+
+// Base service schema
+export const baseServiceSchema = z.object({
+  id: z.string().uuid(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  version: z.string().default('${confirmedValues.version}')
+});
+
+// Service-specific schemas based on type
+${typeSchemas}
+
+// Request/Response schemas
+export const healthCheckResponseSchema = z.object({
+  status: z.enum(['healthy', 'unhealthy']),
+  timestamp: z.string().datetime(),
+  service: z.string(),
+  version: z.string(),
+  environment: z.string()
+});
+
+export const errorResponseSchema = z.object({
+  error: z.string(),
+  message: z.string(),
+  timestamp: z.string().datetime(),
+  service: z.string(),
+  version: z.string()
+});
+
+// Validation helpers
+export function validateServiceRequest(data, schema) {
+  try {
+    return { success: true, data: schema.parse(data) };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.errors.map(err => ({
+        field: err.path.join('.'),
+        message: err.message
+      }))
+    };
+  }
+}
+
+export function createServiceResponse(data, schema) {
+  try {
+    return { success: true, data: schema.parse(data) };
+  } catch (error) {
+    throw new Error(\`Response validation failed: \${error.message}\`);
+  }
+}
+`;
+    await this.writeFile(join('src', 'schemas', 'service-schema.js'), content);
+    return join(servicePath, 'src', 'schemas', 'service-schema.js');
+  }
+  _generateTypeSpecificSchemas(serviceType) {
+    const schemas = {
+      'data-service': `export const dataItemSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(1).max(100),
+  description: z.string().max(500).optional(),
+  data: z.record(z.any()),
+  tags: z.array(z.string()).optional(),
+  status: z.enum(['active', 'inactive', 'archived']).default('active')
+});
+
+export const dataQuerySchema = z.object({
+  limit: z.number().min(1).max(100).default(20),
+  offset: z.number().min(0).default(0),
+  search: z.string().optional(),
+  filters: z.record(z.any()).optional(),
+  sortBy: z.string().optional(),
+  sortOrder: z.enum(['asc', 'desc']).default('asc')
+});`,
+      'auth-service': `export const userSchema = z.object({
+  id: z.string().uuid(),
+  email: z.string().email(),
+  username: z.string().min(3).max(50),
+  displayName: z.string().min(1).max(100),
+  roles: z.array(z.string()),
+  isActive: z.boolean().default(true),
+  lastLogin: z.date().optional(),
+  emailVerified: z.boolean().default(false)
+});
+
+export const authTokenSchema = z.object({
+  token: z.string(),
+  type: z.enum(['access', 'refresh']),
+  expiresAt: z.date(),
+  userId: z.string().uuid(),
+  scopes: z.array(z.string())
+});`,
+      'content-service': `export const contentItemSchema = z.object({
+  id: z.string().uuid(),
+  title: z.string().min(1).max(200),
+  content: z.string(),
+  contentType: z.enum(['article', 'page', 'media', 'document']),
+  slug: z.string().min(1).max(100),
+  author: z.string(),
+  published: z.boolean().default(false),
+  publishedAt: z.date().optional(),
+  tags: z.array(z.string()),
+  metadata: z.record(z.any())
+});
+
+export const mediaAssetSchema = z.object({
+  id: z.string().uuid(),
+  filename: z.string(),
+  originalName: z.string(),
+  mimeType: z.string(),
+  size: z.number(),
+  url: z.string(),
+  thumbnailUrl: z.string().optional(),
+  altText: z.string().optional()
+});`,
+      'api-gateway': `export const apiRouteSchema = z.object({
+  path: z.string().regex(/^\\/.*/),
+  method: z.enum(['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS']),
+  targetService: z.string(),
+  targetPath: z.string(),
+  rateLimit: z.number().optional(),
+  authentication: z.boolean().default(false),
+  authorization: z.array(z.string()).optional()
+});
+
+export const apiMetricsSchema = z.object({
+  route: z.string(),
+  method: z.string(),
+  responseTime: z.number(),
+  statusCode: z.number(),
+  timestamp: z.date(),
+  userAgent: z.string().optional(),
+  ipAddress: z.string().optional()
+});`,
+      'generic': `export const genericItemSchema = z.object({
+  id: z.string().uuid(),
+  type: z.string(),
+  data: z.record(z.any()),
+  metadata: z.record(z.any()).optional()
+});`
+    };
+    return schemas[serviceType] || schemas.generic;
+  }
+  validateContext(context) {
+    const coreInputs = context.coreInputs || context;
+    const confirmedValues = context.confirmedValues || context;
+    if (!coreInputs.serviceType || !confirmedValues.version || !confirmedValues.displayName) {
+      throw new Error('ServiceSchemaGenerator: Missing required fields');
+    }
+    return true;
+  }
+}