edmaxlabs-core 2.5.0 → 2.5.1

package/dist/index.cjs

@@ -32,12 +32,13 @@ module.exports = __toCommonJS(src_exports);
 
 // src/authentication/Credentials.ts
 var Credentials = class _Credentials {
-  constructor(uid, displayInfo, createdAt, updatedAt, lastLogged) {
+  constructor(uid, displayInfo, createdAt, updatedAt, lastLogged, logged) {
     this.uid = uid;
     this.displayInfo = displayInfo;
     this.createdAt = createdAt;
     this.updatedAt = updatedAt;
     this.lastLogged = lastLogged;
+    this.logged = logged === true;
   }
   static fromMap(map) {
     const uid = map.id ?? map.uid ?? "";
@@ -46,12 +47,14 @@ var Credentials = class _Credentials {
     const createdAt = data.createdAt;
     const updatedAt = data.updatedAt;
     const lastLogged = data.lastLogged;
+    const logged = data.logged;
     const result = new _Credentials(
       uid,
       d_info,
       createdAt,
       updatedAt,
-      lastLogged
+      lastLogged,
+      logged
     );
     return result;
   }
@@ -61,7 +64,8 @@ var Credentials = class _Credentials {
       displayInfo: this.displayInfo,
       createdAt: this.createdAt,
       updatedAt: this.updatedAt,
-      lastLogged: this.lastLogged
+      lastLogged: this.lastLogged,
+      logged: this.logged
     };
   }
 };
@@ -129,91 +133,123 @@ var HttpsRequest = class {
 
 // src/authentication/Authentication.ts
 var _Authentication = class _Authentication {
-  // Re-entrancy guard
   constructor() {
-    this.eUser = null;
-    this.client = null;
-    this.app = null;
-    // Dedicated lightweight instance for auth
     this.eventListeners = /* @__PURE__ */ new Map();
-    this.isHandlingChange = false;
-    // ====================== AUTH METHODS ======================
+    this.eventWaiters = /* @__PURE__ */ new Map();
+    this.unsubscribers = /* @__PURE__ */ new Set();
+    this.isSameCredentials = (a, b) => {
+      if (!a && !b)
+        return true;
+      if (!a || !b)
+        return false;
+      return JSON.stringify(a.toMap()) === JSON.stringify(b.toMap());
+    };
     this.createUserWithEmailAndPassword = async ({
       email,
       password
     }) => {
+      this.eUser = void 0;
       this.saveCredentials(null);
-      const app = this.app.getDatabase;
-      const existing = await app.collection("users").query.where({ key: "email", op: "===", value: email }).get();
-      if (existing.length > 0) {
+      const app = this.app?.getDatabase;
+      const data = await app?.collection("users").query.where({
+        key: "email",
+        op: "===",
+        value: email
+      }).get();
+      if (data.length > 0) {
         throw new Error("Email Already In Use.");
       }
-      const userRef = await app.collection("users").add({
+      const userRef = await app?.collection("users").add({
         email,
         password,
-        token: this.client.getConfig().token,
         logged: true,
-        lastLogged: Date.now()
+        lastLogged: Date.now(),
+        displayInfo: {
+          firstname: email.split("@")[0],
+          lastname: "",
+          surname: "",
+          profile: "./logo.png",
+          email,
+          phone: ""
+        }
       });
-      if (!userRef?.id) {
-        throw new Error("Something went wrong. Please try again.");
+      if (!userRef?.id || userRef?.id === "") {
+        throw new Error("Something went wrong try Again.");
       }
-      const newCreds = Credentials.fromMap(userRef.toMap());
-      this.saveCredentials(newCreds);
-      return newCreds;
+      this.eUser = Credentials.fromMap(userRef);
+      this.saveCredentials(this.eUser);
+      return Credentials.fromMap(userRef.toMap());
     };
     this.signInWithEmailAndPassword = async ({
       email,
       password
     }) => {
-      const app = this.app.getDatabase;
-      const data = await app.collection("users").query.where({ key: "email", op: "===", value: email }).where({ key: "password", op: "===", value: password }).get();
-      if (!data || data.length === 0) {
+      const app = this.app?.getDatabase;
+      const data = await app?.collection("users").query.where({
+        key: "email",
+        op: "===",
+        value: email
+      }).where({
+        key: "password",
+        op: "===",
+        value: password
+      }).get();
+      if (data === void 0) {
+        throw new Error("Auth Failed.");
+      }
+      if (data?.length === 0) {
         throw new Error("User Not Found.");
       }
-      const userDoc = data[0];
-      await app.collection("users").doc(userDoc.id).update({
+      const _data = data[0];
+      await app?.collection("users").doc(_data.id).update({
         logged: true,
         lastLogged: Date.now()
       });
-      const signedInUser = Credentials.fromMap(userDoc.toMap());
-      this.saveCredentials(signedInUser);
-      return signedInUser;
-    };
-    this.signOut = async () => {
-      const current = this.currentUser();
-      if (!current)
-        return;
-      const app = this.app.getDatabase;
-      await app.collection("users").doc(current.uid).update({
-        logged: false,
-        lastLogged: Date.now()
-      });
-      this.saveCredentials(null);
+      this.eUser = Credentials.fromMap(_data);
+      this.saveCredentials(this.eUser);
+      return Credentials.fromMap(_data);
     };
     this.deleteUser = async () => {
-      if (!this.eUser)
+      if (!this.eUser) {
         throw new Error("No User Signed in");
-      const app = this.app.getDatabase;
-      await app.collection("users").doc(this.eUser.uid).delete();
+      }
+      const app = this.app?.getDatabase;
+      const userRef = await app?.collection("users").doc(this.eUser.uid).delete();
+      if (userRef) {
+        throw new Error("Something went wrong try Again.");
+      }
+      this.eUser = void 0;
+      this.saveCredentials(null);
+    };
+    this.signOut = async () => {
+      const app = this.app?.getDatabase;
+      const luid = this.currentUser();
+      this.eUser = void 0;
       this.saveCredentials(null);
+      if (luid)
+        await app?.collection("users").doc(luid?.uid).update({
+          logged: false,
+          lastLogged: Date.now()
+        });
+      return;
     };
-    // Optional: Rules verification
     this.rules = async (path, context) => {
       const res = await new HttpsRequest({
         method: "POST" /* POST */,
-        endpoint: `${this.client.getBaseUrl()}/auth/rules/verify`,
+        endpoint: this.client.getBaseUrl() + "/auth/rules/verify",
         headers: {
           authorization: this.client.getConfig().token,
           project: this.client.getConfig().project
         },
-        body: { path, context }
+        body: {
+          path,
+          context
+        }
       }).sendRequest();
       return res;
     };
-    if (_Authentication.instance) {
+    if (_Authentication.instance)
       return _Authentication.instance;
-    }
     this.client = EdmaxLabs.instance;
     this.app = new EdmaxLabs({
       token: "auth",
@@ -222,16 +258,26 @@ var _Authentication = class _Authentication {
     _Authentication.instance = this;
     this.restoreSession();
   }
+  restoreSession() {
+    const saved = this.currentUser();
+    if (saved) {
+      this.eUser = saved;
+      this.emitValue("creds", saved);
+    }
+  }
+  // Better singleton
   static getInstance() {
     if (!_Authentication.instance) {
       _Authentication.instance = new _Authentication();
     }
     return _Authentication.instance;
   }
-  // ====================== EVENT SYSTEM ======================
   emitValue(key, value) {
     const listeners = this.eventListeners.get(key) || [];
-    [...listeners].forEach((listener) => listener(value));
+    listeners.forEach((l) => l(value));
+    const waiters = this.eventWaiters.get(key) || [];
+    waiters.forEach((resolve) => resolve(value));
+    this.eventWaiters.delete(key);
   }
   onValue(key, callback) {
     const listeners = this.eventListeners.get(key) || [];
@@ -242,7 +288,6 @@ var _Authentication = class _Authentication {
       this.eventListeners.set(key, filtered);
     };
   }
-  // ====================== CREDENTIALS ======================
   currentUser() {
     const data = localStorage.getItem("eauth");
     if (!data)
@@ -265,71 +310,50 @@ var _Authentication = class _Authentication {
     this.eUser = credentials;
     this.emitValue("creds", credentials);
   }
-  isSameCredentials(a, b) {
-    if (!a && !b)
-      return true;
-    if (!a || !b)
-      return false;
-    return a.uid === b.uid && a.displayInfo.email === b.displayInfo.email && a.lastLogged === b.lastLogged;
-  }
-  restoreSession() {
-    const saved = this.currentUser();
-    if (saved) {
-      this.eUser = saved;
-    }
-  }
-  // ====================== MAIN AUTH STATE LISTENER ======================
-  /**
-   * Main method to listen to authentication state changes.
-   * This listener stays alive for the entire app lifetime.
-   */
+  // Main auth state listener - should be called ONCE at app root
   authState({
     onChange,
     onSignOut,
     onDeleted
   }) {
     let userDocUnsubscribe;
-    let credsUnsub;
     const handleCredsChange = (creds) => {
-      if (this.isHandlingChange)
-        return;
-      this.isHandlingChange = true;
-      userDocUnsubscribe?.();
-      userDocUnsubscribe = void 0;
+      if (userDocUnsubscribe) {
+        userDocUnsubscribe();
+        userDocUnsubscribe = void 0;
+      }
       if (!creds) {
         this.eUser = null;
         onSignOut?.();
-        this.isHandlingChange = false;
         return;
       }
-      const userRef = this.app.getDatabase.collection("users").doc(creds.uid);
+      const userRef = this.app?.getDatabase.collection("users").doc(creds.uid);
+      if (!userRef)
+        return;
       userDocUnsubscribe = userRef.onSnapshot(
         (snapshot, change) => {
+          console.log(snapshot);
           if (change === "delete") {
             this.saveCredentials(null);
             onSignOut?.();
             onDeleted?.();
-            this.isHandlingChange = false;
             return;
           }
           if (change === "insert" || change === "update") {
-            if (!snapshot?.data) {
-              this.isHandlingChange = false;
+            if (!snapshot)
               return;
-            }
             if (snapshot.data.logged === false || snapshot.data.logged === "false") {
               this.saveCredentials(null);
               onSignOut?.();
-              this.isHandlingChange = false;
               return;
             }
             const newCreds = Credentials.fromMap(snapshot.toMap());
             if (!this.isSameCredentials(this.eUser, newCreds)) {
+              this.eUser = newCreds;
               this.saveCredentials(newCreds);
               onChange(newCreds);
             }
           }
-          this.isHandlingChange = false;
         }
       );
     };
@@ -338,10 +362,10 @@ var _Authentication = class _Authentication {
       this.eUser = initialUser;
       onChange(initialUser);
     }
-    credsUnsub = this.onValue("creds", handleCredsChange);
     handleCredsChange(initialUser);
+    const credsUnsub = this.onValue("creds", handleCredsChange);
     return () => {
-      credsUnsub?.();
+      credsUnsub();
       userDocUnsubscribe?.();
     };
   }
@@ -368,308 +392,6 @@ var DocumentSnapshot = class _DocumentSnapshot {
   }
 };
 
-// src/database/Timestamp.ts
-var Timestamp = class _Timestamp {
-  constructor(seconds, nanoseconds = 0) {
-    this.seconds = seconds;
-    this.nanoseconds = nanoseconds;
-  }
-  static now() {
-    return _Timestamp.fromMillis(Date.now());
-  }
-  static fromDate(date) {
-    return new _Timestamp(
-      Math.floor(date.getTime() / 1e3),
-      date.getTime() % 1e3 * 1e6
-    );
-  }
-  static fromMillis(ms) {
-    return new _Timestamp(Math.floor(ms / 1e3), ms % 1e3 * 1e6);
-  }
-  static fromMongo(dateObj) {
-    return _Timestamp.fromMillis(dateObj.getTime());
-  }
-  static fromJSON(obj) {
-    return new _Timestamp(obj.seconds, obj.nanoseconds);
-  }
-  toDate() {
-    return new Date(this.toMillis());
-  }
-  toMillis() {
-    return this.seconds * 1e3 + Math.floor(this.nanoseconds / 1e6);
-  }
-  sinceEpoch() {
-    return this.seconds;
-  }
-  toMongo() {
-    return new Date(this.toMillis());
-  }
-  format(pattern = "dd-MM-yyyy HH:mm:ss") {
-    const d = this.toDate();
-    const monthsShort = [
-      "Jan",
-      "Feb",
-      "Mar",
-      "Apr",
-      "May",
-      "Jun",
-      "Jul",
-      "Aug",
-      "Sep",
-      "Oct",
-      "Nov",
-      "Dec"
-    ];
-    const monthsLong = [
-      "January",
-      "February",
-      "March",
-      "April",
-      "May",
-      "June",
-      "July",
-      "August",
-      "September",
-      "October",
-      "November",
-      "December"
-    ];
-    const hours = d.getHours();
-    const hours12 = hours % 12 === 0 ? 12 : hours % 12;
-    const ampm = hours < 12 ? "AM" : "PM";
-    const map = {
-      dd: String(d.getDate()).padStart(2, "0"),
-      MM: String(d.getMonth() + 1).padStart(2, "0"),
-      yyyy: d.getFullYear(),
-      HH: String(d.getHours()).padStart(2, "0"),
-      mm: String(d.getMinutes()).padStart(2, "0"),
-      ss: String(d.getSeconds()).padStart(2, "0"),
-      SSS: String(d.getMilliseconds()).padStart(3, "0"),
-      MMM: monthsShort[d.getMonth()],
-      MMMM: monthsLong[d.getMonth()],
-      a: ampm.toLowerCase(),
-      // am/pm
-      A: ampm
-      // AM/PM
-    };
-    return pattern.replace(
-      /MMMM|MMM|dd|MM|yyyy|HH|mm|ss|SSS|a|A/g,
-      (match) => String(map[match])
-    );
-  }
-  compare(other) {
-    if (this.seconds !== other.seconds) {
-      return this.seconds - other.seconds;
-    }
-    return this.nanoseconds - other.nanoseconds;
-  }
-  relative(fmt = "dd-MM-yyyy HH:mm:ss") {
-    const now = Date.now();
-    const diff = now - this.toMillis();
-    const sec = Math.floor(diff / 1e3);
-    if (sec < 60)
-      return `${sec}s ago`;
-    const min = Math.floor(sec / 60);
-    if (min < 60)
-      return `${min}m ago`;
-    const hrs = Math.floor(min / 60);
-    if (hrs < 24)
-      return `${hrs}h ago`;
-    const days = Math.floor(hrs / 24);
-    if (days < 3)
-      return `${days}d ago`;
-    return this.format(fmt);
-  }
-  add({
-    seconds = 0,
-    minutes = 0,
-    hours = 0,
-    days = 0
-  }) {
-    const totalMs = seconds * 1e3 + minutes * 6e4 + hours * 36e5 + days * 864e5;
-    return _Timestamp.fromMillis(this.toMillis() + totalMs);
-  }
-  weekdayName() {
-    return ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][this.toDate().getDay()];
-  }
-  toJSON() {
-    return {
-      _type: "timestamp",
-      seconds: this.seconds,
-      nanoseconds: this.nanoseconds
-    };
-  }
-  toString() {
-    return this.format("yyyy-MM-dd HH:mm:ss");
-  }
-};
-
-// src/database/ArraySnapshot.ts
-var ArraySnapshot = class _ArraySnapshot {
-  constructor(id = "", index, data, dt) {
-    this.data = data;
-    this.id = id;
-    this.dt = dt ?? Timestamp.now();
-  }
-  static fromMap(map) {
-    const index = map.index ?? map.index ?? -1;
-    const id = map.id ?? map._id ?? "";
-    const document2 = map.data ?? map.document ?? map;
-    return new _ArraySnapshot(id, index, document2);
-  }
-  toMap() {
-    return {
-      id: this.id ?? "",
-      data: this.data,
-      dt: this.dt
-    };
-  }
-};
-
-// src/database/Array.ts
-var Array2 = class {
-  constructor(app, collection, key, id) {
-    this.app = app;
-    this.collection = collection;
-    this.key = key;
-    this.docID = id;
-    this.persistence = app.offline().persistence;
-    this.syncEngine = app.offline().syncEngine;
-    this.localStore = app.offline().localStore;
-  }
-  /** 
-   * Get current array elements (offline-first: prefers local cache)
-   */
-  async show() {
-    if (this.persistence) {
-      const doc = await this.persistence.getDoc(this.collection, this.docID);
-      if (doc?.exists && !doc.deleted) {
-        const arrayData = doc.data[this.key] || [];
-        return arrayData.map((item) => ArraySnapshot.fromMap(item));
-      }
-    }
-    if (typeof navigator === "undefined" || navigator.onLine) {
-      this.refreshFromRemote().catch(() => {
-      });
-    }
-    return [];
-  }
-  async refreshFromRemote() {
-    try {
-      const res = await new HttpsRequest({
-        method: "POST" /* POST */,
-        endpoint: `${this.app.getBaseUrl()}/db/array/show`,
-        headers: { authorization: this.app.getConfig().token, "x-project": this.app.getConfig().project },
-        body: {
-          collection: this.collection,
-          document: this.docID,
-          array: this.key
-        }
-      }).sendRequest();
-      if (!res?.success || !globalThis.Array.isArray(res.documents)) {
-        return [];
-      }
-      const snapshots = res.documents.filter((d) => d != null).map((d) => ArraySnapshot.fromMap(d));
-      if (this.persistence) {
-        const currentDoc = await this.persistence.getDoc(this.collection, this.docID);
-        if (currentDoc) {
-          await this.persistence.upsertDoc({
-            ...currentDoc,
-            data: { ...currentDoc.data, [this.key]: res.documents },
-            pending: 0,
-            status: "synced",
-            lastSyncedAt: Date.now()
-          });
-        }
-      }
-      return snapshots;
-    } catch {
-      return [];
-    }
-  }
-  async push(data, id) {
-    const payload = {
-      data,
-      id: id || this.persistence?.createLocalId?.() || void 0,
-      dt: Timestamp.now()
-    };
-    if (this.persistence) {
-      await this.persistence.enqueueMutation({
-        mutationId: this.persistence.createMutationId(),
-        collection: this.collection,
-        documentId: this.docID,
-        type: "array_push",
-        // custom type
-        payload: { arrayKey: this.key, ...payload }
-      });
-      this.syncEngine?.flush().catch(console.error);
-      const doc = await this.persistence.getDoc(this.collection, this.docID);
-      if (doc) {
-        const updatedArray = [...doc.data[this.key] || [], payload];
-        const snap = ArraySnapshot.fromMap(payload);
-        this.localStore?.emitDocument(
-          this.collection,
-          this.docID,
-          DocumentSnapshot.fromMap({ ...doc.data, [this.key]: updatedArray }),
-          "update"
-        );
-      }
-      return ArraySnapshot.fromMap(payload);
-    }
-    const res = await new HttpsRequest({
-      method: "POST" /* POST */,
-      endpoint: `${this.app.getBaseUrl()}/db/array/push`,
-      headers: { authorization: this.app.getConfig().token, "x-project": this.app.getConfig().project },
-      body: {
-        collection: this.collection,
-        document: this.docID,
-        array: this.key,
-        ...payload
-      }
-    }).sendRequest();
-    return res?.success ? ArraySnapshot.fromMap(res.document) : null;
-  }
-  // Similar pattern for update, insert, remove, get...
-  // (I'll show one more as example; apply the same logic to the rest)
-  async update(position, data, id) {
-    if (this.persistence) {
-      await this.persistence.enqueueMutation({
-        mutationId: this.persistence.createMutationId(),
-        collection: this.collection,
-        documentId: this.docID,
-        type: "array_update",
-        payload: { arrayKey: this.key, position, data, id }
-      });
-      this.syncEngine?.flush().catch(console.error);
-      return ArraySnapshot.fromMap({ ...data, id });
-    }
-    const res = await new HttpsRequest({
-      method: "POST" /* POST */,
-      endpoint: `${this.app.getBaseUrl()}/db/array/update`,
-      headers: { authorization: this.app.getConfig().token, "x-project": this.app.getConfig().project },
-      body: {
-        collection: this.collection,
-        document: this.docID,
-        array: this.key,
-        position,
-        data,
-        id
-      }
-    }).sendRequest();
-    return res?.success ? ArraySnapshot.fromMap(res.document) : null;
-  }
-  // TODO: Implement insert(), get(), remove() using the exact same offline pattern as push/update
-  async insert(position, data, id) {
-    return null;
-  }
-  async get(position) {
-    return null;
-  }
-  async remove(position) {
-    return null;
-  }
-};
-
 // src/utils/documentNomalizer.ts
 function normalizePayload(payload) {
   const raw = payload?.document ?? payload?.data ?? payload;
@@ -689,11 +411,8 @@ function validateDocumentData(data, operation) {
   if (data === null || data === void 0) {
     throw new Error(`${operation}: data cannot be null or undefined`);
   }
-  if (typeof data !== "object") {
-    throw new Error(`${operation}: data must be an object`);
-  }
-  if (data instanceof Array2) {
-    throw new Error(`${operation}: data cannot be an array`);
+  if (typeof data !== "object" || Array.isArray(data)) {
+    throw new Error(`${operation}: data must be a plain object`);
   }
   const reservedFields = ["id", "_id", "_createdAt", "_updatedAt", "_deleted"];
   for (const field of reservedFields) {
@@ -701,18 +420,18 @@ function validateDocumentData(data, operation) {
       throw new Error(`${operation}: '${field}' is a reserved field and cannot be set manually`);
     }
   }
-  const dataSize = JSON.stringify(data).length;
-  if (dataSize > 1024 * 1024) {
-    throw new Error(`${operation}: document size (${Math.round(dataSize / 1024)}KB) exceeds maximum allowed size (1MB)`);
-  }
   try {
-    JSON.stringify(data);
+    const size = JSON.stringify(data).length;
+    if (size > 1024 * 1024) {
+      throw new Error(`${operation}: document too large (max 1MB)`);
+    }
   } catch {
     throw new Error(`${operation}: data contains circular references`);
   }
 }
 var DocumentRef = class {
   constructor(app, collection, id) {
+    this._isUpdating = false;
     this.app = app;
     this.collection = collection;
     this.id = id;
@@ -720,58 +439,60 @@ var DocumentRef = class {
     this.syncEngine = app.offline().syncEngine;
     this.localStore = app.offline().localStore;
   }
+  // ====================== GET ======================
   async get() {
     if (this.persistence) {
       try {
         const localSnap = await this.persistence.getDocSnapshot(this.collection, this.id);
         if (localSnap)
-          return localSnap;
-        return null;
-      } catch (error) {
-        console.error("[EdmaxLabs] Error reading from cache:", error);
-      }
-    }
-    return await this.app.getDatabase.collection(this.collection).doc(this.id).get();
-  }
-  async set(data) {
-    validateDocumentData(data, "DocumentRef.set");
-    if (!this.persistence) {
-      const res = await new HttpsRequest({
-        method: "POST" /* POST */,
-        endpoint: `${this.app.getBaseUrl()}/db/create`,
-        headers: { authorization: this.app.getConfig().token, "x-project": this.app.getConfig().project },
-        body: { collection: this.collection, data: { ...data, id: this.id } }
-      }).sendRequest();
-      return res?.success ? DocumentSnapshot.fromMap(data) : null;
-    }
-    const updated = await this.persistence.upsertDoc({
-      collection: this.collection,
-      id: this.id,
-      data: { ...data, id: this.id },
-      exists: true,
-      deleted: false,
-      pending: 1,
-      localOnly: false,
-      status: "pending"
-    });
-    await this.persistence.enqueueMutation({
-      mutationId: this.persistence.createMutationId(),
-      collection: this.collection,
-      documentId: this.id,
-      type: "insert",
-      // or "create" if you want to distinguish truly new docs
-      payload: data
-    });
-    const snap = DocumentSnapshot.fromMap(updated.data);
-    this.localStore?.emitDocument(this.collection, this.id, snap, "update");
-    const currentCollection = await this.persistence.getCollectionSnapshots(this.collection);
-    this.localStore?.emitCollection(this.collection, currentCollection, "update", this.id);
-    this.syncEngine?.flush().catch(console.error);
-    return snap;
+          return localSnap;
+      } catch (error) {
+        console.error("[EdmaxLabs] Cache read error:", error);
+      }
+    }
+    try {
+      const res = await new HttpsRequest({
+        method: "POST" /* POST */,
+        endpoint: `${this.app.getBaseUrl()}/db/read`,
+        headers: {
+          authorization: this.app.getConfig().token,
+          "x-project": this.app.getConfig().project
+        },
+        body: {
+          collection: this.collection,
+          id: this.id,
+          single: true
+        }
+      }).sendRequest();
+      if (!res?.success || !res.document)
+        return null;
+      return DocumentSnapshot.fromMap(res.document);
+    } catch (error) {
+      console.error(`[DocumentRef] get(${this.collection}/${this.id}) failed:`, error);
+      return null;
+    }
   }
+  // ====================== UPDATE ======================
   async update(data) {
-    validateDocumentData(data, "DocumentRef.update");
-    if (this.persistence) {
+    if (this._isUpdating) {
+      console.warn(`[DocumentRef] update recursion blocked on ${this.collection}/${this.id}`);
+      return null;
+    }
+    this._isUpdating = true;
+    try {
+      validateDocumentData(data, "DocumentRef.update");
+      if (!this.persistence) {
+        const res = await new HttpsRequest({
+          method: "POST" /* POST */,
+          endpoint: `${this.app.getBaseUrl()}/db/update`,
+          headers: {
+            authorization: this.app.getConfig().token,
+            "x-project": this.app.getConfig().project
+          },
+          body: { collection: this.collection, id: this.id, data }
+        }).sendRequest();
+        return res?.success ? DocumentSnapshot.fromMap({ ...data, id: this.id }) : null;
+      }
       const old = await this.persistence.getDoc(this.collection, this.id);
       if (!old || old.deleted)
         return null;
@@ -801,9 +522,49 @@ var DocumentRef = class {
       this.localStore?.notifyCollectionChanged(this.collection, this.id, "update");
       this.syncEngine?.flush().catch(console.error);
       return snap;
+    } finally {
+      this._isUpdating = false;
+    }
+  }
+  // ====================== SET ======================
+  async set(data) {
+    validateDocumentData(data, "DocumentRef.set");
+    if (!this.persistence) {
+      const res = await new HttpsRequest({
+        method: "POST" /* POST */,
+        endpoint: `${this.app.getBaseUrl()}/db/create`,
+        headers: {
+          authorization: this.app.getConfig().token,
+          "x-project": this.app.getConfig().project
+        },
+        body: { collection: this.collection, data: { ...data, id: this.id } }
+      }).sendRequest();
+      return res?.success ? DocumentSnapshot.fromMap({ ...data, id: this.id }) : null;
     }
-    return await this.app.getDatabase.collection(this.collection).doc(this.id).update(data);
+    const updated = await this.persistence.upsertDoc({
+      collection: this.collection,
+      id: this.id,
+      data: { ...data, id: this.id },
+      exists: true,
+      deleted: false,
+      pending: 1,
+      localOnly: false,
+      status: "pending"
+    });
+    await this.persistence.enqueueMutation({
+      mutationId: this.persistence.createMutationId(),
+      collection: this.collection,
+      documentId: this.id,
+      type: "insert",
+      payload: data
+    });
+    const snap = DocumentSnapshot.fromMap(updated.data);
+    this.localStore?.emitDocument(this.collection, this.id, snap, "update");
+    this.localStore?.notifyCollectionChanged(this.collection, this.id, "update");
+    this.syncEngine?.flush().catch(console.error);
+    return snap;
   }
+  // ====================== DELETE ======================
   async delete() {
     if (this.persistence) {
       await this.persistence.markDeleted(this.collection, this.id, 1);
@@ -819,19 +580,22 @@ var DocumentRef = class {
       this.syncEngine?.flush().catch(console.error);
       return true;
     }
-    return await this.app.getDatabase.collection(this.collection).doc(this.id).delete();
+    const res = await new HttpsRequest({
+      method: "POST" /* POST */,
+      endpoint: `${this.app.getBaseUrl()}/db/delete`,
+      headers: {
+        authorization: this.app.getConfig().token,
+        "x-project": this.app.getConfig().project
+      },
+      body: { collection: this.collection, id: this.id }
+    }).sendRequest();
+    return !!res?.success;
   }
-  // array(key: string): Array {
-  //   return new Array(this.app, this.collection, key, this.id);
-  // }
+  // ====================== SNAPSHOT ======================
   onSnapshot(callback) {
-    if (this.app.offline().persistence && this.app.offline().localStore && this.app.offline().realtimeBridge) {
+    if (this.persistence && this.localStore && this.app.offline().realtimeBridge) {
       this.app.offline().realtimeBridge?.watchDocument(this.collection, this.id);
-      return this.app.offline().localStore?.subscribeToDocument(
-        this.collection,
-        this.id,
-        callback
-      ) || (() => {
+      return this.localStore.subscribeToDocument(this.collection, this.id, callback) || (() => {
       });
     }
     return this.app.rtdb().subscribeToDocumentRaw(this.collection, this.id, (snapshot, change) => {
@@ -1059,15 +823,42 @@ var CollectionRef = class {
       }
       return local;
     }
-    ;
-    return await this.app.getDatabase.collection(this.collection).get();
+    try {
+      const res = await new HttpsRequest({
+        method: "POST" /* POST */,
+        endpoint: `${this.app.getBaseUrl()}/db/read`,
+        headers: {
+          authorization: this.app.getConfig().token,
+          "x-project": this.app.getConfig().project
+        },
+        body: {
+          collection: this.collection,
+          filter: {}
+        }
+      }).sendRequest();
+      if (!res?.success || !Array.isArray(res.documents)) {
+        return [];
+      }
+      return res.documents.map((d) => {
+        delete d.token;
+        d.id = d.id ?? d._id;
+        delete d._id;
+        return DocumentSnapshot.fromMap(d);
+      });
+    } catch (error) {
+      console.error("[EdmaxLabs] Collection get failed:", error);
+      return [];
+    }
   }
   async refreshFromRemote() {
     try {
       const res = await new HttpsRequest({
         method: "POST" /* POST */,
         endpoint: `${this.app.getBaseUrl()}/db/read`,
-        headers: { authorization: this.app.getConfig().token, "x-project": this.app.getConfig().project },
+        headers: {
+          authorization: this.app.getConfig().token,
+          "x-project": this.app.getConfig().project
+        },
         body: {
           collection: this.collection,
           filter: {}
@@ -1093,7 +884,8 @@ var CollectionRef = class {
         delete d._id;
         return DocumentSnapshot.fromMap(d);
       });
-    } catch {
+    } catch (error) {
+      console.error("[EdmaxLabs] refreshFromRemote failed:", error);
       return [];
     }
   }
@@ -1123,13 +915,24 @@ var CollectionRef = class {
       this.syncEngine?.flush().catch(console.error);
       return snap;
     }
-    ;
-    return await this.app.getDatabase.collection(this.collection).add(data);
+    const res = await new HttpsRequest({
+      method: "POST" /* POST */,
+      endpoint: `${this.app.getBaseUrl()}/db/create`,
+      headers: {
+        authorization: this.app.getConfig().token,
+        "x-project": this.app.getConfig().project
+      },
+      body: { collection: this.collection, data: { ...data, id: "" } }
+      // server will generate id
+    }).sendRequest();
+    if (!res?.success || !res.document)
+      return null;
+    return DocumentSnapshot.fromMap(res.document);
   }
   onSnapshot(callback) {
-    if (this.app.offline().persistence) {
+    if (this.persistence && this.localStore && this.app.offline().realtimeBridge) {
       this.app.offline().realtimeBridge?.watchCollection(this.collection);
-      return this.app.offline().localStore?.subscribeToCollection(this.collection, callback) ?? (() => {
+      return this.localStore.subscribeToCollection(this.collection, callback) ?? (() => {
       });
     }
     return this.app.rtdb().subscribeToCollectionRaw(this.collection, (payload, changes) => {
@@ -2722,6 +2525,164 @@ var _EdmaxLabs = class _EdmaxLabs {
 _EdmaxLabs.instance = null;
 var EdmaxLabs = _EdmaxLabs;
 
+// src/database/Timestamp.ts
+var Timestamp = class _Timestamp {
+  constructor(seconds, nanoseconds = 0) {
+    this.seconds = seconds;
+    this.nanoseconds = nanoseconds;
+  }
+  static now() {
+    return _Timestamp.fromMillis(Date.now());
+  }
+  static fromDate(date) {
+    return new _Timestamp(
+      Math.floor(date.getTime() / 1e3),
+      date.getTime() % 1e3 * 1e6
+    );
+  }
+  static fromMillis(ms) {
+    return new _Timestamp(Math.floor(ms / 1e3), ms % 1e3 * 1e6);
+  }
+  static fromMongo(dateObj) {
+    return _Timestamp.fromMillis(dateObj.getTime());
+  }
+  static fromJSON(obj) {
+    return new _Timestamp(obj.seconds, obj.nanoseconds);
+  }
+  toDate() {
+    return new Date(this.toMillis());
+  }
+  toMillis() {
+    return this.seconds * 1e3 + Math.floor(this.nanoseconds / 1e6);
+  }
+  sinceEpoch() {
+    return this.seconds;
+  }
+  toMongo() {
+    return new Date(this.toMillis());
+  }
+  format(pattern = "dd-MM-yyyy HH:mm:ss") {
+    const d = this.toDate();
+    const monthsShort = [
+      "Jan",
+      "Feb",
+      "Mar",
+      "Apr",
+      "May",
+      "Jun",
+      "Jul",
+      "Aug",
+      "Sep",
+      "Oct",
+      "Nov",
+      "Dec"
+    ];
+    const monthsLong = [
+      "January",
+      "February",
+      "March",
+      "April",
+      "May",
+      "June",
+      "July",
+      "August",
+      "September",
+      "October",
+      "November",
+      "December"
+    ];
+    const hours = d.getHours();
+    const hours12 = hours % 12 === 0 ? 12 : hours % 12;
+    const ampm = hours < 12 ? "AM" : "PM";
+    const map = {
+      dd: String(d.getDate()).padStart(2, "0"),
+      MM: String(d.getMonth() + 1).padStart(2, "0"),
+      yyyy: d.getFullYear(),
+      HH: String(d.getHours()).padStart(2, "0"),
+      mm: String(d.getMinutes()).padStart(2, "0"),
+      ss: String(d.getSeconds()).padStart(2, "0"),
+      SSS: String(d.getMilliseconds()).padStart(3, "0"),
+      MMM: monthsShort[d.getMonth()],
+      MMMM: monthsLong[d.getMonth()],
+      a: ampm.toLowerCase(),
+      // am/pm
+      A: ampm
+      // AM/PM
+    };
+    return pattern.replace(
+      /MMMM|MMM|dd|MM|yyyy|HH|mm|ss|SSS|a|A/g,
+      (match) => String(map[match])
+    );
+  }
+  compare(other) {
+    if (this.seconds !== other.seconds) {
+      return this.seconds - other.seconds;
+    }
+    return this.nanoseconds - other.nanoseconds;
+  }
+  relative(fmt = "dd-MM-yyyy HH:mm:ss") {
+    const now = Date.now();
+    const diff = now - this.toMillis();
+    const sec = Math.floor(diff / 1e3);
+    if (sec < 60)
+      return `${sec}s ago`;
+    const min = Math.floor(sec / 60);
+    if (min < 60)
+      return `${min}m ago`;
+    const hrs = Math.floor(min / 60);
+    if (hrs < 24)
+      return `${hrs}h ago`;
+    const days = Math.floor(hrs / 24);
+    if (days < 3)
+      return `${days}d ago`;
+    return this.format(fmt);
+  }
+  add({
+    seconds = 0,
+    minutes = 0,
+    hours = 0,
+    days = 0
+  }) {
+    const totalMs = seconds * 1e3 + minutes * 6e4 + hours * 36e5 + days * 864e5;
+    return _Timestamp.fromMillis(this.toMillis() + totalMs);
+  }
+  weekdayName() {
+    return ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][this.toDate().getDay()];
+  }
+  toJSON() {
+    return {
+      _type: "timestamp",
+      seconds: this.seconds,
+      nanoseconds: this.nanoseconds
+    };
+  }
+  toString() {
+    return this.format("yyyy-MM-dd HH:mm:ss");
+  }
+};
+
+// src/database/ArraySnapshot.ts
+var ArraySnapshot = class _ArraySnapshot {
+  constructor(id = "", index, data, dt) {
+    this.data = data;
+    this.id = id;
+    this.dt = dt ?? Timestamp.now();
+  }
+  static fromMap(map) {
+    const index = map.index ?? map.index ?? -1;
+    const id = map.id ?? map._id ?? "";
+    const document2 = map.data ?? map.document ?? map;
+    return new _ArraySnapshot(id, index, document2);
+  }
+  toMap() {
+    return {
+      id: this.id ?? "",
+      data: this.data,
+      dt: this.dt
+    };
+  }
+};
+
 // src/index.ts
 var src_default = EdmaxLabs;
 // Annotate the CommonJS export names for ESM import in node: