create-prisma-php-app 1.26.503 → 1.26.504

package/dist/bootstrap.php

@@ -381,7 +381,11 @@ function checkForDuplicateRoutes()
     }
 
     if (!empty($errorMessages)) {
-        $errorMessageString = implode("<br>", $errorMessages);
+        if (isAjaxOrXFileRequestOrRouteFile()) {
+            $errorMessageString = implode("\n", $errorMessages);
+        } else {
+            $errorMessageString = implode("<br>", $errorMessages);
+        }
         modifyOutputLayoutForError($errorMessageString);
     }
 }
@@ -571,18 +575,36 @@ function modifyOutputLayoutForError($contentToAdd)
 
         $errorContent = $contentToAdd;
 
-        $layoutFile = APP_PATH . '/layout.php';
-        if (file_exists($layoutFile)) {
-
-            ob_start();
-            include_once $errorFile;
-            MainLayout::$children = ob_get_clean();
-            include $layoutFile;
+        if (isAjaxOrXFileRequestOrRouteFile()) {
+            header('Content-Type: application/json');
+            echo json_encode([
+                'success' => false,
+                'error' => $errorContent
+            ]);
+            http_response_code(403);
         } else {
-            echo $errorContent;
+            $layoutFile = APP_PATH . '/layout.php';
+            if (file_exists($layoutFile)) {
+
+                ob_start();
+                require_once $errorFile;
+                MainLayout::$children = ob_get_clean();
+                require_once $layoutFile;
+            } else {
+                echo $errorContent;
+            }
         }
     } else {
-        echo $contentToAdd;
+        if (isAjaxOrXFileRequestOrRouteFile()) {
+            header('Content-Type: application/json');
+            echo json_encode([
+                'success' => false,
+                'error' => $contentToAdd
+            ]);
+            http_response_code(403);
+        } else {
+            echo $contentToAdd;
+        }
     }
     exit;
 }
@@ -646,21 +668,34 @@ function authenticateUserToken()
 }
 
 set_exception_handler(function ($exception) {
-    $errorContent = "<div class='error'>Exception: " . htmlspecialchars($exception->getMessage(), ENT_QUOTES, 'UTF-8') . "</div>";
+    if (isAjaxOrXFileRequestOrRouteFile()) {
+        $errorContent = "Exception: " . $exception->getMessage();
+    } else {
+        $errorContent = "<div class='error'>Exception: " . htmlspecialchars($exception->getMessage(), ENT_QUOTES, 'UTF-8') . "</div>";
+    }
     modifyOutputLayoutForError($errorContent);
 });
 
 register_shutdown_function(function () {
     $error = error_get_last();
     if ($error !== null && in_array($error['type'], [E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR, E_RECOVERABLE_ERROR])) {
-        $formattedError = "<div class='error'>Fatal Error: " . htmlspecialchars($error['message'], ENT_QUOTES, 'UTF-8') .
-            " in " . htmlspecialchars($error['file'], ENT_QUOTES, 'UTF-8') .
-            " on line " . $error['line'] . "</div>";
-        $errorContent = $formattedError;
+
+        if (isAjaxOrXFileRequestOrRouteFile()) {
+            $errorContent = "Fatal Error: " . $error['message'] . " in " . $error['file'] . " on line " . $error['line'];
+        } else {
+            $errorContent = "<div class='error'>Fatal Error: " . htmlspecialchars($error['message'], ENT_QUOTES, 'UTF-8') .
+                " in " . htmlspecialchars($error['file'], ENT_QUOTES, 'UTF-8') .
+                " on line " . $error['line'] . "</div>";
+        }
         modifyOutputLayoutForError($errorContent);
     }
 });
 
+function isAjaxOrXFileRequestOrRouteFile(): bool
+{
+    return Request::$isAjax || Request::$isXFileRequest || Request::$fileToInclude === 'route.php';
+}
+
 try {
     $_determineContentToInclude = determineContentToInclude();
     $_contentToInclude = $_determineContentToInclude['path'] ?? '';
@@ -800,24 +835,42 @@ try {
         }
     } else {
         if ($_isContentIncluded) {
-            echo "<div class='error'>The parent layout file does not contain &lt;?php echo MainLayout::\$children; ?&gt; Or &lt;?= MainLayout::\$children ?&gt;<br>" . "<strong>$_parentLayoutPath</strong></div>";
+            if (isAjaxOrXFileRequestOrRouteFile()) {
+                $_errorDetails = "The layout file does not contain &lt;?php echo MainLayout::\$childLayoutChildren; ?&gt; or &lt;?= MainLayout::\$childLayoutChildren ?&gt;<br><strong>$layoutPath</strong>";
+            } else {
+                $_errorDetails = "<div class='error'>The parent layout file does not contain &lt;?php echo MainLayout::\$children; ?&gt; Or &lt;?= MainLayout::\$children ?&gt;<br>" . "<strong>$_parentLayoutPath</strong></div>";
+            }
+            modifyOutputLayoutForError($_errorDetails);
         } else {
-            $_errorDetails = "<div class='error'>The layout file does not contain &lt;?php echo MainLayout::\$childLayoutChildren; ?&gt; or &lt;?= MainLayout::\$childLayoutChildren ?&gt;<br><strong>$layoutPath</strong></div>";
+            if (isAjaxOrXFileRequestOrRouteFile()) {
+                $_errorDetails = "The layout file does not contain &lt;?php echo MainLayout::\$childLayoutChildren; ?&gt; or &lt;?= MainLayout::\$childLayoutChildren ?&gt;<br><strong>$layoutPath</strong>";
+            } else {
+                $_errorDetails = "<div class='error'>The layout file does not contain &lt;?php echo MainLayout::\$childLayoutChildren; ?&gt; or &lt;?= MainLayout::\$childLayoutChildren ?&gt;<br><strong>$layoutPath</strong></div>";
+            }
             modifyOutputLayoutForError($_errorDetails);
         }
     }
 } catch (Throwable $e) {
-    $_errorDetails = "Unhandled Exception: " . htmlspecialchars($e->getMessage(), ENT_QUOTES, 'UTF-8');
-    $_errorDetails .= "<br>File: " . htmlspecialchars($e->getFile(), ENT_QUOTES, 'UTF-8');
-    $_errorDetails .= "<br>Line: " . htmlspecialchars($e->getLine(), ENT_QUOTES, 'UTF-8');
-    $_errorDetails = "<div class='error'>$_errorDetails</div>";
+    if (isAjaxOrXFileRequestOrRouteFile()) {
+        $_errorDetails = "Unhandled Exception: " . $e->getMessage() . " in " . $e->getFile() . " on line " . $e->getLine();
+    } else {
+        $_errorDetails = "Unhandled Exception: " . htmlspecialchars($e->getMessage(), ENT_QUOTES, 'UTF-8');
+        $_errorDetails .= "<br>File: " . htmlspecialchars($e->getFile(), ENT_QUOTES, 'UTF-8');
+        $_errorDetails .= "<br>Line: " . htmlspecialchars($e->getLine(), ENT_QUOTES, 'UTF-8');
+        $_errorDetails = "<div class='error'>$_errorDetails</div>";
+    }
     modifyOutputLayoutForError($_errorDetails);
 }
 
 (function () {
     $lastErrorCapture = error_get_last();
     if ($lastErrorCapture !== null) {
-        $errorContent = "<div class='error'>Error: " . $lastErrorCapture['message'] . " in " . $lastErrorCapture['file'] . " on line " . $lastErrorCapture['line'] . "</div>";
+
+        if (isAjaxOrXFileRequestOrRouteFile()) {
+            $errorContent = "Error: " . $lastErrorCapture['message'] . " in " . $lastErrorCapture['file'] . " on line " . $lastErrorCapture['line'];
+        } else {
+            $errorContent = "<div class='error'>Error: " . $lastErrorCapture['message'] . " in " . $lastErrorCapture['file'] . " on line " . $lastErrorCapture['line'] . "</div>";
+        }
         modifyOutputLayoutForError($errorContent);
     }
 })();
@@ -829,7 +882,11 @@ set_error_handler(function ($severity, $message, $file, $line) {
     }
 
     // Capture the specific severity types, including warnings (E_WARNING)
-    $errorContent = "<div class='error'>Error: {$severity} - {$message} in {$file} on line {$line}</div>";
+    if (isAjaxOrXFileRequestOrRouteFile()) {
+        $errorContent = "Error: {$severity} - {$message} in {$file} on line {$line}";
+    } else {
+        $errorContent = "<div class='error'>Error: {$message} in {$file} on line {$line}</div>";
+    }
 
     // If needed, log it or output immediately based on severity
     if ($severity === E_WARNING || $severity === E_NOTICE) {

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

@@ -7,12 +7,145 @@ import { swaggerConfig } from "./swagger-config.js";
 import { getFileMeta } from "./utils.js";
 import prismaSchemaConfigJson from "./prisma-schema-config.json";
 import prompts from "prompts";
+import { exit } from "process";
 
 const { __dirname } = getFileMeta();
 const prismaSchemaJsonPath = resolve(__dirname, "./prisma-schema.json");
 
+type PrismaSchemaConfig = {
+  swaggerDocsDir: string;
+  skipDefaultName: string[];
+  skipByPropertyValue: Record<string, boolean>;
+  skipFields: string[];
+  generateEndpoints: boolean;
+  generatePhpClasses: boolean;
+};
+
+type Field = {
+  name: string;
+  kind: string;
+  isList: boolean;
+  isRequired: boolean;
+  isUnique: boolean;
+  isId: boolean;
+  isReadOnly: boolean;
+  hasDefaultValue: boolean;
+  type: string;
+  isGenerated: boolean;
+  isUpdatedAt: boolean;
+  default?: {
+    name: string;
+    args: any[];
+  };
+};
+
+function shouldSkipField(field: Field): boolean {
+  const config: PrismaSchemaConfig = prismaSchemaConfigJson;
+
+  if (field.kind === "object") {
+    return true;
+  }
+
+  // Skip fields that are explicitly marked to be skipped by name
+  if (config.skipFields && config.skipFields.includes(field.name)) {
+    return true;
+  }
+
+  // Skip fields based on specific property values defined in skipByPropertyValue
+  for (const [property, value] of Object.entries(config.skipByPropertyValue)) {
+    if ((field as any)[property] === value) {
+      return true;
+    }
+  }
+
+  // Skip ID fields with auto-creation during creation
+  if (config.skipDefaultName.includes(field.default?.name || "")) {
+    return true;
+  }
+
+  return false;
+}
+
+// Function to determine an appropriate example based on the field type for Prisma ORM
+function getExampleValue(field: Field): any {
+  const fieldType = field.type.toLowerCase();
+
+  if (field.isId) {
+    // Provide examples based on common ID types
+    if (field.hasDefaultValue) {
+      switch (field.default?.name.toLowerCase()) {
+        case "uuid(4)":
+          return `"123e4567-e89b-12d3-a456-426614174000"`; // Example for UUID IDs
+        case "cuid":
+          return `"cjrscj5d40002s6s0b6nq9jfg"`; // Example for CUID IDs
+        case "autoincrement":
+          return 1; // Example for auto-increment IDs
+        default:
+          return `"${field.name}"`; // Default example for unknown ID types
+      }
+    } else {
+      switch (fieldType) {
+        case "int":
+        case "bigint":
+          return 123; // Example for integer and BigInt IDs
+        default:
+          return `"${field.name}"`; // Default example for unknown ID types
+      }
+    }
+  }
+
+  // Example values for other field types
+  switch (fieldType) {
+    case "int":
+    case "bigint":
+      return 123; // Example for integer and BigInt types
+    case "float":
+    case "decimal":
+      return 123.45; // Example for floating-point types
+    case "boolean":
+      return true; // Example for boolean types
+    case "string":
+      return `"${field.name}"`; // Example for string types
+    case "datetime":
+      return `"2024-01-01T00:00:00Z"`; // Example for date/time types
+    case "json":
+      return `{"key": "value"}`; // Example for JSON type
+    case "uuid":
+      return `"123e4567-e89b-12d3-a456-426614174000"`; // Example for UUID type
+    case "cuid":
+      return `"cjrscj5d40002s6s0b6nq9jfg"`; // Example for CUID type
+    default:
+      return `"${field.name}"`; // Default example for unrecognized types
+  }
+}
+
+/**
+ * Convert a Prisma field type to a Swagger-supported type.
+ * @param prismaType The type of the field as defined in the Prisma schema
+ * @returns A Swagger-compatible type
+ */
+function convertPrismaTypeToSwaggerType(prismaType: string): string {
+  // Map Prisma types to Swagger-compatible types
+  const typeMapping: Record<string, string> = {
+    String: "string",
+    Int: "integer",
+    BigInt: "integer",
+    Float: "number",
+    Decimal: "number",
+    Boolean: "boolean",
+    DateTime: "string", // For Swagger, we use "string" with format date-time
+    Json: "object",
+    UUID: "string",
+    CUID: "string",
+    Bytes: "string", // Can be represented as base64 strings in Swagger
+  };
+
+  // Default to "string" if the type is not found in the mapping
+  return typeMapping[prismaType] || "string";
+}
+
 // Function to generate properties for Swagger annotations
-function generateProperties(fields: any[]): {
+function generateProperties(fields: Field[]): {
   properties: string;
   allProperties: string;
 } {
@@ -24,24 +157,21 @@ function generateProperties(fields: any[]): {
       return;
     }
 
-    const example = field.example || (field.isId ? 1 : `"${field.name}"`);
+    const example = getExampleValue(field);
+    const fieldType = convertPrismaTypeToSwaggerType(field.type); // Convert Prisma type to Swagger type
     allProperties += `
-   *                   ${field.name}:
-   *                     type: ${field.type.toLowerCase()}
-   *                     example: ${example}`;
+ *                   ${field.name}:
+ *                     type: ${fieldType}
+ *                     example: ${example}`;
 
-    if (prismaSchemaConfigJson.skipFields.includes(field.name)) {
-      return;
-    }
-
-    if (prismaSchemaConfigJson.skipDefaultName.includes(field.default?.name)) {
+    if (shouldSkipField(field)) {
       return;
     }
 
     properties += `
-   *                   ${field.name}:
-   *                     type: ${field.type.toLowerCase()}
-   *                     example: ${example}`;
+ *                   ${field.name}:
+ *                     type: ${fieldType}
+ *                     example: ${example}`;
   });
 
   return { properties, allProperties };
@@ -54,170 +184,143 @@ function toKebabCase(str: string): string {
     .toLowerCase();
 }
 
+// Function to find the ID field from the model
+function getIdField(fields: Field[]): Field | undefined {
+  return fields.find((field) => field.isId);
+}
+
 // Function to generate Swagger annotation for a CRUD operation
-function generateSwaggerAnnotation(modelName: string, fields: any[]): string {
+function generateSwaggerAnnotation(modelName: string, fields: Field[]): string {
+  // Extract the ID field dynamically
+  const idField = getIdField(fields);
+  if (!idField) {
+    throw new Error(`No ID field found for model: ${modelName}`);
+  }
+
+  const idFieldName = idField.name;
+  const idFieldType = convertPrismaTypeToSwaggerType(idField.type); // Convert Prisma type to Swagger type
   const { properties, allProperties } = generateProperties(fields);
   const kebabCaseModelName = toKebabCase(modelName);
 
   return `/**
-   * @swagger
-   * tags:
-   *   name: ${modelName}
-   *   description: ${modelName} management API
-   */
-  
-  /**
-   * @swagger
-   * /${kebabCaseModelName}:
-   *   get:
-   *     summary: Retrieve a list of ${modelName}
-   *     tags:
-   *       - ${modelName}
-   *     responses:
-   *       200:
-   *         description: A list of ${modelName}
-   *         content:
-   *           application/json:
-   *             schema:
-   *               type: array
-   *               items:
-   *                 type: object
-   *                 properties:${allProperties}
-   */
-  
-  /**
-   * @swagger
-   * /${kebabCaseModelName}/{id}:
-   *   get:
-   *     summary: Retrieve a single ${modelName} by ID
-   *     tags:
-   *       - ${modelName}
-   *     parameters:
-   *       - in: path
-   *         name: id
-   *         required: true
-   *         description: The ${modelName} ID
-   *         schema:
-   *           type: string
-   *     responses:
-   *       200:
-   *         description: A single ${modelName} object
-   *         content:
-   *           application/json:
-   *             schema:
-   *               type: object
-   *               properties:${allProperties}
-   *       404:
-   *         description: ${modelName} not found
-   */
-  
-  /**
-   * @swagger
-   * /${kebabCaseModelName}/create:
-   *   post:
-   *     summary: Create a new ${modelName}
-   *     tags:
-   *       - ${modelName}
-   *     requestBody:
-   *       required: true
-   *       content:
-   *         application/json:
-   *           schema:
-   *             type: object
-   *             properties:${properties}
-   *     responses:
-   *       201:
-   *         description: ${modelName} created successfully.
-   */
-  
-  /**
-   * @swagger
-   * /${kebabCaseModelName}/update/{id}:
-   *   put:
-   *     summary: Update a ${modelName} by ID
-   *     tags:
-   *       - ${modelName}
-   *     parameters:
-   *       - in: path
-   *         name: id
-   *         required: true
-   *         description: The ${modelName} ID
-   *         schema:
-   *           type: string
-   *     requestBody:
-   *       required: true
-   *       content:
-   *         application/json:
-   *           schema:
-   *             type: object
-   *             properties:${properties}
-   *     responses:
-   *       200:
-   *         description: ${modelName} updated successfully.
-   *       404:
-   *         description: ${modelName} not found
-   */
-  
-  /**
-   * @swagger
-   * /${kebabCaseModelName}/delete/{id}:
-   *   delete:
-   *     summary: Delete a ${modelName} by ID
-   *     tags:
-   *       - ${modelName}
-   *     parameters:
-   *       - in: path
-   *         name: id
-   *         required: true
-   *         description: The ${modelName} ID
-   *         schema:
-   *           type: string
-   *     responses:
-   *       204:
-   *         description: ${modelName} successfully deleted
-   *       404:
-   *         description: ${modelName} not found
-   */
-  `;
-}
-
-// Function to generate dynamic validation rules and request payloads
-function generateValidationAndPayload(fields: any[]) {
-  let validations = "";
-  let payload = "";
-  let variableAssignments = "";
-
-  fields.forEach((field) => {
-    if (field.kind === "object") return; // Skip relations for now
-
-    // Skip fields that are explicitly marked to be skipped
-    if (prismaSchemaConfigJson.skipFields.includes(field.name)) {
-      return;
-    }
-
-    // Skip ID fields with auto-creation during creation
-    if (prismaSchemaConfigJson.skipDefaultName.includes(field.default?.name)) {
-      return;
-    }
-
-    // Define variable assignments
-    const variableName = field.name;
-    variableAssignments += `$${variableName} = Request::$params->${variableName} ?? null;\n`;
-
-    // Dynamic validation for required fields (excluding skipped fields)
-    if (field.isRequired) {
-      const fieldType = field.type.toLowerCase();
-      validations += `
-if (!Validator::${fieldType}($${variableName})) {
-    Boom::badRequest("Invalid ${variableName}")->toResponse();
-}`;
-    }
-
-    // Prepare payload dynamically
-    payload += `'${variableName}' => $${variableName},\n        `;
-  });
-
-  return { validations, payload, variableAssignments };
+ * @swagger
+ * tags:
+ *   name: ${modelName}
+ *   description: ${modelName} management API
+ */
+
+/**
+ * @swagger
+ * /${kebabCaseModelName}:
+ *   get:
+ *     summary: Retrieve a list of ${modelName}
+ *     tags:
+ *       - ${modelName}
+ *     responses:
+ *       200:
+ *         description: A list of ${modelName}
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: array
+ *               items:
+ *                 type: object
+ *                 properties:${allProperties}
+ */
+
+/**
+ * @swagger
+ * /${kebabCaseModelName}/{${idFieldName}}:
+ *   get:
+ *     summary: Retrieve a single ${modelName} by ${idFieldName}
+ *     tags:
+ *       - ${modelName}
+ *     parameters:
+ *       - in: path
+ *         name: ${idFieldName}
+ *         required: true
+ *         description: The ${modelName} ${idFieldName}
+ *         schema:
+ *           type: ${idFieldType}
+ *     responses:
+ *       200:
+ *         description: A single ${modelName} object
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:${allProperties}
+ *       404:
+ *         description: ${modelName} not found
+ */
+
+/**
+ * @swagger
+ * /${kebabCaseModelName}/create:
+ *   post:
+ *     summary: Create a new ${modelName}
+ *     tags:
+ *       - ${modelName}
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             properties:${properties}
+ *     responses:
+ *       201:
+ *         description: ${modelName} created successfully.
+ */
+
+/**
+ * @swagger
+ * /${kebabCaseModelName}/update/{${idFieldName}}:
+ *   put:
+ *     summary: Update a ${modelName} by ${idFieldName}
+ *     tags:
+ *       - ${modelName}
+ *     parameters:
+ *       - in: path
+ *         name: ${idFieldName}
+ *         required: true
+ *         description: The ${modelName} ${idFieldName}
+ *         schema:
+ *           type: ${idFieldType}
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             properties:${properties}
+ *     responses:
+ *       200:
+ *         description: ${modelName} updated successfully.
+ *       404:
+ *         description: ${modelName} not found
+ */
+
+/**
+ * @swagger
+ * /${kebabCaseModelName}/delete/{${idFieldName}}:
+ *   delete:
+ *     summary: Delete a ${modelName} by ${idFieldName}
+ *     tags:
+ *       - ${modelName}
+ *     parameters:
+ *       - in: path
+ *         name: ${idFieldName}
+ *         required: true
+ *         description: The ${modelName} ${idFieldName}
+ *         schema:
+ *           type: ${idFieldType}
+ *     responses:
+ *       204:
+ *         description: ${modelName} successfully deleted
+ *       404:
+ *         description: ${modelName} not found
+ */`;
 }
 
 // Function to generate dynamic ID validation logic for update and find-by-ID routes
@@ -241,6 +344,10 @@ function generateEndpoints(modelName: string, fields: any[]): void {
     modelName.charAt(0).toLowerCase() + modelName.slice(1);
   const baseDir = `src/app/${kebabCasedModelName}`;
   const idField = fields.find((field) => field.isId);
+  const fieldsToCreateAndUpdate = fields.filter(
+    (field) => shouldSkipField(field) === false
+  );
+  const idFieldName = idField.name;
   const baseDirPath = resolve(__dirname, `../${baseDir}`);
 
   mkdirSync(baseDirPath, { recursive: true });
@@ -279,7 +386,7 @@ ${idValidationLogic}
 
 $${camelCaseModelName} = $prisma->${camelCaseModelName}->findUnique([
     'where' => [
-        'id' => $id
+        '${idFieldName}' => $id
     ]
 ]);
 
@@ -295,15 +402,10 @@ echo json_encode($${camelCaseModelName});`;
   );
 
   // Endpoint: POST /{kebabCasedModelName}/create
-  const {
-    validations: createValidations,
-    payload: createPayload,
-    variableAssignments,
-  } = generateValidationAndPayload(fields);
-
   const createDir = `${baseDir}/create`;
   mkdirSync(resolve(__dirname, `../${createDir}`), { recursive: true });
   const createRoutePath = `${createDir}/route.php`;
+
   const createRouteContent = `<?php
 
 use Lib\\Prisma\\Classes\\Prisma;
@@ -312,26 +414,57 @@ use Lib\\Headers\\Boom;
 use Lib\\Request;
 
 $prisma = Prisma::getInstance();
-${
-  variableAssignments.length > 0
-    ? variableAssignments
-    : "// Your custom variable assignments here"
-}
-${
-  createValidations.length > 0
-    ? createValidations
-    : "\n// Your custom validation logic here"
+
+// 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")}
+];
+
+$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();
+        }
+
+        // Assign the validated value to the data array
+        $data[$field] = $value;
+    }
 }
 
+// Create the new record using the Prisma instance
 $new${modelName} = $prisma->${camelCaseModelName}->create([
-    'data' => [
-        ${createPayload}
-    ]
+    'data' => $data
 ]);
 
+// Handle potential internal server error
 if (!$new${modelName}) {
     Boom::internal()->toResponse();
 }
+
+// Return the newly created record in JSON format
 echo json_encode($new${modelName});`;
 
   writeFileSync(
@@ -341,12 +474,10 @@ echo json_encode($new${modelName});`;
   );
 
   // Endpoint: PUT /{kebabCasedModelName}/update/{id}
-  const { validations: updateValidations, payload: updatePayload } =
-    generateValidationAndPayload(fields);
-
   const updateDir = `${baseDir}/update/[id]`;
   mkdirSync(resolve(__dirname, `../${updateDir}`), { recursive: true });
   const updateRoutePath = `${updateDir}/route.php`;
+
   const updateRouteContent = `<?php
 
 use Lib\\Prisma\\Classes\\Prisma;
@@ -356,29 +487,65 @@ use Lib\\Request;
 
 $prisma = Prisma::getInstance();
 $id = Request::$dynamicParams->id ?? null;
-${
-  variableAssignments.length > 0
-    ? variableAssignments
-    : "// Your custom variable assignments here"
+
+// Perform validation for the ID
+if (!Validator::int($id)) {
+  Boom::badRequest("Invalid id")->toResponse();
 }
-${idValidationLogic}
-${
-  updateValidations.length > 0
-    ? updateValidations
-    : "\n// Your custom validation logic here"
+
+// 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")}
+];
+
+$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();
+        }
+
+        // Assign the validated value to the data array
+        $data[$field] = $value;
+    }
 }
 
+// Update the record
 $updated${modelName} = $prisma->${camelCaseModelName}->update([
-    'where' => ['id' => $id],
-    'data' => [
-        ${updatePayload}
-    ]
+  'where' => ['${idFieldName}' => $id],
+  'data' => $data,
 ]);
 
+// Handle potential internal server error
 if (!$updated${modelName}) {
-    Boom::notFound()->toResponse();
+  Boom::notFound()->toResponse();
 }
-echo json_encode($updated${modelName});`;
+
+// Return the updated record in JSON format
+echo json_encode($updated${modelName});
+`;
 
   writeFileSync(
     resolve(__dirname, `../${updateRoutePath}`),
@@ -403,7 +570,7 @@ ${idValidationLogic}
 
 $deleted${modelName} = $prisma->${camelCaseModelName}->delete([
     'where' => [
-        'id' => $id
+        '${idFieldName}' => $id
     ]
 ]);
 
@@ -421,6 +588,33 @@ echo json_encode($deleted${modelName});`;
 
 async function promptUserForGenerationOptions() {
   const response = await prompts([
+    {
+      type: "confirm",
+      name: "generateApisOnly",
+      message: "Do you want to generate swagger docs only?",
+      initial: false,
+    },
+  ]);
+
+  // If the user wants to generate only Swagger docs
+  if (response.generateApisOnly) {
+    // Update the configuration
+    prismaSchemaConfigJson.generateSwaggerDocsOnly = true;
+
+    // Save the updated settings back to the JSON file if needed
+    writeFileSync(
+      resolve(__dirname, "./prisma-schema-config.json"),
+      JSON.stringify(prismaSchemaConfigJson, null, 2),
+      "utf-8"
+    );
+
+    // Generate Swagger docs and exit
+    await swaggerConfig();
+    exit(0); // Exit the process here
+  }
+
+  // If the user did not select generateApisOnly, ask for other options
+  const otherResponses = await prompts([
     {
       type: "confirm",
       name: "generateEndpoints",
@@ -435,11 +629,12 @@ async function promptUserForGenerationOptions() {
     },
   ]);
 
-  // Update the configuration based on user input
-  prismaSchemaConfigJson.generateEndpoints = response.generateEndpoints;
-  prismaSchemaConfigJson.generatePhpClasses = response.generatePhpClasses;
+  // Update the configuration based on other responses
+  prismaSchemaConfigJson.generateSwaggerDocsOnly = false;
+  prismaSchemaConfigJson.generateEndpoints = otherResponses.generateEndpoints;
+  prismaSchemaConfigJson.generatePhpClasses = otherResponses.generatePhpClasses;
 
-  // Optionally, you can save the updated settings back to the JSON file
+  // Save the updated settings back to the JSON file
   writeFileSync(
     resolve(__dirname, "./prisma-schema-config.json"),
     JSON.stringify(prismaSchemaConfigJson, null, 2),

package/dist/settings/bs-config.ts

@@ -2,7 +2,7 @@ import { createProxyMiddleware } from "http-proxy-middleware";
 import { writeFileSync } from "fs";
 import chokidar from "chokidar";
 import browserSync, { BrowserSyncInstance } from "browser-sync";
-import prismaPhpConfig from "../prisma-php.json";
+import prismaPhpConfigJson from "../prisma-php.json";
 import { generateFileListJson } from "./files-list.js";
 import { join } from "path";
 import { getFileMeta } from "./utils.js";
@@ -43,7 +43,7 @@ bs.init(
         next();
       },
       createProxyMiddleware({
-        target: prismaPhpConfig.bsTarget,
+        target: prismaPhpConfigJson.bsTarget,
         changeOrigin: true,
         pathRewrite: {},
       }),

package/dist/settings/prisma-schema-config.json

@@ -1,7 +1,16 @@
 {
   "swaggerDocsDir": "src/app/swagger-docs/apis",
-  "skipDefaultName": ["autoincrement", "cuid", "uuid", "now"],
-  "skipFields": ["updatedAt"],
+  "skipDefaultName": [
+    "autoincrement",
+    "cuid",
+    "uuid",
+    "now"
+  ],
+  "skipByPropertyValue": {
+    "isUpdatedAt": true
+  },
+  "skipFields": [],
+  "generateSwaggerDocsOnly": true,
   "generateEndpoints": false,
-  "generatePhpClasses": true
-}
+  "generatePhpClasses": false
+}

package/dist/settings/project-name.ts

@@ -1,6 +1,6 @@
 import { existsSync, unlink, writeFile } from "fs";
 import { join, basename, dirname, normalize, sep } from "path";
-import prismaPhpConfig from "../prisma-php.json";
+import prismaPhpConfigJson from "../prisma-php.json";
 import { getFileMeta } from "./utils.js";
 
 const { __dirname } = getFileMeta();
@@ -15,20 +15,23 @@ function updateProjectNameInConfig(
   const filePathDir = dirname(filePath);
 
   // Update the projectName directly in the imported config
-  prismaPhpConfig.projectName = newProjectName;
+  prismaPhpConfigJson.projectName = newProjectName;
 
   // Update other paths
-  prismaPhpConfig.projectRootPath = filePathDir;
+  prismaPhpConfigJson.projectRootPath = filePathDir;
 
-  const targetPath = getTargetPath(filePathDir, prismaPhpConfig.phpEnvironment);
+  const targetPath = getTargetPath(
+    filePathDir,
+    prismaPhpConfigJson.phpEnvironment
+  );
 
-  prismaPhpConfig.bsTarget = `http://localhost${targetPath}`;
-  prismaPhpConfig.bsPathRewrite["^/"] = targetPath;
+  prismaPhpConfigJson.bsTarget = `http://localhost${targetPath}`;
+  prismaPhpConfigJson.bsPathRewrite["^/"] = targetPath;
 
   // Save the updated config back to the JSON file
   writeFile(
     filePath,
-    JSON.stringify(prismaPhpConfig, null, 2),
+    JSON.stringify(prismaPhpConfigJson, null, 2),
     "utf8",
     (err) => {
       if (err) {

package/dist/settings/swagger-config.ts

@@ -3,7 +3,8 @@ import { writeFileSync } from "fs";
 import { join } from "path";
 import chalk from "chalk";
 import { getFileMeta } from "./utils.js";
-import bsConnectionInfo from "./bs-config.json";
+import bsConfigJson from "./bs-config.json";
+import prismaPhpConfigJson from "../prisma-php.json";
 
 const { __dirname } = getFileMeta();
 
@@ -23,7 +24,7 @@ export async function swaggerConfig(): Promise<void> {
       },
       servers: [
         {
-          url: bsConnectionInfo.local, // For Development
+          url: bsConfigJson.local, // For Development
           description: "Development Server",
         },
         {
@@ -65,5 +66,5 @@ export async function swaggerConfig(): Promise<void> {
   }
 }
 
-// Call the function to generate the Swagger JSON
-swaggerConfig();
+if (prismaPhpConfigJson.swaggerDocs && !prismaPhpConfigJson.prisma)
+  swaggerConfig();

package/dist/src/Lib/Auth/Auth.php

@@ -13,10 +13,10 @@ use Lib\Request;
 
 class Auth
 {
-    public const PAYLOAD_NAME = 'role';
+    public const PAYLOAD_NAME = 'payload_name_8639D';
     public const ROLE_NAME = '';
-    public const PAYLOAD_SESSION_KEY = 'payload_2183A';
-    public const COOKIE_NAME = 'pphp_aut_token_D36E5';
+    public const PAYLOAD_SESSION_KEY = 'payload_session_key_2183A';
+    public const COOKIE_NAME = 'cookie_name_D36E5';
 
     private static ?Auth $instance = null;
     private const PPHPAUTH = 'pphpauth';

package/dist/src/Lib/PrismaPHPSettings.php

@@ -2,23 +2,69 @@
 
 namespace Lib;
 
+class BSPathRewrite
+{
+    public string $pattern;
+    public string $replacement;
+
+    public function __construct(array $data)
+    {
+        $this->pattern = $data['pattern'] ?? '';
+        $this->replacement = $data['replacement'] ?? '';
+    }
+}
+
+class PrismaSettings
+{
+    public string $projectName;
+    public string $projectRootPath;
+    public string $phpEnvironment;
+    public string $phpRootPathExe;
+    public string $phpGenerateClassPath;
+    public string $bsTarget;
+    public BSPathRewrite $bsPathRewrite;
+    public bool $backendOnly;
+    public bool $swaggerDocs;
+    public bool $tailwindcss;
+    public bool $websocket;
+    public bool $prisma;
+    public bool $docker;
+    public string $version;
+    public array $excludeFiles;
+
+    public function __construct(array $data)
+    {
+        $this->projectName = $data['projectName'] ?? '';
+        $this->projectRootPath = $data['projectRootPath'] ?? '';
+        $this->phpEnvironment = $data['phpEnvironment'] ?? '';
+        $this->phpRootPathExe = $data['phpRootPathExe'] ?? '';
+        $this->phpGenerateClassPath = $data['phpGenerateClassPath'] ?? '';
+        $this->bsTarget = $data['bsTarget'] ?? '';
+        $this->bsPathRewrite = new BSPathRewrite($data['bsPathRewrite'] ?? []);
+        $this->backendOnly = $data['backendOnly'] ?? false;
+        $this->swaggerDocs = $data['swaggerDocs'] ?? true;
+        $this->tailwindcss = $data['tailwindcss'] ?? true;
+        $this->websocket = $data['websocket'] ?? true;
+        $this->prisma = $data['prisma'] ?? true;
+        $this->docker = $data['docker'] ?? false;
+        $this->version = $data['version'] ?? '';
+        $this->excludeFiles = $data['excludeFiles'] ?? [];
+    }
+}
+
 class PrismaPHPSettings
 {
     /**
      * The settings from the prisma-php.json file.
      * 
-     * @var \stdClass
-     * @access public
-     * @static
+     * @var PrismaSettings
      */
-    public static \ArrayObject $option;
+    public static PrismaSettings $option;
 
     /**
      * The list of route files from the files-list.json file.
      * 
      * @var array
-     * @access public
-     * @static
      */
     public static array $routeFiles = [];
 
@@ -28,20 +74,28 @@ class PrismaPHPSettings
         self::$routeFiles = self::getRoutesFileList();
     }
 
-    private static function getPrismaSettings(): \ArrayObject
+    /**
+     * Get Prisma settings from the JSON file.
+     *
+     * @return PrismaSettings
+     * @throws Exception if the JSON file cannot be decoded.
+     */
+    private static function getPrismaSettings(): PrismaSettings
     {
         $prismaPHPSettingsJson = DOCUMENT_PATH . '/prisma-php.json';
 
-        if (file_exists($prismaPHPSettingsJson)) {
-            $jsonContent = file_get_contents($prismaPHPSettingsJson);
-            $decodedJson = json_decode($jsonContent, true);
+        if (!file_exists($prismaPHPSettingsJson)) {
+            throw new \Exception("Settings file not found: $prismaPHPSettingsJson");
+        }
+
+        $jsonContent = file_get_contents($prismaPHPSettingsJson);
+        $decodedJson = json_decode($jsonContent, true);
 
-            if (json_last_error() === JSON_ERROR_NONE) {
-                return new \ArrayObject($decodedJson, \ArrayObject::ARRAY_AS_PROPS);
-            } else {
-                return new \ArrayObject([], \ArrayObject::ARRAY_AS_PROPS);
-            }
+        if (json_last_error() !== JSON_ERROR_NONE) {
+            throw new \Exception("Failed to decode JSON: " . json_last_error_msg());
         }
+
+        return new PrismaSettings($decodedJson);
     }
 
     private static function getRoutesFileList(): array

package/dist/src/Lib/Request.php

@@ -195,8 +195,36 @@ class Request
      */
     private static function isAjaxRequest(): bool
     {
-        return (!empty($_SERVER['HTTP_X_REQUESTED_WITH']) && strtolower($_SERVER['HTTP_X_REQUESTED_WITH']) === 'xmlhttprequest')
-            || in_array(strtoupper(self::$method), ['POST', 'PUT', 'PATCH', 'DELETE']);
+        $isAjax = false;
+
+        // Check for standard AJAX header
+        if (!empty($_SERVER['HTTP_X_REQUESTED_WITH']) && strtolower($_SERVER['HTTP_X_REQUESTED_WITH']) === 'xmlhttprequest') {
+            $isAjax = true;
+        }
+
+        // Check for common AJAX content types
+        if (!empty($_SERVER['CONTENT_TYPE'])) {
+            $ajaxContentTypes = [
+                'application/json',
+                'application/x-www-form-urlencoded',
+                'multipart/form-data',
+            ];
+
+            foreach ($ajaxContentTypes as $contentType) {
+                if (strpos($_SERVER['CONTENT_TYPE'], $contentType) !== false) {
+                    $isAjax = true;
+                    break;
+                }
+            }
+        }
+
+        // Check for common AJAX request methods
+        $ajaxMethods = ['POST', 'PUT', 'PATCH', 'DELETE'];
+        if (in_array(strtoupper($_SERVER['REQUEST_METHOD']), $ajaxMethods)) {
+            $isAjax = true;
+        }
+
+        return $isAjax;
     }
 
     /**
@@ -217,8 +245,8 @@ class Request
     {
         $serverFetchSite = $_SERVER['HTTP_SEC_FETCH_SITE'] ?? '';
         if (isset($serverFetchSite) && $serverFetchSite === 'same-origin') {
-            $headers = getallheaders();
-            return isset($headers['http_pphp_x_file_request']) && strtolower($headers['http_pphp_x_file_request']) === 'true';
+            $headers = array_change_key_case(getallheaders(), CASE_LOWER);
+            return isset($headers['http_pphp_x_file_request']) && $headers['http_pphp_x_file_request'] === 'true';
         }
 
         return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-prisma-php-app",
-  "version": "1.26.503",
+  "version": "1.26.504",
   "description": "Prisma-PHP: A Revolutionary Library Bridging PHP with Prisma ORM",
   "main": "dist/index.js",
   "type": "module",