@internetderdinge/api 1.224.2 → 1.229.1

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

@@ -1,7 +1,8 @@
+// @ts-nocheck
 /* eslint-disable no-param-reassign */
-import mongoose from 'mongoose';
-import type { Schema, Document, Model, PipelineStage } from 'mongoose';
-import type { PaginateOptions, QueryResult } from './types';
+import mongoose from "mongoose";
+import type { Schema, Document, Model, PipelineStage } from "mongoose";
+import type { PaginateOptions, QueryResult } from "./paginate.plugin.js";
 
 const paginate = (schema: Schema): void => {
   /**
@@ -14,19 +15,26 @@ const paginate = (schema: Schema): void => {
     filter: Record<string, any> = {},
     options: PaginateOptions = {},
     plugin?: any,
-  ): Promise<QueryResult> {
+  ): Promise<QueryResult<any>> {
     // 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;
-        }, {})
+      ? 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;
+      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
@@ -38,7 +46,7 @@ const paginate = (schema: Schema): void => {
 
     // Helper function to determine if a path is a virtual field
     const isVirtualField = (path: string): boolean => {
-      const rootPath = path.split('.')[0];
+      const rootPath = path.split(".")[0];
       return !!schema.virtuals[rootPath];
     };
 
@@ -50,14 +58,16 @@ const paginate = (schema: Schema): void => {
 
         for (const key in filterObj) {
           if (filterObj.hasOwnProperty(key)) {
-            if (key === '$or' || key === '$and') {
+            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);
+                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 (Object.keys(itemVirtual).length > 0)
+                  virtualArray.push(itemVirtual);
               });
 
               if (mainArray.length > 0) main[key] = mainArray;
@@ -87,8 +97,8 @@ const paginate = (schema: Schema): void => {
 
     // Handle virtual fields population
     if (options.populate) {
-      options.populate.split(',').forEach((populateOption: string) => {
-        const paths = populateOption.split('.');
+      options.populate.split(",").forEach((populateOption: string) => {
+        const paths = populateOption.split(".");
         const localField = paths[0];
         const virtual = schema.virtuals[localField];
         if (!virtual) {
@@ -140,7 +150,9 @@ const paginate = (schema: Schema): void => {
 
     // Handle fuzzy search (if applicable)
     if (this.fuzzySearch && options.fuzzySearch) {
-      throw new Error('Fuzzy search is not supported with aggregation in this paginate function.');
+      throw new Error(
+        "Fuzzy search is not supported with aggregation in this paginate function.",
+      );
     }
 
     // Add sorting, skipping, and limiting stages
@@ -151,7 +163,7 @@ const paginate = (schema: Schema): void => {
     // Rename root _id to id
     pipeline.push({
       $addFields: {
-        id: '$_id',
+        id: "$_id",
       },
     });
     pipeline.push({
@@ -166,7 +178,7 @@ const paginate = (schema: Schema): void => {
         $facet: {
           metadata: [
             {
-              $count: 'totalResults',
+              $count: "totalResults",
             },
           ],
           data: pipeline,
@@ -174,7 +186,7 @@ const paginate = (schema: Schema): void => {
       },
       {
         $addFields: {
-          totalResults: { $arrayElemAt: ['$metadata.totalResults', 0] },
+          totalResults: { $arrayElemAt: ["$metadata.totalResults", 0] },
         },
       },
     ];

package/src/models/plugins/simplePopulate.ts

@@ -1,10 +1,15 @@
 function simplePopulate(populate: string): Record<string, any> {
   let docsPromise: Record<string, any> = {};
-  populate.split(',').forEach((populateOption) => {
+  populate.split(",").forEach((populateOption) => {
     docsPromise = populateOption
-      .split('.')
+      .split(".")
       .reverse()
-      .reduce((a, b) => ({ path: b, populate: a }));
+      .reduce<Record<string, any>>((acc, key) => {
+        if (Object.keys(acc).length === 0) {
+          return { path: key };
+        }
+        return { path: key, populate: acc };
+      }, {});
   });
   return docsPromise;
 }

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

@@ -6,9 +6,14 @@
  *  - replaces _id with id
  */
 
-import type { Schema, Document } from 'mongoose';
-
-const deleteAtPath = (obj: Record<string, any>, path: string[], index: number): void => {
+// @ts-nocheck
+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;
@@ -17,7 +22,9 @@ const deleteAtPath = (obj: Record<string, any>, path: string[], index: number):
 };
 
 const toJSON = (schema: Schema, timestamps: boolean = false): void => {
-  let transform: ((doc: Document, ret: Record<string, any>, options: any) => any) | undefined;
+  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;
@@ -28,7 +35,7 @@ const toJSON = (schema: Schema, timestamps: boolean = false): void => {
     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);
+          deleteAtPath(ret, path.split("."), 0);
         }
       });
 

package/src/organizations/organizations.controller.ts

@@ -1,5 +1,4 @@
-import express from "express";
-const { Request, Response } = express;
+import type { Request, Response } from "express";
 import httpStatus from "http-status";
 import pick from "../utils/pick.js";
 import ApiError from "../utils/ApiError.js";

package/src/organizations/organizations.model.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import mongoose, { Schema, Document, Model } from "mongoose";
 import { toJSON, paginate } from "../models/plugins/index.js";
 
@@ -54,9 +55,8 @@ organizationSchema.plugin(toJSON);
 organizationSchema.plugin(paginate);
 
 // Define the model
-const Organization: Model<IOrganization> = mongoose.model<IOrganization>(
-  "Organization",
-  organizationSchema,
-);
+const Organization: Model<IOrganization> =
+  (mongoose.models.Organization as Model<IOrganization>) ||
+  mongoose.model<IOrganization>("Organization", organizationSchema);
 
 export default Organization;

package/src/organizations/organizations.route.ts

@@ -31,7 +31,7 @@ export const organizationsRouteSpecs: RouteSpec[] = [
     path: "/",
     validate: [auth("manageUsers")],
     requestSchema: createOrganizationSchema,
-    responseSchema: {},
+    responseSchema: organizationResponseSchema,
     handler: createOrganization,
     summary: "Create a new organization",
     description: "Creates a new organization with the provided details.",

package/src/organizations/organizations.service.ts

@@ -1,7 +1,9 @@
+// @ts-nocheck
 import httpStatus from "http-status";
 import { ObjectId } from "mongoose";
 import Organization from "./organizations.model.js";
-import type { IOrganization, QueryResult } from "./organizations.model.js";
+import type { IOrganization } from "./organizations.model.js";
+import type { QueryResult } from "../models/plugins/paginate.plugin.js";
 import ApiError from "../utils/ApiError.js";
 
 const createOrganization = async (
@@ -13,17 +15,24 @@ const createOrganization = async (
 
 const queryOrganizations = async (
   filter: Record<string, any>,
-  options: { sortBy?: string; limit?: number; page?: number },
-): Promise<QueryResult> => {
+  options: {
+    sortBy?: string;
+    limit?: number;
+    page?: number;
+    populate?: string;
+  },
+): Promise<QueryResult<IOrganization>> => {
   const organizations = await Organization.paginate(filter, options);
   return organizations;
 };
 
 const queryOrganizationsByUser = async (
-  organizationsList: Array<{ organization: ObjectId }>,
-): Promise<QueryResult | false> => {
+  organizationsList: Array<{ organization?: ObjectId | null }>,
+): Promise<QueryResult<IOrganization> | false> => {
   if (!organizationsList) return false;
-  const organizationIds = organizationsList.map((e) => e.organization);
+  const organizationIds = organizationsList
+    .map((e) => e.organization)
+    .filter((id): id is ObjectId => Boolean(id));
   const organizations = await Organization.paginate(
     {
       _id: { $in: organizationIds },

package/src/pdf/pdf.controller.ts

@@ -1,14 +1,31 @@
 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({ ...req.query, token });
+  const result = await pdfService.generatePdfFromUrl({ urlPath, token });
 
   res.status(httpStatus.CREATED).send({ signed: result });
 });

package/src/pdf/pdf.service.ts

@@ -1,7 +1,7 @@
-import puppeteer from 'puppeteer';
-import { v4 as uuidv4 } from 'uuid';
-import AWS from 'aws-sdk';
-import path from 'path';
+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({
@@ -11,13 +11,16 @@ const s3 = new AWS.S3({
 });
 
 // Function to upload a file to S3
-const uploadBuffer = async (buffer: Buffer, fileName: string): Promise<string> => {
+const uploadBuffer = async (
+  buffer: Buffer,
+  fileName: string,
+): Promise<string> => {
   const params = {
     Bucket: process.env.AWS_S3_BUCKET_NAME!,
     Key: fileName,
     Body: buffer,
-    ContentType: 'application/pdf',
-    ACL: 'private',
+    ContentType: "application/pdf",
+    ACL: "private",
   };
 
   const data = await s3.upload(params).promise();
@@ -32,7 +35,7 @@ const generateSignedUrl = (fileName: string): string => {
     Expires: 60 * 60, // URL expiration time in seconds
   };
 
-  return s3.getSignedUrl('getObject', params);
+  return s3.getSignedUrl("getObject", params);
 };
 
 interface GeneratePdfOptions {
@@ -40,7 +43,10 @@ interface GeneratePdfOptions {
   token: string;
 }
 
-const generatePdfFromUrl = async ({ urlPath, token }: GeneratePdfOptions): Promise<string> => {
+const generatePdfFromUrl = async ({
+  urlPath,
+  token,
+}: GeneratePdfOptions): Promise<string> => {
   const domain = process.env.FRONTEND_URL!;
   const browser = await puppeteer.launch({
     defaultViewport: {
@@ -49,7 +55,7 @@ const generatePdfFromUrl = async ({ urlPath, token }: GeneratePdfOptions): Promi
       deviceScaleFactor: 1,
     },
     executablePath: process.env.CHROME_BIN,
-    args: ['--no-sandbox'],
+    args: ["--no-sandbox"],
   });
 
   const page = await browser.newPage();
@@ -58,22 +64,25 @@ const generatePdfFromUrl = async ({ urlPath, token }: GeneratePdfOptions): Promi
 
   // Set the token in local storage
   await page.evaluate((token) => {
-    localStorage.setItem('print-token', token);
+    localStorage.setItem("print-token", token);
   }, token);
 
-  await page.goto(domain + urlPath, { waitUntil: 'networkidle2' });
+  await page.goto(domain + urlPath, { waitUntil: "networkidle2" });
 
-  await page.waitForSelector('.pdf-render-complete');
+  await page.waitForSelector(".pdf-render-complete");
 
-  const pdf = await page.pdf({ format: 'A4', printBackground: true });
+  const pdf = await page.pdf({ format: "A4", printBackground: true });
 
   await page.evaluate(() => {
-    localStorage.setItem('print-token', '');
+    localStorage.setItem("print-token", "");
   });
 
   await browser.close();
 
-  const fileUrl = await uploadBuffer(pdf, `download-${uuidv4()}.pdf`);
+  const fileUrl = await uploadBuffer(
+    Buffer.from(pdf),
+    `download-${uuidv4()}.pdf`,
+  );
 
   console.log(`File uploaded successfully. File URL: ${fileUrl}`);
 

package/src/tokens/tokens.controller.ts

@@ -38,16 +38,15 @@ export const createToken = async (
 
 // Get a token by ID
 export const getToken = async (
-  req: Request,
+  req: Request<{ tokenId: string }>,
   res: Response,
   next: NextFunction,
 ): Promise<void> => {
   try {
     const token = await tokensService.getTokenById(req.params.tokenId);
     if (!token) {
-      return res
-        .status(httpStatus.NOT_FOUND)
-        .send({ message: "Token not found" });
+      res.status(httpStatus.NOT_FOUND).send({ message: "Token not found" });
+      return;
     }
     res.send(token);
   } catch (error) {
@@ -57,16 +56,15 @@ export const getToken = async (
 
 // Delete a token by ID
 export const deleteToken = async (
-  req: Request,
+  req: Request<{ tokenId: string }>,
   res: Response,
   next: NextFunction,
 ): Promise<void> => {
   try {
     const token = await tokensService.deleteTokenById(req.params.tokenId);
     if (!token) {
-      return res
-        .status(httpStatus.NOT_FOUND)
-        .send({ message: "Token not found" });
+      res.status(httpStatus.NOT_FOUND).send({ message: "Token not found" });
+      return;
     }
     res.status(httpStatus.NO_CONTENT).send();
   } catch (error) {

package/src/tokens/tokens.model.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import mongoose, { Schema, Model } from "mongoose";
 import crypto from "crypto";
 import { toJSON, paginate } from "../models/plugins/index.js";
@@ -19,6 +20,7 @@ const tokenSchema: Schema = new mongoose.Schema(
 tokenSchema.plugin(toJSON, true);
 tokenSchema.plugin(paginate);
 
-const Token: Model<any> = mongoose.model("Token", tokenSchema);
+const Token: Model<any> =
+  (mongoose.models.Token as Model<any>) || mongoose.model("Token", tokenSchema);
 
 export default Token;

package/src/tokens/tokens.service.ts

@@ -1,12 +1,13 @@
 import crypto from "crypto";
 import type { Document } from "mongoose";
 import Token from "./tokens.model.js";
+import type { QueryResult } from "../models/plugins/paginate.plugin.js";
 
 export const queryTokens = async (
   filter: Record<string, any>,
   options: { sortBy?: string; limit?: number; page?: number },
-): Promise<QueryResult> => {
-  return Token.paginate(filter, options);
+): Promise<QueryResult<any>> => {
+  return (Token as any).paginate(filter, options);
 };
 
 export const createToken = async (

package/src/types/express.d.ts

@@ -0,0 +1,17 @@
+declare global {
+  namespace Express {
+    interface Request {
+      auth?: {
+        sub: string;
+        id?: string;
+        tokenId?: string;
+        type?: string;
+        [key: string]: any;
+      };
+      currentUser?: any;
+      user?: any;
+    }
+  }
+}
+
+export {};

package/src/types/mongoose.d.ts

@@ -0,0 +1,22 @@
+declare module "mongoose" {
+  const mongoose: any;
+  export default mongoose;
+
+  export type ObjectId = any;
+  export type Document = any;
+  export type Model<T = any> = any;
+  export type Schema<T = any> = any;
+  export type Query<T = any> = any;
+  export type FilterQuery<T = any> = any;
+  export type PaginateOptions = any;
+  export type PaginateModel<T = any> = any;
+  export type PipelineStage = any;
+
+  export const Schema: any;
+  export const Types: any;
+  export function model<T = any>(...args: any[]): Model<T>;
+
+  export namespace Types {
+    type ObjectId = any;
+  }
+}

package/src/users/users.controller.ts

@@ -18,13 +18,13 @@ export const createUser = catchAsync(
   async (req: AuthRequest<{}, any, {}>, res: Response) => {
     const { body } = req;
     if (body.email) {
-      const auth0user = await auth0Service.getUserIdByEmail(body.email);
+      const auth0users = await auth0Service.getUserIdByEmail(body.email);
       body.status = "invited";
       body.inviteCode = crypto.randomBytes(48).toString("base64url");
 
-      if (auth0user.data[0]) {
+      if (auth0users[0]) {
         const userFound = await userService.getUserByOwner(
-          auth0user.data[0].user_id,
+          auth0users[0].user_id,
           body.organization,
         );
         if (userFound) {
@@ -101,10 +101,8 @@ export const getCurrentUser = catchAsync(
     req: AuthRequest<{}, any, { organization?: string }>,
     res: Response,
   ) => {
-    const result = await userService.getUserByOwner(
-      req.auth.sub,
-      req.query.organization,
-    );
+    const organization = req.query.organization as string;
+    const result = await userService.getUserByOwner(req.auth.sub, organization);
     res.send(result);
   },
 );
@@ -181,9 +179,10 @@ export const getInvite = catchAsync(
         `User not found token: ${authReq.params.inviteCode}`,
       );
     }
+    const organizationId = String(user.organization);
     const already = await userService.getUserByOwner(
       authReq.auth.sub,
-      user.organization,
+      organizationId,
     );
     if (already) {
       throw new ApiError(httpStatus.CONFLICT, "User already in organization");
@@ -222,7 +221,7 @@ export const organizationRemove = catchAsync(
 export const cleanup = catchAsync(async (_req: Request, res: Response) => {
   const all = await userService.queryAllCalendars();
   const filtered = all.filter((e) => e.organizationData === null);
-  const ids = filtered.map((e) => e._id);
+  const ids = filtered.map((e) => String(e._id));
   const deleted = await userService.deleteMany(ids);
   res.send({
     deleted,

package/src/users/users.model.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import mongoose, { Schema, Document, Model, Types } from "mongoose";
 import validator from "validator";
 import { toJSON, paginate } from "../models/plugins/index.js";
@@ -9,9 +10,10 @@ export interface IUser {
   timezone: string;
   owner?: string;
   organization?: Types.ObjectId;
+  organizationData?: any;
   inviteCode?: string;
   email?: string;
-  role: keyof typeof roles;
+  role: (typeof roles)[number];
   category: string;
   status?: string;
   meta?: Record<string, any>;
@@ -83,7 +85,6 @@ userSchema.methods.isPasswordMatch = async function (
   return false;
 };
 
-export const User = mongoose.model<IUserDocument, IUserModel>(
-  "User",
-  userSchema,
-);
+export const User =
+  (mongoose.models.User as IUserModel) ||
+  mongoose.model<IUserDocument, IUserModel>("User", userSchema);

package/src/users/users.route.ts

@@ -108,7 +108,6 @@ export const userRouteSpecs: RouteSpec[] = [
     privateDocs: true,
     summary: "Get invite details by code",
     description: "Retrieves information about a pending invite using its code.",
-    privateDocs: true,
   },
   {
     method: "post",

package/src/users/users.service.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import httpStatus from "http-status";
 import type { FilterQuery, PaginateOptions } from "mongoose";
 import { User } from "./users.model.js";
@@ -315,6 +316,18 @@ export const updateInvite = async (params: {
   return user;
 };
 
+/**
+ * Update a user's organization membership (placeholder for legacy callers)
+ */
+export const organizationUpdate = async (
+  _body: any,
+): Promise<IUserDocument> => {
+  throw new ApiError(
+    httpStatus.NOT_IMPLEMENTED,
+    "organizationUpdate not implemented",
+  );
+};
+
 /**
  * Remove a user from an organization
  */
@@ -383,6 +396,7 @@ export default {
   organizationInvite,
   getInvite,
   updateInvite,
+  organizationUpdate,
   organizationRemove,
   queryUsers,
   queryAllCalendars,
@@ -391,3 +405,5 @@ export default {
   populateAuth0User,
   populateAuth0Users,
 };
+
+export type UserService = typeof import("./users.service");

package/src/users/users.types.ts

@@ -0,0 +1 @@
+export type User = any;

package/src/users/users.validation.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { z } from "zod";
 import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";
 import { objectId, password } from "../validations/custom.validation.js";
@@ -5,6 +6,7 @@ import {
   zPagination,
   zGet,
   zObjectId,
+  zObjectIdFor,
   zPatchBody,
   zUpdate,
   zDelete,
@@ -49,9 +51,11 @@ export const createCurrentUserSchema = createUserSchema;
 export const queryUsersSchema = {
   ...zPagination,
   query: zPagination.query.extend({
-    organization: zObjectId.optional().openapi({
+    organization: zObjectIdFor("organization").openapi({
       description: "Filter users by organization ObjectId",
-      example: "60c72b2f9b1e8d001c8e4f3a",
+      example:
+        process.env.SCHEMA_EXAMPLE_ORGANIZATION_ID ||
+        "60c72b2f9b1e8d001c8e4f3a",
     }),
   }),
 };