@churchsoln/dbms 1.0.62 → 1.0.64

package/constants/index.js

@@ -84,6 +84,39 @@ const JOURNAL_ENTRY_STATUS = {
     DRAFT: "draft",
 };
 
+const BILL_STATUS = {
+    DRAFT: "Draft",
+    UNPAID: "Unpaid",
+    PARTIALLY_PAID: "PartiallyPaid",
+    PAID: "Paid",
+};
+
+const BILL_TAX_MODE = {
+    EXCLUSIVE: "exclusive",
+    INCLUSIVE: "inclusive",
+};
+
+const BILL_PAYMENT_METHOD = {
+    CASH: "Cash",
+    CHECK: "Check",
+    BANK_TRANSFER: "BankTransfer",
+    CARD: "Card",
+    OTHER: "Other",
+};
+
+const ACCOUNTS_PAYABLE_CODE = "2010";
+
+// Invoices share the bill lifecycle (Draft -> Unpaid -> PartiallyPaid -> Paid; Overdue is derived).
+const INVOICE_STATUS = {
+    DRAFT: "Draft",
+    UNPAID: "Unpaid",
+    PARTIALLY_PAID: "PartiallyPaid",
+    PAID: "Paid",
+};
+
+// An asset account, but not cash: excluded wherever "posting asset" means a bank/cash account.
+const ACCOUNTS_RECEIVABLE_CODE = "1100";
+
 const ACCOUNTING_ACCOUNT_TYPES = {
     ASSET: { name: "Asset", normalBalance: NORMAL_BALANCE.DEBIT },
     LIABILITY: { name: "Liability", normalBalance: NORMAL_BALANCE.CREDIT },
@@ -96,7 +129,9 @@ 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: "1100", name: "Accounts Receivable", accountingAccountType: "Asset", parentCode: "1000", isPostingAccount: true },
     { code: "2000", name: "Liabilities", accountingAccountType: "Liability", parentCode: null, isPostingAccount: false },
+    { code: "2010", name: "Accounts Payable", accountingAccountType: "Liability", parentCode: "2000", isPostingAccount: true },
     { 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 },
@@ -253,4 +288,10 @@ module.exports = {
     CHART_OF_ACCOUNTS,
     JOURNAL_ENTRY_SOURCE_TYPE,
     JOURNAL_ENTRY_STATUS,
+    BILL_STATUS,
+    BILL_TAX_MODE,
+    BILL_PAYMENT_METHOD,
+    ACCOUNTS_PAYABLE_CODE,
+    INVOICE_STATUS,
+    ACCOUNTS_RECEIVABLE_CODE,
 };

package/migrations/church/20261017170648-create-vendor.js

@@ -0,0 +1,46 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .createTable(
+                "Vendor",
+                {
+                    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                    name: { type: DataTypes.STRING, allowNull: false, unique: true },
+                    email: { type: DataTypes.STRING, allowNull: true },
+                    phone: { type: DataTypes.STRING, allowNull: true },
+                    addressLine1: { type: DataTypes.STRING, allowNull: true },
+                    addressLine2: { type: DataTypes.STRING, allowNull: true },
+                    defaultTerms: { type: DataTypes.STRING, allowNull: true },
+                    defaultChartOfAccountId: { type: DataTypes.INTEGER, allowNull: true },
+                    notes: { type: DataTypes.TEXT, allowNull: 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("Vendor", {
+                    fields: ["defaultChartOfAccountId"],
+                    type: "foreign key",
+                    name: "Vendor_DefaultChartOfAccountId_Fkey",
+                    references: {
+                        table: "ChartOfAccounts",
+                        field: "id",
+                    },
+                    onDelete: "set null",
+                    onUpdate: "cascade",
+                })
+            );
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("Vendor");
+    },
+};

package/migrations/church/20261017170649-create-bill.js

@@ -0,0 +1,73 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .createTable(
+                "Bill",
+                {
+                    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                    billNo: { type: DataTypes.STRING, allowNull: false, unique: true },
+                    vendorId: { type: DataTypes.INTEGER, allowNull: false },
+                    reference: { type: DataTypes.STRING, allowNull: true },
+                    description: { type: DataTypes.TEXT, allowNull: true },
+                    billDate: { type: DataTypes.DATEONLY, allowNull: true },
+                    dueDate: { type: DataTypes.DATEONLY, allowNull: true },
+                    terms: { type: DataTypes.STRING, allowNull: true },
+                    currency: { type: DataTypes.STRING, defaultValue: "USD" },
+                    memo: { type: DataTypes.TEXT, allowNull: true },
+                    notes: { type: DataTypes.TEXT, allowNull: true },
+                    status: { type: DataTypes.STRING, defaultValue: "Draft" },
+                    taxMode: { type: DataTypes.STRING, defaultValue: "exclusive" },
+                    subtotal: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+                    tax: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+                    discount: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+                    amount: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+                    amountPaid: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+                    amountDue: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+                    paidDate: { type: DataTypes.DATEONLY, allowNull: true },
+                    journalEntryId: { type: DataTypes.INTEGER, allowNull: true },
+                    createdBy: { type: DataTypes.INTEGER, 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("Bill", {
+                    fields: ["vendorId"],
+                    type: "foreign key",
+                    name: "Bill_VendorId_Fkey",
+                    references: {
+                        table: "Vendor",
+                        field: "id",
+                    },
+                    onDelete: "restrict",
+                    onUpdate: "cascade",
+                })
+            )
+            .then(() =>
+                queryInterface.addConstraint("Bill", {
+                    fields: ["journalEntryId"],
+                    type: "foreign key",
+                    name: "Bill_JournalEntryId_Fkey",
+                    references: {
+                        table: "JournalEntry",
+                        field: "id",
+                    },
+                    onDelete: "set null",
+                    onUpdate: "cascade",
+                })
+            )
+            .then(() => queryInterface.addIndex("Bill", ["status"]))
+            .then(() => queryInterface.addIndex("Bill", ["dueDate"]));
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("Bill");
+    },
+};

package/migrations/church/20261017170650-create-billLine.js

@@ -0,0 +1,61 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .createTable(
+                "BillLine",
+                {
+                    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                    billId: { type: DataTypes.INTEGER, allowNull: false },
+                    chartOfAccountId: { type: DataTypes.INTEGER, allowNull: true },
+                    description: { type: DataTypes.TEXT, allowNull: true },
+                    className: { type: DataTypes.STRING, allowNull: true },
+                    amount: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+                    taxRate: { type: DataTypes.DECIMAL(6, 4), defaultValue: 0 },
+                    taxLabel: { type: DataTypes.STRING, allowNull: true },
+                    netAmount: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+                    taxAmount: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+                    total: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+                    sortOrder: { type: DataTypes.INTEGER, defaultValue: 0 },
+                    createdAt: {
+                        type: DataTypes.DATE,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                    updatedAt: {
+                        type: DataTypes.DATE,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                },
+                { timestamps: false }
+            )
+            .then(() =>
+                queryInterface.addConstraint("BillLine", {
+                    fields: ["billId"],
+                    type: "foreign key",
+                    name: "BillLine_BillId_Fkey",
+                    references: {
+                        table: "Bill",
+                        field: "id",
+                    },
+                    onDelete: "cascade",
+                    onUpdate: "cascade",
+                })
+            )
+            .then(() =>
+                queryInterface.addConstraint("BillLine", {
+                    fields: ["chartOfAccountId"],
+                    type: "foreign key",
+                    name: "BillLine_ChartOfAccountId_Fkey",
+                    references: {
+                        table: "ChartOfAccounts",
+                        field: "id",
+                    },
+                    onDelete: "restrict",
+                    onUpdate: "cascade",
+                })
+            );
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("BillLine");
+    },
+};

package/migrations/church/20261017170651-create-billAttachment.js

@@ -0,0 +1,43 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .createTable(
+                "BillAttachment",
+                {
+                    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                    billId: { type: DataTypes.INTEGER, allowNull: false },
+                    name: { type: DataTypes.STRING, allowNull: false },
+                    fileName: { type: DataTypes.STRING, allowNull: false },
+                    url: { type: DataTypes.STRING, allowNull: false },
+                    mimeType: { type: DataTypes.STRING, allowNull: true },
+                    size: { type: DataTypes.INTEGER, 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("BillAttachment", {
+                    fields: ["billId"],
+                    type: "foreign key",
+                    name: "BillAttachment_BillId_Fkey",
+                    references: {
+                        table: "Bill",
+                        field: "id",
+                    },
+                    onDelete: "cascade",
+                    onUpdate: "cascade",
+                })
+            );
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("BillAttachment");
+    },
+};

package/migrations/church/20261017170652-create-billPayment.js

@@ -0,0 +1,72 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .createTable(
+                "BillPayment",
+                {
+                    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                    billId: { type: DataTypes.INTEGER, allowNull: false },
+                    paymentDate: { type: DataTypes.DATEONLY, allowNull: false },
+                    amount: { type: DataTypes.DECIMAL(12, 2), allowNull: false },
+                    paidFromAccountId: { type: DataTypes.INTEGER, allowNull: false },
+                    method: { type: DataTypes.STRING, allowNull: true },
+                    reference: { type: DataTypes.STRING, allowNull: true },
+                    memo: { type: DataTypes.TEXT, allowNull: true },
+                    journalEntryId: { type: DataTypes.INTEGER, allowNull: true },
+                    createdBy: { type: DataTypes.INTEGER, 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("BillPayment", {
+                    fields: ["billId"],
+                    type: "foreign key",
+                    name: "BillPayment_BillId_Fkey",
+                    references: {
+                        table: "Bill",
+                        field: "id",
+                    },
+                    onDelete: "restrict",
+                    onUpdate: "cascade",
+                })
+            )
+            .then(() =>
+                queryInterface.addConstraint("BillPayment", {
+                    fields: ["paidFromAccountId"],
+                    type: "foreign key",
+                    name: "BillPayment_PaidFromAccountId_Fkey",
+                    references: {
+                        table: "ChartOfAccounts",
+                        field: "id",
+                    },
+                    onDelete: "restrict",
+                    onUpdate: "cascade",
+                })
+            )
+            .then(() =>
+                queryInterface.addConstraint("BillPayment", {
+                    fields: ["journalEntryId"],
+                    type: "foreign key",
+                    name: "BillPayment_JournalEntryId_Fkey",
+                    references: {
+                        table: "JournalEntry",
+                        field: "id",
+                    },
+                    onDelete: "set null",
+                    onUpdate: "cascade",
+                })
+            );
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("BillPayment");
+    },
+};

package/migrations/church/20261023090000-create-customer.js

@@ -0,0 +1,46 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .createTable(
+                "Customer",
+                {
+                    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                    name: { type: DataTypes.STRING, allowNull: false, unique: true },
+                    email: { type: DataTypes.STRING, allowNull: true },
+                    phone: { type: DataTypes.STRING, allowNull: true },
+                    addressLine1: { type: DataTypes.STRING, allowNull: true },
+                    addressLine2: { type: DataTypes.STRING, allowNull: true },
+                    defaultTerms: { type: DataTypes.STRING, allowNull: true },
+                    defaultChartOfAccountId: { type: DataTypes.INTEGER, allowNull: true },
+                    notes: { type: DataTypes.TEXT, allowNull: 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("Customer", {
+                    fields: ["defaultChartOfAccountId"],
+                    type: "foreign key",
+                    name: "Customer_DefaultChartOfAccountId_Fkey",
+                    references: {
+                        table: "ChartOfAccounts",
+                        field: "id",
+                    },
+                    onDelete: "set null",
+                    onUpdate: "cascade",
+                })
+            );
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("Customer");
+    },
+};

package/migrations/church/20261023090001-create-invoice.js

@@ -0,0 +1,71 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .createTable(
+                "Invoice",
+                {
+                    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                    invoiceNo: { type: DataTypes.STRING, allowNull: false, unique: true },
+                    customerId: { type: DataTypes.INTEGER, allowNull: false },
+                    reference: { type: DataTypes.STRING, allowNull: true },
+                    description: { type: DataTypes.TEXT, allowNull: true },
+                    invoiceDate: { type: DataTypes.DATEONLY, allowNull: true },
+                    dueDate: { type: DataTypes.DATEONLY, allowNull: true },
+                    terms: { type: DataTypes.STRING, allowNull: true },
+                    currency: { type: DataTypes.STRING, defaultValue: "USD" },
+                    memo: { type: DataTypes.TEXT, allowNull: true },
+                    notes: { type: DataTypes.TEXT, allowNull: true },
+                    status: { type: DataTypes.STRING, defaultValue: "Draft" },
+                    subtotal: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+                    discount: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+                    amount: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+                    amountPaid: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+                    amountDue: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+                    paidDate: { type: DataTypes.DATEONLY, allowNull: true },
+                    journalEntryId: { type: DataTypes.INTEGER, allowNull: true },
+                    createdBy: { type: DataTypes.INTEGER, 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("Invoice", {
+                    fields: ["customerId"],
+                    type: "foreign key",
+                    name: "Invoice_CustomerId_Fkey",
+                    references: {
+                        table: "Customer",
+                        field: "id",
+                    },
+                    onDelete: "restrict",
+                    onUpdate: "cascade",
+                })
+            )
+            .then(() =>
+                queryInterface.addConstraint("Invoice", {
+                    fields: ["journalEntryId"],
+                    type: "foreign key",
+                    name: "Invoice_JournalEntryId_Fkey",
+                    references: {
+                        table: "JournalEntry",
+                        field: "id",
+                    },
+                    onDelete: "set null",
+                    onUpdate: "cascade",
+                })
+            )
+            .then(() => queryInterface.addIndex("Invoice", ["status"]))
+            .then(() => queryInterface.addIndex("Invoice", ["dueDate"]));
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("Invoice");
+    },
+};

package/migrations/church/20261023090002-create-invoiceLine.js

@@ -0,0 +1,57 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .createTable(
+                "InvoiceLine",
+                {
+                    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                    invoiceId: { type: DataTypes.INTEGER, allowNull: false },
+                    chartOfAccountId: { type: DataTypes.INTEGER, allowNull: true },
+                    description: { type: DataTypes.TEXT, allowNull: true },
+                    quantity: { type: DataTypes.DECIMAL(12, 2), defaultValue: 1 },
+                    rate: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+                    amount: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+                    sortOrder: { type: DataTypes.INTEGER, defaultValue: 0 },
+                    createdAt: {
+                        type: DataTypes.DATE,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                    updatedAt: {
+                        type: DataTypes.DATE,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                },
+                { timestamps: false }
+            )
+            .then(() =>
+                queryInterface.addConstraint("InvoiceLine", {
+                    fields: ["invoiceId"],
+                    type: "foreign key",
+                    name: "InvoiceLine_InvoiceId_Fkey",
+                    references: {
+                        table: "Invoice",
+                        field: "id",
+                    },
+                    onDelete: "cascade",
+                    onUpdate: "cascade",
+                })
+            )
+            .then(() =>
+                queryInterface.addConstraint("InvoiceLine", {
+                    fields: ["chartOfAccountId"],
+                    type: "foreign key",
+                    name: "InvoiceLine_ChartOfAccountId_Fkey",
+                    references: {
+                        table: "ChartOfAccounts",
+                        field: "id",
+                    },
+                    onDelete: "restrict",
+                    onUpdate: "cascade",
+                })
+            );
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("InvoiceLine");
+    },
+};

package/migrations/church/20261023090003-create-invoicePayment.js

@@ -0,0 +1,72 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .createTable(
+                "InvoicePayment",
+                {
+                    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                    invoiceId: { type: DataTypes.INTEGER, allowNull: false },
+                    paymentDate: { type: DataTypes.DATEONLY, allowNull: false },
+                    amount: { type: DataTypes.DECIMAL(12, 2), allowNull: false },
+                    depositToAccountId: { type: DataTypes.INTEGER, allowNull: false },
+                    method: { type: DataTypes.STRING, allowNull: true },
+                    reference: { type: DataTypes.STRING, allowNull: true },
+                    memo: { type: DataTypes.TEXT, allowNull: true },
+                    journalEntryId: { type: DataTypes.INTEGER, allowNull: true },
+                    createdBy: { type: DataTypes.INTEGER, 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("InvoicePayment", {
+                    fields: ["invoiceId"],
+                    type: "foreign key",
+                    name: "InvoicePayment_InvoiceId_Fkey",
+                    references: {
+                        table: "Invoice",
+                        field: "id",
+                    },
+                    onDelete: "restrict",
+                    onUpdate: "cascade",
+                })
+            )
+            .then(() =>
+                queryInterface.addConstraint("InvoicePayment", {
+                    fields: ["depositToAccountId"],
+                    type: "foreign key",
+                    name: "InvoicePayment_DepositToAccountId_Fkey",
+                    references: {
+                        table: "ChartOfAccounts",
+                        field: "id",
+                    },
+                    onDelete: "restrict",
+                    onUpdate: "cascade",
+                })
+            )
+            .then(() =>
+                queryInterface.addConstraint("InvoicePayment", {
+                    fields: ["journalEntryId"],
+                    type: "foreign key",
+                    name: "InvoicePayment_JournalEntryId_Fkey",
+                    references: {
+                        table: "JournalEntry",
+                        field: "id",
+                    },
+                    onDelete: "set null",
+                    onUpdate: "cascade",
+                })
+            );
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("InvoicePayment");
+    },
+};

package/models/church/bill.js

@@ -0,0 +1,83 @@
+const { BILL_STATUS, BILL_TAX_MODE } = require("../../constants");
+
+module.exports = (sequelize, DataTypes) => {
+    const bill = sequelize.define(
+        "Bill",
+        {
+            id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            billNo: { type: DataTypes.STRING, allowNull: false, unique: true },
+            vendorId: { type: DataTypes.INTEGER, allowNull: false },
+            reference: { type: DataTypes.STRING, allowNull: true },
+            description: { type: DataTypes.TEXT, allowNull: true },
+            billDate: { type: DataTypes.DATEONLY, allowNull: true },
+            dueDate: { type: DataTypes.DATEONLY, allowNull: true },
+            terms: { type: DataTypes.STRING, allowNull: true },
+            currency: { type: DataTypes.STRING, defaultValue: "USD" },
+            memo: { type: DataTypes.TEXT, allowNull: true },
+            notes: { type: DataTypes.TEXT, allowNull: true },
+            status: { type: DataTypes.STRING, defaultValue: BILL_STATUS.DRAFT },
+            taxMode: { type: DataTypes.STRING, defaultValue: BILL_TAX_MODE.EXCLUSIVE },
+            subtotal: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+            tax: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+            discount: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+            amount: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+            amountPaid: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+            amountDue: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+            paidDate: { type: DataTypes.DATEONLY, allowNull: true },
+            journalEntryId: { type: DataTypes.INTEGER, allowNull: true },
+            createdBy: { type: DataTypes.INTEGER, allowNull: true },
+            createdAt: { type: DataTypes.DATE },
+            updatedAt: { type: DataTypes.DATE },
+        },
+        { freezeTableName: true, timestamps: false }
+    );
+    bill.associate = function (models) {
+        bill.belongsTo(models.vendor, {
+            foreignKey: "vendorId",
+            as: "vendor",
+        });
+        bill.belongsTo(models.journalEntry, {
+            foreignKey: "journalEntryId",
+            as: "journalEntry",
+        });
+        bill.hasMany(models.billLine, {
+            foreignKey: "billId",
+            as: "billLines",
+        });
+        bill.hasMany(models.billAttachment, {
+            foreignKey: "billId",
+            as: "billAttachments",
+        });
+        bill.hasMany(models.billPayment, {
+            foreignKey: "billId",
+            as: "billPayments",
+        });
+    };
+    bill.selectedFields = [
+        "id",
+        "billNo",
+        "vendorId",
+        "reference",
+        "description",
+        "billDate",
+        "dueDate",
+        "terms",
+        "currency",
+        "memo",
+        "notes",
+        "status",
+        "taxMode",
+        "subtotal",
+        "tax",
+        "discount",
+        "amount",
+        "amountPaid",
+        "amountDue",
+        "paidDate",
+        "journalEntryId",
+        "createdBy",
+        "createdAt",
+        "updatedAt",
+    ];
+    return bill;
+};

package/models/church/billAttachment.js

@@ -0,0 +1,34 @@
+module.exports = (sequelize, DataTypes) => {
+    const billAttachment = sequelize.define(
+        "BillAttachment",
+        {
+            id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            billId: { type: DataTypes.INTEGER, allowNull: false },
+            name: { type: DataTypes.STRING, allowNull: false },
+            fileName: { type: DataTypes.STRING, allowNull: false },
+            url: { type: DataTypes.STRING, allowNull: false },
+            mimeType: { type: DataTypes.STRING, allowNull: true },
+            size: { type: DataTypes.INTEGER, allowNull: true },
+            createdAt: { type: DataTypes.DATE },
+            updatedAt: { type: DataTypes.DATE },
+        },
+        { freezeTableName: true, timestamps: false }
+    );
+    billAttachment.associate = function (models) {
+        billAttachment.belongsTo(models.bill, {
+            foreignKey: "billId",
+            as: "bill",
+        });
+    };
+    billAttachment.selectedFields = [
+        "id",
+        "billId",
+        "name",
+        "fileName",
+        "url",
+        "mimeType",
+        "size",
+        "createdAt",
+    ];
+    return billAttachment;
+};

package/models/church/billLine.js

@@ -0,0 +1,47 @@
+module.exports = (sequelize, DataTypes) => {
+    const billLine = sequelize.define(
+        "BillLine",
+        {
+            id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            billId: { type: DataTypes.INTEGER, allowNull: false },
+            chartOfAccountId: { type: DataTypes.INTEGER, allowNull: true },
+            description: { type: DataTypes.TEXT, allowNull: true },
+            className: { type: DataTypes.STRING, allowNull: true },
+            amount: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+            taxRate: { type: DataTypes.DECIMAL(6, 4), defaultValue: 0 },
+            taxLabel: { type: DataTypes.STRING, allowNull: true },
+            netAmount: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+            taxAmount: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+            total: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+            sortOrder: { type: DataTypes.INTEGER, defaultValue: 0 },
+            createdAt: { type: DataTypes.DATE },
+            updatedAt: { type: DataTypes.DATE },
+        },
+        { freezeTableName: true, timestamps: false }
+    );
+    billLine.associate = function (models) {
+        billLine.belongsTo(models.bill, {
+            foreignKey: "billId",
+            as: "bill",
+        });
+        billLine.belongsTo(models.chartOfAccounts, {
+            foreignKey: "chartOfAccountId",
+            as: "chartOfAccount",
+        });
+    };
+    billLine.selectedFields = [
+        "id",
+        "billId",
+        "chartOfAccountId",
+        "description",
+        "className",
+        "amount",
+        "taxRate",
+        "taxLabel",
+        "netAmount",
+        "taxAmount",
+        "total",
+        "sortOrder",
+    ];
+    return billLine;
+};

package/models/church/billPayment.js

@@ -0,0 +1,48 @@
+module.exports = (sequelize, DataTypes) => {
+    const billPayment = sequelize.define(
+        "BillPayment",
+        {
+            id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            billId: { type: DataTypes.INTEGER, allowNull: false },
+            paymentDate: { type: DataTypes.DATEONLY, allowNull: false },
+            amount: { type: DataTypes.DECIMAL(12, 2), allowNull: false },
+            paidFromAccountId: { type: DataTypes.INTEGER, allowNull: false },
+            method: { type: DataTypes.STRING, allowNull: true },
+            reference: { type: DataTypes.STRING, allowNull: true },
+            memo: { type: DataTypes.TEXT, allowNull: true },
+            journalEntryId: { type: DataTypes.INTEGER, allowNull: true },
+            createdBy: { type: DataTypes.INTEGER, allowNull: true },
+            createdAt: { type: DataTypes.DATE },
+            updatedAt: { type: DataTypes.DATE },
+        },
+        { freezeTableName: true, timestamps: false }
+    );
+    billPayment.associate = function (models) {
+        billPayment.belongsTo(models.bill, {
+            foreignKey: "billId",
+            as: "bill",
+        });
+        billPayment.belongsTo(models.chartOfAccounts, {
+            foreignKey: "paidFromAccountId",
+            as: "paidFromAccount",
+        });
+        billPayment.belongsTo(models.journalEntry, {
+            foreignKey: "journalEntryId",
+            as: "journalEntry",
+        });
+    };
+    billPayment.selectedFields = [
+        "id",
+        "billId",
+        "paymentDate",
+        "amount",
+        "paidFromAccountId",
+        "method",
+        "reference",
+        "memo",
+        "journalEntryId",
+        "createdBy",
+        "createdAt",
+    ];
+    return billPayment;
+};

package/models/church/customer.js

@@ -0,0 +1,45 @@
+module.exports = (sequelize, DataTypes) => {
+    const customer = sequelize.define(
+        "Customer",
+        {
+            id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            name: { type: DataTypes.STRING, allowNull: false, unique: true },
+            email: { type: DataTypes.STRING, allowNull: true },
+            phone: { type: DataTypes.STRING, allowNull: true },
+            addressLine1: { type: DataTypes.STRING, allowNull: true },
+            addressLine2: { type: DataTypes.STRING, allowNull: true },
+            defaultTerms: { type: DataTypes.STRING, allowNull: true },
+            defaultChartOfAccountId: { type: DataTypes.INTEGER, allowNull: true },
+            notes: { type: DataTypes.TEXT, allowNull: true },
+            status: { type: DataTypes.BOOLEAN, defaultValue: true },
+            createdAt: { type: DataTypes.DATE },
+            updatedAt: { type: DataTypes.DATE },
+        },
+        { freezeTableName: true, timestamps: false }
+    );
+    customer.associate = function (models) {
+        customer.belongsTo(models.chartOfAccounts, {
+            foreignKey: "defaultChartOfAccountId",
+            as: "defaultChartOfAccount",
+        });
+        customer.hasMany(models.invoice, {
+            foreignKey: "customerId",
+            as: "invoices",
+        });
+    };
+    customer.selectedFields = [
+        "id",
+        "name",
+        "email",
+        "phone",
+        "addressLine1",
+        "addressLine2",
+        "defaultTerms",
+        "defaultChartOfAccountId",
+        "notes",
+        "status",
+        "createdAt",
+        "updatedAt",
+    ];
+    return customer;
+};

package/models/church/invoice.js

@@ -0,0 +1,75 @@
+const { INVOICE_STATUS } = require("../../constants");
+
+module.exports = (sequelize, DataTypes) => {
+    const invoice = sequelize.define(
+        "Invoice",
+        {
+            id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            invoiceNo: { type: DataTypes.STRING, allowNull: false, unique: true },
+            customerId: { type: DataTypes.INTEGER, allowNull: false },
+            reference: { type: DataTypes.STRING, allowNull: true },
+            description: { type: DataTypes.TEXT, allowNull: true },
+            invoiceDate: { type: DataTypes.DATEONLY, allowNull: true },
+            dueDate: { type: DataTypes.DATEONLY, allowNull: true },
+            terms: { type: DataTypes.STRING, allowNull: true },
+            currency: { type: DataTypes.STRING, defaultValue: "USD" },
+            memo: { type: DataTypes.TEXT, allowNull: true },
+            notes: { type: DataTypes.TEXT, allowNull: true },
+            status: { type: DataTypes.STRING, defaultValue: INVOICE_STATUS.DRAFT },
+            subtotal: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+            discount: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+            amount: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+            amountPaid: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+            amountDue: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+            paidDate: { type: DataTypes.DATEONLY, allowNull: true },
+            journalEntryId: { type: DataTypes.INTEGER, allowNull: true },
+            createdBy: { type: DataTypes.INTEGER, allowNull: true },
+            createdAt: { type: DataTypes.DATE },
+            updatedAt: { type: DataTypes.DATE },
+        },
+        { freezeTableName: true, timestamps: false }
+    );
+    invoice.associate = function (models) {
+        invoice.belongsTo(models.customer, {
+            foreignKey: "customerId",
+            as: "customer",
+        });
+        invoice.belongsTo(models.journalEntry, {
+            foreignKey: "journalEntryId",
+            as: "journalEntry",
+        });
+        invoice.hasMany(models.invoiceLine, {
+            foreignKey: "invoiceId",
+            as: "invoiceLines",
+        });
+        invoice.hasMany(models.invoicePayment, {
+            foreignKey: "invoiceId",
+            as: "invoicePayments",
+        });
+    };
+    invoice.selectedFields = [
+        "id",
+        "invoiceNo",
+        "customerId",
+        "reference",
+        "description",
+        "invoiceDate",
+        "dueDate",
+        "terms",
+        "currency",
+        "memo",
+        "notes",
+        "status",
+        "subtotal",
+        "discount",
+        "amount",
+        "amountPaid",
+        "amountDue",
+        "paidDate",
+        "journalEntryId",
+        "createdBy",
+        "createdAt",
+        "updatedAt",
+    ];
+    return invoice;
+};

package/models/church/invoiceLine.js

@@ -0,0 +1,39 @@
+module.exports = (sequelize, DataTypes) => {
+    const invoiceLine = sequelize.define(
+        "InvoiceLine",
+        {
+            id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            invoiceId: { type: DataTypes.INTEGER, allowNull: false },
+            chartOfAccountId: { type: DataTypes.INTEGER, allowNull: true },
+            description: { type: DataTypes.TEXT, allowNull: true },
+            quantity: { type: DataTypes.DECIMAL(12, 2), defaultValue: 1 },
+            rate: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+            amount: { type: DataTypes.DECIMAL(12, 2), defaultValue: 0 },
+            sortOrder: { type: DataTypes.INTEGER, defaultValue: 0 },
+            createdAt: { type: DataTypes.DATE },
+            updatedAt: { type: DataTypes.DATE },
+        },
+        { freezeTableName: true, timestamps: false }
+    );
+    invoiceLine.associate = function (models) {
+        invoiceLine.belongsTo(models.invoice, {
+            foreignKey: "invoiceId",
+            as: "invoice",
+        });
+        invoiceLine.belongsTo(models.chartOfAccounts, {
+            foreignKey: "chartOfAccountId",
+            as: "chartOfAccount",
+        });
+    };
+    invoiceLine.selectedFields = [
+        "id",
+        "invoiceId",
+        "chartOfAccountId",
+        "description",
+        "quantity",
+        "rate",
+        "amount",
+        "sortOrder",
+    ];
+    return invoiceLine;
+};

package/models/church/invoicePayment.js

@@ -0,0 +1,48 @@
+module.exports = (sequelize, DataTypes) => {
+    const invoicePayment = sequelize.define(
+        "InvoicePayment",
+        {
+            id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            invoiceId: { type: DataTypes.INTEGER, allowNull: false },
+            paymentDate: { type: DataTypes.DATEONLY, allowNull: false },
+            amount: { type: DataTypes.DECIMAL(12, 2), allowNull: false },
+            depositToAccountId: { type: DataTypes.INTEGER, allowNull: false },
+            method: { type: DataTypes.STRING, allowNull: true },
+            reference: { type: DataTypes.STRING, allowNull: true },
+            memo: { type: DataTypes.TEXT, allowNull: true },
+            journalEntryId: { type: DataTypes.INTEGER, allowNull: true },
+            createdBy: { type: DataTypes.INTEGER, allowNull: true },
+            createdAt: { type: DataTypes.DATE },
+            updatedAt: { type: DataTypes.DATE },
+        },
+        { freezeTableName: true, timestamps: false }
+    );
+    invoicePayment.associate = function (models) {
+        invoicePayment.belongsTo(models.invoice, {
+            foreignKey: "invoiceId",
+            as: "invoice",
+        });
+        invoicePayment.belongsTo(models.chartOfAccounts, {
+            foreignKey: "depositToAccountId",
+            as: "depositToAccount",
+        });
+        invoicePayment.belongsTo(models.journalEntry, {
+            foreignKey: "journalEntryId",
+            as: "journalEntry",
+        });
+    };
+    invoicePayment.selectedFields = [
+        "id",
+        "invoiceId",
+        "paymentDate",
+        "amount",
+        "depositToAccountId",
+        "method",
+        "reference",
+        "memo",
+        "journalEntryId",
+        "createdBy",
+        "createdAt",
+    ];
+    return invoicePayment;
+};

package/models/church/vendor.js

@@ -0,0 +1,45 @@
+module.exports = (sequelize, DataTypes) => {
+    const vendor = sequelize.define(
+        "Vendor",
+        {
+            id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            name: { type: DataTypes.STRING, allowNull: false, unique: true },
+            email: { type: DataTypes.STRING, allowNull: true },
+            phone: { type: DataTypes.STRING, allowNull: true },
+            addressLine1: { type: DataTypes.STRING, allowNull: true },
+            addressLine2: { type: DataTypes.STRING, allowNull: true },
+            defaultTerms: { type: DataTypes.STRING, allowNull: true },
+            defaultChartOfAccountId: { type: DataTypes.INTEGER, allowNull: true },
+            notes: { type: DataTypes.TEXT, allowNull: true },
+            status: { type: DataTypes.BOOLEAN, defaultValue: true },
+            createdAt: { type: DataTypes.DATE },
+            updatedAt: { type: DataTypes.DATE },
+        },
+        { freezeTableName: true, timestamps: false }
+    );
+    vendor.associate = function (models) {
+        vendor.belongsTo(models.chartOfAccounts, {
+            foreignKey: "defaultChartOfAccountId",
+            as: "defaultChartOfAccount",
+        });
+        vendor.hasMany(models.bill, {
+            foreignKey: "vendorId",
+            as: "bills",
+        });
+    };
+    vendor.selectedFields = [
+        "id",
+        "name",
+        "email",
+        "phone",
+        "addressLine1",
+        "addressLine2",
+        "defaultTerms",
+        "defaultChartOfAccountId",
+        "notes",
+        "status",
+        "createdAt",
+        "updatedAt",
+    ];
+    return vendor;
+};

package/package.json

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

package/seeders/church/20261017170653-chartOfAccounts-accountsPayable.js

@@ -0,0 +1,44 @@
+"use strict";
+
+const { ACCOUNTS_PAYABLE_CODE, CHART_OF_ACCOUNTS } = require("../../constants");
+
+// The chartOfAccounts seeder is tracked in SequelizeData, so existing churches never re-run it.
+// This seeder adds the Accounts Payable account that bills post to.
+module.exports = {
+    up: async (queryInterface) => {
+        const account = CHART_OF_ACCOUNTS.find((a) => a.code === ACCOUNTS_PAYABLE_CODE);
+        const existingId = await queryInterface.rawSelect(
+            "ChartOfAccounts",
+            { where: { code: account.code } },
+            ["id"]
+        );
+        if (existingId) return;
+
+        const accountingAccountTypeId = await queryInterface.rawSelect(
+            "AccountingAccountTypes",
+            { where: { name: account.accountingAccountType } },
+            ["id"]
+        );
+        // Account types are seeded by 20260706170638-accountingAccountTypes; without them there is no chart to extend.
+        if (!accountingAccountTypeId) return;
+        const parentAccountId = await queryInterface.rawSelect(
+            "ChartOfAccounts",
+            { where: { code: account.parentCode } },
+            ["id"]
+        );
+        await queryInterface.bulkInsert("ChartOfAccounts", [
+            {
+                code: account.code,
+                name: account.name,
+                accountingAccountTypeId,
+                parentAccountId: parentAccountId || null,
+                isPostingAccount: account.isPostingAccount,
+                status: true,
+            },
+        ]);
+    },
+
+    down: async (queryInterface) => {
+        await queryInterface.bulkDelete("ChartOfAccounts", { code: ACCOUNTS_PAYABLE_CODE });
+    },
+};

package/seeders/church/20261023090004-chartOfAccounts-accountsReceivable.js

@@ -0,0 +1,44 @@
+"use strict";
+
+const { ACCOUNTS_RECEIVABLE_CODE, CHART_OF_ACCOUNTS } = require("../../constants");
+
+// The chartOfAccounts seeder is tracked in SequelizeData, so existing churches never re-run it.
+// This seeder adds the Accounts Receivable account that invoices post to.
+module.exports = {
+    up: async (queryInterface) => {
+        const account = CHART_OF_ACCOUNTS.find((a) => a.code === ACCOUNTS_RECEIVABLE_CODE);
+        const existingId = await queryInterface.rawSelect(
+            "ChartOfAccounts",
+            { where: { code: account.code } },
+            ["id"]
+        );
+        if (existingId) return;
+
+        const accountingAccountTypeId = await queryInterface.rawSelect(
+            "AccountingAccountTypes",
+            { where: { name: account.accountingAccountType } },
+            ["id"]
+        );
+        // Account types are seeded by 20260706170638-accountingAccountTypes; without them there is no chart to extend.
+        if (!accountingAccountTypeId) return;
+        const parentAccountId = await queryInterface.rawSelect(
+            "ChartOfAccounts",
+            { where: { code: account.parentCode } },
+            ["id"]
+        );
+        await queryInterface.bulkInsert("ChartOfAccounts", [
+            {
+                code: account.code,
+                name: account.name,
+                accountingAccountTypeId,
+                parentAccountId: parentAccountId || null,
+                isPostingAccount: account.isPostingAccount,
+                status: true,
+            },
+        ]);
+    },
+
+    down: async (queryInterface) => {
+        await queryInterface.bulkDelete("ChartOfAccounts", { code: ACCOUNTS_RECEIVABLE_CODE });
+    },
+};