tabletcommand-backend-models 5.39.7 → 7.0.1

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

@@ -1,21 +1,24 @@
 import * as  uuid from "uuid";
 import {
-  createModel,
-  createSchema,
-  createSchemaDefinition,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 import CADStatusOptionSelectedModule from "./schema/cad-status-option-selected";
+import { Model } from "mongoose";
+import { CADVehicleStatusType } from "../types/cad";
 
-export async function CADVehicleStatusModule(mongoose: MongooseModule) {
+export interface CADVehicleStatus extends CADVehicleStatusType { }
+
+interface DestinationType {
+  address: string,
+  name: string,
+}
+
+export default async function CADVehicleStatusModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
   const CADStatusOptionSelected = CADStatusOptionSelectedModule(mongoose);
 
-  const Destination = createSchema(Schema, {
+  const Destination = new Schema<DestinationType>({
     // eg 1234 Main St
     address: {
       type: String,
@@ -31,7 +34,8 @@ export async function CADVehicleStatusModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchemaConfig = createSchemaDefinition({
+
+  const modelSchema = new Schema<CADVehicleStatusType>({
     uuid: {
       type: String,
       index: true,
@@ -134,16 +138,11 @@ export async function CADVehicleStatusModule(mongoose: MongooseModule) {
     backupDate: {
       type: Date,
     },
-  });
-
-  const modelSchema = createSchema(Schema, modelSchemaConfig, {
-    collection: "massive_cad_vehicle_status",
+  }, {
   });
 
   modelSchema.set("autoIndex", false);
-  return createModel(mongoose, "CADVehicleStatus", modelSchema);
+  return mongoose.model<CADVehicleStatus>("CADVehicleStatus", modelSchema, "massive_cad_vehicle_status", { overwriteModels: true });
 }
 
-export interface CADVehicleStatus extends ItemTypeFromTypeSchemaFunction<typeof CADVehicleStatusModule> { }
-export interface CADVehicleStatusModel extends ModelTypeFromTypeSchemaFunction<CADVehicleStatus> { }
-export default CADVehicleStatusModule as ReplaceModelReturnType<typeof CADVehicleStatusModule, CADVehicleStatusModel>;
+export interface CADVehicleStatusModel extends Model<CADVehicleStatus> { }

package/src/models/cad-vehicle.ts

@@ -1,18 +1,17 @@
+import { Model } from "mongoose";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 import * as uuid from "uuid";
+import { CADVehicleType, StationType } from "../types/cad";
 
-export async function CADVehicleModule(mongoose: MongooseModule) {
+export interface CADVehicle extends CADVehicleType { }
+
+export default async function CADVehicleModule(mongoose: MongooseModule) {
   const Schema = mongoose.Schema;
 
-  const Station = createSchema(Schema, {
+  const Station = new Schema<StationType>({
     code: {
       type: String,
       default: "",
@@ -26,7 +25,7 @@ export async function CADVehicleModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<CADVehicleType>({
     // Internal
     uuid: {
       type: String,
@@ -84,13 +83,10 @@ export async function CADVehicleModule(mongoose: MongooseModule) {
       type: Date,
     },
   }, {
-    collection: "massive_cad_vehicle",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "CADVehicle", modelSchema);
+  return mongoose.model<CADVehicle>("CADVehicle", modelSchema, "massive_cad_vehicle", { overwriteModels: true });
 }
 
-export interface CADVehicle extends ItemTypeFromTypeSchemaFunction<typeof CADVehicleModule> { }
-export interface CADVehicleModel extends ModelTypeFromTypeSchemaFunction<CADVehicle> { }
-export default CADVehicleModule as ReplaceModelReturnType<typeof CADVehicleModule, CADVehicleModel>;
+export interface CADVehicleModel extends Model<CADVehicle> { }

package/src/models/chart-device-stats.ts

@@ -1,20 +1,19 @@
 import {
   MongooseModule,
   MongooseDocument,
-  createSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { Model } from "mongoose";
 
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import { ChartDeviceStatsType, ChartItemType } from "../types/chart";
 const defaultDate = new Date("2023-04-19T00:00:00.000Z"); // Chart fallback date, after the feature was implemented
 
-export async function ChartDeviceStatsModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface ChartDeviceStats extends ChartDeviceStatsType { }
 
-  const ChartItem = createSchema(Schema, {
+export default async function ChartDeviceStatsModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const ChartItem = new Schema<ChartItemType>({
     // used to keep track of current user, 
     // email + os + app would be a good unique key
     email: {
@@ -52,9 +51,9 @@ export async function ChartDeviceStatsModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<ChartDeviceStatsType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     dateAt: {
@@ -72,7 +71,6 @@ export async function ChartDeviceStatsModule(mongoose: MongooseModule) {
       default: [],
     },
   }, {
-    collection: "massive_chart_device_stat",
   });
   modelSchema.set("autoIndex", false);
 
@@ -88,9 +86,7 @@ export async function ChartDeviceStatsModule(mongoose: MongooseModule) {
 
   modelSchema.plugin(mongooseLeanVirtuals);
 
-  return createModel(mongoose, "ChartDeviceStat", modelSchema);
+  return mongoose.model<ChartDeviceStats>("ChartDeviceStat", modelSchema, "massive_chart_device_stat", { overwriteModels: true });
 }
 
-export interface ChartDeviceStats extends ItemTypeFromTypeSchemaFunction<typeof ChartDeviceStatsModule> { }
-export interface ChartDeviceStatsModel extends ModelTypeFromTypeSchemaFunction<ChartDeviceStats> { }
-export default ChartDeviceStatsModule as ReplaceModelReturnType<typeof ChartDeviceStatsModule, ChartDeviceStatsModel>;
+export interface ChartDeviceStatsModel extends Model<ChartDeviceStats> { }

package/src/models/chart-incident.ts

@@ -1,20 +1,19 @@
+import { Model } from "mongoose";
 import {
   MongooseModule,
   MongooseDocument,
-  createSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
 
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import { ChartIncidentType, ChartItemType } from "../types/chart";
 const defaultDate = new Date("2013-01-01T00:26:40.000Z"); // Chart fallback date, before sync
 
-export async function ChartIncidentModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface ChartIncident extends ChartIncidentType { }
 
-  const ChartItem = createSchema(Schema, {
+export default async function ChartIncidentModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const ChartItem = new Schema<ChartItemType>({
     item: {
       type: String,
       default: "",
@@ -28,9 +27,9 @@ export async function ChartIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<ChartIncidentType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     dateAt: {
@@ -52,7 +51,6 @@ export async function ChartIncidentModule(mongoose: MongooseModule) {
       default: [],
     },
   }, {
-    collection: "massive_chart_incident",
   });
   modelSchema.set("autoIndex", false);
 
@@ -68,9 +66,7 @@ export async function ChartIncidentModule(mongoose: MongooseModule) {
 
   modelSchema.plugin(mongooseLeanVirtuals);
 
-  return createModel(mongoose, "ChartIncident", modelSchema);
+  return mongoose.model<ChartIncident>("ChartIncident", modelSchema, "massive_chart_incident", { overwriteModels: true });
 }
 
-export interface ChartIncident extends ItemTypeFromTypeSchemaFunction<typeof ChartIncidentModule> { }
-export interface ChartIncidentModel extends ModelTypeFromTypeSchemaFunction<ChartIncident> { }
-export default ChartIncidentModule as ReplaceModelReturnType<typeof ChartIncidentModule, ChartIncidentModel>;
+export interface ChartIncidentModel extends Model<ChartIncident> { }

package/src/models/chart-managed-incident.ts

@@ -1,21 +1,20 @@
+import { Model } from "mongoose";
 import {
   MongooseModule,
   MongooseDocument,
-  createSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
 
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import { ChartItemType, ChartManagedIncidentType } from "../types/chart";
+
+export interface ChartManagedIncident extends ChartManagedIncidentType { }
 
 const defaultDate = new Date("2013-01-01T00:26:40.000Z"); // Chart fallback date, before sync
 
-export async function ChartManagedIncidentModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export default async function ChartManagedIncidentModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  const ChartItem = createSchema(Schema, {
+  const ChartItem = new Schema<ChartItemType>({
     item: {
       type: String,
       default: "",
@@ -29,9 +28,9 @@ export async function ChartManagedIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<ChartManagedIncidentType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     dateAt: {
@@ -58,7 +57,6 @@ export async function ChartManagedIncidentModule(mongoose: MongooseModule) {
       default: [],
     },
   }, {
-    collection: "massive_chart_managed_incident",
   });
   modelSchema.set("autoIndex", false);
 
@@ -74,9 +72,7 @@ export async function ChartManagedIncidentModule(mongoose: MongooseModule) {
 
   modelSchema.plugin(mongooseLeanVirtuals);
 
-  return createModel(mongoose, "ChartManagedIncident", modelSchema);
+  return mongoose.model<ChartManagedIncident>("ChartManagedIncident", modelSchema, "massive_chart_managed_incident", { overwriteModels: true });
 }
 
-export interface ChartManagedIncident extends ItemTypeFromTypeSchemaFunction<typeof ChartManagedIncidentModule> { }
-export interface ChartManagedIncidentModel extends ModelTypeFromTypeSchemaFunction<ChartManagedIncident> { }
-export default ChartManagedIncidentModule as ReplaceModelReturnType<typeof ChartManagedIncidentModule, ChartManagedIncidentModel>;
+export interface ChartManagedIncidentModel extends Model<ChartManagedIncident> { }

package/src/models/chart-user.ts

@@ -1,22 +1,21 @@
+import { Model } from "mongoose";
 import {
   MongooseModule,
   MongooseDocument,
-  createSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
 
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import { ChartUserType } from "../types/chart";
 const defaultDate = new Date("2013-01-01T00:26:40.000Z"); // Chart fallback date, before sync
 
-export async function ChartUserModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface ChartUser extends ChartUserType { }
 
-  const modelSchema = createSchema(Schema, {
+export default async function ChartUserModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const modelSchema = new Schema<ChartUserType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     dateAt: {
@@ -38,7 +37,6 @@ export async function ChartUserModule(mongoose: MongooseModule) {
       default: [],
     },
   }, {
-    collection: "massive_chart_user",
   });
   modelSchema.set("autoIndex", false);
 
@@ -54,9 +52,7 @@ export async function ChartUserModule(mongoose: MongooseModule) {
 
   modelSchema.plugin(mongooseLeanVirtuals);
 
-  return createModel(mongoose, "ChartUser", modelSchema);
+  return mongoose.model<ChartUser>("ChartUser", modelSchema, "massive_chart_user", { overwriteModels: true });
 }
 
-export interface ChartUser extends ItemTypeFromTypeSchemaFunction<typeof ChartUserModule> { }
-export interface ChartUserModel extends ModelTypeFromTypeSchemaFunction<ChartUser> { }
-export default ChartUserModule as ReplaceModelReturnType<typeof ChartUserModule, ChartUserModel>;
+export interface ChartUserModel extends Model<ChartUser> { }

package/src/models/checklist-item.ts

@@ -3,25 +3,19 @@ import * as uuid from "uuid";
 import {
   MongooseModule,
   MongooseDocument,
-  createSchema,
-  DocumentTypeFromSchema,
-  ModelFromSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   retrieveCurrentUnixTime
 } from "../helpers";
+import { Model } from "mongoose";
+import { ChecklistItemType } from "../types/checklist";
+
+export interface ChecklistItem extends ChecklistItemType, Record<string, unknown> { }
 
 export function ChecklistItemSchema(mongoose: MongooseModule) {
-  const {
-    Schema,
-    Types,
-  } = mongoose;
+  const { Schema } = mongoose;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<ChecklistItemType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     position: {
@@ -68,31 +62,26 @@ export function ChecklistItemSchema(mongoose: MongooseModule) {
       default: ""
     }
   }, {
-    collection: "massive_checklist_item_sync",
   });
   modelSchema.set("autoIndex", false);
   return modelSchema;
 }
 
-export async function ChecklistItemModule(mongoose: MongooseModule) {
+export default async function ChecklistItemModule(mongoose: MongooseModule) {
   const modelSchema = ChecklistItemSchema(mongoose);
 
+  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>) {
-      ret.id = ret._id;
-    },
   });
 
-  modelSchema.virtual("id").get(function (this: MongooseDocument) {
-    // tslint:disable-next-line: no-unsafe-any
-    return this._id.toString();
-  });
 
-  return createModel(mongoose, "ChecklistItem", modelSchema);
+  return mongoose.model<ChecklistItem>("ChecklistItem", modelSchema, "massive_checklist_item_sync", { overwriteModels: true });
 }
 
-export interface ChecklistItem extends ItemTypeFromTypeSchemaFunction<typeof ChecklistItemModule> { }
-export interface ChecklistItemModel extends ModelTypeFromTypeSchemaFunction<ChecklistItem> { }
-export default ChecklistItemModule as ReplaceModelReturnType<typeof ChecklistItemModule, ChecklistItemModel>;
+export interface ChecklistItemModel extends Model<ChecklistItem> { }

package/src/models/checklist.ts

@@ -3,27 +3,24 @@ import * as uuid from "uuid";
 import {
   MongooseModule,
   MongooseDocument,
-  createSchema,
   currentDate,
-  DocumentTypeFromSchema,
-  ModelFromSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   retrieveCurrentUnixTime
 } from "../helpers";
 
 import { ChecklistItemSchema } from "./checklist-item";
+import { Model } from "mongoose";
+import { ChecklistType } from "../types/checklist";
+
+export interface Checklist extends ChecklistType, Record<string, unknown> { }
 
 export function ChecklistSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+  const { Schema } = mongoose;
 
   const ChecklistItem = ChecklistItemSchema(mongoose);
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<ChecklistType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     position: {
@@ -67,7 +64,7 @@ export function ChecklistSchema(mongoose: MongooseModule) {
       required: true
     },
     agencyId: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       ref: "Agency",
       default: null,
     },
@@ -76,30 +73,25 @@ export function ChecklistSchema(mongoose: MongooseModule) {
       default: [],
     }
   }, {
-    collection: "massive_checklist_sync",
   });
   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>) {
-      ret.id = ret._id;
-    },
   });
 
-  modelSchema.virtual("id").get(function (this: MongooseDocument) {
-    // tslint:disable-next-line: no-unsafe-any
-    return this._id.toString();
-  });
 
   return modelSchema;
 }
 
-export async function ChecklistModule(mongoose: MongooseModule) {
+export default async function ChecklistModule(mongoose: MongooseModule) {
   const modelSchema = ChecklistSchema(mongoose);
-  return createModel(mongoose, "Checklist", modelSchema);
+  return mongoose.model<Checklist>("Checklist", modelSchema, "massive_checklist_sync", { overwriteModels: true });
 }
 
-export interface Checklist extends ItemTypeFromTypeSchemaFunction<typeof ChecklistModule> { }
-export interface ChecklistModel extends ModelTypeFromTypeSchemaFunction<Checklist> { }
-export default ChecklistModule as ReplaceModelReturnType<typeof ChecklistModule, ChecklistModel>;
+export interface ChecklistModel extends Model<Checklist> { }

package/src/models/csv-import.ts

@@ -1,19 +1,18 @@
+import { Model } from "mongoose";
 import {
-  createSchema,
-  createModel,
   currentDate,
   MongooseModule,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { CSVImportType } from "../types/csv-import";
 
-export async function CSVImportModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface CSVImport extends CSVImportType { }
 
-  const modelSchema = createSchema(Schema, {
+export default async function CSVImportModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const modelSchema = new Schema<CSVImportType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     batchId: {
@@ -69,13 +68,10 @@ export async function CSVImportModule(mongoose: MongooseModule) {
       default: false
     },
   }, {
-    collection: "massive_csv_import",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "CSVImport", modelSchema);
+  return mongoose.model<CSVImport>("CSVImport", modelSchema, "massive_csv_import", { overwriteModels: true });
 }
 
-export interface CSVImport extends ItemTypeFromTypeSchemaFunction<typeof CSVImportModule> { }
-export interface CSVImportModel extends ModelTypeFromTypeSchemaFunction<CSVImport> { }
-export default CSVImportModule as ReplaceModelReturnType<typeof CSVImportModule, CSVImportModel>;
+export interface CSVImportModel extends Model<CSVImport> { }