@vandenberghinc/volt 1.2.6 → 1.2.7

package/backend/dist/esm/backend/src/database/filters/strict_filter_v0.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh.
+ */
+import * as mongodb from 'mongodb';
+/**
+ * Helper type for recursive depth limiting
+ */
+type PathsPrev = [never, 0, 1, 2, 3, 4];
+/**
+ * Extract all valid paths from a schema including nested paths
+ * Supports dot notation for nested objects
+ */
+type Paths<T, D extends number = 4> = [D] extends [never] ? never : T extends object ? {
+    [K in keyof T]-?: K extends string | number ? `${K}` | (T[K] extends object ? T[K] extends ReadonlyArray<any> ? never : Paths<T[K], PathsPrev[D]> extends infer P ? P extends string ? `${K}.${P}` : never : never : never) : never;
+}[keyof T] : '';
+/**
+ * Get the value type at a specific path in the schema
+ */
+type PathValue<T, P extends string> = P extends keyof T ? T[P] : P extends `${infer K}.${infer Rest}` ? K extends keyof T ? PathValue<T[K], Rest> : never : never;
+/**
+ * Create an exact object type that doesn't allow extra properties
+ * This is the key to making our types strict
+ */
+type Exact<T, Shape = T> = T extends Shape ? T extends infer O ? {
+    [K in keyof O]: O[K];
+} & {
+    [K in Exclude<keyof T, keyof Shape>]?: never;
+} : never : Shape;
+/**
+ * Strict filter fields that only allow schema paths.
+ * If a field is an array (e.g., string[]), allow operators for the *element* type
+ * (e.g., FilterOperators<string>) in addition to plain array equality and
+ * array-typed operators.
+ */
+type FilterFields<TSchema> = {
+    [K in Paths<TSchema>]?: PathValue<TSchema, K> extends (infer U)[] ? PathValue<TSchema, K> | mongodb.FilterOperators<U> : PathValue<TSchema, K> | mongodb.FilterOperators<PathValue<TSchema, K>>;
+};
+/**
+ * Strict version of MongoDB Filter that only allows querying existing fields
+ * Supports logical operators ($and, $or, $nor) with recursive StrictFilter values.
+ * NOTE: We intentionally avoid mongodb.RootFilterOperators here to keep keys airtight.
+ * @template TSchema - The document schema type
+ */
+export type StrictFilter<TSchema> = Exact<FilterFields<TSchema> & {
+    $and?: StrictFilter<TSchema>[];
+    $or?: StrictFilter<TSchema>[];
+    $nor?: StrictFilter<TSchema>[];
+}>;
+export {};

package/backend/dist/esm/backend/src/database/filters/strict_filter_v0.js

@@ -0,0 +1,5 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh.
+ */
+export {};

package/backend/dist/esm/backend/src/database/filters/strict_filter_v1.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh.
+ */
+import * as mongodb from 'mongodb';
+/**
+ * Helper type for recursive depth limiting
+ */
+type PathsPrev = [never, 0, 1, 2, 3, 4];
+/**
+ * Extract all valid paths from a schema including nested paths
+ * Supports dot notation for nested objects
+ */
+type Paths<T, D extends number = 4> = [D] extends [never] ? never : T extends object ? {
+    [K in keyof T]-?: K extends string | number ? `${K}` | (T[K] extends object ? T[K] extends ReadonlyArray<any> ? never : Paths<T[K], PathsPrev[D]> extends infer P ? P extends string ? `${K}.${P}` : never : never : never) : never;
+}[keyof T] : '';
+/**
+ * Get the value type at a specific path in the schema
+ */
+type PathValue<T, P extends string> = P extends keyof T ? T[P] : P extends `${infer K}.${infer Rest}` ? K extends keyof T ? PathValue<T[K], Rest> : never : never;
+type Expand<T> = {
+    [K in keyof T]: T[K];
+};
+type CommonOpKeys = '$eq' | '$ne' | '$gt' | '$gte' | '$lt' | '$lte' | '$in' | '$nin' | '$exists' | '$type' | '$not';
+type StringOnlyOpKeys = '$regex' | '$options';
+type NumberOnlyOpKeys = '$mod' | '$bitsAllClear' | '$bitsAllSet' | '$bitsAnyClear' | '$bitsAnySet';
+type GeoOpKeys = '$geoIntersects' | '$geoWithin' | '$near' | '$nearSphere';
+/**
+ * Field-level operators we allow.
+ * Using Pick<...> *removes* any inherited `[key: string]: any]` index signature
+ * so unknown operator keys will NOT type-check.
+ */
+type KnownFieldOps<V> = Pick<mongodb.FilterOperators<V>, CommonOpKeys | StringOnlyOpKeys | NumberOnlyOpKeys | GeoOpKeys>;
+/**
+ * For whole-array field (not element-wise) we only allow a few generic checks.
+ * This avoids array-of-arrays `$in` through `FilterOperators<A>`.
+ */
+type ArrayFieldGenericOps<A> = Pick<mongodb.FilterOperators<A>, '$exists' | '$type' | '$not'>;
+type Elem<T> = T extends ReadonlyArray<infer U> ? U : T extends Array<infer U> ? U : never;
+type ElemMatchValue<U> = U extends object ? StrictFilter<U> : KnownFieldOps<U>;
+type StrictArrayLevelOperators<A> = A extends ReadonlyArray<infer U> | (infer U)[] ? {
+    $all?: ReadonlyArray<U>;
+    $size?: number;
+    $elemMatch?: ElemMatchValue<U>;
+} : never;
+/**
+ * Full value type allowed for an array field — *without* ever using
+ * `mongodb.FilterOperators<A>` wholesale (prevents indexer leakage and
+ * array-of-arrays `$in`).
+ */
+type StrictArrayValue<A> = A extends ReadonlyArray<any> | any[] ? A | Elem<A> | KnownFieldOps<Elem<A>> | ArrayFieldGenericOps<A> | StrictArrayLevelOperators<A> : never;
+type DotOnlyPaths<T> = Exclude<Paths<T>, Extract<keyof T, string>>;
+type DotPathFilters<T> = {
+    [K in DotOnlyPaths<T>]?: PathValue<T, K> extends ReadonlyArray<any> | any[] ? StrictArrayValue<PathValue<T, K>> : PathValue<T, K> | KnownFieldOps<PathValue<T, K>>;
+};
+type TopFieldKeys<T> = '_id' | Extract<keyof mongodb.EnhancedOmit<T, '_id'>, string>;
+type TopFieldFilters<T> = {
+    [K in TopFieldKeys<T>]?: K extends keyof T ? (T[K] extends ReadonlyArray<any> | any[] ? StrictArrayValue<T[K]> : T[K] | KnownFieldOps<T[K]>) : mongodb.Condition<mongodb.WithId<T>[K]>;
+};
+type StrictLogicalOps<T> = {
+    $and?: StrictFilter<T>[];
+    $or?: StrictFilter<T>[];
+    $nor?: StrictFilter<T>[];
+};
+type StrictOtherRootOps<T> = Partial<Pick<mongodb.RootFilterOperators<T>, '$expr' | '$jsonSchema' | '$text' | '$where' | '$comment' | '$rand'>>;
+type StrictRootOperators<T> = StrictLogicalOps<T> & StrictOtherRootOps<T>;
+/**
+ * StrictFilter:
+ *  • Unknown keys rejected on object literals (no string index signature)
+ *  • Dot-notation paths allowed & typed
+ *  • Arrays keep strict $elemMatch/$size/$all behavior
+ *  • Root operators optional and typed to the driver
+ *  • Structurally compatible with mongodb.Filter<T>
+ */
+export type StrictFilter<T> = Expand<TopFieldFilters<T> & DotPathFilters<T> & StrictRootOperators<T>>;
+export {};

package/backend/dist/esm/backend/src/database/filters/strict_filter_v1.js

@@ -0,0 +1,44 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh.
+ */
+export {};
+// // ==================================================================
+// // Strict Filter — v1
+// // ==================================================================
+// /**
+//  * Create an exact object type that doesn't allow extra properties
+//  * This is the key to making our types strict
+//  */
+// type Exact<T, Shape = T> = T extends Shape ?
+//     T extends infer O ?
+//     { [K in keyof O]: O[K] } &
+//     { [K in Exclude<keyof T, keyof Shape>]?: never }
+//     : never
+//     : Shape;
+// /**
+//  * Strict filter fields that only allow schema paths.
+//  * If a field is an array (e.g., string[]), allow operators for the *element* type
+//  * (e.g., FilterOperators<string>) in addition to plain array equality and
+//  * array-typed operators.
+//  */
+// type FilterFields<TSchema> = {
+//     [K in Paths<TSchema>]?: PathValue<TSchema, K> extends (infer U)[]
+//     // arrays: allow equality on the whole array OR element-wise operators
+//     ? PathValue<TSchema, K> | mongodb.FilterOperators<U>
+//     // non-arrays: keep original behavior
+//     : PathValue<TSchema, K> | mongodb.FilterOperators<PathValue<TSchema, K>>;
+// };
+// /**
+//  * Strict version of MongoDB Filter that only allows querying existing fields
+//  * Supports logical operators ($and, $or, $nor) with recursive StrictFilter values.
+//  * NOTE: We intentionally avoid mongodb.RootFilterOperators here to keep keys airtight.
+//  * @template TSchema - The document schema type
+//  */
+// export type StrictFilter<TSchema> = Exact<
+//     FilterFields<TSchema> & {
+//         $and?: StrictFilter<TSchema>[];
+//         $or?: StrictFilter<TSchema>[];
+//         $nor?: StrictFilter<TSchema>[];
+//     }
+// >;

package/backend/dist/esm/backend/src/database/filters/strict_filter_v2.d.ts

@@ -0,0 +1,75 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh.
+ */
+import * as mongodb from 'mongodb';
+/**
+ * Helper type for recursive depth limiting
+ */
+type PathsPrev = [never, 0, 1, 2, 3, 4];
+/**
+ * Extract all valid paths from a schema including nested paths
+ * Supports dot notation for nested objects
+ */
+type Paths<T, D extends number = 4> = [D] extends [never] ? never : T extends object ? {
+    [K in keyof T]-?: K extends string | number ? `${K}` | (T[K] extends object ? T[K] extends ReadonlyArray<any> ? never : Paths<T[K], PathsPrev[D]> extends infer P ? P extends string ? `${K}.${P}` : never : never : never) : never;
+}[keyof T] : '';
+/**
+ * Get the value type at a specific path in the schema
+ */
+type PathValue<T, P extends string> = P extends keyof T ? T[P] : P extends `${infer K}.${infer Rest}` ? K extends keyof T ? PathValue<T[K], Rest> : never : never;
+type Expand<T> = {
+    [K in keyof T]: T[K];
+};
+type CommonOpKeys = '$eq' | '$ne' | '$gt' | '$gte' | '$lt' | '$lte' | '$in' | '$nin' | '$exists' | '$type' | '$not';
+type StringOnlyOpKeys = '$regex' | '$options';
+type NumberOnlyOpKeys = '$mod' | '$bitsAllClear' | '$bitsAllSet' | '$bitsAnyClear' | '$bitsAnySet';
+type GeoOpKeys = '$geoIntersects' | '$geoWithin' | '$near' | '$nearSphere';
+/**
+ * Field-level operators we allow.
+ * Using Pick<...> removes any inherited index signature,
+ * so unknown operator keys will NOT type-check.
+ */
+type KnownFieldOps<V> = Pick<mongodb.FilterOperators<V>, CommonOpKeys | StringOnlyOpKeys | NumberOnlyOpKeys | GeoOpKeys>;
+/**
+ * For whole-array field (not element-wise) we only allow a few generic checks.
+ * This avoids array-of-arrays `$in` through `FilterOperators<A>`.
+ */
+type ArrayFieldGenericOps<A> = Pick<mongodb.FilterOperators<A>, '$exists' | '$type' | '$not'>;
+type Elem<T> = T extends ReadonlyArray<infer U> ? U : T extends Array<infer U> ? U : never;
+type ElemMatchValue<U> = U extends object ? StrictFilter<U> : KnownFieldOps<U>;
+type StrictArrayLevelOperators<A> = A extends ReadonlyArray<infer U> | (infer U)[] ? {
+    $all?: ReadonlyArray<U>;
+    $size?: number;
+    $elemMatch?: ElemMatchValue<U>;
+} : never;
+/**
+ * Full value type allowed for an array field — *without* ever using
+ * `mongodb.FilterOperators<A>` wholesale (prevents indexer leakage and
+ * array-of-arrays `$in`).
+ */
+type StrictArrayValue<A> = A extends ReadonlyArray<any> | any[] ? A | Elem<A> | KnownFieldOps<Elem<A>> | ArrayFieldGenericOps<A> | StrictArrayLevelOperators<A> : never;
+type DotOnlyPaths<T> = Exclude<Paths<T>, Extract<keyof T, string>>;
+type DotPathFilters<T> = {
+    [K in DotOnlyPaths<T>]?: PathValue<T, K> extends ReadonlyArray<any> | any[] ? StrictArrayValue<PathValue<T, K>> : PathValue<T, K> | KnownFieldOps<PathValue<T, K>>;
+};
+type TopFieldFilters<T> = {
+    [K in keyof mongodb.WithId<T> as K extends string ? K : never]?: K extends keyof T ? (T[K] extends ReadonlyArray<any> | any[] ? StrictArrayValue<T[K]> : T[K] | KnownFieldOps<T[K]>) : mongodb.Condition<mongodb.WithId<T>[K]>;
+};
+type StrictLogicalOps<T> = {
+    $and?: StrictFilter<T>[];
+    $or?: StrictFilter<T>[];
+    $nor?: StrictFilter<T>[];
+};
+type StrictOtherRootOps<T> = Partial<Pick<mongodb.RootFilterOperators<T>, '$expr' | '$jsonSchema' | '$text' | '$where' | '$comment' | '$rand'>>;
+type StrictRootOperators<T> = StrictLogicalOps<T> & StrictOtherRootOps<T>;
+/**
+ * StrictFilter:
+ *  • Unknown keys rejected on object literals (no string index signature)
+ *  • Dot-notation paths allowed & typed
+ *  • Arrays keep strict $elemMatch/$size/$all behavior
+ *  • Root operators optional and typed to the driver
+ *  • Assignable to mongodb.Filter<T> even at generic boundaries
+ */
+export type StrictFilter<T> = Expand<TopFieldFilters<T> & DotPathFilters<T> & StrictRootOperators<T>>;
+export {};

package/backend/dist/esm/backend/src/database/filters/strict_filter_v2.js

@@ -0,0 +1,5 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh.
+ */
+export {};

package/backend/dist/esm/backend/src/database/filters/strict_filter_v3.d.ts

@@ -0,0 +1,219 @@
+import type { ObjectId, Document as MongoDocument, WithId } from "mongodb";
+type KnownKeys<T> = {
+    [K in keyof T]-?: string extends K ? never : number extends K ? never : symbol extends K ? never : K;
+}[keyof T];
+type Comparable = number | bigint | Date;
+type Elem<T> = T extends readonly (infer U)[] ? U : never;
+type IsArray<T> = T extends readonly any[] ? true : false;
+type Defined<T> = Exclude<T, undefined>;
+type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+type Join<K, P> = K extends string | number ? P extends string | number ? `${K}.${P}` : never : never;
+/** Dot paths over object properties, ignoring arrays. Depth default = 5. */
+export type DotPaths<T, D extends number = 5> = [D] extends [never] ? never : T extends object ? {
+    [K in KnownKeys<T>]: T[K] extends object ? IsArray<T[K]> extends true ? K & string : (K & string) | Join<K & string, DotPaths<T[K], Prev[D]>> : K & string;
+}[KnownKeys<T>] : never;
+/** Value type at a given dot-path (subset handles up to depth ~5 cleanly). */
+export type PathValue<T, P extends string> = P extends `${infer K}.${infer R}` ? K extends keyof T ? PathValue<T[K], R> : never : P extends keyof T ? T[P] : never;
+export type BSONTypeName = "double" | "string" | "object" | "array" | "binData" | "undefined" | "objectId" | "bool" | "date" | "null" | "regex" | "dbPointer" | "javascript" | "symbol" | "javascriptWithScope" | "int" | "timestamp" | "long" | "decimal" | "minKey" | "maxKey";
+export type BSONType = BSONTypeName | number;
+export type Position = [number, number] | [number, number, number];
+export type Point = {
+    type: "Point";
+    coordinates: Position;
+};
+export type LineString = {
+    type: "LineString";
+    coordinates: Position[];
+};
+export type Polygon = {
+    type: "Polygon";
+    coordinates: Position[][];
+};
+export type MultiPoint = {
+    type: "MultiPoint";
+    coordinates: Position[];
+};
+export type MultiLineString = {
+    type: "MultiLineString";
+    coordinates: Position[][];
+};
+export type MultiPolygon = {
+    type: "MultiPolygon";
+    coordinates: Position[][][];
+};
+export type Geometry = Point | LineString | Polygon | MultiPoint | MultiLineString | MultiPolygon;
+type AllFieldPaths<T extends MongoDocument> = DotPaths<WithId<T>> | "_id";
+export type FieldRef<T extends MongoDocument> = `$${AllFieldPaths<T>}`;
+type ExprLiteral = string | number | boolean | null | Date;
+/** Strict expression tree for `$expr`. */
+export type Expr<T extends MongoDocument> = ExprLiteral | FieldRef<T> | Expr<T>[] | {
+    $add?: Expr<T>[];
+    $subtract?: [Expr<T>, Expr<T>];
+    $multiply?: Expr<T>[];
+    $divide?: [Expr<T>, Expr<T>];
+    $mod?: [Expr<T>, Expr<T>];
+    $eq?: [Expr<T>, Expr<T>];
+    $ne?: [Expr<T>, Expr<T>];
+    $gt?: [Expr<T>, Expr<T>];
+    $gte?: [Expr<T>, Expr<T>];
+    $lt?: [Expr<T>, Expr<T>];
+    $lte?: [Expr<T>, Expr<T>];
+    $and?: Expr<T>[];
+    $or?: Expr<T>[];
+    $not?: Expr<T>;
+    $concat?: Expr<T>[];
+    $size?: Expr<T>;
+    $in?: [Expr<T>, Expr<T>];
+    $toString?: Expr<T>;
+    $toInt?: Expr<T>;
+    $toDouble?: Expr<T>;
+    $toDecimal?: Expr<T>;
+    $toLong?: Expr<T>;
+    $toBool?: Expr<T>;
+    $toDate?: Expr<T>;
+};
+type BitwiseOps<T> = T extends number | bigint ? {
+    $bitsAllClear?: number;
+    $bitsAllSet?: number;
+    $bitsAnyClear?: number;
+    $bitsAnySet?: number;
+} : {};
+type NumericComparators<T> = T extends Comparable ? {
+    $gt?: T;
+    $gte?: T;
+    $lt?: T;
+    $lte?: T;
+    $mod?: T extends number | bigint ? [number, number] : never;
+} : {};
+/**
+ * String ops:
+ * - `$regex` optional overall, but `$options` is only legal when `$regex` is present.
+ */
+type StringRegexOps = {
+    $regex: RegExp | string;
+    $options?: string;
+} | {
+    $regex?: undefined;
+    $options?: undefined;
+};
+type StringOps<T> = T extends string ? StringRegexOps : {};
+type ArrayOps<T> = T extends readonly any[] ? {
+    $size?: number;
+    $all?: Elem<T>[];
+    $elemMatch?: Elem<T> extends object ? StrictFilter<Elem<T>> | FieldOperators<Elem<T>> : FieldOperators<Elem<T>>;
+    $in?: Elem<T>[];
+    $nin?: Elem<T>[];
+} : {};
+type ExistsOp = {
+    $exists?: boolean;
+};
+/**
+ * `$type` differs for string fields for driver-interop:
+ * - For string/regex fields, the mongodb driver narrows *`$type`* to **names only** (no numeric codes).
+ * - For other fields we allow both numeric codes and names.
+ */
+type TypeOpByField<T> = {
+    $type?: Defined<T> extends string ? BSONTypeName | BSONTypeName[] : BSONType | BSONType[];
+};
+type ArrayOfUnion<T> = T extends any ? T[] : never;
+/** For arrays, omit $in/$nin here to avoid the `string[][] & string[]` intersection. */
+type EqualityOps<T> = T extends readonly any[] ? {
+    $eq?: T;
+    $ne?: T;
+} : {
+    $eq?: T;
+    $ne?: T;
+    $in?: ArrayOfUnion<T>;
+    $nin?: ArrayOfUnion<T>;
+};
+/** Geospatial operators (field-level) */
+type GeoOps = {
+    $geoWithin?: {
+        $geometry: Geometry;
+    } | {
+        $box: [Position, Position];
+    } | {
+        $polygon: Position[];
+    } | {
+        $centerSphere: [Position, number];
+    };
+    $geoIntersects?: {
+        $geometry: Geometry;
+    };
+    /**
+     * `$near`/`$nearSphere`: accept only GeoJSON Point (+ optional distance bounds).
+     * (Unit tests expect raw coordinate arrays to be rejected.)
+     */
+    $near?: Point & {
+        $maxDistance?: number;
+        $minDistance?: number;
+    };
+    $nearSphere?: Point & {
+        $maxDistance?: number;
+        $minDistance?: number;
+    };
+};
+/** Operators excluding equality — used as the inner type for $not */
+type FieldOperatorsBase<T> = ExistsOp & TypeOpByField<T> & NumericComparators<Defined<T>> & StringOps<Defined<T>> & ArrayOps<T extends undefined ? never : T> & BitwiseOps<Defined<T>> & GeoOps;
+type NotInner<T> = Omit<FieldOperatorsBase<T>, "$not">;
+export type FieldOperators<T> = EqualityOps<Defined<T>> & FieldOperatorsBase<T> & {
+    /**
+     * Field-level $not wrapping EITHER a regex (only for string fields)
+     * OR any non-equality operators. (Equality inside $not is not allowed.)
+     *
+     * This shape also matches the driver's `FilterOperators<string | RegExp | BSONRegExp>`
+     * so `StrictFilter<T>` remains assignable to `mongodb.Filter<T>`.
+     */
+    $not?: (Defined<T> extends string ? RegExp : never) | NotInner<Defined<T>>;
+};
+/** Value OR operators for a given field type.
+ * For strings, allow bare RegExp because the driver accepts `{ name: /x/ }`.
+ */
+export type FieldCondition<T> = T extends string ? string | RegExp | FieldOperators<T> : Defined<T> | FieldOperators<T>;
+type IdField = {
+    _id?: ObjectId | FieldOperators<ObjectId>;
+};
+type FieldQueryMap<T extends MongoDocument> = {
+    [K in KnownKeys<T>]?: FieldCondition<T[K]>;
+};
+type DotPathQueryMap<T extends MongoDocument> = {
+    [P in DotPaths<T>]?: FieldCondition<PathValue<T, P>>;
+};
+/**
+ * Use `WithId<T>` in logicals for driver interop (driver defines logicals in terms of `Filter<WithId<T>>`).
+ * That lets `StrictFilter<T>` be assignable to `Filter<T>` and also makes arrays of `StrictFilter<T>`
+ * usable where the driver expects `Filter<WithId<T>>[]` (because `StrictFilter<T>` is a subtype).
+ */
+type LogicalOps<T extends MongoDocument> = {
+    $and?: StrictFilter<WithId<T>>[];
+    $or?: StrictFilter<WithId<T>>[];
+    $nor?: StrictFilter<WithId<T>>[];
+};
+/** Top-level evaluation-ish operators accepted by find() / $match */
+type TopEvalOps<T extends MongoDocument> = {
+    $expr?: Expr<T>;
+    $jsonSchema?: unknown;
+    /**
+     * Accept a $where function compatible with both our tests (WithId<T>) and the driver
+     * (which spells it as WithId<WithId<T>>). The intersection makes it callable as either.
+     */
+    $where?: string | (((this: WithId<T>) => boolean) & ((this: WithId<WithId<T>>) => boolean));
+    $text?: {
+        $search: string;
+        $language?: string;
+        $caseSensitive?: boolean;
+        $diacriticSensitive?: boolean;
+    };
+    $comment?: string;
+};
+/**
+ * StrictFilter<T>
+ * - Only allows T's declared keys (plus dot paths) and legal top-level operators.
+ * - Field operators strictly depend on the field type.
+ * - `$expr` has a strongly-typed expression tree with field refs limited to known paths.
+ * - Includes support for _id field which is always present in MongoDB documents.
+ *
+ * NOTE: No string index signatures anywhere — TS excess property checks will catch typos.
+ */
+export type StrictFilter<TSchema extends MongoDocument> = IdField & FieldQueryMap<TSchema> & DotPathQueryMap<TSchema> & LogicalOps<TSchema> & TopEvalOps<TSchema>;
+export {};

package/backend/dist/esm/backend/src/database/filters/strict_filter_v3.js

@@ -0,0 +1 @@
+export {};

package/backend/dist/esm/backend/src/database/filters/strict_update_filter.d.ts

@@ -0,0 +1,165 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh.
+ */
+import * as mongodb from 'mongodb';
+/**
+ * Helper type for recursive depth limiting
+ */
+type PathsPrev = [never, 0, 1, 2, 3, 4];
+/**
+ * Extract all valid paths from a schema including nested paths
+ * Supports dot notation for nested objects
+ */
+type Paths<T, D extends number = 4> = [D] extends [never] ? never : T extends object ? {
+    [K in keyof T]-?: K extends string | number ? `${K}` | (T[K] extends object ? T[K] extends ReadonlyArray<any> ? never : Paths<T[K], PathsPrev[D]> extends infer P ? P extends string ? `${K}.${P}` : never : never : never) : never;
+}[keyof T] : '';
+/**
+ * Get the value type at a specific path in the schema
+ */
+type PathValue<T, P extends string> = P extends keyof T ? T[P] : P extends `${infer K}.${infer Rest}` ? K extends keyof T ? PathValue<T[K], Rest> : never : never;
+/**
+ * MongoDB bitwise operations — exactly one of 'and' | 'or' | 'xor',
+ * each requiring an integer value per the driver typings.
+ */
+type BitwiseOperators = {
+    and: mongodb.IntegerType;
+} | {
+    or: mongodb.IntegerType;
+} | {
+    xor: mongodb.IntegerType;
+};
+/**
+ * Create an exact object type that doesn't allow extra properties
+ * This is the key to making our types strict
+ */
+type Exact<T, Shape = T> = T extends Shape ? T extends infer O ? {
+    [K in keyof O]: O[K];
+} & {
+    [K in Exclude<keyof T, keyof Shape>]?: never;
+} : never : Shape;
+/**
+ * Strict set/update fields
+ */
+type SetFields<TSchema> = Exact<{
+    [K in Paths<TSchema>]?: PathValue<TSchema, K>;
+}>;
+/**
+ * Strict numeric fields for math operations
+ */
+type NumericFields<TSchema> = Exact<{
+    [K in Paths<TSchema> as PathValue<TSchema, K> extends (number | bigint | undefined) ? K : never]?: Exclude<PathValue<TSchema, K>, undefined>;
+}>;
+/**
+ * Strict unset fields
+ */
+type UnsetFields<TSchema> = Exact<{
+    [K in Paths<TSchema>]?: '' | true | 1;
+}>;
+/**
+ * Strict rename fields
+ */
+type RenameFields<TSchema> = Exact<{
+    [K in Paths<TSchema>]?: string;
+}>;
+/**
+ * Strict date fields
+ */
+type DateFields<TSchema> = Exact<{
+    [K in Paths<TSchema> as PathValue<TSchema, K> extends Date | mongodb.Timestamp | undefined ? K : never]?: true | {
+        $type: 'date' | 'timestamp';
+    };
+}>;
+/**
+ * Strict array fields for array operations
+ */
+type ArrayAddFields<TSchema> = Exact<{
+    [K in Paths<TSchema> as PathValue<TSchema, K> extends any[] ? K : never]?: PathValue<TSchema, K> extends (infer U)[] ? U | {
+        $each: U[];
+    } : never;
+}>;
+type ArrayPopFields<TSchema> = Exact<{
+    [K in Paths<TSchema> as PathValue<TSchema, K> extends any[] ? K : never]?: 1 | -1;
+}>;
+type ArrayPullFields<TSchema> = Exact<{
+    [K in Paths<TSchema> as PathValue<TSchema, K> extends any[] ? K : never]?: PathValue<TSchema, K> extends (infer U)[] ? U | mongodb.FilterOperators<U> : never;
+}>;
+type ArrayPushFields<TSchema> = Exact<{
+    [K in Paths<TSchema> as PathValue<TSchema, K> extends any[] ? K : never]?: PathValue<TSchema, K> extends (infer U)[] ? U | mongodb.ArrayOperator<PathValue<TSchema, K>> : never;
+}>;
+type ArrayPullAllFields<TSchema> = Exact<{
+    [K in Paths<TSchema> as PathValue<TSchema, K> extends any[] ? K : never]?: PathValue<TSchema, K> extends (infer U)[] ? U[] : never;
+}>;
+/**
+ * Strict bit fields
+ */
+type BitFields<TSchema> = Exact<{
+    [K in Paths<TSchema> as PathValue<TSchema, K> extends number | undefined ? K : never]?: BitwiseOperators;
+}>;
+/**
+ * Strict version of MongoDB UpdateFilter that only allows updating existing fields
+ * @template TSchema - The document schema type
+ */
+export type StrictUpdateFilter<TSchema> = Exact<{
+    /**
+     * The $set operator replaces the value of a field with the specified value.
+     */
+    $set?: SetFields<TSchema>;
+    /**
+     * The $setOnInsert operator assigns values to fields during an upsert only when inserting a new document.
+     */
+    $setOnInsert?: SetFields<TSchema>;
+    /**
+     * The $unset operator deletes a particular field.
+     */
+    $unset?: UnsetFields<TSchema>;
+    /**
+     * The $inc operator increments a field by a specified value.
+     */
+    $inc?: NumericFields<TSchema>;
+    /**
+     * The $mul operator multiplies the value of a field by a number.
+     */
+    $mul?: NumericFields<TSchema>;
+    /**
+     * The $min operator updates the value of the field to a specified value if the specified value is less than the current value of the field.
+     */
+    $min?: SetFields<TSchema>;
+    /**
+     * The $max operator updates the value of the field to a specified value if the specified value is greater than the current value of the field.
+     */
+    $max?: SetFields<TSchema>;
+    /**
+     * The $currentDate operator sets the value of a field to the current date.
+     */
+    $currentDate?: DateFields<TSchema>;
+    /**
+     * The $rename operator updates the name of a field.
+     */
+    $rename?: RenameFields<TSchema>;
+    /**
+     * The $addToSet operator adds a value to an array unless the value is already present.
+     */
+    $addToSet?: ArrayAddFields<TSchema>;
+    /**
+     * The $pop operator removes the first or last element of an array.
+     */
+    $pop?: ArrayPopFields<TSchema>;
+    /**
+     * The $pull operator removes from an array all instances of a value or values that match a specified condition.
+     */
+    $pull?: ArrayPullFields<TSchema>;
+    /**
+     * The $push operator appends a specified value to an array.
+     */
+    $push?: ArrayPushFields<TSchema>;
+    /**
+     * The $pullAll operator removes all instances of the specified values from an array.
+     */
+    $pullAll?: ArrayPullAllFields<TSchema>;
+    /**
+     * The $bit operator performs a bitwise update of a field.
+     */
+    $bit?: BitFields<TSchema>;
+}>;
+export {};

package/backend/dist/esm/backend/src/database/filters/strict_update_filter.js

@@ -0,0 +1,5 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh.
+ */
+export {};

package/backend/dist/esm/backend/src/database/filters/strict_update_filter_test.d.ts

@@ -0,0 +1,5 @@
+export interface Query<Type extends string> {
+    uid: string;
+    type: Type;
+    name: string;
+}