@internetderdinge/api 1.224.2

package/src/utils/comparePapers.service.ts

@@ -0,0 +1,48 @@
+import sharp from 'sharp';
+import pixelmatch from 'pixelmatch';
+
+/**
+ * Compares two image buffers and returns the similarity percentage
+ * @param {Buffer} imgBuffer1 - First image buffer
+ * @param {Buffer} imgBuffer2 - Second image buffer
+ * @returns {Promise<number>} - Percentage of similarity (0-100)
+ */
+export async function compareImages(imgBuffer1: Buffer, imgBuffer2: Buffer): Promise<number> {
+  // Load the images using sharp and resize them to the same size
+
+  const image1 = await sharp(imgBuffer1).raw().ensureAlpha().toBuffer({ resolveWithObject: true });
+  const image2 = await sharp(imgBuffer2).raw().ensureAlpha().toBuffer({ resolveWithObject: true });
+
+  // Ensure both images are of the same dimensions
+  const width = Math.min(image1.info.width, image2.info.width);
+  const height = Math.min(image1.info.height, image2.info.height);
+
+  if (image1.info.width !== image2.info.width || image1.info.height !== image2.info.height) {
+    return 0;
+  }
+
+  // Resize the images to match in size
+  const resizedImage1 = await sharp(imgBuffer1).resize(width, height).raw().ensureAlpha().toBuffer();
+  const resizedImage2 = await sharp(imgBuffer2).resize(width, height).raw().ensureAlpha().toBuffer();
+
+  // Create an empty array to store pixel differences
+  const diff = new Uint8Array(width * height * 4);
+
+  // Compare the two images pixel by pixel
+  const numDiffPixels = pixelmatch(
+    resizedImage1,
+    resizedImage2,
+    diff,
+    width,
+    height,
+    { threshold: 0.3 } // Threshold for pixel comparison
+  );
+
+  // Calculate similarity percentage
+  const totalPixels = width * height;
+  const similarityPercentage = ((totalPixels - numDiffPixels) / totalPixels) * 100;
+
+  return similarityPercentage;
+}
+
+export default { compareImages };

package/src/utils/filterOptions.ts

@@ -0,0 +1,37 @@
+import mongoose from 'mongoose';
+import type { FilterQuery } from 'mongoose';
+
+const { ObjectId } = mongoose.Types;
+
+interface FilterOptions {
+  objectIds: string[];
+  search: string[];
+}
+
+const filterOptions = (query: { search?: string }, filter: FilterQuery<any>, options: FilterOptions): FilterQuery<any> => {
+  let filterAlt = filter;
+
+  if (query.search && mongoose.isValidObjectId(query.search)) {
+    const idList = options.objectIds.map((e) => ({
+      [e]: new ObjectId(query.search),
+    }));
+
+    filterAlt = {
+      $and: [filter, { $or: idList }],
+    };
+  } else if (query.search) {
+    const regexp = new RegExp(query.search, 'i');
+
+    const searchList = options.search.map((e) => ({
+      [e]: { $regex: regexp },
+    }));
+
+    filterAlt = {
+      $and: [filter, { $or: searchList }],
+    };
+  }
+
+  return filterAlt;
+};
+
+export { filterOptions };

package/src/utils/medicationName.ts

@@ -0,0 +1,12 @@
+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 });
+
+  return name;
+};

package/src/utils/pick.ts

@@ -0,0 +1,16 @@
+/**
+ * Create an object composed of the picked object properties
+ * @param {Record<string, any>} object - The source object
+ * @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> => {
+  return keys.reduce((obj, key) => {
+    if (object && Object.prototype.hasOwnProperty.call(object, key)) {
+      obj[key] = object[key];
+    }
+    return obj;
+  }, {} as Partial<T>);
+};
+
+export default pick;

package/src/utils/registerOpenApi.ts

@@ -0,0 +1,32 @@
+import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+
+export const registry = new OpenAPIRegistry();
+
+// add Bearer JWT auth
+export const bearerAuth = registry.registerComponent('securitySchemes', 'bearerAuth', {
+  type: 'http',
+  scheme: 'bearer',
+  bearerFormat: 'JWT',
+  description: 'JWT Bearer authentication',
+});
+
+export const xApiKey = registry.registerComponent('securitySchemes', 'x-api-key', {
+  type: 'apiKey',
+  in: 'header',
+  name: 'x-api-key',
+  description: 'API key for authentication',
+});
+
+/*
+registry.registerComponent('global', 'wwww', [
+  { name: 'ai', description: 'All AI-powered endpoints.' },
+  { name: 'auth', description: 'Authentication and authorization.' },
+  { name: 'Users', description: 'User management (create, read, update, delete).' },
+  // add more as needed
+]);
+
+registry.registerComponent('tag', 'users', {
+  name: 'users',
+  description: 'Operations about users',
+});
+*/

package/src/utils/urlUtils.ts

@@ -0,0 +1,14 @@
+export const resolvePossiblyRelativeUrl = (maybeUrl?: string | null, baseUrl?: string | null) => {
+  if (!maybeUrl) return null;
+  if (maybeUrl.startsWith('http')) return maybeUrl;
+
+  if (baseUrl && baseUrl.startsWith('http')) {
+    try {
+      return new URL(maybeUrl, baseUrl).toString();
+    } catch {
+      return maybeUrl;
+    }
+  }
+
+  return maybeUrl;
+};

package/src/utils/userName.ts

@@ -0,0 +1,27 @@
+import { getUserById } from "../accounts/auth0.service";
+import type { Patient } from "../types/patient"; // Assuming a `Patient` type exists in your project
+
+const generateUserName = async (patient: Patient): Promise<string | null> => {
+  if (patient.owner) {
+    const auth0UserById = await getUserById(patient.owner);
+    patient.auth0User = auth0UserById.data;
+  }
+
+  if (patient?.auth0User?.app_metadata?.first_name) {
+    return `${patient.auth0User.app_metadata.first_name} ${patient.auth0User.app_metadata.last_name}`;
+  }
+  if (patient?.auth0User?.family_name) {
+    return `${patient.auth0User.given_name} ${patient.auth0User.family_name}`;
+  }
+
+  if (patient && patient?.auth0User) {
+    return patient.auth0User.name;
+  }
+
+  if (patient && (patient.meta?.firstName || patient.meta?.lastName)) {
+    return `${patient.meta?.firstName}${patient.meta?.firstName ? " " : ""}${patient.meta?.lastName}`;
+  }
+  return null;
+};
+
+export default generateUserName;

package/src/utils/zValidations.ts

@@ -0,0 +1,89 @@
+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(),
+    search: z
+      .string()
+      .openapi({
+        example: 'search term',
+        description: 'Search term to filter results',
+      })
+      .optional(),
+    limit: z.coerce
+      .number()
+      .openapi({
+        example: 10,
+        description: 'Number of items per page',
+      })
+      .int()
+      .min(1)
+      .max(100000)
+      .optional(),
+    offset: z
+      .number() // was z.int()
+      .openapi({
+        example: 0,
+        description: 'Offset for pagination, used to skip a number of items',
+      })
+      .int()
+      .min(0)
+      .max(100000)
+      .optional(),
+    page: z
+      .number()
+      .int()
+      .openapi({
+        example: 1,
+        description: 'Page number for pagination',
+      })
+      .min(1)
+      .max(100000)
+      .optional(),
+  }),
+};
+
+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' }),
+  });
+
+export const zGet = (id: string) => ({
+  params: z.object({
+    [id]: zObjectId /* .openapi({ example: '682fd0d7d4a6325d9d45b86d' }) */,
+  }),
+});
+
+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,
+  }),
+});
+
+export const zDelete = (id: string) => ({
+  params: z.object({
+    [id]: zObjectId,
+  }),
+});
+
+export const zObjectId = z
+  .string()
+  .refine((val) => {
+    return mongoose.Types.ObjectId.isValid(val);
+  })
+  .openapi({ example: '682fd0d7d4a6325d9d45b86d', description: 'A valid MongoDB ObjectId' });
+
+export const zDate = () => z.string().pipe(z.coerce.date());

package/src/validations/auth.validation.cjs

@@ -0,0 +1,60 @@
+const Joi = require('joi');
+const { password } = require('./custom.validation.ts');
+
+const register = {
+  body: Joi.object().keys({
+    email: Joi.string().required().email(),
+    password: Joi.string().required().custom(password),
+    name: Joi.string().required(),
+  }),
+};
+
+const login = {
+  body: Joi.object().keys({
+    email: Joi.string().required(),
+    password: Joi.string().required(),
+  }),
+};
+
+const logout = {
+  body: Joi.object().keys({
+    refreshToken: Joi.string().required(),
+  }),
+};
+
+const refreshTokens = {
+  body: Joi.object().keys({
+    refreshToken: Joi.string().required(),
+  }),
+};
+
+const forgotPassword = {
+  body: Joi.object().keys({
+    email: Joi.string().email().required(),
+  }),
+};
+
+const resetPassword = {
+  query: Joi.object().keys({
+    token: Joi.string().required(),
+  }),
+  body: Joi.object().keys({
+    password: Joi.string().required().custom(password),
+  }),
+};
+
+const verifyEmail = {
+  query: Joi.object().keys({
+    token: Joi.string().required(),
+  }),
+};
+
+module.exports = {
+  register,
+  login,
+  logout,
+  refreshTokens,
+  forgotPassword,
+  resetPassword,
+  verifyEmail,
+};

package/src/validations/custom.validation.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+// Can be anything starting with nrf- or epd7, or epd- followed by a number
+export const deviceId = () =>
+  z.string().regex(/^(?:nrf-.*|epd7.*|epd-\d+)$/, {
+    message: 'must start with "nrf-", "epd7" or "epd-" followed by a number',
+  });
+
+export const objectId = () =>
+  z.string().regex(/^[0-9a-fA-F]{24}$/, {
+    message: 'must be a valid mongo id',
+  });
+
+export const password = () =>
+  z
+    .string()
+    .min(8, 'password must be at least 8 characters')
+    .refine((val) => /\d/.test(val) && /[a-zA-Z]/.test(val), {
+      message: 'password must contain at least 1 letter and 1 number',
+    });
+
+export default {
+  deviceId,
+  objectId,
+  password,
+};

package/src/validations/index.cjs

@@ -0,0 +1,2 @@
+module.exports.authValidation = require('./auth.validation.cjs');
+module.exports.userValidation = require('./user.validation.cjs');

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "baseUrl": ".",
+    "rootDir": ".",
+    "outDir": "./dist",
+    "esModuleInterop": true,
+    "strict": true,
+    "moduleResolution": "NodeNext",
+    "resolveJsonModule": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "allowJs": true
+  },
+  "ts-node": {
+    "esm": true,
+    "experimentalSpecifierResolution": "node"
+  },
+  "include": ["src/**/*", "common.legac, "../memo-api/src/middlewares/validateMessage.ts"y/**/*"],
+  "exclude": ["node_modules", "dist"]
+}