@jumentix/cli-init 0.0.0

package/templates/backend/src/interface/HTTP/ports/BaseController.ts

@@ -0,0 +1,110 @@
+import { _INFRA_NOT_IMPLEMENTED_ } from '@src/config/constants';
+import type { IAuthService } from '@src/modules/Users/service/ports/IAuthService';
+import type { IControllerFactory } from '@src/interface/HTTP/ports/IControllerFactory';
+import type { IDatabaseClient } from '@src/infra/persistence/port/IDatabaseClient';
+import type { IMutexService } from '@src/infra/mutex/port/IMutexService';
+import type { IPasswordCryptoService } from '@src/infra/security/IPasswordCryptoService';
+import type { IMessageMediator } from '@src/modules/port';
+
+export abstract class BaseController {
+  private _authService: IAuthService = {} as IAuthService;
+
+  public _databaseClient: IDatabaseClient = {} as IDatabaseClient;
+
+  private _passwordCryptoService: IPasswordCryptoService = {} as IPasswordCryptoService;
+
+  private _mutexService: IMutexService = {} as IMutexService;
+
+  private _messageMediator: IMessageMediator | undefined;
+
+  public openApiSpecification: any;
+
+  constructor(factory: IControllerFactory) {
+    this.authService = factory.authService;
+
+    this.databaseClient = factory.databaseClient;
+
+    this.openApiSpecification = factory.openApiSpecification;
+
+    if (factory.passwordCryptoService) {
+      this.passwordCryptoService = factory.passwordCryptoService;
+    }
+
+    if (factory.mutexService) {
+      this.mutexService = factory.mutexService;
+    }
+
+    if (factory.messageMediator) {
+      this.messageMediator = factory.messageMediator;
+    }
+  }
+
+  public get passwordCryptoService(): IPasswordCryptoService {
+    return this._passwordCryptoService;
+  }
+
+  public set passwordCryptoService(service: IPasswordCryptoService) {
+    if (!service.hash) {
+      const error = new Error('PasswordCryptoService is not implemented');
+      error.name = _INFRA_NOT_IMPLEMENTED_;
+      throw error;
+    }
+    this._passwordCryptoService = service;
+  }
+
+  public get mutexService(): IMutexService {
+    return this._mutexService;
+  }
+
+  public set mutexService(service: IMutexService) {
+    if (!service.lock) {
+      const error = new Error('MutexService is not implemented');
+      error.name = _INFRA_NOT_IMPLEMENTED_;
+      throw error;
+    }
+    this._mutexService = service;
+  }
+
+  public get authService() {
+    return this._authService;
+  }
+
+  public set authService(service: IAuthService) {
+    if (!service.authenticate) {
+      const error = new Error('AuthService is not implemented');
+      error.name = _INFRA_NOT_IMPLEMENTED_;
+      throw error;
+    }
+    this._authService = service;
+  }
+
+  public get messageMediator(): IMessageMediator | undefined {
+    return this._messageMediator;
+  }
+
+  public set messageMediator(service: IMessageMediator | undefined) {
+    if (!service) {
+      this._messageMediator = undefined;
+      return;
+    }
+    if (!service.request || !service.registerHandler) {
+      const error = new Error('MessageMediator is not implemented');
+      error.name = _INFRA_NOT_IMPLEMENTED_;
+      throw error;
+    }
+    this._messageMediator = service;
+  }
+
+  public get databaseClient() {
+    return this._databaseClient;
+  }
+
+  public set databaseClient(service: IDatabaseClient) {
+    if (!service.stores) {
+      const error = new Error('DatabaseClient is not implemented');
+      error.name = _INFRA_NOT_IMPLEMENTED_;
+      throw error;
+    }
+    this._databaseClient = service;
+  }
+}

package/templates/backend/src/interface/HTTP/ports/EHTTPFrameworks.ts

@@ -0,0 +1,14 @@
+// eslint-disable-next-line no-shadow
+export enum EHTTPFrameworks {
+  express = 'express',
+  fastify = 'fastify',
+  restify = 'restify',
+  cloudflare_workers = 'cloudflare-workers',
+  vercel_functions = 'vercel-functions',
+  loopback = 'loopback',
+  sails_js = 'sails-js',
+  feathers = 'feathers',
+  derby_js = 'derby-js',
+  adonis_js = 'adonis-js',
+  total_js = 'total-js',
+}

package/templates/backend/src/interface/HTTP/ports/EndPointFactory.ts

@@ -0,0 +1,4 @@
+import type { IbaseHandler } from '@src/interface/HTTP/ports/IbaseHandler';
+import type { IHandlerFactory } from './IHandlerFactory';
+
+export type EndPointFactory = (config: IHandlerFactory) => IbaseHandler;

package/templates/backend/src/interface/HTTP/ports/HTTPBaseServer.ts

@@ -0,0 +1,46 @@
+import type { IHTTPServer } from './IHTTPServer';
+import type { IbaseHandler } from './IbaseHandler';
+
+export abstract class HTTPBaseServer<T> implements IHTTPServer<T> {
+  // eslint-disable-next-line no-useless-constructor, no-empty-function
+  // constructor() { }
+
+  /**
+   * Register one endpoint, failing loudly when the framework refuses it.
+   *
+   * This used to swallow every error from the framework's own registration
+   * call. A route that failed to register simply did not exist, and every
+   * request to it came back as the framework's 404 — no log at boot, no failed
+   * assertion until some test asked for that route and got a 404 where it
+   * expected a 403, a 400 or a 200. That is the shape JUM-687 recorded three
+   * times from CI and never explained: "a request that did not reach the
+   * handler the test was aiming at", with no domain error raised anywhere.
+   *
+   * Registration is boot-time work with no user waiting on it, so the only
+   * useful behaviour is to stop: an API that silently serves fewer routes than
+   * its specification declares is worse than one that refuses to start
+   * (Requirement 065).
+   */
+  public endPointRegister(handlerFactory: IbaseHandler): void {
+    try {
+      (this.application as any)[handlerFactory.method](
+        handlerFactory.path,
+        handlerFactory.handler
+      );
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Endpoint registration failed for ${String(handlerFactory.method).toUpperCase()} `
+          + `${handlerFactory.path}: ${reason}`
+      );
+    }
+  }
+
+  public abstract application: T;
+
+  public abstract start(): Promise<void>;
+
+  public abstract stop(): Promise<void>;
+
+  public static compile() {}
+}

package/templates/backend/src/interface/HTTP/ports/IAPIFactory.ts

@@ -0,0 +1,22 @@
+import type { IDatabaseClient } from '@src/infra/persistence/port/IDatabaseClient';
+import type { IHTTPServer, EndPointFactory } from '@src/interface/HTTP/ports';
+import { EHTTPFrameworks } from '@src/interface/HTTP/ports';
+// import { IMutexService } from '@src/domains/ports/mutex/IMutexService';
+import type { IAuthService } from '@src/modules/Users/service/ports/IAuthService';
+import type { IPasswordCryptoService } from '@src/infra/security/IPasswordCryptoService';
+import type { IKeyValueStorageClient } from '@src/infra/persistence/KeyValueStorage/IKeyValueStorageClient';
+import type { IMutexService } from '@src/infra/mutex/port/IMutexService';
+import type { IEventBus, IMessageMediator } from '@src/modules/port';
+
+export interface IAPIFactory<ServerType> {
+  databaseClient: IDatabaseClient,
+  webServer: IHTTPServer<ServerType>,
+  serverType?: EHTTPFrameworks;
+  mutexService?: IMutexService,
+  infraHandlers: Record<string, EndPointFactory>;
+  authService?: IAuthService;
+  passwordCryptoService?: IPasswordCryptoService;
+  keyValueStorageClient?: IKeyValueStorageClient;
+  eventBus?: IEventBus;
+  messageMediator?: IMessageMediator;
+}

package/templates/backend/src/interface/HTTP/ports/IController.ts

@@ -0,0 +1,39 @@
+import { BaseDomainEvent } from '@src/modules/port/BaseDomainEvent';
+import type { IServiceResponse } from '@src/modules/port';
+import type { IAuthService } from '@src/modules/Users/service/ports/IAuthService';
+import type { IDatabaseClient } from '@src/infra/persistence/port/IDatabaseClient';
+
+export interface IController {
+  authService: IAuthService;
+  openApiSpecification: any;
+  databaseClient: IDatabaseClient;
+  create?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  update?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  delete?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  getOneById?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  getAll?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  getUsersMetrics?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  getOrganizationsMetrics?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  login?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  logout?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  register?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  updatePassword?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  createOrganization?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  updateOrganization?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  deleteOrganization?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  getOrganizationById?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  getAllOrganizations?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  createOrganizationAddress?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  updateOrganizationAddress?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  deleteOrganizationAddress?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  createOrganizationPhone?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  updateOrganizationPhone?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  deleteOrganizationPhone?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  createOrganizationEmail?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  updateOrganizationEmail?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  deleteOrganizationEmail?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  restore?(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  // update(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  // create(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+  // create(event: BaseDomainEvent): Promise<IServiceResponse<any>>;
+}

package/templates/backend/src/interface/HTTP/ports/IControllerFactory.ts

@@ -0,0 +1,23 @@
+import type { IAuthService } from '@src/modules/Users/service/ports/IAuthService';
+import { UserService } from '@src/modules/Users/service/UserService';
+import type { IUserUseCases } from '@src/modules/Users/application/ports/IUserUseCases';
+import type { IAuthUseCases } from '@src/modules/Users/application/ports/IAuthUseCases';
+import type { IOrganizationUseCases } from '@src/modules/Users/application/ports/IOrganizationUseCases';
+import type { IMutexService } from '@src/infra/mutex/port/IMutexService';
+import type { IDatabaseClient } from '@src/infra/persistence/port/IDatabaseClient';
+import type { IPasswordCryptoService } from '@src/infra/security/IPasswordCryptoService';
+import type { IMessageMediator } from '@src/modules/port';
+// import { PasswordCryptoService } from '@src/infra/security/PasswordCryptoService';
+
+export interface IControllerFactory {
+  authService: IAuthService;
+  openApiSpecification: any;
+  databaseClient: IDatabaseClient;
+  userService?: UserService;
+  userUseCases?: IUserUseCases;
+  organizationUseCases?: IOrganizationUseCases;
+  authUseCases?: IAuthUseCases;
+  passwordCryptoService?: IPasswordCryptoService,
+  mutexService?: IMutexService;
+  messageMediator?: IMessageMediator;
+}

package/templates/backend/src/interface/HTTP/ports/IHTTPRequest.ts

@@ -0,0 +1,5 @@
+import type { Request } from 'express';
+import type restify from 'restify';
+import type { FastifyRequest } from 'fastify';
+
+export type IHTTPRequest = FastifyRequest | Request | restify.Request;

package/templates/backend/src/interface/HTTP/ports/IHTTPResponse.ts

@@ -0,0 +1,5 @@
+import type { Response } from 'express';
+import type { FastifyReply } from 'fastify';
+import type restify from 'restify';
+
+export type IHTTPResponse = FastifyReply | Response | restify.Response;

package/templates/backend/src/interface/HTTP/ports/IHTTPServer.ts

@@ -0,0 +1,9 @@
+import type { IbaseHandler } from './IbaseHandler';
+
+export interface IHTTPServer<T> {
+  // _application: HTTPServerTypes;
+  endPointRegister (handlerFactory: IbaseHandler): void;
+  application: T;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+}

package/templates/backend/src/interface/HTTP/ports/IHandlerFactory.ts

@@ -0,0 +1,16 @@
+import { OpenAPIV3 } from 'openapi-types';
+import type { IDatabaseClient } from '@src/infra/persistence/port/IDatabaseClient';
+import type { IMutexService } from '@src/infra/mutex/port/IMutexService';
+import type { IAuthService } from '@src/modules/Users/service/ports/IAuthService';
+import type { IController } from './IController';
+
+export interface IHandlerFactory {
+    databaseClient: IDatabaseClient;
+    mutexService?: IMutexService;
+    endPointConfig: Record<string, any>;
+    spec: OpenAPIV3.Document;
+    version?: string;
+    apiDocs?: Map<string, OpenAPIV3.Document>;
+    authService?: IAuthService;
+    controller?: IController;
+}

package/templates/backend/src/interface/HTTP/ports/IbaseHandler.ts

@@ -0,0 +1,9 @@
+import type { IHTTPRequest } from './IHTTPRequest';
+import type { IHTTPResponse } from './IHTTPResponse';
+
+export interface IbaseHandler {
+    method: string;
+    path: string;
+    handler(req: IHTTPRequest, res: IHTTPResponse): void | Promise<any>;
+    securitySchemes?(req: IHTTPRequest, res: IHTTPResponse, next: any): void;
+}

package/templates/backend/src/interface/HTTP/ports/IbaseHandlerFactory.ts

@@ -0,0 +1,8 @@
+import type { IHTTPRequest } from './IHTTPRequest';
+import type { IHTTPResponse } from './IHTTPResponse';
+
+export interface IbaseHandlerFactory {
+    method: string;
+    path: string;
+    handler(req: IHTTPRequest, res: IHTTPResponse): void;
+}

package/templates/backend/src/interface/HTTP/ports/index.ts

@@ -0,0 +1,39 @@
+import { EHTTPFrameworks } from './EHTTPFrameworks';
+import type { EndPointFactory } from './EndPointFactory';
+import { HTTPBaseServer } from './HTTPBaseServer';
+import type { IAPIFactory } from './IAPIFactory';
+import type { IbaseHandler } from './IbaseHandler';
+import type { IbaseHandlerFactory } from './IbaseHandlerFactory';
+import type { IController } from './IController';
+import type { IControllerFactory } from './IControllerFactory';
+import type { IHandlerFactory } from './IHandlerFactory';
+import type { IHTTPRequest } from './IHTTPRequest';
+import type { IHTTPResponse } from './IHTTPResponse';
+import type { IHTTPServer } from './IHTTPServer';
+
+// Split by declaration kind. Everything imported above with `import type` is erased
+// at runtime, so listing it in a value `export { … }` block leaves Bun's ESM loader
+// resolving a binding that does not exist and the whole barrel fails to load.
+//
+// The repo-wide codemod missed this shape: it handled `export { … } from '…'` but not
+// a *local* re-export block fed by separate import statements.
+//
+// `EHTTPFrameworks` is an enum and `HTTPBaseServer` an abstract class — real runtime
+// values, which is why they stay in the value export.
+export type {
+  EndPointFactory,
+  IAPIFactory,
+  IbaseHandler,
+  IbaseHandlerFactory,
+  IController,
+  IControllerFactory,
+  IHandlerFactory,
+  IHTTPRequest,
+  IHTTPResponse,
+  IHTTPServer
+};
+
+export {
+  EHTTPFrameworks,
+  HTTPBaseServer
+};

package/templates/backend/src/interface/HTTP/validators/checkRequiredProperties.ts

@@ -0,0 +1,22 @@
+import { ValidationError } from '@src/infra/exceptions';
+/**
+ * Checks if the payload contains all the required properties
+ * @param payload the payload to check
+ * @param required the required properties
+ * @returns true if the payload contains all the required properties
+ */
+export default function checkRequiredProperties(
+  payload: Record<string, any>,
+  required: string[]
+): boolean {
+  const payloadKeyNames = Object.keys(payload);
+  for (const name of required) {
+    if (payloadKeyNames.indexOf(name) === -1) {
+      throw new ValidationError(`The property ${name} is required.`);
+    }
+    if (payload[name] === undefined || payload[name] === null) {
+      throw new ValidationError(`The property ${name} can not be null or undefined.`);
+    }
+  }
+  return true;
+}

package/templates/backend/src/interface/HTTP/validators/getSchema.ts

@@ -0,0 +1,34 @@
+import { OpenAPIV3 } from 'openapi-types';
+
+const resolveRef = (
+  spec: OpenAPIV3.Document,
+  ref: string
+): Record<string, any> | undefined => {
+  if (!ref.startsWith('#/')) return undefined;
+  const path = ref.slice(2).split('/');
+  let current: any = spec;
+  for (const entry of path) {
+    if (!current || typeof current !== 'object') {
+      return undefined;
+    }
+    current = current[entry];
+  }
+  return current as Record<string, any> | undefined;
+};
+
+export default function getSchema(
+  spec: OpenAPIV3.Document,
+  content: Record<string, any>
+): Record<string, any> | undefined {
+  const keyName = Object.keys(content || {})[0];
+  if (!keyName) return undefined;
+
+  const schema = content[keyName]?.schema;
+  if (!schema) return undefined;
+
+  if (schema.$ref && typeof schema.$ref === 'string') {
+    return resolveRef(spec, schema.$ref);
+  }
+
+  return schema as Record<string, any>;
+}

package/templates/backend/src/interface/HTTP/validators/index.ts

@@ -0,0 +1,6 @@
+export { default as throwIfOASInputValidationFails } from './throwIfOASInputValidationFails';
+export { default as isPropertiesMatching } from './isPropertiesMatching';
+export { default as getSchema } from './getSchema';
+export { default as checkRequiredProperties } from './checkRequiredProperties';
+export { default as validateRequestParams } from './validateRequestParams';
+export { default as validateRequestAgainstOAS } from './validateRequestAgainstOAS';

package/templates/backend/src/interface/HTTP/validators/isPropertiesMatching.ts

@@ -0,0 +1,20 @@
+import { ValidationError } from '@src/infra/exceptions';
+/**
+ * Check if properties exists in payload
+ *
+ * @param payload - The payload to check
+ * @param properties - The properties to check
+ * @returns True if properties exists in payload
+ */
+export default function isPropertiesMatching(
+  payload: Record<string, any>,
+  properties: Record<string, any>
+): boolean {
+  const propertyNames = Object.keys(properties);
+  for (const name of Object.keys(payload)) {
+    if (propertyNames.indexOf(name) === -1) {
+      throw new ValidationError(`The property ${name} from input payload does not exist.`);
+    }
+  }
+  return true;
+}

package/templates/backend/src/interface/HTTP/validators/throwIfOASInputValidationFails.ts

@@ -0,0 +1,94 @@
+import { OpenAPIV3 } from 'openapi-types';
+import { ValidationError } from '@src/infra/exceptions';
+import { validateValueAgainstOpenApiSchema } from '@src/shared/openapi/OpenApi31DataEntity';
+import getSchema from './getSchema';
+import isPropertiesMatching from './isPropertiesMatching';
+import checkRequiredProperties from './checkRequiredProperties';
+
+const SERVER_MANAGED_INPUT_PROPERTIES = new Set(['createdAt', 'updatedAt', 'deletedAt']);
+
+const toPublicValidationMessage = (
+  message: string,
+  payload: unknown,
+  operationId?: string
+): string => {
+  const fieldMatch = message.match(/payload\.([A-Za-z0-9_]+)/);
+  const fieldName = fieldMatch?.[1];
+  if (!fieldName || typeof payload !== 'object' || payload === null) {
+    return message;
+  }
+
+  const fieldValue = (payload as Record<string, unknown>)[fieldName];
+  if (fieldValue === '' && (
+    message.includes('minLength')
+    || message.includes('value must be one of')
+  )) {
+    if (
+      fieldName === 'password'
+      && message.includes('minLength')
+      && operationId !== 'updatePassword'
+    ) {
+      const minimum = message.match(/minLength is (\d+)/)?.[1];
+      if (minimum) {
+        return `password must have at least ${minimum} chars.`;
+      }
+    }
+    return `${fieldName} can not be empty`;
+  }
+
+  if (fieldName === 'password' && message.includes('minLength')) {
+    const minimum = message.match(/minLength is (\d+)/)?.[1];
+    if (minimum) {
+      return `password must have at least ${minimum} chars.`;
+    }
+  }
+
+  return message;
+};
+
+export default function throwIfOASInputValidationFails(
+  spec: OpenAPIV3.Document,
+  endPointConfig: Record<string, any>,
+  payload: unknown
+): boolean {
+  const requestBody = endPointConfig?.requestBody;
+  if (!requestBody) return true;
+
+  const { content, required } = requestBody;
+  if ((payload === undefined || payload === null) && required) {
+    throw new ValidationError('Request body is required by OpenAPI schema.');
+  }
+
+  if (payload === undefined || payload === null) {
+    return true;
+  }
+
+  const schema = getSchema(spec, content);
+  if (schema) {
+    const objectPayload = payload as Record<string, unknown>;
+    if (
+      typeof objectPayload === 'object'
+      && !Array.isArray(objectPayload)
+      && schema.properties
+    ) {
+      const contractInput = Object.fromEntries(
+        Object.entries(objectPayload)
+          .filter(([name]) => !SERVER_MANAGED_INPUT_PROPERTIES.has(name))
+      );
+      isPropertiesMatching(contractInput, schema.properties);
+      checkRequiredProperties(objectPayload, schema.required || []);
+    }
+
+    try {
+      validateValueAgainstOpenApiSchema(payload, schema, spec as unknown as Record<string, any>);
+    } catch (error) {
+      throw new ValidationError(toPublicValidationMessage(
+        (error as Error).message,
+        payload,
+        endPointConfig.operationId
+      ));
+    }
+  }
+
+  return true;
+}

package/templates/backend/src/interface/HTTP/validators/validateRequestAgainstOAS.ts

@@ -0,0 +1,29 @@
+import { OpenAPIV3 } from 'openapi-types';
+import throwIfOASInputValidationFails from './throwIfOASInputValidationFails';
+import validateRequestParams from './validateRequestParams';
+
+type RequestValidationInput = {
+  input?: unknown;
+  params?: Record<string, any>;
+  queryString?: Record<string, any>;
+  authorization?: string;
+};
+
+export default function validateRequestAgainstOAS(
+  spec: OpenAPIV3.Document,
+  endPointConfig: Record<string, any>,
+  request: RequestValidationInput
+): boolean {
+  validateRequestParams(
+    endPointConfig,
+    request.params || {},
+    request.queryString || {},
+    { authorization: request.authorization || '' }
+  );
+
+  return throwIfOASInputValidationFails(
+    spec,
+    endPointConfig,
+    request.input
+  );
+}

package/templates/backend/src/interface/HTTP/validators/validateRequestParams.ts

@@ -0,0 +1,78 @@
+import { ValidationError } from '@src/infra/exceptions';
+import { validateValueAgainstOpenApiSchema } from '@src/shared/openapi/OpenApi31DataEntity';
+
+const coerceQueryValue = (value: unknown, schema: Record<string, any>): unknown => {
+  if (typeof value !== 'string') return value;
+  const type = Array.isArray(schema?.type) ? schema.type[0] : schema?.type;
+  if (type === 'integer' || type === 'number') {
+    const trimmed = value.trim();
+    if (trimmed === '') return value;
+    const parsed = Number(trimmed);
+    return Number.isNaN(parsed) ? value : parsed;
+  }
+  if (type === 'boolean') {
+    if (value === 'true') return true;
+    if (value === 'false') return false;
+  }
+  return value;
+};
+
+/**
+ * Validate request parameters
+ * @param endPointConfig
+ * @param requestParams
+ */
+export default function validateRequestParams(
+  endPointConfig: Record<string, any>,
+  requestParams: Record<string, any>,
+  queryString: Record<string, any> = {},
+  headers: Record<string, any> = {}
+): boolean {
+  const { parameters } = endPointConfig;
+  if (!parameters) return true;
+  for (const parameter of parameters) {
+    const {
+      name,
+      required,
+      schema = {},
+      in: location = 'path'
+    } = parameter;
+    let source = requestParams;
+    if (location === 'query') {
+      source = queryString;
+    } else if (location === 'header') {
+      source = headers;
+    }
+    // Query strings arrive as text; coerce to the declared primitive before
+    // validating so `page=2` satisfies `type: integer` (JUM-777). Values that
+    // do not parse stay strings and fail the type check with a clear message.
+    const value = location === 'query' ? coerceQueryValue(source?.[name], schema) : source?.[name];
+
+    if (required) {
+      if (value === undefined || value === null || value === '') {
+        throw new ValidationError(`The parameter ${name} is required in ${location}.`);
+      }
+    }
+
+    if (value !== undefined && value !== null) {
+      if (typeof value === 'string' && value.length === 0) {
+        throw new ValidationError(`The parameter ${name} can not be empty.`);
+      }
+      if (typeof value === 'string' && value.toLowerCase() === 'null') {
+        throw new ValidationError(`The parameter ${name} can not be null.`);
+      }
+
+      try {
+        validateValueAgainstOpenApiSchema(
+          value,
+          schema,
+          { components: { schemas: {} } },
+          `params.${name}`
+        );
+      } catch (error) {
+        throw new ValidationError((error as Error).message);
+      }
+    }
+  }
+  return true;
+}