@oneuptime/common 12.0.5 → 12.0.7

package/Server/Services/DataSourceService.ts

@@ -0,0 +1,200 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/DataSource";
+import CreateBy from "../Types/Database/CreateBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import DataSourceType, {
+  DataSourceTypeUtil,
+} from "../../Types/DataSource/DataSourceType";
+import { DataSourceConnectionSettings } from "../Utils/DataSource/Types";
+import Dictionary from "../../Types/Dictionary";
+import { JSONObject } from "../../Types/JSON";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  /*
+   * Per-type shape validation so a broken data source fails at save time
+   * with a clear message, not at first query with a connector error.
+   */
+  private validateDataSourceShape(data: {
+    dataSourceType?: DataSourceType | undefined;
+    url?: string | undefined;
+    databaseHost?: string | undefined;
+  }): void {
+    const dataSourceType: DataSourceType | undefined = data.dataSourceType;
+
+    if (!dataSourceType) {
+      return; // updates that don't touch the type/host/url skip validation.
+    }
+
+    if (!DataSourceTypeUtil.getAllDataSourceTypes().includes(dataSourceType)) {
+      throw new BadDataException(`Unknown data source type: ${dataSourceType}`);
+    }
+
+    if (DataSourceTypeUtil.isHttpBasedType(dataSourceType) && !data.url) {
+      throw new BadDataException(
+        `${dataSourceType} data sources require a URL.`,
+      );
+    }
+
+    if (
+      DataSourceTypeUtil.isDatabaseType(dataSourceType) &&
+      !data.databaseHost
+    ) {
+      throw new BadDataException(
+        `${dataSourceType} data sources require a database host.`,
+      );
+    }
+  }
+
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    this.validateDataSourceShape({
+      dataSourceType: createBy.data.dataSourceType,
+      url: createBy.data.url,
+      databaseHost: createBy.data.databaseHost,
+    });
+
+    return { createBy, carryForward: null };
+  }
+
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    /*
+     * Only validate when the update touches the fields that participate in
+     * shape validation. Changing the TYPE of an existing source without
+     * also sending url/host can produce a source that fails validation on
+     * its own merits — so when dataSourceType changes, re-validate against
+     * the stored row's values merged with the update.
+     */
+    const data: {
+      dataSourceType?: DataSourceType | undefined;
+      url?: string | undefined;
+      databaseHost?: string | undefined;
+    } = updateBy.data as unknown as {
+      dataSourceType?: DataSourceType | undefined;
+      url?: string | undefined;
+      databaseHost?: string | undefined;
+    };
+
+    /*
+     * Presence check, not truthiness — an update that CLEARS url or
+     * databaseHost (null / empty string) must still be validated, or an
+     * HTTP source could be stripped of its URL and break at query time.
+     */
+    const updateData: Record<string, unknown> = updateBy.data as Record<
+      string,
+      unknown
+    >;
+    const touchesShape: boolean =
+      "dataSourceType" in updateData ||
+      "url" in updateData ||
+      "databaseHost" in updateData;
+
+    if (touchesShape) {
+      const existing: Model | null = await this.findOneBy({
+        query: updateBy.query,
+        select: {
+          _id: true,
+          dataSourceType: true,
+          url: true,
+          databaseHost: true,
+        },
+        props: { isRoot: true },
+      });
+
+      /*
+       * A field present in the update wins even when cleared (null/"" →
+       * undefined, which validation treats as missing); an absent field
+       * falls back to the stored row.
+       */
+      this.validateDataSourceShape({
+        dataSourceType: data.dataSourceType || existing?.dataSourceType,
+        url: "url" in updateData ? data.url || undefined : existing?.url,
+        databaseHost:
+          "databaseHost" in updateData
+            ? data.databaseHost || undefined
+            : existing?.databaseHost,
+      });
+    }
+
+    return { updateBy, carryForward: null };
+  }
+
+  /*
+   * Decrypted connection settings for the server-side connector paths
+   * (/test and /query). ROOT read — the caller MUST have already performed
+   * a user-scoped access check on this id (the LlmProviderAPI two-phase
+   * pattern). The returned object holds plaintext secrets: never serialize
+   * it into a response or a log line.
+   */
+  @CaptureSpan()
+  public async getConnectionSettingsById(
+    dataSourceId: ObjectID,
+  ): Promise<DataSourceConnectionSettings | null> {
+    if (!ObjectID.isValidUUID(dataSourceId.toString())) {
+      /*
+       * A non-uuid string in a uuid column is a Postgres cast error, not
+       * an empty result — shape-check before querying.
+       */
+      return null;
+    }
+
+    const dataSource: Model | null = await this.findOneById({
+      id: dataSourceId,
+      select: {
+        _id: true,
+        projectId: true,
+        dataSourceType: true,
+        url: true,
+        databaseHost: true,
+        databasePort: true,
+        databaseName: true,
+        username: true,
+        password: true,
+        apiToken: true,
+        customHeaders: true,
+        additionalOptions: true,
+      },
+      props: { isRoot: true },
+    });
+
+    if (!dataSource || !dataSource.dataSourceType) {
+      return null;
+    }
+
+    let customHeaders: Dictionary<string> | undefined = undefined;
+    if (dataSource.customHeaders) {
+      customHeaders = {};
+      const headers: JSONObject = dataSource.customHeaders;
+      for (const key of Object.keys(headers)) {
+        if (headers[key] !== null && headers[key] !== undefined) {
+          customHeaders[key] = headers[key]!.toString();
+        }
+      }
+    }
+
+    return {
+      dataSourceType: dataSource.dataSourceType,
+      url: dataSource.url,
+      databaseHost: dataSource.databaseHost,
+      databasePort: dataSource.databasePort,
+      databaseName: dataSource.databaseName,
+      username: dataSource.username,
+      password: dataSource.password,
+      apiToken: dataSource.apiToken,
+      customHeaders: customHeaders,
+      additionalOptions: dataSource.additionalOptions,
+    };
+  }
+}
+
+export default new Service();

package/Server/Services/DatabaseService.ts

@@ -1489,6 +1489,7 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
         _id: deleteById.id.toString(),
       } as any,
       deletedByUser: deleteById.deletedByUser,
+      deletionReason: deleteById.deletionReason,
       props: deleteById.props,
     });
   }

package/Server/Services/DeletedProjectService.ts

@@ -0,0 +1,138 @@
+import { IsBillingEnabled } from "../EnvironmentConfig";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import DatabaseService from "./DatabaseService";
+import UserService from "./UserService";
+import Model from "../../Models/DatabaseModels/DeletedProject";
+import Project from "../../Models/DatabaseModels/Project";
+import User from "../../Models/DatabaseModels/User";
+import OneUptimeDate from "../../Types/Date";
+import ObjectID from "../../Types/ObjectID";
+import Phone from "../../Types/Phone";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  /*
+   * Records a project that has just been deleted so the team can follow up with
+   * the customer. The project row is already gone by the time this runs, so
+   * everything written here has to come from the snapshot the caller took
+   * before the delete (ProjectService.onBeforeDelete).
+   *
+   * SaaS only. Self-hosted installs have no one to reach out to, and the
+   * gate lives here rather than at the call site so every caller gets it.
+   *
+   * Returns the row it wrote, or null when logging was skipped.
+   */
+  @CaptureSpan()
+  public async logProjectDeletion(data: {
+    project: Project;
+    deletedByUserId?: ObjectID | undefined;
+    deletionReason?: string | undefined;
+  }): Promise<Model | null> {
+    if (!IsBillingEnabled) {
+      return null;
+    }
+
+    const project: Project = data.project;
+
+    if (!project.id) {
+      return null;
+    }
+
+    /*
+     * Who to reach out to. The user who deleted the project is usually also
+     * the one who created it - reuse the snapshot in that case instead of
+     * spending a query on it.
+     */
+    let deletedByUser: User | null = null;
+
+    if (data.deletedByUserId) {
+      if (
+        project.createdByUser &&
+        project.createdByUserId?.toString() === data.deletedByUserId.toString()
+      ) {
+        deletedByUser = project.createdByUser;
+      } else {
+        deletedByUser = await UserService.findOneById({
+          id: data.deletedByUserId,
+          select: {
+            _id: true,
+            name: true,
+            email: true,
+            companyName: true,
+            companyPhoneNumber: true,
+            companySize: true,
+            jobRole: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+      }
+    }
+
+    const createdByUser: User | undefined = project.createdByUser;
+
+    const deletedProject: Model = new Model();
+
+    deletedProject.projectId = project.id;
+    deletedProject.projectName = project.name || "";
+    deletedProject.projectSlug = project.slug;
+    deletedProject.projectCreatedAt = project.createdAt;
+    deletedProject.projectDeletedAt = OneUptimeDate.getCurrentDate();
+    deletedProject.deletionReason = data.deletionReason;
+
+    deletedProject.projectDeletedByUserId = data.deletedByUserId;
+    deletedProject.projectDeletedByUserName = deletedByUser?.name?.toString();
+    deletedProject.projectDeletedByUserEmail = deletedByUser?.email;
+
+    deletedProject.projectCreatedByUserId = project.createdByUserId;
+    deletedProject.projectCreatedByUserName = createdByUser?.name?.toString();
+    deletedProject.projectCreatedByUserEmail = createdByUser?.email;
+
+    /*
+     * Company details are collected at signup and hang off the User, so take
+     * them from whoever created the project and fall back to whoever deleted
+     * it - between the two there is usually one filled-in answer.
+     */
+    const companyName: string | undefined =
+      createdByUser?.companyName || deletedByUser?.companyName;
+    const companyPhoneNumber: Phone | undefined =
+      createdByUser?.companyPhoneNumber || deletedByUser?.companyPhoneNumber;
+    const companySize: string | undefined =
+      createdByUser?.companySize || deletedByUser?.companySize;
+    const jobRole: string | undefined =
+      createdByUser?.jobRole || deletedByUser?.jobRole;
+
+    deletedProject.companyName = companyName;
+    deletedProject.companyPhoneNumber = companyPhoneNumber;
+    deletedProject.companySize = companySize;
+    deletedProject.jobRole = jobRole;
+
+    deletedProject.planName = project.planName;
+    deletedProject.paymentProviderPlanId = project.paymentProviderPlanId;
+    deletedProject.paymentProviderCustomerId =
+      project.paymentProviderCustomerId;
+    deletedProject.paymentProviderSubscriptionId =
+      project.paymentProviderSubscriptionId;
+    deletedProject.paymentProviderSubscriptionStatus =
+      project.paymentProviderSubscriptionStatus;
+    deletedProject.paymentProviderSubscriptionSeats =
+      project.paymentProviderSubscriptionSeats;
+    deletedProject.trialEndsAt = project.trialEndsAt;
+
+    deletedProject.activeMonitorCount = project.currentActiveMonitorsCount;
+    deletedProject.wasProjectBlocked = project.isBlocked ?? false;
+
+    return await this.create({
+      data: deletedProject,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+}
+
+export default new Service();

package/Server/Services/FileService.ts

@@ -4,15 +4,30 @@ import FindBy from "../Types/Database/FindBy";
 import { OnCreate, OnDelete, OnFind, OnUpdate } from "../Types/Database/Hooks";
 import UpdateBy from "../Types/Database/UpdateBy";
 import DatabaseService from "./DatabaseService";
+import BadDataException from "../../Types/Exception/BadDataException";
 import NotAuthorizedException from "../../Types/Exception/NotAuthorizedException";
 import File from "../../Models/DatabaseModels/File";
+import MimeType from "../../Types/File/MimeType";
+import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger from "../Utils/Logger";
 import crypto from "crypto";
 
 const generateImageAccessToken: () => string = (): string => {
   return crypto.randomBytes(32).toString("hex");
 };
 
+/*
+ * fileType is declared as MimeType but persisted as a varchar, so the enum
+ * buys nothing at runtime - the API will happily store "text/html" if a client
+ * asks for it. Response.sendFileResponse refuses to echo an unknown type back,
+ * but keeping junk out of the column in the first place means the stored row
+ * matches what we are willing to serve.
+ */
+const ALLOWED_MIME_TYPES: Set<string> = new Set<string>(
+  Object.values(MimeType),
+);
+
 export class Service extends DatabaseService<File> {
   public constructor() {
     super(File);
@@ -22,6 +37,18 @@ export class Service extends DatabaseService<File> {
   protected override async onBeforeCreate(
     createBy: CreateBy<File>,
   ): Promise<OnCreate<File>> {
+    const fileType: string = (createBy.data.fileType || "")
+      .trim()
+      .toLowerCase();
+
+    if (!ALLOWED_MIME_TYPES.has(fileType)) {
+      throw new BadDataException(
+        "This file type is not supported. Please upload a supported file type.",
+      );
+    }
+
+    createBy.data.fileType = fileType as MimeType;
+
     /*
      * Always generate an unguessable access token server-side. The token
      * is the only safe way to address an inline-uploaded image in
@@ -56,6 +83,40 @@ export class Service extends DatabaseService<File> {
     return { deleteBy, carryForward: null };
   }
 
+  /*
+   * Marks a file as anonymously readable. Uploads from the file picker
+   * arrive private, so attaching one as an intentionally public asset
+   * (probe icon, AI agent icon) is the point at which it becomes public
+   * — those are served by the id-based image route, which serves only
+   * public files. Best-effort: a visibility sync failure must never fail
+   * the write the user actually asked for.
+   */
+  @CaptureSpan()
+  public async makeFilePublic(
+    fileId: ObjectID | undefined | null,
+  ): Promise<void> {
+    if (!fileId) {
+      return;
+    }
+
+    try {
+      await this.updateOneById({
+        id: fileId,
+        data: {
+          isPublic: true,
+        },
+        props: {
+          isRoot: true,
+          ignoreHooks: true,
+        },
+      });
+    } catch (err) {
+      logger.error(
+        `Failed to mark file ${fileId.toString()} public: ${String(err)}`,
+      );
+    }
+  }
+
   @CaptureSpan()
   protected override async onBeforeFind(
     findBy: FindBy<File>,

package/Server/Services/HostService.ts

@@ -11,6 +11,7 @@ import QueryHelper from "../Types/Database/QueryHelper";
 import OneUptimeDate from "../../Types/Date";
 import LIMIT_MAX from "../../Types/Database/LimitMax";
 import GlobalCache from "../Infrastructure/GlobalCache";
+import InProcessMemo from "../Utils/InProcessMemo";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { canonicalizeEntityValue } from "../../Utils/Telemetry/EntityKey";
 import crypto from "crypto";
@@ -21,6 +22,46 @@ const LAST_SEEN_THROTTLE_SECONDS: number = 60;
 const LABELS_APPLIED_CACHE_NAMESPACE: string = "host-labels-applied";
 const LABELS_APPLIED_CACHE_TTL_SECONDS: number = 60;
 
+/*
+ * What `findOrCreateByHostIdentifier` memoizes: the resolved row's id plus
+ * the identifier it converged to. A flat shape rather than the Model itself
+ * so a memo hit hands every caller a FRESH Model instance — the resolving
+ * call and a memoed call must not share one mutable entity object.
+ */
+interface HostResolution {
+  hostIdStr: string;
+  hostIdentifier: string;
+}
+
+/*
+ * Per-process memo for `(projectId, canonical hostIdentifier) -> Host`.
+ *
+ * `findOrCreateByHostIdentifier` ran an unconditional Postgres SELECT per
+ * call, and the metrics ingest path calls it once per unique host per job
+ * (the host-enrichment aggregation loop) on top of `autoDiscoverHost`'s
+ * Redis-cache misses — for a fleet of workers chewing hostmetrics batches
+ * that is a steady stream of identical case-insensitive lookups for rows
+ * that change never. Same L1 shape as the service-resolution memo in
+ * OpenTelemetryIngestService: 60-second TTL, bounded because host
+ * identifiers arrive from collector-controlled resource attributes.
+ *
+ * ONLY positive resolutions (the host exists / was just created) are
+ * memoized, and only on success. There is deliberately no negative
+ * caching: the miss path must keep falling through to the create, so a
+ * create that loses a concurrent race still throws its unique-violation
+ * into the existing catch-and-refetch handling unchanged. Staleness is a
+ * non-issue for the id itself (ids are immutable); a deleted host keeps
+ * resolving for up to the TTL, which the 24-hour host-id Redis cache in
+ * OtelIngestBaseService already dwarfs.
+ */
+const HOST_RESOLUTION_MEMO_TTL_IN_MS: number = 60 * 1000;
+const HOST_RESOLUTION_MEMO_MAX_ENTRIES: number = 10_000;
+const hostResolutionInProcessMemo: InProcessMemo<HostResolution> =
+  new InProcessMemo<HostResolution>({
+    ttlInMs: HOST_RESOLUTION_MEMO_TTL_IN_MS,
+    maxEntries: HOST_RESOLUTION_MEMO_MAX_ENTRIES,
+  });
+
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
@@ -75,6 +116,24 @@ export class Service extends DatabaseService<Model> {
      */
     const hostIdentifier: string = canonicalizeEntityValue(data.hostIdentifier);
 
+    /*
+     * L1: in-process memo. The canonical identifier is the memo key, so
+     * every casing of one host collapses onto the entry the previous batch
+     * wrote — the same folding the SQL predicate below performs. A hit
+     * skips the SELECT (and the already-converged identifier write) that
+     * the resolving call performed within the last minute.
+     */
+    const memoKey: string = `${data.projectId.toString()}:${hostIdentifier}`;
+    const memoedResolution: HostResolution | undefined =
+      hostResolutionInProcessMemo.get(memoKey);
+    if (memoedResolution) {
+      const memoedHost: Model = new Model();
+      memoedHost._id = memoedResolution.hostIdStr;
+      memoedHost.projectId = data.projectId;
+      memoedHost.hostIdentifier = memoedResolution.hostIdentifier;
+      return memoedHost;
+    }
+
     /*
      * Look up case-insensitively. The unique guard on name/hostIdentifier
      * (DatabaseService.checkUniqueColumnBy -> QueryHelper.findWithSameText)
@@ -131,6 +190,18 @@ export class Service extends DatabaseService<Model> {
         }
       }
 
+      /*
+       * Memoize the identifier the row ACTUALLY holds (post-convergence,
+       * or the legacy casing when the best-effort update failed) so a memo
+       * hit returns exactly what a repeated lookup would have.
+       */
+      if (existingHost._id) {
+        hostResolutionInProcessMemo.set(memoKey, {
+          hostIdStr: existingHost._id.toString(),
+          hostIdentifier: existingHost.hostIdentifier || hostIdentifier,
+        });
+      }
+
       return existingHost;
     }
 
@@ -149,6 +220,13 @@ export class Service extends DatabaseService<Model> {
         },
       });
 
+      if (createdHost._id) {
+        hostResolutionInProcessMemo.set(memoKey, {
+          hostIdStr: createdHost._id.toString(),
+          hostIdentifier: hostIdentifier,
+        });
+      }
+
       return createdHost;
     } catch {
       /*
@@ -173,6 +251,20 @@ export class Service extends DatabaseService<Model> {
       });
 
       if (reFetchedHost) {
+        /*
+         * The refetch after a lost create race emits the same SELECT as
+         * the cold lookup, and a first-contact stampede on a brand-new
+         * host is exactly when this branch runs hot — memoize it like the
+         * other two resolution paths (mirrors the service-resolution
+         * cache's create-race handling).
+         */
+        if (reFetchedHost._id) {
+          hostResolutionInProcessMemo.set(memoKey, {
+            hostIdStr: reFetchedHost._id.toString(),
+            hostIdentifier: reFetchedHost.hostIdentifier || hostIdentifier,
+          });
+        }
+
         return reFetchedHost;
       }
 

package/Server/Services/IncidentEpisodePublicNoteService.ts

@@ -14,6 +14,7 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import StatusPageSubscriberNotificationStatus from "../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
 import File from "../../Models/DatabaseModels/File";
 import FileAttachmentMarkdownUtil from "../Utils/FileAttachmentMarkdownUtil";
+import { syncIsPublicForMarkdownImages } from "../Utils/InlineImageAccessTokenSync";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -116,6 +117,17 @@ export class Service extends DatabaseService<Model> {
     const userId: ObjectID | null | undefined =
       createdItem.createdByUserId || createdItem.createdByUser?.id;
 
+    /*
+     * A public note is always rendered on the status page, so any inline
+     * image the markdown editor uploaded as private must flip to public
+     * for anonymous status page viewers to be able to render it.
+     */
+    await syncIsPublicForMarkdownImages(
+      createdItem.note,
+      true,
+      `incident episode public note ${createdItem.id?.toString()}`,
+    );
+
     const incidentEpisodeId: ObjectID = createdItem.incidentEpisodeId!;
     const projectId: ObjectID = createdItem.projectId!;
     const episodeNumberResult: {
@@ -185,6 +197,12 @@ ${(createdItem.note || "") + attachmentsMarkdown}
       for (const updatedItem of updatedItems) {
         const episode: IncidentEpisode = updatedItem.incidentEpisode!;
 
+        await syncIsPublicForMarkdownImages(
+          updatedItem.note,
+          true,
+          `incident episode public note ${updatedItem.id?.toString()}`,
+        );
+
         const attachmentsMarkdown: string = await this.getAttachmentsMarkdown(
           updatedItem.id!,
           "/incident-episode-public-note/attachment",

package/Server/Services/IncidentPublicNoteService.ts

@@ -14,6 +14,7 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import StatusPageSubscriberNotificationStatus from "../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
 import File from "../../Models/DatabaseModels/File";
 import FileAttachmentMarkdownUtil from "../Utils/FileAttachmentMarkdownUtil";
+import { syncIsPublicForMarkdownImages } from "../Utils/InlineImageAccessTokenSync";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -116,6 +117,17 @@ export class Service extends DatabaseService<Model> {
     const userId: ObjectID | null | undefined =
       createdItem.createdByUserId || createdItem.createdByUser?.id;
 
+    /*
+     * A public note is always rendered on the status page, so any inline
+     * image the markdown editor uploaded as private must flip to public
+     * for anonymous status page viewers to be able to render it.
+     */
+    await syncIsPublicForMarkdownImages(
+      createdItem.note,
+      true,
+      `incident public note ${createdItem.id?.toString()}`,
+    );
+
     const incidentId: ObjectID = createdItem.incidentId!;
     const projectId: ObjectID = createdItem.projectId!;
     const incidentNumberResult: {
@@ -187,6 +199,12 @@ ${(createdItem.note || "") + attachmentsMarkdown}
       for (const updatedItem of updatedItems) {
         const incident: Incident = updatedItem.incident!;
 
+        await syncIsPublicForMarkdownImages(
+          updatedItem.note,
+          true,
+          `incident public note ${updatedItem.id?.toString()}`,
+        );
+
         const attachmentsMarkdown: string = await this.getAttachmentsMarkdown(
           updatedItem.id!,
           "/incident-public-note/attachment",