create-prisma-php-app 4.0.0-alpha.47 → 4.0.0-alpha.48

package/dist/index.js

@@ -1023,116 +1023,6 @@ function composerPkg(name) {
     ? `${name}:${composerPinnedVersions[name]}`
     : name;
 }
-async function downloadStarterKit(starterKit, tempDir) {
-  if (!starterKit.source) {
-    throw new Error("No source defined for starter kit");
-  }
-  const { type, url, branch = "main", subfolder } = starterKit.source;
-  switch (type) {
-    case "git":
-      console.log(chalk.blue(`Cloning ${starterKit.name} from ${url}...`));
-      const cloneCommand = branch
-        ? `git clone -b ${branch} --depth 1 ${url} ${tempDir}`
-        : `git clone --depth 1 ${url} ${tempDir}`;
-      execSync(cloneCommand, { stdio: "inherit" });
-      // Remove .git directory
-      const gitDir = path.join(tempDir, ".git");
-      if (fs.existsSync(gitDir)) {
-        fs.rmSync(gitDir, { recursive: true, force: true });
-      }
-      // Return the subfolder if specified
-      return subfolder ? path.join(tempDir, subfolder) : tempDir;
-    case "npm":
-      console.log(chalk.blue(`Downloading ${starterKit.name} from npm...`));
-      execSync(`npm pack ${url}`, { cwd: tempDir, stdio: "inherit" });
-      // Extract the tarball
-      const tarball = fs.readdirSync(tempDir).find((f) => f.endsWith(".tgz"));
-      if (tarball) {
-        execSync(`tar -xzf ${tarball}`, { cwd: tempDir });
-        fs.unlinkSync(path.join(tempDir, tarball));
-        return path.join(tempDir, "package");
-      }
-      throw new Error("Failed to extract npm package");
-    case "url":
-      throw new Error("URL download not implemented yet");
-    default:
-      throw new Error(`Unsupported source type: ${type}`);
-  }
-}
-async function mergeStarterKitFiles(starterKitPath, projectPath, answer) {
-  console.log(chalk.blue("Merging starter kit files..."));
-  // First, check if starter kit has a prisma-php.json to preserve excludeFiles
-  const starterKitConfigPath = path.join(starterKitPath, "prisma-php.json");
-  let starterKitExcludeFiles = [];
-  if (fs.existsSync(starterKitConfigPath)) {
-    try {
-      const starterKitConfig = JSON.parse(
-        fs.readFileSync(starterKitConfigPath, "utf8")
-      );
-      starterKitExcludeFiles = starterKitConfig.excludeFiles || [];
-      console.log(
-        chalk.blue(
-          `Found ${starterKitExcludeFiles.length} excluded files in starter kit`
-        )
-      );
-    } catch (error) {
-      console.warn(chalk.yellow("Failed to parse starter kit prisma-php.json"));
-    }
-  }
-  // Temporarily store excludeFiles for the copy process
-  const tempUpdateAnswer = updateAnswer;
-  updateAnswer = {
-    ...answer,
-    isUpdate: false, // Treat as new project for copying
-    excludeFiles: starterKitExcludeFiles,
-    excludeFilePath: starterKitExcludeFiles.map((file) =>
-      path.join(projectPath, file).replace(/\\/g, "/")
-    ),
-  };
-  // Copy all files from starter kit
-  copyRecursiveSync(starterKitPath, projectPath, answer);
-  // Restore original updateAnswer
-  updateAnswer = tempUpdateAnswer;
-  // Handle starter kit specific configuration
-  const starterKitConfig = path.join(starterKitPath, "starter-kit.json");
-  if (fs.existsSync(starterKitConfig)) {
-    const config = JSON.parse(fs.readFileSync(starterKitConfig, "utf8"));
-    // Handle post-install scripts
-    if (config.postInstall) {
-      console.log(chalk.blue("Running post-install scripts..."));
-      for (const script of config.postInstall) {
-        console.log(chalk.gray(`Running: ${script}`));
-        execSync(script, { cwd: projectPath, stdio: "inherit" });
-      }
-    }
-    // Handle additional dependencies
-    if (config.additionalNpmDependencies) {
-      await installNpmDependencies(
-        projectPath,
-        config.additionalNpmDependencies.map(npmPkg),
-        true
-      );
-    }
-    if (config.additionalComposerDependencies) {
-      await installComposerDependencies(
-        projectPath,
-        config.additionalComposerDependencies.map(composerPkg)
-      );
-    }
-  }
-  // Store the excludeFiles for later use in main()
-  if (starterKitExcludeFiles.length > 0) {
-    // Create a temporary marker file to pass excludeFiles to main()
-    const tempConfigPath = path.join(
-      projectPath,
-      ".temp-starter-kit-config.json"
-    );
-    fs.writeFileSync(
-      tempConfigPath,
-      JSON.stringify({ excludeFiles: starterKitExcludeFiles })
-    );
-  }
-}
 async function setupStarterKit(baseDir, answer) {
   if (!answer.starterKit) return;
   let starterKit = null;
@@ -1161,35 +1051,53 @@ async function setupStarterKit(baseDir, answer) {
     return;
   }
   console.log(chalk.green(`Setting up ${starterKit.name}...`));
-  // If it's a custom starter kit with source, download it
+  // If it's a custom starter kit with source, clone it directly to the target directory
   if (starterKit.source) {
-    const tempDir = path.join(baseDir, ".temp-starter-kit");
     try {
-      // Create temp directory
-      if (fs.existsSync(tempDir)) {
-        fs.rmSync(tempDir, { recursive: true, force: true });
+      // Clone directly to the target directory
+      const cloneCommand = starterKit.source.branch
+        ? `git clone -b ${starterKit.source.branch} --depth 1 ${starterKit.source.url} ${baseDir}`
+        : `git clone --depth 1 ${starterKit.source.url} ${baseDir}`;
+      execSync(cloneCommand, { stdio: "inherit" });
+      // Remove .git directory
+      const gitDir = path.join(baseDir, ".git");
+      if (fs.existsSync(gitDir)) {
+        fs.rmSync(gitDir, { recursive: true, force: true });
       }
-      fs.mkdirSync(tempDir, { recursive: true });
-      // Download the starter kit
-      const kitPath = await downloadStarterKit(starterKit, tempDir);
-      // Merge files from starter kit
-      await mergeStarterKitFiles(kitPath, baseDir, answer);
-      // Check if starter kit has its own configuration
-      const kitConfigPath = path.join(kitPath, "prisma-php-starter.json");
-      if (fs.existsSync(kitConfigPath)) {
-        const kitConfig = JSON.parse(fs.readFileSync(kitConfigPath, "utf8"));
-        // Override features with starter kit configuration
-        Object.assign(answer, kitConfig.features || {});
-        console.log(chalk.green(`Applied starter kit configuration`));
+      console.log(chalk.blue("Starter kit cloned successfully!"));
+      // Update the project name in the existing prisma-php.json
+      const configPath = path.join(baseDir, "prisma-php.json");
+      if (fs.existsSync(configPath)) {
+        try {
+          const existingConfig = JSON.parse(
+            fs.readFileSync(configPath, "utf8")
+          );
+          // Only update project-specific fields, preserve everything else
+          const projectPathModified = baseDir.replace(/\\/g, "\\");
+          const bsConfig = bsConfigUrls(projectPathModified);
+          existingConfig.projectName = answer.projectName;
+          existingConfig.projectRootPath = projectPathModified;
+          existingConfig.bsTarget = bsConfig.bsTarget;
+          existingConfig.bsPathRewrite = bsConfig.bsPathRewrite;
+          // Update version to latest
+          const latestVersion = await fetchPackageVersion(
+            "create-prisma-php-app"
+          );
+          existingConfig.version = latestVersion;
+          fs.writeFileSync(configPath, JSON.stringify(existingConfig, null, 2));
+          console.log(
+            chalk.green("Updated prisma-php.json with new project details")
+          );
+        } catch (error) {
+          console.warn(
+            chalk.yellow(
+              "Failed to update prisma-php.json, will create new one"
+            )
+          );
+        }
       }
-      // Clean up temp directory
-      fs.rmSync(tempDir, { recursive: true, force: true });
     } catch (error) {
       console.error(chalk.red(`Failed to setup starter kit: ${error}`));
-      // Clean up temp directory on error
-      if (fs.existsSync(tempDir)) {
-        fs.rmSync(tempDir, { recursive: true, force: true });
-      }
       throw error;
     }
   }
@@ -1243,10 +1151,27 @@ async function main() {
       return;
     }
     let answer = null;
+    let isStarterKitProject = false;
     if (projectName) {
       const currentDir = process.cwd();
       const configPath = path.join(currentDir, "prisma-php.json");
-      if (fs.existsSync(configPath)) {
+      // Check if it's a starter kit project
+      if (starterKitFromArgs && starterKitSource) {
+        isStarterKitProject = true;
+        const predefinedAnswers = {
+          projectName,
+          starterKit: starterKitFromArgs,
+          starterKitSource: starterKitSource,
+          backendOnly: args.includes("--backend-only"),
+          swaggerDocs: args.includes("--swagger-docs"),
+          tailwindcss: args.includes("--tailwindcss"),
+          websocket: args.includes("--websocket"),
+          mcp: args.includes("--mcp"),
+          prisma: args.includes("--prisma"),
+          docker: args.includes("--docker"),
+        };
+        answer = await getAnswer(predefinedAnswers);
+      } else if (fs.existsSync(configPath)) {
         // It's an update - read existing settings
         const localSettings = readJsonFile(configPath);
         let excludeFiles = [];
@@ -1357,33 +1282,86 @@ async function main() {
     const currentDir = process.cwd();
     let projectPath;
     if (projectName) {
-      // Check if we're in an existing project (has prisma-php.json) or creating a new one
-      const configPath = path.join(currentDir, "prisma-php.json");
-      const projectNamePath = path.join(currentDir, projectName);
-      const projectNameConfigPath = path.join(
-        projectNamePath,
-        "prisma-php.json"
-      );
-      if (fs.existsSync(configPath)) {
-        // We're updating an existing project in current directory
-        projectPath = currentDir;
-      } else if (
-        fs.existsSync(projectNamePath) &&
-        fs.existsSync(projectNameConfigPath)
-      ) {
-        // We're updating an existing project in the named directory
-        projectPath = projectNamePath;
-        process.chdir(projectNamePath);
-      } else {
-        // We're creating a new project with the given name
+      if (isStarterKitProject) {
+        // For starter kit projects, create directory first
+        const projectNamePath = path.join(currentDir, projectName);
         if (!fs.existsSync(projectNamePath)) {
           fs.mkdirSync(projectNamePath, { recursive: true });
         }
         projectPath = projectNamePath;
-        process.chdir(projectNamePath);
+        // Clone the starter kit first
+        await setupStarterKit(projectPath, answer);
+        // Change to project directory
+        process.chdir(projectPath);
+        // Now check if it has prisma-php.json and treat as update
+        const configPath = path.join(projectPath, "prisma-php.json");
+        if (fs.existsSync(configPath)) {
+          // Read the existing config and merge with CLI overrides
+          const existingConfig = JSON.parse(
+            fs.readFileSync(configPath, "utf8")
+          );
+          // Override with CLI arguments if provided
+          if (args.includes("--backend-only"))
+            existingConfig.backendOnly = true;
+          if (args.includes("--swagger-docs"))
+            existingConfig.swaggerDocs = true;
+          if (args.includes("--tailwindcss")) existingConfig.tailwindcss = true;
+          if (args.includes("--websocket")) existingConfig.websocket = true;
+          if (args.includes("--mcp")) existingConfig.mcp = true;
+          if (args.includes("--prisma")) existingConfig.prisma = true;
+          if (args.includes("--docker")) existingConfig.docker = true;
+          // Update answer with existing config
+          answer = {
+            ...answer,
+            backendOnly: existingConfig.backendOnly,
+            swaggerDocs: existingConfig.swaggerDocs,
+            tailwindcss: existingConfig.tailwindcss,
+            websocket: existingConfig.websocket,
+            mcp: existingConfig.mcp,
+            prisma: existingConfig.prisma,
+            docker: existingConfig.docker,
+          };
+          // Set up as an update
+          let excludeFiles = [];
+          existingConfig.excludeFiles?.map((file) => {
+            const filePath = path.join(projectPath, file);
+            if (fs.existsSync(filePath))
+              excludeFiles.push(filePath.replace(/\\/g, "/"));
+          });
+          updateAnswer = {
+            ...answer,
+            isUpdate: true,
+            excludeFiles: existingConfig.excludeFiles ?? [],
+            excludeFilePath: excludeFiles ?? [],
+            filePath: projectPath,
+          };
+        }
+      } else {
+        // Regular project handling (existing logic)
+        const configPath = path.join(currentDir, "prisma-php.json");
+        const projectNamePath = path.join(currentDir, projectName);
+        const projectNameConfigPath = path.join(
+          projectNamePath,
+          "prisma-php.json"
+        );
+        if (fs.existsSync(configPath)) {
+          projectPath = currentDir;
+        } else if (
+          fs.existsSync(projectNamePath) &&
+          fs.existsSync(projectNameConfigPath)
+        ) {
+          projectPath = projectNamePath;
+          process.chdir(projectNamePath);
+        } else {
+          if (!fs.existsSync(projectNamePath)) {
+            fs.mkdirSync(projectNamePath, { recursive: true });
+          }
+          projectPath = projectNamePath;
+          process.chdir(projectNamePath);
+        }
       }
     } else {
-      // Interactive mode - create directory with answer.projectName
+      // Interactive mode
       fs.mkdirSync(answer.projectName, { recursive: true });
       projectPath = path.join(currentDir, answer.projectName);
       process.chdir(answer.projectName);
@@ -1436,8 +1414,8 @@ async function main() {
     if (answer.prisma) {
       execSync("npm install -g prisma-client-php", { stdio: "inherit" });
     }
-    // Add starter kit setup before npm/composer installation
-    if (answer.starterKit) {
+    // Only setup starter kit if it's not already done
+    if (answer.starterKit && !isStarterKitProject) {
       await setupStarterKit(projectPath, answer);
     }
     await installNpmDependencies(projectPath, npmDependencies, true);
@@ -1673,48 +1651,37 @@ async function main() {
         await uninstallComposerDependencies(projectPath, composerToUninstall);
       }
     }
-    const projectPathModified = projectPath.replace(/\\/g, "\\");
-    const bsConfig = bsConfigUrls(projectPathModified);
-    let starterKitExcludeFiles = [];
-    const tempConfigPath = path.join(
-      projectPath,
-      ".temp-starter-kit-config.json"
-    );
-    if (fs.existsSync(tempConfigPath)) {
-      try {
-        const tempConfig = JSON.parse(fs.readFileSync(tempConfigPath, "utf8"));
-        starterKitExcludeFiles = tempConfig.excludeFiles || [];
-        fs.unlinkSync(tempConfigPath); // Clean up temp file
-      } catch (error) {
-        console.warn("Failed to read temp starter kit config");
-      }
+    // Skip creating prismaPhpConfig if it's a starter kit project that already has one
+    if (
+      !isStarterKitProject ||
+      !fs.existsSync(path.join(projectPath, "prisma-php.json"))
+    ) {
+      // Create prisma-php.json with all the existing logic
+      const projectPathModified = projectPath.replace(/\\/g, "\\");
+      const bsConfig = bsConfigUrls(projectPathModified);
+      const prismaPhpConfig = {
+        projectName: answer.projectName,
+        projectRootPath: projectPathModified,
+        phpEnvironment: "XAMPP",
+        phpRootPathExe: "C:\\xampp\\php\\php.exe",
+        bsTarget: bsConfig.bsTarget,
+        bsPathRewrite: bsConfig.bsPathRewrite,
+        backendOnly: answer.backendOnly,
+        swaggerDocs: answer.swaggerDocs,
+        tailwindcss: answer.tailwindcss,
+        websocket: answer.websocket,
+        mcp: answer.mcp,
+        prisma: answer.prisma,
+        docker: answer.docker,
+        version: latestVersionOfCreatePrismaPhpApp,
+        excludeFiles: updateAnswer?.excludeFiles ?? [],
+      };
+      fs.writeFileSync(
+        path.join(projectPath, "prisma-php.json"),
+        JSON.stringify(prismaPhpConfig, null, 2),
+        { flag: "w" }
+      );
     }
-    // Then update the prismaPhpConfig creation:
-    const prismaPhpConfig = {
-      projectName: answer.projectName,
-      projectRootPath: projectPathModified,
-      phpEnvironment: "XAMPP",
-      phpRootPathExe: "C:\\xampp\\php\\php.exe",
-      bsTarget: bsConfig.bsTarget,
-      bsPathRewrite: bsConfig.bsPathRewrite,
-      backendOnly: answer.backendOnly,
-      swaggerDocs: answer.swaggerDocs,
-      tailwindcss: answer.tailwindcss,
-      websocket: answer.websocket,
-      mcp: answer.mcp,
-      prisma: answer.prisma,
-      docker: answer.docker,
-      version: latestVersionOfCreatePrismaPhpApp,
-      excludeFiles:
-        starterKitExcludeFiles.length > 0
-          ? starterKitExcludeFiles
-          : updateAnswer?.excludeFiles ?? [],
-    };
-    fs.writeFileSync(
-      path.join(projectPath, "prisma-php.json"),
-      JSON.stringify(prismaPhpConfig, null, 2),
-      { flag: "w" }
-    );
     if (updateAnswer?.isUpdate) {
       execSync(
         "C:\\xampp\\php\\php.exe C:\\ProgramData\\ComposerSetup\\bin\\composer.phar update",

package/package.json

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