@oneuptime/common 10.2.1 → 10.2.2

package/Server/API/ProjectOIDC.ts

@@ -0,0 +1,73 @@
+import ProjectOidcService, {
+  Service as ProjectOidcServiceType,
+} from "../Services/ProjectOidcService";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import PositiveNumber from "../../Types/PositiveNumber";
+import ProjectOIDC from "../../Models/DatabaseModels/ProjectOidc";
+
+export default class ProjectOidcAPI extends BaseAPI<
+  ProjectOIDC,
+  ProjectOidcServiceType
+> {
+  public constructor() {
+    super(ProjectOIDC, ProjectOidcService);
+
+    // OIDC Fetch API
+    this.router.post(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/:projectId/oidc-list`,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const projectId: ObjectID = new ObjectID(
+            req.params["projectId"] as string,
+          );
+
+          if (!projectId) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid project id."),
+            );
+          }
+
+          const oidc: Array<ProjectOIDC> = await this.service.findBy({
+            query: {
+              projectId: projectId,
+              isEnabled: true,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            select: {
+              name: true,
+              description: true,
+              _id: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          return Response.sendEntityArrayResponse(
+            req,
+            res,
+            oidc,
+            new PositiveNumber(oidc.length),
+            ProjectOIDC,
+          );
+        } catch (err) {
+          return next(err);
+        }
+      },
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1778506655291-AddProjectOIDC.ts

@@ -0,0 +1,79 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddProjectOIDC1778506655291 implements MigrationInterface {
+  name = "AddProjectOIDC1778506655291";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "ProjectOIDC" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "projectId" uuid NOT NULL, "name" character varying(100) NOT NULL, "description" character varying NOT NULL, "discoveryURL" text NOT NULL, "issuerURL" text NOT NULL, "clientId" character varying(100) NOT NULL, "clientSecret" character varying NOT NULL, "scopes" character varying(100) NOT NULL, "emailClaimName" character varying(100) NOT NULL, "nameClaimName" character varying(100) NOT NULL, "createdByUserId" uuid, "deletedByUserId" uuid, "isEnabled" boolean NOT NULL DEFAULT false, "isTested" boolean NOT NULL DEFAULT false, CONSTRAINT "PK_22abf8119bac3f7f4f9f03b201f" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_b5b93c3e2885549c370b816194" ON "ProjectOIDC" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "ProjectOidcTeam" ("projectOidcId" uuid NOT NULL, "teamId" uuid NOT NULL, CONSTRAINT "PK_bdae022f28d23653e2aa4a40abb" PRIMARY KEY ("projectOidcId", "teamId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_8c317a3effac6698ad8dfbc82d" ON "ProjectOidcTeam" ("projectOidcId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_456cebe2924528d694b29f91bc" ON "ProjectOidcTeam" ("teamId") `,
+    );
+    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(
+      `ALTER TABLE "ProjectOIDC" ADD CONSTRAINT "FK_b5b93c3e2885549c370b8161940" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOIDC" ADD CONSTRAINT "FK_df47207e1005bef42ca062f7a4b" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOIDC" ADD CONSTRAINT "FK_3f386ff54e38e36f4c016187648" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOidcTeam" ADD CONSTRAINT "FK_8c317a3effac6698ad8dfbc82d4" FOREIGN KEY ("projectOidcId") REFERENCES "ProjectOIDC"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOidcTeam" ADD CONSTRAINT "FK_456cebe2924528d694b29f91bc9" FOREIGN KEY ("teamId") REFERENCES "Team"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOidcTeam" DROP CONSTRAINT "FK_456cebe2924528d694b29f91bc9"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOidcTeam" DROP CONSTRAINT "FK_8c317a3effac6698ad8dfbc82d4"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOIDC" DROP CONSTRAINT "FK_3f386ff54e38e36f4c016187648"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOIDC" DROP CONSTRAINT "FK_df47207e1005bef42ca062f7a4b"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOIDC" DROP CONSTRAINT "FK_b5b93c3e2885549c370b8161940"`,
+    );
+    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(
+      `DROP INDEX "public"."IDX_456cebe2924528d694b29f91bc"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_8c317a3effac6698ad8dfbc82d"`,
+    );
+    await queryRunner.query(`DROP TABLE "ProjectOidcTeam"`);
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_b5b93c3e2885549c370b816194"`,
+    );
+    await queryRunner.query(`DROP TABLE "ProjectOIDC"`);
+  }
+}

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

@@ -312,6 +312,7 @@ import { AddOwnerRuleInheritFlags1778413144103 } from "./1778413144103-AddOwnerR
 import { AddAlertIsPrivate1778438949454 } from "./1778438949454-AddAlertIsPrivate";
 import { AddPrivacyRules1778440665575 } from "./1778440665575-AddPrivacyRules";
 import { AddEpisodePrivacyRules1778442385970 } from "./1778442385970-AddEpisodePrivacyRules";
+import { AddProjectOIDC1778506655291 } from "./1778506655291-AddProjectOIDC";
 export default [
   InitialMigration,
   MigrationName1717678334852,
@@ -627,4 +628,5 @@ export default [
   AddAlertIsPrivate1778438949454,
   AddPrivacyRules1778440665575,
   AddEpisodePrivacyRules1778442385970,
+  AddProjectOIDC1778506655291,
 ];

package/Server/Services/Index.ts

@@ -85,6 +85,7 @@ import ProfileSampleService from "./ProfileSampleService";
 // Project SMTP Config.
 import ProjectSmtpConfigService from "./ProjectSmtpConfigService";
 import ProjectSsoService from "./ProjectSsoService";
+import ProjectOidcService from "./ProjectOidcService";
 import PromoCodeService from "./PromoCodeService";
 import EnterpriseLicenseService from "./EnterpriseLicenseService";
 import OpenSourceDeploymentService from "./OpenSourceDeploymentService";
@@ -300,6 +301,7 @@ const services: Array<BaseService> = [
   AIAgentTaskLogService,
   AIAgentTaskPullRequestService,
   ProjectSsoService,
+  ProjectOidcService,
 
   ScheduledMaintenanceCustomFieldService,
   ScheduledMaintenanceInternalNoteService,

package/Server/Services/OnCallDutyPolicyScheduleService.ts

@@ -1,12 +1,18 @@
 import DatabaseService from "./DatabaseService";
 import OnCallDutyPolicyScheduleLayerService from "./OnCallDutyPolicyScheduleLayerService";
 import OnCallDutyPolicyScheduleLayerUserService from "./OnCallDutyPolicyScheduleLayerUserService";
+import OnCallDutyPolicyUserOverrideService from "./OnCallDutyPolicyUserOverrideService";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import CalendarEvent from "../../Types/Calendar/CalendarEvent";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import OneUptimeDate from "../../Types/Date";
 import ObjectID from "../../Types/ObjectID";
 import LayerUtil, { LayerProps } from "../../Types/OnCallDutyPolicy/Layer";
+import UserOverrideUtil, {
+  UserOverrideRecord,
+} from "../../Types/OnCallDutyPolicy/UserOverrideUtil";
+import OnCallDutyPolicyUserOverride from "../../Models/DatabaseModels/OnCallDutyPolicyUserOverride";
+import QueryHelper from "../Types/Database/QueryHelper";
 import OnCallDutyPolicyScheduleLayer from "../../Models/DatabaseModels/OnCallDutyPolicyScheduleLayer";
 import OnCallDutyPolicyScheduleLayerUser from "../../Models/DatabaseModels/OnCallDutyPolicyScheduleLayerUser";
 import User from "../../Models/DatabaseModels/User";
@@ -914,9 +920,11 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
     return resultReturn;
   }
 
-  private async getScheduleLayerProps(data: {
-    scheduleId: ObjectID;
-  }): Promise<Array<LayerProps>> {
+  private async getScheduleLayerProps(data: { scheduleId: ObjectID }): Promise<{
+    layerProps: Array<LayerProps>;
+    projectId: ObjectID | null;
+    scheduleUserIds: Array<ObjectID>;
+  }> {
     // get schedule layers.
 
     const scheduleId: ObjectID = data.scheduleId;
@@ -968,23 +976,34 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       });
 
     const layerProps: Array<LayerProps> = [];
+    const scheduleUserIds: Array<ObjectID> = [];
+    const seenUserIds: Set<string> = new Set<string>();
 
     for (const layer of layers) {
+      const usersForLayer: Array<User> = layerUsers
+        .filter((layerUser: OnCallDutyPolicyScheduleLayerUser) => {
+          return (
+            layerUser.onCallDutyPolicyScheduleLayerId?.toString() ===
+            layer.id?.toString()
+          );
+        })
+        .map((layerUser: OnCallDutyPolicyScheduleLayerUser) => {
+          return layerUser.user!;
+        })
+        .filter((user: User) => {
+          return Boolean(user);
+        });
+
+      for (const user of usersForLayer) {
+        const idStr: string = user.id?.toString() || "";
+        if (idStr && !seenUserIds.has(idStr)) {
+          seenUserIds.add(idStr);
+          scheduleUserIds.push(user.id!);
+        }
+      }
+
       layerProps.push({
-        users:
-          layerUsers
-            .filter((layerUser: OnCallDutyPolicyScheduleLayerUser) => {
-              return (
-                layerUser.onCallDutyPolicyScheduleLayerId?.toString() ===
-                layer.id?.toString()
-              );
-            })
-            .map((layerUser: OnCallDutyPolicyScheduleLayerUser) => {
-              return layerUser.user!;
-            })
-            .filter((user: User) => {
-              return Boolean(user);
-            }) || [],
+        users: usersForLayer,
         startDateTimeOfLayer: layer.startsAt!,
         restrictionTimes: layer.restrictionTimes!,
         rotation: layer.rotation!,
@@ -992,7 +1011,65 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       });
     }
 
-    return layerProps;
+    const projectId: ObjectID | null = layers[0]?.projectId || null;
+
+    return { layerProps, projectId, scheduleUserIds };
+  }
+
+  private async fetchOverridesForSchedule(data: {
+    projectId: ObjectID;
+    scheduleUserIds: Array<ObjectID>;
+    windowStart: Date;
+    windowEnd: Date;
+  }): Promise<Array<UserOverrideRecord>> {
+    if (data.scheduleUserIds.length === 0) {
+      return [];
+    }
+
+    const overrides: Array<OnCallDutyPolicyUserOverride> =
+      await OnCallDutyPolicyUserOverrideService.findBy({
+        query: {
+          projectId: data.projectId,
+          startsAt: QueryHelper.lessThanEqualTo(data.windowEnd),
+          endsAt: QueryHelper.greaterThanEqualTo(data.windowStart),
+        },
+        select: {
+          startsAt: true,
+          endsAt: true,
+          overrideUserId: true,
+          routeAlertsToUserId: true,
+          onCallDutyPolicyId: true,
+        },
+        sort: {
+          startsAt: SortOrder.Ascending,
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    const scheduleUserIdSet: Set<string> = new Set<string>(
+      data.scheduleUserIds.map((id: ObjectID) => {
+        return id.toString();
+      }),
+    );
+
+    return overrides
+      .filter((o: OnCallDutyPolicyUserOverride) => {
+        const overrideUserId: string = o.overrideUserId?.toString() || "";
+        return scheduleUserIdSet.has(overrideUserId);
+      })
+      .map((o: OnCallDutyPolicyUserOverride): UserOverrideRecord => {
+        return {
+          overrideUserId: o.overrideUserId?.toString() || "",
+          routeAlertsToUserId: o.routeAlertsToUserId?.toString() || "",
+          startsAt: o.startsAt!,
+          endsAt: o.endsAt!,
+          onCallDutyPolicyId: o.onCallDutyPolicyId?.toString() || null,
+        };
+      });
   }
 
   public async getEventByIndexInSchedule(data: {
@@ -1006,9 +1083,10 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       } as LogAttributes,
     );
 
-    const layerProps: Array<LayerProps> = await this.getScheduleLayerProps({
-      scheduleId: data.scheduleId,
-    });
+    const { layerProps, projectId, scheduleUserIds } =
+      await this.getScheduleLayerProps({
+        scheduleId: data.scheduleId,
+      });
 
     logger.debug("Layer properties fetched: " + JSON.stringify(layerProps), {
       onCallDutyPolicyScheduleId: data.scheduleId.toString(),
@@ -1042,7 +1120,7 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       onCallDutyPolicyScheduleId: data.scheduleId.toString(),
     } as LogAttributes);
 
-    const events: Array<CalendarEvent> = this.layerUtil.getMultiLayerEvents(
+    let events: Array<CalendarEvent> = this.layerUtil.getMultiLayerEvents(
       {
         layers: layerProps,
         calendarStartDate: currentStartTime,
@@ -1053,6 +1131,23 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       },
     );
 
+    if (projectId && events.length > 0) {
+      const overrides: Array<UserOverrideRecord> =
+        await this.fetchOverridesForSchedule({
+          projectId,
+          scheduleUserIds,
+          windowStart: currentStartTime,
+          windowEnd: currentEndTime,
+        });
+
+      if (overrides.length > 0) {
+        events = UserOverrideUtil.applyOverridesToEvents({
+          events,
+          overrides,
+        });
+      }
+    }
+
     logger.debug("Events fetched: " + JSON.stringify(events), {
       onCallDutyPolicyScheduleId: data.scheduleId.toString(),
     } as LogAttributes);
@@ -1064,9 +1159,10 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
   public async getCurrentUserIdInSchedule(
     scheduleId: ObjectID,
   ): Promise<ObjectID | null> {
-    const layerProps: Array<LayerProps> = await this.getScheduleLayerProps({
-      scheduleId: scheduleId,
-    });
+    const { layerProps, projectId, scheduleUserIds } =
+      await this.getScheduleLayerProps({
+        scheduleId: scheduleId,
+      });
 
     if (layerProps.length === 0) {
       return null;
@@ -1078,7 +1174,7 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       1,
     );
 
-    const events: Array<CalendarEvent> = this.layerUtil.getMultiLayerEvents(
+    let events: Array<CalendarEvent> = this.layerUtil.getMultiLayerEvents(
       {
         layers: layerProps,
         calendarStartDate: currentStartTime,
@@ -1089,6 +1185,23 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       },
     );
 
+    if (projectId && events.length > 0) {
+      const overrides: Array<UserOverrideRecord> =
+        await this.fetchOverridesForSchedule({
+          projectId,
+          scheduleUserIds,
+          windowStart: currentStartTime,
+          windowEnd: currentEndTime,
+        });
+
+      if (overrides.length > 0) {
+        events = UserOverrideUtil.applyOverridesToEvents({
+          events,
+          overrides,
+        });
+      }
+    }
+
     const currentEvent: CalendarEvent | null = events[0] || null;
 
     if (!currentEvent) {

package/Server/Services/ProjectOidcService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/ProjectOidc";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Types/OnCallDutyPolicy/UserOverrideUtil.ts

@@ -0,0 +1,155 @@
+import CalendarEvent from "../Calendar/CalendarEvent";
+import OneUptimeDate from "../Date";
+
+export interface UserOverrideRecord {
+  overrideUserId: string;
+  routeAlertsToUserId: string;
+  startsAt: Date;
+  endsAt: Date;
+  // null/undefined means global override (applies to all on-call duty policies)
+  onCallDutyPolicyId?: string | null | undefined;
+}
+
+export interface OverrideEventMeta {
+  isOverride: true;
+  originalUserId: string;
+  overrideUserId: string;
+  overrideStartsAt: Date;
+  overrideEndsAt: Date;
+}
+
+/*
+ * CalendarEvent extends JSONObject so it accepts string-indexed metadata.
+ * We attach the override info under a known key so downstream consumers can
+ * detect and render the substitution distinctly.
+ */
+export const OVERRIDE_META_KEY: string = "_override";
+
+export default class UserOverrideUtil {
+  /**
+   * Returns true when this override should be applied on top of the schedule
+   * events. Global overrides always apply; policy-scoped overrides apply to
+   * any schedule, since a schedule's calendar shows coverage information for
+   * every user who could potentially be paged through it.
+   */
+  public static isOverrideApplicable(_override: UserOverrideRecord): boolean {
+    return true;
+  }
+
+  public static applyOverridesToEvents(data: {
+    events: Array<CalendarEvent>;
+    overrides: Array<UserOverrideRecord>;
+  }): Array<CalendarEvent> {
+    const applicable: Array<UserOverrideRecord> = data.overrides.filter(
+      UserOverrideUtil.isOverrideApplicable,
+    );
+
+    if (applicable.length === 0) {
+      return data.events;
+    }
+
+    let working: Array<CalendarEvent> = data.events;
+
+    for (const override of applicable) {
+      const next: Array<CalendarEvent> = [];
+      for (const event of working) {
+        next.push(...UserOverrideUtil.splitEventByOverride(event, override));
+      }
+      working = next;
+    }
+
+    return UserOverrideUtil.reassignEventIds(working);
+  }
+
+  private static splitEventByOverride(
+    event: CalendarEvent,
+    override: UserOverrideRecord,
+  ): Array<CalendarEvent> {
+    if (event.title !== override.overrideUserId) {
+      return [event];
+    }
+
+    // Override window doesn't overlap event window at all.
+    if (
+      OneUptimeDate.isAfter(override.startsAt, event.end) ||
+      OneUptimeDate.isSame(override.startsAt, event.end) ||
+      OneUptimeDate.isBefore(override.endsAt, event.start) ||
+      OneUptimeDate.isSame(override.endsAt, event.start)
+    ) {
+      return [event];
+    }
+
+    const overrideStart: Date = OneUptimeDate.isAfter(
+      override.startsAt,
+      event.start,
+    )
+      ? override.startsAt
+      : event.start;
+
+    const overrideEnd: Date = OneUptimeDate.isBefore(override.endsAt, event.end)
+      ? override.endsAt
+      : event.end;
+
+    const segments: Array<CalendarEvent> = [];
+
+    // Segment before the override window — original user remains on call.
+    if (OneUptimeDate.isBefore(event.start, overrideStart)) {
+      segments.push({
+        ...event,
+        end: overrideStart,
+      });
+    }
+
+    // Override window — substitute user takes over.
+    const meta: OverrideEventMeta = {
+      isOverride: true,
+      originalUserId: override.overrideUserId,
+      overrideUserId: override.routeAlertsToUserId,
+      overrideStartsAt: override.startsAt,
+      overrideEndsAt: override.endsAt,
+    };
+
+    segments.push({
+      ...event,
+      start: overrideStart,
+      end: overrideEnd,
+      title: override.routeAlertsToUserId,
+      [OVERRIDE_META_KEY]: meta as unknown as never,
+    });
+
+    // Segment after the override window — original user resumes.
+    if (OneUptimeDate.isAfter(event.end, overrideEnd)) {
+      segments.push({
+        ...event,
+        start: overrideEnd,
+      });
+    }
+
+    return segments;
+  }
+
+  private static reassignEventIds(
+    events: Array<CalendarEvent>,
+  ): Array<CalendarEvent> {
+    let id: number = 1;
+    return events.map((event: CalendarEvent) => {
+      return { ...event, id: id++ };
+    });
+  }
+
+  public static getOverrideMeta(
+    event: CalendarEvent,
+  ): OverrideEventMeta | null {
+    const meta: unknown = (event as unknown as Record<string, unknown>)[
+      OVERRIDE_META_KEY
+    ];
+    if (
+      meta &&
+      typeof meta === "object" &&
+      (meta as { isOverride?: boolean }).isOverride === true
+    ) {
+      return meta as OverrideEventMeta;
+    }
+    return null;
+  }
+}

package/Types/Permission.ts

@@ -527,6 +527,11 @@ enum Permission {
   EditProjectSSO = "EditProjectSSO",
   ReadProjectSSO = "ReadProjectSSO",
 
+  CreateProjectOIDC = "CreateProjectOIDC",
+  DeleteProjectOIDC = "DeleteProjectOIDC",
+  EditProjectOIDC = "EditProjectOIDC",
+  ReadProjectOIDC = "ReadProjectOIDC",
+
   CreateStatusPageSSO = "CreateStatusPageSSO",
   DeleteStatusPageSSO = "DeleteStatusPageSSO",
   EditStatusPageSSO = "EditStatusPageSSO",
@@ -2949,6 +2954,43 @@ export class PermissionHelper {
         group: PermissionGroup.Settings,
       },
 
+      {
+        permission: Permission.CreateProjectOIDC,
+        title: "Create Project OIDC",
+        description: "This permission can create Project OIDC in this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Settings,
+      },
+      {
+        permission: Permission.DeleteProjectOIDC,
+        title: "Delete Project OIDC",
+        description: "This permission can delete Project OIDC in this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Settings,
+      },
+      {
+        permission: Permission.EditProjectOIDC,
+        title: "Edit Project OIDC",
+        description: "This permission can edit Project OIDC in this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Settings,
+      },
+      {
+        permission: Permission.ReadProjectOIDC,
+        title: "Read Project OIDC",
+        description: "This permission can read Project OIDC in this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Settings,
+      },
+
       {
         permission: Permission.CreateStatusPageSSO,
         title: "Create Status Page SSO",