@internetderdinge/api 1.229.0 → 1.229.2

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

@@ -17,14 +17,14 @@ export const eventResponseSchema = z.object({
   id: z.string(),
   deviceId: z.string(),
   type: z.string(),
-  payload: z.record(z.any()),
+  payload: z.record(z.string(), z.any()),
   timestamp: z.string(), // ISO timestamp
   // ...other event fields...
 });
 
-export const genericResponseSchema = z.object({
-  message: z.string(),
-});
+export const genericResponseSchema = z
+  .record(z.string(), 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,12 +4,12 @@ import { objectId } from "../validations/custom.validation.js";
 import {
   zGet,
   zObjectId,
+  zObjectIdFor,
   zPatchBody,
   zUpdate,
   zDelete,
   zPagination,
 } from "../utils/zValidations.js";
-import { enable } from "agenda/dist/job/enable";
 
 extendZodWithOpenApi(z);
 
@@ -19,7 +19,7 @@ export const createEntrySchema = {
       name: z.string().optional(),
       deviceId: z.string().optional(),
       kind: z.string().optional(),
-      meta: z.record(z.any()).optional(),
+      meta: z.record(z.string(), z.any()).optional(),
       organization: zObjectId,
       patient: zObjectId.optional(),
       paper: zObjectId.optional().nullable(),
@@ -51,14 +51,14 @@ export const updateEntrySchema = {
     organization: zObjectId.optional(),
     patient: zObjectId.optional().nullable(),
     paper: zObjectId.optional().nullable(),
-    meta: z.record(z.any()).optional(),
-    iotDevice: z.record(z.any()).optional(),
+    meta: z.record(z.string(), z.any()).optional(),
+    iotDevice: z.record(z.string(), z.any()).optional(),
     shadow: z.union([z.string(), z.number()]).optional(),
     alarmEnable: z.number().int().optional(),
     takeOffsetTime: z.number().int().optional(),
     updatedAt: z.string().datetime().optional(),
     createdAt: z.string().datetime().optional(),
-    payment: z.record(z.any()).optional(),
+    payment: z.record(z.string(), z.any()).optional(),
     lut: z.string().optional(),
     sleepTime: z.string().optional(),
     clearScreen: z.boolean().optional(),
@@ -66,6 +66,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 +97,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 +169,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 +182,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 = {
@@ -199,8 +236,8 @@ export const uploadSingleImageFromWebsiteSchema = {};
 export const updateDeviceSchema = {
   ...zUpdate("deviceId"),
   body: zPatchBody({
-    intake: z.record(z.any()).optional(),
-    meta: z.record(z.any()).optional(),
+    intake: z.record(z.string(), z.any()).optional(),
+    meta: z.record(z.string(), z.any()).optional(),
     organization: zObjectId.optional(),
     patient: zObjectId.optional().nullable(),
     paper: zObjectId.optional().nullable(),
@@ -208,14 +245,38 @@ export const updateDeviceSchema = {
     deviceId: z.string().optional(),
     alarmEnable: z.number().int().optional(),
     takeOffsetTime: z.number().int().optional(),
-    iotDevice: z.record(z.any()).optional(),
-    payment: z.record(z.any()).optional(),
+    iotDevice: z.record(z.string(), z.any()).optional(),
+    payment: z.record(z.string(), z.any()).optional(),
   }),
 };
 
-export const updateSingleImageMetaSchema = {};
+export const updateSingleImageMetaSchema = {
+  params: z.object({
+    deviceId: zObjectIdFor("deviceId").openapi({
+      description: "Device ObjectId",
+    }),
+  }),
+  body: z
+    .object({
+      meta: z.record(z.string(), 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;

package/src/devicesNotifications/devicesNotifications.service.ts

@@ -1,20 +1,31 @@
-import httpStatus from 'http-status';
-import { SESv2Client, ListSuppressedDestinationsCommand } from '@aws-sdk/client-sesv2';
-import DeviceNotification from './devicesNotifications.model';
-import ApiError from '../../src/utils/ApiError';
-import { auth0 } from '../accounts/auth0.service';
-
-import type { Notification } from './devicesNotifications.model';
-import type { FilterQuery, PaginateOptions, QueryResult } from 'mongoose';
+// @ts-nocheck
+import httpStatus from "http-status";
+import {
+  SESv2Client,
+  ListSuppressedDestinationsCommand,
+} from "@aws-sdk/client-sesv2";
+import DeviceNotification from "./devicesNotifications.model";
+import ApiError from "../../src/utils/ApiError";
+import { auth0 } from "../accounts/auth0.service";
+import type { Notification } from "./devicesNotifications.model";
+import type { FilterQuery, PaginateOptions, QueryResult } from "mongoose";
 
 /**
  * Create a user
  * @param {Object} userBody
  * @returns {Promise<Notification>}
  */
-export const createNotificationUser = async ({ user }: { user: string }): Promise<Notification> => {
+export const createNotificationUser = async ({
+  user,
+}: {
+  user: string;
+}): Promise<Notification> => {
   const result = await DeviceNotification.findOne({ user });
-  if (result) throw new ApiError(httpStatus.NOT_FOUND, 'DevicesNotifications user existing');
+  if (result)
+    throw new ApiError(
+      httpStatus.NOT_FOUND,
+      "DevicesNotifications user existing",
+    );
   const devicesNotification = await DeviceNotification.create({ user });
   return devicesNotification;
 };
@@ -37,7 +48,9 @@ export const setDeviceToken = async ({
     result = await createNotificationUser({ user });
   }
 
-  result.tokens = [...new Map(result.tokens.map((m) => [m.deviceId, m])).values()];
+  result.tokens = [
+    ...new Map(result.tokens.map((m) => [m.deviceId, m])).values(),
+  ];
 
   if (result.tokens.find((t) => t.token === token)) return result;
 
@@ -120,7 +133,7 @@ const getByUser = async (user) => {
 const updateById = async (notificationId, updateBody) => {
   const user = await getById(notificationId);
   if (!user) {
-    throw new ApiError(httpStatus.NOT_FOUND, 'Notification not found');
+    throw new ApiError(httpStatus.NOT_FOUND, "Notification not found");
   }
   Object.assign(user, updateBody);
   await user.save();
@@ -148,7 +161,7 @@ const updateByUserId = async (user, updateBody) => {
 const deleteById = async (userId) => {
   const user = await getById(userId);
   if (!user) {
-    throw new ApiError(httpStatus.NOT_FOUND, 'Notification not found');
+    throw new ApiError(httpStatus.NOT_FOUND, "Notification not found");
   }
   await user.deleteOne();
   return user;
@@ -164,17 +177,22 @@ const cleanup = async () => {
 
   const auth0Users = await auth0.getUsers();
 
-  const sesV2 = new SESv2Client({ region: 'eu-central-1' });
+  const sesV2 = new SESv2Client({ region: "eu-central-1" });
   const input = {
-    Reasons: ['BOUNCE' || 'COMPLAINT'],
+    Reasons: ["BOUNCE" || "COMPLAINT"],
     PageSize: 300,
   };
 
   const command = new ListSuppressedDestinationsCommand(input);
   const suppressedDestinations = await sesV2.send(command);
 
-  const suppressedEmailList = suppressedDestinations.SuppressedDestinationSummaries.map((a) => a.EmailAddress);
-  const suppressedEmailAuth0Users = auth0Users.filter((a) => suppressedEmailList.includes(a.email));
+  const suppressedEmailList =
+    suppressedDestinations.SuppressedDestinationSummaries.map(
+      (a) => a.EmailAddress,
+    );
+  const suppressedEmailAuth0Users = auth0Users.filter((a) =>
+    suppressedEmailList.includes(a.email),
+  );
   await Promise.all(
     suppressedEmailAuth0Users.map(async (a) => {
       updateByUserId(a.user_id, { bounceEmail: a.email });