@classytic/mongokit 1.0.2 → 2.1.0

package/dist/plugins/index.js

@@ -0,0 +1,857 @@
+// src/utils/field-selection.ts
+function getFieldsForUser(user, preset) {
+  if (!preset) {
+    throw new Error("Field preset is required");
+  }
+  const fields = [...preset.public || []];
+  if (user) {
+    fields.push(...preset.authenticated || []);
+    const roles = Array.isArray(user.roles) ? user.roles : user.roles ? [user.roles] : [];
+    if (roles.includes("admin") || roles.includes("superadmin")) {
+      fields.push(...preset.admin || []);
+    }
+  }
+  return [...new Set(fields)];
+}
+
+// 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 softDeletePlugin(options = {}) {
+  const deletedField = options.deletedField || "deletedAt";
+  const deletedByField = options.deletedByField || "deletedBy";
+  return {
+    name: "softDelete",
+    apply(repo) {
+      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 (!context.includeDeleted && options.soft !== false) {
+          const queryParams = context.queryParams || {};
+          queryParams.filters = {
+            ...queryParams.filters || {},
+            [deletedField]: { $exists: false }
+          };
+          context.queryParams = queryParams;
+        }
+      });
+      repo.on("before:getById", (context) => {
+        if (!context.includeDeleted && options.soft !== false) {
+          context.query = {
+            ...context.query || {},
+            [deletedField]: { $exists: false }
+          };
+        }
+      });
+    }
+  };
+}
+
+// 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/utils/error.ts
+function createError(status, message) {
+  const error = new Error(message);
+  error.status = status;
+  return error;
+}
+
+// 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/actions/create.ts
+async function upsert(Model, query, data, options = {}) {
+  return Model.findOneAndUpdate(
+    query,
+    { $setOnInsert: data },
+    {
+      upsert: true,
+      new: true,
+      runValidators: true,
+      session: options.session,
+      ...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
+    }
+  );
+}
+
+// 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);
+          const result = await this.Model.updateMany(query, data, {
+            runValidators: true,
+            session: options.session
+          }).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/utils/cache-keys.ts
+function hashString(str) {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) + hash ^ str.charCodeAt(i);
+  }
+  return (hash >>> 0).toString(16);
+}
+function stableStringify(obj) {
+  if (obj === null || obj === void 0) return "";
+  if (typeof obj !== "object") return String(obj);
+  if (Array.isArray(obj)) {
+    return "[" + obj.map(stableStringify).join(",") + "]";
+  }
+  const sorted = Object.keys(obj).sort().map((key) => `${key}:${stableStringify(obj[key])}`);
+  return "{" + sorted.join(",") + "}";
+}
+function byIdKey(prefix, model, id) {
+  return `${prefix}:id:${model}:${id}`;
+}
+function byQueryKey(prefix, model, query, options) {
+  const hashInput = stableStringify({ q: query, s: options?.select, p: options?.populate });
+  return `${prefix}:one:${model}:${hashString(hashInput)}`;
+}
+function listQueryKey(prefix, model, version, params) {
+  const hashInput = stableStringify({
+    f: params.filters,
+    s: params.sort,
+    pg: params.page,
+    lm: params.limit,
+    af: params.after,
+    sl: params.select,
+    pp: params.populate
+  });
+  return `${prefix}:list:${model}:${version}:${hashString(hashInput)}`;
+}
+function versionKey(prefix, model) {
+  return `${prefix}:ver:${model}`;
+}
+function modelPattern(prefix, model) {
+  return `${prefix}:*:${model}:*`;
+}
+
+// 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) {
+      console.log(`[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
+        };
+        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
+        };
+        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;
+      };
+    }
+  };
+}
+
+export { aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, fieldFilterPlugin, immutableField, methodRegistryPlugin, mongoOperationsPlugin, requireField, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map