create-prisma-php-app 3.5.4 → 3.6.1

package/dist/settings/auto-swagger-docs.ts

@@ -323,18 +323,153 @@ function generateSwaggerAnnotation(modelName: string, fields: Field[]): string {
  */`;
 }
 
-// Function to generate dynamic ID validation logic for update and find-by-ID routes
-function generateIdValidationLogic(idField: any) {
-  const fieldType = idField.type.toLowerCase();
+function isRequiredOnCreate(field: Field): boolean {
+  // Required if Prisma says required AND no DB default AND not generated/readOnly/updatedAt/id
+  return (
+    field.isRequired &&
+    !field.hasDefaultValue &&
+    !field.isGenerated &&
+    !field.isUpdatedAt &&
+    !field.isId &&
+    !field.isReadOnly
+  );
+}
+
+function phpRuleBodyForType(prismaTypeLower: string): string {
+  switch (prismaTypeLower) {
+    case "boolean":
+      return `
+        $b = Validator::boolean($v);
+        if ($b === null) return false;
+        $out = (bool)$b;
+        return true;`;
+
+    case "int":
+    case "bigint":
+      return `
+        $i = Validator::int($v);
+        if ($i === null) return false;
+        $out = $i;
+        return true;`;
+
+    case "float":
+      return `
+        $f = Validator::float($v);
+        if ($f === null) return false;
+        $out = $f;
+        return true;`;
+
+    case "decimal":
+      return `
+        $d = Validator::decimal($v);
+        if ($d === null) return false;
+        $out = (string)$d; // keep decimals canonical as string
+        return true;`;
+
+    case "datetime":
+      return `
+        $dt = Validator::dateTime($v, 'Y-m-d H:i:s');
+        if ($dt === null) return false;
+        $out = $dt;
+        return true;`;
+
+    case "json":
+      return `
+        if (is_string($v)) {
+          json_decode($v);
+          if (json_last_error() !== JSON_ERROR_NONE) return false;
+          $out = $v;
+          return true;
+        } else {
+          $enc = json_encode($v, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
+          if ($enc === false) return false;
+          $out = $enc;
+          return true;
+        }`;
+
+    case "uuid":
+      return `
+        $s = Validator::uuid($v);
+        if ($s === null) return false;
+        $out = $s;
+        return true;`;
+
+    case "cuid":
+      return `
+        $s = Validator::cuid($v);
+        if ($s === null) return false;
+        $out = $s;
+        return true;`;
+
+    case "cuid2":
+      return `
+        $s = Validator::cuid2($v);
+        if ($s === null) return false;
+        $out = $s;
+        return true;`;
+
+    case "string":
+    default:
+      return `
+        $s = Validator::string($v, false); // trim, no HTML escaping for DB
+        if ($s === '') return false;
+        $out = $s;
+        return true;`;
+  }
+}
+
+function generatePhpSchema(fields: Field[], forUpdate: boolean): string {
+  const entries = fields
+    .filter((f) => !shouldSkipField(f))
+    .map((f) => {
+      const t = f.type.toLowerCase();
+      const required = forUpdate ? false : isRequiredOnCreate(f);
+      const body = phpRuleBodyForType(t).trim();
+      return `  '${f.name}' => [
+    'type' => '${t}',
+    'required' => ${required ? "true" : "false"},
+    'validate' => function($v, &$out) {
+      ${body}
+    },
+  ]`;
+    })
+    .join(",\n");
+  return `[\n${entries}\n]`;
+}
 
-  if (["cuid", "uuid", "autoincrement"].includes(idField.default?.name)) {
+function idValidatorSnippet(idField: Field): string {
+  const t = idField.type.toLowerCase();
+  const def = (idField as any).default?.name?.toLowerCase?.() || "";
+
+  // numeric ids (int/bigint or autoincrement())
+  if (t === "int" || t === "bigint" || def === "autoincrement") {
+    return `
+$__id = Validator::int($id);
+if ($__id === null) { Boom::badRequest("Invalid ${idField.name}")->toResponse(); return; }
+$id = $__id;`;
+  }
+
+  // uuid() default or explicit UUID type
+  if (t === "uuid" || def === "uuid") {
     return `
-if (!Validator::${fieldType}($id)) {
-    Boom::badRequest("Invalid ${idField.name}")->toResponse();
-}`;
+if (Validator::uuid($id) === null) { Boom::badRequest("Invalid ${idField.name}")->toResponse(); return; }`;
   }
 
-  return ""; // No specific validation needed otherwise
+  // cuid() / cuid2() defaults
+  if (def === "cuid") {
+    return `
+if (Validator::cuid($id) === null) { Boom::badRequest("Invalid ${idField.name}")->toResponse(); return; }`;
+  }
+  if (def === "cuid2") {
+    return `
+if (Validator::cuid2($id) === null) { Boom::badRequest("Invalid ${idField.name}")->toResponse(); return; }`;
+  }
+
+  // fallback: non-empty string
+  return `
+$__id = Validator::string($id, false);
+if ($__id === '') { Boom::badRequest("Invalid ${idField.name}")->toResponse(); return; }
+$id = $__id;`;
 }
 
 // Function to generate endpoints for a model
@@ -372,7 +507,7 @@ function generateEndpoints(modelName: string, fields: any[]): void {
   const idDir = `${baseDir}/[id]`;
   mkdirSync(resolve(__dirname, `../${idDir}`), { recursive: true });
   const idRoutePath = `${idDir}/route.php`;
-  const idValidationLogic = generateIdValidationLogic(idField);
+  const idCheck = idValidatorSnippet(idField);
   const idRouteContent = `<?php
 
 use Lib\\Prisma\\Classes\\Prisma;
@@ -382,7 +517,7 @@ use Lib\\Request;
 
 $prisma = Prisma::getInstance();
 $id = Request::$dynamicParams->id ?? null;
-${idValidationLogic}
+${idCheck}
 
 $${camelCaseModelName} = $prisma->${camelCaseModelName}->findUnique([
     'where' => [
@@ -406,6 +541,8 @@ echo json_encode($${camelCaseModelName});`;
   mkdirSync(resolve(__dirname, `../${createDir}`), { recursive: true });
   const createRoutePath = `${createDir}/route.php`;
 
+  const createSchema = generatePhpSchema(fieldsToCreateAndUpdate, false);
+
   const createRouteContent = `<?php
 
 use Lib\\Prisma\\Classes\\Prisma;
@@ -415,56 +552,39 @@ use Lib\\Request;
 
 $prisma = Prisma::getInstance();
 
-// Define fields with their types, required status, and validation functions
-$fieldsWithTypesAndStatus = [
-${fieldsToCreateAndUpdate
-  .map(
-    (field) =>
-      `    '${field.name}' => [
-        'type' => '${field.type.toLowerCase()}', 
-        'required' => ${field.isRequired ? "true" : "false"}, 
-        'validate' => fn($value) => is_null($value) || $value === '' || Validator::${field.type.toLowerCase()}($value)
-    ]`
-  )
-  .join(",\n")}
-];
+/** Schema: type-aware validate + normalize */
+$schema = ${createSchema};
 
 $data = [];
-foreach ($fieldsWithTypesAndStatus as $field => $details) {
-    $isRequired = $details['required'];
-    $type = $details['type'];
-    $validationFn = $details['validate'];
-
-    // Check if the field is required and missing in the request
-    if ($isRequired && !isset(Request::$params->$field)) {
-        Boom::badRequest("Missing {$field}")->toResponse();
-    }
-
-    // Check if the field is present in the request
-    if (isset(Request::$params->$field)) {
-        $value = Request::$params->$field;
-
-        // Validate the field using the validation function
-        if (!$validationFn($value)) {
-            Boom::badRequest("Invalid {$field}", ["Expected type '{$type}'"])->toResponse();
+foreach ($schema as $field => $rule) {
+    $isRequired = $rule['required'] ?? false;
+
+    $has = is_object(Request::$params) && property_exists(Request::$params, $field);
+    if (!$has) {
+        if ($isRequired) {
+            Boom::badRequest("Missing {$field}")->toResponse();
+            return;
         }
+        continue;
+    }
 
-        // Assign the validated value to the data array
-        $data[$field] = $value;
+    $raw = Request::$params->$field;
+    $out = null;
+    if (!($rule['validate'])($raw, $out)) {
+        $type = $rule['type'] ?? 'unknown';
+        Boom::badRequest("Invalid {$field}", ["Expected type '{$type}'"])->toResponse();
+        return;
     }
+    $data[$field] = $out;
 }
 
-// Create the new record using the Prisma instance
-$new${modelName} = $prisma->${camelCaseModelName}->create([
-    'data' => $data
-]);
+$new${modelName} = $prisma->${camelCaseModelName}->create(['data' => $data]);
 
-// Handle potential internal server error
 if (!$new${modelName}) {
     Boom::internal()->toResponse();
+    return;
 }
 
-// Return the newly created record in JSON format
 echo json_encode($new${modelName});`;
 
   writeFileSync(
@@ -478,6 +598,8 @@ echo json_encode($new${modelName});`;
   mkdirSync(resolve(__dirname, `../${updateDir}`), { recursive: true });
   const updateRoutePath = `${updateDir}/route.php`;
 
+  const updateSchema = generatePhpSchema(fieldsToCreateAndUpdate, true);
+
   const updateRouteContent = `<?php
 
 use Lib\\Prisma\\Classes\\Prisma;
@@ -487,65 +609,44 @@ use Lib\\Request;
 
 $prisma = Prisma::getInstance();
 $id = Request::$dynamicParams->id ?? null;
+${idCheck}
 
-// Perform validation for the ID
-if (!Validator::int($id)) {
-  Boom::badRequest("Invalid id")->toResponse();
-}
-
-// Define fields with their types, required status, and validation functions
-$fieldsWithTypesAndStatus = [
-${fieldsToCreateAndUpdate
-  .map(
-    (field) =>
-      `    '${field.name}' => [
-        'type' => '${field.type.toLowerCase()}', 
-        'required' => ${field.isRequired ? "true" : "false"}, 
-        'validate' => fn($value) => is_null($value) || $value === '' || Validator::${field.type.toLowerCase()}($value)
-    ]`
-  )
-  .join(",\n")}
-];
-
+/** Partial update: nothing is required, but at least one field must be present */
+$schema = ${updateSchema};
 $data = [];
-foreach ($fieldsWithTypesAndStatus as $field => $details) {
-    $isRequired = $details['required'];
-    $type = $details['type'];
-    $validationFn = $details['validate'];
-
-    // Check if the field is required and missing in the request
-    if ($isRequired && !isset(Request::$params->$field)) {
-        Boom::badRequest("Missing {$field}")->toResponse();
+$any = false;
+
+foreach ($schema as $field => $rule) {
+    $has = is_object(Request::$params) && property_exists(Request::$params, $field);
+    if (!$has) continue;
+
+    $raw = Request::$params->$field;
+    $out = null;
+    if (!($rule['validate'])($raw, $out)) {
+        $type = $rule['type'] ?? 'unknown';
+        Boom::badRequest("Invalid {$field}", ["Expected type '{$type}'"])->toResponse();
+        return;
     }
+    $data[$field] = $out;
+    $any = true;
+}
 
-    // Check if the field is present in the request
-    if (isset(Request::$params->$field)) {
-        $value = Request::$params->$field;
-
-        // Validate the field using the validation function
-        if (!$validationFn($value)) {
-            Boom::badRequest("Invalid {$field}", ["Expected type '{$type}'"])->toResponse();
-        }
-
-        // Assign the validated value to the data array
-        $data[$field] = $value;
-    }
+if (!$any) {
+    Boom::badRequest("No fields to update")->toResponse();
+    return;
 }
 
-// Update the record
 $updated${modelName} = $prisma->${camelCaseModelName}->update([
   'where' => ['${idFieldName}' => $id],
-  'data' => $data,
+  'data'  => $data,
 ]);
 
-// Handle potential internal server error
 if (!$updated${modelName}) {
   Boom::notFound()->toResponse();
+  return;
 }
 
-// Return the updated record in JSON format
-echo json_encode($updated${modelName});
-`;
+echo json_encode($updated${modelName});`;
 
   writeFileSync(
     resolve(__dirname, `../${updateRoutePath}`),
@@ -566,7 +667,7 @@ use Lib\\Request;
 
 $prisma = Prisma::getInstance();
 $id = Request::$dynamicParams->id ?? null;
-${idValidationLogic}
+${idCheck}
 
 $deleted${modelName} = $prisma->${camelCaseModelName}->delete([
     'where' => [

package/dist/settings/bs-config.ts

@@ -1,6 +1,5 @@
 import { createProxyMiddleware } from "http-proxy-middleware";
 import { writeFileSync } from "fs";
-import chokidar from "chokidar";
 import browserSync, { BrowserSyncInstance } from "browser-sync";
 import prismaPhpConfigJson from "../prisma-php.json";
 import { generateFileListJson } from "./files-list.js";
@@ -14,75 +13,76 @@ import {
   updateComponentImports,
 } from "./class-imports";
 import { checkComponentImports } from "./component-import-checker";
+import { DebouncedWorker, createSrcWatcher, DEFAULT_AWF } from "./utils.js";
 
 const { __dirname } = getFileMeta();
 
 const bs: BrowserSyncInstance = browserSync.create();
 
-// Watch for file changes (create, delete, save)
-const watcher = chokidar.watch("src/app/**/*", {
-  ignored: /(^|[\/\\])\../, // Ignore dotfiles
-  persistent: true,
-  usePolling: true,
-  interval: 1000,
-});
+// ---------- Watcher (whole ./src) ----------
+const pipeline = new DebouncedWorker(
+  async () => {
+    await generateFileListJson();
+    await updateAllClassLogs();
+    await updateComponentImports();
 
-// On changes, generate file list and also update the class log
-const handleFileChange = async () => {
-  await generateFileListJson();
-  await updateAllClassLogs();
-  await updateComponentImports();
+    // Scan all PHP files in the whole SRC tree
+    const phpFiles = await getAllPhpFiles(SRC_DIR);
+    for (const file of phpFiles) {
+      const rawFileImports = await analyzeImportsInFile(file);
 
-  // Optionally, run the component check on each PHP file.
-  const phpFiles = await getAllPhpFiles(SRC_DIR + "/app");
-  for (const file of phpFiles) {
-    const rawFileImports = await analyzeImportsInFile(file);
-    // Convert Record<string, string> to Record<string, { className: string; filePath: string; importer?: string }[]>
-    const fileImports: Record<
-      string,
-      | { className: string; filePath: string; importer?: string }[]
-      | { className: string; filePath: string; importer?: string }
-    > = {};
-    for (const key in rawFileImports) {
-      if (typeof rawFileImports[key] === "string") {
-        fileImports[key] = [
-          {
-            className: key,
-            filePath: rawFileImports[key],
-          },
-        ];
-      } else {
-        fileImports[key] = rawFileImports[key];
+      // Normalize to array-of-objects shape expected by the checker
+      const fileImports: Record<
+        string,
+        { className: string; filePath: string; importer?: string }[]
+      > = {};
+      for (const key in rawFileImports) {
+        const v = rawFileImports[key];
+        fileImports[key] = Array.isArray(v)
+          ? v
+          : [{ className: key, filePath: v }];
       }
+      await checkComponentImports(file, fileImports);
     }
-    await checkComponentImports(file, fileImports);
-  }
-};
+  },
+  350,
+  "bs-pipeline"
+);
 
-// Perform specific actions for file events
-watcher
-  .on("add", handleFileChange)
-  .on("change", handleFileChange)
-  .on("unlink", handleFileChange);
+// watch the entire src; we don’t need an extension filter here
+createSrcWatcher(join(SRC_DIR, "**", "*"), {
+  onEvent: (_ev, _abs, rel) => pipeline.schedule(rel),
+  awaitWriteFinish: DEFAULT_AWF,
+  logPrefix: "watch",
+  usePolling: true,
+  interval: 1000,
+});
 
-// BrowserSync initialization
+// ---------- BrowserSync ----------
 bs.init(
   {
+    /**
+     * Proxy your PHP app (from prisma-php.json).
+     * Use object form to enable WebSocket proxying.
+     */
     proxy: "http://localhost:3000",
+
     middleware: [
-      (_: any, res: any, next: any) => {
+      (_req, res, next) => {
         res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
         res.setHeader("Pragma", "no-cache");
         res.setHeader("Expires", "0");
         next();
       },
+
       createProxyMiddleware({
         target: prismaPhpConfigJson.bsTarget,
         changeOrigin: true,
         pathRewrite: {},
       }),
     ],
-    files: "src/**/*.*",
+
+    files: `${SRC_DIR}/**/*.*`, // still do file-level reloads as a safety net
     notify: false,
     open: false,
     ghostMode: false,
@@ -98,24 +98,19 @@ bs.init(
       return;
     }
 
-    // Retrieve the active URLs from the BrowserSync instance
-    const options = bsInstance.getOption("urls");
-    const localUrl = options.get("local");
-    const externalUrl = options.get("external");
-    const uiUrl = options.get("ui");
-    const uiExternalUrl = options.get("ui-external");
-
-    // Construct the URLs dynamically
-    const urls = {
-      local: localUrl,
-      external: externalUrl,
-      ui: uiUrl,
-      uiExternal: uiExternalUrl,
+    // Write live URLs for other tooling
+    const urls = bsInstance.getOption("urls");
+    const out = {
+      local: urls.get("local"),
+      external: urls.get("external"),
+      ui: urls.get("ui"),
+      uiExternal: urls.get("ui-external"),
     };
 
     writeFileSync(
       join(__dirname, "bs-config.json"),
-      JSON.stringify(urls, null, 2)
+      JSON.stringify(out, null, 2)
     );
+    console.log("\n\x1b[90mPress Ctrl+C to stop.\x1b[0m\n");
   }
 );

package/dist/settings/project-name.ts

@@ -5,6 +5,7 @@ import { getFileMeta } from "./utils.js";
 import { promises as fsPromises } from "fs";
 import { updateAllClassLogs } from "./class-log";
 import { updateComponentImports } from "./class-imports";
+import { generateFileListJson } from "./files-list";
 
 const { __dirname } = getFileMeta();
 
@@ -147,6 +148,7 @@ export const dirsToDelete = [
   join(__dirname, "..", ".pphp"),
 ];
 
+await generateFileListJson();
 await deleteFilesIfExist(filesToDelete);
 await deleteDirectoriesIfExist(dirsToDelete);
 await updateAllClassLogs();

package/dist/settings/restart-mcp.ts

@@ -0,0 +1,58 @@
+import { join } from "path";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+import {
+  createRestartableProcess,
+  createSrcWatcher,
+  DebouncedWorker,
+  DEFAULT_AWF,
+  onExit,
+} from "./utils.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const phpPath = process.env.PHP_PATH || "php";
+const serverScriptPath = join(
+  __dirname,
+  "..",
+  "src",
+  "Lib",
+  "MCP",
+  "mcp-server.php"
+);
+const watchRoot = join(__dirname, "..", "src");
+
+// Restartable MCP server
+const mcp = createRestartableProcess({
+  name: "MCP",
+  cmd: phpPath,
+  args: [serverScriptPath],
+  windowsKillTree: true,
+});
+
+mcp.start();
+
+// Debounced restarter
+const restarter = new DebouncedWorker(
+  async () => {
+    await mcp.restart("file change");
+  },
+  250,
+  "mcp-restart"
+);
+
+// Watch ./src for relevant changes
+createSrcWatcher(watchRoot, {
+  exts: [".php", ".ts", ".js", ".json"],
+  onEvent: (ev, _abs, rel) => restarter.schedule(`${ev}: ${rel}`),
+  awaitWriteFinish: DEFAULT_AWF,
+  logPrefix: "MCP watch",
+  usePolling: true,
+  interval: 1000,
+});
+
+// Graceful shutdown
+onExit(async () => {
+  await mcp.stop();
+});