@rockcarver/frodo-lib 0.16.2-8 → 0.17.0

package/esm/ops/SecretsOps.mjs

@@ -2,21 +2,19 @@ import { createKeyValueTable, createProgressIndicator, createTable, printMessage
 import { createNewVersionOfSecret, deleteSecret, deleteVersionOfSecret, getSecret, getSecrets, getSecretVersions, putSecret, setSecretDescription, setStatusOfVersionOfSecret, VersionOfSecretStatus } from '../api/SecretsApi';
 import wordwrap from './utils/Wordwrap';
 import { resolveUserName } from './ManagedObjectOps';
+
 /**
  * List secrets
  * @param {boolean} long Long version, all the fields
  */
-
 export async function listSecrets(long) {
   let secrets = [];
-
   try {
     secrets = (await getSecrets()).result;
   } catch (error) {
     printMessage(`${error.message}`, 'error');
     printMessage(error.response.data, 'error');
   }
-
   if (long) {
     const table = createTable(['Id'['brightCyan'], {
       hAlign: 'right',
@@ -26,7 +24,6 @@ export async function listSecrets(long) {
       content: 'Loaded\nVersion'['brightCyan']
     }, 'Status'['brightCyan'], 'Description'['brightCyan'], 'Modifier'['brightCyan'], 'Modified'['brightCyan']]);
     secrets.sort((a, b) => a._id.localeCompare(b._id));
-
     for (const secret of secrets) {
       table.push([secret._id, {
         hAlign: 'right',
@@ -34,10 +31,10 @@ export async function listSecrets(long) {
       }, {
         hAlign: 'right',
         content: secret.loadedVersion
-      }, secret.loaded ? 'loaded'['brightGreen'] : 'unloaded'['brightRed'], wordwrap(secret.description, 40), // eslint-disable-next-line no-await-in-loop
+      }, secret.loaded ? 'loaded'['brightGreen'] : 'unloaded'['brightRed'], wordwrap(secret.description, 40),
+      // eslint-disable-next-line no-await-in-loop
       await resolveUserName('teammember', secret.lastChangedBy), new Date(secret.lastChangeDate).toLocaleString()]);
     }
-
     printMessage(table.toString());
   } else {
     secrets.forEach(secret => {
@@ -45,6 +42,7 @@ export async function listSecrets(long) {
     });
   }
 }
+
 /**
  * Create secret
  * @param {String} id secret id
@@ -53,10 +51,8 @@ export async function listSecrets(long) {
  * @param {String} encoding secret encoding
  * @param {boolean} useInPlaceholders use secret in placeholders
  */
-
 export async function createSecret(id, value, description, encoding, useInPlaceholders) {
   createProgressIndicator(undefined, `Creating secret ${id}...`, 'indeterminate');
-
   try {
     await putSecret(id, value, description, encoding, useInPlaceholders);
     stopProgressIndicator(`Created secret ${id}`, 'success');
@@ -64,15 +60,14 @@ export async function createSecret(id, value, description, encoding, useInPlaceh
     stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
   }
 }
+
 /**
  * Set description of secret
  * @param {String} secretId secret id
  * @param {String} description secret description
  */
-
 export async function setDescriptionOfSecret(secretId, description) {
   createProgressIndicator(undefined, `Setting description of secret ${secretId}...`, 'indeterminate');
-
   try {
     await setSecretDescription(secretId, description);
     stopProgressIndicator(`Set description of secret ${secretId}`, 'success');
@@ -80,14 +75,13 @@ export async function setDescriptionOfSecret(secretId, description) {
     stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
   }
 }
+
 /**
  * Delete a secret
  * @param {String} secretId secret id
  */
-
 export async function deleteSecretCmd(secretId) {
   createProgressIndicator(undefined, `Deleting secret ${secretId}...`, 'indeterminate');
-
   try {
     await deleteSecret(secretId);
     stopProgressIndicator(`Deleted secret ${secretId}`, 'success');
@@ -95,15 +89,14 @@ export async function deleteSecretCmd(secretId) {
     stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
   }
 }
+
 /**
  * Delete all secrets
  */
-
 export async function deleteSecretsCmd() {
   try {
     const secrets = (await getSecrets()).result;
     createProgressIndicator(secrets.length, `Deleting secrets...`);
-
     for (const secret of secrets) {
       try {
         // eslint-disable-next-line no-await-in-loop
@@ -113,52 +106,47 @@ export async function deleteSecretsCmd() {
         printMessage(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'error');
       }
     }
-
     stopProgressIndicator(`Secrets deleted.`);
   } catch (error) {
     printMessage(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'error');
   }
 }
+
 /**
  * List all the versions of the secret
  * @param {String} secretId secret id
  */
-
 export async function listSecretVersionsCmd(secretId) {
   let versions = [];
-
   try {
     versions = await getSecretVersions(secretId);
   } catch (error) {
     printMessage(`${error.message}`, 'error');
     printMessage(error.response.data, 'error');
   }
-
   const table = createTable([{
     hAlign: 'right',
     content: 'Version'['brightCyan']
-  }, 'Status'['brightCyan'], 'Loaded'['brightCyan'], 'Created'['brightCyan']]); // versions.sort((a, b) => a._id.localeCompare(b._id));
-
+  }, 'Status'['brightCyan'], 'Loaded'['brightCyan'], 'Created'['brightCyan']]);
+  // versions.sort((a, b) => a._id.localeCompare(b._id));
   const statusMap = {
     ENABLED: 'active'['brightGreen'],
     DISABLED: 'inactive'['brightRed'],
     DESTROYED: 'deleted'['brightRed']
   };
-
   for (const version of versions) {
     table.push([{
       hAlign: 'right',
       content: version.version
     }, statusMap[version.status], version.loaded ? 'loaded'['brightGreen'] : 'unloaded'['brightRed'], new Date(version.createDate).toLocaleString()]);
   }
-
   printMessage(table.toString());
 }
+
 /**
  * Describe a secret
  * @param {String} secretId Secret id
  */
-
 export async function describeSecret(secretId) {
   const secret = await getSecret(secretId);
   const table = createKeyValueTable();
@@ -176,15 +164,14 @@ export async function describeSecret(secretId) {
   printMessage('\nSecret Versions:');
   await listSecretVersionsCmd(secretId);
 }
+
 /**
  * Create new version of secret
  * @param {String} secretId secret id
  * @param {String} value secret value
  */
-
 export async function createNewVersionOfSecretCmd(secretId, value) {
   createProgressIndicator(undefined, `Creating new version of secret ${secretId}...`, 'indeterminate');
-
   try {
     const version = await createNewVersionOfSecret(secretId, value);
     stopProgressIndicator(`Created version ${version.version} of secret ${secretId}`, 'success');
@@ -192,15 +179,14 @@ export async function createNewVersionOfSecretCmd(secretId, value) {
     stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
   }
 }
+
 /**
  * Activate a version of a secret
  * @param {String} secretId secret id
  * @param {Number} version version of secret
  */
-
 export async function activateVersionOfSecret(secretId, version) {
   createProgressIndicator(undefined, `Activating version ${version} of secret ${secretId}...`, 'indeterminate');
-
   try {
     await setStatusOfVersionOfSecret(secretId, version, VersionOfSecretStatus.ENABLED);
     stopProgressIndicator(`Activated version ${version} of secret ${secretId}`, 'success');
@@ -208,15 +194,14 @@ export async function activateVersionOfSecret(secretId, version) {
     stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
   }
 }
+
 /**
  * Deactivate a version of a secret
  * @param {String} secretId secret id
  * @param {Number} version version of secret
  */
-
 export async function deactivateVersionOfSecret(secretId, version) {
   createProgressIndicator(undefined, `Deactivating version ${version} of secret ${secretId}...`, 'indeterminate');
-
   try {
     await setStatusOfVersionOfSecret(secretId, version, VersionOfSecretStatus.DISABLED);
     stopProgressIndicator(`Deactivated version ${version} of secret ${secretId}`, 'success');
@@ -224,15 +209,14 @@ export async function deactivateVersionOfSecret(secretId, version) {
     stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
   }
 }
+
 /**
  * Delete version of secret
  * @param {String} secretId secret id
  * @param {Number} version version of secret
  */
-
 export async function deleteVersionOfSecretCmd(secretId, version) {
   createProgressIndicator(undefined, `Deleting version ${version} of secret ${secretId}...`, 'indeterminate');
-
   try {
     await deleteVersionOfSecret(secretId, version);
     stopProgressIndicator(`Deleted version ${version} of secret ${secretId}`, 'success');

package/esm/ops/ServiceAccountOps.mjs

@@ -0,0 +1,41 @@
+import { createManagedObject } from '../api/ManagedObjectApi';
+import { debugMessage } from './utils/Console';
+import { getConfigEntity } from './IdmOps';
+const moType = 'svcacct';
+let serviceAccountsFeatureAvailable = undefined;
+export async function isServiceAccountsFeatureAvailable() {
+  debugMessage(`ServiceAccountOps.isServiceAccountsFeatureAvailable: start`);
+  // only look up the schema once
+  if (typeof serviceAccountsFeatureAvailable !== 'undefined') return serviceAccountsFeatureAvailable;
+  serviceAccountsFeatureAvailable = false;
+  const schema = await getConfigEntity('managed');
+  for (const object of schema['objects']) {
+    if (object['name'] === 'svcacct') serviceAccountsFeatureAvailable = true;
+  }
+  debugMessage(`ServiceAccountOps.isServiceAccountsFeatureAvailable: end, available=${serviceAccountsFeatureAvailable}`);
+  return serviceAccountsFeatureAvailable;
+}
+
+/**
+ * Create service account
+ * @param {string} name Human-readable name of service account
+ * @param {string} description Description of service account
+ * @param {'Active' | 'Inactive'} accountStatus Service account status
+ * @param {string[]} scopes Scopes.
+ * @param {JwksInterface} jwks Java Web Key Set
+ * @returns {Promise<ObjectSkeletonInterface>} A promise resolving to a service account object
+ */
+export async function createServiceAccount(name, description, accountStatus, scopes, jwks) {
+  const payload = {
+    name,
+    description,
+    accountStatus,
+    scopes,
+    jwks: JSON.stringify(jwks)
+  };
+  debugMessage(`SvcacctOps: createSvcacct: payload:`);
+  debugMessage(payload);
+  const result = await createManagedObject(moType, payload);
+  return result;
+}
+//# sourceMappingURL=ServiceAccountOps.js.map

package/esm/ops/ServiceAccountOps.test.mjs

@@ -0,0 +1,51 @@
+import axios from 'axios';
+import MockAdapter from 'axios-mock-adapter';
+import { state } from '../index';
+import * as globalConfig from '../storage/StaticStorage';
+import { createJwkRsa, createJwks, getJwkRsaPublic } from './JoseOps';
+import * as ServiceAccount from './ServiceAccountOps';
+import { mockCreateManagedObject } from '../test/mocks/ForgeRockApiMockEngine';
+import { isEqualJson } from './utils/OpsUtils';
+const mock = new MockAdapter(axios);
+const outputHandler = message => {
+  console.log(message);
+};
+state.setHost('https://openam-frodo-dev.forgeblocks.com/am');
+state.setRealm('alpha');
+state.setCookieName('cookieName');
+state.setCookieValue('cookieValue');
+state.setDeploymentType(globalConfig.CLOUD_DEPLOYMENT_TYPE_KEY);
+state.setDebug(true);
+state.setDebugHandler(outputHandler);
+state.setPrintHandler(outputHandler);
+state.setCurlirize(true);
+state.setCurlirizeHandler(outputHandler);
+describe('SvcacctOps - createSvcacct()', () => {
+  test('createSvcacct() 0: Method is implemented', async () => {
+    expect(ServiceAccount.createServiceAccount).toBeDefined();
+  });
+  test('createSvcacct() 1: Create service account', async () => {
+    let moId = null;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let moData = null;
+    const name = 'sa';
+    const description = 'service account';
+    const accountStatus = 'Active';
+    const scopes = ['fr:am:*', 'fr:idm:*', 'fr:idc:esv:*'];
+    const jwk = await createJwkRsa();
+    const publicJwk = await getJwkRsaPublic(jwk);
+    const jwks = await createJwks(publicJwk);
+    mockCreateManagedObject(mock, (mockManagedObjId, mockManagedObj) => {
+      moId = mockManagedObjId;
+      moData = mockManagedObj;
+    });
+    const payload = await ServiceAccount.createServiceAccount(name, description, accountStatus, scopes, jwks);
+    expect(isEqualJson(payload, moData)).toBeTruthy();
+    expect(payload).toBeTruthy();
+    expect(payload._id).toBe(moId);
+    expect(payload.name).toBe(name);
+    expect(payload.description).toBe(description);
+    expect(payload.scopes).toStrictEqual(scopes);
+  });
+});
+//# sourceMappingURL=ServiceAccountOps.test.js.map

package/esm/ops/ServiceOps.mjs

@@ -1,6 +1,5 @@
 import { deleteService, deleteServiceNextDescendent, getService, getListOfServices as _getListOfServices, getServiceDescendents, putService, putServiceNextDescendent } from '../api/ServiceApi';
 import { debugMessage, printMessage } from './utils/Console';
-
 /**
  * Create an empty service export template
  * @returns {SingleTreeExportInterface} an empty service export template
@@ -11,36 +10,37 @@ export function createServiceExportTemplate() {
     service: {}
   };
 }
+
 /**
  * Get list of services
+ * @param {boolean} globalConfig true if the list of global services is requested, false otherwise. Default: false.
  */
-
-export async function getListOfServices() {
+export async function getListOfServices(globalConfig = false) {
   debugMessage(`ServiceOps.getListOfServices: start`);
-  const services = (await _getListOfServices()).result;
+  const services = (await _getListOfServices(globalConfig)).result;
   debugMessage(`ServiceOps.getListOfServices: end`);
   return services;
 }
+
 /**
  * Get all services including their descendents.
+ * @param {boolean} globalConfig true if the global service is the target of the operation, false otherwise. Default: false.
  * @returns Promise resolving to an array of services with their descendants
  */
-
-export async function getFullServices() {
-  debugMessage(`ServiceOps.getFullServices: start`);
-  const serviceList = (await _getListOfServices()).result;
+export async function getFullServices(globalConfig = false) {
+  debugMessage(`ServiceOps.getFullServices: start, globalConfig=${globalConfig}`);
+  const serviceList = (await _getListOfServices(globalConfig)).result;
   const fullServiceData = await Promise.all(serviceList.map(async listItem => {
     try {
-      const [service, nextDescendents] = await Promise.all([getService(listItem._id), getServiceDescendents(listItem._id)]);
-      return { ...service,
+      const [service, nextDescendents] = await Promise.all([getService(listItem._id, globalConfig), getServiceDescendents(listItem._id, globalConfig)]);
+      return {
+        ...service,
         nextDescendents
       };
     } catch (error) {
       var _error$response, _error$response2, _error$response2$data;
-
       if (!(((_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.status) === 403 && ((_error$response2 = error.response) === null || _error$response2 === void 0 ? void 0 : (_error$response2$data = _error$response2.data) === null || _error$response2$data === void 0 ? void 0 : _error$response2$data.message) === 'This operation is not available in ForgeRock Identity Cloud.')) {
         var _error$response3, _error$response3$data;
-
         const message = (_error$response3 = error.response) === null || _error$response3 === void 0 ? void 0 : (_error$response3$data = _error$response3.data) === null || _error$response3$data === void 0 ? void 0 : _error$response3$data.message;
         printMessage(`Unable to retrieve data for ${listItem._id} with error: ${message}`, 'error');
       }
@@ -49,126 +49,118 @@ export async function getFullServices() {
   debugMessage(`ServiceOps.getFullServices: end`);
   return fullServiceData.filter(data => !!data); // make sure to filter out any undefined objects
 }
+
 /**
  * Saves a service using the provide id and data, including descendents
  * @param {string} serviceId the service id / name
  * @param {string} fullServiceData service object including descendants
+ * @param {boolean} globalConfig true if the global service is the target of the operation, false otherwise. Default: false.
  * @returns promise resolving to a service object
  */
-
-async function putFullService(serviceId, fullServiceData, clean) {
-  debugMessage(`ServiceOps.putFullService: start, serviceId=${serviceId}`);
+async function putFullService(serviceId, fullServiceData, clean, globalConfig = false) {
+  debugMessage(`ServiceOps.putFullService: start, serviceId=${serviceId}, globalConfig=${globalConfig}`);
   const nextDescendents = fullServiceData.nextDescendents;
   delete fullServiceData.nextDescendents;
   delete fullServiceData._rev;
   delete fullServiceData.enabled;
-
   if (clean) {
     try {
       debugMessage(`ServiceOps.putFullService: clean`);
-      await deleteFullService(serviceId);
+      await deleteFullService(serviceId, globalConfig);
     } catch (error) {
       var _error$response4, _error$response5, _error$response5$data;
-
       if (!(((_error$response4 = error.response) === null || _error$response4 === void 0 ? void 0 : _error$response4.status) === 404 && ((_error$response5 = error.response) === null || _error$response5 === void 0 ? void 0 : (_error$response5$data = _error$response5.data) === null || _error$response5$data === void 0 ? void 0 : _error$response5$data.message) === 'Not Found')) {
         var _error$response6, _error$response6$data;
-
         const message = (_error$response6 = error.response) === null || _error$response6 === void 0 ? void 0 : (_error$response6$data = _error$response6.data) === null || _error$response6$data === void 0 ? void 0 : _error$response6$data.message;
         printMessage(`Error deleting service '${serviceId}' before import: ${message}`, 'error');
       }
     }
-  } // create service first
-
+  }
 
-  const result = await putService(serviceId, fullServiceData); // return fast if no next descendents supplied
+  // create service first
+  const result = await putService(serviceId, fullServiceData, globalConfig);
 
+  // return fast if no next descendents supplied
   if (nextDescendents.length === 0) {
     debugMessage(`ServiceOps.putFullService: end (w/o descendents)`);
     return result;
-  } // now create next descendents
-
+  }
 
+  // now create next descendents
   await Promise.all(nextDescendents.map(async descendent => {
     const type = descendent._type._id;
     const descendentId = descendent._id;
     debugMessage(`ServiceOps.putFullService: descendentId=${descendentId}`);
     let result = undefined;
-
     try {
-      result = await putServiceNextDescendent(serviceId, type, descendentId, descendent);
+      result = await putServiceNextDescendent(serviceId, type, descendentId, descendent, globalConfig);
     } catch (error) {
       var _error$response7, _error$response7$data;
-
       const message = (_error$response7 = error.response) === null || _error$response7 === void 0 ? void 0 : (_error$response7$data = _error$response7.data) === null || _error$response7$data === void 0 ? void 0 : _error$response7$data.message;
       printMessage(`Put descendent '${descendentId}' of service '${serviceId}': ${message}`, 'error');
     }
-
     return result;
   }));
   debugMessage(`ServiceOps.putFullService: end (w/ descendents)`);
 }
+
 /**
  * Saves multiple services using the serviceEntries which contain both id and data with descendants
  * @param {[string, FullService][]} serviceEntries The services to add
  * @param {boolean} clean Indicates whether to remove possible existing services first
+ * @param {boolean} globalConfig true if the global service is the target of the operation, false otherwise. Default: false.
  * @returns {Promise<AmService[]>} promise resolving to an array of service objects
  */
-
-
-async function putFullServices(serviceEntries, clean) {
-  debugMessage(`ServiceOps.putFullServices: start`);
+async function putFullServices(serviceEntries, clean, globalConfig = false) {
+  debugMessage(`ServiceOps.putFullServices: start, globalConfig=${globalConfig}`);
   const results = [];
-
   for (const [id, data] of serviceEntries) {
     try {
-      const result = await putFullService(id, data, clean);
+      const result = await putFullService(id, data, clean, globalConfig);
       results.push(result);
       printMessage(`Imported: ${id}`, 'info');
     } catch (error) {
       var _error$response8, _error$response8$data, _error$response9, _error$response9$data;
-
       const message = (_error$response8 = error.response) === null || _error$response8 === void 0 ? void 0 : (_error$response8$data = _error$response8.data) === null || _error$response8$data === void 0 ? void 0 : _error$response8$data.message;
       const detail = (_error$response9 = error.response) === null || _error$response9 === void 0 ? void 0 : (_error$response9$data = _error$response9.data) === null || _error$response9$data === void 0 ? void 0 : _error$response9$data.detail;
       printMessage(`Import service '${id}': ${message}`, 'error');
-
       if (detail) {
         printMessage(`Details: ${JSON.stringify(detail)}`, 'error');
       }
     }
   }
-
   debugMessage(`ServiceOps.putFullServices: end`);
   return results;
 }
+
 /**
  * Deletes the specified service
  * @param {string} serviceId The service to delete
+ * @param {boolean} globalConfig true if the global service is the target of the operation, false otherwise. Default: false.
  */
-
-
-export async function deleteFullService(serviceId) {
-  const serviceNextDescendentData = await getServiceDescendents(serviceId);
-  await Promise.all(serviceNextDescendentData.map(nextDescendent => deleteServiceNextDescendent(serviceId, nextDescendent._type._id, nextDescendent._id)));
-  await deleteService(serviceId);
+export async function deleteFullService(serviceId, globalConfig = false) {
+  debugMessage(`ServiceOps.deleteFullService: start, globalConfig=${globalConfig}`);
+  const serviceNextDescendentData = await getServiceDescendents(serviceId, globalConfig);
+  await Promise.all(serviceNextDescendentData.map(nextDescendent => deleteServiceNextDescendent(serviceId, nextDescendent._type._id, nextDescendent._id, globalConfig)));
+  await deleteService(serviceId, globalConfig);
+  debugMessage(`ServiceOps.deleteFullService: end`);
 }
+
 /**
  * Deletes all services
+ * @param {boolean} globalConfig true if the global service is the target of the operation, false otherwise. Default: false.
  */
-
-export async function deleteFullServices() {
-  debugMessage(`ServiceOps.deleteFullServices: start`);
-
+export async function deleteFullServices(globalConfig = false) {
+  debugMessage(`ServiceOps.deleteFullServices: start, globalConfig=${globalConfig}`);
   try {
-    const serviceList = (await _getListOfServices()).result;
+    const serviceList = (await _getListOfServices(globalConfig)).result;
     await Promise.all(serviceList.map(async serviceListItem => {
       try {
-        await deleteFullService(serviceListItem._id);
+        await deleteFullService(serviceListItem._id, globalConfig);
       } catch (error) {
         var _error$response10, _error$response11, _error$response11$dat;
-
         if (!(((_error$response10 = error.response) === null || _error$response10 === void 0 ? void 0 : _error$response10.status) === 403 && ((_error$response11 = error.response) === null || _error$response11 === void 0 ? void 0 : (_error$response11$dat = _error$response11.data) === null || _error$response11$dat === void 0 ? void 0 : _error$response11$dat.message) === 'This operation is not available in ForgeRock Identity Cloud.')) {
           var _error$response12, _error$response12$dat;
-
           const message = (_error$response12 = error.response) === null || _error$response12 === void 0 ? void 0 : (_error$response12$dat = _error$response12.data) === null || _error$response12$dat === void 0 ? void 0 : _error$response12$dat.message;
           printMessage(`Delete service '${serviceListItem._id}': ${message}`, 'error');
         }
@@ -176,100 +168,91 @@ export async function deleteFullServices() {
     }));
   } catch (error) {
     var _error$response13, _error$response13$dat;
-
     const message = (_error$response13 = error.response) === null || _error$response13 === void 0 ? void 0 : (_error$response13$dat = _error$response13.data) === null || _error$response13$dat === void 0 ? void 0 : _error$response13$dat.message;
     printMessage(`Delete services: ${message}`, 'error');
   }
-
   debugMessage(`ServiceOps.deleteFullServices: end`);
 }
+
 /**
  * Export service. The response can be saved to file as is.
  * @param serviceId service id/name
+ * @param {boolean} globalConfig true if the global service is the target of the operation, false otherwise. Default: false.
  * @returns {Promise<ServiceExportInterface>} Promise resolving to a ServiceExportInterface object.
  */
-
-export async function exportService(serviceId) {
-  debugMessage(`ServiceOps.exportService: start`);
+export async function exportService(serviceId, globalConfig = false) {
+  debugMessage(`ServiceOps.exportService: start, globalConfig=${globalConfig}`);
   const exportData = createServiceExportTemplate();
-
   try {
-    const service = await getService(serviceId);
-    service.nextDescendents = await getServiceDescendents(serviceId);
+    const service = await getService(serviceId, globalConfig);
+    service.nextDescendents = await getServiceDescendents(serviceId, globalConfig);
     exportData.service[serviceId] = service;
   } catch (error) {
     var _error$response14, _error$response14$dat;
-
     const message = (_error$response14 = error.response) === null || _error$response14 === void 0 ? void 0 : (_error$response14$dat = _error$response14.data) === null || _error$response14$dat === void 0 ? void 0 : _error$response14$dat.message;
     printMessage(`Export service '${serviceId}': ${message}`, 'error');
   }
-
   debugMessage(`ServiceOps.exportService: end`);
   return exportData;
 }
+
 /**
  * Export all services
- * @param {string} file Options filename for the file, otherwise all{realm}Services.service.json will be the name
+ * @param {boolean} globalConfig true if the global service is the target of the operation, false otherwise. Default: false.
  */
-
-export async function exportServices() {
-  debugMessage(`ServiceOps.exportServices: start`);
+export async function exportServices(globalConfig = false) {
+  debugMessage(`ServiceOps.exportServices: start, globalConfig=${globalConfig}`);
   const exportData = createServiceExportTemplate();
-
   try {
-    const services = await getFullServices();
-
+    const services = await getFullServices(globalConfig);
     for (const service of services) {
       exportData.service[service._type._id] = service;
     }
   } catch (error) {
     var _error$response15, _error$response15$dat;
-
     const message = (_error$response15 = error.response) === null || _error$response15 === void 0 ? void 0 : (_error$response15$dat = _error$response15.data) === null || _error$response15$dat === void 0 ? void 0 : _error$response15$dat.message;
     printMessage(`Export servics: ${message}`, 'error');
   }
-
   debugMessage(`ServiceOps.exportServices: end`);
   return exportData;
 }
+
 /**
  * Imports a single service using a reference to the service and a file to read the data from. Optionally clean (remove) an existing service first
  * @param {string} serviceId The service id/name to add
+ * @param {ServiceExportInterface} importData The service configuration export data to import
  * @param {boolean} clean Indicates whether to remove a possible existing service with the same id first.
- * @param {string} file Reference to the filename with the data for the service
+ * @param {boolean} globalConfig true if the global service is the target of the operation, false otherwise. Default: false.
  * @returns Promise resolving when the service has been imported
  */
-
-export async function importService(serviceId, importData, clean) {
-  debugMessage(`ServiceOps.importService: start`);
+export async function importService(serviceId, importData, clean, globalConfig = false) {
+  debugMessage(`ServiceOps.importService: start, globalConfig=${globalConfig}`);
   const serviceData = importData.service[serviceId];
-  const result = await putFullService(serviceId, serviceData, clean);
+  const result = await putFullService(serviceId, serviceData, clean, globalConfig);
   debugMessage(`ServiceOps.importService: end`);
   return result;
 }
+
 /**
  * Imports multiple services from the same file. Optionally clean (remove) existing services first
+ * @param {ServiceExportInterface} importData The service configuration export data to import
  * @param {boolean} clean Indicates whether to remove possible existing services first
+ * @param {boolean} globalConfig true if the global service is the target of the operation, false otherwise. Default: false.
  */
-
-export async function importServices(importData, clean) {
-  debugMessage(`ServiceOps.importServices: start`);
-
+export async function importServices(importData, clean, globalConfig = false) {
+  debugMessage(`ServiceOps.importServices: start, globalConfig=${globalConfig}`);
   try {
-    const result = await putFullServices(Object.entries(importData.service), clean);
+    const result = await putFullServices(Object.entries(importData.service), clean, globalConfig);
     debugMessage(`ServiceOps.importServices: end`);
     return result;
   } catch (error) {
     var _error$response16, _error$response16$dat, _error$response17, _error$response17$dat;
-
     const message = (_error$response16 = error.response) === null || _error$response16 === void 0 ? void 0 : (_error$response16$dat = _error$response16.data) === null || _error$response16$dat === void 0 ? void 0 : _error$response16$dat.message;
     const detail = (_error$response17 = error.response) === null || _error$response17 === void 0 ? void 0 : (_error$response17$dat = _error$response17.data) === null || _error$response17$dat === void 0 ? void 0 : _error$response17$dat.detail;
     printMessage(`Unable to import services: error: ${message}`, 'error');
-
     if (detail) {
       printMessage(`Details: ${JSON.stringify(detail)}`, 'error');
     }
-
     throw error;
   }
 }