@classytic/mongokit 3.1.0 → 3.1.1

package/dist/actions/index.d.ts

@@ -1,3 +1,3 @@
-export { b as aggregate, c as create, _ as deleteActions, r as read, u as update } from '../index-3Nkm_Brq.js';
+export { b as aggregate, c as create, _ as deleteActions, r as read, u as update } from '../index-C2NCVxJK.js';
 import 'mongoose';
-import '../types-CrSoCuWu.js';
+import '../types-DA0rs2Jh.js';

package/dist/actions/index.js

@@ -1,515 +1,3 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/actions/create.ts
-var create_exports = {};
-__export(create_exports, {
-  create: () => create,
-  createDefault: () => createDefault,
-  createMany: () => createMany,
-  upsert: () => upsert
-});
-async function create(Model, data, options = {}) {
-  const document = new Model(data);
-  await document.save({ session: options.session });
-  return document;
-}
-async function createMany(Model, dataArray, options = {}) {
-  return Model.insertMany(dataArray, {
-    session: options.session,
-    ordered: options.ordered !== false
-  });
-}
-async function createDefault(Model, overrides = {}, options = {}) {
-  const defaults = {};
-  Model.schema.eachPath((path, schemaType) => {
-    const schemaOptions = schemaType.options;
-    if (schemaOptions.default !== void 0 && path !== "_id") {
-      defaults[path] = typeof schemaOptions.default === "function" ? schemaOptions.default() : schemaOptions.default;
-    }
-  });
-  return create(Model, { ...defaults, ...overrides }, options);
-}
-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/actions/read.ts
-var read_exports = {};
-__export(read_exports, {
-  count: () => count,
-  exists: () => exists,
-  getAll: () => getAll,
-  getById: () => getById,
-  getByQuery: () => getByQuery,
-  getOrCreate: () => getOrCreate,
-  tryGetByQuery: () => tryGetByQuery
-});
-
-// src/utils/error.ts
-function createError(status, message) {
-  const error = new Error(message);
-  error.status = status;
-  return error;
-}
-
-// src/actions/read.ts
-function parsePopulate(populate) {
-  if (!populate) return [];
-  if (typeof populate === "string") {
-    return populate.split(",").map((p) => p.trim());
-  }
-  if (Array.isArray(populate)) {
-    return populate.map((p) => typeof p === "string" ? p.trim() : p);
-  }
-  return [populate];
-}
-async function getById(Model, id, options = {}) {
-  const query = options.query ? Model.findOne({ _id: id, ...options.query }) : Model.findById(id);
-  if (options.select) query.select(options.select);
-  if (options.populate) query.populate(parsePopulate(options.populate));
-  if (options.lean) query.lean();
-  if (options.session) query.session(options.session);
-  const document = await query.exec();
-  if (!document && options.throwOnNotFound !== false) {
-    throw createError(404, "Document not found");
-  }
-  return document;
-}
-async function getByQuery(Model, query, options = {}) {
-  const mongoQuery = Model.findOne(query);
-  if (options.select) mongoQuery.select(options.select);
-  if (options.populate) mongoQuery.populate(parsePopulate(options.populate));
-  if (options.lean) mongoQuery.lean();
-  if (options.session) mongoQuery.session(options.session);
-  const document = await mongoQuery.exec();
-  if (!document && options.throwOnNotFound !== false) {
-    throw createError(404, "Document not found");
-  }
-  return document;
-}
-async function tryGetByQuery(Model, query, options = {}) {
-  return getByQuery(Model, query, { ...options, throwOnNotFound: false });
-}
-async function getAll(Model, query = {}, options = {}) {
-  let mongoQuery = Model.find(query);
-  if (options.select) mongoQuery = mongoQuery.select(options.select);
-  if (options.populate) mongoQuery = mongoQuery.populate(parsePopulate(options.populate));
-  if (options.sort) mongoQuery = mongoQuery.sort(options.sort);
-  if (options.limit) mongoQuery = mongoQuery.limit(options.limit);
-  if (options.skip) mongoQuery = mongoQuery.skip(options.skip);
-  mongoQuery = mongoQuery.lean(options.lean !== false);
-  if (options.session) mongoQuery = mongoQuery.session(options.session);
-  return mongoQuery.exec();
-}
-async function getOrCreate(Model, query, createData, options = {}) {
-  return Model.findOneAndUpdate(
-    query,
-    { $setOnInsert: createData },
-    {
-      upsert: true,
-      new: true,
-      runValidators: true,
-      session: options.session,
-      ...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
-    }
-  );
-}
-async function count(Model, query = {}, options = {}) {
-  return Model.countDocuments(query).session(options.session ?? null);
-}
-async function exists(Model, query, options = {}) {
-  return Model.exists(query).session(options.session ?? null);
-}
-
-// src/actions/update.ts
-var update_exports = {};
-__export(update_exports, {
-  increment: () => increment,
-  pullFromArray: () => pullFromArray,
-  pushToArray: () => pushToArray,
-  update: () => update,
-  updateByQuery: () => updateByQuery,
-  updateMany: () => updateMany,
-  updateWithConstraints: () => updateWithConstraints,
-  updateWithValidation: () => updateWithValidation
-});
-function assertUpdatePipelineAllowed(update2, updatePipeline) {
-  if (Array.isArray(update2) && updatePipeline !== true) {
-    throw createError(
-      400,
-      "Update pipelines (array updates) are disabled by default; pass `{ updatePipeline: true }` to explicitly allow pipeline-style updates."
-    );
-  }
-}
-function parsePopulate2(populate) {
-  if (!populate) return [];
-  if (typeof populate === "string") {
-    return populate.split(",").map((p) => p.trim());
-  }
-  if (Array.isArray(populate)) {
-    return populate.map((p) => typeof p === "string" ? p.trim() : p);
-  }
-  return [populate];
-}
-async function update(Model, id, data, options = {}) {
-  assertUpdatePipelineAllowed(data, options.updatePipeline);
-  const document = await Model.findByIdAndUpdate(id, data, {
-    new: true,
-    runValidators: true,
-    session: options.session,
-    ...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
-  }).select(options.select || "").populate(parsePopulate2(options.populate)).lean(options.lean ?? false);
-  if (!document) {
-    throw createError(404, "Document not found");
-  }
-  return document;
-}
-async function updateWithConstraints(Model, id, data, constraints = {}, options = {}) {
-  assertUpdatePipelineAllowed(data, options.updatePipeline);
-  const query = { _id: id, ...constraints };
-  const document = await Model.findOneAndUpdate(query, data, {
-    new: true,
-    runValidators: true,
-    session: options.session,
-    ...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
-  }).select(options.select || "").populate(parsePopulate2(options.populate)).lean(options.lean ?? false);
-  return document;
-}
-async function updateWithValidation(Model, id, data, validationOptions = {}, options = {}) {
-  const { buildConstraints, validateUpdate } = validationOptions;
-  assertUpdatePipelineAllowed(data, options.updatePipeline);
-  if (buildConstraints) {
-    const constraints = buildConstraints(data);
-    const document = await updateWithConstraints(Model, id, data, constraints, options);
-    if (document) {
-      return { success: true, data: document };
-    }
-  }
-  const existing = await Model.findById(id).select(options.select || "").lean();
-  if (!existing) {
-    return {
-      success: false,
-      error: {
-        code: 404,
-        message: "Document not found"
-      }
-    };
-  }
-  if (validateUpdate) {
-    const validation = validateUpdate(existing, data);
-    if (!validation.valid) {
-      return {
-        success: false,
-        error: {
-          code: 403,
-          message: validation.message || "Update not allowed",
-          violations: validation.violations
-        }
-      };
-    }
-  }
-  const updated = await update(Model, id, data, options);
-  return { success: true, data: updated };
-}
-async function updateMany(Model, query, data, options = {}) {
-  assertUpdatePipelineAllowed(data, options.updatePipeline);
-  const result = await Model.updateMany(query, data, {
-    runValidators: true,
-    session: options.session,
-    ...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
-  });
-  return {
-    matchedCount: result.matchedCount,
-    modifiedCount: result.modifiedCount
-  };
-}
-async function updateByQuery(Model, query, data, options = {}) {
-  assertUpdatePipelineAllowed(data, options.updatePipeline);
-  const document = await Model.findOneAndUpdate(query, data, {
-    new: true,
-    runValidators: true,
-    session: options.session,
-    ...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
-  }).select(options.select || "").populate(parsePopulate2(options.populate)).lean(options.lean ?? false);
-  if (!document && options.throwOnNotFound !== false) {
-    throw createError(404, "Document not found");
-  }
-  return document;
-}
-async function increment(Model, id, field, value = 1, options = {}) {
-  return update(Model, id, { $inc: { [field]: value } }, options);
-}
-async function pushToArray(Model, id, field, value, options = {}) {
-  return update(Model, id, { $push: { [field]: value } }, options);
-}
-async function pullFromArray(Model, id, field, value, options = {}) {
-  return update(Model, id, { $pull: { [field]: value } }, options);
-}
-
-// src/actions/delete.ts
-var delete_exports = {};
-__export(delete_exports, {
-  deleteById: () => deleteById,
-  deleteByQuery: () => deleteByQuery,
-  deleteMany: () => deleteMany,
-  restore: () => restore,
-  softDelete: () => softDelete
-});
-async function deleteById(Model, id, options = {}) {
-  const document = await Model.findByIdAndDelete(id).session(options.session ?? null);
-  if (!document) {
-    throw createError(404, "Document not found");
-  }
-  return { success: true, message: "Deleted successfully" };
-}
-async function deleteMany(Model, query, options = {}) {
-  const result = await Model.deleteMany(query).session(options.session ?? null);
-  return {
-    success: true,
-    count: result.deletedCount,
-    message: "Deleted successfully"
-  };
-}
-async function deleteByQuery(Model, query, options = {}) {
-  const document = await Model.findOneAndDelete(query).session(options.session ?? null);
-  if (!document && options.throwOnNotFound !== false) {
-    throw createError(404, "Document not found");
-  }
-  return { success: true, message: "Deleted successfully" };
-}
-async function softDelete(Model, id, options = {}) {
-  const document = await Model.findByIdAndUpdate(
-    id,
-    {
-      deleted: true,
-      deletedAt: /* @__PURE__ */ new Date(),
-      deletedBy: options.userId
-    },
-    { new: true, session: options.session }
-  );
-  if (!document) {
-    throw createError(404, "Document not found");
-  }
-  return { success: true, message: "Soft deleted successfully" };
-}
-async function restore(Model, id, options = {}) {
-  const document = await Model.findByIdAndUpdate(
-    id,
-    {
-      deleted: false,
-      deletedAt: null,
-      deletedBy: null
-    },
-    { new: true, session: options.session }
-  );
-  if (!document) {
-    throw createError(404, "Document not found");
-  }
-  return { success: true, message: "Restored successfully" };
-}
-
-// src/actions/aggregate.ts
-var aggregate_exports = {};
-__export(aggregate_exports, {
-  aggregate: () => aggregate,
-  aggregatePaginate: () => aggregatePaginate,
-  average: () => average,
-  countBy: () => countBy,
-  distinct: () => distinct,
-  facet: () => facet,
-  groupBy: () => groupBy,
-  lookup: () => lookup,
-  minMax: () => minMax,
-  sum: () => sum,
-  unwind: () => unwind
-});
-async function aggregate(Model, pipeline, options = {}) {
-  const aggregation = Model.aggregate(pipeline);
-  if (options.session) {
-    aggregation.session(options.session);
-  }
-  return aggregation.exec();
-}
-async function aggregatePaginate(Model, pipeline, options = {}) {
-  const page = parseInt(String(options.page || 1), 10);
-  const limit = parseInt(String(options.limit || 10), 10);
-  const skip = (page - 1) * limit;
-  const SAFE_LIMIT = 1e3;
-  if (limit > SAFE_LIMIT) {
-    console.warn(
-      `[mongokit] Large aggregation limit (${limit}). $facet results must be <16MB. Consider using Repository.aggregatePaginate() for safer handling of large datasets.`
-    );
-  }
-  const facetPipeline = [
-    ...pipeline,
-    {
-      $facet: {
-        docs: [{ $skip: skip }, { $limit: limit }],
-        total: [{ $count: "count" }]
-      }
-    }
-  ];
-  const aggregation = Model.aggregate(facetPipeline);
-  if (options.session) {
-    aggregation.session(options.session);
-  }
-  const [result] = await aggregation.exec();
-  const docs = result.docs || [];
-  const total = result.total[0]?.count || 0;
-  const pages = Math.ceil(total / limit);
-  return {
-    docs,
-    total,
-    page,
-    limit,
-    pages,
-    hasNext: page < pages,
-    hasPrev: page > 1
-  };
-}
-async function groupBy(Model, field, options = {}) {
-  const pipeline = [
-    { $group: { _id: `$${field}`, count: { $sum: 1 } } },
-    { $sort: { count: -1 } }
-  ];
-  if (options.limit) {
-    pipeline.push({ $limit: options.limit });
-  }
-  return aggregate(Model, pipeline, options);
-}
-async function countBy(Model, field, query = {}, options = {}) {
-  const pipeline = [];
-  if (Object.keys(query).length > 0) {
-    pipeline.push({ $match: query });
-  }
-  pipeline.push(
-    { $group: { _id: `$${field}`, count: { $sum: 1 } } },
-    { $sort: { count: -1 } }
-  );
-  return aggregate(Model, pipeline, options);
-}
-async function lookup(Model, lookupOptions) {
-  const { from, localField, foreignField, as, pipeline = [], let: letVars, query = {}, options = {} } = lookupOptions;
-  const aggPipeline = [];
-  if (Object.keys(query).length > 0) {
-    aggPipeline.push({ $match: query });
-  }
-  const usePipelineForm = pipeline.length > 0 || letVars;
-  if (usePipelineForm) {
-    if (pipeline.length === 0 && localField && foreignField) {
-      const autoPipeline = [
-        {
-          $match: {
-            $expr: {
-              $eq: [`$${foreignField}`, `$$${localField}`]
-            }
-          }
-        }
-      ];
-      aggPipeline.push({
-        $lookup: {
-          from,
-          let: { [localField]: `$${localField}`, ...letVars || {} },
-          pipeline: autoPipeline,
-          as
-        }
-      });
-    } else {
-      aggPipeline.push({
-        $lookup: {
-          from,
-          ...letVars && { let: letVars },
-          pipeline,
-          as
-        }
-      });
-    }
-  } else {
-    aggPipeline.push({
-      $lookup: {
-        from,
-        localField,
-        foreignField,
-        as
-      }
-    });
-  }
-  return aggregate(Model, aggPipeline, options);
-}
-async function unwind(Model, field, options = {}) {
-  const pipeline = [
-    {
-      $unwind: {
-        path: `$${field}`,
-        preserveNullAndEmptyArrays: options.preserveEmpty !== false
-      }
-    }
-  ];
-  return aggregate(Model, pipeline, { session: options.session });
-}
-async function facet(Model, facets, options = {}) {
-  const pipeline = [{ $facet: facets }];
-  return aggregate(Model, pipeline, options);
-}
-async function distinct(Model, field, query = {}, options = {}) {
-  return Model.distinct(field, query).session(options.session ?? null);
-}
-async function sum(Model, field, query = {}, options = {}) {
-  const pipeline = [];
-  if (Object.keys(query).length > 0) {
-    pipeline.push({ $match: query });
-  }
-  pipeline.push({
-    $group: {
-      _id: null,
-      total: { $sum: `$${field}` }
-    }
-  });
-  const result = await aggregate(Model, pipeline, options);
-  return result[0]?.total || 0;
-}
-async function average(Model, field, query = {}, options = {}) {
-  const pipeline = [];
-  if (Object.keys(query).length > 0) {
-    pipeline.push({ $match: query });
-  }
-  pipeline.push({
-    $group: {
-      _id: null,
-      average: { $avg: `$${field}` }
-    }
-  });
-  const result = await aggregate(Model, pipeline, options);
-  return result[0]?.average || 0;
-}
-async function minMax(Model, field, query = {}, options = {}) {
-  const pipeline = [];
-  if (Object.keys(query).length > 0) {
-    pipeline.push({ $match: query });
-  }
-  pipeline.push({
-    $group: {
-      _id: null,
-      min: { $min: `$${field}` },
-      max: { $max: `$${field}` }
-    }
-  });
-  const result = await aggregate(Model, pipeline, options);
-  return result[0] || { min: null, max: null };
-}
-
-export { aggregate_exports as aggregate, create_exports as create, delete_exports as deleteActions, read_exports as read, update_exports as update };
+export { aggregate_exports as aggregate, delete_exports as deleteActions, read_exports as read, update_exports as update } from '../chunks/chunk-SAKSLT47.js';
+export { create_exports as create } from '../chunks/chunk-CF6FLC2G.js';
+import '../chunks/chunk-VJXDGP3C.js';

package/dist/chunks/chunk-2ZN65ZOP.js

@@ -0,0 +1,93 @@
+// 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)];
+}
+function getMongooseProjection(user, preset) {
+  const fields = getFieldsForUser(user, preset);
+  return fields.join(" ");
+}
+function 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;
+}
+function filterResponseData(data, preset, user = null) {
+  const allowedFields = getFieldsForUser(user, preset);
+  if (Array.isArray(data)) {
+    return data.map((item) => filterObject(item, allowedFields));
+  }
+  return filterObject(data, allowedFields);
+}
+function createFieldPreset(config) {
+  return {
+    public: config.public || [],
+    authenticated: config.authenticated || [],
+    admin: config.admin || []
+  };
+}
+
+// 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}:*`;
+}
+function listPattern(prefix, model) {
+  return `${prefix}:list:${model}:*`;
+}
+
+export { byIdKey, byQueryKey, createFieldPreset, filterResponseData, getFieldsForUser, getMongooseProjection, listPattern, listQueryKey, modelPattern, versionKey };

package/dist/chunks/chunk-CF6FLC2G.js

@@ -0,0 +1,46 @@
+import { __export } from './chunk-VJXDGP3C.js';
+
+// src/actions/create.ts
+var create_exports = {};
+__export(create_exports, {
+  create: () => create,
+  createDefault: () => createDefault,
+  createMany: () => createMany,
+  upsert: () => upsert
+});
+async function create(Model, data, options = {}) {
+  const document = new Model(data);
+  await document.save({ session: options.session });
+  return document;
+}
+async function createMany(Model, dataArray, options = {}) {
+  return Model.insertMany(dataArray, {
+    session: options.session,
+    ordered: options.ordered !== false
+  });
+}
+async function createDefault(Model, overrides = {}, options = {}) {
+  const defaults = {};
+  Model.schema.eachPath((path, schemaType) => {
+    const schemaOptions = schemaType.options;
+    if (schemaOptions.default !== void 0 && path !== "_id") {
+      defaults[path] = typeof schemaOptions.default === "function" ? schemaOptions.default() : schemaOptions.default;
+    }
+  });
+  return create(Model, { ...defaults, ...overrides }, options);
+}
+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 } : {}
+    }
+  );
+}
+
+export { create, createMany, create_exports, upsert };