@classytic/mongokit 1.0.2 → 2.0.0

package/src/utils/field-selection.js

@@ -1,156 +1,156 @@
-/**
- * Field Selection Utilities
- *
- * Provides explicit, performant field filtering using Mongoose projections.
- *
- * Philosophy:
- * - Explicit is better than implicit
- * - Filter at DB level (10x faster than in-memory)
- * - Progressive disclosure (show more fields as trust increases)
- *
- * Usage:
- * ```javascript
- * // For Mongoose queries (PREFERRED - 90% of cases)
- * const projection = getMongooseProjection(request.user, fieldPresets.gymPlans);
- * const plans = await GymPlan.find().select(projection).lean();
- *
- * // For complex data (10% of cases - aggregations, multiple sources)
- * const filtered = filterResponseData(complexData, fieldPresets.gymPlans, request.user);
- * ```
- */
-
-/**
- * Get allowed fields for a user based on their context
- *
- * @param {Object} user - User object from request.user (or null for public)
- * @param {Object} preset - Field preset configuration
- * @param {string[]} preset.public - Fields visible to everyone
- * @param {string[]} preset.authenticated - Additional fields for authenticated users
- * @param {string[]} preset.admin - Additional fields for admins
- * @returns {string[]} Array of allowed field names
- */
-export const getFieldsForUser = (user, preset) => {
-  if (!preset) {
-    throw new Error('Field preset is required');
-  }
-
-  // Start with public fields
-  let fields = [...(preset.public || [])];
-
-  // Add authenticated fields if user is logged in
-  if (user) {
-    fields.push(...(preset.authenticated || []));
-
-    // Add admin fields if user is admin/superadmin
-    const roles = Array.isArray(user.roles) ? user.roles : (user.roles ? [user.roles] : []);
-    if (roles.includes('admin') || roles.includes('superadmin')) {
-      fields.push(...(preset.admin || []));
-    }
-  }
-
-  // Remove duplicates
-  return [...new Set(fields)];
-};
-
-/**
- * Get Mongoose projection string for query .select()
- *
- * @param {Object} user - User object from request.user
- * @param {Object} preset - Field preset configuration
- * @returns {string} Space-separated field names for Mongoose .select()
- *
- * @example
- * const projection = getMongooseProjection(request.user, fieldPresets.gymPlans);
- * const plans = await GymPlan.find({ organizationId }).select(projection).lean();
- */
-export const getMongooseProjection = (user, preset) => {
-  const fields = getFieldsForUser(user, preset);
-  return fields.join(' ');
-};
-
-/**
- * Filter response data to include only allowed fields
- *
- * Use this for complex responses where Mongoose projections aren't applicable:
- * - Aggregation pipeline results
- * - Data from multiple sources
- * - Custom computed fields
- *
- * For simple DB queries, prefer getMongooseProjection() (10x faster)
- *
- * @param {Object|Array} data - Data to filter
- * @param {Object} preset - Field preset configuration
- * @param {Object} user - User object from request.user
- * @returns {Object|Array} Filtered data
- *
- * @example
- * const stats = await calculateComplexStats();
- * const filtered = filterResponseData(stats, fieldPresets.dashboard, request.user);
- * return reply.send(filtered);
- */
-export const filterResponseData = (data, preset, user = null) => {
-  const allowedFields = getFieldsForUser(user, preset);
-
-  // Handle arrays
-  if (Array.isArray(data)) {
-    return data.map(item => filterObject(item, allowedFields));
-  }
-
-  // Handle single object
-  return filterObject(data, allowedFields);
-};
-
-/**
- * Filter a single object to include only allowed fields
- *
- * @private
- * @param {Object} obj - Object to filter
- * @param {string[]} allowedFields - Array of allowed field names
- * @returns {Object} Filtered object
- */
-const filterObject = (obj, allowedFields) => {
-  if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
-    return obj;
-  }
-
-  const filtered = {};
-
-  for (const field of allowedFields) {
-    if (field in obj) {
-      filtered[field] = obj[field];
-    }
-  }
-
-  return filtered;
-};
-
-/**
- * Helper to create field presets (module-level)
- *
- * Each module should define its own field preset in its own directory.
- * This keeps modules independent and self-contained.
- *
- * @param {Object} config - Field configuration
- * @returns {Object} Field preset
- *
- * @example
- * // In modules/gym-plan/gym-plan.fields.js
- * import { createFieldPreset } from '#common/utils/field-selection.js';
- *
- * export const gymPlanFieldPreset = createFieldPreset({
- *   public: ['id', 'name', 'price'],
- *   authenticated: ['features', 'description'],
- *   admin: ['createdAt', 'updatedAt', 'internalNotes']
- * });
- *
- * // Then in controller:
- * import { gymPlanFieldPreset } from './gym-plan.fields.js';
- * super(gymPlanRepository, { fieldPreset: gymPlanFieldPreset });
- */
-export const createFieldPreset = (config) => {
-  return {
-    public: config.public || [],
-    authenticated: config.authenticated || [],
-    admin: config.admin || [],
-  };
-};
+/**
+ * Field Selection Utilities
+ *
+ * Provides explicit, performant field filtering using Mongoose projections.
+ *
+ * Philosophy:
+ * - Explicit is better than implicit
+ * - Filter at DB level (10x faster than in-memory)
+ * - Progressive disclosure (show more fields as trust increases)
+ *
+ * Usage:
+ * ```javascript
+ * // For Mongoose queries (PREFERRED - 90% of cases)
+ * const projection = getMongooseProjection(request.user, fieldPresets.gymPlans);
+ * const plans = await GymPlan.find().select(projection).lean();
+ *
+ * // For complex data (10% of cases - aggregations, multiple sources)
+ * const filtered = filterResponseData(complexData, fieldPresets.gymPlans, request.user);
+ * ```
+ */
+
+/**
+ * Get allowed fields for a user based on their context
+ *
+ * @param {Object} user - User object from request.user (or null for public)
+ * @param {Object} preset - Field preset configuration
+ * @param {string[]} preset.public - Fields visible to everyone
+ * @param {string[]} preset.authenticated - Additional fields for authenticated users
+ * @param {string[]} preset.admin - Additional fields for admins
+ * @returns {string[]} Array of allowed field names
+ */
+export const getFieldsForUser = (user, preset) => {
+  if (!preset) {
+    throw new Error('Field preset is required');
+  }
+
+  // Start with public fields
+  let fields = [...(preset.public || [])];
+
+  // Add authenticated fields if user is logged in
+  if (user) {
+    fields.push(...(preset.authenticated || []));
+
+    // Add admin fields if user is admin/superadmin
+    const roles = Array.isArray(user.roles) ? user.roles : (user.roles ? [user.roles] : []);
+    if (roles.includes('admin') || roles.includes('superadmin')) {
+      fields.push(...(preset.admin || []));
+    }
+  }
+
+  // Remove duplicates
+  return [...new Set(fields)];
+};
+
+/**
+ * Get Mongoose projection string for query .select()
+ *
+ * @param {Object} user - User object from request.user
+ * @param {Object} preset - Field preset configuration
+ * @returns {string} Space-separated field names for Mongoose .select()
+ *
+ * @example
+ * const projection = getMongooseProjection(request.user, fieldPresets.gymPlans);
+ * const plans = await GymPlan.find({ organizationId }).select(projection).lean();
+ */
+export const getMongooseProjection = (user, preset) => {
+  const fields = getFieldsForUser(user, preset);
+  return fields.join(' ');
+};
+
+/**
+ * Filter response data to include only allowed fields
+ *
+ * Use this for complex responses where Mongoose projections aren't applicable:
+ * - Aggregation pipeline results
+ * - Data from multiple sources
+ * - Custom computed fields
+ *
+ * For simple DB queries, prefer getMongooseProjection() (10x faster)
+ *
+ * @param {Object|Array} data - Data to filter
+ * @param {Object} preset - Field preset configuration
+ * @param {Object} user - User object from request.user
+ * @returns {Object|Array} Filtered data
+ *
+ * @example
+ * const stats = await calculateComplexStats();
+ * const filtered = filterResponseData(stats, fieldPresets.dashboard, request.user);
+ * return reply.send(filtered);
+ */
+export const filterResponseData = (data, preset, user = null) => {
+  const allowedFields = getFieldsForUser(user, preset);
+
+  // Handle arrays
+  if (Array.isArray(data)) {
+    return data.map(item => filterObject(item, allowedFields));
+  }
+
+  // Handle single object
+  return filterObject(data, allowedFields);
+};
+
+/**
+ * Filter a single object to include only allowed fields
+ *
+ * @private
+ * @param {Object} obj - Object to filter
+ * @param {string[]} allowedFields - Array of allowed field names
+ * @returns {Object} Filtered object
+ */
+const filterObject = (obj, allowedFields) => {
+  if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
+    return obj;
+  }
+
+  const filtered = {};
+
+  for (const field of allowedFields) {
+    if (field in obj) {
+      filtered[field] = obj[field];
+    }
+  }
+
+  return filtered;
+};
+
+/**
+ * Helper to create field presets (module-level)
+ *
+ * Each module should define its own field preset in its own directory.
+ * This keeps modules independent and self-contained.
+ *
+ * @param {Object} config - Field configuration
+ * @returns {Object} Field preset
+ *
+ * @example
+ * // In modules/gym-plan/gym-plan.fields.js
+ * import { createFieldPreset } from '#common/utils/field-selection.js';
+ *
+ * export const gymPlanFieldPreset = createFieldPreset({
+ *   public: ['id', 'name', 'price'],
+ *   authenticated: ['features', 'description'],
+ *   admin: ['createdAt', 'updatedAt', 'internalNotes']
+ * });
+ *
+ * // Then in controller:
+ * import { gymPlanFieldPreset } from './gym-plan.fields.js';
+ * super(gymPlanRepository, { fieldPreset: gymPlanFieldPreset });
+ */
+export const createFieldPreset = (config) => {
+  return {
+    public: config.public || [],
+    authenticated: config.authenticated || [],
+    admin: config.admin || [],
+  };
+};

package/src/utils/index.js

@@ -1,12 +1,12 @@
-/**
- * Utility Functions for MongoKit
- * Reusable helpers for field selection, filtering, and more
- */
-
-export {
-  getFieldsForUser,
-  getMongooseProjection,
-  filterResponseData,
-  createFieldPreset,
-} from './field-selection.js';
-
+/**
+ * Utility Functions for MongoKit
+ * Reusable helpers for field selection, filtering, and more
+ */
+
+export {
+  getFieldsForUser,
+  getMongooseProjection,
+  filterResponseData,
+  createFieldPreset,
+} from './field-selection.js';
+

package/types/Repository.d.ts

@@ -0,0 +1,95 @@
+/**
+ * @typedef {import('./types.js').OffsetPaginationResult} OffsetPaginationResult
+ * @typedef {import('./types.js').KeysetPaginationResult} KeysetPaginationResult
+ * @typedef {import('./types.js').AggregatePaginationResult} AggregatePaginationResult
+ * @typedef {import('./types.js').ObjectId} ObjectId
+ */
+export class Repository {
+    constructor(Model: any, plugins?: any[], paginationConfig?: {});
+    Model: any;
+    model: any;
+    _hooks: Map<any, any>;
+    _pagination: PaginationEngine;
+    use(plugin: any): this;
+    on(event: any, listener: any): this;
+    emit(event: any, data: any): void;
+    create(data: any, options?: {}): Promise<any>;
+    createMany(dataArray: any, options?: {}): Promise<any>;
+    getById(id: any, options?: {}): Promise<any>;
+    getByQuery(query: any, options?: {}): Promise<any>;
+    /**
+     * Unified pagination - auto-detects offset vs keyset based on params
+     *
+     * Auto-detection logic:
+     * - If params has 'cursor' or 'after' → uses keyset pagination (stream)
+     * - If params has 'pagination' or 'page' → uses offset pagination (paginate)
+     * - Else → defaults to offset pagination with page=1
+     *
+     * @param {Object} params - Query and pagination parameters
+     * @param {Object} [params.filters] - MongoDB query filters
+     * @param {string|Object} [params.sort] - Sort specification
+     * @param {string} [params.cursor] - Cursor token for keyset pagination
+     * @param {string} [params.after] - Alias for cursor
+     * @param {number} [params.page] - Page number for offset pagination
+     * @param {Object} [params.pagination] - Pagination config { page, limit }
+     * @param {number} [params.limit] - Documents per page
+     * @param {string} [params.search] - Full-text search query
+     * @param {Object} [options] - Additional options (select, populate, lean, session)
+     * @returns {Promise<OffsetPaginationResult|KeysetPaginationResult>} Discriminated union based on method
+     *
+     * @example
+     * // Offset pagination (page-based)
+     * await repo.getAll({ page: 1, limit: 50, filters: { status: 'active' } });
+     * await repo.getAll({ pagination: { page: 2, limit: 20 } });
+     *
+     * // Keyset pagination (cursor-based)
+     * await repo.getAll({ cursor: 'eyJ2Ij...', limit: 50 });
+     * await repo.getAll({ after: 'eyJ2Ij...', sort: { createdAt: -1 } });
+     *
+     * // Simple query (defaults to page 1)
+     * await repo.getAll({ filters: { status: 'active' } });
+     */
+    getAll(params?: {
+        filters?: any;
+        sort?: string | any;
+        cursor?: string;
+        after?: string;
+        page?: number;
+        pagination?: any;
+        limit?: number;
+        search?: string;
+    }, options?: any): Promise<OffsetPaginationResult | KeysetPaginationResult>;
+    getOrCreate(query: any, createData: any, options?: {}): Promise<any>;
+    count(query?: {}, options?: {}): Promise<number>;
+    exists(query: any, options?: {}): Promise<{
+        _id: any;
+    }>;
+    update(id: any, data: any, options?: {}): Promise<any>;
+    delete(id: any, options?: {}): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    aggregate(pipeline: any, options?: {}): Promise<any[]>;
+    /**
+     * Aggregate pipeline with pagination
+     * Best for: Complex queries, grouping, joins
+     *
+     * @param {Object} options - Aggregate pagination options
+     * @returns {Promise<AggregatePaginationResult>}
+     */
+    aggregatePaginate(options?: any): Promise<AggregatePaginationResult>;
+    distinct(field: any, query?: {}, options?: {}): Promise<any>;
+    withTransaction(callback: any): Promise<any>;
+    _executeQuery(buildQuery: any): Promise<any>;
+    _buildContext(operation: any, options: any): Promise<any>;
+    _parseSort(sort: any): any;
+    _parsePopulate(populate: any): any[];
+    _handleError(error: any): any;
+}
+export default Repository;
+export type OffsetPaginationResult = import("./types.js").OffsetPaginationResult;
+export type KeysetPaginationResult = import("./types.js").KeysetPaginationResult;
+export type AggregatePaginationResult = import("./types.js").AggregatePaginationResult;
+export type ObjectId = import("./types.js").ObjectId;
+import { PaginationEngine } from './pagination/PaginationEngine.js';
+//# sourceMappingURL=Repository.d.ts.map

package/types/Repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Repository.d.ts","sourceRoot":"","sources":["../src/Repository.js"],"names":[],"mappings":"AASA;;;;;GAKG;AAEH;IACE,gEAMC;IALC,WAAkB;IAClB,WAA4B;IAC5B,sBAAuB;IACvB,8BAAgE;IAIlE,uBAOC;IAED,oCAMC;IAED,kCAGC;IAED,8CAWC;IAED,uDAWC;IAED,6CAGC;IAED,mDAGC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,gBAvBG;QAAwB,OAAO;QACA,IAAI,GAA3B,MAAM,MAAO;QACG,MAAM,GAAtB,MAAM;QACU,KAAK,GAArB,MAAM;QACU,IAAI,GAApB,MAAM;QACU,UAAU;QACV,KAAK,GAArB,MAAM;QACU,MAAM,GAAtB,MAAM;KACd,kBACU,OAAO,CAAC,sBAAsB,GAAC,sBAAsB,CAAC,CAgElE;IAED,qEAEC;IAED,iDAEC;IAED;;OAEC;IAED,uDAWC;IAED;;;OAWC;IAED,uDAEC;IAED;;;;;;OAMG;IACH,kCAFa,OAAO,CAAC,yBAAyB,CAAC,CAK9C;IAED,6DAEC;IAED,6CAaC;IAED,6CAYC;IAED,0DAUC;IAED,2BAOC;IAED,qCAKC;IAED,8BAUC;CACF;;qCA3RY,OAAO,YAAY,EAAE,sBAAsB;qCAC3C,OAAO,YAAY,EAAE,sBAAsB;wCAC3C,OAAO,YAAY,EAAE,yBAAyB;uBAC9C,OAAO,YAAY,EAAE,QAAQ;iCANT,kCAAkC"}

package/types/actions/aggregate.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Aggregate Actions
+ * MongoDB aggregation pipeline operations
+ */
+/**
+ * @typedef {import('mongoose').Model} Model
+ * @typedef {import('mongoose').ClientSession} ClientSession
+ */
+/**
+ * Execute aggregation pipeline
+ *
+ * @param {Model} Model - Mongoose model
+ * @param {any[]} pipeline - Aggregation pipeline stages
+ * @param {Object} [options={}] - Aggregation options
+ * @param {ClientSession} [options.session] - MongoDB session
+ * @returns {Promise<any[]>} Aggregation results
+ */
+export function aggregate(Model: Model, pipeline: any[], options?: {
+    session?: ClientSession;
+}): Promise<any[]>;
+/**
+ * Aggregate with pagination using native MongoDB $facet
+ * WARNING: $facet results must be <16MB. For larger results (limit >1000),
+ * consider using Repository.aggregatePaginate() or splitting into separate queries.
+ *
+ * @param {Model} Model - Mongoose model
+ * @param {any[]} pipeline - Aggregation pipeline stages (before pagination)
+ * @param {Object} [options={}] - Pagination options
+ * @param {number} [options.page=1] - Page number (1-indexed)
+ * @param {number} [options.limit=10] - Documents per page
+ * @param {ClientSession} [options.session] - MongoDB session
+ * @returns {Promise<{docs: any[], total: number, page: number, limit: number, pages: number, hasNext: boolean, hasPrev: boolean}>} Paginated results
+ *
+ * @example
+ * const result = await aggregatePaginate(UserModel, [
+ *   { $match: { status: 'active' } },
+ *   { $group: { _id: '$category', count: { $sum: 1 } } }
+ * ], { page: 1, limit: 20 });
+ */
+export function aggregatePaginate(Model: Model, pipeline: any[], options?: {
+    page?: number;
+    limit?: number;
+    session?: ClientSession;
+}): Promise<{
+    docs: any[];
+    total: number;
+    page: number;
+    limit: number;
+    pages: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+}>;
+/**
+ * Group documents by field value
+ *
+ * @param {Model} Model - Mongoose model
+ * @param {string} field - Field name to group by
+ * @param {Object} [options={}] - Options
+ * @param {number} [options.limit] - Maximum groups to return
+ * @param {ClientSession} [options.session] - MongoDB session
+ * @returns {Promise<Array<{_id: any, count: number}>>} Grouped results
+ */
+export function groupBy(Model: Model, field: string, options?: {
+    limit?: number;
+    session?: ClientSession;
+}): Promise<Array<{
+    _id: any;
+    count: number;
+}>>;
+/**
+ * Count by field values
+ */
+export function countBy(Model: any, field: any, query?: {}, options?: {}): Promise<any[]>;
+/**
+ * Lookup (join) with another collection
+ */
+export function lookup(Model: any, { from, localField, foreignField, as, pipeline, query, options }: {
+    from: any;
+    localField: any;
+    foreignField: any;
+    as: any;
+    pipeline?: any[];
+    query?: {};
+    options?: {};
+}): Promise<any[]>;
+/**
+ * Unwind array field
+ */
+export function unwind(Model: any, field: any, options?: {}): Promise<any[]>;
+/**
+ * Facet search (multiple aggregations in one query)
+ */
+export function facet(Model: any, facets: any, options?: {}): Promise<any[]>;
+/**
+ * Get distinct values
+ */
+export function distinct(Model: any, field: any, query?: {}, options?: {}): Promise<any>;
+/**
+ * Calculate sum
+ */
+export function sum(Model: any, field: any, query?: {}, options?: {}): Promise<any>;
+/**
+ * Calculate average
+ */
+export function average(Model: any, field: any, query?: {}, options?: {}): Promise<any>;
+/**
+ * Min/Max
+ */
+export function minMax(Model: any, field: any, query?: {}, options?: {}): Promise<any>;
+export type Model = import("mongoose").Model<any, any, any, any, any, any, any>;
+export type ClientSession = import("mongoose").ClientSession;
+//# sourceMappingURL=aggregate.d.ts.map

package/types/actions/aggregate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../src/actions/aggregate.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AAEH;;;;;;;;GAQG;AACH,iCANW,KAAK,YACL,GAAG,EAAE,YAEb;IAAgC,OAAO,GAA/B,aAAa;CACrB,GAAU,OAAO,CAAC,GAAG,EAAE,CAAC,CAU1B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,yCAdW,KAAK,YACL,GAAG,EAAE,YAEb;IAAyB,IAAI,GAArB,MAAM;IACW,KAAK,GAAtB,MAAM;IACkB,OAAO,GAA/B,aAAa;CACrB,GAAU,OAAO,CAAC;IAAC,IAAI,EAAE,GAAG,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAC,CAAC,CAwDjI;AAED;;;;;;;;;GASG;AACH,+BAPW,KAAK,SACL,MAAM,YAEd;IAAyB,KAAK,GAAtB,MAAM;IACkB,OAAO,GAA/B,aAAa;CACrB,GAAU,OAAO,CAAC,KAAK,CAAC;IAAC,GAAG,EAAE,GAAG,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC,CAarD;AAED;;GAEG;AACH,0FAaC;AAED;;GAEG;AACH;;;;;;;;mBA0BC;AAED;;GAEG;AACH,6EAWC;AAED;;GAEG;AACH,6EAIC;AAED;;GAEG;AACH,yFAEC;AAED;;GAEG;AACH,oFAgBC;AAED;;GAEG;AACH,wFAgBC;AAED;;GAEG;AACH,uFAiBC;;4BAjQY,OAAO,UAAU,EAAE,aAAa"}

package/types/actions/create.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Create Actions
+ * Pure functions for document creation
+ */
+/**
+ * Create single document
+ */
+export function create(Model: any, data: any, options?: {}): Promise<any>;
+/**
+ * Create multiple documents
+ */
+export function createMany(Model: any, dataArray: any, options?: {}): Promise<any>;
+/**
+ * Create with defaults (useful for initialization)
+ */
+export function createDefault(Model: any, overrides?: {}, options?: {}): Promise<any>;
+/**
+ * Upsert (create or update)
+ */
+export function upsert(Model: any, query: any, data: any, options?: {}): Promise<any>;
+//# sourceMappingURL=create.d.ts.map

package/types/actions/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/actions/create.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,0EAIC;AAED;;GAEG;AACH,mFAKC;AAED;;GAEG;AACH,sFAaC;AAED;;GAEG;AACH,sFAYC"}

package/types/actions/delete.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Delete by ID
+ */
+export function deleteById(Model: any, id: any, options?: {}): Promise<{
+    success: boolean;
+    message: string;
+}>;
+/**
+ * Delete many documents
+ */
+export function deleteMany(Model: any, query: any, options?: {}): Promise<{
+    success: boolean;
+    count: any;
+    message: string;
+}>;
+/**
+ * Delete by query
+ */
+export function deleteByQuery(Model: any, query: any, options?: {}): Promise<{
+    success: boolean;
+    message: string;
+}>;
+/**
+ * Soft delete (set deleted flag)
+ */
+export function softDelete(Model: any, id: any, options?: {}): Promise<{
+    success: boolean;
+    message: string;
+}>;
+/**
+ * Restore soft deleted document
+ */
+export function restore(Model: any, id: any, options?: {}): Promise<{
+    success: boolean;
+    message: string;
+}>;
+//# sourceMappingURL=delete.d.ts.map

package/types/actions/delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../src/actions/delete.js"],"names":[],"mappings":"AAOA;;GAEG;AACH;;;GAQC;AAED;;GAEG;AACH;;;;GAQC;AAED;;GAEG;AACH;;;GAQC;AAED;;GAEG;AACH;;;GAgBC;AAED;;GAEG;AACH;;;GAgBC"}