dataverse-utils 2.0.10 → 2.0.11

package/lib/assemblyDeploy.js

@@ -1,22 +1,29 @@
-import fs from 'fs';
-import path from 'path';
-import { deploy } from './models/pluginAssembly';
-import { logger } from 'just-scripts-utils';
-export async function deployAssembly(creds, apiConfig) {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployAssembly = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const pluginAssembly_1 = require("./models/pluginAssembly");
+const just_scripts_utils_1 = require("just-scripts-utils");
+async function deployAssembly(creds, apiConfig) {
     const currentPath = '.';
-    const configFile = fs.readFileSync(path.resolve(currentPath, 'dataverse.config.json'), 'utf8');
+    const configFile = fs_1.default.readFileSync(path_1.default.resolve(currentPath, 'dataverse.config.json'), 'utf8');
     if (configFile == null) {
-        logger.warn('unable to find dataverse.config.json file');
+        just_scripts_utils_1.logger.warn('unable to find dataverse.config.json file');
         return;
     }
     const config = JSON.parse(configFile);
-    logger.info('deploy assembly');
+    just_scripts_utils_1.logger.info('deploy assembly');
     try {
-        await deploy(config, apiConfig, creds.solution);
+        await (0, pluginAssembly_1.deploy)(config, apiConfig, creds.solution);
     }
     catch (error) {
-        logger.error(error.message);
+        just_scripts_utils_1.logger.error(error.message);
         return;
     }
-    logger.info(`deployed assembly ${config.name}\r\n`);
+    just_scripts_utils_1.logger.info(`deployed assembly ${config.name}\r\n`);
 }
+exports.deployAssembly = deployAssembly;

package/lib/auth.js

@@ -1,18 +1,21 @@
-import { cachePlugin } from './cachePlugin';
-import { PublicClientApplication } from '@azure/msal-node';
-import { logger } from 'just-scripts-utils';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccessToken = void 0;
+const cachePlugin_1 = require("./cachePlugin");
+const msal_node_1 = require("@azure/msal-node");
+const just_scripts_utils_1 = require("just-scripts-utils");
 const clientId = '51f81489-12ee-4a9e-aaae-a2591f45987d';
-export const getAccessToken = async (tenant, url) => {
+const getAccessToken = async (tenant, url) => {
     const config = {
         auth: {
             clientId: clientId,
             authority: `https://login.microsoftonline.com/${tenant}/`
         },
         cache: {
-            cachePlugin: cachePlugin(url.replace('https://', '').split('.')[0])
+            cachePlugin: (0, cachePlugin_1.cachePlugin)(url.replace('https://', '').split('.')[0])
         }
     };
-    const pca = new PublicClientApplication(config);
+    const pca = new msal_node_1.PublicClientApplication(config);
     const cache = pca.getTokenCache();
     const accounts = await cache?.getAllAccounts().catch(ex => {
         throw new Error(ex.message);
@@ -32,9 +35,10 @@ export const getAccessToken = async (tenant, url) => {
     // Acquire token by device code
     const token = await pca.acquireTokenByDeviceCode({
         scopes: [`${url}/.default`],
-        deviceCodeCallback: (response) => logger.info(response.message)
+        deviceCodeCallback: (response) => just_scripts_utils_1.logger.info(response.message)
     }).catch(ex => {
         throw new Error(ex.message);
     });
     return token;
 };
+exports.getAccessToken = getAccessToken;

package/lib/cachePlugin.js

@@ -1,31 +1,37 @@
-import os from 'os';
-import path from 'path';
-import fs from 'fs';
-import Cryptr from 'cryptr';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachePlugin = void 0;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const cryptr_1 = __importDefault(require("cryptr"));
 const encrypt = (text) => {
-    const user = os.userInfo().username;
-    const cryptr = new Cryptr(user);
+    const user = os_1.default.userInfo().username;
+    const cryptr = new cryptr_1.default(user);
     const encrypted = cryptr.encrypt(text);
     return encrypted;
 };
 const decrypt = (text) => {
-    const user = os.userInfo().username;
-    const cryptr = new Cryptr(user);
+    const user = os_1.default.userInfo().username;
+    const cryptr = new cryptr_1.default(user);
     const decrypted = cryptr.decrypt(text);
     return decrypted;
 };
-export function cachePlugin(org) {
+function cachePlugin(org) {
     const getCachePath = () => {
-        if (!fs.existsSync(path.join(os.homedir(), './.dataverse-utils/'))) {
-            fs.mkdirSync(path.join(os.homedir(), './.dataverse-utils/'));
+        if (!fs_1.default.existsSync(path_1.default.join(os_1.default.homedir(), './.dataverse-utils/'))) {
+            fs_1.default.mkdirSync(path_1.default.join(os_1.default.homedir(), './.dataverse-utils/'));
         }
-        return path.join(os.homedir(), `./.dataverse-utils/${org}.json`);
+        return path_1.default.join(os_1.default.homedir(), `./.dataverse-utils/${org}.json`);
     };
     const cacheLocation = getCachePath();
     const beforeCacheAccess = (tokenCacheContext) => {
         return new Promise((resolve, reject) => {
-            if (fs.existsSync(cacheLocation)) {
-                fs.readFile(cacheLocation, 'utf-8', (err, data) => {
+            if (fs_1.default.existsSync(cacheLocation)) {
+                fs_1.default.readFile(cacheLocation, 'utf-8', (err, data) => {
                     if (err) {
                         reject();
                     }
@@ -38,7 +44,7 @@ export function cachePlugin(org) {
             }
             else {
                 const encrypted = encrypt(tokenCacheContext.tokenCache.serialize());
-                fs.writeFile(cacheLocation, encrypted, (err) => {
+                fs_1.default.writeFile(cacheLocation, encrypted, (err) => {
                     if (err) {
                         reject();
                     }
@@ -53,7 +59,7 @@ export function cachePlugin(org) {
         return new Promise((resolve, reject) => {
             if (tokenCacheContext.cacheHasChanged) {
                 const encrypted = encrypt(tokenCacheContext.tokenCache.serialize());
-                fs.writeFile(cacheLocation, encrypted, (err) => {
+                fs_1.default.writeFile(cacheLocation, encrypted, (err) => {
                     if (err) {
                         reject(err);
                     }
@@ -70,3 +76,4 @@ export function cachePlugin(org) {
         afterCacheAccess
     };
 }
+exports.cachePlugin = cachePlugin;

package/lib/dataverse-utils.js

@@ -1,38 +1,43 @@
 #!/usr/bin/env node
-import { program } from 'commander';
-import deploy from './deploy';
-import generate from './generate';
-program
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const deploy_1 = __importDefault(require("./deploy"));
+const generate_1 = __importDefault(require("./generate"));
+commander_1.program
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     .version(require('../package').version)
     .usage('<command> [options]');
 // Deploy command
-program
+commander_1.program
     .command('deploy')
     .description('Deploy file(s) to dataverse (webresource, plugin, workflow)')
     .argument('[type]', 'Type of project to deploy')
     .argument('[files]', 'Comma separate list of files to deploy')
     .action((type, files) => {
-    deploy(type, files);
+    (0, deploy_1.default)(type, files);
 });
 // Generate command
-program
+commander_1.program
     .command('generate')
     .description('Generate early-bound TypeScript file for specified table')
     .argument('[table]', 'Table to generate')
     .action((table) => {
-    generate(table);
+    (0, generate_1.default)(table);
 });
 // Show help on unknown command
-program
+commander_1.program
     .arguments('<command>')
     .action((cmd) => {
-    program.outputHelp();
+    commander_1.program.outputHelp();
     console.log();
     console.log(`Unknown command ${cmd}.`);
     console.log();
 });
-program.parse(process.argv);
+commander_1.program.parse(process.argv);
 if (!process.argv.slice(2).length) {
-    program.outputHelp();
+    commander_1.program.outputHelp();
 }

package/lib/dataverse.service.js

@@ -1,13 +1,16 @@
-import { retrieveMultiple, unboundAction } from 'dataverse-webapi/lib/node';
-export var ComponentType;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTableMetadata = exports.publish = exports.addToSolution = exports.ComponentType = void 0;
+const node_1 = require("dataverse-webapi/lib/node");
+var ComponentType;
 (function (ComponentType) {
     ComponentType[ComponentType["WebResource"] = 61] = "WebResource";
     ComponentType[ComponentType["PluginType"] = 90] = "PluginType";
     ComponentType[ComponentType["PluginAssembly"] = 91] = "PluginAssembly";
     ComponentType[ComponentType["SDKMessageProcessingStep"] = 92] = "SDKMessageProcessingStep";
     ComponentType[ComponentType["SDKMessageProcessingStepImage"] = 93] = "SDKMessageProcessingStepImage";
-})(ComponentType || (ComponentType = {}));
-export async function addToSolution(id, solution, type, apiConfig) {
+})(ComponentType = exports.ComponentType || (exports.ComponentType = {}));
+async function addToSolution(id, solution, type, apiConfig) {
     const data = {
         ComponentId: id,
         ComponentType: type,
@@ -15,20 +18,22 @@ export async function addToSolution(id, solution, type, apiConfig) {
         AddRequiredComponents: false,
         IncludedComponentSettingsValues: null
     };
-    await unboundAction(apiConfig, 'AddSolutionComponent', data);
+    await (0, node_1.unboundAction)(apiConfig, 'AddSolutionComponent', data);
 }
-export async function publish(publishXml, apiConfig) {
+exports.addToSolution = addToSolution;
+async function publish(publishXml, apiConfig) {
     const data = {
         ParameterXml: `<importexportxml><webresources>${publishXml}</webresources></importexportxml>`
     };
-    await unboundAction(apiConfig, 'PublishXml', data);
+    await (0, node_1.unboundAction)(apiConfig, 'PublishXml', data);
 }
-export async function getTableMetadata(table, apiConfig) {
+exports.publish = publish;
+async function getTableMetadata(table, apiConfig) {
     const options = [
         '?$select=DisplayName,LogicalName,EntitySetName,SchemaName',
         '&$expand=Attributes($select=LogicalName,SchemaName)'
     ].join('');
-    const metadata = await retrieveMultiple(apiConfig, `EntityDefinitions(LogicalName='${table}')`, options);
+    const metadata = await (0, node_1.retrieveMultiple)(apiConfig, `EntityDefinitions(LogicalName='${table}')`, options);
     if (metadata == null) {
         throw Error(`Table ${table} not found in metadata cache`);
     }
@@ -36,7 +41,7 @@ export async function getTableMetadata(table, apiConfig) {
         '?$select=attributevalue,value,attributename',
         `&$filter=objecttypecode eq '${table}'`
     ].join('');
-    const choiceMetadata = await retrieveMultiple(apiConfig, 'stringmaps', choiceOptions);
+    const choiceMetadata = await (0, node_1.retrieveMultiple)(apiConfig, 'stringmaps', choiceOptions);
     const tableMetadata = {
         logicalName: metadata.LogicalName,
         schemaName: metadata.SchemaName,
@@ -60,3 +65,4 @@ export async function getTableMetadata(table, apiConfig) {
     });
     return tableMetadata;
 }
+exports.getTableMetadata = getTableMetadata;

package/lib/deploy.js

@@ -1,16 +1,21 @@
-import prompts from 'prompts';
-import fs from 'fs';
-import path from 'path';
-import { logger } from 'just-scripts-utils';
-import { deployAssembly } from './assemblyDeploy';
-import { deployWebResource } from './webResourceDeploy';
-import { WebApiConfig } from 'dataverse-webapi/lib/node';
-import { getAccessToken } from './auth';
-export default async function deploy(type, files) {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompts_1 = __importDefault(require("prompts"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const just_scripts_utils_1 = require("just-scripts-utils");
+const assemblyDeploy_1 = require("./assemblyDeploy");
+const webResourceDeploy_1 = require("./webResourceDeploy");
+const node_1 = require("dataverse-webapi/lib/node");
+const auth_1 = require("./auth");
+async function deploy(type, files) {
     if (!type || (type !== 'webresource' && type !== 'assembly')) {
         const invalid = type !== undefined && type !== 'webresource' && type !== 'assembly';
         const invalidMessage = invalid ? `${type} is not a valid project type.` : '';
-        const { typePrompt } = await prompts({
+        const { typePrompt } = await (0, prompts_1.default)({
             type: 'select',
             name: 'typePrompt',
             message: `${invalidMessage} select project type to deploy`,
@@ -22,33 +27,34 @@ export default async function deploy(type, files) {
         type = typePrompt;
     }
     const currentPath = '.';
-    const credsFile = fs.readFileSync(path.resolve(currentPath, 'dataverse.config.json'), 'utf8');
+    const credsFile = fs_1.default.readFileSync(path_1.default.resolve(currentPath, 'dataverse.config.json'), 'utf8');
     if (credsFile == null) {
-        logger.warn('unable to find dataverse.config.json file');
+        just_scripts_utils_1.logger.warn('unable to find dataverse.config.json file');
         return;
     }
     const creds = JSON.parse(credsFile).connection;
     let token = null;
     try {
-        token = await getAccessToken(creds.tenant, creds.server);
+        token = await (0, auth_1.getAccessToken)(creds.tenant, creds.server);
     }
     catch (error) {
-        logger.error(`failed to acquire access token: ${error.message}`);
+        just_scripts_utils_1.logger.error(`failed to acquire access token: ${error.message}`);
         return;
     }
     if (token == null || token.accessToken == null) {
-        logger.error('failed to acquire access token');
+        just_scripts_utils_1.logger.error('failed to acquire access token');
         return;
     }
-    const apiConfig = new WebApiConfig('8.2', token.accessToken, creds.server);
+    const apiConfig = new node_1.WebApiConfig('8.2', token.accessToken, creds.server);
     switch (type) {
         case 'webresource':
-            await deployWebResource(creds, apiConfig, files);
+            await (0, webResourceDeploy_1.deployWebResource)(creds, apiConfig, files);
             break;
         case 'assembly':
-            await deployAssembly(creds, apiConfig);
+            await (0, assemblyDeploy_1.deployAssembly)(creds, apiConfig);
             break;
         default:
             break;
     }
 }
+exports.default = deploy;

package/lib/generate.js

@@ -1,13 +1,18 @@
-import prompts from 'prompts';
-import fs from 'fs';
-import path from 'path';
-import { logger } from 'just-scripts-utils';
-import { getTableMetadata } from './dataverse.service';
-import { WebApiConfig } from 'dataverse-webapi/lib/node';
-import { getAccessToken } from './auth';
-export default async function generate(table) {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompts_1 = __importDefault(require("prompts"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const just_scripts_utils_1 = require("just-scripts-utils");
+const dataverse_service_1 = require("./dataverse.service");
+const node_1 = require("dataverse-webapi/lib/node");
+const auth_1 = require("./auth");
+async function generate(table) {
     while (!table) {
-        const { tablePrompt } = await prompts({
+        const { tablePrompt } = await (0, prompts_1.default)({
             type: 'text',
             name: 'tablePrompt',
             message: `enter table to generate`
@@ -15,32 +20,32 @@ export default async function generate(table) {
         table = tablePrompt;
     }
     const currentPath = '.';
-    const credsFile = fs.readFileSync(path.resolve(currentPath, 'dataverse.config.json'), 'utf8');
+    const credsFile = fs_1.default.readFileSync(path_1.default.resolve(currentPath, 'dataverse.config.json'), 'utf8');
     if (credsFile == null) {
-        logger.warn('unable to find dataverse.config.json file');
+        just_scripts_utils_1.logger.warn('unable to find dataverse.config.json file');
         return;
     }
     const creds = JSON.parse(credsFile).connection;
     let token = null;
     try {
-        token = await getAccessToken(creds.tenant, creds.server);
+        token = await (0, auth_1.getAccessToken)(creds.tenant, creds.server);
     }
     catch (error) {
-        logger.error(`failed to acquire access token: ${error.message}`);
+        just_scripts_utils_1.logger.error(`failed to acquire access token: ${error.message}`);
         return;
     }
     if (token == null || token.accessToken == null) {
-        logger.error('failed to acquire access token');
+        just_scripts_utils_1.logger.error('failed to acquire access token');
         return;
     }
-    const apiConfig = new WebApiConfig('8.2', token.accessToken, creds.server);
+    const apiConfig = new node_1.WebApiConfig('8.2', token.accessToken, creds.server);
     let metadata = {};
-    logger.info('Retrieve table metadata');
+    just_scripts_utils_1.logger.info('Retrieve table metadata');
     try {
-        metadata = await getTableMetadata(table, apiConfig);
+        metadata = await (0, dataverse_service_1.getTableMetadata)(table, apiConfig);
     }
     catch (error) {
-        logger.error(error.message);
+        just_scripts_utils_1.logger.error(error.message);
         return;
     }
     // Build code file from metadata
@@ -85,9 +90,10 @@ export default async function generate(table) {
         '\r\n',
         `export default new ${metadata.schemaName}();`
     ].join('');
-    if (!fs.existsSync(path.resolve(currentPath, 'src', 'scripts', 'models'))) {
-        fs.mkdirSync(path.resolve(currentPath, 'src', 'scripts', 'models'));
+    if (!fs_1.default.existsSync(path_1.default.resolve(currentPath, 'src', 'scripts', 'models'))) {
+        fs_1.default.mkdirSync(path_1.default.resolve(currentPath, 'src', 'scripts', 'models'));
     }
-    fs.writeFileSync(path.resolve(currentPath, 'src', 'scripts', 'models', `${metadata.schemaName}.ts`), codeFile);
-    logger.info(`Table metadata output to models/${metadata.schemaName}.ts`);
+    fs_1.default.writeFileSync(path_1.default.resolve(currentPath, 'src', 'scripts', 'models', `${metadata.schemaName}.ts`), codeFile);
+    just_scripts_utils_1.logger.info(`Table metadata output to models/${metadata.schemaName}.ts`);
 }
+exports.default = generate;

package/lib/models/pluginAssembly.js

@@ -1,22 +1,28 @@
-import fs from 'fs';
-import glob from 'glob';
-import { retrieveMultiple, createWithReturnData, update } from 'dataverse-webapi/lib/node';
-import { deployType } from './pluginType';
-import { addToSolution, ComponentType } from '../dataverse.service';
-import { logger } from 'just-scripts-utils';
-export async function deploy(config, apiConfig, solution) {
-    const files = glob.sync(`**/${config.name}.dll`);
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploy = void 0;
+const fs_1 = __importDefault(require("fs"));
+const glob_1 = __importDefault(require("glob"));
+const node_1 = require("dataverse-webapi/lib/node");
+const pluginType_1 = require("./pluginType");
+const dataverse_service_1 = require("../dataverse.service");
+const just_scripts_utils_1 = require("just-scripts-utils");
+async function deploy(config, apiConfig, solution) {
+    const files = glob_1.default.sync(`**/${config.name}.dll`);
     if (files.length === 0) {
-        logger.error(`assembly ${config.name}.dll not found`);
+        just_scripts_utils_1.logger.error(`assembly ${config.name}.dll not found`);
         return;
     }
-    const content = fs.readFileSync(files[0]).toString('base64');
+    const content = fs_1.default.readFileSync(files[0]).toString('base64');
     let assemblyId = '';
     try {
         assemblyId = await retrieveAssembly(config.name, apiConfig);
     }
     catch (error) {
-        logger.error(`failed to retrieve assembly ${config.name}: ${error.message}`);
+        just_scripts_utils_1.logger.error(`failed to retrieve assembly ${config.name}: ${error.message}`);
         return;
     }
     if (assemblyId != '') {
@@ -36,10 +42,10 @@ export async function deploy(config, apiConfig, solution) {
         }
         if (solution != undefined) {
             try {
-                await addToSolution(assemblyId, solution, ComponentType.PluginAssembly, apiConfig);
+                await (0, dataverse_service_1.addToSolution)(assemblyId, solution, dataverse_service_1.ComponentType.PluginAssembly, apiConfig);
             }
             catch (error) {
-                logger.error(`failed to add to solution: ${error.message}`);
+                just_scripts_utils_1.logger.error(`failed to add to solution: ${error.message}`);
             }
         }
     }
@@ -47,23 +53,24 @@ export async function deploy(config, apiConfig, solution) {
         try {
             const promises = config.types.map(async (type) => {
                 type['pluginassemblyid@odata.bind'] = `/pluginassemblies(${assemblyId})`;
-                await deployType(type, apiConfig, solution);
+                await (0, pluginType_1.deployType)(type, apiConfig, solution);
             });
             await Promise.all(promises);
         }
         catch (error) {
-            logger.error(error.message);
+            just_scripts_utils_1.logger.error(error.message);
             return;
         }
     }
 }
+exports.deploy = deploy;
 async function retrieveAssembly(name, apiConfig) {
     const options = `$select=pluginassemblyid&$filter=name eq '${name}'`;
-    const result = await retrieveMultiple(apiConfig, 'pluginassemblies', options);
+    const result = await (0, node_1.retrieveMultiple)(apiConfig, 'pluginassemblies', options);
     return result.value.length > 0 ? result.value[0].pluginassemblyid : '';
 }
 async function createAssembly(config, content, apiConfig) {
-    logger.info(`create assembly ${config.name}`);
+    just_scripts_utils_1.logger.info(`create assembly ${config.name}`);
     const assembly = {
         name: config.name,
         content: content,
@@ -73,17 +80,17 @@ async function createAssembly(config, content, apiConfig) {
         sourcetype: 0,
         culture: ''
     };
-    const result = await createWithReturnData(apiConfig, 'pluginassemblies', assembly, '$select=pluginassemblyid');
+    const result = await (0, node_1.createWithReturnData)(apiConfig, 'pluginassemblies', assembly, '$select=pluginassemblyid');
     if (result.error) {
         throw new Error(result.error.message);
     }
     return result.pluginassemblyid;
 }
 async function updateAssembly(id, config, content, apiConfig) {
-    logger.info(`update assembly ${config.name}`);
+    just_scripts_utils_1.logger.info(`update assembly ${config.name}`);
     const assembly = {
         content: content,
         version: config.version
     };
-    return update(apiConfig, 'pluginassemblies', id, assembly);
+    return (0, node_1.update)(apiConfig, 'pluginassemblies', id, assembly);
 }

package/lib/models/pluginImage.js

@@ -1,6 +1,9 @@
-import { logger } from 'just-scripts-utils';
-import { retrieveMultiple, createWithReturnData, update } from 'dataverse-webapi/lib/node';
-export async function deployImage(stepId, image, message, apiConfig) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployImage = void 0;
+const just_scripts_utils_1 = require("just-scripts-utils");
+const node_1 = require("dataverse-webapi/lib/node");
+async function deployImage(stepId, image, message, apiConfig) {
     image['sdkmessageprocessingstepid@odata.bind'] = `/sdkmessageprocessingsteps(${stepId})`;
     switch (message) {
         case 'Create':
@@ -38,20 +41,21 @@ export async function deployImage(stepId, image, message, apiConfig) {
     }
     return imageId;
 }
+exports.deployImage = deployImage;
 async function retrieveImage(stepId, image, apiConfig) {
     const options = `$select=sdkmessageprocessingstepimageid&$filter=name eq '${image.name}' and _sdkmessageprocessingstepid_value eq ${stepId}`;
-    const result = await retrieveMultiple(apiConfig, 'sdkmessageprocessingstepimages', options);
+    const result = await (0, node_1.retrieveMultiple)(apiConfig, 'sdkmessageprocessingstepimages', options);
     return result.value.length > 0 ? result.value[0].sdkmessageprocessingstepimageid : '';
 }
 async function createImage(image, apiConfig) {
-    logger.info(`create plugin image ${image.name}`);
-    const result = await createWithReturnData(apiConfig, 'sdkmessageprocessingstepimages', image, '$select=sdkmessageprocessingstepimageid');
+    just_scripts_utils_1.logger.info(`create plugin image ${image.name}`);
+    const result = await (0, node_1.createWithReturnData)(apiConfig, 'sdkmessageprocessingstepimages', image, '$select=sdkmessageprocessingstepimageid');
     if (result.error) {
         throw new Error(result.error.message);
     }
     return result.sdkmessageprocessingstepimageid;
 }
 async function updateImage(id, image, apiConfig) {
-    logger.info(`update plugin image ${image.name}`);
-    return update(apiConfig, 'sdkmessageprocessingstepimages', id, image);
+    just_scripts_utils_1.logger.info(`update plugin image ${image.name}`);
+    return (0, node_1.update)(apiConfig, 'sdkmessageprocessingstepimages', id, image);
 }

package/lib/models/pluginStep.js

@@ -1,17 +1,20 @@
-import { retrieveMultiple, createWithReturnData, update } from 'dataverse-webapi/lib/node';
-import { addToSolution, ComponentType } from '../dataverse.service';
-import { logger } from 'just-scripts-utils';
-import { deployImage } from './pluginImage';
-export async function deployStep(step, apiConfig, solution) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployStep = void 0;
+const node_1 = require("dataverse-webapi/lib/node");
+const dataverse_service_1 = require("../dataverse.service");
+const just_scripts_utils_1 = require("just-scripts-utils");
+const pluginImage_1 = require("./pluginImage");
+async function deployStep(step, apiConfig, solution) {
     let stepId = await retrieveStep(step.name, apiConfig);
     const messageId = await getSdkMessageId(step.message ?? '', apiConfig);
     if (messageId == '') {
-        logger.error(`sdk message ${step.message} not found`);
+        just_scripts_utils_1.logger.error(`sdk message ${step.message} not found`);
         return;
     }
     const filterId = await getSdkMessageFilterId(messageId, step.entity ?? '', apiConfig);
     if (filterId == '') {
-        logger.error(`sdk message ${step.message} for entity ${step.entity} not found`);
+        just_scripts_utils_1.logger.error(`sdk message ${step.message} for entity ${step.entity} not found`);
         return;
     }
     step['sdkmessagefilterid@odata.bind'] = `/sdkmessagefilters(${filterId})`;
@@ -41,7 +44,7 @@ export async function deployStep(step, apiConfig, solution) {
         }
         if (solution != undefined) {
             try {
-                await addToSolution(stepId, solution, ComponentType.SDKMessageProcessingStep, apiConfig);
+                await (0, dataverse_service_1.addToSolution)(stepId, solution, dataverse_service_1.ComponentType.SDKMessageProcessingStep, apiConfig);
             }
             catch (error) {
                 throw new Error(`failed to add to solution: ${error.message}`);
@@ -50,7 +53,7 @@ export async function deployStep(step, apiConfig, solution) {
     }
     if (images && images.length > 0) {
         try {
-            const promises = images.map(image => deployImage(stepId, image, message, apiConfig));
+            const promises = images.map(image => (0, pluginImage_1.deployImage)(stepId, image, message, apiConfig));
             await Promise.all(promises);
         }
         catch (error) {
@@ -59,9 +62,10 @@ export async function deployStep(step, apiConfig, solution) {
     }
     return stepId;
 }
+exports.deployStep = deployStep;
 async function retrieveStep(name, apiConfig) {
     const options = `$select=sdkmessageprocessingstepid&$filter=name eq '${name}'`;
-    const result = await retrieveMultiple(apiConfig, 'sdkmessageprocessingsteps', options);
+    const result = await (0, node_1.retrieveMultiple)(apiConfig, 'sdkmessageprocessingsteps', options);
     return result.value.length > 0 ? result.value[0].sdkmessageprocessingstepid : '';
 }
 async function getSdkMessageFilterId(messageId, entityName, apiConfig) {
@@ -69,7 +73,7 @@ async function getSdkMessageFilterId(messageId, entityName, apiConfig) {
         `?$filter=primaryobjecttypecode eq '${entityName}' and _sdkmessageid_value eq ${messageId}`,
         '&$select=sdkmessagefilterid'
     ].join('');
-    const message = await retrieveMultiple(apiConfig, 'sdkmessagefilters', options);
+    const message = await (0, node_1.retrieveMultiple)(apiConfig, 'sdkmessagefilters', options);
     return message.value.length > 0 ? message.value[0].sdkmessagefilterid : '';
 }
 async function getSdkMessageId(name, apiConfig) {
@@ -77,18 +81,18 @@ async function getSdkMessageId(name, apiConfig) {
         `?$filter=name eq '${name}'`,
         '&$select=sdkmessageid'
     ].join('');
-    const message = await retrieveMultiple(apiConfig, 'sdkmessages', options);
+    const message = await (0, node_1.retrieveMultiple)(apiConfig, 'sdkmessages', options);
     return message.value.length > 0 ? message.value[0].sdkmessageid : '';
 }
 async function createStep(step, apiConfig) {
-    logger.info(`create plugin step ${step.name}`);
-    const result = await createWithReturnData(apiConfig, 'sdkmessageprocessingsteps', step, '$select=sdkmessageprocessingstepid');
+    just_scripts_utils_1.logger.info(`create plugin step ${step.name}`);
+    const result = await (0, node_1.createWithReturnData)(apiConfig, 'sdkmessageprocessingsteps', step, '$select=sdkmessageprocessingstepid');
     if (result.error) {
         throw new Error(result.error.message);
     }
     return result.sdkmessageprocessingstepid;
 }
 async function updateStep(id, step, apiConfig) {
-    logger.info(`update plugin step ${step.name}`);
-    return update(apiConfig, 'sdkmessageprocessingsteps', id, step);
+    just_scripts_utils_1.logger.info(`update plugin step ${step.name}`);
+    return (0, node_1.update)(apiConfig, 'sdkmessageprocessingsteps', id, step);
 }

package/lib/models/pluginType.js

@@ -1,7 +1,10 @@
-import { retrieveMultiple, createWithReturnData, update } from 'dataverse-webapi/lib/node';
-import { deployStep } from './pluginStep';
-import { logger } from 'just-scripts-utils';
-export async function deployType(type, apiConfig, solution) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployType = void 0;
+const node_1 = require("dataverse-webapi/lib/node");
+const pluginStep_1 = require("./pluginStep");
+const just_scripts_utils_1 = require("just-scripts-utils");
+async function deployType(type, apiConfig, solution) {
     let typeId = await retrieveType(type.typename, apiConfig);
     const record = {
         name: type.name,
@@ -30,7 +33,7 @@ export async function deployType(type, apiConfig, solution) {
         if (type.steps) {
             const promises = type.steps.map(async (step) => {
                 step['plugintypeid@odata.bind'] = `/plugintypes(${typeId})`;
-                await deployStep(step, apiConfig, solution);
+                await (0, pluginStep_1.deployStep)(step, apiConfig, solution);
             });
             await Promise.all(promises);
         }
@@ -40,20 +43,21 @@ export async function deployType(type, apiConfig, solution) {
     }
     return typeId;
 }
+exports.deployType = deployType;
 async function retrieveType(name, apiConfig) {
     const options = `$select=plugintypeid&$filter=typename eq '${name}'`;
-    const result = await retrieveMultiple(apiConfig, 'plugintypes', options);
+    const result = await (0, node_1.retrieveMultiple)(apiConfig, 'plugintypes', options);
     return result.value.length > 0 ? result.value[0].plugintypeid : '';
 }
 async function createType(type, apiConfig) {
-    logger.info(`create assembly type ${type.name}`);
-    const result = await createWithReturnData(apiConfig, 'plugintypes', type, '$select=plugintypeid');
+    just_scripts_utils_1.logger.info(`create assembly type ${type.name}`);
+    const result = await (0, node_1.createWithReturnData)(apiConfig, 'plugintypes', type, '$select=plugintypeid');
     if (result.error) {
         throw new Error(result.error.message);
     }
     return result.plugintypeid;
 }
 async function updateType(id, type, apiConfig) {
-    logger.info(`update assembly type ${type.name}`);
-    return update(apiConfig, 'plugintypes', id, type);
+    just_scripts_utils_1.logger.info(`update assembly type ${type.name}`);
+    return (0, node_1.update)(apiConfig, 'plugintypes', id, type);
 }

package/lib/models/webResource.js

@@ -1,7 +1,13 @@
-import { addToSolution, ComponentType, publish } from '../dataverse.service';
-import { retrieveMultiple, createWithReturnData, update } from 'dataverse-webapi/lib/node';
-import { logger } from 'just-scripts-utils';
-import fs from 'fs';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploy = void 0;
+const dataverse_service_1 = require("../dataverse.service");
+const node_1 = require("dataverse-webapi/lib/node");
+const just_scripts_utils_1 = require("just-scripts-utils");
+const fs_1 = __importDefault(require("fs"));
 function getWebResourceType(type) {
     switch (type) {
         case 'HTML':
@@ -32,7 +38,7 @@ function getWebResourceType(type) {
             return 0;
     }
 }
-export async function deploy(webResources, apiConfig, solution, files) {
+async function deploy(webResources, apiConfig, solution, files) {
     const publishXml = [];
     let resources = webResources;
     // Use list of files if provided
@@ -41,7 +47,7 @@ export async function deploy(webResources, apiConfig, solution, files) {
         for (const file of files.split(',')) {
             const resource = webResources.filter(r => r.path?.endsWith(file));
             if (resource.length === 0) {
-                logger.error(`web resource ${file} not found in dataverse.config.json`);
+                just_scripts_utils_1.logger.error(`web resource ${file} not found in dataverse.config.json`);
                 continue;
             }
             resources.push(resource[0]);
@@ -53,10 +59,10 @@ export async function deploy(webResources, apiConfig, solution, files) {
             resourceId = await retrieveResource(resource.name, apiConfig);
         }
         catch (error) {
-            logger.error(`failed to retrieve resource ${resource.name}: ${error.message}`);
+            just_scripts_utils_1.logger.error(`failed to retrieve resource ${resource.name}: ${error.message}`);
             return;
         }
-        const fileContent = fs.readFileSync(resource.path, 'utf8');
+        const fileContent = fs_1.default.readFileSync(resource.path, 'utf8');
         const content = Buffer.from(fileContent).toString('base64');
         if (resourceId != '') {
             try {
@@ -64,7 +70,7 @@ export async function deploy(webResources, apiConfig, solution, files) {
                 publishXml.push(updated);
             }
             catch (error) {
-                logger.error(`failed to update resource: ${error.message}`);
+                just_scripts_utils_1.logger.error(`failed to update resource: ${error.message}`);
             }
         }
         else {
@@ -72,14 +78,14 @@ export async function deploy(webResources, apiConfig, solution, files) {
                 resourceId = await createResource(resource, content, apiConfig);
             }
             catch (error) {
-                logger.error(`failed to create resource: ${error.message}`);
+                just_scripts_utils_1.logger.error(`failed to create resource: ${error.message}`);
             }
             if (solution != undefined) {
                 try {
-                    await addToSolution(resourceId, solution, ComponentType.WebResource, apiConfig);
+                    await (0, dataverse_service_1.addToSolution)(resourceId, solution, dataverse_service_1.ComponentType.WebResource, apiConfig);
                 }
                 catch (error) {
-                    logger.error(`failed to add to solution: ${error.message}`);
+                    just_scripts_utils_1.logger.error(`failed to add to solution: ${error.message}`);
                 }
             }
         }
@@ -88,37 +94,38 @@ export async function deploy(webResources, apiConfig, solution, files) {
     // publish resources
     if (publishXml.length > 0) {
         try {
-            await publish(publishXml.join(''), apiConfig);
+            await (0, dataverse_service_1.publish)(publishXml.join(''), apiConfig);
         }
         catch (error) {
-            logger.error(error.message);
+            just_scripts_utils_1.logger.error(error.message);
         }
     }
 }
+exports.deploy = deploy;
 async function retrieveResource(name, apiConfig) {
     const options = `$select=webresourceid&$filter=name eq '${name}'`;
-    const result = await retrieveMultiple(apiConfig, 'webresourceset', options);
+    const result = await (0, node_1.retrieveMultiple)(apiConfig, 'webresourceset', options);
     return result.value.length > 0 ? result.value[0].webresourceid : '';
 }
 async function createResource(resource, content, apiConfig) {
-    logger.info(`create web resource ${resource.name}`);
+    just_scripts_utils_1.logger.info(`create web resource ${resource.name}`);
     const webResource = {
         webresourcetype: getWebResourceType(resource.type),
         name: resource.name,
         displayname: resource.displayname || resource.name,
         content: content
     };
-    const result = await createWithReturnData(apiConfig, 'webresourceset', webResource, '$select=webresourceid');
+    const result = await (0, node_1.createWithReturnData)(apiConfig, 'webresourceset', webResource, '$select=webresourceid');
     if (result.error) {
         throw new Error(result.error.message);
     }
     return result.webresourceid;
 }
 async function updateResource(id, resource, content, apiConfig) {
-    logger.info(`update web resource ${resource.name}`);
+    just_scripts_utils_1.logger.info(`update web resource ${resource.name}`);
     const webResource = {
         content: content
     };
-    await update(apiConfig, 'webresourceset', id, webResource);
+    await (0, node_1.update)(apiConfig, 'webresourceset', id, webResource);
     return `<webresource>{${id}}</webresource>`;
 }

package/lib/webResourceDeploy.js

@@ -1,22 +1,29 @@
-import path from 'path';
-import fs from 'fs';
-import { logger } from 'just-scripts-utils';
-import { deploy } from './models/webResource';
-export async function deployWebResource(creds, apiConfig, files) {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployWebResource = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const just_scripts_utils_1 = require("just-scripts-utils");
+const webResource_1 = require("./models/webResource");
+async function deployWebResource(creds, apiConfig, files) {
     const currentPath = '.';
-    const configFile = fs.readFileSync(path.resolve(currentPath, 'dataverse.config.json'), 'utf8');
+    const configFile = fs_1.default.readFileSync(path_1.default.resolve(currentPath, 'dataverse.config.json'), 'utf8');
     if (configFile == null) {
-        logger.warn('unable to find dataverse.config.json file');
+        just_scripts_utils_1.logger.warn('unable to find dataverse.config.json file');
         return;
     }
     const config = JSON.parse(configFile).webResources;
-    logger.info('deploy web resources');
+    just_scripts_utils_1.logger.info('deploy web resources');
     try {
-        await deploy(config, apiConfig, creds.solution, files);
+        await (0, webResource_1.deploy)(config, apiConfig, creds.solution, files);
     }
     catch (error) {
-        logger.error(error.message);
+        just_scripts_utils_1.logger.error(error.message);
         return;
     }
-    logger.info('deployed web resources');
+    just_scripts_utils_1.logger.info('deployed web resources');
 }
+exports.deployWebResource = deployWebResource;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dataverse-utils",
-  "version": "2.0.10",
+  "version": "2.0.11",
   "license": "MIT",
   "description": "Utilities for interacting with Dataverse environments",
   "main": "lib/index.js",
@@ -21,13 +21,13 @@
   },
   "dependencies": {
     "@azure/msal-node": "^1.3.1",
-    "commander": "^8.2.0",
+    "commander": "^8.3.0",
     "glob": "^7.2.0",
     "cryptr": "^6.0.2",
     "dataverse-webapi": "^2.0.2",
     "envinfo": "^7.8.1",
     "just-scripts-utils": "^1.1.4",
-    "prompts": "^2.4.1"
+    "prompts": "^2.4.2"
   },
   "devDependencies": {
     "@types/node": "^16.9.1",