tabletcommand-backend-models 5.39.7 → 7.0.1

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

@@ -1,10 +1,5 @@
 import {
-  createSchema,
   currentDate,
-  DocumentTypeFromSchema,
-  FieldsOfDocument,
-  ModelFromSchema,
-  MongooseDocument,
   MongooseModule,
 } from "../../helpers";
 
@@ -19,34 +14,58 @@ import {
   SharedSourceSchema,
   SharedToSchema,
 } from "./shared-incident";
+import { CADCommentOptsTypes, CADCommentType, CADUnitType, APNNotificationTypeType, CADPriorIncidentType, CADIncidentSchemaType } from "../../types/cad-incident";
 
 export function CADIncidentSchema(mongoose: MongooseModule) {
-  const toJSONOpts = {
-    versionKey: false,
-    transform(doc: DocumentTypeFromSchema<typeof modelSchema>, ret: FieldsOfDocument<DocumentTypeFromSchema<typeof modelSchema>>) {
-      strictSchema(doc.schema, ret);
-    },
-  };
-
-  const { Schema, Types } = mongoose;
+  const { Schema } = mongoose;
   const IncidentEvent = IncidentEventSchema(mongoose);
 
   // Share incident properties - copy to managed incidents
   const CADPerson = CADPersonSchema(mongoose);
-  CADPerson.set("toJSON", toJSONOpts);
+  CADPerson.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
   const RadioChannel = RadioChannelSchema(mongoose);
-  RadioChannel.set("toJSON", toJSONOpts);
+  RadioChannel.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
   const RecordValue = RecordSchema(mongoose);
-  RecordValue.set("toJSON", toJSONOpts);
+  RecordValue.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
   const ReportNumber = ReportNumberSchema(mongoose);
-  ReportNumber.set("toJSON", toJSONOpts);
+  ReportNumber.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
   const SharedSource = SharedSourceSchema(mongoose);
-  SharedSource.set("toJSON", toJSONOpts);
+  SharedSource.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
   const SharedTo = SharedToSchema(mongoose);
-  SharedTo.set("toJSON", toJSONOpts);
+  SharedTo.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
 
   // Currently, supporting type: "ack", item: "knife"
-  const CADCommentOpts = createSchema(Schema, {
+  const CADCommentOpts = new Schema<CADCommentOptsTypes>({
     type: {
       type: String,
     },
@@ -57,9 +76,11 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
     _id: false,
     id: false,
   });
-  CADCommentOpts.set("toJSON", toJSONOpts);
+  CADCommentOpts.set("toJSON", {
+
+  });
 
-  const CADComment = createSchema(Schema, {
+  const CADComment = new Schema<CADCommentType>({
     Comment: {
       type: String,
     },
@@ -80,9 +101,14 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
     _id: false,
     id: false,
   });
-  CADComment.set("toJSON", toJSONOpts);
+  CADComment.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
 
-  const CADUnit = createSchema(Schema, {
+  const CADUnit = new Schema<CADUnitType>({
     UnitID: {
       type: String,
       required: true,
@@ -137,9 +163,14 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
     _id: false,
     id: false,
   });
-  CADUnit.set("toJSON", toJSONOpts);
+  CADUnit.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
 
-  const APNNotificationType = createSchema(Schema, {
+  const APNNotificationType = new Schema<APNNotificationTypeType>({
     name: {
       type: String,
     },
@@ -150,9 +181,14 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
     _id: false,
     id: false,
   });
-  APNNotificationType.set("toJSON", toJSONOpts);
+  APNNotificationType.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
 
-  const CADPriorIncident = createSchema(Schema, {
+  const CADPriorIncident = new Schema<CADPriorIncidentType>({
     Address: {
       type: String,
     },
@@ -178,12 +214,17 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
     _id: false,
     id: false,
   });
-  CADPriorIncident.set("toJSON", toJSONOpts);
+  CADPriorIncident.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
 
   // Main schema
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<CADIncidentSchemaType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     uuid: {
@@ -481,24 +522,21 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
     // collection: "massive_incident_cad",
     // strict: false, // Because we accept all kind of data in
   });
+  modelSchema.virtual("id").get(function(this: CADIncidentSchemaType) {
+    return this._id.toString();
+  });
 
   modelSchema.set("toJSON", {
     virtuals: true,
     versionKey: false,
-    transform(doc: ModelFromSchema<typeof modelSchema>, ret: DocumentTypeFromSchema<typeof modelSchema>) {
+    transform(doc, ret: Record<string, unknown>) {
       // Remove fields that should not be here
       delete (ret as unknown as { apikey: unknown }).apikey;
 
       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();
-  });
 
   const ignoreFields: ReadonlyArray<string> = ["station", "callerNumber"];
 

package/src/models/schema/cad-status-option-selected.ts

@@ -1,12 +1,12 @@
 import {
   MongooseModule,
-  createSchema,
 } from "../../helpers";
+import { CADStatusOptionSelectedSchemaType } from "../../types/cad";
 
 export default function CADStatusOptionSelectedSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const Item = createSchema(Schema, {
+  const Item = new Schema<CADStatusOptionSelectedSchemaType>({
     name: {
       type: String,
       default: "",

package/src/models/schema/color.ts

@@ -1,12 +1,12 @@
 import {
   MongooseModule,
-  createSchema,
 } from "../../helpers";
+import { ColorSchemaType } from "../../types/color";
 
 export default function ColorSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const Color = createSchema(Schema, {
+  const Color = new Schema<ColorSchemaType>({
     background: {
       type: String,
       default: "#851414", // Red-like

package/src/models/schema/esri-auth.ts

@@ -1,12 +1,12 @@
 import {
-  createSchema,
   MongooseModule,
 } from "../../helpers";
+import { EsriAuthPasswordType, EsriAuthSchemaType } from "../../types/esri";
 
 export default function EsriAuthSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const EsriAuthPassword = createSchema(Schema, {
+  const EsriAuthPassword = new Schema<EsriAuthPasswordType>({
     iv: {
       type: String,
       default: "",
@@ -20,7 +20,7 @@ export default function EsriAuthSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const EsriAuth = createSchema(Schema, {
+  const EsriAuth = new Schema<EsriAuthSchemaType>({
     username: {
       type: String,
       default: "",

package/src/models/schema/esri-error.ts

@@ -1,12 +1,12 @@
 import {
-  createSchema,
   MongooseModule,
 } from "../../helpers";
+import { EsriErrorSchemaType } from "../../types/esri";
 
 export default function EsriErrorSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const EsriError = createSchema(Schema, {
+  const EsriError = new Schema<EsriErrorSchemaType>({
     code: {
       type: Number,
       default: 1,

package/src/models/schema/esri-map.ts

@@ -1,12 +1,12 @@
 import {
-  createSchema,
   MongooseModule,
 } from "../../helpers";
+import { MapLayerType, BaseMapType, OfflineMapType, EsriMapType } from "../../types/esri";
 
 export default function EsriMapSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const MapLayer = createSchema(Schema, {
+  const MapLayer = new Schema<MapLayerType>({
     layerId: {
       type: String,
       default: "",
@@ -48,7 +48,7 @@ export default function EsriMapSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const BaseMap = createSchema(Schema, {
+  const BaseMap = new Schema<BaseMapType>({
     baseMapLayers: {
       type: [MapLayer],
       default: [],
@@ -97,7 +97,7 @@ export default function EsriMapSchema(mongoose: MongooseModule) {
     },
   };
 
-  const OfflineMap = createSchema(Schema, {
+  const OfflineMap = new Schema<OfflineMapType>({
     ...SimpleMapSchema,
     status: {
       type: String,
@@ -108,7 +108,7 @@ export default function EsriMapSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const Map = createSchema(Schema, {
+  const Map = new Schema<EsriMapType>({
     ...SimpleMapSchema,
     mapLayers: {
       type: [MapLayer],

package/src/models/schema/firemapper-auth.ts

@@ -1,12 +1,12 @@
 import {
-  createSchema,
   MongooseModule,
 } from "../../helpers";
+import { FireMapperEncryptedType, FireMapperAuthType } from "../../types/firemapper-auth";
 
 export default function FireMapperAuthSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const FireMapperEncrypted = createSchema(Schema, {
+  const FireMapperEncrypted = new Schema<FireMapperEncryptedType>({
     iv: {
       type: String,
       default: "",
@@ -20,7 +20,7 @@ export default function FireMapperAuthSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const FireMapperAuth = createSchema(Schema, {
+  const FireMapperAuth = new Schema<FireMapperAuthType>({
     username: {
       type: String,
       default: "",

package/src/models/schema/geojson-point.ts

@@ -1,12 +1,12 @@
 import {
-  createSchema,
   MongooseModule,
 } from "../../helpers";
+import { GeoJSONPointType } from "../../types/geojson-point";
 
 export default function GeoJSONPointSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const GeoJSONPoint = createSchema(Schema, {
+  const GeoJSONPoint = new Schema<GeoJSONPointType>({
     type: {
       type: String,
       required: true,

package/src/models/schema/oauth.ts

@@ -1,12 +1,12 @@
 import {
   MongooseModule,
-  createSchema,
 } from "../../helpers";
+import { OAuthSchemaType } from "../../types/oauth";
 
 export default function OAuthSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const Item = createSchema(Schema, {
+  const Item = new Schema<OAuthSchemaType>({
     accessToken: {
       type: String,
       default: "",
@@ -22,7 +22,7 @@ export default function OAuthSchema(mongoose: MongooseModule) {
   }, {
     _id: false,
     id: false,
-  });  
+  });
 
   return Item;
 }

package/src/models/schema/pubnub-token.ts

@@ -1,13 +1,13 @@
 import {
   MongooseModule,
-  createSchema,
   currentDate,
 } from "../../helpers";
+import { PubNubTokenSchemaType } from "../../types/pubnub-token";
 
 export default function PubNubTokenSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const Item = createSchema(Schema, {
+  const Item = new Schema<PubNubTokenSchemaType>({
     token: {
       type: String,
       default: "",
@@ -17,13 +17,13 @@ export default function PubNubTokenSchema(mongoose: MongooseModule) {
       default: currentDate,
     },
     runAt: {
-      type: Date,
+      type: Date || String,
       default: "",
     },
   }, {
     _id: false,
     id: false,
-  });  
+  });
 
   return Item;
 }

package/src/models/schema/remote-file.ts

@@ -1,13 +1,13 @@
 import {
   MongooseModule,
-  createSchema,
   currentDate,
 } from "../../helpers";
+import { RemoteFileSchemaType } from "../../types/remote-file";
 
 export default function RemoteFileSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const Item = createSchema(Schema, {
+  const Item = new Schema<RemoteFileSchemaType>({
     originalName: {
       type: String,
       default: "", // e.g database.sqlite

package/src/models/schema/shared-incident.ts

@@ -1,16 +1,25 @@
 import {
   MongooseModule,
-  createSchema,
   currentDate,
 } from "../../helpers";
+import {
+  CADPersonSchemaType,
+  RadioChannelSchemaType,
+  RecordSchemaType,
+  ReportNumberSchemaType,
+  ShareReasonSchemaType,
+  SharedToSchemaType,
+  SharedSourceSchemaType
+} from "../../types/shared-incident";
 
 // Properties shared between CAD and Managed Incident
 // They are copied on iOS
 
+
 export function CADPersonSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const Person = createSchema(Schema, {
+  const Person = new Schema<CADPersonSchemaType>({
     PersonnelID: {
       type: String,
     },
@@ -40,7 +49,7 @@ export function CADPersonSchema(mongoose: MongooseModule) {
 export function RadioChannelSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const RadioChannel = createSchema(Schema, {
+  const RadioChannel = new Schema<RadioChannelSchemaType>({
     name: {
       type: String,
       default: "",
@@ -71,7 +80,7 @@ export function RadioChannelSchema(mongoose: MongooseModule) {
 export function RecordSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const Record = createSchema(Schema, {
+  const Record = new Schema<RecordSchemaType>({
     name: {
       type: String,
       default: ""
@@ -94,7 +103,7 @@ export function RecordSchema(mongoose: MongooseModule) {
 export function ReportNumberSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const ReportNumber = createSchema(Schema, {
+  const ReportNumber = new Schema<ReportNumberSchemaType>({
     name: {
       type: String,
       default: "",
@@ -117,7 +126,7 @@ export function ReportNumberSchema(mongoose: MongooseModule) {
 export function ShareReasonSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const ShareReason = createSchema(Schema, {
+  const ShareReason = new Schema<ShareReasonSchemaType>({
     name: {
       type: String,
       default: "",
@@ -141,7 +150,7 @@ export function SharedToSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
   const ShareReason = ShareReasonSchema(mongoose);
 
-  const SharedTo = createSchema(Schema, {
+  const SharedTo = new Schema<SharedToSchemaType>({
     departmentId: {
       type: String,
       default: "",
@@ -182,7 +191,7 @@ export function SharedSourceSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
   const ShareReason = ShareReasonSchema(mongoose);
 
-  const SharedSource = createSchema(Schema, {
+  const SharedSource = new Schema<SharedSourceSchemaType>({
     // Department Name (always matches record .departmentId)
     name: {
       type: String,

package/src/models/schema/validation-error-item.ts

@@ -1,13 +1,13 @@
 import {
   MongooseModule,
-  createSchema,
   currentDate,
 } from "../../helpers";
+import { ValidationErrorItemSchemaType } from "../../types/validation";
 
 export default function ValidationErrorItemSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const Item = createSchema(Schema, {
+  const Item = new Schema<ValidationErrorItemSchemaType>({
     message: {
       type: String,
       default: "",

package/src/models/session.ts

@@ -1,27 +1,24 @@
 import {
-  createModel,
-  createSchema,
-  DocumentTypeFromSchema,
-  FieldsOfDocument,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 import * as uuid from "uuid";
 
 import OAuthSchema from "./schema/oauth";
+import { Model } from "mongoose";
+import { SessionType } from "../types/session";
 
-export async function SessionModule(mongoose: MongooseModule) {
+export interface Session extends SessionType { }
+
+export default async function SessionModule(mongoose: MongooseModule) {
   const Schema = mongoose.Schema;
   const OAuthToken = OAuthSchema(mongoose);
 
-  function requiredButAllowEmptyString(this: { myField: unknown }) {
+  function requiredButAllowEmptyString(this: Session) {
     // Workaround to set required, and allow empty id
-    return typeof this.myField === "string";
+    return typeof this.departmentId === "string";
   }
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<SessionType>({
     _id: {
       type: String,
       default: uuid.v4,
@@ -75,30 +72,24 @@ export async function SessionModule(mongoose: MongooseModule) {
       default: null,
     },
   }, {
-    collection: "sys_login",
   });
   modelSchema.set("autoIndex", false);
 
   modelSchema.pre("save", function(next) {
-    this._id = this.get("token") as string; // Copy _id from token
+    this._id = this.get("token"); // Copy _id from token
     next();
   });
+  modelSchema.virtual("id").get(function(this: Session) {
+    return this._id.toString();
+  });
 
   modelSchema.set("toJSON", {
     virtuals: true,
     versionKey: false,
-    transform(doc: DocumentTypeFromSchema<typeof modelSchema>, ret: FieldsOfDocument<DocumentTypeFromSchema<typeof modelSchema>>) {
-      ret.id = ret._id;
-    },
   });
 
-  modelSchema.virtual("id").get(function(this: DocumentTypeFromSchema<typeof modelSchema>) {
-    return this._id.toString();
-  });
 
-  return createModel(mongoose, "Session", modelSchema);
+  return mongoose.model<Session>("Session", modelSchema, "sys_login", { overwriteModels: true });
 }
 
-export interface Session extends ItemTypeFromTypeSchemaFunction<typeof SessionModule> { }
-export interface SessionModel extends ModelTypeFromTypeSchemaFunction<Session> { }
-export default SessionModule as ReplaceModelReturnType<typeof SessionModule, SessionModel>;
+export interface SessionModel extends Model<Session> { }

package/src/models/smtp-unhandled.ts

@@ -1,20 +1,19 @@
+import { Model } from "mongoose";
 import {
-  createModel,
-  createSchema,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseDocument,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import { SMTPUnhandledType } from "../types/smtp-unhandled";
 
-export async function SMTPUnhandledModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface SMTPUnhandled extends SMTPUnhandledType { }
 
-  const modelSchema = createSchema(Schema, {
+export default async function SMTPUnhandledModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const modelSchema = new Schema<SMTPUnhandledType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     email: {
@@ -28,7 +27,6 @@ export async function SMTPUnhandledModule(mongoose: MongooseModule) {
       required: true,
     },
   }, {
-    collection: "massive_smtp_unhandled",
   });
   modelSchema.set("toJSON", {
     virtuals: true,
@@ -42,9 +40,7 @@ export async function SMTPUnhandledModule(mongoose: MongooseModule) {
   modelSchema.plugin(mongooseLeanVirtuals);
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "SMTPUnhandled", modelSchema);
+  return mongoose.model<SMTPUnhandled>("SMTPUnhandled", modelSchema, "massive_smtp_unhandled", { overwriteModels: true });
 }
 
-export interface SMTPUnhandled extends ItemTypeFromTypeSchemaFunction<typeof SMTPUnhandledModule> { }
-export interface SMTPUnhandledModel extends ModelTypeFromTypeSchemaFunction<SMTPUnhandled> { }
-export default SMTPUnhandledModule as ReplaceModelReturnType<typeof SMTPUnhandledModule, SMTPUnhandledModel>;
+export interface SMTPUnhandledModel extends Model<SMTPUnhandled> { }