@oneuptime/common 10.0.28 → 10.0.30

package/Server/Infrastructure/Postgres/SchemaMigrations/1773344537755-MigrationName.ts

@@ -0,0 +1,91 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1773344537755 implements MigrationInterface {
+  public name = "MigrationName1773344537755";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "LogSavedView" DROP CONSTRAINT "FK_56e1d744839c4e59c50de300a9d"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "LogSavedView" DROP CONSTRAINT "FK_fa55f4b8cb6e6ce31554b7b021f"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "LogSavedView" DROP CONSTRAINT "FK_8bd2b62c5f269dc8b2c74da0f27"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_56e1d744839c4e59c50de300a9"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_80241afbecf0a3749cc775f93f"`,
+    );
+    await queryRunner.query(`ALTER TABLE "LogSavedView" DROP COLUMN "name"`);
+    await queryRunner.query(
+      `ALTER TABLE "LogSavedView" ADD "name" character varying(50) NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_fd2dce79ac83d56416311f50e5" ON "LogSavedView" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_0f23bc454fb9a7dbecaeee6b93" ON "LogSavedView" ("isDefault") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "LogSavedView" ADD CONSTRAINT "FK_fd2dce79ac83d56416311f50e52" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "LogSavedView" ADD CONSTRAINT "FK_93663ad4128292e6a57f5950ab9" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "LogSavedView" ADD CONSTRAINT "FK_a7817e3946945d28ef65a81e173" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "LogSavedView" DROP CONSTRAINT "FK_a7817e3946945d28ef65a81e173"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "LogSavedView" DROP CONSTRAINT "FK_93663ad4128292e6a57f5950ab9"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "LogSavedView" DROP CONSTRAINT "FK_fd2dce79ac83d56416311f50e52"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_0f23bc454fb9a7dbecaeee6b93"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_fd2dce79ac83d56416311f50e5"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type": "RestrictionTimes", "value": {"restictionType": "None", "dayRestrictionTimes": null, "weeklyRestrictionTimes": []}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type": "Recurring", "value": {"intervalType": "Day", "intervalCount": {"_type": "PositiveNumber", "value": 1}}}'`,
+    );
+    await queryRunner.query(`ALTER TABLE "LogSavedView" DROP COLUMN "name"`);
+    await queryRunner.query(
+      `ALTER TABLE "LogSavedView" ADD "name" character varying(100) NOT NULL`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_80241afbecf0a3749cc775f93f" ON "LogSavedView" ("isDefault") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_56e1d744839c4e59c50de300a9" ON "LogSavedView" ("projectId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "LogSavedView" ADD CONSTRAINT "FK_8bd2b62c5f269dc8b2c74da0f27" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "LogSavedView" ADD CONSTRAINT "FK_fa55f4b8cb6e6ce31554b7b021f" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "LogSavedView" ADD CONSTRAINT "FK_56e1d744839c4e59c50de300a9d" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -262,6 +262,8 @@ import { MigrationName1770834237091 } from "./1770834237091-MigrationName";
 import { MigrationName1772111896988 } from "./1772111896988-MigrationName";
 import { MigrationName1772280000000 } from "./1772280000000-MigrationName";
 import { MigrationName1772350000000 } from "./1772350000000-MigrationName";
+import { AddLogSavedView1772355000000 } from "./1772355000000-AddLogSavedView";
+import { MigrationName1773344537755 } from "./1773344537755-MigrationName";
 
 export default [
   InitialMigration,
@@ -528,4 +530,6 @@ export default [
   MigrationName1772111896988,
   MigrationName1772280000000,
   MigrationName1772350000000,
+  AddLogSavedView1772355000000,
+  MigrationName1773344537755,
 ];

package/Server/Services/LogAggregationService.ts

@@ -44,6 +44,42 @@ export interface FacetRequest {
   spanIds?: Array<string> | undefined;
 }
 
+export type AnalyticsChartType = "timeseries" | "toplist" | "table";
+export type AnalyticsAggregation = "count" | "unique";
+
+export interface AnalyticsRequest {
+  projectId: ObjectID;
+  startTime: Date;
+  endTime: Date;
+  bucketSizeInMinutes: number;
+  chartType: AnalyticsChartType;
+  groupBy?: Array<string> | undefined;
+  aggregation: AnalyticsAggregation;
+  aggregationField?: string | undefined;
+  serviceIds?: Array<ObjectID> | undefined;
+  severityTexts?: Array<string> | undefined;
+  bodySearchText?: string | undefined;
+  traceIds?: Array<string> | undefined;
+  spanIds?: Array<string> | undefined;
+  limit?: number | undefined;
+}
+
+export interface AnalyticsTimeseriesRow {
+  time: string;
+  count: number;
+  groupValues: Record<string, string>;
+}
+
+export interface AnalyticsTopItem {
+  value: string;
+  count: number;
+}
+
+export interface AnalyticsTableRow {
+  groupValues: Record<string, string>;
+  count: number;
+}
+
 export class LogAggregationService {
   private static readonly DEFAULT_FACET_LIMIT: number = 500;
   private static readonly TABLE_NAME: string = "LogItem";
@@ -197,6 +233,357 @@ export class LogAggregationService {
     return statement;
   }
 
+  private static readonly DEFAULT_ANALYTICS_LIMIT: number = 10;
+  private static readonly MAX_GROUP_BY_DIMENSIONS: number = 2;
+
+  @CaptureSpan()
+  public static async getAnalyticsTimeseries(
+    request: AnalyticsRequest,
+  ): Promise<Array<AnalyticsTimeseriesRow>> {
+    const statement: Statement =
+      LogAggregationService.buildAnalyticsTimeseriesStatement(request);
+
+    const dbResult: Results = await LogDatabaseService.executeQuery(statement);
+    const response: DbJSONResponse = await dbResult.json<{
+      data?: Array<JSONObject>;
+    }>();
+
+    const rows: Array<JSONObject> = response.data || [];
+    const groupByKeys: Array<string> = request.groupBy || [];
+
+    return rows.map((row: JSONObject): AnalyticsTimeseriesRow => {
+      const groupValues: Record<string, string> = {};
+
+      for (const key of groupByKeys) {
+        const alias: string = LogAggregationService.groupByAlias(key);
+        groupValues[key] = String(row[alias] || "");
+      }
+
+      return {
+        time: String(row["bucket"] || ""),
+        count: Number(row["cnt"] || 0),
+        groupValues,
+      };
+    });
+  }
+
+  @CaptureSpan()
+  public static async getAnalyticsTopList(
+    request: AnalyticsRequest,
+  ): Promise<Array<AnalyticsTopItem>> {
+    if (!request.groupBy || request.groupBy.length === 0) {
+      throw new BadDataException(
+        "groupBy with at least one dimension is required for top list",
+      );
+    }
+
+    const statement: Statement =
+      LogAggregationService.buildAnalyticsTopListStatement(request);
+
+    const dbResult: Results = await LogDatabaseService.executeQuery(statement);
+    const response: DbJSONResponse = await dbResult.json<{
+      data?: Array<JSONObject>;
+    }>();
+
+    const rows: Array<JSONObject> = response.data || [];
+
+    return rows
+      .map((row: JSONObject): AnalyticsTopItem => {
+        return {
+          value: String(row["val"] || ""),
+          count: Number(row["cnt"] || 0),
+        };
+      })
+      .filter((item: AnalyticsTopItem): boolean => {
+        return item.value.length > 0;
+      });
+  }
+
+  @CaptureSpan()
+  public static async getAnalyticsTable(
+    request: AnalyticsRequest,
+  ): Promise<Array<AnalyticsTableRow>> {
+    if (!request.groupBy || request.groupBy.length === 0) {
+      throw new BadDataException(
+        "groupBy with at least one dimension is required for table",
+      );
+    }
+
+    const statement: Statement =
+      LogAggregationService.buildAnalyticsTableStatement(request);
+
+    const dbResult: Results = await LogDatabaseService.executeQuery(statement);
+    const response: DbJSONResponse = await dbResult.json<{
+      data?: Array<JSONObject>;
+    }>();
+
+    const rows: Array<JSONObject> = response.data || [];
+    const groupByKeys: Array<string> = request.groupBy;
+
+    return rows.map((row: JSONObject): AnalyticsTableRow => {
+      const groupValues: Record<string, string> = {};
+
+      for (const key of groupByKeys) {
+        const alias: string = LogAggregationService.groupByAlias(key);
+        groupValues[key] = String(row[alias] || "");
+      }
+
+      return {
+        groupValues,
+        count: Number(row["cnt"] || 0),
+      };
+    });
+  }
+
+  private static groupByAlias(key: string): string {
+    if (LogAggregationService.isTopLevelColumn(key)) {
+      return key;
+    }
+
+    // For attribute keys, use a sanitized alias
+    return `attr_${key.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+  }
+
+  private static appendGroupBySelect(
+    statement: Statement,
+    groupByKeys: Array<string>,
+  ): void {
+    for (const key of groupByKeys) {
+      LogAggregationService.validateFacetKey(key);
+
+      if (LogAggregationService.isTopLevelColumn(key)) {
+        statement.append(`, toString(${key}) AS ${key}`);
+      } else {
+        const alias: string = LogAggregationService.groupByAlias(key);
+        statement.append(
+          SQL`, JSONExtractRaw(attributes, ${{
+            type: TableColumnType.Text,
+            value: key,
+          }}) AS ${alias}`,
+        );
+      }
+    }
+  }
+
+  private static appendGroupByClause(
+    statement: Statement,
+    groupByKeys: Array<string>,
+  ): void {
+    for (const key of groupByKeys) {
+      if (LogAggregationService.isTopLevelColumn(key)) {
+        statement.append(`, ${key}`);
+      } else {
+        const alias: string = LogAggregationService.groupByAlias(key);
+        statement.append(`, ${alias}`);
+      }
+    }
+  }
+
+  private static getAggregationExpression(request: AnalyticsRequest): string {
+    if (request.aggregation === "unique" && request.aggregationField) {
+      LogAggregationService.validateFacetKey(request.aggregationField);
+
+      if (LogAggregationService.isTopLevelColumn(request.aggregationField)) {
+        return `uniqExact(${request.aggregationField})`;
+      }
+
+      return `uniqExact(JSONExtractRaw(attributes, '${request.aggregationField.replace(/'/g, "\\'")}'))`;
+    }
+
+    return "count()";
+  }
+
+  private static validateGroupBy(groupBy: Array<string> | undefined): void {
+    if (!groupBy) {
+      return;
+    }
+
+    if (groupBy.length > LogAggregationService.MAX_GROUP_BY_DIMENSIONS) {
+      throw new BadDataException(
+        `groupBy supports at most ${LogAggregationService.MAX_GROUP_BY_DIMENSIONS} dimensions`,
+      );
+    }
+
+    for (const key of groupBy) {
+      LogAggregationService.validateFacetKey(key);
+    }
+  }
+
+  private static buildAnalyticsTimeseriesStatement(
+    request: AnalyticsRequest,
+  ): Statement {
+    LogAggregationService.validateGroupBy(request.groupBy);
+
+    const intervalSeconds: number = request.bucketSizeInMinutes * 60;
+    const aggExpr: string =
+      LogAggregationService.getAggregationExpression(request);
+
+    const statement: Statement = SQL`
+      SELECT
+        toStartOfInterval(time, INTERVAL ${{
+          type: TableColumnType.Number,
+          value: intervalSeconds,
+        }} SECOND) AS bucket`;
+
+    statement.append(`, ${aggExpr} AS cnt`);
+
+    if (request.groupBy && request.groupBy.length > 0) {
+      LogAggregationService.appendGroupBySelect(statement, request.groupBy);
+    }
+
+    statement.append(
+      SQL`
+      FROM ${LogAggregationService.TABLE_NAME}
+      WHERE projectId = ${{
+        type: TableColumnType.ObjectID,
+        value: request.projectId,
+      }}
+        AND time >= ${{
+          type: TableColumnType.Date,
+          value: request.startTime,
+        }}
+        AND time <= ${{
+          type: TableColumnType.Date,
+          value: request.endTime,
+        }}`,
+    );
+
+    LogAggregationService.appendCommonFilters(statement, request);
+
+    statement.append(" GROUP BY bucket");
+
+    if (request.groupBy && request.groupBy.length > 0) {
+      LogAggregationService.appendGroupByClause(statement, request.groupBy);
+    }
+
+    statement.append(" ORDER BY bucket ASC");
+
+    return statement;
+  }
+
+  private static buildAnalyticsTopListStatement(
+    request: AnalyticsRequest,
+  ): Statement {
+    const groupByKey: string = request.groupBy![0]!;
+    LogAggregationService.validateFacetKey(groupByKey);
+
+    const limit: number =
+      request.limit ?? LogAggregationService.DEFAULT_ANALYTICS_LIMIT;
+    const aggExpr: string =
+      LogAggregationService.getAggregationExpression(request);
+
+    const isTopLevel: boolean =
+      LogAggregationService.isTopLevelColumn(groupByKey);
+
+    const statement: Statement = new Statement();
+
+    if (isTopLevel) {
+      statement.append(
+        `SELECT toString(${groupByKey}) AS val, ${aggExpr} AS cnt FROM ${LogAggregationService.TABLE_NAME}`,
+      );
+    } else {
+      statement.append(`SELECT JSONExtractRaw(attributes, `);
+      statement.append(
+        SQL`${{
+          type: TableColumnType.Text,
+          value: groupByKey,
+        }}`,
+      );
+      statement.append(
+        `) AS val, ${aggExpr} AS cnt FROM ${LogAggregationService.TABLE_NAME}`,
+      );
+    }
+
+    statement.append(
+      SQL` WHERE projectId = ${{
+        type: TableColumnType.ObjectID,
+        value: request.projectId,
+      }} AND time >= ${{
+        type: TableColumnType.Date,
+        value: request.startTime,
+      }} AND time <= ${{
+        type: TableColumnType.Date,
+        value: request.endTime,
+      }}`,
+    );
+
+    if (!isTopLevel) {
+      statement.append(
+        SQL` AND JSONHas(attributes, ${{
+          type: TableColumnType.Text,
+          value: groupByKey,
+        }}) = 1`,
+      );
+    }
+
+    LogAggregationService.appendCommonFilters(statement, request);
+
+    statement.append(
+      SQL` GROUP BY val ORDER BY cnt DESC LIMIT ${{
+        type: TableColumnType.Number,
+        value: limit,
+      }}`,
+    );
+
+    return statement;
+  }
+
+  private static buildAnalyticsTableStatement(
+    request: AnalyticsRequest,
+  ): Statement {
+    LogAggregationService.validateGroupBy(request.groupBy);
+
+    const groupByKeys: Array<string> = request.groupBy!;
+    const limit: number =
+      request.limit ?? LogAggregationService.DEFAULT_ANALYTICS_LIMIT;
+    const aggExpr: string =
+      LogAggregationService.getAggregationExpression(request);
+
+    const statement: Statement = new Statement();
+    statement.append(`SELECT ${aggExpr} AS cnt`);
+
+    LogAggregationService.appendGroupBySelect(statement, groupByKeys);
+
+    statement.append(
+      SQL`
+      FROM ${LogAggregationService.TABLE_NAME}
+      WHERE projectId = ${{
+        type: TableColumnType.ObjectID,
+        value: request.projectId,
+      }}
+        AND time >= ${{
+          type: TableColumnType.Date,
+          value: request.startTime,
+        }}
+        AND time <= ${{
+          type: TableColumnType.Date,
+          value: request.endTime,
+        }}`,
+    );
+
+    LogAggregationService.appendCommonFilters(statement, request);
+
+    // Build GROUP BY from aliases
+    const aliases: Array<string> = groupByKeys.map((key: string) => {
+      if (LogAggregationService.isTopLevelColumn(key)) {
+        return key;
+      }
+
+      return LogAggregationService.groupByAlias(key);
+    });
+
+    statement.append(` GROUP BY ${aliases.join(", ")}`);
+
+    statement.append(
+      SQL` ORDER BY cnt DESC LIMIT ${{
+        type: TableColumnType.Number,
+        value: limit,
+      }}`,
+    );
+
+    return statement;
+  }
+
   private static appendCommonFilters(
     statement: Statement,
     request: Pick<

package/Server/Services/LogSavedViewService.ts

@@ -0,0 +1,109 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/LogSavedView";
+import CreateBy from "../Types/Database/CreateBy";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import UpdateBy from "../Types/Database/UpdateBy";
+import ObjectID from "../../Types/ObjectID";
+import QueryHelper from "../Types/Database/QueryHelper";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    if (createBy.data.isDefault === undefined && createBy.data.projectId) {
+      const existingDefaultView: Model | null = await this.findOneBy({
+        query: {
+          projectId: createBy.data.projectId,
+          isDefault: true,
+        },
+        select: {
+          _id: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      createBy.data.isDefault = !existingDefaultView;
+    }
+
+    if (createBy.data.projectId) {
+      await this.unsetOtherDefaultsIfNeeded({
+        projectId: createBy.data.projectId,
+        isDefault: createBy.data.isDefault || false,
+      });
+    }
+
+    return { createBy, carryForward: null };
+  }
+
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    if (updateBy.data.isDefault !== true) {
+      return { updateBy, carryForward: null };
+    }
+
+    const itemsToUpdate: Array<Model> = await this.findBy({
+      query: updateBy.query,
+      select: {
+        _id: true,
+        projectId: true,
+      },
+      props: {
+        isRoot: true,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+    });
+
+    for (const item of itemsToUpdate) {
+      if (item.projectId) {
+        await this.unsetOtherDefaultsIfNeeded({
+          projectId: item.projectId,
+          isDefault: true,
+          excludeIds: item._id ? [item._id] : [],
+        });
+      }
+    }
+
+    return { updateBy, carryForward: null };
+  }
+
+  private async unsetOtherDefaultsIfNeeded(data: {
+    projectId?: ObjectID;
+    isDefault?: boolean;
+    excludeIds?: Array<string>;
+  }): Promise<void> {
+    if (!data.projectId || !data.isDefault) {
+      return;
+    }
+
+    await this.updateBy({
+      query: {
+        projectId: data.projectId,
+        isDefault: true,
+        ...(data.excludeIds && data.excludeIds.length > 0
+          ? {
+              _id: QueryHelper.notInOrNull(data.excludeIds),
+            }
+          : {}),
+      },
+      data: {
+        isDefault: false,
+      },
+      props: {
+        isRoot: true,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+    });
+  }
+}
+
+export default new Service();

package/Server/Types/Workflow/Components/BaseModel/OnTriggerBaseModel.ts

@@ -138,6 +138,21 @@ export default class OnTriggerBaseModel<
       select = JSONFunctions.parse(select) as Select<TBaseModel>;
     }
 
+    /*
+     * Convert string "true"/"false" values to booleans in select.
+     * Workflow arguments may pass select values as strings (e.g. "true")
+     * which causes TypeORM to iterate string characters as property indices.
+     */
+    if (select && typeof select === "object") {
+      for (const key in select) {
+        if ((select as any)[key] === "true") {
+          (select as any)[key] = true;
+        } else if ((select as any)[key] === "false") {
+          (select as any)[key] = false;
+        }
+      }
+    }
+
     const model: TBaseModel | null = await this.service!.findOneById({
       id: new ObjectID(data["_id"].toString()),
       props: {

package/Server/Utils/Express.ts

@@ -21,6 +21,7 @@ export type NextFunction = express.NextFunction;
 export const ExpressStatic: GenericFunction = express.static;
 export const ExpressJson: GenericFunction = express.json;
 export const ExpressUrlEncoded: GenericFunction = express.urlencoded;
+export const ExpressRaw: GenericFunction = express.raw;
 
 export type ProbeRequest = {
   id: ObjectID;

package/Server/Utils/OpenAPI.ts

@@ -257,6 +257,20 @@ export default class OpenAPIUtil {
                 query: { $ref: `#/components/schemas/${querySchemaName}` },
                 select: { $ref: `#/components/schemas/${selectSchemaName}` },
                 sort: { $ref: `#/components/schemas/${sortSchemaName}` },
+                limit: {
+                  type: "number",
+                  description:
+                    "Maximum number of items to return. Defaults to 10.",
+                  default: 10,
+                  minimum: 1,
+                },
+                skip: {
+                  type: "number",
+                  description:
+                    "Number of items to skip for pagination. Defaults to 0.",
+                  default: 0,
+                  minimum: 0,
+                },
               },
             },
           },
@@ -891,6 +905,20 @@ export default class OpenAPIUtil {
                 select: { $ref: `#/components/schemas/${selectSchemaName}` },
                 sort: { $ref: `#/components/schemas/${sortSchemaName}` },
                 groupBy: { $ref: `#/components/schemas/${groupBySchemaName}` },
+                limit: {
+                  type: "number",
+                  description:
+                    "Maximum number of items to return. Defaults to 10.",
+                  default: 10,
+                  minimum: 1,
+                },
+                skip: {
+                  type: "number",
+                  description:
+                    "Number of items to skip for pagination. Defaults to 0.",
+                  default: 0,
+                  minimum: 0,
+                },
               },
             },
           },