@oneuptime/common 12.0.7 → 12.0.9

package/Models/AnalyticsModels/MetricItemAggMV1mByK8sCluster.ts

@@ -9,7 +9,7 @@ import TableColumnType from "../../Types/AnalyticsDatabase/TableColumnType";
  * samples — sibling of `MetricItemAggMV1mByHostV2`, keyed by the stable
  * 16-hex `k8sClusterEntityKey` the ingest pipeline stamps on every row
  * whose resource carries a Kubernetes cluster identity. Cluster identity
- * is `k8s.cluster.name` ONLY (see `TelemetryEntity.k8sClusterIdentity`),
+ * is `k8s.cluster.name` ONLY (see `InventoryItem.k8sClusterIdentity`),
  * so the read side can derive the key directly from the incoming
  * `resource.k8s.cluster.name` filter via
  * `EntityKey.keyForKubernetesCluster` — no registry lookup needed.

package/Models/AnalyticsModels/MetricItemAggMV1mByService.ts

@@ -16,7 +16,7 @@ import TableColumnType from "../../Types/AnalyticsDatabase/TableColumnType";
  * `service.name` can map to SEVERAL serviceEntityKeys (one per
  * namespace variant). The read side therefore never derives a single
  * key from the name: `MetricService.tryBuildEntityAggregateMVStatement`
- * resolves the full key set from the Postgres TelemetryEntity registry
+ * resolves the full key set from the Postgres InventoryItem registry
  * and compiles `serviceEntityKey IN (<keys>)`, falling back to the raw
  * table when the registry has no rows for the name.
  *

package/Models/DatabaseModels/AIConversation.ts

@@ -18,6 +18,7 @@ import ObjectID from "../../Types/ObjectID";
 import Permission from "../../Types/Permission";
 import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
 import EnableDocumentation from "../../Types/Database/EnableDocumentation";
+import { AIChatPageContext } from "../../Types/AI/AIChatPageContext";
 
 /*
  * A conversation between a user and the OneUptime AI about the project's
@@ -235,6 +236,37 @@ export default class AIConversation extends BaseModel {
   })
   public permissionMode?: string = undefined;
 
+  /*
+   * The conversation's subject: the dashboard page (usually one specific
+   * entity, e.g. an incident) the user was looking at when the conversation
+   * started. ChatAgentRunner persists it from the first turn that carries a
+   * sanitized page context and falls back to it on later turns that arrive
+   * without one, so "this incident" keeps resolving after the user navigates
+   * away. Written only by the server (never member-writable through CRUD),
+   * so it cannot be forged to point at another project's entity.
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.JSON,
+    title: "Page Context",
+    description:
+      "The dashboard page (entity) this conversation is about. Set from the first message that carried a page context.",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.JSON,
+  })
+  public pageContext?: AIChatPageContext = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [],

package/Models/DatabaseModels/AIConversationMessage.ts

@@ -27,6 +27,18 @@ import {
   AIChatWidget,
 } from "../../Types/AI/AIChatTypes";
 
+/*
+ * Thumbs feedback the user can leave on an assistant message via
+ * POST /ai-chat/message-feedback. Stored as the enum's string value in a
+ * ShortText column, the same shape as `role` and `status`. Declared here
+ * (not in Types/AI) because it is a property of this row, not a shared
+ * chat-protocol concept.
+ */
+export enum AIConversationMessageFeedback {
+  Up = "Up",
+  Down = "Down",
+}
+
 /*
  * A single message in an AI conversation. Create/update table permissions are
  * deliberately EMPTY: only the server (isRoot) writes message rows. This
@@ -416,6 +428,35 @@ export default class AIConversationMessage extends BaseModel {
   })
   public errorMessage?: string = undefined;
 
+  /*
+   * Update ACL is empty like every other column: feedback is written only by
+   * the server through POST /ai-chat/message-feedback, which verifies the
+   * requesting user owns the conversation and the message is assistant-role.
+   * Null means no feedback has been left (or it was cleared).
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.ShortText,
+    title: "User Feedback",
+    description:
+      "Thumbs feedback the user left on this assistant message: Up or Down.",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public userFeedback?: AIConversationMessageFeedback = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [],

package/Models/DatabaseModels/AlertEpisodeMember.ts

@@ -87,6 +87,33 @@ export enum AlertEpisodeMemberAddedBy {
   name: "AlertEpisodeMember",
 })
 @Index(["alertEpisodeId", "alertId", "projectId"])
+/*
+ * AlertEpisodeOwner:SendAlertAddedEmail sweeps this table every minute for
+ * rows whose owner has not been notified yet.
+ *
+ * Ordinary inserts do not write the flag at all — the column is NOT NULL
+ * DEFAULT false, so a new member starts out un-notified and the sweep picks
+ * it up. The one exception is the episode's FOUNDING member, which
+ * AlertEpisodeMemberService.onBeforeCreate sets to true up front (the
+ * "episode created" notification already covers that alert, so the sweep must
+ * skip it). Every other row is flipped true by the sweep itself. In steady
+ * state, then, almost every row is true and the sweep finds nothing — a full
+ * sequential scan of the whole table, 1,440 times a day, to return zero rows.
+ *
+ * The index is PARTIAL for that same reason: indexing the column outright
+ * would build a structure the size of the table to serve a predicate that
+ * matches a handful of rows. Restricted to the un-notified rows it stays
+ * roughly as small as the sweep's own working set, and Postgres can prove
+ * the sweep's predicate implies it.
+ *
+ * "deletedAt" IS NULL is in the predicate because the sweep always carries
+ * it (TypeORM adds it for the soft-delete column) and, more importantly,
+ * because nothing ever flips the flag on a soft-deleted row — those would
+ * otherwise accumulate in the index forever.
+ */
+@Index(["isOwnerNotifiedOfAlertAdded"], {
+  where: '"isOwnerNotifiedOfAlertAdded" = false AND "deletedAt" IS NULL',
+})
 export default class AlertEpisodeMember extends BaseModel {
   @ColumnAccessControl({
     create: [

package/Models/DatabaseModels/IncidentEpisodeMember.ts

@@ -87,6 +87,34 @@ export enum IncidentEpisodeMemberAddedBy {
   name: "IncidentEpisodeMember",
 })
 @Index(["incidentEpisodeId", "incidentId", "projectId"])
+/*
+ * IncidentEpisodeOwner:SendIncidentAddedEmail sweeps this table every minute
+ * for rows whose owner has not been notified yet.
+ *
+ * Ordinary inserts do not write the flag at all — the column is NOT NULL
+ * DEFAULT false, so a new member starts out un-notified and the sweep picks
+ * it up. The one exception is the episode's FOUNDING member, which
+ * IncidentEpisodeMemberService.onBeforeCreate sets to true up front (the
+ * "episode created" notification already covers that incident, so the sweep
+ * must skip it). Every other row is flipped true by the sweep itself. In
+ * steady state, then, almost every row is true and the sweep finds nothing —
+ * a full sequential scan of the whole table, 1,440 times a day, to return
+ * zero rows.
+ *
+ * The index is PARTIAL for that same reason: indexing the column outright
+ * would build a structure the size of the table to serve a predicate that
+ * matches a handful of rows. Restricted to the un-notified rows it stays
+ * roughly as small as the sweep's own working set, and Postgres can prove
+ * the sweep's predicate implies it.
+ *
+ * "deletedAt" IS NULL is in the predicate because the sweep always carries
+ * it (TypeORM adds it for the soft-delete column) and, more importantly,
+ * because nothing ever flips the flag on a soft-deleted row — those would
+ * otherwise accumulate in the index forever.
+ */
+@Index(["isOwnerNotifiedOfIncidentAdded"], {
+  where: '"isOwnerNotifiedOfIncidentAdded" = false AND "deletedAt" IS NULL',
+})
 export default class IncidentEpisodeMember extends BaseModel {
   @ColumnAccessControl({
     create: [

package/Models/DatabaseModels/Index.ts

@@ -18,6 +18,9 @@ import NetworkSiteType from "./NetworkSiteType";
 import NetworkEndpoint from "./NetworkEndpoint";
 import NetworkSiteStatusTimeline from "./NetworkSiteStatusTimeline";
 import NetworkSiteLink from "./NetworkSiteLink";
+import NetworkDeviceLink from "./NetworkDeviceLink";
+import NetworkDeviceLinkRule from "./NetworkDeviceLinkRule";
+import NetworkTopologySuppression from "./NetworkTopologySuppression";
 import NetworkSiteAssignmentRule from "./NetworkSiteAssignmentRule";
 import DockerHostOwnerTeam from "./DockerHostOwnerTeam";
 import DockerHostOwnerUser from "./DockerHostOwnerUser";
@@ -307,8 +310,9 @@ import UserWebAuthn from "./UserWebAuthn";
 import TelemetryIngestionKey from "./TelemetryIngestionKey";
 
 import TelemetryException from "./TelemetryException";
-import TelemetryEntity from "./TelemetryEntity";
-import TelemetryEntityRelationship from "./TelemetryEntityRelationship";
+import InventoryItem from "./InventoryItem";
+import InventoryItemCustomField from "./InventoryItemCustomField";
+import InventoryItemRelationship from "./InventoryItemRelationship";
 import ScheduledMaintenanceTemplate from "./ScheduledMaintenanceTemplate";
 import ScheduledMaintenanceTemplateOwnerTeam from "./ScheduledMaintenanceTemplateOwnerTeam";
 import ScheduledMaintenanceTemplateOwnerUser from "./ScheduledMaintenanceTemplateOwnerUser";
@@ -775,8 +779,9 @@ const AllModelTypes: Array<{
   TelemetryIngestionKey,
 
   TelemetryException,
-  TelemetryEntity,
-  TelemetryEntityRelationship,
+  InventoryItem,
+  InventoryItemCustomField,
+  InventoryItemRelationship,
 
   TableView,
 
@@ -820,6 +825,9 @@ const AllModelTypes: Array<{
   NetworkEndpoint,
   NetworkSiteStatusTimeline,
   NetworkSiteLink,
+  NetworkDeviceLink,
+  NetworkDeviceLinkRule,
+  NetworkTopologySuppression,
   NetworkSiteAssignmentRule,
   DockerHostOwnerTeam,
   DockerHostOwnerUser,

package/Models/DatabaseModels/{TelemetryEntity.ts → InventoryItem.ts}

@@ -6,6 +6,7 @@ import TableAccessControl from "../../Types/Database/AccessControl/TableAccessCo
 import ColumnLength from "../../Types/Database/ColumnLength";
 import ColumnType from "../../Types/Database/ColumnType";
 import CrudApiEndpoint from "../../Types/Database/CrudApiEndpoint";
+import EnableAuditLog from "../../Types/Database/EnableAuditLog";
 import EnableDocumentation from "../../Types/Database/EnableDocumentation";
 import TableColumn from "../../Types/Database/TableColumn";
 import TableColumnType from "../../Types/Database/TableColumnType";
@@ -15,12 +16,13 @@ import IconProp from "../../Types/Icon/IconProp";
 import { JSONObject } from "../../Types/JSON";
 import ObjectID from "../../Types/ObjectID";
 import Permission from "../../Types/Permission";
+import EntitySource from "../../Types/Telemetry/EntitySource";
 import EntityType from "../../Types/Telemetry/EntityType";
 import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
 import DatabaseBaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
 
 /*
- * Reusable access-control sets. A TelemetryEntity is a project-scoped
+ * Reusable access-control sets. A InventoryItem is a project-scoped
  * catalog row (like Service / MetricType), machine-populated at ingest, so
  * it reuses the telemetry-service permissions rather than introducing a
  * new permission family.
@@ -78,22 +80,40 @@ const UPDATE_PERMS: Array<Permission> = [
   ],
   update: UPDATE_PERMS,
 })
-@CrudApiEndpoint(new Route("/telemetry-entity"))
+@CrudApiEndpoint(new Route("/inventory-item"))
+/*
+ * Audit logging is scoped to changes a person made.
+ *
+ * `create` is off because ingest creates one row per discovered entity: on a
+ * churning Kubernetes estate that is a new row per pod, and the resulting
+ * flood of "created" entries says nothing the `firstSeenAt` column does not
+ * already say. `update` and `delete` are on and cost nothing at ingest
+ * volume, because the reconciler bumps `lastSeenAt` through
+ * `updateColumnsByIdIfUnlockedWithoutHooks` and the prune sweep removes rows
+ * through `hardDeleteBy` — neither of which reaches the audit-log hook. What
+ * is left is exactly the user-initiated edits and deletions.
+ */
+@EnableAuditLog({ create: false, update: true, delete: true })
 @TableMetadata({
-  tableName: "TelemetryEntity",
-  singularName: "Telemetry Entity",
-  pluralName: "Telemetry Entities",
+  tableName: "InventoryItem",
+  singularName: "Inventory Item",
+  pluralName: "Inventory Items",
   icon: IconProp.Cube,
   tableDescription:
-    "Catalog of OpenTelemetry entities (service, host, k8s.pod, container, ...) discovered from telemetry resource attributes.",
+    "Catalog of everything OneUptime knows about your estate (service, host, k8s.pod, container, network device, ...), discovered from telemetry resource attributes, mirrored from inventory tables, or registered by hand.",
 })
-@Entity({ name: "TelemetryEntity" })
+@Entity({ name: "InventoryItem" })
 // Natural key + upsert conflict target for the throttled ingest reconciler.
 @Index(["projectId", "entityType", "entityKey"], { unique: true })
 // List-by-type (entity explorer) and reverse lookup from a typed resource row.
 @Index(["projectId", "entityType"])
 @Index(["projectId", "resourceType", "resourceId"])
-export default class TelemetryEntity extends DatabaseBaseModel {
+/*
+ * Every list view filters on `isArchived`, so it belongs in the same index as
+ * the tenant column rather than being scanned per row.
+ */
+@Index(["projectId", "isArchived"])
+export default class InventoryItem extends DatabaseBaseModel {
   @ColumnAccessControl({ create: CREATE_PERMS, read: READ_PERMS, update: [] })
   @TableColumn({
     manyToOneRelationColumn: "projectId",
@@ -177,7 +197,7 @@ export default class TelemetryEntity extends DatabaseBaseModel {
     type: TableColumnType.ShortText,
     required: false,
     title: "Display Name",
-    description: "Human-readable name derived for the entity explorer UI.",
+    description: "Human-readable name shown in the Inventory list.",
     example: "checkout-7d9f",
   })
   @Column({
@@ -187,6 +207,50 @@ export default class TelemetryEntity extends DatabaseBaseModel {
   })
   public displayName?: string = undefined;
 
+  /*
+   * Immutable after create (`update: []`): the value decides whether
+   * PruneStaleEntities may reap the row, so letting it be edited would let a
+   * user flip a manual CI into a TTL-pruned one — or quietly make a
+   * discovered row immortal. Re-create the row instead.
+   */
+  @ColumnAccessControl({ create: CREATE_PERMS, read: READ_PERMS, update: [] })
+  @TableColumn({
+    type: TableColumnType.ShortText,
+    required: true,
+    title: "Source",
+    description:
+      "How this row came to exist: discovered from telemetry, mirrored from a OneUptime inventory table, or created manually by a user. Determines whether stale-entity pruning applies.",
+    example: "discovered",
+  })
+  @Index()
+  @Column({
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    nullable: false,
+    default: EntitySource.Discovered,
+  })
+  public source?: EntitySource = undefined;
+
+  @ColumnAccessControl({
+    create: CREATE_PERMS,
+    read: READ_PERMS,
+    update: UPDATE_PERMS,
+  })
+  @TableColumn({
+    type: TableColumnType.LongText,
+    required: false,
+    title: "Description",
+    description:
+      "Free-text description. Primarily for manually created entities, where there are no telemetry attributes to explain what the thing is.",
+    example: "Stripe payments API - vendor managed, no telemetry.",
+  })
+  @Column({
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
+    nullable: true,
+  })
+  public description?: string = undefined;
+
   @ColumnAccessControl({
     create: CREATE_PERMS,
     read: READ_PERMS,
@@ -304,6 +368,117 @@ export default class TelemetryEntity extends DatabaseBaseModel {
   @Column({ type: ColumnType.Date, nullable: true })
   public lastSeenAt?: Date = undefined;
 
+  /*
+   * Archiving is the disposal route that actually works for this table.
+   *
+   * Deleting a discovered or mirrored row does not stick — ingest re-creates
+   * it on the next reconcile, the poller re-mirrors it on the next sweep. So
+   * "I have seen this and I do not want it in my list" had no expression at
+   * all before this column: the only button available was one that undoes
+   * itself. Archiving is a user annotation the reconciler never writes (its
+   * update is the `lastSeenAt` bump plus an attribute merge, and neither
+   * touches this), so it survives re-registration.
+   *
+   * The row keeps its identity and keeps collecting telemetry; it is only
+   * hidden from the default list.
+   */
+  @ColumnAccessControl({
+    create: CREATE_PERMS,
+    read: READ_PERMS,
+    update: UPDATE_PERMS,
+  })
+  @TableColumn({
+    isDefaultValueColumn: true,
+    required: true,
+    type: TableColumnType.Boolean,
+    title: "Is Archived",
+    description:
+      "Is this item archived? Archived items are hidden from the default list but keep their identity and keep collecting telemetry.",
+    defaultValue: false,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public isArchived?: boolean = undefined;
+
+  /*
+   * Stamped server-side from the `isArchived` write (see
+   * DatabaseService.sanitizeCreateOrUpdate), which is why these two are
+   * read-only to the client.
+   */
+  @ColumnAccessControl({ create: [], read: READ_PERMS, update: [] })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Date,
+    title: "Archived At",
+    description: "When this item was archived.",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+  })
+  public archivedAt?: Date = undefined;
+
+  @ColumnAccessControl({ create: [], read: READ_PERMS, update: [] })
+  @TableColumn({
+    manyToOneRelationColumn: "archivedByUserId",
+    type: TableColumnType.Entity,
+    modelType: User,
+    title: "Archived by User",
+    description:
+      "Relation to User who archived this object (if this object was archived by a User)",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "archivedByUserId" })
+  public archivedByUser?: User = undefined;
+
+  @ColumnAccessControl({ create: [], read: READ_PERMS, update: [] })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Archived by User ID",
+    description:
+      "User ID who archived this object (if this object was archived by a User)",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public archivedByUserId?: ObjectID = undefined;
+
+  /*
+   * Project-defined fields, whose shape lives in InventoryItemCustomField.
+   * Useful here in a way it is not on most tables: an estate catalog is
+   * exactly where an organisation wants to hang its own vocabulary — owner
+   * team, cost centre, compliance scope — on rows OneUptime discovered
+   * rather than rows a person filled in.
+   */
+  @ColumnAccessControl({
+    create: CREATE_PERMS,
+    read: READ_PERMS,
+    update: UPDATE_PERMS,
+  })
+  @TableColumn({
+    type: TableColumnType.JSON,
+    required: false,
+    title: "Custom Fields",
+    description: "Custom fields on this item.",
+  })
+  @Column({ type: ColumnType.JSON, nullable: true })
+  public customFields?: JSONObject = undefined;
+
   @ColumnAccessControl({ create: CREATE_PERMS, read: READ_PERMS, update: [] })
   @TableColumn({
     manyToOneRelationColumn: "createdByUserId",