@xen-orchestra/rest-api 0.29.0 → 0.30.0

package/dist/middlewares/acl.middleware.mjs

@@ -0,0 +1,202 @@
+import { getMissingPrivileges, } from '@xen-orchestra/acl';
+import { RestApi } from '../rest-api/rest-api.mjs';
+import { iocContainer } from '../ioc/ioc.mjs';
+import { ValidateError } from 'tsoa';
+import { ApiError } from '../helpers/error.helper.mjs';
+export const ACL_MIDDLEWARE_NAME = '_aclMiddleware';
+export function actionsFromBody(actions) {
+    return ({ req }) => actions.filter(action => {
+        const [, field] = action.split(':');
+        return field in req.body;
+    });
+}
+export function actionFromBody(action) {
+    return opts => actionsFromBody([action])(opts)[0];
+}
+export function actionsIfNotSelfUser(actions) {
+    return ({ req, restApi }) => {
+        const currentUser = restApi.getCurrentUser();
+        const userId = req.params.id;
+        if (currentUser.id !== userId) {
+            return actions;
+        }
+        return [];
+    };
+}
+export function actionIfNotSelfUser(action) {
+    return opts => actionsIfNotSelfUser([action])(opts)[0];
+}
+export function autoBindService(serviceId, method) {
+    return ({ restApi }) => {
+        const service = restApi.ioc.get(serviceId);
+        const fn = service[method];
+        if (typeof fn !== 'function') {
+            throw new Error(`Invalid method: ${String(method)}`);
+        }
+        return fn.bind(service);
+    };
+}
+export const XAPI_TYPE_BY_ACL_RESOURCE = {
+    message: 'message',
+    gpuGroup: 'gpuGroup',
+    host: 'host',
+    network: 'network',
+    pbd: 'PBD',
+    pci: 'PCI',
+    pgpu: 'PGPU',
+    pif: 'PIF',
+    pool: 'pool',
+    sr: 'SR',
+    vbd: 'VBD',
+    vdi: 'VDI',
+    'vdi-snapshot': 'VDI-snapshot',
+    'vdi-unmanaged': 'VDI-unmanaged',
+    vgpu: 'vgpu',
+    vgpuType: 'vgpuType',
+    vif: 'VIF',
+    vm: 'VM',
+    'vm-controller': 'VM-controller',
+    'vm-snapshot': 'VM-snapshot',
+    'vm-template': 'VM-template',
+    vtpm: 'VTPM',
+    sm: 'SM',
+};
+function normalizeAclEntry(acl) {
+    const aclAction = acl.action;
+    const aclActions = 'actions' in acl && acl.actions !== undefined
+        ? acl.actions
+        : typeof aclAction === 'function'
+            ? (opts) => [aclAction(opts)]
+            : [aclAction];
+    const actionsResolver = typeof aclActions === 'function'
+        ? (req, restApi) => aclActions({ req, restApi })
+        : () => aclActions;
+    const base = { resource: acl.resource, actionsResolver, getObject: acl.getObject };
+    if ('objects' in acl && acl.objects !== undefined) {
+        return { ...base, objects: acl.objects };
+    }
+    if ('object' in acl && acl.object !== undefined) {
+        let objects;
+        if (typeof acl.object === 'function') {
+            const fn = acl.object;
+            objects = async (opts) => [await fn(opts)];
+        }
+        else {
+            objects = [acl.object];
+        }
+        return { ...base, objects };
+    }
+    if ('objectIds' in acl && acl.objectIds !== undefined) {
+        return { ...base, objectIds: acl.objectIds };
+    }
+    if ('objectId' in acl && acl.objectId !== undefined) {
+        let objectIds;
+        if (typeof acl.objectId === 'function') {
+            const fn = acl.objectId;
+            objectIds = (opts) => [fn(opts)];
+        }
+        else {
+            objectIds = [acl.objectId];
+        }
+        return { ...base, objectIds };
+    }
+    throw new Error('invalid ACL entry');
+}
+export function acl(acls) {
+    acls = Array.isArray(acls) ? acls : [acls];
+    const _acls = acls.map(normalizeAclEntry);
+    async function middleware(req, res, next) {
+        const restApi = iocContainer.get(RestApi);
+        const user = restApi.getCurrentUser();
+        const invalidFields = {};
+        const missingPrivilegeParams = [];
+        for (const acl of _acls) {
+            let objects = [];
+            if ('objectIds' in acl) {
+                let ids = [];
+                if (typeof acl.objectIds === 'function') {
+                    try {
+                        ids = acl.objectIds({ req, restApi }).map(id => ({ id }));
+                    }
+                    catch (error) {
+                        return next(error);
+                    }
+                }
+                else {
+                    for (const path of acl.objectIds) {
+                        const id = path.split('.').reduce((obj, part) => obj?.[part], req);
+                        ids.push({ id, path });
+                    }
+                }
+                for (const { id, path } of ids) {
+                    if (id === undefined) {
+                        continue;
+                    }
+                    if (typeof id !== 'string') {
+                        invalidFields[path ?? 'unknown'] = {
+                            message: 'invalid string value',
+                            value: id,
+                        };
+                        continue;
+                    }
+                    if (Object.keys(invalidFields).length > 0) {
+                        // No need to get objects if we already known some params are invalid
+                        continue;
+                    }
+                    try {
+                        const object = (await acl.getObject?.({ restApi })(id)) ??
+                            restApi.getObject(id, XAPI_TYPE_BY_ACL_RESOURCE[acl.resource]);
+                        objects.push(object);
+                    }
+                    catch (error) {
+                        return next(error);
+                    }
+                }
+            }
+            if ('objects' in acl) {
+                if (typeof acl.objects === 'function') {
+                    const _objects = await acl.objects({ req, restApi });
+                    if (_objects !== undefined) {
+                        objects = _objects;
+                    }
+                }
+                else {
+                    objects = acl.objects;
+                }
+            }
+            // We cast here to restore the discriminated union correlation between `resource` and `action`.
+            // When rebuilding an object from individual properties of a discriminated union, TypeScript transform it into an union type
+            //   { resource: SupportedResource, action: SupportedAction<SupportedResource> }
+            // This loses the original correlation (e.g. it would allow invalid pairs like { resource: 'vgpu', action: 'snapshot' }).
+            // The `as` cast re-asserts the discriminated union member type.
+            for (const action of acl.actionsResolver(req, restApi)) {
+                if (action === undefined) {
+                    // action can be undefined, if the action is created from `actionFromBody` or `actionIfNotSelfUser`
+                    continue;
+                }
+                missingPrivilegeParams.push({ action, resource: acl.resource, objects, user });
+            }
+        }
+        if (Object.keys(invalidFields).length > 0) {
+            return next(new ValidateError(invalidFields, 'invalid parameters'));
+        }
+        let userPrivileges;
+        try {
+            userPrivileges = (await restApi.xoApp.getAclV2UserPrivileges(user.id));
+        }
+        catch (error) {
+            return next(error);
+        }
+        const missingPrivileges = getMissingPrivileges(missingPrivilegeParams, userPrivileges);
+        if (missingPrivileges.length > 0) {
+            return next(new ApiError('not enough privileges', 403, {
+                data: {
+                    missingPrivileges,
+                },
+            }));
+        }
+        next();
+    }
+    Object.defineProperty(middleware, 'name', { value: ACL_MIDDLEWARE_NAME });
+    return middleware;
+}

package/dist/middlewares/authentication.middleware.mjs

@@ -1,13 +1,12 @@
 import { createLogger } from '@xen-orchestra/log';
 import { unauthorized } from 'xo-common/api-errors.js';
+import { ApiError } from '../helpers/error.helper.mjs';
 import { iocContainer } from '../ioc/ioc.mjs';
 import { RestApi } from '../rest-api/rest-api.mjs';
-import { ApiError } from '../helpers/error.helper.mjs';
+import { ACL_MIDDLEWARE_NAME } from './acl.middleware.mjs';
 const log = createLogger('xo:rest-api:authentication');
-// TODO: correctly handle ACL/Resource set users
-// for now only support "xoa-admin"
 // TSOA spec require this function to be async
-export async function expressAuthentication(req, securityName) {
+export async function expressAuthentication(req, securityName, scopes) {
     if (securityName === 'none') {
         return undefined;
     }
@@ -17,8 +16,18 @@ export async function expressAuthentication(req, securityName) {
     if (securityName !== '*' && authType !== securityName) {
         throw new ApiError(`invalid authentification. please use ${securityName} authentication`, 401);
     }
-    if (user.permission !== 'admin') {
-        log.error(`The REST API can only be used by 'xoa-admin' users for now. Your permission: ${user.permission}`);
+    if (user.permission === 'admin') {
+        return user;
+    }
+    // This means the route requires authentication, but it doesn't need to be associated with a specific ACL.
+    // The route's content will depend on the users' ACLs.
+    // (For example: GET /vms -> empty array if no VMs ACL; GET /events -> only changes related to the users' ACLs will be sent)
+    if (scopes.includes('acl')) {
+        return user;
+    }
+    const aclMiddleware = req.route.stack.find(layer => layer.name === ACL_MIDDLEWARE_NAME);
+    if (aclMiddleware === undefined) {
+        log.error(`${req.route.path} can only be used by an administrator`);
         throw unauthorized();
     }
     return user;

package/dist/middlewares/tsoa-to-xo-error.middleware.mjs

@@ -2,7 +2,25 @@ import { invalidParameters } from 'xo-common/api-errors.js';
 import { ValidateError } from 'tsoa';
 export default function tsoaToXoErrorHandler(error, _req, _res, next) {
     if (error instanceof ValidateError) {
-        throw invalidParameters(error.fields);
+        const fields = simplifyUnionValidationErrors(error.fields);
+        throw invalidParameters(fields);
     }
     return next(error);
 }
+function simplifyUnionValidationErrors(fields) {
+    const result = {};
+    for (const [key, field] of Object.entries(fields)) {
+        if (isUnionMismatchError(field)) {
+            result[key] = {
+                ...field,
+                message: 'Value does not match any allowed schema',
+            };
+            continue;
+        }
+        result[key] = field;
+    }
+    return result;
+}
+function isUnionMismatchError(field) {
+    return field.message.startsWith('Could not match the union against any of the items');
+}

package/dist/networks/network.controller.mjs

@@ -7,18 +7,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { Example, Get, Path, Query, Response, Request, Route, Security, Tags, Delete, SuccessResponse, Put } from 'tsoa';
+import { Example, Get, Path, Query, Response, Request, Route, Security, Tags, Delete, SuccessResponse, Put, Middlewares, } from 'tsoa';
 import { inject } from 'inversify';
 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 { network, networkIds, partialNetworks } from '../open-api/oa-examples/network.oa-example.mjs';
-import { badRequestResp, noContentResp, notFoundResp, unauthorizedResp, } from '../open-api/common/response.common.mjs';
+import { badRequestResp, forbiddenOperationResp, noContentResp, notFoundResp, unauthorizedResp, } from '../open-api/common/response.common.mjs';
 import { RestApi } from '../rest-api/rest-api.mjs';
 import { XapiXoController } from '../abstract-classes/xapi-xo-controller.mjs';
 import { messageIds, partialMessages } from '../open-api/oa-examples/message.oa-example.mjs';
 import { partialTasks, taskIds } from '../open-api/oa-examples/task.oa-example.mjs';
+import { acl } from '../middlewares/acl.middleware.mjs';
 let NetworkController = class NetworkController extends XapiXoController {
     #alarmService;
     constructor(restApi, alarmService) {
@@ -26,27 +27,42 @@ let NetworkController = class NetworkController extends XapiXoController {
         this.#alarmService = alarmService;
     }
     /**
+     * Returns all networks that match the following privilege:
+     * - resource: network, action: read
+     *
      * @example fields "nbd,name_label,id"
      * @example filter "nbd?"
      * @example limit 42
      */
     getNetworks(req, fields, ndjson, markdown, filter, limit) {
-        return this.sendObjects(Object.values(this.getObjects({ filter, limit })), req);
+        return this.sendObjects(Object.values(this.getObjects({ filter })), req, {
+            limit,
+            privilege: { action: 'read', resource: 'network' },
+        });
     }
     /**
+     * Required privilege:
+     * - resource: network, action: read
+     *
      * @example id "9fe12ca3-d75d-cfb0-492e-cfd2bc6c568f"
      */
     getNetwork(id) {
         return this.getObject(id);
     }
     /**
-     * @example id "593c39a5-9c56-28eb-969b-255b2f53791b"
+     * Required privilege:
+     * - resource: network, action: delete
+     *
+     * @example id "9fe12ca3-d75d-cfb0-492e-cfd2bc6c568f"
      */
     async deleteNetwork(id) {
         const networkId = id;
         await this.getXapiObject(networkId).$xapi.deleteNetwork(networkId);
     }
     /**
+     * Returns all alarms that match the following privilege:
+     * - resource: alarm, action: read
+     *
      * @example id "9fe12ca3-d75d-cfb0-492e-cfd2bc6c568f"
      * @example fields "id,time"
      * @example filter "time:>1747053793"
@@ -56,31 +72,51 @@ let NetworkController = class NetworkController extends XapiXoController {
         const network = this.getObject(id);
         const alarms = this.#alarmService.getAlarms({
             filter: `${escapeUnsafeComplexMatcher(filter) ?? ''} object:uuid:${network.uuid}`,
+        });
+        return this.sendObjects(Object.values(alarms), req, {
+            path: 'alarms',
             limit,
+            privilege: { action: 'read', resource: 'alarm' },
         });
-        return this.sendObjects(Object.values(alarms), req, 'alarms');
     }
     /**
+     * Returns all messages that match the following privilege:
+     * - resource: message, action: read
+     *
      * @example id "9fe12ca3-d75d-cfb0-492e-cfd2bc6c568f"
      * @example fields "name,id,$object"
      * @example filter "name:VM_STARTED"
      * @example limit 42
      */
     getNetworkMessages(req, id, fields, ndjson, markdown, filter, limit) {
-        const messages = this.getMessagesForObject(id, { filter, limit });
-        return this.sendObjects(Object.values(messages), req, 'messages');
+        const messages = this.getMessagesForObject(id, { filter });
+        return this.sendObjects(Object.values(messages), req, {
+            path: 'messages',
+            limit,
+            privilege: { action: 'read', resource: 'message' },
+        });
     }
     /**
+     * Returns all tasks that match the following privilege:
+     * - resource: task, action: read
+     *
      * @example id "9fe12ca3-d75d-cfb0-492e-cfd2bc6c568f"
      * @example fields "id,status,properties"
      * @example filter "status:failure"
      * @example limit 42
      */
     async getNetworkTasks(req, id, fields, ndjson, markdown, filter, limit) {
-        const tasks = await this.getTasksForObject(id, { filter, limit });
-        return this.sendObjects(Object.values(tasks), req, 'tasks');
+        const tasks = await this.getTasksForObject(id, { filter });
+        return this.sendObjects(Object.values(tasks), req, {
+            path: 'tasks',
+            limit,
+            privilege: { action: 'read', resource: 'task' },
+        });
     }
     /**
+     * Required privilege:
+     * - resource: network, action: update:tags
+     *
      * @example id "9fe12ca3-d75d-cfb0-492e-cfd2bc6c568f"
      * @example tag "from-rest-api"
      */
@@ -89,6 +125,9 @@ let NetworkController = class NetworkController extends XapiXoController {
         await network.$call('add_tags', tag);
     }
     /**
+     * Required privilege:
+     * - resource: network, action: update:tags
+     *
      * @example id "9fe12ca3-d75d-cfb0-492e-cfd2bc6c568f"
      * @example tag "from-rest-api"
      */
@@ -101,6 +140,7 @@ __decorate([
     Example(networkIds),
     Example(partialNetworks),
     Get(''),
+    Security('*', ['acl']),
     __param(0, Request()),
     __param(1, Query()),
     __param(2, Query()),
@@ -111,11 +151,15 @@ __decorate([
 __decorate([
     Example(network),
     Get('{id}'),
+    Middlewares(acl({ resource: 'network', action: 'read', objectId: 'params.id' })),
+    Response(forbiddenOperationResp.status, forbiddenOperationResp.description),
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Path())
 ], NetworkController.prototype, "getNetwork", null);
 __decorate([
     Delete('{id}'),
+    Middlewares(acl({ resource: 'network', action: 'delete', objectId: 'params.id' })),
+    Response(forbiddenOperationResp.status, forbiddenOperationResp.description),
     SuccessResponse(noContentResp.status, noContentResp.description),
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Path())
@@ -123,6 +167,7 @@ __decorate([
 __decorate([
     Example(genericAlarmsExample),
     Get('{id}/alarms'),
+    Security('*', ['acl']),
     Tags('alarms'),
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Request()),
@@ -137,6 +182,7 @@ __decorate([
     Example(messageIds),
     Example(partialMessages),
     Get('{id}/messages'),
+    Security('*', ['acl']),
     Tags('messages'),
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Request()),
@@ -151,6 +197,7 @@ __decorate([
     Example(taskIds),
     Example(partialTasks),
     Get('{id}/tasks'),
+    Security('*', ['acl']),
     Tags('tasks'),
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Request()),
@@ -163,14 +210,18 @@ __decorate([
 ], NetworkController.prototype, "getNetworkTasks", null);
 __decorate([
     Put('{id}/tags/{tag}'),
+    Middlewares(acl({ resource: 'network', action: 'update:tags', objectId: 'params.id' })),
     SuccessResponse(noContentResp.status, noContentResp.description),
+    Response(forbiddenOperationResp.status, forbiddenOperationResp.description),
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Path()),
     __param(1, Path())
 ], NetworkController.prototype, "putNetworkTag", null);
 __decorate([
     Delete('{id}/tags/{tag}'),
+    Middlewares(acl({ resource: 'network', action: 'update:tags', objectId: 'params.id' })),
     SuccessResponse(noContentResp.status, noContentResp.description),
+    Response(forbiddenOperationResp.status, forbiddenOperationResp.description),
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Path()),
     __param(1, Path())

package/dist/open-api/oa-examples/acl-privilege.oa-example.mjs

@@ -0,0 +1,25 @@
+export const aclPrivilegeIds = [
+    '/rest/v0/acl-privileges/6d16ac11-ad48-483a-a926-3d9655648b28',
+    '/rest/v0/acl-privileges/7a81ac36-264e-468e-ad4d-63d9a10aee6a',
+];
+export const partialAclPrivileges = [
+    {
+        id: '6d16ac11-ad48-483a-a926-3d9655648b28',
+        action: 'create',
+        resource: 'vif',
+        href: '/rest/v0/acl-privileges/6d16ac11-ad48-483a-a926-3d9655648b28',
+    },
+    {
+        id: '7a81ac36-264e-468e-ad4d-63d9a10aee6a',
+        action: 'create',
+        resource: 'vdi',
+        href: '/rest/v0/acl-privileges/7a81ac36-264e-468e-ad4d-63d9a10aee6a',
+    },
+];
+export const aclPrivilege = {
+    action: 'create',
+    effect: 'allow',
+    resource: 'vif',
+    roleId: 'ccaab6e6-bae6-4d9c-9866-911dfc88bdc6',
+    id: '6d16ac11-ad48-483a-a926-3d9655648b28',
+};

package/dist/open-api/oa-examples/acl-role.oa-example.mjs

@@ -0,0 +1,22 @@
+export const aclRoleIds = [
+    '/rest/v0/acl-roles/9cac02e2-f612-4b71-851e-d28b9c0cda88',
+    '/rest/v0/acl-roles/784bd959-08de-4b26-b575-92ded5aef872',
+];
+export const partialAclRoles = [
+    {
+        id: '9cac02e2-f612-4b71-851e-d28b9c0cda88',
+        name: 'VMs read only',
+        isTemplate: true,
+        href: '/rest/v0/acl-roles/9cac02e2-f612-4b71-851e-d28b9c0cda88',
+    },
+    {
+        id: '784bd959-08de-4b26-b575-92ded5aef872',
+        name: 'mra-test-read-only',
+        href: '/rest/v0/acl-roles/784bd959-08de-4b26-b575-92ded5aef872',
+    },
+];
+export const aclRole = {
+    name: 'mra-test-read-only',
+    description: 'Access the whole infra in read-only mode',
+    id: '784bd959-08de-4b26-b575-92ded5aef872',
+};

package/dist/open-api/oa-examples/backup-archive.oa-example.mjs

@@ -1,10 +1,10 @@
 export const backupArchiveIds = [
-    '/rest/v0/backup-archives/231264c3-af43-4ec0-a3be-394c5b1fdbfc//xo-vm-backups/6ef7c09e-677b-1e6f-0546-7ab30413c61c/20250801T080832Z.json',
-    '/rest/v0/backup-archives/1af95910-01b4-4e87-9c2f-d895cafe0776//xo-vm-backups/7cf6150f-a978-09e6-6b41-0d1d41967bdc/20250918T132942Z.json',
+    '/rest/v0/backup-archives/231264c3-af43-4ec0-a3be-394c5b1fdbfc/xo-vm-backups/6ef7c09e-677b-1e6f-0546-7ab30413c61c/20250801T080832Z.json',
+    '/rest/v0/backup-archives/1af95910-01b4-4e87-9c2f-d895cafe0776/xo-vm-backups/7cf6150f-a978-09e6-6b41-0d1d41967bdc/20250918T132942Z.json',
 ];
 export const partialBackupArchives = [
     {
-        id: '231264c3-af43-4ec0-a3be-394c5b1fdbfc//xo-vm-backups/6ef7c09e-677b-1e6f-0546-7ab30413c61c/20250801T080832Z.json',
+        id: '231264c3-af43-4ec0-a3be-394c5b1fdbfc/xo-vm-backups/6ef7c09e-677b-1e6f-0546-7ab30413c61c/20250801T080832Z.json',
         backupRepository: '231264c3-af43-4ec0-a3be-394c5b1fdbfc',
         disks: [
             {
@@ -21,7 +21,7 @@ export const partialBackupArchives = [
         href: '/rest/v0/backup-archives/231264c3-af43-4ec0-a3be-394c5b1fdbfc/xo-vm-backups/6ef7c09e-677b-1e6f-0546-7ab30413c61c/20250801T080832Z.json',
     },
     {
-        id: '1af95910-01b4-4e87-9c2f-d895cafe0776//xo-vm-backups/7cf6150f-a978-09e6-6b41-0d1d41967bdc/20250918T132942Z.json',
+        id: '1af95910-01b4-4e87-9c2f-d895cafe0776/xo-vm-backups/7cf6150f-a978-09e6-6b41-0d1d41967bdc/20250918T132942Z.json',
         backupRepository: '1af95910-01b4-4e87-9c2f-d895cafe0776',
         disks: [
             {
@@ -30,7 +30,7 @@ export const partialBackupArchives = [
                 uuid: '73ed06ed-fdc8-43ef-a1c4-253e9005fbe0',
             },
         ],
-        href: '/rest/v0/backup-archives/1af95910-01b4-4e87-9c2f-d895cafe0776//xo-vm-backups/7cf6150f-a978-09e6-6b41-0d1d41967bdc/20250918T132942Z.json',
+        href: '/rest/v0/backup-archives/1af95910-01b4-4e87-9c2f-d895cafe0776/xo-vm-backups/7cf6150f-a978-09e6-6b41-0d1d41967bdc/20250918T132942Z.json',
     },
 ];
 export const backupArchive = {
@@ -43,7 +43,7 @@ export const backupArchive = {
             uuid: 'c922ef3c-9d76-4482-87f8-a4da5849ee45',
         },
     ],
-    id: '1af95910-01b4-4e87-9c2f-d895cafe0776//xo-vm-backups/7cf6150f-a978-09e6-6b41-0d1d41967bdc/20250918T132942Z.json',
+    id: '1af95910-01b4-4e87-9c2f-d895cafe0776/xo-vm-backups/7cf6150f-a978-09e6-6b41-0d1d41967bdc/20250918T132942Z.json',
     jobId: 'f2599aa4-7bb4-434b-bf71-cf0ebe1e06a4',
     mode: 'delta',
     scheduleId: '8db1c2da-2635-436f-8f78-62079fea3aa6',

package/dist/open-api/oa-examples/common.oa-example.mjs

@@ -0,0 +1,3 @@
+export const entityId = {
+    id: '9cac02e2-f612-4b71-851e-d28b9c0cda88',
+};