@churchsoln/dbms 1.0.46 → 1.0.48

package/migrations/church/20240919170629-create-contributionTransactionLine.js

@@ -1,75 +1,75 @@
-"use strict";
-module.exports = {
-    up: async (queryInterface, DataTypes) => {
-        await queryInterface
-            .createTable(
-                "ContributionTransactionLine",
-                {
-                    id: {
-                        type: DataTypes.INTEGER,
-                        autoIncrement: true,
-                        primaryKey: true,
-                    },
-                    contributionTransactionId: {
-                        type: DataTypes.INTEGER,
-                        allowNull: false,
-                        validate: {
-                            notNull: { msg: "Transaction ID is required" },
-                            isInt: { msg: "Transaction ID must be an integer" },
-                        },
-                        references: {
-                            model: "ContributionTransaction",
-                            key: "id",
-                        },
-                        onDelete: "CASCADE",
-                    },
-                    accountId: {
-                        type: DataTypes.INTEGER,
-                        allowNull: false,
-                        validate: {
-                            notNull: { msg: "Account ID is required" },
-                            isInt: { msg: "Account ID must be an integer" },
-                        },
-                        references: {
-                            model: "Accounts",
-                            key: "id",
-                        },
-                        onDelete: "SET NULL",
-                    },
-                    amount: {
-                        type: DataTypes.DECIMAL(10, 2),
-                        allowNull: false,
-                        validate: {
-                            notNull: { msg: "Amount is required" },
-                            isDecimal: { msg: "Amount must be a valid decimal" },
-                            minAmount(value) {
-                                if (parseFloat(value) <= 0) {
-                                throw new Error("Amount must be greater than 0");
-                                }
-                            },
-                        },
-                    },
-                    isLoosePlate: { type: DataTypes.BOOLEAN, defaultValue: false },
-                    isTaxable: {
-                        type: DataTypes.BOOLEAN,
-                        defaultValue: true,
-                    },
-                    memo: {
-                        type: DataTypes.TEXT,
-                    },
-                    createdAt: {
-                        type: DataTypes.DATE,
-                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
-                    },
-                    updatedAt: {
-                        type: DataTypes.DATE,
-                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
-                    },
-                },
-                { timestamps: false }
-            )
-    },
-    down: async (queryInterface) => {
-        await queryInterface.dropTable("ContributionTransactionLine");
-    },
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .createTable(
+                "ContributionTransactionLine",
+                {
+                    id: {
+                        type: DataTypes.INTEGER,
+                        autoIncrement: true,
+                        primaryKey: true,
+                    },
+                    contributionTransactionId: {
+                        type: DataTypes.INTEGER,
+                        allowNull: false,
+                        validate: {
+                            notNull: { msg: "Transaction ID is required" },
+                            isInt: { msg: "Transaction ID must be an integer" },
+                        },
+                        references: {
+                            model: "ContributionTransaction",
+                            key: "id",
+                        },
+                        onDelete: "CASCADE",
+                    },
+                    accountId: {
+                        type: DataTypes.INTEGER,
+                        allowNull: false,
+                        validate: {
+                            notNull: { msg: "Account ID is required" },
+                            isInt: { msg: "Account ID must be an integer" },
+                        },
+                        references: {
+                            model: "Accounts",
+                            key: "id",
+                        },
+                        onDelete: "SET NULL",
+                    },
+                    amount: {
+                        type: DataTypes.DECIMAL(10, 2),
+                        allowNull: false,
+                        validate: {
+                            notNull: { msg: "Amount is required" },
+                            isDecimal: { msg: "Amount must be a valid decimal" },
+                            minAmount(value) {
+                                if (parseFloat(value) <= 0) {
+                                throw new Error("Amount must be greater than 0");
+                                }
+                            },
+                        },
+                    },
+                    isLoosePlate: { type: DataTypes.BOOLEAN, defaultValue: false },
+                    isTaxable: {
+                        type: DataTypes.BOOLEAN,
+                        defaultValue: true,
+                    },
+                    memo: {
+                        type: DataTypes.TEXT,
+                    },
+                    createdAt: {
+                        type: DataTypes.DATE,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                    updatedAt: {
+                        type: DataTypes.DATE,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                },
+                { timestamps: false }
+            )
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("ContributionTransactionLine");
+    },
 }

package/migrations/church/20240919170630-update-groupMembers.js

@@ -1,77 +1,77 @@
-"use strict";
-
-module.exports = {
-    up: async (queryInterface, DataTypes) => {
-        // Remove the old foreign key constraint
-        await queryInterface.removeConstraint(
-            "GroupMembers",
-            "GroupMembers_UserId_Fkey"
-        );
-
-        // Remove the userId column
-        await queryInterface.removeColumn(
-            "GroupMembers",
-            "userId"
-        );
-
-        // Add the new memberId column
-        await queryInterface.addColumn(
-            "GroupMembers",
-            "memberId",
-            {
-                type: DataTypes.INTEGER,
-                allowNull: true
-            }
-        );
-
-        // Add the new foreign key constraint with memberId
-        await queryInterface.addConstraint("GroupMembers", {
-            fields: ["memberId"],
-            type: "foreign key",
-            name: "GroupMembers_MemberId_Fkey",
-            references: {
-                table: "Member",
-                field: "id",
-            },
-            onDelete: "cascade",
-            onUpdate: "cascade",
-        });
-    },
-
-    down: async (queryInterface, DataTypes) => {
-        // Remove the new foreign key constraint
-        await queryInterface.removeConstraint(
-            "GroupMembers",
-            "GroupMembers_MemberId_Fkey"
-        );
-
-        // Remove the memberId column
-        await queryInterface.removeColumn(
-            "GroupMembers",
-            "memberId"
-        );
-
-        // Add back the userId column
-        await queryInterface.addColumn(
-            "GroupMembers",
-            "userId",
-            {
-                type: DataTypes.INTEGER,
-                allowNull: true
-            }
-        );
-
-        // Restore the old foreign key constraint
-        await queryInterface.addConstraint("GroupMembers", {
-            fields: ["userId"],
-            type: "foreign key",
-            name: "GroupMembers_UserId_Fkey",
-            references: {
-                table: "User",
-                field: "id",
-            },
-            onDelete: "cascade",
-            onUpdate: "cascade",
-        });
-    }
-};
+"use strict";
+
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        // Remove the old foreign key constraint
+        await queryInterface.removeConstraint(
+            "GroupMembers",
+            "GroupMembers_UserId_Fkey"
+        );
+
+        // Remove the userId column
+        await queryInterface.removeColumn(
+            "GroupMembers",
+            "userId"
+        );
+
+        // Add the new memberId column
+        await queryInterface.addColumn(
+            "GroupMembers",
+            "memberId",
+            {
+                type: DataTypes.INTEGER,
+                allowNull: true
+            }
+        );
+
+        // Add the new foreign key constraint with memberId
+        await queryInterface.addConstraint("GroupMembers", {
+            fields: ["memberId"],
+            type: "foreign key",
+            name: "GroupMembers_MemberId_Fkey",
+            references: {
+                table: "Member",
+                field: "id",
+            },
+            onDelete: "cascade",
+            onUpdate: "cascade",
+        });
+    },
+
+    down: async (queryInterface, DataTypes) => {
+        // Remove the new foreign key constraint
+        await queryInterface.removeConstraint(
+            "GroupMembers",
+            "GroupMembers_MemberId_Fkey"
+        );
+
+        // Remove the memberId column
+        await queryInterface.removeColumn(
+            "GroupMembers",
+            "memberId"
+        );
+
+        // Add back the userId column
+        await queryInterface.addColumn(
+            "GroupMembers",
+            "userId",
+            {
+                type: DataTypes.INTEGER,
+                allowNull: true
+            }
+        );
+
+        // Restore the old foreign key constraint
+        await queryInterface.addConstraint("GroupMembers", {
+            fields: ["userId"],
+            type: "foreign key",
+            name: "GroupMembers_UserId_Fkey",
+            references: {
+                table: "User",
+                field: "id",
+            },
+            onDelete: "cascade",
+            onUpdate: "cascade",
+        });
+    }
+};

package/migrations/church/{20241204170631-create-pledgeCampaign.js → 20241204170631-create-pledgeAccount.js}

@@ -1,41 +1,55 @@
-"use strict";
-
-module.exports = {
-    up: async (queryInterface, DataTypes) => {
-        await queryInterface.createTable(
-            "PledgeAccount",
-            {
-                id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
-                accountId: { type: DataTypes.INTEGER },
-                name: { type: DataTypes.STRING },
-                description: { type: DataTypes.TEXT },
-                pledged: { type: DataTypes.INTEGER },
-                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("PledgeAccount", {
-                    fields: ["accountId"],
-                    type: "foreign key",
-                    name: "PledgeAccount_AccountId_Fkey",
-                    references: {
-                        table: "Accounts",
-                        field: "id",
-                    },
-                    onDelete: "cascade",
-                    onUpdate: "cascade",
-                })
-            );;
-    },
-    down: async (queryInterface) => {
-        await queryInterface.dropTable("PledgeAccount");
-    },
-};
+"use strict";
+
+const { MEMBER_STATUS } = require("../../constants");
+
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface.createTable(
+            "PledgeAccount",
+            {
+                id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                accountId: { type: DataTypes.INTEGER },
+                name: { type: DataTypes.STRING },
+                description: { type: DataTypes.TEXT },
+                isTaxable: { type: DataTypes.BOOLEAN, defaultValue: false },
+                status: {
+                    type: DataTypes.STRING,
+                    defaultValue: MEMBER_STATUS.ACTIVE,
+                    validate: {
+                        isIn: [
+                            [
+                                MEMBER_STATUS.ACTIVE,
+                                MEMBER_STATUS.INACTIVE,
+                            ],
+                        ],
+                    },
+                },
+                pledged: { type: DataTypes.INTEGER },
+                createdAt: {
+                    type: DataTypes.DATE,
+                    defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                },
+                updatedAt: {
+                    type: DataTypes.DATE,
+                    defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                },
+            },
+            { timestamps: false }
+        ).then(() =>
+                queryInterface.addConstraint("PledgeAccount", {
+                    fields: ["accountId"],
+                    type: "foreign key",
+                    name: "PledgeAccount_AccountId_Fkey",
+                    references: {
+                        table: "Accounts",
+                        field: "id",
+                    },
+                    onDelete: "cascade",
+                    onUpdate: "cascade",
+                })
+            );;
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("PledgeAccount");
+    },
+};

package/migrations/church/20241204170632-create-memberStatus.js

@@ -0,0 +1,26 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface.createTable(
+            "MemberStatus",
+            {
+                id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                name: { type: DataTypes.STRING },
+                isEditable: { type: DataTypes.BOOLEAN, defaultValue: true },
+                status: { type: DataTypes.BOOLEAN, defaultValue: true },
+                createdAt: {
+                    type: DataTypes.DATE,
+                    defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                },
+                updatedAt: {
+                    type: DataTypes.DATE,
+                    defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                },
+            },
+            { timestamps: false }
+        );
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("MemberStatus");
+    },
+};

package/migrations/church/20241204170633-update-member.js

@@ -0,0 +1,33 @@
+"use strict";
+
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface.removeColumn(
+            "Member",
+            "memberStatus"
+        );
+
+        await queryInterface.addColumn(
+            "Member",
+            "memberStatusId",
+            {
+                type: DataTypes.INTEGER,
+                allowNull: true
+            }
+        );
+
+        await queryInterface.addConstraint("Member", {
+            fields: ["memberStatusId"],
+            type: "foreign key",
+            name: "Member_MemberStatusId_Fkey",
+            references: {
+                table: "MemberStatus",
+                field: "id",
+            },
+            onDelete: "cascade",
+            onUpdate: "cascade",
+        });
+    },
+
+    down: async (queryInterface, DataTypes) => {}
+};

package/migrations/church/20241204170634-update-membership.js

@@ -0,0 +1,33 @@
+"use strict";
+
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface.removeColumn(
+            "Membership",
+            "memberStatus"
+        );
+
+        await queryInterface.addColumn(
+            "Membership",
+            "memberStatusId",
+            {
+                type: DataTypes.INTEGER,
+                allowNull: true
+            }
+        );
+
+        await queryInterface.addConstraint("Membership", {
+            fields: ["memberStatusId"],
+            type: "foreign key",
+            name: "Membership_MemberStatusId_Fkey",
+            references: {
+                table: "MemberStatus",
+                field: "id",
+            },
+            onDelete: "cascade",
+            onUpdate: "cascade",
+        });
+    },
+
+    down: async (queryInterface, DataTypes) => {}
+};

package/migrations/church/20241204170635-update-pledge.js

@@ -0,0 +1,33 @@
+"use strict";
+
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface.removeColumn(
+            "Pledge",
+            "accountId"
+        );
+
+        await queryInterface.addColumn(
+            "Pledge",
+            "pledgeAccountId",
+            {
+                type: DataTypes.INTEGER,
+                allowNull: true
+            }
+        );
+
+        await queryInterface.addConstraint("Pledge", {
+            fields: ["pledgeAccountId"],
+            type: "foreign key",
+            name: "Pledge_PledgeAccountId_Fkey",
+            references: {
+                table: "PledgeAccount",
+                field: "id",
+            },
+            onDelete: "cascade",
+            onUpdate: "cascade",
+        });
+    },
+
+    down: async (queryInterface, DataTypes) => {}
+};

package/migrations/church/20241204170636-update-contributionTransactionLine.js

@@ -0,0 +1,33 @@
+"use strict";
+
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface.removeColumn(
+            "ContributionTransactionLine",
+            "accountId"
+        );
+
+        await queryInterface.addColumn(
+            "ContributionTransactionLine",
+            "pledgeAccountId",
+            {
+                type: DataTypes.INTEGER,
+                allowNull: true
+            }
+        );
+
+        await queryInterface.addConstraint("ContributionTransactionLine", {
+            fields: ["pledgeAccountId"],
+            type: "foreign key",
+            name: "ContributionTxnLine_PledgeAccountId_Fkey",
+            references: {
+                table: "PledgeAccount",
+                field: "id",
+            },
+            onDelete: "cascade",
+            onUpdate: "cascade",
+        });
+    },
+
+    down: async (queryInterface, DataTypes) => {}
+};

package/migrations/common/20221226140655-create-subscriptionPlan.js

@@ -1,31 +1,31 @@
-"use strict";
-module.exports = {
-    up: async (queryInterface, DataTypes) => {
-        await queryInterface.createTable(
-            "SubscriptionPlan",
-            {
-                id: {
-                    type: DataTypes.INTEGER,
-                    primaryKey: true,
-                    autoIncrement: true,
-                },
-                name: { type: DataTypes.STRING },
-                isFree: { type: DataTypes.BOOLEAN, defaultValue: false },
-                isCustom: { type: DataTypes.BOOLEAN, defaultValue: false },
-                status: { type: DataTypes.BOOLEAN, defaultValue: true },
-                createdAt: {
-                    type: DataTypes.DATE,
-                    defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
-                },
-                updatedAt: {
-                    type: DataTypes.DATE,
-                    defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
-                },
-            },
-            { timestamps: false }
-        );
-    },
-    down: async (queryInterface) => {
-        await queryInterface.dropTable("SubscriptionPlan");
-    },
-};
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface.createTable(
+            "SubscriptionPlan",
+            {
+                id: {
+                    type: DataTypes.INTEGER,
+                    primaryKey: true,
+                    autoIncrement: true,
+                },
+                name: { type: DataTypes.STRING },
+                isFree: { type: DataTypes.BOOLEAN, defaultValue: false },
+                isCustom: { type: DataTypes.BOOLEAN, defaultValue: false },
+                status: { type: DataTypes.BOOLEAN, defaultValue: true },
+                createdAt: {
+                    type: DataTypes.DATE,
+                    defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                },
+                updatedAt: {
+                    type: DataTypes.DATE,
+                    defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                },
+            },
+            { timestamps: false }
+        );
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("SubscriptionPlan");
+    },
+};