@internetderdinge/api 1.229.0 → 1.229.1

package/src/middlewares/auth.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import passport from "passport";
 import httpStatus from "http-status";
 import { expressjwt as jwt } from "express-jwt";
@@ -8,14 +9,7 @@ import ApiError from "../utils/ApiError";
 import Token from "../tokens/tokens.model";
 import { roleRights } from "../config/roles";
 
-interface AuthRequest extends Request {
-  auth?: {
-    id: string;
-    tokenId: string;
-    type: string;
-    [key: string]: any; // Additional user data
-  };
-}
+type AuthRequest = Request;
 
 type VerifyCallback = (
   req: AuthRequest,

package/src/middlewares/error.ts

@@ -1,16 +1,25 @@
-import mongoose from 'mongoose';
-import httpStatus from 'http-status';
-import config from '../config/config';
-import logger from '../config/logger';
-import ApiError from '../utils/ApiError';
+// @ts-nocheck
+import mongoose from "mongoose";
+import httpStatus from "http-status";
+import config from "../config/config";
+import logger from "../config/logger";
+import ApiError from "../utils/ApiError";
 
-import type { Request, Response, NextFunction } from 'express';
+import type { Request, Response, NextFunction } from "express";
 
-export const errorConverter = (err: any, req: Request, res: Response, next: NextFunction): void => {
+export const errorConverter = (
+  err: any,
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): void => {
   let error = err;
   if (!(error instanceof ApiError)) {
     const statusCode =
-      error.statusCode || (error instanceof mongoose.Error ? httpStatus.BAD_REQUEST : httpStatus.INTERNAL_SERVER_ERROR);
+      error.statusCode ||
+      (error instanceof mongoose.Error
+        ? httpStatus.BAD_REQUEST
+        : httpStatus.INTERNAL_SERVER_ERROR);
     const message = error.message || httpStatus[statusCode];
     error = new ApiError(statusCode, message, false, err.stack);
   }
@@ -18,9 +27,14 @@ export const errorConverter = (err: any, req: Request, res: Response, next: Next
 };
 
 // eslint-disable-next-line no-unused-vars
-export const errorHandler = (err: ApiError, req: Request, res: Response, next: NextFunction): void => {
+export const errorHandler = (
+  err: ApiError,
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): void => {
   let { statusCode, message } = err;
-  if (config.env === 'production' && !err.isOperational) {
+  if (config.env === "production" && !err.isOperational) {
     statusCode = httpStatus.INTERNAL_SERVER_ERROR;
     message = httpStatus[httpStatus.INTERNAL_SERVER_ERROR];
   }
@@ -30,10 +44,10 @@ export const errorHandler = (err: ApiError, req: Request, res: Response, next: N
   const response = {
     code: statusCode,
     message,
-    ...(config.env === 'development' && { stack: err.stack }),
+    ...(config.env === "development" && { stack: err.stack }),
   };
 
-  if (config.env === 'development') {
+  if (config.env === "development") {
     logger.error(err);
   }
 

package/src/middlewares/mongooseValidations/ensureSameOrganization.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 /**
  * Throws if patient doesn’t exist or isn’t in the given org.
  */
@@ -7,9 +8,9 @@ export async function ensureSameOrganization(
   UserModel: Model<any>,
 ) {
   // console.log('ensureSameOrganization', patientId, organizationId);
-  const user = await UserModel.findById(patientId).select('organization');
-  if (!user) throw new Error('Patient not found');
+  const user = await UserModel.findById(patientId).select("organization");
+  if (!user) throw new Error("Patient not found");
   if (!user.organization.equals(organizationId)) {
-    throw new Error('Patient must belong to the same organization');
+    throw new Error("Patient must belong to the same organization");
   }
 }

package/src/middlewares/validateAi.ts

@@ -1,24 +1,32 @@
-import httpStatus from 'http-status';
-import ApiError from '../utils/ApiError'; // keep .cjs import
-import expressPkg from 'express';
-const { Request, Response, NextFunction } = expressPkg;
+import httpStatus from "http-status";
+import ApiError from "../utils/ApiError"; // keep .cjs import
+import type { Request, Response, NextFunction } from "express";
 
 interface User {
-  'https://memo.wirewire.de/roles'?: string[];
+  "https://memo.wirewire.de/roles"?: string[];
 }
 
 // you can adjust the User source if your auth payload differs
 export const isAiRole = (user?: User): boolean => {
   if (!user) return false;
-  return user['https://memo.wirewire.de/roles']?.includes('ai') ?? false;
+  return user["https://memo.wirewire.de/roles"]?.includes("ai") ?? false;
 };
 
-export const validateAiRole = async (req: Request & { auth?: User }, res: Response, next: NextFunction): Promise<void> => {
+export const validateAiRole = async (
+  req: Request & { auth?: User },
+  res: Response,
+  next: NextFunction,
+): Promise<void> => {
   // assuming the auth payload is attached to req.auth
 
-  console.log('Validating AI role for user:', req.auth);
+  console.log("Validating AI role for user:", req.auth);
   if (isAiRole(req.auth)) {
     return next();
   }
-  return next(new ApiError(httpStatus.FORBIDDEN, 'User is not part of the ai group (validateAi)'));
+  return next(
+    new ApiError(
+      httpStatus.FORBIDDEN,
+      "User is not part of the ai group (validateAi)",
+    ),
+  );
 };

package/src/middlewares/validateDevice.ts

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

package/src/middlewares/validateDeviceUserOrganization.ts

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

package/src/middlewares/validateOrganization.ts

@@ -1,7 +1,7 @@
+// @ts-nocheck
 import type { Request, Response, NextFunction } from "express";
 import type { UserService } from "../users/users.service";
 import userService from "../users/users.service";
-
 import httpStatus from "http-status";
 import ApiError from "../utils/ApiError";
 import { isAdmin } from "./validateAdmin";

package/src/middlewares/validateQuerySearchUserAndOrganization.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import httpStatus from "http-status";
 import ApiError from "../utils/ApiError";
 import { isAdmin } from "./validateAdmin";

package/src/middlewares/validateTokens.ts

@@ -21,7 +21,8 @@ export async function validateParamsToken(
   }
 
   // compare owner vs. authenticated sub
-  if (token.owner !== res.req.auth.sub) {
+  const tokenOwner = (token as { owner?: string }).owner;
+  if (!tokenOwner || tokenOwner !== res.req.auth?.sub) {
     return next(
       new ApiError(
         httpStatus.FORBIDDEN,

package/src/middlewares/validateUser.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import httpStatus from "http-status";
 import ApiError from "../utils/ApiError";
 import usersService from "../users/users.service";

package/src/models/plugins/index.ts

@@ -1,7 +1,8 @@
-import type { ToJSONPlugin } from './toJSON.plugin';
-import type { PaginatePlugin } from './paginate.plugin';
+// @ts-nocheck
+import type { ToJSONPlugin } from "./toJSON.plugin";
+import type { PaginatePlugin } from "./paginate.plugin";
 // import type { PaginateNewPlugin } from './paginateNew.plugin';
 
-export { default as toJSON } from './toJSON.plugin';
-export { default as paginate } from './paginate.plugin';
+export { default as toJSON } from "./toJSON.plugin";
+export { default as paginate } from "./paginate.plugin";
 // export { default as paginateNew } from './paginateNew.plugin';

package/src/models/plugins/paginate.plugin.ts

@@ -1,5 +1,6 @@
+// @ts-nocheck
 /* eslint-disable no-param-reassign */
-import { Document, Model, Query, Types } from 'mongoose';
+import { Document, Model, Query, Types } from "mongoose";
 
 export interface QueryResult<T> {
   results: T[];
@@ -26,20 +27,26 @@ function paginate<T extends Document>(schema: any) {
     options: PaginateOptions = {},
     plugin?: PluginFunction,
   ): Promise<QueryResult<T>> {
-    let sort = '';
+    let sort = "";
     if (options.sortBy) {
       const sortingCriteria: string[] = [];
-      options.sortBy.split(',').forEach((sortOption) => {
-        const [key, order] = sortOption.split(':');
-        sortingCriteria.push((order === 'desc' ? '-' : '') + key);
+      options.sortBy.split(",").forEach((sortOption) => {
+        const [key, order] = sortOption.split(":");
+        sortingCriteria.push((order === "desc" ? "-" : "") + key);
       });
-      sort = sortingCriteria.join(' ');
+      sort = sortingCriteria.join(" ");
     } else {
-      sort = 'createdAt';
+      sort = "createdAt";
     }
 
-    const limit = options.limit && parseInt(String(options.limit), 10) > 0 ? parseInt(String(options.limit), 10) : 10000;
-    const page = options.page && parseInt(String(options.page), 10) > 0 ? parseInt(String(options.page), 10) : 1;
+    const limit =
+      options.limit && parseInt(String(options.limit), 10) > 0
+        ? parseInt(String(options.limit), 10)
+        : 10000;
+    const page =
+      options.page && parseInt(String(options.page), 10) > 0
+        ? parseInt(String(options.page), 10)
+        : 1;
     const skip = (page - 1) * limit;
 
     let results: any[] = [];
@@ -51,7 +58,7 @@ function paginate<T extends Document>(schema: any) {
 
       const fuzzyFields = options.fuzzySearch.fields;
       const mustClauses = Object.entries(filter).map(([key, value]) => {
-        if (typeof value === 'string' && value.match(/^[a-fA-F0-9]{24}$/)) {
+        if (typeof value === "string" && value.match(/^[a-fA-F0-9]{24}$/)) {
           return { equals: { path: key, value: new Types.ObjectId(value) } };
         }
         return { equals: { path: key, value } };
@@ -81,7 +88,7 @@ function paginate<T extends Document>(schema: any) {
         {
           $facet: {
             results: [],
-            totalCount: [{ $count: 'count' }],
+            totalCount: [{ $count: "count" }],
           },
         },
       ];
@@ -93,12 +100,15 @@ function paginate<T extends Document>(schema: any) {
       // Regular find branch
       const countPromise = this.countDocuments(filter).exec();
 
-      let docsPromise: any = this.find(filter).sort(sort).skip(skip).limit(limit);
+      let docsPromise: any = this.find(filter)
+        .sort(sort)
+        .skip(skip)
+        .limit(limit);
       if (options.populate) {
-        options.populate.split(',').forEach((populateOption) => {
+        options.populate.split(",").forEach((populateOption) => {
           docsPromise = docsPromise.populate(
             populateOption
-              .split('.')
+              .split(".")
               .reverse()
               .reduce((a, b) => ({ path: b, populate: a })),
           );
@@ -117,9 +127,9 @@ function paginate<T extends Document>(schema: any) {
       if (options.populate) {
         results = await this.populate(
           results,
-          options.populate.split(',').map((populateOption) =>
+          options.populate.split(",").map((populateOption) =>
             populateOption
-              .split('.')
+              .split(".")
               .reverse()
               .reduce((a, b) => ({ path: b, populate: a })),
           ),

package/src/models/plugins/paginateNew.plugin.ts

@@ -1,7 +1,8 @@
+// @ts-nocheck
 /* eslint-disable no-param-reassign */
-import mongoose from 'mongoose';
-import type { Schema, Document, Model, PipelineStage } from 'mongoose';
-import type { PaginateOptions, QueryResult } from './types';
+import mongoose from "mongoose";
+import type { Schema, Document, Model, PipelineStage } from "mongoose";
+import type { PaginateOptions, QueryResult } from "./paginate.plugin.js";
 
 const paginate = (schema: Schema): void => {
   /**
@@ -14,19 +15,26 @@ const paginate = (schema: Schema): void => {
     filter: Record<string, any> = {},
     options: PaginateOptions = {},
     plugin?: any,
-  ): Promise<QueryResult> {
+  ): Promise<QueryResult<any>> {
     // Parse sorting options
     const sort = options.sortBy
-      ? options.sortBy.split(',').reduce((acc: Record<string, number>, sortOption: string) => {
-          const [key, order] = sortOption.split(':');
-          acc[key] = order === 'desc' ? -1 : 1;
-          return acc;
-        }, {})
+      ? options.sortBy
+          .split(",")
+          .reduce((acc: Record<string, number>, sortOption: string) => {
+            const [key, order] = sortOption.split(":");
+            acc[key] = order === "desc" ? -1 : 1;
+            return acc;
+          }, {})
       : { createdAt: -1 };
 
     const limit =
-      options.limit && parseInt(options.limit.toString(), 10) > 0 ? parseInt(options.limit.toString(), 10) : 10000;
-    const page = options.page && parseInt(options.page.toString(), 10) > 0 ? parseInt(options.page.toString(), 10) : 1;
+      options.limit && parseInt(options.limit.toString(), 10) > 0
+        ? parseInt(options.limit.toString(), 10)
+        : 10000;
+    const page =
+      options.page && parseInt(options.page.toString(), 10) > 0
+        ? parseInt(options.page.toString(), 10)
+        : 1;
     const skip = (page - 1) * limit;
 
     // Build aggregation pipeline
@@ -38,7 +46,7 @@ const paginate = (schema: Schema): void => {
 
     // Helper function to determine if a path is a virtual field
     const isVirtualField = (path: string): boolean => {
-      const rootPath = path.split('.')[0];
+      const rootPath = path.split(".")[0];
       return !!schema.virtuals[rootPath];
     };
 
@@ -50,14 +58,16 @@ const paginate = (schema: Schema): void => {
 
         for (const key in filterObj) {
           if (filterObj.hasOwnProperty(key)) {
-            if (key === '$or' || key === '$and') {
+            if (key === "$or" || key === "$and") {
               const mainArray: Record<string, any>[] = [];
               const virtualArray: Record<string, any>[] = [];
 
               filterObj[key].forEach((item: Record<string, any>) => {
-                const { main: itemMain, virtual: itemVirtual } = separateFilter(item);
+                const { main: itemMain, virtual: itemVirtual } =
+                  separateFilter(item);
                 if (Object.keys(itemMain).length > 0) mainArray.push(itemMain);
-                if (Object.keys(itemVirtual).length > 0) virtualArray.push(itemVirtual);
+                if (Object.keys(itemVirtual).length > 0)
+                  virtualArray.push(itemVirtual);
               });
 
               if (mainArray.length > 0) main[key] = mainArray;
@@ -87,8 +97,8 @@ const paginate = (schema: Schema): void => {
 
     // Handle virtual fields population
     if (options.populate) {
-      options.populate.split(',').forEach((populateOption: string) => {
-        const paths = populateOption.split('.');
+      options.populate.split(",").forEach((populateOption: string) => {
+        const paths = populateOption.split(".");
         const localField = paths[0];
         const virtual = schema.virtuals[localField];
         if (!virtual) {
@@ -140,7 +150,9 @@ const paginate = (schema: Schema): void => {
 
     // Handle fuzzy search (if applicable)
     if (this.fuzzySearch && options.fuzzySearch) {
-      throw new Error('Fuzzy search is not supported with aggregation in this paginate function.');
+      throw new Error(
+        "Fuzzy search is not supported with aggregation in this paginate function.",
+      );
     }
 
     // Add sorting, skipping, and limiting stages
@@ -151,7 +163,7 @@ const paginate = (schema: Schema): void => {
     // Rename root _id to id
     pipeline.push({
       $addFields: {
-        id: '$_id',
+        id: "$_id",
       },
     });
     pipeline.push({
@@ -166,7 +178,7 @@ const paginate = (schema: Schema): void => {
         $facet: {
           metadata: [
             {
-              $count: 'totalResults',
+              $count: "totalResults",
             },
           ],
           data: pipeline,
@@ -174,7 +186,7 @@ const paginate = (schema: Schema): void => {
       },
       {
         $addFields: {
-          totalResults: { $arrayElemAt: ['$metadata.totalResults', 0] },
+          totalResults: { $arrayElemAt: ["$metadata.totalResults", 0] },
         },
       },
     ];

package/src/models/plugins/simplePopulate.ts

@@ -1,10 +1,15 @@
 function simplePopulate(populate: string): Record<string, any> {
   let docsPromise: Record<string, any> = {};
-  populate.split(',').forEach((populateOption) => {
+  populate.split(",").forEach((populateOption) => {
     docsPromise = populateOption
-      .split('.')
+      .split(".")
       .reverse()
-      .reduce((a, b) => ({ path: b, populate: a }));
+      .reduce<Record<string, any>>((acc, key) => {
+        if (Object.keys(acc).length === 0) {
+          return { path: key };
+        }
+        return { path: key, populate: acc };
+      }, {});
   });
   return docsPromise;
 }

package/src/models/plugins/toJSON.plugin.ts

@@ -6,9 +6,14 @@
  *  - replaces _id with id
  */
 
-import type { Schema, Document } from 'mongoose';
-
-const deleteAtPath = (obj: Record<string, any>, path: string[], index: number): void => {
+// @ts-nocheck
+import type { Schema, Document } from "mongoose";
+
+const deleteAtPath = (
+  obj: Record<string, any>,
+  path: string[],
+  index: number,
+): void => {
   if (index === path.length - 1) {
     delete obj[path[index]];
     return;
@@ -17,7 +22,9 @@ const deleteAtPath = (obj: Record<string, any>, path: string[], index: number):
 };
 
 const toJSON = (schema: Schema, timestamps: boolean = false): void => {
-  let transform: ((doc: Document, ret: Record<string, any>, options: any) => any) | undefined;
+  let transform:
+    | ((doc: Document, ret: Record<string, any>, options: any) => any)
+    | undefined;
 
   if (schema.options.toJSON && schema.options.toJSON.transform) {
     transform = schema.options.toJSON.transform;
@@ -28,7 +35,7 @@ const toJSON = (schema: Schema, timestamps: boolean = false): void => {
     transform(doc: Document, ret: Record<string, any>, options: any): any {
       Object.keys(schema.paths).forEach((path) => {
         if (schema.paths[path].options && schema.paths[path].options.private) {
-          deleteAtPath(ret, path.split('.'), 0);
+          deleteAtPath(ret, path.split("."), 0);
         }
       });
 

package/src/organizations/organizations.controller.ts

@@ -1,5 +1,4 @@
-import express from "express";
-const { Request, Response } = express;
+import type { Request, Response } from "express";
 import httpStatus from "http-status";
 import pick from "../utils/pick.js";
 import ApiError from "../utils/ApiError.js";

package/src/organizations/organizations.model.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import mongoose, { Schema, Document, Model } from "mongoose";
 import { toJSON, paginate } from "../models/plugins/index.js";
 
@@ -54,9 +55,8 @@ organizationSchema.plugin(toJSON);
 organizationSchema.plugin(paginate);
 
 // Define the model
-const Organization: Model<IOrganization> = mongoose.model<IOrganization>(
-  "Organization",
-  organizationSchema,
-);
+const Organization: Model<IOrganization> =
+  (mongoose.models.Organization as Model<IOrganization>) ||
+  mongoose.model<IOrganization>("Organization", organizationSchema);
 
 export default Organization;

package/src/organizations/organizations.route.ts

@@ -31,7 +31,7 @@ export const organizationsRouteSpecs: RouteSpec[] = [
     path: "/",
     validate: [auth("manageUsers")],
     requestSchema: createOrganizationSchema,
-    responseSchema: {},
+    responseSchema: organizationResponseSchema,
     handler: createOrganization,
     summary: "Create a new organization",
     description: "Creates a new organization with the provided details.",

package/src/organizations/organizations.service.ts

@@ -1,7 +1,9 @@
+// @ts-nocheck
 import httpStatus from "http-status";
 import { ObjectId } from "mongoose";
 import Organization from "./organizations.model.js";
-import type { IOrganization, QueryResult } from "./organizations.model.js";
+import type { IOrganization } from "./organizations.model.js";
+import type { QueryResult } from "../models/plugins/paginate.plugin.js";
 import ApiError from "../utils/ApiError.js";
 
 const createOrganization = async (
@@ -13,17 +15,24 @@ const createOrganization = async (
 
 const queryOrganizations = async (
   filter: Record<string, any>,
-  options: { sortBy?: string; limit?: number; page?: number },
-): Promise<QueryResult> => {
+  options: {
+    sortBy?: string;
+    limit?: number;
+    page?: number;
+    populate?: string;
+  },
+): Promise<QueryResult<IOrganization>> => {
   const organizations = await Organization.paginate(filter, options);
   return organizations;
 };
 
 const queryOrganizationsByUser = async (
-  organizationsList: Array<{ organization: ObjectId }>,
-): Promise<QueryResult | false> => {
+  organizationsList: Array<{ organization?: ObjectId | null }>,
+): Promise<QueryResult<IOrganization> | false> => {
   if (!organizationsList) return false;
-  const organizationIds = organizationsList.map((e) => e.organization);
+  const organizationIds = organizationsList
+    .map((e) => e.organization)
+    .filter((id): id is ObjectId => Boolean(id));
   const organizations = await Organization.paginate(
     {
       _id: { $in: organizationIds },

package/src/pdf/pdf.controller.ts

@@ -1,14 +1,31 @@
 import httpStatus from "http-status";
 import catchAsync from "../utils/catchAsync.js";
 import pdfService from "./pdf.service.js";
+import ApiError from "../utils/ApiError.js";
 
 export const generatePdfFromUrl = catchAsync(async (req, res) => {
   const fileName = "memo-print";
 
   const authHeader = req.headers["authorization"];
+  if (!authHeader) {
+    throw new ApiError(httpStatus.UNAUTHORIZED, "Missing Authorization header");
+  }
+
   const token = authHeader.split(" ")[1];
+  if (!token) {
+    throw new ApiError(httpStatus.UNAUTHORIZED, "Missing bearer token");
+  }
+
+  const urlPath =
+    typeof req.query.urlPath === "string" ? req.query.urlPath : undefined;
+  if (!urlPath) {
+    throw new ApiError(
+      httpStatus.BAD_REQUEST,
+      "Missing urlPath query parameter",
+    );
+  }
 
-  const result = await pdfService.generatePdfFromUrl({ ...req.query, token });
+  const result = await pdfService.generatePdfFromUrl({ urlPath, token });
 
   res.status(httpStatus.CREATED).send({ signed: result });
 });