@churchsoln/dbms 1.0.55 → 1.0.57

package/constants/index.js

@@ -59,28 +59,141 @@ const MEMBER_STATUS = {
     VISITOR: "Visitor",
 };
 
+const NORMAL_BALANCE = {
+    DEBIT: "Debit",
+    CREDIT: "Credit",
+};
+
+const ACCOUNTING_ACCOUNT_TYPES = {
+    ASSET: { name: "Asset", normalBalance: NORMAL_BALANCE.DEBIT },
+    LIABILITY: { name: "Liability", normalBalance: NORMAL_BALANCE.CREDIT },
+    EQUITY: { name: "Equity", normalBalance: NORMAL_BALANCE.CREDIT },
+    INCOME: { name: "Income", normalBalance: NORMAL_BALANCE.CREDIT },
+    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",
@@ -114,5 +227,8 @@ module.exports = {
     GENDER,
     RELATIONSHIP,
     CODE_LENGTH,
-    ACCOUNTS
+    ACCOUNTS,
+    NORMAL_BALANCE,
+    ACCOUNTING_ACCOUNT_TYPES,
+    CHART_OF_ACCOUNTS,
 };

package/migrations/church/20260706170637-create-accountingAccountTypes.js

@@ -0,0 +1,26 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface.createTable(
+            "AccountingAccountTypes",
+            {
+                id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                name: { type: DataTypes.STRING, allowNull: false, unique: true },
+                normalBalance: { type: DataTypes.STRING, allowNull: false },
+                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 }
+        );
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("AccountingAccountTypes");
+    },
+};

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/models/church/accountingAccountTypes.js

@@ -0,0 +1,22 @@
+module.exports = (sequelize, DataTypes) => {
+    const accountingAccountTypes = sequelize.define(
+        "AccountingAccountTypes",
+        {
+            id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            name: { type: DataTypes.STRING, allowNull: false, unique: true },
+            normalBalance: { type: DataTypes.STRING, allowNull: false },
+            status: { type: DataTypes.BOOLEAN, defaultValue: true },
+            createdAt: { type: DataTypes.DATE },
+            updatedAt: { type: DataTypes.DATE },
+        },
+        { 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,45 @@
+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.selectedFields = [
+        "id",
+        "code",
+        "name",
+        "accountingAccountTypeId",
+        "parentAccountId",
+        "isPostingAccount",
+        "status",
+    ];
+    return chartOfAccounts;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@churchsoln/dbms",
-    "version": "1.0.55",
+    "version": "1.0.57",
     "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/20260706170638-accountingAccountTypes.js

@@ -0,0 +1,38 @@
+"use strict";
+
+const { ACCOUNTING_ACCOUNT_TYPES } = require("../../constants");
+
+module.exports = {
+    up: async (queryInterface) => {
+        const accountTypes = Object.values(ACCOUNTING_ACCOUNT_TYPES).map((accountType) => ({
+            name: accountType.name,
+            normalBalance: accountType.normalBalance,
+            status: true,
+        }));
+
+        for (const accountType of accountTypes) {
+            const existingAccountType = await queryInterface.rawSelect(
+                "AccountingAccountTypes",
+                {
+                    where: { name: accountType.name },
+                },
+                ["id"]
+            );
+
+            if (existingAccountType) {
+                await queryInterface.bulkUpdate(
+                    "AccountingAccountTypes",
+                    {
+                        normalBalance: accountType.normalBalance,
+                        status: accountType.status,
+                    },
+                    { name: accountType.name }
+                );
+            } else {
+                await queryInterface.bulkInsert("AccountingAccountTypes", [accountType], {});
+            }
+        }
+    },
+
+    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 () => {},
+};