@l4yercak3/cli 1.2.21 → 1.3.1

package/src/commands/scaffold.js

@@ -0,0 +1,409 @@
+/**
+ * Scaffold Command
+ * Generates integration files based on the project manifest (.l4yercak3.json)
+ * Diff-aware: only creates files that don't already exist
+ */
+
+const fs = require('fs');
+const path = require('path');
+const configManager = require('../config/config-manager');
+const manifestGenerator = require('../generators/manifest-generator');
+const { ensureDir, checkFileOverwrite, GENERATED_HEADER } = require('../utils/file-utils');
+const { requireAuth } = require('../utils/init-helpers');
+const chalk = require('chalk');
+
+async function handleScaffold() {
+  requireAuth(configManager);
+
+  console.log(chalk.cyan('  📦 Scaffolding integration files...\n'));
+
+  try {
+    const projectPath = process.cwd();
+
+    // Step 1: Load manifest
+    const manifest = manifestGenerator.loadManifest(projectPath);
+    if (!manifest) {
+      console.log(chalk.yellow('  ⚠️  No .l4yercak3.json manifest found.'));
+      console.log(chalk.gray('     Run "l4yercak3 init" first to scan your project.\n'));
+      process.exit(1);
+    }
+
+    const framework = manifest.framework || 'unknown';
+    const routerType = manifest.routerType || 'pages';
+    const isTypeScript = manifest.typescript || false;
+    const ext = isTypeScript ? 'ts' : 'js';
+
+    console.log(chalk.green(`  ✅ Loaded manifest: ${framework} (${routerType} router, ${isTypeScript ? 'TypeScript' : 'JavaScript'})`));
+    console.log(chalk.gray(`     ${manifest.detectedModels?.length || 0} models, ${manifest.detectedRoutes?.length || 0} routes\n`));
+
+    // Step 2: Determine which files to generate
+    const filesToGenerate = [];
+
+    // a) lib/l4yercak3 client wrapper
+    const clientDir = path.join(projectPath, 'lib');
+    const clientFile = path.join(clientDir, `l4yercak3.${ext}`);
+    filesToGenerate.push({
+      path: clientFile,
+      name: `lib/l4yercak3.${ext}`,
+      content: generateClientWrapper(manifest, isTypeScript),
+    });
+
+    // b) Webhook handler (framework-specific path)
+    let webhookFile;
+    if (framework === 'nextjs' && routerType === 'app') {
+      webhookFile = path.join(projectPath, 'app', 'api', 'webhooks', 'l4yercak3', `route.${ext}`);
+    } else if (framework === 'nextjs') {
+      webhookFile = path.join(projectPath, 'pages', 'api', 'webhooks', `l4yercak3.${ext}`);
+    }
+
+    if (webhookFile) {
+      const relPath = path.relative(projectPath, webhookFile);
+      filesToGenerate.push({
+        path: webhookFile,
+        name: relPath,
+        content: generateWebhookHandler(manifest, isTypeScript, routerType),
+      });
+    }
+
+    // c) Types file (if TypeScript and has models/mappings)
+    if (isTypeScript && manifest.detectedModels?.length > 0) {
+      const typesDir = path.join(projectPath, 'types');
+      const typesFile = path.join(typesDir, 'l4yercak3.ts');
+      filesToGenerate.push({
+        path: typesFile,
+        name: 'types/l4yercak3.ts',
+        content: generateTypes(manifest),
+      });
+    }
+
+    // Step 3: Diff-aware generation
+    console.log(chalk.cyan('  🔍 Checking existing files...\n'));
+    const created = [];
+    const skipped = [];
+
+    for (const file of filesToGenerate) {
+      const action = await checkFileOverwrite(file.path, { defaultAction: 'skip' });
+
+      if (action === 'skip') {
+        skipped.push(file.name);
+        continue;
+      }
+
+      // Ensure directory exists
+      ensureDir(path.dirname(file.path));
+
+      // Write file
+      fs.writeFileSync(file.path, file.content, 'utf8');
+      created.push(file.name);
+    }
+
+    // Step 4: Display results
+    if (created.length > 0) {
+      console.log(chalk.green('  ✅ Files created:\n'));
+      for (const name of created) {
+        console.log(chalk.gray(`     • ${name}`));
+      }
+    }
+
+    if (skipped.length > 0) {
+      console.log(chalk.gray(`\n  ⏭️  Skipped (already exist):\n`));
+      for (const name of skipped) {
+        console.log(chalk.gray(`     • ${name}`));
+      }
+    }
+
+    if (created.length === 0 && skipped.length > 0) {
+      console.log(chalk.green('\n  ✅ All integration files already exist. Nothing to generate.\n'));
+    } else {
+      console.log(chalk.cyan('\n  🎉 Scaffold complete!\n'));
+    }
+
+    console.log(chalk.gray('  Next steps:'));
+    console.log(chalk.gray('     • Import the L4YERCAK3 client: import { l4yercak3 } from "@/lib/l4yercak3"'));
+    console.log(chalk.gray('     • Run "l4yercak3 sync" after changing your project structure\n'));
+
+  } catch (error) {
+    console.error(chalk.red(`\n  ❌ Error: ${error.message}\n`));
+    if (process.env.L4YERCAK3_DEBUG && error.stack) {
+      console.error(chalk.gray(error.stack));
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Generate the L4YERCAK3 client wrapper
+ */
+function generateClientWrapper(manifest, isTypeScript) {
+  const mappings = manifest.suggestedMappings || [];
+  const hasContact = mappings.some(m => m.platformType === 'contact');
+  const hasBooking = mappings.some(m => m.platformType === 'booking');
+  const hasEvent = mappings.some(m => m.platformType === 'event');
+  const hasProduct = mappings.some(m => m.platformType === 'product');
+
+  const typeAnnotation = isTypeScript ? ': string' : '';
+  const typeImport = isTypeScript
+    ? `import type { L4yercak3Config } from '@/types/l4yercak3';\n\n`
+    : '';
+
+  return `/**
+ * L4YERCAK3 API Client
+ * ${GENERATED_HEADER}
+ *
+ * Usage: import { l4yercak3 } from '@/lib/l4yercak3';
+ */
+
+${typeImport}const API_KEY${typeAnnotation} = process.env.L4YERCAK3_API_KEY || '';
+const BASE_URL${typeAnnotation} = process.env.L4YERCAK3_BACKEND_URL || 'https://agreeable-lion-828.convex.site';
+const ORG_ID${typeAnnotation} = process.env.L4YERCAK3_ORG_ID || '';
+const APP_ID${typeAnnotation} = process.env.L4YERCAK3_APP_ID || '';
+
+class L4yercak3Client {
+  constructor() {
+    this.apiKey = API_KEY;
+    this.baseUrl = BASE_URL;
+    this.orgId = ORG_ID;
+    this.appId = APP_ID;
+  }
+
+  async request(method${typeAnnotation ? ': string' : ''}, endpoint${typeAnnotation ? ': string' : ''}, data${isTypeScript ? '?: Record<string, unknown>' : ''}) {
+    const url = \`\${this.baseUrl}\${endpoint}\`;
+    const headers${isTypeScript ? ': Record<string, string>' : ''} = {
+      'Content-Type': 'application/json',
+      'Authorization': \`Bearer \${this.apiKey}\`,
+      'X-Organization-Id': this.orgId,
+      'X-Application-Id': this.appId,
+    };
+
+    const options${isTypeScript ? ': RequestInit' : ''} = { method, headers };
+    if (data && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+      options.body = JSON.stringify(data);
+    }
+
+    const response = await fetch(url, options);
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new Error(error.message || \`API error: \${response.status}\`);
+    }
+    return response.json();
+  }
+${hasContact ? `
+  // Contact methods
+  async getContacts() {
+    return this.request('GET', '/api/v1/contacts');
+  }
+
+  async createContact(data${isTypeScript ? ': Record<string, unknown>' : ''}) {
+    return this.request('POST', '/api/v1/contacts', data);
+  }
+` : ''}${hasBooking ? `
+  // Booking methods
+  async getBookings() {
+    return this.request('GET', '/api/v1/bookings');
+  }
+
+  async createBooking(data${isTypeScript ? ': Record<string, unknown>' : ''}) {
+    return this.request('POST', '/api/v1/bookings', data);
+  }
+` : ''}${hasEvent ? `
+  // Event methods
+  async getEvents() {
+    return this.request('GET', '/api/v1/events');
+  }
+
+  async createEvent(data${isTypeScript ? ': Record<string, unknown>' : ''}) {
+    return this.request('POST', '/api/v1/events', data);
+  }
+` : ''}${hasProduct ? `
+  // Product methods
+  async getProducts() {
+    return this.request('GET', '/api/v1/products');
+  }
+
+  async createProduct(data${isTypeScript ? ': Record<string, unknown>' : ''}) {
+    return this.request('POST', '/api/v1/products', data);
+  }
+` : ''}
+  // Generic resource methods
+  async get(resource${typeAnnotation ? ': string' : ''}) {
+    return this.request('GET', \`/api/v1/\${resource}\`);
+  }
+
+  async create(resource${typeAnnotation ? ': string' : ''}, data${isTypeScript ? ': Record<string, unknown>' : ''}) {
+    return this.request('POST', \`/api/v1/\${resource}\`, data);
+  }
+
+  async update(resource${typeAnnotation ? ': string' : ''}, id${typeAnnotation ? ': string' : ''}, data${isTypeScript ? ': Record<string, unknown>' : ''}) {
+    return this.request('PATCH', \`/api/v1/\${resource}/\${id}\`, data);
+  }
+
+  async remove(resource${typeAnnotation ? ': string' : ''}, id${typeAnnotation ? ': string' : ''}) {
+    return this.request('DELETE', \`/api/v1/\${resource}/\${id}\`);
+  }
+}
+
+export const l4yercak3 = new L4yercak3Client();
+export default l4yercak3;
+`;
+}
+
+/**
+ * Generate webhook handler
+ */
+function generateWebhookHandler(manifest, isTypeScript, routerType) {
+  if (routerType === 'app') {
+    return `/**
+ * L4YERCAK3 Webhook Handler (App Router)
+ * ${GENERATED_HEADER}
+ *
+ * Receives webhook events from the L4YERCAK3 platform.
+ * Configure your webhook URL in the L4YERCAK3 dashboard.
+ */
+
+import { NextResponse } from 'next/server';
+
+export async function POST(request${isTypeScript ? ': Request' : ''}) {
+  try {
+    const body = await request.json();
+    const eventType = body.type;
+
+    // Verify webhook signature (recommended for production)
+    // const signature = request.headers.get('x-l4yercak3-signature');
+
+    switch (eventType) {
+      case 'contact.created':
+      case 'contact.updated':
+        // Handle contact events
+        console.log(\`[L4YERCAK3] \${eventType}:\`, body.data);
+        break;
+
+      case 'booking.created':
+      case 'booking.updated':
+        // Handle booking events
+        console.log(\`[L4YERCAK3] \${eventType}:\`, body.data);
+        break;
+
+      default:
+        console.log(\`[L4YERCAK3] Unhandled event: \${eventType}\`);
+    }
+
+    return NextResponse.json({ received: true });
+  } catch (error) {
+    console.error('[L4YERCAK3] Webhook error:', error);
+    return NextResponse.json({ error: 'Webhook processing failed' }, { status: 500 });
+  }
+}
+`;
+  }
+
+  // Pages Router
+  return `/**
+ * L4YERCAK3 Webhook Handler (Pages Router)
+ * ${GENERATED_HEADER}
+ *
+ * Receives webhook events from the L4YERCAK3 platform.
+ * Configure your webhook URL in the L4YERCAK3 dashboard.
+ */
+
+export default async function handler(req, res) {
+  if (req.method !== 'POST') {
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  try {
+    const body = req.body;
+    const eventType = body.type;
+
+    // Verify webhook signature (recommended for production)
+    // const signature = req.headers['x-l4yercak3-signature'];
+
+    switch (eventType) {
+      case 'contact.created':
+      case 'contact.updated':
+        // Handle contact events
+        console.log(\`[L4YERCAK3] \${eventType}:\`, body.data);
+        break;
+
+      case 'booking.created':
+      case 'booking.updated':
+        // Handle booking events
+        console.log(\`[L4YERCAK3] \${eventType}:\`, body.data);
+        break;
+
+      default:
+        console.log(\`[L4YERCAK3] Unhandled event: \${eventType}\`);
+    }
+
+    return res.status(200).json({ received: true });
+  } catch (error) {
+    console.error('[L4YERCAK3] Webhook error:', error);
+    return res.status(500).json({ error: 'Webhook processing failed' });
+  }
+}
+`;
+}
+
+/**
+ * Generate TypeScript types based on manifest models and mappings
+ */
+function generateTypes(manifest) {
+  const models = manifest.detectedModels || [];
+  const mappings = manifest.suggestedMappings || [];
+
+  let content = `/**
+ * L4YERCAK3 Types
+ * ${GENERATED_HEADER}
+ *
+ * Types generated from your project's detected models and platform mappings.
+ */
+
+export interface L4yercak3Config {
+  apiKey: string;
+  baseUrl: string;
+  orgId: string;
+  appId: string;
+}
+
+export interface WebhookEvent {
+  type: string;
+  data: Record<string, unknown>;
+  timestamp: number;
+  applicationId: string;
+}
+
+`;
+
+  // Generate interfaces for each mapping
+  for (const mapping of mappings) {
+    const model = models.find(m => m.name === mapping.localModel);
+    if (model) {
+      content += `/**
+ * Platform mapping: ${model.name} → ${mapping.platformType} (${mapping.confidence}% confidence)
+ * Source: ${model.source}
+ */
+export interface ${model.name}Mapping {
+`;
+      for (const field of model.fields) {
+        content += `  ${field}: unknown;\n`;
+      }
+      content += `  // Platform fields
+  _platformType: '${mapping.platformType}';
+  _platformId?: string;
+}\n\n`;
+    }
+  }
+
+  // Generate union type of all platform types used
+  const platformTypes = [...new Set(mappings.map(m => m.platformType))];
+  if (platformTypes.length > 0) {
+    content += `export type PlatformType = ${platformTypes.map(t => `'${t}'`).join(' | ')};\n`;
+  }
+
+  return content;
+}
+
+module.exports = {
+  command: 'scaffold',
+  description: 'Generate integration files based on your project manifest',
+  handler: handleScaffold,
+};