create-prisma-php-app 5.0.0-alpha.8 → 5.0.0

package/dist/settings/component-map.ts

@@ -0,0 +1,476 @@
+import { promises as fs } from "fs";
+import path from "path";
+import { Engine } from "php-parser";
+import { getFileMeta } from "./utils.js";
+
+const { __dirname } = getFileMeta();
+
+const parser = new Engine({
+  parser: {
+    php8: true,
+    suppressErrors: true,
+  },
+  ast: {
+    withPositions: false,
+  },
+});
+
+const PROJECT_ROOT = path.join(__dirname, "..");
+const CONFIG_FILE = path.join(PROJECT_ROOT, "prisma-php.json");
+const COMPONENT_MAP_FILE = path.join(
+  PROJECT_ROOT,
+  "settings/component-map.json",
+);
+
+export const SRC_DIR = path.join(PROJECT_ROOT, "src");
+
+const PHPX_BASE_CLASS = "PHPX";
+
+type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | JsonValue[]
+  | { [key: string]: JsonValue };
+
+export interface ComponentMapProp {
+  name: string;
+  type: string;
+  hasDefault: boolean;
+  defaultValue: JsonValue | string;
+}
+
+export interface ComponentMapEntry {
+  componentName: string;
+  tagName: string;
+  filePath: string;
+  relativePath: string;
+  importRoute: string;
+  extendsPHPX: boolean;
+  acceptsArbitraryProps: boolean;
+  props: ComponentMapProp[];
+}
+
+interface PrismaPhpConfig {
+  projectRootPath?: string;
+  excludeFiles?: string[];
+  componentScanDirs?: string[];
+}
+
+type DiscoveredComponent = ComponentMapEntry;
+
+async function loadConfig(): Promise<PrismaPhpConfig> {
+  try {
+    const raw = await fs.readFile(CONFIG_FILE, "utf-8");
+    return JSON.parse(raw) as PrismaPhpConfig;
+  } catch {
+    return {};
+  }
+}
+
+function resolveProjectRoot(config: PrismaPhpConfig): string {
+  if (config.projectRootPath && path.isAbsolute(config.projectRootPath)) {
+    return config.projectRootPath;
+  }
+
+  return PROJECT_ROOT;
+}
+
+function resolveScanRoots(
+  config: PrismaPhpConfig,
+  projectRoot: string,
+): string[] {
+  const scanDirs =
+    Array.isArray(config.componentScanDirs) &&
+    config.componentScanDirs.length > 0
+      ? config.componentScanDirs
+      : ["src"];
+
+  return scanDirs.map((dirPath) =>
+    path.isAbsolute(dirPath) ? dirPath : path.join(projectRoot, dirPath),
+  );
+}
+
+function normalizePathKey(filePath: string): string {
+  return path.normalize(filePath).toLowerCase();
+}
+
+function toAbsoluteComponentPath(filePath: string): string {
+  return path.normalize(filePath);
+}
+
+function toProjectRelativePath(filePath: string, projectRoot: string): string {
+  return path.relative(projectRoot, filePath).replace(/\\/g, "/");
+}
+
+async function saveJsonFile(filePath: string, value: unknown): Promise<void> {
+  await fs.writeFile(filePath, JSON.stringify(value, null, 2), "utf-8");
+}
+
+export function componentNameToTagName(componentName: string): string {
+  const kebabName = componentName
+    .replace(/([a-z\d])([A-Z])/g, "$1-$2")
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
+    .replace(/[_.\s]+/g, "-")
+    .toLowerCase();
+
+  return `x-${kebabName}`;
+}
+
+export async function getAllPhpFiles(dir: string): Promise<string[]> {
+  const files: string[] = [];
+
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        files.push(...(await getAllPhpFiles(fullPath)));
+      } else if (entry.isFile() && fullPath.toLowerCase().endsWith(".php")) {
+        files.push(fullPath);
+      }
+    }
+  } catch {
+    return files;
+  }
+
+  return files;
+}
+
+function nameToString(node: any): string {
+  if (!node) {
+    return "";
+  }
+
+  if (typeof node === "string") {
+    return node;
+  }
+
+  if (typeof node.raw === "string" && node.raw.trim() !== "") {
+    return node.raw;
+  }
+
+  if (typeof node.name === "string") {
+    return node.name;
+  }
+
+  if (Array.isArray(node.name)) {
+    return node.name
+      .map((part: any) =>
+        typeof part === "string" ? part : (part?.name ?? ""),
+      )
+      .filter(Boolean)
+      .join("\\");
+  }
+
+  if (Array.isArray(node.items)) {
+    return node.items.map(nameToString).filter(Boolean).join("|");
+  }
+
+  return String(node.name ?? "");
+}
+
+function typeToString(typeNode: any, nullable = false): string {
+  if (!typeNode) {
+    return "mixed";
+  }
+
+  let rawType = "";
+
+  if (typeof typeNode.raw === "string" && typeNode.raw.trim() !== "") {
+    rawType = typeNode.raw.replace(/\s+/g, "");
+  } else if (Array.isArray(typeNode.types)) {
+    rawType = typeNode.types.map((item: any) => typeToString(item)).join("|");
+  } else {
+    rawType = nameToString(typeNode).replace(/\s+/g, "");
+  }
+
+  if (
+    nullable &&
+    rawType !== "mixed" &&
+    !rawType.startsWith("?") &&
+    !rawType.split("|").includes("null")
+  ) {
+    return `?${rawType}`;
+  }
+
+  return rawType || "mixed";
+}
+
+function astValueToJson(valueNode: any): JsonValue | string {
+  if (!valueNode || typeof valueNode !== "object") {
+    return null;
+  }
+
+  switch (valueNode.kind) {
+    case "string":
+      return valueNode.value ?? "";
+    case "number":
+      return Number(valueNode.value ?? valueNode.raw ?? 0);
+    case "boolean":
+      return Boolean(valueNode.value);
+    case "nullkeyword":
+      return null;
+    case "array": {
+      const items = Array.isArray(valueNode.items) ? valueNode.items : [];
+      const hasNamedKeys = items.some((item: any) => item?.key);
+
+      if (!hasNamedKeys) {
+        return items.map((item: any) => astValueToJson(item?.value ?? item));
+      }
+
+      const mapped: Record<string, JsonValue | string> = {};
+
+      for (const item of items) {
+        const key = item?.key ? String(astValueToJson(item.key)) : "";
+        mapped[key] = astValueToJson(item?.value);
+      }
+
+      return mapped;
+    }
+    case "unary": {
+      const inner = astValueToJson(valueNode.what);
+
+      if (typeof inner === "number") {
+        return valueNode.type === "-" ? -inner : inner;
+      }
+
+      return typeof valueNode.raw === "string" ? valueNode.raw : String(inner);
+    }
+    case "constref": {
+      const constantName = nameToString(valueNode.name).toLowerCase();
+
+      if (constantName === "true") {
+        return true;
+      }
+
+      if (constantName === "false") {
+        return false;
+      }
+
+      if (constantName === "null") {
+        return null;
+      }
+
+      return nameToString(valueNode.name);
+    }
+    default:
+      if (typeof valueNode.raw === "string" && valueNode.raw.trim() !== "") {
+        return valueNode.raw;
+      }
+
+      return nameToString(valueNode);
+  }
+}
+
+function extractComponentProps(classNode: any): ComponentMapProp[] {
+  const props: ComponentMapProp[] = [];
+
+  for (const statement of classNode.body ?? []) {
+    if (
+      !statement ||
+      statement.kind !== "propertystatement" ||
+      statement.visibility !== "public" ||
+      statement.isStatic
+    ) {
+      continue;
+    }
+
+    for (const property of statement.properties ?? []) {
+      props.push({
+        name: nameToString(property.name),
+        type: typeToString(property.type, Boolean(property.nullable)),
+        hasDefault: property.value !== undefined && property.value !== null,
+        defaultValue:
+          property.value !== undefined && property.value !== null
+            ? astValueToJson(property.value)
+            : null,
+      });
+    }
+  }
+
+  return props;
+}
+
+function classExtendsPHPX(classNode: any): boolean {
+  if (!classNode?.extends) {
+    return false;
+  }
+
+  const name = nameToString(classNode.extends);
+  return name.split("\\").pop() === PHPX_BASE_CLASS;
+}
+
+export async function analyzeComponentsInFile(
+  filePath: string,
+  projectRoot: string,
+): Promise<DiscoveredComponent[]> {
+  const code = await fs.readFile(filePath, "utf-8");
+
+  try {
+    const ast = parser.parseCode(code, filePath);
+    const components: DiscoveredComponent[] = [];
+
+    function traverse(node: any, currentNamespace = "") {
+      if (Array.isArray(node)) {
+        node.forEach((childNode) => traverse(childNode, currentNamespace));
+        return;
+      }
+
+      if (!node || typeof node !== "object") {
+        return;
+      }
+
+      if (node.kind === "namespace") {
+        const nextNamespace = nameToString(node.name).replace(/^\\+/, "");
+
+        for (const [key, value] of Object.entries(node)) {
+          if (key === "kind" || key === "name") {
+            continue;
+          }
+
+          traverse(value, nextNamespace || currentNamespace);
+        }
+
+        return;
+      }
+
+      if (node.kind === "class" && node.name?.name) {
+        const extendsPHPX = classExtendsPHPX(node);
+
+        if (extendsPHPX) {
+          const componentName = node.name.name as string;
+          const importRoute =
+            (currentNamespace ? `${currentNamespace}\\` : "") + componentName;
+
+          components.push({
+            componentName,
+            tagName: componentNameToTagName(componentName),
+            filePath: toAbsoluteComponentPath(filePath),
+            relativePath: toProjectRelativePath(filePath, projectRoot),
+            importRoute,
+            extendsPHPX,
+            acceptsArbitraryProps: extendsPHPX,
+            props: extractComponentProps(node),
+          });
+        }
+      }
+
+      for (const [key, value] of Object.entries(node)) {
+        if (key === "kind" || key === "name") {
+          continue;
+        }
+
+        traverse(value, currentNamespace);
+      }
+    }
+
+    traverse(ast);
+    return components;
+  } catch (error) {
+    console.error(`Error parsing component file: ${filePath}`, error);
+    return [];
+  }
+}
+
+function sortComponentMap(
+  componentMap: DiscoveredComponent[],
+): DiscoveredComponent[] {
+  return [...componentMap].sort((left, right) => {
+    const nameComparison = left.componentName.localeCompare(
+      right.componentName,
+    );
+
+    if (nameComparison !== 0) {
+      return nameComparison;
+    }
+
+    return left.relativePath.localeCompare(right.relativePath);
+  });
+}
+
+export function buildRuntimeComponentLookup(
+  componentMap: ComponentMapEntry[],
+): Record<
+  string,
+  Array<{
+    tagName: string;
+    componentName: string;
+    className: string;
+    filePath: string;
+  }>
+> {
+  const lookup: Record<
+    string,
+    Array<{
+      tagName: string;
+      componentName: string;
+      className: string;
+      filePath: string;
+    }>
+  > = {};
+
+  for (const entry of componentMap) {
+    const tagName = entry.tagName.toLowerCase();
+
+    if (!lookup[tagName]) {
+      lookup[tagName] = [];
+    }
+
+    lookup[tagName].push({
+      tagName,
+      componentName: entry.componentName,
+      className: entry.importRoute,
+      filePath: entry.filePath,
+    });
+  }
+
+  return Object.fromEntries(
+    Object.entries(lookup).sort(([left], [right]) => left.localeCompare(right)),
+  );
+}
+
+export async function updateComponentMap(): Promise<ComponentMapEntry[]> {
+  const config = await loadConfig();
+  const projectRoot = resolveProjectRoot(config);
+  const scanRoots = resolveScanRoots(config, projectRoot);
+  const excludedFiles = new Set(
+    (config.excludeFiles ?? []).map((filePath) =>
+      normalizePathKey(
+        path.isAbsolute(filePath) ? filePath : path.join(projectRoot, filePath),
+      ),
+    ),
+  );
+
+  const phpFiles: string[] = [];
+
+  for (const scanRoot of scanRoots) {
+    const discoveredFiles = await getAllPhpFiles(scanRoot);
+
+    for (const filePath of discoveredFiles) {
+      if (!excludedFiles.has(normalizePathKey(filePath))) {
+        phpFiles.push(filePath);
+      }
+    }
+  }
+
+  const uniquePhpFiles = [
+    ...new Set(phpFiles.map((filePath) => path.normalize(filePath))),
+  ];
+  const discoveredComponents: DiscoveredComponent[] = [];
+
+  for (const filePath of uniquePhpFiles) {
+    discoveredComponents.push(
+      ...(await analyzeComponentsInFile(filePath, projectRoot)),
+    );
+  }
+
+  const sortedComponents = sortComponentMap(discoveredComponents);
+  const componentMap: ComponentMapEntry[] = [...sortedComponents];
+  await saveJsonFile(COMPONENT_MAP_FILE, componentMap);
+
+  return componentMap;
+}

package/dist/settings/files-list.ts

@@ -23,7 +23,7 @@ const getAllFiles = (dirPath: string): string[] => {
     } else {
       const relativePath = `.${sep}${relative(
         join(__dirname, ".."),
-        fullPath
+        fullPath,
       )}`;
       files.push(relativePath.replace(/\\/g, "/").replace(/^\.\.\//, ""));
     }
@@ -41,7 +41,7 @@ export const generateFileListJson = async (): Promise<void> => {
   if (allFiles.length > 0) {
     writeFileSync(jsonFilePath, JSON.stringify(allFiles, null, 2));
     console.log(
-      `File list generated: ${appFiles.length} app files, ${publicFiles.length} public files`
+      `File list generated: ${appFiles.length} app files, ${publicFiles.length} public files`,
     );
   } else {
     console.error("No files found to save in the JSON file.");

package/dist/settings/project-name.ts

@@ -3,8 +3,7 @@ import { join, basename, dirname, normalize, sep } from "path";
 import prismaPhpConfigJson from "../prisma-php.json";
 import { getFileMeta } from "./utils.js";
 import { promises as fsPromises } from "fs";
-import { updateAllClassLogs } from "./class-log";
-import { updateComponentImports } from "./class-imports";
+import { updateComponentMap } from "./component-map";
 import { generateFileListJson } from "./files-list";
 
 const { __dirname } = getFileMeta();
@@ -152,8 +151,7 @@ export async function deleteDirectoriesIfExist(
 
 export const filesToDelete = [
   join(__dirname, "request-data.json"),
-  join(__dirname, "class-log.json"),
-  join(__dirname, "class-imports.json"),
+  join(__dirname, "component-map.json"),
 ];
 
 export const dirsToDelete = [
@@ -164,5 +162,4 @@ export const dirsToDelete = [
 await deleteFilesIfExist(filesToDelete);
 await deleteDirectoriesIfExist(dirsToDelete);
 await generateFileListJson();
-await updateAllClassLogs();
-await updateComponentImports();
+await updateComponentMap();

package/dist/settings/restart-mcp.ts

@@ -19,7 +19,7 @@ const serverScriptPath = join(
   "src",
   "Lib",
   "MCP",
-  "mcp-server.php"
+  "mcp-server.php",
 );
 const watchRoot = join(__dirname, "..", "src");
 
@@ -37,7 +37,7 @@ const restarter = new DebouncedWorker(
     await mcp.restart("file change");
   },
   250,
-  "mcp-restart"
+  "mcp-restart",
 );
 
 createSrcWatcher(watchRoot, {

package/dist/settings/restart-websocket.ts

@@ -13,7 +13,7 @@ const serverScriptPath = join(
   SRC_DIR,
   "Lib",
   "Websocket",
-  "websocket-server.php"
+  "websocket-server.php",
 );
 
 const ws = createRestartableProcess({
@@ -30,7 +30,7 @@ const restarter = new DebouncedWorker(
     await ws.restart("file change");
   },
   400,
-  "ws-restart"
+  "ws-restart",
 );
 
 createSrcWatcher(SRC_DIR, {