create-prisma-php-app 4.4.0-beta → 4.4.0

package/dist/settings/bs-config.ts

@@ -1,9 +1,12 @@
-import { createProxyMiddleware } from "http-proxy-middleware";
+import {
+  createProxyMiddleware,
+  responseInterceptor,
+} from "http-proxy-middleware";
 import { writeFileSync, existsSync, mkdirSync } from "fs";
 import browserSync, { BrowserSyncInstance } from "browser-sync";
 import prismaPhpConfigJson from "../prisma-php.json";
 import { generateFileListJson } from "./files-list.js";
-import { join, dirname } from "path";
+import { join, dirname, relative } from "path";
 import { getFileMeta, PUBLIC_DIR, SRC_DIR } from "./utils.js";
 import { updateAllClassLogs } from "./class-log.js";
 import {
@@ -13,11 +16,13 @@ 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 pipeline = new DebouncedWorker(
   async () => {
     await generateFileListJson();
@@ -45,18 +50,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, "**", "*"), {
@@ -68,7 +73,19 @@ createSrcWatcher(join(SRC_DIR, "**", "*"), {
 });
 
 createSrcWatcher(join(PUBLIC_DIR, "**", "*"), {
-  onEvent: (_ev, _abs, rel) => publicPipeline.schedule(rel),
+  onEvent: (_ev, abs, _) => {
+    const relFromPublic = relative(PUBLIC_DIR, abs);
+    const normalized = relFromPublic.replace(/\\/g, "/");
+
+    const segments = normalized.split("/").filter(Boolean);
+    const firstSegment = segments[0] || "";
+
+    if (PUBLIC_IGNORE_DIRS.includes(firstSegment)) {
+      return;
+    }
+
+    publicPipeline.schedule(relFromPublic);
+  },
   awaitWriteFinish: DEFAULT_AWF,
   logPrefix: "watch-public",
   usePolling: true,
@@ -77,16 +94,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();
     }
   },
@@ -106,36 +124,138 @@ 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 urls = bsInstance.getOption("urls");
+    const localUrl = urls.get("local");
+    const externalUrl = urls.get("external");
+    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/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");
+}