@classytic/mongokit 3.1.0 → 3.1.1

package/dist/{types-CrSoCuWu.d.ts → types-DA0rs2Jh.d.ts}

@@ -23,7 +23,63 @@ type PopulateSpec = string | string[] | PopulateOptions | PopulateOptions[];
 /** Select specification */
 type SelectSpec = string | string[] | Record<string, 0 | 1>;
 /** Filter query type for MongoDB queries (compatible with Mongoose 8 & 9) */
-type FilterQuery<T> = Record<string, unknown>;
+type FilterQuery<_T = unknown> = Record<string, unknown>;
+/**
+ * Infer document type from a Mongoose Model
+ * @example
+ * type UserDoc = InferDocument<typeof UserModel>;
+ */
+type InferDocument<TModel> = TModel extends Model<infer TDoc> ? TDoc : never;
+/**
+ * Infer raw document shape (without Mongoose Document methods)
+ * @example
+ * type User = InferRawDoc<typeof UserModel>;
+ */
+type InferRawDoc<TModel> = TModel extends Model<infer TDoc> ? TDoc extends Document ? Omit<TDoc, keyof Document> : TDoc : never;
+/**
+ * Make specific fields optional
+ * @example
+ * type CreateUser = PartialBy<User, 'createdAt' | 'updatedAt'>;
+ */
+type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/**
+ * Make specific fields required
+ * @example
+ * type UserWithId = RequiredBy<User, '_id'>;
+ */
+type RequiredBy<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+/**
+ * Extract keys of type T that have values of type V
+ * @example
+ * type StringFields = KeysOfType<User, string>; // 'name' | 'email'
+ */
+type KeysOfType<T, V> = {
+    [K in keyof T]: T[K] extends V ? K : never;
+}[keyof T];
+/**
+ * Deep partial - makes all nested properties optional
+ */
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+/**
+ * Strict object type - prevents excess properties
+ * Use with `satisfies` for compile-time validation
+ */
+type Strict<T> = T & {
+    [K in Exclude<string, keyof T>]?: never;
+};
+/**
+ * NonNullable fields extractor
+ */
+type NonNullableFields<T> = {
+    [K in keyof T]: NonNullable<T[K]>;
+};
+/**
+ * Create/Update input types from document
+ */
+type CreateInput<TDoc> = Omit<TDoc, '_id' | 'createdAt' | 'updatedAt' | '__v'>;
+type UpdateInput<TDoc> = Partial<Omit<TDoc, '_id' | 'createdAt' | '__v'>>;
 /** Hook execution mode */
 type HookMode = 'sync' | 'async';
 /** Repository options */
@@ -242,8 +298,30 @@ interface RepositoryContext {
     lean?: boolean;
     /** MongoDB session */
     session?: ClientSession;
-    /** Include soft-deleted documents */
+    /** Pagination filters */
+    filters?: Record<string, unknown>;
+    /** Sort specification */
+    sort?: SortSpec;
+    /** Page number (offset pagination) */
+    page?: number;
+    /** Items per page */
+    limit?: number;
+    /** Cursor for next page (keyset pagination) */
+    after?: string;
+    /** Whether this is a soft delete operation (set by softDeletePlugin) */
+    softDeleted?: boolean;
+    /** Include soft-deleted documents in queries */
     includeDeleted?: boolean;
+    /** Skip cache for this operation */
+    skipCache?: boolean;
+    /** Custom TTL for this operation (seconds) */
+    cacheTtl?: number;
+    /** Whether result was served from cache (internal) */
+    _cacheHit?: boolean;
+    /** Cached result (internal) */
+    _cachedResult?: unknown;
+    /** IDs to cascade delete (internal) */
+    _cascadeIds?: unknown[];
     /** Custom context data from plugins */
     [key: string]: unknown;
 }
@@ -272,8 +350,24 @@ interface RepositoryInstance {
     hasMethod?(name: string): boolean;
     [key: string]: unknown;
 }
-/** Repository event names */
-type RepositoryEvent = 'before:create' | 'after:create' | 'error:create' | 'before:createMany' | 'after:createMany' | 'error:createMany' | 'before:update' | 'after:update' | 'error:update' | 'before:updateMany' | 'after:updateMany' | 'error:updateMany' | 'before:delete' | 'after:delete' | 'error:delete' | 'before:deleteMany' | 'after:deleteMany' | 'error:deleteMany' | 'before:getById' | 'after:getById' | 'before:getByQuery' | 'after:getByQuery' | 'before:getAll' | 'after:getAll' | 'before:aggregatePaginate' | 'method:registered' | 'error:hook';
+/** Repository operation names */
+type RepositoryOperation = 'create' | 'createMany' | 'update' | 'updateMany' | 'delete' | 'deleteMany' | 'getById' | 'getByQuery' | 'getAll' | 'aggregatePaginate' | 'lookupPopulate';
+/** Event lifecycle phases */
+type EventPhase = 'before' | 'after' | 'error';
+/** Repository event names (generated from template literals) */
+type RepositoryEvent = `${EventPhase}:${RepositoryOperation}` | 'method:registered' | 'error:hook';
+/** Type-safe event handler map */
+type EventHandlers<TDoc = unknown> = {
+    [K in RepositoryEvent]?: K extends `after:${string}` ? (payload: {
+        context: RepositoryContext;
+        result: TDoc | TDoc[];
+    }) => void | Promise<void> : K extends `error:${string}` ? (payload: {
+        context: RepositoryContext;
+        error: Error;
+    }) => void | Promise<void> : (payload: {
+        context: RepositoryContext;
+    }) => void | Promise<void>;
+};
 /** Event payload */
 interface EventPayload {
     context: RepositoryContext;
@@ -553,4 +647,4 @@ interface HttpError extends Error {
     }>;
 }
 
-export type { CascadeOptions as $, AnyDocument as A, ValidatorDefinition as B, CacheAdapter as C, DeleteResult as D, EventPayload as E, FieldPreset as F, ValidationChainOptions as G, HttpError as H, SoftDeleteOptions as I, JsonSchema as J, KeysetPaginationOptions as K, Logger as L, SoftDeleteFilterMode as M, SoftDeleteRepository as N, OffsetPaginationOptions as O, PaginationConfig as P, GroupResult as Q, RepositoryOptions as R, SelectSpec as S, MinMaxResult as T, UserContext as U, ValidationResult as V, WithTransactionOptions as W, CacheOptions as X, CacheOperationOptions as Y, CacheStats as Z, CascadeRelation as _, OffsetPaginationResult as a, KeysetPaginationResult as b, AggregatePaginationOptions as c, AggregatePaginationResult as d, PopulateSpec as e, SortSpec as f, SchemaBuilderOptions as g, CrudSchemas as h, PaginationResult as i, PluginType as j, ObjectId as k, UpdateOptions as l, RepositoryContext as m, AnyModel as n, SortDirection as o, HookMode as p, OperationOptions as q, CreateOptions as r, UpdateManyResult as s, UpdateWithValidationResult as t, Plugin as u, PluginFunction as v, RepositoryInstance as w, RepositoryEvent as x, FieldRules as y, DecodedCursor as z };
+export type { DecodedCursor as $, AnyDocument as A, UpdateManyResult as B, CacheAdapter as C, DeepPartial as D, UpdateWithValidationResult as E, FieldPreset as F, Plugin as G, HttpError as H, InferDocument as I, PluginFunction as J, KeysetPaginationOptions as K, RepositoryInstance as L, RepositoryOperation as M, NonNullableFields as N, OffsetPaginationOptions as O, PaginationConfig as P, EventPhase as Q, RepositoryOptions as R, SelectSpec as S, RepositoryEvent as T, UserContext as U, ValidationResult as V, WithTransactionOptions as W, EventHandlers as X, EventPayload as Y, FieldRules as Z, JsonSchema as _, OffsetPaginationResult as a, ValidatorDefinition as a0, ValidationChainOptions as a1, Logger as a2, SoftDeleteOptions as a3, SoftDeleteFilterMode as a4, SoftDeleteRepository as a5, GroupResult as a6, MinMaxResult as a7, CacheOptions as a8, CacheOperationOptions as a9, CacheStats as aa, CascadeRelation as ab, CascadeOptions as ac, KeysetPaginationResult as b, AggregatePaginationOptions as c, AggregatePaginationResult as d, PopulateSpec as e, SortSpec as f, SchemaBuilderOptions as g, CrudSchemas as h, PaginationResult as i, PluginType as j, ObjectId as k, UpdateOptions as l, RepositoryContext as m, AnyModel as n, SortDirection as o, HookMode as p, InferRawDoc as q, PartialBy as r, RequiredBy as s, KeysOfType as t, Strict as u, CreateInput as v, UpdateInput as w, OperationOptions as x, CreateOptions as y, DeleteResult as z };

package/dist/utils/index.d.ts

@@ -1,5 +1,5 @@
-export { d as buildCrudSchemasFromModel, b as buildCrudSchemasFromMongooseSchema, j as createError, c as createFieldPreset, k as createMemoryCache, f as filterResponseData, g as getFieldsForUser, e as getImmutableFields, a as getMongooseProjection, h as getSystemManagedFields, i as isFieldUpdateAllowed, v as validateUpdateBody } from '../mongooseToJsonSchema-CUQma8QK.js';
-import { S as SelectSpec, e as PopulateSpec, f as SortSpec } from '../types-CrSoCuWu.js';
+export { d as buildCrudSchemasFromModel, b as buildCrudSchemasFromMongooseSchema, j as createError, c as createFieldPreset, k as createMemoryCache, f as filterResponseData, g as getFieldsForUser, e as getImmutableFields, a as getMongooseProjection, h as getSystemManagedFields, i as isFieldUpdateAllowed, v as validateUpdateBody } from '../mongooseToJsonSchema-BKMxPbPp.js';
+import { S as SelectSpec, e as PopulateSpec, f as SortSpec } from '../types-DA0rs2Jh.js';
 import 'mongoose';
 
 /**

package/dist/utils/index.js

@@ -1,398 +1,3 @@
-import 'mongoose';
-
-// 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 || []
-  };
-}
-function buildCrudSchemasFromMongooseSchema(mongooseSchema, options = {}) {
-  const jsonCreate = buildJsonSchemaFromPaths(mongooseSchema, options);
-  const jsonUpdate = buildJsonSchemaForUpdate(jsonCreate, options);
-  const jsonParams = {
-    type: "object",
-    properties: { id: { type: "string", pattern: "^[0-9a-fA-F]{24}$" } },
-    required: ["id"]
-  };
-  const tree = mongooseSchema?.obj || {};
-  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 buildJsonSchemaFromPaths(mongooseSchema, options) {
-  const properties = {};
-  const required = [];
-  const paths = mongooseSchema.paths;
-  const rootFields = /* @__PURE__ */ new Map();
-  for (const [path, schemaType] of Object.entries(paths)) {
-    if (path === "_id" || path === "__v") continue;
-    const parts = path.split(".");
-    const rootField = parts[0];
-    if (!rootFields.has(rootField)) {
-      rootFields.set(rootField, []);
-    }
-    rootFields.get(rootField).push({ path, schemaType });
-  }
-  for (const [rootField, fieldPaths] of rootFields.entries()) {
-    if (fieldPaths.length === 1 && fieldPaths[0].path === rootField) {
-      const schemaType = fieldPaths[0].schemaType;
-      properties[rootField] = schemaTypeToJsonSchema(schemaType);
-      if (schemaType.isRequired) {
-        required.push(rootField);
-      }
-    } else {
-      const nestedSchema = buildNestedJsonSchema(fieldPaths, rootField);
-      properties[rootField] = nestedSchema.schema;
-      if (nestedSchema.required) {
-        required.push(rootField);
-      }
-    }
-  }
-  const schema = { type: "object", properties };
-  if (required.length) schema.required = required;
-  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 (schema.properties?.[field]) {
-      delete schema.properties[field];
-    }
-    if (schema.required) {
-      schema.required = schema.required.filter((k) => k !== field);
-    }
-  });
-  const reqOv = options?.create?.requiredOverrides || {};
-  const optOv = options?.create?.optionalOverrides || {};
-  schema.required = schema.required || [];
-  for (const [k, v] of Object.entries(reqOv)) {
-    if (v && !schema.required.includes(k)) schema.required.push(k);
-  }
-  for (const [k, v] of Object.entries(optOv)) {
-    if (v && schema.required) schema.required = schema.required.filter((x) => x !== k);
-  }
-  Object.entries(fieldRules).forEach(([field, rules]) => {
-    if (rules.optional && schema.required) {
-      schema.required = schema.required.filter((x) => x !== field);
-    }
-  });
-  const schemaOverrides = options?.create?.schemaOverrides || {};
-  for (const [k, override] of Object.entries(schemaOverrides)) {
-    if (schema.properties?.[k]) {
-      schema.properties[k] = override;
-    }
-  }
-  if (options?.strictAdditionalProperties === true) {
-    schema.additionalProperties = false;
-  }
-  return schema;
-}
-function buildNestedJsonSchema(fieldPaths, rootField) {
-  const properties = {};
-  const required = [];
-  let hasRequiredFields = false;
-  for (const { path, schemaType } of fieldPaths) {
-    const relativePath = path.substring(rootField.length + 1);
-    const parts = relativePath.split(".");
-    if (parts.length === 1) {
-      properties[parts[0]] = schemaTypeToJsonSchema(schemaType);
-      if (schemaType.isRequired) {
-        required.push(parts[0]);
-        hasRequiredFields = true;
-      }
-    } else {
-      const fieldName = parts[0];
-      if (!properties[fieldName]) {
-        properties[fieldName] = { type: "object", properties: {} };
-      }
-      const nestedObj = properties[fieldName];
-      if (!nestedObj.properties) nestedObj.properties = {};
-      const deepPath = parts.slice(1).join(".");
-      nestedObj.properties[deepPath] = schemaTypeToJsonSchema(schemaType);
-    }
-  }
-  const schema = { type: "object", properties };
-  if (required.length) schema.required = required;
-  return { schema, required: hasRequiredFields };
-}
-function schemaTypeToJsonSchema(schemaType) {
-  const result = {};
-  const instance = schemaType.instance;
-  const options = schemaType.options || {};
-  if (instance === "String") {
-    result.type = "string";
-    if (typeof options.minlength === "number") result.minLength = options.minlength;
-    if (typeof options.maxlength === "number") result.maxLength = options.maxlength;
-    if (options.match instanceof RegExp) result.pattern = options.match.source;
-    if (options.enum && Array.isArray(options.enum)) result.enum = options.enum;
-  } else if (instance === "Number") {
-    result.type = "number";
-    if (typeof options.min === "number") result.minimum = options.min;
-    if (typeof options.max === "number") result.maximum = options.max;
-  } else if (instance === "Boolean") {
-    result.type = "boolean";
-  } else if (instance === "Date") {
-    result.type = "string";
-    result.format = "date-time";
-  } else if (instance === "ObjectId" || instance === "ObjectID") {
-    result.type = "string";
-    result.pattern = "^[0-9a-fA-F]{24}$";
-  } else if (instance === "Array") {
-    result.type = "array";
-    result.items = { type: "string" };
-  } else {
-    result.type = "object";
-    result.additionalProperties = true;
-  }
-  return result;
-}
-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;
-  }
-  if (options?.update?.requireAtLeastOne === true) {
-    clone.minProperties = 1;
-  }
-  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;
-}
-
-// src/utils/error.ts
-function createError(status, message) {
-  const error = new Error(message);
-  error.status = status;
-  return error;
-}
-
-// src/utils/memory-cache.ts
-function createMemoryCache(maxEntries = 1e3) {
-  const cache = /* @__PURE__ */ new Map();
-  function cleanup() {
-    const now = Date.now();
-    for (const [key, entry] of cache) {
-      if (entry.expiresAt < now) {
-        cache.delete(key);
-      }
-    }
-  }
-  function evictOldest() {
-    if (cache.size >= maxEntries) {
-      const firstKey = cache.keys().next().value;
-      if (firstKey) cache.delete(firstKey);
-    }
-  }
-  return {
-    async get(key) {
-      cleanup();
-      const entry = cache.get(key);
-      if (!entry) return null;
-      if (entry.expiresAt < Date.now()) {
-        cache.delete(key);
-        return null;
-      }
-      return entry.value;
-    },
-    async set(key, value, ttl) {
-      cleanup();
-      evictOldest();
-      cache.set(key, {
-        value,
-        expiresAt: Date.now() + ttl * 1e3
-      });
-    },
-    async del(key) {
-      cache.delete(key);
-    },
-    async clear(pattern) {
-      if (!pattern) {
-        cache.clear();
-        return;
-      }
-      const regex = new RegExp(
-        "^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
-      );
-      for (const key of cache.keys()) {
-        if (regex.test(key)) {
-          cache.delete(key);
-        }
-      }
-    }
-  };
-}
-
-// 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 { buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, byIdKey, byQueryKey, createError, createFieldPreset, createMemoryCache, filterResponseData, getFieldsForUser, getImmutableFields, getMongooseProjection, getSystemManagedFields, isFieldUpdateAllowed, listPattern, listQueryKey, modelPattern, validateUpdateBody, versionKey };
+export { buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, createMemoryCache, getImmutableFields, getSystemManagedFields, isFieldUpdateAllowed, validateUpdateBody } from '../chunks/chunk-IT7DCOKR.js';
+export { byIdKey, byQueryKey, createFieldPreset, filterResponseData, getFieldsForUser, getMongooseProjection, listPattern, listQueryKey, modelPattern, versionKey } from '../chunks/chunk-2ZN65ZOP.js';
+export { createError } from '../chunks/chunk-VJXDGP3C.js';

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "@classytic/mongokit",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "description": "Production-grade MongoDB repositories with zero dependencies - smart pagination, events, and plugins",
   "type": "module",
+  "sideEffects": false,
   "main": "./dist/index.js",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
@@ -57,7 +59,10 @@
     "nextjs",
     "typescript"
   ],
-  "author": "Sadman Chowdhury (Github: @siam923)",
+  "author": "Classytic <classytic.dev@gmail.com> (https://github.com/classytic)",
+  "contributors": [
+    "Sadman Chowdhury (https://github.com/siam923)"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -92,7 +97,7 @@
     "@types/node": "^22.0.0",
     "@vitest/coverage-v8": "^3.2.4",
     "mongodb-memory-server": "^10.2.3",
-    "mongoose": "^9.0.0",
+    "mongoose": "^9.1.3",
     "tsup": "^8.0.0",
     "typescript": "^5.7.0",
     "vitest": "^3.0.0"