@navneet_25/tempjs 1.1.0 → 2.0.0

package/cli/brand-manager.js

@@ -3,52 +3,78 @@ import { stdin as input, stdout as output } from "node:process";
 import { readFile, writeFile } from "node:fs/promises";
 import { findSiteTs } from "./theme-manager.js";
 
-export async function promptAndApplyBrand(targetDir) {
-  const siteTsPath = await findSiteTs(targetDir);
-  if (!siteTsPath) {
-    console.error("Error: Could not locate constants/site.ts. Make sure you are inside an initialized tempjs template directory.");
-    return;
-  }
-
-  // Load current values if possible to provide defaults
-  let siteContent = await readFile(siteTsPath, "utf8");
+/**
+ * @typedef {{
+ *   yes?: boolean,
+ *   name?: string,
+ *   shortName?: string,
+ *   baseUrl?: string,
+ *   phone?: string,
+ *   phoneDisplay?: string,
+ *   countryCode?: string,
+ *   email?: string,
+ *   address?: string
+ * }} BrandOptions
+ */
 
-  // Parse existing values using simple regex
-  const currentBrandName = (siteContent.match(/name:\s*"([^"]+)"/) || [])[1] || "Chanakya Resort";
-  const currentShortName = (siteContent.match(/shortName:\s*"([^"]+)"/) || [])[1] || "Chanakya";
-  const currentBaseUrl = (siteContent.match(/baseUrl:\s*"([^"]+)"/) || [])[1] || "https://chanakyaresort.com";
-  const currentPhone = (siteContent.match(/phone:\s*"([^"]+)"/) || [])[1] || "9876543210";
-  const currentPhoneDisplay = (siteContent.match(/phoneDisplay:\s*"([^"]+)"/) || [])[1] || "+91 98765 43210";
-  const currentCountryCode = (siteContent.match(/countryCode:\s*"([^"]+)"/) || [])[1] || "91";
-  const currentEmail = (siteContent.match(/email:\s*"([^"]+)"/) || [])[1] || "reservations@chanakyaresort.com";
-  const currentAddress = (siteContent.match(/full:\s*"([^"]+)"/) || [])[1] || "Lonavala, Maharashtra, India";
+/**
+ * @param {string} siteContent
+ */
+function parseCurrentBrandValues(siteContent) {
+  return {
+    brandName: (siteContent.match(/name:\s*"([^"]+)"/) || [])[1] || "Chanakya Resort",
+    shortName: (siteContent.match(/shortName:\s*"([^"]+)"/) || [])[1] || "Chanakya",
+    baseUrl: (siteContent.match(/baseUrl:\s*"([^"]+)"/) || [])[1] || "https://chanakyaresort.com",
+    phone: (siteContent.match(/phone:\s*"([^"]+)"/) || [])[1] || "9876543210",
+    phoneDisplay: (siteContent.match(/phoneDisplay:\s*"([^"]+)"/) || [])[1] || "+91 98765 43210",
+    countryCode: (siteContent.match(/countryCode:\s*"([^"]+)"/) || [])[1] || "91",
+    email: (siteContent.match(/email:\s*"([^"]+)"/) || [])[1] || "reservations@chanakyaresort.com",
+    address: (siteContent.match(/full:\s*"([^"]+)"/) || [])[1] || "Lonavala, Maharashtra, India",
+  };
+}
 
-  const rl = createInterface({ input, output });
+/**
+ * @param {string} baseUrl
+ */
+function deriveWwwHost(baseUrl) {
   try {
-    console.log("\n--- Configure Brand & Contact Details ---");
+    const url = new URL(baseUrl);
+    return url.hostname.startsWith("www.") ? url.hostname : `www.${url.hostname}`;
+  } catch {
+    let wwwHost = baseUrl.replace(/^https?:\/\//, "");
+    if (!wwwHost.startsWith("www.")) wwwHost = `www.${wwwHost}`;
+    return wwwHost;
+  }
+}
+
+/**
+ * @param {string} siteContent
+ * @param {{
+ *   brandName: string,
+ *   shortName: string,
+ *   baseUrl: string,
+ *   phone: string,
+ *   phoneDisplay: string,
+ *   countryCode: string,
+ *   email: string,
+ *   address: string
+ * }} values
+ */
+function applyBrandToSiteContent(siteContent, values) {
+  const {
+    brandName,
+    shortName,
+    baseUrl,
+    phone,
+    phoneDisplay,
+    countryCode,
+    email,
+    address,
+  } = values;
 
-    const brandName = (await rl.question(`Brand Name [${currentBrandName}]: `)).trim() || currentBrandName;
-    const shortName = (await rl.question(`Short/Display Name [${currentShortName}]: `)).trim() || currentShortName;
-    const baseUrl = (await rl.question(`Base URL [${currentBaseUrl}]: `)).trim() || currentBaseUrl;
-
-    // Derive wwwHost from baseUrl
-    let wwwHost = "www.example.com";
-    try {
-      const url = new URL(baseUrl);
-      wwwHost = url.hostname.startsWith("www.") ? url.hostname : `www.${url.hostname}`;
-    } catch {
-      wwwHost = baseUrl.replace(/^https?:\/\//, "");
-      if (!wwwHost.startsWith("www.")) wwwHost = `www.${wwwHost}`;
-    }
-
-    const phone = (await rl.question(`Contact Phone Number [${currentPhone}]: `)).trim() || currentPhone;
-    const phoneDisplay = (await rl.question(`Display Phone Number [${currentPhoneDisplay}]: `)).trim() || currentPhoneDisplay;
-    const countryCode = (await rl.question(`Country Code [${currentCountryCode}]: `)).trim() || currentCountryCode;
-    const email = (await rl.question(`Contact Email [${currentEmail}]: `)).trim() || currentEmail;
-    const address = (await rl.question(`Full Address [${currentAddress}]: `)).trim() || currentAddress;
-
-    // Build replacement blocks
-    const newBrandBlock = `brand: {
+  const wwwHost = deriveWwwHost(baseUrl);
+
+  const newBrandBlock = `brand: {
     name: "${brandName}",
     shortName: "${shortName}",
     tagline: "Where Nature Meets Refined Comfort",
@@ -58,21 +84,20 @@ export async function promptAndApplyBrand(targetDir) {
     managedBy: "Managed by ${brandName}.",
   }`;
 
-    const newDomainBlock = `domain: {
+  const newDomainBlock = `domain: {
     baseUrl: "${baseUrl}",
     wwwHost: "${wwwHost}",
   }`;
 
-    // Extract address locality/region/country or keep defaults
-    let locality = "Lonavala";
-    let region = "MH";
-    const addressParts = address.split(",");
-    if (addressParts.length >= 2) {
-      locality = addressParts[0].trim();
-      region = addressParts[1].trim();
-    }
+  let locality = "Lonavala";
+  let region = "MH";
+  const addressParts = address.split(",");
+  if (addressParts.length >= 2) {
+    locality = addressParts[0].trim();
+    region = addressParts[1].trim();
+  }
 
-    const newContactBlock = `contact: {
+  const newContactBlock = `contact: {
     phone: "${phone}",
     phoneDisplay: "${phoneDisplay}",
     countryCode: "${countryCode}",
@@ -85,20 +110,107 @@ export async function promptAndApplyBrand(targetDir) {
     },
   }`;
 
-    // Apply replacements using exact patterns matching our templates
-    const brandRegex = /brand:\s*\{[\s\S]*?\n\s*\},/;
-    const domainRegex = /domain:\s*\{[\s\S]*?\n\s*\},/;
-    const contactRegex = /contact:\s*\{[\s\S]*?address:\s*\{[\s\S]*?\}[\s\S]*?\n\s*\},/;
-
-    if (brandRegex.test(siteContent)) {
-      siteContent = siteContent.replace(brandRegex, newBrandBlock + ",");
-    }
-    if (domainRegex.test(siteContent)) {
-      siteContent = siteContent.replace(domainRegex, newDomainBlock + ",");
-    }
-    if (contactRegex.test(siteContent)) {
-      siteContent = siteContent.replace(contactRegex, newContactBlock + ",");
-    }
+  const brandRegex = /brand:\s*\{[\s\S]*?\n\s*\},/;
+  const domainRegex = /domain:\s*\{[\s\S]*?\n\s*\},/;
+  const contactRegex = /contact:\s*\{[\s\S]*?address:\s*\{[\s\S]*?\}[\s\S]*?\n\s*\},/;
+
+  if (brandRegex.test(siteContent)) {
+    siteContent = siteContent.replace(brandRegex, newBrandBlock + ",");
+  }
+  if (domainRegex.test(siteContent)) {
+    siteContent = siteContent.replace(domainRegex, newDomainBlock + ",");
+  }
+  if (contactRegex.test(siteContent)) {
+    siteContent = siteContent.replace(contactRegex, newContactBlock + ",");
+  }
+
+  return siteContent;
+}
+
+/**
+ * @param {string} targetDir
+ * @param {BrandOptions} options
+ */
+export async function applyBrand(targetDir, options = {}) {
+  const siteTsPath = await findSiteTs(targetDir);
+  if (!siteTsPath) {
+    throw new Error(
+      "Could not locate constants/site.ts. Make sure you are inside an initialized tempjs template directory."
+    );
+  }
+
+  let siteContent = await readFile(siteTsPath, "utf8");
+  const current = parseCurrentBrandValues(siteContent);
+
+  const values = {
+    brandName: options.name?.trim() || current.brandName,
+    shortName: options.shortName?.trim() || current.shortName,
+    baseUrl: options.baseUrl?.trim() || current.baseUrl,
+    phone: options.phone?.trim() || current.phone,
+    phoneDisplay: options.phoneDisplay?.trim() || current.phoneDisplay,
+    countryCode: options.countryCode?.trim() || current.countryCode,
+    email: options.email?.trim() || current.email,
+    address: options.address?.trim() || current.address,
+  };
+
+  siteContent = applyBrandToSiteContent(siteContent, values);
+  await writeFile(siteTsPath, siteContent, "utf8");
+  console.log("Successfully updated brand and contact configurations in constants/site.ts.");
+}
+
+/**
+ * @param {string} targetDir
+ * @param {BrandOptions} options
+ */
+export async function promptAndApplyBrand(targetDir, options = {}) {
+  if (options.yes) {
+    await applyBrand(targetDir, options);
+    return;
+  }
+
+  const siteTsPath = await findSiteTs(targetDir);
+  if (!siteTsPath) {
+    console.error(
+      "Error: Could not locate constants/site.ts. Make sure you are inside an initialized tempjs template directory."
+    );
+    return;
+  }
+
+  let siteContent = await readFile(siteTsPath, "utf8");
+  const current = parseCurrentBrandValues(siteContent);
+
+  const rl = createInterface({ input, output });
+  try {
+    console.log("\n--- Configure Brand & Contact Details ---");
+
+    const brandName =
+      (await rl.question(`Brand Name [${current.brandName}]: `)).trim() || current.brandName;
+    const shortName =
+      (await rl.question(`Short/Display Name [${current.shortName}]: `)).trim() || current.shortName;
+    const baseUrl =
+      (await rl.question(`Base URL [${current.baseUrl}]: `)).trim() || current.baseUrl;
+    const phone =
+      (await rl.question(`Contact Phone Number [${current.phone}]: `)).trim() || current.phone;
+    const phoneDisplay =
+      (await rl.question(`Display Phone Number [${current.phoneDisplay}]: `)).trim() ||
+      current.phoneDisplay;
+    const countryCode =
+      (await rl.question(`Country Code [${current.countryCode}]: `)).trim() || current.countryCode;
+    const email =
+      (await rl.question(`Contact Email [${current.email}]: `)).trim() || current.email;
+    const address =
+      (await rl.question(`Full Address [${current.address}]: `)).trim() || current.address;
+
+    siteContent = applyBrandToSiteContent(siteContent, {
+      brandName,
+      shortName,
+      baseUrl,
+      phone,
+      phoneDisplay,
+      countryCode,
+      email,
+      address,
+    });
 
     await writeFile(siteTsPath, siteContent, "utf8");
     console.log("Successfully updated brand and contact configurations in constants/site.ts.");

package/cli/config.js

@@ -5,7 +5,20 @@ import { fileURLToPath } from "node:url";
 const packageRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
 
 /** @typedef {{ owner: string, repo: string, branch: string, templatesPath: string }} RepositoryConfig */
-/** @typedef {{ directory: string, name: string, description: string }} TemplateEntry */
+/** @typedef {{
+ *   directory: string,
+ *   name: string,
+ *   description: string,
+ *   version?: string,
+ *   stack?: string[],
+ *   packageManager?: string,
+ *   node?: string,
+ *   setupTime?: string,
+ *   docker?: boolean,
+ *   tags?: string[],
+ *   features?: string[],
+ *   docs?: string
+ * }} TemplateEntry */
 /** @typedef {{ repository: RepositoryConfig, templates: Record<string, TemplateEntry> }} Manifest */
 
 /**

package/cli/copy.js

@@ -9,23 +9,10 @@ import {
   statSync,
 } from "node:fs";
 import { join } from "node:path";
+import { NEVER_COPY_NAMES, shouldSkipFileName } from "./fs-ignore.js";
 
-const NEVER_COPY = new Set([".git", ".gitignore.bak"]);
 const NEVER_OVERWRITE = new Set([".git"]);
 
-/**
- * Files that must never be transferred into a generated project.
- * @param {string} name
- * @returns {boolean}
- */
-function shouldSkipFile(name) {
-  if (NEVER_COPY.has(name)) return true;
-  if (name === ".env" || name.startsWith(".env.")) {
-    return name !== ".env.example";
-  }
-  return false;
-}
-
 /**
  * @param {string} dir
  * @returns {string[]}
@@ -75,7 +62,7 @@ function collectConflicts(sourceDir, targetDir, relative, conflicts) {
 
   const sourceNames = readdirSync(currentSource);
   for (const name of sourceNames) {
-    if (shouldSkipFile(name)) continue;
+    if (shouldSkipFileName(name)) continue;
 
     const relPath = relative ? join(relative, name) : name;
     const sourcePath = join(sourceDir, relPath);
@@ -126,7 +113,7 @@ function copyRecursive(sourceRoot, targetRoot, relative) {
   const names = readdirSync(sourcePath);
 
   for (const name of names) {
-    if (shouldSkipFile(name)) continue;
+    if (shouldSkipFileName(name) || NEVER_COPY_NAMES.has(name)) continue;
 
     const relPath = relative ? join(relative, name) : name;
     const from = join(sourceRoot, relPath);
@@ -138,7 +125,6 @@ function copyRecursive(sourceRoot, targetRoot, relative) {
 
     const stat = lstatSync(from);
     if (stat.isSymbolicLink()) {
-      const linkTarget = readlinkSync(from);
       mkdirSync(join(to, ".."), { recursive: true });
       cpSync(from, to, { recursive: true, force: true });
       continue;
@@ -158,7 +144,7 @@ function copyRecursive(sourceRoot, targetRoot, relative) {
  * @param {string} dir
  */
 export function removeDirectory(dir) {
-  if (existsSync(dir)) {
+  if (dir && existsSync(dir)) {
     rmSync(dir, { recursive: true, force: true });
   }
 }

package/cli/db-setup.js

@@ -6,11 +6,29 @@ import { join, basename, resolve } from "node:path";
 import crypto from "node:crypto";
 import { execSync } from "node:child_process";
 
-export async function promptAndSetupDb(targetDir) {
+/**
+ * @typedef {{
+ *   yes?: boolean,
+ *   dbHost?: string,
+ *   dbPort?: string,
+ *   dbUser?: string,
+ *   dbPassword?: string,
+ *   dbName?: string,
+ *   adminUser?: string,
+ *   adminPassword?: string,
+ *   skipDbPush?: boolean,
+ *   dbPush?: boolean
+ * }} DbSetupOptions
+ */
+
+/**
+ * @param {string} targetDir
+ * @param {DbSetupOptions} options
+ */
+export async function setupDb(targetDir, options = {}) {
   const envPath = join(targetDir, ".env");
   const envExamplePath = join(targetDir, ".env.example");
 
-  // Load existing env values as defaults if .env exists
   let existingEnv = "";
   if (existsSync(envPath)) {
     try {
@@ -20,22 +38,23 @@ export async function promptAndSetupDb(targetDir) {
     }
   }
 
-  // Helper to extract env var
   const getEnvVal = (key, fallback) => {
     const match = existingEnv.match(new RegExp(`^${key}\\s*=\\s*["']?([^"'\r\n]+)["']?`, "m"));
     return match ? match[1] : fallback;
   };
 
-  // Parse existing DB URL if any
   const currentDbUrl = getEnvVal("DATABASE_URL", "");
   let defaultHost = "localhost";
   let defaultPort = "3306";
   let defaultUser = "root";
   let defaultPass = "";
-  let defaultDbName = basename(resolve(targetDir)).toLowerCase().replace(/[^a-z0-9_]/g, "_") + "_db";
+  let defaultDbName =
+    basename(resolve(targetDir)).toLowerCase().replace(/[^a-z0-9_]/g, "_") + "_db";
 
   if (currentDbUrl) {
-    const urlMatch = currentDbUrl.match(/mysql:\/\/([^:@]+)(?::([^@]+))?@([^:/]+)(?::(\d+))?\/([^?]+)/);
+    const urlMatch = currentDbUrl.match(
+      /mysql:\/\/([^:@]+)(?::([^@]+))?@([^:/]+)(?::(\d+))?\/([^?]+)/
+    );
     if (urlMatch) {
       defaultUser = urlMatch[1];
       defaultPass = urlMatch[2] || "";
@@ -48,71 +67,173 @@ export async function promptAndSetupDb(targetDir) {
   const defaultAdminUser = getEnvVal("ADMIN_USER", "admin");
   const defaultAdminPass = getEnvVal("ADMIN_PASSWORD", crypto.randomBytes(4).toString("hex"));
 
-  const rl = createInterface({ input, output });
-  try {
-    console.log("\n--- Configure Database & Environment Variables ---");
+  const host = options.dbHost?.trim() || defaultHost;
+  const port = options.dbPort?.trim() || defaultPort;
+  const user = options.dbUser?.trim() || defaultUser;
+  const pass = options.dbPassword !== undefined ? options.dbPassword : defaultPass;
+  const dbName = options.dbName?.trim() || defaultDbName;
+  const adminUser = options.adminUser?.trim() || defaultAdminUser;
+  const adminPass = options.adminPassword?.trim() || defaultAdminPass;
 
-    const host = (await rl.question(`MySQL Database Host [${defaultHost}]: `)).trim() || defaultHost;
-    const port = (await rl.question(`MySQL Database Port [${defaultPort}]: `)).trim() || defaultPort;
-    const user = (await rl.question(`MySQL Database Username [${defaultUser}]: `)).trim() || defaultUser;
-    const pass = (await rl.question(`MySQL Database Password [${defaultPass ? "*****" : "(empty)"}]: `)).trim() || defaultPass;
-    const dbName = (await rl.question(`MySQL Database Name [${defaultDbName}]: `)).trim() || defaultDbName;
+  const dbUrl = `mysql://${user}${pass ? `:${encodeURIComponent(pass)}` : ""}@${host}:${port}/${dbName}`;
 
-    const adminUser = (await rl.question(`Admin Portal Username [${defaultAdminUser}]: `)).trim() || defaultAdminUser;
-    const adminPass = (await rl.question(`Admin Portal Password [${defaultAdminPass}]: `)).trim() || defaultAdminPass;
+  let envContent = "";
+  if (existsSync(envExamplePath)) {
+    envContent = await readFile(envExamplePath, "utf8");
+  }
 
-    // Construct MySQL Connection URL
-    const dbUrl = `mysql://${user}${pass ? `:${encodeURIComponent(pass)}` : ""}@${host}:${port}/${dbName}`;
+  const randomSecret = crypto.randomBytes(32).toString("base64");
 
-    // Read template or write fresh environment file
-    let envContent = "";
-    if (existsSync(envExamplePath)) {
-      envContent = await readFile(envExamplePath, "utf8");
+  const updateEnvKey = (content, key, value) => {
+    const regex = new RegExp(`^#?\\s*${key}\\s*=.*$`, "m");
+    if (regex.test(content)) {
+      return content.replace(regex, `${key}="${value}"`);
     }
+    return `${content.trim()}\n${key}="${value}"\n`;
+  };
 
-    // Generate fresh secret
-    const randomSecret = crypto.randomBytes(32).toString("base64");
-
-    // Replace or construct env keys
-    const updateEnvKey = (content, key, value) => {
-      const regex = new RegExp(`^#?\\s*${key}\\s*=.*$`, "m");
-      if (regex.test(content)) {
-        return content.replace(regex, `${key}="${value}"`);
-      }
-      return `${content.trim()}\n${key}="${value}"\n`;
-    };
-
-    if (envContent) {
-      envContent = updateEnvKey(envContent, "DATABASE_URL", dbUrl);
-      envContent = updateEnvKey(envContent, "AUTH_SECRET", randomSecret);
-      envContent = updateEnvKey(envContent, "ADMIN_USER", adminUser);
-      envContent = updateEnvKey(envContent, "ADMIN_PASSWORD", adminPass);
-    } else {
-      envContent = `DATABASE_URL="${dbUrl}"
+  if (envContent) {
+    envContent = updateEnvKey(envContent, "DATABASE_URL", dbUrl);
+    envContent = updateEnvKey(envContent, "AUTH_SECRET", randomSecret);
+    envContent = updateEnvKey(envContent, "ADMIN_USER", adminUser);
+    envContent = updateEnvKey(envContent, "ADMIN_PASSWORD", adminPass);
+  } else {
+    envContent = `DATABASE_URL="${dbUrl}"
 AUTH_SECRET="${randomSecret}"
 ADMIN_USER="${adminUser}"
 ADMIN_PASSWORD="${adminPass}"
 AUTH_TRUST_HOST="true"
 `;
+  }
+
+  await writeFile(envPath, envContent, "utf8");
+  console.log("Successfully created/updated .env configuration file.");
+
+  const shouldPush =
+    options.dbPush ||
+    (options.yes && !options.skipDbPush);
+
+  if (shouldPush) {
+    console.log("\nRunning Prisma Database Push (npx prisma db push)...");
+    try {
+      execSync("npx prisma db push", { cwd: targetDir, stdio: "inherit" });
+      console.log("\nSuccessfully synchronized database schemas.");
+    } catch {
+      console.error(
+        "\nWarning: Database synchronization failed. Make sure your MySQL server is running and the database details are correct."
+      );
+      console.error("You can run this manually later inside the project folder via: npx prisma db push");
     }
+  } else if (options.yes && options.skipDbPush) {
+    console.log("\nSkipped database table synchronization (--skip-db-push).");
+  }
+}
+
+/**
+ * @param {string} targetDir
+ * @param {DbSetupOptions} options
+ */
+export async function promptAndSetupDb(targetDir, options = {}) {
+  if (options.yes) {
+    await setupDb(targetDir, options);
+    return;
+  }
 
-    await writeFile(envPath, envContent, "utf8");
-    console.log("Successfully created/updated .env configuration file.");
+  const envPath = join(targetDir, ".env");
+  const envExamplePath = join(targetDir, ".env.example");
+
+  let existingEnv = "";
+  if (existsSync(envPath)) {
+    try {
+      existingEnv = await readFile(envPath, "utf8");
+    } catch {
+      // Ignore
+    }
+  }
+
+  const getEnvVal = (key, fallback) => {
+    const match = existingEnv.match(new RegExp(`^${key}\\s*=\\s*["']?([^"'\r\n]+)["']?`, "m"));
+    return match ? match[1] : fallback;
+  };
+
+  const currentDbUrl = getEnvVal("DATABASE_URL", "");
+  let defaultHost = "localhost";
+  let defaultPort = "3306";
+  let defaultUser = "root";
+  let defaultPass = "";
+  let defaultDbName =
+    basename(resolve(targetDir)).toLowerCase().replace(/[^a-z0-9_]/g, "_") + "_db";
+
+  if (currentDbUrl) {
+    const urlMatch = currentDbUrl.match(
+      /mysql:\/\/([^:@]+)(?::([^@]+))?@([^:/]+)(?::(\d+))?\/([^?]+)/
+    );
+    if (urlMatch) {
+      defaultUser = urlMatch[1];
+      defaultPass = urlMatch[2] || "";
+      defaultHost = urlMatch[3];
+      defaultPort = urlMatch[4] || "3306";
+      defaultDbName = urlMatch[5];
+    }
+  }
+
+  const defaultAdminUser = getEnvVal("ADMIN_USER", "admin");
+  const defaultAdminPass = getEnvVal("ADMIN_PASSWORD", crypto.randomBytes(4).toString("hex"));
+
+  const rl = createInterface({ input, output });
+  try {
+    console.log("\n--- Configure Database & Environment Variables ---");
 
-    // Prompt to run prisma database push
-    const runMigrate = await rl.question("\nDo you want to initialize the database tables now using Prisma? (y/n) [y]: ");
+    const host =
+      (await rl.question(`MySQL Database Host [${defaultHost}]: `)).trim() || defaultHost;
+    const port =
+      (await rl.question(`MySQL Database Port [${defaultPort}]: `)).trim() || defaultPort;
+    const user =
+      (await rl.question(`MySQL Database Username [${defaultUser}]: `)).trim() || defaultUser;
+    const pass =
+      (await rl.question(`MySQL Database Password [${defaultPass ? "*****" : "(empty)"}]: `)).trim() ||
+      defaultPass;
+    const dbName =
+      (await rl.question(`MySQL Database Name [${defaultDbName}]: `)).trim() || defaultDbName;
+    const adminUser =
+      (await rl.question(`Admin Portal Username [${defaultAdminUser}]: `)).trim() ||
+      defaultAdminUser;
+    const adminPass =
+      (await rl.question(`Admin Portal Password [${defaultAdminPass}]: `)).trim() ||
+      defaultAdminPass;
+
+    await setupDb(targetDir, {
+      dbHost: host,
+      dbPort: port,
+      dbUser: user,
+      dbPassword: pass,
+      dbName,
+      adminUser,
+      adminPassword: adminPass,
+      skipDbPush: true,
+    });
+
+    const runMigrate = await rl.question(
+      "\nDo you want to initialize the database tables now using Prisma? (y/n) [y]: "
+    );
     const choice = runMigrate.trim().toLowerCase();
     if (choice === "" || choice === "y" || choice === "yes") {
       console.log("\nRunning Prisma Database Push (npx prisma db push)...");
       try {
         execSync("npx prisma db push", { cwd: targetDir, stdio: "inherit" });
         console.log("\nSuccessfully synchronized database schemas.");
-      } catch (err) {
-        console.error("\nWarning: Database synchronization failed. Make sure your MySQL server is running and the database details are correct.");
-        console.error("You can run this manually later inside the project folder via: npx prisma db push");
+      } catch {
+        console.error(
+          "\nWarning: Database synchronization failed. Make sure your MySQL server is running and the database details are correct."
+        );
+        console.error(
+          "You can run this manually later inside the project folder via: npx prisma db push"
+        );
       }
     } else {
-      console.log("\nSkipped database table synchronization. Remember to run 'npx prisma db push' before running the app.");
+      console.log(
+        "\nSkipped database table synchronization. Remember to run 'npx prisma db push' before running the app."
+      );
     }
   } finally {
     rl.close();