@angelps/prisma-query-builder 0.1.1

package/dist/errors/error-messages.d.ts

@@ -0,0 +1,80 @@
+export interface ErrorResponse {
+    statusCode: number;
+    message: string;
+    details?: string;
+}
+export declare const ErrorMessages: {
+    readonly PERMISSION_DENIED: {
+        readonly message: "Permiso denegado";
+        readonly statusCode: 403;
+    };
+    readonly INVALID_CREDENTIALS: {
+        readonly message: "Credenciales inválidas";
+        readonly statusCode: 401;
+    };
+    readonly UNAUTHORIZED_ACCESS: {
+        readonly message: "Acceso no autorizado";
+        readonly statusCode: 401;
+    };
+    readonly FORBIDDEN_ACTION: {
+        readonly message: "Acción prohibida";
+        readonly statusCode: 403;
+    };
+    readonly RESOURCE_ALREADY_EXISTS: {
+        readonly message: "El recurso ya existe";
+        readonly statusCode: 409;
+    };
+    readonly INTERNAL_SERVER_ERROR: {
+        readonly message: "Ha ocurrido un error desconocido";
+        readonly statusCode: 500;
+    };
+    readonly BAD_REQUEST: {
+        readonly message: "Solicitud incorrecta";
+        readonly statusCode: 400;
+    };
+    readonly RESOURCE_NOT_FOUND: {
+        readonly message: "Recurso no encontrado";
+        readonly statusCode: 404;
+    };
+    readonly USER_NOT_FOUND: {
+        readonly message: "Usuario no encontrado";
+        readonly statusCode: 404;
+    };
+    readonly CONFLICT_ERROR: {
+        readonly message: "Error de conflicto";
+        readonly statusCode: 409;
+    };
+    readonly VALIDATION_ERROR: {
+        readonly message: "Error de validación";
+        readonly statusCode: 422;
+    };
+    readonly DIFFERENT_PASSWORDS: {
+        readonly message: "Las contraseñas no coinciden";
+        readonly statusCode: 400;
+    };
+    readonly MISSING_FIELDS: {
+        readonly message: "Campos faltantes";
+        readonly statusCode: 400;
+    };
+    readonly INVALID_QUERY_PARAMS: {
+        readonly message: "Parámetros de consulta inválidos";
+        readonly statusCode: 400;
+    };
+    readonly INVALID_SCHEMA: {
+        readonly message: "Esquema inválido";
+        readonly statusCode: 500;
+    };
+    readonly INVALID_DATE: {
+        readonly message: "Fecha inválida";
+        readonly statusCode: 400;
+    };
+    readonly INVALID_TOKEN: {
+        readonly message: "El token ha expirado o es inválido";
+        readonly statusCode: 400;
+    };
+    readonly USER_NOT_ACTIVE: {
+        readonly message: "El usuario no está activo o ha expirado";
+        readonly statusCode: 403;
+    };
+};
+//# sourceMappingURL=error-messages.d.ts.map

package/dist/errors/error-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-messages.d.ts","sourceRoot":"","sources":["../../src/errors/error-messages.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyEhB,CAAC"}

package/dist/errors/error-messages.js

@@ -0,0 +1,75 @@
+export const ErrorMessages = {
+    PERMISSION_DENIED: {
+        message: 'Permiso denegado',
+        statusCode: 403,
+    },
+    INVALID_CREDENTIALS: {
+        message: 'Credenciales inválidas',
+        statusCode: 401,
+    },
+    UNAUTHORIZED_ACCESS: {
+        message: 'Acceso no autorizado',
+        statusCode: 401,
+    },
+    FORBIDDEN_ACTION: {
+        message: 'Acción prohibida',
+        statusCode: 403,
+    },
+    RESOURCE_ALREADY_EXISTS: {
+        message: 'El recurso ya existe',
+        statusCode: 409,
+    },
+    INTERNAL_SERVER_ERROR: {
+        message: 'Ha ocurrido un error desconocido',
+        statusCode: 500,
+    },
+    BAD_REQUEST: {
+        message: 'Solicitud incorrecta',
+        statusCode: 400,
+    },
+    RESOURCE_NOT_FOUND: {
+        message: 'Recurso no encontrado',
+        statusCode: 404,
+    },
+    USER_NOT_FOUND: {
+        message: 'Usuario no encontrado',
+        statusCode: 404,
+    },
+    CONFLICT_ERROR: {
+        message: 'Error de conflicto',
+        statusCode: 409,
+    },
+    VALIDATION_ERROR: {
+        message: 'Error de validación',
+        statusCode: 422,
+    },
+    DIFFERENT_PASSWORDS: {
+        message: 'Las contraseñas no coinciden',
+        statusCode: 400,
+    },
+    MISSING_FIELDS: {
+        message: 'Campos faltantes',
+        statusCode: 400,
+    },
+    INVALID_QUERY_PARAMS: {
+        message: 'Parámetros de consulta inválidos',
+        statusCode: 400,
+    },
+    INVALID_SCHEMA: {
+        message: 'Esquema inválido',
+        statusCode: 500,
+    },
+    INVALID_DATE: {
+        message: 'Fecha inválida',
+        statusCode: 400,
+    },
+    INVALID_TOKEN: {
+        message: 'El token ha expirado o es inválido',
+        statusCode: 400,
+    },
+    USER_NOT_ACTIVE: {
+        message: 'El usuario no está activo o ha expirado',
+        statusCode: 403,
+    },
+};
+//# sourceMappingURL=error-messages.js.map

package/dist/errors/error-messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-messages.js","sourceRoot":"","sources":["../../src/errors/error-messages.ts"],"names":[],"mappings":"AAMA,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,iBAAiB,EAAE;QACjB,OAAO,EAAE,kBAAkB;QAC3B,UAAU,EAAE,GAAG;KAChB;IACD,mBAAmB,EAAE;QACnB,OAAO,EAAE,wBAAwB;QACjC,UAAU,EAAE,GAAG;KAChB;IACD,mBAAmB,EAAE;QACnB,OAAO,EAAE,sBAAsB;QAC/B,UAAU,EAAE,GAAG;KAChB;IACD,gBAAgB,EAAE;QAChB,OAAO,EAAE,kBAAkB;QAC3B,UAAU,EAAE,GAAG;KAChB;IACD,uBAAuB,EAAE;QACvB,OAAO,EAAE,sBAAsB;QAC/B,UAAU,EAAE,GAAG;KAChB;IACD,qBAAqB,EAAE;QACrB,OAAO,EAAE,kCAAkC;QAC3C,UAAU,EAAE,GAAG;KAChB;IACD,WAAW,EAAE;QACX,OAAO,EAAE,sBAAsB;QAC/B,UAAU,EAAE,GAAG;KAChB;IACD,kBAAkB,EAAE;QAClB,OAAO,EAAE,uBAAuB;QAChC,UAAU,EAAE,GAAG;KAChB;IACD,cAAc,EAAE;QACd,OAAO,EAAE,uBAAuB;QAChC,UAAU,EAAE,GAAG;KAChB;IACD,cAAc,EAAE;QACd,OAAO,EAAE,oBAAoB;QAC7B,UAAU,EAAE,GAAG;KAChB;IACD,gBAAgB,EAAE;QAChB,OAAO,EAAE,qBAAqB;QAC9B,UAAU,EAAE,GAAG;KAChB;IACD,mBAAmB,EAAE;QACnB,OAAO,EAAE,8BAA8B;QACvC,UAAU,EAAE,GAAG;KAChB;IACD,cAAc,EAAE;QACd,OAAO,EAAE,kBAAkB;QAC3B,UAAU,EAAE,GAAG;KAChB;IACD,oBAAoB,EAAE;QACpB,OAAO,EAAE,kCAAkC;QAC3C,UAAU,EAAE,GAAG;KAChB;IACD,cAAc,EAAE;QACd,OAAO,EAAE,kBAAkB;QAC3B,UAAU,EAAE,GAAG;KAChB;IACD,YAAY,EAAE;QACZ,OAAO,EAAE,gBAAgB;QACzB,UAAU,EAAE,GAAG;KAChB;IACD,aAAa,EAAE;QACb,OAAO,EAAE,oCAAoC;QAC7C,UAAU,EAAE,GAAG;KAChB;IACD,eAAe,EAAE;QACf,OAAO,EAAE,yCAAyC;QAClD,UAAU,EAAE,GAAG;KAChB;CACO,CAAC"}

package/dist/errors/index.d.ts

@@ -0,0 +1,3 @@
+export * from './error-messages.js';
+export * from './app-errors.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC"}

package/dist/errors/index.js

@@ -0,0 +1,3 @@
+export * from './error-messages.js';
+export * from './app-errors.js';
+//# sourceMappingURL=index.js.map

package/dist/errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './types/index.js';
+export * from './errors/index.js';
+export * from './utils/index.js';
+export * from './services/index.js';
+export * from './query-builder/index.js';
+export * from './repositories/index.js';
+export * from './controllers/index.js';
+export * from './adapters/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from './types/index.js';
+export * from './errors/index.js';
+export * from './utils/index.js';
+export * from './services/index.js';
+export * from './query-builder/index.js';
+export * from './repositories/index.js';
+export * from './controllers/index.js';
+export * from './adapters/index.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC"}

package/dist/query-builder/helpers/order-by.helper.d.ts

@@ -0,0 +1,4 @@
+import type { CrudConfig } from '../../types/crud-config.js';
+import type { QueryBuilderOptions } from '../query-builder.types.js';
+export declare function buildOrderByClause<TResult, TOrderBy>(sort: string | undefined, options: QueryBuilderOptions<TResult>, config: CrudConfig<any>): TOrderBy[] | undefined;
+//# sourceMappingURL=order-by.helper.d.ts.map

package/dist/query-builder/helpers/order-by.helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-by.helper.d.ts","sourceRoot":"","sources":["../../../src/query-builder/helpers/order-by.helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAIrE,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,QAAQ,EAClD,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,OAAO,EAAE,mBAAmB,CAAC,OAAO,CAAC,EACrC,MAAM,EAAE,UAAU,CAAC,GAAG,CAAC,GACtB,QAAQ,EAAE,GAAG,SAAS,CAyBxB"}

package/dist/query-builder/helpers/order-by.helper.js

@@ -0,0 +1,24 @@
+import { BadRequestError } from '../../errors/app-errors.js';
+export function buildOrderByClause(sort, options, config) {
+    const { sortableFields = [], omitFields = [], orderBy = [] } = options;
+    const defaultOrderBy = config.defaultOrderBy ?? orderBy;
+    if (!sort || typeof sort !== 'string' || sort.trim() === '') {
+        if (defaultOrderBy.length === 0)
+            return undefined;
+        return defaultOrderBy.map((o) => ({ [o.field]: o.direction }));
+    }
+    const availableSortFields = sortableFields.filter((f) => !omitFields.includes(f));
+    return sort
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .map((p) => {
+        const desc = p.startsWith('-');
+        const field = desc ? p.slice(1) : p;
+        if (availableSortFields.length > 0 && !availableSortFields.includes(field)) {
+            throw new BadRequestError(`El campo "${field}" no es un campo de ordenamiento válido`);
+        }
+        return { [field]: desc ? 'desc' : 'asc' };
+    });
+}
+//# sourceMappingURL=order-by.helper.js.map

package/dist/query-builder/helpers/order-by.helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-by.helper.js","sourceRoot":"","sources":["../../../src/query-builder/helpers/order-by.helper.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,MAAM,UAAU,kBAAkB,CAChC,IAAwB,EACxB,OAAqC,EACrC,MAAuB;IAEvB,MAAM,EAAE,cAAc,GAAG,EAAE,EAAE,UAAU,GAAG,EAAE,EAAE,OAAO,GAAG,EAAE,EAAE,GAAG,OAAO,CAAC;IACvE,MAAM,cAAc,GAAG,MAAM,CAAC,cAAc,IAAI,OAAO,CAAC;IAExD,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QAC5D,IAAI,cAAc,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAClD,OAAO,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,SAAS,EAAE,CAAwB,CAAC,CAAC;IACxF,CAAC;IAED,MAAM,mBAAmB,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;IAElF,OAAO,IAAI;SACR,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;SACpB,MAAM,CAAC,OAAO,CAAC;SACf,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;QACT,MAAM,IAAI,GAAG,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;QAC/B,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAEpC,IAAI,mBAAmB,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,KAAsB,CAAC,EAAE,CAAC;YAC5F,MAAM,IAAI,eAAe,CAAC,aAAa,KAAK,yCAAyC,CAAC,CAAC;QACzF,CAAC;QAED,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,EAAyB,CAAC;IACnE,CAAC,CAAC,CAAC;AACP,CAAC"}

package/dist/query-builder/helpers/pagination.helper.d.ts

@@ -0,0 +1,6 @@
+import type { QueryParams } from '../../types/query-params.js';
+export declare function parsePagination(queryParams: QueryParams, pageDefault: number, sizeDefault: number): {
+    page: number;
+    size: number;
+};
+//# sourceMappingURL=pagination.helper.d.ts.map

package/dist/query-builder/helpers/pagination.helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.helper.d.ts","sourceRoot":"","sources":["../../../src/query-builder/helpers/pagination.helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE/D,wBAAgB,eAAe,CAC7B,WAAW,EAAE,WAAW,EACxB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAQhC"}

package/dist/query-builder/helpers/pagination.helper.js

@@ -0,0 +1,9 @@
+export function parsePagination(queryParams, pageDefault, sizeDefault) {
+    const rawPage = queryParams.page ? parseInt(String(queryParams.page), 10) : pageDefault;
+    const rawSize = queryParams.size ? parseInt(String(queryParams.size), 10) : sizeDefault;
+    return {
+        page: Number.isFinite(rawPage) && rawPage > 0 ? rawPage : pageDefault,
+        size: Number.isFinite(rawSize) && rawSize > 0 ? rawSize : sizeDefault,
+    };
+}
+//# sourceMappingURL=pagination.helper.js.map

package/dist/query-builder/helpers/pagination.helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.helper.js","sourceRoot":"","sources":["../../../src/query-builder/helpers/pagination.helper.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,eAAe,CAC7B,WAAwB,EACxB,WAAmB,EACnB,WAAmB;IAEnB,MAAM,OAAO,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;IACxF,MAAM,OAAO,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;IAExF,OAAO;QACL,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW;QACrE,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW;KACtE,CAAC;AACJ,CAAC"}

package/dist/query-builder/helpers/where.helper.d.ts

@@ -0,0 +1,5 @@
+import type { QueryParams } from '../../types/query-params.js';
+import type { CrudConfig } from '../../types/crud-config.js';
+import type { QueryBuilderOptions } from '../query-builder.types.js';
+export declare function buildWhereClause<TResult, TWhere>(params: QueryParams, options: QueryBuilderOptions<TResult>, config: CrudConfig<any>, additionalWhere?: Record<string, unknown>): TWhere;
+//# sourceMappingURL=where.helper.d.ts.map

package/dist/query-builder/helpers/where.helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"where.helper.d.ts","sourceRoot":"","sources":["../../../src/query-builder/helpers/where.helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAkMrE,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAC9C,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,mBAAmB,CAAC,OAAO,CAAC,EACrC,MAAM,EAAE,UAAU,CAAC,GAAG,CAAC,EACvB,eAAe,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAC5C,MAAM,CA6LR"}

package/dist/query-builder/helpers/where.helper.js

@@ -0,0 +1,356 @@
+import { startDateOfDay, endDateOfDay } from '../../utils/date.utils.js';
+import { defaultLogger } from '../../types/logger.js';
+import { BadRequestError } from '../../errors/app-errors.js';
+// ─── Operator suffix mapping ──────────────────────────────────────────────
+const OPERATOR_SUFFIXES = {
+    _gte: 'gte',
+    _lte: 'lte',
+    _gt: 'gt',
+    _lt: 'lt',
+    _contains: 'contains',
+    _startsWith: 'startsWith',
+    _in: 'in',
+    _not: 'not',
+};
+const SUFFIX_KEYS = Object.keys(OPERATOR_SUFFIXES).sort((a, b) => b.length - a.length);
+/**
+ * Try to split a param key like "price_gte" into { field: "price", operator: "gte" }.
+ * Returns null when no known suffix matches.
+ */
+function parseOperatorSuffix(key) {
+    for (const suffix of SUFFIX_KEYS) {
+        if (key.endsWith(suffix)) {
+            return {
+                field: key.slice(0, -suffix.length),
+                operator: OPERATOR_SUFFIXES[suffix],
+            };
+        }
+    }
+    return null;
+}
+// ─── Nested / relational filter helpers ───────────────────────────────────
+/**
+ * Build a nested Prisma where object from a dot-notated key.
+ *
+ * `"orders.items.status"` → `{ orders: { some: { items: { some: { status: value } } } } }`
+ */
+function buildNestedWhere(dotPath, value) {
+    const parts = dotPath.split('.');
+    let current = {};
+    const root = current;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (i === parts.length - 1) {
+            // leaf — assign the value
+            current[part] = value;
+        }
+        else {
+            // intermediate relation — wrap in `some`
+            const nested = {};
+            current[part] = { some: nested };
+            current = nested;
+        }
+    }
+    return root;
+}
+// ─── OR compound helpers ──────────────────────────────────────────────────
+/**
+ * Parse `or[0][field]=value` style query params into an array of condition objects.
+ *
+ * Example input (from Express query string):
+ * ```
+ * { 'or[0][status]': 'ACTIVE', 'or[0][role]': 'ADMIN', 'or[1][status]': 'PENDING' }
+ * ```
+ * Output: `[{ status: 'ACTIVE', role: 'ADMIN' }, { status: 'PENDING' }]`
+ */
+function parseOrConditions(params) {
+    const orPattern = /^or\[(\d+)]\[(.+)]$/;
+    const groups = new Map();
+    for (const [key, value] of Object.entries(params)) {
+        const match = key.match(orPattern);
+        if (!match)
+            continue;
+        const index = parseInt(match[1], 10);
+        const field = match[2];
+        if (!groups.has(index))
+            groups.set(index, {});
+        groups.get(index)[field] = castValue(value);
+    }
+    if (groups.size === 0)
+        return null;
+    // Sort by index for deterministic output
+    return [...groups.entries()]
+        .sort(([a], [b]) => a - b)
+        .map(([, condition]) => condition);
+}
+// ─── Value casting ────────────────────────────────────────────────────────
+/** Auto-cast a raw query-string value to its most specific JS type. */
+function castValue(value) {
+    if (value === undefined || value === '')
+        return value;
+    // null / not-null literals
+    if (value === 'null')
+        return null;
+    if (value === '!null')
+        return { not: null };
+    // booleans
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    // numeric
+    const numValue = Number(value);
+    if (!Number.isNaN(numValue) && String(numValue) === String(value)) {
+        return numValue;
+    }
+    // CSV → { in: [...] }
+    if (typeof value === 'string' && value.includes(',')) {
+        const values = value.split(',').map((v) => v.trim());
+        const numericValues = values.map((v) => Number(v));
+        const allNumeric = numericValues.every((n, i) => !Number.isNaN(n) && String(n) === values[i]);
+        return { in: allNumeric ? numericValues : values };
+    }
+    return value;
+}
+// ─── Runtime query-param validation ──────────────────────────────────────
+/** Params that are part of the query contract and should never be treated as filters. */
+const RESERVED_PARAMS = new Set([
+    'page', 'size', 'sort', 'search', 'from', 'to',
+    'notLike', 'greaterThan', 'lessThan', 'cursor', 'fields',
+]);
+/**
+ * Throw a 400 if any query param is not a recognised filter.
+ * Only runs when `filterableFields` is explicitly configured.
+ */
+function validateQueryParams(params, availableFieldStrings, filterableFields) {
+    if (filterableFields.length === 0)
+        return;
+    for (const paramKey of Object.keys(params)) {
+        if (RESERVED_PARAMS.has(paramKey))
+            continue;
+        if (paramKey.startsWith('or['))
+            continue;
+        if (paramKey.includes('.'))
+            continue; // nested relations are always allowed
+        if (availableFieldStrings.has(paramKey))
+            continue;
+        const parsed = parseOperatorSuffix(paramKey);
+        if (parsed && availableFieldStrings.has(parsed.field))
+            continue;
+        throw new BadRequestError(`El parámetro de filtro "${paramKey}" no es válido`);
+    }
+}
+// ─── Dev-time field validation ────────────────────────────────────────────
+function validateFieldArrays(options, logger) {
+    if (typeof process !== 'undefined' && process.env?.['NODE_ENV'] === 'production')
+        return;
+    const fieldArrays = [
+        ['filterableFields', options.filterableFields],
+        ['likeFields', options.likeFields],
+        ['notLikeFields', options.notLikeFields],
+        ['sortableFields', options.sortableFields],
+        ['searchDateFields', options.searchDateFields],
+        ['operationFields', options.operationFields],
+        ['omitFields', options.omitFields],
+    ];
+    for (const [name, fields] of fieldArrays) {
+        if (!fields)
+            continue;
+        for (const field of fields) {
+            if (typeof field !== 'string' || field.trim() === '') {
+                logger.warn(`[PrismaQueryBuilder] ${name} contains an invalid entry: ${JSON.stringify(field)}. ` +
+                    'Expected a non-empty string matching a model field.');
+            }
+        }
+    }
+}
+// ─── Main builder ─────────────────────────────────────────────────────────
+export function buildWhereClause(params, options, config, additionalWhere = {}) {
+    const logger = config.logger ?? defaultLogger;
+    const where = { ...additionalWhere };
+    // Dev-time validation (mejora #9)
+    validateFieldArrays(options, logger);
+    // Soft delete
+    const softDeleteField = config.softDeleteField ?? 'deletedAt';
+    const excludeSoftDeleted = config.excludeSoftDeleted ?? true;
+    if (excludeSoftDeleted && softDeleteField) {
+        where[softDeleteField] = null;
+    }
+    const { filterableFields = [], likeFields = [], notLikeFields = [], searchDateFields = [], operationFields = [], omitFields = [], } = options;
+    const availableFields = filterableFields.filter((f) => !omitFields.includes(f));
+    const availableFieldStrings = new Set(availableFields.map(String));
+    validateQueryParams(params, availableFieldStrings, filterableFields);
+    // ── Exact filters on filterable fields ────────────────────────────────
+    for (const field of availableFields) {
+        const value = params[field];
+        if (value === undefined || value === '')
+            continue;
+        const casted = castValue(value);
+        where[field] = casted;
+    }
+    // ── Operator-suffix filters (mejora #2): price_gte=100, name_contains=shirt ──
+    for (const [paramKey, rawValue] of Object.entries(params)) {
+        if (rawValue === undefined || rawValue === '')
+            continue;
+        const parsed = parseOperatorSuffix(paramKey);
+        if (!parsed)
+            continue;
+        const { field, operator } = parsed;
+        // Only apply to filterable fields
+        if (!availableFieldStrings.has(field))
+            continue;
+        // Build the Prisma operator value
+        let operatorValue;
+        if (operator === 'in') {
+            // _in expects CSV → array
+            const values = String(rawValue).split(',').map((v) => v.trim());
+            const numericValues = values.map((v) => Number(v));
+            const allNumeric = numericValues.every((n, i) => !Number.isNaN(n) && String(n) === values[i]);
+            operatorValue = allNumeric ? numericValues : values;
+        }
+        else if (operator === 'not') {
+            operatorValue = castValue(rawValue);
+        }
+        else if (['gte', 'lte', 'gt', 'lt'].includes(operator)) {
+            const num = Number(rawValue);
+            operatorValue = Number.isNaN(num) ? rawValue : num;
+        }
+        else {
+            // contains, startsWith — string operators
+            operatorValue = String(rawValue);
+        }
+        // Merge onto potentially existing operator object
+        if (operator === 'contains' || operator === 'startsWith') {
+            where[field] = {
+                ...(typeof where[field] === 'object' && where[field] !== null ? where[field] : {}),
+                [operator]: operatorValue,
+                mode: 'insensitive',
+            };
+        }
+        else {
+            where[field] = {
+                ...(typeof where[field] === 'object' && where[field] !== null ? where[field] : {}),
+                [operator]: operatorValue,
+            };
+        }
+    }
+    // ── Nested / relational filters (mejora #1): orders.status=PENDING ────
+    for (const [paramKey, rawValue] of Object.entries(params)) {
+        if (rawValue === undefined || rawValue === '')
+            continue;
+        if (!paramKey.includes('.'))
+            continue;
+        // Don't process reserved params or OR conditions
+        if (paramKey.startsWith('or['))
+            continue;
+        const casted = castValue(rawValue);
+        const nested = buildNestedWhere(paramKey, casted);
+        // Deep-merge the nested object into where
+        deepMerge(where, nested);
+    }
+    // ── OR compound conditions (mejora #4): or[0][status]=ACTIVE ──────────
+    const orConditions = parseOrConditions(params);
+    if (orConditions && orConditions.length > 0) {
+        // If there's already an OR from search, we need to merge them with AND
+        if (where.OR) {
+            where.AND = where.AND ?? [];
+            where.AND.push({ OR: where.OR });
+            where.AND.push({ OR: orConditions });
+            delete where.OR;
+        }
+        else {
+            where.OR = orConditions;
+        }
+    }
+    // ── LIKE search (OR between multiple fields) ──────────────────────────
+    const searchValue = params.search;
+    if (searchValue !== undefined && searchValue !== '') {
+        const availableLikeFields = likeFields.filter((f) => !omitFields.includes(f));
+        if (availableLikeFields.length > 0) {
+            const searchOR = availableLikeFields.map((field) => ({
+                [field]: { contains: String(searchValue), mode: 'insensitive' },
+            }));
+            if (where.OR) {
+                // Existing OR (from compound or other) — wrap both in AND
+                where.AND = where.AND ?? [];
+                where.AND.push({ OR: where.OR });
+                where.AND.push({ OR: searchOR });
+                delete where.OR;
+            }
+            else {
+                where.OR = searchOR;
+            }
+        }
+    }
+    // ── NOT LIKE filter (AND between multiple values) ─────────────────────
+    const notLike = params.notLike;
+    if (notLike !== undefined && notLike !== '') {
+        const notLikeArray = String(notLike).includes(',')
+            ? String(notLike).split(',').map((s) => s.trim())
+            : [String(notLike).trim()];
+        const availableNotLikeFields = notLikeFields.filter((f) => !omitFields.includes(f));
+        if (availableNotLikeFields.length > 0) {
+            where.AND = where.AND ?? [];
+            for (const field of availableNotLikeFields) {
+                for (const term of notLikeArray) {
+                    where.AND.push({
+                        [field]: { not: { contains: term, mode: 'insensitive' } },
+                    });
+                }
+            }
+        }
+    }
+    // ── Date range filter ─────────────────────────────────────────────────
+    const { from, to } = params;
+    if ((from || to) && searchDateFields.length > 0) {
+        const availableDateFields = searchDateFields.filter((f) => !omitFields.includes(f));
+        where.AND = where.AND ?? [];
+        for (const field of availableDateFields) {
+            where.AND.push({
+                [field]: {
+                    gte: startDateOfDay(from),
+                    lte: endDateOfDay(to),
+                },
+            });
+        }
+    }
+    // ── Comparison operators (greaterThan, lessThan) ──────────────────────
+    const { greaterThan, lessThan } = params;
+    if (greaterThan !== undefined && greaterThan !== '') {
+        const numValue = Number(greaterThan);
+        if (!Number.isNaN(numValue)) {
+            for (const field of operationFields) {
+                where[field] = { ...(where[field] ?? {}), gt: numValue };
+            }
+        }
+    }
+    if (lessThan !== undefined && lessThan !== '') {
+        const numValue = Number(lessThan);
+        if (!Number.isNaN(numValue)) {
+            for (const field of operationFields) {
+                where[field] = { ...(where[field] ?? {}), lt: numValue };
+            }
+        }
+    }
+    return where;
+}
+// ─── Utilities ────────────────────────────────────────────────────────────
+/** Deep-merge `source` into `target` (mutates target). */
+function deepMerge(target, source) {
+    for (const key of Object.keys(source)) {
+        const tVal = target[key];
+        const sVal = source[key];
+        if (tVal &&
+            sVal &&
+            typeof tVal === 'object' &&
+            typeof sVal === 'object' &&
+            !Array.isArray(tVal) &&
+            !Array.isArray(sVal)) {
+            deepMerge(tVal, sVal);
+        }
+        else {
+            target[key] = sVal;
+        }
+    }
+}
+//# sourceMappingURL=where.helper.js.map