tabletcommand-backend-models 7.4.104 → 7.4.106

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabletcommand-backend-models",
-  "version": "7.4.104",
+  "version": "7.4.106",
   "description": "Tablet Command Backend Models",
   "scripts": {
     "lint": "eslint src",
@@ -8,7 +8,7 @@
     "test": "tsx --test --test-concurrency=1 --test-reporter=spec src/test/*.ts"
   },
   "author": "Marius Ursache <marius@tabletcommand.com>",
-  "license": "MIT",
+  "license": "UNLICENSED",
   "repository": {
     "type": "git",
     "url": "git://github.com/TabletCommand/tabletcommand-backend-models.git"

package/src/index.ts

@@ -88,6 +88,7 @@ async function wireModels(mongoose: MongooseModule) {
     UserDevice: await getModel(import("./models/user-device")),
     UserRegistration: await getModel(import("./models/user-registration")),
     ValidationReport: await getModel(import("./models/validation-report")),
+    WatchDutyEvent: await getModel(import("./models/watchduty-event")),
   };
 }
 
@@ -154,6 +155,7 @@ export { User, UserModel } from "./models/user";
 export { UserDevice, UserDeviceModel } from "./models/user-device";
 export { UserRegistration, UserRegistrationModel } from "./models/user-registration";
 export { ValidationReport, ValidationReportModel } from "./models/validation-report";
+export { WatchDutyEvent, WatchDutyEventModel } from "./models/watchduty-event";
 
 export * from "./helpers";
 export { IntegrationTypes } from "./types/department";

package/src/models/department.ts

@@ -2288,6 +2288,17 @@ export default async function DepartmentModule(mongoose: MongooseModule) {
         default: 45000,
       },
     },
+
+    watchDuty: {
+      enabled: {
+        type: Boolean,
+        default: false,
+      },
+      visible: {
+        type: Boolean,
+        default: false,
+      },
+    },
     activeUserCount: {
       type: Number,
       default: 0,

package/src/models/global-settings.ts

@@ -5,6 +5,7 @@ import { Model } from "mongoose";
 import {
   ArcGISKeyType,
   GlobalSettingsType,
+  WatchDutySyncType,
   ZonehavenTokenType,
 } from "../types/global-settings";
 import { EncryptedDataType } from "../types/common";
@@ -58,6 +59,15 @@ export default async function GlobalSettingsModule(mongoose: MongooseModule) {
     id: false,
   });
 
+  const WatchDutySync = new Schema<WatchDutySyncType>({
+    lastModifiedAt: {
+      type: Date,
+    },
+  }, {
+    _id: false,
+    id: false,
+  });
+
   const modelSchema = new Schema<GlobalSettingsType>({
     _id: {
       type: Schema.Types.ObjectId,
@@ -74,6 +84,9 @@ export default async function GlobalSettingsModule(mongoose: MongooseModule) {
     zonehavenToken: {
       type: ZonehavenToken,
     },
+    watchDutySync: {
+      type: WatchDutySync,
+    },
     updatedAt: {
       type: Date,
     },

package/src/models/watchduty-event.ts

@@ -0,0 +1,135 @@
+import { Model } from "mongoose";
+import {
+  MongooseModule,
+  currentDate,
+} from "../helpers";
+import { GeoPointSchema } from "./schema/geojson";
+import { WatchDutyEventType, WatchDutyRegionType } from "../types/watchduty-event";
+
+export interface WatchDutyEvent extends WatchDutyEventType { }
+
+export default async function WatchDutyEventModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+  const GeoJSONPoint = GeoPointSchema(mongoose);
+
+  const WatchDutyRegion = new Schema<WatchDutyRegionType>({
+    name: {
+      type: String,
+      default: "",
+    },
+    state: {
+      type: String,
+      default: "",
+    },
+  }, {
+    _id: false,
+    id: false,
+  });
+
+  const modelSchema = new Schema<WatchDutyEventType>({
+    _id: {
+      type: Schema.Types.ObjectId,
+      auto: true,
+    },
+    watchDutyId: {
+      type: Number,
+      required: true,
+    },
+    name: {
+      type: String,
+      default: "",
+    },
+    description: {
+      type: String,
+      default: "",
+    },
+    geoEventType: {
+      type: String,
+      default: "",
+    },
+    locationGeoJSON: {
+      type: GeoJSONPoint,
+      default: null,
+    },
+    address: {
+      type: String,
+      default: "",
+    },
+    isPrescribed: {
+      type: Boolean,
+      default: false,
+    },
+    areaSquareMeters: {
+      type: Number,
+      default: null,
+    },
+    containment: {
+      type: Number,
+      default: null,
+    },
+    evacuationOrders: {
+      type: String,
+      default: "",
+    },
+    evacuationWarnings: {
+      type: String,
+      default: "",
+    },
+    evacuationAdvisories: {
+      type: String,
+      default: "",
+    },
+    evacuationShelterInPlace: {
+      type: String,
+      default: "",
+    },
+    regions: {
+      type: [WatchDutyRegion],
+      default: [],
+    },
+    active: {
+      type: Boolean,
+      default: true,
+    },
+    watchDutyCreatedAt: {
+      type: Date,
+      required: true,
+    },
+    watchDutyModifiedAt: {
+      type: Date,
+      required: true,
+    },
+    created: {
+      type: Date,
+      default: currentDate,
+    },
+    modified: {
+      type: Date,
+      default: currentDate,
+    },
+  }, {
+    autoIndex: false,
+    timestamps: {
+      createdAt: "created",
+      updatedAt: "modified",
+    },
+  });
+
+  modelSchema.index({
+    watchDutyId: 1,
+  }, {
+    name: "watchDutyId_1_unique",
+    unique: true,
+  });
+
+  modelSchema.index({
+    active: 1,
+    modified: 1,
+  }, {
+    name: "active_1_modified_1",
+  });
+
+  return mongoose.model<WatchDutyEvent>("WatchDutyEvent", modelSchema, "massive_watchduty_event", { overwriteModels: true });
+}
+
+export interface WatchDutyEventModel extends Model<WatchDutyEvent> { }

package/src/test/0index.ts

@@ -77,5 +77,6 @@ describe(" Models", function() {
     assert.isFunction(models.UserDevice, "Missing UserDevice");
     assert.isFunction(models.UserRegistration, "Missing UserRegistration");
     assert.isFunction(models.ValidationReport, "Missing ValidationReport");
+    assert.isFunction(models.WatchDutyEvent, "Missing WatchDutyEvent");
   });
 });

package/src/test/department.ts

@@ -134,6 +134,8 @@ describe("Department", function () {
     assert.equal(sut.timeZone, testItem.timeZone);
     assert.equal(sut.webDisclaimer.message, testItem.webDisclaimer?.message);
     assert.equal(sut.webDisclaimer.enabled, testItem.webDisclaimer?.enabled);
+    assert.isFalse(sut.watchDuty.enabled);
+    assert.isFalse(sut.watchDuty.visible);
   });
 
   it("saves SOAP forwarding connection properties", async function () {

package/src/test/global-settings.ts

@@ -49,5 +49,9 @@ describe("GlobalSettings", function() {
     assert.equal(sut.zonehavenToken?.expireAt?.toISOString(), "2025-12-12T01:02:03.000Z");
     assert.equal(sut.zonehavenToken?.token, testItem.zonehavenToken?.token);
     assert.equal(sut.zonehavenToken?.referer, testItem.zonehavenToken?.referer);
+
+    assert.isObject(sut.watchDutySync);
+    assert.isTrue(isDate(sut.watchDutySync.lastModifiedAt));
+    assert.equal(sut.watchDutySync?.lastModifiedAt?.toISOString(), "2025-11-11T04:05:06.000Z");
   });
 });

package/src/test/mock.ts

@@ -996,6 +996,34 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
       expireAt: new Date("2025-12-12T01:02:03.000Z"),
       referer: "tabletcommand.com",
     },
+    watchDutySync: {
+      lastModifiedAt: new Date("2025-11-11T04:05:06.000Z"),
+    },
+  };
+
+  const watchDutyEvent = {
+    watchDutyId: 123456,
+    name: "Line Fire",
+    description: "Vegetation fire off Highway 38",
+    geoEventType: "wildfire",
+    locationGeoJSON: {
+      type: "Point",
+      coordinates: [-117.1234, 34.1234],
+    },
+    address: "Highway 38, Angelus Oaks, CA",
+    isPrescribed: false,
+    areaSquareMeters: 5060594,
+    containment: 42,
+    evacuationOrders: "Zone A, Zone B",
+    evacuationWarnings: "Zone C",
+    evacuationAdvisories: "Zone D",
+    evacuationShelterInPlace: "Zone E",
+    regions: [
+      { name: "San Bernardino County", state: "CA" },
+    ],
+    active: true,
+    watchDutyCreatedAt: new Date("2025-08-01T10:00:00.000Z"),
+    watchDutyModifiedAt: new Date("2025-08-02T11:00:00.000Z"),
   };
 
   const audioStreamAuthentication = {
@@ -1682,5 +1710,6 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
     userDevice,
     userRegistration,
     validationReport,
+    watchDutyEvent,
   };
 }

package/src/test/watchduty-event.ts

@@ -0,0 +1,163 @@
+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("WatchDutyEvent", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: ReturnType<typeof mockModule>["watchDutyEvent"];
+
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+    testItem = mockModule({ mongoose }).watchDutyEvent;
+    await models.WatchDutyEvent.syncIndexes();
+  });
+  afterEach(async function() {
+    await models.WatchDutyEvent.deleteMany({});
+    await mongoose.disconnect();
+  });
+
+  it("is saved and reads back every field", async function() {
+    const sut = await new models.WatchDutyEvent(testItem).save();
+
+    assert.isNotNull(sut._id);
+    assert.equal(sut.watchDutyId, testItem.watchDutyId);
+    assert.equal(sut.name, testItem.name);
+    assert.equal(sut.description, testItem.description);
+    assert.equal(sut.geoEventType, testItem.geoEventType);
+    assert.equal(sut.locationGeoJSON?.type, "Point");
+    assert.equal(sut.locationGeoJSON?.coordinates[0], testItem.locationGeoJSON.coordinates[0]);
+    assert.equal(sut.locationGeoJSON?.coordinates[1], testItem.locationGeoJSON.coordinates[1]);
+    assert.equal(sut.address, testItem.address);
+    assert.isFalse(sut.isPrescribed);
+    assert.equal(sut.areaSquareMeters, testItem.areaSquareMeters);
+    assert.equal(sut.containment, testItem.containment);
+    assert.equal(sut.evacuationOrders, testItem.evacuationOrders);
+    assert.equal(sut.evacuationWarnings, testItem.evacuationWarnings);
+    assert.equal(sut.evacuationAdvisories, testItem.evacuationAdvisories);
+    assert.equal(sut.evacuationShelterInPlace, testItem.evacuationShelterInPlace);
+    assert.equal(sut.regions.length, 1);
+    assert.equal(sut.regions[0]?.name, testItem.regions[0]?.name);
+    assert.equal(sut.regions[0]?.state, testItem.regions[0]?.state);
+    assert.isTrue(sut.active);
+    assert.equal(sut.watchDutyCreatedAt.toISOString(), testItem.watchDutyCreatedAt.toISOString());
+    assert.equal(sut.watchDutyModifiedAt.toISOString(), testItem.watchDutyModifiedAt.toISOString());
+    assert.instanceOf(sut.created, Date);
+    assert.instanceOf(sut.modified, Date);
+  });
+
+  it("defaults optional fields", async function() {
+    const sut = await new models.WatchDutyEvent({
+      watchDutyId: 654321,
+      watchDutyCreatedAt: new Date(),
+      watchDutyModifiedAt: new Date(),
+    }).save();
+
+    assert.equal(sut.name, "");
+    assert.equal(sut.description, "");
+    assert.equal(sut.geoEventType, "");
+    assert.isNull(sut.locationGeoJSON);
+    assert.equal(sut.address, "");
+    assert.isFalse(sut.isPrescribed);
+    assert.isNull(sut.areaSquareMeters);
+    assert.isNull(sut.containment);
+    assert.equal(sut.evacuationOrders, "");
+    assert.equal(sut.evacuationWarnings, "");
+    assert.equal(sut.evacuationAdvisories, "");
+    assert.equal(sut.evacuationShelterInPlace, "");
+    assert.deepEqual(sut.regions, []);
+    assert.isTrue(sut.active);
+    assert.instanceOf(sut.created, Date);
+    assert.instanceOf(sut.modified, Date);
+  });
+
+  // timestamps defaults createdAt to true, which would store an undeclared createdAt field.
+  it("stores no timestamp field outside the schema", async function() {
+    await new models.WatchDutyEvent({
+      watchDutyId: 333,
+      watchDutyCreatedAt: new Date(),
+      watchDutyModifiedAt: new Date(),
+    }).save();
+
+    const raw = await models.WatchDutyEvent.collection.findOne({ watchDutyId: 333 });
+    assert.isNotNull(raw);
+    assert.notProperty(raw, "createdAt");
+    assert.notProperty(raw, "updatedAt");
+    assert.property(raw, "created");
+    assert.property(raw, "modified");
+  });
+
+  // The retention sweep deletes inactive events by `modified`, and the cron upserts through
+  // findOneAndUpdate, which skips the schema default. Only the timestamps option keeps the
+  // field current.
+  it("advances modified on findOneAndUpdate", async function() {
+    const staleDate = new Date("2020-01-02T03:04:05.000Z");
+    await new models.WatchDutyEvent({
+      watchDutyId: 222,
+      watchDutyCreatedAt: new Date(),
+      watchDutyModifiedAt: new Date(),
+    }).save();
+    await models.WatchDutyEvent.collection.updateOne({
+      watchDutyId: 222,
+    }, {
+      $set: {
+        modified: staleDate,
+      },
+    });
+
+    const updated = await models.WatchDutyEvent.findOneAndUpdate({
+      watchDutyId: 222,
+    }, {
+      $set: {
+        active: false,
+      },
+    }, {
+      new: true,
+    });
+
+    assert.isNotNull(updated);
+    assert.isFalse(updated?.active);
+    assert.isAbove(Number(updated?.modified), Number(staleDate));
+  });
+
+  it("enforces a unique watchDutyId index", async function() {
+    await new models.WatchDutyEvent({
+      watchDutyId: 111,
+      watchDutyCreatedAt: new Date(),
+      watchDutyModifiedAt: new Date(),
+    }).save();
+
+    let thrownError: unknown = null;
+    try {
+      await new models.WatchDutyEvent({
+        watchDutyId: 111,
+        watchDutyCreatedAt: new Date(),
+        watchDutyModifiedAt: new Date(),
+      }).save();
+    } catch (e) {
+      thrownError = e;
+    }
+
+    assert.isNotNull(thrownError, "expected duplicate watchDutyId to be rejected");
+    assert.equal((thrownError as { code?: number }).code, 11000);
+    assert.include(String((thrownError as Error).message), "E11000");
+  });
+
+  it("requires watchDutyId", async function() {
+    let thrownError: unknown = null;
+    try {
+      await new models.WatchDutyEvent({
+        watchDutyCreatedAt: new Date(),
+        watchDutyModifiedAt: new Date(),
+      }).save();
+    } catch (e) {
+      thrownError = e;
+    }
+
+    assert.isNotNull(thrownError, "expected missing watchDutyId to be rejected");
+    assert.include(String((thrownError as Error).message), "watchDutyId");
+  });
+});

package/src/types/department.ts

@@ -546,6 +546,11 @@ export type AccountConfigurationZonehaven = {
   fadeZoomLevel: number,
 };
 
+export type AccountConfigurationWatchDuty = {
+  enabled: boolean,
+  visible: boolean,
+};
+
 export type ManagedIncidentPriorityItem = {
   title: string,
   color: ColorSchemaType,
@@ -705,4 +710,5 @@ export interface DepartmentType {
   webhook: WebhookConfigType,
   wsFeed: WSFeedConfigType,
   zonehaven: AccountConfigurationZonehaven,
+  watchDuty: AccountConfigurationWatchDuty,
 }

package/src/types/global-settings.ts

@@ -12,10 +12,18 @@ export type ZonehavenTokenType = {
   referer: string | null,
 };
 
+// Incremental pull cursor for the Watch Duty events cron. One Watch Duty account feeds every
+// department, so the cursor is global. The cron holds it back when a fetch is incomplete, which
+// is why it is stored and not derived from the events themselves.
+export type WatchDutySyncType = {
+  lastModifiedAt: Date | null,
+};
+
 export interface GlobalSettingsType {
   _id: Types.ObjectId,
   name: "global",
   arcgisApiKey: ArcGISKeyType,
   zonehavenToken: ZonehavenTokenType,
+  watchDutySync: WatchDutySyncType,
   updatedAt: Date,
 }

package/src/types/watchduty-event.ts

@@ -0,0 +1,36 @@
+import { Types } from "mongoose";
+import { GeoPoint } from "./geojson";
+
+export interface WatchDutyRegionType {
+  name: string,
+  state: string,
+}
+
+export interface WatchDutyEventType {
+  _id: Types.ObjectId,
+  watchDutyId: number,
+  name: string,
+  description: string,
+  geoEventType: string,
+  // Null when Watch Duty reports no usable lat/lng. The event is still stored, it just cannot
+  // be drawn.
+  locationGeoJSON: GeoPoint | null,
+  address: string,
+  isPrescribed: boolean,
+  // Watch Duty reports the burned area in acres. It is converted on the way in.
+  areaSquareMeters: number | null,
+  // Percent of the fire perimeter contained, 0 to 100.
+  containment: number | null,
+  evacuationOrders: string,
+  evacuationWarnings: string,
+  evacuationAdvisories: string,
+  evacuationShelterInPlace: string,
+  regions: WatchDutyRegionType[],
+  active: boolean,
+  // Watch Duty's own timestamps. `created` and `modified` are ours, and mean the first and the
+  // last time we wrote the record.
+  watchDutyCreatedAt: Date,
+  watchDutyModifiedAt: Date,
+  created: Date,
+  modified: Date,
+}

package/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016 Marius Ursache
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.