tabletcommand-backend-models 5.39.7 → 7.0.1

package/src/models/battalion.ts

@@ -3,32 +3,20 @@ import * as uuid from "uuid";
 import {
   MongooseModule,
   MongooseDocument,
-  createSchema,
   currentDate,
-  DocumentTypeFromSchema,
-  ModelFromSchema,
-  createModel,
-  FieldsOfDocument,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   retrieveCurrentUnixTime
 } from "../helpers";
 
-export function BattalionSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
-  const toJSONOpts = {
-    virtuals: true,
-    versionKey: false,
-    transform(doc: DocumentTypeFromSchema<typeof modelSchema>, ret: FieldsOfDocument<DocumentTypeFromSchema<typeof modelSchema>>) {
-      strictSchema(doc.schema, ret);
-      ret.id = ret._id;
-    },
-  };
+import { Model } from "mongoose";
+import { BattalionType, BattalionUnitType } from "../types/battalion";
+
+export interface Battalion extends BattalionType, Record<string, unknown> { }
 
-  const BattalionUnit = createSchema(Schema, {
+export function BattalionSchema(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+  const BattalionUnit = new Schema<BattalionUnitType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     name: {
@@ -81,17 +69,28 @@ export function BattalionSchema(mongoose: MongooseModule) {
       type: String,
     },
     agencyId: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       ref: "Agency",
       default: null,
     },
   }, {});
 
-  BattalionUnit.set("toJSON", toJSONOpts);
+  BattalionUnit.virtual("id").get(function(this: MongooseDocument) {
+    // tslint:disable-next-line: no-unsafe-any
+    return this._id.toString();
+  });
+  BattalionUnit.set("toJSON", {
+    virtuals: true,
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    },
+  });
 
-  const modelSchema = createSchema(Schema, {
+
+  const modelSchema = new Schema<BattalionType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     name: {
@@ -131,7 +130,7 @@ export function BattalionSchema(mongoose: MongooseModule) {
       index: true,
     },
     agencyId: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       ref: "Agency",
       default: null,
     },
@@ -144,25 +143,24 @@ export function BattalionSchema(mongoose: MongooseModule) {
       default: []
     },
   }, {
-    collection: "massive_battalion",
+    autoIndex: false,
   });
   modelSchema.set("autoIndex", false);
+  modelSchema.virtual("id").get(function(this: MongooseDocument) {
+    // tslint:disable-next-line: no-unsafe-any
+    return this._id.toString();
+  });
   modelSchema.set("toJSON", {
     virtuals: true,
     versionKey: false,
-    transform(doc: ModelFromSchema<typeof modelSchema>, ret: DocumentTypeFromSchema<typeof modelSchema>) {
+    transform(doc, ret) {
       strictSchema(doc.schema as typeof modelSchema, ret);
-      ret.id = ret._id;
     },
   });
 
-  modelSchema.virtual("id").get(function (this: MongooseDocument) {
-    // tslint:disable-next-line: no-unsafe-any
-    return this._id.toString();
-  });
 
   function strictSchema(schema: typeof modelSchema, ret: Record<string, unknown>) {
-    Object.keys(ret).forEach(function (element) {
+    Object.keys(ret).forEach(function(element) {
       // Don't complain about the virtuals
       if (element === "id") {
         return;
@@ -178,11 +176,9 @@ export function BattalionSchema(mongoose: MongooseModule) {
   return modelSchema;
 }
 
-export async function BattalionModule(mongoose: MongooseModule) {
+export default async function BattalionModule(mongoose: MongooseModule) {
   const modelSchema = BattalionSchema(mongoose);
-  return createModel(mongoose, "Battalion", modelSchema);
+  return mongoose.model<Battalion>("Battalion", modelSchema, "massive_battalion", { overwriteModels: true });
 }
 
-export interface Battalion extends ItemTypeFromTypeSchemaFunction<typeof BattalionModule> { }
-export interface BattalionModel extends ModelTypeFromTypeSchemaFunction<Battalion> { }
-export default BattalionModule as ReplaceModelReturnType<typeof BattalionModule, BattalionModel>;
+export interface BattalionModel extends Model<Battalion> { }

package/src/models/beacon-log.ts

@@ -1,20 +1,19 @@
 import {
   MongooseModule,
-  createSchema,
-  createModel,
   currentDate,
   retrieveCurrentUnixTime,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { Model } from "mongoose";
+import { BeaconLogType } from "../types/beacon-log";
 
-export async function BeaconLogModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface BeaconLog extends BeaconLogType { }
 
-  const modelSchema = createSchema(Schema, {
+export default async function BeaconLogModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const modelSchema = new Schema<BeaconLogType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -38,13 +37,10 @@ export async function BeaconLogModule(mongoose: MongooseModule) {
       default: retrieveCurrentUnixTime,
     },
   }, {
-    collection: "massive_beacon_log",
+    autoIndex: false,
   });
-  modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "BeaconLog", modelSchema);
+  return mongoose.model<BeaconLog>("BeaconLog", modelSchema, "massive_beacon_log", { overwriteModels: true });
 }
 
-export interface BeaconLog extends ItemTypeFromTypeSchemaFunction<typeof BeaconLogModule> { }
-export interface BeaconLogModel extends ModelTypeFromTypeSchemaFunction<BeaconLog> { }
-export default BeaconLogModule as ReplaceModelReturnType<typeof BeaconLogModule, BeaconLogModel>;
+export interface BeaconLogModel extends Model<BeaconLog> { }

package/src/models/cad-incident-block.ts

@@ -1,27 +1,26 @@
 import {
   MongooseModule,
   MongooseDocument,
-  createSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
 
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
 
 import { ReportNumberSchema } from "./schema/shared-incident";
+import { Model } from "mongoose";
+import { CADIncidentBlockType } from "../types/cad";
 
-export async function CADIncidentBlockModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface CADIncidentBlock extends CADIncidentBlockType { }
+
+export default async function CADIncidentBlockModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
   const ReportNumber = ReportNumberSchema(mongoose);
 
   // Simplified schema.
   // Payload should confirm to cad-incident (more or less)
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<CADIncidentBlockType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -55,7 +54,6 @@ export async function CADIncidentBlockModule(mongoose: MongooseModule) {
       default: [],
     }
   }, {
-    collection: "massive_cad_incident_block",
     timestamps: true,
     autoIndex: false,
     toJSON: {
@@ -71,9 +69,7 @@ export async function CADIncidentBlockModule(mongoose: MongooseModule) {
 
   modelSchema.plugin(mongooseLeanVirtuals);
 
-  return createModel(mongoose, "CADIncidentBlock", modelSchema);
+  return mongoose.model<CADIncidentBlock>("CADIncidentBlock", modelSchema, "massive_cad_incident_block", { overwriteModels: true });
 }
 
-export interface CADIncidentBlock extends ItemTypeFromTypeSchemaFunction<typeof CADIncidentBlockModule> { }
-export interface CADIncidentBlockModel extends ModelTypeFromTypeSchemaFunction<CADIncidentBlock> { }
-export default CADIncidentBlockModule as ReplaceModelReturnType<typeof CADIncidentBlockModule, CADIncidentBlockModel>;
+export interface CADIncidentBlockModel extends Model<CADIncidentBlock> { }

package/src/models/cad-incident-stream.ts

@@ -1,26 +1,25 @@
 import {
   MongooseModule,
   MongooseDocument,
-  createSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   currentDate,
 } from "../helpers";
 
 import * as uuid from "uuid";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import { Model } from "mongoose";
+import { CADIncidentStreamType } from "../types/cad";
 
-export async function CADIncidentStreamModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface CADIncidentStream extends CADIncidentStreamType { }
+
+export default async function CADIncidentStreamModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
   // Simplified schema.
   // Payload should confirm to cad-incident (more or less)
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<CADIncidentStreamType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     uuid: {
@@ -52,7 +51,6 @@ export async function CADIncidentStreamModule(mongoose: MongooseModule) {
     },
   }, {
     autoIndex: false,
-    collection: "massive_cad_incident_stream",
     toJSON: {
       virtuals: true,
       versionKey: false,
@@ -66,9 +64,7 @@ export async function CADIncidentStreamModule(mongoose: MongooseModule) {
 
   modelSchema.plugin(mongooseLeanVirtuals);
 
-  return createModel(mongoose, "CADIncidentStream", modelSchema);
+  return mongoose.model<CADIncidentStream>("CADIncidentStream", modelSchema, "massive_cad_incident_stream", { overwriteModels: true });
 }
 
-export interface CADIncidentStream extends ItemTypeFromTypeSchemaFunction<typeof CADIncidentStreamModule> { }
-export interface CADIncidentStreamModel extends ModelTypeFromTypeSchemaFunction<CADIncidentStream> { }
-export default CADIncidentStreamModule as ReplaceModelReturnType<typeof CADIncidentStreamModule, CADIncidentStreamModel>;
+export interface CADIncidentStreamModel extends Model<CADIncidentStream> { }

package/src/models/cad-incident.ts

@@ -1,16 +1,15 @@
+import { Model } from "mongoose";
 import {
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 
 import { CADIncidentSchema } from "./schema/cad-incident";
+import { CADIncidentSchemaType } from "../types/cad-incident";
 
-export async function CADIncidentModule(mongoose: MongooseModule) {
+export interface CADIncident extends CADIncidentSchemaType, Record<string, unknown> { }
+
+export default async function CADIncidentModule(mongoose: MongooseModule) {
   const modelSchema = CADIncidentSchema(mongoose);
-  modelSchema.set("collection", "massive_incident_cad");
   modelSchema.set("strict", false); // Because we accept all kind of data in
 
   // Indexes
@@ -22,9 +21,8 @@ export async function CADIncidentModule(mongoose: MongooseModule) {
     unique: true,
   });
 
-  return createModel(mongoose, "CADIncident", modelSchema);
+  return mongoose.model<CADIncident>("CADIncident", modelSchema, "massive_incident_cad", { overwriteModels: true });
 }
 
-export interface CADIncident extends ItemTypeFromTypeSchemaFunction<typeof CADIncidentModule> { }
-export interface CADIncidentModel extends ModelTypeFromTypeSchemaFunction<CADIncident> { }
-export default CADIncidentModule as ReplaceModelReturnType<typeof CADIncidentModule, CADIncidentModel>;
+
+export interface CADIncidentModel extends Model<CADIncident> { }

package/src/models/cad-simulation.ts

@@ -1,21 +1,17 @@
+import { Model } from "mongoose";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 import * as uuid from "uuid";
+import { SimPriorCommentType, SimPriorIncidentType, SimRadioChannelType, SimCommentType, SimUnitType, SequenceType, CADSimulationType } from "../types/cad";
 
-export async function CADSimulationModule(mongoose: MongooseModule) {
-  const {
-    Schema,
-    Types,
-  } = mongoose;
+export interface CADSimulation extends CADSimulationType { }
 
-  const SimPriorComment = createSchema(Schema, {
+export default async function CADSimulationModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const SimPriorComment = new Schema<SimPriorCommentType>({
     Comment: {
       type: String,
       default: "",
@@ -33,7 +29,7 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const SimPriorIncident = createSchema(Schema, {
+  const SimPriorIncident = new Schema<SimPriorIncidentType>({
     IncidentNumber: {
       type: String,
       default: "",
@@ -63,7 +59,7 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const SimRadioChannel = createSchema(Schema, {
+  const SimRadioChannel = new Schema<SimRadioChannelType>({
     name: {
       type: String,
       default: "",
@@ -77,7 +73,7 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const SimComment = createSchema(Schema, {
+  const SimComment = new Schema<SimCommentType>({
     comment: {
       type: String,
       default: "",
@@ -91,7 +87,7 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const SimUnit = createSchema(Schema, {
+  const SimUnit = new Schema<SimUnitType>({
     alarmLevelAtDispatch: {
       type: String,
       default: "",
@@ -105,9 +101,9 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const Sequence = createSchema(Schema, {
-     _id: {
-      type: Types.ObjectId,
+  const Sequence = new Schema<SequenceType>({
+    _id: {
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     title: {
@@ -132,7 +128,7 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
     }
   }, {});
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<CADSimulationType>({
     // Internal
     uuid: {
       type: String,
@@ -155,7 +151,7 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
       default: currentDate,
     },
     active: {
-      type: Boolean, 
+      type: Boolean,
       default: true
     },
     friendlyId: {
@@ -171,7 +167,7 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
       default: "",
     },
     simulation: {
-      type: Boolean, 
+      type: Boolean,
       default: true,
     },
     notify: {
@@ -179,11 +175,11 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
       default: false,
     },
     rts: {
-      type: Boolean, 
+      type: Boolean,
       default: false
     },
     tags: {
-      type: [String], 
+      type: [String],
       default: []
     },
     incidentType: {
@@ -251,11 +247,11 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
       default: [],
     },
     randomPriorIncidents: {
-      type: Boolean, 
+      type: Boolean,
       default: false
     },
     randomStaffing: {
-      type: Boolean, 
+      type: Boolean,
       default: false
     },
     sequences: {
@@ -271,13 +267,10 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
       default: false,
     },
   }, {
-    collection: "massive_cad_simulation",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "CADSimulation", modelSchema);
+  return mongoose.model<CADSimulation>("CADSimulation", modelSchema, "massive_cad_simulation", { overwriteModels: true });
 }
 
-export interface CADSimulation extends ItemTypeFromTypeSchemaFunction<typeof CADSimulationModule> { }
-export interface CADSimulationModel extends ModelTypeFromTypeSchemaFunction<CADSimulation> { }
-export default CADSimulationModule as ReplaceModelReturnType<typeof CADSimulationModule, CADSimulationModel>;
+export interface CADSimulationModel extends Model<CADSimulation> { }

package/src/models/cad-status-map.ts

@@ -1,17 +1,16 @@
+import { Model } from "mongoose";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { CADStatusMapType, ToStatusIdType } from "../types/cad";
 
-export async function CADStatusMapModule(mongoose: MongooseModule) {
+export interface CADStatusMap extends CADStatusMapType { }
+
+export default async function CADStatusMapModule(mongoose: MongooseModule) {
   const Schema = mongoose.Schema;
 
-  const ToStatusIdSchema = createSchema(Schema, {
+  const ToStatusIdSchema = new Schema<ToStatusIdType>({
     statusId: {
       type: Number,
       default: 0,
@@ -31,7 +30,7 @@ export async function CADStatusMapModule(mongoose: MongooseModule) {
   });
 
   // Update static items (keep in sync with the lib/cad-status-map/updateDocument!)
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<CADStatusMap>({
     departmentId: {
       type: String,
       default: "",
@@ -61,13 +60,10 @@ export async function CADStatusMapModule(mongoose: MongooseModule) {
       type: Date,
     },
   }, {
-    collection: "massive_cad_status_map",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "CADStatusMap", modelSchema);
+  return mongoose.model<CADStatusMap>("CADStatusMap", modelSchema, "massive_cad_status_map", { overwriteModels: true });
 }
 
-export interface CADStatusMap extends ItemTypeFromTypeSchemaFunction<typeof CADStatusMapModule> { }
-export interface CADStatusMapModel extends ModelTypeFromTypeSchemaFunction<CADStatusMap> { }
-export default CADStatusMapModule as ReplaceModelReturnType<typeof CADStatusMapModule, CADStatusMapModel>;
+export interface CADStatusMapModel extends Model<CADStatusMap> { }

package/src/models/cad-status.ts

@@ -1,20 +1,19 @@
 import * as uuid from "uuid";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 import ColorModule from "./schema/color";
+import { Model } from "mongoose";
+import { StatusOptionValueType, StatusOptionType, CADStatusType } from "../types/cad";
 
-export async function CADStatusModule(mongoose: MongooseModule) {
+export interface CADStatus extends CADStatusType { }
+
+export default async function CADStatusModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
   const Color = ColorModule(mongoose);
 
-  const StatusOptionValue = createSchema(Schema, {
+  const StatusOptionValue = new Schema<StatusOptionValueType>({
     name: {
       type: String,
       default: "",
@@ -61,7 +60,7 @@ export async function CADStatusModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const StatusOption = createSchema(Schema, {
+  const StatusOption = new Schema<StatusOptionType>({
     name: {
       type: String,
       default: "",
@@ -87,7 +86,7 @@ export async function CADStatusModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<CADStatus>({
     uuid: {
       type: String,
       index: true,
@@ -158,13 +157,10 @@ export async function CADStatusModule(mongoose: MongooseModule) {
       type: Date,
     },
   }, {
-    collection: "massive_cad_status",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "CADStatus", modelSchema);
+  return mongoose.model<CADStatus>("CADStatus", modelSchema, "massive_cad_status", { overwriteModels: true });
 }
 
-export interface CADStatus extends ItemTypeFromTypeSchemaFunction<typeof CADStatusModule> { }
-export interface CADStatusModel extends ModelTypeFromTypeSchemaFunction<CADStatus> { }
-export default CADStatusModule as ReplaceModelReturnType<typeof CADStatusModule, CADStatusModel>;
+export interface CADStatusModel extends Model<CADStatus> { }

package/src/models/cad-vehicle-status-history.ts

@@ -1,20 +1,18 @@
+import { Model } from "mongoose";
 import {
-  createModel,
-  createSchema,
-  createSchemaDefinition,
   currentDate,
   MongooseModule,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
 import CADStatusOptionSelectedModule from "./schema/cad-status-option-selected";
+import { CADVehicleStatusHistoryType } from "../types/cad";
 
-export async function CADVehicleStatusHistoryModule(mongoose: MongooseModule) {
+export interface CADVehicleStatusHistory extends CADVehicleStatusHistoryType { }
+
+export default async function CADVehicleStatusHistoryModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
   const CADStatusOptionSelected = CADStatusOptionSelectedModule(mongoose);
 
-  const modelSchemaConfig = createSchemaDefinition({
+  const modelSchema = new Schema<CADVehicleStatusHistoryType>({
     departmentId: {
       type: String,
       default: "",
@@ -76,16 +74,11 @@ export async function CADVehicleStatusHistoryModule(mongoose: MongooseModule) {
       type: String,
       default: "",
     },
-  });
-
-  const modelSchema = createSchema(Schema, modelSchemaConfig, {
-    collection: "massive_cad_vehicle_status_history",
+  }, {
   });
 
   modelSchema.set("autoIndex", false);
-  return createModel(mongoose, "CADVehicleStatusHistory", modelSchema);
+  return mongoose.model<CADVehicleStatusHistory>("CADVehicleStatusHistory", modelSchema, "massive_cad_vehicle_status_history", { overwriteModels: true });
 }
 
-export interface CADVehicleStatusHistory extends ItemTypeFromTypeSchemaFunction<typeof CADVehicleStatusHistoryModule> { }
-export interface CADVehicleStatusHistoryModel extends ModelTypeFromTypeSchemaFunction<CADVehicleStatusHistory> { }
-export default CADVehicleStatusHistoryModule as ReplaceModelReturnType<typeof CADVehicleStatusHistoryModule, CADVehicleStatusHistoryModel>;
+export interface CADVehicleStatusHistoryModel extends Model<CADVehicleStatusHistory> { }