@oneuptime/common 12.0.17 → 12.0.19

package/Server/API/UserSlackAPI.ts

@@ -0,0 +1,125 @@
+import UserMiddleware from "../Middleware/UserAuthorization";
+import UserSlackService, {
+  Service as UserSlackServiceType,
+} from "../Services/UserSlackService";
+import WorkspaceUserNotificationService from "../Services/WorkspaceUserNotificationService";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+  OneUptimeRequest,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import BadDataException from "../../Types/Exception/BadDataException";
+import UserSlack from "../../Models/DatabaseModels/UserSlack";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import { WorkspacePayloadMarkdown } from "../../Types/Workspace/WorkspaceMessagePayload";
+
+export default class UserSlackAPI extends BaseAPI<
+  UserSlack,
+  UserSlackServiceType
+> {
+  public constructor() {
+    super(UserSlack, UserSlackService);
+
+    /*
+     * Sends a test direct message to the caller's own linked Slack account,
+     * so "will a page actually reach me?" is answerable with one click
+     * instead of a real incident.
+     */
+    this.router.post(
+      `${new this.entityType().getCrudApiPath()?.toString()}/test`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          req = req as OneUptimeRequest;
+
+          if (!req.body["itemId"]) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid item ID"),
+            );
+          }
+
+          const item: UserSlack | null = await this.service.findOneById({
+            id: req.body["itemId"],
+            props: {
+              isRoot: true,
+            },
+            select: {
+              userId: true,
+              projectId: true,
+              slackUserId: true,
+              isVerified: true,
+            },
+          });
+
+          if (!item) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Item not found"),
+            );
+          }
+
+          if (
+            item.userId?.toString() !==
+            (req as OneUptimeRequest)?.userAuthorization?.userId?.toString()
+          ) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid user ID"),
+            );
+          }
+
+          if (!item.slackUserId || !item.isVerified) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException(
+                "This Slack account is not verified. Please remove it and add it again.",
+              ),
+            );
+          }
+
+          const markdownBlock: WorkspacePayloadMarkdown = {
+            _type: "WorkspacePayloadMarkdown",
+            text: "👋 This is a OneUptime test notification. Your Slack account can receive on-call notifications.",
+          };
+
+          try {
+            await WorkspaceUserNotificationService.sendDirectMessageToUser({
+              projectId: item.projectId!,
+              workspaceType: WorkspaceType.Slack,
+              workspaceUserId: item.slackUserId,
+              messageBlocks: [markdownBlock],
+              messageSummary: "Test notification",
+              userId: item.userId!,
+            });
+          } catch (err) {
+            const message: string =
+              err instanceof Error && err.message
+                ? err.message
+                : "Unknown error sending test Slack message.";
+
+            return Response.sendJsonObjectResponse(req, res, {
+              ok: false,
+              statusMessage: message,
+            });
+          }
+
+          return Response.sendJsonObjectResponse(req, res, {
+            ok: true,
+            statusMessage:
+              "Test message sent. Check your Slack direct messages.",
+          });
+        } catch (err) {
+          return next(err);
+        }
+      },
+    );
+  }
+}

package/Server/EnvironmentConfig.ts

@@ -376,116 +376,21 @@ export const AnalyticsHost: string = process.env["ANALYTICS_HOST"] || "";
 export const CalWebhookSecret: string = process.env["CAL_WEBHOOK_SECRET"] || "";
 
 /*
- * Google Ads offline conversion uploads (MarketingConversions worker job).
- * Server-only secrets — must never be added to FRONTEND_ENV_ALLOW_LIST.
- */
-export const GoogleAdsDeveloperToken: string =
-  process.env["GOOGLE_ADS_DEVELOPER_TOKEN"] || "";
-export const GoogleAdsOAuthClientId: string =
-  process.env["GOOGLE_ADS_OAUTH_CLIENT_ID"] || "";
-export const GoogleAdsOAuthClientSecret: string =
-  process.env["GOOGLE_ADS_OAUTH_CLIENT_SECRET"] || "";
-export const GoogleAdsOAuthRefreshToken: string =
-  process.env["GOOGLE_ADS_OAUTH_REFRESH_TOKEN"] || "";
-// Digits only, no dashes (e.g. 1234567890).
-export const GoogleAdsCustomerId: string =
-  process.env["GOOGLE_ADS_CUSTOMER_ID"] || "";
-// Manager (MCC) account id when the OAuth user accesses the account via a manager.
-export const GoogleAdsLoginCustomerId: string =
-  process.env["GOOGLE_ADS_LOGIN_CUSTOMER_ID"] || "";
-/*
- * Google sunsets Ads API versions roughly yearly (v20 died 2026-06-10) —
- * keep this default on a currently supported version and prefer setting
- * GOOGLE_ADS_API_VERSION explicitly in production.
- */
-export const GoogleAdsApiVersion: string =
-  process.env["GOOGLE_ADS_API_VERSION"] || "v23";
-/*
- * Numeric conversion action ids from Google Ads (Goals -> Conversions). One
- * per conversion type: the provider maps types to actions exhaustively, and an
- * empty value leaves that type pending rather than uploading it under some
- * other type's action.
- */
-export const GoogleAdsSignUpConversionActionId: string =
-  process.env["GOOGLE_ADS_SIGNUP_CONVERSION_ACTION_ID"] || "";
-export const GoogleAdsPaidSubscriptionConversionActionId: string =
-  process.env["GOOGLE_ADS_PAID_SUBSCRIPTION_CONVERSION_ACTION_ID"] || "";
-export const GoogleAdsMeetingBookedConversionActionId: string =
-  process.env["GOOGLE_ADS_MEETING_BOOKED_CONVERSION_ACTION_ID"] || "";
-
-/*
- * Enhanced conversions for leads: upload a conversion identified ONLY by a
- * hashed email, with no gclid at all.
+ * Outbound marketing conversion webhooks.
  *
- * This is the mechanism that makes a sales-led funnel measurable — a demo
- * booked in June and a licence signed in October share an email and nothing
- * else. It is off by default because it is not purely a OneUptime-side switch:
- * the Google Ads account must have enhanced conversions for leads turned on
- * and the conversion action configured for it, and uploading email-only
- * conversions to an account without that returns a per-conversion rejection.
+ * OneUptime does not store conversions. Signups, booked meetings and plan
+ * upgrades/downgrades are POSTed to this endpoint as they happen and kept
+ * nowhere afterwards, so an unset URL means those moments are simply not
+ * measured — nothing accumulates waiting for one to be configured.
  *
- * Hashing the email ALONGSIDE a click id needs no flag and is always sent — it
- * only improves the match rate of a conversion that was uploadable anyway.
- */
-export const GoogleAdsEnhancedConversionsForLeadsEnabled: boolean =
-  process.env["GOOGLE_ADS_ENHANCED_CONVERSIONS_FOR_LEADS_ENABLED"] === "true";
-
-// Meta (Facebook) Conversions API. Server-only secrets.
-export const MetaConversionsPixelId: string =
-  process.env["META_CONVERSIONS_PIXEL_ID"] || "";
-export const MetaConversionsAccessToken: string =
-  process.env["META_CONVERSIONS_ACCESS_TOKEN"] || "";
-export const MetaGraphApiVersion: string =
-  process.env["META_GRAPH_API_VERSION"] || "v22.0";
-
-// Microsoft Advertising (Bing Ads) offline conversions. Server-only secrets.
-export const MicrosoftAdsDeveloperToken: string =
-  process.env["MICROSOFT_ADS_DEVELOPER_TOKEN"] || "";
-export const MicrosoftAdsOAuthClientId: string =
-  process.env["MICROSOFT_ADS_OAUTH_CLIENT_ID"] || "";
-export const MicrosoftAdsOAuthClientSecret: string =
-  process.env["MICROSOFT_ADS_OAUTH_CLIENT_SECRET"] || "";
-export const MicrosoftAdsOAuthRefreshToken: string =
-  process.env["MICROSOFT_ADS_OAUTH_REFRESH_TOKEN"] || "";
-export const MicrosoftAdsCustomerId: string =
-  process.env["MICROSOFT_ADS_CUSTOMER_ID"] || "";
-export const MicrosoftAdsAccountId: string =
-  process.env["MICROSOFT_ADS_ACCOUNT_ID"] || "";
-// Offline conversion goals are matched by NAME in Microsoft Advertising.
-export const MicrosoftAdsSignUpConversionName: string =
-  process.env["MICROSOFT_ADS_SIGNUP_CONVERSION_NAME"] || "";
-export const MicrosoftAdsPaidSubscriptionConversionName: string =
-  process.env["MICROSOFT_ADS_PAID_SUBSCRIPTION_CONVERSION_NAME"] || "";
-export const MicrosoftAdsMeetingBookedConversionName: string =
-  process.env["MICROSOFT_ADS_MEETING_BOOKED_CONVERSION_NAME"] || "";
-
-// LinkedIn Conversions API. Server-only secrets.
-export const LinkedInConversionsAccessToken: string =
-  process.env["LINKEDIN_CONVERSIONS_ACCESS_TOKEN"] || "";
-/*
- * LinkedIn publishes a new Marketing API version monthly and supports each
- * for ~12 months — keep this default recent and prefer setting
- * LINKEDIN_API_VERSION explicitly in production.
+ * Both are required. The payload carries email addresses and campaign data,
+ * so a URL set without a secret is refused rather than sent unsigned. The
+ * secret is server-only and must never reach FRONTEND_ENV_ALLOW_LIST.
  */
-export const LinkedInApiVersion: string =
-  process.env["LINKEDIN_API_VERSION"] || "202606";
-// Numeric conversion rule ids (urn:lla:llaPartnerConversion:{id}).
-export const LinkedInSignUpConversionId: string =
-  process.env["LINKEDIN_SIGNUP_CONVERSION_ID"] || "";
-export const LinkedInPaidSubscriptionConversionId: string =
-  process.env["LINKEDIN_PAID_SUBSCRIPTION_CONVERSION_ID"] || "";
-export const LinkedInMeetingBookedConversionId: string =
-  process.env["LINKEDIN_MEETING_BOOKED_CONVERSION_ID"] || "";
-
-// Reddit Conversions API. Server-only secrets.
-export const RedditAdsOAuthClientId: string =
-  process.env["REDDIT_ADS_OAUTH_CLIENT_ID"] || "";
-export const RedditAdsOAuthClientSecret: string =
-  process.env["REDDIT_ADS_OAUTH_CLIENT_SECRET"] || "";
-export const RedditAdsOAuthRefreshToken: string =
-  process.env["REDDIT_ADS_OAUTH_REFRESH_TOKEN"] || "";
-export const RedditAdsAccountId: string =
-  process.env["REDDIT_ADS_ACCOUNT_ID"] || "";
+export const MarketingWebhookUrl: string =
+  process.env["MARKETING_WEBHOOK_URL"] || "";
+export const MarketingWebhookSecret: string =
+  process.env["MARKETING_WEBHOOK_SECRET"] || "";
 
 export const DisableAutomaticIncidentCreation: boolean =
   process.env["DISABLE_AUTOMATIC_INCIDENT_CREATION"] === "true";

package/Server/Infrastructure/Postgres/SchemaMigrations/1788700000000-RemoveMarketingConversionUploadState.ts

@@ -0,0 +1,33 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Drop the per-ad-platform upload state from the conversion ledger.
+ *
+ * OneUptime no longer uploads offline conversions to Google Ads, Meta,
+ * Microsoft Advertising, LinkedIn or Reddit. The ledger is now purely
+ * OneUptime's own reporting record, so the only column that existed to track
+ * delivery to those platforms has nothing left to describe.
+ *
+ * The down migration restores the column but not its contents: the statuses
+ * were per-provider delivery bookkeeping, they are not recoverable from
+ * anything else in the schema, and no reporting reads them. Nothing else on
+ * the row changes — conversions, their attribution and their chains are
+ * untouched.
+ */
+export class RemoveMarketingConversionUploadState1788700000000
+  implements MigrationInterface
+{
+  public name: string = "RemoveMarketingConversionUploadState1788700000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "MarketingConversion" DROP COLUMN IF EXISTS "uploadState"`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "MarketingConversion" ADD "uploadState" jsonb`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1788800000000-DropMarketingConversionAddEnterpriseLicenseEmail.ts

@@ -0,0 +1,51 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Replace the conversion ledger with outbound webhooks, and give an enterprise
+ * licence a contact email.
+ *
+ * TWO CHANGES, ONE MIGRATION, because they are one decision: conversions are
+ * no longer stored in OneUptime, they are emitted as they happen and joined by
+ * the receiver on email. EnterpriseLicense.email is what makes a sales-led
+ * licence joinable to the meeting_booked that produced it, months earlier —
+ * without it, dropping the ledger would leave enterprise revenue attributable
+ * to nothing at all.
+ *
+ * The DROP is not reversible in any way that matters. `down` recreates the
+ * table's shape so a rollback finds the schema it expects, but every
+ * conversion, its attribution and its chain are gone: nothing else in the
+ * schema holds them, and nothing writes them any more. Export the table before
+ * running this if the history is wanted.
+ */
+export class DropMarketingConversionAddEnterpriseLicenseEmail1788800000000
+  implements MigrationInterface
+{
+  public name: string =
+    "DropMarketingConversionAddEnterpriseLicenseEmail1788800000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "EnterpriseLicense" ADD "email" character varying(100)`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "idx_enterprise_license_email" ON "EnterpriseLicense" ("email")`,
+    );
+    await queryRunner.query(`DROP TABLE IF EXISTS "MarketingConversion"`);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    /*
+     * Shape only — deliberately no data. Recreated so a rollback to the
+     * previous release starts against the schema it was built for.
+     */
+    await queryRunner.query(
+      `CREATE TABLE IF NOT EXISTS "MarketingConversion" ("_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, "conversionType" character varying(100) NOT NULL, "userId" uuid, "projectId" uuid, "email" character varying(100), "clickIds" jsonb NOT NULL, "conversionAt" TIMESTAMP WITH TIME ZONE NOT NULL, "conversionValueInUSDCents" integer, "utmCampaign" character varying(500), "utmSource" character varying(500), "utmMedium" character varying(500), "utmTerm" character varying(500), "utmContent" character varying(500), "utmUrl" character varying(500), "firstTouchAttribution" jsonb, "emailHash" character varying(100), "attributedToConversionId" uuid, CONSTRAINT "PK_MarketingConversion_id" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `DROP INDEX IF EXISTS "idx_enterprise_license_email"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "EnterpriseLicense" DROP COLUMN IF EXISTS "email"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1788900000000-RedactStoredMonitorIngestSecrets.ts

@@ -0,0 +1,117 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Scrub monitor ingest keys out of payloads that were already persisted.
+ *
+ * https://github.com/OneUptime/oneuptime/issues/3360
+ *
+ * An Incoming Email monitor's `incomingEmailSecretKey` IS its inbound address:
+ * `SendGridInboundProvider.generateMonitorEmailAddress` builds
+ * `monitor-{secretKey}@{inboundDomain}`, and `extractSecretKeyFromEmail` reads
+ * the key straight back out. Every stored copy of the recipient was therefore a
+ * stored copy of a live bearer credential — `emailTo`, the `To:` header, and
+ * the `Received:` / `Delivered-To:` headers added in transit.
+ *
+ * `ProcessProbeIngest.processIncomingEmailFromQueue` now masks the key at the
+ * ingest boundary, so nothing written from here on carries it. That fixes the
+ * flow and not the stock: rows written before this deploy still hold the key in
+ * plaintext, in columns a `Permission.Viewer` can select. Narrowing a read ACL
+ * would not have helped either — the same snapshot is copied onto incidents and
+ * alerts, which are gated on their own permissions.
+ *
+ * The four Postgres sinks, all of them jsonb:
+ *
+ *   - `Monitor.incomingEmailMonitorRequest`  (the reported leak)
+ *   - `Monitor.incomingMonitorRequest`       (same shape, `incomingRequestSecretKey`)
+ *   - `Incident.monitorSummary`              (via MonitorSummaryCapture)
+ *   - `Alert.monitorSummary`                 (via MonitorSummaryCapture)
+ *
+ * `MonitorLog.logBody` is the fifth sink and is deliberately not touched here:
+ * it lives in ClickHouse, not Postgres, and every row carries a `retentionDate`
+ * with a `retentionDate DELETE` TTL, so historical rows age out on their own.
+ *
+ * Matching is case-insensitive (`gi`). A uuid renders lowercase in Postgres,
+ * but the key reaches these payloads through relay headers that preserve
+ * whatever case the sender used. A uuid is made of hex digits and hyphens, so
+ * it needs no regex escaping, and the replacement text contains no backslash,
+ * so it needs none either.
+ */
+export class RedactStoredMonitorIngestSecrets1788900000000
+  implements MigrationInterface
+{
+  public name: string = "RedactStoredMonitorIngestSecrets1788900000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    /*
+     * The monitor's own row: the key and the payload quoting it are on the
+     * same row, so this needs no join.
+     */
+    await queryRunner.query(
+      `UPDATE "Monitor"
+          SET "incomingEmailMonitorRequest" = regexp_replace(
+                "incomingEmailMonitorRequest"::text,
+                "incomingEmailSecretKey"::text,
+                '[REDACTED]',
+                'gi'
+              )::jsonb
+        WHERE "incomingEmailSecretKey" IS NOT NULL
+          AND "incomingEmailMonitorRequest" IS NOT NULL
+          AND "incomingEmailMonitorRequest"::text ILIKE '%' || "incomingEmailSecretKey"::text || '%'`,
+    );
+
+    await queryRunner.query(
+      `UPDATE "Monitor"
+          SET "incomingMonitorRequest" = regexp_replace(
+                "incomingMonitorRequest"::text,
+                "incomingRequestSecretKey"::text,
+                '[REDACTED]',
+                'gi'
+              )::jsonb
+        WHERE "incomingRequestSecretKey" IS NOT NULL
+          AND "incomingMonitorRequest" IS NOT NULL
+          AND "incomingMonitorRequest"::text ILIKE '%' || "incomingRequestSecretKey"::text || '%'`,
+    );
+
+    /*
+     * Incident and Alert keep a copy of the snapshot the monitor was evaluated
+     * from. The key is not on those rows, so join back to the monitor. The
+     * `projectId` equality keeps the join from degenerating into a cross
+     * product; the ILIKE is what actually selects the affected rows, and a
+     * snapshot describes exactly one monitor, so at most one monitor row can
+     * match a given summary.
+     */
+    for (const table of ["Incident", "Alert"]) {
+      for (const secretColumn of [
+        "incomingEmailSecretKey",
+        "incomingRequestSecretKey",
+      ]) {
+        await queryRunner.query(
+          `UPDATE "${table}" AS t
+              SET "monitorSummary" = regexp_replace(
+                    t."monitorSummary"::text,
+                    m."${secretColumn}"::text,
+                    '[REDACTED]',
+                    'gi'
+                  )::jsonb
+             FROM "Monitor" AS m
+            WHERE m."${secretColumn}" IS NOT NULL
+              AND m."projectId" = t."projectId"
+              AND t."monitorSummary" IS NOT NULL
+              AND t."monitorSummary"::text ILIKE '%' || m."${secretColumn}"::text || '%'`,
+        );
+      }
+    }
+  }
+
+  public async down(): Promise<void> {
+    /*
+     * Deliberately empty. The whole point of the up migration is that these
+     * values are gone; the original text is not recoverable from anything else
+     * in the schema, and recovering it would mean re-publishing the leak.
+     *
+     * Nothing depends on the redacted text either: `IncomingEmailCriteria`
+     * re-evaluates against live mail, and the summary cards render whatever
+     * string is stored. Rolling the schema back therefore needs no data change.
+     */
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1789000000000-AddUserSlackAndMicrosoftTeams.ts

@@ -0,0 +1,197 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Slack and Microsoft Teams as user notification methods.
+ *
+ * Two new per-user method tables (UserSlack / UserMicrosoftTeams — pointers at
+ * the user's OAuth workspace link, created verified), the notification-rule
+ * and on-call timeline foreign keys that let rules route pages to them, and
+ * the two per-event toggles on UserNotificationSetting.
+ */
+export class AddUserSlackAndMicrosoftTeams1789000000000
+  implements MigrationInterface
+{
+  public name = "AddUserSlackAndMicrosoftTeams1789000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "UserSlack" ("_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, "slackUserId" character varying(100), "slackUserName" character varying(100), "userId" uuid, "createdByUserId" uuid, "deletedByUserId" uuid, "isVerified" boolean NOT NULL DEFAULT false, CONSTRAINT "PK_86de4cd76b41a08811fc403e23a" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_d5dd2503bf422c6a19946216e1" ON "UserSlack" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_abe4265455b18cd43a94bb84ed" ON "UserSlack" ("slackUserId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_9c8fa391e949f53f670dabe222" ON "UserSlack" ("userId") `,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "UserMicrosoftTeams" ("_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, "microsoftTeamsUserId" character varying(100), "microsoftTeamsUserName" character varying(100), "userId" uuid, "createdByUserId" uuid, "deletedByUserId" uuid, "isVerified" boolean NOT NULL DEFAULT false, CONSTRAINT "PK_9e2c27aadbc24a991c68e55c130" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_cebf1edfa5f30a7e597633bddf" ON "UserMicrosoftTeams" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_a746ef4fd29b03ac5abe8f4e4c" ON "UserMicrosoftTeams" ("microsoftTeamsUserId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_e4405f9dacd3d1e3c363e8dbd3" ON "UserMicrosoftTeams" ("userId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationRule" ADD "userSlackId" uuid`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationRule" ADD "userMicrosoftTeamsId" uuid`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserOnCallLogTimeline" ADD "userSlackId" uuid`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserOnCallLogTimeline" ADD "userMicrosoftTeamsId" uuid`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationSetting" ADD "alertBySlack" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationSetting" ADD "alertByMicrosoftTeams" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_0c24badba9b152d08700f7d8aa" ON "UserNotificationRule" ("userSlackId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_3dc4e1c367eab9fd36b7983e44" ON "UserNotificationRule" ("userMicrosoftTeamsId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_d51ef7b2a8b813d37e94890ff7" ON "UserOnCallLogTimeline" ("userSlackId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_a7206c19df5cdfe02cf3215a64" ON "UserOnCallLogTimeline" ("userMicrosoftTeamsId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserSlack" ADD CONSTRAINT "FK_d5dd2503bf422c6a19946216e19" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserSlack" ADD CONSTRAINT "FK_9c8fa391e949f53f670dabe2220" FOREIGN KEY ("userId") REFERENCES "User"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserSlack" ADD CONSTRAINT "FK_fd38a9ee050702437ed323f21fb" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserSlack" ADD CONSTRAINT "FK_2f058862227400121f90925d65e" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserMicrosoftTeams" ADD CONSTRAINT "FK_cebf1edfa5f30a7e597633bddf9" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserMicrosoftTeams" ADD CONSTRAINT "FK_e4405f9dacd3d1e3c363e8dbd30" FOREIGN KEY ("userId") REFERENCES "User"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserMicrosoftTeams" ADD CONSTRAINT "FK_81443b1ab79d63b7700f3d16c84" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserMicrosoftTeams" ADD CONSTRAINT "FK_1d7cfdf5a4e314cf4b4cc7873e0" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationRule" ADD CONSTRAINT "FK_0c24badba9b152d08700f7d8aa8" FOREIGN KEY ("userSlackId") REFERENCES "UserSlack"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationRule" ADD CONSTRAINT "FK_3dc4e1c367eab9fd36b7983e444" FOREIGN KEY ("userMicrosoftTeamsId") REFERENCES "UserMicrosoftTeams"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserOnCallLogTimeline" ADD CONSTRAINT "FK_d51ef7b2a8b813d37e94890ff77" FOREIGN KEY ("userSlackId") REFERENCES "UserSlack"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserOnCallLogTimeline" ADD CONSTRAINT "FK_a7206c19df5cdfe02cf3215a64c" FOREIGN KEY ("userMicrosoftTeamsId") REFERENCES "UserMicrosoftTeams"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "UserOnCallLogTimeline" DROP CONSTRAINT "FK_a7206c19df5cdfe02cf3215a64c"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserOnCallLogTimeline" DROP CONSTRAINT "FK_d51ef7b2a8b813d37e94890ff77"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationRule" DROP CONSTRAINT "FK_3dc4e1c367eab9fd36b7983e444"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationRule" DROP CONSTRAINT "FK_0c24badba9b152d08700f7d8aa8"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserMicrosoftTeams" DROP CONSTRAINT "FK_1d7cfdf5a4e314cf4b4cc7873e0"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserMicrosoftTeams" DROP CONSTRAINT "FK_81443b1ab79d63b7700f3d16c84"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserMicrosoftTeams" DROP CONSTRAINT "FK_e4405f9dacd3d1e3c363e8dbd30"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserMicrosoftTeams" DROP CONSTRAINT "FK_cebf1edfa5f30a7e597633bddf9"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserSlack" DROP CONSTRAINT "FK_2f058862227400121f90925d65e"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserSlack" DROP CONSTRAINT "FK_fd38a9ee050702437ed323f21fb"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserSlack" DROP CONSTRAINT "FK_9c8fa391e949f53f670dabe2220"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserSlack" DROP CONSTRAINT "FK_d5dd2503bf422c6a19946216e19"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_a7206c19df5cdfe02cf3215a64"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_d51ef7b2a8b813d37e94890ff7"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_3dc4e1c367eab9fd36b7983e44"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_0c24badba9b152d08700f7d8aa"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationSetting" DROP COLUMN "alertByMicrosoftTeams"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationSetting" DROP COLUMN "alertBySlack"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserOnCallLogTimeline" DROP COLUMN "userMicrosoftTeamsId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserOnCallLogTimeline" DROP COLUMN "userSlackId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationRule" DROP COLUMN "userMicrosoftTeamsId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationRule" DROP COLUMN "userSlackId"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_e4405f9dacd3d1e3c363e8dbd3"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_a746ef4fd29b03ac5abe8f4e4c"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_cebf1edfa5f30a7e597633bddf"`,
+    );
+    await queryRunner.query(`DROP TABLE "UserMicrosoftTeams"`);
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_9c8fa391e949f53f670dabe222"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_abe4265455b18cd43a94bb84ed"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_d5dd2503bf422c6a19946216e1"`,
+    );
+    await queryRunner.query(`DROP TABLE "UserSlack"`);
+  }
+}