@internetderdinge/api 1.229.0 → 1.229.2

package/dist/src/models/plugins/paginateNew.plugin.js

@@ -0,0 +1,185 @@
+// @ts-nocheck
+/* eslint-disable no-param-reassign */
+import mongoose from "mongoose";
+const paginate = (schema) => {
+    /**
+     * Query for documents with pagination
+     * @param {Object} [filter] - Mongo filter
+     * @param {PaginateOptions} [options] - Query options
+     * @returns {Promise<QueryResult>}
+     */
+    schema.statics.paginate = async function (filter = {}, options = {}, plugin) {
+        // Parse sorting options
+        const sort = options.sortBy
+            ? options.sortBy
+                .split(",")
+                .reduce((acc, sortOption) => {
+                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;
+        const skip = (page - 1) * limit;
+        // Build aggregation pipeline
+        const pipeline = [];
+        let mainMatch = {};
+        let virtualMatch = {};
+        let hasVirtualFields = false;
+        // Helper function to determine if a path is a virtual field
+        const isVirtualField = (path) => {
+            const rootPath = path.split(".")[0];
+            return !!schema.virtuals[rootPath];
+        };
+        // Separate filter into main collection fields and virtual fields
+        if (filter) {
+            const separateFilter = (filterObj) => {
+                const main = {};
+                const virtual = {};
+                for (const key in filterObj) {
+                    if (filterObj.hasOwnProperty(key)) {
+                        if (key === "$or" || key === "$and") {
+                            const mainArray = [];
+                            const virtualArray = [];
+                            filterObj[key].forEach((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 (mainArray.length > 0)
+                                main[key] = mainArray;
+                            if (virtualArray.length > 0)
+                                virtual[key] = virtualArray;
+                        }
+                        else {
+                            if (isVirtualField(key)) {
+                                virtual[key] = filterObj[key];
+                                hasVirtualFields = true;
+                            }
+                            else {
+                                main[key] = filterObj[key];
+                            }
+                        }
+                    }
+                }
+                return { main, virtual };
+            };
+            const { main, virtual } = separateFilter(filter);
+            mainMatch = main;
+            virtualMatch = virtual;
+        }
+        // Add main collection $match stage
+        if (Object.keys(mainMatch).length > 0) {
+            pipeline.push({ $match: mainMatch });
+        }
+        // Handle virtual fields population
+        if (options.populate) {
+            options.populate.split(",").forEach((populateOption) => {
+                const paths = populateOption.split(".");
+                const localField = paths[0];
+                const virtual = schema.virtuals[localField];
+                if (!virtual) {
+                    throw new Error(`Cannot populate unknown field: ${localField}`);
+                }
+                const refModel = virtual.options.ref;
+                const localFieldOption = virtual.options.localField;
+                const foreignFieldOption = virtual.options.foreignField;
+                const asField = localField;
+                const lookupStage = {
+                    $lookup: {
+                        from: mongoose.model(refModel).collection.name,
+                        localField: localFieldOption,
+                        foreignField: foreignFieldOption,
+                        as: asField,
+                    },
+                };
+                pipeline.push(lookupStage);
+                if (virtual.options.justOne) {
+                    pipeline.push({
+                        $unwind: {
+                            path: `$${asField}`,
+                            preserveNullAndEmptyArrays: true,
+                        },
+                    });
+                }
+                // Add $addFields stage to rename nested _id to id in populated documents
+                pipeline.push({
+                    $addFields: {
+                        [`${asField}.id`]: `$${asField}._id`,
+                    },
+                });
+                pipeline.push({
+                    $project: {
+                        [`${asField}._id`]: 0,
+                    },
+                });
+            });
+        }
+        // Add virtual fields $match stage
+        if (hasVirtualFields && Object.keys(virtualMatch).length > 0) {
+            pipeline.push({ $match: virtualMatch });
+        }
+        // Handle fuzzy search (if applicable)
+        if (this.fuzzySearch && options.fuzzySearch) {
+            throw new Error("Fuzzy search is not supported with aggregation in this paginate function.");
+        }
+        // Add sorting, skipping, and limiting stages
+        pipeline.push({ $sort: sort });
+        pipeline.push({ $skip: skip });
+        pipeline.push({ $limit: limit });
+        // Rename root _id to id
+        pipeline.push({
+            $addFields: {
+                id: "$_id",
+            },
+        });
+        pipeline.push({
+            $project: {
+                _id: 0,
+            },
+        });
+        // Use $facet to get both the results and the total count
+        const facetPipeline = [
+            {
+                $facet: {
+                    metadata: [
+                        {
+                            $count: "totalResults",
+                        },
+                    ],
+                    data: pipeline,
+                },
+            },
+            {
+                $addFields: {
+                    totalResults: { $arrayElemAt: ["$metadata.totalResults", 0] },
+                },
+            },
+        ];
+        // Execute the aggregation pipeline
+        const aggResult = await this.aggregate(facetPipeline).exec();
+        // Extract results and total count
+        let totalResults = 0;
+        let results = [];
+        if (aggResult && aggResult.length > 0) {
+            totalResults = aggResult[0].totalResults || 0;
+            results = aggResult[0].data || [];
+        }
+        const totalPages = Math.ceil(totalResults / limit) || 1;
+        return {
+            results,
+            page,
+            limit,
+            totalPages,
+            totalResults,
+        };
+    };
+};
+export default paginate;

package/dist/src/models/plugins/simplePopulate.js

@@ -0,0 +1,16 @@
+function simplePopulate(populate) {
+    let docsPromise = {};
+    populate.split(",").forEach((populateOption) => {
+        docsPromise = populateOption
+            .split(".")
+            .reverse()
+            .reduce((acc, key) => {
+            if (Object.keys(acc).length === 0) {
+                return { path: key };
+            }
+            return { path: key, populate: acc };
+        }, {});
+    });
+    return docsPromise;
+}
+export default simplePopulate;

package/dist/src/models/plugins/toJSON.plugin.js

@@ -0,0 +1,35 @@
+/* eslint-disable no-param-reassign */
+const deleteAtPath = (obj, path, index) => {
+    if (index === path.length - 1) {
+        delete obj[path[index]];
+        return;
+    }
+    deleteAtPath(obj[path[index]], path, index + 1);
+};
+const toJSON = (schema, timestamps = false) => {
+    let transform;
+    if (schema.options.toJSON && schema.options.toJSON.transform) {
+        transform = schema.options.toJSON.transform;
+    }
+    schema.options.toJSON = {
+        ...schema.options.toJSON,
+        transform(doc, ret, options) {
+            Object.keys(schema.paths).forEach((path) => {
+                if (schema.paths[path].options && schema.paths[path].options.private) {
+                    deleteAtPath(ret, path.split("."), 0);
+                }
+            });
+            ret.id = ret._id.toString();
+            delete ret._id;
+            delete ret.__v;
+            if (!timestamps) {
+                delete ret.createdAt;
+                delete ret.updatedAt;
+            }
+            if (transform) {
+                return transform(doc, ret, options);
+            }
+        },
+    };
+};
+export default toJSON;

package/dist/src/organizations/organizations.controller.js

@@ -0,0 +1,64 @@
+import httpStatus from "http-status";
+import pick from "../utils/pick.js";
+import ApiError from "../utils/ApiError.js";
+import catchAsync from "../utils/catchAsync.js";
+import usersService from "../users/users.service";
+import organizationsService, { deleteOrganizationById, } from "./organizations.service.js";
+import mongoose from "mongoose";
+import { filterOptions } from "../utils/filterOptions.js";
+const ObjectId = mongoose.Types.ObjectId;
+export const createOrganization = catchAsync(async (req, res) => {
+    const organization = await organizationsService.createOrganization(req.body);
+    const user = await usersService.createUser({
+        organization: organization._id,
+        owner: res.req.auth.sub,
+        role: "admin",
+        category: "relative",
+        status: "accept",
+    });
+    res.status(httpStatus.CREATED).send(organization);
+});
+export const getOrganizations = catchAsync(async (req, res) => {
+    const filter = pick(req.query, ["name", "kind"]);
+    const options = pick(req.query, ["sortBy", "limit", "page"]);
+    console.log("getOrganizations", req.query, filter, options);
+    const filteredOptions = filterOptions(req.query, filter, {
+        objectIds: ["_id", "patient"],
+        search: ["name", "kind"],
+    });
+    const optionsPopulate = {
+        ...options,
+        // fuzzySearch: req.query.search ? { search: req.query.search, fields: ['name', 'kind'] } : undefined,
+        populate: "usersData,devicesData",
+    };
+    const result = await organizationsService.queryOrganizations(filteredOptions, optionsPopulate);
+    res.send(result);
+});
+export const queryOrganizationsByUser = catchAsync(async (req, res) => {
+    const users = await usersService.getUsersByOwner(res.req.auth.sub);
+    const result = await organizationsService.queryOrganizationsByUser(users);
+    res.send(result);
+});
+export const getOrganizationById = catchAsync(async (req, res) => {
+    const organization = await organizationsService.getOrganizationById(req.params.organizationId);
+    if (!organization) {
+        throw new ApiError(httpStatus.NOT_FOUND, "Organization not found");
+    }
+    res.send(organization);
+});
+export const updateOrganization = catchAsync(async (req, res) => {
+    const user = await organizationsService.updateOrganizationById(req.params.organizationId, req.body);
+    res.send(user);
+});
+export const deleteOrganization = catchAsync(async (req, res) => {
+    const entry = await deleteOrganizationById(req.params.organizationId);
+    res.send(entry);
+});
+export default {
+    createOrganization,
+    getOrganizations,
+    queryOrganizationsByUser,
+    getOrganizationById,
+    updateOrganization,
+    deleteOrganization,
+};

package/dist/src/organizations/organizations.model.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import mongoose, { Schema } from "mongoose";
+import { toJSON, paginate } from "../models/plugins/index.js";
+// Define the schema
+const organizationSchema = new Schema({
+    name: {
+        type: String,
+        trim: true,
+        // required: true,
+    },
+    meta: { type: Object },
+    kind: { type: String },
+}, {
+    timestamps: true,
+    toObject: {
+        virtuals: true,
+    },
+    toJSON: {
+        virtuals: true,
+    },
+});
+// Virtuals
+organizationSchema.virtual("usersData", {
+    ref: "User",
+    localField: "_id",
+    foreignField: "organization",
+    justOne: false,
+});
+organizationSchema.virtual("devicesData", {
+    ref: "Device",
+    localField: "_id",
+    foreignField: "organization",
+    justOne: false,
+});
+// Add plugins
+organizationSchema.plugin(toJSON);
+organizationSchema.plugin(paginate);
+// Define the model
+const Organization = mongoose.models.Organization ||
+    mongoose.model("Organization", organizationSchema);
+export default Organization;

package/dist/src/organizations/organizations.route.js

@@ -0,0 +1,98 @@
+import { Router } from "express";
+import buildRouterAndDocs from "../utils/buildRouterAndDocs.js";
+import { createOrganizationSchema, updateOrganizationSchema, getOrganizationByIdSchema, queryOrganizationsSchema, } from "./organizations.validation.js";
+import { organizationResponseSchema } from "./organizations.schemas.js";
+import { createOrganization, getOrganizations, queryOrganizationsByUser, getOrganizationById, updateOrganization, deleteOrganization, } from "./organizations.controller.js";
+import auth from "../middlewares/auth.js";
+import { validateAdmin } from "../middlewares/validateAdmin.js";
+import { validateOrganization } from "../middlewares/validateOrganization.js";
+import { validateOrganizationDelete, validateOrganizationUpdate, } from "../middlewares/validateAction.js";
+export const organizationsRouteSpecs = [
+    {
+        method: "post",
+        path: "/",
+        validate: [auth("manageUsers")],
+        requestSchema: createOrganizationSchema,
+        responseSchema: organizationResponseSchema,
+        handler: createOrganization,
+        summary: "Create a new organization",
+        description: "Creates a new organization with the provided details.",
+    },
+    {
+        method: "get",
+        path: "/",
+        validate: [auth("getUsers")],
+        requestSchema: {},
+        responseSchema: organizationResponseSchema.array(),
+        handler: queryOrganizationsByUser,
+        summary: "Get all organizations",
+        description: "Retrieves all organizations accessible to the current user.",
+    },
+    {
+        method: "get",
+        path: "/all",
+        validate: [auth("getUsers"), validateAdmin],
+        requestSchema: queryOrganizationsSchema,
+        responseSchema: organizationResponseSchema.array(),
+        handler: getOrganizations,
+        summary: "Get all organizations",
+        description: "Retrieves all organizations in the system.",
+    },
+    {
+        method: "get",
+        path: "/:organizationId",
+        validate: [auth("getUsers"), validateOrganization],
+        requestSchema: getOrganizationByIdSchema,
+        responseSchema: organizationResponseSchema,
+        handler: getOrganizationById,
+        summary: "Get an organization by ID",
+        description: "Retrieves the details of a specific organization by its ID.",
+    },
+    {
+        method: "patch",
+        path: "/:organizationId",
+        validate: [
+            auth("manageUsers"),
+            validateOrganization,
+            validateOrganizationUpdate,
+        ],
+        requestSchema: updateOrganizationSchema,
+        responseSchema: organizationResponseSchema,
+        handler: updateOrganization,
+        summary: "Update an organization by ID",
+        description: "Updates the details of a specific organization by its ID.",
+    },
+    {
+        method: "post",
+        path: "/:organizationId",
+        validate: [
+            auth("manageUsers"),
+            validateOrganization,
+            validateOrganizationUpdate,
+        ],
+        requestSchema: updateOrganizationSchema,
+        responseSchema: organizationResponseSchema,
+        handler: updateOrganization,
+        summary: "Update an organization by ID",
+        description: "Updates the details of a specific organization by its ID.",
+    },
+    {
+        method: "delete",
+        path: "/:organizationId",
+        validate: [
+            auth("manageUsers"),
+            validateOrganization,
+            validateOrganizationDelete,
+        ],
+        requestSchema: getOrganizationByIdSchema,
+        responseSchema: organizationResponseSchema,
+        handler: deleteOrganization,
+        summary: "Delete an organization by ID",
+        description: "Deletes a specific organization by its ID.",
+    },
+];
+const router = Router();
+buildRouterAndDocs(router, organizationsRouteSpecs, "/organizations", [
+    "Organizations",
+]);
+export default router;

package/dist/src/organizations/organizations.schemas.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export const organizationResponseSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    email: z.string().email(),
+    kind: z.string().optional(),
+});

package/dist/src/organizations/organizations.service.js

@@ -0,0 +1,59 @@
+// @ts-nocheck
+import httpStatus from "http-status";
+import Organization from "./organizations.model.js";
+import ApiError from "../utils/ApiError.js";
+const createOrganization = async (organizationBody) => {
+    const organization = await Organization.create(organizationBody);
+    return organization;
+};
+const queryOrganizations = async (filter, options) => {
+    const organizations = await Organization.paginate(filter, options);
+    return organizations;
+};
+const queryOrganizationsByUser = async (organizationsList) => {
+    if (!organizationsList)
+        return false;
+    const organizationIds = organizationsList
+        .map((e) => e.organization)
+        .filter((id) => Boolean(id));
+    const organizations = await Organization.paginate({
+        _id: { $in: organizationIds },
+    }, {});
+    return organizations;
+};
+export const getOrganizationById = async (id) => {
+    return Organization.findById(id);
+};
+export const getOrganizationByEmail = async (email) => {
+    return Organization.findOne({ email });
+};
+const updateOrganizationById = async (organizationId, updateBody) => {
+    const organization = await getOrganizationById(organizationId);
+    if (!organization) {
+        throw new ApiError(httpStatus.NOT_FOUND, "Organization not found");
+    }
+    // Legacy: Remove organization field if present in updateBody
+    if ("organization" in updateBody) {
+        delete updateBody.organization;
+    }
+    Object.assign(organization, updateBody);
+    await organization.save();
+    return organization;
+};
+export const deleteOrganizationById = async (organizationId) => {
+    const organization = await getOrganizationById(organizationId);
+    if (!organization) {
+        throw new ApiError(httpStatus.NOT_FOUND, "Organization not found");
+    }
+    await organization.deleteOne();
+    return organization;
+};
+export default {
+    createOrganization,
+    queryOrganizations,
+    getOrganizationById,
+    queryOrganizationsByUser,
+    getOrganizationByEmail,
+    updateOrganizationById,
+    deleteOrganizationById,
+};

package/dist/src/organizations/organizations.validation.js

@@ -0,0 +1,62 @@
+import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";
+import { z } from "zod";
+import { zPagination, zGet, zObjectId, zUpdate, zDelete, } from "../utils/zValidations.js";
+extendZodWithOpenApi(z);
+export const createOrganizationSchema = {
+    body: z.object({
+        /*  name: z.string().openapi({
+          example: 'Acme Inc.',
+          description: 'The name of the organization',
+        }),
+        email: z.string().email().openapi({
+          example: 'contact@acme.com',
+          description: 'Contact email for the organization',
+        }), */
+        kind: z.string().openapi({
+            example: "private",
+            description: "The type or category of the organization",
+        }),
+    }),
+};
+export const queryOrganizationsSchema = zPagination;
+export const getOrganizationByIdSchema = zGet("organizationId");
+export const updateOrganizationSchema = {
+    ...zUpdate("organizationId"),
+    body: z.object({
+        name: z
+            .string()
+            .openapi({
+            example: "Acme Inc.",
+            description: "The name of the organization",
+        })
+            .optional(),
+        organization: zObjectId, // Legacy field, to be removed later
+        kind: z
+            .string()
+            .openapi({
+            example: "private",
+            description: "The type or category of the organization",
+        })
+            .optional(),
+        meta: z
+            .record(z.string(), z.any())
+            .openapi({
+            example: { key: "value" },
+            description: "Additional metadata for the entry",
+        })
+            .optional(),
+    }),
+    //...zUpdate('organizationId'),
+    /* body: z.object({
+      meta: z.any,
+      /* organization: zObjectId,
+      kind: z
+        .string()
+        .openapi({
+          example: 'private',
+          description: 'The type or category of the organization',
+        })
+        .optional(),
+    }),*/
+};
+export const deleteOrganizationSchema = zDelete("organizationId");

package/dist/src/pdf/pdf.controller.js

@@ -0,0 +1,24 @@
+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({ urlPath, token });
+    res.status(httpStatus.CREATED).send({ signed: result });
+});
+export default {
+    generatePdfFromUrl,
+};

package/dist/src/pdf/pdf.route.js

@@ -0,0 +1,22 @@
+import { Router } from "express";
+import buildRouterAndDocs from "../utils/buildRouterAndDocs.js";
+import { generatePdfSchema } from "./pdf.validation.js";
+import { pdfResponseSchema } from "./pdf.schemas.js";
+import { generatePdfFromUrl } from "./pdf.controller.js";
+import auth from "../middlewares/auth.js";
+export const pdfRouteSpecs = [
+    {
+        method: "get",
+        path: "/",
+        validate: [auth("manageUsers")],
+        requestSchema: generatePdfSchema,
+        responseSchema: pdfResponseSchema,
+        handler: generatePdfFromUrl,
+        summary: "Generate a PDF from a provided URL",
+        description: "This endpoint allows users to generate a PDF document from a specified URL.",
+        memoOnly: true,
+    },
+];
+const router = Router();
+buildRouterAndDocs(router, pdfRouteSpecs, "/pdf", ["PDF"]);
+export default router;

package/dist/src/pdf/pdf.schemas.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export const pdfResponseSchema = z.object({
+    url: z.string().url(),
+    filename: z.string(),
+    size: z.number(),
+});