create-backlist 7.3.1 → 7.4.0

package/bin/qa.js

@@ -0,0 +1,103 @@
+// ═══════════════════════════════════════════════════════════════════════════
+//  Backlist QA CLI — qa.js
+//  Standalone QA entry point: `node bin/qa.js`
+//  Copyright (c) W.A.H.ISHAN — MIT License
+// ═══════════════════════════════════════════════════════════════════════════
+
+#!/usr/bin/env node
+
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { runManualQA, runAutomatedQA, viewQAHistory, initQASystem } from '../src/qa/qa-engine.js';
+
+// ── QA Banner ────────────────────────────────────────────────────────────
+function printQABanner() {
+  const c1 = chalk.hex('#00F5FF');
+  const c2 = chalk.hex('#BF40FF');
+  const c3 = chalk.hex('#FF6B6B');
+  const dim = chalk.gray;
+
+  console.log('');
+  console.log(c1('  ╔══════════════════════════════════════════════════════════════╗'));
+  console.log(c1('  ║') + c2.bold('   ____  ___    ______ ____ ______________  _   ________     ') + c1('║'));
+  console.log(c1('  ║') + c2.bold('  / __ )/   |  / ____// //_// /  _/ ___/  / | / / ____/     ') + c1('║'));
+  console.log(c1('  ║') + c2.bold(' / __  / /| | / /    / ,<  / // /\\__ \\  /  |/ / / __       ') + c1('║'));
+  console.log(c1('  ║') + c2.bold('/ /_/ / ___ |/ /___ / /| |/ /___/__ /_ / /|  / /_/ /        ') + c1('║'));
+  console.log(c1('  ║') + c2.bold('/_____/_/  |_|\\____//_/ |_/_//____/___//_/ |_/\\____/        ') + c1('║'));
+  console.log(c1('  ║') + '                                                              ' + c1('║'));
+  console.log(c1('  ║') + c3.bold('         🧪 QA Testing System — Manual & Automated 🤖        ') + c1('║'));
+  console.log(c1('  ║') + dim('          Bug Reports · Test Suites · HTML/JSON Export         ') + c1('║'));
+  console.log(c1('  ╚══════════════════════════════════════════════════════════════╝'));
+  console.log('');
+  console.log(dim('  Part of create-backlist v7.0 — Polyglot Backend Engine'));
+  console.log(dim('  ─────────────────────────────────────────────────────────────'));
+  console.log('');
+}
+
+// ── Main QA CLI ──────────────────────────────────────────────────────────
+async function main() {
+  printQABanner();
+  await initQASystem();
+
+  p.intro(chalk.hex('#00F5FF').bold(' Backlist QA — Testing & Quality Assurance '));
+
+  const mode = await p.select({
+    message: 'Select QA mode:',
+    options: [
+      {
+        value: 'manual',
+        label: '🧪 Manual QA Testing',
+        hint: 'Interactive — create, execute & track test cases with bug reports',
+      },
+      {
+        value: 'auto',
+        label: '🤖 Automated QA Testing',
+        hint: 'One-time run — test suites against your project',
+      },
+      {
+        value: 'auto-continuous',
+        label: '⚡ Live Continuous Automated QA',
+        hint: 'Runs every 30s — real-time monitoring',
+      },
+      {
+        value: 'history',
+        label: '📜 View QA History',
+        hint: 'See past QA run summaries',
+      },
+    ],
+  });
+
+  if (p.isCancel(mode)) {
+    p.cancel('QA session cancelled.');
+    process.exit(0);
+  }
+
+  switch (mode) {
+    case 'manual':
+      await runManualQA();
+      break;
+
+    case 'auto':
+      await runAutomatedQA({ continuous: false });
+      break;
+
+    case 'auto-continuous':
+      await runAutomatedQA({ continuous: true });
+      break;
+
+    case 'history':
+      await viewQAHistory();
+      p.outro(chalk.hex('#00F5FF').bold('History viewed.'));
+      break;
+
+    default:
+      p.cancel('Unknown mode.');
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(chalk.red.bold(`\n  QA Error: ${err.message || err}`));
+  if (err.stack) console.error(chalk.gray(err.stack));
+  process.exit(1);
+});

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "create-backlist",
-  "version": "7.3.1",
+  "version": "7.4.0",
   "description": "An advanced, multi-language backend generator based on frontend analysis. Smart Freemium SaaS CLI.",
   "type": "module",
   "bin": {
-    "create-backlist": "bin/index.js"
+    "create-backlist": "bin/index.js",
+    "backlist-qa": "bin/qa.js"
   },
   "files": [
     "bin",
@@ -12,7 +13,10 @@
     "AiModuls"
   ],
   "scripts": {
-    "start": "node bin/index.js"
+    "start": "node bin/index.js",
+    "qa": "node bin/qa.js",
+    "qa:auto": "node bin/qa.js --auto",
+    "qa:live": "node bin/qa.js --live"
   },
   "author": "W.A.H.ISHAN",
   "license": "MIT",

package/src/env-resolver.js

@@ -1,70 +1,70 @@
-import fs from "fs-extra";
-import path from "node:path";
-
-const ENV_FILES = [
-  ".env.local",
-  ".env.development",
-  ".env.development.local",
-  ".env",
-];
-
-const API_URL_PATTERNS = [
-  "API_URL",
-  "API_BASE_URL",
-  "API_BASE",
-  "BASE_URL",
-  "BACKEND_URL",
-  "SERVER_URL",
-];
-
-export async function parseEnvFiles(projectRoot) {
-  const envMap = new Map();
-
-  for (const envFile of ENV_FILES) {
-    const filePath = path.join(projectRoot, envFile);
-    if (!(await fs.pathExists(filePath))) continue;
-
-    let content;
-    try {
-      content = await fs.readFile(filePath, "utf-8");
-    } catch {
-      continue;
-    }
-
-    for (const line of content.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
-
-      const eqIndex = trimmed.indexOf("=");
-      if (eqIndex === -1) continue;
-
-      const key = trimmed.slice(0, eqIndex).trim();
-      let value = trimmed.slice(eqIndex + 1).trim();
-
-      if (
-        (value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith("'") && value.endsWith("'"))
-      ) {
-        value = value.slice(1, -1);
-      }
-
-      if (key && value && !envMap.has(key)) {
-        envMap.set(key, value);
-      }
-    }
-  }
-
-  return envMap;
-}
-
-export function extractBaseUrlFromEnv(envMap) {
-  for (const [key, value] of envMap) {
-    const upperKey = key.toUpperCase();
-    for (const pattern of API_URL_PATTERNS) {
-      if (upperKey.includes(pattern) && value.startsWith("http")) {
-        return value.replace(/\/$/, "");
-      }
-    }
-  }
-  return null;
-}
+import fs from "fs-extra";
+import path from "node:path";
+
+const ENV_FILES = [
+  ".env.local",
+  ".env.development",
+  ".env.development.local",
+  ".env",
+];
+
+const API_URL_PATTERNS = [
+  "API_URL",
+  "API_BASE_URL",
+  "API_BASE",
+  "BASE_URL",
+  "BACKEND_URL",
+  "SERVER_URL",
+];
+
+export async function parseEnvFiles(projectRoot) {
+  const envMap = new Map();
+
+  for (const envFile of ENV_FILES) {
+    const filePath = path.join(projectRoot, envFile);
+    if (!(await fs.pathExists(filePath))) continue;
+
+    let content;
+    try {
+      content = await fs.readFile(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+
+      const eqIndex = trimmed.indexOf("=");
+      if (eqIndex === -1) continue;
+
+      const key = trimmed.slice(0, eqIndex).trim();
+      let value = trimmed.slice(eqIndex + 1).trim();
+
+      if (
+        (value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))
+      ) {
+        value = value.slice(1, -1);
+      }
+
+      if (key && value && !envMap.has(key)) {
+        envMap.set(key, value);
+      }
+    }
+  }
+
+  return envMap;
+}
+
+export function extractBaseUrlFromEnv(envMap) {
+  for (const [key, value] of envMap) {
+    const upperKey = key.toUpperCase();
+    for (const pattern of API_URL_PATTERNS) {
+      if (upperKey.includes(pattern) && value.startsWith("http")) {
+        return value.replace(/\/$/, "");
+      }
+    }
+  }
+  return null;
+}

package/src/generators/dotnet.js

@@ -1,134 +1,134 @@
-import chalk from 'chalk';
-import { execa } from 'execa';
-import fs from 'fs-extra';
-import path from 'node:path';
-import { analyzeFrontend } from '../analyzer.js';
-import { renderAndWrite, getTemplatePath } from './template.js';
-
-export async function generateDotnetProject(options) {
-  const { projectDir, projectName, frontendSrcDir } = options;
-
-  try {
-    console.log(chalk.blue('  -> Analyzing frontend for C# backend...'));
-    const endpoints = await analyzeFrontend(frontendSrcDir);
-    const modelsToGenerate = new Map();
-    endpoints.forEach(ep => {
-      if (ep.schemaFields && ep.controllerName !== 'Default' && !modelsToGenerate.has(ep.controllerName)) {
-        modelsToGenerate.set(ep.controllerName, {
-          name: ep.controllerName,
-          fields: Object.entries(ep.schemaFields).map(([key, type]) => ({ name: key, type }))
-        });
-      }
-    });
-
-    if (modelsToGenerate.size > 0) {
-      console.log(chalk.green(`  -> Identified ${modelsToGenerate.size} models/controllers to generate.`));
-    } else {
-      console.log(chalk.yellow('  -> No API calls with body data found. A basic API project will be created without models.'));
-    }
-
-    console.log(chalk.blue('  -> Scaffolding .NET Core Web API project...'));
-    await execa('dotnet', ['new', 'webapi', '-n', projectName, '-o', projectDir, '--no-https']);
-
-    if (modelsToGenerate.size > 0) {
-      console.log(chalk.blue('  -> Adding NuGet packages (Entity Framework Core)...'));
-      const packages = [
-        'Microsoft.EntityFrameworkCore.Design',
-        'Microsoft.EntityFrameworkCore.InMemory'
-      ];
-      for (const pkg of packages) {
-        await execa('dotnet', ['add', 'package', pkg], { cwd: projectDir });
-      }
-    }
-
-    if (modelsToGenerate.size > 0) {
-      console.log(chalk.blue('  -> Generating EF Core models and DbContext...'));
-      const modelsDir = path.join(projectDir, 'Models');
-      const dataDir = path.join(projectDir, 'Data');
-      await fs.ensureDir(modelsDir);
-      await fs.ensureDir(dataDir);
-
-      for (const [modelName, modelData] of modelsToGenerate.entries()) {
-        await renderAndWrite(
-          getTemplatePath('dotnet/partials/Model.cs.ejs'),
-          path.join(modelsDir, `${modelName}.cs`),
-          { projectName, modelName, model: modelData }
-        );
-      }
-
-      await renderAndWrite(
-        getTemplatePath('dotnet/partials/DbContext.cs.ejs'),
-        path.join(dataDir, 'ApplicationDbContext.cs'),
-        { projectName, modelsToGenerate: Array.from(modelsToGenerate.values()) }
-      );
-    }
-
-    console.log(chalk.blue('  -> Configuring services in Program.cs...'));
-    const programCsPath = path.join(projectDir, 'Program.cs');
-    let programCsContent = await fs.readFile(programCsPath, 'utf-8');
-
-    let usingStatements = 'using Microsoft.EntityFrameworkCore;\nusing ' + projectName + '.Data;\n';
-    programCsContent = usingStatements + programCsContent;
-
-    let dbContextService = '// Configure the database context\nbuilder.Services.AddDbContext<ApplicationDbContext>(opt => opt.UseInMemoryDatabase("MyDb"));';
-    programCsContent = programCsContent.replace('builder.Services.AddControllers();', `builder.Services.AddControllers();\n\n${dbContextService}`);
-
-    const corsPolicy = `
-builder.Services.AddCors(options =>
-{
-    options.AddDefaultPolicy(
-        policy =>
-        {
-            policy.WithOrigins("http://localhost:3000", "http://localhost:5173")
-                   .AllowAnyHeader()
-                   .AllowAnyMethod();
-        });
-});`;
-    programCsContent = programCsContent.replace('var app = builder.Build();', `${corsPolicy}\n\nvar app = builder.Build();\n\napp.UseCors();`);
-
-    await fs.writeFile(programCsPath, programCsContent);
-
-    console.log(chalk.blue('  -> Generating controllers with CRUD logic...'));
-    await fs.remove(path.join(projectDir, 'Controllers', 'WeatherForecastController.cs'));
-    await fs.remove(path.join(projectDir, 'WeatherForecast.cs'));
-
-    const controllersToGenerate = new Set(Array.from(modelsToGenerate.keys()));
-    endpoints.forEach(ep => {
-      if (ep.controllerName !== 'Default') controllersToGenerate.add(ep.controllerName);
-    });
-
-    for (const controllerName of controllersToGenerate) {
-      const controllerEndpoints = endpoints.filter(
-        ep => ep.controllerName === controllerName
-      );
-      await renderAndWrite(
-        getTemplatePath('dotnet/partials/Controller.cs.ejs'),
-        path.join(projectDir, 'Controllers', `${controllerName}Controller.cs`),
-        { projectName, controllerName, endpoints: controllerEndpoints }
-      );
-    }
-
-    console.log(chalk.blue('  -> Generating Docker files...'));
-    await renderAndWrite(
-      getTemplatePath('dotnet/partials/Dockerfile.ejs'),
-      path.join(projectDir, 'Dockerfile'),
-      { projectName }
-    );
-    await renderAndWrite(
-      getTemplatePath('dotnet/partials/docker-compose.yml.ejs'),
-      path.join(projectDir, 'docker-compose.yml'),
-      { projectName }
-    );
-
-    await renderAndWrite(
-      getTemplatePath('dotnet/partials/README.md.ejs'),
-      path.join(projectDir, 'README.md'),
-      { projectName }
-    );
-
-    console.log(chalk.green('  -> C# backend generation is complete!'));
-
-  } catch (error) {
-    throw error;
-  }
-}
+import chalk from 'chalk';
+import { execa } from 'execa';
+import fs from 'fs-extra';
+import path from 'node:path';
+import { analyzeFrontend } from '../analyzer.js';
+import { renderAndWrite, getTemplatePath } from './template.js';
+
+export async function generateDotnetProject(options) {
+  const { projectDir, projectName, frontendSrcDir } = options;
+
+  try {
+    console.log(chalk.blue('  -> Analyzing frontend for C# backend...'));
+    const endpoints = await analyzeFrontend(frontendSrcDir);
+    const modelsToGenerate = new Map();
+    endpoints.forEach(ep => {
+      if (ep.schemaFields && ep.controllerName !== 'Default' && !modelsToGenerate.has(ep.controllerName)) {
+        modelsToGenerate.set(ep.controllerName, {
+          name: ep.controllerName,
+          fields: Object.entries(ep.schemaFields).map(([key, type]) => ({ name: key, type }))
+        });
+      }
+    });
+
+    if (modelsToGenerate.size > 0) {
+      console.log(chalk.green(`  -> Identified ${modelsToGenerate.size} models/controllers to generate.`));
+    } else {
+      console.log(chalk.yellow('  -> No API calls with body data found. A basic API project will be created without models.'));
+    }
+
+    console.log(chalk.blue('  -> Scaffolding .NET Core Web API project...'));
+    await execa('dotnet', ['new', 'webapi', '-n', projectName, '-o', projectDir, '--no-https']);
+
+    if (modelsToGenerate.size > 0) {
+      console.log(chalk.blue('  -> Adding NuGet packages (Entity Framework Core)...'));
+      const packages = [
+        'Microsoft.EntityFrameworkCore.Design',
+        'Microsoft.EntityFrameworkCore.InMemory'
+      ];
+      for (const pkg of packages) {
+        await execa('dotnet', ['add', 'package', pkg], { cwd: projectDir });
+      }
+    }
+
+    if (modelsToGenerate.size > 0) {
+      console.log(chalk.blue('  -> Generating EF Core models and DbContext...'));
+      const modelsDir = path.join(projectDir, 'Models');
+      const dataDir = path.join(projectDir, 'Data');
+      await fs.ensureDir(modelsDir);
+      await fs.ensureDir(dataDir);
+
+      for (const [modelName, modelData] of modelsToGenerate.entries()) {
+        await renderAndWrite(
+          getTemplatePath('dotnet/partials/Model.cs.ejs'),
+          path.join(modelsDir, `${modelName}.cs`),
+          { projectName, modelName, model: modelData }
+        );
+      }
+
+      await renderAndWrite(
+        getTemplatePath('dotnet/partials/DbContext.cs.ejs'),
+        path.join(dataDir, 'ApplicationDbContext.cs'),
+        { projectName, modelsToGenerate: Array.from(modelsToGenerate.values()) }
+      );
+    }
+
+    console.log(chalk.blue('  -> Configuring services in Program.cs...'));
+    const programCsPath = path.join(projectDir, 'Program.cs');
+    let programCsContent = await fs.readFile(programCsPath, 'utf-8');
+
+    let usingStatements = 'using Microsoft.EntityFrameworkCore;\nusing ' + projectName + '.Data;\n';
+    programCsContent = usingStatements + programCsContent;
+
+    let dbContextService = '// Configure the database context\nbuilder.Services.AddDbContext<ApplicationDbContext>(opt => opt.UseInMemoryDatabase("MyDb"));';
+    programCsContent = programCsContent.replace('builder.Services.AddControllers();', `builder.Services.AddControllers();\n\n${dbContextService}`);
+
+    const corsPolicy = `
+builder.Services.AddCors(options =>
+{
+    options.AddDefaultPolicy(
+        policy =>
+        {
+            policy.WithOrigins("http://localhost:3000", "http://localhost:5173")
+                   .AllowAnyHeader()
+                   .AllowAnyMethod();
+        });
+});`;
+    programCsContent = programCsContent.replace('var app = builder.Build();', `${corsPolicy}\n\nvar app = builder.Build();\n\napp.UseCors();`);
+
+    await fs.writeFile(programCsPath, programCsContent);
+
+    console.log(chalk.blue('  -> Generating controllers with CRUD logic...'));
+    await fs.remove(path.join(projectDir, 'Controllers', 'WeatherForecastController.cs'));
+    await fs.remove(path.join(projectDir, 'WeatherForecast.cs'));
+
+    const controllersToGenerate = new Set(Array.from(modelsToGenerate.keys()));
+    endpoints.forEach(ep => {
+      if (ep.controllerName !== 'Default') controllersToGenerate.add(ep.controllerName);
+    });
+
+    for (const controllerName of controllersToGenerate) {
+      const controllerEndpoints = endpoints.filter(
+        ep => ep.controllerName === controllerName
+      );
+      await renderAndWrite(
+        getTemplatePath('dotnet/partials/Controller.cs.ejs'),
+        path.join(projectDir, 'Controllers', `${controllerName}Controller.cs`),
+        { projectName, controllerName, endpoints: controllerEndpoints }
+      );
+    }
+
+    console.log(chalk.blue('  -> Generating Docker files...'));
+    await renderAndWrite(
+      getTemplatePath('dotnet/partials/Dockerfile.ejs'),
+      path.join(projectDir, 'Dockerfile'),
+      { projectName }
+    );
+    await renderAndWrite(
+      getTemplatePath('dotnet/partials/docker-compose.yml.ejs'),
+      path.join(projectDir, 'docker-compose.yml'),
+      { projectName }
+    );
+
+    await renderAndWrite(
+      getTemplatePath('dotnet/partials/README.md.ejs'),
+      path.join(projectDir, 'README.md'),
+      { projectName }
+    );
+
+    console.log(chalk.green('  -> C# backend generation is complete!'));
+
+  } catch (error) {
+    throw error;
+  }
+}