@classytic/mongokit 3.0.4 → 3.0.6

package/dist/actions/index.d.ts

@@ -1,3 +1,3 @@
-export { a as aggregate, c as create, _ as deleteActions, r as read, u as update } from '../index-wXrOSYWG.js';
+export { a as aggregate, c as create, _ as deleteActions, r as read, u as update } from '../index-CkwbNdpJ.js';
 import 'mongoose';
-import '../types-DAl69QgM.js';
+import '../types-DDDYo18H.js';

package/dist/{index-wXrOSYWG.d.ts → index-CkwbNdpJ.d.ts}

@@ -1,5 +1,5 @@
 import { Model, ClientSession, PipelineStage } from 'mongoose';
-import { A as AnyDocument, C as CreateOptions, f as ObjectId, n as OperationOptions, S as SelectSpec, g as PopulateSpec, h as SortSpec, U as UpdateOptions, p as UpdateWithValidationResult, o as UpdateManyResult, D as DeleteResult, W as GroupResult, T as LookupOptions, X as MinMaxResult } from './types-DAl69QgM.js';
+import { A as AnyDocument, C as CreateOptions, h as ObjectId, n as OperationOptions, S as SelectSpec, e as PopulateSpec, f as SortSpec, U as UpdateOptions, p as UpdateWithValidationResult, o as UpdateManyResult, D as DeleteResult, X as GroupResult, T as LookupOptions, Y as MinMaxResult } from './types-DDDYo18H.js';
 
 /**
  * Create Actions

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { A as AnyDocument, e as PluginType, P as PaginationConfig, R as RepositoryOptions, f as ObjectId, S as SelectSpec, g as PopulateSpec, h as SortSpec, a as OffsetPaginationResult, b as KeysetPaginationResult, U as UpdateOptions, d as AggregatePaginationResult, i as RepositoryContext, H as HttpError } from './types-DAl69QgM.js';
-export { c as AggregatePaginationOptions, j as AnyModel, Y as CacheAdapter, _ as CacheOperationOptions, Z as CacheOptions, $ as CacheStats, a1 as CascadeOptions, a0 as CascadeRelation, C as CreateOptions, z as CrudSchemas, B as DecodedCursor, D as DeleteResult, E as EventPayload, F as FieldPreset, x as FieldRules, w as FilterQuery, W as GroupResult, l as HookMode, J as JsonSchema, K as KeysetPaginationOptions, L as Logger, T as LookupOptions, X as MinMaxResult, O as OffsetPaginationOptions, n as OperationOptions, m as PaginationResult, v as ParsedQuery, r as Plugin, s as PluginFunction, u as RepositoryEvent, t as RepositoryInstance, y as SchemaBuilderOptions, N as SoftDeleteFilterMode, M as SoftDeleteOptions, Q as SoftDeleteRepository, k as SortDirection, o as UpdateManyResult, p as UpdateWithValidationResult, q as UserContext, I as ValidationChainOptions, V as ValidationResult, G as ValidatorDefinition } from './types-DAl69QgM.js';
+import { A as AnyDocument, g as PluginType, P as PaginationConfig, R as RepositoryOptions, h as ObjectId, S as SelectSpec, e as PopulateSpec, f as SortSpec, a as OffsetPaginationResult, b as KeysetPaginationResult, U as UpdateOptions, d as AggregatePaginationResult, W as WithTransactionOptions, i as RepositoryContext, H as HttpError } from './types-DDDYo18H.js';
+export { c as AggregatePaginationOptions, j as AnyModel, Z as CacheAdapter, $ as CacheOperationOptions, _ as CacheOptions, a0 as CacheStats, a2 as CascadeOptions, a1 as CascadeRelation, C as CreateOptions, z as CrudSchemas, B as DecodedCursor, D as DeleteResult, E as EventPayload, F as FieldPreset, x as FieldRules, w as FilterQuery, X as GroupResult, l as HookMode, J as JsonSchema, K as KeysetPaginationOptions, L as Logger, T as LookupOptions, Y as MinMaxResult, O as OffsetPaginationOptions, n as OperationOptions, m as PaginationResult, v as ParsedQuery, r as Plugin, s as PluginFunction, u as RepositoryEvent, t as RepositoryInstance, y as SchemaBuilderOptions, N as SoftDeleteFilterMode, M as SoftDeleteOptions, Q as SoftDeleteRepository, k as SortDirection, o as UpdateManyResult, p as UpdateWithValidationResult, q as UserContext, I as ValidationChainOptions, V as ValidationResult, G as ValidatorDefinition } from './types-DDDYo18H.js';
 import * as mongoose from 'mongoose';
 import { Model, ClientSession, PipelineStage, PopulateOptions } from 'mongoose';
 import { PaginationEngine } from './pagination/PaginationEngine.js';
 export { aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, cascadePlugin, fieldFilterPlugin, immutableField, methodRegistryPlugin, mongoOperationsPlugin, requireField, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin } from './plugins/index.js';
-export { F as FilterValue, O as OperatorMap, Q as QueryParser, h as QueryParserOptions, b as createError, c as createFieldPreset, d as createMemoryCache, f as filterResponseData, g as getFieldsForUser, a as getMongooseProjection, e as queryParser } from './queryParser-Bek4yy3x.js';
-export { i as actions } from './index-wXrOSYWG.js';
+export { F as FilterValue, O as OperatorMap, Q as QueryParser, b as QueryParserOptions, h as buildCrudSchemasFromModel, e as buildCrudSchemasFromMongooseSchema, l as createError, c as createFieldPreset, m as createMemoryCache, f as filterResponseData, g as getFieldsForUser, i as getImmutableFields, a as getMongooseProjection, j as getSystemManagedFields, k as isFieldUpdateAllowed, d as queryParser, v as validateUpdateBody } from './queryParser-Do3SgsyJ.js';
+export { i as actions } from './index-CkwbNdpJ.js';
 
 /**
  * Repository Pattern - Data Access Layer
@@ -203,7 +203,8 @@ declare class Repository<TDoc = AnyDocument> {
     /**
      * Execute callback within a transaction
      */
-    withTransaction<T>(callback: (session: ClientSession) => Promise<T>): Promise<T>;
+    withTransaction<T>(callback: (session: ClientSession | null) => Promise<T>, options?: WithTransactionOptions): Promise<T>;
+    private _isTransactionUnsupported;
     /**
      * Execute custom query with event emission
      */
@@ -238,4 +239,4 @@ declare class Repository<TDoc = AnyDocument> {
  */
 declare function createRepository<TDoc>(Model: mongoose.Model<TDoc, any, any, any>, plugins?: PluginType[], paginationConfig?: PaginationConfig, options?: RepositoryOptions): Repository<TDoc>;
 
-export { AggregatePaginationResult, AnyDocument, HttpError, KeysetPaginationResult, ObjectId, OffsetPaginationResult, PaginationConfig, PaginationEngine, PluginType, PopulateSpec, Repository, RepositoryContext, RepositoryOptions, SelectSpec, SortSpec, UpdateOptions, createRepository, Repository as default };
+export { AggregatePaginationResult, AnyDocument, HttpError, KeysetPaginationResult, ObjectId, OffsetPaginationResult, PaginationConfig, PaginationEngine, PluginType, PopulateSpec, Repository, RepositoryContext, RepositoryOptions, SelectSpec, SortSpec, UpdateOptions, WithTransactionOptions, createRepository, Repository as default };

package/dist/index.js

@@ -1,4 +1,4 @@
-import mongoose from 'mongoose';
+import mongoose4 from 'mongoose';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -521,12 +521,12 @@ function validateCursorVersion(cursorVersion, expectedVersion) {
 }
 function serializeValue(value) {
   if (value instanceof Date) return value.toISOString();
-  if (value instanceof mongoose.Types.ObjectId) return value.toString();
+  if (value instanceof mongoose4.Types.ObjectId) return value.toString();
   return value;
 }
 function getValueType(value) {
   if (value instanceof Date) return "date";
-  if (value instanceof mongoose.Types.ObjectId) return "objectid";
+  if (value instanceof mongoose4.Types.ObjectId) return "objectid";
   if (typeof value === "boolean") return "boolean";
   if (typeof value === "number") return "number";
   if (typeof value === "string") return "string";
@@ -537,7 +537,7 @@ function rehydrateValue(serialized, type) {
     case "date":
       return new Date(serialized);
     case "objectid":
-      return new mongoose.Types.ObjectId(serialized);
+      return new mongoose4.Types.ObjectId(serialized);
     case "boolean":
       return Boolean(serialized);
     case "number":
@@ -1108,20 +1108,41 @@ var Repository = class {
   /**
    * Execute callback within a transaction
    */
-  async withTransaction(callback) {
-    const session = await mongoose.startSession();
-    session.startTransaction();
+  async withTransaction(callback, options = {}) {
+    const session = await mongoose4.startSession();
+    let started = false;
     try {
+      session.startTransaction();
+      started = true;
       const result = await callback(session);
       await session.commitTransaction();
       return result;
     } catch (error) {
-      await session.abortTransaction();
-      throw error;
+      const err = error;
+      if (options.allowFallback && this._isTransactionUnsupported(err)) {
+        if (typeof options.onFallback === "function") {
+          options.onFallback(err);
+        }
+        if (started && session.inTransaction()) {
+          try {
+            await session.abortTransaction();
+          } catch {
+          }
+        }
+        return await callback(null);
+      }
+      if (started && session.inTransaction()) {
+        await session.abortTransaction();
+      }
+      throw err;
     } finally {
       session.endSession();
     }
   }
+  _isTransactionUnsupported(error) {
+    const message = (error.message || "").toLowerCase();
+    return message.includes("transaction numbers are only allowed on a replica set member") || message.includes("replica set") || message.includes("mongos");
+  }
   /**
    * Execute custom query with event emission
    */
@@ -1172,11 +1193,11 @@ var Repository = class {
    * Handle errors with proper HTTP status codes
    */
   _handleError(error) {
-    if (error instanceof mongoose.Error.ValidationError) {
+    if (error instanceof mongoose4.Error.ValidationError) {
       const messages = Object.values(error.errors).map((err) => err.message);
       return createError(400, `Validation Error: ${messages.join(", ")}`);
     }
-    if (error instanceof mongoose.Error.CastError) {
+    if (error instanceof mongoose4.Error.CastError) {
       return createError(400, `Invalid ${error.path}: ${error.value}`);
     }
     if (error.status && error.message) return error;
@@ -2207,7 +2228,7 @@ function cascadePlugin(options) {
         }
         const isSoftDelete = context.softDeleted === true;
         const cascadeDelete = async (relation) => {
-          const RelatedModel = mongoose.models[relation.model];
+          const RelatedModel = mongoose4.models[relation.model];
           if (!RelatedModel) {
             logger?.warn?.(`Cascade delete skipped: model '${relation.model}' not found`, {
               parentModel: context.model,
@@ -2298,7 +2319,7 @@ function cascadePlugin(options) {
           }
           const isSoftDelete = context.softDeleted === true;
           const cascadeDeleteMany = async (relation) => {
-            const RelatedModel = mongoose.models[relation.model];
+            const RelatedModel = mongoose4.models[relation.model];
             if (!RelatedModel) {
               logger?.warn?.(`Cascade deleteMany skipped: model '${relation.model}' not found`, {
                 parentModel: context.model
@@ -2414,6 +2435,244 @@ function createMemoryCache(maxEntries = 1e3) {
     }
   };
 }
+function isMongooseSchema(value) {
+  return value instanceof mongoose4.Schema;
+}
+function isPlainObject(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+function isObjectIdType(t) {
+  return t === mongoose4.Schema.Types.ObjectId || t === mongoose4.Types.ObjectId;
+}
+function buildCrudSchemasFromMongooseSchema(mongooseSchema, options = {}) {
+  const tree = mongooseSchema?.obj || {};
+  const jsonCreate = buildJsonSchemaForCreate(tree, options);
+  const jsonUpdate = buildJsonSchemaForUpdate(jsonCreate, options);
+  const jsonParams = {
+    type: "object",
+    properties: { id: { type: "string", pattern: "^[0-9a-fA-F]{24}$" } },
+    required: ["id"]
+  };
+  const jsonQuery = buildJsonSchemaForQuery(tree, options);
+  return { createBody: jsonCreate, updateBody: jsonUpdate, params: jsonParams, listQuery: jsonQuery };
+}
+function buildCrudSchemasFromModel(mongooseModel, options = {}) {
+  if (!mongooseModel || !mongooseModel.schema) {
+    throw new Error("Invalid mongoose model");
+  }
+  return buildCrudSchemasFromMongooseSchema(mongooseModel.schema, options);
+}
+function getImmutableFields(options = {}) {
+  const immutable = [];
+  const fieldRules = options?.fieldRules || {};
+  Object.entries(fieldRules).forEach(([field, rules]) => {
+    if (rules.immutable || rules.immutableAfterCreate) {
+      immutable.push(field);
+    }
+  });
+  (options?.update?.omitFields || []).forEach((f) => {
+    if (!immutable.includes(f)) immutable.push(f);
+  });
+  return immutable;
+}
+function getSystemManagedFields(options = {}) {
+  const systemManaged = [];
+  const fieldRules = options?.fieldRules || {};
+  Object.entries(fieldRules).forEach(([field, rules]) => {
+    if (rules.systemManaged) {
+      systemManaged.push(field);
+    }
+  });
+  return systemManaged;
+}
+function isFieldUpdateAllowed(fieldName, options = {}) {
+  const immutableFields = getImmutableFields(options);
+  const systemManagedFields = getSystemManagedFields(options);
+  return !immutableFields.includes(fieldName) && !systemManagedFields.includes(fieldName);
+}
+function validateUpdateBody(body = {}, options = {}) {
+  const violations = [];
+  const immutableFields = getImmutableFields(options);
+  const systemManagedFields = getSystemManagedFields(options);
+  Object.keys(body).forEach((field) => {
+    if (immutableFields.includes(field)) {
+      violations.push({ field, reason: "Field is immutable" });
+    } else if (systemManagedFields.includes(field)) {
+      violations.push({ field, reason: "Field is system-managed" });
+    }
+  });
+  return {
+    valid: violations.length === 0,
+    violations
+  };
+}
+function jsonTypeFor(def, options, seen) {
+  if (Array.isArray(def)) {
+    if (def[0] === mongoose4.Schema.Types.Mixed) {
+      return { type: "array", items: { type: "object", additionalProperties: true } };
+    }
+    return { type: "array", items: jsonTypeFor(def[0] ?? String, options, seen) };
+  }
+  if (isPlainObject(def) && "type" in def) {
+    const typedDef = def;
+    if (typedDef.enum && Array.isArray(typedDef.enum) && typedDef.enum.length) {
+      return { type: "string", enum: typedDef.enum.map(String) };
+    }
+    if (Array.isArray(typedDef.type)) {
+      const inner = typedDef.type[0] !== void 0 ? typedDef.type[0] : String;
+      if (inner === mongoose4.Schema.Types.Mixed) {
+        return { type: "array", items: { type: "object", additionalProperties: true } };
+      }
+      return { type: "array", items: jsonTypeFor(inner, options, seen) };
+    }
+    if (typedDef.type === String) return { type: "string" };
+    if (typedDef.type === Number) return { type: "number" };
+    if (typedDef.type === Boolean) return { type: "boolean" };
+    if (typedDef.type === Date) {
+      const mode = options?.dateAs || "datetime";
+      return mode === "date" ? { type: "string", format: "date" } : { type: "string", format: "date-time" };
+    }
+    if (typedDef.type === Map || typedDef.type === mongoose4.Schema.Types.Map) {
+      const ofSchema = jsonTypeFor(typedDef.of || String, options, seen);
+      return { type: "object", additionalProperties: ofSchema };
+    }
+    if (typedDef.type === mongoose4.Schema.Types.Mixed) {
+      return { type: "object", additionalProperties: true };
+    }
+    if (isObjectIdType(typedDef.type)) {
+      return { type: "string", pattern: "^[0-9a-fA-F]{24}$" };
+    }
+    if (isMongooseSchema(typedDef.type)) {
+      const obj = typedDef.type.obj;
+      if (obj && typeof obj === "object") {
+        if (seen.has(obj)) return { type: "object", additionalProperties: true };
+        seen.add(obj);
+        return convertTreeToJsonSchema(obj, options, seen);
+      }
+    }
+  }
+  if (def === String) return { type: "string" };
+  if (def === Number) return { type: "number" };
+  if (def === Boolean) return { type: "boolean" };
+  if (def === Date) {
+    const mode = options?.dateAs || "datetime";
+    return mode === "date" ? { type: "string", format: "date" } : { type: "string", format: "date-time" };
+  }
+  if (isObjectIdType(def)) return { type: "string", pattern: "^[0-9a-fA-F]{24}$" };
+  if (isPlainObject(def)) {
+    if (seen.has(def)) return { type: "object", additionalProperties: true };
+    seen.add(def);
+    return convertTreeToJsonSchema(def, options, seen);
+  }
+  return {};
+}
+function convertTreeToJsonSchema(tree, options, seen = /* @__PURE__ */ new WeakSet()) {
+  if (!tree || typeof tree !== "object") {
+    return { type: "object", properties: {} };
+  }
+  if (seen.has(tree)) {
+    return { type: "object", additionalProperties: true };
+  }
+  seen.add(tree);
+  const properties = {};
+  const required = [];
+  for (const [key, val] of Object.entries(tree || {})) {
+    if (key === "__v" || key === "_id" || key === "id") continue;
+    const cfg = isPlainObject(val) && "type" in val ? val : { };
+    properties[key] = jsonTypeFor(val, options, seen);
+    if (cfg.required === true) required.push(key);
+  }
+  const schema = { type: "object", properties };
+  if (required.length) schema.required = required;
+  return schema;
+}
+function buildJsonSchemaForCreate(tree, options) {
+  const base = convertTreeToJsonSchema(tree, options, /* @__PURE__ */ new WeakSet());
+  const fieldsToOmit = /* @__PURE__ */ new Set(["createdAt", "updatedAt", "__v"]);
+  (options?.create?.omitFields || []).forEach((f) => fieldsToOmit.add(f));
+  const fieldRules = options?.fieldRules || {};
+  Object.entries(fieldRules).forEach(([field, rules]) => {
+    if (rules.systemManaged) {
+      fieldsToOmit.add(field);
+    }
+  });
+  fieldsToOmit.forEach((field) => {
+    if (base.properties?.[field]) {
+      delete base.properties[field];
+    }
+    if (base.required) {
+      base.required = base.required.filter((k) => k !== field);
+    }
+  });
+  const reqOv = options?.create?.requiredOverrides || {};
+  const optOv = options?.create?.optionalOverrides || {};
+  base.required = base.required || [];
+  for (const [k, v] of Object.entries(reqOv)) {
+    if (v && !base.required.includes(k)) base.required.push(k);
+  }
+  for (const [k, v] of Object.entries(optOv)) {
+    if (v && base.required) base.required = base.required.filter((x) => x !== k);
+  }
+  Object.entries(fieldRules).forEach(([field, rules]) => {
+    if (rules.optional && base.required) {
+      base.required = base.required.filter((x) => x !== field);
+    }
+  });
+  const schemaOverrides = options?.create?.schemaOverrides || {};
+  for (const [k, override] of Object.entries(schemaOverrides)) {
+    if (base.properties?.[k]) {
+      base.properties[k] = override;
+    }
+  }
+  if (options?.strictAdditionalProperties === true) {
+    base.additionalProperties = false;
+  }
+  return base;
+}
+function buildJsonSchemaForUpdate(createJson, options) {
+  const clone = JSON.parse(JSON.stringify(createJson));
+  delete clone.required;
+  const fieldsToOmit = /* @__PURE__ */ new Set();
+  (options?.update?.omitFields || []).forEach((f) => fieldsToOmit.add(f));
+  const fieldRules = options?.fieldRules || {};
+  Object.entries(fieldRules).forEach(([field, rules]) => {
+    if (rules.immutable || rules.immutableAfterCreate) {
+      fieldsToOmit.add(field);
+    }
+  });
+  fieldsToOmit.forEach((field) => {
+    if (clone.properties?.[field]) {
+      delete clone.properties[field];
+    }
+  });
+  if (options?.strictAdditionalProperties === true) {
+    clone.additionalProperties = false;
+  }
+  return clone;
+}
+function buildJsonSchemaForQuery(_tree, options) {
+  const basePagination = {
+    type: "object",
+    properties: {
+      page: { type: "string" },
+      limit: { type: "string" },
+      sort: { type: "string" },
+      populate: { type: "string" },
+      search: { type: "string" },
+      select: { type: "string" },
+      lean: { type: "string" },
+      includeDeleted: { type: "string" }
+    },
+    additionalProperties: true
+  };
+  const filterable = options?.query?.filterableFields || {};
+  for (const [k, v] of Object.entries(filterable)) {
+    if (basePagination.properties) {
+      basePagination.properties[k] = v && typeof v === "object" && "type" in v ? v : { type: "string" };
+    }
+  }
+  return basePagination;
+}
 var QueryParser = class {
   options;
   operators = {
@@ -2687,7 +2946,7 @@ var QueryParser = class {
     const stringValue = String(value);
     if (stringValue === "true") return true;
     if (stringValue === "false") return false;
-    if (mongoose.Types.ObjectId.isValid(stringValue) && stringValue.length === 24) {
+    if (mongoose4.Types.ObjectId.isValid(stringValue) && stringValue.length === 24) {
       return stringValue;
     }
     return stringValue;
@@ -2784,4 +3043,4 @@ var index_default = Repository;
  * ```
  */
 
-export { PaginationEngine, QueryParser, Repository, actions_exports as actions, aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, cascadePlugin, createError, createFieldPreset, createMemoryCache, createRepository, index_default as default, fieldFilterPlugin, filterResponseData, getFieldsForUser, getMongooseProjection, immutableField, methodRegistryPlugin, mongoOperationsPlugin, queryParser_default as queryParser, requireField, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };
+export { PaginationEngine, QueryParser, Repository, actions_exports as actions, aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, cachePlugin, cascadePlugin, createError, createFieldPreset, createMemoryCache, createRepository, index_default as default, fieldFilterPlugin, filterResponseData, getFieldsForUser, getImmutableFields, getMongooseProjection, getSystemManagedFields, immutableField, isFieldUpdateAllowed, methodRegistryPlugin, mongoOperationsPlugin, queryParser_default as queryParser, requireField, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validateUpdateBody, validationChainPlugin };

package/dist/pagination/PaginationEngine.d.ts

@@ -1,5 +1,5 @@
 import { Model } from 'mongoose';
-import { A as AnyDocument, P as PaginationConfig, O as OffsetPaginationOptions, a as OffsetPaginationResult, K as KeysetPaginationOptions, b as KeysetPaginationResult, c as AggregatePaginationOptions, d as AggregatePaginationResult } from '../types-DAl69QgM.js';
+import { A as AnyDocument, P as PaginationConfig, O as OffsetPaginationOptions, a as OffsetPaginationResult, K as KeysetPaginationOptions, b as KeysetPaginationResult, c as AggregatePaginationOptions, d as AggregatePaginationResult } from '../types-DDDYo18H.js';
 
 /**
  * Pagination Engine

package/dist/plugins/index.d.ts

@@ -1,4 +1,4 @@
-import { F as FieldPreset, r as Plugin, L as Logger, M as SoftDeleteOptions, t as RepositoryInstance, G as ValidatorDefinition, I as ValidationChainOptions, i as RepositoryContext, Z as CacheOptions, a1 as CascadeOptions } from '../types-DAl69QgM.js';
+import { F as FieldPreset, r as Plugin, L as Logger, M as SoftDeleteOptions, t as RepositoryInstance, G as ValidatorDefinition, I as ValidationChainOptions, i as RepositoryContext, _ as CacheOptions, a2 as CascadeOptions } from '../types-DDDYo18H.js';
 import 'mongoose';
 
 /**

package/dist/{queryParser-Bek4yy3x.d.ts → queryParser-Do3SgsyJ.d.ts}

@@ -1,4 +1,5 @@
-import { q as UserContext, F as FieldPreset, H as HttpError, Y as CacheAdapter, v as ParsedQuery } from './types-DAl69QgM.js';
+import { q as UserContext, F as FieldPreset, H as HttpError, Z as CacheAdapter, y as SchemaBuilderOptions, z as CrudSchemas, V as ValidationResult, v as ParsedQuery } from './types-DDDYo18H.js';
+import mongoose__default, { Schema } from 'mongoose';
 
 /**
  * Field Selection Utilities
@@ -139,6 +140,58 @@ declare function createError(status: number, message: string): HttpError;
  */
 declare function createMemoryCache(maxEntries?: number): CacheAdapter;
 
+/**
+ * Mongoose to JSON Schema Converter with Field Rules
+ *
+ * Generates Fastify JSON schemas from Mongoose models with declarative field rules.
+ *
+ * Field Rules (options.fieldRules):
+ * - immutable: Field cannot be updated (omitted from update schema)
+ * - immutableAfterCreate: Alias for immutable
+ * - systemManaged: System-only field (omitted from create/update)
+ * - optional: Remove from required array
+ *
+ * Additional Options:
+ * - strictAdditionalProperties: Set to true to add "additionalProperties: false" to schemas
+ *   This makes Fastify reject unknown fields at validation level (default: false for backward compatibility)
+ *
+ * @example
+ * buildCrudSchemasFromModel(Model, {
+ *   strictAdditionalProperties: true, // Reject unknown fields
+ *   fieldRules: {
+ *     organizationId: { immutable: true },
+ *     status: { systemManaged: true },
+ *   },
+ *   create: { omitFields: ['verifiedAt'] },
+ *   update: { omitFields: ['customerId'] }
+ * })
+ */
+
+/**
+ * Build CRUD schemas from Mongoose schema
+ */
+declare function buildCrudSchemasFromMongooseSchema(mongooseSchema: Schema, options?: SchemaBuilderOptions): CrudSchemas;
+/**
+ * Build CRUD schemas from Mongoose model
+ */
+declare function buildCrudSchemasFromModel(mongooseModel: mongoose__default.Model<unknown>, options?: SchemaBuilderOptions): CrudSchemas;
+/**
+ * Get fields that are immutable (cannot be updated)
+ */
+declare function getImmutableFields(options?: SchemaBuilderOptions): string[];
+/**
+ * Get fields that are system-managed (cannot be set by users)
+ */
+declare function getSystemManagedFields(options?: SchemaBuilderOptions): string[];
+/**
+ * Check if field is allowed in update
+ */
+declare function isFieldUpdateAllowed(fieldName: string, options?: SchemaBuilderOptions): boolean;
+/**
+ * Validate update body against field rules
+ */
+declare function validateUpdateBody(body?: Record<string, unknown>, options?: SchemaBuilderOptions): ValidationResult;
+
 /**
  * Query Parser
  *
@@ -247,4 +300,4 @@ declare class QueryParser {
 /** Default query parser instance with standard options */
 declare const defaultQueryParser: QueryParser;
 
-export { type FilterValue as F, type OperatorMap as O, QueryParser as Q, getMongooseProjection as a, createError as b, createFieldPreset as c, createMemoryCache as d, defaultQueryParser as e, filterResponseData as f, getFieldsForUser as g, type QueryParserOptions as h };
+export { type FilterValue as F, type OperatorMap as O, QueryParser as Q, getMongooseProjection as a, type QueryParserOptions as b, createFieldPreset as c, defaultQueryParser as d, buildCrudSchemasFromMongooseSchema as e, filterResponseData as f, getFieldsForUser as g, buildCrudSchemasFromModel as h, getImmutableFields as i, getSystemManagedFields as j, isFieldUpdateAllowed as k, createError as l, createMemoryCache as m, validateUpdateBody as v };

package/dist/{types-DAl69QgM.d.ts → types-DDDYo18H.d.ts}

@@ -158,6 +158,13 @@ interface OperationOptions {
     /** Additional query filters (e.g., for soft delete) */
     query?: Record<string, unknown>;
 }
+/** withTransaction options */
+interface WithTransactionOptions {
+    /** Allow non-transactional fallback when transactions are unsupported */
+    allowFallback?: boolean;
+    /** Optional hook to observe fallback triggers */
+    onFallback?: (error: Error) => void;
+}
 /** Create operation options */
 interface CreateOptions {
     /** MongoDB session for transactions */
@@ -348,30 +355,16 @@ interface JsonSchema {
     format?: string;
     pattern?: string;
 }
-/** CRUD schemas result */
+/** CRUD schemas result - framework-agnostic JSON schemas */
 interface CrudSchemas {
+    /** JSON Schema for create request body */
     createBody: JsonSchema;
+    /** JSON Schema for update request body */
     updateBody: JsonSchema;
+    /** JSON Schema for route params (id validation) */
     params: JsonSchema;
+    /** JSON Schema for list/query parameters */
     listQuery: JsonSchema;
-    crudSchemas: {
-        create: {
-            body: JsonSchema;
-        };
-        update: {
-            body: JsonSchema;
-            params: JsonSchema;
-        };
-        get: {
-            params: JsonSchema;
-        };
-        list: {
-            query: JsonSchema;
-        };
-        remove: {
-            params: JsonSchema;
-        };
-    };
 }
 /** Decoded cursor */
 interface DecodedCursor {
@@ -580,4 +573,4 @@ interface HttpError extends Error {
     }>;
 }
 
-export type { CacheStats as $, AnyDocument as A, DecodedCursor as B, CreateOptions as C, DeleteResult as D, EventPayload as E, FieldPreset as F, ValidatorDefinition as G, HttpError as H, ValidationChainOptions as I, JsonSchema as J, KeysetPaginationOptions as K, Logger as L, SoftDeleteOptions as M, SoftDeleteFilterMode as N, OffsetPaginationOptions as O, PaginationConfig as P, SoftDeleteRepository as Q, RepositoryOptions as R, SelectSpec as S, LookupOptions as T, UpdateOptions as U, ValidationResult as V, GroupResult as W, MinMaxResult as X, CacheAdapter as Y, CacheOptions as Z, CacheOperationOptions as _, OffsetPaginationResult as a, CascadeRelation as a0, CascadeOptions as a1, KeysetPaginationResult as b, AggregatePaginationOptions as c, AggregatePaginationResult as d, PluginType as e, ObjectId as f, PopulateSpec as g, SortSpec as h, RepositoryContext as i, AnyModel as j, SortDirection as k, HookMode as l, PaginationResult as m, OperationOptions as n, UpdateManyResult as o, UpdateWithValidationResult as p, UserContext as q, Plugin as r, PluginFunction as s, RepositoryInstance as t, RepositoryEvent as u, ParsedQuery as v, FilterQuery as w, FieldRules as x, SchemaBuilderOptions as y, CrudSchemas as z };
+export type { CacheOperationOptions as $, AnyDocument as A, DecodedCursor as B, CreateOptions as C, DeleteResult as D, EventPayload as E, FieldPreset as F, ValidatorDefinition as G, HttpError as H, ValidationChainOptions as I, JsonSchema as J, KeysetPaginationOptions as K, Logger as L, SoftDeleteOptions as M, SoftDeleteFilterMode as N, OffsetPaginationOptions as O, PaginationConfig as P, SoftDeleteRepository as Q, RepositoryOptions as R, SelectSpec as S, LookupOptions as T, UpdateOptions as U, ValidationResult as V, WithTransactionOptions as W, GroupResult as X, MinMaxResult as Y, CacheAdapter as Z, CacheOptions as _, OffsetPaginationResult as a, CacheStats as a0, CascadeRelation as a1, CascadeOptions as a2, KeysetPaginationResult as b, AggregatePaginationOptions as c, AggregatePaginationResult as d, PopulateSpec as e, SortSpec as f, PluginType as g, ObjectId as h, RepositoryContext as i, AnyModel as j, SortDirection as k, HookMode as l, PaginationResult as m, OperationOptions as n, UpdateManyResult as o, UpdateWithValidationResult as p, UserContext as q, Plugin as r, PluginFunction as s, RepositoryInstance as t, RepositoryEvent as u, ParsedQuery as v, FilterQuery as w, FieldRules as x, SchemaBuilderOptions as y, CrudSchemas as z };

package/dist/utils/index.d.ts

@@ -1,58 +1,6 @@
-export { F as FilterValue, O as OperatorMap, Q as QueryParser, h as QueryParserOptions, b as createError, c as createFieldPreset, d as createMemoryCache, f as filterResponseData, g as getFieldsForUser, a as getMongooseProjection, e as queryParser } from '../queryParser-Bek4yy3x.js';
-import mongoose__default, { Schema } from 'mongoose';
-import { y as SchemaBuilderOptions, z as CrudSchemas, V as ValidationResult, S as SelectSpec, g as PopulateSpec, h as SortSpec } from '../types-DAl69QgM.js';
-
-/**
- * Mongoose to JSON Schema Converter with Field Rules
- *
- * Generates Fastify JSON schemas from Mongoose models with declarative field rules.
- *
- * Field Rules (options.fieldRules):
- * - immutable: Field cannot be updated (omitted from update schema)
- * - immutableAfterCreate: Alias for immutable
- * - systemManaged: System-only field (omitted from create/update)
- * - optional: Remove from required array
- *
- * Additional Options:
- * - strictAdditionalProperties: Set to true to add "additionalProperties: false" to schemas
- *   This makes Fastify reject unknown fields at validation level (default: false for backward compatibility)
- *
- * @example
- * buildCrudSchemasFromModel(Model, {
- *   strictAdditionalProperties: true, // Reject unknown fields
- *   fieldRules: {
- *     organizationId: { immutable: true },
- *     status: { systemManaged: true },
- *   },
- *   create: { omitFields: ['verifiedAt'] },
- *   update: { omitFields: ['customerId'] }
- * })
- */
-
-/**
- * Build CRUD schemas from Mongoose schema
- */
-declare function buildCrudSchemasFromMongooseSchema(mongooseSchema: Schema, options?: SchemaBuilderOptions): CrudSchemas;
-/**
- * Build CRUD schemas from Mongoose model
- */
-declare function buildCrudSchemasFromModel(mongooseModel: mongoose__default.Model<unknown>, options?: SchemaBuilderOptions): CrudSchemas;
-/**
- * Get fields that are immutable (cannot be updated)
- */
-declare function getImmutableFields(options?: SchemaBuilderOptions): string[];
-/**
- * Get fields that are system-managed (cannot be set by users)
- */
-declare function getSystemManagedFields(options?: SchemaBuilderOptions): string[];
-/**
- * Check if field is allowed in update
- */
-declare function isFieldUpdateAllowed(fieldName: string, options?: SchemaBuilderOptions): boolean;
-/**
- * Validate update body against field rules
- */
-declare function validateUpdateBody(body?: Record<string, unknown>, options?: SchemaBuilderOptions): ValidationResult;
+export { F as FilterValue, O as OperatorMap, Q as QueryParser, b as QueryParserOptions, h as buildCrudSchemasFromModel, e as buildCrudSchemasFromMongooseSchema, l as createError, c as createFieldPreset, m as createMemoryCache, f as filterResponseData, g as getFieldsForUser, i as getImmutableFields, a as getMongooseProjection, j as getSystemManagedFields, k as isFieldUpdateAllowed, d as queryParser, v as validateUpdateBody } from '../queryParser-Do3SgsyJ.js';
+import { S as SelectSpec, e as PopulateSpec, f as SortSpec } from '../types-DDDYo18H.js';
+import 'mongoose';
 
 /**
  * Cache Key Utilities
@@ -131,4 +79,4 @@ declare function modelPattern(prefix: string, model: string): string;
  */
 declare function listPattern(prefix: string, model: string): string;
 
-export { buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, byIdKey, byQueryKey, getImmutableFields, getSystemManagedFields, isFieldUpdateAllowed, listPattern, listQueryKey, modelPattern, validateUpdateBody, versionKey };
+export { byIdKey, byQueryKey, listPattern, listQueryKey, modelPattern, versionKey };

package/dist/utils/index.js

@@ -379,14 +379,7 @@ function buildCrudSchemasFromMongooseSchema(mongooseSchema, options = {}) {
     required: ["id"]
   };
   const jsonQuery = buildJsonSchemaForQuery(tree, options);
-  const crudSchemas = {
-    create: { body: jsonCreate },
-    update: { body: jsonUpdate, params: jsonParams },
-    get: { params: jsonParams },
-    list: { query: jsonQuery },
-    remove: { params: jsonParams }
-  };
-  return { createBody: jsonCreate, updateBody: jsonUpdate, params: jsonParams, listQuery: jsonQuery, crudSchemas };
+  return { createBody: jsonCreate, updateBody: jsonUpdate, params: jsonParams, listQuery: jsonQuery };
 }
 function buildCrudSchemasFromModel(mongooseModel, options = {}) {
   if (!mongooseModel || !mongooseModel.schema) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classytic/mongokit",
-  "version": "3.0.4",
+  "version": "3.0.6",
   "description": "Production-grade MongoDB repositories with zero dependencies - smart pagination, events, and plugins",
   "type": "module",
   "main": "./dist/index.js",