better-auth-firestore 1.2.5 → 1.2.6

package/dist/firebase-adapter.js

@@ -248,6 +248,174 @@ function buildFirestoreWriteData(data, mapper) {
     }
     return { docData, idOverride };
 }
+class TxBuffer {
+    constructor() {
+        this.byPath = new Map();
+    }
+    /** Stage a create. Returns the entry so the caller can read back `appData.id`. */
+    stageCreate(model, ref, docData, appNormalized) {
+        const entry = {
+            op: "create",
+            model,
+            ref,
+            docData: { ...docData },
+            appData: { ...appNormalized, id: ref.id },
+        };
+        this.byPath.set(ref.path, entry);
+        return entry;
+    }
+    /**
+     * Stage an update on `ref`. If a prior entry exists for the same ref —
+     * regardless of whether it was a create or update — merge in place so
+     * the flush emits one combined write. `baseAppData` provides the
+     * pre-update fields needed to build a full app-visible state for
+     * subsequent read overlays.
+     */
+    stageUpdate(model, ref, updateDocData, updateAppData, baseAppData) {
+        const existing = this.byPath.get(ref.path);
+        if (existing) {
+            Object.assign(existing.docData, updateDocData);
+            Object.assign(existing.appData, updateAppData);
+            return existing;
+        }
+        const entry = {
+            op: "update",
+            model,
+            ref,
+            docData: { ...updateDocData },
+            appData: { ...baseAppData, ...updateAppData, id: ref.id },
+        };
+        this.byPath.set(ref.path, entry);
+        return entry;
+    }
+    /** First buffered create for `model` whose appData satisfies `where`. */
+    findCreateMatching(model, where) {
+        for (const entry of this.byPath.values()) {
+            if (entry.op !== "create" || entry.model !== model)
+                continue;
+            if (matchesWhere(entry.appData, where))
+                return entry;
+        }
+        return undefined;
+    }
+    /** Buffered entry (create or update) for a specific ref path, if any. */
+    getByPath(refPath) {
+        return this.byPath.get(refPath);
+    }
+    /** Replay every staged write onto the transaction in insertion order. */
+    flush(transaction) {
+        for (const entry of this.byPath.values()) {
+            if (entry.op === "create")
+                transaction.set(entry.ref, entry.docData);
+            else
+                transaction.update(entry.ref, entry.docData);
+        }
+    }
+}
+/**
+ * Evaluates a where clause against an in-memory app-side doc. AND-within-
+ * group, OR-between-groups (a new group starts at every `connector: "OR"`).
+ * Unknown operators fall back to equality — see TxBuffer header for the
+ * supported set.
+ */
+function matchesWhere(appData, where) {
+    if (!where || where.length === 0)
+        return true;
+    const groups = [];
+    let current = [];
+    for (const cond of where) {
+        if (cond.connector === "OR" && current.length > 0) {
+            groups.push(current);
+            current = [cond];
+        }
+        else {
+            current.push(cond);
+        }
+    }
+    if (current.length > 0)
+        groups.push(current);
+    return groups.some((group) => group.every((cond) => matchesCondition(appData, cond)));
+}
+function matchesCondition(appData, cond) {
+    const val = appData[cond.field];
+    const op = (cond.operator || "eq");
+    switch (op) {
+        case "eq":
+        case "==":
+            return val === cond.value;
+        case "ne":
+        case "!=":
+            return val !== cond.value;
+        case "in":
+            return Array.isArray(cond.value)
+                ? cond.value.includes(val)
+                : val === cond.value;
+        case "notIn":
+        case "not_in":
+            return Array.isArray(cond.value)
+                ? !cond.value.includes(val)
+                : val !== cond.value;
+        case "gt":
+            return val > cond.value;
+        case "gte":
+            return val >= cond.value;
+        case "lt":
+            return val < cond.value;
+        case "lte":
+            return val <= cond.value;
+        case "contains":
+        case "array-contains":
+            if (Array.isArray(val))
+                return val.includes(cond.value);
+            if (typeof val === "string")
+                return val.includes(String(cond.value));
+            return false;
+        case "startsWith":
+        case "starts-with":
+        case "starts_with":
+            return typeof val === "string" && val.startsWith(String(cond.value));
+        case "endsWith":
+        case "ends-with":
+        case "ends_with":
+            return typeof val === "string" && val.endsWith(String(cond.value));
+        default:
+            return val === cond.value;
+    }
+}
+/**
+ * Look up a single doc inside a transaction, mirroring the non-tx
+ * findOne/update path. Special-cases `id eq value` to use `col.doc(id)`
+ * because Firestore document IDs are metadata, not fields — they can't
+ * be queried with `.where("id", ...)`. Returns undefined when nothing
+ * matches.
+ */
+async function lookupTxDoc(transaction, col, where, mapper) {
+    if (where &&
+        where.length === 1 &&
+        where[0]?.field === "id" &&
+        (where[0]?.operator === "eq" || !where[0]?.operator)) {
+        const docRef = col.doc(where[0].value);
+        const snap = await transaction.get(docRef);
+        return snap.exists ? snap : undefined;
+    }
+    for (const whereClause of getChunkedWhereClauses(where)) {
+        const q = applyWhereClause(col, whereClause, mapper);
+        const snap = await transaction.get(q.limit(1));
+        if (snap.docs[0])
+            return snap.docs[0];
+    }
+    return undefined;
+}
+/** Convert a Firestore document body (db-side keys, Timestamps) to app shape. */
+function dbDataToAppData(data, mapper) {
+    const result = {};
+    for (const [k, v] of Object.entries(data)) {
+        if (k === "__name__")
+            continue;
+        result[mapper.fromDb(k)] = convertTimestamp(v);
+    }
+    return result;
+}
 export const firestoreAdapter = (config = {}) => {
     const db = resolveDb(config);
     const { namingStrategy = "default", collections: collectionsOverride = {}, debugLogs = false, } = (config && config.collection
@@ -267,62 +435,69 @@ export const firestoreAdapter = (config = {}) => {
             debugLogs,
             transaction: async (run) => {
                 return await db.runTransaction(async (transaction) => {
+                    const buffer = new TxBuffer();
                     const txAdapter = {
                         create: async ({ model, data }) => {
                             const col = getCollectionRef(db, model, collections);
                             const normalizedData = normalizeWriteData(model, data);
                             const { docData, idOverride } = buildFirestoreWriteData(normalizedData, mapper);
                             const ref = idOverride ? col.doc(idOverride) : col.doc();
-                            transaction.set(ref, docData);
-                            return { ...normalizedData, id: ref.id };
+                            const entry = buffer.stageCreate(model, ref, docData, normalizedData);
+                            return { ...entry.appData };
                         },
                         update: async ({ model, where, update }) => {
                             const col = getCollectionRef(db, model, collections);
-                            let doc;
-                            for (const whereClause of getChunkedWhereClauses(where)) {
-                                const q = applyWhereClause(col, whereClause, mapper);
-                                const snap = await transaction.get(q.limit(1));
-                                doc = snap.docs[0];
-                                if (doc)
-                                    break;
+                            const normalizedUpdate = normalizeWriteData(model, update);
+                            const { docData: updateData } = buildFirestoreWriteData(normalizedUpdate, mapper);
+                            // 1. Overlay: target may already be staged as a create in
+                            //    this same transaction. Mutate it in place so the flush
+                            //    emits one combined `set`.
+                            const stagedCreate = buffer.findCreateMatching(model, where);
+                            if (stagedCreate) {
+                                Object.assign(stagedCreate.docData, updateData);
+                                Object.assign(stagedCreate.appData, normalizedUpdate);
+                                return { ...stagedCreate.appData };
                             }
+                            // 2. Otherwise read from Firestore (still safe — no writes
+                            //    have been flushed yet) to locate the target doc.
+                            const doc = await lookupTxDoc(transaction, col, where, mapper);
                             if (!doc)
                                 return null;
-                            const normalizedUpdate = normalizeWriteData(model, update);
-                            const { docData: updateData } = buildFirestoreWriteData(normalizedUpdate, mapper);
-                            transaction.update(doc.ref, updateData);
-                            const existing = doc.data();
-                            const result = { id: doc.id };
+                            // 3. Same ref may already have an update staged; merge.
+                            const existing = buffer.getByPath(doc.ref.path);
                             if (existing) {
-                                for (const [k, v] of Object.entries(existing)) {
-                                    result[mapper.fromDb(k)] = v;
-                                }
+                                Object.assign(existing.docData, updateData);
+                                Object.assign(existing.appData, normalizedUpdate);
+                                return { ...existing.appData };
                             }
-                            return { ...result, ...normalizedUpdate };
+                            // 4. Stage a fresh update.
+                            const baseAppData = dbDataToAppData(doc.data() ?? {}, mapper);
+                            const entry = buffer.stageUpdate(model, doc.ref, updateData, normalizedUpdate, baseAppData);
+                            return { ...entry.appData };
                         },
                         findOne: async ({ model, where }) => {
                             const col = getCollectionRef(db, model, collections);
-                            let doc;
-                            for (const whereClause of getChunkedWhereClauses(where)) {
-                                const q = applyWhereClause(col, whereClause, mapper);
-                                const snap = await transaction.get(q.limit(1));
-                                doc = snap.docs[0];
-                                if (doc)
-                                    break;
-                            }
+                            // 1. Overlay: return any matching staged create directly.
+                            const stagedCreate = buffer.findCreateMatching(model, where);
+                            if (stagedCreate)
+                                return { ...stagedCreate.appData };
+                            // 2. Real read.
+                            const doc = await lookupTxDoc(transaction, col, where, mapper);
                             if (!doc)
                                 return null;
+                            // 3. Layer any pending update on top of the snapshot.
+                            const staged = buffer.getByPath(doc.ref.path);
+                            if (staged)
+                                return { ...staged.appData };
                             const data = doc.data();
                             if (!data)
                                 return null;
-                            const result = { id: doc.id };
-                            for (const [k, v] of Object.entries(data)) {
-                                result[mapper.fromDb(k)] = convertTimestamp(v);
-                            }
-                            return result;
+                            return { id: doc.id, ...dbDataToAppData(data, mapper) };
                         },
                     };
-                    return run(txAdapter);
+                    const result = await run(txAdapter);
+                    buffer.flush(transaction);
+                    return result;
                 });
             },
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "better-auth-firestore",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "private": false,
   "description": "Firestore adapter for Better Auth (Firebase Admin SDK)",
   "author": "Slava Yultyyev <yultyyev@gmail.com>",