@internetderdinge/api 1.224.2

package/src/models/plugins/paginateNew.plugin.ts

@@ -0,0 +1,206 @@
+/* eslint-disable no-param-reassign */
+import mongoose from 'mongoose';
+import type { Schema, Document, Model, PipelineStage } from 'mongoose';
+import type { PaginateOptions, QueryResult } from './types';
+
+const paginate = (schema: Schema): void => {
+  /**
+   * Query for documents with pagination
+   * @param {Object} [filter] - Mongo filter
+   * @param {PaginateOptions} [options] - Query options
+   * @returns {Promise<QueryResult>}
+   */
+  schema.statics.paginate = async function (
+    filter: Record<string, any> = {},
+    options: PaginateOptions = {},
+    plugin?: any,
+  ): Promise<QueryResult> {
+    // Parse sorting options
+    const sort = options.sortBy
+      ? options.sortBy.split(',').reduce((acc: Record<string, number>, sortOption: string) => {
+          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: PipelineStage[] = [];
+
+    let mainMatch: Record<string, any> = {};
+    let virtualMatch: Record<string, any> = {};
+    let hasVirtualFields = false;
+
+    // Helper function to determine if a path is a virtual field
+    const isVirtualField = (path: string): boolean => {
+      const rootPath = path.split('.')[0];
+      return !!schema.virtuals[rootPath];
+    };
+
+    // Separate filter into main collection fields and virtual fields
+    if (filter) {
+      const separateFilter = (filterObj: Record<string, any>) => {
+        const main: Record<string, any> = {};
+        const virtual: Record<string, any> = {};
+
+        for (const key in filterObj) {
+          if (filterObj.hasOwnProperty(key)) {
+            if (key === '$or' || key === '$and') {
+              const mainArray: Record<string, any>[] = [];
+              const virtualArray: Record<string, any>[] = [];
+
+              filterObj[key].forEach((item: Record<string, any>) => {
+                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: string) => {
+        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: PipelineStage.Lookup = {
+          $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: PipelineStage[] = [
+      {
+        $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: any[] = [];
+
+    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/src/models/plugins/simplePopulate.ts

@@ -0,0 +1,12 @@
+function simplePopulate(populate: string): Record<string, any> {
+  let docsPromise: Record<string, any> = {};
+  populate.split(',').forEach((populateOption) => {
+    docsPromise = populateOption
+      .split('.')
+      .reverse()
+      .reduce((a, b) => ({ path: b, populate: a }));
+  });
+  return docsPromise;
+}
+
+export default simplePopulate;

package/src/models/plugins/toJSON.plugin.ts

@@ -0,0 +1,51 @@
+/* eslint-disable no-param-reassign */
+
+/**
+ * A mongoose schema plugin which applies the following in the toJSON transform call:
+ *  - removes __v, createdAt, updatedAt, and any path that has private: true
+ *  - replaces _id with id
+ */
+
+import type { Schema, Document } from 'mongoose';
+
+const deleteAtPath = (obj: Record<string, any>, path: string[], index: number): void => {
+  if (index === path.length - 1) {
+    delete obj[path[index]];
+    return;
+  }
+  deleteAtPath(obj[path[index]], path, index + 1);
+};
+
+const toJSON = (schema: Schema, timestamps: boolean = false): void => {
+  let transform: ((doc: Document, ret: Record<string, any>, options: any) => any) | undefined;
+
+  if (schema.options.toJSON && schema.options.toJSON.transform) {
+    transform = schema.options.toJSON.transform;
+  }
+
+  schema.options.toJSON = {
+    ...schema.options.toJSON,
+    transform(doc: Document, ret: Record<string, any>, options: any): any {
+      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/src/organizations/organizations.controller.ts

@@ -0,0 +1,101 @@
+import express from "express";
+const { Request, Response } = express;
+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: Request, res: Response): Promise<void> => {
+    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: Request, res: Response): Promise<void> => {
+    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: Request, res: Response): Promise<void> => {
+    const users = await usersService.getUsersByOwner(res.req.auth.sub);
+    const result = await organizationsService.queryOrganizationsByUser(users);
+    res.send(result);
+  },
+);
+
+export const getOrganizationById = catchAsync(
+  async (req: Request, res: Response): Promise<void> => {
+    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: Request, res: Response): Promise<void> => {
+    const user = await organizationsService.updateOrganizationById(
+      req.params.organizationId,
+      req.body,
+    );
+    res.send(user);
+  },
+);
+
+export const deleteOrganization = catchAsync(
+  async (req: Request, res: Response): Promise<void> => {
+    const entry = await deleteOrganizationById(req.params.organizationId);
+    res.send(entry);
+  },
+);
+
+export default {
+  createOrganization,
+  getOrganizations,
+  queryOrganizationsByUser,
+  getOrganizationById,
+  updateOrganization,
+  deleteOrganization,
+};

package/src/organizations/organizations.model.ts

@@ -0,0 +1,62 @@
+import mongoose, { Schema, Document, Model } from "mongoose";
+import { toJSON, paginate } from "../models/plugins/index.js";
+
+// Define the interface for the Organization document
+export interface IOrganization extends Document {
+  name: string;
+  meta?: Record<string, any>;
+  kind?: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+  usersData?: mongoose.Types.ObjectId[];
+  devicesData?: mongoose.Types.ObjectId[];
+}
+
+// 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: Model<IOrganization> = mongoose.model<IOrganization>(
+  "Organization",
+  organizationSchema,
+);
+
+export default Organization;

package/src/organizations/organizations.route.ts

@@ -0,0 +1,119 @@
+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 type { RouteSpec } from "../types/routeSpec";
+import { validateAdmin } from "../middlewares/validateAdmin.js";
+import { validateOrganization } from "../middlewares/validateOrganization.js";
+import {
+  validateOrganizationDelete,
+  validateOrganizationUpdate,
+} from "../middlewares/validateAction.js";
+import { request } from "http";
+
+export const organizationsRouteSpecs: RouteSpec[] = [
+  {
+    method: "post",
+    path: "/",
+    validate: [auth("manageUsers")],
+    requestSchema: createOrganizationSchema,
+    responseSchema: {},
+    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 = Router();
+
+buildRouterAndDocs(router, organizationsRouteSpecs, "/organizations", [
+  "Organizations",
+]);
+
+export default router;

package/src/organizations/organizations.schemas.ts

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

package/src/organizations/organizations.service.ts

@@ -0,0 +1,85 @@
+import httpStatus from "http-status";
+import { ObjectId } from "mongoose";
+import Organization from "./organizations.model.js";
+import type { IOrganization, QueryResult } from "./organizations.model.js";
+import ApiError from "../utils/ApiError.js";
+
+const createOrganization = async (
+  organizationBody: Partial<IOrganization>,
+): Promise<IOrganization> => {
+  const organization = await Organization.create(organizationBody);
+  return organization;
+};
+
+const queryOrganizations = async (
+  filter: Record<string, any>,
+  options: { sortBy?: string; limit?: number; page?: number },
+): Promise<QueryResult> => {
+  const organizations = await Organization.paginate(filter, options);
+  return organizations;
+};
+
+const queryOrganizationsByUser = async (
+  organizationsList: Array<{ organization: ObjectId }>,
+): Promise<QueryResult | false> => {
+  if (!organizationsList) return false;
+  const organizationIds = organizationsList.map((e) => e.organization);
+  const organizations = await Organization.paginate(
+    {
+      _id: { $in: organizationIds },
+    },
+    {},
+  );
+  return organizations;
+};
+
+export const getOrganizationById = async (
+  id: ObjectId,
+): Promise<IOrganization | null> => {
+  return Organization.findById(id);
+};
+
+export const getOrganizationByEmail = async (
+  email: string,
+): Promise<IOrganization | null> => {
+  return Organization.findOne({ email });
+};
+
+const updateOrganizationById = async (
+  organizationId: ObjectId,
+  updateBody: Partial<IOrganization>,
+): Promise<IOrganization> => {
+  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: ObjectId,
+): Promise<IOrganization> => {
+  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,
+};