tabletcommand-backend-models 7.4.90 → 7.4.92

package/src/models/status-beacon-transition.ts

@@ -0,0 +1,60 @@
+import {
+  MongooseModule,
+} from "../helpers";
+import { Model } from "mongoose";
+import { StatusBeaconTransitionType } from "../types/status-beacon";
+
+export interface StatusBeaconTransition extends StatusBeaconTransitionType { }
+
+export default async function StatusBeaconTransitionModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const modelSchema = new Schema<StatusBeaconTransitionType>({
+    _id: {
+      type: Schema.Types.ObjectId,
+      auto: true,
+    },
+    departmentId: {
+      type: String,
+      default: "",
+      required: true,
+    },
+    integration: {
+      type: String,
+      default: "",
+      required: true,
+    },
+    triggerReason: {
+      type: String,
+      default: "",
+    },
+    healthState: {
+      type: String,
+      default: "",
+    },
+    consecutiveFailures: {
+      type: Number,
+      default: 0,
+    },
+    totalFailuresSinceLastHealthy: {
+      type: Number,
+      default: 0,
+    },
+    lastError: {
+      type: String,
+      default: "",
+    },
+  }, {
+    autoIndex: false,
+    timestamps: true,
+  });
+
+  modelSchema.index({ departmentId: 1, integration: 1, createdAt: -1 }, {
+    name: "departmentId_1_integration_1_createdAt_-1",
+  });
+  modelSchema.index({ createdAt: 1 }, { name: "createdAt_1" });
+
+  return mongoose.model<StatusBeaconTransition>("StatusBeaconTransition", modelSchema, "massive_status_beacon_transition", { overwriteModels: true });
+}
+
+export interface StatusBeaconTransitionModel extends Model<StatusBeaconTransition> { }

package/src/models/status-beacon.ts

@@ -0,0 +1,193 @@
+import {
+  MongooseModule,
+  currentDate,
+} from "../helpers";
+import { Model } from "mongoose";
+import {
+  StatusBeaconType,
+  QueueDepthsType,
+  TCSendHealthType,
+  WriteBackHealthType,
+  SyncHealthType,
+} from "../types/status-beacon";
+
+export interface StatusBeacon extends StatusBeaconType { }
+
+export default async function StatusBeaconModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const QueueDepths = new Schema<QueueDepthsType>({
+    incident: { type: Number, default: 0 },
+    status: { type: Number, default: 0 },
+    vehicle: { type: Number, default: 0 },
+    total: { type: Number, default: 0 },
+  }, { _id: false, id: false });
+
+  const TCSendHealth = new Schema<TCSendHealthType>({
+    lastSuccessfulIncidentSend: { type: Date },
+    lastSuccessfulUnitStatusSend: { type: Date },
+    sendFailuresDelta: { type: Number, default: 0 },
+    lastSendError: { type: String, default: "" },
+  }, { _id: false, id: false });
+
+  const WriteBackHealth = new Schema<WriteBackHealthType>({
+    attemptsDelta: { type: Number, default: 0 },
+    failuresDelta: { type: Number, default: 0 },
+    lastSuccessfulWriteBack: { type: Date },
+    lastError: { type: String, default: "" },
+  }, { _id: false, id: false });
+
+  const SyncHealth = new Schema<SyncHealthType>({
+    lastCacheRefresh: { type: Date },
+    cacheAgeSeconds: { type: Number, default: 0 },
+    consecutiveEmptyPolls: { type: Number, default: 0 },
+    lastPollChanges: { type: Number, default: 0 },
+    incidentCacheGrowthDelta: { type: Number, default: 0 },
+  }, { _id: false, id: false });
+
+  const modelSchema = new Schema<StatusBeaconType>({
+    _id: {
+      type: Schema.Types.ObjectId,
+      auto: true,
+    },
+    departmentId: {
+      type: String,
+      default: "",
+      required: true,
+    },
+    // Identity
+    integration: {
+      type: String,
+      default: "",
+      required: true,
+    },
+    interfaceStartTime: {
+      type: Date,
+      default: currentDate,
+    },
+    // Health State
+    healthState: {
+      type: String,
+      default: "",
+    },
+    triggerReason: {
+      type: String,
+      default: "",
+    },
+    consecutiveFailures: {
+      type: Number,
+      default: 0,
+    },
+    consecutiveSuccesses: {
+      type: Number,
+      default: 0,
+    },
+    totalFailuresSinceLastHealthy: {
+      type: Number,
+      default: 0,
+    },
+    outageStartTime: {
+      type: Date,
+    },
+    // Cycle Metrics
+    pollCycle: {
+      type: Number,
+      default: 0,
+    },
+    lastPollMs: {
+      type: Number,
+      default: 0,
+    },
+    activeIncidents: {
+      type: Number,
+      default: 0,
+    },
+    activeUnits: {
+      type: Number,
+      default: 0,
+    },
+    // Data Flow Deltas
+    incidentsDelta: {
+      type: Number,
+      default: 0,
+    },
+    unitStatusDelta: {
+      type: Number,
+      default: 0,
+    },
+    // Queue Depths
+    queueDepths: {
+      type: QueueDepths,
+      default: () => ({}),
+    },
+    // Auth Token Health
+    tokenAgeSecs: {
+      type: Number,
+    },
+    tokenExpiresAt: {
+      type: Date,
+    },
+    // TC Send Health
+    tCSend: {
+      type: TCSendHealth,
+      default: () => ({}),
+    },
+    // Write-back Health
+    writeBack: {
+      type: WriteBackHealth,
+      default: () => ({}),
+    },
+    // Sync Health
+    sync: {
+      type: SyncHealth,
+      default: () => ({}),
+    },
+    // Debug & Config
+    debugPushActive: {
+      type: Boolean,
+      default: false,
+    },
+    lastConfigSave: {
+      type: Date,
+    },
+    lastConfigSaveFile: {
+      type: String,
+      default: "",
+    },
+    // Error & Version
+    lastError: {
+      type: String,
+      default: "",
+    },
+    interfaceVersion: {
+      type: String,
+      default: "",
+    },
+    cadVersion: {
+      type: String,
+      default: "",
+    },
+    unifiedVersion: {
+      type: String,
+      default: "",
+    },
+  }, {
+    autoIndex: false,
+    timestamps: true,
+  });
+
+  modelSchema.index({ departmentId: 1, integration: 1 }, {
+    name: "departmentId_1_integration_1",
+    unique: true,
+  });
+  modelSchema.index({ healthState: 1 }, { name: "healthState_1" });
+  modelSchema.index({ triggerReason: 1 }, { name: "triggerReason_1" });
+  modelSchema.index({ "queueDepths.total": 1 }, { name: "queueDepths_total_1" });
+  modelSchema.index({ "tCSend.sendFailuresDelta": 1 }, { name: "tCSend_sendFailuresDelta_1" });
+  modelSchema.index({ "writeBack.failuresDelta": 1 }, { name: "writeBack_failuresDelta_1" });
+  modelSchema.index({ "sync.consecutiveEmptyPolls": 1 }, { name: "sync_consecutiveEmptyPolls_1" });
+
+  return mongoose.model<StatusBeacon>("StatusBeacon", modelSchema, "massive_status_beacon", { overwriteModels: true });
+}
+
+export interface StatusBeaconModel extends Model<StatusBeacon> { }

package/src/test/0index.ts

@@ -67,6 +67,8 @@ describe(" Models", function() {
     assert.isFunction(models.RemoteLogStream, "Missing RemoteLogStream");
     assert.isFunction(models.Session, "Missing Session");
     assert.isFunction(models.SAML, "Missing SAML");
+    assert.isFunction(models.StatusBeacon, "Missing StatusBeacon");
+    assert.isFunction(models.StatusBeaconTransition, "Missing StatusBeaconTransition");
     assert.isFunction(models.SMSLog, "Missing SMSLog");
     assert.isFunction(models.SMTPUnhandled, "Missing SMTPUnhandled");
     assert.isFunction(models.Template, "Missing Template");

package/src/test/esri.ts

@@ -1,5 +1,6 @@
 import { assert } from "chai";
 import { describe, it, beforeEach, afterEach } from "node:test";
+import { rejects as assertRejects } from "node:assert/strict";
 import * as m from "../index";
 import * as config from "./config";
 import mockModule from "./mock";
@@ -59,4 +60,49 @@ describe("Esri", function() {
     const props = mapPropsFound[0];
     assert.equal(props?.download, true);
   });
+
+  it("enforces unique arcGISAuth.username constraint", async function() {
+    await new models.Esri({
+      departmentId: new mongoose.Types.ObjectId(),
+      arcGISAuth: { username: "tc_dup_user" },
+    }).save();
+
+    // A second department claiming the same non-empty username must be rejected.
+    // assertRejects fails if the save does NOT reject, so there is no false-positive.
+    await assertRejects(
+      new models.Esri({
+        departmentId: new mongoose.Types.ObjectId(),
+        arcGISAuth: { username: "tc_dup_user" },
+      }).save(),
+      /duplicate key/
+    );
+  });
+
+  it("normalizes an empty arcGISAuth.username to null", async function() {
+    // EsriAuth.username defaults to "" (schema shared with auth); an arcGISAuth
+    // present without a real username collapses to null so it is never indexed.
+    const saved = await new models.Esri({
+      departmentId: new mongoose.Types.ObjectId(),
+      arcGISAuth: { username: "" },
+    }).save();
+    assert.isNull(saved.arcGISAuth);
+  });
+
+  it("allows multiple missing/empty arcGISAuth.username and distinct values", async function() {
+    // missing arcGISAuth entirely (defaults to null) — not indexed
+    await new models.Esri({ departmentId: new mongoose.Types.ObjectId() }).save();
+    await new models.Esri({ departmentId: new mongoose.Types.ObjectId() }).save();
+    // empty-string username — normalized to null by the pre-save hook, so not indexed.
+    // Both must coexist: without normalization the second would collide on "" under $exists.
+    const empty1 = await new models.Esri({ departmentId: new mongoose.Types.ObjectId(), arcGISAuth: { username: "" } }).save();
+    const empty2 = await new models.Esri({ departmentId: new mongoose.Types.ObjectId(), arcGISAuth: { username: "" } }).save();
+    assert.isNull(empty1.arcGISAuth);
+    assert.isNull(empty2.arcGISAuth);
+    // distinct non-empty usernames — allowed
+    await new models.Esri({ departmentId: new mongoose.Types.ObjectId(), arcGISAuth: { username: "tc_user_a" } }).save();
+    await new models.Esri({ departmentId: new mongoose.Types.ObjectId(), arcGISAuth: { username: "tc_user_b" } }).save();
+
+    const count = await models.Esri.countDocuments({});
+    assert.equal(count, 6);
+  });
 });

package/src/test/mock.ts

@@ -1504,6 +1504,70 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
     sendNotification: false
   };
 
+  const statusBeacon = {
+    _id: new mongoose.Types.ObjectId(),
+    departmentId,
+    integration: "test-cad-integration",
+    interfaceStartTime: new Date(),
+    healthState: "healthy",
+    triggerReason: "poll_success",
+    consecutiveFailures: 0,
+    consecutiveSuccesses: 5,
+    totalFailuresSinceLastHealthy: 0,
+    outageStartTime: undefined,
+    pollCycle: 42,
+    lastPollMs: 350,
+    activeIncidents: 3,
+    activeUnits: 12,
+    incidentsDelta: 1,
+    unitStatusDelta: 2,
+    queueDepths: {
+      incident: 0,
+      status: 0,
+      vehicle: 0,
+      total: 0,
+    },
+    tokenAgeSecs: 1800,
+    tokenExpiresAt: new Date(),
+    tCSend: {
+      lastSuccessfulIncidentSend: new Date(),
+      lastSuccessfulUnitStatusSend: new Date(),
+      sendFailuresDelta: 0,
+      lastSendError: "",
+    },
+    writeBack: {
+      attemptsDelta: 0,
+      failuresDelta: 0,
+      lastSuccessfulWriteBack: new Date(),
+      lastError: "",
+    },
+    sync: {
+      lastCacheRefresh: new Date(),
+      cacheAgeSeconds: 30,
+      consecutiveEmptyPolls: 0,
+      lastPollChanges: 2,
+      incidentCacheGrowthDelta: 1,
+    },
+    debugPushActive: false,
+    lastConfigSave: new Date(),
+    lastConfigSaveFile: "config-v1.json",
+    lastError: "",
+    interfaceVersion: "1.2.3",
+    cadVersion: "4.5.6",
+    unifiedVersion: "7.8.9",
+  };
+
+  const statusBeaconTransition = {
+    _id: new mongoose.Types.ObjectId(),
+    departmentId,
+    integration: "test-cad-integration",
+    triggerReason: "consecutive_failures",
+    healthState: "degraded",
+    consecutiveFailures: 3,
+    totalFailuresSinceLastHealthy: 5,
+    lastError: "connection timeout",
+  };
+
   const validationReport = {
     _id: new mongoose.Types.ObjectId(),
     departmentId: new mongoose.Types.ObjectId("56131f724143487a10000001"),
@@ -1601,6 +1665,8 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
     releaseNote,
     session,
     saml,
+    statusBeacon,
+    statusBeaconTransition,
     template,
     user,
     userDevice,

package/src/test/status-beacon.ts

@@ -0,0 +1,121 @@
+import { assert } from "chai";
+import { describe, it, beforeEach, afterEach } from "node:test";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("StatusBeacon", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.StatusBeacon>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({ mongoose });
+    testItem = mock.statusBeacon;
+    await mock.beforeEach();
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.StatusBeacon(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(sut._id);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.integration, sut.integration);
+    assert.equal(testItem.healthState, sut.healthState);
+    assert.equal(testItem.triggerReason, sut.triggerReason);
+    assert.equal(testItem.consecutiveFailures, sut.consecutiveFailures);
+    assert.equal(testItem.consecutiveSuccesses, sut.consecutiveSuccesses);
+    assert.equal(testItem.totalFailuresSinceLastHealthy, sut.totalFailuresSinceLastHealthy);
+    assert.equal(testItem.pollCycle, sut.pollCycle);
+    assert.equal(testItem.lastPollMs, sut.lastPollMs);
+    assert.equal(testItem.activeIncidents, sut.activeIncidents);
+    assert.equal(testItem.activeUnits, sut.activeUnits);
+    assert.equal(testItem.incidentsDelta, sut.incidentsDelta);
+    assert.equal(testItem.unitStatusDelta, sut.unitStatusDelta);
+    assert.equal(testItem.tokenAgeSecs, sut.tokenAgeSecs);
+    assert.equal(testItem.debugPushActive, sut.debugPushActive);
+    assert.equal(testItem.lastConfigSaveFile, sut.lastConfigSaveFile);
+    assert.equal(testItem.lastError, sut.lastError);
+    assert.equal(testItem.interfaceVersion, sut.interfaceVersion);
+    assert.equal(testItem.cadVersion, sut.cadVersion);
+    assert.equal(testItem.unifiedVersion, sut.unifiedVersion);
+    assert.isNotNull(sut.createdAt);
+    assert.isNotNull(sut.updatedAt);
+  });
+
+  it("saves nested queueDepths", async function() {
+    const item = new models.StatusBeacon(testItem);
+    const sut = await item.save();
+
+    assert.equal(testItem.queueDepths?.incident, sut.queueDepths.incident);
+    assert.equal(testItem.queueDepths?.status, sut.queueDepths.status);
+    assert.equal(testItem.queueDepths?.vehicle, sut.queueDepths.vehicle);
+    assert.equal(testItem.queueDepths?.total, sut.queueDepths.total);
+  });
+
+  it("saves nested tCSend health", async function() {
+    const item = new models.StatusBeacon(testItem);
+    const sut = await item.save();
+
+    assert.equal(testItem.tCSend?.sendFailuresDelta, sut.tCSend.sendFailuresDelta);
+    assert.equal(testItem.tCSend?.lastSendError, sut.tCSend.lastSendError);
+  });
+
+  it("saves nested writeBack health", async function() {
+    const item = new models.StatusBeacon(testItem);
+    const sut = await item.save();
+
+    assert.equal(testItem.writeBack?.attemptsDelta, sut.writeBack.attemptsDelta);
+    assert.equal(testItem.writeBack?.failuresDelta, sut.writeBack.failuresDelta);
+    assert.equal(testItem.writeBack?.lastError, sut.writeBack.lastError);
+  });
+
+  it("saves nested sync health", async function() {
+    const item = new models.StatusBeacon(testItem);
+    const sut = await item.save();
+
+    assert.equal(testItem.sync?.cacheAgeSeconds, sut.sync.cacheAgeSeconds);
+    assert.equal(testItem.sync?.consecutiveEmptyPolls, sut.sync.consecutiveEmptyPolls);
+    assert.equal(testItem.sync?.lastPollChanges, sut.sync.lastPollChanges);
+    assert.equal(testItem.sync?.incidentCacheGrowthDelta, sut.sync.incidentCacheGrowthDelta);
+  });
+});
+
+describe("StatusBeaconTransition", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.StatusBeaconTransition>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({ mongoose });
+    testItem = mock.statusBeaconTransition;
+    await mock.beforeEach();
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.StatusBeaconTransition(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(sut._id);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.integration, sut.integration);
+    assert.equal(testItem.triggerReason, sut.triggerReason);
+    assert.equal(testItem.healthState, sut.healthState);
+    assert.equal(testItem.consecutiveFailures, sut.consecutiveFailures);
+    assert.equal(testItem.totalFailuresSinceLastHealthy, sut.totalFailuresSinceLastHealthy);
+    assert.equal(testItem.lastError, sut.lastError);
+    assert.isNotNull(sut.createdAt);
+    assert.isNotNull(sut.updatedAt);
+  });
+});

package/src/types/status-beacon.ts

@@ -0,0 +1,90 @@
+import { Types } from "mongoose";
+
+export interface QueueDepthsType {
+  incident: number;
+  status: number;
+  vehicle: number;
+  total: number;
+}
+
+export interface TCSendHealthType {
+  lastSuccessfulIncidentSend?: Date;
+  lastSuccessfulUnitStatusSend?: Date;
+  sendFailuresDelta: number;
+  lastSendError: string;
+}
+
+export interface WriteBackHealthType {
+  attemptsDelta: number;
+  failuresDelta: number;
+  lastSuccessfulWriteBack?: Date;
+  lastError: string;
+}
+
+export interface SyncHealthType {
+  lastCacheRefresh?: Date;
+  cacheAgeSeconds: number;
+  consecutiveEmptyPolls: number;
+  lastPollChanges: number;
+  incidentCacheGrowthDelta: number;
+}
+
+export interface StatusBeaconType {
+  _id: Types.ObjectId;
+  departmentId: string;
+  // Identity
+  integration: string;
+  interfaceStartTime: Date; // UTC time the integration service process started; never resets — use for uptime
+  // Health State
+  healthState: string;
+  triggerReason: string;
+  consecutiveFailures: number;
+  consecutiveSuccesses: number;
+  totalFailuresSinceLastHealthy: number;
+  outageStartTime?: Date; // UTC time the current outage began; absent when healthy
+  // Cycle Metrics
+  pollCycle: number;
+  lastPollMs: number;
+  activeIncidents: number;
+  activeUnits: number;
+  // Data Flow Deltas
+  incidentsDelta: number;
+  unitStatusDelta: number;
+  // Queue Depths
+  queueDepths: QueueDepthsType;
+  // Auth Token Health (Bearer auth only; null otherwise)
+  tokenAgeSecs?: number;
+  tokenExpiresAt?: Date;
+  // TC Send Health
+  tCSend: TCSendHealthType;
+  // Write-back Health
+  writeBack: WriteBackHealthType;
+  // Sync Health
+  sync: SyncHealthType;
+  // Debug & Config
+  debugPushActive: boolean;
+  lastConfigSave?: Date;
+  lastConfigSaveFile: string;
+  // Error & Version
+  lastError: string;
+  interfaceVersion: string;
+  cadVersion: string;
+  unifiedVersion: string;
+  // System (managed by Mongoose timestamps)
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface StatusBeaconTransitionType {
+  _id: Types.ObjectId;
+  departmentId: string;
+  integration: string;
+  triggerReason: string;
+  healthState: string;
+  consecutiveFailures: number;
+  totalFailuresSinceLastHealthy: number;
+  lastError: string;
+  // System (managed by Mongoose timestamps)
+  createdAt: Date;
+  updatedAt: Date;
+}