@communecter/cocolight-api-client 1.0.40 → 1.0.42

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@communecter/cocolight-api-client",
-    "version": "1.0.40",
+    "version": "1.0.42",
     "description": "Client Axios simplifié pour l'API cocolight",
     "repository": {
         "type": "git",

package/src/api/BaseEntity.js

@@ -5,7 +5,7 @@ import EJSON from "ejson";
 import pkg from "file-type";
 
 import { ApiAuthenticationError, ApiError, ApiResponseError, ApiValidationError } from "../error.js";
-import { autoSyncDraftFromSchema, reactive } from "../utils/reactive.js";
+import { isReactive, isSignal, reactive } from "../utils/reactive.js";
 const { fromBuffer } = pkg;
 
 /**
@@ -89,9 +89,9 @@ export class BaseEntity {
       throw new ApiError("deps.EndpointApi doit être une classe ou une instance valide.");
     }
 
-    this._serverData = null;
+    this._serverData = reactive({});
 
-    const { draft, proxy } = this._buildDraftAndProxy({
+    const { draft, proxy, initial } = this._buildDraftAndProxy({
       data: { ...data, ...this.defaultFields },
       serverData: this._serverData,
       constant: this.constructor.SCHEMA_CONSTANTS,
@@ -100,7 +100,7 @@ export class BaseEntity {
       removeFields: this.removeFields
     });
 
-    this._initialDraftData = JSON.parse(JSON.stringify(draft));
+    this._initialDraftData = initial;
     this._draftData = draft;
     this.data = proxy;
   }
@@ -162,7 +162,7 @@ export class BaseEntity {
    * @returns {boolean}
    */
   hasChanges() {
-    return JSON.stringify(this._draftData) !== JSON.stringify(this._initialDraftData);
+    return this._serialize(this._toRawDeep(this._draftData)) !== this._serialize(this._initialDraftData);
   }
 
   /**
@@ -186,6 +186,7 @@ export class BaseEntity {
 
       if (!this.id && typeof this._add === "function") {
         await this._add(payload);
+        this._resetInitialDraftData();
         // on refresh le contexte utilisateur si besoin
         if(this.userContext) {
           await this.userContext.refresh();
@@ -193,6 +194,7 @@ export class BaseEntity {
         return await this.refresh();
       } else if (typeof this._update === "function") {
         const hasChanged = await this._update(payload);
+        this._resetInitialDraftData();
         if (hasChanged) return await this.refresh();
       }
 
@@ -223,29 +225,94 @@ export class BaseEntity {
    * @returns {void}
    * @private
    */
-  _setData(newData) {
+  _setData(newData, { forceInitialDraftReset = false } = {}) {
     if (this.userContext && this.userContext !== this) {
       this.apiClient._logger?.info?.(`[${this.__entityTag}] Mise à jour liée à userContext : ${this.userContext.id}`);
     }
-    this._serverData = reactive({ ...newData });
 
-    const { draft, proxy } = this._buildDraftAndProxy({
-      data: { ...newData, ...this.defaultFields },
+    if (isReactive(this._serverData)) {
+      Object.assign(this._serverData, newData);
+    } else {
+      this._serverData = reactive({ ...newData });
+    }
+
+    const clientDraft = this._draftData ? this._toRawDeep(this._draftData) : {};
+
+    const mergedData = {
+      ...newData,
+      ...this.defaultFields,
+      ...clientDraft
+    };
+
+    const { draft, proxy, initial } = this._buildDraftAndProxy({
+      data: mergedData,
       serverData: this._serverData,
+      previousDraft: this._draftData,
       constant: this.constructor.SCHEMA_CONSTANTS,
       apiClient: this.apiClient,
       transforms: this.transforms,
       removeFields: this.removeFields
     });
-    this._initialDraftData = JSON.parse(JSON.stringify(draft));
-    this._draftData = draft;
-    this.data = proxy;
 
-    if (this._syncReactiveDraft) {
-      this.setupReactiveSync();
+    if (forceInitialDraftReset) {
+      this._initialDraftData = structuredClone(this._toRawDeep(draft));
+    } else if (!this._initialDraftData) {
+      this._initialDraftData = initial;
+    }
+
+    if (isReactive(this._draftData)) {
+      this._updateDraftPreservingUserChanges(draft);
+    } else {
+      this._draftData = reactive(draft);
+    }
+
+    if (!this.data) {
+      this.data = proxy;
+    }
+
+  }
+
+  _updateDraftPreservingUserChanges(draft) {
+    for (const key of Object.keys(draft)) {
+      const current = this._draftData?.[key];
+      const initialValue = this._initialDraftData?.[key];
+
+      const isModified =
+      current !== undefined &&
+      initialValue !== undefined &&
+      this._serialize(this._toRawDeep(current)) !== this._serialize(initialValue);
+
+      if (!isModified) {
+        this._draftData[key] = draft[key];
+      }
     }
   }
 
+  _resetInitialDraftData() {
+    const raw = this._toRawDeep(this._draftData);
+    this._initialDraftData = structuredClone(raw);
+  }
+
+
+  _toRawDeep(obj) {
+    if (isSignal(obj)) {
+      return this._toRawDeep(obj.value);
+    }
+
+    if (Array.isArray(obj)) {
+      return obj.map(this._toRawDeep);
+    }
+
+    if (typeof obj === "object" && obj !== null) {
+      const result = {};
+      for (const key of Object.keys(obj)) {
+        result[key] = this._toRawDeep(obj[key]);
+      }
+      return result;
+    }
+
+    return obj; // valeur primitive
+  }
 
   /**
    * Champs à ajouter automatiquement à chaque draft (ex: `typeElement`).
@@ -768,9 +835,24 @@ export class BaseEntity {
   _createDraftProxy(apiClient, server = {}, draft = {}, allowedFields = [], transforms = {}, options = {}) {
     return new Proxy({}, {
       get: (_, prop) => {
-        const val = prop in draft ? draft[prop] : server[prop];
-        const transformer = transforms[prop];
-        return typeof transformer === "function" ? transformer(val) : val;
+      // Ne pas tenter d’accéder à des propriétés système
+        if (typeof prop !== "string" && typeof prop !== "symbol") return undefined;
+
+        // Lecture explicite — déclenche signal si draft est réactif
+        if (prop in draft) {
+          const value = draft[prop];
+          const transformer = transforms[prop];
+          return typeof transformer === "function" ? transformer(value) : value;
+        }
+
+        // Fallback vers serverData — aussi potentiellement réactif
+        if (server && typeof server === "object" && prop in server) {
+          const value = server[prop];
+          const transformer = transforms[prop];
+          return typeof transformer === "function" ? transformer(value) : value;
+        }
+
+        return undefined;
       },
 
       set: (_, prop, value) => {
@@ -786,7 +868,13 @@ export class BaseEntity {
           apiClient._logger.warn(message);
           return false;
         }
-        draft[prop] = value;
+        const current = draft[prop];
+
+        if (current && typeof current === "object" && current.__isSignal === true) {
+          current.value = value; // ✅ met à jour le signal
+        } else {
+          draft[prop] = value; // fallback classique
+        }
         return true;
       },
 
@@ -797,8 +885,16 @@ export class BaseEntity {
       },
 
       has: (_, prop) => prop in draft || prop in server,
-      ownKeys: () => [...new Set([...Object.keys(server), ...Object.keys(draft)])],
-      getOwnPropertyDescriptor: () => ({ enumerable: true, configurable: true })
+
+      ownKeys: () => [...new Set([
+        ...Object.keys(server || {}),
+        ...Object.keys(draft || {})
+      ])],
+
+      getOwnPropertyDescriptor: () => ({
+        enumerable: true,
+        configurable: true
+      })
     });
   }
 
@@ -874,7 +970,7 @@ export class BaseEntity {
    * @returns {Object} - Objet contenant le brouillon et le proxy.
    * @private
    */
-  _buildDraftAndProxy({ data = {}, serverData = null, constant, apiClient, transforms = {}, throwOnError = true, removeFields = [] }) {
+  _buildDraftAndProxy({ data = {}, serverData = null, previousDraft = null, constant, apiClient, transforms = {}, throwOnError = true, removeFields = [] }) {
     const constants = Array.isArray(constant) ? constant : [constant];
     const combinedSchema = {
       allOf: [],
@@ -898,7 +994,7 @@ export class BaseEntity {
     
       combinedSchema.allOf.push(sch);
     }
-    const draft = {};
+
     let allowed = this._extractWritableFields(combinedSchema, data);
 
     if (data.id && allowed.indexOf("id") === -1) {
@@ -910,15 +1006,32 @@ export class BaseEntity {
 
     allowed = allowed.filter(k => !removeFields.includes(k));
 
-    for (const key of allowed) {
-      const raw = data[key];
-      const transformed = typeof transforms[key] === "function" ? transforms[key](raw, data) : raw;
-      if (transformed !== undefined) draft[key] = transformed;
-    }
+    // Transformation des champs autorisés
+    const rawDraft = Object.fromEntries(
+      allowed.map((key) => {
+        const raw = data[key];
+        const transformed = typeof transforms[key] === "function"
+          ? transforms[key](raw, data)
+          : raw;
+        return [key, transformed];
+      // eslint-disable-next-line no-unused-vars
+      }).filter(([_, v]) => v !== undefined)
+    );
 
-    const proxy = this._createDraftProxy(apiClient, serverData, draft, allowed, transforms, { throwOnError });
+    const initial = structuredClone ? structuredClone(rawDraft) : JSON.parse(JSON.stringify(rawDraft));
 
-    return { draft, proxy };
+    const draft = isReactive(previousDraft)
+      ? Object.assign(previousDraft, rawDraft)
+      : reactive(rawDraft);
+
+    // Assure que serverData est réactif si c'est un objet
+    const reactiveServer = isReactive(serverData)
+      ? serverData
+      : (serverData && typeof serverData === "object" ? reactive(serverData) : serverData);
+
+    const proxy = this._createDraftProxy(apiClient, reactiveServer, draft, allowed, transforms, { throwOnError });
+
+    return { draft, proxy, initial};
   }
 
   /**
@@ -962,25 +1075,6 @@ export class BaseEntity {
     return Object.keys(changed).length > 0 ? changed : null;
   }
 
-  /**
-   * ───────────────────────────────
-   * ReactiveMixin
-   * ───────────────────────────────
-   */
-
-  /**
-   * Active la synchronisation réactive entre le brouillon et le schéma.
-   * 
-   * @returns {void}
-   * @public
-   */
-  setupReactiveSync() {
-    if (!this._syncReactiveDraft) {
-      this._syncReactiveDraft = true;
-    }
-    autoSyncDraftFromSchema(this);
-  }
-
   /**
    * ───────────────────────────────
    * MutualEntityMixin
@@ -1594,7 +1688,7 @@ export class BaseEntity {
   async get() {
     return this.apiClient.safeCall(async () => {
       const data = await this._getPublicProfile();
-      this._setData(data);
+      this._setData(data, { forceInitialDraftReset: true });
       return data;
     });
   }

package/src/utils/reactive.js

@@ -1,7 +1,5 @@
 // reactive.js - Système maison combinant Signal + Proxy pour réactivité profonde et fine
 
-import { ApiError } from "../error.js";
-
 const effectStack = [];
 const computedCache = new WeakMap();
 const signalRegistry = new WeakMap();
@@ -56,7 +54,12 @@ function createSignal(initialValue) {
   return signal;
 }
 
-function isSignal(obj) {
+/**
+ * vérifie si un objet est un signal.
+ * @param {*} obj
+ * @returns {boolean}
+ */
+export function isSignal(obj) {
   return obj && obj.__isSignal === true;
 }
 
@@ -199,95 +202,3 @@ export function subscribeTo(obj, key, callback) {
   const signal = signals.get(key);
   return signal?.subscribe?.(() => callback(signal.value)) ?? (() => {});
 }
-
-// --- Helpers internes ---
-function _getPathValue(obj, path) {
-  return path.split(".").reduce((o, k) => (o ? o[k] : undefined), obj);
-}
-
-function _setPathValue(obj, path, value) {
-  const keys = path.split(".");
-  const lastKey = keys.pop();
-  const parent = keys.reduce((o, k) => {
-    if (o[k] == null) o[k] = {};
-    return o[k];
-  }, obj);
-  parent[lastKey] = value;
-}
-
-function _deletePathValue(obj, path) {
-  const keys = path.split(".");
-  const lastKey = keys.pop();
-  const parent = keys.reduce((o, k) => o?.[k], obj);
-  if (parent && lastKey in parent) delete parent[lastKey];
-}
-
-function _applyTransformIfExists(path, val, entity) {
-  const topKey = path.split(".")[0];
-  const transform = entity.transforms?.[topKey];
-  return typeof transform === "function" ? transform(val, entity.serverData) : val;
-}
-
-/**
- * Synchronise certaines clés du draft avec serverData tant qu'elles ne sont pas modifiées.
- * @param {object} entityInstance
- * @param {string[]} keys
- * @param {{ cleanIfEqual?: boolean }} [options]
- */
-export function syncDraftOnServerChange(entityInstance, keys = [], { cleanIfEqual = true } = {}) {
-  for (const path of keys) {
-    effect(() => {
-      const rawServerVal = _getPathValue(entityInstance.serverData, path);
-      const transformedServerVal = _applyTransformIfExists(path, rawServerVal, entityInstance);
-
-      const draftVal = _getPathValue(entityInstance.draftData, path);
-      const initialVal = _getPathValue(entityInstance.initialDraftData, path);
-
-      const isModified = JSON.stringify(draftVal) !== JSON.stringify(initialVal);
-
-      if (!isModified) {
-        if (cleanIfEqual && JSON.stringify(draftVal) === JSON.stringify(transformedServerVal)) {
-          _deletePathValue(entityInstance.draftData, path);
-        } else {
-          _setPathValue(entityInstance.draftData, path, transformedServerVal);
-        }
-      }
-    });
-  }
-}
-
-/**
- * Applique `syncDraftOnServerChange()` pour tous les champs autorisés de l'entité.
- * @param {object} entityInstance
- */
-export function autoSyncDraftFromSchema(entityInstance) {
-  const constants = Array.isArray(entityInstance.constructor.SCHEMA_CONSTANTS)
-    ? entityInstance.constructor.SCHEMA_CONSTANTS
-    : [entityInstance.constructor.SCHEMA_CONSTANTS];
-
-  const combinedSchema = { allOf: [], $defs: {} };
-
-  for (const key of constants) {
-    const sch = entityInstance.apiClient.getRequestSchema(key);
-    if (!sch) throw new ApiError(`Unable to find schema for ${key}.`);
-    if (sch.$defs) {
-      for (const [defKey, defVal] of Object.entries(sch.$defs)) {
-        if (!combinedSchema.$defs[defKey]) {
-          combinedSchema.$defs[defKey] = defVal;
-        }
-      }
-    }
-    combinedSchema.allOf.push(sch);
-  }
-
-  const data = {
-    ...entityInstance.serverData,
-    ...entityInstance.defaultFields
-  };
-
-  let allowed = entityInstance._extractWritableFields?.(combinedSchema, data) || [];
-  allowed = allowed.filter(k => !entityInstance.removeFields.includes(k));
-  allowed = allowed.filter(k => !["id"].includes(k));
-
-  syncDraftOnServerChange(entityInstance, allowed);
-}