@classytic/mongokit 2.1.0 → 3.0.0

package/dist/index.d.cts

@@ -1,239 +0,0 @@
-import { A as AnyDocument, e as PluginType, P as PaginationConfig, S as SelectSpec, f as PopulateSpec, g as SortSpec, a as OffsetPaginationResult, b as KeysetPaginationResult, d as AggregatePaginationResult, R as RepositoryContext, H as HttpError } from './types-Nxhmi1aI.cjs';
-export { c as AggregatePaginationOptions, i as AnyModel, N as CacheAdapter, T as CacheOperationOptions, Q as CacheOptions, W as CacheStats, C as CreateOptions, w as CrudSchemas, x as DecodedCursor, D as DeleteResult, E as EventPayload, F as FieldPreset, u as FieldRules, I as GroupResult, J as JsonSchema, K as KeysetPaginationOptions, L as Logger, G as LookupOptions, M as MinMaxResult, h as ObjectId, O as OffsetPaginationOptions, l as OperationOptions, k as PaginationResult, t as ParsedQuery, p as Plugin, q as PluginFunction, s as RepositoryEvent, r as RepositoryInstance, v as SchemaBuilderOptions, B as SoftDeleteOptions, j as SortDirection, m as UpdateManyResult, U as UpdateOptions, n as UpdateWithValidationResult, o as UserContext, z as ValidationChainOptions, V as ValidationResult, y as ValidatorDefinition } from './types-Nxhmi1aI.cjs';
-import * as mongoose from 'mongoose';
-import { Model, ClientSession, PipelineStage, PopulateOptions } from 'mongoose';
-import { PaginationEngine } from './pagination/PaginationEngine.cjs';
-export { aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, fieldFilterPlugin, immutableField, methodRegistryPlugin, mongoOperationsPlugin, requireField, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin } from './plugins/index.cjs';
-export { b as createError, c as createFieldPreset, d as createMemoryCache, f as filterResponseData, g as getFieldsForUser, a as getMongooseProjection } from './memory-cache-DqfFfKes.cjs';
-export { i as actions } from './index-BfVJZF-3.cjs';
-
-/**
- * Repository Pattern - Data Access Layer
- *
- * Event-driven, plugin-based abstraction for MongoDB operations
- * Inspired by Meta & Stripe's repository patterns
- *
- * @example
- * ```typescript
- * const userRepo = new Repository(UserModel, [
- *   timestampPlugin(),
- *   softDeletePlugin(),
- * ]);
- *
- * // Create
- * const user = await userRepo.create({ name: 'John', email: 'john@example.com' });
- *
- * // Read with pagination
- * const users = await userRepo.getAll({ page: 1, limit: 20, filters: { status: 'active' } });
- *
- * // Update
- * const updated = await userRepo.update(user._id, { name: 'John Doe' });
- *
- * // Delete
- * await userRepo.delete(user._id);
- * ```
- */
-
-type HookListener = (data: any) => void | Promise<void>;
-/**
- * Production-grade repository for MongoDB
- * Event-driven, plugin-based, with smart pagination
- */
-declare class Repository<TDoc = AnyDocument> {
-    readonly Model: Model<TDoc>;
-    readonly model: string;
-    readonly _hooks: Map<string, HookListener[]>;
-    readonly _pagination: PaginationEngine<TDoc>;
-    [key: string]: unknown;
-    constructor(Model: Model<TDoc>, plugins?: PluginType[], paginationConfig?: PaginationConfig);
-    /**
-     * Register a plugin
-     */
-    use(plugin: PluginType): this;
-    /**
-     * Register event listener
-     */
-    on(event: string, listener: HookListener): this;
-    /**
-     * Emit event
-     */
-    emit(event: string, data: unknown): void;
-    /**
-     * Create single document
-     */
-    create(data: Record<string, unknown>, options?: {
-        session?: ClientSession;
-    }): Promise<TDoc>;
-    /**
-     * Create multiple documents
-     */
-    createMany(dataArray: Record<string, unknown>[], options?: {
-        session?: ClientSession;
-        ordered?: boolean;
-    }): Promise<TDoc[]>;
-    /**
-     * Get document by ID
-     */
-    getById(id: string, options?: {
-        select?: SelectSpec;
-        populate?: PopulateSpec;
-        lean?: boolean;
-        session?: ClientSession;
-        throwOnNotFound?: boolean;
-        skipCache?: boolean;
-        cacheTtl?: number;
-    }): Promise<TDoc | null>;
-    /**
-     * Get single document by query
-     */
-    getByQuery(query: Record<string, unknown>, options?: {
-        select?: SelectSpec;
-        populate?: PopulateSpec;
-        lean?: boolean;
-        session?: ClientSession;
-        throwOnNotFound?: boolean;
-        skipCache?: boolean;
-        cacheTtl?: number;
-    }): Promise<TDoc | null>;
-    /**
-     * 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
-     *
-     * @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' } });
-     *
-     * // Skip cache for fresh data
-     * await repo.getAll({ filters: { status: 'active' } }, { skipCache: true });
-     */
-    getAll(params?: {
-        filters?: Record<string, unknown>;
-        sort?: SortSpec | string;
-        cursor?: string;
-        after?: string;
-        page?: number;
-        pagination?: {
-            page?: number;
-            limit?: number;
-        };
-        limit?: number;
-        search?: string;
-    }, options?: {
-        select?: SelectSpec;
-        populate?: PopulateSpec;
-        lean?: boolean;
-        session?: ClientSession;
-        skipCache?: boolean;
-        cacheTtl?: number;
-    }): Promise<OffsetPaginationResult<TDoc> | KeysetPaginationResult<TDoc>>;
-    /**
-     * Get or create document
-     */
-    getOrCreate(query: Record<string, unknown>, createData: Record<string, unknown>, options?: {
-        session?: ClientSession;
-    }): Promise<TDoc | null>;
-    /**
-     * Count documents
-     */
-    count(query?: Record<string, unknown>, options?: {
-        session?: ClientSession;
-    }): Promise<number>;
-    /**
-     * Check if document exists
-     */
-    exists(query: Record<string, unknown>, options?: {
-        session?: ClientSession;
-    }): Promise<{
-        _id: unknown;
-    } | null>;
-    /**
-     * Update document by ID
-     */
-    update(id: string, data: Record<string, unknown>, options?: {
-        select?: SelectSpec;
-        populate?: PopulateSpec;
-        lean?: boolean;
-        session?: ClientSession;
-    }): Promise<TDoc>;
-    /**
-     * Delete document by ID
-     */
-    delete(id: string, options?: {
-        session?: ClientSession;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    /**
-     * Execute aggregation pipeline
-     */
-    aggregate<TResult = unknown>(pipeline: PipelineStage[], options?: {
-        session?: ClientSession;
-    }): Promise<TResult[]>;
-    /**
-     * Aggregate pipeline with pagination
-     * Best for: Complex queries, grouping, joins
-     */
-    aggregatePaginate(options?: {
-        pipeline?: PipelineStage[];
-        page?: number;
-        limit?: number;
-        session?: ClientSession;
-    }): Promise<AggregatePaginationResult<TDoc>>;
-    /**
-     * Get distinct values
-     */
-    distinct<T = unknown>(field: string, query?: Record<string, unknown>, options?: {
-        session?: ClientSession;
-    }): Promise<T[]>;
-    /**
-     * Execute callback within a transaction
-     */
-    withTransaction<T>(callback: (session: ClientSession) => Promise<T>): Promise<T>;
-    /**
-     * Execute custom query with event emission
-     */
-    _executeQuery<T>(buildQuery: (Model: Model<TDoc>) => Promise<T>): Promise<T>;
-    /**
-     * Build operation context and run before hooks
-     */
-    _buildContext(operation: string, options: Record<string, unknown>): Promise<RepositoryContext>;
-    /**
-     * Parse sort string or object
-     */
-    _parseSort(sort: SortSpec | string | undefined): SortSpec;
-    /**
-     * Parse populate specification
-     */
-    _parsePopulate(populate: PopulateSpec | undefined): string[] | PopulateOptions[];
-    /**
-     * Handle errors with proper HTTP status codes
-     */
-    _handleError(error: Error): HttpError;
-}
-
-/**
- * Factory function to create a repository instance
- *
- * @param Model - Mongoose model
- * @param plugins - Array of plugins to apply
- * @returns Repository instance
- *
- * @example
- * const userRepo = createRepository(UserModel, [timestampPlugin()]);
- */
-declare function createRepository<TDoc>(Model: mongoose.Model<TDoc>, plugins?: PluginType[]): Repository<TDoc>;
-
-export { AggregatePaginationResult, AnyDocument, HttpError, KeysetPaginationResult, OffsetPaginationResult, PaginationConfig, PaginationEngine, PluginType, PopulateSpec, Repository, RepositoryContext, SelectSpec, SortSpec, createRepository, Repository as default };

package/dist/memory-cache-DqfFfKes.d.cts

@@ -1,142 +0,0 @@
-import { o as UserContext, F as FieldPreset, H as HttpError, N as CacheAdapter } from './types-Nxhmi1aI.cjs';
-
-/**
- * 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)
- *
- * @example
- * ```typescript
- * // 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 user - User object from request.user (or null for public)
- * @param preset - Field preset configuration
- * @returns Array of allowed field names
- *
- * @example
- * const fields = getFieldsForUser(request.user, {
- *   public: ['id', 'name', 'price'],
- *   authenticated: ['description', 'features'],
- *   admin: ['createdAt', 'internalNotes']
- * });
- */
-declare function getFieldsForUser(user: UserContext | null | undefined, preset: FieldPreset): string[];
-/**
- * Get Mongoose projection string for query .select()
- *
- * @param user - User object from request.user
- * @param preset - Field preset configuration
- * @returns Space-separated field names for Mongoose .select()
- *
- * @example
- * const projection = getMongooseProjection(request.user, fieldPresets.gymPlans);
- * const plans = await GymPlan.find({ organizationId }).select(projection).lean();
- */
-declare function getMongooseProjection(user: UserContext | null | undefined, preset: FieldPreset): string;
-/**
- * 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 data - Data to filter
- * @param preset - Field preset configuration
- * @param user - User object from request.user
- * @returns Filtered data
- *
- * @example
- * const stats = await calculateComplexStats();
- * const filtered = filterResponseData(stats, fieldPresets.dashboard, request.user);
- * return reply.send(filtered);
- */
-declare function filterResponseData<T extends Record<string, unknown>>(data: T | T[], preset: FieldPreset, user?: UserContext | null): Partial<T> | Partial<T>[];
-/**
- * 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 config - Field configuration
- * @returns Field preset
- *
- * @example
- * // In modules/gym-plan/gym-plan.fields.ts
- * export const gymPlanFieldPreset = createFieldPreset({
- *   public: ['id', 'name', 'price'],
- *   authenticated: ['features', 'description'],
- *   admin: ['createdAt', 'updatedAt', 'internalNotes']
- * });
- */
-declare function createFieldPreset(config: Partial<FieldPreset>): FieldPreset;
-
-/**
- * Error Utilities
- *
- * HTTP-compatible error creation for repository operations
- */
-
-/**
- * Creates an error with HTTP status code
- *
- * @param status - HTTP status code
- * @param message - Error message
- * @returns Error with status property
- *
- * @example
- * throw createError(404, 'Document not found');
- * throw createError(400, 'Invalid input');
- * throw createError(403, 'Access denied');
- */
-declare function createError(status: number, message: string): HttpError;
-
-/**
- * In-Memory Cache Adapter
- *
- * Simple cache adapter for development and testing.
- * NOT recommended for production - use Redis or similar.
- *
- * @example
- * ```typescript
- * import { cachePlugin, createMemoryCache } from '@classytic/mongokit';
- *
- * const repo = new Repository(UserModel, [
- *   cachePlugin({
- *     adapter: createMemoryCache(),
- *     ttl: 60,
- *   })
- * ]);
- * ```
- */
-
-/**
- * Creates an in-memory cache adapter
- *
- * Features:
- * - Automatic TTL expiration
- * - Pattern-based clearing (simple glob with *)
- * - Max entries limit to prevent memory leaks
- *
- * @param maxEntries - Maximum cache entries before oldest are evicted (default: 1000)
- */
-declare function createMemoryCache(maxEntries?: number): CacheAdapter;
-
-export { getMongooseProjection as a, createError as b, createFieldPreset as c, createMemoryCache as d, filterResponseData as f, getFieldsForUser as g };