create-prisma-php-app 4.4.7-beta → 4.4.7

package/dist/settings/bs-config.ts

@@ -1,5 +1,9 @@
-import { createProxyMiddleware } from "http-proxy-middleware";
+import {
+  createProxyMiddleware,
+  responseInterceptor,
+} from "http-proxy-middleware";
 import { writeFileSync, existsSync, mkdirSync } from "fs";
+import { networkInterfaces } from "os";
 import browserSync, { BrowserSyncInstance } from "browser-sync";
 import prismaPhpConfigJson from "../prisma-php.json";
 import { generateFileListJson } from "./files-list.js";
@@ -13,11 +17,24 @@ import {
 } from "./class-imports";
 import { checkComponentImports } from "./component-import-checker";
 import { DebouncedWorker, createSrcWatcher, DEFAULT_AWF } from "./utils.js";
+import chalk from "chalk";
 
 const { __dirname } = getFileMeta();
 const bs: BrowserSyncInstance = browserSync.create();
 
-const PUBLIC_IGNORE_DIRS = [''];
+const PUBLIC_IGNORE_DIRS = [""];
+
+function getExternalIP(): string | null {
+  const nets = networkInterfaces();
+  for (const name of Object.keys(nets)) {
+    for (const net of nets[name]!) {
+      if (net.family === "IPv4" && !net.internal) {
+        return net.address;
+      }
+    }
+  }
+  return null;
+}
 
 const pipeline = new DebouncedWorker(
   async () => {
@@ -46,18 +63,18 @@ const pipeline = new DebouncedWorker(
     }
   },
   350,
-  "bs-pipeline"
+  "bs-pipeline",
 );
 
 const publicPipeline = new DebouncedWorker(
   async () => {
-    console.log("→ Public directory changed, reloading browser...");
+    console.log(chalk.cyan("→ Public directory changed, reloading browser..."));
     if (bs.active) {
       bs.reload();
     }
   },
   350,
-  "bs-public-pipeline"
+  "bs-public-pipeline",
 );
 
 createSrcWatcher(join(SRC_DIR, "**", "*"), {
@@ -90,16 +107,17 @@ createSrcWatcher(join(PUBLIC_DIR, "**", "*"), {
 
 const viteFlagFile = join(__dirname, "..", ".pp", ".vite-build-complete");
 mkdirSync(dirname(viteFlagFile), { recursive: true });
-writeFileSync(viteFlagFile, "");
 
 if (!existsSync(viteFlagFile)) {
   writeFileSync(viteFlagFile, "0");
+} else {
+  writeFileSync(viteFlagFile, "");
 }
 
 createSrcWatcher(viteFlagFile, {
   onEvent: (ev) => {
     if (ev === "change" && bs.active) {
-      console.log("→ Vite build complete, reloading browser...");
+      console.log(chalk.green("→ Vite build complete, reloading browser..."));
       bs.reload();
     }
   },
@@ -112,6 +130,7 @@ createSrcWatcher(viteFlagFile, {
 bs.init(
   {
     proxy: "http://localhost:3000",
+    online: true,
     middleware: [
       (_req, res, next) => {
         res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
@@ -119,36 +138,142 @@ bs.init(
         res.setHeader("Expires", "0");
         next();
       },
+
+      (req, _, next) => {
+        const time = new Date().toLocaleTimeString();
+        console.log(
+          `${chalk.gray(time)} ${chalk.cyan("[Proxy]")} ${chalk.bold(req.method)} ${req.url}`,
+        );
+        next();
+      },
+
       createProxyMiddleware({
         target: prismaPhpConfigJson.bsTarget,
         changeOrigin: true,
         pathRewrite: {},
+        selfHandleResponse: true,
+
+        on: {
+          proxyReq: (proxyReq, req, _res) => {
+            proxyReq.setHeader("Accept-Encoding", "");
+
+            const sendsJson =
+              req.headers["content-type"]?.includes("application/json");
+            const asksJson =
+              req.headers["accept"]?.includes("application/json");
+
+            if (!sendsJson && !asksJson) return;
+
+            const originalWrite = proxyReq.write;
+            proxyReq.write = function (data, ...args) {
+              if (data) {
+                try {
+                  const body = data.toString();
+                  const json = JSON.parse(body);
+                  console.log(
+                    chalk.blue("→ API Request:"),
+                    JSON.stringify(json, null, 2),
+                  );
+                } catch {
+                  if (data.toString().trim() !== "") {
+                    console.log(chalk.blue("→ API Request:"), data.toString());
+                  }
+                }
+              }
+              // @ts-ignore
+              return originalWrite.call(proxyReq, data, ...args);
+            };
+          },
+
+          proxyRes: responseInterceptor(
+            async (responseBuffer, proxyRes, _req, _res) => {
+              const contentType = proxyRes.headers["content-type"] || "";
+
+              if (!contentType.includes("application/json")) {
+                return responseBuffer;
+              }
+
+              try {
+                const body = responseBuffer.toString("utf8");
+                console.log(
+                  chalk.green("← API Response:"),
+                  JSON.stringify(JSON.parse(body), null, 2),
+                );
+                console.log(
+                  chalk.gray("----------------------------------------"),
+                );
+              } catch (e) {
+                console.log(
+                  chalk.red("← API Response (Parse Error):"),
+                  responseBuffer.toString(),
+                );
+              }
+
+              return responseBuffer;
+            },
+          ),
+
+          error: (err) => {
+            console.error(chalk.red("Proxy Error:"), err);
+          },
+        },
       }),
     ],
-
     notify: false,
     open: false,
     ghostMode: false,
     codeSync: true,
+    logLevel: "silent",
   },
   (err, bsInstance) => {
     if (err) {
-      console.error("BrowserSync failed to start:", err);
+      console.error(chalk.red("BrowserSync failed to start:"), err);
       return;
     }
 
+    const bsPort = bsInstance.getOption("port");
     const urls = bsInstance.getOption("urls");
+    const localUrl = urls.get("local") || `http://localhost:${bsPort}`;
+    const externalIP = getExternalIP();
+    const externalUrl =
+      urls.get("external") ||
+      (externalIP ? `http://${externalIP}:${bsPort}` : null);
+    const uiUrl = urls.get("ui");
+    const uiExtUrl = urls.get("ui-external");
+
+    console.log("");
+    console.log(chalk.green.bold("✔ Ports Configured:"));
+    console.log(
+      `  ${chalk.blue.bold("Frontend (BrowserSync):")} ${chalk.magenta(localUrl)}`,
+    );
+    console.log(
+      `  ${chalk.yellow.bold("Backend (PHP Target):")}   ${chalk.magenta(
+        prismaPhpConfigJson.bsTarget || "http://localhost:80",
+      )}`,
+    );
+    console.log(chalk.gray(" ------------------------------------"));
+
+    if (externalUrl) {
+      console.log(
+        `    ${chalk.bold("External:")} ${chalk.magenta(externalUrl)}`,
+      );
+    }
+
+    if (uiUrl) {
+      console.log(`          ${chalk.bold("UI:")} ${chalk.magenta(uiUrl)}`);
+    }
+
     const out = {
-      local: urls.get("local"),
-      external: urls.get("external"),
-      ui: urls.get("ui"),
-      uiExternal: urls.get("ui-external"),
+      local: localUrl,
+      external: externalUrl,
+      ui: uiUrl,
+      uiExternal: uiExtUrl,
     };
 
     writeFileSync(
       join(__dirname, "bs-config.json"),
-      JSON.stringify(out, null, 2)
+      JSON.stringify(out, null, 2),
     );
-    console.log("\n\x1b[90mPress Ctrl+C to stop.\x1b[0m\n");
-  }
+    console.log(`\n${chalk.gray("Press Ctrl+C to stop.")}\n`);
+  },
 );

package/dist/settings/project-name.ts

@@ -13,7 +13,7 @@ const newProjectName = basename(join(__dirname, ".."));
 
 function updateProjectNameInConfig(
   filePath: string,
-  newProjectName: string
+  newProjectName: string,
 ): void {
   const filePathDir = dirname(filePath);
 
@@ -23,7 +23,7 @@ function updateProjectNameInConfig(
 
   const targetPath = getTargetPath(
     filePathDir,
-    prismaPhpConfigJson.phpEnvironment
+    prismaPhpConfigJson.phpEnvironment,
   );
 
   prismaPhpConfigJson.bsTarget = `http://localhost${targetPath}`;
@@ -39,59 +39,84 @@ function updateProjectNameInConfig(
         return;
       }
       console.log(
-        "The project name, PHP path, and other paths have been updated successfully."
+        "The project name, PHP path, and other paths have been updated successfully.",
       );
-    }
+    },
   );
 }
 
 function getTargetPath(fullPath: string, environment: string): string {
   const normalizedPath = normalize(fullPath);
 
-  if (process.env.CI === "true") {
+  // ---- CI / Railway / Docker safe-guards ----
+  // GitHub Actions etc.
+  if (process.env.CI === "true") return "/";
+
+  // Railway commonly exposes these (not guaranteed, but helpful)
+  if (process.env.RAILWAY_ENVIRONMENT || process.env.RAILWAY_PROJECT_ID)
+    return "/";
+
+  // Docker/containers: your app root is usually /app
+  // If you're not inside an AMP stack folder, don't crash.
+  const lower = normalizedPath.toLowerCase();
+  if (
+    lower === "/app" ||
+    lower.startsWith("/app" + sep) ||
+    lower.startsWith("/app/")
+  ) {
     return "/";
   }
 
-  const webDirectories: { [key: string]: string } = {
+  // ---- Local AMP detection map (your original logic) ----
+  const webDirectories: Record<string, string> = {
     XAMPP: join("htdocs"),
     WAMP: join("www"),
     MAMP: join("htdocs"),
     LAMP: join("var", "www", "html"),
     LEMP: join("usr", "share", "nginx", "html"),
     AMPPS: join("www"),
-    UniformServer: join("www"),
-    EasyPHP: join("data", "localweb"),
+    UNIFORMSERVER: join("www"),
+    EASYPHP: join("data", "localweb"),
   };
 
-  const webDir = webDirectories[environment.toUpperCase()];
-  if (!webDir) {
-    throw new Error(`Unsupported environment: ${environment}`);
-  }
+  const envKey = (environment || "").toUpperCase();
+  const webDir = webDirectories[envKey];
 
-  const indexOfWebDir = normalizedPath
-    .toLowerCase()
-    .indexOf(normalize(webDir).toLowerCase());
-  if (indexOfWebDir === -1) {
-    throw new Error(`Web directory not found in path: ${webDir}`);
-  }
+  // If phpEnvironment is missing/unknown, don't crash in non-local contexts.
+  if (!webDir) return "/";
 
-  const startIndex = indexOfWebDir + webDir.length;
+  const webDirNorm = normalize(webDir).toLowerCase();
+  const idx = lower.indexOf(webDirNorm);
+
+  // If we can't find htdocs/www/etc, fall back instead of throwing.
+  if (idx === -1) return "/";
+
+  const startIndex = idx + webDir.length;
   const subPath = normalizedPath.slice(startIndex);
+
   const safeSeparatorRegex = new RegExp(
     sep.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&"),
-    "g"
+    "g",
   );
-  const finalPath = subPath.replace(safeSeparatorRegex, "/") + "/";
 
-  return finalPath;
+  const finalPath = (subPath.replace(safeSeparatorRegex, "/") || "/") + "/";
+
+  // Ensure it starts with "/"
+  return finalPath.startsWith("/") ? finalPath : `/${finalPath}`;
 }
 
 const configFilePath = join(__dirname, "..", "prisma-php.json");
 
-updateProjectNameInConfig(configFilePath, newProjectName);
+const isLocal =
+  !process.env.CI &&
+  !process.env.RAILWAY_ENVIRONMENT &&
+  !process.env.RAILWAY_PROJECT_ID;
+if (isLocal) {
+  updateProjectNameInConfig(configFilePath, newProjectName);
+}
 
 export const deleteFilesIfExist = async (
-  filePaths: string[]
+  filePaths: string[],
 ): Promise<void> => {
   for (const filePath of filePaths) {
     try {
@@ -113,7 +138,7 @@ export const deleteFilesIfExist = async (
 };
 
 export async function deleteDirectoriesIfExist(
-  dirPaths: string[]
+  dirPaths: string[],
 ): Promise<void> {
   for (const dirPath of dirPaths) {
     try {

package/dist/settings/vite-plugins/generate-global-types.ts

@@ -0,0 +1,301 @@
+import { Plugin } from "vite";
+import path from "path";
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from "fs";
+import ts from "typescript";
+
+export function generateGlobalTypes(): Plugin {
+  const dtsPath = path.resolve(process.cwd(), ".pp", "global-functions.d.ts");
+
+  return {
+    name: "generate-global-types",
+
+    buildStart() {
+      const mainPath = path.resolve(process.cwd(), "ts", "main.ts");
+
+      if (!existsSync(mainPath)) {
+        console.warn("⚠️  ts/main.ts not found, skipping type generation");
+        return;
+      }
+
+      const content = readFileSync(mainPath, "utf-8");
+      const globals = parseGlobalSingletons(content, mainPath);
+
+      if (globals.length === 0) {
+        console.warn("⚠️  No createGlobalSingleton calls found");
+        return;
+      }
+
+      generateDtsWithTypeChecker(globals, dtsPath, mainPath);
+    },
+  };
+}
+
+interface GlobalDeclaration {
+  name: string;
+  importPath: string;
+  exportName: string;
+  isNamespace: boolean;
+}
+
+function parseGlobalSingletons(
+  content: string,
+  filePath: string
+): GlobalDeclaration[] {
+  const sf = ts.createSourceFile(
+    filePath,
+    content,
+    ts.ScriptTarget.Latest,
+    true
+  );
+
+  const globals: GlobalDeclaration[] = [];
+  const importMap = new Map<
+    string,
+    { path: string; originalName: string; isNamespace: boolean }
+  >();
+
+  sf.statements.forEach((stmt) => {
+    if (ts.isImportDeclaration(stmt) && stmt.importClause) {
+      const moduleSpecifier = (stmt.moduleSpecifier as ts.StringLiteral).text;
+
+      if (stmt.importClause.namedBindings) {
+        if (ts.isNamedImports(stmt.importClause.namedBindings)) {
+          stmt.importClause.namedBindings.elements.forEach((element) => {
+            const localName = element.name.text;
+            const importedName = element.propertyName
+              ? element.propertyName.text
+              : localName;
+
+            importMap.set(localName, {
+              path: moduleSpecifier,
+              originalName: importedName,
+              isNamespace: false,
+            });
+          });
+        } else if (ts.isNamespaceImport(stmt.importClause.namedBindings)) {
+          const localName = stmt.importClause.namedBindings.name.text;
+          importMap.set(localName, {
+            path: moduleSpecifier,
+            originalName: localName,
+            isNamespace: true,
+          });
+        }
+      } else if (stmt.importClause.name) {
+        const localName = stmt.importClause.name.text;
+        importMap.set(localName, {
+          path: moduleSpecifier,
+          originalName: "default",
+          isNamespace: false,
+        });
+      }
+    }
+  });
+
+  function visit(node: ts.Node) {
+    if (
+      ts.isCallExpression(node) &&
+      ts.isIdentifier(node.expression) &&
+      node.expression.text === "createGlobalSingleton"
+    ) {
+      if (node.arguments.length >= 2) {
+        const nameArg = node.arguments[0];
+        const valueArg = node.arguments[1];
+
+        if (ts.isStringLiteral(nameArg) && ts.isIdentifier(valueArg)) {
+          const name = nameArg.text;
+          const variable = valueArg.text;
+          const importInfo = importMap.get(variable);
+
+          if (importInfo) {
+            globals.push({
+              name,
+              importPath: importInfo.path,
+              exportName: importInfo.originalName,
+              isNamespace: importInfo.isNamespace,
+            });
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sf);
+  return globals;
+}
+
+function generateDtsWithTypeChecker(
+  globals: GlobalDeclaration[],
+  dtsPath: string,
+  mainPath: string
+) {
+  const configPath = ts.findConfigFile(
+    process.cwd(),
+    ts.sys.fileExists,
+    "tsconfig.json"
+  );
+  const { config } = configPath
+    ? ts.readConfigFile(configPath, ts.sys.readFile)
+    : { config: {} };
+  const parsedConfig = ts.parseJsonConfigFileContent(
+    config,
+    ts.sys,
+    process.cwd()
+  );
+
+  const program = ts.createProgram(
+    parsedConfig.fileNames,
+    parsedConfig.options
+  );
+  const checker = program.getTypeChecker();
+  const sourceFile = program.getSourceFile(mainPath);
+
+  if (!sourceFile) {
+    generateFallbackDts(globals, dtsPath);
+    return;
+  }
+
+  const signatures = new Map<string, string>();
+  const importMap = new Map<string, ts.ImportDeclaration>();
+
+  sourceFile.statements.forEach((stmt) => {
+    if (ts.isImportDeclaration(stmt)) {
+      if (stmt.importClause?.namedBindings) {
+        if (ts.isNamedImports(stmt.importClause.namedBindings)) {
+          stmt.importClause.namedBindings.elements.forEach((element) => {
+            importMap.set(element.name.text, stmt);
+          });
+        } else if (ts.isNamespaceImport(stmt.importClause.namedBindings)) {
+          importMap.set(stmt.importClause.namedBindings.name.text, stmt);
+        }
+      } else if (stmt.importClause?.name) {
+        importMap.set(stmt.importClause.name.text, stmt);
+      }
+    }
+  });
+
+  globals.forEach(({ name, exportName, importPath, isNamespace }) => {
+    const isExternalLibrary =
+      !importPath.startsWith(".") && !importPath.startsWith("/");
+
+    if (isExternalLibrary) {
+      if (isNamespace) {
+        signatures.set(name, `typeof import("${importPath}")`);
+      } else {
+        signatures.set(name, `typeof import("${importPath}").${exportName}`);
+      }
+      return;
+    }
+
+    try {
+      const importDecl =
+        importMap.get(exportName === "default" ? name : exportName) ||
+        importMap.get(isNamespace ? name : exportName);
+      let symbol: ts.Symbol | undefined;
+
+      if (importDecl && importDecl.importClause) {
+        if (importDecl.importClause.namedBindings) {
+          if (ts.isNamedImports(importDecl.importClause.namedBindings)) {
+            const importSpec =
+              importDecl.importClause.namedBindings.elements.find(
+                (el) =>
+                  (el.propertyName?.text || el.name.text) === exportName ||
+                  el.name.text === exportName
+              );
+            if (importSpec)
+              symbol = checker.getSymbolAtLocation(importSpec.name);
+          } else if (
+            ts.isNamespaceImport(importDecl.importClause.namedBindings)
+          ) {
+            symbol = checker.getSymbolAtLocation(
+              importDecl.importClause.namedBindings.name
+            );
+          }
+        } else if (importDecl.importClause.name) {
+          symbol = checker.getSymbolAtLocation(importDecl.importClause.name);
+        }
+      }
+
+      if (symbol) {
+        const aliasedSymbol = checker.getAliasedSymbol(symbol);
+        const targetSymbol = aliasedSymbol || symbol;
+        const type = checker.getTypeOfSymbolAtLocation(
+          targetSymbol,
+          targetSymbol.valueDeclaration!
+        );
+        const signature = checker.typeToString(
+          type,
+          undefined,
+          ts.TypeFormatFlags.NoTruncation |
+            ts.TypeFormatFlags.UseFullyQualifiedType
+        );
+
+        if (signature !== "any") {
+          signatures.set(name, signature);
+          return;
+        }
+      }
+    } catch (error) {
+      console.warn(`Failed to resolve type for ${name}`);
+    }
+
+    // Fallback
+    signatures.set(name, "any");
+  });
+
+  const declarations = globals
+    .map(({ name, importPath }) => {
+      const sig = signatures.get(name) || "any";
+      return `  // @source: ${importPath}\n  const ${name}: ${sig};`;
+    })
+    .join("\n");
+
+  const windowDeclarations = globals
+    .map(({ name }) => `    ${name}: typeof globalThis.${name};`)
+    .join("\n");
+
+  const content = `// Auto-generated by Vite plugin
+// Do not edit manually - regenerate with: npm run dev or npm run build
+// Source: ts/main.ts
+
+declare global {
+${declarations}
+
+  interface Window {
+${windowDeclarations}
+  }
+}
+
+export {};
+`;
+
+  const dir = path.dirname(dtsPath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(dtsPath, content, "utf-8");
+  console.log(`✅ Generated ${path.relative(process.cwd(), dtsPath)}`);
+}
+
+function generateFallbackDts(globals: GlobalDeclaration[], dtsPath: string) {
+  const declarations = globals
+    .map(
+      ({ name, importPath }) =>
+        `  // @source: ${importPath}\n  const ${name}: any;`
+    )
+    .join("\n");
+
+  const windowDeclarations = globals
+    .map(({ name }) => `    ${name}: typeof globalThis.${name};`)
+    .join("\n");
+
+  const content = `// Auto-generated by Vite plugin
+declare global {
+${declarations}
+
+  interface Window {
+${windowDeclarations}
+  }
+}
+export {};
+`;
+  writeFileSync(dtsPath, content, "utf-8");
+}