@churchsoln/dbms 1.0.57 → 1.0.59

package/constants/index.js

@@ -64,6 +64,25 @@ const NORMAL_BALANCE = {
     CREDIT: "Credit",
 };
 
+const JOURNAL_ENTRY_SOURCE_TYPE = {
+    MANUAL: "Manual",
+    CONTRIBUTION: "Contribution",
+    PLEDGE: "Pledge",
+    BILL: "Bill",
+    BILL_PAYMENT: "BillPayment",
+    INVOICE: "Invoice",
+    RECEIPT: "Receipt",
+    PAYROLL: "Payroll",
+    BANK_DEPOSIT: "BankDeposit",
+    BANK_TRANSFER: "BankTransfer",
+    OPENING_BALANCE: "OpeningBalance",
+    ADJUSTMENT: "Adjustment",
+};
+
+const JOURNAL_ENTRY_STATUS = {
+    POSTED: "posted",
+};
+
 const ACCOUNTING_ACCOUNT_TYPES = {
     ASSET: { name: "Asset", normalBalance: NORMAL_BALANCE.DEBIT },
     LIABILITY: { name: "Liability", normalBalance: NORMAL_BALANCE.CREDIT },
@@ -231,4 +250,6 @@ module.exports = {
     NORMAL_BALANCE,
     ACCOUNTING_ACCOUNT_TYPES,
     CHART_OF_ACCOUNTS,
+    JOURNAL_ENTRY_SOURCE_TYPE,
+    JOURNAL_ENTRY_STATUS,
 };

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/migrations/church/20260726170643-create-fiscalYears.js

@@ -0,0 +1,44 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .createTable(
+                "FiscalYears",
+                {
+                    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                    name: { type: DataTypes.STRING(100), allowNull: false },
+                    startDate: { type: DataTypes.DATEONLY, allowNull: false },
+                    endDate: { type: DataTypes.DATEONLY, allowNull: false },
+                    status: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: true },
+                    createdAt: {
+                        type: DataTypes.DATE,
+                        allowNull: false,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                    updatedAt: {
+                        type: DataTypes.DATE,
+                        allowNull: false,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                },
+                { timestamps: false }
+            )
+            .then(() =>
+                queryInterface.addConstraint("FiscalYears", {
+                    fields: ["startDate", "endDate"],
+                    type: "unique",
+                    name: "FiscalYears_date_unique",
+                })
+            )
+            .then(() =>
+                queryInterface.sequelize.query(`
+                    ALTER TABLE "FiscalYears"
+                    ADD CONSTRAINT "FiscalYears_date_check"
+                    CHECK ("endDate" >= "startDate")
+                `)
+            );
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("FiscalYears");
+    },
+};

package/migrations/church/20260726170644-create-openingBalance.js

@@ -0,0 +1,60 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .createTable(
+                "OpeningBalance",
+                {
+                    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                    fiscalYearId: { type: DataTypes.INTEGER, allowNull: false },
+                    chartOfAccountId: { type: DataTypes.INTEGER, allowNull: false },
+                    amount: { type: DataTypes.DECIMAL(18, 2), allowNull: false },
+                    createdAt: {
+                        type: DataTypes.DATE,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                    updatedAt: {
+                        type: DataTypes.DATE,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                },
+                { timestamps: false }
+            )
+            .then(() =>
+                queryInterface.addConstraint("OpeningBalance", {
+                    fields: ["fiscalYearId"],
+                    type: "foreign key",
+                    name: "OpeningBalance_FiscalYearId_Fkey",
+                    references: {
+                        table: "FiscalYears",
+                        field: "id",
+                    },
+                    onDelete: "restrict",
+                    onUpdate: "cascade",
+                })
+            )
+            .then(() =>
+                queryInterface.addConstraint("OpeningBalance", {
+                    fields: ["chartOfAccountId"],
+                    type: "foreign key",
+                    name: "OpeningBalance_ChartOfAccountId_Fkey",
+                    references: {
+                        table: "ChartOfAccounts",
+                        field: "id",
+                    },
+                    onDelete: "restrict",
+                    onUpdate: "cascade",
+                })
+            )
+            .then(() =>
+                queryInterface.addConstraint("OpeningBalance", {
+                    fields: ["fiscalYearId", "chartOfAccountId"],
+                    type: "unique",
+                    name: "OpeningBalance_FiscalYearId_ChartOfAccountId_Unique",
+                })
+            );
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("OpeningBalance");
+    },
+};

package/migrations/church/20260726170645-update-journalEntry-sourceType-enum.js

@@ -0,0 +1,41 @@
+"use strict";
+const { JOURNAL_ENTRY_SOURCE_TYPE } = require("../../constants");
+
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        const table = await queryInterface.describeTable("JournalEntry");
+        if (table.sourceType) {
+            await queryInterface.removeColumn("JournalEntry", "sourceType");
+        }
+
+        const enumValues = Object.values(JOURNAL_ENTRY_SOURCE_TYPE)
+            .map((value) => `'${value}'`)
+            .join(", ");
+
+        await queryInterface.sequelize.query(`
+            DO $$
+            BEGIN
+                IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = 'JournalSourceType') THEN
+                    CREATE TYPE "JournalSourceType" AS ENUM (${enumValues});
+                END IF;
+            END
+            $$;
+        `);
+
+        await queryInterface.sequelize.query(`
+            ALTER TABLE "JournalEntry"
+            ADD COLUMN "sourceType" "JournalSourceType"
+        `);
+    },
+    down: async (queryInterface, DataTypes) => {
+        const table = await queryInterface.describeTable("JournalEntry");
+        if (table.sourceType) {
+            await queryInterface.removeColumn("JournalEntry", "sourceType");
+        }
+        await queryInterface.sequelize.query(`DROP TYPE IF EXISTS "JournalSourceType"`);
+        await queryInterface.addColumn("JournalEntry", "sourceType", {
+            type: DataTypes.STRING,
+            allowNull: true,
+        });
+    },
+};

package/models/church/chartOfAccounts.js

@@ -31,6 +31,14 @@ module.exports = (sequelize, DataTypes) => {
             foreignKey: "chartOfAccountId",
             as: "accounts",
         });
+        chartOfAccounts.hasMany(models.journalEntryLine, {
+            foreignKey: "chartOfAccountId",
+            as: "journalEntryLines",
+        });
+        chartOfAccounts.hasMany(models.openingBalance, {
+            foreignKey: "chartOfAccountId",
+            as: "openingBalances",
+        });
     };
     chartOfAccounts.selectedFields = [
         "id",

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/fiscalYears.js

@@ -0,0 +1,23 @@
+module.exports = (sequelize, DataTypes) => {
+    const fiscalYears = sequelize.define(
+        "FiscalYears",
+        {
+            id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            name: { type: DataTypes.STRING(100), allowNull: false },
+            startDate: { type: DataTypes.DATEONLY, allowNull: false },
+            endDate: { type: DataTypes.DATEONLY, allowNull: false },
+            status: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: true },
+            createdAt: { type: DataTypes.DATE },
+            updatedAt: { type: DataTypes.DATE },
+        },
+        { freezeTableName: true, timestamps: false }
+    );
+    fiscalYears.associate = function (models) {
+        fiscalYears.hasMany(models.openingBalance, {
+            foreignKey: "fiscalYearId",
+            as: "openingBalances",
+        });
+    };
+    fiscalYears.selectedFields = ["id", "name", "startDate", "endDate", "status"];
+    return fiscalYears;
+};

package/models/church/journalEntry.js

@@ -0,0 +1,45 @@
+const { JOURNAL_ENTRY_SOURCE_TYPE } = require("../../constants");
+
+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.ENUM({
+                    name: "JournalSourceType",
+                    values: Object.values(JOURNAL_ENTRY_SOURCE_TYPE),
+                }),
+                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/models/church/openingBalance.js

@@ -0,0 +1,33 @@
+module.exports = (sequelize, DataTypes) => {
+    const openingBalance = sequelize.define(
+        "OpeningBalance",
+        {
+            id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            fiscalYearId: { type: DataTypes.INTEGER, allowNull: false },
+            chartOfAccountId: { type: DataTypes.INTEGER, allowNull: false },
+            amount: { type: DataTypes.DECIMAL(18, 2), allowNull: false },
+            createdAt: { type: DataTypes.DATE },
+            updatedAt: { type: DataTypes.DATE },
+        },
+        { freezeTableName: true, timestamps: false }
+    );
+    openingBalance.associate = function (models) {
+        openingBalance.belongsTo(models.fiscalYears, {
+            foreignKey: "fiscalYearId",
+            as: "fiscalYear",
+        });
+        openingBalance.belongsTo(models.chartOfAccounts, {
+            foreignKey: "chartOfAccountId",
+            as: "chartOfAccount",
+        });
+    };
+    openingBalance.selectedFields = [
+        "id",
+        "fiscalYearId",
+        "chartOfAccountId",
+        "amount",
+        "createdAt",
+        "updatedAt",
+    ];
+    return openingBalance;
+};

package/package.json

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