@classytic/mongokit 3.2.0 → 3.2.2

package/dist/chunks/chunk-DEVXDBRL.js

@@ -1,1226 +0,0 @@
-import { upsert } from './chunk-I7CWNAJB.js';
-import { versionKey, byIdKey, byQueryKey, listQueryKey, modelPattern, getFieldsForUser } from './chunk-2ZN65ZOP.js';
-import { warn, debug } from './chunk-URLJFIR7.js';
-import { createError } from './chunk-JWUAVZ3L.js';
-import mongoose from 'mongoose';
-
-// src/plugins/field-filter.plugin.ts
-function fieldFilterPlugin(fieldPreset) {
-  return {
-    name: "fieldFilter",
-    apply(repo) {
-      const applyFieldFiltering = (context) => {
-        if (!fieldPreset) return;
-        const user = context.context?.user || context.user;
-        const fields = getFieldsForUser(user, fieldPreset);
-        const presetSelect = fields.join(" ");
-        if (context.select) {
-          context.select = `${presetSelect} ${context.select}`;
-        } else {
-          context.select = presetSelect;
-        }
-      };
-      repo.on("before:getAll", applyFieldFiltering);
-      repo.on("before:getById", applyFieldFiltering);
-      repo.on("before:getByQuery", applyFieldFiltering);
-    }
-  };
-}
-
-// src/plugins/timestamp.plugin.ts
-function timestampPlugin() {
-  return {
-    name: "timestamp",
-    apply(repo) {
-      repo.on("before:create", (context) => {
-        if (!context.data) return;
-        const now = /* @__PURE__ */ new Date();
-        if (!context.data.createdAt) context.data.createdAt = now;
-        if (!context.data.updatedAt) context.data.updatedAt = now;
-      });
-      repo.on("before:update", (context) => {
-        if (!context.data) return;
-        context.data.updatedAt = /* @__PURE__ */ new Date();
-      });
-    }
-  };
-}
-
-// src/plugins/audit-log.plugin.ts
-function auditLogPlugin(logger) {
-  return {
-    name: "auditLog",
-    apply(repo) {
-      repo.on("after:create", ({ context, result }) => {
-        logger?.info?.("Document created", {
-          model: context.model || repo.model,
-          id: result?._id,
-          userId: context.user?._id || context.user?.id,
-          organizationId: context.organizationId
-        });
-      });
-      repo.on("after:update", ({ context, result }) => {
-        logger?.info?.("Document updated", {
-          model: context.model || repo.model,
-          id: context.id || result?._id,
-          userId: context.user?._id || context.user?.id,
-          organizationId: context.organizationId
-        });
-      });
-      repo.on("after:delete", ({ context }) => {
-        logger?.info?.("Document deleted", {
-          model: context.model || repo.model,
-          id: context.id,
-          userId: context.user?._id || context.user?.id,
-          organizationId: context.organizationId
-        });
-      });
-      repo.on("error:create", ({ context, error }) => {
-        logger?.error?.("Create failed", {
-          model: context.model || repo.model,
-          error: error.message,
-          userId: context.user?._id || context.user?.id
-        });
-      });
-      repo.on("error:update", ({ context, error }) => {
-        logger?.error?.("Update failed", {
-          model: context.model || repo.model,
-          id: context.id,
-          error: error.message,
-          userId: context.user?._id || context.user?.id
-        });
-      });
-      repo.on("error:delete", ({ context, error }) => {
-        logger?.error?.("Delete failed", {
-          model: context.model || repo.model,
-          id: context.id,
-          error: error.message,
-          userId: context.user?._id || context.user?.id
-        });
-      });
-    }
-  };
-}
-
-// src/plugins/soft-delete.plugin.ts
-function buildDeletedFilter(deletedField, filterMode, includeDeleted) {
-  if (includeDeleted) {
-    return {};
-  }
-  if (filterMode === "exists") {
-    return { [deletedField]: { $exists: false } };
-  }
-  return { [deletedField]: null };
-}
-function buildGetDeletedFilter(deletedField, filterMode) {
-  if (filterMode === "exists") {
-    return { [deletedField]: { $exists: true, $ne: null } };
-  }
-  return { [deletedField]: { $ne: null } };
-}
-function softDeletePlugin(options = {}) {
-  const deletedField = options.deletedField || "deletedAt";
-  const deletedByField = options.deletedByField || "deletedBy";
-  const filterMode = options.filterMode || "null";
-  const addRestoreMethod = options.addRestoreMethod !== false;
-  const addGetDeletedMethod = options.addGetDeletedMethod !== false;
-  const ttlDays = options.ttlDays;
-  return {
-    name: "softDelete",
-    apply(repo) {
-      if (ttlDays !== void 0 && ttlDays > 0) {
-        const ttlSeconds = ttlDays * 24 * 60 * 60;
-        repo.Model.collection.createIndex(
-          { [deletedField]: 1 },
-          {
-            expireAfterSeconds: ttlSeconds,
-            partialFilterExpression: { [deletedField]: { $type: "date" } }
-          }
-        ).catch((err) => {
-          if (!err.message.includes("already exists")) {
-            warn(`[softDeletePlugin] Failed to create TTL index: ${err.message}`);
-          }
-        });
-      }
-      repo.on("before:delete", async (context) => {
-        if (options.soft !== false) {
-          const updateData = {
-            [deletedField]: /* @__PURE__ */ new Date()
-          };
-          if (context.user) {
-            updateData[deletedByField] = context.user._id || context.user.id;
-          }
-          await repo.Model.findByIdAndUpdate(context.id, updateData, { session: context.session });
-          context.softDeleted = true;
-        }
-      });
-      repo.on("before:getAll", (context) => {
-        if (options.soft !== false) {
-          const deleteFilter = buildDeletedFilter(deletedField, filterMode, !!context.includeDeleted);
-          if (Object.keys(deleteFilter).length > 0) {
-            const existingFilters = context.filters || {};
-            context.filters = {
-              ...existingFilters,
-              ...deleteFilter
-            };
-          }
-        }
-      });
-      repo.on("before:getById", (context) => {
-        if (options.soft !== false) {
-          const deleteFilter = buildDeletedFilter(deletedField, filterMode, !!context.includeDeleted);
-          if (Object.keys(deleteFilter).length > 0) {
-            context.query = {
-              ...context.query || {},
-              ...deleteFilter
-            };
-          }
-        }
-      });
-      repo.on("before:getByQuery", (context) => {
-        if (options.soft !== false) {
-          const deleteFilter = buildDeletedFilter(deletedField, filterMode, !!context.includeDeleted);
-          if (Object.keys(deleteFilter).length > 0) {
-            context.query = {
-              ...context.query || {},
-              ...deleteFilter
-            };
-          }
-        }
-      });
-      if (addRestoreMethod) {
-        const restoreMethod = async function(id, restoreOptions = {}) {
-          const updateData = {
-            [deletedField]: null,
-            [deletedByField]: null
-          };
-          const result = await this.Model.findByIdAndUpdate(id, { $set: updateData }, {
-            new: true,
-            session: restoreOptions.session
-          });
-          if (!result) {
-            const error = new Error(`Document with id '${id}' not found`);
-            error.status = 404;
-            throw error;
-          }
-          await this.emitAsync("after:restore", { id, result });
-          return result;
-        };
-        if (typeof repo.registerMethod === "function") {
-          repo.registerMethod("restore", restoreMethod);
-        } else {
-          repo.restore = restoreMethod.bind(repo);
-        }
-      }
-      if (addGetDeletedMethod) {
-        const getDeletedMethod = async function(params = {}, getDeletedOptions = {}) {
-          const deletedFilter = buildGetDeletedFilter(deletedField, filterMode);
-          const combinedFilters = {
-            ...params.filters || {},
-            ...deletedFilter
-          };
-          const page = params.page || 1;
-          const limit = params.limit || 20;
-          const skip = (page - 1) * limit;
-          let sortSpec = { [deletedField]: -1 };
-          if (params.sort) {
-            if (typeof params.sort === "string") {
-              const sortOrder = params.sort.startsWith("-") ? -1 : 1;
-              const sortField = params.sort.startsWith("-") ? params.sort.substring(1) : params.sort;
-              sortSpec = { [sortField]: sortOrder };
-            } else {
-              sortSpec = params.sort;
-            }
-          }
-          let query = this.Model.find(combinedFilters).sort(sortSpec).skip(skip).limit(limit);
-          if (getDeletedOptions.session) {
-            query = query.session(getDeletedOptions.session);
-          }
-          if (getDeletedOptions.select) {
-            const selectValue = Array.isArray(getDeletedOptions.select) ? getDeletedOptions.select.join(" ") : getDeletedOptions.select;
-            query = query.select(selectValue);
-          }
-          if (getDeletedOptions.populate) {
-            const populateSpec = getDeletedOptions.populate;
-            if (typeof populateSpec === "string") {
-              query = query.populate(populateSpec.split(",").map((p) => p.trim()));
-            } else if (Array.isArray(populateSpec)) {
-              query = query.populate(populateSpec);
-            } else {
-              query = query.populate(populateSpec);
-            }
-          }
-          if (getDeletedOptions.lean !== false) {
-            query = query.lean();
-          }
-          const [docs, total] = await Promise.all([
-            query.exec(),
-            this.Model.countDocuments(combinedFilters)
-          ]);
-          const pages = Math.ceil(total / limit);
-          return {
-            method: "offset",
-            docs,
-            page,
-            limit,
-            total,
-            pages,
-            hasNext: page < pages,
-            hasPrev: page > 1
-          };
-        };
-        if (typeof repo.registerMethod === "function") {
-          repo.registerMethod("getDeleted", getDeletedMethod);
-        } else {
-          repo.getDeleted = getDeletedMethod.bind(repo);
-        }
-      }
-    }
-  };
-}
-
-// src/plugins/method-registry.plugin.ts
-function methodRegistryPlugin() {
-  return {
-    name: "method-registry",
-    apply(repo) {
-      const registeredMethods = [];
-      repo.registerMethod = function(name, fn) {
-        if (repo[name]) {
-          throw new Error(
-            `Cannot register method '${name}': Method already exists on repository. Choose a different name or use a plugin that doesn't conflict.`
-          );
-        }
-        if (!name || typeof name !== "string") {
-          throw new Error("Method name must be a non-empty string");
-        }
-        if (typeof fn !== "function") {
-          throw new Error(`Method '${name}' must be a function`);
-        }
-        repo[name] = fn.bind(repo);
-        registeredMethods.push(name);
-        repo.emit("method:registered", { name, fn });
-      };
-      repo.hasMethod = function(name) {
-        return typeof repo[name] === "function";
-      };
-      repo.getRegisteredMethods = function() {
-        return [...registeredMethods];
-      };
-    }
-  };
-}
-
-// src/plugins/validation-chain.plugin.ts
-function validationChainPlugin(validators = [], options = {}) {
-  const { stopOnFirstError = true } = options;
-  validators.forEach((v, idx) => {
-    if (!v.name || typeof v.name !== "string") {
-      throw new Error(`Validator at index ${idx} missing 'name' (string)`);
-    }
-    if (typeof v.validate !== "function") {
-      throw new Error(`Validator '${v.name}' missing 'validate' function`);
-    }
-  });
-  const validatorsByOperation = {
-    create: [],
-    update: [],
-    delete: [],
-    createMany: []
-  };
-  const allOperationsValidators = [];
-  validators.forEach((v) => {
-    if (!v.operations || v.operations.length === 0) {
-      allOperationsValidators.push(v);
-    } else {
-      v.operations.forEach((op) => {
-        if (validatorsByOperation[op]) {
-          validatorsByOperation[op].push(v);
-        }
-      });
-    }
-  });
-  return {
-    name: "validation-chain",
-    apply(repo) {
-      const getValidatorsForOperation = (operation) => {
-        const specific = validatorsByOperation[operation] || [];
-        return [...allOperationsValidators, ...specific];
-      };
-      const runValidators = async (operation, context) => {
-        const operationValidators = getValidatorsForOperation(operation);
-        const errors = [];
-        for (const validator of operationValidators) {
-          try {
-            await validator.validate(context, repo);
-          } catch (error) {
-            if (stopOnFirstError) {
-              throw error;
-            }
-            errors.push({
-              validator: validator.name,
-              error: error.message || String(error)
-            });
-          }
-        }
-        if (errors.length > 0) {
-          const err = createError(
-            400,
-            `Validation failed: ${errors.map((e) => `[${e.validator}] ${e.error}`).join("; ")}`
-          );
-          err.validationErrors = errors;
-          throw err;
-        }
-      };
-      repo.on("before:create", async (context) => runValidators("create", context));
-      repo.on("before:createMany", async (context) => runValidators("createMany", context));
-      repo.on("before:update", async (context) => runValidators("update", context));
-      repo.on("before:delete", async (context) => runValidators("delete", context));
-    }
-  };
-}
-function blockIf(name, operations, condition, errorMessage) {
-  return {
-    name,
-    operations,
-    validate: (context) => {
-      if (condition(context)) {
-        throw createError(403, errorMessage);
-      }
-    }
-  };
-}
-function requireField(field, operations = ["create"]) {
-  return {
-    name: `require-${field}`,
-    operations,
-    validate: (context) => {
-      if (!context.data || context.data[field] === void 0 || context.data[field] === null) {
-        throw createError(400, `Field '${field}' is required`);
-      }
-    }
-  };
-}
-function autoInject(field, getter, operations = ["create"]) {
-  return {
-    name: `auto-inject-${field}`,
-    operations,
-    validate: (context) => {
-      if (context.data && !(field in context.data)) {
-        const value = getter(context);
-        if (value !== null && value !== void 0) {
-          context.data[field] = value;
-        }
-      }
-    }
-  };
-}
-function immutableField(field) {
-  return {
-    name: `immutable-${field}`,
-    operations: ["update"],
-    validate: (context) => {
-      if (context.data && field in context.data) {
-        throw createError(400, `Field '${field}' cannot be modified`);
-      }
-    }
-  };
-}
-function uniqueField(field, errorMessage) {
-  return {
-    name: `unique-${field}`,
-    operations: ["create", "update"],
-    validate: async (context, repo) => {
-      if (!context.data || !context.data[field] || !repo) return;
-      const query = { [field]: context.data[field] };
-      const getByQuery = repo.getByQuery;
-      if (typeof getByQuery !== "function") return;
-      const existing = await getByQuery.call(repo, query, {
-        select: "_id",
-        lean: true,
-        throwOnNotFound: false
-      });
-      if (existing && String(existing._id) !== String(context.id)) {
-        throw createError(409, errorMessage || `${field} already exists`);
-      }
-    }
-  };
-}
-
-// src/plugins/mongo-operations.plugin.ts
-function mongoOperationsPlugin() {
-  return {
-    name: "mongo-operations",
-    apply(repo) {
-      if (!repo.registerMethod) {
-        throw new Error(
-          "mongoOperationsPlugin requires methodRegistryPlugin. Add methodRegistryPlugin() before mongoOperationsPlugin() in plugins array."
-        );
-      }
-      repo.registerMethod("upsert", async function(query, data, options = {}) {
-        return upsert(this.Model, query, data, options);
-      });
-      const validateAndUpdateNumeric = async function(id, field, value, operator, operationName, options) {
-        if (typeof value !== "number") {
-          throw createError(400, `${operationName} value must be a number`);
-        }
-        return this.update(id, { [operator]: { [field]: value } }, options);
-      };
-      repo.registerMethod("increment", async function(id, field, value = 1, options = {}) {
-        return validateAndUpdateNumeric.call(this, id, field, value, "$inc", "Increment", options);
-      });
-      repo.registerMethod("decrement", async function(id, field, value = 1, options = {}) {
-        return validateAndUpdateNumeric.call(this, id, field, -value, "$inc", "Decrement", options);
-      });
-      const applyOperator = function(id, field, value, operator, options) {
-        return this.update(id, { [operator]: { [field]: value } }, options);
-      };
-      repo.registerMethod("pushToArray", async function(id, field, value, options = {}) {
-        return applyOperator.call(this, id, field, value, "$push", options);
-      });
-      repo.registerMethod("pullFromArray", async function(id, field, value, options = {}) {
-        return applyOperator.call(this, id, field, value, "$pull", options);
-      });
-      repo.registerMethod("addToSet", async function(id, field, value, options = {}) {
-        return applyOperator.call(this, id, field, value, "$addToSet", options);
-      });
-      repo.registerMethod("setField", async function(id, field, value, options = {}) {
-        return applyOperator.call(this, id, field, value, "$set", options);
-      });
-      repo.registerMethod("unsetField", async function(id, fields, options = {}) {
-        const fieldArray = Array.isArray(fields) ? fields : [fields];
-        const unsetObj = fieldArray.reduce((acc, field) => {
-          acc[field] = "";
-          return acc;
-        }, {});
-        return this.update(id, { $unset: unsetObj }, options);
-      });
-      repo.registerMethod("renameField", async function(id, oldName, newName, options = {}) {
-        return this.update(id, { $rename: { [oldName]: newName } }, options);
-      });
-      repo.registerMethod("multiplyField", async function(id, field, multiplier, options = {}) {
-        return validateAndUpdateNumeric.call(this, id, field, multiplier, "$mul", "Multiplier", options);
-      });
-      repo.registerMethod("setMin", async function(id, field, value, options = {}) {
-        return applyOperator.call(this, id, field, value, "$min", options);
-      });
-      repo.registerMethod("setMax", async function(id, field, value, options = {}) {
-        return applyOperator.call(this, id, field, value, "$max", options);
-      });
-    }
-  };
-}
-
-// src/plugins/batch-operations.plugin.ts
-function batchOperationsPlugin() {
-  return {
-    name: "batch-operations",
-    apply(repo) {
-      if (!repo.registerMethod) {
-        throw new Error("batchOperationsPlugin requires methodRegistryPlugin");
-      }
-      repo.registerMethod("updateMany", async function(query, data, options = {}) {
-        const _buildContext = this._buildContext;
-        const context = await _buildContext.call(this, "updateMany", { query, data, options });
-        try {
-          this.emit("before:updateMany", context);
-          if (Array.isArray(data) && options.updatePipeline !== true) {
-            throw createError(
-              400,
-              "Update pipelines (array updates) are disabled by default; pass `{ updatePipeline: true }` to explicitly allow pipeline-style updates."
-            );
-          }
-          const result = await this.Model.updateMany(query, data, {
-            runValidators: true,
-            session: options.session,
-            ...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
-          }).exec();
-          this.emit("after:updateMany", { context, result });
-          return result;
-        } catch (error) {
-          this.emit("error:updateMany", { context, error });
-          const _handleError = this._handleError;
-          throw _handleError.call(this, error);
-        }
-      });
-      repo.registerMethod("deleteMany", async function(query, options = {}) {
-        const _buildContext = this._buildContext;
-        const context = await _buildContext.call(this, "deleteMany", { query, options });
-        try {
-          this.emit("before:deleteMany", context);
-          const result = await this.Model.deleteMany(query, {
-            session: options.session
-          }).exec();
-          this.emit("after:deleteMany", { context, result });
-          return result;
-        } catch (error) {
-          this.emit("error:deleteMany", { context, error });
-          const _handleError = this._handleError;
-          throw _handleError.call(this, error);
-        }
-      });
-    }
-  };
-}
-
-// src/plugins/aggregate-helpers.plugin.ts
-function aggregateHelpersPlugin() {
-  return {
-    name: "aggregate-helpers",
-    apply(repo) {
-      if (!repo.registerMethod) {
-        throw new Error("aggregateHelpersPlugin requires methodRegistryPlugin");
-      }
-      repo.registerMethod("groupBy", async function(field, options = {}) {
-        const pipeline = [
-          { $group: { _id: `$${field}`, count: { $sum: 1 } } },
-          { $sort: { count: -1 } }
-        ];
-        if (options.limit) {
-          pipeline.push({ $limit: options.limit });
-        }
-        const aggregate = this.aggregate;
-        return aggregate.call(this, pipeline, options);
-      });
-      const aggregateOperation = async function(field, operator, resultKey, query = {}, options = {}) {
-        const pipeline = [
-          { $match: query },
-          { $group: { _id: null, [resultKey]: { [operator]: `$${field}` } } }
-        ];
-        const aggregate = this.aggregate;
-        const result = await aggregate.call(this, pipeline, options);
-        return result[0]?.[resultKey] || 0;
-      };
-      repo.registerMethod("sum", async function(field, query = {}, options = {}) {
-        return aggregateOperation.call(this, field, "$sum", "total", query, options);
-      });
-      repo.registerMethod("average", async function(field, query = {}, options = {}) {
-        return aggregateOperation.call(this, field, "$avg", "avg", query, options);
-      });
-      repo.registerMethod("min", async function(field, query = {}, options = {}) {
-        return aggregateOperation.call(this, field, "$min", "min", query, options);
-      });
-      repo.registerMethod("max", async function(field, query = {}, options = {}) {
-        return aggregateOperation.call(this, field, "$max", "max", query, options);
-      });
-    }
-  };
-}
-
-// src/plugins/subdocument.plugin.ts
-function subdocumentPlugin() {
-  return {
-    name: "subdocument",
-    apply(repo) {
-      if (!repo.registerMethod) {
-        throw new Error("subdocumentPlugin requires methodRegistryPlugin");
-      }
-      repo.registerMethod("addSubdocument", async function(parentId, arrayPath, subData, options = {}) {
-        const update = this.update;
-        return update.call(this, parentId, { $push: { [arrayPath]: subData } }, options);
-      });
-      repo.registerMethod("getSubdocument", async function(parentId, arrayPath, subId, options = {}) {
-        const _executeQuery = this._executeQuery;
-        return _executeQuery.call(this, async (Model) => {
-          const parent = await Model.findById(parentId).session(options.session).exec();
-          if (!parent) throw createError(404, "Parent not found");
-          const parentObj = parent;
-          const arrayField = parentObj[arrayPath];
-          if (!arrayField || typeof arrayField.id !== "function") {
-            throw createError(404, "Array field not found");
-          }
-          const sub = arrayField.id(subId);
-          if (!sub) throw createError(404, "Subdocument not found");
-          return options.lean && typeof sub.toObject === "function" ? sub.toObject() : sub;
-        });
-      });
-      repo.registerMethod("updateSubdocument", async function(parentId, arrayPath, subId, updateData, options = {}) {
-        const _executeQuery = this._executeQuery;
-        return _executeQuery.call(this, async (Model) => {
-          const query = { _id: parentId, [`${arrayPath}._id`]: subId };
-          const update = { $set: { [`${arrayPath}.$`]: { ...updateData, _id: subId } } };
-          const result = await Model.findOneAndUpdate(query, update, {
-            new: true,
-            runValidators: true,
-            session: options.session
-          }).exec();
-          if (!result) throw createError(404, "Parent or subdocument not found");
-          return result;
-        });
-      });
-      repo.registerMethod("deleteSubdocument", async function(parentId, arrayPath, subId, options = {}) {
-        const update = this.update;
-        return update.call(this, parentId, { $pull: { [arrayPath]: { _id: subId } } }, options);
-      });
-    }
-  };
-}
-
-// src/plugins/cache.plugin.ts
-function cachePlugin(options) {
-  const config = {
-    adapter: options.adapter,
-    ttl: options.ttl ?? 60,
-    byIdTtl: options.byIdTtl ?? options.ttl ?? 60,
-    queryTtl: options.queryTtl ?? options.ttl ?? 60,
-    prefix: options.prefix ?? "mk",
-    debug: options.debug ?? false,
-    skipIfLargeLimit: options.skipIf?.largeLimit ?? 100
-  };
-  const stats = {
-    hits: 0,
-    misses: 0,
-    sets: 0,
-    invalidations: 0
-  };
-  let collectionVersion = 0;
-  const log = (msg, data) => {
-    if (config.debug) {
-      debug(`[mongokit:cache] ${msg}`, data ?? "");
-    }
-  };
-  return {
-    name: "cache",
-    apply(repo) {
-      const model = repo.model;
-      (async () => {
-        try {
-          const cached = await config.adapter.get(versionKey(config.prefix, model));
-          if (cached !== null) {
-            collectionVersion = cached;
-            log(`Initialized version for ${model}:`, collectionVersion);
-          }
-        } catch (e) {
-          log(`Failed to initialize version for ${model}:`, e);
-        }
-      })();
-      async function bumpVersion() {
-        collectionVersion++;
-        try {
-          await config.adapter.set(versionKey(config.prefix, model), collectionVersion, config.ttl * 10);
-          stats.invalidations++;
-          log(`Bumped version for ${model} to:`, collectionVersion);
-        } catch (e) {
-          log(`Failed to bump version for ${model}:`, e);
-        }
-      }
-      async function invalidateById(id) {
-        const key = byIdKey(config.prefix, model, id);
-        try {
-          await config.adapter.del(key);
-          stats.invalidations++;
-          log(`Invalidated byId cache:`, key);
-        } catch (e) {
-          log(`Failed to invalidate byId cache:`, e);
-        }
-      }
-      repo.on("before:getById", async (context) => {
-        if (context.skipCache) {
-          log(`Skipping cache for getById: ${context.id}`);
-          return;
-        }
-        const id = String(context.id);
-        const key = byIdKey(config.prefix, model, id);
-        try {
-          const cached = await config.adapter.get(key);
-          if (cached !== null) {
-            stats.hits++;
-            log(`Cache HIT for getById:`, key);
-            context._cacheHit = true;
-            context._cachedResult = cached;
-          } else {
-            stats.misses++;
-            log(`Cache MISS for getById:`, key);
-          }
-        } catch (e) {
-          log(`Cache error for getById:`, e);
-          stats.misses++;
-        }
-      });
-      repo.on("before:getByQuery", async (context) => {
-        if (context.skipCache) {
-          log(`Skipping cache for getByQuery`);
-          return;
-        }
-        const query = context.query || {};
-        const key = byQueryKey(config.prefix, model, query, {
-          select: context.select,
-          populate: context.populate
-        });
-        try {
-          const cached = await config.adapter.get(key);
-          if (cached !== null) {
-            stats.hits++;
-            log(`Cache HIT for getByQuery:`, key);
-            context._cacheHit = true;
-            context._cachedResult = cached;
-          } else {
-            stats.misses++;
-            log(`Cache MISS for getByQuery:`, key);
-          }
-        } catch (e) {
-          log(`Cache error for getByQuery:`, e);
-          stats.misses++;
-        }
-      });
-      repo.on("before:getAll", async (context) => {
-        if (context.skipCache) {
-          log(`Skipping cache for getAll`);
-          return;
-        }
-        const limit = context.limit;
-        if (limit && limit > config.skipIfLargeLimit) {
-          log(`Skipping cache for large query (limit: ${limit})`);
-          return;
-        }
-        const params = {
-          filters: context.filters,
-          sort: context.sort,
-          page: context.page,
-          limit,
-          after: context.after,
-          select: context.select,
-          populate: context.populate,
-          search: context.search
-        };
-        const key = listQueryKey(config.prefix, model, collectionVersion, params);
-        try {
-          const cached = await config.adapter.get(key);
-          if (cached !== null) {
-            stats.hits++;
-            log(`Cache HIT for getAll:`, key);
-            context._cacheHit = true;
-            context._cachedResult = cached;
-          } else {
-            stats.misses++;
-            log(`Cache MISS for getAll:`, key);
-          }
-        } catch (e) {
-          log(`Cache error for getAll:`, e);
-          stats.misses++;
-        }
-      });
-      repo.on("after:getById", async (payload) => {
-        const { context, result } = payload;
-        if (context._cacheHit) return;
-        if (context.skipCache) return;
-        if (result === null) return;
-        const id = String(context.id);
-        const key = byIdKey(config.prefix, model, id);
-        const ttl = context.cacheTtl ?? config.byIdTtl;
-        try {
-          await config.adapter.set(key, result, ttl);
-          stats.sets++;
-          log(`Cached getById result:`, key);
-        } catch (e) {
-          log(`Failed to cache getById:`, e);
-        }
-      });
-      repo.on("after:getByQuery", async (payload) => {
-        const { context, result } = payload;
-        if (context._cacheHit) return;
-        if (context.skipCache) return;
-        if (result === null) return;
-        const query = context.query || {};
-        const key = byQueryKey(config.prefix, model, query, {
-          select: context.select,
-          populate: context.populate
-        });
-        const ttl = context.cacheTtl ?? config.queryTtl;
-        try {
-          await config.adapter.set(key, result, ttl);
-          stats.sets++;
-          log(`Cached getByQuery result:`, key);
-        } catch (e) {
-          log(`Failed to cache getByQuery:`, e);
-        }
-      });
-      repo.on("after:getAll", async (payload) => {
-        const { context, result } = payload;
-        if (context._cacheHit) return;
-        if (context.skipCache) return;
-        const limit = context.limit;
-        if (limit && limit > config.skipIfLargeLimit) return;
-        const params = {
-          filters: context.filters,
-          sort: context.sort,
-          page: context.page,
-          limit,
-          after: context.after,
-          select: context.select,
-          populate: context.populate,
-          search: context.search
-        };
-        const key = listQueryKey(config.prefix, model, collectionVersion, params);
-        const ttl = context.cacheTtl ?? config.queryTtl;
-        try {
-          await config.adapter.set(key, result, ttl);
-          stats.sets++;
-          log(`Cached getAll result:`, key);
-        } catch (e) {
-          log(`Failed to cache getAll:`, e);
-        }
-      });
-      repo.on("after:create", async () => {
-        await bumpVersion();
-      });
-      repo.on("after:createMany", async () => {
-        await bumpVersion();
-      });
-      repo.on("after:update", async (payload) => {
-        const { context } = payload;
-        const id = String(context.id);
-        await Promise.all([
-          invalidateById(id),
-          bumpVersion()
-        ]);
-      });
-      repo.on("after:updateMany", async () => {
-        await bumpVersion();
-      });
-      repo.on("after:delete", async (payload) => {
-        const { context } = payload;
-        const id = String(context.id);
-        await Promise.all([
-          invalidateById(id),
-          bumpVersion()
-        ]);
-      });
-      repo.on("after:deleteMany", async () => {
-        await bumpVersion();
-      });
-      repo.invalidateCache = async (id) => {
-        await invalidateById(id);
-        log(`Manual invalidation for ID:`, id);
-      };
-      repo.invalidateListCache = async () => {
-        await bumpVersion();
-        log(`Manual list cache invalidation for ${model}`);
-      };
-      repo.invalidateAllCache = async () => {
-        if (config.adapter.clear) {
-          try {
-            await config.adapter.clear(modelPattern(config.prefix, model));
-            stats.invalidations++;
-            log(`Full cache invalidation for ${model}`);
-          } catch (e) {
-            log(`Failed full cache invalidation for ${model}:`, e);
-          }
-        } else {
-          await bumpVersion();
-          log(`Partial cache invalidation for ${model} (adapter.clear not available)`);
-        }
-      };
-      repo.getCacheStats = () => ({ ...stats });
-      repo.resetCacheStats = () => {
-        stats.hits = 0;
-        stats.misses = 0;
-        stats.sets = 0;
-        stats.invalidations = 0;
-      };
-    }
-  };
-}
-function cascadePlugin(options) {
-  const { relations, parallel = true, logger } = options;
-  if (!relations || relations.length === 0) {
-    throw new Error("cascadePlugin requires at least one relation");
-  }
-  return {
-    name: "cascade",
-    apply(repo) {
-      repo.on("after:delete", async (payload) => {
-        const { context } = payload;
-        const deletedId = context.id;
-        if (!deletedId) {
-          logger?.warn?.("Cascade delete skipped: no document ID in context", {
-            model: context.model
-          });
-          return;
-        }
-        const isSoftDelete = context.softDeleted === true;
-        const cascadeDelete = async (relation) => {
-          const RelatedModel = mongoose.models[relation.model];
-          if (!RelatedModel) {
-            logger?.warn?.(`Cascade delete skipped: model '${relation.model}' not found`, {
-              parentModel: context.model,
-              parentId: String(deletedId)
-            });
-            return;
-          }
-          const query = { [relation.foreignKey]: deletedId };
-          try {
-            const shouldSoftDelete = relation.softDelete ?? isSoftDelete;
-            if (shouldSoftDelete) {
-              const updateResult = await RelatedModel.updateMany(
-                query,
-                {
-                  deletedAt: /* @__PURE__ */ new Date(),
-                  ...context.user ? { deletedBy: context.user._id || context.user.id } : {}
-                },
-                { session: context.session }
-              );
-              logger?.info?.(`Cascade soft-deleted ${updateResult.modifiedCount} documents`, {
-                parentModel: context.model,
-                parentId: String(deletedId),
-                relatedModel: relation.model,
-                foreignKey: relation.foreignKey,
-                count: updateResult.modifiedCount
-              });
-            } else {
-              const deleteResult = await RelatedModel.deleteMany(query, {
-                session: context.session
-              });
-              logger?.info?.(`Cascade deleted ${deleteResult.deletedCount} documents`, {
-                parentModel: context.model,
-                parentId: String(deletedId),
-                relatedModel: relation.model,
-                foreignKey: relation.foreignKey,
-                count: deleteResult.deletedCount
-              });
-            }
-          } catch (error) {
-            logger?.error?.(`Cascade delete failed for model '${relation.model}'`, {
-              parentModel: context.model,
-              parentId: String(deletedId),
-              relatedModel: relation.model,
-              foreignKey: relation.foreignKey,
-              error: error.message
-            });
-            throw error;
-          }
-        };
-        if (parallel) {
-          const results = await Promise.allSettled(relations.map(cascadeDelete));
-          const failures = results.filter((r) => r.status === "rejected");
-          if (failures.length) {
-            const err = failures[0].reason;
-            if (failures.length > 1) {
-              err.message = `${failures.length} cascade deletes failed. First: ${err.message}`;
-            }
-            throw err;
-          }
-        } else {
-          for (const relation of relations) {
-            await cascadeDelete(relation);
-          }
-        }
-      });
-      repo.on("after:deleteMany", async (payload) => {
-        const { context, result } = payload;
-        const query = context.query;
-        if (!query || Object.keys(query).length === 0) {
-          logger?.warn?.("Cascade deleteMany skipped: empty query", {
-            model: context.model
-          });
-          return;
-        }
-        logger?.warn?.("Cascade deleteMany: use before:deleteMany hook for complete cascade support", {
-          model: context.model
-        });
-      });
-      repo.on("before:deleteMany", async (context) => {
-        const query = context.query;
-        if (!query || Object.keys(query).length === 0) {
-          return;
-        }
-        const docs = await repo.Model.find(query, { _id: 1 }).lean().session(context.session ?? null);
-        const ids = docs.map((doc) => doc._id);
-        context._cascadeIds = ids;
-      });
-      const originalAfterDeleteMany = repo._hooks.get("after:deleteMany") || [];
-      repo._hooks.set("after:deleteMany", [
-        ...originalAfterDeleteMany,
-        async (payload) => {
-          const { context } = payload;
-          const ids = context._cascadeIds;
-          if (!ids || ids.length === 0) {
-            return;
-          }
-          const isSoftDelete = context.softDeleted === true;
-          const cascadeDeleteMany = async (relation) => {
-            const RelatedModel = mongoose.models[relation.model];
-            if (!RelatedModel) {
-              logger?.warn?.(`Cascade deleteMany skipped: model '${relation.model}' not found`, {
-                parentModel: context.model
-              });
-              return;
-            }
-            const query = { [relation.foreignKey]: { $in: ids } };
-            const shouldSoftDelete = relation.softDelete ?? isSoftDelete;
-            try {
-              if (shouldSoftDelete) {
-                const updateResult = await RelatedModel.updateMany(
-                  query,
-                  {
-                    deletedAt: /* @__PURE__ */ new Date(),
-                    ...context.user ? { deletedBy: context.user._id || context.user.id } : {}
-                  },
-                  { session: context.session }
-                );
-                logger?.info?.(`Cascade soft-deleted ${updateResult.modifiedCount} documents (bulk)`, {
-                  parentModel: context.model,
-                  parentCount: ids.length,
-                  relatedModel: relation.model,
-                  foreignKey: relation.foreignKey,
-                  count: updateResult.modifiedCount
-                });
-              } else {
-                const deleteResult = await RelatedModel.deleteMany(query, {
-                  session: context.session
-                });
-                logger?.info?.(`Cascade deleted ${deleteResult.deletedCount} documents (bulk)`, {
-                  parentModel: context.model,
-                  parentCount: ids.length,
-                  relatedModel: relation.model,
-                  foreignKey: relation.foreignKey,
-                  count: deleteResult.deletedCount
-                });
-              }
-            } catch (error) {
-              logger?.error?.(`Cascade deleteMany failed for model '${relation.model}'`, {
-                parentModel: context.model,
-                relatedModel: relation.model,
-                foreignKey: relation.foreignKey,
-                error: error.message
-              });
-              throw error;
-            }
-          };
-          if (parallel) {
-            const results = await Promise.allSettled(relations.map(cascadeDeleteMany));
-            const failures = results.filter((r) => r.status === "rejected");
-            if (failures.length) {
-              const err = failures[0].reason;
-              if (failures.length > 1) {
-                err.message = `${failures.length} cascade deletes failed. First: ${err.message}`;
-              }
-              throw err;
-            }
-          } else {
-            for (const relation of relations) {
-              await cascadeDeleteMany(relation);
-            }
-          }
-        }
-      ]);
-    }
-  };
-}
-
-// src/plugins/multi-tenant.plugin.ts
-function multiTenantPlugin(options = {}) {
-  const {
-    tenantField = "organizationId",
-    contextKey = "organizationId",
-    required = true,
-    skipOperations = [],
-    skipWhen,
-    resolveContext
-  } = options;
-  const readOps = ["getById", "getByQuery", "getAll", "aggregatePaginate", "lookupPopulate"];
-  const writeOps = ["create", "createMany", "update", "delete"];
-  const allOps = [...readOps, ...writeOps];
-  return {
-    name: "multi-tenant",
-    apply(repo) {
-      for (const op of allOps) {
-        if (skipOperations.includes(op)) continue;
-        repo.on(`before:${op}`, (context) => {
-          if (skipWhen?.(context, op)) return;
-          let tenantId = context[contextKey];
-          if (!tenantId && resolveContext) {
-            tenantId = resolveContext();
-            if (tenantId) context[contextKey] = tenantId;
-          }
-          if (!tenantId && required) {
-            throw new Error(
-              `[mongokit] Multi-tenant: Missing '${contextKey}' in context for '${op}'. Pass it via options or set required: false.`
-            );
-          }
-          if (!tenantId) return;
-          if (readOps.includes(op)) {
-            if (op === "getAll" || op === "aggregatePaginate" || op === "lookupPopulate") {
-              context.filters = { ...context.filters, [tenantField]: tenantId };
-            } else {
-              context.query = { ...context.query, [tenantField]: tenantId };
-            }
-          }
-          if (op === "create" && context.data) {
-            context.data[tenantField] = tenantId;
-          }
-          if (op === "createMany" && context.dataArray) {
-            for (const doc of context.dataArray) {
-              doc[tenantField] = tenantId;
-            }
-          }
-          if (op === "update" || op === "delete") {
-            context.query = { ...context.query, [tenantField]: tenantId };
-          }
-        });
-      }
-    }
-  };
-}
-
-// src/plugins/observability.plugin.ts
-var DEFAULT_OPS = [
-  "create",
-  "createMany",
-  "update",
-  "delete",
-  "getById",
-  "getByQuery",
-  "getAll",
-  "aggregatePaginate",
-  "lookupPopulate"
-];
-var timers = /* @__PURE__ */ new WeakMap();
-function observabilityPlugin(options) {
-  const { onMetric, slowThresholdMs } = options;
-  const ops = options.operations ?? DEFAULT_OPS;
-  return {
-    name: "observability",
-    apply(repo) {
-      for (const op of ops) {
-        repo.on(`before:${op}`, (context) => {
-          timers.set(context, performance.now());
-        });
-        repo.on(`after:${op}`, ({ context }) => {
-          const start = timers.get(context);
-          if (start == null) return;
-          const durationMs = Math.round((performance.now() - start) * 100) / 100;
-          timers.delete(context);
-          if (slowThresholdMs != null && durationMs < slowThresholdMs) return;
-          onMetric({
-            operation: op,
-            model: context.model || repo.model,
-            durationMs,
-            success: true,
-            startedAt: new Date(Date.now() - durationMs),
-            userId: context.user?._id?.toString() || context.user?.id?.toString(),
-            organizationId: context.organizationId?.toString()
-          });
-        });
-        repo.on(`error:${op}`, ({ context, error }) => {
-          const start = timers.get(context);
-          if (start == null) return;
-          const durationMs = Math.round((performance.now() - start) * 100) / 100;
-          timers.delete(context);
-          onMetric({
-            operation: op,
-            model: context.model || repo.model,
-            durationMs,
-            success: false,
-            error: error.message,
-            startedAt: new Date(Date.now() - durationMs),
-            userId: context.user?._id?.toString() || context.user?.id?.toString(),
-            organizationId: context.organizationId?.toString()
-          });
-        });
-      }
-    }
-  };
-}
-
-export { aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, cascadePlugin, fieldFilterPlugin, immutableField, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, requireField, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };