@internetderdinge/api 1.229.0 → 1.229.2

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",
     }),
   }),
 };

package/src/utils/ApiError.ts

@@ -1,8 +1,15 @@
+// @ts-nocheck
 export class ApiError extends Error {
   statusCode: number;
   isOperational: boolean;
 
-  constructor(statusCode: number, message: string, isOperational = true, stack = '', raw: any = null) {
+  constructor(
+    statusCode: number,
+    message: string,
+    isOperational = true,
+    stack = "",
+    raw: any = null,
+  ) {
     super(message);
     this.statusCode = statusCode;
     this.isOperational = isOperational;

package/src/utils/buildRouterAndDocs.ts

@@ -1,28 +1,40 @@
-import { registry } from '../utils/registerOpenApi';
+import type { RequestHandler, Router } from "express";
+import { registry } from "../utils/registerOpenApi";
 
-import { validateZod } from '../middlewares/validateZod';
-import { bearerAuth, xApiKey } 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';
+import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";
+import { z } from "zod";
+import type { ZodTypeAny } from "zod";
 
 extendZodWithOpenApi(z);
 
-const roleValidatorNames = ['validateAiRole', 'validateAdmin'];
+const roleValidatorNames = ["validateAiRole", "validateAdmin"];
 function hasRoleValidation(validators: Function[] = []): boolean {
   return validators.some((fn) => roleValidatorNames.includes(fn.name));
 }
 
 export type RouteSpec = {
-  method: 'post';
+  method: "get" | "post" | "put" | "patch" | "delete" | "options" | "head";
   path: string;
-  requestBody: AnyZodObject;
-  responseSchema?: AnyZodObject;
-  handler: RequestHandler;
+  validate?: RequestHandler<any, any, any, any, any>[];
+  validateWithRequestSchema?: RequestHandler<any, any, any, any, any>[];
+  requestSchema?: Partial<Record<string, ZodTypeAny>>;
+  responseSchema?: ZodTypeAny;
+  handler: RequestHandler<any, any, any, any, any>;
   summary: string;
+  description?: string;
+  privateDocs?: boolean;
+  memoOnly?: boolean;
 };
 
-export default function buildAiRouterAndDocs(router: Router, routeSpecs: any, basePath = '/', tags: string[] = []) {
+export default function buildAiRouterAndDocs(
+  router: Router,
+  routeSpecs: any,
+  basePath = "/",
+  tags: string[] = [],
+) {
   routeSpecs.forEach((spec) => {
     // mount Express
 
@@ -31,11 +43,18 @@ export default function buildAiRouterAndDocs(router: Router, routeSpecs: any, ba
     }
 
     if (spec.requestSchema) {
-      spec.validateWithRequestSchema = [validateZod(spec.requestSchema), ...spec.validate];
+      spec.validateWithRequestSchema = [
+        validateZod(spec.requestSchema),
+        ...spec.validate,
+      ];
     }
 
     if (spec.validateWithRequestSchema) {
-      router[spec.method](spec.path, ...spec.validateWithRequestSchema, spec.handler);
+      router[spec.method](
+        spec.path,
+        ...spec.validateWithRequestSchema,
+        spec.handler,
+      );
     }
 
     var { body, ...rest } = spec.requestSchema || {};
@@ -43,37 +62,53 @@ export default function buildAiRouterAndDocs(router: Router, routeSpecs: any, ba
     if (body) {
       rest.body = {
         content: {
-          'application/json': {
+          "application/json": {
             schema: body,
           },
         },
       };
     }
 
-    // console.log('spec.requestSchema', body);
+    console.log("spec.requestScbn");
 
-    if (spec.responseSchema && !hasRoleValidation(spec.validate) && spec.privateDocs !== true && spec.memoOnly !== true) {
+    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 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: basePath + spec.path,
+        path: openApiPath,
         summary: spec.summary,
         request: rest,
 
         // append middleware names to the description
-        description: [spec.description, `\n\nMiddlewares: ${middlewareNames.join(', ')}`].filter(Boolean).join('\n'),
+        description: [
+          spec.description,
+          `\n\nMiddlewares: ${middlewareNames.join(", ")}`,
+        ]
+          .filter(Boolean)
+          .join("\n"),
 
         // (optionally) expose them as a custom extension instead:
-        'x-middlewares': middlewareNames,
+        "x-middlewares": middlewareNames,
 
         security: [{ [bearerAuth.name]: [] }, { [xApiKey.name]: [] }],
         responses: {
           200: {
-            description: 'Object with user data.',
+            description: "Object with user data.",
             content: {
-              'application/json': { schema: spec.responseSchema },
+              "application/json": { schema: spec.responseSchema },
             },
           },
         },

package/src/utils/catchAsync.ts

@@ -1,8 +1,32 @@
-import type { Request, Response, NextFunction } from 'express';
+import type { Request, Response, NextFunction } from "express";
+
+type AsyncRequestHandler<
+  P = any,
+  ResBody = any,
+  ReqBody = any,
+  ReqQuery = any,
+  Locals extends Record<string, any> = Record<string, any>,
+> = (
+  req: Request<P, ResBody, ReqBody, ReqQuery, Locals>,
+  res: Response<ResBody, Locals>,
+  next: NextFunction,
+) => Promise<any>;
 
 const catchAsync =
-  (fn: (req: Request, res: Response, next: NextFunction) => Promise<any>) =>
-  (req: Request, res: Response, next: NextFunction): void => {
+  <
+    P = any,
+    ResBody = any,
+    ReqBody = any,
+    ReqQuery = any,
+    Locals extends Record<string, any> = Record<string, any>,
+  >(
+    fn: AsyncRequestHandler<P, ResBody, ReqBody, ReqQuery, Locals>,
+  ) =>
+  (
+    req: Request<P, ResBody, ReqBody, ReqQuery, Locals>,
+    res: Response<ResBody, Locals>,
+    next: NextFunction,
+  ): void => {
     Promise.resolve(fn(req, res, next)).catch((err) => next(err));
   };
 

package/src/utils/medicationName.ts

@@ -1,12 +1,13 @@
-import i18n from '../i18n/i18n';
-import type { MedicationEntry } from '../types/MedicationEntry';
+// @ts-nocheck
+import i18n from "../i18n/i18n";
+import type { MedicationEntry } from "../types/MedicationEntry";
 
 export const medicationName = (entry: MedicationEntry, lng: string): string => {
   const name = entry.medicationData?.Kurzname
     ? entry.medicationData.Kurzname
     : entry.localMedicationData?.meta?.name
-      ? entry.localMedicationData.meta.name.replace(/ .*/, '')
-      : i18n.t('A medication', { lng });
+      ? entry.localMedicationData.meta.name.replace(/ .*/, "")
+      : i18n.t("A medication", { lng });
 
   return name;
 };

package/src/utils/pick.ts

@@ -4,7 +4,11 @@
  * @param {string[]} keys - The keys to pick
  * @returns {Partial<Record<string, any>>} - The new object with picked properties
  */
-const pick = <T extends Record<string, any>>(object: T, keys: (keyof T)[]): Partial<T> => {
+// @ts-nocheck
+const pick = <T extends Record<string, any>>(
+  object: T,
+  keys: string[],
+): Partial<T> => {
   return keys.reduce((obj, key) => {
     if (object && Object.prototype.hasOwnProperty.call(object, key)) {
       obj[key] = object[key];

package/src/utils/registerOpenApi.ts

@@ -1,32 +1,83 @@
-import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import { OpenAPIRegistry } from "@asteasolutions/zod-to-openapi";
+import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";
+import { z } from "zod";
+
+extendZodWithOpenApi(z);
 
 export const registry = new OpenAPIRegistry();
 
 // add Bearer JWT auth
-export const bearerAuth = registry.registerComponent('securitySchemes', 'bearerAuth', {
-  type: 'http',
-  scheme: 'bearer',
-  bearerFormat: 'JWT',
-  description: 'JWT Bearer authentication',
-});
+export const bearerAuth = registry.registerComponent(
+  "securitySchemes",
+  "bearerAuth",
+  {
+    type: "http",
+    scheme: "bearer",
+    bearerFormat: "JWT",
+    description: "JWT Bearer authentication",
+  },
+);
+
+export const xApiKey = registry.registerComponent(
+  "securitySchemes",
+  "x-api-key",
+  {
+    type: "apiKey",
+    in: "header",
+    name: "x-api-key",
+    description: "API key for authentication",
+  },
+);
+
+const UserSchema = z
+  .object({
+    id: z.string().openapi({ example: "1212121" }),
+    name: z.string().openapi({ example: "John Doe" }),
+    age: z.number().openapi({ example: 42 }),
+  })
+  .openapi("User");
+
+registry.registerPath({
+  method: "get",
+  path: "/usersnnn/{id}",
+  summary: "Get a single user",
+  request: {
+    params: z.object({ id: z.string() }),
+  },
 
-export const xApiKey = registry.registerComponent('securitySchemes', 'x-api-key', {
-  type: 'apiKey',
-  in: 'header',
-  name: 'x-api-key',
-  description: 'API key for authentication',
+  responses: {
+    200: {
+      description: "Object with user data.",
+      content: {
+        "application/json": {
+          schema: UserSchema,
+        },
+      },
+    },
+  },
 });
 
-/*
-registry.registerComponent('global', 'wwww', [
-  { name: 'ai', description: 'All AI-powered endpoints.' },
-  { name: 'auth', description: 'Authentication and authorization.' },
-  { name: 'Users', description: 'User management (create, read, update, delete).' },
-  // add more as needed
-]);
-
-registry.registerComponent('tag', 'users', {
-  name: 'users',
-  description: 'Operations about users',
+registry.registerPath({
+  method: "get",
+  path: "/users/{id}",
+  description: "Get user data by its id",
+  summary: "Get a single user",
+  request: {
+    params: z.object({
+      id: z.string().openapi({ example: "1212121" }),
+    }),
+  },
+  responses: {
+    200: {
+      description: "Object with user data.",
+      content: {
+        "application/json": {
+          schema: UserSchema,
+        },
+      },
+    },
+    204: {
+      description: "No content - successful operation",
+    },
+  },
 });
-*/

package/src/utils/userName.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { getUserById } from "../accounts/auth0.service";
 import type { Patient } from "../types/patient"; // Assuming a `Patient` type exists in your project