@churchsoln/dbms 1.0.61 → 1.0.63

package/config/config.js

@@ -1,4 +1,10 @@
 require("dotenv").config();
+
+const seedTracking = {
+  seederStorage: "sequelize",
+  seederStorageTableName: "SequelizeData",
+};
+
 module.exports = {
   localdev: {
     user: "root",
@@ -9,6 +15,7 @@ module.exports = {
     port: "5432",
     dialect: "postgres",
     url: "postgres://root:root@localhost:5432/dbms",
+    ...seedTracking,
   },
   development: {
     user: process.env.POSTGRES_USER,
@@ -19,6 +26,7 @@ module.exports = {
     port: process.env.POSTGRES_PORT,
     dialect: "postgres",
     url: `postgres://${process.env.POSTGRES_USER}:${process.env.POSTGRES_PASSWORD}@${process.env.POSTGRES_HOST}:${process.env.POSTGRES_PORT}/${process.env.POSTGRES_DB}`,
+    ...seedTracking,
   },
   test: {
     user: process.env.POSTGRES_USER,
@@ -29,5 +37,6 @@ module.exports = {
     port: process.env.POSTGRES_PORT,
     dialect: "postgres",
     url: `postgres://${process.env.POSTGRES_USER}:${process.env.POSTGRES_PASSWORD}@${process.env.POSTGRES_HOST}:${process.env.POSTGRES_PORT}/${process.env.POSTGRES_DB}`,
+    ...seedTracking,
   },
 };

package/constants/index.js

@@ -81,6 +81,7 @@ const JOURNAL_ENTRY_SOURCE_TYPE = {
 
 const JOURNAL_ENTRY_STATUS = {
     POSTED: "posted",
+    DRAFT: "draft",
 };
 
 const ACCOUNTING_ACCOUNT_TYPES = {

package/db-setup.js

@@ -2,6 +2,7 @@ const { exec } = require("child_process");
 const { Sequelize } = require("sequelize");
 const env = process.env.NODE_ENV || "development";
 const config = require("./config/config")[env];
+const { backfillSeedTracking } = require("./utils/seedTracking");
 const rootSequelize = new Sequelize("postgres", config.username, "root", {
     host: config.host,
     dialect: config.dialect,
@@ -78,6 +79,10 @@ function runSeed() {
     try {
         await ensureDatabaseExists();
         await runMigrations();
+        await backfillSeedTracking({
+            connectionUrl: config.url,
+            kind: "common",
+        });
         await runSeed();
         console.log("Database setup and migrations complete.");
     } catch (error) {

package/package.json

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

package/utils/seedTracking.js

@@ -0,0 +1,95 @@
+"use strict";
+
+/**
+ * Seed tracking (migration-style via SequelizeData) for common and church DBs:
+ * - Fresh DB: no backfill → db:seed:all runs all seeders once → recorded in SequelizeData
+ * - Re-seed: skip applied files; only new seed files run
+ * - Tenant/common-deleted seeded rows stay deleted (old insert seeds never re-run)
+ * - Global data changes: add a new seed file; do not edit old seed files
+ */
+
+const fs = require("fs");
+const path = require("path");
+const Sequelize = require("sequelize");
+const { ONBOARD_STATUS } = require("../constants");
+
+const SEQUELIZE_DATA_TABLE = "SequelizeData";
+const SEEDERS_ROOT = path.join(__dirname, "..", "seeders");
+
+const listSeederFilenames = (seedersPath) =>
+    fs
+        .readdirSync(seedersPath)
+        .filter((file) => file.endsWith(".js") && !file.startsWith("."));
+
+const resolveSeedersPath = (kind) => path.join(SEEDERS_ROOT, kind === "common" ? "common" : "church");
+
+/**
+ * Ensure SequelizeData exists. When the DB was already seeded but has no tracking
+ * rows, mark all current seeder files as applied so the next db:seed:all only
+ * runs newly added seed files.
+ *
+ * @param {object} opts
+ * @param {string} opts.connectionUrl
+ * @param {"common"|"church"} opts.kind
+ * @param {string} [opts.seedStatus] church seedStatus (used when kind=church)
+ */
+const backfillSeedTracking = async ({ connectionUrl, kind, seedStatus }) => {
+    if (!connectionUrl) return;
+
+    const sequelize = new Sequelize(connectionUrl, {
+        dialectOptions: { multipleStatements: true },
+        logging: false,
+    });
+
+    try {
+        await sequelize.authenticate();
+        await sequelize.query(`
+            CREATE TABLE IF NOT EXISTS "${SEQUELIZE_DATA_TABLE}" (
+                "name" VARCHAR(255) NOT NULL PRIMARY KEY
+            );
+        `);
+
+        const [rows] = await sequelize.query(
+            `SELECT COUNT(*)::int AS count FROM "${SEQUELIZE_DATA_TABLE}"`
+        );
+        const count = rows?.[0]?.count ?? 0;
+        if (count > 0) return;
+
+        let shouldBackfill = false;
+        if (kind === "church") {
+            shouldBackfill = seedStatus === ONBOARD_STATUS.SEED_COMPLETED;
+        } else {
+            // Common has no seedStatus: backfill only if Role data already exists
+            try {
+                const [roleRows] = await sequelize.query(
+                    `SELECT COUNT(*)::int AS count FROM "Role"`
+                );
+                shouldBackfill = (roleRows?.[0]?.count ?? 0) > 0;
+            } catch {
+                shouldBackfill = false;
+            }
+        }
+        if (!shouldBackfill) return;
+
+        const seedersPath = resolveSeedersPath(kind);
+        const filenames = listSeederFilenames(seedersPath);
+        if (!filenames.length) return;
+
+        const values = filenames.map((name) => `('${name.replace(/'/g, "''")}')`).join(", ");
+        await sequelize.query(
+            `INSERT INTO "${SEQUELIZE_DATA_TABLE}" ("name") VALUES ${values} ON CONFLICT ("name") DO NOTHING`
+        );
+        console.log(
+            `Backfilled ${filenames.length} ${kind} seed file(s) into ${SEQUELIZE_DATA_TABLE}`
+        );
+    } finally {
+        await sequelize.close();
+    }
+};
+
+module.exports = {
+    backfillSeedTracking,
+    listSeederFilenames,
+    resolveSeedersPath,
+    SEQUELIZE_DATA_TABLE,
+};

package/workers/seed.js

@@ -3,53 +3,73 @@ const redisConfig = require("../redis/config");
 const commonDb = require("../models/common");
 const { exec } = require("child_process");
 const { WORKERS, ONBOARD_STATUS } = require("../constants");
+const { backfillSeedTracking } = require("../utils/seedTracking");
 
 const seedDb = async (seedData) => {
     return new Promise(async (resolve, reject) => {
-        const { id, connectionUrl, name, isCommonDb = false } = seedData;
+        const { id, connectionUrl, name, isCommonDb = false, seedStatus } = seedData;
+        const kind = isCommonDb ? "common" : "church";
         console.log(
-            `Applying seed for ${isCommonDb ? "common" : "church"} db: ${!isCommonDb ? name : ""}`
+            `Applying seed for ${kind} db: ${!isCommonDb ? name : ""}`
         );
-        if (!isCommonDb) {
-            await commonDb.church.update(
-                { seedStatus: ONBOARD_STATUS.SEED_IN_PROGRESS },
-                { where: { id } }
-            );
-        }
-        exec(
-            `DEBUG=sequelize:* npx sequelize-cli db:seed:all --url ${connectionUrl} --seeders-path ${
-                isCommonDb ? "./seeders/common" : "./seeders/church"
-            }`,
-            async (error, stdout, stderr) => {
-                if (error) {
-                    console.error(
-                        `Error applying seed for ${isCommonDb ? "common" : "church"} db: ${
+        try {
+            // Use original church seedStatus / common Role check before running
+            // so already-seeded DBs get SequelizeData backfilled and only new seeds run.
+            await backfillSeedTracking({
+                connectionUrl,
+                kind,
+                seedStatus,
+            });
+            if (!isCommonDb) {
+                await commonDb.church.update(
+                    { seedStatus: ONBOARD_STATUS.SEED_IN_PROGRESS },
+                    { where: { id } }
+                );
+            }
+            exec(
+                `DEBUG=sequelize:* npx sequelize-cli db:seed:all --url ${connectionUrl} --seeders-path ${
+                    isCommonDb ? "./seeders/common" : "./seeders/church"
+                }`,
+                async (error, stdout, stderr) => {
+                    if (error) {
+                        console.error(
+                            `Error applying seed for ${kind} db: ${
+                                !isCommonDb ? name : ""
+                            }`,
+                            error.message
+                        );
+                        if (!isCommonDb) {
+                            await commonDb.church.update(
+                                { seedStatus: ONBOARD_STATUS.SEED_FAILED },
+                                { where: { id } }
+                            );
+                        }
+                        reject(error);
+                        return;
+                    }
+                    console.log(
+                        `Seed applied for ${kind} db: ${
                             !isCommonDb ? name : ""
-                        }`,
-                        error.message
+                        }`
                     );
                     if (!isCommonDb) {
                         await commonDb.church.update(
-                            { seedStatus: ONBOARD_STATUS.SEED_FAILED },
+                            { seedStatus: ONBOARD_STATUS.SEED_COMPLETED },
                             { where: { id } }
                         );
                     }
-                    reject(error);
+                    resolve();
                 }
-                console.log(
-                    `Seed applied for ${isCommonDb ? "common" : "church"} db: ${
-                        !isCommonDb ? name : ""
-                    }`
+            );
+        } catch (err) {
+            if (!isCommonDb && id) {
+                await commonDb.church.update(
+                    { seedStatus: ONBOARD_STATUS.SEED_FAILED },
+                    { where: { id } }
                 );
-                if (!isCommonDb) {
-                    await commonDb.church.update(
-                        { seedStatus: ONBOARD_STATUS.SEED_COMPLETED },
-                        { where: { id } }
-                    );
-                }
-                resolve();
             }
-        );
+            reject(err);
+        }
     });
 };
 new Worker(