@oneuptime/common 7.0.4358 → 7.0.4395

package/Utils/Schema/ModelSchema.ts

@@ -6,42 +6,31 @@ 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";
+import ObjectID from "../../Types/ObjectID";
+import Email from "../../Types/Email";
+import Phone from "../../Types/Phone";
+import Domain from "../../Types/Domain";
+import Version from "../../Types/Version";
+import Name from "../../Types/Name";
+import IP from "../../Types/IP/IP";
+import Port from "../../Types/Port";
+import MonitorSteps from "../../Types/Monitor/MonitorSteps";
 
 export type ModelSchemaType = ZodSchema;
 
-// Type for schema examples
-type SchemaExample = Record<string, unknown>;
-
-// Type for operator examples in OpenAPI format
-type OperatorExample = {
-  properties: Record<
-    string,
-    {
-      type: string;
-      enum?: string[];
-      items?: { type: string };
-    }
-  >;
-  required: string[];
-  example: Record<string, unknown>;
-};
-
-// Type for shape objects using Zod's type inference
-type ShapeRecord = Record<string, ZodTypes.ZodTypeAny>;
-
 // Type for schema method functions
 type SchemaMethodFunction = (data: {
   modelType: new () => DatabaseBaseModel;
 }) => ModelSchemaType;
 
-export class ModelSchema {
+export class ModelSchema extends BaseSchema {
   /**
    * Format permissions array into a human-readable string for OpenAPI documentation
    */
@@ -49,7 +38,7 @@ export class ModelSchema {
     permissions: Array<Permission> | undefined,
   ): string {
     if (!permissions || permissions.length === 0) {
-      return "No permissions required";
+      return "No access - you don't have permission for this operation";
     }
 
     return PermissionHelper.getPermissionTitles(permissions).join(", ");
@@ -92,20 +81,37 @@ export class ModelSchema {
 
     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;
       }
+
+      // 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({
-          type: "string",
-          example: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
-        });
+        zodType = ObjectID.getSchema();
       } else if (column.type === TableColumnType.Color) {
         zodType = Color.getSchema();
+      } else if (column.type === TableColumnType.MonitorSteps) {
+        zodType = MonitorSteps.getSchema();
       } else if (column.type === TableColumnType.Date) {
         zodType = z.date().openapi({
           type: "string",
@@ -124,11 +130,7 @@ export class ModelSchema {
       ) {
         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",
-        });
+        zodType = Email.getSchema();
       } else if (column.type === TableColumnType.HashedString) {
         zodType = z
           .string()
@@ -148,14 +150,9 @@ export class ModelSchema {
             "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" });
+        zodType = Phone.getSchema();
       } else if (column.type === TableColumnType.Version) {
-        zodType = z.string().openapi({
-          type: "string",
-          example: "1.0.0",
-        });
+        zodType = Version.getSchema();
       } else if (column.type === TableColumnType.Password) {
         zodType = z.string().openapi({
           type: "string",
@@ -163,10 +160,7 @@ export class ModelSchema {
           example: "••••••••",
         });
       } else if (column.type === TableColumnType.Name) {
-        zodType = z.string().openapi({
-          type: "string",
-          example: "John Doe",
-        });
+        zodType = Name.getSchema();
       } else if (column.type === TableColumnType.Description) {
         zodType = z.string().openapi({
           type: "string",
@@ -193,10 +187,11 @@ export class ModelSchema {
           example: "# Heading\n\nThis is **markdown** content",
         });
       } else if (column.type === TableColumnType.Domain) {
-        zodType = z.string().openapi({
-          type: "string",
-          example: "example.com",
-        });
+        zodType = Domain.getSchema();
+      } else if (column.type === TableColumnType.Port) {
+        zodType = Port.getSchema();
+      } else if (column.type === TableColumnType.IP) {
+        zodType = IP.getSchema();
       } else if (column.type === TableColumnType.LongURL) {
         zodType = z.string().url().openapi({
           type: "string",
@@ -380,72 +375,36 @@ export class ModelSchema {
     const modelType: new () => DatabaseBaseModel = data.modelType;
     const model: DatabaseBaseModel = new modelType();
 
-    const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
-
-    const shape: ShapeRecord = {};
-
-    for (const key in columns) {
-      const column: TableColumnMetadata | undefined = columns[key];
-      if (!column) {
-        continue;
-      }
-
-      // Get valid operators for this column type
-      const validOperators: Array<string> = this.getValidOperatorsForColumnType(
-        column.type,
-      );
-
-      if (validOperators.length === 0) {
-        continue;
-      }
-
-      // Create a union type of all valid operators for this column
-      const operatorSchemas: Array<ZodTypes.ZodTypeAny> = validOperators.map(
-        (operatorType: string) => {
-          return this.getOperatorSchema(operatorType, column.type);
-        },
-      );
-
-      let columnSchema: ZodTypes.ZodTypeAny;
-      if (operatorSchemas.length === 1 && operatorSchemas[0]) {
-        columnSchema = operatorSchemas[0].optional();
-      } else if (operatorSchemas.length > 1) {
-        columnSchema = z
-          .union(
-            operatorSchemas as [
-              ZodTypes.ZodTypeAny,
-              ZodTypes.ZodTypeAny,
-              ...ZodTypes.ZodTypeAny[],
-            ],
-          )
-          .optional();
-      } else {
-        // Fallback for empty operators array
-        columnSchema = z.any().optional();
-      }
-
-      // Add OpenAPI documentation for query operators
-      const operatorExamples: Array<OperatorExample> =
-        this.getQueryOperatorExamples(column.type, validOperators);
-      columnSchema = columnSchema.openapi({
-        type: "object",
-        description: `Query operators for ${key} field of type ${column.type}. Supported operators: ${validOperators.join(", ")}`,
-        example:
-          operatorExamples.length > 0 && operatorExamples[0]
-            ? operatorExamples[0].example
-            : {},
-      });
-
-      shape[key] = columnSchema;
-    }
-
-    const schema: ModelSchemaType = z.object(shape).openapi({
-      type: "object",
-      description: `Query schema for ${model.tableName || "model"} model. Each field can use various operators based on its data type.`,
-      example: this.getQuerySchemaExample(modelType),
+    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);
+      },
     });
-
-    return schema;
   }
 
   private static getValidOperatorsForColumnType(
@@ -585,20 +544,34 @@ export class ModelSchema {
   ): ZodTypes.ZodTypeAny {
     switch (columnType) {
       case TableColumnType.ObjectID:
-        return z.string();
+        return ObjectID.getSchema();
 
       case TableColumnType.Email:
-        return z.string().email();
+        return Email.getSchema();
 
       case TableColumnType.Phone:
+        return Phone.getSchema();
+
+      case TableColumnType.Name:
+        return Name.getSchema();
+
+      case TableColumnType.Domain:
+        return Domain.getSchema();
+
+      case TableColumnType.Version:
+        return Version.getSchema();
+
+      case TableColumnType.IP:
+        return IP.getSchema();
+      case TableColumnType.Port:
+        return Port.getSchema();
+
       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:
@@ -607,7 +580,6 @@ export class ModelSchema {
       case TableColumnType.ShortURL:
       case TableColumnType.OTP:
       case TableColumnType.Password:
-      case TableColumnType.Version:
         return z.string();
 
       case TableColumnType.Number:
@@ -658,40 +630,23 @@ export class ModelSchema {
     const modelType: new () => DatabaseBaseModel = data.modelType;
     const model: DatabaseBaseModel = new modelType();
 
-    const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
-
-    const shape: ShapeRecord = {};
-
-    for (const key in columns) {
-      const column: TableColumnMetadata | undefined = columns[key];
-      if (!column) {
-        continue;
-      }
-
-      const isSortable: boolean = ModelSchema.getSortableTypes().includes(
-        column.type,
-      );
-
-      if (!isSortable) {
-        continue;
-      }
-
-      shape[key] = z
-        .enum([SortOrder.Ascending, SortOrder.Descending])
-        .optional()
-        .openapi({
-          type: "string",
-          enum: [SortOrder.Ascending, SortOrder.Descending],
-          description: `Sort order for ${key} field`,
-          example: SortOrder.Ascending,
-        });
-    }
-
-    return z.object(shape).openapi({
-      type: "object",
-      description: `Sort schema for ${model.tableName || "model"} model. Only sortable fields are included.`,
-      example: this.getSortSchemaExample(),
-      additionalProperties: false,
+    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 }>;
+      },
     });
   }
 
@@ -702,50 +657,40 @@ export class ModelSchema {
     const modelType: new () => DatabaseBaseModel = data.modelType;
     const model: DatabaseBaseModel = new modelType();
 
-    const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
-
-    const shape: ShapeRecord = {};
-
-    for (const key in columns) {
-      const column: TableColumnMetadata | undefined = columns[key];
-      if (!column) {
-        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,
-        }).openapi({
-          type: "object",
-          description: `Select fields for nested ${key} entity`,
-          example: { id: true, name: true },
-        });
-        continue;
-      }
-
-      shape[key] = z
-        .boolean()
-        .optional()
-        .openapi({
-          type: "boolean",
-          description: `Select ${key} field in the response`,
-          example: true,
-        });
-    }
-
-    return z.object(shape).openapi({
-      type: "object",
-      description: `Select schema for ${model.tableName || "model"} model. Set fields to true to include them in the response.`,
-      example: this.getSelectSchemaExample(modelType),
-      additionalProperties: false,
+    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;
+      },
     });
   }
 
@@ -755,244 +700,44 @@ export class ModelSchema {
     const modelType: new () => DatabaseBaseModel = data.modelType;
     const model: DatabaseBaseModel = new modelType();
 
-    const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
-
-    const shape: ShapeRecord = {};
-
-    for (const key in columns) {
-      const column: TableColumnMetadata | undefined = columns[key];
-      if (!column) {
-        continue;
-      }
-
-      // Only allow grouping by certain field types that make sense for aggregation
-      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) {
-        continue;
-      }
-
-      shape[key] = z
-        .literal(true)
-        .optional()
-        .openapi({
-          type: "boolean",
-          description: `Group by ${key} field. Only one field can be selected for grouping.`,
-          example: true,
-        });
-    }
-
-    return z.object(shape).openapi({
-      type: "object",
-      description: `Group by schema for ${model.tableName || "model"} model. Only one field can be set to true for grouping.`,
-      example: this.getGroupBySchemaExample(modelType),
-      additionalProperties: false,
+    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 getQueryOperatorExamples(
-    columnType: TableColumnType,
-    validOperators: Array<string>,
-  ): Array<OperatorExample> {
-    const examples: Array<OperatorExample> = [];
-
-    for (const operator of validOperators) {
-      switch (operator) {
-        case "EqualTo":
-          examples.push({
-            properties: {
-              _type: { type: "string", enum: ["EqualTo"] },
-              value: { type: this.getOpenAPITypeForColumn(columnType) },
-            },
-            required: ["_type", "value"],
-            example: {
-              _type: "EqualTo",
-              value: this.getExampleValueForColumn(columnType),
-            },
-          });
-          break;
-        case "NotEqual":
-          examples.push({
-            properties: {
-              _type: { type: "string", enum: ["NotEqual"] },
-              value: { type: this.getOpenAPITypeForColumn(columnType) },
-            },
-            required: ["_type", "value"],
-            example: {
-              _type: "NotEqual",
-              value: this.getExampleValueForColumn(columnType),
-            },
-          });
-          break;
-        case "Search":
-          examples.push({
-            properties: {
-              _type: { type: "string", enum: ["Search"] },
-              value: { type: "string" },
-            },
-            required: ["_type", "value"],
-            example: { _type: "Search", value: "search term" },
-          });
-          break;
-        case "GreaterThan":
-          examples.push({
-            properties: {
-              _type: { type: "string", enum: ["GreaterThan"] },
-              value: { type: this.getOpenAPITypeForColumn(columnType) },
-            },
-            required: ["_type", "value"],
-            example: {
-              _type: "GreaterThan",
-              value: this.getExampleValueForColumn(columnType),
-            },
-          });
-          break;
-        case "LessThan":
-          examples.push({
-            properties: {
-              _type: { type: "string", enum: ["LessThan"] },
-              value: { type: this.getOpenAPITypeForColumn(columnType) },
-            },
-            required: ["_type", "value"],
-            example: {
-              _type: "LessThan",
-              value: this.getExampleValueForColumn(columnType),
-            },
-          });
-          break;
-        case "GreaterThanOrEqual":
-          examples.push({
-            properties: {
-              _type: { type: "string", enum: ["GreaterThanOrEqual"] },
-              value: { type: this.getOpenAPITypeForColumn(columnType) },
-            },
-            required: ["_type", "value"],
-            example: {
-              _type: "GreaterThanOrEqual",
-              value: this.getExampleValueForColumn(columnType),
-            },
-          });
-          break;
-        case "LessThanOrEqual":
-          examples.push({
-            properties: {
-              _type: { type: "string", enum: ["LessThanOrEqual"] },
-              value: { type: this.getOpenAPITypeForColumn(columnType) },
-            },
-            required: ["_type", "value"],
-            example: {
-              _type: "LessThanOrEqual",
-              value: this.getExampleValueForColumn(columnType),
-            },
-          });
-          break;
-        case "EqualToOrNull":
-          examples.push({
-            properties: {
-              _type: { type: "string", enum: ["EqualToOrNull"] },
-              value: { type: this.getOpenAPITypeForColumn(columnType) },
-            },
-            required: ["_type", "value"],
-            example: {
-              _type: "EqualToOrNull",
-              value: this.getExampleValueForColumn(columnType),
-            },
-          });
-          break;
-        case "InBetween":
-          examples.push({
-            properties: {
-              _type: { type: "string", enum: ["InBetween"] },
-              startValue: { type: this.getOpenAPITypeForColumn(columnType) },
-              endValue: { type: this.getOpenAPITypeForColumn(columnType) },
-            },
-            required: ["_type", "startValue", "endValue"],
-            example: {
-              _type: "InBetween",
-              startValue: this.getExampleValueForColumn(columnType),
-              endValue: this.getExampleValueForColumn(columnType, true),
-            },
-          });
-          break;
-        case "IsNull":
-          examples.push({
-            properties: {
-              _type: { type: "string", enum: ["IsNull"] },
-            },
-            required: ["_type"],
-            example: { _type: "IsNull" },
-          });
-          break;
-        case "NotNull":
-          examples.push({
-            properties: {
-              _type: { type: "string", enum: ["NotNull"] },
-            },
-            required: ["_type"],
-            example: { _type: "NotNull" },
-          });
-          break;
-        case "Includes":
-          examples.push({
-            properties: {
-              _type: { type: "string", enum: ["Includes"] },
-              value: {
-                type: "array",
-                items: { type: this.getOpenAPITypeForColumn(columnType) },
-              },
-            },
-            required: ["_type", "value"],
-            example: {
-              _type: "Includes",
-              value: [
-                this.getExampleValueForColumn(columnType),
-                this.getExampleValueForColumn(columnType, true),
-              ],
-            },
-          });
-          break;
-      }
-    }
-
-    return examples;
-  }
-
-  private static getOpenAPITypeForColumn(columnType: TableColumnType): string {
-    switch (columnType) {
-      case TableColumnType.Number:
-      case TableColumnType.PositiveNumber:
-      case TableColumnType.SmallNumber:
-      case TableColumnType.SmallPositiveNumber:
-      case TableColumnType.BigNumber:
-      case TableColumnType.BigPositiveNumber:
-        return "number";
-      case TableColumnType.Boolean:
-        return "boolean";
-      case TableColumnType.Date:
-        return "string";
-      case TableColumnType.JSON:
-      case TableColumnType.Array:
-        return "object";
-      default:
-        return "string";
-    }
-  }
-
   private static getExampleValueForColumn(
     columnType: TableColumnType,
     isSecondValue: boolean = false,
@@ -1124,12 +869,6 @@ export class ModelSchema {
     return example;
   }
 
-  private static getSortSchemaExample(): SchemaExample {
-    return {
-      createdAt: "Descending",
-    };
-  }
-
   private static getSelectSchemaExample(
     modelType: new () => DatabaseBaseModel,
   ): SchemaExample {
@@ -1257,6 +996,10 @@ export class ModelSchema {
     const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
     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) {
@@ -1273,6 +1016,42 @@ export class ModelSchema {
         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,
@@ -1319,10 +1098,13 @@ export class ModelSchema {
     let zodType: ZodTypes.ZodTypeAny;
 
     if (column.type === TableColumnType.ObjectID) {
-      zodType = z.string().openapi({
-        type: "string",
-        example: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
-      });
+      zodType = ObjectID.getSchema();
+    } else if (column.type === TableColumnType.Port) {
+      zodType = Port.getSchema();
+    } else if (column.type === TableColumnType.MonitorSteps) {
+      zodType = MonitorSteps.getSchema();
+    } else if (column.type === TableColumnType.IP) {
+      zodType = IP.getSchema();
     } else if (column.type === TableColumnType.Color) {
       zodType = Color.getSchema();
     } else if (column.type === TableColumnType.Date) {
@@ -1343,11 +1125,7 @@ export class ModelSchema {
     ) {
       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",
-      });
+      zodType = Email.getSchema();
     } else if (column.type === TableColumnType.HashedString) {
       zodType = z
         .string()
@@ -1367,14 +1145,9 @@ export class ModelSchema {
           "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" });
+      zodType = Phone.getSchema();
     } else if (column.type === TableColumnType.Version) {
-      zodType = z.string().openapi({
-        type: "string",
-        example: "1.0.0",
-      });
+      zodType = Version.getSchema();
     } else if (column.type === TableColumnType.Password) {
       zodType = z.string().openapi({
         type: "string",
@@ -1382,10 +1155,7 @@ export class ModelSchema {
         example: "••••••••",
       });
     } else if (column.type === TableColumnType.Name) {
-      zodType = z.string().openapi({
-        type: "string",
-        example: "John Doe",
-      });
+      zodType = Name.getSchema();
     } else if (column.type === TableColumnType.Description) {
       zodType = z.string().openapi({
         type: "string",
@@ -1412,10 +1182,7 @@ export class ModelSchema {
         example: "# Heading\n\nThis is **markdown** content",
       });
     } else if (column.type === TableColumnType.Domain) {
-      zodType = z.string().openapi({
-        type: "string",
-        example: "example.com",
-      });
+      zodType = Domain.getSchema();
     } else if (column.type === TableColumnType.LongURL) {
       zodType = z.string().url().openapi({
         type: "string",