emberflow 1.4.3 → 1.4.5

package/lib/index.js

@@ -56,6 +56,7 @@ const firestore_1 = require("firebase-functions/v2/firestore");
 const https_1 = require("firebase-functions/v2/https");
 const functions_1 = require("./utils/functions");
 var FieldValue = firebase_admin_1.firestore.FieldValue;
+const transaction_1 = require("./utils/transaction");
 exports.functionsConfig = {};
 exports.SUBMIT_FORM_TOPIC_NAME = "submit-form-queue";
 exports.VIEW_LOGICS_TOPIC_NAME = "view-logics-queue";
@@ -242,92 +243,104 @@ async function onFormSubmit(event) {
             await formRef.update({ "@status": "validation-error", "@messages": validationResult });
             return;
         }
-        const document = (await exports.db.doc(docPath).get()).data() || {};
-        const formModifiedFields = (0, index_utils_1.getFormModifiedFields)(form, document);
-        let user;
-        if (!isServiceAccount) {
-            user = (await exports.db.doc(`users/${userId}`).get()).data();
-            if (!user) {
-                const message = "No user data found";
-                console.warn(message);
-                await formRef.update({ "@status": "error", "@messages": message });
-                return;
+        let runStatus = { status: "running", logicResults: [] };
+        let errorMessage = "";
+        const actionRef = exports._mockable.initActionRef(formId);
+        await exports.db.runTransaction(async (txn) => {
+            const docRef = exports.db.doc(docPath);
+            const document = (await txn.get(docRef)).data() || {};
+            const formModifiedFields = (0, index_utils_1.getFormModifiedFields)(form, document);
+            let user;
+            if (!isServiceAccount) {
+                const userRef = exports.db.doc(`users/${userId}`);
+                user = (await txn.get(userRef)).data();
+                if (!user) {
+                    const message = "No user data found";
+                    console.warn(message);
+                    await formRef.update({ "@status": "error", "@messages": message });
+                    return;
+                }
             }
-        }
-        else {
-            user = { "@id": userId };
-        }
-        console.info("Validating Security");
-        const securityFn = (0, index_utils_1.getSecurityFn)(entity);
-        if (securityFn) {
-            const securityFnStart = performance.now();
-            const securityResult = await securityFn(entity, docPath, document, actionType, formModifiedFields, user);
-            const securityFnEnd = performance.now();
-            const securityLogicResult = {
-                name: "securityFn",
-                status: "finished",
-                documents: [],
-                execTime: securityFnEnd - securityFnStart,
-            };
-            logicResults.push(securityLogicResult);
-            if (securityResult.status === "rejected") {
-                console.log(`Security check failed: ${securityResult.message}`);
-                await formRef.update({ "@status": "security-error", "@messages": securityResult.message });
-                return;
+            else {
+                user = { "@id": userId };
             }
-        }
-        // Check for delay
-        console.info("Checking for delay");
-        const delay = form["@delay"];
-        if (delay) {
-            const delayStart = performance.now();
-            const cancelled = await (0, index_utils_1.delayFormSubmissionAndCheckIfCancelled)(delay, formRef);
-            const delayEnd = performance.now();
-            const delayLogicResult = {
-                name: "delayFormSubmission",
+            console.info("Validating Security");
+            const securityFn = (0, index_utils_1.getSecurityFn)(entity);
+            if (securityFn) {
+                const securityFnStart = performance.now();
+                const securityResult = await securityFn(entity, docPath, document, actionType, formModifiedFields, user);
+                const securityFnEnd = performance.now();
+                const securityLogicResult = {
+                    name: "securityFn",
+                    status: "finished",
+                    documents: [],
+                    execTime: securityFnEnd - securityFnStart,
+                };
+                logicResults.push(securityLogicResult);
+                if (securityResult.status === "rejected") {
+                    console.log(`Security check failed: ${securityResult.message}`);
+                    await formRef.update({ "@status": "security-error", "@messages": securityResult.message });
+                    return;
+                }
+            }
+            // Check for delay
+            console.info("Checking for delay");
+            const delay = form["@delay"];
+            if (delay) {
+                const delayStart = performance.now();
+                const cancelled = await (0, index_utils_1.delayFormSubmissionAndCheckIfCancelled)(delay, formRef);
+                const delayEnd = performance.now();
+                const delayLogicResult = {
+                    name: "delayFormSubmission",
+                    status: "finished",
+                    documents: [],
+                    execTime: delayEnd - delayStart,
+                };
+                logicResults.push(delayLogicResult);
+                if (cancelled) {
+                    await formRef.update({ "@status": "cancelled" });
+                    return;
+                }
+            }
+            await formRef.update({ "@status": "processing" });
+            const status = "processing";
+            const timeCreated = exports._mockable.createNowTimestamp();
+            console.info("Creating Action");
+            const eventContext = {
+                id: event.id,
+                uid: userId,
+                formId,
+                docId: entityId,
+                docPath,
+                entity,
+            };
+            const action = {
+                eventContext,
+                actionType,
+                document,
+                status,
+                timeCreated,
+                modifiedFields: formModifiedFields,
+                user,
+            };
+            await formRef.update({ "@status": "submitted" });
+            console.info("Running Business Logics");
+            const businessLogicStart = performance.now();
+            runStatus = await (0, index_utils_1.runBusinessLogics)((0, transaction_1.extractTransactionGetOnly)(txn), action);
+            const businessLogicEnd = performance.now();
+            const businessLogicLogicResult = {
+                name: "runBusinessLogics",
                 status: "finished",
                 documents: [],
-                execTime: delayEnd - delayStart,
+                execTime: businessLogicEnd - businessLogicStart,
             };
-            logicResults.push(delayLogicResult);
-            if (cancelled) {
-                await formRef.update({ "@status": "cancelled" });
-                return;
-            }
-        }
-        await formRef.update({ "@status": "processing" });
-        const status = "processing";
-        const timeCreated = exports._mockable.createNowTimestamp();
-        console.info("Creating Action");
-        const eventContext = {
-            id: event.id,
-            uid: userId,
-            formId,
-            docId: entityId,
-            docPath,
-            entity,
-        };
-        const action = {
-            eventContext,
-            actionType,
-            document,
-            status,
-            timeCreated,
-            modifiedFields: formModifiedFields,
-            user,
-        };
-        const actionRef = exports._mockable.initActionRef(formId);
-        await actionRef.set(action);
-        await formRef.update({ "@status": "submitted" });
-        console.info("Running Business Logics");
-        let errorMessage = "";
-        const businessLogicStart = performance.now();
-        const runStatus = await (0, index_utils_1.runBusinessLogics)(actionRef, action, async (actionRef, logicResults, page) => {
+            logicResults.push(businessLogicLogicResult);
+            await actionRef.set(action);
             async function saveLogicResults() {
-                for (let i = 0; i < logicResults.length; i++) {
-                    const _a = logicResults[i], { documents } = _a, logicResult = __rest(_a, ["documents"]);
+                for (let i = 0; i < runStatus.logicResults.length; i++) {
+                    const _a = runStatus.logicResults[i], { documents } = _a, logicResult = __rest(_a, ["documents"]);
                     const logicResultsRef = actionRef.collection("logicResults")
-                        .doc(`${actionRef.id}-${page}-${i}`);
+                        .doc(`${actionRef.id}-${i}`);
                     await logicResultsRef.set(logicResult);
                     const documentsRef = logicResultsRef.collection("documents");
                     for (let j = 0; j < documents.length; j++) {
@@ -337,228 +350,42 @@ async function onFormSubmit(event) {
             }
             await saveLogicResults();
             function updateErrorMessage() {
-                const errorLogicResults = logicResults.filter((result) => result.status === "error");
+                const errorLogicResults = runStatus.logicResults.filter((result) => result.status === "error");
                 if (errorLogicResults.length > 0) {
                     errorMessage = errorMessage + errorLogicResults.map((result) => result.message).join("\n");
                 }
             }
             updateErrorMessage();
-            async function writeJournalEntriesFirst() {
-                // Gather all logicResultDoc with journalEntries
-                const logicResultDocsWithJournalEntries = logicResults
-                    .map((result) => result.documents).flat()
-                    .filter((logicResultDoc) => logicResultDoc.journalEntries &&
-                    logicResultDoc.action !== "delete");
-                if (logicResultDocsWithJournalEntries.length === 0) {
-                    console.info("No journal entries to write");
-                    return;
-                }
-                const dstPathLogicDocsWithJournalEntriesMap = await (0, index_utils_1.expandConsolidateAndGroupByDstPath)(logicResultDocsWithJournalEntries);
-                for (const [dstPath, logicDocs] of dstPathLogicDocsWithJournalEntriesMap) {
-                    const docId = dstPath.split("/").pop();
-                    if (!docId) {
-                        console.error("Dst path has no docId");
-                        continue;
-                    }
-                    for (const logicDoc of logicDocs) {
-                        const { doc, instructions, journalEntries, action, skipRunViewLogics, } = logicDoc;
-                        if (!journalEntries) {
-                            continue;
-                        }
-                        const accounts = new Set(journalEntries.map((entry) => entry.ledgerEntries).flat()
-                            .map((entry) => entry.account));
-                        if (Object.keys(doc || {}).some((key) => accounts.has(key))) {
-                            console.error("Doc cannot have keys that are the same as account names");
-                            continue;
-                        }
-                        if (Object.keys(instructions || {}).some((key) => accounts.has(key))) {
-                            console.error("Instructions cannot have keys that are the same as account names");
-                            continue;
-                        }
-                        for (let i = 0; i < journalEntries.length; i++) {
-                            const { ledgerEntries, recordEntry, equation, date, } = journalEntries[i];
-                            const consolidatedPerAccount = ledgerEntries
-                                .reduce((acc, entry) => {
-                                const { account } = entry;
-                                if (acc[account]) {
-                                    acc[account].debit += entry.debit;
-                                    acc[account].credit += entry.credit;
-                                }
-                                else {
-                                    acc[account] = {
-                                        debit: entry.debit,
-                                        credit: entry.credit,
-                                    };
-                                }
-                                return acc;
-                            }, {});
-                            // loop through keys of consolidatedPerAccount
-                            const totalCreditDebit = Object.entries(consolidatedPerAccount)
-                                .reduce((acc, [account, { debit, credit }]) => {
-                                return {
-                                    debit: acc.debit + debit,
-                                    credit: acc.credit + credit,
-                                };
-                            }, { debit: 0, credit: 0 });
-                            if (totalCreditDebit.debit !== totalCreditDebit.credit) {
-                                console.error("Debit and credit should be equal");
-                                continue;
-                            }
-                            await exports.db.runTransaction(async (transaction) => {
-                                const docRef = exports.db.doc(dstPath);
-                                const currData = (await transaction.get(docRef)).data();
-                                let instructionsDbValues;
-                                if (instructions) {
-                                    instructionsDbValues = await (0, distribution_1.convertInstructionsToDbValues)(instructions);
-                                }
-                                const finalDoc = Object.assign(Object.assign({}, (doc ? doc : {})), (instructionsDbValues ? instructionsDbValues : {}));
-                                if (currData) {
-                                    transaction.update(docRef, Object.assign(Object.assign({}, finalDoc), { "@forDeletionLater": true }));
-                                }
-                                else {
-                                    transaction.set(docRef, Object.assign(Object.assign({}, finalDoc), { "@forDeletionLater": true }));
-                                }
-                                const [leftSide, ..._] = equation.split("=");
-                                Object.entries(consolidatedPerAccount).forEach(([account, { debit, credit }]) => {
-                                    const increment = leftSide.includes(account) ? debit - credit : credit - debit;
-                                    if (increment === 0) {
-                                        transaction.update(docRef, {
-                                            "@forDeletionLater": FieldValue.delete(),
-                                        });
-                                        return;
-                                    }
-                                    const accountVal = ((currData === null || currData === void 0 ? void 0 : currData[account]) || 0) + increment;
-                                    if (accountVal < 0) {
-                                        throw new Error("Account value cannot be negative");
-                                    }
-                                    finalDoc[account] = accountVal;
-                                    transaction.update(docRef, {
-                                        [account]: accountVal,
-                                        "@forDeletionLater": FieldValue.delete(),
-                                    });
-                                });
-                                if (Object.keys(finalDoc).length > 0 && !skipRunViewLogics &&
-                                    ["create", "merge"].includes(action)) {
-                                    logicDoc.doc = finalDoc;
-                                    await (0, view_logics_1.queueRunViewLogics)(logicDoc);
-                                }
-                                if (recordEntry) {
-                                    for (let j = 0; j < ledgerEntries.length; j++) {
-                                        const { account, debit, credit, description } = ledgerEntries[j];
-                                        const journalEntryId = docId + i;
-                                        const ledgerEntryId = journalEntryId + j;
-                                        const ledgerEntryDoc = Object.assign({ journalEntryId,
-                                            account,
-                                            credit,
-                                            debit,
-                                            equation,
-                                            date }, (description && { description }));
-                                        const entryRef = docRef.collection("@ledgers").doc(ledgerEntryId);
-                                        transaction.set(entryRef, ledgerEntryDoc);
-                                    }
-                                }
-                            });
-                        }
-                    }
-                }
-            }
-            await writeJournalEntriesFirst();
-            async function distributeTransactionalLogicResults() {
-                const transactionalResults = logicResults.filter((result) => result.transactional);
-                if (transactionalResults.length === 0) {
-                    console.info("No transactional logic results to distribute");
-                    return;
-                }
-                // We always distribute transactional results first
-                const transactionalDstPathLogicDocsMap = await (0, index_utils_1.expandConsolidateAndGroupByDstPath)(transactionalResults.map((result) => result.documents).flat().filter((doc) => !doc.journalEntries || doc.journalEntries && doc.action === "delete"));
-                // Write to firestore in one transaction
-                await exports.db.runTransaction(async (transaction) => {
-                    for (const [dstPath, logicDocs] of transactionalDstPathLogicDocsMap) {
-                        for (const logicDoc of logicDocs) {
-                            const docRef = exports.db.doc(dstPath);
-                            const { action } = logicDoc;
-                            if (action === "create") {
-                                transaction.set(docRef, logicDoc.doc);
-                            }
-                            else if (action === "merge") {
-                                transaction.update(docRef, logicDoc.doc);
-                            }
-                            else if (action === "delete") {
-                                transaction.delete(docRef);
-                            }
-                            if (logicDoc.instructions) {
-                                const { updateData, removeData } = await (0, distribution_1.convertInstructionsToDbValues)(logicDoc.instructions);
-                                if (Object.keys(updateData).length > 0) {
-                                    transaction.update(docRef, updateData);
-                                }
-                                if (Object.keys(removeData).length > 0) {
-                                    transaction.update(docRef, removeData);
-                                }
-                            }
-                        }
-                    }
-                });
-            }
-            await distributeTransactionalLogicResults();
-            async function distributeNonTransactionalLogicResults() {
-                const nonTransactionalResults = logicResults.filter((result) => !result.transactional);
-                console.info(`Group logic docs by priority: ${nonTransactionalResults.length}`);
-                const { highPriorityDocs, normalPriorityDocs, lowPriorityDocs } = nonTransactionalResults
-                    .map((result) => result.documents)
-                    .flat()
-                    .filter((doc) => !doc.journalEntries || doc.journalEntries && doc.action === "delete")
-                    .reduce((acc, doc) => {
-                    if (doc.priority === "high") {
-                        acc.highPriorityDocs.push(doc);
-                    }
-                    else if (!doc.priority || doc.priority === "normal") {
-                        acc.normalPriorityDocs.push(doc);
-                    }
-                    else {
-                        acc.lowPriorityDocs.push(doc);
-                    }
-                    return acc;
-                }, {
-                    highPriorityDocs: [],
-                    normalPriorityDocs: [],
-                    lowPriorityDocs: [],
-                });
-                console.info(`Consolidating and Distributing High Priority Logic Results: ${highPriorityDocs.length}`);
-                const highPriorityDstPathLogicDocsMap = await (0, index_utils_1.expandConsolidateAndGroupByDstPath)(highPriorityDocs);
-                const { docsByDocPath: highPriorityDocsByDocPath, otherDocsByDocPath: highPriorityOtherDocsByDocPath, } = (0, index_utils_1.groupDocsByTargetDocPath)(highPriorityDstPathLogicDocsMap, docPath);
-                await (0, index_utils_1.distribute)(highPriorityDocsByDocPath);
-                await (0, index_utils_1.distribute)(highPriorityOtherDocsByDocPath);
-                if (page === 0) {
-                    await formRef.update({ "@status": "finished" });
-                }
-                console.info(`Consolidating and Distributing Normal Priority Logic Results: ${normalPriorityDocs.length}`);
-                const normalPriorityDstPathLogicDocsMap = await (0, index_utils_1.expandConsolidateAndGroupByDstPath)(normalPriorityDocs);
-                const { docsByDocPath: normalPriorityDocsByDocPath, otherDocsByDocPath: normalPriorityOtherDocsByDocPath, } = (0, index_utils_1.groupDocsByTargetDocPath)(normalPriorityDstPathLogicDocsMap, docPath);
-                await (0, index_utils_1.distribute)(normalPriorityDocsByDocPath);
-                await (0, index_utils_1.distributeLater)(normalPriorityOtherDocsByDocPath);
-                console.info(`Consolidating and Distributing Low Priority Logic Results: ${lowPriorityDocs.length}`);
-                const lowPriorityDstPathLogicDocsMap = await (0, index_utils_1.expandConsolidateAndGroupByDstPath)(lowPriorityDocs);
-                const { docsByDocPath: lowPriorityDocsByDocPath, otherDocsByDocPath: lowPriorityOtherDocsByDocPath, } = (0, index_utils_1.groupDocsByTargetDocPath)(lowPriorityDstPathLogicDocsMap, docPath);
-                await (0, index_utils_1.distributeLater)(lowPriorityDocsByDocPath);
-                await (0, index_utils_1.distributeLater)(lowPriorityOtherDocsByDocPath);
-            }
-            await distributeNonTransactionalLogicResults();
+            const distributeTransactionalLogicResultsStart = performance.now();
+            await distributeFnTransactional(txn, runStatus.logicResults);
+            const distributeTransactionalLogicResultsEnd = performance.now();
+            const distributeTransactionalLogicResults = {
+                name: "distributeTransactionalLogicResults",
+                status: "finished",
+                documents: [],
+                execTime: distributeTransactionalLogicResultsEnd - distributeTransactionalLogicResultsStart,
+            };
+            logicResults.push(distributeTransactionalLogicResults);
         });
-        const businessLogicEnd = performance.now();
-        const businessLogicLogicResult = {
-            name: "runBusinessLogics",
+        const distributeNonTransactionalLogicResultsStart = performance.now();
+        await distributeNonTransactionalLogicResults(runStatus.logicResults, docPath);
+        const distributeNonTransactionalLogicResultsEnd = performance.now();
+        const distributeNonTransactionalPerfLogicResults = {
+            name: "distributeNonTransactionalLogicResults",
             status: "finished",
             documents: [],
-            execTime: businessLogicEnd - businessLogicStart,
+            execTime: distributeNonTransactionalLogicResultsEnd - distributeNonTransactionalLogicResultsStart,
         };
-        logicResults.push(businessLogicLogicResult);
-        if (runStatus === "cancel-then-retry") {
-            await formRef.update({ "@status": "cancelled", "@messages": "cancel-then-retry received " +
-                    "from business logic" });
-            return;
-        }
+        logicResults.push(distributeNonTransactionalPerfLogicResults);
+        await formRef.update({ "@status": "finished" });
         const end = performance.now();
         const execTime = end - start;
+        if (errorMessage) {
+            await actionRef.update({ status: "finished-with-error", message: errorMessage, execTime: execTime });
+        }
+        else {
+            await actionRef.update({ status: "finished", execTime: execTime });
+        }
         const onFormSubmitLogicResult = {
             name: "onFormSubmit",
             status: "finished",
@@ -566,12 +393,7 @@ async function onFormSubmit(event) {
             execTime,
         };
         logicResults.push(onFormSubmitLogicResult);
-        if (errorMessage) {
-            await actionRef.update({ status: "finished-with-error", message: errorMessage, execTime: execTime });
-        }
-        else {
-            await actionRef.update({ status: "finished", execTime: execTime });
-        }
+        await index_utils_1._mockable.createMetricExecution(logicResults);
         console.info("Finished");
     }
     catch (error) {
@@ -587,9 +409,202 @@ async function onFormSubmit(event) {
         logicResults.push(onFormSubmitLogicResult);
         await formRef.update({ "@status": "error", "@messages": error, "execTime": execTime });
     }
-    await index_utils_1._mockable.createMetricExecution(logicResults);
 }
 exports.onFormSubmit = onFormSubmit;
+async function distributeNonTransactionalLogicResults(logicResults, docPath) {
+    const nonTransactionalResults = logicResults.filter((result) => !result.transactional);
+    console.info(`Group logic docs by priority: ${nonTransactionalResults.length}`);
+    const { highPriorityDocs, normalPriorityDocs, lowPriorityDocs } = nonTransactionalResults
+        .map((result) => result.documents)
+        .flat()
+        .filter((doc) => !doc.journalEntries || doc.journalEntries && doc.action === "delete")
+        .reduce((acc, doc) => {
+        if (doc.priority === "high") {
+            acc.highPriorityDocs.push(doc);
+        }
+        else if (!doc.priority || doc.priority === "normal") {
+            acc.normalPriorityDocs.push(doc);
+        }
+        else {
+            acc.lowPriorityDocs.push(doc);
+        }
+        return acc;
+    }, {
+        highPriorityDocs: [],
+        normalPriorityDocs: [],
+        lowPriorityDocs: [],
+    });
+    console.info(`Consolidating and Distributing High Priority Logic Results: ${highPriorityDocs.length}`);
+    const highPriorityDstPathLogicDocsMap = await (0, index_utils_1.expandConsolidateAndGroupByDstPath)(highPriorityDocs);
+    const { docsByDocPath: highPriorityDocsByDocPath, otherDocsByDocPath: highPriorityOtherDocsByDocPath, } = (0, index_utils_1.groupDocsByTargetDocPath)(highPriorityDstPathLogicDocsMap, docPath);
+    await (0, index_utils_1.distributeFnNonTransactional)(highPriorityDocsByDocPath);
+    await (0, index_utils_1.distributeFnNonTransactional)(highPriorityOtherDocsByDocPath);
+    console.info(`Consolidating and Distributing Normal Priority Logic Results: ${normalPriorityDocs.length}`);
+    const normalPriorityDstPathLogicDocsMap = await (0, index_utils_1.expandConsolidateAndGroupByDstPath)(normalPriorityDocs);
+    const { docsByDocPath: normalPriorityDocsByDocPath, otherDocsByDocPath: normalPriorityOtherDocsByDocPath, } = (0, index_utils_1.groupDocsByTargetDocPath)(normalPriorityDstPathLogicDocsMap, docPath);
+    await (0, index_utils_1.distributeFnNonTransactional)(normalPriorityDocsByDocPath);
+    await (0, index_utils_1.distributeLater)(normalPriorityOtherDocsByDocPath);
+    console.info(`Consolidating and Distributing Low Priority Logic Results: ${lowPriorityDocs.length}`);
+    const lowPriorityDstPathLogicDocsMap = await (0, index_utils_1.expandConsolidateAndGroupByDstPath)(lowPriorityDocs);
+    const { docsByDocPath: lowPriorityDocsByDocPath, otherDocsByDocPath: lowPriorityOtherDocsByDocPath, } = (0, index_utils_1.groupDocsByTargetDocPath)(lowPriorityDstPathLogicDocsMap, docPath);
+    await (0, index_utils_1.distributeLater)(lowPriorityDocsByDocPath);
+    await (0, index_utils_1.distributeLater)(lowPriorityOtherDocsByDocPath);
+}
+async function distributeFnTransactional(txn, logicResults) {
+    async function writeJournalEntriesFirst() {
+        // Gather all logicResultDoc with journalEntries
+        const logicResultDocsWithJournalEntries = logicResults
+            .map((result) => result.documents).flat()
+            .filter((logicResultDoc) => logicResultDoc.journalEntries &&
+            logicResultDoc.action !== "delete");
+        if (logicResultDocsWithJournalEntries.length === 0) {
+            console.info("No journal entries to write");
+            return;
+        }
+        const dstPathLogicDocsWithJournalEntriesMap = await (0, index_utils_1.expandConsolidateAndGroupByDstPath)(logicResultDocsWithJournalEntries);
+        for (const [dstPath, logicDocs] of dstPathLogicDocsWithJournalEntriesMap) {
+            const docId = dstPath.split("/").pop();
+            if (!docId) {
+                console.error("Dst path has no docId");
+                continue;
+            }
+            for (const logicDoc of logicDocs) {
+                const { doc, instructions, journalEntries, action, skipRunViewLogics, } = logicDoc;
+                if (!journalEntries) {
+                    continue;
+                }
+                const accounts = new Set(journalEntries.map((entry) => entry.ledgerEntries).flat()
+                    .map((entry) => entry.account));
+                if (Object.keys(doc || {}).some((key) => accounts.has(key))) {
+                    console.error("Doc cannot have keys that are the same as account names");
+                    continue;
+                }
+                if (Object.keys(instructions || {}).some((key) => accounts.has(key))) {
+                    console.error("Instructions cannot have keys that are the same as account names");
+                    continue;
+                }
+                for (let i = 0; i < journalEntries.length; i++) {
+                    const { ledgerEntries, recordEntry, equation, date, } = journalEntries[i];
+                    const consolidatedPerAccount = ledgerEntries
+                        .reduce((acc, entry) => {
+                        const { account } = entry;
+                        if (acc[account]) {
+                            acc[account].debit += entry.debit;
+                            acc[account].credit += entry.credit;
+                        }
+                        else {
+                            acc[account] = {
+                                debit: entry.debit,
+                                credit: entry.credit,
+                            };
+                        }
+                        return acc;
+                    }, {});
+                    // loop through keys of consolidatedPerAccount
+                    const totalCreditDebit = Object.entries(consolidatedPerAccount)
+                        .reduce((acc, [account, { debit, credit }]) => {
+                        return {
+                            debit: acc.debit + debit,
+                            credit: acc.credit + credit,
+                        };
+                    }, { debit: 0, credit: 0 });
+                    if (totalCreditDebit.debit !== totalCreditDebit.credit) {
+                        console.error("Debit and credit should be equal");
+                        continue;
+                    }
+                    const docRef = exports.db.doc(dstPath);
+                    const currData = (await txn.get(docRef)).data();
+                    let instructionsDbValues;
+                    if (instructions) {
+                        instructionsDbValues = await (0, distribution_1.convertInstructionsToDbValues)(txn, instructions);
+                    }
+                    const finalDoc = Object.assign(Object.assign({}, (doc ? doc : {})), (instructionsDbValues ? instructionsDbValues : {}));
+                    if (currData) {
+                        txn.update(docRef, Object.assign(Object.assign({}, finalDoc), { "@forDeletionLater": true }));
+                    }
+                    else {
+                        txn.set(docRef, Object.assign(Object.assign({}, finalDoc), { "@forDeletionLater": true }));
+                    }
+                    const [leftSide, ..._] = equation.split("=");
+                    Object.entries(consolidatedPerAccount).forEach(([account, { debit, credit }]) => {
+                        const increment = leftSide.includes(account) ? debit - credit : credit - debit;
+                        if (increment === 0) {
+                            txn.update(docRef, {
+                                "@forDeletionLater": FieldValue.delete(),
+                            });
+                            return;
+                        }
+                        const accountVal = ((currData === null || currData === void 0 ? void 0 : currData[account]) || 0) + increment;
+                        if (accountVal < 0) {
+                            throw new Error("Account value cannot be negative");
+                        }
+                        finalDoc[account] = accountVal;
+                        txn.update(docRef, {
+                            [account]: accountVal,
+                            "@forDeletionLater": FieldValue.delete(),
+                        });
+                    });
+                    if (Object.keys(finalDoc).length > 0 && !skipRunViewLogics &&
+                        ["create", "merge"].includes(action)) {
+                        logicDoc.doc = finalDoc;
+                        await (0, view_logics_1.queueRunViewLogics)(logicDoc);
+                    }
+                    if (recordEntry) {
+                        for (let j = 0; j < ledgerEntries.length; j++) {
+                            const { account, debit, credit, description } = ledgerEntries[j];
+                            const journalEntryId = docId + i;
+                            const ledgerEntryId = journalEntryId + j;
+                            const ledgerEntryDoc = Object.assign({ journalEntryId,
+                                account,
+                                credit,
+                                debit,
+                                equation,
+                                date }, (description && { description }));
+                            const entryRef = docRef.collection("@ledgers").doc(ledgerEntryId);
+                            txn.set(entryRef, ledgerEntryDoc);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    await writeJournalEntriesFirst();
+    async function distributeTransactionalLogicResults() {
+        const transactionalResults = logicResults.filter((result) => result.transactional);
+        if (transactionalResults.length === 0) {
+            console.info("No transactional logic results to distribute");
+            return;
+        }
+        // We always distribute transactional results first
+        const transactionalDstPathLogicDocsMap = await (0, index_utils_1.expandConsolidateAndGroupByDstPath)(transactionalResults.map((result) => result.documents).flat().filter((doc) => !doc.journalEntries || doc.journalEntries && doc.action === "delete"));
+        // Write to firestore in one transaction
+        for (const [dstPath, logicDocs] of transactionalDstPathLogicDocsMap) {
+            for (const logicDoc of logicDocs) {
+                const docRef = exports.db.doc(dstPath);
+                const { action } = logicDoc;
+                if (action === "create") {
+                    txn.set(docRef, logicDoc.doc);
+                }
+                else if (action === "merge") {
+                    txn.update(docRef, logicDoc.doc);
+                }
+                else if (action === "delete") {
+                    txn.delete(docRef);
+                }
+                if (logicDoc.instructions) {
+                    const { updateData, removeData } = await (0, distribution_1.convertInstructionsToDbValues)(txn, logicDoc.instructions);
+                    if (Object.keys(updateData).length > 0) {
+                        txn.update(docRef, updateData);
+                    }
+                    if (Object.keys(removeData).length > 0) {
+                        txn.update(docRef, removeData);
+                    }
+                }
+            }
+        }
+    }
+    await distributeTransactionalLogicResults();
+}
 const onUserRegister = async (user) => {
     await exports.db.doc(`users/${user.uid}`).set({
         "@id": user.uid,