@churchsoln/dbms 1.0.63 → 1.0.65

package/migrations/church/20261026170654-update-journalEntryLine-add-reconciliation.js

@@ -0,0 +1,35 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .addColumn("JournalEntryLine", "cleared", {
+                type: DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: false,
+            })
+            .then(() =>
+                queryInterface.addColumn("JournalEntryLine", "bankReconciliationId", {
+                    type: DataTypes.INTEGER,
+                    allowNull: true,
+                })
+            )
+            .then(() =>
+                queryInterface.addConstraint("JournalEntryLine", {
+                    fields: ["bankReconciliationId"],
+                    type: "foreign key",
+                    name: "JournalEntryLine_BankReconciliationId_Fkey",
+                    references: {
+                        table: "BankReconciliation",
+                        field: "id",
+                    },
+                    onDelete: "set null",
+                    onUpdate: "cascade",
+                })
+            );
+    },
+    down: async (queryInterface) => {
+        await queryInterface.removeConstraint("JournalEntryLine", "JournalEntryLine_BankReconciliationId_Fkey");
+        await queryInterface.removeColumn("JournalEntryLine", "bankReconciliationId");
+        await queryInterface.removeColumn("JournalEntryLine", "cleared");
+    },
+};

package/models/church/bankReconciliation.js

@@ -0,0 +1,48 @@
+const { BANK_RECONCILIATION_STATUS } = require("../../constants");
+
+module.exports = (sequelize, DataTypes) => {
+    const bankReconciliation = sequelize.define(
+        "BankReconciliation",
+        {
+            id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            chartOfAccountId: { type: DataTypes.INTEGER, allowNull: false },
+            statementDate: { type: DataTypes.DATEONLY, allowNull: false },
+            statementEndingBalance: { type: DataTypes.DECIMAL(12, 2), allowNull: false },
+            beginningBalance: { type: DataTypes.DECIMAL(12, 2), allowNull: false },
+            clearedBalance: { type: DataTypes.DECIMAL(12, 2), allowNull: true },
+            difference: { type: DataTypes.DECIMAL(12, 2), allowNull: true },
+            status: { type: DataTypes.STRING, defaultValue: BANK_RECONCILIATION_STATUS.IN_PROGRESS },
+            startedAt: { type: DataTypes.DATE },
+            completedAt: { type: DataTypes.DATE, allowNull: true },
+            createdBy: { type: DataTypes.INTEGER, allowNull: true },
+            createdAt: { type: DataTypes.DATE },
+            updatedAt: { type: DataTypes.DATE },
+        },
+        { freezeTableName: true, timestamps: false }
+    );
+    bankReconciliation.associate = function (models) {
+        bankReconciliation.belongsTo(models.chartOfAccounts, {
+            foreignKey: "chartOfAccountId",
+            as: "chartOfAccount",
+        });
+        bankReconciliation.hasMany(models.journalEntryLine, {
+            foreignKey: "bankReconciliationId",
+            as: "clearedLines",
+        });
+    };
+    bankReconciliation.selectedFields = [
+        "id",
+        "chartOfAccountId",
+        "statementDate",
+        "statementEndingBalance",
+        "beginningBalance",
+        "clearedBalance",
+        "difference",
+        "status",
+        "startedAt",
+        "completedAt",
+        "createdBy",
+        "createdAt",
+    ];
+    return bankReconciliation;
+};

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

@@ -8,6 +8,10 @@ module.exports = (sequelize, DataTypes) => {
             debit: { type: DataTypes.DECIMAL(10, 2), defaultValue: 0 },
             credit: { type: DataTypes.DECIMAL(10, 2), defaultValue: 0 },
             memo: { type: DataTypes.TEXT, allowNull: true },
+            // Bank reconciliation: cleared is toggled while a reconciliation is in progress;
+            // bankReconciliationId is stamped once that reconciliation is completed, locking the line in.
+            cleared: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false },
+            bankReconciliationId: { type: DataTypes.INTEGER, allowNull: true },
             createdAt: { type: DataTypes.DATE },
             updatedAt: { type: DataTypes.DATE },
         },
@@ -22,6 +26,10 @@ module.exports = (sequelize, DataTypes) => {
             foreignKey: "chartOfAccountId",
             as: "chartOfAccount",
         });
+        journalEntryLine.belongsTo(models.bankReconciliation, {
+            foreignKey: "bankReconciliationId",
+            as: "bankReconciliation",
+        });
     };
     journalEntryLine.selectedFields = [
         "id",
@@ -30,6 +38,8 @@ module.exports = (sequelize, DataTypes) => {
         "debit",
         "credit",
         "memo",
+        "cleared",
+        "bankReconciliationId",
         "createdAt",
         "updatedAt",
     ];

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.63",
+    "version": "1.0.65",
     "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 });
+    },
+};