@oneuptime/common 7.0.4547 → 7.0.4585

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

@@ -85,7 +85,11 @@ export class ModelSchema extends BaseSchema {
             }
             else if (column.type === TableColumnType.Number ||
                 column.type === TableColumnType.PositiveNumber) {
-                zodType = z.number().openapi({ type: "number", example: 42 });
+                const openapiConfig = { type: "number", example: 42 };
+                if (column.defaultValue !== undefined) {
+                    openapiConfig.default = column.defaultValue;
+                }
+                zodType = z.number().openapi(openapiConfig);
             }
             else if (column.type === TableColumnType.Email) {
                 zodType = Email.getSchema();
@@ -101,15 +105,23 @@ export class ModelSchema extends BaseSchema {
                     .openapi({ type: "string", example: "example-slug-value" });
             }
             else if (column.type === TableColumnType.ShortText) {
+                const openapiConfig = { type: "string", example: "Example short text" };
+                if (column.defaultValue !== undefined) {
+                    openapiConfig.default = column.defaultValue;
+                }
                 zodType = z
                     .string()
-                    .openapi({ type: "string", example: "Example short text" });
+                    .openapi(openapiConfig);
             }
             else if (column.type === TableColumnType.LongText) {
-                zodType = z.string().openapi({
+                const openapiConfig = {
                     type: "string",
                     example: "This is an example of longer text content that might be stored in this field.",
-                });
+                };
+                if (column.defaultValue !== undefined) {
+                    openapiConfig.default = column.defaultValue;
+                }
+                zodType = z.string().openapi(openapiConfig);
             }
             else if (column.type === TableColumnType.Phone) {
                 zodType = Phone.getSchema();
@@ -206,28 +218,44 @@ export class ModelSchema extends BaseSchema {
                 });
             }
             else if (column.type === TableColumnType.SmallPositiveNumber) {
-                zodType = z.number().int().nonnegative().openapi({
+                const openapiConfig = {
                     type: "integer",
                     example: 5,
-                });
+                };
+                if (column.defaultValue !== undefined) {
+                    openapiConfig.default = column.defaultValue;
+                }
+                zodType = z.number().int().nonnegative().openapi(openapiConfig);
             }
             else if (column.type === TableColumnType.BigPositiveNumber) {
-                zodType = z.number().nonnegative().openapi({
+                const openapiConfig = {
                     type: "number",
                     example: 1000000,
-                });
+                };
+                if (column.defaultValue !== undefined) {
+                    openapiConfig.default = column.defaultValue;
+                }
+                zodType = z.number().nonnegative().openapi(openapiConfig);
             }
             else if (column.type === TableColumnType.SmallNumber) {
-                zodType = z.number().int().openapi({
+                const openapiConfig = {
                     type: "integer",
                     example: 10,
-                });
+                };
+                if (column.defaultValue !== undefined) {
+                    openapiConfig.default = column.defaultValue;
+                }
+                zodType = z.number().int().openapi(openapiConfig);
             }
             else if (column.type === TableColumnType.BigNumber) {
-                zodType = z.number().openapi({
+                const openapiConfig = {
                     type: "number",
                     example: 1000000,
-                });
+                };
+                if (column.defaultValue !== undefined) {
+                    openapiConfig.default = column.defaultValue;
+                }
+                zodType = z.number().openapi(openapiConfig);
             }
             else if (column.type === TableColumnType.Permission) {
                 zodType = z.any().openapi({
@@ -254,7 +282,11 @@ export class ModelSchema extends BaseSchema {
                 });
             }
             else if (column.type === TableColumnType.Boolean) {
-                zodType = z.boolean().openapi({ type: "boolean", example: true });
+                const openapiConfig = { type: "boolean", example: true };
+                if (column.defaultValue !== undefined) {
+                    openapiConfig.default = column.defaultValue;
+                }
+                zodType = z.boolean().openapi(openapiConfig);
             }
             else if (column.type === TableColumnType.JSON) {
                 zodType = z.any().openapi({
@@ -334,13 +366,31 @@ export class ModelSchema extends BaseSchema {
                 zodType = zodType.optional();
             }
             // add title and description to the schema
-            if (column.title) {
-                zodType = zodType.describe(column.title);
+            let finalDescription = "";
+            // Add column description first if it exists
+            if (column.description) {
+                finalDescription = column.description;
+            }
+            else if (column.title) {
+                finalDescription = column.title;
             }
-            // Add permissions description to the schema
+            // Add permissions description, prefixed to the column description
             const permissionsDescription = this.getColumnPermissionsDescription(model, key);
             if (permissionsDescription) {
-                zodType = zodType.describe(permissionsDescription);
+                if (finalDescription) {
+                    finalDescription = `${finalDescription}. ${permissionsDescription}`;
+                }
+                else {
+                    finalDescription = permissionsDescription;
+                }
+            }
+            // Set the final combined description
+            if (finalDescription) {
+                zodType = zodType.describe(finalDescription);
+            }
+            // Mark computed fields as readOnly in OpenAPI spec
+            if (column.computed) {
+                zodType = zodType.openapi({ readOnly: true });
             }
             shape[key] = zodType;
         }
@@ -871,6 +921,7 @@ export class ModelSchema extends BaseSchema {
     }
     // Shared method to build model schemas with different field exclusions
     static buildModelSchema(data) {
+        var _a;
         const modelType = data.modelType;
         const model = new modelType();
         const columns = getTableColumns(model);
@@ -897,6 +948,11 @@ export class ModelSchema extends BaseSchema {
             if (data.includedFields && !data.includedFields.includes(key)) {
                 continue;
             }
+            // Skip computed fields for create and update operations
+            if (column.computed &&
+                (data.schemaType === "create" || data.schemaType === "update")) {
+                continue;
+            }
             // Filter out columns with no permissions (root-only access)
             const accessControl = columnAccessControl[key];
             if (accessControl) {
@@ -933,6 +989,10 @@ export class ModelSchema extends BaseSchema {
                 // should be optional
                 zodType = zodType.optional();
             }
+            else if (((_a = column.title) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === "project id" && column.type === TableColumnType.ObjectID) {
+                // this is optional in the API as well as it's derived from API key
+                zodType = zodType.optional();
+            }
             else if (column.required) {
                 // leave as is
             }
@@ -944,8 +1004,27 @@ export class ModelSchema extends BaseSchema {
                 zodType = zodType.optional();
             }
             // Add title and description to the schema
-            if (column.title) {
-                zodType = zodType.describe(column.title);
+            let finalDescription = "";
+            // Add column description first if it exists
+            if (column.description) {
+                finalDescription = column.description;
+            }
+            else if (column.title) {
+                finalDescription = column.title;
+            }
+            // Add permissions description, prefixed to the column description
+            const permissionsDescription = this.getColumnPermissionsDescription(model, key);
+            if (permissionsDescription) {
+                if (finalDescription) {
+                    finalDescription = `${finalDescription}. ${permissionsDescription}`;
+                }
+                else {
+                    finalDescription = permissionsDescription;
+                }
+            }
+            // Set the final combined description
+            if (finalDescription) {
+                zodType = zodType.describe(finalDescription);
             }
             shape[key] = zodType;
         }
@@ -959,6 +1038,13 @@ export class ModelSchema extends BaseSchema {
     // Helper method to get Zod type for a column
     static getZodTypeForColumn(column, schemaType) {
         let zodType;
+        // Helper function to add default value to openapi schema if it exists
+        const addDefaultToOpenApi = (openApiConfig) => {
+            if (column.defaultValue !== undefined && column.defaultValue !== null) {
+                return Object.assign(Object.assign({}, openApiConfig), { default: column.defaultValue });
+            }
+            return openApiConfig;
+        };
         if (column.type === TableColumnType.ObjectID) {
             zodType = ObjectID.getSchema();
         }
@@ -978,14 +1064,14 @@ export class ModelSchema extends BaseSchema {
             zodType = OneUptimeDate.getSchema();
         }
         else if (column.type === TableColumnType.VeryLongText) {
-            zodType = z.string().openapi({
+            zodType = z.string().openapi(addDefaultToOpenApi({
                 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 });
+            zodType = z.number().openapi(addDefaultToOpenApi({ type: "number", example: 42 }));
         }
         else if (column.type === TableColumnType.Email) {
             zodType = Email.getSchema();
@@ -993,23 +1079,23 @@ export class ModelSchema extends BaseSchema {
         else if (column.type === TableColumnType.HashedString) {
             zodType = z
                 .string()
-                .openapi({ type: "string", example: "hashed_string_value" });
+                .openapi(addDefaultToOpenApi({ type: "string", example: "hashed_string_value" }));
         }
         else if (column.type === TableColumnType.Slug) {
             zodType = z
                 .string()
-                .openapi({ type: "string", example: "example-slug-value" });
+                .openapi(addDefaultToOpenApi({ type: "string", example: "example-slug-value" }));
         }
         else if (column.type === TableColumnType.ShortText) {
             zodType = z
                 .string()
-                .openapi({ type: "string", example: "Example short text" });
+                .openapi(addDefaultToOpenApi({ type: "string", example: "Example short text" }));
         }
         else if (column.type === TableColumnType.LongText) {
-            zodType = z.string().openapi({
+            zodType = z.string().openapi(addDefaultToOpenApi({
                 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 = Phone.getSchema();
@@ -1018,152 +1104,152 @@ export class ModelSchema extends BaseSchema {
             zodType = Version.getSchema();
         }
         else if (column.type === TableColumnType.Password) {
-            zodType = z.string().openapi({
+            zodType = z.string().openapi(addDefaultToOpenApi({
                 type: "string",
                 format: "password",
                 example: "••••••••",
-            });
+            }));
         }
         else if (column.type === TableColumnType.Name) {
             zodType = Name.getSchema();
         }
         else if (column.type === TableColumnType.Description) {
-            zodType = z.string().openapi({
+            zodType = z.string().openapi(addDefaultToOpenApi({
                 type: "string",
                 example: "This is a description of the item",
-            });
+            }));
         }
         else if (column.type === TableColumnType.File) {
-            zodType = z.any().openapi({
+            zodType = z.any().openapi(addDefaultToOpenApi({
                 type: "string",
                 format: "binary",
-            });
+            }));
         }
         else if (column.type === TableColumnType.Buffer) {
-            zodType = z.any().openapi({
+            zodType = z.any().openapi(addDefaultToOpenApi({
                 type: "string",
                 format: "binary",
-            });
+            }));
         }
         else if (column.type === TableColumnType.ShortURL) {
-            zodType = z.string().url().openapi({
+            zodType = z.string().url().openapi(addDefaultToOpenApi({
                 type: "string",
                 example: "https://short.url/abc123",
-            });
+            }));
         }
         else if (column.type === TableColumnType.Markdown) {
-            zodType = z.string().openapi({
+            zodType = z.string().openapi(addDefaultToOpenApi({
                 type: "string",
                 example: "# Heading\n\nThis is **markdown** content",
-            });
+            }));
         }
         else if (column.type === TableColumnType.Domain) {
             zodType = Domain.getSchema();
         }
         else if (column.type === TableColumnType.LongURL) {
-            zodType = z.string().url().openapi({
+            zodType = z.string().url().openapi(addDefaultToOpenApi({
                 type: "string",
                 example: "https://www.example.com/path/to/resource?param=value",
-            });
+            }));
         }
         else if (column.type === TableColumnType.OTP) {
-            zodType = z.string().openapi({
+            zodType = z.string().openapi(addDefaultToOpenApi({
                 type: "string",
                 example: "123456",
-            });
+            }));
         }
         else if (column.type === TableColumnType.HTML) {
-            zodType = z.string().openapi({
+            zodType = z.string().openapi(addDefaultToOpenApi({
                 type: "string",
                 example: "<div><h1>Title</h1><p>Content</p></div>",
-            });
+            }));
         }
         else if (column.type === TableColumnType.JavaScript) {
-            zodType = z.string().openapi({
+            zodType = z.string().openapi(addDefaultToOpenApi({
                 type: "string",
                 example: "function example() { return true; }",
-            });
+            }));
         }
         else if (column.type === TableColumnType.CSS) {
-            zodType = z.string().openapi({
+            zodType = z.string().openapi(addDefaultToOpenApi({
                 type: "string",
                 example: "body { color: #333; margin: 0; }",
-            });
+            }));
         }
         else if (column.type === TableColumnType.Array) {
-            zodType = z.array(z.any()).openapi({
+            zodType = z.array(z.any()).openapi(addDefaultToOpenApi({
                 type: "array",
                 items: {
                     type: "string",
                 },
                 example: ["item1", "item2", "item3"],
-            });
+            }));
         }
         else if (column.type === TableColumnType.SmallPositiveNumber) {
-            zodType = z.number().int().nonnegative().openapi({
+            zodType = z.number().int().nonnegative().openapi(addDefaultToOpenApi({
                 type: "integer",
                 example: 5,
-            });
+            }));
         }
         else if (column.type === TableColumnType.BigPositiveNumber) {
-            zodType = z.number().nonnegative().openapi({
+            zodType = z.number().nonnegative().openapi(addDefaultToOpenApi({
                 type: "number",
                 example: 1000000,
-            });
+            }));
         }
         else if (column.type === TableColumnType.SmallNumber) {
-            zodType = z.number().int().openapi({
+            zodType = z.number().int().openapi(addDefaultToOpenApi({
                 type: "integer",
                 example: 10,
-            });
+            }));
         }
         else if (column.type === TableColumnType.BigNumber) {
-            zodType = z.number().openapi({
+            zodType = z.number().openapi(addDefaultToOpenApi({
                 type: "number",
                 example: 1000000,
-            });
+            }));
         }
         else if (column.type === TableColumnType.Permission) {
-            zodType = z.any().openapi({
+            zodType = z.any().openapi(addDefaultToOpenApi({
                 type: "object",
                 example: { read: true, write: false, delete: false },
-            });
+            }));
         }
         else if (column.type === TableColumnType.CustomFieldType) {
-            zodType = z.any().openapi({
+            zodType = z.any().openapi(addDefaultToOpenApi({
                 type: "object",
                 example: { type: "text", required: true },
-            });
+            }));
         }
         else if (column.type === TableColumnType.MonitorType) {
-            zodType = z.string().openapi({
+            zodType = z.string().openapi(addDefaultToOpenApi({
                 type: "string",
                 example: "HTTP",
-            });
+            }));
         }
         else if (column.type === TableColumnType.WorkflowStatus) {
-            zodType = z.string().openapi({
+            zodType = z.string().openapi(addDefaultToOpenApi({
                 type: "string",
                 example: "In Progress",
-            });
+            }));
         }
         else if (column.type === TableColumnType.Boolean) {
-            zodType = z.boolean().openapi({ type: "boolean", example: true });
+            zodType = z.boolean().openapi(addDefaultToOpenApi({ type: "boolean", example: true }));
         }
         else if (column.type === TableColumnType.JSON) {
-            zodType = z.any().openapi({
+            zodType = z.any().openapi(addDefaultToOpenApi({
                 type: "object",
                 example: { key: "value", nested: { data: 123 } },
-            });
+            }));
         }
         else if (column.type === TableColumnType.EntityArray) {
             const entityArrayType = column.modelType;
             if (!entityArrayType) {
-                return z.any().openapi({
+                return z.any().openapi(addDefaultToOpenApi({
                     type: "array",
                     items: { type: "object" },
                     example: [],
-                });
+                }));
             }
             // Use the appropriate schema method based on the operation type
             let schemaMethod;
@@ -1187,7 +1273,7 @@ export class ModelSchema extends BaseSchema {
                     modelType: entityArrayType,
                 });
             }))
-                .openapi({
+                .openapi(addDefaultToOpenApi({
                 type: "array",
                 items: {
                     type: "object",
@@ -1196,16 +1282,16 @@ export class ModelSchema extends BaseSchema {
                     },
                 },
                 example: [{ id: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" }],
-            });
+            }));
         }
         else if (column.type === TableColumnType.Entity) {
             const entityType = column.modelType;
             if (!entityType) {
-                return z.any().openapi({
+                return z.any().openapi(addDefaultToOpenApi({
                     type: "object",
                     description: "Entity reference",
                     example: { _id: "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa" },
-                });
+                }));
             }
             // Use the appropriate schema method based on the operation type
             let schema;
@@ -1227,13 +1313,21 @@ export class ModelSchema extends BaseSchema {
                 .lazy(() => {
                 return schema;
             })
-                .openapi({
+                .openapi(addDefaultToOpenApi({
                 type: "object",
                 example: { id: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" },
-            });
+            }));
         }
         else {
-            zodType = z.any().openapi({ type: "null", example: null });
+            zodType = z.any().openapi(addDefaultToOpenApi({ type: "null", example: null }));
+        }
+        // Apply default value if it exists in the column metadata
+        if (column.defaultValue !== undefined && column.defaultValue !== null) {
+            zodType = zodType.default(column.defaultValue);
+        }
+        // Mark computed fields as readOnly in OpenAPI spec
+        if (column.computed) {
+            zodType = zodType.openapi({ readOnly: true });
         }
         return zodType;
     }