@classytic/mongokit 3.0.6 → 3.1.1

package/dist/{queryParser-Do3SgsyJ.d.ts → mongooseToJsonSchema-BKMxPbPp.d.ts}

@@ -1,4 +1,4 @@
-import { q as UserContext, F as FieldPreset, H as HttpError, Z as CacheAdapter, y as SchemaBuilderOptions, z as CrudSchemas, V as ValidationResult, v as ParsedQuery } from './types-DDDYo18H.js';
+import { U as UserContext, F as FieldPreset, H as HttpError, C as CacheAdapter, g as SchemaBuilderOptions, h as CrudSchemas, V as ValidationResult } from './types-DA0rs2Jh.js';
 import mongoose__default, { Schema } from 'mongoose';
 
 /**
@@ -154,6 +154,8 @@ declare function createMemoryCache(maxEntries?: number): CacheAdapter;
  * Additional Options:
  * - strictAdditionalProperties: Set to true to add "additionalProperties: false" to schemas
  *   This makes Fastify reject unknown fields at validation level (default: false for backward compatibility)
+ * - update.requireAtLeastOne: Set to true to add "minProperties: 1" to update schema
+ *   This prevents empty update payloads (default: false)
  *
  * @example
  * buildCrudSchemasFromModel(Model, {
@@ -163,7 +165,10 @@ declare function createMemoryCache(maxEntries?: number): CacheAdapter;
  *     status: { systemManaged: true },
  *   },
  *   create: { omitFields: ['verifiedAt'] },
- *   update: { omitFields: ['customerId'] }
+ *   update: {
+ *     omitFields: ['customerId'],
+ *     requireAtLeastOne: true // Reject empty updates
+ *   }
  * })
  */
 
@@ -192,112 +197,4 @@ declare function isFieldUpdateAllowed(fieldName: string, options?: SchemaBuilder
  */
 declare function validateUpdateBody(body?: Record<string, unknown>, options?: SchemaBuilderOptions): ValidationResult;
 
-/**
- * Query Parser
- *
- * Parses HTTP query parameters into MongoDB-compatible query objects.
- * Supports operators, pagination, sorting, and filtering.
- */
-
-/** Operator mapping from query syntax to MongoDB operators */
-type OperatorMap = Record<string, string>;
-/** Possible values in filter parameters */
-type FilterValue = string | number | boolean | null | undefined | Record<string, unknown> | unknown[];
-/** Configuration options for QueryParser */
-interface QueryParserOptions {
-    /** Maximum allowed regex pattern length (default: 500) */
-    maxRegexLength?: number;
-    /** Maximum allowed text search query length (default: 200) */
-    maxSearchLength?: number;
-    /** Maximum allowed filter depth (default: 10) */
-    maxFilterDepth?: number;
-    /** Additional operators to block */
-    additionalDangerousOperators?: string[];
-}
-/**
- * Query Parser Class
- *
- * Parses HTTP query parameters into MongoDB-compatible query objects.
- * Includes security measures against NoSQL injection and ReDoS attacks.
- *
- * @example
- * ```typescript
- * import { QueryParser } from '@classytic/mongokit';
- *
- * const parser = new QueryParser({ maxRegexLength: 100 });
- * const query = parser.parseQuery(req.query);
- * ```
- */
-declare class QueryParser {
-    private readonly options;
-    private readonly operators;
-    /**
-     * Dangerous MongoDB operators that should never be accepted from user input
-     * Security: Prevent NoSQL injection attacks
-     */
-    private readonly dangerousOperators;
-    /**
-     * Regex pattern characters that can cause catastrophic backtracking (ReDoS)
-     */
-    private readonly dangerousRegexPatterns;
-    constructor(options?: QueryParserOptions);
-    /**
-     * Parse query parameters into MongoDB query format
-     */
-    parseQuery(query: Record<string, unknown> | null | undefined): ParsedQuery;
-    /**
-     * Parse sort parameter
-     * Converts string like '-createdAt' to { createdAt: -1 }
-     * Handles multiple sorts: '-createdAt,name' → { createdAt: -1, name: 1 }
-     */
-    private _parseSort;
-    /**
-     * Parse standard filter parameter (filter[field]=value)
-     */
-    private _parseFilters;
-    /**
-     * Handle operator syntax: field[operator]=value
-     */
-    private _handleOperatorSyntax;
-    /**
-     * Handle bracket syntax with object value
-     */
-    private _handleBracketSyntax;
-    /**
-     * Convert operator to MongoDB format
-     */
-    private _toMongoOperator;
-    /**
-     * Create a safe regex pattern with protection against ReDoS attacks
-     * @param pattern - The pattern string from user input
-     * @param flags - Regex flags (default: 'i' for case-insensitive)
-     * @returns A safe RegExp or null if pattern is invalid/dangerous
-     */
-    private _createSafeRegex;
-    /**
-     * Escape special regex characters for literal matching
-     */
-    private _escapeRegex;
-    /**
-     * Sanitize text search query for MongoDB $text search
-     * @param search - Raw search input from user
-     * @returns Sanitized search string or undefined
-     */
-    private _sanitizeSearch;
-    /**
-     * Convert values based on operator type
-     */
-    private _convertValue;
-    /**
-     * Parse $or conditions
-     */
-    private _parseOr;
-    /**
-     * Enhance filters with between operator
-     */
-    private _enhanceWithBetween;
-}
-/** Default query parser instance with standard options */
-declare const defaultQueryParser: QueryParser;
-
-export { type FilterValue as F, type OperatorMap as O, QueryParser as Q, getMongooseProjection as a, type QueryParserOptions as b, createFieldPreset as c, defaultQueryParser as d, buildCrudSchemasFromMongooseSchema as e, filterResponseData as f, getFieldsForUser as g, buildCrudSchemasFromModel as h, getImmutableFields as i, getSystemManagedFields as j, isFieldUpdateAllowed as k, createError as l, createMemoryCache as m, validateUpdateBody as v };
+export { getMongooseProjection as a, buildCrudSchemasFromMongooseSchema as b, createFieldPreset as c, buildCrudSchemasFromModel as d, getImmutableFields as e, filterResponseData as f, getFieldsForUser as g, getSystemManagedFields as h, isFieldUpdateAllowed as i, createError as j, createMemoryCache as k, validateUpdateBody as v };

package/dist/pagination/PaginationEngine.d.ts

@@ -1,5 +1,5 @@
 import { Model } from 'mongoose';
-import { A as AnyDocument, P as PaginationConfig, O as OffsetPaginationOptions, a as OffsetPaginationResult, K as KeysetPaginationOptions, b as KeysetPaginationResult, c as AggregatePaginationOptions, d as AggregatePaginationResult } from '../types-DDDYo18H.js';
+import { A as AnyDocument, P as PaginationConfig, O as OffsetPaginationOptions, a as OffsetPaginationResult, K as KeysetPaginationOptions, b as KeysetPaginationResult, c as AggregatePaginationOptions, d as AggregatePaginationResult } from '../types-DA0rs2Jh.js';
 
 /**
  * Pagination Engine

package/dist/pagination/PaginationEngine.js

@@ -1,368 +1,2 @@
-import mongoose from 'mongoose';
-
-// src/pagination/utils/cursor.ts
-function encodeCursor(doc, primaryField, sort, version = 1) {
-  const primaryValue = doc[primaryField];
-  const idValue = doc._id;
-  const payload = {
-    v: serializeValue(primaryValue),
-    t: getValueType(primaryValue),
-    id: serializeValue(idValue),
-    idType: getValueType(idValue),
-    sort,
-    ver: version
-  };
-  return Buffer.from(JSON.stringify(payload)).toString("base64");
-}
-function decodeCursor(token) {
-  try {
-    const json = Buffer.from(token, "base64").toString("utf-8");
-    const payload = JSON.parse(json);
-    return {
-      value: rehydrateValue(payload.v, payload.t),
-      id: rehydrateValue(payload.id, payload.idType),
-      sort: payload.sort,
-      version: payload.ver
-    };
-  } catch {
-    throw new Error("Invalid cursor token");
-  }
-}
-function validateCursorSort(cursorSort, currentSort) {
-  const cursorSortStr = JSON.stringify(cursorSort);
-  const currentSortStr = JSON.stringify(currentSort);
-  if (cursorSortStr !== currentSortStr) {
-    throw new Error("Cursor sort does not match current query sort");
-  }
-}
-function validateCursorVersion(cursorVersion, expectedVersion) {
-  if (cursorVersion !== expectedVersion) {
-    throw new Error(`Cursor version ${cursorVersion} does not match expected version ${expectedVersion}`);
-  }
-}
-function serializeValue(value) {
-  if (value instanceof Date) return value.toISOString();
-  if (value instanceof mongoose.Types.ObjectId) return value.toString();
-  return value;
-}
-function getValueType(value) {
-  if (value instanceof Date) return "date";
-  if (value instanceof mongoose.Types.ObjectId) return "objectid";
-  if (typeof value === "boolean") return "boolean";
-  if (typeof value === "number") return "number";
-  if (typeof value === "string") return "string";
-  return "unknown";
-}
-function rehydrateValue(serialized, type) {
-  switch (type) {
-    case "date":
-      return new Date(serialized);
-    case "objectid":
-      return new mongoose.Types.ObjectId(serialized);
-    case "boolean":
-      return Boolean(serialized);
-    case "number":
-      return Number(serialized);
-    default:
-      return serialized;
-  }
-}
-
-// src/pagination/utils/sort.ts
-function normalizeSort(sort) {
-  const normalized = {};
-  Object.keys(sort).forEach((key) => {
-    if (key !== "_id") normalized[key] = sort[key];
-  });
-  if (sort._id !== void 0) {
-    normalized._id = sort._id;
-  }
-  return normalized;
-}
-function validateKeysetSort(sort) {
-  const keys = Object.keys(sort);
-  if (keys.length === 1 && keys[0] !== "_id") {
-    const field = keys[0];
-    const direction = sort[field];
-    return normalizeSort({ [field]: direction, _id: direction });
-  }
-  if (keys.length === 1 && keys[0] === "_id") {
-    return normalizeSort(sort);
-  }
-  if (keys.length === 2) {
-    if (!keys.includes("_id")) {
-      throw new Error("Keyset pagination requires _id as tie-breaker");
-    }
-    const primaryField = keys.find((k) => k !== "_id");
-    const primaryDirection = sort[primaryField];
-    const idDirection = sort._id;
-    if (primaryDirection !== idDirection) {
-      throw new Error("_id direction must match primary field direction");
-    }
-    return normalizeSort(sort);
-  }
-  throw new Error("Keyset pagination only supports single field + _id");
-}
-function getPrimaryField(sort) {
-  const keys = Object.keys(sort);
-  return keys.find((k) => k !== "_id") || "_id";
-}
-
-// src/pagination/utils/filter.ts
-function buildKeysetFilter(baseFilters, sort, cursorValue, cursorId) {
-  const primaryField = Object.keys(sort).find((k) => k !== "_id") || "_id";
-  const direction = sort[primaryField];
-  const operator = direction === 1 ? "$gt" : "$lt";
-  return {
-    ...baseFilters,
-    $or: [
-      { [primaryField]: { [operator]: cursorValue } },
-      {
-        [primaryField]: cursorValue,
-        _id: { [operator]: cursorId }
-      }
-    ]
-  };
-}
-
-// src/pagination/utils/limits.ts
-function validateLimit(limit, config) {
-  const parsed = Number(limit);
-  if (!Number.isFinite(parsed) || parsed < 1) {
-    return config.defaultLimit || 10;
-  }
-  return Math.min(Math.floor(parsed), config.maxLimit || 100);
-}
-function validatePage(page, config) {
-  const parsed = Number(page);
-  if (!Number.isFinite(parsed) || parsed < 1) {
-    return 1;
-  }
-  const sanitized = Math.floor(parsed);
-  if (sanitized > (config.maxPage || 1e4)) {
-    throw new Error(`Page ${sanitized} exceeds maximum ${config.maxPage || 1e4}`);
-  }
-  return sanitized;
-}
-function shouldWarnDeepPagination(page, threshold) {
-  return page > threshold;
-}
-function calculateSkip(page, limit) {
-  return (page - 1) * limit;
-}
-function calculateTotalPages(total, limit) {
-  return Math.ceil(total / limit);
-}
-
-// src/utils/error.ts
-function createError(status, message) {
-  const error = new Error(message);
-  error.status = status;
-  return error;
-}
-
-// src/pagination/PaginationEngine.ts
-var PaginationEngine = class {
-  Model;
-  config;
-  /**
-   * Create a new pagination engine
-   *
-   * @param Model - Mongoose model to paginate
-   * @param config - Pagination configuration
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  constructor(Model, config = {}) {
-    this.Model = Model;
-    this.config = {
-      defaultLimit: config.defaultLimit || 10,
-      maxLimit: config.maxLimit || 100,
-      maxPage: config.maxPage || 1e4,
-      deepPageThreshold: config.deepPageThreshold || 100,
-      cursorVersion: config.cursorVersion || 1,
-      useEstimatedCount: config.useEstimatedCount || false
-    };
-  }
-  /**
-   * Offset-based pagination using skip/limit
-   * Best for small datasets and when users need random page access
-   * O(n) performance - slower for deep pages
-   *
-   * @param options - Pagination options
-   * @returns Pagination result with total count
-   *
-   * @example
-   * const result = await engine.paginate({
-   *   filters: { status: 'active' },
-   *   sort: { createdAt: -1 },
-   *   page: 1,
-   *   limit: 20
-   * });
-   * console.log(result.docs, result.total, result.hasNext);
-   */
-  async paginate(options = {}) {
-    const {
-      filters = {},
-      sort = { _id: -1 },
-      page = 1,
-      limit = this.config.defaultLimit,
-      select,
-      populate = [],
-      lean = true,
-      session
-    } = options;
-    const sanitizedPage = validatePage(page, this.config);
-    const sanitizedLimit = validateLimit(limit, this.config);
-    const skip = calculateSkip(sanitizedPage, sanitizedLimit);
-    let query = this.Model.find(filters);
-    if (select) query = query.select(select);
-    if (populate && (Array.isArray(populate) ? populate.length : populate)) {
-      query = query.populate(populate);
-    }
-    query = query.sort(sort).skip(skip).limit(sanitizedLimit).lean(lean);
-    if (session) query = query.session(session);
-    const hasFilters = Object.keys(filters).length > 0;
-    const useEstimated = this.config.useEstimatedCount && !hasFilters;
-    const [docs, total] = await Promise.all([
-      query.exec(),
-      useEstimated ? this.Model.estimatedDocumentCount() : this.Model.countDocuments(filters).session(session ?? null)
-    ]);
-    const totalPages = calculateTotalPages(total, sanitizedLimit);
-    const warning = shouldWarnDeepPagination(sanitizedPage, this.config.deepPageThreshold) ? `Deep pagination (page ${sanitizedPage}). Consider getAll({ after, sort, limit }) for better performance.` : void 0;
-    return {
-      method: "offset",
-      docs,
-      page: sanitizedPage,
-      limit: sanitizedLimit,
-      total,
-      pages: totalPages,
-      hasNext: sanitizedPage < totalPages,
-      hasPrev: sanitizedPage > 1,
-      ...warning && { warning }
-    };
-  }
-  /**
-   * Keyset (cursor-based) pagination for high-performance streaming
-   * Best for large datasets, infinite scroll, real-time feeds
-   * O(1) performance - consistent speed regardless of position
-   *
-   * @param options - Pagination options (sort is required)
-   * @returns Pagination result with next cursor
-   *
-   * @example
-   * // First page
-   * const page1 = await engine.stream({
-   *   sort: { createdAt: -1 },
-   *   limit: 20
-   * });
-   *
-   * // Next page using cursor
-   * const page2 = await engine.stream({
-   *   sort: { createdAt: -1 },
-   *   after: page1.next,
-   *   limit: 20
-   * });
-   */
-  async stream(options) {
-    const {
-      filters = {},
-      sort,
-      after,
-      limit = this.config.defaultLimit,
-      select,
-      populate = [],
-      lean = true,
-      session
-    } = options;
-    if (!sort) {
-      throw createError(400, "sort is required for keyset pagination");
-    }
-    const sanitizedLimit = validateLimit(limit, this.config);
-    const normalizedSort = validateKeysetSort(sort);
-    let query = { ...filters };
-    if (after) {
-      const cursor = decodeCursor(after);
-      validateCursorVersion(cursor.version, this.config.cursorVersion);
-      validateCursorSort(cursor.sort, normalizedSort);
-      query = buildKeysetFilter(query, normalizedSort, cursor.value, cursor.id);
-    }
-    let mongoQuery = this.Model.find(query);
-    if (select) mongoQuery = mongoQuery.select(select);
-    if (populate && (Array.isArray(populate) ? populate.length : populate)) {
-      mongoQuery = mongoQuery.populate(populate);
-    }
-    mongoQuery = mongoQuery.sort(normalizedSort).limit(sanitizedLimit + 1).lean(lean);
-    if (session) mongoQuery = mongoQuery.session(session);
-    const docs = await mongoQuery.exec();
-    const hasMore = docs.length > sanitizedLimit;
-    if (hasMore) docs.pop();
-    const primaryField = getPrimaryField(normalizedSort);
-    const nextCursor = hasMore && docs.length > 0 ? encodeCursor(docs[docs.length - 1], primaryField, normalizedSort, this.config.cursorVersion) : null;
-    return {
-      method: "keyset",
-      docs,
-      limit: sanitizedLimit,
-      hasMore,
-      next: nextCursor
-    };
-  }
-  /**
-   * Aggregate pipeline with pagination
-   * Best for complex queries requiring aggregation stages
-   * Uses $facet to combine results and count in single query
-   *
-   * @param options - Aggregation options
-   * @returns Pagination result with total count
-   *
-   * @example
-   * const result = await engine.aggregatePaginate({
-   *   pipeline: [
-   *     { $match: { status: 'active' } },
-   *     { $group: { _id: '$category', count: { $sum: 1 } } },
-   *     { $sort: { count: -1 } }
-   *   ],
-   *   page: 1,
-   *   limit: 20
-   * });
-   */
-  async aggregatePaginate(options = {}) {
-    const {
-      pipeline = [],
-      page = 1,
-      limit = this.config.defaultLimit,
-      session
-    } = options;
-    const sanitizedPage = validatePage(page, this.config);
-    const sanitizedLimit = validateLimit(limit, this.config);
-    const skip = calculateSkip(sanitizedPage, sanitizedLimit);
-    const facetPipeline = [
-      ...pipeline,
-      {
-        $facet: {
-          docs: [{ $skip: skip }, { $limit: sanitizedLimit }],
-          total: [{ $count: "count" }]
-        }
-      }
-    ];
-    const aggregation = this.Model.aggregate(facetPipeline);
-    if (session) aggregation.session(session);
-    const [result] = await aggregation.exec();
-    const docs = result.docs;
-    const total = result.total[0]?.count || 0;
-    const totalPages = calculateTotalPages(total, sanitizedLimit);
-    const warning = shouldWarnDeepPagination(sanitizedPage, this.config.deepPageThreshold) ? `Deep pagination in aggregate (page ${sanitizedPage}). Uses $skip internally.` : void 0;
-    return {
-      method: "aggregate",
-      docs,
-      page: sanitizedPage,
-      limit: sanitizedLimit,
-      total,
-      pages: totalPages,
-      hasNext: sanitizedPage < totalPages,
-      hasPrev: sanitizedPage > 1,
-      ...warning && { warning }
-    };
-  }
-};
-
-export { PaginationEngine };
+export { PaginationEngine } from '../chunks/chunk-M2XHQGZB.js';
+import '../chunks/chunk-VJXDGP3C.js';

package/dist/plugins/index.d.ts

@@ -1,4 +1,4 @@
-import { F as FieldPreset, r as Plugin, L as Logger, M as SoftDeleteOptions, t as RepositoryInstance, G as ValidatorDefinition, I as ValidationChainOptions, i as RepositoryContext, _ as CacheOptions, a2 as CascadeOptions } from '../types-DDDYo18H.js';
+import { F as FieldPreset, G as Plugin, a2 as Logger, a3 as SoftDeleteOptions, L as RepositoryInstance, a0 as ValidatorDefinition, a1 as ValidationChainOptions, m as RepositoryContext, a8 as CacheOptions, ac as CascadeOptions } from '../types-DA0rs2Jh.js';
 import 'mongoose';
 
 /**