@internetderdinge/api 1.229.0 → 1.229.1

package/src/accounts/auth0.service.ts

@@ -1,7 +1,8 @@
-import { AuthenticationClient, ManagementClient } from 'auth0';
-import type { ManagementClientOptions, User } from 'auth0';
-import { promises as fs, readFileSync } from 'fs';
-import { config } from 'process';
+// @ts-nocheck
+import { AuthenticationClient, ManagementClient } from "auth0";
+import type { ManagementClientOptions, User } from "auth0";
+import { promises as fs, readFileSync } from "fs";
+import { config } from "process";
 
 interface TokenManagementClient {
   clientId?: string;
@@ -21,12 +22,12 @@ let tokenManagementClient: TokenManagementClient = {
 
 //if (config.env !== 'production') {
 try {
-  console.warn('Auth0 client: use local token from cache try');
-  const token = readFileSync('./token.txt', 'utf8');
-  console.warn('Auth0 client: use local token from cache');
+  console.warn("Auth0 client: use local token from cache try");
+  const token = readFileSync("./token.txt", "utf8");
+  console.warn("Auth0 client: use local token from cache");
   tokenManagementClient = { token };
 } catch (error) {
-  console.log('Auth0 Client: use new token');
+  console.log("Auth0 Client: use new token");
 }
 //}
 
@@ -56,14 +57,16 @@ let cachedManagementToken: string | null = null;
 let managementTokenExpiresAt: number | null = null;
 let pendingManagementTokenPromise: Promise<string> | null = null;
 
-const TOKEN_FILE_PATH = './token.txt';
-const MANAGEMENT_TOKEN_FILE_PATH = './token.management.txt';
+const TOKEN_FILE_PATH = "./token.txt";
+const MANAGEMENT_TOKEN_FILE_PATH = "./token.management.txt";
 const TOKEN_BUFFER_SECONDS = 60; // refresh a minute before expiry
 const TOKEN_FALLBACK_TTL_SECONDS = 3300; // ~55 minutes when no expiry metadata exists
 
-const loadTokenFromFile = async (filePath: string): Promise<CachedToken | null> => {
+const loadTokenFromFile = async (
+  filePath: string,
+): Promise<CachedToken | null> => {
   try {
-    const raw = await fs.readFile(filePath, 'utf8');
+    const raw = await fs.readFile(filePath, "utf8");
     try {
       const parsed = JSON.parse(raw);
       if (parsed?.token && parsed?.expiresAt) {
@@ -80,22 +83,34 @@ const loadTokenFromFile = async (filePath: string): Promise<CachedToken | null>
   return null;
 };
 
-const writeTokenFile = async (filePath: string, token: string, expiresAt: number): Promise<void> => {
+const writeTokenFile = async (
+  filePath: string,
+  token: string,
+  expiresAt: number,
+): Promise<void> => {
   const payload = JSON.stringify({ token, expiresAt });
-  await fs.writeFile(filePath, payload, 'utf8');
+  await fs.writeFile(filePath, payload, "utf8");
 };
 
-const tokenIsValid = (token: string | null, expiresAt: number | null, now: number): boolean => {
+const tokenIsValid = (
+  token: string | null,
+  expiresAt: number | null,
+  now: number,
+): boolean => {
   if (!token || !expiresAt) return false;
   return now < expiresAt - TOKEN_BUFFER_SECONDS;
 };
 
 export const getAuth0Token = async (): Promise<string> => {
-  const audience = process.env.AUTH0_AUDIENCE || process.env.AUTH0_MANAGEMENT_AUDIENCE || 'localhost:3000/';
+  const audience =
+    process.env.AUTH0_AUDIENCE ||
+    process.env.AUTH0_MANAGEMENT_AUDIENCE ||
+    "localhost:3000/";
   const grantOpts = { audience };
 
   const now = Math.floor(Date.now() / 1000);
-  if (tokenIsValid(cachedToken, tokenExpiresAt, now)) return cachedToken as string;
+  if (tokenIsValid(cachedToken, tokenExpiresAt, now))
+    return cachedToken as string;
   if (pendingTokenPromise) return pendingTokenPromise;
 
   pendingTokenPromise = (async () => {
@@ -110,7 +125,8 @@ export const getAuth0Token = async (): Promise<string> => {
     }
     //}
 
-    const tokenResponse = await auth0AuthClient.oauth.clientCredentialsGrant(grantOpts);
+    const tokenResponse =
+      await auth0AuthClient.oauth.clientCredentialsGrant(grantOpts);
     const expiresIn = tokenResponse.data.expires_in || 3600;
     cachedToken = tokenResponse.data.access_token;
     tokenExpiresAt = now + expiresIn;
@@ -129,13 +145,16 @@ export const getAuth0Token = async (): Promise<string> => {
 export const getAuth0ManagementToken = async (): Promise<string> => {
   const audience = process.env.AUTH0_MANAGEMENT_AUDIENCE;
   if (!audience) {
-    throw new Error('Missing AUTH0_MANAGEMENT_AUDIENCE; cannot mint Management API token');
+    throw new Error(
+      "Missing AUTH0_MANAGEMENT_AUDIENCE; cannot mint Management API token",
+    );
   }
 
   const grantOpts = { audience };
   const now = Math.floor(Date.now() / 1000);
 
-  if (tokenIsValid(cachedManagementToken, managementTokenExpiresAt, now)) return cachedManagementToken as string;
+  if (tokenIsValid(cachedManagementToken, managementTokenExpiresAt, now))
+    return cachedManagementToken as string;
   if (pendingManagementTokenPromise) return pendingManagementTokenPromise;
 
   pendingManagementTokenPromise = (async () => {
@@ -147,12 +166,17 @@ export const getAuth0ManagementToken = async (): Promise<string> => {
       return cachedManagementToken;
     }
 
-    const tokenResponse = await auth0AuthClient.oauth.clientCredentialsGrant(grantOpts);
+    const tokenResponse =
+      await auth0AuthClient.oauth.clientCredentialsGrant(grantOpts);
     const expiresIn = tokenResponse.data.expires_in || 3600;
     cachedManagementToken = tokenResponse.data.access_token;
     managementTokenExpiresAt = now + expiresIn;
 
-    await writeTokenFile(MANAGEMENT_TOKEN_FILE_PATH, cachedManagementToken, managementTokenExpiresAt);
+    await writeTokenFile(
+      MANAGEMENT_TOKEN_FILE_PATH,
+      cachedManagementToken,
+      managementTokenExpiresAt,
+    );
 
     pendingManagementTokenPromise = null;
     return cachedManagementToken;
@@ -172,8 +196,8 @@ export const getUserIdByEmail = async (email: string): Promise<User[]> => {
   return auth0.usersByEmail.getByEmail({ email });
 };
 
-export const sendVerificationEmail = async (userID: string): Promise<void> => {
-  await auth0.jobs.verifyEmail({ user_id: userID });
+export const sendVerificationEmail = async (userID: string): Promise<any> => {
+  return auth0.jobs.verifyEmail({ user_id: userID });
 };
 
 export const getUserById = async (userId: string): Promise<User> => {
@@ -184,7 +208,10 @@ export const avatar = async (userId: string): Promise<User> => {
   return auth0.users.get({ id: userId });
 };
 
-export const mfaEnrollAccount = async (userId: string, mfaToken: string): Promise<any> => {
+export const mfaEnrollAccount = async (
+  userId: string,
+  mfaToken: string,
+): Promise<any> => {
   const ticketResponse = await auth0.guardian.createEnrollmentTicket({
     user_id: userId,
     send_mail: false,
@@ -199,13 +226,13 @@ export const mfaDisableAccount = async (userId: string): Promise<any> => {
 };
 
 export const getUsersByIds = async (postIDs: string[]): Promise<User[]> => {
-  let q = '';
+  let q = "";
   postIDs.forEach((e, i) => {
-    if (e) q = `${q} ${i >= 2 ? ' OR ' : ''} user_id:"${e}"`;
+    if (e) q = `${q} ${i >= 2 ? " OR " : ""} user_id:"${e}"`;
   });
 
   const params = {
-    search_engine: 'v3',
+    search_engine: "v3",
     q,
     per_page: 100,
     page: 0,

package/src/config/config.ts

@@ -3,6 +3,12 @@ import dotenv from "dotenv";
 // Load env from the current working directory
 dotenv.config();
 
+console.log("Current working directory:", process.cwd());
+console.log("Loaded environment variables:", {
+  NODE_ENV: process.env.NODE_ENV,
+  PORT: process.env.PORT,
+  MONGODB_URL: process.env.MONGODB_URL,
+});
 import Joi from "joi";
 
 const envVarsSchema = Joi.object()

package/src/config/logger.ts

@@ -1,6 +1,7 @@
-import winston from 'winston';
-import type { Format } from 'logform';
-import config from './config';
+// @ts-nocheck
+import winston from "winston";
+import type { Format } from "logform";
+import config from "./config";
 
 const enumerateErrorFormat: Format = winston.format((info) => {
   if (info instanceof Error) {
@@ -10,22 +11,27 @@ const enumerateErrorFormat: Format = winston.format((info) => {
 });
 
 const logger = winston.createLogger({
-  level: config.env === 'development' ? 'debug' : 'info',
+  level: config.env === "development" ? "debug" : "info",
   format: winston.format.combine(
     enumerateErrorFormat(),
-    config.env === 'development' ? winston.format.colorize() : winston.format.uncolorize(),
+    config.env === "development"
+      ? winston.format.colorize()
+      : winston.format.uncolorize(),
     winston.format.splat(),
     winston.format.printf((info) => {
-      const { level, message, stack, ...rest } = info as Record<string, unknown>;
+      const { level, message, stack, ...rest } = info as Record<
+        string,
+        unknown
+      >;
       const restKeys = Object.keys(rest);
-      const restText = restKeys.length ? ` ${JSON.stringify(rest)}` : '';
-      const stackText = stack ? `\n${stack}` : '';
+      const restText = restKeys.length ? ` ${JSON.stringify(rest)}` : "";
+      const stackText = stack ? `\n${stack}` : "";
       return `${level}: ${message}${stackText}${restText}`;
     }),
   ),
   transports: [
     new winston.transports.Console({
-      stderrLevels: ['error'],
+      stderrLevels: ["error"],
     }),
   ],
 });

package/src/devices/devices.controller.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import httpStatus from "http-status";
 import mongoose from "mongoose";
 import multer from "multer";
@@ -247,9 +248,14 @@ const uploadSingleImage = catchAsync(
   async (req: Request, res: Response): Promise<void> => {
     const device = await devicesService.getById(req.params.deviceId);
 
+    const files = req.files as Array<{ buffer: Buffer }> | undefined;
+    if (!files || files.length === 0) {
+      throw new ApiError(httpStatus.BAD_REQUEST, "No image file uploaded");
+    }
+
     const iotUpload = await iotDevicesService.uploadSingleImage({
       deviceName: device.deviceId,
-      buffer: req.files[0].buffer,
+      buffer: files[0].buffer,
       deviceId: req.params.deviceId,
       uuid: req.body.uuid,
     });

package/src/devices/devices.model.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import mongoose, { Schema, Document, Model, Types } from "mongoose";
 import { toJSON, paginate } from "../models/plugins/index.js";
 import { ensureSameOrganization } from "../middlewares/mongooseValidations/ensureSameOrganization.js";
@@ -121,6 +122,8 @@ addIotDevice(deviceSchema);
 deviceSchema.plugin((schema: Schema) => toJSON(schema, true));
 deviceSchema.plugin(paginate);
 
-const Devices: Model<IDevice> = mongoose.model<IDevice>("Device", deviceSchema);
+const Devices: Model<IDevice> =
+  (mongoose.models.Device as Model<IDevice>) ||
+  mongoose.model<IDevice>("Device", deviceSchema);
 
 export default Devices;

package/src/devices/devices.schemas.ts

@@ -22,9 +22,9 @@ export const eventResponseSchema = z.object({
   // ...other event fields...
 });
 
-export const genericResponseSchema = z.object({
-  message: z.string(),
-});
+export const genericResponseSchema = z
+  .record(z.any())
+  .openapi({ description: "Generic response payload" });
 
 export const imageResponseSchema = z.object({
   uuid: z.string(),
@@ -64,11 +64,13 @@ export const subscriptionResponseSchema = z.object({
   // ...other subscription fields...
 });
 
-export const uploadResponseSchema = z.object({
-  filenames: z.array(z.string()),
-  urls: z.array(z.string().url()),
-  // ...other upload result fields...
-});
+export const uploadResponseSchema = z
+  .object({
+    key: z.string().optional(),
+    similarityPercentage: z.number().nullable().optional(),
+    skippedUpload: z.boolean().optional(),
+  })
+  .openapi({ description: "Upload response payload" });
 
 export const pingDeviceSchema = {
   params: z.object({

package/src/devices/devices.service.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import httpStatus from "http-status";
 import Device from "./devices.model.js";
 import ApiError from "../utils/ApiError.js";

package/src/devices/devices.types.ts

@@ -0,0 +1 @@
+export type Device = any;

package/src/devices/devices.validation.ts

@@ -4,6 +4,7 @@ import { objectId } from "../validations/custom.validation.js";
 import {
   zGet,
   zObjectId,
+  zObjectIdFor,
   zPatchBody,
   zUpdate,
   zDelete,
@@ -66,6 +67,11 @@ export const updateEntrySchema = {
 };
 
 export const getEventsSchema = {
+  params: z.object({
+    deviceId: zObjectIdFor("deviceId").openapi({
+      description: "Device ObjectId",
+    }),
+  }),
   query: z
     .object({
       DateStart: z.string(),
@@ -92,14 +98,29 @@ export const createCustomerPortalSessionSchema = {
 export const createDeviceSchema = {
   body: z.object({
     kind: z.string().optional(),
-    patient: zObjectId.optional().nullable(),
-    paper: zObjectId.optional().nullable(),
-    organization: zObjectId.openapi({ description: "Organization ObjectId" }),
+    patient: zObjectIdFor("patient")
+      .optional()
+      .nullable()
+      .openapi({ description: "Patient ObjectId", example: null }),
+    paper: zObjectIdFor("paper")
+      .optional()
+      .nullable()
+      .openapi({ description: "Paper ObjectId", example: null }),
+    organization: zObjectIdFor("organization").openapi({
+      description: "Organization ObjectId",
+    }),
   }),
 };
 export const deleteDeviceSchema = zDelete("deviceId");
 export const getDeviceSchema = zGet("deviceId");
-export const getImageSchema = zGet("deviceId");
+export const getImageSchema = {
+  params: z.object({
+    deviceId: zObjectIdFor("deviceId").openapi({
+      description: "Device ObjectId",
+    }),
+    uuid: z.string().openapi({ description: "Image UUID" }),
+  }),
+};
 export const ledLightSchema = {
   params: z.object({
     deviceId: zObjectId.openapi({ description: "Device ObjectId" }),
@@ -149,7 +170,9 @@ export const ledLightSchema = {
 };
 export const pingDeviceSchema = {
   params: z.object({
-    deviceId: zObjectId.openapi({ description: "Device ObjectId" }),
+    deviceId: zObjectIdFor("deviceId").openapi({
+      description: "Device ObjectId",
+    }),
   }),
   query: z.object({
     dataResponse: z
@@ -160,34 +183,49 @@ export const pingDeviceSchema = {
 
 export const resetDeviceSchema = {
   params: z.object({
-    deviceId: zObjectId.openapi({ description: "Device ObjectId" }),
+    deviceId: zObjectIdFor("deviceId").openapi({
+      description: "Device ObjectId",
+    }),
   }),
 };
 
 export const rebootDeviceSchema = zGet("deviceId");
 
 export const registerDeviceSchema = {
-  ...zPagination,
-  body: z.object({
-    enable: z.boolean(),
-    organization: zObjectId,
-    patient: zObjectId.optional().nullable(),
-    paper: zObjectId.optional().nullable(),
-  }),
+  body: z
+    .object({
+      enable: z.boolean(),
+      organization: zObjectIdFor("organization"),
+      patient: zObjectId.optional().nullable(),
+      paper: zObjectId.optional().nullable(),
+    })
+    .openapi({
+      example: {
+        enable: true,
+        organization:
+          process.env.SCHEMA_EXAMPLE_ORGANIZATION_ID || "682fd0d7d4a6325d9d45b86d",
+        patient: process.env.SCHEMA_EXAMPLE_USER_ID || "682fd0d7d4a6325d9d45b86d",
+        paper: process.env.SCHEMA_EXAMPLE_PAPER_ID || null,
+      },
+    }),
   params: z.object({
-    deviceId: z.string(),
-  }),
-  query: zPagination.query.extend({
-    patient: zObjectId.optional(),
-    organization: zObjectId.optional(),
+    deviceId: (
+      process.env.SCHEMA_STRICT_EXAMPLES === "true" &&
+      process.env.SCHEMA_EXAMPLE_DEVICE_SERIAL
+        ? z.literal(process.env.SCHEMA_EXAMPLE_DEVICE_SERIAL)
+        : z.string()
+    ).openapi({
+      description: "Device serial",
+      example: process.env.SCHEMA_EXAMPLE_DEVICE_SERIAL || "DEVICE-EXAMPLE",
+    }),
   }),
 };
 
 export const queryDevicesSchema = {
   ...zPagination,
   query: zPagination.query.extend({
-    patient: zObjectId.optional(),
-    organization: zObjectId.optional(),
+    patient: zObjectIdFor("patient").optional(),
+    organization: zObjectIdFor("organization"),
   }),
 };
 export const subscriptionSchema = {
@@ -213,9 +251,33 @@ export const updateDeviceSchema = {
   }),
 };
 
-export const updateSingleImageMetaSchema = {};
+export const updateSingleImageMetaSchema = {
+  params: z.object({
+    deviceId: zObjectIdFor("deviceId").openapi({
+      description: "Device ObjectId",
+    }),
+  }),
+  body: z
+    .object({
+      meta: z.record(z.any()).optional(),
+    })
+    .openapi({ description: "Image metadata updates" }),
+};
 export const uploadSingleImageSchema = {
-  body: z.object({
-    file: z.instanceof(File).openapi({ description: "File to upload" }),
+  params: z.object({
+    deviceId: zObjectIdFor("deviceId").openapi({
+      description: "Device ObjectId",
+    }),
   }),
+  body: z
+    .object({
+      uuid: z
+        .string()
+        .optional()
+        .openapi({ description: "Optional image UUID", example: "mock-uuid" }),
+    })
+    .openapi({
+      description: "Multipart body is mocked during tests.",
+      example: { uuid: "mock-uuid" },
+    }),
 };

package/src/devicesNotifications/devicesNotifications.controller.ts

@@ -1,56 +1,85 @@
-import httpStatus from 'http-status';
+// @ts-nocheck
+import httpStatus from "http-status";
 
-import pick from '../../src/utils/pick';
-import ApiError from '../../src/utils/ApiError';
-import catchAsync from '../../src/utils/catchAsync';
-import devicesNotificationsService from './devicesNotifications.service';
+import pick from "../../src/utils/pick";
+import ApiError from "../../src/utils/ApiError";
+import catchAsync from "../../src/utils/catchAsync";
+import devicesNotificationsService from "./devicesNotifications.service";
 
-import type { Request, Response } from 'express';
+import type { Request, Response } from "express";
 
 export const createEntry = catchAsync(async (req: Request, res: Response) => {
-  const user = await devicesNotificationsService.createNotification({ user: res.req.auth.sub, token: req.body.token });
+  const user = await devicesNotificationsService.createNotification({
+    user: res.req.auth.sub,
+    token: req.body.token,
+  });
   res.status(httpStatus.CREATED).send(user);
 });
 
-export const setDeviceToken = catchAsync(async (req: Request, res: Response) => {
-  const user = await devicesNotificationsService.setDeviceToken({ user: res.req.auth.sub, body: req.body });
-  res.status(httpStatus.CREATED).send(user);
-});
+export const setDeviceToken = catchAsync(
+  async (req: Request, res: Response) => {
+    const user = await devicesNotificationsService.setDeviceToken({
+      user: res.req.auth.sub,
+      body: req.body,
+    });
+    res.status(httpStatus.CREATED).send(user);
+  },
+);
 
-export const removeDeviceToken = catchAsync(async (req: Request, res: Response) => {
-  const user = await devicesNotificationsService.removeDeviceToken({ user: res.req.auth.sub, body: req.body });
-  res.status(httpStatus.CREATED).send(user);
-});
+export const removeDeviceToken = catchAsync(
+  async (req: Request, res: Response) => {
+    const user = await devicesNotificationsService.removeDeviceToken({
+      user: res.req.auth.sub,
+      body: req.body,
+    });
+    res.status(httpStatus.CREATED).send(user);
+  },
+);
 
 export const getEntries = catchAsync(async (req: Request, res: Response) => {
-  const filter = pick(req.query, ['name', 'role']);
-  const options = pick(req.query, ['sortBy', 'limit', 'page']);
-  const result = await devicesNotificationsService.queryNotifications(filter, options);
+  const filter = pick(req.query, ["name", "role"]);
+  const options = pick(req.query, ["sortBy", "limit", "page"]);
+  const result = await devicesNotificationsService.queryNotifications(
+    filter,
+    options,
+  );
   res.send(result);
 });
 
-export const queryNotificationsByUser = catchAsync(async (req: Request, res: Response) => {
-  const filter = pick({ user: res.req.auth.sub }, ['user']);
-  const options = pick(req.query, ['sortBy', 'limit', 'page']);
-  const result = await devicesNotificationsService.queryNotificationsByUser(filter, options);
-  res.send(result);
-});
+export const queryNotificationsByUser = catchAsync(
+  async (req: Request, res: Response) => {
+    const filter = pick({ user: res.req.auth.sub }, ["user"]);
+    const options = pick(req.query, ["sortBy", "limit", "page"]);
+    const result = await devicesNotificationsService.queryNotificationsByUser(
+      filter,
+      options,
+    );
+    res.send(result);
+  },
+);
 
 export const getEntry = catchAsync(async (req: Request, res: Response) => {
-  const notification = await devicesNotificationsService.getById(req.params.notificationId);
+  const notification = await devicesNotificationsService.getById(
+    req.params.notificationId,
+  );
   if (!notification) {
-    throw new ApiError(httpStatus.NOT_FOUND, 'Notification not found');
+    throw new ApiError(httpStatus.NOT_FOUND, "Notification not found");
   }
   res.send(notification);
 });
 
 export const updateEntry = catchAsync(async (req: Request, res: Response) => {
-  const user = await devicesNotificationsService.updateById(req.params.notificationId, req.body);
+  const user = await devicesNotificationsService.updateById(
+    req.params.notificationId,
+    req.body,
+  );
   res.send(user);
 });
 
 export const deleteEntry = catchAsync(async (req: Request, res: Response) => {
-  const entry = await devicesNotificationsService.deleteById(req.params.notificationId);
+  const entry = await devicesNotificationsService.deleteById(
+    req.params.notificationId,
+  );
   res.send(entry);
 });
 

package/src/devicesNotifications/devicesNotifications.model.ts

@@ -1,6 +1,7 @@
-import mongoose, { Schema, Document, Model } from 'mongoose';
-import type { PaginateModel } from 'mongoose';
-import { toJSON, paginate } from '../../src/models/plugins/index';
+// @ts-nocheck
+import mongoose, { Schema, Document, Model } from "mongoose";
+import type { PaginateModel } from "mongoose";
+import { toJSON, paginate } from "../../src/models/plugins/index";
 
 interface Token {
   token: string;
@@ -11,7 +12,7 @@ interface Token {
 
 interface Settings {
   intake: { email: boolean; push: boolean };
-  'intake-reminder': { email: boolean; push: boolean };
+  "intake-reminder": { email: boolean; push: boolean };
   battery: { email: boolean; push: boolean };
 }
 
@@ -24,7 +25,8 @@ export interface DeviceNotificationDocument extends Document {
   updatedAt: Date;
 }
 
-export type DeviceNotificationModel = Model<DeviceNotificationDocument> & PaginateModel<DeviceNotificationDocument>;
+export type DeviceNotificationModel = Model<DeviceNotificationDocument> &
+  PaginateModel<DeviceNotificationDocument>;
 
 const deviceNotificationSchema = new Schema<DeviceNotificationDocument>(
   {
@@ -42,12 +44,18 @@ const deviceNotificationSchema = new Schema<DeviceNotificationDocument>(
     ],
     bounceEmail: { type: String },
     settings: {
-      intake: { email: { type: Boolean, default: true }, push: { type: Boolean, default: true } },
-      'intake-reminder': {
+      intake: {
+        email: { type: Boolean, default: true },
+        push: { type: Boolean, default: true },
+      },
+      "intake-reminder": {
+        email: { type: Boolean, default: true },
+        push: { type: Boolean, default: true },
+      },
+      battery: {
         email: { type: Boolean, default: true },
         push: { type: Boolean, default: true },
       },
-      battery: { email: { type: Boolean, default: true }, push: { type: Boolean, default: true } },
     },
   },
   {
@@ -59,9 +67,9 @@ const deviceNotificationSchema = new Schema<DeviceNotificationDocument>(
 deviceNotificationSchema.plugin(toJSON);
 deviceNotificationSchema.plugin(paginate);
 
-const DeviceNotifications = mongoose.model<DeviceNotificationDocument, DeviceNotificationModel>(
-  'DeviceNotification',
-  deviceNotificationSchema,
-);
+const DeviceNotifications = mongoose.model<
+  DeviceNotificationDocument,
+  DeviceNotificationModel
+>("DeviceNotification", deviceNotificationSchema);
 
 export default DeviceNotifications;