@classytic/mongokit 3.11.0 → 3.12.0

package/dist/{types-xOyTec4n.d.mts → types-DXscZnLu.d.mts}

@@ -1,9 +1,12 @@
+import * as _$_classytic_repo_core_filter0 from "@classytic/repo-core/filter";
+import { Filter } from "@classytic/repo-core/filter";
 import * as _$mongoose from "mongoose";
 import { 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 { DeleteManyResult, DeleteResult, LookupPopulateResult, UpdateManyResult } from "@classytic/repo-core/repository";
 import { ValidationResult } from "@classytic/repo-core/schema";
+import { AnyPaginationResult, OffsetPaginationResult } from "@classytic/repo-core/pagination";
+import { HttpError } from "@classytic/repo-core/errors";
 
 //#region src/query/LookupBuilder.d.ts
 interface LookupOptions {
@@ -17,8 +20,15 @@ interface LookupOptions {
   as?: string;
   /** Whether to unwrap array to single object */
   single?: boolean;
-  /** Field selection on the joined collection (shorthand for $project pipeline) */
-  select?: string | Record<string, 0 | 1>;
+  /**
+   * Field selection on the joined collection (shorthand for `$project`).
+   * Three accepted shapes — all map to a single `$project` stage:
+   *   - `string` — CSV form (`'name,price'`); leading `-` marks an exclusion.
+   *   - `readonly string[]` — array form (`['name', 'price']` / `['-status']`);
+   *     mirrors `repo-core/lookup` `LookupSpec.select` for cross-kit parity.
+   *   - `Record<string, 0 | 1>` — explicit Mongo projection map.
+   */
+  select?: string | readonly string[] | Record<string, 0 | 1>;
   /** Additional pipeline to run on the joined collection */
   pipeline?: PipelineStage[];
   /** Optional let variables for pipeline */
@@ -31,6 +41,18 @@ interface LookupOptions {
   };
   /** Sanitize pipeline stages (default: true). Set false only for trusted server-side pipelines */
   sanitize?: boolean;
+  /**
+   * Joined-side filter, compiled into a `$match` stage inside the lookup
+   * pipeline AFTER the auto-generated join correlation. Mirrors
+   * `repo-core/lookup/types.ts#LookupSpec.where` and sqlitekit's
+   * predicate-on-the-JOIN behavior, so cross-kit code that narrows the
+   * foreign side (`where: eq('status', 'active')`) gets identical rows
+   * from both backends.
+   *
+   * Accepts Filter IR or a plain mongo query — `compileFilterToMongo`
+   * routes each correctly.
+   */
+  where?: Filter | Record<string, unknown>;
 }
 /**
  * Fluent builder for MongoDB $lookup aggregation stage
@@ -307,7 +329,7 @@ interface IController<TDoc> {
    * }
    * ```
    */
-  list(context: IRequestContext): Promise<IControllerResponse<PaginationResult<TDoc>>>;
+  list(context: IRequestContext): Promise<IControllerResponse<AnyPaginationResult<TDoc>>>;
   /**
    * Get single resource by ID
    *
@@ -457,7 +479,7 @@ interface IResponseFormatter {
    * Format paginated response
    * @param result - Pagination result from Repository.getAll()
    */
-  paginated<T>(result: PaginationResult<T>): IControllerResponse<PaginationResult<T>>;
+  paginated<T>(result: AnyPaginationResult<T>): IControllerResponse<AnyPaginationResult<T>>;
 }
 //#endregion
 //#region src/types.d.ts
@@ -732,63 +754,6 @@ interface AggregatePaginationOptions {
   /** Read preference for replica sets (e.g. 'secondaryPreferred') */
   readPreference?: ReadPreferenceType;
 }
-/** Offset pagination result */
-interface OffsetPaginationResult<T = unknown> {
-  /** Pagination method used */
-  method: 'offset';
-  /** Array of documents */
-  docs: T[];
-  /** Current page number */
-  page: number;
-  /** Documents per page */
-  limit: number;
-  /** Total document count */
-  total: number;
-  /** Total page count */
-  pages: number;
-  /** Whether next page exists */
-  hasNext: boolean;
-  /** Whether previous page exists */
-  hasPrev: boolean;
-  /** Performance warning for deep pagination */
-  warning?: string;
-}
-/** Keyset pagination result */
-interface KeysetPaginationResult<T = unknown> {
-  /** Pagination method used */
-  method: 'keyset';
-  /** Array of documents */
-  docs: T[];
-  /** Documents per page */
-  limit: number;
-  /** Whether more documents exist */
-  hasMore: boolean;
-  /** Cursor token for next page */
-  next: string | null;
-}
-/** Aggregate pagination result */
-interface AggregatePaginationResult<T = unknown> {
-  /** Pagination method used */
-  method: 'aggregate';
-  /** Array of documents */
-  docs: T[];
-  /** Current page number */
-  page: number;
-  /** Documents per page */
-  limit: number;
-  /** Total document count */
-  total: number;
-  /** Total page count */
-  pages: number;
-  /** Whether next page exists */
-  hasNext: boolean;
-  /** Whether previous page exists */
-  hasPrev: boolean;
-  /** Performance warning for deep pagination */
-  warning?: string;
-}
-/** Union type for all pagination results */
-type PaginationResult<T = unknown> = OffsetPaginationResult<T> | KeysetPaginationResult<T> | AggregatePaginationResult<T>;
 /** Session-only options — shared base for lightweight operations */
 interface SessionOptions {
   /** MongoDB session for transactions */
@@ -1136,6 +1101,27 @@ interface FieldPreset {
   /** Additional fields for admins */
   admin?: string[];
 }
+/** Value type identifier for cursor serialization */
+type ValueType = 'date' | 'objectid' | 'boolean' | 'number' | 'string' | 'null' | 'unknown';
+/** Cursor payload */
+interface CursorPayload {
+  /** Primary sort field value (legacy single-field) */
+  v: string | number | boolean | null;
+  /** Value type identifier (legacy single-field) */
+  t: ValueType;
+  /** Document ID */
+  id: string;
+  /** ID type identifier */
+  idType: ValueType;
+  /** Sort specification */
+  sort: SortSpec;
+  /** Cursor version */
+  ver: number;
+  /** Compound sort field values (multi-field keyset) */
+  vals?: Record<string, string | number | boolean | null>;
+  /** Compound sort value types */
+  types?: Record<string, ValueType>;
+}
 /** Decoded cursor */
 interface DecodedCursor {
   /** Primary sort field value (rehydrated) — legacy compat */
@@ -1349,24 +1335,6 @@ interface CascadeOptions {
   /** Logger for cascade operations */
   logger?: Logger;
 }
-/** HTTP Error with status code */
-interface HttpError extends Error {
-  status: number;
-  validationErrors?: Array<{
-    validator: string;
-    error: string;
-  }>;
-  /**
-   * Structured metadata for duplicate-key (E11000) errors. Safe to surface in
-   * logs/audit. Includes the offending field names and a boolean-only mirror
-   * of whether each field had a duplicate value — never the value itself
-   * unless `parseDuplicateKeyError` was called with `{ exposeValues: true }`.
-   */
-  duplicate?: {
-    fields: string[]; /** Only populated when parseDuplicateKeyError was called with exposeValues:true. */
-    values?: Record<string, unknown>;
-  };
-}
 /**
  * Combines all plugin method types into a single type
  * Useful when you're using all plugins and want full type safety
@@ -1497,4 +1465,4 @@ type AllPluginMethods<TDoc> = {
  */
 type WithPlugins<TDoc, TRepo extends RepositoryInstance = RepositoryInstance> = TRepo & AllPluginMethods<TDoc>;
 //#endregion
-export { ReadPreferenceType as $, InferDocument as A, ObjectId as B, EventPayload as C, WithTransactionOptions as Ct, GroupResult as D, IResponseFormatter as Dt, FindOneAndUpdateOptions as E, IRequestContext as Et, Logger as F, PaginationResult as G, OffsetPaginationResult as H, LookupPopulateOptions as I, PluginFunction as J, PartialBy as K, LookupPopulateResult as L, KeysOfType as M, KeysetPaginationOptions as N, HookMode as O, LookupBuilder as Ot, KeysetPaginationResult as P, ReadOptions as Q, MinMaxResult as R, EventHandlers as S, WithPlugins as St, FieldPreset as T, IControllerResponse as Tt, OperationOptions as U, OffsetPaginationOptions as V, PaginationConfig as W, PopulateSpec as X, PluginType as Y, PrioritizedHook as Z, DecodedCursor as _, UpdatePatch as _t, AnyDocument as a, RequiredBy as at, DeleteResult as b, ValidationChainOptions as bt, CacheOperationOptions as c, SoftDeleteFilterMode as ct, CacheableOptions as d, SortDirection as dt, RepositoryContext as et, CascadeOptions as f, SortSpec as ft, CreateOptions as g, UpdateOptions as gt, CreateInput as h, UpdateManyResult as ht, AllPluginMethods as i, RepositoryOptions as it, InferRawDoc as j, HttpError as k, LookupOptions as kt, CacheOptions as l, SoftDeleteOptions as lt, CollationOptions as m, UpdateInput as mt, AggregatePaginationOptions as n, RepositoryInstance as nt, AnyModel as o, SelectSpec as ot, CascadeRelation as p, Strict as pt, Plugin as q, AggregatePaginationResult as r, RepositoryOperation as rt, CacheAdapter as s, SessionOptions as st, AggregateOptions as t, RepositoryEvent as tt, CacheStats as u, SoftDeleteRepository as ut, DeepPartial as v, UpdateWithValidationResult as vt, EventPhase as w, IController as wt, DocField as x, ValidatorDefinition as xt, DeleteManyResult as y, UserContext as yt, NonNullableFields as z };
+export { RepositoryInstance as $, InferDocument as A, OffsetPaginationOptions as B, EventHandlers as C, IControllerResponse as Ct, FindOneAndUpdateOptions as D, LookupOptions as Dt, FieldPreset as E, LookupBuilder as Et, LookupPopulateOptions as F, PluginFunction as G, PaginationConfig as H, LookupPopulateResult as I, PrioritizedHook as J, PluginType as K, MinMaxResult as L, KeysOfType as M, KeysetPaginationOptions as N, GroupResult as O, Logger as P, RepositoryEvent as Q, NonNullableFields as R, DocField as S, IController as St, EventPhase as T, IResponseFormatter as Tt, PartialBy as U, OperationOptions as V, Plugin as W, ReadPreferenceType as X, ReadOptions as Y, RepositoryContext as Z, CursorPayload as _, ValidationChainOptions as _t, AnyModel as a, SoftDeleteFilterMode as at, DeleteManyResult as b, WithPlugins as bt, CacheOperationOptions as c, SortDirection as ct, CacheableOptions as d, UpdateInput as dt, RepositoryOperation as et, CascadeOptions as f, UpdateManyResult as ft, CreateOptions as g, UserContext as gt, CreateInput as h, UpdateWithValidationResult as ht, AnyDocument as i, SessionOptions as it, InferRawDoc as j, HookMode as k, CacheOptions as l, SortSpec as lt, CollationOptions as m, UpdatePatch as mt, AggregatePaginationOptions as n, RequiredBy as nt, BasePaginationOptions as o, SoftDeleteOptions as ot, CascadeRelation as p, UpdateOptions as pt, PopulateSpec as q, AllPluginMethods as r, SelectSpec as rt, CacheAdapter as s, SoftDeleteRepository as st, AggregateOptions as t, RepositoryOptions as tt, CacheStats as u, Strict as ut, DecodedCursor as v, ValidatorDefinition as vt, EventPayload as w, IRequestContext as wt, DeleteResult as x, WithTransactionOptions as xt, DeepPartial as y, ValueType as yt, ObjectId as z };

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

@@ -1,6 +1,103 @@
 import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
-import { r as warn } from "./logger-DJ7egMnd.mjs";
-import { t as createError } from "./error-CzYwrfUP.mjs";
+import { r as warn } from "./logger-8-VS1za6.mjs";
+import { t as createError } from "./error-B00pI7dV.mjs";
+import { isFilter } from "@classytic/repo-core/filter";
+//#region src/filter/compile.ts
+/**
+* Compile a Filter IR node to a MongoDB query object. Returns `{}`
+* when the node is `TRUE` (or an empty `and`) so callers can merge
+* with other scopes without special-casing.
+*
+* The `input` is typed as `unknown` so callers can pass either a
+* Filter IR node or an already-built Mongo query and we dispatch
+* appropriately. This keeps the portable API ergonomic for apps that
+* write Mongo queries directly today.
+*/
+function compileFilterToMongo(input) {
+	if (!input) return {};
+	if (!isFilter(input)) return input;
+	return compile(input);
+}
+function compile(filter) {
+	switch (filter.op) {
+		case "true": return {};
+		case "false": return { $expr: false };
+		case "eq": return { [filter.field]: filter.value };
+		case "ne": return filter.value === null ? { [filter.field]: { $ne: null } } : { $and: [{ [filter.field]: { $ne: filter.value } }, { [filter.field]: { $ne: null } }] };
+		case "gt": return { [filter.field]: { $gt: filter.value } };
+		case "gte": return { [filter.field]: { $gte: filter.value } };
+		case "lt": return { [filter.field]: { $lt: filter.value } };
+		case "lte": return { [filter.field]: { $lte: filter.value } };
+		case "in":
+			if (filter.values.length === 0) return { $expr: false };
+			return { [filter.field]: { $in: [...filter.values] } };
+		case "nin":
+			if (filter.values.length === 0) return {};
+			return { [filter.field]: { $nin: [...filter.values] } };
+		case "exists": return filter.exists ? { [filter.field]: { $ne: null } } : { [filter.field]: null };
+		case "like": return { [filter.field]: likeToRegex(filter.pattern, filter.caseSensitivity) };
+		case "regex": return { [filter.field]: { $regex: filter.pattern } };
+		case "and": {
+			if (filter.children.length === 0) return {};
+			const parts = filter.children.map(compile);
+			if (parts.length === 1) return parts[0];
+			return { $and: parts };
+		}
+		case "or": {
+			if (filter.children.length === 0) return { $expr: false };
+			const parts = filter.children.map(compile);
+			if (parts.length === 1) return parts[0];
+			return { $or: parts };
+		}
+		case "not": return { $nor: [compile(filter.child)] };
+		case "raw": throw new Error("mongokit/filter: `raw` is a SQL escape hatch and has no safe MongoDB translation. Pass a Mongo query object directly to the filter slot instead.");
+	}
+}
+/**
+* Translate a SQL-style LIKE pattern to a MongoDB regex.
+*
+* SQL semantics:
+*   - `%`  → match zero or more characters (`.*`)
+*   - `_`  → match exactly one character   (`.`)
+*   - `\%` → literal percent  (escape via backslash)
+*   - `\_` → literal underscore
+*   - `\\` → literal backslash
+*   - everything else is literal — regex metacharacters get escaped.
+*
+* The naive implementation `pattern.replace(/%/g, '.*')` is wrong:
+* it also expands escaped `\%` into a wildcard. We walk the pattern
+* char-by-char, honoring backslash escapes, so `like('notes', '50\\% off')`
+* matches the literal string `50% off` instead of `50<anything> off`.
+*
+* Anchored with `^` / `$` so LIKE matches the whole field value, the
+* same way sqlitekit's `LIKE` semantically does.
+*/
+function likeToRegex(pattern, caseSensitivity) {
+	let out = "^";
+	for (let i = 0; i < pattern.length; i++) {
+		const ch = pattern[i];
+		if (ch === "\\" && i + 1 < pattern.length) {
+			const next = pattern[i + 1];
+			if (next === "%" || next === "_" || next === "\\") {
+				out += escapeRegexChar(next);
+				i++;
+				continue;
+			}
+		}
+		if (ch === "%") out += ".*";
+		else if (ch === "_") out += ".";
+		else out += escapeRegexChar(ch);
+	}
+	out += "$";
+	return caseSensitivity === "sensitive" ? { $regex: out } : {
+		$regex: out,
+		$options: "i"
+	};
+}
+function escapeRegexChar(ch) {
+	return /[.*+?^${}()|[\]\\]/.test(ch) ? `\\${ch}` : ch;
+}
+//#endregion
 //#region src/query/LookupBuilder.ts
 /** Stages that are never valid inside a $lookup pipeline */
 const BLOCKED_PIPELINE_STAGES = [
@@ -191,28 +288,24 @@ var LookupBuilder = class LookupBuilder {
 			const builder = new LookupBuilder(lookup.from).localField(lookup.localField).foreignField(lookup.foreignField);
 			if (lookup.as) builder.as(lookup.as);
 			if (lookup.single) builder.single(lookup.single);
-			if (lookup.select) {
-				let projection;
-				if (typeof lookup.select === "string") {
-					projection = {};
-					for (const field of lookup.select.split(",").map((f) => f.trim())) if (field.startsWith("-")) projection[field.substring(1)] = 0;
-					else projection[field] = 1;
-				} else projection = lookup.select;
-				const joinStage = { $match: { $expr: { $eq: [`$${lookup.foreignField}`, "$$lookupJoinVal"] } } };
-				const existing = lookup.pipeline || [];
-				builder.pipeline([
-					joinStage,
-					...existing,
-					{ $project: projection }
-				]);
+			const stages = [];
+			const appendCallerStages = (raw) => {
+				if (raw.length === 0) return;
+				stages.push(...LookupBuilder.sanitizePipeline(raw));
+			};
+			const compiledWhere = lookup.where ? compileFilterToMongo(lookup.where) : void 0;
+			const hasWhere = !!compiledWhere && Object.keys(compiledWhere).length > 0;
+			if (!!(lookup.select || lookup.pipeline || hasWhere)) {
+				stages.push({ $match: { $expr: { $eq: [`$${lookup.foreignField}`, "$$lookupJoinVal"] } } });
+				if (hasWhere && compiledWhere) appendCallerStages([{ $match: compiledWhere }]);
+				if (lookup.pipeline) appendCallerStages(lookup.pipeline);
+				if (lookup.select) stages.push({ $project: compileSelectToProjection(lookup.select) });
+				builder.pipeline(stages);
 				builder.let({
 					lookupJoinVal: `$${lookup.localField}`,
 					...lookup.let || {}
 				});
 				builder.sanitize(false);
-			} else if (lookup.pipeline) {
-				builder.pipeline(lookup.pipeline);
-				if (lookup.let) builder.let(lookup.let);
 			} else if (lookup.let) builder.let(lookup.let);
 			return builder.build();
 		});
@@ -281,6 +374,38 @@ var LookupBuilder = class LookupBuilder {
 	}
 };
 /**
+* Normalize the three accepted `LookupOptions.select` shapes into a single
+* Mongo `$project` map.
+*
+*  - `string`              → CSV form, leading `-` excludes (`'name,-status'`)
+*  - `readonly string[]`   → array form, leading `-` excludes (`['-status']`)
+*  - `Record<string, 0|1>` → already a projection map, copied as-is
+*
+* The array form mirrors `repo-core`'s `LookupSpec.select` so cross-kit
+* callers (`select: ['name']`) compile identically on mongokit and sqlitekit.
+*/
+function compileSelectToProjection(select) {
+	if (typeof select === "string") {
+		const projection = {};
+		for (const field of select.split(",").map((f) => f.trim())) {
+			if (!field) continue;
+			if (field.startsWith("-")) projection[field.substring(1)] = 0;
+			else projection[field] = 1;
+		}
+		return projection;
+	}
+	if (Array.isArray(select)) {
+		const projection = {};
+		for (const field of select) {
+			if (!field) continue;
+			if (field.startsWith("-")) projection[field.substring(1)] = 0;
+			else projection[field] = 1;
+		}
+		return projection;
+	}
+	return { ...select };
+}
+/**
 * Performance Guidelines for $lookup at Scale:
 *
 * 1. **Index Requirements** (Critical for millions of records):
@@ -918,4 +1043,4 @@ async function pullFromArray(Model, id, field, value, options = {}) {
 	return update(Model, id, { $pull: { [field]: value } }, options);
 }
 //#endregion
-export { upsert as _, count as a, LookupBuilder as b, getByQuery as c, deleteById as d, deleteByQuery as f, create_exports as g, createMany as h, update_exports as i, getOrCreate as l, create as m, update as n, exists as o, delete_exports as p, updateByQuery as r, getById as s, findOneAndUpdate as t, read_exports as u, aggregate_exports as v, distinct as y };
+export { upsert as _, count as a, LookupBuilder as b, getByQuery as c, deleteById as d, deleteByQuery as f, create_exports as g, createMany as h, update_exports as i, getOrCreate as l, create as m, update as n, exists as o, delete_exports as p, updateByQuery as r, getById as s, findOneAndUpdate as t, read_exports as u, aggregate_exports as v, compileFilterToMongo as x, distinct as y };

package/dist/utils/index.d.mts

@@ -1,5 +1,5 @@
-import { X as PopulateSpec, ft as SortSpec, ot as SelectSpec } from "../types-xOyTec4n.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-BH6OFec5.mjs";
+import { lt as SortSpec, q as PopulateSpec, rt as SelectSpec } from "../types-DXscZnLu.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-rtkdbBhf.mjs";
 
 //#region src/utils/cache-keys.d.ts
 /**

package/dist/utils/index.mjs

@@ -1,6 +1,6 @@
-import { t as configureLogger } from "../logger-DJ7egMnd.mjs";
-import { t as createError } from "../error-CzYwrfUP.mjs";
+import { t as configureLogger } from "../logger-8-VS1za6.mjs";
+import { t as createError } from "../error-B00pI7dV.mjs";
 import { n as isObjectIdInstance, r as isValidIdForType, t as getSchemaIdType } from "../id-resolution-e4BT9zAV.mjs";
 import { a as byIdKey, c as listQueryKey, i as getMongooseProjection, l as modelPattern, n as filterResponseData, o as byQueryKey, r as getFieldsForUser, s as listPattern, t as createFieldPreset, u as versionKey } from "../field-selection-dI0m4RBs.mjs";
-import { n as buildCrudSchemasFromMongooseSchema, r as createMemoryCache, t as buildCrudSchemasFromModel } from "../mongooseToJsonSchema-D1sdCOmj.mjs";
+import { n as buildCrudSchemasFromMongooseSchema, r as createMemoryCache, t as buildCrudSchemasFromModel } from "../mongooseToJsonSchema-B187ufOP.mjs";
 export { buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, byIdKey, byQueryKey, configureLogger, createError, createFieldPreset, createMemoryCache, filterResponseData, getFieldsForUser, getMongooseProjection, getSchemaIdType, isObjectIdInstance, isValidIdForType, listPattern, listQueryKey, modelPattern, versionKey };