create-backlist 10.1.0 → 10.1.2

package/src/generators/js.js

@@ -4,30 +4,45 @@ import fs from 'fs-extra';
 import path from 'node:path';
 import ejs from 'ejs';
 import { analyzeFrontend } from '../analyzer.js';
-import { renderAndWrite, getTemplatePath } from './template.js';
+import { renderAndWrite, renderAndWriteAll, getTemplatePath, preloadTemplates } from './template.js';
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function timer() {
+  const s = Date.now();
+  return () => `${((Date.now() - s) / 1000).toFixed(2)}s`;
+}
+
+async function withRetry(fn, { attempts = 3, baseDelay = 300, label = 'task' } = {}) {
+  let lastErr;
+  for (let i = 0; i < attempts; i++) {
+    try { return await fn(); } catch (err) {
+      lastErr = err;
+      if (i < attempts - 1) {
+        const delay = baseDelay * 2 ** i;
+        console.log(chalk.yellow(`  [RETRY] ${label} (${i + 1}/${attempts}), retrying in ${delay}ms...`));
+        await new Promise(r => setTimeout(r, delay));
+      }
+    }
+  }
+  throw lastErr;
+}
 
 function stripQuery(p) {
   return String(p || '').split('?')[0];
 }
 
 function safePascalName(name) {
-  const cleaned = String(name || 'Default')
-    .split('?')[0]
-    .replace(/[^a-zA-Z0-9]/g, '');
+  const cleaned = String(name || 'Default').split('?')[0].replace(/[^a-zA-Z0-9]/g, '');
   if (!cleaned) return 'Default';
   return cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
 }
 
 function sanitizeEndpoints(endpoints) {
   if (!Array.isArray(endpoints)) return [];
-
   return endpoints.map((ep) => {
     const rawPath = stripQuery(ep.path || ep.route || '/');
-    const parts = rawPath
-      .split('/')
-      .filter(Boolean)
-      .filter((p) => p !== 'api' && !/^v\d+$/i.test(p));
-
+    const parts = rawPath.split('/').filter(Boolean).filter((p) => p !== 'api' && !/^v\d+$/i.test(p));
     const resource = parts[0] || 'Default';
     const controllerName = safePascalName(resource);
     let functionName = '';
@@ -44,86 +59,108 @@ function sanitizeEndpoints(endpoints) {
       const method = String(ep.method || 'GET').toUpperCase();
       const hasId = rawPath.includes(':') || rawPath.includes('{') || /\/\d+/.test(rawPath);
 
-      if (method === 'GET') {
-        functionName = hasId ? `get${pascalSingular}ById` : `getAll${pascalPlural}`;
-      } else if (method === 'POST') {
-        functionName = `create${pascalSingular}`;
-      } else if (method === 'PUT' || method === 'PATCH') {
-        functionName = `update${pascalSingular}ById`;
-      } else if (method === 'DELETE') {
-        functionName = `delete${pascalSingular}ById`;
-      } else {
-        functionName = `${method.toLowerCase()}${pascalPlural}`;
-      }
+      if (method === 'GET') functionName = hasId ? `get${pascalSingular}ById` : `getAll${pascalPlural}`;
+      else if (method === 'POST') functionName = `create${pascalSingular}`;
+      else if (method === 'PUT' || method === 'PATCH') functionName = `update${pascalSingular}ById`;
+      else if (method === 'DELETE') functionName = `delete${pascalSingular}ById`;
+      else functionName = `${method.toLowerCase()}${pascalPlural}`;
     }
 
     return { ...ep, path: rawPath, route: rawPath, controllerName, functionName };
   });
 }
 
-export async function generateJsProject(options) {
-  const {
-    projectDir,
-    projectName,
-    frontendSrcDir,
-    dbType,
-    addAuth,
-    addSeeder,
-    extraFeatures = [],
-  } = options;
+// ─── Main Generator ───────────────────────────────────────────────────────────
 
+export async function generateJsProject(options) {
+  const { projectDir, projectName, frontendSrcDir, dbType, addAuth, addSeeder, extraFeatures = [] } = options;
   const port = 8000;
+  const totalTimer = timer();
 
   try {
-    // --- Step 1: Analyze Frontend ---
-    console.log(chalk.blue('  -> Analyzing frontend for API endpoints...'));
-    let endpoints = await analyzeFrontend(frontendSrcDir);
-
-    if (Array.isArray(endpoints) && endpoints.length > 0) {
-      console.log(chalk.green(`  -> Found ${endpoints.length} endpoints.`));
-      endpoints = sanitizeEndpoints(endpoints);
-    } else {
-      endpoints = [];
-      console.log(chalk.yellow('  -> No API endpoints found. A basic project will be created.'));
-    }
+    // ── Step 1: Analyze + preload templates in parallel ────────────────────────
+    const step1 = timer();
+    console.log(chalk.blue('  -> [1] Analyzing frontend & preloading templates in parallel...'));
+
+    const templatePrefetch = [
+      'js-express/partials/package.json.ejs',
+      'js-express/partials/db.js.ejs',
+      'js-express/partials/routes.js.ejs',
+      'js-express/partials/controller.js.ejs',
+      'js-express/partials/service.js.ejs',
+      ...(dbType === 'mongoose' ? ['js-express/partials/model.js.ejs'] : []),
+      ...(dbType === 'prisma' ? ['js-express/partials/prisma.schema.ejs'] : []),
+      ...(addAuth ? ['js-express/partials/auth.controller.js.ejs', 'js-express/partials/auth.middleware.js.ejs', 'js-express/partials/auth.routes.js.ejs'] : []),
+      ...(addSeeder ? ['js-express/partials/seeder.js.ejs'] : []),
+      ...(extraFeatures.includes('docker') ? ['js-express/partials/Dockerfile.ejs', 'js-express/partials/docker-compose.yml.ejs'] : []),
+      ...(extraFeatures.includes('swagger') ? ['js-express/partials/swagger.js.ejs'] : []),
+      ...(extraFeatures.includes('testing') ? ['js-express/partials/test.js.ejs'] : []),
+    ];
+
+    const [endpointsRaw] = await Promise.all([
+      analyzeFrontend(frontendSrcDir),
+      preloadTemplates(templatePrefetch).catch(() => {}),
+    ]);
+
+    let endpoints = Array.isArray(endpointsRaw) && endpointsRaw.length > 0
+      ? sanitizeEndpoints(endpointsRaw)
+      : [];
+
+    console.log(
+      endpoints.length > 0
+        ? chalk.green(`  -> Found ${endpoints.length} endpoints. ${chalk.gray(step1())}`)
+        : chalk.yellow(`  -> No endpoints found. Basic project will be created. ${chalk.gray(step1())}`)
+    );
 
-    // --- Step 2: Identify Models ---
+    // ── Step 2: Build model map ────────────────────────────────────────────────
     const modelsToGenerate = new Map();
     endpoints.forEach((ep) => {
       if (!ep) return;
       const ctrl = safePascalName(ep.controllerName);
       if (ctrl === 'Default' || ctrl === 'Auth') return;
       if (!modelsToGenerate.has(ctrl)) {
-        let fields = [];
-        if (ep.schemaFields) {
-          fields = Object.entries(ep.schemaFields).map(([key, type]) => ({
-            name: key,
-            type,
-            isUnique: key === 'email',
-          }));
-        }
+        const fields = ep.schemaFields
+          ? Object.entries(ep.schemaFields).map(([key, type]) => ({ name: key, type, isUnique: key === 'email' }))
+          : [];
         modelsToGenerate.set(ctrl, { name: ctrl, fields });
       }
     });
 
     if (addAuth && !modelsToGenerate.has('User')) {
-      modelsToGenerate.set('User', {
-        name: 'User',
-        fields: [
-          { name: 'name', type: 'String' },
-          { name: 'email', type: 'String', isUnique: true },
-          { name: 'password', type: 'String' },
-        ],
-      });
+      modelsToGenerate.set('User', { name: 'User', fields: [
+        { name: 'name', type: 'String' },
+        { name: 'email', type: 'String', isUnique: true },
+        { name: 'password', type: 'String' },
+      ]});
     }
 
-    // --- Step 3: Base Scaffolding ---
-    console.log(chalk.blue('  -> Scaffolding JavaScript (ESM) Express project...'));
-    const srcDir = path.join(projectDir, 'src');
-    await fs.ensureDir(srcDir);
-    await fs.copy(getTemplatePath('js-express/base/server.js'), path.join(srcDir, 'server.js'));
+    // ── Step 3: Scaffold dirs + copy base server.js in parallel ───────────────
+    const step3 = timer();
+    console.log(chalk.blue('  -> [3] Scaffolding directory structure in parallel...'));
 
-    // --- Step 4: package.json ---
+    const srcDir = path.join(projectDir, 'src');
+    const dirsToCreate = [
+      srcDir,
+      path.join(srcDir, 'routes'),
+      ...(modelsToGenerate.size > 0 ? [
+        path.join(srcDir, 'controllers'),
+        path.join(srcDir, 'services'),
+        ...(dbType === 'mongoose' ? [path.join(srcDir, 'models')] : []),
+        ...(dbType === 'prisma' ? [path.join(projectDir, 'prisma')] : []),
+      ] : []),
+      ...(addAuth ? [path.join(srcDir, 'middleware')] : []),
+      ...(addSeeder ? [path.join(projectDir, 'scripts')] : []),
+      ...(extraFeatures.includes('swagger') ? [path.join(srcDir, 'utils')] : []),
+      ...(extraFeatures.includes('testing') ? [path.join(projectDir, 'tests')] : []),
+    ];
+
+    await Promise.all([
+      ...dirsToCreate.map(d => fs.ensureDir(d)),
+      fs.copy(getTemplatePath('js-express/base/server.js'), path.join(srcDir, 'server.js')),
+    ]);
+    console.log(chalk.gray(`     Scaffolding done. ${step3()}`));
+
+    // ── Step 4: package.json (build once) ─────────────────────────────────────
     const pkgTpl = await fs.readFile(getTemplatePath('js-express/partials/package.json.ejs'), 'utf-8');
     const packageJsonContent = JSON.parse(ejs.render(pkgTpl, { projectName }));
 
@@ -132,24 +169,20 @@ export async function generateJsProject(options) {
       packageJsonContent.dependencies['@prisma/client'] = '^5.6.0';
       packageJsonContent.devDependencies.prisma = '^5.6.0';
     }
-
     if (addAuth) {
       packageJsonContent.dependencies.jsonwebtoken = '^9.0.2';
       packageJsonContent.dependencies.bcryptjs = '^2.4.3';
     }
-
     if (addSeeder) {
       packageJsonContent.devDependencies['@faker-js/faker'] = '^8.3.1';
       packageJsonContent.scripts.seed = 'node scripts/seeder.js';
       packageJsonContent.scripts.destroy = 'node scripts/seeder.js -d';
     }
-
     if (extraFeatures.includes('testing')) {
       packageJsonContent.devDependencies.vitest = '^1.1.0';
       packageJsonContent.devDependencies.supertest = '^6.3.3';
       packageJsonContent.scripts.test = 'vitest run';
     }
-
     if (extraFeatures.includes('swagger')) {
       packageJsonContent.dependencies['swagger-ui-express'] = '^5.0.0';
       packageJsonContent.dependencies['swagger-jsdoc'] = '^6.2.8';
@@ -157,181 +190,140 @@ export async function generateJsProject(options) {
 
     await fs.writeJson(path.join(projectDir, 'package.json'), packageJsonContent, { spaces: 2 });
 
-    // --- Step 5: Database connection file ---
-    await renderAndWrite(
-      getTemplatePath('js-express/partials/db.js.ejs'),
-      path.join(srcDir, 'db.js'),
-      { dbType, projectName }
-    );
+    // ── Step 5: All file generation tasks in PARALLEL batches ─────────────────
+    const step5 = timer();
+    console.log(chalk.blue('  -> [5] Generating all project files in parallel...'));
 
-    // --- Step 6: Models + Controllers + Services ---
-    if (modelsToGenerate.size > 0) {
-      const controllersDir = path.join(srcDir, 'controllers');
-      const servicesDir = path.join(srcDir, 'services');
-      const modelsDir = path.join(srcDir, 'models');
-
-      await fs.ensureDir(controllersDir);
-      await fs.ensureDir(servicesDir);
-
-      if (dbType === 'mongoose') {
-        console.log(chalk.blue('  -> Generating Mongoose models...'));
-        await fs.ensureDir(modelsDir);
-        for (const [modelName, modelData] of modelsToGenerate.entries()) {
-          await renderAndWrite(
-            getTemplatePath('js-express/partials/model.js.ejs'),
-            path.join(modelsDir, `${modelName}.model.js`),
-            { modelName, fields: modelData.fields || [] }
-          );
-        }
-      } else if (dbType === 'prisma') {
-        console.log(chalk.blue('  -> Generating Prisma schema...'));
-        await fs.ensureDir(path.join(projectDir, 'prisma'));
-        await renderAndWrite(
-          getTemplatePath('js-express/partials/prisma.schema.ejs'),
-          path.join(projectDir, 'prisma', 'schema.prisma'),
-          { models: Array.from(modelsToGenerate.values()) }
-        );
-      }
+    const renderTasks = [];
 
-      console.log(chalk.blue('  -> Generating Controllers & Services...'));
-      for (const [modelName] of modelsToGenerate.entries()) {
-        if (modelName === 'Auth') continue;
-        await renderAndWrite(
-          getTemplatePath('js-express/partials/controller.js.ejs'),
-          path.join(controllersDir, `${modelName}.controller.js`),
-          { modelName, dbType }
-        );
-        await renderAndWrite(
-          getTemplatePath('js-express/partials/service.js.ejs'),
-          path.join(servicesDir, `${modelName}.service.js`),
-          { modelName, dbType }
-        );
+    // DB connection file
+    renderTasks.push({
+      templatePath: getTemplatePath('js-express/partials/db.js.ejs'),
+      outPath: path.join(srcDir, 'db.js'),
+      data: { dbType, projectName },
+    });
+
+    // Models
+    if (dbType === 'mongoose') {
+      for (const [modelName, modelData] of modelsToGenerate.entries()) {
+        renderTasks.push({
+          templatePath: getTemplatePath('js-express/partials/model.js.ejs'),
+          outPath: path.join(srcDir, 'models', `${modelName}.model.js`),
+          data: { modelName, fields: modelData.fields || [] },
+        });
       }
+    } else if (dbType === 'prisma') {
+      renderTasks.push({
+        templatePath: getTemplatePath('js-express/partials/prisma.schema.ejs'),
+        outPath: path.join(projectDir, 'prisma', 'schema.prisma'),
+        data: { models: Array.from(modelsToGenerate.values()) },
+      });
     }
 
-    // --- Step 7: Routes ---
-    const nonAuthEndpoints = endpoints.filter((ep) => safePascalName(ep.controllerName) !== 'Auth');
-    await fs.ensureDir(path.join(srcDir, 'routes'));
+    // Controllers + Services
+    for (const [modelName] of modelsToGenerate.entries()) {
+      if (modelName === 'Auth') continue;
+      renderTasks.push(
+        { templatePath: getTemplatePath('js-express/partials/controller.js.ejs'), outPath: path.join(srcDir, 'controllers', `${modelName}.controller.js`), data: { modelName, dbType } },
+        { templatePath: getTemplatePath('js-express/partials/service.js.ejs'),    outPath: path.join(srcDir, 'services',    `${modelName}.service.js`),    data: { modelName, dbType } }
+      );
+    }
 
-    await renderAndWrite(
-      getTemplatePath('js-express/partials/routes.js.ejs'),
-      path.join(srcDir, 'routes', 'index.js'),
-      { endpoints: nonAuthEndpoints, addAuth, dbType }
-    );
+    // Routes
+    const nonAuthEndpoints = endpoints.filter((ep) => safePascalName(ep.controllerName) !== 'Auth');
+    renderTasks.push({
+      templatePath: getTemplatePath('js-express/partials/routes.js.ejs'),
+      outPath: path.join(srcDir, 'routes', 'index.js'),
+      data: { endpoints: nonAuthEndpoints, addAuth, dbType },
+    });
 
-    // --- Step 8: Auth ---
+    // Auth
     if (addAuth) {
-      console.log(chalk.blue('  -> Generating authentication boilerplate...'));
-      await fs.ensureDir(path.join(srcDir, 'controllers'));
-      await fs.ensureDir(path.join(srcDir, 'middleware'));
-      await fs.ensureDir(path.join(srcDir, 'routes'));
-
-      await renderAndWrite(
-        getTemplatePath('js-express/partials/auth.controller.js.ejs'),
-        path.join(srcDir, 'controllers', 'Auth.controller.js'),
-        { dbType, projectName }
-      );
-      await renderAndWrite(
-        getTemplatePath('js-express/partials/auth.middleware.js.ejs'),
-        path.join(srcDir, 'middleware', 'auth.js'),
-        { projectName }
-      );
-      await renderAndWrite(
-        getTemplatePath('js-express/partials/auth.routes.js.ejs'),
-        path.join(srcDir, 'routes', 'auth.js'),
-        { projectName }
+      renderTasks.push(
+        { templatePath: getTemplatePath('js-express/partials/auth.controller.js.ejs'), outPath: path.join(srcDir, 'controllers', 'Auth.controller.js'), data: { dbType, projectName } },
+        { templatePath: getTemplatePath('js-express/partials/auth.middleware.js.ejs'), outPath: path.join(srcDir, 'middleware', 'auth.js'), data: { projectName } },
+        { templatePath: getTemplatePath('js-express/partials/auth.routes.js.ejs'),     outPath: path.join(srcDir, 'routes', 'auth.js'), data: { projectName } }
       );
     }
 
-    // --- Step 9: Seeder ---
+    // Seeder
     if (addSeeder) {
-      console.log(chalk.blue('  -> Generating database seeder script...'));
-      await fs.ensureDir(path.join(projectDir, 'scripts'));
-      await renderAndWrite(
-        getTemplatePath('js-express/partials/seeder.js.ejs'),
-        path.join(projectDir, 'scripts', 'seeder.js'),
-        { projectName, dbType, models: Array.from(modelsToGenerate.values()) }
-      );
+      renderTasks.push({
+        templatePath: getTemplatePath('js-express/partials/seeder.js.ejs'),
+        outPath: path.join(projectDir, 'scripts', 'seeder.js'),
+        data: { projectName, dbType, models: Array.from(modelsToGenerate.values()) },
+      });
     }
 
-    // --- Step 10: Docker ---
+    // Docker
     if (extraFeatures.includes('docker')) {
-      console.log(chalk.blue('  -> Generating Docker files...'));
-      await renderAndWrite(
-        getTemplatePath('js-express/partials/Dockerfile.ejs'),
-        path.join(projectDir, 'Dockerfile'),
-        { port }
-      );
-      await renderAndWrite(
-        getTemplatePath('js-express/partials/docker-compose.yml.ejs'),
-        path.join(projectDir, 'docker-compose.yml'),
-        { projectName, dbType, port }
+      renderTasks.push(
+        { templatePath: getTemplatePath('js-express/partials/Dockerfile.ejs'),          outPath: path.join(projectDir, 'Dockerfile'),         data: { port } },
+        { templatePath: getTemplatePath('js-express/partials/docker-compose.yml.ejs'),  outPath: path.join(projectDir, 'docker-compose.yml'), data: { projectName, dbType, port } }
       );
     }
 
-    // --- Step 11: Swagger ---
+    // Swagger
     if (extraFeatures.includes('swagger')) {
-      console.log(chalk.blue('  -> Generating API documentation setup...'));
-      await fs.ensureDir(path.join(srcDir, 'utils'));
-      await renderAndWrite(
-        getTemplatePath('js-express/partials/swagger.js.ejs'),
-        path.join(srcDir, 'utils', 'swagger.js'),
-        { projectName, port, addAuth }
-      );
+      renderTasks.push({
+        templatePath: getTemplatePath('js-express/partials/swagger.js.ejs'),
+        outPath: path.join(srcDir, 'utils', 'swagger.js'),
+        data: { projectName, port, addAuth },
+      });
     }
 
-    // --- Step 12: Testing ---
+    // Testing
     if (extraFeatures.includes('testing')) {
-      console.log(chalk.blue('  -> Generating test boilerplate...'));
-      await fs.ensureDir(path.join(projectDir, 'tests'));
-      await renderAndWrite(
-        getTemplatePath('js-express/partials/test.js.ejs'),
-        path.join(projectDir, 'tests', 'api.test.js'),
-        { addAuth, endpoints }
-      );
+      renderTasks.push({
+        templatePath: getTemplatePath('js-express/partials/test.js.ejs'),
+        outPath: path.join(projectDir, 'tests', 'api.test.js'),
+        data: { addAuth, endpoints },
+      });
     }
 
-    // --- Step 13: Inject into server.js ---
+    await renderAndWriteAll(renderTasks, 12);
+    console.log(chalk.gray(`     All files generated. ${step5()}`));
+
+    // ── Step 6: Patch server.js ────────────────────────────────────────────────
     let serverContent = await fs.readFile(path.join(srcDir, 'server.js'), 'utf-8');
 
-    let dbImport = '';
-    if (dbType === 'mongoose') {
-      dbImport = "\nimport { connectDB } from './db.js';\nconnectDB();\n";
-    } else if (dbType === 'prisma') {
-      dbImport = "\nimport { prisma } from './db.js';\n";
-    }
+    const dbImport =
+      dbType === 'mongoose' ? "\nimport { connectDB } from './db.js';\nconnectDB();\n"
+      : dbType === 'prisma' ? "\nimport { prisma } from './db.js';\n"
+      : '';
 
-    let swaggerInject = '';
-    if (extraFeatures.includes('swagger')) {
-      swaggerInject = "\nimport { setupSwagger } from './utils/swagger.js';\nsetupSwagger(app);\n";
-    }
+    const swaggerInject = extraFeatures.includes('swagger')
+      ? "\nimport { setupSwagger } from './utils/swagger.js';\nsetupSwagger(app);\n"
+      : '';
 
-    let authInject = '';
-    if (addAuth) {
-      authInject = "import authRoutes from './routes/auth.js';\napp.use('/api/auth', authRoutes);\n\n";
-    }
+    const authInject = addAuth
+      ? "import authRoutes from './routes/auth.js';\napp.use('/api/auth', authRoutes);\n\n"
+      : '';
 
     serverContent = serverContent
       .replace('dotenv.config();', `dotenv.config();${dbImport}`)
-      .replace(
-        '// INJECT:ROUTES',
-        `${authInject}import apiRoutes from './routes/index.js';\napp.use('/api', apiRoutes);`
-      );
-
-    serverContent = serverContent.replace(/(const server = app\.listen\()/, `${swaggerInject}\n$1`);
+      .replace('// INJECT:ROUTES', `${authInject}import apiRoutes from './routes/index.js';\napp.use('/api', apiRoutes);`)
+      .replace(/(const server = app\.listen\()/, `${swaggerInject}\n$1`);
 
     await fs.writeFile(path.join(srcDir, 'server.js'), serverContent);
 
-    // --- Step 14: Install deps ---
-    console.log(chalk.magenta('  -> Installing dependencies... This may take a moment.'));
-    await execa('npm', ['install'], { cwd: projectDir });
+    // ── Step 7: Install deps (with retry) ─────────────────────────────────────
+    console.log(chalk.magenta('  -> [7] Installing dependencies...'));
+    const step7 = timer();
+
+    await withRetry(() => execa('npm', ['install'], { cwd: projectDir }), {
+      attempts: 2, baseDelay: 1000, label: 'npm install',
+    });
+
+    console.log(chalk.gray(`     npm install done. ${step7()}`));
 
     if (dbType === 'prisma') {
-      console.log(chalk.blue('  -> Running `prisma generate`...'));
-      await execa('npx', ['prisma', 'generate'], { cwd: projectDir });
+      await withRetry(() => execa('npx', ['prisma', 'generate'], { cwd: projectDir }), {
+        attempts: 2, baseDelay: 500, label: 'prisma generate',
+      });
     }
 
-    // --- Step 15: .env.example ---
+    // ── Step 8: .env.example ───────────────────────────────────────────────────
     let envContent = `PORT=${port}\n`;
     if (dbType === 'mongoose') envContent += `MONGO_URI=mongodb://127.0.0.1:27017/${projectName}\n`;
     if (dbType === 'prisma') envContent += `DATABASE_URL="postgresql://user:password@localhost:5432/${projectName}?schema=public"\n`;
@@ -339,7 +331,7 @@ export async function generateJsProject(options) {
 
     await fs.writeFile(path.join(projectDir, '.env.example'), envContent);
 
-    console.log(chalk.green('  -> JavaScript Express backend generation complete.'));
+    console.log(chalk.green(`  -> ✓ JavaScript Express backend generation complete. Total: ${chalk.bold(totalTimer())}`));
   } catch (error) {
     throw error;
   }