@oneuptime/common 12.0.5 → 12.0.7

package/Types/DataSource/DataSourceType.ts

@@ -0,0 +1,213 @@
+/*
+ * External systems a project-level Data Source can connect to. Dashboards
+ * bind widgets to a Data Source + a query written in that source's native
+ * query language (PromQL, SQL, LogQL, ES Query DSL, or a REST request
+ * descriptor), and the server-side connector for the type normalizes the
+ * response into the same shapes OneUptime's own widgets already consume.
+ */
+enum DataSourceType {
+  Prometheus = "Prometheus",
+  PostgreSQL = "PostgreSQL",
+  MySQL = "MySQL",
+  MicrosoftSqlServer = "Microsoft SQL Server",
+  ClickHouse = "ClickHouse",
+  Loki = "Loki",
+  Elasticsearch = "Elasticsearch",
+  RestApi = "REST API",
+}
+
+export default DataSourceType;
+
+/*
+ * What a type is used for, so the type picker can group hundreds of
+ * connectors into a handful of sections. Enum values are the section
+ * headings; DataSourceTypeCategories below fixes the display order.
+ */
+export enum DataSourceTypeCategory {
+  Metrics = "Metrics",
+  Logs = "Logs",
+  Databases = "Databases",
+  Search = "Search",
+  Api = "APIs",
+}
+
+export const DataSourceTypeCategories: Array<DataSourceTypeCategory> = [
+  DataSourceTypeCategory.Metrics,
+  DataSourceTypeCategory.Logs,
+  DataSourceTypeCategory.Databases,
+  DataSourceTypeCategory.Search,
+  DataSourceTypeCategory.Api,
+];
+
+export interface DataSourceTypeProps {
+  dataSourceType: DataSourceType;
+  title: string;
+  description: string;
+  category: DataSourceTypeCategory;
+  queryLanguageTitle: string;
+  queryPlaceholder: string;
+}
+
+export class DataSourceTypeUtil {
+  public static getAllDataSourceTypes(): Array<DataSourceType> {
+    return [
+      DataSourceType.Prometheus,
+      DataSourceType.PostgreSQL,
+      DataSourceType.MySQL,
+      DataSourceType.MicrosoftSqlServer,
+      DataSourceType.ClickHouse,
+      DataSourceType.Loki,
+      DataSourceType.Elasticsearch,
+      DataSourceType.RestApi,
+    ];
+  }
+
+  /*
+   * Sources reached over HTTP(S) at a base URL (Prometheus-compatible APIs,
+   * Loki, Elasticsearch, arbitrary REST endpoints). These require `url` on
+   * the Data Source and are queried through the SSRF-guarded HTTP client.
+   */
+  public static isHttpBasedType(dataSourceType: DataSourceType): boolean {
+    return [
+      DataSourceType.Prometheus,
+      DataSourceType.Loki,
+      DataSourceType.Elasticsearch,
+      DataSourceType.RestApi,
+    ].includes(dataSourceType);
+  }
+
+  /*
+   * Sources reached with a database driver over host/port. These require
+   * `databaseHost` (+ optionally port/databaseName/username/password) and
+   * run read-only guarded SQL.
+   */
+  public static isDatabaseType(dataSourceType: DataSourceType): boolean {
+    return [
+      DataSourceType.PostgreSQL,
+      DataSourceType.MySQL,
+      DataSourceType.MicrosoftSqlServer,
+      DataSourceType.ClickHouse,
+    ].includes(dataSourceType);
+  }
+
+  public static getCategory(
+    dataSourceType: DataSourceType,
+  ): DataSourceTypeCategory {
+    return DataSourceTypeUtil.getProps(dataSourceType).category;
+  }
+
+  /** Default port used to seed the settings form for database sources. */
+  public static getDefaultPort(dataSourceType: DataSourceType): number | null {
+    switch (dataSourceType) {
+      case DataSourceType.PostgreSQL:
+        return 5432;
+      case DataSourceType.MySQL:
+        return 3306;
+      case DataSourceType.MicrosoftSqlServer:
+        return 1433;
+      case DataSourceType.ClickHouse:
+        return 8123; // HTTP interface — the @clickhouse/client transport.
+      default:
+        return null;
+    }
+  }
+
+  public static getProps(dataSourceType: DataSourceType): DataSourceTypeProps {
+    switch (dataSourceType) {
+      case DataSourceType.Prometheus:
+        return {
+          dataSourceType,
+          title: "Prometheus",
+          description:
+            "Query a Prometheus-compatible API (Prometheus, Thanos, Cortex, Mimir, VictoriaMetrics) with PromQL.",
+          category: DataSourceTypeCategory.Metrics,
+          queryLanguageTitle: "PromQL",
+          queryPlaceholder: 'rate(http_requests_total{job="api"}[5m])',
+        };
+      case DataSourceType.PostgreSQL:
+        return {
+          dataSourceType,
+          title: "PostgreSQL",
+          description:
+            "Run read-only SQL against a PostgreSQL-compatible database (PostgreSQL, TimescaleDB, CockroachDB).",
+          category: DataSourceTypeCategory.Databases,
+          queryLanguageTitle: "SQL",
+          queryPlaceholder:
+            "SELECT created_at AS time, COUNT(*) AS value FROM orders WHERE created_at BETWEEN $__startTime AND $__endTime GROUP BY 1 ORDER BY 1",
+        };
+      case DataSourceType.MySQL:
+        return {
+          dataSourceType,
+          title: "MySQL",
+          description: "Run read-only SQL against a MySQL or MariaDB database.",
+          category: DataSourceTypeCategory.Databases,
+          queryLanguageTitle: "SQL",
+          queryPlaceholder:
+            "SELECT created_at AS time, COUNT(*) AS value FROM orders WHERE created_at BETWEEN $__startTime AND $__endTime GROUP BY 1 ORDER BY 1",
+        };
+      case DataSourceType.MicrosoftSqlServer:
+        return {
+          dataSourceType,
+          title: "Microsoft SQL Server",
+          description:
+            "Run read-only SQL against a Microsoft SQL Server or Azure SQL database.",
+          category: DataSourceTypeCategory.Databases,
+          queryLanguageTitle: "T-SQL",
+          queryPlaceholder:
+            "SELECT created_at AS time, COUNT(*) AS value FROM orders WHERE created_at BETWEEN $__startTime AND $__endTime GROUP BY created_at ORDER BY created_at",
+        };
+      case DataSourceType.ClickHouse:
+        return {
+          dataSourceType,
+          title: "ClickHouse",
+          description:
+            "Run read-only SQL against a ClickHouse database over its HTTP interface.",
+          category: DataSourceTypeCategory.Databases,
+          queryLanguageTitle: "SQL",
+          queryPlaceholder:
+            "SELECT toStartOfMinute(timestamp) AS time, count() AS value FROM events WHERE timestamp BETWEEN $__startTime AND $__endTime GROUP BY time ORDER BY time",
+        };
+      case DataSourceType.Loki:
+        return {
+          dataSourceType,
+          title: "Grafana Loki",
+          description:
+            "Query a Grafana Loki log aggregation endpoint with LogQL metric queries.",
+          category: DataSourceTypeCategory.Logs,
+          queryLanguageTitle: "LogQL",
+          queryPlaceholder: 'sum(rate({app="api"} |= "error" [5m]))',
+        };
+      case DataSourceType.Elasticsearch:
+        return {
+          dataSourceType,
+          title: "Elasticsearch",
+          description:
+            "Query an Elasticsearch or OpenSearch cluster with Query DSL (date-histogram aggregations for charts).",
+          category: DataSourceTypeCategory.Search,
+          queryLanguageTitle: "Query DSL (JSON)",
+          queryPlaceholder:
+            '{ "query": { "match_all": {} }, "aggs": { "over_time": { "date_histogram": { "field": "@timestamp", "fixed_interval": "1m" }, "aggs": { "value": { "value_count": { "field": "_id" } } } } } }',
+        };
+      case DataSourceType.RestApi:
+        return {
+          dataSourceType,
+          title: "REST API",
+          description:
+            "Fetch JSON from any HTTP(S) API and map fields into time series or tables.",
+          category: DataSourceTypeCategory.Api,
+          queryLanguageTitle: "Request (JSON)",
+          queryPlaceholder:
+            '{ "path": "/api/stats", "method": "GET", "rowsPath": "data.items", "timestampField": "time", "valueField": "count" }',
+        };
+      default:
+        return {
+          dataSourceType,
+          title: dataSourceType,
+          description: "",
+          category: DataSourceTypeCategory.Api,
+          queryLanguageTitle: "Query",
+          queryPlaceholder: "",
+        };
+    }
+  }
+}

package/Types/Date.ts

@@ -476,7 +476,12 @@ export default class OneUptimeDate {
   }
 
   public static getCurrentDate(): Date {
-    return moment().toDate();
+    /*
+     * Not moment().toDate(): this is called on per-record telemetry ingest
+     * paths, and a moment wrapper allocation per call is pure overhead for
+     * what is exactly `new Date()`.
+     */
+    return new Date();
   }
 
   public static fromNow(date: Date): string {
@@ -934,6 +939,17 @@ export default class OneUptimeDate {
     return this.getSecondsInDays(days) * 1000;
   }
 
+  public static getSecondsInHours(hours: PositiveNumber | number): number {
+    if (!(hours instanceof PositiveNumber)) {
+      hours = new PositiveNumber(hours);
+    }
+    return hours.positiveNumber * 60 * 60;
+  }
+
+  public static getMillisecondsInHours(hours: PositiveNumber | number): number {
+    return this.getSecondsInHours(hours) * 1000;
+  }
+
   public static getSomeHoursAgo(hours: PositiveNumber | number): Date {
     if (!(hours instanceof PositiveNumber)) {
       hours = new PositiveNumber(hours);
@@ -2067,9 +2083,33 @@ export default class OneUptimeDate {
     return date;
   }
 
+  /*
+   * Hand-rolled UTC "YYYY-MM-DD HH:mm:ss" formatter. The two Clickhouse
+   * formatters below run several times per ingested log / span / metric
+   * datapoint — millions of calls per minute on a busy worker — and a
+   * moment() wrapper plus format-token parsing per call is roughly an order
+   * of magnitude more expensive than reading the UTC fields directly.
+   * Output is byte-identical to moment's, including the "Invalid date"
+   * sentinel for NaN dates.
+   */
+  private static formatUtcClickhouseDateTime(date: Date): string {
+    if (Number.isNaN(date.getTime())) {
+      return "Invalid date";
+    }
+
+    const year: string = String(date.getUTCFullYear()).padStart(4, "0");
+    const month: string = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const day: string = String(date.getUTCDate()).padStart(2, "0");
+    const hours: string = String(date.getUTCHours()).padStart(2, "0");
+    const minutes: string = String(date.getUTCMinutes()).padStart(2, "0");
+    const seconds: string = String(date.getUTCSeconds()).padStart(2, "0");
+
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+  }
+
   public static toClickhouseDateTime(date: Date | string): string {
     const parsedDate: Date = this.fromString(date);
-    return moment(parsedDate).utc().format("YYYY-MM-DD HH:mm:ss");
+    return this.formatUtcClickhouseDateTime(parsedDate);
   }
 
   public static toClickhouseDateTime64(
@@ -2077,7 +2117,7 @@ export default class OneUptimeDate {
     nanoTimestamp?: number,
   ): string {
     const parsedDate: Date = this.fromString(date);
-    const base: string = moment(parsedDate).utc().format("YYYY-MM-DD HH:mm:ss");
+    const base: string = this.formatUtcClickhouseDateTime(parsedDate);
 
     let nanoFraction: string;
 

package/Types/Domain.ts

@@ -67,6 +67,32 @@ export default class Domain extends DatabaseProperty {
     return domainRegex.test(domain);
   }
 
+  /**
+   * Validates a subdomain: one or more DNS labels, no scheme, no port, no
+   * path, no userinfo.
+   *
+   * This is a security control, not a nicety. A subdomain is concatenated
+   * with a verified base domain to build fullDomain, and fullDomain is
+   * interpolated into a URL that the certificate-provisioning cron fetches
+   * unattended. URL parsing takes everything before the first "/" as the
+   * host, so a subdomain of "169.254.169.254/latest/meta-data/#" yields a URL
+   * whose host, port and path are all attacker-chosen. Restricting the value
+   * to DNS labels removes the ability to smuggle any of those.
+   *
+   * The empty string is NOT valid here: callers use "" (or "@") to mean the
+   * apex and must check for that before calling.
+   */
+  public static isValidSubdomain(subdomain: string): boolean {
+    if (!subdomain || subdomain.length > 253) {
+      return false;
+    }
+
+    const subdomainRegex: RegExp =
+      /^[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+
+    return subdomainRegex.test(subdomain);
+  }
+
   public constructor(domain: string) {
     super();
     this.domain = domain;

package/Types/File/MimeType.ts

@@ -8,6 +8,17 @@ enum MimeType {
   svg = "image/svg+xml",
   gif = "image/gif",
   webp = "image/webp",
+  /*
+   * Raster formats a browser or an API client can legitimately report but the
+   * file picker never names. Listed so those uploads are not rejected outright
+   * now that FileService validates fileType against this enum, and so rows
+   * written before the picker normalised types are still servable.
+   */
+  ico = "image/x-icon",
+  bmp = "image/bmp",
+  tiff = "image/tiff",
+  avif = "image/avif",
+  heic = "image/heic",
   pdf = "application/pdf",
   doc = "application/msword",
   docx = "application/vnd.openxmlformats-officedocument.wordprocessingml.document",

package/Types/JSONFunctions.ts

@@ -297,6 +297,21 @@ export default class JSONFunctions {
       Object.keys(ObjectType).includes((val as JSONObject)["_type"] as string)
     ) {
       return val;
+    } else if (Array.isArray(val)) {
+      /*
+       * This has to be checked before the plain-object branch below: arrays are
+       * typeof "object", so falling through to serialize() would walk them by
+       * key and hand back { "0": ..., "1": ... } instead of an array. That
+       * silently corrupts every nested array persisted into a JSON column —
+       * e.g. the [facetKey, value] filter tuples of a telemetry saved view.
+       */
+      const arr: Array<JSONValue> = [];
+
+      for (const v of val) {
+        arr.push(this.serializeValue(v));
+      }
+
+      return arr;
     } else if (typeof val === Typeof.Object) {
       return this.serialize(val as JSONObject);
     }

package/Types/Password.ts

@@ -0,0 +1,64 @@
+/*
+ * The password rules, in one place, so the form that collects a password and
+ * the endpoint that stores it cannot disagree about what is acceptable.
+ *
+ * Every password form in OneUptime has historically carried its own inline
+ * `minLength: 6`, and no server-side check existed at all -- the browser was
+ * the only thing enforcing it. That is fine right up until a password arrives
+ * from somewhere that is not the browser, which is exactly what an admin API
+ * is. These constants and `getPasswordValidationError` live in Common/Types
+ * (not Common/Server) precisely so the browser can import them too.
+ */
+
+/*
+ * Six is the number every existing OneUptime password form already enforces
+ * (Accounts sign-up, Accounts reset-password, the user profile, the status
+ * page). It is stated here rather than raised so that adopting this module
+ * cannot lock out anyone whose current password was accepted under the old
+ * inline rule.
+ */
+export const MINIMUM_PASSWORD_LENGTH: number = 6;
+
+/*
+ * An upper bound, so a caller cannot hand the hasher an arbitrarily large
+ * string. It is not a security property -- scrypt's cost is set by N/r/p, not
+ * by input length -- it just keeps a pathological request from becoming work.
+ * 100 is far above any password a person types and far below anything that
+ * matters.
+ */
+export const MAXIMUM_PASSWORD_LENGTH: number = 100;
+
+/**
+ * Why this password is unacceptable, or null if it is fine.
+ *
+ * Returns a message rather than throwing so the same function can back a
+ * browser-side form validator and a server-side guard -- the server wraps the
+ * message in the exception type it wants to return.
+ *
+ * Length is measured on the raw value, NOT a trimmed one: a password is a
+ * secret the user typed, and silently trimming it would store something other
+ * than what they entered and then fail to match it at login. A value that is
+ * *only* whitespace is rejected outright, though -- that is a mistake, not a
+ * password.
+ */
+export function getPasswordValidationError(
+  password: string | undefined | null,
+): string | null {
+  if (password === undefined || password === null || password === "") {
+    return "Password is required.";
+  }
+
+  if (password.trim().length === 0) {
+    return "Password cannot be blank.";
+  }
+
+  if (password.length < MINIMUM_PASSWORD_LENGTH) {
+    return `Password cannot be less than ${MINIMUM_PASSWORD_LENGTH} characters.`;
+  }
+
+  if (password.length > MAXIMUM_PASSWORD_LENGTH) {
+    return `Password cannot be more than ${MAXIMUM_PASSWORD_LENGTH} characters.`;
+  }
+
+  return null;
+}

package/Types/Permission.ts

@@ -130,6 +130,13 @@ enum Permission {
   ReadDashboard = "ReadDashboard",
   EditDashboard = "EditDashboard",
 
+  // Data Sources (external systems dashboards can query)
+
+  CreateDataSource = "CreateDataSource",
+  DeleteDataSource = "DeleteDataSource",
+  ReadDataSource = "ReadDataSource",
+  EditDataSource = "EditDataSource",
+
   // Dashboard Domains
   CreateDashboardDomain = "CreateDashboardDomain",
   DeleteDashboardDomain = "DeleteDashboardDomain",
@@ -2498,6 +2505,45 @@ export class PermissionHelper {
         group: PermissionGroup.Settings,
       },
 
+      // Data Sources.
+
+      {
+        permission: Permission.CreateDataSource,
+        title: "Create Data Source",
+        description: "This permission can create Data Sources of this project",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Settings,
+      },
+      {
+        permission: Permission.DeleteDataSource,
+        title: "Delete Data Source",
+        description: "This permission can delete Data Sources of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Settings,
+      },
+      {
+        permission: Permission.EditDataSource,
+        title: "Edit Data Source",
+        description: "This permission can edit Data Sources of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Settings,
+      },
+      {
+        permission: Permission.ReadDataSource,
+        title: "Read Data Source",
+        description: "This permission can read Data Sources of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Settings,
+      },
+
       // Dashboard Owner Team Permissions
       {
         permission: Permission.CreateDashboardOwnerTeam,

package/Types/Telemetry/TelemetrySavedViewState.ts

@@ -19,7 +19,15 @@ export interface TelemetrySavedViewTimeRange {
 export default interface TelemetrySavedViewState {
   // Submitted search string from the explorer search bar.
   search?: string | undefined;
-  // Active facet filters as [facetKey, value] tuples.
+  /*
+   * Active facet filters as [facetKey, value] tuples.
+   *
+   * Read these with readSavedViewFilters (Common/Utils/Telemetry/
+   * SavedViewFilters) rather than destructuring them. Rows written before
+   * JSONFunctions.serializeValue learned to preserve nested arrays hold
+   * { "0": facetKey, "1": value } instead, and destructuring one of those
+   * throws — which is what this type asserting otherwise once cost us.
+   */
   filters?: Array<[string, string]> | undefined;
   // Selected time range.
   timeRange?: TelemetrySavedViewTimeRange | undefined;

package/Types/UserAuthenticationStatus.ts

@@ -0,0 +1,34 @@
+/**
+ * What an operator needs to know about how one user can sign in, with nothing
+ * secret in it.
+ *
+ * `hasPassword` is a boolean rather than the column itself for a specific
+ * reason: the password column holds a scrypt digest, and a master admin
+ * bypasses column read permissions, so "just select it in the UI" would put
+ * every user's password hash in a browser's network tab. The only fact the
+ * Admin Dashboard needs is whether one is set at all.
+ *
+ * This lives in Common/Types rather than beside the service that builds it so
+ * that the page rendering it and the endpoint producing it are typed against
+ * the same declaration -- a renamed field then fails to compile instead of
+ * quietly rendering `undefined`.
+ */
+export default interface UserAuthenticationStatus {
+  // Can this user sign in with a password at all, or are they SSO-only?
+  hasPassword: boolean;
+
+  isEmailVerified: boolean;
+
+  /*
+   * Read from User.enableTwoFactorAuth, NOT the similarly named
+   * User.twoFactorAuthEnabled. Both columns exist; only `enableTwoFactorAuth`
+   * is the one login consults and the one the rest of the product writes.
+   * `twoFactorAuthEnabled` is a vestige of the initial migration that nothing
+   * reads -- reporting it here would tell an operator "2FA off" about a user
+   * who very much has it on.
+   */
+  isTwoFactorAuthEnabled: boolean;
+
+  // Is there an unexpired password-reset link outstanding for this user?
+  hasPendingPasswordResetLink: boolean;
+}