@classytic/mongokit 1.0.2 → 2.1.0

package/src/actions/aggregate.js

@@ -1,191 +0,0 @@
-/**
- * Aggregate Actions
- * MongoDB aggregation pipeline operations
- */
-
-/**
- * Execute aggregation pipeline
- */
-export async function aggregate(Model, pipeline, options = {}) {
-  const aggregation = Model.aggregate(pipeline);
-
-  if (options.session) {
-    aggregation.session(options.session);
-  }
-
-  return aggregation.exec();
-}
-
-/**
- * Aggregate with pagination
- */
-export async function aggregatePaginate(Model, pipeline, options = {}) {
-  const { page = 1, limit = 10 } = options;
-
-  return Model.aggregatePaginate(Model.aggregate(pipeline), {
-    page: parseInt(page, 10),
-    limit: parseInt(limit, 10),
-  });
-}
-
-/**
- * Group by field
- */
-export 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);
-}
-
-/**
- * Count by field values
- */
-export 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);
-}
-
-/**
- * Lookup (join) with another collection
- */
-export async function lookup(Model, {
-  from,
-  localField,
-  foreignField,
-  as,
-  pipeline = [],
-  query = {},
-  options = {}
-}) {
-  const aggPipeline = [];
-
-  if (Object.keys(query).length > 0) {
-    aggPipeline.push({ $match: query });
-  }
-
-  aggPipeline.push({
-    $lookup: {
-      from,
-      localField,
-      foreignField,
-      as,
-      ...(pipeline.length > 0 ? { pipeline } : {}),
-    },
-  });
-
-  return aggregate(Model, aggPipeline, options);
-}
-
-/**
- * Unwind array field
- */
-export async function unwind(Model, field, options = {}) {
-  const pipeline = [
-    {
-      $unwind: {
-        path: `$${field}`,
-        preserveNullAndEmptyArrays: options.preserveEmpty !== false,
-      },
-    },
-  ];
-
-  return aggregate(Model, pipeline, options);
-}
-
-/**
- * Facet search (multiple aggregations in one query)
- */
-export async function facet(Model, facets, options = {}) {
-  const pipeline = [{ $facet: facets }];
-
-  return aggregate(Model, pipeline, options);
-}
-
-/**
- * Get distinct values
- */
-export async function distinct(Model, field, query = {}, options = {}) {
-  return Model.distinct(field, query).session(options.session);
-}
-
-/**
- * Calculate sum
- */
-export 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;
-}
-
-/**
- * Calculate average
- */
-export 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;
-}
-
-/**
- * Min/Max
- */
-export 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 };
-}
-

package/src/actions/create.js

@@ -1,59 +0,0 @@
-/**
- * Create Actions
- * Pure functions for document creation
- */
-
-/**
- * Create single document
- */
-export async function create(Model, data, options = {}) {
-  const document = new Model(data);
-  await document.save({ session: options.session });
-  return document;
-}
-
-/**
- * Create multiple documents
- */
-export async function createMany(Model, dataArray, options = {}) {
-  return Model.insertMany(dataArray, {
-    session: options.session,
-    ordered: options.ordered !== false,
-  });
-}
-
-/**
- * Create with defaults (useful for initialization)
- */
-export async function createDefault(Model, overrides = {}, options = {}) {
-  const defaults = {};
-  
-  // Extract defaults from schema
-  Model.schema.eachPath((path, schemaType) => {
-    if (schemaType.options.default !== undefined && path !== '_id') {
-      defaults[path] = typeof schemaType.options.default === 'function'
-        ? schemaType.options.default()
-        : schemaType.options.default;
-    }
-  });
-  
-  return create(Model, { ...defaults, ...overrides }, options);
-}
-
-/**
- * Upsert (create or update)
- */
-export async function upsert(Model, query, data, options = {}) {
-  return Model.findOneAndUpdate(
-    query,
-    { $setOnInsert: data },
-    {
-      upsert: true,
-      new: true,
-      runValidators: true,
-      session: options.session,
-      ...(options.updatePipeline !== undefined ? { updatePipeline: options.updatePipeline } : {}),
-    }
-  );
-}
-

package/src/actions/delete.js

@@ -1,88 +0,0 @@
-/**
- * Delete Actions
- * Pure functions for document deletion
- */
-
-import createError from 'http-errors';
-
-/**
- * Delete by ID
- */
-export async function deleteById(Model, id, options = {}) {
-  const document = await Model.findByIdAndDelete(id).session(options.session);
-
-  if (!document) {
-    throw createError(404, 'Document not found');
-  }
-
-  return { success: true, message: 'Deleted successfully' };
-}
-
-/**
- * Delete many documents
- */
-export async function deleteMany(Model, query, options = {}) {
-  const result = await Model.deleteMany(query).session(options.session);
-
-  return {
-    success: true,
-    count: result.deletedCount,
-    message: 'Deleted successfully',
-  };
-}
-
-/**
- * Delete by query
- */
-export async function deleteByQuery(Model, query, options = {}) {
-  const document = await Model.findOneAndDelete(query).session(options.session);
-
-  if (!document && options.throwOnNotFound !== false) {
-    throw createError(404, 'Document not found');
-  }
-
-  return { success: true, message: 'Deleted successfully' };
-}
-
-/**
- * Soft delete (set deleted flag)
- */
-export async function softDelete(Model, id, options = {}) {
-  const document = await Model.findByIdAndUpdate(
-    id,
-    {
-      deleted: true,
-      deletedAt: 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' };
-}
-
-/**
- * Restore soft deleted document
- */
-export 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' };
-}
-

package/src/actions/index.js

@@ -1,11 +0,0 @@
-/**
- * Repository Actions
- * Modular, composable data access operations
- */
-
-export * as create from './create.js';
-export * as read from './read.js';
-export * as update from './update.js';
-export * as deleteActions from './delete.js';
-export * as aggregate from './aggregate.js';
-

package/src/actions/read.js

@@ -1,156 +0,0 @@
-/**
- * Read Actions
- * Pure functions for document retrieval
- */
-
-import createError from 'http-errors';
-
-/**
- * Get by ID
- */
-export async function getById(Model, id, options = {}) {
-  const 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;
-}
-
-/**
- * Get by query
- */
-export 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;
-}
-
-/**
- * Get all with pagination
- */
-export async function getAll(Model, queryParams, options = {}) {
-  const {
-    pagination = { page: 1, limit: 10 },
-    search,
-    sort = '-createdAt',
-    filters = {},
-  } = queryParams;
-
-  let query = {};
-  
-  if (search) {
-    query.$text = { $search: search };
-  }
-  
-  if (filters) {
-    query = { ...query, ...parseFilters(filters) };
-  }
-
-  const paginateOptions = {
-    page: parseInt(pagination.page, 10),
-    limit: parseInt(pagination.limit, 10),
-    sort: parseSort(sort),
-    populate: parsePopulate(options.populate),
-    select: options.select,
-    lean: options.lean !== false,
-    session: options.session,
-  };
-
-  return Model.paginate(query, paginateOptions);
-}
-
-/**
- * Get or create
- */
-export async function getOrCreate(Model, query, createData, options = {}) {
-  return Model.findOneAndUpdate(
-    query,
-    { $setOnInsert: createData },
-    {
-      upsert: true,
-      new: true,
-      runValidators: true,
-      session: options.session,
-      ...(options.updatePipeline !== undefined ? { updatePipeline: options.updatePipeline } : {}),
-    }
-  );
-}
-
-/**
- * Count documents
- */
-export async function count(Model, query = {}, options = {}) {
-  return Model.countDocuments(query).session(options.session);
-}
-
-/**
- * Check existence
- */
-export async function exists(Model, query, options = {}) {
-  return Model.exists(query).session(options.session);
-}
-
-// Utilities
-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];
-}
-
-function parseSort(sort) {
-  if (!sort) return { createdAt: -1 };
-  const sortOrder = sort.startsWith('-') ? -1 : 1;
-  const sortField = sort.startsWith('-') ? sort.substring(1) : sort;
-  return { [sortField]: sortOrder };
-}
-
-function parseFilters(filters) {
-  const parsed = {};
-  for (const [key, value] of Object.entries(filters)) {
-    parsed[key] = parseFilterValue(value);
-  }
-  return parsed;
-}
-
-function parseFilterValue(value) {
-  if (typeof value === 'string') return value;
-  
-  if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-    const processed = {};
-    for (const [operator, operatorValue] of Object.entries(value)) {
-      if (operator === 'contains' || operator === 'like') {
-        processed.$regex = operatorValue;
-        processed.$options = 'i';
-      } else {
-        processed[operator.startsWith('$') ? operator : `$${operator}`] = operatorValue;
-      }
-    }
-    return processed;
-  }
-  
-  return value;
-}
-

package/src/actions/update.js

@@ -1,176 +0,0 @@
-/**
- * Update Actions
- * Pure functions for document updates with optimizations
- */
-
-import createError from 'http-errors';
-
-/**
- * Update by ID
- */
-export async function update(Model, id, data, options = {}) {
-  const document = await Model.findByIdAndUpdate(id, data, {
-    new: true,
-    runValidators: true,
-    session: options.session,
-    ...(options.updatePipeline !== undefined ? { updatePipeline: options.updatePipeline } : {}),
-  })
-    .select(options.select)
-    .populate(parsePopulate(options.populate))
-    .lean(options.lean);
-
-  if (!document) {
-    throw createError(404, 'Document not found');
-  }
-
-  return document;
-}
-
-/**
- * Update with query constraints (optimized)
- * Returns null if constraints not met (not an error)
- */
-export async function updateWithConstraints(Model, id, data, constraints = {}, options = {}) {
-  const query = { _id: id, ...constraints };
-
-  const document = await Model.findOneAndUpdate(query, data, {
-    new: true,
-    runValidators: true,
-    session: options.session,
-    ...(options.updatePipeline !== undefined ? { updatePipeline: options.updatePipeline } : {}),
-  })
-    .select(options.select)
-    .populate(parsePopulate(options.populate))
-    .lean(options.lean);
-
-  return document;
-}
-
-/**
- * Update with validation (smart optimization)
- * 1-query on success, 2-queries for detailed errors
- */
-export async function updateWithValidation(
-  Model,
-  id,
-  data,
-  validationOptions = {},
-  options = {}
-) {
-  const { buildConstraints, validateUpdate } = validationOptions;
-
-  // Try optimized update with constraints
-  if (buildConstraints) {
-    const constraints = buildConstraints(data);
-    const document = await updateWithConstraints(Model, id, data, constraints, options);
-
-    if (document) {
-      return { success: true, data: document };
-    }
-  }
-
-  // Fetch for validation
-  const existing = await Model.findById(id)
-    .select(options.select)
-    .lean();
-
-  if (!existing) {
-    return {
-      success: false,
-      error: {
-        code: 404,
-        message: 'Document not found',
-      },
-    };
-  }
-
-  // Run custom validation
-  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,
-        },
-      };
-    }
-  }
-
-  // Validation passed - perform update
-  const updated = await update(Model, id, data, options);
-  return { success: true, data: updated };
-}
-
-/**
- * Update many documents
- */
-export async function updateMany(Model, query, data, options = {}) {
-  const result = await Model.updateMany(query, data, {
-    runValidators: true,
-    session: options.session,
-    ...(options.updatePipeline !== undefined ? { updatePipeline: options.updatePipeline } : {}),
-  });
-
-  return {
-    matchedCount: result.matchedCount,
-    modifiedCount: result.modifiedCount,
-  };
-}
-
-/**
- * Update by query
- */
-export async function updateByQuery(Model, query, data, options = {}) {
-  const document = await Model.findOneAndUpdate(query, data, {
-    new: true,
-    runValidators: true,
-    session: options.session,
-    ...(options.updatePipeline !== undefined ? { updatePipeline: options.updatePipeline } : {}),
-  })
-    .select(options.select)
-    .populate(parsePopulate(options.populate))
-    .lean(options.lean);
-
-  if (!document && options.throwOnNotFound !== false) {
-    throw createError(404, 'Document not found');
-  }
-
-  return document;
-}
-
-/**
- * Increment field
- */
-export async function increment(Model, id, field, value = 1, options = {}) {
-  return update(Model, id, { $inc: { [field]: value } }, options);
-}
-
-/**
- * Push to array
- */
-export async function pushToArray(Model, id, field, value, options = {}) {
-  return update(Model, id, { $push: { [field]: value } }, options);
-}
-
-/**
- * Pull from array
- */
-export async function pullFromArray(Model, id, field, value, options = {}) {
-  return update(Model, id, { $pull: { [field]: value } }, options);
-}
-
-// Utilities
-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];
-}
-