@internetderdinge/api 1.224.2 → 1.229.1

package/src/utils/ApiError.ts

@@ -1,8 +1,15 @@
+// @ts-nocheck
 export class ApiError extends Error {
   statusCode: number;
   isOperational: boolean;
 
-  constructor(statusCode: number, message: string, isOperational = true, stack = '', raw: any = null) {
+  constructor(
+    statusCode: number,
+    message: string,
+    isOperational = true,
+    stack = "",
+    raw: any = null,
+  ) {
     super(message);
     this.statusCode = statusCode;
     this.isOperational = isOperational;

package/src/utils/buildRouterAndDocs.ts

@@ -1,28 +1,40 @@
-import { registry } from '../utils/registerOpenApi';
+import type { RequestHandler, Router } from "express";
+import { registry } from "../utils/registerOpenApi";
 
-import { validateZod } from '../middlewares/validateZod';
-import { bearerAuth, xApiKey } from '../utils/registerOpenApi';
+import { validateZod } from "../middlewares/validateZod";
+import { bearerAuth, xApiKey } from "../utils/registerOpenApi";
 
-import { extendZodWithOpenApi } from '@asteasolutions/zod-to-openapi';
-import { z } from 'zod';
+import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";
+import { z } from "zod";
+import type { ZodTypeAny } from "zod";
 
 extendZodWithOpenApi(z);
 
-const roleValidatorNames = ['validateAiRole', 'validateAdmin'];
+const roleValidatorNames = ["validateAiRole", "validateAdmin"];
 function hasRoleValidation(validators: Function[] = []): boolean {
   return validators.some((fn) => roleValidatorNames.includes(fn.name));
 }
 
 export type RouteSpec = {
-  method: 'post';
+  method: "get" | "post" | "put" | "patch" | "delete" | "options" | "head";
   path: string;
-  requestBody: AnyZodObject;
-  responseSchema?: AnyZodObject;
-  handler: RequestHandler;
+  validate?: RequestHandler<any, any, any, any, any>[];
+  validateWithRequestSchema?: RequestHandler<any, any, any, any, any>[];
+  requestSchema?: Partial<Record<string, ZodTypeAny>>;
+  responseSchema?: ZodTypeAny;
+  handler: RequestHandler<any, any, any, any, any>;
   summary: string;
+  description?: string;
+  privateDocs?: boolean;
+  memoOnly?: boolean;
 };
 
-export default function buildAiRouterAndDocs(router: Router, routeSpecs: any, basePath = '/', tags: string[] = []) {
+export default function buildAiRouterAndDocs(
+  router: Router,
+  routeSpecs: any,
+  basePath = "/",
+  tags: string[] = [],
+) {
   routeSpecs.forEach((spec) => {
     // mount Express
 
@@ -31,11 +43,18 @@ export default function buildAiRouterAndDocs(router: Router, routeSpecs: any, ba
     }
 
     if (spec.requestSchema) {
-      spec.validateWithRequestSchema = [validateZod(spec.requestSchema), ...spec.validate];
+      spec.validateWithRequestSchema = [
+        validateZod(spec.requestSchema),
+        ...spec.validate,
+      ];
     }
 
     if (spec.validateWithRequestSchema) {
-      router[spec.method](spec.path, ...spec.validateWithRequestSchema, spec.handler);
+      router[spec.method](
+        spec.path,
+        ...spec.validateWithRequestSchema,
+        spec.handler,
+      );
     }
 
     var { body, ...rest } = spec.requestSchema || {};
@@ -43,7 +62,7 @@ export default function buildAiRouterAndDocs(router: Router, routeSpecs: any, ba
     if (body) {
       rest.body = {
         content: {
-          'application/json': {
+          "application/json": {
             schema: body,
           },
         },
@@ -52,28 +71,44 @@ export default function buildAiRouterAndDocs(router: Router, routeSpecs: any, ba
 
     // console.log('spec.requestSchema', body);
 
-    if (spec.responseSchema && !hasRoleValidation(spec.validate) && spec.privateDocs !== true && spec.memoOnly !== true) {
+    if (
+      spec.responseSchema &&
+      !hasRoleValidation(spec.validate) &&
+      spec.privateDocs !== true &&
+      spec.memoOnly !== true
+    ) {
       // collect all middleware fn names (falls back to '<anonymous>' if unnamed)
-      const middlewareNames = (spec.validate || []).map((fn) => `\`${fn.name}\`` || '<anonymous>');
+      const middlewareNames = (spec.validate || []).map(
+        (fn) => `\`${fn.name}\`` || "<anonymous>",
+      );
+      const openApiPath = (basePath + spec.path).replace(
+        /:([A-Za-z0-9_]+)/g,
+        "{$1}",
+      );
 
       registry.registerPath({
         method: spec.method,
-        path: basePath + spec.path,
+        path: openApiPath,
         summary: spec.summary,
         request: rest,
 
         // append middleware names to the description
-        description: [spec.description, `\n\nMiddlewares: ${middlewareNames.join(', ')}`].filter(Boolean).join('\n'),
+        description: [
+          spec.description,
+          `\n\nMiddlewares: ${middlewareNames.join(", ")}`,
+        ]
+          .filter(Boolean)
+          .join("\n"),
 
         // (optionally) expose them as a custom extension instead:
-        'x-middlewares': middlewareNames,
+        "x-middlewares": middlewareNames,
 
         security: [{ [bearerAuth.name]: [] }, { [xApiKey.name]: [] }],
         responses: {
           200: {
-            description: 'Object with user data.',
+            description: "Object with user data.",
             content: {
-              'application/json': { schema: spec.responseSchema },
+              "application/json": { schema: spec.responseSchema },
             },
           },
         },

package/src/utils/catchAsync.ts

@@ -1,8 +1,32 @@
-import type { Request, Response, NextFunction } from 'express';
+import type { Request, Response, NextFunction } from "express";
+
+type AsyncRequestHandler<
+  P = any,
+  ResBody = any,
+  ReqBody = any,
+  ReqQuery = any,
+  Locals extends Record<string, any> = Record<string, any>,
+> = (
+  req: Request<P, ResBody, ReqBody, ReqQuery, Locals>,
+  res: Response<ResBody, Locals>,
+  next: NextFunction,
+) => Promise<any>;
 
 const catchAsync =
-  (fn: (req: Request, res: Response, next: NextFunction) => Promise<any>) =>
-  (req: Request, res: Response, next: NextFunction): void => {
+  <
+    P = any,
+    ResBody = any,
+    ReqBody = any,
+    ReqQuery = any,
+    Locals extends Record<string, any> = Record<string, any>,
+  >(
+    fn: AsyncRequestHandler<P, ResBody, ReqBody, ReqQuery, Locals>,
+  ) =>
+  (
+    req: Request<P, ResBody, ReqBody, ReqQuery, Locals>,
+    res: Response<ResBody, Locals>,
+    next: NextFunction,
+  ): void => {
     Promise.resolve(fn(req, res, next)).catch((err) => next(err));
   };
 

package/src/utils/deviceUtils.ts

@@ -0,0 +1,109 @@
+import { readFileSync } from "fs";
+import path from "path";
+
+export type DeviceListEntry = {
+  id: string;
+  features: string[];
+  deviceNameDetection?: string;
+  [key: string]: any;
+};
+
+export interface InitDeviceListOptions {
+  list?: DeviceListEntry[];
+  listPath?: string;
+}
+
+let deviceList: DeviceListEntry[] | null = null;
+
+const parseDeviceList = (value: unknown): DeviceListEntry[] => {
+  if (!Array.isArray(value)) {
+    throw new Error("Device list must be an array.");
+  }
+  return value as DeviceListEntry[];
+};
+
+const loadDeviceListFromFile = (listPath: string): DeviceListEntry[] => {
+  const absolutePath = path.resolve(listPath);
+  const raw = readFileSync(absolutePath, "utf8");
+  const parsed = JSON.parse(raw) as unknown;
+  return parseDeviceList(parsed);
+};
+
+export const initDeviceList = (
+  options: InitDeviceListOptions = {},
+): DeviceListEntry[] => {
+  if (options.list) {
+    deviceList = options.list;
+    return deviceList;
+  }
+  if (options.listPath) {
+    deviceList = loadDeviceListFromFile(options.listPath);
+    return deviceList;
+  }
+  throw new Error("initDeviceList requires list or listPath.");
+};
+
+const ensureDeviceList = (): DeviceListEntry[] => {
+  if (!deviceList) {
+    throw new Error(
+      "deviceList is not initialized. Call initDeviceList(...) before using device utilities.",
+    );
+  }
+  return deviceList;
+};
+
+export { deviceList as default };
+
+export function deviceByKind(device): any {
+  const list = ensureDeviceList();
+  const result = list.find((e) => e.id === device);
+  return result;
+}
+
+export function deviceByDeviceName(deviceName): any {
+  if (!deviceName) return false;
+  const list = ensureDeviceList();
+  const result = list.find((e) => {
+    if (!e.deviceNameDetection) return false;
+
+    return deviceName.startsWith(e.deviceNameDetection);
+  });
+  if (!result) return false;
+  return result;
+}
+
+/**
+ * Returns true if the device kind has the given feature
+ */
+export function deviceKindHasFeature(
+  feature:
+    | "analog"
+    | "wifi"
+    | "epaper"
+    | "nbiot"
+    | "nouser"
+    | "battery-offline"
+    | "code7"
+    | "sensor"
+    | "payment"
+    | "anabox-smart"
+    | "intakes1"
+    | "intakes3"
+    | "intakes4"
+    | "intakes5"
+    | "intakes7"
+    | "stationaer"
+    | "tray-colors"
+    | "nuechtern-bedarf"
+    | "week-colors"
+    | "day-colors"
+    | "alt-device"
+    | "battery-level",
+  kind?: DeviceListEntry["id"],
+): boolean {
+  if (!kind) return false;
+  const list = ensureDeviceList();
+  const result = list.find((e) => e.id === kind);
+  if (!result) return false;
+  return result.features.includes(feature);
+}

package/src/utils/medicationName.ts

@@ -1,12 +1,13 @@
-import i18n from '../i18n/i18n';
-import type { MedicationEntry } from '../types/MedicationEntry';
+// @ts-nocheck
+import i18n from "../i18n/i18n";
+import type { MedicationEntry } from "../types/MedicationEntry";
 
 export const medicationName = (entry: MedicationEntry, lng: string): string => {
   const name = entry.medicationData?.Kurzname
     ? entry.medicationData.Kurzname
     : entry.localMedicationData?.meta?.name
-      ? entry.localMedicationData.meta.name.replace(/ .*/, '')
-      : i18n.t('A medication', { lng });
+      ? entry.localMedicationData.meta.name.replace(/ .*/, "")
+      : i18n.t("A medication", { lng });
 
   return name;
 };

package/src/utils/pick.ts

@@ -4,7 +4,11 @@
  * @param {string[]} keys - The keys to pick
  * @returns {Partial<Record<string, any>>} - The new object with picked properties
  */
-const pick = <T extends Record<string, any>>(object: T, keys: (keyof T)[]): Partial<T> => {
+// @ts-nocheck
+const pick = <T extends Record<string, any>>(
+  object: T,
+  keys: string[],
+): Partial<T> => {
   return keys.reduce((obj, key) => {
     if (object && Object.prototype.hasOwnProperty.call(object, key)) {
       obj[key] = object[key];

package/src/utils/userName.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { getUserById } from "../accounts/auth0.service";
 import type { Patient } from "../types/patient"; // Assuming a `Patient` type exists in your project
 

package/src/utils/zValidations.ts

@@ -1,45 +1,52 @@
-import { z } from 'zod';
-import { objectId } from '../validations/custom.validation';
-import mongoose from 'mongoose';
+// @ts-nocheck
+import { z } from "zod";
+import { objectId } from "../validations/custom.validation";
+import mongoose from "mongoose";
 
 export const zPagination = {
   query: z.object({
     name: z.string().optional(),
-    role: z.string().openapi({ example: 'admin', description: 'Role to filter by' }).optional(),
-    sortBy: z.string().openapi({ example: 'createdAt', description: 'Field to sort by' }).optional(),
+    role: z
+      .string()
+      .openapi({ example: "admin", description: "Role to filter by" })
+      .optional(),
+    sortBy: z
+      .string()
+      .openapi({ example: "createdAt", description: "Field to sort by" })
+      .optional(),
     search: z
       .string()
       .openapi({
-        example: 'search term',
-        description: 'Search term to filter results',
+        example: process.env.SCHEMA_EXAMPLE_SEARCH || "",
+        description: "Search term to filter results",
       })
       .optional(),
     limit: z.coerce
       .number()
       .openapi({
         example: 10,
-        description: 'Number of items per page',
+        description: "Number of items per page",
       })
       .int()
       .min(1)
       .max(100000)
       .optional(),
-    offset: z
+    offset: z.coerce
       .number() // was z.int()
       .openapi({
         example: 0,
-        description: 'Offset for pagination, used to skip a number of items',
+        description: "Offset for pagination, used to skip a number of items",
       })
       .int()
       .min(0)
       .max(100000)
       .optional(),
-    page: z
+    page: z.coerce
       .number()
       .int()
       .openapi({
         example: 1,
-        description: 'Page number for pagination',
+        description: "Page number for pagination",
       })
       .min(1)
       .max(100000)
@@ -50,40 +57,85 @@ export const zPagination = {
 export const zPaginationResponse = () =>
   z.object({
     results: z.array(z.unknown()), // Replace with your specific item schema
-    totalResults: z.number().openapi({ example: 100, description: 'Total number of items' }),
-    totalPages: z.number().openapi({ example: 10, description: 'Total number of pages' }),
-    page: z.number().openapi({ example: 1, description: 'Current page number' }),
-    limit: z.number().openapi({ example: 10, description: 'Number of items per page' }),
+    totalResults: z
+      .number()
+      .openapi({ example: 100, description: "Total number of items" }),
+    totalPages: z
+      .number()
+      .openapi({ example: 10, description: "Total number of pages" }),
+    page: z
+      .number()
+      .openapi({ example: 1, description: "Current page number" }),
+    limit: z
+      .number()
+      .openapi({ example: 10, description: "Number of items per page" }),
   });
 
+const defaultObjectIdExample = "682fd0d7d4a6325d9d45b86d";
+const exampleDefaults = {
+  organization: "682fd0d7d4a6325d9d45b86e",
+  user: defaultObjectIdExample,
+  device: "682fd0d7d4a6325d9d45b86f",
+  paper: "682fd0d7d4a6325d9d45b870",
+};
+const objectIdExampleOverrides: Record<string, string | undefined> = {
+  organizationId:
+    process.env.SCHEMA_EXAMPLE_ORGANIZATION_ID || exampleDefaults.organization,
+  organization:
+    process.env.SCHEMA_EXAMPLE_ORGANIZATION_ID || exampleDefaults.organization,
+  userId: process.env.SCHEMA_EXAMPLE_USER_ID || exampleDefaults.user,
+  deviceId: process.env.SCHEMA_EXAMPLE_DEVICE_ID || exampleDefaults.device,
+  device: process.env.SCHEMA_EXAMPLE_DEVICE_ID || exampleDefaults.device,
+  paperId: process.env.SCHEMA_EXAMPLE_PAPER_ID || exampleDefaults.paper,
+  paper: process.env.SCHEMA_EXAMPLE_PAPER_ID || exampleDefaults.paper,
+  patient: process.env.SCHEMA_EXAMPLE_USER_ID || exampleDefaults.user,
+  accountId: process.env.SCHEMA_EXAMPLE_ACCOUNT_ID,
+  tokenId: process.env.SCHEMA_EXAMPLE_TOKEN_ID,
+};
+
+export const zObjectIdFor = (paramName?: string) => {
+  const example = paramName ? objectIdExampleOverrides[paramName] : undefined;
+  const exampleValue = example || defaultObjectIdExample;
+  return z
+    .string()
+    .refine((val) => {
+      if (process.env.SCHEMA_STRICT_EXAMPLES === "true" && example) {
+        return val === example;
+      }
+      return mongoose.Types.ObjectId.isValid(val);
+    })
+    .openapi({
+      example: exampleValue,
+      description: "A valid MongoDB ObjectId",
+    });
+};
+
 export const zGet = (id: string) => ({
   params: z.object({
-    [id]: zObjectId /* .openapi({ example: '682fd0d7d4a6325d9d45b86d' }) */,
+    [id]: zObjectIdFor(id),
   }),
 });
 
-export function zPatchBody<T extends ZodRawShape>(shape: T, message = 'At least one field must be provided for update') {
+export function zPatchBody<T extends ZodRawShape>(
+  shape: T,
+  message = "At least one field must be provided for update",
+) {
   // assume user passed in already-optional vals
   return z.object(shape); // .refine((o) => Object.keys(o).length > 0, { message });
 }
 
 export const zUpdate = (id: string) => ({
   params: z.object({
-    [id]: zObjectId,
+    [id]: zObjectIdFor(id),
   }),
 });
 
 export const zDelete = (id: string) => ({
   params: z.object({
-    [id]: zObjectId,
+    [id]: zObjectIdFor(id),
   }),
 });
 
-export const zObjectId = z
-  .string()
-  .refine((val) => {
-    return mongoose.Types.ObjectId.isValid(val);
-  })
-  .openapi({ example: '682fd0d7d4a6325d9d45b86d', description: 'A valid MongoDB ObjectId' });
+export const zObjectId = zObjectIdFor();
 
 export const zDate = () => z.string().pipe(z.coerce.date());

package/tsconfig.json

@@ -1,13 +1,18 @@
 {
   "compilerOptions": {
     "target": "ES2020",
-    "module": "NodeNext",
+    "module": "ES2020",
     "baseUrl": ".",
     "rootDir": ".",
     "outDir": "./dist",
     "esModuleInterop": true,
-    "strict": true,
-    "moduleResolution": "NodeNext",
+    "strict": false,
+    "noImplicitAny": false,
+    "noImplicitThis": false,
+    "useUnknownInCatchVariables": false,
+    "noUncheckedIndexedAccess": false,
+    "exactOptionalPropertyTypes": false,
+    "moduleResolution": "Bundler",
     "resolveJsonModule": true,
     "forceConsistentCasingInFileNames": true,
     "skipLibCheck": true,
@@ -17,6 +22,10 @@
     "esm": true,
     "experimentalSpecifierResolution": "node"
   },
-  "include": ["src/**/*", "common.legac, "../memo-api/src/middlewares/validateMessage.ts"y/**/*"],
+  "include": [
+    "src/**/*",
+    "common.legacy/**/*",
+    "../memo-api/src/middlewares/validateMessage.ts"
+  ],
   "exclude": ["node_modules", "dist"]
 }