@classytic/mongokit 1.0.1 → 2.0.0

package/src/actions/update.js

@@ -1,172 +1,176 @@
-/**
- * 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,
-  })
-    .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,
-  })
-    .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,
-  });
-
-  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,
-  })
-    .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];
-}
-
+/**
+ * Update Actions
+ * Pure functions for document updates with optimizations
+ */
+
+import { createError } from '../utils/error.js';
+
+/**
+ * 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];
+}
+

package/src/hooks/lifecycle.js

@@ -1,146 +1,146 @@
-/**
- * Lifecycle Hooks
- * Event system for repository actions
- */
-
-import { EventEmitter } from 'events';
-
-export class RepositoryLifecycle extends EventEmitter {
-  constructor() {
-    super();
-    this.hooks = new Map();
-  }
-
-  /**
-   * Register hook
-   */
-  on(event, handler) {
-    if (!this.hooks.has(event)) {
-      this.hooks.set(event, []);
-    }
-    this.hooks.get(event).push(handler);
-    return super.on(event, handler);
-  }
-
-  /**
-   * Execute hooks before action
-   */
-  async runBeforeHooks(action, context) {
-    const event = `before:${action}`;
-    await this.emit(event, context);
-    
-    const hooks = this.hooks.get(event) || [];
-    for (const hook of hooks) {
-      await hook(context);
-    }
-  }
-
-  /**
-   * Execute hooks after action
-   */
-  async runAfterHooks(action, context, result) {
-    const event = `after:${action}`;
-    await this.emit(event, context, result);
-    
-    const hooks = this.hooks.get(event) || [];
-    for (const hook of hooks) {
-      await hook(context, result);
-    }
-  }
-
-  /**
-   * Execute hooks on error
-   */
-  async runErrorHooks(action, context, error) {
-    const event = `error:${action}`;
-    await this.emit(event, context, error);
-    
-    const hooks = this.hooks.get(event) || [];
-    for (const hook of hooks) {
-      await hook(context, error);
-    }
-  }
-}
-
-/**
- * Hook decorators for common patterns
- */
-export const hooks = {
-  /**
-   * Auto-timestamp before create/update
-   */
-  autoTimestamp: () => ({
-    'before:create': (context) => {
-      context.data.createdAt = new Date();
-      context.data.updatedAt = new Date();
-    },
-    'before:update': (context) => {
-      context.data.updatedAt = new Date();
-    },
-  }),
-
-  /**
-   * Auto-inject user context
-   */
-  autoUser: (userField = 'userId') => ({
-    'before:create': (context) => {
-      if (context.user && !context.data[userField]) {
-        context.data[userField] = context.user._id || context.user.id;
-      }
-    },
-  }),
-
-  /**
-   * Auto-inject organization scope
-   */
-  autoOrganization: (orgField = 'organizationId') => ({
-    'before:create': (context) => {
-      if (context.organizationId && !context.data[orgField]) {
-        context.data[orgField] = context.organizationId;
-      }
-    },
-  }),
-
-  /**
-   * Audit log
-   */
-  auditLog: (logger) => ({
-    'after:create': (context, result) => {
-      logger.info('Document created', {
-        model: context.model,
-        id: result._id,
-        user: context.user?.id,
-      });
-    },
-    'after:update': (context, result) => {
-      logger.info('Document updated', {
-        model: context.model,
-        id: result._id,
-        user: context.user?.id,
-      });
-    },
-    'after:delete': (context, result) => {
-      logger.info('Document deleted', {
-        model: context.model,
-        user: context.user?.id,
-      });
-    },
-  }),
-
-  /**
-   * Cache invalidation
-   */
-  cacheInvalidation: (cache) => ({
-    'after:create': async (context, result) => {
-      await cache.invalidate(`${context.model}:*`);
-    },
-    'after:update': async (context, result) => {
-      await cache.invalidate(`${context.model}:${result._id}`);
-      await cache.invalidate(`${context.model}:*`);
-    },
-    'after:delete': async (context) => {
-      await cache.invalidate(`${context.model}:*`);
-    },
-  }),
-};
-
+/**
+ * Lifecycle Hooks
+ * Event system for repository actions
+ */
+
+import { EventEmitter } from 'events';
+
+export class RepositoryLifecycle extends EventEmitter {
+  constructor() {
+    super();
+    this.hooks = new Map();
+  }
+
+  /**
+   * Register hook
+   */
+  on(event, handler) {
+    if (!this.hooks.has(event)) {
+      this.hooks.set(event, []);
+    }
+    this.hooks.get(event).push(handler);
+    return super.on(event, handler);
+  }
+
+  /**
+   * Execute hooks before action
+   */
+  async runBeforeHooks(action, context) {
+    const event = `before:${action}`;
+    await this.emit(event, context);
+    
+    const hooks = this.hooks.get(event) || [];
+    for (const hook of hooks) {
+      await hook(context);
+    }
+  }
+
+  /**
+   * Execute hooks after action
+   */
+  async runAfterHooks(action, context, result) {
+    const event = `after:${action}`;
+    await this.emit(event, context, result);
+    
+    const hooks = this.hooks.get(event) || [];
+    for (const hook of hooks) {
+      await hook(context, result);
+    }
+  }
+
+  /**
+   * Execute hooks on error
+   */
+  async runErrorHooks(action, context, error) {
+    const event = `error:${action}`;
+    await this.emit(event, context, error);
+    
+    const hooks = this.hooks.get(event) || [];
+    for (const hook of hooks) {
+      await hook(context, error);
+    }
+  }
+}
+
+/**
+ * Hook decorators for common patterns
+ */
+export const hooks = {
+  /**
+   * Auto-timestamp before create/update
+   */
+  autoTimestamp: () => ({
+    'before:create': (context) => {
+      context.data.createdAt = new Date();
+      context.data.updatedAt = new Date();
+    },
+    'before:update': (context) => {
+      context.data.updatedAt = new Date();
+    },
+  }),
+
+  /**
+   * Auto-inject user context
+   */
+  autoUser: (userField = 'userId') => ({
+    'before:create': (context) => {
+      if (context.user && !context.data[userField]) {
+        context.data[userField] = context.user._id || context.user.id;
+      }
+    },
+  }),
+
+  /**
+   * Auto-inject organization scope
+   */
+  autoOrganization: (orgField = 'organizationId') => ({
+    'before:create': (context) => {
+      if (context.organizationId && !context.data[orgField]) {
+        context.data[orgField] = context.organizationId;
+      }
+    },
+  }),
+
+  /**
+   * Audit log
+   */
+  auditLog: (logger) => ({
+    'after:create': (context, result) => {
+      logger.info('Document created', {
+        model: context.model,
+        id: result._id,
+        user: context.user?.id,
+      });
+    },
+    'after:update': (context, result) => {
+      logger.info('Document updated', {
+        model: context.model,
+        id: result._id,
+        user: context.user?.id,
+      });
+    },
+    'after:delete': (context, result) => {
+      logger.info('Document deleted', {
+        model: context.model,
+        user: context.user?.id,
+      });
+    },
+  }),
+
+  /**
+   * Cache invalidation
+   */
+  cacheInvalidation: (cache) => ({
+    'after:create': async (context, result) => {
+      await cache.invalidate(`${context.model}:*`);
+    },
+    'after:update': async (context, result) => {
+      await cache.invalidate(`${context.model}:${result._id}`);
+      await cache.invalidate(`${context.model}:*`);
+    },
+    'after:delete': async (context) => {
+      await cache.invalidate(`${context.model}:*`);
+    },
+  }),
+};
+