Merge pull request #4764 from FlowFuse/4756-search-api

Add search api for apps/devices/instances

Author: cstns

forge/db/models/Application.js

@@ -2,7 +2,7 @@
  * An application definition
  * @namespace forge.db.models.Application
  */
-const { DataTypes, Op, literal } = require('sequelize')
+const { col, fn, DataTypes, Op, literal, where } = require('sequelize')
 
 const { KEY_SETTINGS, KEY_HA } = require('./ProjectSettings')
 
@@ -47,7 +47,7 @@ module.exports = {
                         ]
                     })
                 },
-                byTeam: async (teamIdOrHash, { includeInstances = false, includeApplicationDevices = false, includeInstanceStorageFlow = false, associationsLimit = null, includeApplicationSummary = false } = {}) => {
+                byTeam: async (teamIdOrHash, { query = null, includeInstances = false, includeApplicationDevices = false, includeInstanceStorageFlow = false, associationsLimit = null, includeApplicationSummary = false } = {}) => {
                     let id = teamIdOrHash
                     if (typeof teamIdOrHash === 'string') {
                         id = M.Team.decodeHashid(teamIdOrHash)
@@ -117,12 +117,18 @@ module.exports = {
                         includes.push(include)
                     }
 
-                    const query = {
+                    const queryObject = {
                         include: includes
                     }
+                    if (query) {
+                        queryObject.where = where(
+                            fn('lower', col('Application.name')),
+                            { [Op.like]: `%${query.toLowerCase()}%` }
+                        )
+                    }
 
                     if (includeApplicationSummary) {
-                        query.attributes = {
+                        queryObject.attributes = {
                             include: [
                                 [
                                     literal(`(
@@ -166,7 +172,7 @@ module.exports = {
                         // You can add a license without a restart, so we also need to check if the Model is loaded
                         // If the model is loaded, it can be assumed the table exists
                         if (app.license.active() && app.db.models.Pipeline) {
-                            query.attributes.include.push([
+                            queryObject.attributes.include.push([
                                 literal(`(
                                     SELECT count(*)
                                     FROM "Pipelines"
@@ -177,7 +183,7 @@ module.exports = {
                         }
                     }
 
-                    return this.findAll(query)
+                    return this.findAll(queryObject)
                 }
             },
             instance: {

forge/db/models/Device.js

@@ -6,7 +6,7 @@ const crypto = require('crypto')
 
 const SemVer = require('semver')
 
-const { DataTypes, Op } = require('sequelize')
+const { col, fn, DataTypes, Op, where } = require('sequelize')
 
 const Controllers = require('../controllers')
 const { buildPaginationSearchClause } = require('../utils')
@@ -305,6 +305,23 @@ module.exports = {
                         ]
                     })
                 },
+                byTeam: async (teamIdOrHash, { query = null } = {}) => {
+                    let teamId = teamIdOrHash
+                    if (typeof teamId === 'string') {
+                        teamId = M.Team.decodeHashid(teamId)
+                    }
+                    const queryObject = {
+                        where: { [Op.and]: [{ TeamId: teamId }] }
+                    }
+
+                    if (query) {
+                        queryObject.where[Op.and].push(where(
+                            fn('lower', col('Device.name')),
+                            { [Op.like]: `%${query.toLowerCase()}%` }
+                        ))
+                    }
+                    return this.getAll({}, queryObject.where)
+                },
                 getAll: async (pagination = {}, where = {}, { includeInstanceApplication = false, includeDeviceGroup = false } = {}) => {
                     // Pagination
                     const limit = Math.min(parseInt(pagination.limit) || 100, 100)

forge/db/models/Project.js

@@ -13,7 +13,7 @@
 
 const crypto = require('crypto')
 
-const { DataTypes, Op } = require('sequelize')
+const { col, fn, DataTypes, Op, where } = require('sequelize')
 
 const Controllers = require('../controllers')
 
@@ -469,15 +469,20 @@ module.exports = {
                         include
                     })
                 },
-                byTeam: async (teamHashId, { includeSettings = false } = {}) => {
-                    const teamId = M.Team.decodeHashid(teamHashId)
+                byTeam: async (teamIdOrHash, { query = null, includeAssociations = true, includeSettings = false } = {}) => {
+                    let teamId = teamIdOrHash
+                    if (typeof teamId === 'string') {
+                        teamId = M.Team.decodeHashid(teamId)
+                    }
                     const include = [
                         {
                             model: M.Team,
                             where: { id: teamId },
                             attributes: ['hashid', 'id', 'name', 'slug', 'links', 'TeamTypeId']
-                        },
-                        {
+                        }
+                    ]
+                    if (includeAssociations) {
+                        include.push({
                             model: M.Application,
                             attributes: ['hashid', 'id', 'name', 'links']
                         },
@@ -492,7 +497,8 @@ module.exports = {
                             model: M.ProjectTemplate,
                             attributes: ['hashid', 'id', 'name', 'links']
                         }
-                    ]
+                        )
+                    }
 
                     if (includeSettings) {
                         include.push({
@@ -502,7 +508,17 @@ module.exports = {
                         })
                     }
 
-                    return this.findAll({ include })
+                    const queryObject = {
+                        include
+                    }
+
+                    if (query) {
+                        queryObject.where = where(
+                            fn('lower', col('Project.name')),
+                            { [Op.like]: `%${query.toLowerCase()}%` }
+                        )
+                    }
+                    return this.findAll(queryObject)
                 },
                 getProjectTeamId: async (id) => {
                     const project = await this.findOne({

forge/db/views/Application.js

@@ -63,6 +63,8 @@ module.exports = function (app) {
         }
 
         if (detailed) {
+            summary.deviceCount = application.get('deviceCount')
+            summary.instanceCount = application.get('instanceCount')
             summary.deviceGroupCount = application.get('deviceGroupCount')
             summary.snapshotCount = application.get('snapshotCount')
             summary.pipelineCount = application.get('pipelineCount')

forge/lib/permissions.js

@@ -31,6 +31,9 @@ const Permissions = {
     'team:user:invite': { description: 'Invite Members', role: Roles.Owner },
     'team:user:remove': { description: 'Remove Member', role: Roles.Owner, self: true },
     'team:user:change-role': { description: 'Modify Member role', role: Roles.Owner },
+
+    'team:search': { description: 'Search a Teams resources', role: Roles.Viewer },
+
     // Applications
     'application:audit-log': { description: 'Access Application Audit Log', role: Roles.Owner },
     // Projects

forge/routes/api/index.js

@@ -11,6 +11,7 @@ const Assistant = require('./assistant.js')
 const Device = require('./device.js')
 const Project = require('./project.js')
 const ProjectType = require('./projectType.js')
+const Search = require('./search.js')
 const Settings = require('./settings.js')
 const Snapshot = require('./snapshot.js')
 const Stack = require('./stack.js')
@@ -36,6 +37,7 @@ module.exports = async function (app) {
     app.register(ProjectType, { prefix: '/project-types' })
     app.register(Snapshot, { prefix: '/snapshots' })
     app.register(Assistant, { prefix: '/assistant' })
+    app.register(Search, { prefix: '/search' })
     app.get('*', function (request, reply) {
         reply.code(404).send({ code: 'not_found', error: 'Not Found' })
     })

forge/routes/api/search.js

@@ -0,0 +1,116 @@
+/**
+ * Search API
+ *
+ * - /api/v1/search
+ *
+ */
+module.exports = async function (app) {
+    /**
+     * Search API
+     *
+     * Query Params:
+     *  - team : team hash id (required)
+     *  - query: <string> search query term (required)
+     */
+    app.get('/', {
+        schema: {
+            summary: 'Search for resources',
+            tags: ['Search'],
+            query: {
+                type: 'object',
+                // For now, require 'team' query param to scope the search to
+                // a single team. This *could* be relaxed in the future to operate
+                // across all teams the user is a member of.
+                required: ['team'],
+                properties: {
+                    team: { type: 'string' },
+                    query: { type: 'string' }
+                },
+                additionalProperties: true
+            },
+            response: {
+                200: {
+                    type: 'object',
+                    properties: {
+                        count: { type: 'number' },
+                        results: { type: 'array', items: { type: 'object', additionalProperties: true } }
+                    }
+                },
+                '4xx': {
+                    $ref: 'APIError'
+                }
+            }
+        }
+    }, async (request, reply) => {
+        const query = request.query.query?.trim()
+        const teamHashId = request.query.team
+        const [teamId] = app.db.models.Team.decodeHashid(teamHashId)
+        // Only search if query is not blank
+        if (query) {
+            // Only search if a valid team has been provided
+            if (teamId !== undefined) {
+                const membership = await request.session.User.getTeamMembership(teamId)
+                // Check user has access to this team - either admin or at least Viewer role
+                if (request.session.User.admin || app.hasPermission(membership, 'team:search')) {
+                    // Now do the search
+                    const applicationSearchPromise = app.db.models.Application.byTeam(
+                        teamId,
+                        {
+                            query,
+                            includeApplicationSummary: true
+                        }
+                    )
+                    const instanceSearchPromise = app.db.models.Project.byTeam(
+                        teamId,
+                        {
+                            query,
+                            includeAssociations: false
+                        }
+                    )
+                    const deviceSearchPromise = app.db.models.Device.byTeam(
+                        teamId,
+                        {
+                            query
+                        }
+                    )
+                    const results = await Promise.all([
+                        applicationSearchPromise,
+                        instanceSearchPromise,
+                        deviceSearchPromise
+                    ])
+                    const rr = [
+                        ...results[0].map(application => {
+                            return {
+                                object: 'application',
+                                ...app.db.views.Application.applicationSummary(application, { detailed: true })
+                            }
+                        }),
+                        ...results[1].map(instance => {
+                            return {
+                                object: 'instance',
+                                ...app.db.views.Project.projectSummary(instance)
+                            }
+                        }),
+                        ...results[2].devices.map(device => {
+                            return {
+                                object: 'device',
+                                ...app.db.views.Device.deviceSummary(device)
+                            }
+                        })
+                    ]
+
+                    reply.send({
+                        count: rr.length,
+                        results: rr.flat()
+                    })
+                    return
+                }
+            }
+        }
+        // Invalid team - send empty results
+        reply.send({
+            count: 0,
+            results: []
+        })
+    })
+}