@anteros/core 0.0.2 → 0.0.4

package/server/config.ts

@@ -53,7 +53,7 @@ function safePublicConfig() {
             actions: [
                 'insertOne', 'insertMany', 'updateOne', 'updateMany',
                 'deleteOne', 'deleteMany', 'findOne', 'find',
-                'findOneAndUpdate', 'aggregate',
+                'aggregate',
                 ...Object.keys(c.actions ?? {}),
             ],
             fields: (c.fields ?? []).map(f => ({

package/tests/api.test.ts

@@ -116,14 +116,6 @@ describe("updateMany", () => {
     });
 });
 
-describe("findOneAndUpdate", () => {
-    it("finds and updates atomically", async () => {
-        await rest.insertOne("items", { title: "fau", count: 0 });
-        const doc = await rest.findOneAndUpdate("items", { title: "fau" }, { $set: { count: 10 } });
-        expect(doc.count).toBe(10);
-    });
-});
-
 describe("deleteMany", () => {
     it("deletes multiple by ids", async () => {
         const a = await rest.insertOne("items", { title: "d1" });

package/types/api.d.ts

@@ -17,7 +17,6 @@ export declare enum ApiActions {
 }
 
 export type ActionsApiList =
-    | "findOneAndUpdate"
     | "insertOne"
     | "insertMany"
     | "updateOne"

package/types/collection.d.ts

@@ -28,20 +28,17 @@ export type Collection = {
                 payload: any;
                 error: typeof fn.error;
                 jwt: typeof jwt;
-                req: {
-                    cookies: {
-                        set: (name: string, value: string, options?: {
-                            httpOnly?: boolean;
-                            secure?: boolean;
-                            maxAge?: number;
-                            path?: string;
-                            domain?: string;
-                            sameSite?: 'lax' | 'strict' | 'none';
-                        }) => any;
-                        get: (name: string) => string | undefined;
-                        delete: (name: string) => void;
-                    }
-
+                cookies: {
+                    set: (name: string, value: string, options?: {
+                        httpOnly?: boolean;
+                        secure?: boolean;
+                        maxAge?: number;
+                        path?: string;
+                        domain?: string;
+                        sameSite?: 'lax' | 'strict' | 'none';
+                    }) => any;
+                    get: (name: string) => string | undefined;
+                    delete: (name: string) => void;
                 }
             }) => Promise<{
                 token: string;
@@ -52,10 +49,8 @@ export type Collection = {
                 payload: any;
                 error: typeof fn.error;
                 jwt: typeof jwt;
-                req: {
-                    cookies: {
-                        delete: (name: string) => void;
-                    }
+                cookies: {
+                    delete: (name: string) => void;
                 }
             }) => Promise<void>;
         };

package/utils/func.ts

@@ -208,16 +208,28 @@ function cleanDeep<T extends DeepRecord | DeepRecord[]>(data: T): Partial<T> {
     return result as Partial<T>;
 }
 
+/**
+ * Vérifie si une string est une date valide.
+ * Accepte : ISO 8601 (YYYY-MM-DD, YYYY-MM-DDTHH:mm...) et timestamps UNIX (s ou ms).
+ * Rejette les strings ambiguës que certains moteurs JS parsent en date (ex: "REF-2024").
+ */
 function isDate(value: string): boolean {
     if (!value || typeof value !== 'string') return false;
     const trimmed = value.trim();
-    // Chaînes 100 % chiffres : seuls timestamps UNIX s (10) ou ms (13) — sinon codes type "170273" seraient des dates via `new Date("170273")`.
+
+    // Timestamps numériques purs (10 ou 13 chiffres)
     if (/^\d+$/.test(trimmed)) {
         const len = trimmed.length;
         if (len !== 10 && len !== 13) return false;
         const ms = new Date(Number(trimmed)).getTime();
         return !isNaN(ms);
     }
+
+    // ISO 8601 : YYYY-MM-DD avec heure optionnelle
+    if (!/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d{1,3})?)?(Z|[+-]\d{2}:\d{2})?)?$/.test(trimmed)) {
+        return false;
+    }
+
     const date = new Date(trimmed);
     return !isNaN(date.getTime());
 }
@@ -269,14 +281,26 @@ function joinFormatToDatePath(parent: string, segment: string | number): string
     return parent === '' ? s : `${parent}.${s}`;
 }
 
-/** Correspond à un nom de champ schéma (`createdAt`, `user.birthDate`) y compris en profondeur (`$set.createdAt`). */
+/**
+ * Correspond à un nom de champ schéma (`createdAt`, `user.birthDate`)
+ * y compris en profondeur (`$set.createdAt`) ou derrière un opérateur
+ * MongoDB (`createdAt.$lte`, `$match.createdAt.$gte`).
+ */
 function pathMatchesFieldKey(path: string, key: string): boolean {
-    return path === key || path.endsWith('.' + key);
+    // Strip trailing MongoDB operator segments: createdAt.$lte → createdAt
+    const cleanPath = path.replace(/\.\$[a-z]+$/i, '');
+    return cleanPath === key || cleanPath.endsWith('.' + key);
 }
 
 function shouldFormatDateAtPath(path: string, options?: FormatToDateOptions): boolean {
     // Aucune option → convertir partout où `isDate` est vrai
     if (!options) return true;
+
+    // Contexte d'opérateur MongoDB ($lte, $gte, $eq, $in, $nin, $exists, etc.)
+    // → toujours convertir : un opérateur sur une date n'a de sens qu'avec un vrai Date
+    // On vérifie si un segment du chemin commence par '$' (ex: createdAt.$lte, $in.0)
+    if (path.split('.').some((seg) => /^\$[a-z]+$/i.test(seg))) return true;
+
     if (options.omitKeys?.some((k) => pathMatchesFieldKey(path, k))) return false;
     // Whitelist seulement si includeKeys est un tableau non vide
     if (options.includeKeys && options.includeKeys.length > 0) {
@@ -290,6 +314,11 @@ function formatToDate(data: any, options?: FormatToDateOptions, path = ''): any
     if (data instanceof Date) return data;
     if (data instanceof ObjectId) return data;
 
+    // String racine (ex: item de tableau $in) — vérifier avant la branche objet
+    if (typeof data === 'string' && isDate(data)) {
+        return shouldFormatDateAtPath(path, options) ? stringToDate(data) : data;
+    }
+
     if (Array.isArray(data)) {
         return data.map((item, i) => {
             const p = joinFormatToDatePath(path, i);
@@ -563,13 +592,11 @@ function collectDateFieldPathsFromCollection(col: Collection): string[] {
     return [...paths];
 }
 
-function toBson<T>(data: any | any[], options?: FormatInputOptions): T {
+function toBson<T>(data: any | any[], _options?: FormatInputOptions): T {
     let data_ = formatToObjectId(data);
-    const dateOpts: FormatToDateOptions | undefined =
-        options?.col !== undefined
-            ? { includeKeys: collectDateFieldPathsFromCollection(options.col) }
-            : undefined;
-    data_ = formatToDate(data_, dateOpts);
+    // Toujours convertir toutes les strings date valide en Date,
+    // quel que soit le contexte (insert, update, match, pipeline).
+    data_ = formatToDate(data_);
 
     if (Array.isArray(data)) {
         data.length = 0;