modelence 0.9.0 → 0.9.2

package/dist/{types-SXHKNPNY.d.ts → types-V9eDnP35.d.ts}

@@ -122,6 +122,38 @@ type StrictRootFilterOperators<TSchema> = {
     $expr?: any;
     $jsonSchema?: any;
 };
+/**
+ * Helper type to extract array element type
+ * @internal
+ */
+type ArrayElement<T> = T extends (infer E)[] ? E : never;
+/**
+ * Helper type for $in/$nin that accepts any array/tuple where elements are assignable to T
+ * This solves the issue where TypeScript infers ['a', 'b'] as a tuple instead of ('a' | 'b')[]
+ * and where Array<Union> gets distributed into Union1[] | Union2[] | ...
+ * We wrap the Exclude in a tuple check to prevent distribution
+ * @internal
+ */
+type NonUndefined<T> = T extends undefined ? never : T;
+type ArrayLikeOfUnion<T> = [NonUndefined<T>] extends [never] ? never : ReadonlyArray<NonUndefined<T>> | Array<NonUndefined<T>>;
+/**
+ * Enhanced FilterOperators that fixes $in and $nin to properly accept arrays of union types
+ * MongoDB's native FilterOperators has issues with union types in $in/$nin arrays
+ * because TypeScript distributes Array<Union> into Array1 | Array2 | ...
+ * @internal
+ */
+type EnhancedFilterOperators<T> = Omit<FilterOperators<T>, '$in' | '$nin'> & {
+    $in?: ArrayLikeOfUnion<T>;
+    $nin?: ArrayLikeOfUnion<T>;
+};
+/**
+ * Custom filter value type that handles array fields specially:
+ * - For array fields: allows element type, full array type, or FilterOperators
+ * - For non-array fields: allows exact type or FilterOperators
+ * We use [T] to prevent distribution when T is a union type
+ * @internal
+ */
+type FilterValue<T> = [T] extends [unknown[]] ? ArrayElement<T> | T | EnhancedFilterOperators<T> : [T] extends [never] ? never : T | EnhancedFilterOperators<[T] extends [never] ? never : T>;
 /**
  * Type-safe MongoDB filter that ensures only schema fields can be queried
  * while supporting all MongoDB query operators and dot notation for nested fields.
@@ -129,6 +161,7 @@ type StrictRootFilterOperators<TSchema> = {
  * This type combines:
  * - MongoDB's native `FilterOperators<T>` for field-level operators (comprehensive operator support)
  * - Custom `StrictRootFilterOperators<T>` for top-level operators without index signature
+ * - Custom array field handling: allows passing single element when field is an array
  * - Custom restriction: only strings containing dots are allowed for nested field queries
  *
  * @example
@@ -138,6 +171,7 @@ type StrictRootFilterOperators<TSchema> = {
  *     name: schema.string(),
  *     age: schema.number(),
  *     tags: schema.array(schema.string()),
+ *     collections: schema.array(schema.string()),
  *     address: schema.object({
  *       street: schema.string(),
  *       city: schema.string(),
@@ -154,6 +188,9 @@ type StrictRootFilterOperators<TSchema> = {
  * await dbUsers.findOne({ tags: { $in: ['typescript', 'mongodb'] } });
  * await dbUsers.findOne({ $or: [{ name: 'John' }, { name: 'Jane' }] });
  *
+ * // ✅ Valid - array field with single element (checks if array contains the element)
+ * await dbUsers.findOne({ collections: 'users' });
+ *
  * // ✅ Valid - dot notation for nested fields (must contain a dot)
  * await dbUsers.findOne({ 'address.city': 'New York' });
  * await dbUsers.findOne({ 'emails.0.address': 'test@example.com' });
@@ -163,7 +200,7 @@ type StrictRootFilterOperators<TSchema> = {
  * ```
  */
 type TypedFilter<T> = {
-    [K in keyof WithId<T>]?: WithId<T>[K] | FilterOperators<WithId<T>[K]>;
+    [K in keyof WithId<T>]?: FilterValue<WithId<T>[K]>;
 } & StrictRootFilterOperators<T> & {
     [K: `${string}.${string}`]: any;
 };

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 export { A as AppServer, E as ExpressMiddleware, M as ModelenceConfig } from './index-CwdohC5n.js';
 export { e as AppConfig, l as Args, d as AuthErrorProps, q as AuthProvider, A as AuthSuccessProps, j as ClientInfo, b as ConfigKey, C as ConfigSchema, o as ConfigType, p as Configs, k as ConnectionInfo, i as Context, D as DefaultRoles, H as Handler, n as Method, M as MethodDefinition, m as MethodType, P as Permission, h as Role, R as RoleDefinition, f as Session, U as User, g as UserInfo, a as WebsocketClientProvider, W as WebsocketServerProvider } from './types-BOFsm7A2.js';
-export { B as BodyConfig, h as CronJob, C as CronJobInputParams, i as CronJobMetadata, g as EmailAttachment, c as EmailPayload, E as EmailProvider, k as ExpressHandler, H as HttpMethod, I as InferDocumentType, M as ModelSchema, a as RateLimitRule, b as RateLimitType, R as RouteDefinition, d as RouteHandler, j as RouteHandlers, e as RouteParams, f as RouteResponse, s as schema } from './types-SXHKNPNY.js';
+export { B as BodyConfig, h as CronJob, C as CronJobInputParams, i as CronJobMetadata, g as EmailAttachment, c as EmailPayload, E as EmailProvider, k as ExpressHandler, H as HttpMethod, I as InferDocumentType, M as ModelSchema, a as RateLimitRule, b as RateLimitType, R as RouteDefinition, d as RouteHandler, j as RouteHandlers, e as RouteParams, f as RouteResponse, s as schema } from './types-V9eDnP35.js';
 import 'express';
 import 'http';
 import 'mongodb';

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "modelence",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "The Node.js Framework for Real-Time MongoDB Apps",
   "main": "dist/index.js",
   "types": "dist/global.d.ts",