@classytic/mongokit 3.8.0 → 3.10.1

package/dist/{mongooseToJsonSchema-DUwXPStK.mjs → mongooseToJsonSchema-D1sdCOmj.mjs}

@@ -1,5 +1,6 @@
 import { n as isObjectIdInstance } from "./id-resolution-e4BT9zAV.mjs";
 import mongoose from "mongoose";
+import { applyFieldRules, collectFieldsToOmit } from "@classytic/repo-core/schema";
 //#region src/utils/memory-cache.ts
 /**
 * Creates an in-memory cache adapter
@@ -51,7 +52,7 @@ function createMemoryCache(maxEntries = 1e3) {
 				expiresAt: Date.now() + ttl * 1e3
 			});
 		},
-		async del(key) {
+		async delete(key) {
 			cache.delete(key);
 		},
 		async clear(pattern) {
@@ -68,25 +69,22 @@ function createMemoryCache(maxEntries = 1e3) {
 //#endregion
 //#region src/utils/mongooseToJsonSchema.ts
 /**
-* Mongoose to JSON Schema Converter with Field Rules
+* Mongoose → JSON Schema converter.
 *
-* Generates Fastify JSON schemas from Mongoose models with declarative field rules.
+* The **mongoose-specific** half of mongokit's CRUD-schema pipeline. Walks
+* `Model.schema.paths` (accurate type info, including subdocuments, arrays,
+* Maps, enums, length/min/max validators) and emits the four portable
+* `CrudSchemas` fragments defined at `@classytic/repo-core/schema`.
 *
-* 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)
-* - update.requireAtLeastOne: Set to true to add "minProperties: 1" to update schema
-*   This prevents empty update payloads (default: false)
+* Policy — `fieldRules` (immutable / systemManaged / optional) and the
+* `create.omitFields` / `update.omitFields` lists — lives in repo-core and
+* is shared across every kit. Every other kit (sqlitekit's
+* `drizzleToJsonSchema`, prismakit's `prismaToJsonSchema`, ...) reuses the
+* same helpers so a switch of storage backend is a one-line import swap.
 *
 * @example
 * buildCrudSchemasFromModel(Model, {
-*   strictAdditionalProperties: true, // Reject unknown fields
+*   strictAdditionalProperties: true,
 *   fieldRules: {
 *     organizationId: { immutable: true },
 *     status: { systemManaged: true },
@@ -94,9 +92,9 @@ function createMemoryCache(maxEntries = 1e3) {
 *   create: { omitFields: ['verifiedAt'] },
 *   update: {
 *     omitFields: ['customerId'],
-*     requireAtLeastOne: true // Reject empty updates
-*   }
-* })
+*     requireAtLeastOne: true,
+*   },
+* });
 */
 function isMongooseSchema(value) {
 	return value instanceof mongoose.Schema;
@@ -134,89 +132,6 @@ function buildCrudSchemasFromModel(mongooseModel, options = {}) {
 	return buildCrudSchemasFromMongooseSchema(mongooseModel.schema, options);
 }
 /**
-* Collect fields to omit from a generated schema based on field rules and
-* explicit omit lists. This is the single source of truth for "which fields
-* should NOT appear in the create/update body" — called by both the
-* path-based and tree-based schema builders.
-*/
-function collectFieldsToOmit(options, purpose) {
-	const result = new Set([
-		"createdAt",
-		"updatedAt",
-		"__v"
-	]);
-	const rules = options?.fieldRules || {};
-	for (const [field, rule] of Object.entries(rules)) {
-		if (rule.systemManaged) result.add(field);
-		if (purpose === "update" && (rule.immutable || rule.immutableAfterCreate)) result.add(field);
-	}
-	const explicit = purpose === "create" ? options?.create?.omitFields : options?.update?.omitFields;
-	if (explicit) for (const f of explicit) result.add(f);
-	return result;
-}
-/**
-* Apply omissions + optional-overrides to a built JSON schema in-place.
-* Removes properties and adjusts the `required` array.
-*/
-function applyFieldRules(schema, fieldsToOmit, options) {
-	for (const field of fieldsToOmit) {
-		if (schema.properties?.[field]) delete schema.properties[field];
-		if (schema.required) schema.required = schema.required.filter((k) => k !== field);
-	}
-	const rules = options?.fieldRules || {};
-	for (const [field, rule] of Object.entries(rules)) if (rule.optional && schema.required) schema.required = schema.required.filter((k) => k !== field);
-}
-/**
-* Get fields that are immutable (cannot be updated).
-* Delegates to `collectFieldsToOmit` internally.
-*/
-function getImmutableFields(options = {}) {
-	const immutable = [];
-	const rules = options?.fieldRules || {};
-	for (const [field, rule] of Object.entries(rules)) if (rule.immutable || rule.immutableAfterCreate) immutable.push(field);
-	for (const f of options?.update?.omitFields || []) if (!immutable.includes(f)) immutable.push(f);
-	return immutable;
-}
-/**
-* Get fields that are system-managed (cannot be set by users).
-*/
-function getSystemManagedFields(options = {}) {
-	const systemManaged = [];
-	const rules = options?.fieldRules || {};
-	for (const [field, rule] of Object.entries(rules)) if (rule.systemManaged) systemManaged.push(field);
-	return systemManaged;
-}
-/**
-* Check if field is allowed in update
-*/
-function isFieldUpdateAllowed(fieldName, options = {}) {
-	const immutableFields = getImmutableFields(options);
-	const systemManagedFields = getSystemManagedFields(options);
-	return !immutableFields.includes(fieldName) && !systemManagedFields.includes(fieldName);
-}
-/**
-* Validate update body against field rules
-*/
-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
-	};
-}
-/**
 * Build JSON schema from Mongoose schema.paths (accurate type information)
 */
 function buildJsonSchemaFromPaths(mongooseSchema, options) {
@@ -228,6 +143,9 @@ function buildJsonSchemaFromPaths(mongooseSchema, options) {
 		if (softRequiredSet.has(name)) return true;
 		return schemaType?.options?.softRequired === true;
 	};
+	const hasDefault = (schemaType) => {
+		return schemaType?.options?.default !== void 0;
+	};
 	const rootFields = /* @__PURE__ */ new Map();
 	for (const [path, schemaType] of Object.entries(paths)) {
 		if (path === "__v") continue;
@@ -246,7 +164,7 @@ function buildJsonSchemaFromPaths(mongooseSchema, options) {
 	for (const [rootField, fieldPaths] of rootFields.entries()) if (fieldPaths.length === 1 && fieldPaths[0].path === rootField) {
 		const schemaType = fieldPaths[0].schemaType;
 		properties[rootField] = schemaTypeToJsonSchema(schemaType, options);
-		if (schemaType.isRequired && !isSoftRequired(rootField, schemaType)) required.push(rootField);
+		if (schemaType.isRequired && !isSoftRequired(rootField, schemaType) && !hasDefault(schemaType)) required.push(rootField);
 	} else {
 		const nestedSchema = buildNestedJsonSchema(fieldPaths, rootField, options);
 		properties[rootField] = nestedSchema.schema;
@@ -631,4 +549,4 @@ function buildJsonSchemaForQuery(_tree, options) {
 	return basePagination;
 }
 //#endregion
-export { isFieldUpdateAllowed as a, getSystemManagedFields as i, buildCrudSchemasFromMongooseSchema as n, validateUpdateBody as o, getImmutableFields as r, createMemoryCache as s, buildCrudSchemasFromModel as t };
+export { buildCrudSchemasFromMongooseSchema as n, createMemoryCache as r, buildCrudSchemasFromModel as t };

package/dist/{mongooseToJsonSchema-BZaKOXXI.d.mts → mongooseToJsonSchema-DlTx-Or2.d.mts}

@@ -1,5 +1,6 @@
-import { A as HttpError, St as ValidationResult, T as FieldPreset, _ as CrudSchemas, bt as UserContext, s as CacheAdapter, st as SchemaBuilderOptions } from "./types-D57SZJeE.mjs";
+import { O as HttpError, _t as UserContext, s as CacheAdapter, w as FieldPreset } from "./types-Bbr54g--.mjs";
 import mongoose, { Schema } from "mongoose";
+import { CrudSchemas, SchemaBuilderOptions } from "@classytic/repo-core/schema";
 
 //#region src/utils/error.d.ts
 /**
@@ -15,6 +16,23 @@ import mongoose, { Schema } from "mongoose";
  * throw createError(403, 'Access denied');
  */
 declare function createError(status: number, message: string): HttpError;
+/**
+ * Boolean classifier: true when `err` is an authoritative MongoDB duplicate
+ * key error — and ONLY then. Used by arc's outbox / idempotency adapters to
+ * distinguish "write already landed (idempotent no-op)" from "transient DB
+ * error (must retry)".
+ *
+ * Deliberately narrow — matches only:
+ *   - `code === 11000`
+ *   - `codeName === 'DuplicateKey'`
+ *
+ * Does NOT match `err.name === 'MongoServerError'`, which is also true for
+ * WriteConflict (112), NotWritablePrimary (10107), ExceededTimeLimit, and
+ * every other server-side error. Treating those as duplicate keys would
+ * cause arc's outbox to silently swallow transactional retries and lose
+ * events.
+ */
+declare function isDuplicateKeyError(err: unknown): boolean;
 /** Options for parseDuplicateKeyError */
 interface ParseDuplicateKeyOptions {
   /**
@@ -161,22 +179,5 @@ declare function buildCrudSchemasFromMongooseSchema(mongooseSchema: Schema, opti
  * Build CRUD schemas from Mongoose model
  */
 declare function buildCrudSchemasFromModel(mongooseModel: mongoose.Model<unknown>, options?: SchemaBuilderOptions): CrudSchemas;
-/**
- * Get fields that are immutable (cannot be updated).
- * Delegates to `collectFieldsToOmit` internally.
- */
-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;
 //#endregion
-export { isFieldUpdateAllowed as a, configureLogger as c, getFieldsForUser as d, getMongooseProjection as f, getSystemManagedFields as i, createFieldPreset as l, parseDuplicateKeyError as m, buildCrudSchemasFromMongooseSchema as n, validateUpdateBody as o, createError as p, getImmutableFields as r, createMemoryCache as s, buildCrudSchemasFromModel as t, filterResponseData as u };
+export { createFieldPreset as a, getMongooseProjection as c, parseDuplicateKeyError as d, configureLogger as i, createError as l, buildCrudSchemasFromMongooseSchema as n, filterResponseData as o, createMemoryCache as r, getFieldsForUser as s, buildCrudSchemasFromModel as t, isDuplicateKeyError as u };

package/dist/pagination/PaginationEngine.d.mts

@@ -1,4 +1,4 @@
-import { F as KeysetPaginationOptions, I as KeysetPaginationResult, K as PaginationConfig, U as OffsetPaginationOptions, W as OffsetPaginationResult, a as AnyDocument, n as AggregatePaginationOptions, r as AggregatePaginationResult } from "../types-D57SZJeE.mjs";
+import { B as OffsetPaginationOptions, M as KeysetPaginationOptions, N as KeysetPaginationResult, U as PaginationConfig, V as OffsetPaginationResult, a as AnyDocument, n as AggregatePaginationOptions, r as AggregatePaginationResult } from "../types-Bbr54g--.mjs";
 import { Model } from "mongoose";
 
 //#region src/pagination/PaginationEngine.d.ts

package/dist/pagination/PaginationEngine.mjs

@@ -1,2 +1,2 @@
-import { t as PaginationEngine } from "../PaginationEngine-C2_tAvAD.mjs";
+import { t as PaginationEngine } from "../PaginationEngine-B93fLCcO.mjs";
 export { PaginationEngine };

package/dist/plugins/index.d.mts

@@ -1,2 +1,2 @@
-import { $ as aggregateHelpersPlugin, A as PrefixedIdOptions, B as BatchOperationsMethods, C as methodRegistryPlugin, D as CustomIdOptions, E as elasticSearchPlugin, F as prefixedId, G as AuditQueryOptions, H as batchOperationsPlugin, I as sequentialId, J as AuditTrailOptions, K as AuditQueryResult, L as cascadePlugin, M as customIdPlugin, N as dateSequentialId, O as DateSequentialIdOptions, P as getNextSequence, Q as AggregateHelpersMethods, R as CacheMethods, S as MethodRegistryRepository, T as ElasticSearchOptions, U as AuditEntry, W as AuditOperation, X as auditTrailPlugin, Y as AuditTrailQuery, Z as auditLogPlugin, _ as observabilityPlugin, a as uniqueField, b as MongoOperationsMethods, c as TenantContext, d as SubdocumentMethods, f as subdocumentPlugin, g as OperationMetric, h as ObservabilityOptions, i as requireField, j as SequentialIdOptions, k as IdGenerator, l as TenantStore, m as softDeletePlugin, n as blockIf, o as validationChainPlugin, p as SoftDeleteMethods, q as AuditTrailMethods, r as immutableField, s as timestampPlugin, t as autoInject, u as createTenantContext, v as MultiTenantOptions, w as fieldFilterPlugin, x as mongoOperationsPlugin, y as multiTenantPlugin, z as cachePlugin } from "../validation-chain.plugin-wGF34Ym-.mjs";
+import { $ as aggregateHelpersPlugin, A as PrefixedIdOptions, B as BatchOperationsMethods, C as methodRegistryPlugin, D as CustomIdOptions, E as elasticSearchPlugin, F as prefixedId, G as AuditQueryOptions, H as batchOperationsPlugin, I as sequentialId, J as AuditTrailOptions, K as AuditQueryResult, L as cascadePlugin, M as customIdPlugin, N as dateSequentialId, O as DateSequentialIdOptions, P as getNextSequence, Q as AggregateHelpersMethods, R as CacheMethods, S as MethodRegistryRepository, T as ElasticSearchOptions, U as AuditEntry, W as AuditOperation, X as auditTrailPlugin, Y as AuditTrailQuery, Z as auditLogPlugin, _ as observabilityPlugin, a as uniqueField, b as MongoOperationsMethods, c as TenantContext, d as SubdocumentMethods, f as subdocumentPlugin, g as OperationMetric, h as ObservabilityOptions, i as requireField, j as SequentialIdOptions, k as IdGenerator, l as TenantStore, m as softDeletePlugin, n as blockIf, o as validationChainPlugin, p as SoftDeleteMethods, q as AuditTrailMethods, r as immutableField, s as timestampPlugin, t as autoInject, u as createTenantContext, v as MultiTenantOptions, w as fieldFilterPlugin, x as mongoOperationsPlugin, y as multiTenantPlugin, z as cachePlugin } from "../validation-chain.plugin-DAvlX93q.mjs";
 export { type AggregateHelpersMethods, type AuditEntry, type AuditOperation, type AuditQueryOptions, type AuditQueryResult, type AuditTrailMethods, type AuditTrailOptions, AuditTrailQuery, type BatchOperationsMethods, type CacheMethods, type CustomIdOptions, type DateSequentialIdOptions, type ElasticSearchOptions, type IdGenerator, type MethodRegistryRepository, type MongoOperationsMethods, type MultiTenantOptions, type ObservabilityOptions, type OperationMetric, type PrefixedIdOptions, type SequentialIdOptions, type SoftDeleteMethods, type SubdocumentMethods, type TenantContext, type TenantStore, aggregateHelpersPlugin, auditLogPlugin, auditTrailPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, cascadePlugin, createTenantContext, customIdPlugin, dateSequentialId, elasticSearchPlugin, fieldFilterPlugin, getNextSequence, immutableField, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, prefixedId, requireField, sequentialId, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };

package/dist/plugins/index.mjs

@@ -1,2 +1,2 @@
-import { A as AuditTrailQuery, C as cachePlugin, M as auditLogPlugin, N as aggregateHelpersPlugin, S as cascadePlugin, _ as customIdPlugin, a as uniqueField, b as prefixedId, c as createTenantContext, d as observabilityPlugin, f as multiTenantPlugin, g as elasticSearchPlugin, h as fieldFilterPlugin, i as requireField, j as auditTrailPlugin, k as batchOperationsPlugin, l as subdocumentPlugin, m as methodRegistryPlugin, n as blockIf, o as validationChainPlugin, p as mongoOperationsPlugin, r as immutableField, s as timestampPlugin, t as autoInject, u as softDeletePlugin, v as dateSequentialId, x as sequentialId, y as getNextSequence } from "../validation-chain.plugin-DwoOOWse.mjs";
+import { A as AuditTrailQuery, C as cachePlugin, M as auditLogPlugin, N as aggregateHelpersPlugin, S as cascadePlugin, _ as customIdPlugin, a as uniqueField, b as prefixedId, c as createTenantContext, d as observabilityPlugin, f as multiTenantPlugin, g as elasticSearchPlugin, h as fieldFilterPlugin, i as requireField, j as auditTrailPlugin, k as batchOperationsPlugin, l as subdocumentPlugin, m as methodRegistryPlugin, n as blockIf, o as validationChainPlugin, p as mongoOperationsPlugin, r as immutableField, s as timestampPlugin, t as autoInject, u as softDeletePlugin, v as dateSequentialId, x as sequentialId, y as getNextSequence } from "../validation-chain.plugin-Ccu6irtx.mjs";
 export { AuditTrailQuery, aggregateHelpersPlugin, auditLogPlugin, auditTrailPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, cascadePlugin, createTenantContext, customIdPlugin, dateSequentialId, elasticSearchPlugin, fieldFilterPlugin, getNextSequence, immutableField, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, prefixedId, requireField, sequentialId, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };

package/dist/{types-D57SZJeE.d.mts → types-Bbr54g--.d.mts}

@@ -1,5 +1,9 @@
 import * as _$mongoose from "mongoose";
 import { ClientSession, Document, Model, PipelineStage, PopulateOptions, Types } from "mongoose";
+import * as _$_classytic_repo_core_filter0 from "@classytic/repo-core/filter";
+import * as _$_classytic_repo_core_repository0 from "@classytic/repo-core/repository";
+import { DeleteResult, LookupPopulateResult, UpdateManyResult } from "@classytic/repo-core/repository";
+import { ValidationResult } from "@classytic/repo-core/schema";
 
 //#region src/query/LookupBuilder.d.ts
 interface LookupOptions {
@@ -865,11 +869,40 @@ interface AggregateOptions extends ReadOptions {
   maxPipelineStages?: number;
 }
 /** Lookup populate options */
-interface LookupPopulateOptions extends ReadOptions {
-  /** MongoDB query filters */
-  filters?: Record<string, unknown>;
-  /** Lookup configurations for $lookup joins */
-  lookups: LookupOptions[];
+/**
+ * Mongokit's `lookupPopulate` options — kit-native superset of the
+ * portable `LookupPopulateOptions<TBase>` from repo-core. Widens three
+ * slots so arc / mongoose consumers compose cleanly:
+ *
+ *   - `filters`: accepts Filter IR, a `Partial<TBase> & Record<string,
+ *     unknown>` literal (same shape repo-core's contract uses), or a
+ *     plain `Record<string, unknown>` for legacy callers.
+ *   - `lookups`: accepts either the portable `LookupSpec[]` (works on
+ *     every kit) or mongokit's `LookupOptions[]` (adds `pipeline` /
+ *     `let` / `sanitize` for mongo-correlated joins).
+ *   - `select`: accepts mongoose's space-separated string form
+ *     (`'name email'`) in addition to the portable array / inclusion
+ *     map. Kept for arc + existing controller convenience.
+ *
+ * `TBase` defaults to `unknown` so legacy non-generic usage still
+ * compiles; pass the doc type for arc `RepositoryLike<TDoc>` structural
+ * assignment — `LookupPopulateOptions<TDoc>` is bit-compatible with
+ * `import('@classytic/repo-core/repository').LookupPopulateOptions<TDoc>`.
+ */
+interface LookupPopulateOptions<TBase = unknown> extends ReadOptions {
+  /**
+   * Base-table filter. Accepts Filter IR from repo-core, a typed
+   * `Partial<TBase> & Record<string, unknown>` literal (what arc
+   * controllers produce when typed against `StandardRepo<TDoc>`), or
+   * a plain `Record<string, unknown>` for ad-hoc callers.
+   */
+  filters?: _$_classytic_repo_core_filter0.Filter | (Partial<TBase> & Record<string, unknown>) | Record<string, unknown>;
+  /**
+   * Portable `LookupSpec[]` (cross-kit) or mongokit-native
+   * `LookupOptions[]` (with `pipeline` / `let` / `sanitize`). The
+   * portable shape is a structural subset, so callers can mix.
+   */
+  lookups: readonly _$_classytic_repo_core_repository0.LookupSpec[] | LookupOptions[];
   /** Sort specification */
   sort?: SortSpec | string;
   /** Page number (offset mode, 1-indexed) */
@@ -885,38 +918,13 @@ interface LookupPopulateOptions extends ReadOptions {
   /** Count strategy for offset pagination */
   countStrategy?: 'exact' | 'estimated' | 'none';
 }
-/** Lookup populate result */
-interface LookupPopulateResult<T = unknown> {
-  data: T[];
-  total: number;
-  page?: number;
-  limit: number;
-  next?: string | null;
-  hasMore?: boolean;
-}
-/** Delete result */
-interface DeleteResult {
-  success: boolean;
-  message: string;
-  id?: string;
-  soft?: boolean;
-  count?: number;
-}
-/** Update many result */
-interface UpdateManyResult {
-  matchedCount: number;
-  modifiedCount: number;
-}
-/** Validation result */
-interface ValidationResult {
-  valid: boolean;
-  violations?: Array<{
-    field: string;
-    reason: string;
-  }>;
-  message?: string;
-}
-/** Update with validation result */
+/**
+ * Union emitted by the validation-chain plugin. Keeps the violation shape
+ * from `ValidationResult` without re-exporting the type — consumers that
+ * need `ValidationResult`, `CrudSchemas`, `JsonSchema`, `SchemaBuilderOptions`,
+ * `FieldRule` or `FieldRules` import them straight from
+ * `@classytic/repo-core/schema`.
+ */
 type UpdateWithValidationResult<T> = {
   success: true;
   data: T;
@@ -1046,13 +1054,13 @@ interface RepositoryInstance {
   _buildContext(operation: string, options: Record<string, unknown> | object): Promise<RepositoryContext>;
   _handleError(error: Error): HttpError;
   update(id: string | ObjectId, data: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
-  aggregate(pipeline: PipelineStage[], options?: Record<string, unknown>): Promise<unknown[]>;
+  aggregatePipeline(pipeline: PipelineStage[], options?: Record<string, unknown>): Promise<unknown[]>;
   getByQuery(query: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
   _executeQuery<T>(buildQuery: (Model: Model<any>) => Promise<T>): Promise<T>;
   [key: string]: unknown;
 }
 /** Repository operation names */
-type RepositoryOperation = 'create' | 'createMany' | 'update' | 'updateMany' | 'findOneAndUpdate' | 'delete' | 'deleteMany' | 'restore' | 'getById' | 'getByQuery' | 'getOne' | 'getAll' | 'findAll' | 'getOrCreate' | 'count' | 'exists' | 'distinct' | 'aggregate' | 'aggregatePaginate' | 'lookupPopulate' | 'bulkWrite';
+type RepositoryOperation = 'create' | 'createMany' | 'update' | 'updateMany' | 'findOneAndUpdate' | 'delete' | 'deleteMany' | 'restore' | 'getById' | 'getByQuery' | 'getOne' | 'getAll' | 'findAll' | 'getOrCreate' | 'count' | 'exists' | 'distinct' | 'aggregate' | 'aggregatePaginate' | 'aggregatePipeline' | 'aggregatePipelinePaginate' | 'lookupPopulate' | 'bulkWrite';
 /** Event lifecycle phases */
 type EventPhase = 'before' | 'after' | 'error';
 /** Repository event names (generated from template literals) */
@@ -1090,96 +1098,6 @@ interface FieldPreset {
   /** Additional fields for admins */
   admin?: string[];
 }
-/** Field rules for schema building */
-interface FieldRules {
-  [fieldName: string]: {
-    /** Field cannot be updated */immutable?: boolean; /** Alias for immutable */
-    immutableAfterCreate?: boolean; /** System-only field (omitted from create/update) */
-    systemManaged?: boolean; /** Remove from required array */
-    optional?: boolean;
-  };
-}
-/** Schema builder options */
-interface SchemaBuilderOptions {
-  /** Field rules for create/update */
-  fieldRules?: FieldRules;
-  /** Strict additional properties (default: false) */
-  strictAdditionalProperties?: boolean;
-  /** Date format: 'date' | 'datetime' */
-  dateAs?: 'date' | 'datetime';
-  /** Create schema options */
-  create?: {
-    /** Fields to omit from create schema */omitFields?: string[]; /** Override required status */
-    requiredOverrides?: Record<string, boolean>; /** Override optional status */
-    optionalOverrides?: Record<string, boolean>; /** Schema overrides */
-    schemaOverrides?: Record<string, unknown>;
-  };
-  /**
-   * Field names to mark as soft-required: they remain in the generated body
-   * schema's `properties` (still validated when present) but are excluded
-   * from the `required[]` array so the client may omit them.
-   *
-   * Combines with per-path `softRequired: true` Mongoose schema option.
-   * Use this when the Mongoose model is owned by an upstream package and
-   * you can't annotate the schema directly.
-   *
-   * The DB-level `required: true` invariant is unaffected — Mongoose still
-   * rejects null on save. This flag only affects HTTP body validation.
-   */
-  softRequiredFields?: string[];
-  /** Update schema options */
-  update?: {
-    /** Fields to omit from update schema */omitFields?: string[]; /** Require at least one field to be provided (default: false) */
-    requireAtLeastOne?: boolean;
-  };
-  /** Query schema options */
-  query?: {
-    /** Filterable fields */filterableFields?: Record<string, {
-      type: string;
-    } | unknown>;
-  };
-  /**
-   * Emit OpenAPI vendor extensions (`x-*` keywords like `x-ref` for populated
-   * ObjectId fields). Default: `false`.
-   *
-   * Why opt-in: Ajv's strict mode THROWS on any `x-*` keyword it doesn't
-   * recognize (`strict mode: unknown keyword: "x-ref"`). Consumers validating
-   * request bodies with Ajv strict need a keyword-clean schema; consumers
-   * generating OpenAPI documentation want the vendor extensions. Default is
-   * OFF so Ajv-strict-mode consumers are safe out of the box. Turn ON to
-   * include `x-ref` etc. in the output (typically when feeding the schema
-   * into a docgen tool like @fastify/swagger or redocly).
-   */
-  openApiExtensions?: boolean;
-}
-/** JSON Schema type */
-interface JsonSchema {
-  type: string;
-  properties?: Record<string, unknown>;
-  required?: string[];
-  additionalProperties?: boolean | unknown;
-  items?: unknown;
-  enum?: string[];
-  format?: string;
-  pattern?: string;
-  minProperties?: number;
-  maxProperties?: number;
-  minLength?: number;
-  maxLength?: number;
-  minimum?: number;
-  maximum?: number;
-}
-/** 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;
-}
 /** Decoded cursor */
 interface DecodedCursor {
   /** Primary sort field value (rehydrated) — legacy compat */
@@ -1281,15 +1199,20 @@ interface MinMaxResult {
   max: unknown;
 }
 /**
- * Cache adapter interface - bring your own cache implementation
- * Works with Redis, Memcached, in-memory, or any key-value store
+ * Cache adapter interface — bring your own cache implementation.
+ * Works with Redis, Memcached, in-memory, or any key-value store.
+ *
+ * Shape is aligned with `@classytic/repo-core/cache#CacheAdapter` and arc's
+ * `CacheStore` so one adapter implementation satisfies every consumer. The
+ * `delete` method is named for consistency with `Map.delete` / `Set.delete` /
+ * `MinimalRepo.delete(id)` — your Redis wrapper translates to `redis.del`.
  *
  * @example Redis implementation:
  * ```typescript
  * const redisCache: CacheAdapter = {
  *   async get(key) { return JSON.parse(await redis.get(key) || 'null'); },
  *   async set(key, value, ttl) { await redis.setex(key, ttl, JSON.stringify(value)); },
- *   async del(key) { await redis.del(key); },
+ *   async delete(key) { await redis.del(key); },
  *   async clear(pattern) {
  *     const keys = await redis.keys(pattern || '*');
  *     if (keys.length) await redis.del(...keys);
@@ -1302,8 +1225,8 @@ interface CacheAdapter {
   get<T = unknown>(key: string): Promise<T | null>;
   /** Set value with TTL in seconds */
   set<T = unknown>(key: string, value: T, ttl: number): Promise<void>;
-  /** Delete single key */
-  del(key: string): Promise<void>;
+  /** Delete a single key. No-op when the key doesn't exist. */
+  delete(key: string): Promise<void>;
   /** Clear keys matching pattern (optional, used for bulk invalidation) */
   clear?(pattern?: string): Promise<void>;
 }
@@ -1550,4 +1473,4 @@ type AllPluginMethods<TDoc> = {
  */
 type WithPlugins<TDoc, TRepo extends RepositoryInstance = RepositoryInstance> = TRepo & AllPluginMethods<TDoc>;
 //#endregion
-export { ReadOptions as $, HttpError as A, LookupBuilder as At, MinMaxResult as B, EventPayload as C, ValidatorDefinition as Ct, FindOneAndUpdateOptions as D, IControllerResponse as Dt, FieldRules as E, IController as Et, KeysetPaginationOptions as F, OperationOptions as G, ObjectId as H, KeysetPaginationResult as I, PartialBy as J, PaginationConfig as K, Logger as L, InferRawDoc as M, JsonSchema as N, GroupResult as O, IRequestContext as Ot, KeysOfType as P, PopulateSpec as Q, LookupPopulateOptions as R, EventHandlers as S, ValidationResult as St, FieldPreset as T, WithTransactionOptions as Tt, OffsetPaginationOptions as U, NonNullableFields as V, OffsetPaginationResult as W, PluginFunction as X, Plugin as Y, PluginType as Z, CrudSchemas as _, UpdateManyResult as _t, AnyDocument as a, RepositoryOptions as at, DeleteResult as b, UserContext as bt, CacheOperationOptions as c, SelectSpec as ct, CacheableOptions as d, SoftDeleteOptions as dt, ReadPreferenceType as et, CascadeOptions as f, SoftDeleteRepository as ft, CreateOptions as g, UpdateInput as gt, CreateInput as h, Strict as ht, AllPluginMethods as i, RepositoryOperation as it, InferDocument as j, LookupOptions as jt, HookMode as k, IResponseFormatter as kt, CacheOptions as l, SessionOptions as lt, CollationOptions as m, SortSpec as mt, AggregatePaginationOptions as n, RepositoryEvent as nt, AnyModel as o, RequiredBy as ot, CascadeRelation as p, SortDirection as pt, PaginationResult as q, AggregatePaginationResult as r, RepositoryInstance as rt, CacheAdapter as s, SchemaBuilderOptions as st, AggregateOptions as t, RepositoryContext as tt, CacheStats as u, SoftDeleteFilterMode as ut, DecodedCursor as v, UpdateOptions as vt, EventPhase as w, WithPlugins as wt, DocField as x, ValidationChainOptions as xt, DeepPartial as y, UpdateWithValidationResult as yt, LookupPopulateResult as z };
+export { RepositoryContext as $, InferRawDoc as A, OffsetPaginationOptions as B, EventPhase as C, IControllerResponse as Ct, HookMode as D, LookupOptions as Dt, GroupResult as E, LookupBuilder as Et, LookupPopulateOptions as F, PartialBy as G, OperationOptions as H, LookupPopulateResult as I, PluginType as J, Plugin as K, MinMaxResult as L, KeysetPaginationOptions as M, KeysetPaginationResult as N, HttpError as O, Logger as P, ReadPreferenceType as Q, NonNullableFields as R, EventPayload as S, IController as St, FindOneAndUpdateOptions as T, IResponseFormatter as Tt, PaginationConfig as U, OffsetPaginationResult as V, PaginationResult as W, PrioritizedHook as X, PopulateSpec as Y, ReadOptions as Z, DecodedCursor as _, UserContext as _t, AnyDocument as a, SelectSpec as at, DocField as b, WithPlugins as bt, CacheOperationOptions as c, SoftDeleteOptions as ct, CacheableOptions as d, SortSpec as dt, RepositoryEvent as et, CascadeOptions as f, Strict as ft, CreateOptions as g, UpdateWithValidationResult as gt, CreateInput as h, UpdateOptions as ht, AllPluginMethods as i, RequiredBy as it, KeysOfType as j, InferDocument as k, CacheOptions as l, SoftDeleteRepository as lt, CollationOptions as m, UpdateManyResult as mt, AggregatePaginationOptions as n, RepositoryOperation as nt, AnyModel as o, SessionOptions as ot, CascadeRelation as p, UpdateInput as pt, PluginFunction as q, AggregatePaginationResult as r, RepositoryOptions as rt, CacheAdapter as s, SoftDeleteFilterMode as st, AggregateOptions as t, RepositoryInstance as tt, CacheStats as u, SortDirection as ut, DeepPartial as v, ValidationChainOptions as vt, FieldPreset as w, IRequestContext as wt, EventHandlers as x, WithTransactionOptions as xt, DeleteResult as y, ValidatorDefinition as yt, ObjectId as z };

package/dist/{update-yjSoNnWy.mjs → update-CWXfFC6O.mjs}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
 import { r as warn } from "./logger-DJ7egMnd.mjs";
-import { t as createError } from "./error-Lw9GEAro.mjs";
+import { t as createError } from "./error-CzYwrfUP.mjs";
 //#region src/query/LookupBuilder.ts
 /** Stages that are never valid inside a $lookup pipeline */
 const BLOCKED_PIPELINE_STAGES = [
@@ -544,7 +544,11 @@ async function deleteById(Model, id, options = {}) {
 		_id: id,
 		...options.query
 	};
-	if (!await Model.findOneAndDelete(query).session(options.session ?? null)) throw createError(404, "Document not found");
+	if (!await Model.findOneAndDelete(query).session(options.session ?? null)) return {
+		success: false,
+		message: "Document not found",
+		id: String(id)
+	};
 	return {
 		success: true,
 		message: "Deleted successfully",
@@ -566,11 +570,17 @@ async function deleteMany(Model, query, options = {}) {
 */
 async function deleteByQuery(Model, query, options = {}) {
 	const document = await Model.findOneAndDelete(query).session(options.session ?? null);
-	if (!document && options.throwOnNotFound !== false) throw createError(404, "Document not found");
+	if (!document) {
+		if (options.throwOnNotFound === true) throw createError(404, "Document not found");
+		return {
+			success: false,
+			message: "Document not found"
+		};
+	}
 	return {
 		success: true,
 		message: "Deleted successfully",
-		...document ? { id: String(document._id) } : {}
+		id: String(document._id)
 	};
 }
 /**
@@ -650,7 +660,7 @@ async function getById(Model, id, options = {}) {
 	if (options.session) query.session(options.session);
 	if (options.readPreference) query.read(options.readPreference);
 	const document = await query.exec();
-	if (!document && options.throwOnNotFound !== false) throw createError(404, "Document not found");
+	if (!document && options.throwOnNotFound === true) throw createError(404, "Document not found");
 	return document;
 }
 /**
@@ -670,7 +680,7 @@ async function getByQuery(Model, query, options = {}) {
 	if (options.session) mongoQuery.session(options.session);
 	if (options.readPreference) mongoQuery.read(options.readPreference);
 	const document = await mongoQuery.exec();
-	if (!document && options.throwOnNotFound !== false) throw createError(404, "Document not found");
+	if (!document && options.throwOnNotFound === true) throw createError(404, "Document not found");
 	return document;
 }
 /**
@@ -760,15 +770,13 @@ async function update(Model, id, data, options = {}) {
 		_id: id,
 		...options.query
 	};
-	const document = await Model.findOneAndUpdate(query, data, {
+	return await Model.findOneAndUpdate(query, data, {
 		returnDocument: "after",
 		runValidators: true,
 		session: options.session,
 		...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {},
 		...options.arrayFilters ? { arrayFilters: options.arrayFilters } : {}
-	}).select(options.select || "").populate(parsePopulate(options.populate)).lean(options.lean ?? false);
-	if (!document) throw createError(404, "Document not found");
-	return document;
+	}).select(options.select || "").populate(parsePopulate(options.populate)).lean(options.lean ?? false) ?? null;
 }
 /**
 * Update with query constraints (optimized)
@@ -825,9 +833,17 @@ async function updateWithValidation(Model, id, data, validationOptions = {}, opt
 			}
 		};
 	}
+	const updated = await update(Model, id, data, options);
+	if (!updated) return {
+		success: false,
+		error: {
+			code: 404,
+			message: "Document not found"
+		}
+	};
 	return {
 		success: true,
-		data: await update(Model, id, data, options)
+		data: updated
 	};
 }
 /**
@@ -858,7 +874,7 @@ async function updateByQuery(Model, query, data, options = {}) {
 		...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {},
 		...options.arrayFilters ? { arrayFilters: options.arrayFilters } : {}
 	}).select(options.select || "").populate(parsePopulate(options.populate)).lean(options.lean ?? false);
-	if (!document && options.throwOnNotFound !== false) throw createError(404, "Document not found");
+	if (!document && options.throwOnNotFound === true) throw createError(404, "Document not found");
 	return document;
 }
 /**

package/dist/utils/index.d.mts

@@ -1,5 +1,5 @@
-import { Q as PopulateSpec, ct as SelectSpec, mt as SortSpec } from "../types-D57SZJeE.mjs";
-import { a as isFieldUpdateAllowed, c as configureLogger, d as getFieldsForUser, f as getMongooseProjection, i as getSystemManagedFields, l as createFieldPreset, n as buildCrudSchemasFromMongooseSchema, o as validateUpdateBody, p as createError, r as getImmutableFields, s as createMemoryCache, t as buildCrudSchemasFromModel, u as filterResponseData } from "../mongooseToJsonSchema-BZaKOXXI.mjs";
+import { Y as PopulateSpec, at as SelectSpec, dt as SortSpec } from "../types-Bbr54g--.mjs";
+import { a as createFieldPreset, c as getMongooseProjection, i as configureLogger, l as createError, n as buildCrudSchemasFromMongooseSchema, o as filterResponseData, r as createMemoryCache, s as getFieldsForUser, t as buildCrudSchemasFromModel } from "../mongooseToJsonSchema-DlTx-Or2.mjs";
 
 //#region src/utils/cache-keys.d.ts
 /**
@@ -146,4 +146,4 @@ declare function getSchemaIdType(schema?: SchemaLike | null): IdType;
  */
 declare function isValidIdForType(id: unknown, idType: IdType): boolean;
 //#endregion
-export { type IdType, buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, byIdKey, byQueryKey, configureLogger, createError, createFieldPreset, createMemoryCache, filterResponseData, getFieldsForUser, getImmutableFields, getMongooseProjection, getSchemaIdType, getSystemManagedFields, isFieldUpdateAllowed, isObjectIdInstance, isValidIdForType, listPattern, listQueryKey, modelPattern, validateUpdateBody, versionKey };
+export { type IdType, buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, byIdKey, byQueryKey, configureLogger, createError, createFieldPreset, createMemoryCache, filterResponseData, getFieldsForUser, getMongooseProjection, getSchemaIdType, isObjectIdInstance, isValidIdForType, listPattern, listQueryKey, modelPattern, versionKey };