@oneuptime/common 7.0.4358 → 7.0.4372

package/build/dist/Utils/Schema/ModelSchema.js

@@ -1,18 +1,18 @@
 import z from "./Zod";
 import TableColumnType from "../../Types/Database/TableColumnType";
 import { getTableColumns, } from "../../Types/Database/TableColumn";
-import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import logger from "../../Server/Utils/Logger";
 import Color from "../../Types/Color";
 import BadDataException from "../../Types/Exception/BadDataException";
 import { PermissionHelper } from "../../Types/Permission";
-export class ModelSchema {
+import { BaseSchema } from "./BaseSchema";
+export class ModelSchema extends BaseSchema {
     /**
      * Format permissions array into a human-readable string for OpenAPI documentation
      */
     static formatPermissionsForSchema(permissions) {
         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(", ");
     }
@@ -34,11 +34,23 @@ export class ModelSchema {
         const model = new modelType();
         const columns = getTableColumns(model);
         const shape = {};
+        // Get column access control for permission filtering
+        const columnAccessControl = model.getColumnAccessControlForAllColumns();
         for (const key in columns) {
             const column = columns[key];
             if (!column) {
                 continue;
             }
+            // Filter out columns with no permissions (root-only access)
+            const accessControl = columnAccessControl[key];
+            if (accessControl) {
+                // Check if column has any permissions defined for read operation (general schema assumes read access)
+                const hasReadPermissions = accessControl.read && accessControl.read.length > 0;
+                // If no read permissions are defined, exclude the column from general schema
+                if (!hasReadPermissions) {
+                    continue;
+                }
+            }
             let zodType;
             if (column.type === TableColumnType.ObjectID) {
                 zodType = z.string().openapi({
@@ -331,52 +343,33 @@ export class ModelSchema {
     static getQueryModelSchema(data) {
         const modelType = data.modelType;
         const model = new modelType();
-        const columns = getTableColumns(model);
-        const shape = {};
-        for (const key in columns) {
-            const column = columns[key];
-            if (!column) {
-                continue;
-            }
-            // Get valid operators for this column type
-            const validOperators = this.getValidOperatorsForColumnType(column.type);
-            if (validOperators.length === 0) {
-                continue;
-            }
-            // Create a union type of all valid operators for this column
-            const operatorSchemas = validOperators.map((operatorType) => {
-                return this.getOperatorSchema(operatorType, column.type);
-            });
-            let columnSchema;
-            if (operatorSchemas.length === 1 && operatorSchemas[0]) {
-                columnSchema = operatorSchemas[0].optional();
-            }
-            else if (operatorSchemas.length > 1) {
-                columnSchema = z
-                    .union(operatorSchemas)
-                    .optional();
-            }
-            else {
-                // Fallback for empty operators array
-                columnSchema = z.any().optional();
-            }
-            // Add OpenAPI documentation for query operators
-            const operatorExamples = 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 = 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) => {
+                const columns = getTableColumns(model);
+                return Object.keys(columns)
+                    .map((key) => {
+                    const column = columns[key];
+                    return column ? { key, type: column.type } : null;
+                })
+                    .filter((col) => {
+                    return col !== null;
+                });
+            },
+            getValidOperatorsForColumnType: (columnType) => {
+                return this.getValidOperatorsForColumnType(columnType);
+            },
+            getOperatorSchema: (operatorType, columnType) => {
+                return this.getOperatorSchema(operatorType, columnType);
+            },
+            getQuerySchemaExample: () => {
+                return this.getQuerySchemaExample(modelType);
+            },
+            getExampleValueForColumn: (columnType) => {
+                return this.getExampleValueForColumn(columnType);
+            },
         });
-        return schema;
     }
     static getValidOperatorsForColumnType(columnType) {
         const commonOperators = [
@@ -546,303 +539,102 @@ export class ModelSchema {
     static getSortModelSchema(data) {
         const modelType = data.modelType;
         const model = new modelType();
-        const columns = getTableColumns(model);
-        const shape = {};
-        for (const key in columns) {
-            const column = columns[key];
-            if (!column) {
-                continue;
-            }
-            const isSortable = 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) => {
+                const columns = getTableColumns(model);
+                return Object.keys(columns)
+                    .map((key) => {
+                    const column = columns[key];
+                    return column ? { key, type: column.type } : null;
+                })
+                    .filter((col) => {
+                    return col !== null;
+                });
+            },
         });
     }
     static getSelectModelSchema(data) {
         const modelType = data.modelType;
         const model = new modelType();
-        const columns = getTableColumns(model);
-        const shape = {};
-        for (const key in columns) {
-            const column = 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,
-                    isNested: true,
-                }).openapi({
-                    type: "object",
-                    description: `Select fields for nested ${key} entity`,
-                    example: { id: true, name: true },
+        return this.generateSelectSchema({
+            model,
+            tableName: model.tableName || "model",
+            getColumns: (model) => {
+                const columns = getTableColumns(model);
+                return Object.keys(columns)
+                    .map((key) => {
+                    const column = columns[key];
+                    return column ? { key, type: column.type } : null;
+                })
+                    .filter((col) => {
+                    return col !== null;
                 });
-                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,
+            },
+            getSelectSchemaExample: () => {
+                return this.getSelectSchemaExample(modelType);
+            },
+            allowNested: !data.isNested,
+            getNestedSchema: (key, model) => {
+                const columns = getTableColumns(model);
+                const column = columns[key];
+                if (column &&
+                    column.modelType &&
+                    (column.type === TableColumnType.EntityArray ||
+                        column.type === TableColumnType.Entity)) {
+                    return this.getSelectModelSchema({
+                        modelType: column.modelType,
+                        isNested: true,
+                    });
+                }
+                return null;
+            },
         });
     }
     static getGroupByModelSchema(data) {
         const modelType = data.modelType;
         const model = new modelType();
-        const columns = getTableColumns(model);
-        const shape = {};
-        for (const key in columns) {
-            const column = columns[key];
-            if (!column) {
-                continue;
-            }
-            // Only allow grouping by certain field types that make sense for aggregation
-            const isGroupable = [
-                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) => {
+                const columns = getTableColumns(model);
+                return Object.keys(columns)
+                    .map((key) => {
+                    const column = columns[key];
+                    return column ? { key, type: column.type } : null;
+                })
+                    .filter((col) => {
+                    return col !== null;
+                });
+            },
+            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);
+            },
         });
     }
-    static getQueryOperatorExamples(columnType, validOperators) {
-        const examples = [];
-        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;
-    }
-    static getOpenAPITypeForColumn(columnType) {
-        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";
-        }
-    }
     static getExampleValueForColumn(columnType, isSecondValue = false) {
         switch (columnType) {
             case TableColumnType.ObjectID:
@@ -954,11 +746,6 @@ export class ModelSchema {
         }
         return example;
     }
-    static getSortSchemaExample() {
-        return {
-            createdAt: "Descending",
-        };
-    }
     static getSelectSchemaExample(modelType) {
         if (!modelType) {
             throw new BadDataException("Model type is required to generate select schema example.");
@@ -1050,6 +837,8 @@ export class ModelSchema {
         const model = new modelType();
         const columns = getTableColumns(model);
         const shape = {};
+        // Get column access control for permission filtering
+        const columnAccessControl = model.getColumnAccessControlForAllColumns();
         for (const key in columns) {
             const column = columns[key];
             if (!column) {
@@ -1063,6 +852,35 @@ export class ModelSchema {
             if (data.includedFields && !data.includedFields.includes(key)) {
                 continue;
             }
+            // Filter out columns with no permissions (root-only access)
+            const accessControl = columnAccessControl[key];
+            if (accessControl) {
+                let hasPermissions = 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 = this.getZodTypeForColumn(column, key, data.schemaType);
             // Make fields optional if specified
             if (data.makeOptional) {