@oneuptime/common 7.0.4597 → 7.0.4646

package/Utils/Schema/AnalyticsModelSchema.ts

@@ -16,7 +16,7 @@ export class AnalyticsModelSchema extends BaseSchema {
   private static addDefaultToOpenApi(
     openApiConfig: any,
     column: AnalyticsTableColumn,
-  ) {
+  ): any {
     if (column.defaultValue !== undefined && column.defaultValue !== null) {
       return { ...openApiConfig, default: column.defaultValue };
     }
@@ -50,74 +50,135 @@ export class AnalyticsModelSchema extends BaseSchema {
       let zodType: ZodTypes.ZodTypeAny;
 
       if (column.type === TableColumnType.ObjectID) {
-        zodType = z.string().openapi(this.addDefaultToOpenApi({
-          type: "string",
-          example: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
-        }, column));
+        zodType = z.string().openapi(
+          this.addDefaultToOpenApi(
+            {
+              type: "string",
+              example: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+            },
+            column,
+          ),
+        );
       } else if (column.type === TableColumnType.Date) {
-        zodType = z.date().openapi(this.addDefaultToOpenApi({
-          type: "string",
-          format: "date-time",
-          example: "2023-01-15T12:30:00.000Z",
-        }, column));
+        zodType = z.date().openapi(
+          this.addDefaultToOpenApi(
+            {
+              type: "string",
+              format: "date-time",
+              example: "2023-01-15T12:30:00.000Z",
+            },
+            column,
+          ),
+        );
       } else if (column.type === TableColumnType.Text) {
-        zodType = z.string().openapi(this.addDefaultToOpenApi({
-          type: "string",
-          example: "Example text value",
-        }, column));
+        zodType = z.string().openapi(
+          this.addDefaultToOpenApi(
+            {
+              type: "string",
+              example: "Example text value",
+            },
+            column,
+          ),
+        );
       } else if (column.type === TableColumnType.Number) {
-        zodType = z.number().openapi(this.addDefaultToOpenApi({ type: "number", example: 42 }, column));
+        zodType = z
+          .number()
+          .openapi(
+            this.addDefaultToOpenApi({ type: "number", example: 42 }, column),
+          );
       } else if (column.type === TableColumnType.LongNumber) {
-        zodType = z.number().openapi(this.addDefaultToOpenApi({
-          type: "number",
-          example: 1000000,
-        }, column));
+        zodType = z.number().openapi(
+          this.addDefaultToOpenApi(
+            {
+              type: "number",
+              example: 1000000,
+            },
+            column,
+          ),
+        );
       } else if (column.type === TableColumnType.Boolean) {
-        zodType = z.boolean().openapi(this.addDefaultToOpenApi({ type: "boolean", example: true }, column));
+        zodType = z
+          .boolean()
+          .openapi(
+            this.addDefaultToOpenApi(
+              { type: "boolean", example: true },
+              column,
+            ),
+          );
       } else if (column.type === TableColumnType.JSON) {
-        zodType = z.any().openapi(this.addDefaultToOpenApi({
-          type: "object",
-          example: { key: "value", nested: { data: 123 } },
-        }, column));
+        zodType = z.any().openapi(
+          this.addDefaultToOpenApi(
+            {
+              type: "object",
+              example: { key: "value", nested: { data: 123 } },
+            },
+            column,
+          ),
+        );
       } else if (column.type === TableColumnType.JSONArray) {
-        zodType = z.array(z.any()).openapi(this.addDefaultToOpenApi({
-          type: "array",
-          items: {
-            type: "object",
-          },
-          example: [{ key: "value" }, { key2: "value2" }],
-        }, column));
+        zodType = z.array(z.any()).openapi(
+          this.addDefaultToOpenApi(
+            {
+              type: "array",
+              items: {
+                type: "object",
+              },
+              example: [{ key: "value" }, { key2: "value2" }],
+            },
+            column,
+          ),
+        );
       } else if (column.type === TableColumnType.Decimal) {
-        zodType = z.number().openapi(this.addDefaultToOpenApi({
-          type: "number",
-          example: 123.45,
-        }, column));
+        zodType = z.number().openapi(
+          this.addDefaultToOpenApi(
+            {
+              type: "number",
+              example: 123.45,
+            },
+            column,
+          ),
+        );
       } else if (column.type === TableColumnType.ArrayNumber) {
-        zodType = z.array(z.number()).openapi(this.addDefaultToOpenApi({
-          type: "array",
-          items: {
-            type: "number",
-          },
-          example: [1, 2, 3, 4, 5],
-        }, column));
+        zodType = z.array(z.number()).openapi(
+          this.addDefaultToOpenApi(
+            {
+              type: "array",
+              items: {
+                type: "number",
+              },
+              example: [1, 2, 3, 4, 5],
+            },
+            column,
+          ),
+        );
       } else if (column.type === TableColumnType.ArrayText) {
-        zodType = z.array(z.string()).openapi(this.addDefaultToOpenApi({
-          type: "array",
-          items: {
-            type: "string",
-          },
-          example: ["item1", "item2", "item3"],
-        }, column));
+        zodType = z.array(z.string()).openapi(
+          this.addDefaultToOpenApi(
+            {
+              type: "array",
+              items: {
+                type: "string",
+              },
+              example: ["item1", "item2", "item3"],
+            },
+            column,
+          ),
+        );
       } else if (column.type === TableColumnType.IP) {
         zodType = IP.getSchema();
       } else if (column.type === TableColumnType.Port) {
         zodType = Port.getSchema();
       } else {
         // Default fallback
-        zodType = z.any().openapi(this.addDefaultToOpenApi({
-          type: "string",
-          example: "example_value",
-        }, column));
+        zodType = z.any().openapi(
+          this.addDefaultToOpenApi(
+            {
+              type: "string",
+              example: "example_value",
+            },
+            column,
+          ),
+        );
       }
 
       // Apply default value if it exists
@@ -144,6 +205,7 @@ export class AnalyticsModelSchema extends BaseSchema {
 
   private static getZodTypeForColumn(
     column: AnalyticsTableColumn,
+    disableOpenApiSchema: boolean = false,
   ): ZodTypes.ZodTypeAny {
     switch (column.type) {
       case TableColumnType.ObjectID:
@@ -151,56 +213,120 @@ export class AnalyticsModelSchema extends BaseSchema {
       case TableColumnType.Date:
         return OneUptimeDate.getSchema();
       case TableColumnType.Text:
-        return z.string().openapi(this.addDefaultToOpenApi({
-          type: "string",
-          example: "Example text",
-        }, column));
+        return this.applyOpenApi(
+          z.string(),
+          this.addDefaultToOpenApi(
+            {
+              type: "string",
+              example: "Example text",
+            },
+            column,
+          ),
+          disableOpenApiSchema,
+        );
       case TableColumnType.Number:
-        return z.number().openapi(this.addDefaultToOpenApi({ type: "number", example: 42 }, column));
+        return this.applyOpenApi(
+          z.number(),
+          this.addDefaultToOpenApi({ type: "number", example: 42 }, column),
+          disableOpenApiSchema,
+        );
       case TableColumnType.LongNumber:
-        return z.number().openapi(this.addDefaultToOpenApi({
-          type: "number",
-          example: 1000000,
-        }, column));
+        return this.applyOpenApi(
+          z.number(),
+          this.addDefaultToOpenApi(
+            {
+              type: "number",
+              example: 1000000,
+            },
+            column,
+          ),
+          disableOpenApiSchema,
+        );
       case TableColumnType.Boolean:
-        return z.boolean().openapi(this.addDefaultToOpenApi({ type: "boolean", example: true }, column));
+        return this.applyOpenApi(
+          z.boolean(),
+          this.addDefaultToOpenApi({ type: "boolean", example: true }, column),
+          disableOpenApiSchema,
+        );
       case TableColumnType.JSON:
-        return z.any().openapi(this.addDefaultToOpenApi({
-          type: "object",
-          example: { key: "value" },
-        }, column));
+        return this.applyOpenApi(
+          z.any(),
+          this.addDefaultToOpenApi(
+            {
+              type: "object",
+              example: { key: "value" },
+            },
+            column,
+          ),
+          disableOpenApiSchema,
+        );
       case TableColumnType.JSONArray:
-        return z.array(z.any()).openapi(this.addDefaultToOpenApi({
-          type: "array",
-          items: { type: "object" },
-          example: [{ key: "value" }],
-        }, column));
+        return this.applyOpenApi(
+          z.array(z.any()),
+          this.addDefaultToOpenApi(
+            {
+              type: "array",
+              items: { type: "object" },
+              example: [{ key: "value" }],
+            },
+            column,
+          ),
+          disableOpenApiSchema,
+        );
       case TableColumnType.Decimal:
-        return z.number().openapi(this.addDefaultToOpenApi({
-          type: "number",
-          example: 123.45,
-        }, column));
+        return this.applyOpenApi(
+          z.number(),
+          this.addDefaultToOpenApi(
+            {
+              type: "number",
+              example: 123.45,
+            },
+            column,
+          ),
+          disableOpenApiSchema,
+        );
       case TableColumnType.ArrayNumber:
-        return z.array(z.number()).openapi(this.addDefaultToOpenApi({
-          type: "array",
-          items: { type: "number" },
-          example: [1, 2, 3],
-        }, column));
+        return this.applyOpenApi(
+          z.array(z.number()),
+          this.addDefaultToOpenApi(
+            {
+              type: "array",
+              items: { type: "number" },
+              example: [1, 2, 3],
+            },
+            column,
+          ),
+          disableOpenApiSchema,
+        );
       case TableColumnType.ArrayText:
-        return z.array(z.string()).openapi(this.addDefaultToOpenApi({
-          type: "array",
-          items: { type: "string" },
-          example: ["item1", "item2"],
-        }, column));
+        return this.applyOpenApi(
+          z.array(z.string()),
+          this.addDefaultToOpenApi(
+            {
+              type: "array",
+              items: { type: "string" },
+              example: ["item1", "item2"],
+            },
+            column,
+          ),
+          disableOpenApiSchema,
+        );
       case TableColumnType.IP:
         return IP.getSchema();
       case TableColumnType.Port:
         return Port.getSchema();
       default:
-        return z.any().openapi(this.addDefaultToOpenApi({
-          type: "string",
-          example: "example_value",
-        }, column));
+        return this.applyOpenApi(
+          z.any(),
+          this.addDefaultToOpenApi(
+            {
+              type: "string",
+              example: "unknown",
+            },
+            column,
+          ),
+          disableOpenApiSchema,
+        );
     }
   }
 
@@ -217,6 +343,7 @@ export class AnalyticsModelSchema extends BaseSchema {
 
   public static getCreateModelSchema(data: {
     modelType: new () => AnalyticsBaseModel;
+    disableOpenApiSchema?: boolean;
   }): AnalyticsModelSchemaType {
     const modelType: new () => AnalyticsBaseModel = data.modelType;
     const model: AnalyticsBaseModel = new modelType();
@@ -249,7 +376,10 @@ export class AnalyticsModelSchema extends BaseSchema {
         continue;
       }
 
-      let zodType: ZodTypes.ZodTypeAny = this.getZodTypeForColumn(column);
+      let zodType: ZodTypes.ZodTypeAny = this.getZodTypeForColumn(
+        column,
+        data.disableOpenApiSchema || false,
+      );
 
       // Apply default value if it exists
       zodType = this.applyDefaultValue(zodType, column);
@@ -261,16 +391,21 @@ export class AnalyticsModelSchema extends BaseSchema {
       }
     }
 
-    return z.object(shape).openapi({
-      type: "object",
-      description: `Create schema for ${model.tableName || "analytics model"}`,
-      example: this.getCreateSchemaExample(modelType),
-      additionalProperties: false,
-    });
+    return this.applyOpenApi(
+      z.object(shape),
+      {
+        type: "object",
+        description: `Create schema for ${model.tableName || "analytics model"}`,
+        example: this.getCreateSchemaExample(modelType),
+        additionalProperties: false,
+      },
+      data.disableOpenApiSchema || false,
+    );
   }
 
   public static getQueryModelSchema(data: {
     modelType: new () => AnalyticsBaseModel;
+    disableOpenApiSchema?: boolean;
   }): AnalyticsModelSchemaType {
     const modelType: new () => AnalyticsBaseModel = data.modelType;
     const model: AnalyticsBaseModel = new modelType();
@@ -299,6 +434,7 @@ export class AnalyticsModelSchema extends BaseSchema {
       getExampleValueForColumn: (columnType: TableColumnType) => {
         return this.getExampleValueForColumn(columnType);
       },
+      disableOpenApiSchema: data.disableOpenApiSchema || false,
     });
   }
 
@@ -325,6 +461,7 @@ export class AnalyticsModelSchema extends BaseSchema {
 
   public static getSortModelSchema(data: {
     modelType: new () => AnalyticsBaseModel;
+    disableOpenApiSchema?: boolean;
   }): AnalyticsModelSchemaType {
     const modelType: new () => AnalyticsBaseModel = data.modelType;
     const model: AnalyticsBaseModel = new modelType();
@@ -341,6 +478,7 @@ export class AnalyticsModelSchema extends BaseSchema {
           return { key: column.key, type: column.type };
         });
       },
+      disableOpenApiSchema: data.disableOpenApiSchema || false,
     });
   }
 

package/Utils/Schema/BaseSchema.ts

@@ -38,6 +38,7 @@ export abstract class BaseSchema {
     tableName?: string;
     getSortableTypes: () => Array<any>;
     getColumnsForSorting: (model: T) => Array<{ key: string; type: any }>;
+    disableOpenApiSchema?: boolean;
   }): BaseSchemaType {
     const shape: ShapeRecord = {};
     const columns: Array<{ key: string; type: any }> =
@@ -51,23 +52,28 @@ export abstract class BaseSchema {
         continue;
       }
 
-      shape[key] = z
-        .enum([SortOrder.Ascending, SortOrder.Descending])
-        .optional()
-        .openapi({
+      shape[key] = this.applyOpenApi(
+        z.enum([SortOrder.Ascending, SortOrder.Descending]).optional(),
+        {
           type: "string",
           enum: [SortOrder.Ascending, SortOrder.Descending],
           description: `Sort order for ${key} field`,
           example: SortOrder.Ascending,
-        });
+        },
+        data.disableOpenApiSchema || false,
+      );
     }
 
-    return z.object(shape).openapi({
-      type: "object",
-      description: `Sort schema for ${data.tableName || "model"}. Only sortable fields are included.`,
-      example: { createdAt: SortOrder.Descending },
-      additionalProperties: false,
-    });
+    return this.applyOpenApi(
+      z.object(shape),
+      {
+        type: "object",
+        description: `Sort schema for ${data.tableName || "model"}. Only sortable fields are included.`,
+        example: { createdAt: SortOrder.Descending },
+        additionalProperties: false,
+      },
+      data.disableOpenApiSchema || false,
+    );
   }
 
   /**
@@ -180,6 +186,7 @@ export abstract class BaseSchema {
     ) => ZodTypes.ZodTypeAny;
     getQuerySchemaExample: (model: T) => SchemaExample;
     getExampleValueForColumn: (columnType: any) => unknown;
+    disableOpenApiSchema?: boolean;
   }): BaseSchemaType {
     const shape: ShapeRecord = {};
     const columns: Array<{ key: string; type: any }> = data.getColumns(
@@ -233,24 +240,32 @@ export abstract class BaseSchema {
           .optional();
       }
 
-      columnSchema = columnSchema.openapi({
-        type: "object",
-        description: `Query operators for ${key} field of type ${column.type}. Supported operators: ${validOperators.join(", ")}`,
-        example: {
-          _type: "EqualTo",
-          value: data.getExampleValueForColumn(column.type),
+      columnSchema = this.applyOpenApi(
+        columnSchema,
+        {
+          type: "object",
+          description: `Query operators for ${key} field of type ${column.type}. Supported operators: ${validOperators.join(", ")}`,
+          example: {
+            _type: "EqualTo",
+            value: data.getExampleValueForColumn(column.type),
+          },
         },
-      });
+        data.disableOpenApiSchema || false,
+      );
 
       shape[key] = columnSchema;
     }
 
-    return z.object(shape).openapi({
-      type: "object",
-      description: `Query schema for ${data.tableName || "model"}. Each field can use various operators based on its data type.`,
-      example: data.getQuerySchemaExample(data.model),
-      additionalProperties: false,
-    });
+    return this.applyOpenApi(
+      z.object(shape),
+      {
+        type: "object",
+        description: `Query schema for ${data.tableName || "model"}. Each field can use various operators based on its data type.`,
+        example: data.getQuerySchemaExample(data.model),
+        additionalProperties: false,
+      },
+      data.disableOpenApiSchema || false,
+    );
   }
 
   /**
@@ -447,4 +462,18 @@ export abstract class BaseSchema {
       `${schemaType} schema for ${tableName} created with shape keys: ${Object.keys(shape).join(", ")}`,
     );
   }
+
+  /**
+   * Helper method to conditionally apply OpenAPI schema
+   */
+  protected static applyOpenApi<T extends ZodTypes.ZodTypeAny>(
+    baseType: T,
+    openApiConfig: any,
+    disableOpenApiSchema: boolean = false,
+  ): T {
+    if (disableOpenApiSchema) {
+      return baseType;
+    }
+    return baseType.openapi(openApiConfig) as T;
+  }
 }