Installed node settings hook

forge/db/migrations/20260717-01-add-node-red-node-version.js

@@ -0,0 +1,46 @@
+const { DataTypes } = require('sequelize')
+
+module.exports = {
+    /**
+     * upgrade database
+     * @param {QueryInterface} context Sequelize.QueryInterface
+     */
+    up: async (context, Sequelize) => {
+        await context.createTable('NodeREDNodeVersions', {
+            id: {
+                type: DataTypes.INTEGER,
+                primaryKey: true,
+                autoIncrement: true
+            },
+            ownerId: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            ownerType: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            name: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            currentVersion: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            latestVersion: {
+                type: DataTypes.STRING,
+                allowNull: true
+            },
+            createdAt: {
+                type: DataTypes.DATE,
+                allowNull: false
+            },
+            updatedAt: {
+                type: DataTypes.DATE,
+                allowNull: false
+            }
+        })
+    },
+    down: async (context, Sequelize) => {}
+}

forge/db/models/NodeREDNodeVersions.js

@@ -0,0 +1,66 @@
+/**
+ * Which nodes are installed in which Instances
+ * @namespace forge.db.models.NodeREDNodeVersion
+ * // type helpers for design time help and error checking
+ * @typedef {import('sequelize').Model} Model
+ * @typedef {import('sequelize').ModelAttributes} ModelAttributes
+ * @typedef {import('sequelize').SchemaOptions} SchemaOptions
+ * @typedef {import('sequelize').ModelIndexesOptions} ModelIndexesOptions
+ * @typedef {import('sequelize').InitOptions} InitOptions
+ * @typedef {import('sequelize').ModelScopeOptions} ModelScopeOptions
+ * @typedef {{name: string, schema: ModelAttributes, model: Model, indexes?: ModelIndexesOptions[], scopes?: ModelScopeOptions, options?: InitOptions}} FFModel
+ */
+
+const { DataTypes } = require('sequelize')
+
+/** @type {FFModel} */
+module.exports = {
+    name: 'NodeREDNodeVersions',
+    schema: {
+        id: {
+            type: DataTypes.INTEGER,
+            primaryKey: true,
+            autoIncrement: true
+        },
+        ownerId: {
+            type: DataTypes.STRING,
+            allowNull: false
+        },
+        ownerType: {
+            type: DataTypes.STRING,
+            allowNull: false
+        },
+        name: {
+            type: DataTypes.STRING,
+            allowNull: false
+        },
+        currentVersion: {
+            type: DataTypes.STRING,
+            allowNull: false
+        },
+        latestVersion: {
+            type: DataTypes.STRING,
+            allowNull: true
+        }
+    },
+    associations: function (M) {
+        this.belongsTo(M.Project, { foreignKey: 'ownerId', constraints: false })
+        this.belongsTo(M.Device, { foreignKey: 'ownerId', constraints: false })
+    },
+    finders: function (M) {
+        return {
+            static: {
+                updateAllLatest: async (name, version) => {
+                    await this.update({
+                        latestVersion: version
+                    }, {
+                        where: {
+                            name
+                        }
+                    })
+                }
+            },
+            instance: {}
+        }
+    }
+}

forge/db/models/Project.js

@@ -260,6 +260,14 @@ module.exports = {
                         app.log.error(`Error removing MCPRegistrations for deleted instance ${project.id}: ${err.message}`)
                     }
                 }
+                if (app.db.models.NodeREDNodeVersions?.destory) {
+                    await app.db.models.destory({
+                        where: {
+                            ownerType: 'instance',
+                            ownerId: project.id
+                        }
+                    })
+                }
             }
         }
     },

forge/db/models/StorageSettings.js

@@ -4,6 +4,8 @@
  */
 const { DataTypes } = require('sequelize')
 
+const NODE_VERSION_CACHE = 'nodes-latestVersion'
+
 module.exports = {
     name: 'StorageSettings',
     schema: {
@@ -23,5 +25,33 @@ module.exports = {
                 }
             }
         }
+    },
+    hooks: function (M, app) {
+        return {
+            afterUpdate: async (storageSettings, options) => {
+                try {
+                    const cache = app.caches.getCache(NODE_VERSION_CACHE)
+                    await storageSettings.reload({
+                        attributes: ['id', 'settings', 'ProjectId']
+                    })
+                    const settingsObj = JSON.parse(storageSettings.settings)
+                    const nodes = settingsObj.nodes
+                    for (const n of Object.keys(nodes)) {
+                        if (n !== 'node-red') {
+                            const latest = await cache.get(n)
+                            await app.db.models.NodeREDNodeVersions.upsert({
+                                ownerId: storageSettings.ProjectId,
+                                ownerType: 'instance',
+                                name: n,
+                                currentVersion: nodes[n].version,
+                                latestVersion: latest
+                            })
+                        }
+                    }
+                } catch (err) {
+                    // console.log(err)
+                }
+            }
+        }
     }
 }

forge/db/models/index.js

@@ -84,7 +84,8 @@ const modelTypes = [
     'TeamBrokerClient',
     'BrokerCredentials',
     'MQTTTopicSchema',
-    'TeamBrokerAgent'
+    'TeamBrokerAgent',
+    'NodeREDNodeVersions'
 ]
 
 // A local map of the known models.

forge/ee/lib/bom/tasks/cache-catalogues.js

@@ -38,6 +38,10 @@ module.exports = {
                     for (const mod of modules) {
                         const name = mod.id
                         const version = mod.version
+                        const current = await cache.get(name)
+                        if (current && current !== version) {
+                            await app.models.NodeREDNodeVersions.updateAllLatest(name, version)
+                        }
                         cache.set(name, version)
                     }
                 }