tabletcommand-backend-models 7.4.89 → 7.4.91

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabletcommand-backend-models",
-  "version": "7.4.89",
+  "version": "7.4.91",
   "description": "Tablet Command Backend Models",
   "scripts": {
     "lint": "eslint src",

package/src/index.ts

@@ -79,6 +79,8 @@ async function wireModels(mongoose: MongooseModule) {
     SAML: await getModel(import("./models/saml")),
     SMSLog: await getModel(import("./models/sms-log")),
     SMTPUnhandled: await getModel(import("./models/smtp-unhandled")),
+    StatusBeacon: await getModel(import("./models/status-beacon")),
+    StatusBeaconTransition: await getModel(import("./models/status-beacon-transition")),
     Template: await getModel(import("./models/template")),
     User: await getModel(import("./models/user")),
     UserDevice: await getModel(import("./models/user-device")),
@@ -141,6 +143,8 @@ export { Session, SessionModel } from "./models/session";
 export { SAML, SAMLModel } from "./models/saml";
 export { SMSLog, SMSLogModel } from "./models/sms-log";
 export { SMTPUnhandled, SMTPUnhandledModel } from "./models/smtp-unhandled";
+export { StatusBeacon, StatusBeaconModel } from "./models/status-beacon";
+export { StatusBeaconTransition, StatusBeaconTransitionModel } from "./models/status-beacon-transition";
 export { Template, TemplateModel } from "./models/template";
 export { User, UserModel } from "./models/user";
 export { UserDevice, UserDeviceModel } from "./models/user-device";

package/src/models/schema/webhook.ts

@@ -122,7 +122,15 @@ export function WebhookProcessSchema(mongoose: MongooseModule) {
     locationUrl: {
       type: String,
       default: "",
-    }
+    },
+    usePartnerUrl: {
+      type: Boolean,
+      default: false
+    },
+    partnerId: {
+      type: String,
+      default: ""
+    },
   }, {
     _id: false,
     id: false,

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/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/department.ts

@@ -35,6 +35,8 @@ export interface WSFeedConnectionLocationOptionsType extends WSFeedConnectionOpt
 export interface WebhookProcessLocationConfigType {
   enabled: boolean,
   locationUrl: string,
+  usePartnerUrl: boolean,
+  partnerId: string,
 }
 
 export interface WebhookProcessCommentConfigType {

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;
+}