create-prisma-php-app 4.0.0-alpha.19 → 4.0.0-alpha.20

package/dist/settings/restart-websocket.ts

@@ -1,53 +1,52 @@
-import { spawn, ChildProcess } from "child_process";
 import { join } from "path";
-import chokidar from "chokidar";
-import { getFileMeta } from "./utils.js";
-
-const { __dirname } = getFileMeta();
-
-const phpPath = "php";
+import {
+  createRestartableProcess,
+  createSrcWatcher,
+  DebouncedWorker,
+  DEFAULT_AWF,
+  onExit,
+} from "./utils.js";
+
+// Config
+const phpPath = process.env.PHP_PATH ?? "php";
+const SRC_DIR = join(process.cwd(), "src");
 const serverScriptPath = join(
-  __dirname,
-  "..",
-  "src",
+  SRC_DIR,
   "Lib",
   "Websocket",
   "websocket-server.php"
 );
 
-let serverProcess: ChildProcess | null = null;
-
-const restartServer = (): void => {
-  if (serverProcess) {
-    console.log("Stopping WebSocket server...");
-    serverProcess.kill("SIGINT");
-    serverProcess = null;
-  }
-
-  console.log("Starting WebSocket server...");
-  serverProcess = spawn(phpPath, [serverScriptPath]);
-
-  serverProcess.stdout?.on("data", (data: Buffer) => {
-    console.log(`WebSocket Server: ${data.toString()}`);
-  });
-
-  serverProcess.stderr?.on("data", (data: Buffer) => {
-    console.error(`WebSocket Server Error: ${data.toString()}`);
-  });
-
-  serverProcess.on("close", (code: number) => {
-    console.log(`WebSocket server exited with code ${code}`);
-  });
-};
-
-// Initial start
-restartServer();
+// Restartable WS server
+const ws = createRestartableProcess({
+  name: "WebSocket",
+  cmd: phpPath,
+  args: [serverScriptPath],
+  windowsKillTree: true,
+});
+
+ws.start();
+
+// Debounced restarter
+const restarter = new DebouncedWorker(
+  async () => {
+    await ws.restart("file change");
+  },
+  400,
+  "ws-restart"
+);
 
-// Watch for changes
-chokidar
-  .watch(join(__dirname, "..", "src", "Websocket", "**", "*"))
-  .on("change", (path: string) => {
-    const fileChanged = path.split("\\").pop();
-    console.log(`File changed: src/Lib/Websocket/${fileChanged}`);
-    restartServer();
-  });
+// Watch ./src recursively; restart on code/data file changes
+createSrcWatcher(SRC_DIR, {
+  exts: [".php", ".ts", ".js", ".json"],
+  onEvent: (ev, _abs, rel) => restarter.schedule(`${ev}: ${rel}`),
+  awaitWriteFinish: DEFAULT_AWF,
+  logPrefix: "WS watch",
+  usePolling: true,
+  interval: 1000,
+});
+
+// Graceful shutdown
+onExit(async () => {
+  await ws.stop();
+});

package/dist/settings/utils.ts

@@ -1,5 +1,8 @@
 import { fileURLToPath } from "url";
 import { dirname } from "path";
+import chokidar, { FSWatcher } from "chokidar";
+import { spawn, ChildProcess, execFile } from "child_process";
+import { relative } from "path";
 
 /**
  * Retrieves the file metadata including the filename and directory name.
@@ -12,3 +15,240 @@ export function getFileMeta() {
   const __dirname = dirname(__filename);
   return { __filename, __dirname };
 }
+
+export type WatchEvent = "add" | "addDir" | "change" | "unlink" | "unlinkDir";
+
+export const DEFAULT_IGNORES: (string | RegExp)[] = [
+  /(^|[\/\\])\../, // dotfiles
+  "**/node_modules/**",
+  "**/vendor/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.cache/**",
+  "**/*.log",
+  "**/*.tmp",
+  "**/*.swp",
+];
+
+export const DEFAULT_AWF = { stabilityThreshold: 300, pollInterval: 100 };
+
+/**
+ * Create a chokidar watcher for a given root. Optionally filter by file extensions.
+ */
+export function createSrcWatcher(
+  root: string,
+  opts: {
+    exts?: string[]; // e.g. ['.php','.ts']
+    onEvent: (event: WatchEvent, absPath: string, relPath: string) => void;
+    ignored?: (string | RegExp)[];
+    awaitWriteFinish?: { stabilityThreshold: number; pollInterval: number };
+    logPrefix?: string;
+    usePolling?: boolean;
+    interval?: number;
+  }
+): FSWatcher {
+  const {
+    exts,
+    onEvent,
+    ignored = DEFAULT_IGNORES,
+    awaitWriteFinish = DEFAULT_AWF,
+    logPrefix = "watch",
+    usePolling = true,
+  } = opts;
+
+  const watcher = chokidar.watch(root, {
+    ignoreInitial: true,
+    persistent: true,
+    ignored,
+    awaitWriteFinish,
+    usePolling,
+    interval: opts.interval ?? 1000,
+  });
+
+  watcher
+    .on("ready", () => {
+      console.log(`[${logPrefix}] Watching ${root.replace(/\\/g, "/")}/**/*`);
+    })
+    .on("all", (event: WatchEvent, filePath: string) => {
+      // Optional extension filter
+      if (exts && exts.length > 0) {
+        const ok = exts.some((ext) => filePath.endsWith(ext));
+        if (!ok) return;
+      }
+      const rel = relative(root, filePath).replace(/\\/g, "/");
+      if (event === "add" || event === "change" || event === "unlink") {
+        onEvent(event, filePath, rel);
+      }
+    })
+    .on("error", (err) => console.error(`[${logPrefix}] Error:`, err));
+
+  return watcher;
+}
+
+/**
+ * Debounced worker that ensures only one run at a time; extra runs get queued once.
+ */
+export class DebouncedWorker {
+  private timer: NodeJS.Timeout | null = null;
+  private running = false;
+  private queued = false;
+
+  constructor(
+    private work: () => Promise<void> | void,
+    private debounceMs = 350,
+    private name = "worker"
+  ) {}
+
+  schedule(reason?: string) {
+    if (reason) console.log(`[${this.name}] ${reason} → scheduled`);
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.runNow().catch(() => {});
+    }, this.debounceMs);
+  }
+
+  private async runNow() {
+    if (this.running) {
+      this.queued = true;
+      return;
+    }
+    this.running = true;
+    try {
+      await this.work();
+    } catch (err) {
+      console.error(`[${this.name}] error:`, err);
+    } finally {
+      this.running = false;
+      if (this.queued) {
+        this.queued = false;
+        this.runNow().catch(() => {});
+      }
+    }
+  }
+}
+
+/**
+ * Cross-platform restartable process.
+ */
+export function createRestartableProcess(spec: {
+  name: string;
+  cmd: string;
+  args?: string[];
+  stdio?: "inherit" | [any, any, any];
+  gracefulSignal?: NodeJS.Signals;
+  forceKillAfterMs?: number;
+  windowsKillTree?: boolean;
+  onStdout?: (buf: Buffer) => void;
+  onStderr?: (buf: Buffer) => void;
+}) {
+  const {
+    name,
+    cmd,
+    args = [],
+    stdio = ["ignore", "pipe", "pipe"],
+    gracefulSignal = "SIGINT",
+    forceKillAfterMs = 2000,
+    windowsKillTree = true,
+    onStdout,
+    onStderr,
+  } = spec;
+
+  let child: ChildProcess | null = null;
+
+  function start() {
+    console.log(`[${name}] Starting: ${cmd} ${args.join(" ")}`.trim());
+    child = spawn(cmd, args, { stdio, windowsHide: true });
+
+    child.stdout?.on("data", (buf: Buffer) => {
+      if (onStdout) onStdout(buf);
+      else process.stdout.write(`[${name}] ${buf.toString()}`);
+    });
+
+    child.stderr?.on("data", (buf: Buffer) => {
+      if (onStderr) onStderr(buf);
+      else process.stderr.write(`[${name}:err] ${buf.toString()}`);
+    });
+
+    child.on("close", (code) => {
+      console.log(`[${name}] Exited with code ${code}`);
+    });
+
+    child.on("error", (err) => {
+      console.error(`[${name}] Failed to start:`, err);
+    });
+
+    return child;
+  }
+
+  function killOnWindows(pid: number): Promise<void> {
+    return new Promise((resolve) => {
+      const cp = execFile("taskkill", ["/F", "/T", "/PID", String(pid)], () =>
+        resolve()
+      );
+      cp.on("error", () => resolve());
+    });
+  }
+
+  async function stop(): Promise<void> {
+    if (!child || child.killed) return;
+    const pid = child.pid!;
+    console.log(`[${name}] Stopping…`);
+
+    if (process.platform === "win32" && windowsKillTree) {
+      await killOnWindows(pid);
+      child = null;
+      return;
+    }
+
+    await new Promise<void>((resolve) => {
+      const done = () => resolve();
+      child!.once("close", done).once("exit", done).once("disconnect", done);
+      try {
+        child!.kill(gracefulSignal);
+      } catch {
+        resolve();
+      }
+      setTimeout(() => {
+        if (child && !child.killed) {
+          try {
+            process.kill(pid, "SIGKILL");
+          } catch {}
+        }
+      }, forceKillAfterMs);
+    });
+    child = null;
+  }
+
+  async function restart(reason?: string) {
+    if (reason) console.log(`[${name}] Restart requested: ${reason}`);
+    await stop();
+    return start();
+  }
+
+  function getChild() {
+    return child;
+  }
+
+  return { start, stop, restart, getChild };
+}
+
+/**
+ * Register shutdown cleanup callbacks.
+ */
+export function onExit(fn: () => Promise<void> | void) {
+  const wrap = (sig: string) => async () => {
+    console.log(`[proc] Received ${sig}, shutting down…`);
+    try {
+      await fn();
+    } finally {
+      process.exit(0);
+    }
+  };
+  process.on("SIGINT", wrap("SIGINT"));
+  process.on("SIGTERM", wrap("SIGTERM"));
+  process.on("uncaughtException", async (err) => {
+    console.error("[proc] Uncaught exception:", err);
+    await wrap("uncaughtException")();
+  });
+}