@churchsoln/dbms 1.0.56 → 1.0.58

package/constants/index.js

@@ -64,6 +64,17 @@ const NORMAL_BALANCE = {
     CREDIT: "Credit",
 };
 
+const JOURNAL_ENTRY_SOURCE_TYPE = {
+    CONTRIBUTION: "Contribution",
+    MANUAL: "Manual",
+    BILL: "Bill",
+    INVOICE: "Invoice",
+};
+
+const JOURNAL_ENTRY_STATUS = {
+    POSTED: "posted",
+};
+
 const ACCOUNTING_ACCOUNT_TYPES = {
     ASSET: { name: "Asset", normalBalance: NORMAL_BALANCE.DEBIT },
     LIABILITY: { name: "Liability", normalBalance: NORMAL_BALANCE.CREDIT },
@@ -72,28 +83,128 @@ const ACCOUNTING_ACCOUNT_TYPES = {
     EXPENSE: { name: "Expense", normalBalance: NORMAL_BALANCE.DEBIT },
 };
 
+const CHART_OF_ACCOUNTS = [
+    { code: "1000", name: "Assets", accountingAccountType: "Asset", parentCode: null, isPostingAccount: false },
+    { code: "1010", name: "Checking Account", accountingAccountType: "Asset", parentCode: "1000", isPostingAccount: true },
+    { code: "1020", name: "Cash on Hand", accountingAccountType: "Asset", parentCode: "1000", isPostingAccount: true },
+    { code: "2000", name: "Liabilities", accountingAccountType: "Liability", parentCode: null, isPostingAccount: false },
+    { code: "3000", name: "Equity", accountingAccountType: "Equity", parentCode: null, isPostingAccount: false },
+    { code: "4000", name: "Income", accountingAccountType: "Income", parentCode: null, isPostingAccount: false },
+    { code: "4010", name: "Members Subscription Income", accountingAccountType: "Income", parentCode: "4000", isPostingAccount: true },
+    { code: "4020", name: "Capital Fund Donation Income", accountingAccountType: "Income", parentCode: "4000", isPostingAccount: true },
+    { code: "4030", name: "Offering Income", accountingAccountType: "Income", parentCode: "4000", isPostingAccount: true },
+    { code: "4040", name: "Wedding Fees Income", accountingAccountType: "Income", parentCode: "4000", isPostingAccount: true },
+    { code: "4050", name: "Self Denial Cover Income", accountingAccountType: "Income", parentCode: "4000", isPostingAccount: true },
+    { code: "4051", name: "Passion Week Income", accountingAccountType: "Income", parentCode: "4000", isPostingAccount: true },
+    { code: "4060", name: "Special Donation Income", accountingAccountType: "Income", parentCode: "4000", isPostingAccount: true },
+    { code: "5000", name: "Expenses", accountingAccountType: "Expense", parentCode: null, isPostingAccount: false },
+    { code: "5010", name: "Utilities Expense", accountingAccountType: "Expense", parentCode: "5000", isPostingAccount: true },
+    { code: "5020", name: "Mortgage Expense", accountingAccountType: "Expense", parentCode: "5000", isPostingAccount: true },
+    { code: "5030", name: "Office Supplies Expense", accountingAccountType: "Expense", parentCode: "5000", isPostingAccount: true },
+];
+
 const ACCOUNTS = {
-    MEMBERS_SUBSCRIPTION: "Members Subscription",
-    CAPITAL_FUND_DONATION: "Capital Fund Donation",
-    MONTHLY_MORTGAGE_CONTRIBUTION: "Monthly Mortgage Contribution",
-    OFFERTORY_PLATE: "Offertory - Plate (Loose Plate)",
-    OFFERTORY_COVER: "Offertory - Cover",
-    BIRTHDAY_COVER: "Birthday Cover",
-    WEDDING_ANNIVERSARY_COVER: "Wedding Anniversary Cover",
-    REMEMBERANCE_PRAYER_DONATION: "Rememberance Prayer Donation",
-    SELF_DENIAL_COVER: "Self Denial Cover",
-    SPECIAL_DONATION: "Special Donation",
-    PASSION_WEEK: "Passion Week",
-    WEDDING_FEES: "Wedding Fees",
-    BAPTISM_FEES: "Baptism Fees",
-    CATHOLICATE_DAY_FUND: "Catholicate Day Fund",
-    ARTICLE_DONATIONS: "Article Donations",
-    HARVEST_FESTIVAL: "Harvest Festival",
-    SUNDAY_SCHOOL_COLLECTION: "Sunday School - Collection",
-    MMVS_COLLECTION: "MMVS Collection",
-    CHRISTMAS_DONATIONS: "Christmas Donations",
-    CHARITY_FUNDS: "Charity Funds",
-}
+    MEMBERS_SUBSCRIPTION: {
+        accountHead: "Members Subscription",
+        accountDescription: "Members Subscription",
+        chartOfAccountCode: "4010",
+    },
+    CAPITAL_FUND_DONATION: {
+        accountHead: "Capital Fund Donation",
+        accountDescription: "Capital Fund Donation",
+        chartOfAccountCode: "4020",
+    },
+    MONTHLY_MORTGAGE_CONTRIBUTION: {
+        accountHead: "Monthly Mortgage Contribution",
+        accountDescription: "Monthly Mortgage Contribution",
+        chartOfAccountCode: "4020",
+    },
+    OFFERTORY_PLATE: {
+        accountHead: "Offertory - Plate (Loose Plate)",
+        accountDescription: "Offertory - Plate (Loose Plate)",
+        chartOfAccountCode: "4030",
+    },
+    OFFERTORY_COVER: {
+        accountHead: "Offertory - Cover",
+        accountDescription: "Offertory - Cover",
+        chartOfAccountCode: "4030",
+    },
+    BIRTHDAY_COVER: {
+        accountHead: "Birthday Cover",
+        accountDescription: "Birthday Offering",
+        chartOfAccountCode: "4030",
+    },
+    WEDDING_ANNIVERSARY_COVER: {
+        accountHead: "Wedding Anniversary Cover",
+        accountDescription: "Wedding Anniversary Offering",
+        chartOfAccountCode: "4030",
+    },
+    REMEMBERANCE_PRAYER_DONATION: {
+        accountHead: "Rememberance Prayer Donation",
+        accountDescription: "Rememberance Prayer Offering",
+        chartOfAccountCode: "4030",
+    },
+    SELF_DENIAL_COVER: {
+        accountHead: "Self Denial Cover",
+        accountDescription: "Self Denial Cover",
+        chartOfAccountCode: "4050",
+    },
+    SPECIAL_DONATION: {
+        accountHead: "Special Donation",
+        accountDescription: "Special Donation",
+        chartOfAccountCode: "4060",
+    },
+    PASSION_WEEK: {
+        accountHead: "Passion Week",
+        accountDescription: "Passion Week",
+        chartOfAccountCode: "4051",
+    },
+    WEDDING_FEES: {
+        accountHead: "Wedding Fees",
+        accountDescription: "Wedding Fees",
+        chartOfAccountCode: "4040",
+    },
+    BAPTISM_FEES: {
+        accountHead: "Baptism Fees",
+        accountDescription: "Baptism Fees",
+        chartOfAccountCode: "4040",
+    },
+    CATHOLICATE_DAY_FUND: {
+        accountHead: "Catholicate Day Fund",
+        accountDescription: "Catholicate Day Fund",
+        chartOfAccountCode: null,
+    },
+    ARTICLE_DONATIONS: {
+        accountHead: "Article Donations",
+        accountDescription: "Article Donations",
+        chartOfAccountCode: null,
+    },
+    HARVEST_FESTIVAL: {
+        accountHead: "Harvest Festival",
+        accountDescription: "Harvest Festival",
+        chartOfAccountCode: null,
+    },
+    SUNDAY_SCHOOL_COLLECTION: {
+        accountHead: "Sunday School - Collection",
+        accountDescription: "Sunday School - Collection",
+        chartOfAccountCode: null,
+    },
+    MMVS_COLLECTION: {
+        accountHead: "MMVS Collection",
+        accountDescription: "MMVS Collection",
+        chartOfAccountCode: null,
+    },
+    CHRISTMAS_DONATIONS: {
+        accountHead: "Christmas Donations",
+        accountDescription: "Christmas Donations",
+        chartOfAccountCode: null,
+    },
+    CHARITY_FUNDS: {
+        accountHead: "Charity Funds",
+        accountDescription: "Charity Funds",
+        chartOfAccountCode: null,
+    },
+};
 
 const GENDER = {
     MALE: "Male",
@@ -130,4 +241,7 @@ module.exports = {
     ACCOUNTS,
     NORMAL_BALANCE,
     ACCOUNTING_ACCOUNT_TYPES,
+    CHART_OF_ACCOUNTS,
+    JOURNAL_ENTRY_SOURCE_TYPE,
+    JOURNAL_ENTRY_STATUS,
 };

package/migrations/church/20260707170639-create-chartOfAccounts.js

@@ -0,0 +1,56 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .createTable(
+                "ChartOfAccounts",
+                {
+                    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                    code: { type: DataTypes.STRING, allowNull: false, unique: true },
+                    name: { type: DataTypes.STRING, allowNull: false },
+                    accountingAccountTypeId: { type: DataTypes.INTEGER, allowNull: false },
+                    parentAccountId: { type: DataTypes.INTEGER, allowNull: true },
+                    isPostingAccount: { type: DataTypes.BOOLEAN, defaultValue: true },
+                    status: { type: DataTypes.BOOLEAN, defaultValue: true },
+                    createdAt: {
+                        type: DataTypes.DATE,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                    updatedAt: {
+                        type: DataTypes.DATE,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                },
+                { timestamps: false }
+            )
+            .then(() =>
+                queryInterface.addConstraint("ChartOfAccounts", {
+                    fields: ["accountingAccountTypeId"],
+                    type: "foreign key",
+                    name: "ChartOfAccounts_AccountingAccountTypeId_Fkey",
+                    references: {
+                        table: "AccountingAccountTypes",
+                        field: "id",
+                    },
+                    onDelete: "restrict",
+                    onUpdate: "cascade",
+                })
+            )
+            .then(() =>
+                queryInterface.addConstraint("ChartOfAccounts", {
+                    fields: ["parentAccountId"],
+                    type: "foreign key",
+                    name: "ChartOfAccounts_ParentAccountId_Fkey",
+                    references: {
+                        table: "ChartOfAccounts",
+                        field: "id",
+                    },
+                    onDelete: "restrict",
+                    onUpdate: "cascade",
+                })
+            );
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("ChartOfAccounts");
+    },
+};

package/migrations/church/20260707170640-update-accounts-add-chartOfAccountId.js

@@ -0,0 +1,27 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .addColumn("Accounts", "chartOfAccountId", {
+                type: DataTypes.INTEGER,
+                allowNull: true,
+            })
+            .then(() =>
+                queryInterface.addConstraint("Accounts", {
+                    fields: ["chartOfAccountId"],
+                    type: "foreign key",
+                    name: "Accounts_ChartOfAccountId_Fkey",
+                    references: {
+                        table: "ChartOfAccounts",
+                        field: "id",
+                    },
+                    onDelete: "restrict",
+                    onUpdate: "cascade",
+                })
+            );
+    },
+    down: async (queryInterface) => {
+        await queryInterface.removeConstraint("Accounts", "Accounts_ChartOfAccountId_Fkey");
+        await queryInterface.removeColumn("Accounts", "chartOfAccountId");
+    },
+};

package/migrations/church/20260712170641-create-journalEntry.js

@@ -0,0 +1,42 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .createTable(
+                "JournalEntry",
+                {
+                    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                    entryDate: { type: DataTypes.DATEONLY, allowNull: false },
+                    sourceType: { type: DataTypes.STRING, allowNull: true },
+                    contributionTransactionId: { type: DataTypes.INTEGER, allowNull: true },
+                    description: { type: DataTypes.TEXT, allowNull: true },
+                    status: { type: DataTypes.STRING, defaultValue: "posted" },
+                    createdAt: {
+                        type: DataTypes.DATE,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                    updatedAt: {
+                        type: DataTypes.DATE,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                },
+                { timestamps: false }
+            )
+            .then(() =>
+                queryInterface.addConstraint("JournalEntry", {
+                    fields: ["contributionTransactionId"],
+                    type: "foreign key",
+                    name: "JournalEntry_ContributionTransactionId_Fkey",
+                    references: {
+                        table: "ContributionTransaction",
+                        field: "id",
+                    },
+                    onDelete: "restrict",
+                    onUpdate: "cascade",
+                })
+            );
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("JournalEntry");
+    },
+};

package/migrations/church/20260712170642-create-journalEntryLine.js

@@ -0,0 +1,55 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .createTable(
+                "JournalEntryLine",
+                {
+                    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                    journalEntryId: { type: DataTypes.INTEGER, allowNull: false },
+                    chartOfAccountId: { type: DataTypes.INTEGER, allowNull: false },
+                    debit: { type: DataTypes.DECIMAL(10, 2), defaultValue: 0 },
+                    credit: { type: DataTypes.DECIMAL(10, 2), defaultValue: 0 },
+                    memo: { type: DataTypes.TEXT, allowNull: true },
+                    createdAt: {
+                        type: DataTypes.DATE,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                    updatedAt: {
+                        type: DataTypes.DATE,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                },
+                { timestamps: false }
+            )
+            .then(() =>
+                queryInterface.addConstraint("JournalEntryLine", {
+                    fields: ["journalEntryId"],
+                    type: "foreign key",
+                    name: "JournalEntryLine_JournalEntryId_Fkey",
+                    references: {
+                        table: "JournalEntry",
+                        field: "id",
+                    },
+                    onDelete: "cascade",
+                    onUpdate: "cascade",
+                })
+            )
+            .then(() =>
+                queryInterface.addConstraint("JournalEntryLine", {
+                    fields: ["chartOfAccountId"],
+                    type: "foreign key",
+                    name: "JournalEntryLine_ChartOfAccountId_Fkey",
+                    references: {
+                        table: "ChartOfAccounts",
+                        field: "id",
+                    },
+                    onDelete: "restrict",
+                    onUpdate: "cascade",
+                })
+            );
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("JournalEntryLine");
+    },
+};

package/models/church/accountingAccountTypes.js

@@ -12,5 +12,11 @@ module.exports = (sequelize, DataTypes) => {
         { freezeTableName: true, timestamps: false }
     );
     accountingAccountTypes.selectedFields = ["id", "name", "normalBalance", "status"];
+    accountingAccountTypes.associate = function (models) {
+        accountingAccountTypes.hasMany(models.chartOfAccounts, {
+            foreignKey: "accountingAccountTypeId",
+            as: "chartOfAccounts",
+        });
+    };
     return accountingAccountTypes;
 };

package/models/church/accounts.js

@@ -6,6 +6,7 @@ module.exports = (sequelize, DataTypes) => {
             accountHead: { type: DataTypes.STRING },
             accountDescription: { type: DataTypes.STRING },
             isLinkedWithQB: { type: DataTypes.BOOLEAN },
+            chartOfAccountId: { type: DataTypes.INTEGER, allowNull: true },
             status: { type: DataTypes.BOOLEAN, defaultValue: true },
             createdAt: { type: DataTypes.DATE },
             updatedAt: { type: DataTypes.DATE },
@@ -13,6 +14,10 @@ module.exports = (sequelize, DataTypes) => {
         { freezeTableName: true, timestamps: false }
     );
     accounts.associate = function (models) {
+        accounts.belongsTo(models.chartOfAccounts, {
+            foreignKey: "chartOfAccountId",
+            as: "chartOfAccount",
+        });
         accounts.hasMany(models.pledgeAccount, {
             foreignKey: "accountId",
             as: "pledgeAccount",
@@ -22,6 +27,12 @@ module.exports = (sequelize, DataTypes) => {
             as: "contributionTransactionLine",
         });
     }
-    accounts.selectedFields = ["id", "accountHead", "accountDescription", "isLinkedWithQB"];
+    accounts.selectedFields = [
+        "id",
+        "accountHead",
+        "accountDescription",
+        "isLinkedWithQB",
+        "chartOfAccountId",
+    ];
     return accounts;
 };

package/models/church/chartOfAccounts.js

@@ -0,0 +1,49 @@
+module.exports = (sequelize, DataTypes) => {
+    const chartOfAccounts = sequelize.define(
+        "ChartOfAccounts",
+        {
+            id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            code: { type: DataTypes.STRING, allowNull: false, unique: true },
+            name: { type: DataTypes.STRING, allowNull: false },
+            accountingAccountTypeId: { type: DataTypes.INTEGER, allowNull: false },
+            parentAccountId: { type: DataTypes.INTEGER, allowNull: true },
+            isPostingAccount: { type: DataTypes.BOOLEAN, defaultValue: true },
+            status: { type: DataTypes.BOOLEAN, defaultValue: true },
+            createdAt: { type: DataTypes.DATE },
+            updatedAt: { type: DataTypes.DATE },
+        },
+        { freezeTableName: true, timestamps: false }
+    );
+    chartOfAccounts.associate = function (models) {
+        chartOfAccounts.belongsTo(models.accountingAccountTypes, {
+            foreignKey: "accountingAccountTypeId",
+            as: "accountingAccountType",
+        });
+        chartOfAccounts.belongsTo(models.chartOfAccounts, {
+            foreignKey: "parentAccountId",
+            as: "parentAccount",
+        });
+        chartOfAccounts.hasMany(models.chartOfAccounts, {
+            foreignKey: "parentAccountId",
+            as: "childAccounts",
+        });
+        chartOfAccounts.hasMany(models.accounts, {
+            foreignKey: "chartOfAccountId",
+            as: "accounts",
+        });
+        chartOfAccounts.hasMany(models.journalEntryLine, {
+            foreignKey: "chartOfAccountId",
+            as: "journalEntryLines",
+        });
+    };
+    chartOfAccounts.selectedFields = [
+        "id",
+        "code",
+        "name",
+        "accountingAccountTypeId",
+        "parentAccountId",
+        "isPostingAccount",
+        "status",
+    ];
+    return chartOfAccounts;
+};

package/models/church/contributionTransaction.js

@@ -71,6 +71,10 @@ module.exports = (sequelize, DataTypes) => {
             foreignKey: "contributionTransactionId",
             as: "contributionTransactionLine",
         });
+        contributionTransaction.hasMany(models.journalEntry, {
+            foreignKey: "contributionTransactionId",
+            as: "journalEntries",
+        });
     }
     contributionTransaction.selectedFields = [
         "id",

package/models/church/journalEntry.js

@@ -0,0 +1,37 @@
+module.exports = (sequelize, DataTypes) => {
+    const journalEntry = sequelize.define(
+        "JournalEntry",
+        {
+            id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            entryDate: { type: DataTypes.DATEONLY, allowNull: false },
+            sourceType: { type: DataTypes.STRING, allowNull: true },
+            contributionTransactionId: { type: DataTypes.INTEGER, allowNull: true },
+            description: { type: DataTypes.TEXT, allowNull: true },
+            status: { type: DataTypes.STRING, defaultValue: "posted" },
+            createdAt: { type: DataTypes.DATE },
+            updatedAt: { type: DataTypes.DATE },
+        },
+        { freezeTableName: true, timestamps: false }
+    );
+    journalEntry.associate = function (models) {
+        journalEntry.belongsTo(models.contributionTransaction, {
+            foreignKey: "contributionTransactionId",
+            as: "contributionTransaction",
+        });
+        journalEntry.hasMany(models.journalEntryLine, {
+            foreignKey: "journalEntryId",
+            as: "journalEntryLines",
+        });
+    };
+    journalEntry.selectedFields = [
+        "id",
+        "entryDate",
+        "sourceType",
+        "contributionTransactionId",
+        "description",
+        "status",
+        "createdAt",
+        "updatedAt",
+    ];
+    return journalEntry;
+};

package/models/church/journalEntryLine.js

@@ -0,0 +1,37 @@
+module.exports = (sequelize, DataTypes) => {
+    const journalEntryLine = sequelize.define(
+        "JournalEntryLine",
+        {
+            id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            journalEntryId: { type: DataTypes.INTEGER, allowNull: false },
+            chartOfAccountId: { type: DataTypes.INTEGER, allowNull: false },
+            debit: { type: DataTypes.DECIMAL(10, 2), defaultValue: 0 },
+            credit: { type: DataTypes.DECIMAL(10, 2), defaultValue: 0 },
+            memo: { type: DataTypes.TEXT, allowNull: true },
+            createdAt: { type: DataTypes.DATE },
+            updatedAt: { type: DataTypes.DATE },
+        },
+        { freezeTableName: true, timestamps: false }
+    );
+    journalEntryLine.associate = function (models) {
+        journalEntryLine.belongsTo(models.journalEntry, {
+            foreignKey: "journalEntryId",
+            as: "journalEntry",
+        });
+        journalEntryLine.belongsTo(models.chartOfAccounts, {
+            foreignKey: "chartOfAccountId",
+            as: "chartOfAccount",
+        });
+    };
+    journalEntryLine.selectedFields = [
+        "id",
+        "journalEntryId",
+        "chartOfAccountId",
+        "debit",
+        "credit",
+        "memo",
+        "createdAt",
+        "updatedAt",
+    ];
+    return journalEntryLine;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@churchsoln/dbms",
-    "version": "1.0.56",
+    "version": "1.0.58",
     "main": "index.js",
     "scripts": {
         "prestart": "node db-setup.js",

package/seeders/church/20241005131420-accounts.js

@@ -3,10 +3,10 @@
 const { ACCOUNTS } = require("../../constants");
 
 module.exports = {
-    up: async (queryInterface, Sequelize) => {
+    up: async (queryInterface) => {
         const accounts = Object.values(ACCOUNTS).map((account) => ({
-            accountHead: account,
-            accountDescription: account,
+            accountHead: account.accountHead,
+            accountDescription: account.accountDescription,
             isLinkedWithQB: false,
             status: true,
         }));
@@ -23,10 +23,10 @@ module.exports = {
             if (existingAccount) {
                 await queryInterface.bulkUpdate(
                     "Accounts",
-                    { 
-                        status: account.status, 
-                        isLinkedWithQB: account.isLinkedWithQB, 
-                        accountDescription: account.accountDescription 
+                    {
+                        status: account.status,
+                        isLinkedWithQB: account.isLinkedWithQB,
+                        accountDescription: account.accountDescription,
                     },
                     { accountHead: account.accountHead }
                 );
@@ -36,5 +36,5 @@ module.exports = {
         }
     },
 
-    down: async (queryInterface, Sequelize) => {},
+    down: async () => {},
 };

package/seeders/church/20260707170639-chartOfAccounts.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const { CHART_OF_ACCOUNTS } = require("../../constants");
+
+module.exports = {
+    up: async (queryInterface) => {
+        const codeToId = {};
+
+        const getAccountTypeId = async (accountTypeName) =>
+            queryInterface.rawSelect(
+                "AccountingAccountTypes",
+                { where: { name: accountTypeName } },
+                ["id"]
+            );
+
+        for (const account of CHART_OF_ACCOUNTS) {
+            const accountingAccountTypeId = await getAccountTypeId(account.accountingAccountType);
+            if (!accountingAccountTypeId) continue;
+
+            const parentAccountId = account.parentCode ? codeToId[account.parentCode] || null : null;
+
+            const record = {
+                code: account.code,
+                name: account.name,
+                accountingAccountTypeId,
+                parentAccountId,
+                isPostingAccount: account.isPostingAccount,
+                status: true,
+            };
+
+            const existingId = await queryInterface.rawSelect(
+                "ChartOfAccounts",
+                { where: { code: account.code } },
+                ["id"]
+            );
+
+            if (existingId) {
+                await queryInterface.bulkUpdate("ChartOfAccounts", record, { code: account.code });
+                codeToId[account.code] = existingId;
+            } else {
+                await queryInterface.bulkInsert("ChartOfAccounts", [record], {});
+                codeToId[account.code] = await queryInterface.rawSelect(
+                    "ChartOfAccounts",
+                    { where: { code: account.code } },
+                    ["id"]
+                );
+            }
+        }
+    },
+
+    down: async () => {},
+};

package/seeders/church/20260707170640-update-accounts-chartOfAccountId.js

@@ -0,0 +1,37 @@
+"use strict";
+
+const { ACCOUNTS } = require("../../constants");
+
+module.exports = {
+    up: async (queryInterface) => {
+        for (const account of Object.values(ACCOUNTS)) {
+            if (!account.chartOfAccountCode) continue;
+
+            const chartOfAccountId = await queryInterface.rawSelect(
+                "ChartOfAccounts",
+                { where: { code: account.chartOfAccountCode } },
+                ["id"]
+            );
+            if (!chartOfAccountId) continue;
+
+            const existingAccountId = await queryInterface.rawSelect(
+                "Accounts",
+                { where: { accountHead: account.accountHead } },
+                ["id"]
+            );
+
+            if (existingAccountId) {
+                await queryInterface.bulkUpdate(
+                    "Accounts",
+                    {
+                        accountDescription: account.accountDescription,
+                        chartOfAccountId,
+                    },
+                    { accountHead: account.accountHead }
+                );
+            }
+        }
+    },
+
+    down: async () => {},
+};