@xen-orchestra/rest-api 0.14.0 → 0.16.0

package/dist/abstract-classes/base-controller.mjs

@@ -53,8 +53,10 @@ export class BaseController extends Controller {
     }
     maybeCompressResponse(req, res) {
         let transform;
-        let acceptEncoding = req.headers['accept-encoding'];
-        acceptEncoding = Array.isArray(acceptEncoding) ? acceptEncoding : acceptEncoding?.split(',');
+        const _acceptEncoding = req.headers['accept-encoding'];
+        const acceptEncoding = Array.isArray(_acceptEncoding)
+            ? _acceptEncoding
+            : _acceptEncoding?.split(',');
         if (acceptEncoding !== undefined &&
             acceptEncoding.some(encoding => {
                 const value = encoding.split(';')[0].trim().toLowerCase();

package/dist/abstract-classes/xapi-xo-controller.mjs

@@ -1,4 +1,3 @@
-import * as CM from 'complex-matcher';
 import { BaseController } from './base-controller.mjs';
 export class XapiXoController extends BaseController {
     #type;
@@ -6,11 +5,8 @@ export class XapiXoController extends BaseController {
         super(restApi);
         this.#type = type;
     }
-    getObjects({ filter, limit } = {}) {
-        if (filter !== undefined && typeof filter === 'string') {
-            filter = CM.parse(filter).createPredicate();
-        }
-        return this.restApi.getObjectsByType(this.#type, { filter: filter, limit });
+    getObjects(opts) {
+        return this.restApi.getObjectsByType(this.#type, opts);
     }
     getObject(id) {
         return this.restApi.getObject(id, this.#type);

package/dist/alarms/alarm.service.mjs

@@ -3,7 +3,8 @@ import { BASE_URL } from '../index.mjs';
 // E.g: 'value: 0.6\nconfig:\n<variable>\n<name value="cpu_usage"/>\n<alarm_trigger_level value="0.4"/>\n<alarm_trigger_period value ="60"/>\n</variable>';
 const ALARM_BODY_REGEX = /^value:\s*(Infinity|NaN|-Infinity|\d+(?:\.\d+)?)\s*config:\s*<variable>\s*<name value="(.*?)"/;
 const ALARM_NAMES = ['ALARM', 'BOND_STATUS_CHANGED', 'MULTIPATH_PERIODIC_ALERT'];
-export const alarmPredicate = CM.parse(`name:|(${ALARM_NAMES.join(' ')})`).createPredicate();
+export const RAW_ALARM_FILTER = `name:|(${ALARM_NAMES.join(' ')})`;
+export const alarmPredicate = CM.parse(RAW_ALARM_FILTER).createPredicate();
 export class AlarmService {
     #restApi;
     constructor(restApi) {

package/dist/backup-jobs/backup-job.controller.mjs

@@ -0,0 +1,284 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import * as CM from 'complex-matcher';
+import { createLogger } from '@xen-orchestra/log';
+import { inject } from 'inversify';
+import { noSuchObject } from 'xo-common/api-errors.js';
+import { Deprecated, Example, Get, Hidden, Middlewares, Path, Query, Request, Response, Route, Security, Tags, } from 'tsoa';
+import { provide } from 'inversify-binding-decorators';
+import { backupLog, backupLogIds, partialBackupLogs } from '../open-api/oa-examples/backup-log.oa-example.mjs';
+import { BackupLogService } from '../backup-logs/backup-log.service.mjs';
+import { notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
+import { RestApi } from '../rest-api/rest-api.mjs';
+import { limitAndFilterArray } from '../helpers/utils.helper.mjs';
+import { XoController } from '../abstract-classes/xo-controller.mjs';
+import { metadataBackupJob, metadataBackupJobIds, mirrorBackupJob, mirrorBackupJobIds, partialMetadataBackupJobs, partialMirrorBackupJobs, partialVmBackupJobs, vmBackupJob, vmBackupJobIds, } from '../open-api/oa-examples/backup-job.oa-example.mjs';
+import { BASE_URL } from '../index.mjs';
+const log = createLogger('xo:rest-api:backupJob-controller');
+let BackupJobController = class BackupJobController extends XoController {
+    async getAllCollectionObjects() {
+        const allJobs = await this.restApi.xoApp.getAllJobs();
+        const backupJobs = allJobs.filter(job => 'type' in job);
+        return backupJobs;
+    }
+    async getCollectionObject(id) {
+        const job = await this.restApi.xoApp.getJob(id);
+        if (!('type' in job)) {
+            // not a backup job
+            throw noSuchObject(id, 'backup-job');
+        }
+        return job;
+    }
+    /**
+     *
+     * @example fields "name,mode,type,id"
+     * @example filter "type:backup"
+     * @example limit 42
+     */
+    async getBackupJobs(req, fields, ndjson, filter, limit) {
+        const backupJobs = await this.getObjects({ filter, limit });
+        return this.sendObjects(Object.values(backupJobs), req, 'backup-jobs');
+    }
+    /**
+     * @example id "d33f3dc1-92b4-469c-ad58-4c2a106a4721"
+     */
+    getBackupJob(id) {
+        return this.getObject(id);
+    }
+};
+__decorate([
+    Example(vmBackupJobIds),
+    Example(partialVmBackupJobs),
+    Get(''),
+    __param(0, Request()),
+    __param(1, Query()),
+    __param(2, Query()),
+    __param(3, Query()),
+    __param(4, Query())
+], BackupJobController.prototype, "getBackupJobs", null);
+__decorate([
+    Example(vmBackupJob),
+    Response(notFoundResp.status, notFoundResp.description),
+    Get('{id}'),
+    __param(0, Path())
+], BackupJobController.prototype, "getBackupJob", null);
+BackupJobController = __decorate([
+    Route('backup-jobs'),
+    Security('*'),
+    Response(unauthorizedResp.status, unauthorizedResp.description),
+    Tags('backup-jobs'),
+    provide(BackupJobController)
+], BackupJobController);
+export { BackupJobController };
+// ----------- DEPRECATED TO BE REMOVED IN ONE YEAR  (09-12-2026)--------------------
+let DeprecatedBackupController = class DeprecatedBackupController extends XoController {
+    #backupLogService;
+    constructor(restApi, backupLogService) {
+        super(restApi);
+        this.#backupLogService = backupLogService;
+    }
+    async getAllCollectionObjects() {
+        const backupJobs = await this.restApi.xoApp.getAllJobs();
+        return backupJobs.filter(job => 'type' in job);
+    }
+    async getCollectionObject(id) {
+        const backupJob = await this.restApi.xoApp.getJob(id);
+        if (!('type' in backupJob)) {
+            throw noSuchObject(id, 'backup-job');
+        }
+        return backupJob;
+    }
+    async getObject(id, type) {
+        const backupJob = await super.getObject(id);
+        if (backupJob.type !== type) {
+            throw noSuchObject(id, type);
+        }
+        return backupJob;
+    }
+    /**
+     *
+     * @example fields "name,mode,id"
+     * @example filter "mode:delta"
+     * @example limit 42
+     */
+    async getVmBackupJobs(req, fields, ndjson, filter, limit) {
+        const vmBackupJobs = await this.restApi.xoApp.getAllJobs('backup');
+        return this.sendObjects(limitAndFilterArray(vmBackupJobs, { filter, limit }), req, 'backup-jobs');
+    }
+    // For compatibility, redirect /backup/jobs/:id to /backup/jobs/vm/:id
+    async redirectToVmBackupJob(req, id) {
+        const res = req.res;
+        res.redirect(308, BASE_URL + '/backup/jobs/vm/' + id);
+    }
+    /**
+     * @example id "d33f3dc1-92b4-469c-ad58-4c2a106a4721"
+     */
+    getVmBackupJob(id) {
+        return this.getObject(id, 'backup');
+    }
+    /**
+     *
+     * @example fields "name,xoMetadata,id"
+     * @example filter "xoMetadata?"
+     * @example limit 42
+     */
+    async getMetadataBackupJobs(req, fields, ndjson, filter, limit) {
+        const metadataBackupJobs = await this.restApi.xoApp.getAllJobs('metadataBackup');
+        return this.sendObjects(limitAndFilterArray(metadataBackupJobs, { filter, limit }), req, 'backup-jobs');
+    }
+    /**
+     * @example id "b50f95fd-f6b7-4027-87b6-6a02c7dcd5f5"
+     */
+    getMetadataBackupJob(id) {
+        return this.getObject(id, 'metadataBackup');
+    }
+    /**
+     *
+     * @example fields "name,mode,id"
+     * @example filter "mode:delta"
+     * @example limit 42
+     */
+    async getMirrorBackupJobs(req, fields, ndjson, filter, limit) {
+        const mirrorBackupJobs = await this.restApi.xoApp.getAllJobs('mirrorBackup');
+        return this.sendObjects(limitAndFilterArray(mirrorBackupJobs, { filter, limit }), req, 'backup-jobs');
+    }
+    /**
+     * @example id "e680c14c-ab52-45c8-bb0e-bd4ca12ea8f9"
+     */
+    getMirrorBackupJob(id) {
+        return this.getObject(id, 'mirrorBackup');
+    }
+    /**
+     * @example fields "jobName,status,data"
+     * @example filter "status:success"
+     * @example limit 42
+     */
+    async getDeprecatedBackupLogs(req, fields, ndjson, filter, limit) {
+        const userFilter = filter === undefined ? () => true : CM.parse(filter).createPredicate();
+        const predicate = (log) => {
+            if (!this.#backupLogService.isBackupLog(log)) {
+                return false;
+            }
+            return userFilter(log);
+        };
+        const logs = (await this.restApi.xoApp.getBackupNgLogsSorted({ filter: predicate, limit }));
+        return this.sendObjects(logs, req, 'backup-logs');
+    }
+    /**
+     * @example id "1753776067468"
+     */
+    async getDeprecatedBackupLog(id) {
+        const log = await this.restApi.xoApp.getBackupNgLogs(id);
+        if (!this.#backupLogService.isBackupLog(log)) {
+            throw noSuchObject('backup-log');
+        }
+        return log;
+    }
+};
+__decorate([
+    Example(vmBackupJobIds),
+    Example(partialVmBackupJobs),
+    Deprecated(),
+    Get('jobs/vm'),
+    Tags('backup-jobs'),
+    __param(0, Request()),
+    __param(1, Query()),
+    __param(2, Query()),
+    __param(3, Query()),
+    __param(4, Query())
+], DeprecatedBackupController.prototype, "getVmBackupJobs", null);
+__decorate([
+    Hidden(),
+    Get('jobs/{id}'),
+    Tags('backup-jobs'),
+    __param(0, Request()),
+    __param(1, Path())
+], DeprecatedBackupController.prototype, "redirectToVmBackupJob", null);
+__decorate([
+    Example(vmBackupJob),
+    Deprecated(),
+    Response(notFoundResp.status, notFoundResp.description),
+    Get('jobs/vm/{id}'),
+    Tags('backup-jobs'),
+    __param(0, Path())
+], DeprecatedBackupController.prototype, "getVmBackupJob", null);
+__decorate([
+    Example(metadataBackupJobIds),
+    Example(partialMetadataBackupJobs),
+    Deprecated(),
+    Get('jobs/metadata'),
+    Tags('backup-jobs'),
+    __param(0, Request()),
+    __param(1, Query()),
+    __param(2, Query()),
+    __param(3, Query()),
+    __param(4, Query())
+], DeprecatedBackupController.prototype, "getMetadataBackupJobs", null);
+__decorate([
+    Example(metadataBackupJob),
+    Deprecated(),
+    Response(notFoundResp.status, notFoundResp.description),
+    Get('jobs/metadata/{id}'),
+    Tags('backup-jobs'),
+    __param(0, Path())
+], DeprecatedBackupController.prototype, "getMetadataBackupJob", null);
+__decorate([
+    Example(mirrorBackupJobIds),
+    Example(partialMirrorBackupJobs),
+    Deprecated(),
+    Get('jobs/mirror'),
+    Tags('backup-jobs'),
+    __param(0, Request()),
+    __param(1, Query()),
+    __param(2, Query()),
+    __param(3, Query()),
+    __param(4, Query())
+], DeprecatedBackupController.prototype, "getMirrorBackupJobs", null);
+__decorate([
+    Example(mirrorBackupJob),
+    Deprecated(),
+    Response(notFoundResp.status, notFoundResp.description),
+    Get('jobs/mirror/{id}'),
+    Tags('backup-jobs'),
+    __param(0, Path())
+], DeprecatedBackupController.prototype, "getMirrorBackupJob", null);
+__decorate([
+    Example(backupLogIds),
+    Example(partialBackupLogs),
+    Deprecated(),
+    Get('logs'),
+    Tags('backup-logs'),
+    __param(0, Request()),
+    __param(1, Query()),
+    __param(2, Query()),
+    __param(3, Query()),
+    __param(4, Query())
+], DeprecatedBackupController.prototype, "getDeprecatedBackupLogs", null);
+__decorate([
+    Example(backupLog),
+    Deprecated(),
+    Get('logs/{id}'),
+    Tags('backup-logs'),
+    __param(0, Path())
+], DeprecatedBackupController.prototype, "getDeprecatedBackupLog", null);
+DeprecatedBackupController = __decorate([
+    Route('backup'),
+    Security('*'),
+    Response(unauthorizedResp.status, unauthorizedResp.description),
+    Middlewares((_req, _res, next) => {
+        log.warn('You are calling a deprecated route. It will be removed in the futur. Please use `/rest/v0/backup-jobs` or `/rest/v0/backup-logs` instead');
+        next();
+    }),
+    provide(DeprecatedBackupController),
+    __param(0, inject(RestApi)),
+    __param(1, inject(BackupLogService))
+], DeprecatedBackupController);
+export { DeprecatedBackupController };
+// ----------- DEPRECATED TO BE REMOVED IN ONE YEAR  (09-12-2026)--------------------

package/dist/backup-jobs/backup-job.service.mjs

@@ -0,0 +1,25 @@
+import { createPredicate } from 'value-matcher';
+import { extractIdsFromSimplePattern } from '@xen-orchestra/backups/extractIdsFromSimplePattern.mjs';
+const NO_BAK_TAG = 'xo:no-bak';
+export class BackupJobService {
+    #restApi;
+    constructor(restApi) {
+        this.#restApi = restApi;
+    }
+    async isVmInBackupJob(backupJobId, vmId) {
+        const backupJob = await this.#restApi.xoApp.getJob(backupJobId);
+        const vm = this.#restApi.getObject(vmId, 'VM');
+        if (vm.tags.includes(NO_BAK_TAG)) {
+            return false;
+        }
+        try {
+            const vmIds = extractIdsFromSimplePattern(backupJob.vms);
+            return vmIds.some(id => id === vm.id);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (_) {
+            const predicate = createPredicate(backupJob.vms);
+            return predicate(vm);
+        }
+    }
+}

package/dist/backup-jobs/backup-job.type.mjs

@@ -0,0 +1 @@
+export {};

package/dist/backup-logs/backup-log.controller.mjs

@@ -0,0 +1,75 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Example, Get, Path, Query, Request, Response, Route, Security, Tags } from 'tsoa';
+import { inject } from 'inversify';
+import { noSuchObject } from 'xo-common/api-errors.js';
+import { provide } from 'inversify-binding-decorators';
+import { backupLog, backupLogIds, partialBackupLogs } from '../open-api/oa-examples/backup-log.oa-example.mjs';
+import { BackupLogService } from './backup-log.service.mjs';
+import { RestApi } from '../rest-api/rest-api.mjs';
+import { unauthorizedResp } from '../open-api/common/response.common.mjs';
+import { XoController } from '../abstract-classes/xo-controller.mjs';
+let BackupLogController = class BackupLogController extends XoController {
+    #backupLogService;
+    constructor(restApi, backupLogService) {
+        super(restApi);
+        this.#backupLogService = backupLogService;
+    }
+    getAllCollectionObjects() {
+        return this.restApi.xoApp.getBackupNgLogsSorted({ filter: this.#backupLogService.isBackupLog });
+    }
+    async getCollectionObject(id) {
+        const log = await this.restApi.xoApp.getBackupNgLogs(id);
+        if (!this.#backupLogService.isBackupLog(log)) {
+            throw noSuchObject('backup-log');
+        }
+        return log;
+    }
+    /**
+     * @example fields "jobName,status,data"
+     * @example filter "status:success"
+     * @example limit 42
+     */
+    async getBackupLogs(req, fields, ndjson, filter, limit) {
+        const backupLogs = await this.getObjects({ filter, limit });
+        return this.sendObjects(Object.values(backupLogs), req);
+    }
+    /**
+     * @example id "1753776067468"
+     */
+    getBackupLog(id) {
+        return this.getObject(id);
+    }
+};
+__decorate([
+    Example(backupLogIds),
+    Example(partialBackupLogs),
+    Get(''),
+    __param(0, Request()),
+    __param(1, Query()),
+    __param(2, Query()),
+    __param(3, Query()),
+    __param(4, Query())
+], BackupLogController.prototype, "getBackupLogs", null);
+__decorate([
+    Example(backupLog),
+    Get('{id}'),
+    __param(0, Path())
+], BackupLogController.prototype, "getBackupLog", null);
+BackupLogController = __decorate([
+    Route('backup-logs'),
+    Security('*'),
+    Response(unauthorizedResp.status, unauthorizedResp.description),
+    Tags('backup-logs'),
+    provide(BackupLogController),
+    __param(0, inject(RestApi)),
+    __param(1, inject(BackupLogService))
+], BackupLogController);
+export { BackupLogController };

package/dist/backup-logs/backup-log.service.mjs

@@ -0,0 +1,5 @@
+export class BackupLogService {
+    isBackupLog(log) {
+        return log.message === 'backup' || log.message === 'metadata';
+    }
+}

package/dist/groups/group.controller.mjs

@@ -8,13 +8,23 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Body, Delete, Example, Get, Middlewares, Patch, Path, Post, Put, Query, Request, Response, Route, Security, SuccessResponse, Tags, } from 'tsoa';
+import { inject } from 'inversify';
 import { json } from 'express';
 import { provide } from 'inversify-binding-decorators';
 import { forbiddenOperation } from 'xo-common/api-errors.js';
 import { createdResp, forbiddenOperationResp, invalidParameters, noContentResp, notFoundResp, resourceAlreadyExists, unauthorizedResp, } from '../open-api/common/response.common.mjs';
 import { group, groupId, groupIds, partialGroups } from '../open-api/oa-examples/group.oa-example.mjs';
 import { XoController } from '../abstract-classes/xo-controller.mjs';
+import { UserService } from '../users/user.service.mjs';
+import { RestApi } from '../rest-api/rest-api.mjs';
+import { limitAndFilterArray } from '../helpers/utils.helper.mjs';
+import { partialUsers, userIds } from '../open-api/oa-examples/user.oa-example.mjs';
 let GroupController = class GroupController extends XoController {
+    #userService;
+    constructor(restApi, userService) {
+        super(restApi);
+        this.#userService = userService;
+    }
     // --- abstract methods
     getAllCollectionObjects() {
         return this.restApi.xoApp.getAllGroups();
@@ -85,6 +95,17 @@ let GroupController = class GroupController extends XoController {
         }
         await this.restApi.xoApp.addUserToGroup(userId, group.id);
     }
+    /**
+     * @example id "6c81b5e1-afc1-43ea-8f8d-939ceb5f3f90"
+     * @example fields "permission,name,id"
+     * @example filter "permission:none"
+     * @example limit 42
+     */
+    async getGroupUsers(req, id, fields, ndjson, filter, limit) {
+        const group = await this.getObject(id);
+        const users = await Promise.all(group.users.map(id => this.#userService.getUser(id)));
+        return this.sendObjects(limitAndFilterArray(users, { filter, limit }), req, 'users');
+    }
 };
 __decorate([
     Example(groupIds),
@@ -143,11 +164,26 @@ __decorate([
     __param(0, Path()),
     __param(1, Path())
 ], GroupController.prototype, "addUserToGroup", null);
+__decorate([
+    Example(userIds),
+    Example(partialUsers),
+    Get('{id}/users'),
+    Tags('users'),
+    Response(notFoundResp.status, notFoundResp.description),
+    __param(0, Request()),
+    __param(1, Path()),
+    __param(2, Query()),
+    __param(3, Query()),
+    __param(4, Query()),
+    __param(5, Query())
+], GroupController.prototype, "getGroupUsers", null);
 GroupController = __decorate([
     Route('groups'),
     Security('*'),
     Response(unauthorizedResp.status, unauthorizedResp.description),
     Tags('groups'),
-    provide(GroupController)
+    provide(GroupController),
+    __param(0, inject(RestApi)),
+    __param(1, inject(UserService))
 ], GroupController);
 export { GroupController };

package/dist/helpers/error.helper.mjs

@@ -0,0 +1,10 @@
+export class ApiError extends Error {
+    #status;
+    constructor(message, status) {
+        super(message);
+        this.#status = status;
+    }
+    get status() {
+        return this.#status;
+    }
+}

package/dist/hosts/host.controller.mjs

@@ -14,15 +14,18 @@ import { provide } from 'inversify-binding-decorators';
 import { AlarmService } from '../alarms/alarm.service.mjs';
 import { escapeUnsafeComplexMatcher } from '../helpers/utils.helper.mjs';
 import { genericAlarmsExample } from '../open-api/oa-examples/alarm.oa-example.mjs';
-import { host, hostIds, hostSmt, hostStats, partialHosts } from '../open-api/oa-examples/host.oa-example.mjs';
+import { host, hostIds, hostSmt, hostMissingPatches, hostStats, partialHosts, } from '../open-api/oa-examples/host.oa-example.mjs';
 import { RestApi } from '../rest-api/rest-api.mjs';
 import { XapiXoController } from '../abstract-classes/xapi-xo-controller.mjs';
-import { internalServerErrorResp, notFoundResp, unauthorizedResp, } from '../open-api/common/response.common.mjs';
+import { featureUnauthorized, internalServerErrorResp, notFoundResp, unauthorizedResp, } from '../open-api/common/response.common.mjs';
+import { HostService } from './host.service.mjs';
 let HostController = class HostController extends XapiXoController {
     #alarmService;
-    constructor(restApi, alarmService) {
+    #hostService;
+    constructor(restApi, alarmService, hostService) {
         super('host', restApi);
         this.#alarmService = alarmService;
+        this.#hostService = hostService;
     }
     /**
      * @example fields "id,name_label,productBrand"
@@ -105,6 +108,15 @@ let HostController = class HostController extends XapiXoController {
         const enabled = Boolean(await xapiHost.$xapi.isHyperThreadingEnabled(hostId));
         return { enabled };
     }
+    /**
+     * Host must be running
+     *
+     * @example id "b61a5c92-700e-4966-a13b-00633f03eea8"
+     */
+    async getMissingPatches(id) {
+        const { missingPatches } = await this.#hostService.getMissingPatchesInfo({ filter: host => host.id === id });
+        return missingPatches;
+    }
 };
 __decorate([
     Example(hostIds),
@@ -166,6 +178,13 @@ __decorate([
     Response(internalServerErrorResp.status, internalServerErrorResp.description),
     __param(0, Path())
 ], HostController.prototype, "gethostSmt", null);
+__decorate([
+    Example(hostMissingPatches),
+    Get('{id}/missing_patches'),
+    Response(notFoundResp.status, notFoundResp.description),
+    Response(featureUnauthorized.status, featureUnauthorized.description),
+    __param(0, Path())
+], HostController.prototype, "getMissingPatches", null);
 HostController = __decorate([
     Route('hosts'),
     Security('*'),
@@ -173,6 +192,7 @@ HostController = __decorate([
     Tags('hosts'),
     provide(HostController),
     __param(0, inject(RestApi)),
-    __param(1, inject(AlarmService))
+    __param(1, inject(AlarmService)),
+    __param(2, inject(HostService))
 ], HostController);
 export { HostController };

package/dist/hosts/host.service.mjs

@@ -41,13 +41,12 @@ export class HostService {
             total,
         };
     }
-    async getMissingPatchesInfo(opts) {
-        if (!(await this.#restApi.xoApp.hasFeatureAuthorization('LIST_MISSING_PATCHES'))) {
-            return {
-                hasAuthorization: false,
-            };
-        }
-        const hosts = Object.values(this.#restApi.getObjectsByType('host', opts));
+    /**
+     * Throw if no authorization
+     */
+    async getMissingPatchesInfo({ filter, } = {}) {
+        await this.#restApi.xoApp.checkFeatureAuthorization('LIST_MISSING_PATCHES');
+        const hosts = Object.values(this.#restApi.getObjectsByType('host', { filter }));
         const missingPatches = new Map();
         const poolsWithMissingPatches = new Set();
         let nHostsWithMissingPatches = 0;

package/dist/hosts/host.type.mjs

@@ -0,0 +1 @@
+export {};

package/dist/index.mjs

@@ -32,6 +32,10 @@ const SWAGGER_UI_OPTIONS = {
 export default function setupRestApi(express, xoApp) {
     setupContainer(xoApp);
     RegisterRoutes(express);
+    express.get(`${BASE_URL}/docs/swagger.json`, (_req, res) => {
+        res.setHeader('Content-Type', 'application/json');
+        res.json(swaggerOpenApiSpec);
+    });
     // do not register the doc at the root level, or it may lead to unwanted behaviour
     // uncomment when all endpoints are migrated to this API
     // express.get('/rest/v0', (_req, res) => res.redirect('/rest/v0/docs'))

package/dist/ioc/ioc.mjs

@@ -7,6 +7,11 @@ import { XoaService } from '../xoa/xoa.service.mjs';
 import { HostService } from '../hosts/host.service.mjs';
 import { PoolService } from '../pools/pool.service.mjs';
 import { AlarmService } from '../alarms/alarm.service.mjs';
+import { VdiService } from '../vdis/vdi.service.mjs';
+import { TaskService } from '../tasks/task.service.mjs';
+import { UserService } from '../users/user.service.mjs';
+import { BackupJobService } from '../backup-jobs/backup-job.service.mjs';
+import { BackupLogService } from '../backup-logs/backup-log.service.mjs';
 const iocContainer = new Container();
 decorate(injectable(), Controller);
 iocContainer.load(buildProviderModule());
@@ -53,5 +58,36 @@ export function setupContainer(xoApp) {
         return new AlarmService(restApi);
     })
         .inSingletonScope();
+    iocContainer.bind(TaskService).toDynamicValue(ctx => {
+        const restApi = ctx.container.get(RestApi);
+        return new TaskService(restApi);
+    });
+    iocContainer
+        .bind(VdiService)
+        .toDynamicValue(ctx => {
+        const restApi = ctx.container.get(RestApi);
+        return new VdiService(restApi);
+    })
+        .inSingletonScope();
+    iocContainer
+        .bind(UserService)
+        .toDynamicValue(ctx => {
+        const restApi = ctx.container.get(RestApi);
+        return new UserService(restApi);
+    })
+        .inSingletonScope();
+    iocContainer
+        .bind(BackupJobService)
+        .toDynamicValue(ctx => {
+        const restApi = ctx.container.get(RestApi);
+        return new BackupJobService(restApi);
+    })
+        .inSingletonScope();
+    iocContainer
+        .bind(BackupLogService)
+        .toDynamicValue(() => {
+        return new BackupLogService();
+    })
+        .inSingletonScope();
 }
 export { iocContainer };