@internetderdinge/api 1.229.0 → 1.229.2

package/dist/src/pdf/pdf.service.js

@@ -0,0 +1,65 @@
+import puppeteer from "puppeteer";
+import { v4 as uuidv4 } from "uuid";
+import AWS from "aws-sdk";
+import path from "path";
+// Configure AWS SDK
+const s3 = new AWS.S3({
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+    region: process.env.AWS_REGION,
+});
+// Function to upload a file to S3
+const uploadBuffer = async (buffer, fileName) => {
+    const params = {
+        Bucket: process.env.AWS_S3_BUCKET_NAME,
+        Key: fileName,
+        Body: buffer,
+        ContentType: "application/pdf",
+        ACL: "private",
+    };
+    const data = await s3.upload(params).promise();
+    return data.Location;
+};
+// Generate a signed URL
+const generateSignedUrl = (fileName) => {
+    const params = {
+        Bucket: process.env.AWS_S3_BUCKET_NAME,
+        Key: fileName,
+        Expires: 60 * 60, // URL expiration time in seconds
+    };
+    return s3.getSignedUrl("getObject", params);
+};
+const generatePdfFromUrl = async ({ urlPath, token, }) => {
+    const domain = process.env.FRONTEND_URL;
+    const browser = await puppeteer.launch({
+        defaultViewport: {
+            width: 1300,
+            height: 1200,
+            deviceScaleFactor: 1,
+        },
+        executablePath: process.env.CHROME_BIN,
+        args: ["--no-sandbox"],
+    });
+    const page = await browser.newPage();
+    await page.goto(domain);
+    // Set the token in local storage
+    await page.evaluate((token) => {
+        localStorage.setItem("print-token", token);
+    }, token);
+    await page.goto(domain + urlPath, { waitUntil: "networkidle2" });
+    await page.waitForSelector(".pdf-render-complete");
+    const pdf = await page.pdf({ format: "A4", printBackground: true });
+    await page.evaluate(() => {
+        localStorage.setItem("print-token", "");
+    });
+    await browser.close();
+    const fileUrl = await uploadBuffer(Buffer.from(pdf), `download-${uuidv4()}.pdf`);
+    console.log(`File uploaded successfully. File URL: ${fileUrl}`);
+    const fileName = path.basename(fileUrl);
+    const signedUrl = generateSignedUrl(fileName);
+    console.log(`Signed URL: ${signedUrl}`);
+    return signedUrl;
+};
+export default {
+    generatePdfFromUrl,
+};

package/dist/src/pdf/pdf.validation.js

@@ -0,0 +1,27 @@
+import { extendZodWithOpenApi } from '@asteasolutions/zod-to-openapi';
+import { z } from 'zod';
+extendZodWithOpenApi(z);
+export const generatePdfSchema = {
+    query: z.object({
+        urlPath: z
+            .string()
+            /* .url()
+            .refine(
+              (value) =>
+                value.startsWith('https://memo.wirewire.de') ||
+                value.startsWith('https://web.wirewire.de') ||
+                (process.env.NODE_ENV !== 'production' && value.startsWith('http://localhost:3200')),
+              {
+                message:
+                  process.env.NODE_ENV !== 'production'
+                    ? 'urlPath must start with https://memo.wirewire.de, https://web.wirewire.de, or http://localhost:3200'
+                    : 'urlPath must start with https://memo.wirewire.de or https://web.wirewire.de',
+              }
+            ) */
+            .openapi({
+            example: 'https://memo.wirewire.de/example.pdf',
+            description: 'URL path to the PDF generation endpoint. Allowed domains: https://memo.wirewire.de, https://web.wirewire.de' +
+                (process.env.NODE_ENV !== 'production' ? ', or http://localhost:3200 (dev)' : ''),
+        }),
+    }),
+};

package/dist/src/tokens/tokens.controller.js

@@ -0,0 +1,60 @@
+import httpStatus from "http-status";
+import * as tokensService from "./tokens.service.js";
+import pick from "../utils/pick.js";
+export const getTokens = async (req, res, next) => {
+    const filter = pick({ ...req.query, owner: res.req.auth.sub }, [
+        "name",
+        "role",
+        "owner",
+    ]);
+    const options = pick(req.query, ["sortBy", "limit", "page"]);
+    const result = await tokensService.queryTokens(filter, options);
+    res.send(result);
+};
+// Create a new token
+export const createToken = async (req, res, next) => {
+    try {
+        const tokenData = {
+            ...req.body,
+            owner: res.req.auth.sub, // Always set owner from authenticated user
+        };
+        const token = await tokensService.createToken(tokenData);
+        res.status(httpStatus.CREATED).send(token);
+    }
+    catch (error) {
+        next(error);
+    }
+};
+// Get a token by ID
+export const getToken = async (req, res, next) => {
+    try {
+        const token = await tokensService.getTokenById(req.params.tokenId);
+        if (!token) {
+            res.status(httpStatus.NOT_FOUND).send({ message: "Token not found" });
+            return;
+        }
+        res.send(token);
+    }
+    catch (error) {
+        next(error);
+    }
+};
+// Delete a token by ID
+export const deleteToken = async (req, res, next) => {
+    try {
+        const token = await tokensService.deleteTokenById(req.params.tokenId);
+        if (!token) {
+            res.status(httpStatus.NOT_FOUND).send({ message: "Token not found" });
+            return;
+        }
+        res.status(httpStatus.NO_CONTENT).send();
+    }
+    catch (error) {
+        next(error);
+    }
+};
+export default {
+    createToken,
+    getToken,
+    deleteToken,
+};

package/dist/src/tokens/tokens.model.js

@@ -0,0 +1,17 @@
+// @ts-nocheck
+import mongoose, { Schema } from "mongoose";
+import { toJSON, paginate } from "../models/plugins/index.js";
+const tokenSchema = new mongoose.Schema({
+    name: { type: String, required: true, trim: true },
+    value: { type: String, required: true, select: false }, // Store hash only
+    owner: { type: String, required: true, index: true, trim: true },
+    expiresAt: { type: Date, required: false, index: true },
+    usedAt: { type: Date, required: false, index: true },
+    meta: { type: Schema.Types.Mixed, required: false },
+}, {
+    timestamps: true,
+});
+tokenSchema.plugin(toJSON, true);
+tokenSchema.plugin(paginate);
+const Token = mongoose.models.Token || mongoose.model("Token", tokenSchema);
+export default Token;

package/dist/src/tokens/tokens.route.js

@@ -0,0 +1,52 @@
+import { Router } from "express";
+import buildRouterAndDocs from "../utils/buildRouterAndDocs.js";
+import { createTokenSchema, getTokenSchema, deleteTokenSchema, } from "./tokens.validation.js";
+import { tokenResponseSchema } from "./tokens.schemas.js";
+import { createToken, getToken, deleteToken, getTokens, } from "./tokens.controller.js";
+import auth from "../middlewares/auth.js";
+import { validateParamsToken } from "../middlewares/validateTokens.js";
+export const tokensRouteSpecs = [
+    {
+        method: "get",
+        path: "/",
+        validate: [auth("manageTokens")],
+        requestSchema: {},
+        responseSchema: tokenResponseSchema,
+        handler: getTokens,
+        privateDocs: true,
+        summary: "List all tokens of the current user",
+    },
+    {
+        method: "post",
+        path: "/",
+        validate: [auth("manageTokens")],
+        requestSchema: createTokenSchema,
+        responseSchema: tokenResponseSchema,
+        handler: createToken,
+        privateDocs: true,
+        summary: "Create a new token",
+    },
+    {
+        method: "get",
+        path: "/:tokenId",
+        validate: [auth("getTokens"), validateParamsToken],
+        requestSchema: getTokenSchema,
+        responseSchema: tokenResponseSchema,
+        handler: getToken,
+        privateDocs: true,
+        summary: "Get a token by ID",
+    },
+    {
+        method: "delete",
+        path: "/:tokenId",
+        validate: [auth("manageTokens"), validateParamsToken],
+        requestSchema: deleteTokenSchema,
+        responseSchema: tokenResponseSchema,
+        handler: deleteToken,
+        privateDocs: true,
+        summary: "Delete a token by ID",
+    },
+];
+const router = Router();
+buildRouterAndDocs(router, tokensRouteSpecs, "/tokens", ["Tokens"]);
+export default router;

package/dist/src/tokens/tokens.schemas.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export const tokenResponseSchema = z.object({
+    // unique identifier of the token
+    tokenId: z.string().uuid(),
+    // the owning user
+    userId: z.string().uuid(),
+    // optional name or description
+    name: z.string().optional(),
+    // the token value (never returned after creation in real-world apps)
+    token: z.string(),
+    // timestamps
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+});

package/dist/src/tokens/tokens.service.js

@@ -0,0 +1,30 @@
+import crypto from "crypto";
+import Token from "./tokens.model.js";
+export const queryTokens = async (filter, options) => {
+    return Token.paginate(filter, options);
+};
+export const createToken = async (tokenData) => {
+    // 1. Generate raw token
+    const rawToken = crypto.randomBytes(32).toString("hex");
+    // 2. Hash the token (e.g., using SHA-256)
+    const hashedToken = crypto
+        .createHash("sha256")
+        .update(rawToken)
+        .digest("hex");
+    const tokenDataHased = {
+        ...tokenData,
+        value: hashedToken,
+    };
+    const newToken = await Token.create(tokenDataHased);
+    return {
+        ...newToken.toObject(),
+        raw: rawToken, // Return the raw token to the user
+    };
+};
+export const getTokenById = async (tokenId) => {
+    return Token.findById(tokenId);
+};
+// Delete a token by ID
+export const deleteTokenById = async (tokenId) => {
+    return Token.findByIdAndDelete(tokenId);
+};

package/dist/src/tokens/tokens.validation.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import { zGet, zDelete } from "../utils/zValidations.js";
+export const createTokenSchema = {
+    body: z.object({
+        name: z.string().openapi({ example: "my sample token" }),
+    }),
+};
+export const getTokenSchema = zGet("tokenId");
+export const deleteTokenSchema = zDelete("tokenId");

package/dist/src/types/routeSpec.js

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

package/dist/src/users/users.controller.js

@@ -0,0 +1,147 @@
+import httpStatus from "http-status";
+import pick from "../utils/pick.js";
+import ApiError from "../utils/ApiError.js";
+import crypto from "crypto";
+import catchAsync from "../utils/catchAsync.js";
+import * as userService from "./users.service.js";
+import * as devicesService from "../devices/devices.service";
+// import userImageUpload from '../files/upload.service';
+import auth0Service from "../accounts/auth0.service";
+export const createUser = catchAsync(async (req, res) => {
+    const { body } = req;
+    if (body.email) {
+        const auth0users = await auth0Service.getUserIdByEmail(body.email);
+        body.status = "invited";
+        body.inviteCode = crypto.randomBytes(48).toString("base64url");
+        if (auth0users[0]) {
+            const userFound = await userService.getUserByOwner(auth0users[0].user_id, body.organization);
+            if (userFound) {
+                throw new ApiError(httpStatus.CONFLICT, "User already added in organization");
+            }
+        }
+    }
+    const user = await userService.createUser(body);
+    if (body.email) {
+        await userService.sendInviteEmail({
+            user,
+            email: body.email,
+            inviteCode: body.inviteCode,
+            auth: req.auth,
+        });
+    }
+    res.status(httpStatus.CREATED).send(user);
+});
+export const createCurrentUser = catchAsync(async (req, res) => {
+    const user = await userService.createUser({ owner: req.auth.sub });
+    res.status(httpStatus.CREATED).send(user);
+});
+export const sendVerificationEmail = catchAsync(async (req, res) => {
+    const result = await auth0Service.sendVerificationEmail(req.auth.sub);
+    res
+        .status(httpStatus.OK)
+        .send({ message: "Verification email sent", status: result?.status });
+});
+export const getUsers = catchAsync(async (req, res) => {
+    // console.log('getUsers', req.query);
+    const filter = pick(req.query, ["name", "role"]);
+    const options = pick(req.query, ["sortBy", "limit", "page"]);
+    options.fuzzySearch = req.query.search
+        ? {
+            search: req.query.search,
+            index: "users",
+            fields: ["meta.firstName", "meta.lastName"],
+        }
+        : undefined;
+    const result = await userService.queryUsers({ ...filter, organization: req.query.organization }, options);
+    // console.log('getUsers result', req.currentUser);
+    if (req.currentUser?.role &&
+        req.currentUser.role === "onlyself" &&
+        result?.results) {
+        // If the user is onlyself, restrict the results to their own user document
+        result.results = result.results.filter((user) => user.owner === req.auth.sub);
+    }
+    res.send(result);
+});
+export const getCurrentUser = catchAsync(async (req, res) => {
+    const organization = req.query.organization;
+    const result = await userService.getUserByOwner(req.auth.sub, organization);
+    res.send(result);
+});
+export const getUserImage = catchAsync(async (_req, res) => {
+    try {
+        // await userImageUpload.getPhoto(req.query.file, res);
+    }
+    catch (error) {
+        res.status(500).json(`Failed to receive image file: ${error.message}`);
+    }
+});
+export const updateUserImage = catchAsync(async (_req, _res) => {
+    // placeholder for image upload
+});
+export const getUser = catchAsync(async (req, res) => {
+    const user = await userService.getByIdWithAuth0(req.params.userId);
+    if (!user) {
+        throw new ApiError(httpStatus.NOT_FOUND, `User not found ID: ${req.params.userId}`);
+    }
+    res.send(user);
+});
+export const updateUser = catchAsync(async (req, res) => {
+    const authReq = req;
+    const user = await userService.updateUserById(authReq.params.userId, authReq.body, authReq.auth);
+    res.send(user);
+});
+export const deleteUser = catchAsync(async (req, res) => {
+    const devices = await devicesService.getDeviceByUserId(req.params.userId);
+    if (devices) {
+        throw new ApiError(httpStatus.NOT_FOUND, "User still has devices assigned");
+    }
+    const user = await userService.deleteUserById(req.params.userId);
+    res.send(user);
+});
+export const getInvite = catchAsync(async (req, res) => {
+    // console.log('getInvite', req.params.inviteCode);
+    const authReq = req;
+    const user = await userService.getInvite({
+        inviteCode: authReq.params.inviteCode,
+    });
+    if (!user) {
+        throw new ApiError(httpStatus.NOT_FOUND, `User not found token: ${authReq.params.inviteCode}`);
+    }
+    const organizationId = String(user.organization);
+    const already = await userService.getUserByOwner(authReq.auth.sub, organizationId);
+    if (already) {
+        throw new ApiError(httpStatus.CONFLICT, "User already in organization");
+    }
+    res.send(user);
+});
+export const updateInvite = catchAsync(async (req, res) => {
+    const user = await userService.updateInvite({
+        owner: req.auth.sub,
+        ...req.body,
+    });
+    if (!user) {
+        throw new ApiError(httpStatus.NOT_FOUND, "User not found");
+    }
+    res.send(user);
+});
+export const organizationUpdate = catchAsync(async (req, res) => {
+    const user = await userService.organizationUpdate(req.body);
+    res.send(user);
+});
+export const organizationRemove = catchAsync(async (req, res) => {
+    const user = await userService.organizationRemove(req.body);
+    res.send(user);
+});
+export const cleanup = catchAsync(async (_req, res) => {
+    const all = await userService.queryAllCalendars();
+    const filtered = all.filter((e) => e.organizationData === null);
+    const ids = filtered.map((e) => String(e._id));
+    const deleted = await userService.deleteMany(ids);
+    res.send({
+        deleted,
+        ids,
+        filteredCount: filtered.length,
+        totalCount: all.length,
+        filtered,
+    });
+});

package/dist/src/users/users.model.js

@@ -0,0 +1,50 @@
+// @ts-nocheck
+import mongoose, { Schema } from "mongoose";
+import { toJSON, paginate } from "../models/plugins/index.js";
+const userSchema = new Schema({
+    name: { type: String, trim: true },
+    avatar: { type: String },
+    timezone: { type: String, default: "Europe/Berlin" },
+    owner: { type: String },
+    organization: { type: Schema.Types.ObjectId, ref: "User", immutable: true },
+    inviteCode: { type: String },
+    email: { type: String },
+    role: { type: String, default: "patient" /* , enum: Object.keys(roles) */ },
+    category: { type: String, default: "patient" },
+    status: { type: String },
+    meta: { type: Schema.Types.Mixed },
+}, {
+    timestamps: true,
+    toObject: { virtuals: true },
+    toJSON: { virtuals: true },
+});
+userSchema.virtual("organizationData", {
+    ref: "Organization",
+    localField: "organization",
+    foreignField: "_id",
+    justOne: true,
+});
+// plugins
+userSchema.plugin(toJSON);
+userSchema.plugin(paginate);
+/**
+ * Check if email is taken
+ * @param {string} email - The user's email
+ * @param {ObjectId} [excludeUserId] - The id of the user to be excluded
+ * @returns {Promise<boolean>}
+ */
+userSchema.statics.isEmailTaken = async function (email, excludeUserId) {
+    const user = await this.findOne({ email, _id: { $ne: excludeUserId } });
+    return !!user;
+};
+/**
+ * Check if password matches the user's password
+ * @param {string} password
+ * @returns {Promise<boolean>}
+ */
+userSchema.methods.isPasswordMatch = async function (password) {
+    // TODO: implement with bcrypt
+    return false;
+};
+export const User = mongoose.models.User ||
+    mongoose.model("User", userSchema);

package/dist/src/users/users.route.js

@@ -0,0 +1,137 @@
+import { Router } from "express";
+import buildRouterAndDocs from "../utils/buildRouterAndDocs.js";
+import auth from "../middlewares/auth.js";
+import { validateQueryOrganization, validateBodyOrganization, } from "../middlewares/validateOrganization.js";
+import { validateAdmin } from "../middlewares/validateAdmin.js";
+import { createCurrentUserSchema, createUserSchema, deleteUserSchema, updateUserSchema, getUserSchema, getCurrentUserSchema, queryUsersSchema, updateInviteSchema, validateGetInviteSchema, sendVerificationEmailValidationSchema, } from "./users.validation.js";
+import * as userController from "./users.controller.js";
+import { createUserResponseSchema, getUsersResponseSchema, updateUserResponseSchema, deleteUserResponseSchema, } from "./users.schemas.js";
+import { validateParamsUser, } from "../middlewares/validateUser.js";
+export const userRouteSpecs = [
+    {
+        method: "post",
+        path: "/",
+        validate: [auth("manageUsers"), validateBodyOrganization],
+        requestSchema: createUserSchema,
+        responseSchema: createUserResponseSchema,
+        handler: userController.createUser,
+        summary: "Create a new user",
+        description: "Creates a new user within the current organization.",
+        memoOnly: true,
+    },
+    {
+        method: "get",
+        path: "/",
+        validate: [auth("getUsers"), validateQueryOrganization],
+        requestSchema: queryUsersSchema,
+        responseSchema: getUsersResponseSchema,
+        handler: userController.getUsers,
+        summary: "Get a list of users",
+        description: "Retrieves a paginated list of all users in the current organization.",
+    },
+    {
+        method: "get",
+        path: "/cleanup",
+        validate: [auth("cleanup"), validateAdmin],
+        handler: userController.cleanup,
+        summary: "Cleanup user data",
+        description: "Performs cleanup of stale or orphaned user records.",
+    },
+    {
+        method: "post",
+        path: "/current/send-verification-email",
+        validate: [auth("manageUsers")],
+        requestSchema: sendVerificationEmailValidationSchema,
+        responseSchema: getUsersResponseSchema,
+        handler: userController.sendVerificationEmail,
+        summary: "Send verification email to the current user",
+        description: "Sends a new verification email to the authenticated user’s address.",
+        privateDocs: true,
+    },
+    {
+        method: "get",
+        path: "/current",
+        validate: [auth("getUsers"), validateQueryOrganization],
+        requestSchema: getCurrentUserSchema,
+        handler: userController.getCurrentUser,
+        summary: "Get the current user",
+        description: "Fetches details about the currently authenticated user.",
+    },
+    {
+        method: "post",
+        path: "/current",
+        validate: [auth("manageUsers")],
+        requestSchema: createCurrentUserSchema,
+        responseSchema: createUserResponseSchema,
+        handler: userController.createCurrentUser,
+        privateDocs: true,
+        summary: "Create the current user",
+        description: "Creates or initializes a profile for the authenticated user.",
+    },
+    {
+        method: "get",
+        path: "/invite/:inviteCode",
+        validate: [auth("getUsers")],
+        requestSchema: validateGetInviteSchema,
+        responseSchema: getUsersResponseSchema,
+        handler: userController.getInvite,
+        privateDocs: true,
+        summary: "Get invite details by code",
+        description: "Retrieves information about a pending invite using its code.",
+    },
+    {
+        method: "post",
+        path: "/invite",
+        validate: [auth("getUsers")],
+        requestSchema: updateInviteSchema,
+        handler: userController.updateInvite,
+        privateDocs: true,
+        summary: "Update invite details",
+        description: "Modifies the details or status of an existing invite.",
+    },
+    {
+        method: "get",
+        path: "/:userId",
+        validate: [auth("getUsers"), validateParamsUser],
+        requestSchema: getUserSchema,
+        responseSchema: getUsersResponseSchema,
+        handler: userController.getUser,
+        summary: "Get a user by ID",
+        description: "Fetches a single user’s details by their unique ID.",
+    },
+    {
+        method: "post",
+        path: "/:userId",
+        validate: [auth("manageUsers"), validateParamsUser],
+        requestSchema: updateUserSchema,
+        responseSchema: updateUserResponseSchema,
+        handler: userController.updateUser,
+        summary: "Update a user by ID",
+        description: "Replaces a user’s full record with the provided data.",
+        memoOnly: true,
+    },
+    {
+        method: "patch",
+        path: "/:userId",
+        validate: [auth("manageUsers"), validateParamsUser],
+        requestSchema: updateUserSchema,
+        responseSchema: updateUserResponseSchema,
+        handler: userController.updateUser,
+        summary: "Partially update a user by ID",
+        description: "Applies partial updates to a user’s record by ID.",
+        memoOnly: true,
+    },
+    {
+        method: "delete",
+        path: "/:userId",
+        validate: [auth("manageUsers"), validateParamsUser],
+        requestSchema: deleteUserSchema,
+        responseSchema: deleteUserResponseSchema,
+        handler: userController.deleteUser,
+        summary: "Delete a user by ID",
+        description: "Removes a user from the system by their unique ID.",
+    },
+];
+const router = Router();
+buildRouterAndDocs(router, userRouteSpecs, "/users", ["Users"]);
+export default router;