@oneuptime/common 7.0.4349 → 7.0.4372

package/Utils/Schema/ModelSchema.ts

@@ -6,13 +6,62 @@ import {
 } from "../../Types/Database/TableColumn";
 import Dictionary from "../../Types/Dictionary";
 import DatabaseBaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
-import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import logger from "../../Server/Utils/Logger";
 import Color from "../../Types/Color";
+import { z as ZodTypes } from "zod";
+import BadDataException from "../../Types/Exception/BadDataException";
+import Permission, { PermissionHelper } from "../../Types/Permission";
+import { ColumnAccessControl } from "../../Types/BaseDatabase/AccessControl";
+import { BaseSchema, SchemaExample, ShapeRecord } from "./BaseSchema";
 
 export type ModelSchemaType = ZodSchema;
 
-export class ModelSchema {
+// Type for schema method functions
+type SchemaMethodFunction = (data: {
+  modelType: new () => DatabaseBaseModel;
+}) => ModelSchemaType;
+
+export class ModelSchema extends BaseSchema {
+  /**
+   * Format permissions array into a human-readable string for OpenAPI documentation
+   */
+  private static formatPermissionsForSchema(
+    permissions: Array<Permission> | undefined,
+  ): string {
+    if (!permissions || permissions.length === 0) {
+      return "No access - you don't have permission for this operation";
+    }
+
+    return PermissionHelper.getPermissionTitles(permissions).join(", ");
+  }
+
+  /**
+   * Get permissions description for a column to add to OpenAPI schema
+   */
+  private static getColumnPermissionsDescription(
+    model: DatabaseBaseModel,
+    key: string,
+  ): string {
+    const accessControl: ColumnAccessControl | undefined =
+      model.getColumnAccessControlForAllColumns()[key];
+
+    if (!accessControl) {
+      return "";
+    }
+
+    const createPermissions: string = this.formatPermissionsForSchema(
+      accessControl.create,
+    );
+    const readPermissions: string = this.formatPermissionsForSchema(
+      accessControl.read,
+    );
+    const updatePermissions: string = this.formatPermissionsForSchema(
+      accessControl.update,
+    );
+
+    return `Permissions - Create: [${createPermissions}], Read: [${readPermissions}], Update: [${updatePermissions}]`;
+  }
+
   public static getModelSchema(data: {
     modelType: new () => DatabaseBaseModel;
   }): ModelSchemaType {
@@ -21,14 +70,32 @@ export class ModelSchema {
 
     const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
 
-    const shape: Record<string, any> = {};
+    const shape: ShapeRecord = {};
+
+    // Get column access control for permission filtering
+    const columnAccessControl: Dictionary<ColumnAccessControl> =
+      model.getColumnAccessControlForAllColumns();
 
     for (const key in columns) {
       const column: TableColumnMetadata | undefined = columns[key];
       if (!column) {
         continue;
       }
-      let zodType: any;
+
+      // Filter out columns with no permissions (root-only access)
+      const accessControl: ColumnAccessControl | undefined =
+        columnAccessControl[key];
+      if (accessControl) {
+        // Check if column has any permissions defined for read operation (general schema assumes read access)
+        const hasReadPermissions: boolean =
+          accessControl.read && accessControl.read.length > 0;
+
+        // If no read permissions are defined, exclude the column from general schema
+        if (!hasReadPermissions) {
+          continue;
+        }
+      }
+      let zodType: ZodTypes.ZodTypeAny;
 
       if (column.type === TableColumnType.ObjectID) {
         zodType = z.string().openapi({
@@ -268,6 +335,13 @@ export class ModelSchema {
         zodType = zodType.describe(column.title);
       }
 
+      // Add permissions description to the schema
+      const permissionsDescription: string =
+        this.getColumnPermissionsDescription(model, key);
+      if (permissionsDescription) {
+        zodType = zodType.describe(permissionsDescription);
+      }
+
       shape[key] = zodType;
     }
 
@@ -304,20 +378,240 @@ export class ModelSchema {
     const modelType: new () => DatabaseBaseModel = data.modelType;
     const model: DatabaseBaseModel = new modelType();
 
-    const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
+    return this.generateQuerySchema({
+      model,
+      tableName: model.tableName || "model",
+      getColumns: (model: DatabaseBaseModel) => {
+        const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
+        return Object.keys(columns)
+          .map((key: string) => {
+            const column: TableColumnMetadata | undefined = columns[key];
+            return column ? { key, type: column.type } : null;
+          })
+          .filter((col: { key: string; type: any } | null) => {
+            return col !== null;
+          }) as Array<{ key: string; type: any }>;
+      },
+      getValidOperatorsForColumnType: (columnType: TableColumnType) => {
+        return this.getValidOperatorsForColumnType(columnType);
+      },
+      getOperatorSchema: (
+        operatorType: string,
+        columnType: TableColumnType,
+      ) => {
+        return this.getOperatorSchema(operatorType, columnType);
+      },
+      getQuerySchemaExample: () => {
+        return this.getQuerySchemaExample(modelType);
+      },
+      getExampleValueForColumn: (columnType: TableColumnType) => {
+        return this.getExampleValueForColumn(columnType);
+      },
+    });
+  }
 
-    const shape: Record<string, any> = {};
+  private static getValidOperatorsForColumnType(
+    columnType: TableColumnType,
+  ): Array<string> {
+    const commonOperators: Array<string> = [
+      "EqualTo",
+      "NotEqual",
+      "IsNull",
+      "NotNull",
+      "EqualToOrNull",
+    ];
 
-    for (const key in columns) {
-      const column: TableColumnMetadata | undefined = columns[key];
-      if (!column) {
-        continue;
-      }
+    switch (columnType) {
+      case TableColumnType.ObjectID:
+      case TableColumnType.Email:
+      case TableColumnType.Phone:
+      case TableColumnType.HashedString:
+      case TableColumnType.Slug:
+        return [...commonOperators, "Includes"];
+
+      case TableColumnType.ShortText:
+      case TableColumnType.LongText:
+      case TableColumnType.VeryLongText:
+      case TableColumnType.Name:
+      case TableColumnType.Description:
+      case TableColumnType.Domain:
+      case TableColumnType.Markdown:
+        return [...commonOperators, "Search", "Includes"];
 
-      // There are these query operators.
+      case TableColumnType.Number:
+      case TableColumnType.PositiveNumber:
+      case TableColumnType.SmallNumber:
+      case TableColumnType.SmallPositiveNumber:
+      case TableColumnType.BigNumber:
+      case TableColumnType.BigPositiveNumber:
+        return [
+          ...commonOperators,
+          "GreaterThan",
+          "LessThan",
+          "GreaterThanOrEqual",
+          "LessThanOrEqual",
+          "InBetween",
+        ];
+
+      case TableColumnType.Date:
+        return [
+          ...commonOperators,
+          "GreaterThan",
+          "LessThan",
+          "GreaterThanOrEqual",
+          "LessThanOrEqual",
+          "InBetween",
+        ];
+
+      case TableColumnType.Boolean:
+        return commonOperators;
+
+      case TableColumnType.JSON:
+      case TableColumnType.Array:
+        return ["EqualTo", "NotEqual", "IsNull", "NotNull"];
+
+      case TableColumnType.Entity:
+      case TableColumnType.EntityArray:
+        return ["EqualTo", "NotEqual", "IsNull", "NotNull", "Includes"];
+
+      case TableColumnType.Color:
+      case TableColumnType.File:
+      case TableColumnType.Buffer:
+        return commonOperators;
+
+      default:
+        return commonOperators;
     }
+  }
+
+  private static getOperatorSchema(
+    operatorType: string,
+    columnType: TableColumnType,
+  ): ZodTypes.ZodTypeAny {
+    const baseValue: ZodTypes.ZodTypeAny =
+      this.getBaseValueSchemaForColumnType(columnType);
+
+    switch (operatorType) {
+      case "EqualTo":
+      case "NotEqual":
+      case "EqualToOrNull":
+        return z.object({
+          _type: z.literal(operatorType),
+          value: baseValue,
+        });
+
+      case "GreaterThan":
+      case "LessThan":
+      case "GreaterThanOrEqual":
+      case "LessThanOrEqual":
+        return z.object({
+          _type: z.literal(operatorType),
+          value: baseValue,
+        });
+
+      case "Search":
+        return z.object({
+          _type: z.literal("Search"),
+          value: z.string(),
+        });
+
+      case "InBetween":
+        return z.object({
+          _type: z.literal("InBetween"),
+          startValue: baseValue,
+          endValue: baseValue,
+        });
 
-    return z.object(shape);
+      case "IsNull":
+      case "NotNull":
+        return z.object({
+          _type: z.literal(operatorType),
+        });
+
+      case "Includes":
+        return z.object({
+          _type: z.literal("Includes"),
+          value: z.array(baseValue),
+        });
+
+      default:
+        return z.object({
+          _type: z.literal(operatorType),
+          value: baseValue,
+        });
+    }
+  }
+
+  private static getBaseValueSchemaForColumnType(
+    columnType: TableColumnType,
+  ): ZodTypes.ZodTypeAny {
+    switch (columnType) {
+      case TableColumnType.ObjectID:
+        return z.string();
+
+      case TableColumnType.Email:
+        return z.string().email();
+
+      case TableColumnType.Phone:
+      case TableColumnType.HashedString:
+      case TableColumnType.Slug:
+      case TableColumnType.ShortText:
+      case TableColumnType.LongText:
+      case TableColumnType.VeryLongText:
+      case TableColumnType.Name:
+      case TableColumnType.Description:
+      case TableColumnType.Domain:
+      case TableColumnType.Markdown:
+      case TableColumnType.HTML:
+      case TableColumnType.JavaScript:
+      case TableColumnType.CSS:
+      case TableColumnType.LongURL:
+      case TableColumnType.ShortURL:
+      case TableColumnType.OTP:
+      case TableColumnType.Password:
+      case TableColumnType.Version:
+        return z.string();
+
+      case TableColumnType.Number:
+      case TableColumnType.PositiveNumber:
+      case TableColumnType.SmallNumber:
+      case TableColumnType.SmallPositiveNumber:
+      case TableColumnType.BigNumber:
+      case TableColumnType.BigPositiveNumber:
+        return z.number();
+
+      case TableColumnType.Date:
+        return z.date();
+
+      case TableColumnType.Boolean:
+        return z.boolean();
+
+      case TableColumnType.JSON:
+      case TableColumnType.Array:
+      case TableColumnType.Permission:
+      case TableColumnType.CustomFieldType:
+        return z.any();
+
+      case TableColumnType.Color:
+        return Color.getSchema();
+
+      case TableColumnType.Entity:
+        return z.string(); // Entity IDs are typically strings
+
+      case TableColumnType.EntityArray:
+        return z.array(z.string()); // Array of entity IDs
+
+      case TableColumnType.File:
+      case TableColumnType.Buffer:
+        return z.any();
+
+      case TableColumnType.MonitorType:
+      case TableColumnType.WorkflowStatus:
+        return z.string();
+
+      default:
+        return z.string();
+    }
   }
 
   public static getSortModelSchema(data: {
@@ -326,42 +620,375 @@ export class ModelSchema {
     const modelType: new () => DatabaseBaseModel = data.modelType;
     const model: DatabaseBaseModel = new modelType();
 
+    return this.generateSortSchema({
+      model,
+      tableName: model.tableName || "model",
+      getSortableTypes: () => {
+        return this.getSortableTypes();
+      },
+      getColumnsForSorting: (model: DatabaseBaseModel) => {
+        const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
+        return Object.keys(columns)
+          .map((key: string) => {
+            const column: TableColumnMetadata | undefined = columns[key];
+            return column ? { key, type: column.type } : null;
+          })
+          .filter((col: { key: string; type: any } | null) => {
+            return col !== null;
+          }) as Array<{ key: string; type: any }>;
+      },
+    });
+  }
+
+  public static getSelectModelSchema(data: {
+    modelType: new () => DatabaseBaseModel;
+    isNested?: boolean;
+  }): ModelSchemaType {
+    const modelType: new () => DatabaseBaseModel = data.modelType;
+    const model: DatabaseBaseModel = new modelType();
+
+    return this.generateSelectSchema({
+      model,
+      tableName: model.tableName || "model",
+      getColumns: (model: DatabaseBaseModel) => {
+        const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
+        return Object.keys(columns)
+          .map((key: string) => {
+            const column: TableColumnMetadata | undefined = columns[key];
+            return column ? { key, type: column.type } : null;
+          })
+          .filter((col: { key: string; type: any } | null) => {
+            return col !== null;
+          }) as Array<{ key: string; type?: any }>;
+      },
+      getSelectSchemaExample: () => {
+        return this.getSelectSchemaExample(modelType);
+      },
+      allowNested: !data.isNested,
+      getNestedSchema: (key: string, model: DatabaseBaseModel) => {
+        const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
+        const column: TableColumnMetadata | undefined = columns[key];
+        if (
+          column &&
+          column.modelType &&
+          (column.type === TableColumnType.EntityArray ||
+            column.type === TableColumnType.Entity)
+        ) {
+          return this.getSelectModelSchema({
+            modelType: column.modelType as new () => DatabaseBaseModel,
+            isNested: true,
+          });
+        }
+        return null;
+      },
+    });
+  }
+
+  public static getGroupByModelSchema(data: {
+    modelType: new () => DatabaseBaseModel;
+  }): ModelSchemaType {
+    const modelType: new () => DatabaseBaseModel = data.modelType;
+    const model: DatabaseBaseModel = new modelType();
+
+    return this.generateGroupBySchema({
+      model,
+      tableName: model.tableName || "model",
+      getColumns: (model: DatabaseBaseModel) => {
+        const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
+        return Object.keys(columns)
+          .map((key: string) => {
+            const column: TableColumnMetadata | undefined = columns[key];
+            return column ? { key, type: column.type } : null;
+          })
+          .filter((col: { key: string; type: any } | null) => {
+            return col !== null;
+          }) as Array<{ key: string; type: any }>;
+      },
+      getGroupableTypes: () => {
+        return [
+          TableColumnType.ShortText,
+          TableColumnType.LongText,
+          TableColumnType.Name,
+          TableColumnType.Email,
+          TableColumnType.Slug,
+          TableColumnType.ObjectID,
+          TableColumnType.Boolean,
+          TableColumnType.Date,
+          TableColumnType.Number,
+          TableColumnType.PositiveNumber,
+          TableColumnType.SmallNumber,
+          TableColumnType.SmallPositiveNumber,
+          TableColumnType.BigNumber,
+          TableColumnType.BigPositiveNumber,
+        ];
+      },
+      getGroupBySchemaExample: () => {
+        return this.getGroupBySchemaExample(modelType);
+      },
+    });
+  }
+
+  private static getExampleValueForColumn(
+    columnType: TableColumnType,
+    isSecondValue: boolean = false,
+  ): unknown {
+    switch (columnType) {
+      case TableColumnType.ObjectID:
+        return isSecondValue
+          ? "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"
+          : "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa";
+      case TableColumnType.Email:
+        return isSecondValue ? "jane@example.com" : "john@example.com";
+      case TableColumnType.Phone:
+        return isSecondValue ? "+1-555-987-6543" : "+1-555-123-4567";
+      case TableColumnType.Number:
+      case TableColumnType.PositiveNumber:
+        return isSecondValue ? 100 : 50;
+      case TableColumnType.SmallNumber:
+        return isSecondValue ? 20 : 10;
+      case TableColumnType.SmallPositiveNumber:
+        return isSecondValue ? 25 : 15;
+      case TableColumnType.BigNumber:
+        return isSecondValue ? 2000000 : 1000000;
+      case TableColumnType.BigPositiveNumber:
+        return isSecondValue ? 2500000 : 1500000;
+      case TableColumnType.Date:
+        return isSecondValue
+          ? "2023-12-31T23:59:59.000Z"
+          : "2023-01-01T00:00:00.000Z";
+      case TableColumnType.Boolean:
+        return !isSecondValue;
+      case TableColumnType.ShortText:
+      case TableColumnType.Name:
+        return isSecondValue ? "Jane Doe" : "John Doe";
+      case TableColumnType.Description:
+        return isSecondValue
+          ? "Second example description"
+          : "Example description";
+      case TableColumnType.Domain:
+        return isSecondValue ? "example.org" : "example.com";
+      default:
+        return isSecondValue ? "example_value_2" : "example_value_1";
+    }
+  }
+
+  private static getQuerySchemaExample(
+    modelType: new () => DatabaseBaseModel,
+  ): SchemaExample {
+    const model: DatabaseBaseModel = new modelType();
     const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
+    const example: SchemaExample = {};
 
-    const shape: Record<string, any> = {};
+    let exampleCount: number = 0;
+    const maxExamples: number = 3;
 
     for (const key in columns) {
+      if (exampleCount >= maxExamples) {
+        break;
+      }
+
       const column: TableColumnMetadata | undefined = columns[key];
       if (!column) {
         continue;
       }
 
-      const isSortable: boolean = ModelSchema.getSortableTypes().includes(
+      const validOperators: Array<string> = this.getValidOperatorsForColumnType(
         column.type,
       );
+      if (validOperators.length === 0) {
+        continue;
+      }
+
+      // Add example based on column type and available operators
+      if (
+        column.type === TableColumnType.ShortText ||
+        column.type === TableColumnType.Name
+      ) {
+        if (validOperators.includes("EqualTo")) {
+          example[key] = { _type: "EqualTo", value: "Example Text" };
+          exampleCount++;
+        } else if (validOperators.includes("Search")) {
+          example[key] = { _type: "Search", value: "example" };
+          exampleCount++;
+        }
+      } else if (
+        column.type === TableColumnType.Email &&
+        validOperators.includes("EqualTo")
+      ) {
+        example[key] = { _type: "EqualTo", value: "user@example.com" };
+        exampleCount++;
+      } else if (
+        column.type === TableColumnType.Date &&
+        validOperators.includes("GreaterThan")
+      ) {
+        example[key] = {
+          _type: "GreaterThan",
+          value: "2023-01-01T00:00:00.000Z",
+        };
+        exampleCount++;
+      } else if (
+        column.type === TableColumnType.Boolean &&
+        validOperators.includes("EqualTo")
+      ) {
+        example[key] = { _type: "EqualTo", value: true };
+        exampleCount++;
+      } else if (
+        (column.type === TableColumnType.Number ||
+          column.type === TableColumnType.PositiveNumber) &&
+        validOperators.includes("GreaterThan")
+      ) {
+        example[key] = { _type: "GreaterThan", value: 10 };
+        exampleCount++;
+      } else if (validOperators.includes("EqualTo")) {
+        example[key] = {
+          _type: "EqualTo",
+          value: this.getExampleValueForColumn(column.type),
+        };
+        exampleCount++;
+      }
+    }
+
+    // If no examples were added, add a generic one
+    if (exampleCount === 0) {
+      example["_id"] = {
+        _type: "EqualTo",
+        value: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+      };
+    }
+
+    return example;
+  }
+
+  private static getSelectSchemaExample(
+    modelType: new () => DatabaseBaseModel,
+  ): SchemaExample {
+    if (!modelType) {
+      throw new BadDataException(
+        "Model type is required to generate select schema example.",
+      );
+    }
+
+    const model: DatabaseBaseModel = new modelType();
+    const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
+    const example: SchemaExample = {};
+
+    // Add common fields that most models have
+    const commonFields: Array<string> = ["_id", "createdAt", "updatedAt"];
+    for (const field of commonFields) {
+      if (columns[field]) {
+        example[field] = true;
+      }
+    }
+
+    // Add first few non-common fields as examples
+    let fieldCount: number = 0;
+    const maxFields: number = 5;
+    for (const key in columns) {
+      if (fieldCount >= maxFields) {
+        break;
+      }
+
+      const column: TableColumnMetadata | undefined = columns[key];
+      if (!column || commonFields.includes(key)) {
+        continue;
+      }
+
+      // Prioritize fields that are likely to be commonly selected
+      if (
+        column.type === TableColumnType.ShortText ||
+        column.type === TableColumnType.Name ||
+        column.type === TableColumnType.Email ||
+        column.type === TableColumnType.Description
+      ) {
+        example[key] = true;
+        fieldCount++;
+      }
+    }
+
+    return example;
+  }
+
+  private static getGroupBySchemaExample(
+    modelType: new () => DatabaseBaseModel,
+  ): SchemaExample {
+    if (!modelType) {
+      throw new BadDataException(
+        "Model type is required to generate group by schema example.",
+      );
+    }
+
+    const model: DatabaseBaseModel = new modelType();
+    const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
 
-      if (!isSortable) {
+    // Find the first suitable field for grouping
+    for (const key in columns) {
+      const column: TableColumnMetadata | undefined = columns[key];
+      if (!column) {
         continue;
       }
 
-      shape[key] = z
-        .enum([SortOrder.Ascending, SortOrder.Descending])
-        .optional();
+      // Prioritize common groupable fields
+      if (
+        column.type === TableColumnType.ShortText ||
+        column.type === TableColumnType.Name ||
+        column.type === TableColumnType.Boolean ||
+        column.type === TableColumnType.Date
+      ) {
+        return { [key]: true };
+      }
     }
 
-    return z.object(shape);
+    // Fallback to any available field
+    for (const key in columns) {
+      const column: TableColumnMetadata | undefined = columns[key];
+      if (!column) {
+        continue;
+      }
+
+      const isGroupable: boolean = [
+        TableColumnType.ShortText,
+        TableColumnType.LongText,
+        TableColumnType.Name,
+        TableColumnType.Email,
+        TableColumnType.Slug,
+        TableColumnType.ObjectID,
+        TableColumnType.Boolean,
+        TableColumnType.Date,
+        TableColumnType.Number,
+        TableColumnType.PositiveNumber,
+        TableColumnType.SmallNumber,
+        TableColumnType.SmallPositiveNumber,
+        TableColumnType.BigNumber,
+        TableColumnType.BigPositiveNumber,
+      ].includes(column.type);
+
+      if (isGroupable) {
+        return { [key]: true };
+      }
+    }
+
+    // Final fallback
+    return { status: true };
   }
 
-  public static getSelectModelSchema(data: {
+  // Shared method to build model schemas with different field exclusions
+  private static buildModelSchema(data: {
     modelType: new () => DatabaseBaseModel;
-    isNested?: boolean;
+    excludedFields?: string[];
+    includedFields?: string[];
+    schemaType: "create" | "read" | "update" | "delete";
+    description: string;
+    example: SchemaExample;
+    makeOptional?: boolean;
   }): ModelSchemaType {
     const modelType: new () => DatabaseBaseModel = data.modelType;
     const model: DatabaseBaseModel = new modelType();
-
     const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
+    const shape: ShapeRecord = {};
 
-    const shape: Record<string, any> = {};
+    // Get column access control for permission filtering
+    const columnAccessControl: Dictionary<ColumnAccessControl> =
+      model.getColumnAccessControlForAllColumns();
 
     for (const key in columns) {
       const column: TableColumnMetadata | undefined = columns[key];
@@ -369,24 +996,458 @@ export class ModelSchema {
         continue;
       }
 
-      // if its entity array or entity then you can select nested properties
-      if (
-        !data.isNested &&
-        column.modelType &&
-        (column.type === TableColumnType.EntityArray ||
-          column.type === TableColumnType.Entity)
-      ) {
-        // can only do one level of nesting
-        shape[key] = this.getSelectModelSchema({
-          modelType: column.modelType as new () => DatabaseBaseModel,
-          isNested: true,
-        });
+      // Skip excluded fields
+      if (data.excludedFields && data.excludedFields.includes(key)) {
         continue;
       }
 
-      shape[key] = z.boolean().optional();
+      // Only include specified fields if includedFields is provided
+      if (data.includedFields && !data.includedFields.includes(key)) {
+        continue;
+      }
+
+      // Filter out columns with no permissions (root-only access)
+      const accessControl: ColumnAccessControl | undefined =
+        columnAccessControl[key];
+      if (accessControl) {
+        let hasPermissions: boolean = false;
+
+        // Check if column has any permissions defined for the current operation
+        if (
+          data.schemaType === "create" &&
+          accessControl.create &&
+          accessControl.create.length > 0
+        ) {
+          hasPermissions = true;
+        } else if (
+          data.schemaType === "read" &&
+          accessControl.read &&
+          accessControl.read.length > 0
+        ) {
+          hasPermissions = true;
+        } else if (
+          data.schemaType === "update" &&
+          accessControl.update &&
+          accessControl.update.length > 0
+        ) {
+          hasPermissions = true;
+        } else if (data.schemaType === "delete") {
+          // For delete operations, we don't filter by column permissions
+          hasPermissions = true;
+        }
+
+        // If no permissions are defined for this operation, exclude the column
+        if (!hasPermissions) {
+          continue;
+        }
+      }
+
+      let zodType: ZodTypes.ZodTypeAny = this.getZodTypeForColumn(
+        column,
+        key,
+        data.schemaType,
+      );
+
+      // Make fields optional if specified
+      if (data.makeOptional) {
+        zodType = zodType.optional();
+      }
+
+      // Add title and description to the schema
+      if (column.title) {
+        zodType = zodType.describe(column.title);
+      }
+
+      shape[key] = zodType;
+    }
+
+    const schema: ModelSchemaType = z.object(shape).openapi({
+      type: "object",
+      description: `${data.description} schema for ${model.tableName || "model"} model. ${data.description}`,
+      example: data.example,
+      additionalProperties: false,
+    });
+
+    logger.debug(
+      `${data.schemaType} model schema for ${model.tableName} created with shape: ${JSON.stringify(
+        shape,
+        null,
+        2,
+      )}`,
+    );
+
+    return schema;
+  }
+
+  // Helper method to get Zod type for a column
+  private static getZodTypeForColumn(
+    column: TableColumnMetadata,
+    key: string,
+    schemaType: "create" | "read" | "update" | "delete",
+  ): ZodTypes.ZodTypeAny {
+    let zodType: ZodTypes.ZodTypeAny;
+
+    if (column.type === TableColumnType.ObjectID) {
+      zodType = z.string().openapi({
+        type: "string",
+        example: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+      });
+    } else if (column.type === TableColumnType.Color) {
+      zodType = Color.getSchema();
+    } else if (column.type === TableColumnType.Date) {
+      zodType = z.date().openapi({
+        type: "string",
+        format: "date-time",
+        example: "2023-01-15T12:30:00.000Z",
+      });
+    } else if (column.type === TableColumnType.VeryLongText) {
+      zodType = z.string().openapi({
+        type: "string",
+        example:
+          "This is an example of very long text content that might be stored in this field. It can contain a lot of information, such as detailed descriptions, comments, or any other lengthy text data that needs to be stored in the database.",
+      });
+    } else if (
+      column.type === TableColumnType.Number ||
+      column.type === TableColumnType.PositiveNumber
+    ) {
+      zodType = z.number().openapi({ type: "number", example: 42 });
+    } else if (column.type === TableColumnType.Email) {
+      zodType = z.string().email().openapi({
+        type: "string",
+        format: "email",
+        example: "user@example.com",
+      });
+    } else if (column.type === TableColumnType.HashedString) {
+      zodType = z
+        .string()
+        .openapi({ type: "string", example: "hashed_string_value" });
+    } else if (column.type === TableColumnType.Slug) {
+      zodType = z
+        .string()
+        .openapi({ type: "string", example: "example-slug-value" });
+    } else if (column.type === TableColumnType.ShortText) {
+      zodType = z
+        .string()
+        .openapi({ type: "string", example: "Example short text" });
+    } else if (column.type === TableColumnType.LongText) {
+      zodType = z.string().openapi({
+        type: "string",
+        example:
+          "This is an example of longer text content that might be stored in this field.",
+      });
+    } else if (column.type === TableColumnType.Phone) {
+      zodType = z
+        .string()
+        .openapi({ type: "string", example: "+1-555-123-4567" });
+    } else if (column.type === TableColumnType.Version) {
+      zodType = z.string().openapi({
+        type: "string",
+        example: "1.0.0",
+      });
+    } else if (column.type === TableColumnType.Password) {
+      zodType = z.string().openapi({
+        type: "string",
+        format: "password",
+        example: "••••••••",
+      });
+    } else if (column.type === TableColumnType.Name) {
+      zodType = z.string().openapi({
+        type: "string",
+        example: "John Doe",
+      });
+    } else if (column.type === TableColumnType.Description) {
+      zodType = z.string().openapi({
+        type: "string",
+        example: "This is a description of the item",
+      });
+    } else if (column.type === TableColumnType.File) {
+      zodType = z.any().openapi({
+        type: "string",
+        format: "binary",
+      });
+    } else if (column.type === TableColumnType.Buffer) {
+      zodType = z.any().openapi({
+        type: "string",
+        format: "binary",
+      });
+    } else if (column.type === TableColumnType.ShortURL) {
+      zodType = z.string().url().openapi({
+        type: "string",
+        example: "https://short.url/abc123",
+      });
+    } else if (column.type === TableColumnType.Markdown) {
+      zodType = z.string().openapi({
+        type: "string",
+        example: "# Heading\n\nThis is **markdown** content",
+      });
+    } else if (column.type === TableColumnType.Domain) {
+      zodType = z.string().openapi({
+        type: "string",
+        example: "example.com",
+      });
+    } else if (column.type === TableColumnType.LongURL) {
+      zodType = z.string().url().openapi({
+        type: "string",
+        example: "https://www.example.com/path/to/resource?param=value",
+      });
+    } else if (column.type === TableColumnType.OTP) {
+      zodType = z.string().openapi({
+        type: "string",
+        example: "123456",
+      });
+    } else if (column.type === TableColumnType.HTML) {
+      zodType = z.string().openapi({
+        type: "string",
+        example: "<div><h1>Title</h1><p>Content</p></div>",
+      });
+    } else if (column.type === TableColumnType.JavaScript) {
+      zodType = z.string().openapi({
+        type: "string",
+        example: "function example() { return true; }",
+      });
+    } else if (column.type === TableColumnType.CSS) {
+      zodType = z.string().openapi({
+        type: "string",
+        example: "body { color: #333; margin: 0; }",
+      });
+    } else if (column.type === TableColumnType.Array) {
+      zodType = z.array(z.any()).openapi({
+        type: "array",
+        items: {
+          type: "string",
+        },
+        example: ["item1", "item2", "item3"],
+      });
+    } else if (column.type === TableColumnType.SmallPositiveNumber) {
+      zodType = z.number().int().nonnegative().openapi({
+        type: "integer",
+        example: 5,
+      });
+    } else if (column.type === TableColumnType.BigPositiveNumber) {
+      zodType = z.number().nonnegative().openapi({
+        type: "number",
+        example: 1000000,
+      });
+    } else if (column.type === TableColumnType.SmallNumber) {
+      zodType = z.number().int().openapi({
+        type: "integer",
+        example: 10,
+      });
+    } else if (column.type === TableColumnType.BigNumber) {
+      zodType = z.number().openapi({
+        type: "number",
+        example: 1000000,
+      });
+    } else if (column.type === TableColumnType.Permission) {
+      zodType = z.any().openapi({
+        type: "object",
+        example: { read: true, write: false, delete: false },
+      });
+    } else if (column.type === TableColumnType.CustomFieldType) {
+      zodType = z.any().openapi({
+        type: "object",
+        example: { type: "text", required: true },
+      });
+    } else if (column.type === TableColumnType.MonitorType) {
+      zodType = z.string().openapi({
+        type: "string",
+        example: "HTTP",
+      });
+    } else if (column.type === TableColumnType.WorkflowStatus) {
+      zodType = z.string().openapi({
+        type: "string",
+        example: "In Progress",
+      });
+    } else if (column.type === TableColumnType.Boolean) {
+      zodType = z.boolean().openapi({ type: "boolean", example: true });
+    } else if (column.type === TableColumnType.JSON) {
+      zodType = z.any().openapi({
+        type: "object",
+        example: { key: "value", nested: { data: 123 } },
+      });
+    } else if (column.type === TableColumnType.EntityArray) {
+      const entityArrayType: (new () => DatabaseBaseModel) | undefined =
+        column.modelType;
+      if (!entityArrayType) {
+        logger.debug(`Entity type is not defined for column ${key}`);
+        return z.any().openapi({ type: "null", example: null });
+      }
+
+      // Use the appropriate schema method based on the operation type
+      let schemaMethod: SchemaMethodFunction;
+      switch (schemaType) {
+        case "create":
+          schemaMethod = ModelSchema.getCreateModelSchema;
+          break;
+        case "read":
+          schemaMethod = ModelSchema.getReadModelSchema;
+          break;
+        case "update":
+          schemaMethod = ModelSchema.getUpdateModelSchema;
+          break;
+        case "delete":
+          schemaMethod = ModelSchema.getDeleteModelSchema;
+          break;
+      }
+
+      zodType = z
+        .array(
+          z.lazy(() => {
+            return schemaMethod({
+              modelType: entityArrayType as new () => DatabaseBaseModel,
+            });
+          }),
+        )
+        .openapi({
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              id: { type: "string" },
+            },
+          },
+          example: [{ id: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" }],
+        });
+    } else if (column.type === TableColumnType.Entity) {
+      const entityType: (new () => DatabaseBaseModel) | undefined =
+        column.modelType;
+
+      if (!entityType) {
+        logger.debug(`Entity type is not defined for column ${key}`);
+        return z.any().openapi({ type: "null", example: null });
+      }
+
+      // Use the appropriate schema method based on the operation type
+      let schema: ModelSchemaType;
+      switch (schemaType) {
+        case "create":
+          schema = ModelSchema.getCreateModelSchema({ modelType: entityType });
+          break;
+        case "read":
+          schema = ModelSchema.getReadModelSchema({ modelType: entityType });
+          break;
+        case "update":
+          schema = ModelSchema.getUpdateModelSchema({ modelType: entityType });
+          break;
+        case "delete":
+          schema = ModelSchema.getDeleteModelSchema({ modelType: entityType });
+          break;
+      }
+
+      zodType = z
+        .lazy(() => {
+          return schema;
+        })
+        .openapi({
+          type: "object",
+          example: { id: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" },
+        });
+    } else {
+      zodType = z.any().openapi({ type: "null", example: null });
     }
 
-    return z.object(shape);
+    return zodType;
+  }
+
+  public static getCreateModelSchema(data: {
+    modelType: new () => DatabaseBaseModel;
+  }): ModelSchemaType {
+    // Auto-generated fields to exclude from create schema
+    const excludedFields: Array<string> = [
+      "_id",
+      "createdAt",
+      "updatedAt",
+      "deletedAt",
+      "version",
+    ];
+
+    return this.buildModelSchema({
+      modelType: data.modelType,
+      excludedFields,
+      schemaType: "create",
+      description: "Create",
+      example: this.getCreateSchemaExample(),
+    });
+  }
+
+  public static getReadModelSchema(data: {
+    modelType: new () => DatabaseBaseModel;
+  }): ModelSchemaType {
+    // For read operations, include all fields
+    return this.buildModelSchema({
+      modelType: data.modelType,
+      schemaType: "read",
+      description: "Read",
+      example: this.getReadSchemaExample(),
+    });
+  }
+
+  public static getUpdateModelSchema(data: {
+    modelType: new () => DatabaseBaseModel;
+  }): ModelSchemaType {
+    // Auto-generated fields to exclude from update schema (but allow _id for identification)
+    const excludedFields: Array<string> = [
+      "createdAt",
+      "updatedAt",
+      "deletedAt",
+      "version",
+    ];
+
+    return this.buildModelSchema({
+      modelType: data.modelType,
+      excludedFields,
+      schemaType: "update",
+      description: "Update",
+      example: this.getUpdateSchemaExample(),
+      makeOptional: true, // All fields are optional for updates
+    });
+  }
+
+  public static getDeleteModelSchema(data: {
+    modelType: new () => DatabaseBaseModel;
+  }): ModelSchemaType {
+    // For delete, we typically only need the ID
+    const includedFields: Array<string> = ["_id"];
+
+    return this.buildModelSchema({
+      modelType: data.modelType,
+      includedFields,
+      schemaType: "delete",
+      description: "Delete",
+      example: this.getDeleteSchemaExample(),
+    });
+  }
+
+  private static getCreateSchemaExample(): SchemaExample {
+    return {
+      name: "John Doe",
+      email: "john@example.com",
+      description: "Example user description",
+    };
+  }
+
+  private static getReadSchemaExample(): SchemaExample {
+    return {
+      _id: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+      name: "John Doe",
+      email: "john@example.com",
+      description: "Example user description",
+      createdAt: "2023-01-15T12:30:00.000Z",
+      updatedAt: "2023-01-15T12:30:00.000Z",
+      version: 1,
+    };
+  }
+
+  private static getUpdateSchemaExample(): SchemaExample {
+    return {
+      name: "Jane Doe",
+      email: "jane@example.com",
+    };
+  }
+
+  private static getDeleteSchemaExample(): SchemaExample {
+    return {
+      _id: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+    };
   }
 }