@classytic/mongokit 3.2.0 → 3.2.2

package/dist/cache-keys-C8Z9B5sw.mjs

@@ -0,0 +1,204 @@
+//#region src/utils/field-selection.ts
+/**
+* Get allowed fields for a user based on their context
+*
+* @param user - User object from request.user (or null for public)
+* @param preset - Field preset configuration
+* @returns Array of allowed field names
+* 
+* @example
+* const fields = getFieldsForUser(request.user, {
+*   public: ['id', 'name', 'price'],
+*   authenticated: ['description', 'features'],
+*   admin: ['createdAt', 'internalNotes']
+* });
+*/
+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)];
+}
+/**
+* Get Mongoose projection string for query .select()
+*
+* @param user - User object from request.user
+* @param preset - Field preset configuration
+* @returns Space-separated field names for Mongoose .select()
+*
+* @example
+* const projection = getMongooseProjection(request.user, fieldPresets.gymPlans);
+* const plans = await GymPlan.find({ organizationId }).select(projection).lean();
+*/
+function getMongooseProjection(user, preset) {
+	return getFieldsForUser(user, preset).join(" ");
+}
+/**
+* Filter a single object to include only allowed fields
+*/
+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;
+}
+/**
+* Filter response data to include only allowed fields
+*
+* Use this for complex responses where Mongoose projections aren't applicable:
+* - Aggregation pipeline results
+* - Data from multiple sources
+* - Custom computed fields
+*
+* For simple DB queries, prefer getMongooseProjection() (10x faster)
+*
+* @param data - Data to filter
+* @param preset - Field preset configuration
+* @param user - User object from request.user
+* @returns Filtered data
+*
+* @example
+* const stats = await calculateComplexStats();
+* const filtered = filterResponseData(stats, fieldPresets.dashboard, request.user);
+* return reply.send(filtered);
+*/
+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);
+}
+/**
+* Helper to create field presets (module-level)
+*
+* Each module should define its own field preset in its own directory.
+* This keeps modules independent and self-contained.
+*
+* @param config - Field configuration
+* @returns Field preset
+*
+* @example
+* // In modules/gym-plan/gym-plan.fields.ts
+* export const gymPlanFieldPreset = createFieldPreset({
+*   public: ['id', 'name', 'price'],
+*   authenticated: ['features', 'description'],
+*   admin: ['createdAt', 'updatedAt', 'internalNotes']
+* });
+*/
+function createFieldPreset(config) {
+	return {
+		public: config.public || [],
+		authenticated: config.authenticated || [],
+		admin: config.admin || []
+	};
+}
+
+//#endregion
+//#region src/utils/cache-keys.ts
+/**
+* Simple hash function for query parameters
+* Using djb2 algorithm - fast and good distribution
+*/
+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);
+}
+/**
+* Normalize and stringify an object for hashing
+* Ensures deterministic key generation regardless of property order
+*/
+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(",") + "]";
+	return "{" + Object.keys(obj).sort().map((key) => `${key}:${stableStringify(obj[key])}`).join(",") + "}";
+}
+/**
+* Generate cache key for getById operations
+* 
+* Format: {prefix}:id:{model}:{documentId}
+* 
+* @example
+* byIdKey('mk', 'User', '507f1f77bcf86cd799439011')
+* // => 'mk:id:User:507f1f77bcf86cd799439011'
+*/
+function byIdKey(prefix, model, id) {
+	return `${prefix}:id:${model}:${id}`;
+}
+/**
+* Generate cache key for single-document queries
+* 
+* Format: {prefix}:one:{model}:{queryHash}
+* 
+* @example
+* byQueryKey('mk', 'User', { email: 'john@example.com' })
+* // => 'mk:one:User:a1b2c3d4'
+*/
+function byQueryKey(prefix, model, query, options) {
+	return `${prefix}:one:${model}:${hashString(stableStringify({
+		q: query,
+		s: options?.select,
+		p: options?.populate
+	}))}`;
+}
+/**
+* Generate cache key for paginated list queries
+* 
+* Format: {prefix}:list:{model}:{version}:{queryHash}
+* 
+* The version component enables efficient bulk invalidation:
+* - On any mutation, bump the version
+* - All list cache keys become invalid without scanning/deleting each
+* 
+* @example
+* listQueryKey('mk', 'User', 1, { filters: { status: 'active' }, page: 1, limit: 20 })
+* // => 'mk:list:User:1:e5f6g7h8'
+*/
+function listQueryKey(prefix, model, version, params) {
+	return `${prefix}:list:${model}:${version}:${hashString(stableStringify({
+		f: params.filters,
+		s: params.sort,
+		pg: params.page,
+		lm: params.limit,
+		af: params.after,
+		sl: params.select,
+		pp: params.populate
+	}))}`;
+}
+/**
+* Generate cache key for collection version tag
+* 
+* Format: {prefix}:ver:{model}
+* 
+* Used to track mutation version for list invalidation
+*/
+function versionKey(prefix, model) {
+	return `${prefix}:ver:${model}`;
+}
+/**
+* Generate pattern for clearing all cache keys for a model
+* 
+* Format: {prefix}:*:{model}:*
+* 
+* @example
+* modelPattern('mk', 'User')
+* // => 'mk:*:User:*'
+*/
+function modelPattern(prefix, model) {
+	return `${prefix}:*:${model}:*`;
+}
+/**
+* Generate pattern for clearing all list cache keys for a model
+* 
+* Format: {prefix}:list:{model}:*
+*/
+function listPattern(prefix, model) {
+	return `${prefix}:list:${model}:*`;
+}
+
+//#endregion
+export { modelPattern as a, filterResponseData as c, listQueryKey as i, getFieldsForUser as l, byQueryKey as n, versionKey as o, listPattern as r, createFieldPreset as s, byIdKey as t, getMongooseProjection as u };

package/dist/chunk-DQk6qfdC.mjs

@@ -0,0 +1,18 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+export { __exportAll as t };

package/dist/create-BuO6xt0v.mjs

@@ -0,0 +1,55 @@
+import { t as __exportAll } from "./chunk-DQk6qfdC.mjs";
+
+//#region src/actions/create.ts
+var create_exports = /* @__PURE__ */ __exportAll({
+	create: () => create,
+	createDefault: () => createDefault,
+	createMany: () => createMany,
+	upsert: () => upsert
+});
+/**
+* Create single document
+*/
+async function create(Model, data, options = {}) {
+	const document = new Model(data);
+	await document.save({ session: options.session });
+	return document;
+}
+/**
+* Create multiple documents
+*/
+async function createMany(Model, dataArray, options = {}) {
+	return Model.insertMany(dataArray, {
+		session: options.session,
+		ordered: options.ordered !== false
+	});
+}
+/**
+* Create with defaults (useful for initialization)
+*/
+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);
+}
+/**
+* Upsert (create or update)
+*/
+async function upsert(Model, query, data, options = {}) {
+	return Model.findOneAndUpdate(query, { $setOnInsert: data }, {
+		upsert: true,
+		returnDocument: "after",
+		runValidators: true,
+		session: options.session,
+		...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
+	});
+}
+
+//#endregion
+export { upsert as i, createMany as n, create_exports as r, create as t };