@internetderdinge/api 1.229.0 → 1.229.2

package/dist/src/users/users.schemas.js

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { extendZodWithOpenApi } from '@asteasolutions/zod-to-openapi';
+extendZodWithOpenApi(z);
+export const createUserResponseSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    email: z.string(),
+});
+export const getUsersResponseSchema = z.array(z.object({
+    id: z.string(),
+    name: z.string(),
+    email: z.string(),
+}));
+export const updateUserSchema = z.object({
+    name: z.string().optional(),
+    email: z.string().email().optional(),
+});
+export const updateUserResponseSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    email: z.string(),
+});
+export const deleteUserResponseSchema = z.object({
+    success: z.boolean(),
+});
+export const updateTimesByIdResponseSchema = z
+    .array(z.object({
+    rrule: z
+        .object({
+        freq: z.string().optional().openapi({ example: 'DAILY', description: 'Recurrence frequency' }),
+        byweekday: z
+            .array(z.number())
+            .openapi({ example: [0, 1, 2, 6, 3], description: 'Days of week to repeat (0=Sunday)' }),
+        exclude: z.array(z.string()).openapi({ example: ['2024-03-28T10:45:00.000Z'], description: 'Dates to skip' }),
+    })
+        .openapi({ description: 'Recurrence rule object' }),
+    medication: z.string().optional().openapi({ example: '6152c5f3902e7f91374d9f75', description: 'Medication ObjectId' }),
+    patient: z.string().openapi({ example: '614fb1d709dd9f6de85d6374', description: 'Patient ObjectId' }),
+    date: z.string().openapi({ example: '2024-03-25T00:30:00.000Z', description: 'Scheduled date/time (ISO)' }),
+    timeCategory: z.string().openapi({ example: 'noon', description: 'Time category (e.g. morning, noon)' }),
+    amount: z.number().openapi({ example: 1, description: 'Dosage amount' }),
+    emptyStomach: z.boolean().openapi({ example: false, description: 'Whether to take on empty stomach' }),
+    instruction: z.string().optional().openapi({ example: '', description: 'Additional instructions' }),
+    unit: z.string().optional().openapi({ example: 'St', description: 'Dosage unit' }),
+    bake: z.boolean().openapi({ example: false, description: 'Baking flag (if applicable)' }),
+    id: z.string().openapi({ example: '660079fd11fdc2dd935e43af', description: 'Entry identifier' }),
+}))
+    .openapi({
+    example: [
+        {
+            rrule: {
+                freq: 'DAILY',
+                byweekday: [0, 1, 2, 6, 3],
+                exclude: ['2024-03-28T10:45:00.000Z'],
+            },
+            patient: '614fb1d709dd9f6de85d6374',
+            date: '2024-03-25T00:30:00.000Z',
+            timeCategory: 'noon',
+            amount: 1,
+            emptyStomach: false,
+            instruction: '',
+            unit: 'St',
+            bake: false,
+            id: '660079fd11fdc2dd935e43af',
+        },
+        // ...other items
+    ],
+    description: 'Array of updated time entries by ID',
+});

package/dist/src/users/users.service.js

@@ -0,0 +1,295 @@
+// @ts-nocheck
+import httpStatus from "http-status";
+import { User } from "./users.model.js";
+import ApiError from "../utils/ApiError.js";
+import auth0Service from "../accounts/auth0.service";
+import organizationsService from "../organizations/organizations.service";
+import { sendEmail } from "../email/email.service";
+import i18n from "../i18n/i18n";
+let updateTimesByIdHook = null;
+export const setUpdateTimesByIdHook = (hook) => {
+    updateTimesByIdHook = hook ?? null;
+};
+/**
+ * Create a new user
+ */
+export const createUser = async (userBody) => {
+    return User.create(userBody);
+};
+/**
+ * Create the “current” user (alias of createUser)
+ */
+export const createCurrentUser = async (userBody) => {
+    return createUser(userBody);
+};
+/**
+ * Populate a single Auth0 user
+ */
+const populateAuth0User = async (user) => {
+    if (!user)
+        return undefined;
+    const auth0users = await auth0Service.getUsersByIds([user.owner]);
+    return auth0users?.data?.find((u) => u.user_id === user.owner);
+};
+/**
+ * Populate many Auth0 users
+ */
+const populateAuth0Users = async (data) => {
+    const owners = data.map((u) => u.owner);
+    const auth0users = await auth0Service.getUsersByIds(owners);
+    if (!auth0users)
+        return data;
+    return data.map((doc) => ({
+        ...doc.toJSON(),
+        auth0User: auth0users?.data?.find((u) => u.user_id === doc.owner),
+    }));
+};
+/**
+ * Query for users with pagination + Auth0 enrichment
+ */
+export const queryUsers = async (filter, options) => {
+    const result = await User.paginate(filter, options);
+    result.results = await populateAuth0Users(result.results);
+    return result;
+};
+/**
+ * Get user by Mongo _id
+ */
+export const getById = async (id) => {
+    return User.findById(id);
+};
+/**
+ * Get user by _id with Auth0 info
+ */
+export const getByIdWithAuth0 = async (id) => {
+    const user = await getById(id);
+    if (!user)
+        return null;
+    const auth0User = await populateAuth0User(user);
+    const json = user.toJSON();
+    json.auth0User = auth0User;
+    return json;
+};
+/**
+ * Get all users in a given category (and optional organization)
+ */
+export const getUsersByCategory = async (category, organization) => {
+    const filter = { category };
+    if (organization)
+        filter.organization = organization;
+    return User.find(filter);
+};
+/**
+ * Get all users for an organization
+ */
+export const getUsersByOrganization = async (organization) => {
+    return User.find({ organization }).lean();
+};
+/**
+ * Get one user by organization + userId
+ */
+export const getUsersByOrganizationAndId = async (organization, userId) => {
+    return User.findOne({ organization, _id: userId }).lean();
+};
+/**
+ * Get all users for a given owner
+ */
+export const getUsersByOwner = async (owner) => {
+    return User.find({ owner });
+};
+/**
+ * Get single user by owner + organization, with Auth0 info
+ */
+export const getUserByOwner = async (owner, organization) => {
+    const user = await User.findOne({ owner, organization });
+    if (!user)
+        return null;
+    const auth0User = await populateAuth0User(user);
+    const json = user.toJSON();
+    json.auth0User = auth0User;
+    return json;
+};
+/**
+ * Get user by email
+ */
+export const getUserByEmail = async (email) => {
+    return User.findOne({ email });
+};
+/**
+ * Send an invite email
+ */
+export const sendInviteEmail = async (params) => {
+    const { auth, user, inviteCode, email } = params;
+    const organization = await organizationsService.getOrganizationById(user.organization);
+    const auth0User = await auth0Service.getUserById(auth.sub);
+    const lng = auth0User.data?.app_metadata?.language;
+    const title = `${i18n.t("Invite to ", { lng })}${organization.kind === "private-wirewire" ? "paperlesspaper" : "ANABOX smart"}`;
+    const body = i18n.t("You have been invited to join the group. Click on the link to accept the invitation.", { lng });
+    await sendEmail({
+        title,
+        body,
+        url: `/${user.organization}/invite/${inviteCode}`,
+        actionButtonText: "Accept invite",
+        domain: organization.kind === "private-wirewire" ? "web" : "memo",
+        email,
+    });
+};
+/**
+ * Update a user by ID
+ */
+export const updateUserById = async (userId, updateBody, auth) => {
+    const user = await getById(userId);
+    if (!user) {
+        throw new ApiError(httpStatus.NOT_FOUND, `User not found: ${userId}`);
+    }
+    if (user.status === "invited") {
+        await sendInviteEmail({
+            auth,
+            user,
+            inviteCode: user.inviteCode,
+            email: updateBody.email,
+        });
+    }
+    //TODO: restrict fields that can be updated, temporarily excluding role
+    const { role, ...updateBodyRest } = updateBody;
+    const meta = { ...user.meta, ...updateBodyRest.meta };
+    Object.assign(user, { ...updateBodyRest, meta });
+    await user.save();
+    return user;
+};
+/**
+ * Delete a user by ID
+ */
+export const deleteUserById = async (userId) => {
+    const user = await getById(userId);
+    if (!user) {
+        throw new ApiError(httpStatus.NOT_FOUND, `User not found: ${userId}`);
+    }
+    if (user.role === "admin") {
+        const admins = await User.find({
+            organization: user.organization,
+            role: "admin",
+        });
+        if (admins.length < 2) {
+            throw new ApiError(httpStatus.BAD_REQUEST, "At least one admin is required");
+        }
+    }
+    await user.deleteOne();
+    return user;
+};
+/**
+ * (Misnamed) delete a user’s image by ID
+ */
+export const userImageById = async (userId) => {
+    const user = await getById(userId);
+    if (!user) {
+        throw new ApiError(httpStatus.NOT_FOUND, `User not found: ${userId}`);
+    }
+    await user.deleteOne();
+    return user;
+};
+/**
+ * Invite a user to an organization
+ */
+export const organizationInvite = async (body, oldUser, status = "invited") => {
+    const user = await getById(oldUser.id);
+    if (!user)
+        throw new ApiError(httpStatus.NOT_FOUND, "User not found");
+    if (user.organizations.some((o) => o.id.equals(body.organizationId))) {
+        throw new ApiError(httpStatus.BAD_REQUEST, "Invite already exists");
+    }
+    user.organizations.push({ id: body.organizationId, role: body.role, status });
+    await user.save();
+    return user;
+};
+/**
+ * Get an invite by code
+ */
+export const getInvite = async (params) => {
+    return User.findOne({
+        inviteCode: params.inviteCode,
+        owner: { $exists: false },
+    }).populate("organizationData");
+};
+/**
+ * Accept or decline an invite
+ */
+export const updateInvite = async (params) => {
+    const user = await User.findOne({
+        inviteCode: params.inviteCode,
+        owner: { $exists: false },
+    });
+    if (!user)
+        throw new ApiError(httpStatus.NOT_FOUND, "Invite not found");
+    user.status = params.status;
+    user.owner = params.owner;
+    user.inviteCode = null;
+    await user.save();
+    return user;
+};
+/**
+ * Update a user's organization membership (placeholder for legacy callers)
+ */
+export const organizationUpdate = async (_body) => {
+    throw new ApiError(httpStatus.NOT_IMPLEMENTED, "organizationUpdate not implemented");
+};
+/**
+ * Remove a user from an organization
+ */
+export const organizationRemove = async (body) => {
+    const user = await getById(body.userId);
+    if (!user)
+        throw new ApiError(httpStatus.NOT_FOUND, "User not found");
+    user.organizations = user.organizations.filter((o) => !o.id.equals(body.organizationId));
+    await user.save();
+    return user;
+};
+/**
+ * Fetch up to 100k users with organization populated
+ */
+export const queryAllCalendars = async () => {
+    return User.find({}, null, { limit: 100000 }).populate("organizationData");
+};
+/**
+ * Delete many users by ID list
+ */
+export const deleteMany = async (idList) => {
+    return User.deleteMany({ _id: { $in: idList } });
+};
+/**
+ * Update times for a user by ID (hooked from memo-api)
+ */
+export const updateTimesById = async (userId, updateBody, dryRun = true) => {
+    if (!updateTimesByIdHook) {
+        throw new ApiError(httpStatus.NOT_IMPLEMENTED, "updateTimesById not configured");
+    }
+    return updateTimesByIdHook(userId, updateBody, dryRun);
+};
+export default {
+    createUser,
+    createCurrentUser,
+    getById,
+    getByIdWithAuth0,
+    getUsersByCategory,
+    getUsersByOrganization,
+    getUsersByOrganizationAndId,
+    getUsersByOwner,
+    getUserByEmail,
+    getUserByOwner,
+    sendInviteEmail,
+    updateUserById,
+    updateTimesById,
+    deleteUserById,
+    userImageById,
+    organizationInvite,
+    getInvite,
+    updateInvite,
+    organizationUpdate,
+    organizationRemove,
+    queryUsers,
+    queryAllCalendars,
+    deleteMany,
+    sendEmail,
+    populateAuth0User,
+    populateAuth0Users,
+};

package/dist/src/users/users.types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/users/users.validation.js

@@ -0,0 +1,144 @@
+// @ts-nocheck
+import { z } from "zod";
+import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";
+import { password } from "../validations/custom.validation.js";
+import { zPagination, zGet, zObjectId, zObjectIdFor, zPatchBody, zUpdate, zDelete, } from "../utils/zValidations.js";
+extendZodWithOpenApi(z);
+export const createUserSchema = {
+    body: z.object({
+        meta: z
+            .record(z.any())
+            .optional()
+            .openapi({
+            example: { key: "value" },
+            description: "Additional metadata for the user",
+        }),
+        organization: zObjectId.openapi({
+            description: "Organization ObjectId",
+        }),
+        email: z.string().email().optional().nullable().openapi({
+            example: "user@example.com",
+            description: "User email address",
+        }),
+        timezone: z.string().optional().openapi({
+            example: "Europe/Berlin",
+            description: "IANA timezone string",
+        }),
+        role: z.enum(["user", "admin", "patient", "onlyself"]).optional().openapi({
+            description: "Role assigned to the user",
+        }),
+        category: z
+            .enum(["doctor", "nurse", "patient", "pharmacist", "relative"])
+            .optional()
+            .openapi({
+            description: "Category of the user",
+        }),
+    }),
+};
+export const createCurrentUserSchema = createUserSchema;
+export const queryUsersSchema = {
+    ...zPagination,
+    query: zPagination.query.extend({
+        organization: zObjectIdFor("organization").openapi({
+            description: "Filter users by organization ObjectId",
+            example: process.env.SCHEMA_EXAMPLE_ORGANIZATION_ID ||
+                "60c72b2f9b1e8d001c8e4f3a",
+        }),
+    }),
+};
+export const getUserSchema = zGet("userId");
+export const getCurrentUserSchema = {
+    query: z.object({
+        organization: zObjectId,
+    }),
+};
+export const updateUserSchema = {
+    ...zUpdate("userId"),
+    body: zPatchBody({
+        password: z
+            .string()
+            .refine((val) => {
+            try {
+                password(val);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }, { message: "Invalid password format" })
+            .optional()
+            .openapi({ description: "New user password" }),
+        name: z.string().optional().openapi({ description: "User full name" }),
+        timezone: z.string().optional().openapi({ description: "IANA timezone" }),
+        avatar: z.string().optional().openapi({ description: "Avatar URL" }),
+        meta: z
+            .record(z.any())
+            .optional()
+            .openapi({ description: "Additional metadata" }),
+        category: z
+            .enum(["doctor", "nurse", "patient", "pharmacist", "relative"])
+            .optional()
+            .openapi({ description: "User category" }),
+        email: z
+            .string()
+            .email()
+            .nullable()
+            .optional()
+            .openapi({ description: "User email address" }),
+        role: z
+            .enum(["user", "admin", "patient", "onlyself"])
+            .optional()
+            .openapi({ description: "User role" }),
+        inviteCode: z.string().optional().openapi({ description: "Invite code" }),
+        organization: zObjectId
+            .optional()
+            .openapi({ description: "Organization ObjectId" }),
+    }),
+};
+export const deleteUserSchema = zDelete("userId");
+export const organizationInviteSchema = {
+    body: z.object({
+        organizationId: zObjectId.openapi({ description: "Organization ObjectId" }),
+        action: z.string().optional().openapi({ description: "Invite action" }),
+        role: z.string().optional().openapi({ description: "Role on invite" }),
+    }),
+};
+export const updateInviteSchema = {
+    body: z.object({
+        organization: zObjectId.openapi({ description: "Organization ObjectId" }),
+        status: z.enum(["accepted"]).openapi({ description: "Invite status" }),
+        inviteCode: z.string().optional().openapi({ description: "Invite code" }),
+    }),
+};
+export const organizationRemoveSchema = {
+    body: z.object({
+        userId: zObjectId.openapi({ description: "User ObjectId" }),
+        organizationId: zObjectId.openapi({ description: "Organization ObjectId" }),
+    }),
+};
+export const updateTimesByIdSchema = {
+    ...zUpdate("userId"),
+    body: z
+        .object({})
+        .catchall(z.string())
+        .openapi({
+        description: "Arbitrary key/value map of intake times",
+        example: {
+            "intake-morning": "10:00",
+            "intake-noon": "",
+            "intake-afternoon": "",
+            "intake-night": "15:00",
+        },
+    }),
+};
+export const updateTimesByIdSchemas = {
+    // if you need a path param, uncomment and adjust:
+    // ...zUpdate('timeId'),
+    ...updateTimesByIdSchema,
+};
+export const validateGetInviteSchema = {
+    params: z.object({
+        inviteCode: z.string().openapi({ description: "Invite code to validate" }),
+    }),
+};
+export const sendVerificationEmailValidationSchema = {};

package/dist/src/utils/ApiError.js

@@ -0,0 +1,16 @@
+// @ts-nocheck
+export class ApiError extends Error {
+    constructor(statusCode, message, isOperational = true, stack = "", raw = null) {
+        super(message);
+        this.statusCode = statusCode;
+        this.isOperational = isOperational;
+        this.raw = raw;
+        if (stack) {
+            this.stack = stack;
+        }
+        else {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+export default ApiError;

package/dist/src/utils/buildRouterAndDocs.js

@@ -0,0 +1,72 @@
+import { registry } 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";
+extendZodWithOpenApi(z);
+const roleValidatorNames = ["validateAiRole", "validateAdmin"];
+function hasRoleValidation(validators = []) {
+    return validators.some((fn) => roleValidatorNames.includes(fn.name));
+}
+export default function buildAiRouterAndDocs(router, routeSpecs, basePath = "/", tags = []) {
+    routeSpecs.forEach((spec) => {
+        // mount Express
+        if (!spec.validate) {
+            spec.validate = [];
+        }
+        if (spec.requestSchema) {
+            spec.validateWithRequestSchema = [
+                validateZod(spec.requestSchema),
+                ...spec.validate,
+            ];
+        }
+        if (spec.validateWithRequestSchema) {
+            router[spec.method](spec.path, ...spec.validateWithRequestSchema, spec.handler);
+        }
+        var { body, ...rest } = spec.requestSchema || {};
+        if (body) {
+            rest.body = {
+                content: {
+                    "application/json": {
+                        schema: body,
+                    },
+                },
+            };
+        }
+        console.log("spec.requestScbn");
+        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 openApiPath = (basePath + spec.path).replace(/:([A-Za-z0-9_]+)/g, "{$1}");
+            registry.registerPath({
+                method: spec.method,
+                path: openApiPath,
+                summary: spec.summary,
+                request: rest,
+                // append middleware names to the description
+                description: [
+                    spec.description,
+                    `\n\nMiddlewares: ${middlewareNames.join(", ")}`,
+                ]
+                    .filter(Boolean)
+                    .join("\n"),
+                // (optionally) expose them as a custom extension instead:
+                "x-middlewares": middlewareNames,
+                security: [{ [bearerAuth.name]: [] }, { [xApiKey.name]: [] }],
+                responses: {
+                    200: {
+                        description: "Object with user data.",
+                        content: {
+                            "application/json": { schema: spec.responseSchema },
+                        },
+                    },
+                },
+                tags,
+            });
+        }
+        // else: streaming endpoint, we don’t register it in OpenAPI
+    });
+}

package/dist/src/utils/catchAsync.js

@@ -0,0 +1,4 @@
+const catchAsync = (fn) => (req, res, next) => {
+    Promise.resolve(fn(req, res, next)).catch((err) => next(err));
+};
+export default catchAsync;

package/dist/src/utils/comparePapers.service.js

@@ -0,0 +1,32 @@
+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, imgBuffer2) {
+    // 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 };