create-prisma-php-app 1.6.55 → 1.6.57

package/dist/index.js

@@ -438,7 +438,7 @@ const readJsonFile = (filePath) => {
     return JSON.parse(jsonData);
 };
 async function main() {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     try {
         const args = process.argv.slice(2);
         let projectName = args[0];
@@ -464,7 +464,7 @@ async function main() {
             (_a = localSettings.excludeFiles) === null || _a === void 0 ? void 0 : _a.map((file) => {
                 const filePath = path.join(currentDir, file);
                 if (fs.existsSync(filePath))
-                    excludeFiles.push(path.join(currentDir, file));
+                    excludeFiles.push(path.join(currentDir, file).replace(/\\/g, "/"));
             });
             updateAnswer = {
                 projectName,
@@ -622,6 +622,7 @@ async function main() {
             tailwindcss: answer.tailwindcss,
             websocket: answer.websocket,
             version,
+            excludeFiles: (_d = updateAnswer === null || updateAnswer === void 0 ? void 0 : updateAnswer.excludeFiles) !== null && _d !== void 0 ? _d : [],
         };
         fs.writeFileSync(path.join(projectPath, "prisma-php.json"), JSON.stringify(prismaPhpConfig, null, 2), { flag: "w" });
         console.log(`${chalk.green("Success!")} Prisma PHP project successfully created in ${answer.projectName}!`);

package/dist/prisma-php.js

@@ -1,96 +1,680 @@
 #!/usr/bin/env node
-import chalk from "chalk";
-import { spawn } from "child_process";
+import { execSync } from "child_process";
 import fs from "fs";
+import { fileURLToPath } from "url";
 import path from "path";
+import chalk from "chalk";
 import prompts from "prompts";
-import { fileURLToPath } from "url";
+import https from "https";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const args = process.argv.slice(2);
-const readJsonFile = (filePath) => {
-    const jsonData = fs.readFileSync(filePath, "utf8");
-    return JSON.parse(jsonData);
-};
-const executeCommand = (command, args = [], options = {}) => {
-    return new Promise((resolve, reject) => {
-        const process = spawn(command, args, Object.assign({ stdio: "inherit", shell: true }, options));
-        process.on("error", (error) => {
-            console.error(`Execution error: ${error.message}`);
-            reject(error);
-        });
-        process.on("close", (code) => {
-            if (code === 0) {
-                resolve();
-            }
-            else {
-                reject(new Error(`Process exited with code ${code}`));
-            }
+let updateAnswer = null;
+function configureBrowserSyncCommand(baseDir, projectSettings) {
+    // Identify the base path dynamically up to and including 'htdocs'
+    const htdocsIndex = projectSettings.PROJECT_ROOT_PATH.indexOf("\\htdocs\\");
+    if (htdocsIndex === -1) {
+        console.error("Invalid PROJECT_ROOT_PATH. The path does not contain \\htdocs\\");
+        return ""; // Return an empty string or handle the error as appropriate
+    }
+    // Extract the path up to and including 'htdocs\\'
+    const basePathToRemove = projectSettings.PROJECT_ROOT_PATH.substring(0, htdocsIndex + "\\htdocs\\".length);
+    // Escape backslashes for the regex pattern
+    const escapedBasePathToRemove = basePathToRemove.replace(/\\/g, "\\\\");
+    // Remove the base path and replace backslashes with forward slashes for URL compatibility
+    const relativeWebPath = projectSettings.PROJECT_ROOT_PATH.replace(new RegExp(`^${escapedBasePathToRemove}`), "").replace(/\\/g, "/");
+    // Construct the Browser Sync command with the correct proxy URL, being careful not to affect the protocol part
+    let proxyUrl = `http://localhost/${relativeWebPath}`;
+    // Ensure the proxy URL does not end with a slash before appending '/public'
+    proxyUrl = proxyUrl.endsWith("/") ? proxyUrl.slice(0, -1) : proxyUrl;
+    // Clean the URL by replacing "//" with "/" but not affecting "http://"
+    // We replace instances of "//" that are not preceded by ":"
+    const cleanUrl = proxyUrl.replace(/(?<!:)(\/\/+)/g, "/");
+    const cleanRelativeWebPath = relativeWebPath.replace(/\/\/+/g, "/");
+    // Correct the relativeWebPath to ensure it does not start with a "/"
+    const adjustedRelativeWebPath = cleanRelativeWebPath.startsWith("/")
+        ? cleanRelativeWebPath.substring(1)
+        : cleanRelativeWebPath;
+    // TypeScript content to write
+    const bsConfigTsContent = `
+  const { createProxyMiddleware } = require("http-proxy-middleware");
+
+  module.exports = {
+    // First middleware: Set Cache-Control headers
+    function (req, res, next) {
+      res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
+      res.setHeader("Pragma", "no-cache");
+      res.setHeader("Expires", "0");
+      next();
+    },
+    // Use the 'middleware' option to create a proxy that masks the deep URL.
+    middleware: [
+      // This middleware intercepts requests to the root and proxies them to the deep path.
+      createProxyMiddleware("/", {
+        target:
+          "${cleanUrl}",
+        changeOrigin: true,
+        pathRewrite: {
+          "^/": "/${adjustedRelativeWebPath}", // Rewrite the path.
+        },
+      }),
+    ],
+    proxy: "http://localhost:3000", // Proxy the BrowserSync server.
+    // serveStatic: ["src/app"], // Serve static files from this directory.
+    files: "src/**/*.*",
+    notify: false,
+    open: false,
+    ghostMode: false,
+  };`;
+    // Determine the path and write the bs-config.js
+    const bsConfigPath = path.join(baseDir, "settings", "bs-config.cjs");
+    fs.writeFileSync(bsConfigPath, bsConfigTsContent, "utf8");
+    // Return the Browser Sync command string, using the cleaned URL
+    return `browser-sync start --config settings/bs-config.cjs`;
+}
+async function updatePackageJson(baseDir, projectSettings, answer) {
+    var _a;
+    const packageJsonPath = path.join(baseDir, "package.json");
+    if ((_a = updateAnswer === null || updateAnswer === void 0 ? void 0 : updateAnswer.excludeFiles) === null || _a === void 0 ? void 0 : _a.includes(packageJsonPath.replace(/\\/g, "/"))) {
+        console.log(`Skipping file: ${packageJsonPath}`);
+        return;
+    }
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    // Use the new function to configure the Browser Sync command
+    const browserSyncCommand = configureBrowserSyncCommand(baseDir, projectSettings);
+    packageJson.scripts = Object.assign(Object.assign({}, packageJson.scripts), { postinstall: "prisma generate" });
+    let answersToInclude = [];
+    if (answer.tailwindcss) {
+        packageJson.scripts = Object.assign(Object.assign({}, packageJson.scripts), { tailwind: "postcss ./src/app/css/tailwind.css -o ./src/app/css/styles.css --watch" });
+        answersToInclude.push("tailwind");
+    }
+    if (answer.websocket) {
+        packageJson.scripts = Object.assign(Object.assign({}, packageJson.scripts), { websocket: "node ./settings/restartWebsocket.cjs" });
+        answersToInclude.push("websocket");
+    }
+    // Initialize with existing scripts
+    const updatedScripts = Object.assign({}, packageJson.scripts);
+    // Conditionally add "browser-sync" command
+    if (answersToInclude.length > 0) {
+        updatedScripts["browser-sync"] = browserSyncCommand;
+    }
+    // Conditionally set the "dev" command
+    updatedScripts.dev =
+        answersToInclude.length > 0
+            ? `npm-run-all --parallel browser-sync ${answersToInclude.join(" ")}`
+            : browserSyncCommand;
+    // Finally, assign the updated scripts back to packageJson
+    packageJson.scripts = updatedScripts;
+    packageJson.type = "module";
+    packageJson.prisma = {
+        seed: "node prisma/seed.js",
+    };
+    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+}
+async function updateComposerJson(baseDir, answer) {
+    var _a;
+    if (!answer.websocket)
+        return;
+    const composerJsonPath = path.join(baseDir, "composer.json");
+    if ((_a = updateAnswer === null || updateAnswer === void 0 ? void 0 : updateAnswer.excludeFiles) === null || _a === void 0 ? void 0 : _a.includes(composerJsonPath.replace(/\\/g, "/"))) {
+        console.log(`Skipping file: ${composerJsonPath}`);
+        return;
+    }
+    let composerJson;
+    // Check if the composer.json file exists
+    if (fs.existsSync(composerJsonPath)) {
+        // Read the current composer.json content
+        const composerJsonContent = fs.readFileSync(composerJsonPath, "utf8");
+        composerJson = JSON.parse(composerJsonContent);
+    }
+    else {
+        console.error("composer.json does not exist.");
+        return;
+    }
+    // Conditionally add WebSocket dependency
+    if (answer.websocket) {
+        composerJson.require = Object.assign(Object.assign({}, composerJson.require), { "cboden/ratchet": "^0.4.4" });
+    }
+    // Write the modified composer.json back to the file
+    fs.writeFileSync(composerJsonPath, JSON.stringify(composerJson, null, 2));
+    console.log("composer.json updated successfully.");
+}
+async function updateIndexJsForWebSocket(baseDir, answer) {
+    var _a;
+    if (!answer.websocket) {
+        return;
+    }
+    const indexPath = path.join(baseDir, "src", "app", "js", "index.js");
+    if ((_a = updateAnswer === null || updateAnswer === void 0 ? void 0 : updateAnswer.excludeFiles) === null || _a === void 0 ? void 0 : _a.includes(indexPath.replace(/\\/g, "/"))) {
+        console.log(`Skipping file: ${indexPath}`);
+        return;
+    }
+    let indexContent = fs.readFileSync(indexPath, "utf8");
+    // WebSocket initialization code to be appended
+    const webSocketCode = `
+// WebSocket initialization
+const ws = new WebSocket("ws://localhost:8080");
+`;
+    // Append WebSocket code if user chose to use WebSocket
+    indexContent += webSocketCode;
+    fs.writeFileSync(indexPath, indexContent, "utf8");
+    console.log("WebSocket code added to index.js successfully.");
+}
+// This function updates the .gitignore file
+async function createUpdateGitignoreFile(baseDir, additions) {
+    var _a;
+    const gitignorePath = path.join(baseDir, ".gitignore");
+    if ((_a = updateAnswer === null || updateAnswer === void 0 ? void 0 : updateAnswer.excludeFiles) === null || _a === void 0 ? void 0 : _a.includes(gitignorePath.replace(/\\/g, "/"))) {
+        console.log(`Skipping file: ${gitignorePath}`);
+        return;
+    }
+    // Check if the .gitignore file exists, create if it doesn't
+    let gitignoreContent = "";
+    if (fs.existsSync(gitignorePath)) {
+        gitignoreContent = fs.readFileSync(gitignorePath, "utf8");
+    }
+    additions.forEach((addition) => {
+        if (!gitignoreContent.includes(addition)) {
+            gitignoreContent += `\n${addition}`;
+        }
+    });
+    // Ensure there's no leading newline if the file was just created
+    gitignoreContent = gitignoreContent.trimStart();
+    fs.writeFileSync(gitignorePath, gitignoreContent);
+}
+// Recursive copy function
+function copyRecursiveSync(src, dest) {
+    var _a;
+    console.log("🚀 ~ copyRecursiveSync ~ dest:", dest);
+    console.log("🚀 ~ copyRecursiveSync ~ src:", src);
+    const exists = fs.existsSync(src);
+    const stats = exists && fs.statSync(src);
+    const isDirectory = exists && stats && stats.isDirectory();
+    if (isDirectory) {
+        fs.mkdirSync(dest, { recursive: true });
+        fs.readdirSync(src).forEach((childItemName) => {
+            copyRecursiveSync(path.join(src, childItemName), path.join(dest, childItemName));
         });
+    }
+    else {
+        if ((_a = updateAnswer === null || updateAnswer === void 0 ? void 0 : updateAnswer.excludeFiles) === null || _a === void 0 ? void 0 : _a.includes(dest.replace(/\\/g, "/"))) {
+            console.log(`Skipping file: ${src}`);
+            return;
+        }
+        fs.copyFileSync(src, dest, 0);
+    }
+}
+// Function to execute the recursive copy for entire directories
+async function executeCopy(baseDir, directoriesToCopy) {
+    directoriesToCopy.forEach(({ srcDir, destDir }) => {
+        const sourcePath = path.join(__dirname, srcDir);
+        const destPath = path.join(baseDir, destDir);
+        copyRecursiveSync(sourcePath, destPath);
     });
-};
-async function getAnswer() {
-    const questions = [
+}
+function createOrUpdateTailwindConfig(baseDir) {
+    var _a;
+    console.log("🚀 ~ createOrUpdateTailwindConfig ~ baseDir:", baseDir);
+    const filePath = path.join(baseDir, "tailwind.config.js");
+    if ((_a = updateAnswer === null || updateAnswer === void 0 ? void 0 : updateAnswer.excludeFiles) === null || _a === void 0 ? void 0 : _a.includes(filePath.replace(/\\/g, "/"))) {
+        console.log(`Skipping file: ${filePath}`);
+        return;
+    }
+    const newContent = [
+        "./src/app/**/*.{html,js,php}",
+        // Add more paths as needed
+    ];
+    let configData = fs.readFileSync(filePath, "utf8");
+    console.log("🚀 ~ createOrUpdateTailwindConfig ~ configData:", configData);
+    const contentArrayString = newContent
+        .map((item) => `    "${item}"`)
+        .join(",\n");
+    configData = configData.replace(/content: \[\],/g, `content: [\n${contentArrayString}\n],`);
+    fs.writeFileSync(filePath, configData, { flag: "w" });
+    console.log(chalk.green("Tailwind configuration updated successfully."));
+}
+function modifyPostcssConfig(baseDir) {
+    var _a;
+    const filePath = path.join(baseDir, "postcss.config.js");
+    if ((_a = updateAnswer === null || updateAnswer === void 0 ? void 0 : updateAnswer.excludeFiles) === null || _a === void 0 ? void 0 : _a.includes(filePath.replace(/\\/g, "/"))) {
+        console.log(`Skipping file: ${filePath}`);
+        return;
+    }
+    const newContent = `export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+    cssnano: {},
+  },
+};`;
+    fs.writeFileSync(filePath, newContent, { flag: "w" });
+    console.log(chalk.green("postcss.config.js updated successfully."));
+}
+function modifyLayoutPHP(baseDir, useTailwind) {
+    var _a;
+    const layoutPath = path.join(baseDir, "src", "app", "layout.php");
+    if ((_a = updateAnswer === null || updateAnswer === void 0 ? void 0 : updateAnswer.excludeFiles) === null || _a === void 0 ? void 0 : _a.includes(layoutPath.replace(/\\/g, "/"))) {
+        console.log(`Skipping file: ${layoutPath}`);
+        return;
+    }
+    try {
+        let indexContent = fs.readFileSync(layoutPath, "utf8");
+        const stylesAndLinks = `\n    <link href="<?php echo $baseUrl; ?>css/index.css" rel="stylesheet">\n    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600;800&display=swap" rel="stylesheet">\n    <script src="<?php echo $baseUrl; ?>js/index.js"></script>`;
+        // Tailwind CSS link or CDN script
+        const tailwindLink = useTailwind
+            ? `    <link href="<?php echo $baseUrl; ?>css/styles.css" rel="stylesheet"> ${stylesAndLinks}`
+            : `    <script src="https://cdn.tailwindcss.com"></script> ${stylesAndLinks}`;
+        // Insert before the closing </head> tag
+        indexContent = indexContent.replace("</head>", `${tailwindLink}\n</head>`);
+        fs.writeFileSync(layoutPath, indexContent, { flag: "w" });
+        console.log(chalk.green(`index.php modified successfully for ${useTailwind ? "local Tailwind CSS" : "Tailwind CSS CDN"}.`));
+    }
+    catch (error) {
+        console.error(chalk.red("Error modifying index.php:"), error);
+    }
+}
+// This function updates or creates the .env file
+async function createOrUpdateEnvFile(baseDir, content) {
+    var _a;
+    const envPath = path.join(baseDir, ".env");
+    if ((_a = updateAnswer === null || updateAnswer === void 0 ? void 0 : updateAnswer.excludeFiles) === null || _a === void 0 ? void 0 : _a.includes(envPath.replace(/\\/g, "/"))) {
+        console.log(`Skipping file: ${envPath}`);
+        return;
+    }
+    let envContent = fs.existsSync(envPath)
+        ? fs.readFileSync(envPath, "utf8")
+        : "";
+    // Check if the content already exists in the .env file
+    if (!envContent.includes(content)) {
+        envContent += `${envContent !== "" ? "\n\n" : ""}${content}`;
+        fs.writeFileSync(envPath, envContent, { flag: "w" });
+    }
+}
+async function createDirectoryStructure(baseDir, answer, projectSettings) {
+    console.log("🚀 ~ baseDir:", baseDir);
+    console.log("🚀 ~ answer:", answer);
+    console.log("🚀 ~ projectSettings:", projectSettings);
+    const filesToCopy = [
+        { src: "/bootstrap.php", dest: "/bootstrap.php" },
+        { src: "/.htaccess", dest: "/.htaccess" },
+        { src: "/../composer.json", dest: "/composer.json" },
+    ];
+    if (updateAnswer === null || updateAnswer === void 0 ? void 0 : updateAnswer.isUpdate) {
+        filesToCopy.push({ src: "/.env", dest: "/.env" }, { src: "/tsconfig.json", dest: "/tsconfig.json" });
+        if (updateAnswer.tailwindcss) {
+            filesToCopy.push({ src: "/postcss.config.js", dest: "/postcss.config.js" }, { src: "/tailwind.config.js", dest: "/tailwind.config.js" });
+        }
+    }
+    // if (answer.websocket) {
+    //   filesToCopy.push({
+    //     src: "/../composer-websocket.lock",
+    //     dest: "/composer.lock",
+    //   });
+    // } else {
+    //   filesToCopy.push({ src: "/../composer.lock", dest: "/composer.lock" });
+    // }
+    const directoriesToCopy = [
+        {
+            srcDir: "/settings",
+            destDir: "/settings",
+        },
+        {
+            srcDir: "/prisma",
+            destDir: "/prisma",
+        },
         {
+            srcDir: "/src",
+            destDir: "/src",
+        },
+        {
+            srcDir: "/../vendor",
+            destDir: "/vendor",
+        },
+    ];
+    console.log("🚀 ~ directoriesToCopy:", directoriesToCopy);
+    filesToCopy.forEach(({ src, dest }) => {
+        var _a;
+        const sourcePath = path.join(__dirname, src);
+        const destPath = path.join(baseDir, dest);
+        if ((_a = updateAnswer === null || updateAnswer === void 0 ? void 0 : updateAnswer.excludeFiles) === null || _a === void 0 ? void 0 : _a.includes(destPath.replace(/\\/g, "/"))) {
+            console.log(`Skipping file: ${src}`);
+            return;
+        }
+        const code = fs.readFileSync(sourcePath, "utf8");
+        fs.writeFileSync(destPath, code, { flag: "w" });
+    });
+    await executeCopy(baseDir, directoriesToCopy);
+    await updatePackageJson(baseDir, projectSettings, answer);
+    await updateComposerJson(baseDir, answer);
+    await updateIndexJsForWebSocket(baseDir, answer);
+    if (answer.tailwindcss) {
+        createOrUpdateTailwindConfig(baseDir);
+        modifyLayoutPHP(baseDir, true);
+        modifyPostcssConfig(baseDir);
+    }
+    else {
+        modifyLayoutPHP(baseDir, false);
+    }
+    const envContent = `# PHPMailer
+SMTP_HOST=
+SMTP_USERNAME=
+SMTP_PASSWORD=
+SMTP_PORT=
+SMTP_ENCRYPTION=ssl
+MAIL_FROM=
+MAIL_FROM_NAME=""`;
+    await createOrUpdateEnvFile(baseDir, envContent);
+    // Add vendor to .gitignore
+    await createUpdateGitignoreFile(baseDir, ["vendor"]);
+}
+async function getAnswer(predefinedAnswers = {}) {
+    var _a, _b, _c;
+    console.log("🚀 ~ predefinedAnswers:", predefinedAnswers);
+    const questionsArray = [];
+    if (!predefinedAnswers.projectName) {
+        questionsArray.push({
+            type: "text",
+            name: "projectName",
+            message: "What is your project named?",
+            initial: "my-app",
+        });
+    }
+    if (!predefinedAnswers.tailwindcss) {
+        questionsArray.push({
             type: "toggle",
-            name: "shouldProceed",
-            message: `This command will update the ${chalk.blue("create-prisma-php-app")} package and overwrite all default files. ${chalk.blue("Do you want to proceed")}?`,
-            initial: false,
+            name: "tailwindcss",
+            message: `Would you like to use ${chalk.blue("Tailwind CSS")}?`,
+            initial: true,
             active: "Yes",
             inactive: "No",
-        },
-    ];
+        });
+    }
+    if (!predefinedAnswers.websocket) {
+        questionsArray.push({
+            type: "toggle",
+            name: "websocket",
+            message: `Would you like to use ${chalk.blue("Websocket")}?`,
+            initial: true,
+            active: "Yes",
+            inactive: "No",
+        });
+    }
+    const questions = questionsArray;
+    console.log("🚀 ~ questions:", questions);
     const onCancel = () => {
         console.log(chalk.red("Operation cancelled by the user."));
         process.exit(0);
     };
-    const response = await prompts(questions, { onCancel });
-    if (Object.keys(response).length === 0) {
+    try {
+        const response = await prompts(questions, { onCancel });
+        console.log("🚀 ~ response:", response);
+        if (Object.keys(response).length === 0) {
+            return null;
+        }
+        return {
+            projectName: response.projectName
+                ? String(response.projectName).trim().replace(/ /g, "-")
+                : (_a = predefinedAnswers.projectName) !== null && _a !== void 0 ? _a : "my-app",
+            tailwindcss: (_b = response.tailwindcss) !== null && _b !== void 0 ? _b : predefinedAnswers.tailwindcss,
+            websocket: (_c = response.websocket) !== null && _c !== void 0 ? _c : predefinedAnswers.websocket,
+        };
+    }
+    catch (error) {
+        console.error(chalk.red("Prompt error:"), error);
         return null;
     }
-    return response;
 }
-const main = async () => {
-    if (args.length > 0 && args[0] === "update") {
-        try {
-            const answer = await getAnswer();
-            if (!(answer === null || answer === void 0 ? void 0 : answer.shouldProceed)) {
-                console.log(chalk.red("Operation cancelled by the user."));
-                return;
-            }
+/**
+ * Install dependencies in the specified directory.
+ * @param {string} baseDir - The base directory where to install the dependencies.
+ * @param {string[]} dependencies - The list of dependencies to install.
+ * @param {boolean} [isDev=false] - Whether to install the dependencies as devDependencies.
+ */
+async function installDependencies(baseDir, dependencies, isDev = false) {
+    console.log("Initializing new Node.js project...");
+    // Initialize a package.json if it doesn't exist
+    if (!fs.existsSync(path.join(baseDir, "package.json")))
+        execSync("npm init -y", {
+            stdio: "inherit",
+            cwd: baseDir,
+        });
+    // Log the dependencies being installed
+    console.log(`${isDev ? "Installing development dependencies" : "Installing dependencies"}:`);
+    dependencies.forEach((dep) => console.log(`- ${chalk.blue(dep)}`));
+    // Prepare the npm install command with the appropriate flag for dev dependencies
+    const npmInstallCommand = `npm install ${isDev ? "--save-dev" : ""} ${dependencies.join(" ")}`;
+    // Execute the npm install command
+    execSync(npmInstallCommand, {
+        stdio: "inherit",
+        cwd: baseDir,
+    });
+}
+async function uninstallDependencies(baseDir, dependencies, isDev = false) {
+    console.log("Uninstalling dependencies:");
+    dependencies.forEach((dep) => console.log(`- ${chalk.blue(dep)}`));
+    // Prepare the npm uninstall command with the appropriate flag for dev dependencies
+    const npmUninstallCommand = `npm uninstall ${isDev ? "--save-dev" : "--save"} ${dependencies.join(" ")}`;
+    // Execute the npm uninstall command
+    execSync(npmUninstallCommand, {
+        stdio: "inherit",
+        cwd: baseDir,
+    });
+}
+function fetchPackageVersion(packageName) {
+    return new Promise((resolve, reject) => {
+        https
+            .get(`https://registry.npmjs.org/${packageName}`, (res) => {
+            let data = "";
+            res.on("data", (chunk) => (data += chunk));
+            res.on("end", () => {
+                try {
+                    const parsed = JSON.parse(data);
+                    resolve(parsed["dist-tags"].latest);
+                }
+                catch (error) {
+                    reject(new Error("Failed to parse JSON response"));
+                }
+            });
+        })
+            .on("error", (err) => reject(err));
+    });
+}
+const readJsonFile = (filePath) => {
+    const jsonData = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(jsonData);
+};
+async function main() {
+    var _a, _b, _c, _d;
+    try {
+        const args = process.argv.slice(2);
+        let projectName = args[0];
+        console.log("🚀 ~ main ~ projectName:", projectName);
+        let answer = null;
+        if (projectName) {
+            let useTailwind = args.includes("--tailwindcss");
+            let useWebsocket = args.includes("--websocket");
             const currentDir = process.cwd();
             const configPath = path.join(currentDir, "prisma-php.json");
-            if (!fs.existsSync(configPath)) {
-                console.error(chalk.red("The configuration file 'prisma-php.json' was not found in the current directory."));
+            const localSettings = readJsonFile(configPath);
+            const predefinedAnswers = {
+                projectName,
+                tailwindcss: useTailwind,
+                websocket: useWebsocket,
+            };
+            answer = await getAnswer(predefinedAnswers);
+            if (answer === null) {
+                console.log(chalk.red("Installation cancelled."));
                 return;
             }
-            const localSettings = readJsonFile(configPath);
-            const commandArgs = [localSettings.projectName];
-            if (localSettings.tailwindcss)
-                commandArgs.push("--tailwindcss");
-            if (localSettings.websocket)
-                commandArgs.push("--websocket");
-            console.log("Executing command...\n");
-            await executeCommand("npx", [
-                "create-prisma-php-app@alpha-update-command",
-                ...commandArgs,
-            ]);
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                if (error.message.includes("no such file or directory")) {
-                    console.error(chalk.red("The configuration file 'prisma-php.json' was not found in the current directory."));
+            let excludeFiles = [];
+            (_a = localSettings.excludeFiles) === null || _a === void 0 ? void 0 : _a.map((file) => {
+                const filePath = path.join(currentDir, file);
+                if (fs.existsSync(filePath))
+                    excludeFiles.push(path.join(currentDir, file).replace(/\\/g, "/"));
+            });
+            updateAnswer = {
+                projectName,
+                tailwindcss: (_b = answer === null || answer === void 0 ? void 0 : answer.tailwindcss) !== null && _b !== void 0 ? _b : false,
+                websocket: (_c = answer === null || answer === void 0 ? void 0 : answer.websocket) !== null && _c !== void 0 ? _c : false,
+                isUpdate: true,
+                excludeFiles: excludeFiles.length > 0 ? excludeFiles : [],
+            };
+            console.log("🚀 ~ main ~ answer:", answer);
+        }
+        else {
+            answer = await getAnswer();
+        }
+        if (answer === null) {
+            console.log(chalk.red("Installation cancelled."));
+            return;
+        }
+        // execSync(`npm install -g create-prisma-php-app`, { stdio: "inherit" }); // TODO: Uncomment this line before publishing the package
+        execSync(`npm install -g create-prisma-php-app@alpha-update-command`, {
+            stdio: "inherit",
+        }); // TODO: Uncomment this line before publishing the package
+        // Support for browser-sync
+        execSync(`npm install -g browser-sync`, { stdio: "inherit" });
+        // Create the project directory
+        if (!projectName)
+            fs.mkdirSync(answer.projectName);
+        const currentDir = process.cwd();
+        console.log("🚀 ~ main ~ currentDir:", currentDir);
+        let projectPath = projectName
+            ? currentDir
+            : path.join(currentDir, answer.projectName);
+        console.log("🚀 ~ main ~ projectPath:", projectPath);
+        if (!projectName)
+            process.chdir(answer.projectName);
+        const dependencies = [
+            "prisma",
+            "@prisma/client",
+            "typescript",
+            "@types/node",
+            "ts-node",
+            "http-proxy-middleware",
+        ];
+        if (answer.tailwindcss) {
+            dependencies.push("tailwindcss", "autoprefixer", "postcss", "postcss-cli", "cssnano");
+        }
+        if (answer.websocket) {
+            dependencies.push("chokidar-cli");
+        }
+        if (answer.tailwindcss || answer.websocket) {
+            dependencies.push("npm-run-all");
+        }
+        await installDependencies(projectPath, dependencies, true);
+        if (!projectName) {
+            execSync(`npx prisma init`, { stdio: "inherit" });
+            execSync(`npx tsc --init`, { stdio: "inherit" });
+        }
+        if (answer.tailwindcss) {
+            execSync(`npx tailwindcss init -p`, { stdio: "inherit" });
+        }
+        const projectSettings = {
+            PROJECT_NAME: answer.projectName,
+            PROJECT_ROOT_PATH: projectPath.replace(/\\/g, "\\\\"),
+            PHP_ROOT_PATH_EXE: "D:\\\\xampp\\\\php\\\\php.exe",
+            PHP_GENERATE_CLASS_PATH: "src/lib/prisma/classes",
+        };
+        await createDirectoryStructure(projectPath, answer, projectSettings);
+        // if (answer.tailwindcss) {
+        //   execSync(
+        //     `npx tailwindcss -i ./src/app/css/tailwind.css -o ./src/app/css/styles.css --minify`,
+        //     { stdio: "inherit" }
+        //   );
+        // }
+        // execSync(`composer install`, { stdio: "inherit" });
+        // execSync(`composer dump-autoload`, { stdio: "inherit" });
+        // Create settings file
+        const settingsPath = path.join(projectPath, "settings", "project-settings.js");
+        const settingsCode = `export const projectSettings = {
+      PROJECT_NAME: "${answer.projectName}",
+      PROJECT_ROOT_PATH: "${projectPath.replace(/\\/g, "\\\\")}",
+      PHP_ROOT_PATH_EXE: "D:\\\\xampp\\\\php\\\\php.exe",
+      PHP_GENERATE_CLASS_PATH: "src/lib/prisma/classes",
+    };`;
+        fs.writeFileSync(settingsPath, settingsCode, { flag: "w" });
+        const publicDirPath = path.join(projectPath, "public");
+        if (!fs.existsSync(publicDirPath)) {
+            fs.mkdirSync(publicDirPath);
+        }
+        if (!answer.tailwindcss) {
+            const cssPath = path.join(projectPath, "src", "app", "css");
+            const tailwindFiles = ["tailwind.css", "styles.css"];
+            tailwindFiles.forEach((file) => {
+                const filePath = path.join(cssPath, file);
+                if (fs.existsSync(filePath)) {
+                    fs.unlinkSync(filePath); // Delete each file if it exists
+                    console.log(`${file} was deleted successfully.`);
                 }
+                else {
+                    console.log(`${file} does not exist.`);
+                }
+            });
+        }
+        // Update websocket if not chosen by the user
+        if (!answer.websocket) {
+            const wsPath = path.join(projectPath, "src", "lib", "websocket");
+            // Check if the websocket directory exists
+            if (fs.existsSync(wsPath)) {
+                // Use fs.rmSync with recursive option set to true to delete the directory and its contents
+                fs.rmSync(wsPath, { recursive: true, force: true }); // force option is not necessary but can be used to ensure deletion
+                console.log("Websocket directory was deleted successfully.");
             }
             else {
-                console.error("Error in script execution:", error);
+                console.log("Websocket directory does not exist.");
             }
+            // Update settings directory if websocket is not chosen
+            const settingsPath = path.join(projectPath, "settings");
+            const websocketFiles = ["restartWebsocket.cjs", "restart_websocket.bat"];
+            websocketFiles.forEach((file) => {
+                const filePath = path.join(settingsPath, file);
+                if (fs.existsSync(filePath)) {
+                    fs.unlinkSync(filePath); // Delete each file if it exists
+                    console.log(`${file} was deleted successfully.`);
+                }
+                else {
+                    console.log(`${file} does not exist.`);
+                }
+            });
         }
+        if (updateAnswer === null || updateAnswer === void 0 ? void 0 : updateAnswer.isUpdate) {
+            console.log("🚀 ~ main ~ updateAnswer:", updateAnswer);
+            const updateUninstallDependencies = [];
+            if (!updateAnswer.tailwindcss) {
+                const tailwindFiles = ["postcss.config.js", "tailwind.config.js"];
+                tailwindFiles.forEach((file) => {
+                    const filePath = path.join(projectPath, file);
+                    if (fs.existsSync(filePath)) {
+                        fs.unlinkSync(filePath); // Delete each file if it exists
+                        console.log(`${file} was deleted successfully.`);
+                    }
+                    else {
+                        console.log(`${file} does not exist.`);
+                    }
+                });
+                updateUninstallDependencies.push("tailwindcss", "autoprefixer", "postcss", "postcss-cli", "cssnano");
+            }
+            if (!updateAnswer.websocket) {
+                updateUninstallDependencies.push("chokidar-cli");
+            }
+            if (updateUninstallDependencies.length > 0) {
+                await uninstallDependencies(projectPath, updateUninstallDependencies, true);
+            }
+        }
+        const version = await fetchPackageVersion("create-prisma-php-app");
+        const prismaPhpConfig = {
+            projectName: answer.projectName,
+            tailwindcss: answer.tailwindcss,
+            websocket: answer.websocket,
+            version,
+            excludeFiles: (_d = updateAnswer === null || updateAnswer === void 0 ? void 0 : updateAnswer.excludeFiles) !== null && _d !== void 0 ? _d : [],
+        };
+        fs.writeFileSync(path.join(projectPath, "prisma-php.json"), JSON.stringify(prismaPhpConfig, null, 2), { flag: "w" });
+        console.log(`${chalk.green("Success!")} Prisma PHP project successfully created in ${answer.projectName}!`);
     }
-    else {
-        console.log("Command not recognized.");
+    catch (error) {
+        console.error("Error while creating the project:", error);
+        process.exit(1);
     }
-};
-main().catch((error) => {
-    console.error("Unhandled error in main function:", error);
-});
+}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-prisma-php-app",
-  "version": "1.6.55",
+  "version": "1.6.57",
   "description": "Prisma-PHP: A Revolutionary Library Bridging PHP with Prisma ORM",
   "main": "dist/index.js",
   "type": "module",